_Z18ExtractDestinationRK7CScriptRNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
   50|   895k|{
   51|   895k|    std::vector<valtype> vSolutions;
   52|   895k|    TxoutType whichType = Solver(scriptPubKey, vSolutions);
   53|       |
   54|   895k|    switch (whichType) {
  ------------------
  |  Branch (54:13): [True: 895k, False: 0]
  ------------------
   55|  8.54k|    case TxoutType::PUBKEY: {
  ------------------
  |  Branch (55:5): [True: 8.54k, False: 886k]
  ------------------
   56|  8.54k|        CPubKey pubKey(vSolutions[0]);
   57|  8.54k|        if (!pubKey.IsValid()) {
  ------------------
  |  Branch (57:13): [True: 0, False: 8.54k]
  ------------------
   58|      0|            addressRet = CNoDestination(scriptPubKey);
   59|  8.54k|        } else {
   60|  8.54k|            addressRet = PubKeyDestination(pubKey);
   61|  8.54k|        }
   62|  8.54k|        return false;
   63|      0|    }
   64|  11.9k|    case TxoutType::PUBKEYHASH: {
  ------------------
  |  Branch (64:5): [True: 11.9k, False: 883k]
  ------------------
   65|  11.9k|        addressRet = PKHash(uint160(vSolutions[0]));
   66|  11.9k|        return true;
   67|      0|    }
   68|  44.5k|    case TxoutType::SCRIPTHASH: {
  ------------------
  |  Branch (68:5): [True: 44.5k, False: 850k]
  ------------------
   69|  44.5k|        addressRet = ScriptHash(uint160(vSolutions[0]));
   70|  44.5k|        return true;
   71|      0|    }
   72|  27.4k|    case TxoutType::WITNESS_V0_KEYHASH: {
  ------------------
  |  Branch (72:5): [True: 27.4k, False: 867k]
  ------------------
   73|  27.4k|        WitnessV0KeyHash hash;
   74|  27.4k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
   75|  27.4k|        addressRet = hash;
   76|  27.4k|        return true;
   77|      0|    }
   78|  23.5k|    case TxoutType::WITNESS_V0_SCRIPTHASH: {
  ------------------
  |  Branch (78:5): [True: 23.5k, False: 871k]
  ------------------
   79|  23.5k|        WitnessV0ScriptHash hash;
   80|  23.5k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
   81|  23.5k|        addressRet = hash;
   82|  23.5k|        return true;
   83|      0|    }
   84|  6.27k|    case TxoutType::WITNESS_V1_TAPROOT: {
  ------------------
  |  Branch (84:5): [True: 6.27k, False: 889k]
  ------------------
   85|  6.27k|        WitnessV1Taproot tap;
   86|  6.27k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
   87|  6.27k|        addressRet = tap;
   88|  6.27k|        return true;
   89|      0|    }
   90|  1.58k|    case TxoutType::ANCHOR: {
  ------------------
  |  Branch (90:5): [True: 1.58k, False: 893k]
  ------------------
   91|  1.58k|        addressRet = PayToAnchor();
   92|  1.58k|        return true;
   93|      0|    }
   94|  15.5k|    case TxoutType::WITNESS_UNKNOWN: {
  ------------------
  |  Branch (94:5): [True: 15.5k, False: 879k]
  ------------------
   95|  15.5k|        addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};
   96|  15.5k|        return true;
   97|      0|    }
   98|  7.30k|    case TxoutType::MULTISIG:
  ------------------
  |  Branch (98:5): [True: 7.30k, False: 887k]
  ------------------
   99|  11.1k|    case TxoutType::NULL_DATA:
  ------------------
  |  Branch (99:5): [True: 3.79k, False: 891k]
  ------------------
  100|   755k|    case TxoutType::NONSTANDARD:
  ------------------
  |  Branch (100:5): [True: 744k, False: 150k]
  ------------------
  101|   755k|        addressRet = CNoDestination(scriptPubKey);
  102|   755k|        return false;
  103|   895k|    } // no default case, so the compiler can warn about missing cases
  104|   895k|    assert(false);
  ------------------
  |  Branch (104:5): [Folded, False: 0]
  ------------------
  105|      0|}
_Z23GetScriptForDestinationRKNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  167|  64.0k|{
  168|  64.0k|    return std::visit(CScriptVisitor(), dest);
  169|  64.0k|}
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK6PKHash:
  122|  5.95k|    {
  123|  5.95k|        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
  124|  5.95k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK10ScriptHash:
  127|  22.2k|    {
  128|  22.2k|        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
  129|  22.2k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK19WitnessV0ScriptHash:
  137|  11.7k|    {
  138|  11.7k|        return CScript() << OP_0 << ToByteVector(id);
  139|  11.7k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK16WitnessV0KeyHash:
  132|  13.7k|    {
  133|  13.7k|        return CScript() << OP_0 << ToByteVector(id);
  134|  13.7k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK16WitnessV1Taproot:
  142|  1.73k|    {
  143|  1.73k|        return CScript() << OP_1 << ToByteVector(tap);
  144|  1.73k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK14WitnessUnknown:
  147|  8.58k|    {
  148|  8.58k|        return CScript() << CScript::EncodeOP_N(id.GetWitnessVersion()) << id.GetWitnessProgram();
  149|  8.58k|    }

_ZN17PubKeyDestinationC2ERK7CPubKey:
   39|  8.54k|    explicit PubKeyDestination(const CPubKey& pubkey) : m_pubkey(pubkey) {}
_ZN10ScriptHashC2ERK7uint160:
   66|  44.5k|    explicit ScriptHash(const uint160& hash) : BaseHash(hash) {}
_ZN16WitnessV0KeyHashC2Ev:
   81|  27.4k|    WitnessV0KeyHash() : BaseHash() {}
_ZN19WitnessV0ScriptHashC2Ev:
   74|  23.5k|    WitnessV0ScriptHash() : BaseHash() {}
_ZN16WitnessV1TaprootC2Ev:
   90|  6.27k|    WitnessV1Taproot() : XOnlyPubKey() {}
_ZN11PayToAnchorC2Ev:
  125|  1.58k|    PayToAnchor() : WitnessUnknown(1, ANCHOR_BYTES) {
  126|  1.58k|        Assume(CScript::IsPayToAnchor(1, ANCHOR_BYTES));
  ------------------
  |  |  128|  1.58k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  127|  1.58k|    };
_ZN14WitnessUnknownC2EiRKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  103|  17.1k|    WitnessUnknown(int version, const std::vector<unsigned char>& program) : m_version(static_cast<unsigned int>(version)), m_program(program) {}
_ZN6PKHashC2ERK7uint160:
   50|  11.9k|    explicit PKHash(const uint160& hash) : BaseHash(hash) {}
_ZN14CNoDestinationC2ERK7CScript:
   26|   755k|    explicit CNoDestination(const CScript& script) : m_script(script) {}
_ZNK14WitnessUnknown17GetWitnessVersionEv:
  105|  60.0k|    unsigned int GetWitnessVersion() const { return m_version; }
_ZNK14WitnessUnknown17GetWitnessProgramEv:
  106|  25.7k|    const std::vector<unsigned char>& GetWitnessProgram() const LIFETIMEBOUND { return m_program; }
_ZN14CNoDestinationC2Ev:
   25|   895k|    CNoDestination() = default;

_Z12EncodeBase58NSt3__14spanIKhLm18446744073709551615EEE:
   90|  56.4k|{
   91|       |    // Skip & count leading zeroes.
   92|  56.4k|    int zeroes = 0;
   93|  56.4k|    int length = 0;
   94|  56.4k|    while (input.size() > 0 && input[0] == 0) {
  ------------------
  |  Branch (94:12): [True: 56.4k, False: 0]
  |  Branch (94:32): [True: 0, False: 56.4k]
  ------------------
   95|      0|        input = input.subspan(1);
   96|      0|        zeroes++;
   97|      0|    }
   98|       |    // Allocate enough space in big-endian base58 representation.
   99|  56.4k|    int size = input.size() * 138 / 100 + 1; // log(256) / log(58), rounded up.
  100|  56.4k|    std::vector<unsigned char> b58(size);
  101|       |    // Process the bytes.
  102|  1.46M|    while (input.size() > 0) {
  ------------------
  |  Branch (102:12): [True: 1.41M, False: 56.4k]
  ------------------
  103|  1.41M|        int carry = input[0];
  104|  1.41M|        int i = 0;
  105|       |        // Apply "b58 = b58 * 256 + ch".
  106|  27.0M|        for (std::vector<unsigned char>::reverse_iterator it = b58.rbegin(); (carry != 0 || i < length) && (it != b58.rend()); it++, i++) {
  ------------------
  |  Branch (106:78): [True: 25.6M, False: 1.41M]
  |  Branch (106:79): [True: 25.5M, False: 1.50M]
  |  Branch (106:93): [True: 90.1k, False: 1.41M]
  |  Branch (106:108): [True: 25.6M, False: 0]
  ------------------
  107|  25.6M|            carry += 256 * (*it);
  108|  25.6M|            *it = carry % 58;
  109|  25.6M|            carry /= 58;
  110|  25.6M|        }
  111|       |
  112|  1.41M|        assert(carry == 0);
  ------------------
  |  Branch (112:9): [True: 1.41M, False: 0]
  ------------------
  113|  1.41M|        length = i;
  114|  1.41M|        input = input.subspan(1);
  115|  1.41M|    }
  116|       |    // Skip leading zeroes in base58 result.
  117|  56.4k|    std::vector<unsigned char>::iterator it = b58.begin() + (size - length);
  118|  56.4k|    while (it != b58.end() && *it == 0)
  ------------------
  |  Branch (118:12): [True: 56.4k, False: 0]
  |  Branch (118:12): [True: 0, False: 56.4k]
  |  Branch (118:31): [True: 0, False: 56.4k]
  ------------------
  119|      0|        it++;
  120|       |    // Translate the result into a string.
  121|  56.4k|    std::string str;
  122|  56.4k|    str.reserve(zeroes + (b58.end() - it));
  123|  56.4k|    str.assign(zeroes, '1');
  124|  2.02M|    while (it != b58.end())
  ------------------
  |  Branch (124:12): [True: 1.96M, False: 56.4k]
  ------------------
  125|  1.96M|        str += pszBase58[*(it++)];
  126|  56.4k|    return str;
  127|  56.4k|}
_Z17EncodeBase58CheckNSt3__14spanIKhLm18446744073709551615EEE:
  138|  56.4k|{
  139|       |    // add 4-byte hash check to the end
  140|  56.4k|    std::vector<unsigned char> vch(input.begin(), input.end());
  141|  56.4k|    uint256 hash = Hash(vch);
  142|  56.4k|    vch.insert(vch.end(), hash.data(), hash.data() + 4);
  143|  56.4k|    return EncodeBase58(vch);
  144|  56.4k|}

_ZN6bech326EncodeENS_8EncodingERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_6vectorIhNS5_IhEEEE:
  357|  74.4k|std::string Encode(Encoding encoding, const std::string& hrp, const data& values) {
  358|       |    // First ensure that the HRP is all lowercase. BIP-173 and BIP350 require an encoder
  359|       |    // to return a lowercase Bech32/Bech32m string, but if given an uppercase HRP, the
  360|       |    // result will always be invalid.
  361|  74.4k|    for (const char& c : hrp) assert(c < 'A' || c > 'Z');
  ------------------
  |  Branch (361:24): [True: 297k, False: 74.4k]
  |  Branch (361:31): [True: 0, False: 297k]
  |  Branch (361:31): [True: 297k, False: 0]
  |  Branch (361:31): [True: 297k, False: 0]
  ------------------
  362|       |
  363|  74.4k|    std::string ret;
  364|  74.4k|    ret.reserve(hrp.size() + 1 + values.size() + CHECKSUM_SIZE);
  365|  74.4k|    ret += hrp;
  366|  74.4k|    ret += SEPARATOR;
  367|  2.69M|    for (const uint8_t& i : values) ret += CHARSET[i];
  ------------------
  |  Branch (367:27): [True: 2.69M, False: 74.4k]
  ------------------
  368|   446k|    for (const uint8_t& i : CreateChecksum(encoding, hrp, values)) ret += CHARSET[i];
  ------------------
  |  Branch (368:27): [True: 446k, False: 74.4k]
  ------------------
  369|  74.4k|    return ret;
  370|  74.4k|}
bech32.cpp:_ZN6bech3212_GLOBAL__N_114CreateChecksumENS_8EncodingERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIhNS6_IhEEEE:
  342|  74.4k|{
  343|  74.4k|    auto enc = PreparePolynomialCoefficients(hrp, values);
  344|  74.4k|    enc.insert(enc.end(), CHECKSUM_SIZE, 0x00);
  345|  74.4k|    uint32_t mod = PolyMod(enc) ^ EncodingConstant(encoding); // Determine what to XOR into those 6 zeroes.
  346|  74.4k|    data ret(CHECKSUM_SIZE);
  347|   521k|    for (size_t i = 0; i < CHECKSUM_SIZE; ++i) {
  ------------------
  |  Branch (347:24): [True: 446k, False: 74.4k]
  ------------------
  348|       |        // Convert the 5-bit groups in mod to checksum values.
  349|   446k|        ret[i] = (mod >> (5 * (5 - i))) & 31;
  350|   446k|    }
  351|  74.4k|    return ret;
  352|  74.4k|}
bech32.cpp:_ZN6bech3212_GLOBAL__N_129PreparePolynomialCoefficientsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_6vectorIhNS5_IhEEEE:
  311|  74.4k|{
  312|  74.4k|    data ret;
  313|  74.4k|    ret.reserve(hrp.size() + 1 + hrp.size() + values.size() + CHECKSUM_SIZE);
  314|       |
  315|       |    /** Expand a HRP for use in checksum computation. */
  316|   372k|    for (size_t i = 0; i < hrp.size(); ++i) ret.push_back(hrp[i] >> 5);
  ------------------
  |  Branch (316:24): [True: 297k, False: 74.4k]
  ------------------
  317|  74.4k|    ret.push_back(0);
  318|   372k|    for (size_t i = 0; i < hrp.size(); ++i) ret.push_back(hrp[i] & 0x1f);
  ------------------
  |  Branch (318:24): [True: 297k, False: 74.4k]
  ------------------
  319|       |
  320|  74.4k|    ret.insert(ret.end(), values.begin(), values.end());
  321|       |
  322|  74.4k|    return ret;
  323|  74.4k|}
bech32.cpp:_ZN6bech3212_GLOBAL__N_17PolyModERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  130|  74.4k|{
  131|       |    // The input is interpreted as a list of coefficients of a polynomial over F = GF(32), with an
  132|       |    // implicit 1 in front. If the input is [v0,v1,v2,v3,v4], that polynomial is v(x) =
  133|       |    // 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4. The implicit 1 guarantees that
  134|       |    // [v0,v1,v2,...] has a distinct checksum from [0,v0,v1,v2,...].
  135|       |
  136|       |    // The output is a 30-bit integer whose 5-bit groups are the coefficients of the remainder of
  137|       |    // v(x) mod g(x), where g(x) is the Bech32 generator,
  138|       |    // x^6 + {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}. g(x) is chosen in such a way
  139|       |    // that the resulting code is a BCH code, guaranteeing detection of up to 3 errors within a
  140|       |    // window of 1023 characters. Among the various possible BCH codes, one was selected to in
  141|       |    // fact guarantee detection of up to 4 errors within a window of 89 characters.
  142|       |
  143|       |    // Note that the coefficients are elements of GF(32), here represented as decimal numbers
  144|       |    // between {}. In this finite field, addition is just XOR of the corresponding numbers. For
  145|       |    // example, {27} + {13} = {27 ^ 13} = {22}. Multiplication is more complicated, and requires
  146|       |    // treating the bits of values themselves as coefficients of a polynomial over a smaller field,
  147|       |    // GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example, {5} * {26} =
  148|       |    // (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 + a^3 + a) = a^6 + a^5 + a^4 + a
  149|       |    // = a^3 + 1 (mod a^5 + a^3 + 1) = {9}.
  150|       |
  151|       |    // During the course of the loop below, `c` contains the bitpacked coefficients of the
  152|       |    // polynomial constructed from just the values of v that were processed so far, mod g(x). In
  153|       |    // the above example, `c` initially corresponds to 1 mod g(x), and after processing 2 inputs of
  154|       |    // v, it corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the starting value
  155|       |    // for `c`.
  156|       |
  157|       |    // The following Sage code constructs the generator used:
  158|       |    //
  159|       |    // B = GF(2) # Binary field
  160|       |    // BP.<b> = B[] # Polynomials over the binary field
  161|       |    // F_mod = b**5 + b**3 + 1
  162|       |    // F.<f> = GF(32, modulus=F_mod, repr='int') # GF(32) definition
  163|       |    // FP.<x> = F[] # Polynomials over GF(32)
  164|       |    // E_mod = x**2 + F.fetch_int(9)*x + F.fetch_int(23)
  165|       |    // E.<e> = F.extension(E_mod) # GF(1024) extension field definition
  166|       |    // for p in divisors(E.order() - 1): # Verify e has order 1023.
  167|       |    //    assert((e**p == 1) == (p % 1023 == 0))
  168|       |    // G = lcm([(e**i).minpoly() for i in range(997,1000)])
  169|       |    // print(G) # Print out the generator
  170|       |    //
  171|       |    // It demonstrates that g(x) is the least common multiple of the minimal polynomials
  172|       |    // of 3 consecutive powers (997,998,999) of a primitive element (e) of GF(1024).
  173|       |    // That guarantees it is, in fact, the generator of a primitive BCH code with cycle
  174|       |    // length 1023 and distance 4. See https://en.wikipedia.org/wiki/BCH_code for more details.
  175|       |
  176|  74.4k|    uint32_t c = 1;
  177|  3.81M|    for (const auto v_i : v) {
  ------------------
  |  Branch (177:25): [True: 3.81M, False: 74.4k]
  ------------------
  178|       |        // We want to update `c` to correspond to a polynomial with one extra term. If the initial
  179|       |        // value of `c` consists of the coefficients of c(x) = f(x) mod g(x), we modify it to
  180|       |        // correspond to c'(x) = (f(x) * x + v_i) mod g(x), where v_i is the next input to
  181|       |        // process. Simplifying:
  182|       |        // c'(x) = (f(x) * x + v_i) mod g(x)
  183|       |        //         ((f(x) mod g(x)) * x + v_i) mod g(x)
  184|       |        //         (c(x) * x + v_i) mod g(x)
  185|       |        // If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to compute
  186|       |        // c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + v_i mod g(x)
  187|       |        //       = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i mod g(x)
  188|       |        //       = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i
  189|       |        // If we call (x^6 mod g(x)) = k(x), this can be written as
  190|       |        // c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i) + c0*k(x)
  191|       |
  192|       |        // First, determine the value of c0:
  193|  3.81M|        uint8_t c0 = c >> 25;
  194|       |
  195|       |        // Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i:
  196|  3.81M|        c = ((c & 0x1ffffff) << 5) ^ v_i;
  197|       |
  198|       |        // Finally, for each set bit n in c0, conditionally add {2^n}k(x). These constants can be
  199|       |        // computed using the following Sage code (continuing the code above):
  200|       |        //
  201|       |        // for i in [1,2,4,8,16]: # Print out {1,2,4,8,16}*(g(x) mod x^6), packed in hex integers.
  202|       |        //     v = 0
  203|       |        //     for coef in reversed((F.fetch_int(i)*(G % x**6)).coefficients(sparse=True)):
  204|       |        //         v = v*32 + coef.integer_representation()
  205|       |        //     print("0x%x" % v)
  206|       |        //
  207|  3.81M|        if (c0 & 1)  c ^= 0x3b6a57b2; //     k(x) = {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}
  ------------------
  |  Branch (207:13): [True: 1.76M, False: 2.05M]
  ------------------
  208|  3.81M|        if (c0 & 2)  c ^= 0x26508e6d; //  {2}k(x) = {19}x^5 +  {5}x^4 +     x^3 +  {3}x^2 + {19}x + {13}
  ------------------
  |  Branch (208:13): [True: 1.88M, False: 1.93M]
  ------------------
  209|  3.81M|        if (c0 & 4)  c ^= 0x1ea119fa; //  {4}k(x) = {15}x^5 + {10}x^4 +  {2}x^3 +  {6}x^2 + {15}x + {26}
  ------------------
  |  Branch (209:13): [True: 1.75M, False: 2.06M]
  ------------------
  210|  3.81M|        if (c0 & 8)  c ^= 0x3d4233dd; //  {8}k(x) = {30}x^5 + {20}x^4 +  {4}x^3 + {12}x^2 + {30}x + {29}
  ------------------
  |  Branch (210:13): [True: 1.70M, False: 2.11M]
  ------------------
  211|  3.81M|        if (c0 & 16) c ^= 0x2a1462b3; // {16}k(x) = {21}x^5 +     x^4 +  {8}x^3 + {24}x^2 + {21}x + {19}
  ------------------
  |  Branch (211:13): [True: 1.62M, False: 2.19M]
  ------------------
  212|       |
  213|  3.81M|    }
  214|  74.4k|    return c;
  215|  74.4k|}
bech32.cpp:_ZN6bech3212_GLOBAL__N_116EncodingConstantENS_8EncodingE:
  121|  74.4k|uint32_t EncodingConstant(Encoding encoding) {
  122|  74.4k|    assert(encoding == Encoding::BECH32 || encoding == Encoding::BECH32M);
  ------------------
  |  Branch (122:5): [True: 51.0k, False: 23.4k]
  |  Branch (122:5): [True: 23.4k, False: 0]
  |  Branch (122:5): [True: 74.4k, False: 0]
  ------------------
  123|  74.4k|    return encoding == Encoding::BECH32 ? 1 : 0x2bc830a3;
  ------------------
  |  Branch (123:12): [True: 51.0k, False: 23.4k]
  ------------------
  124|  74.4k|}

_Z6Paramsv:
  128|   130k|const CChainParams &Params() {
  129|   130k|    assert(globalChainParams);
  ------------------
  |  Branch (129:5): [True: 130k, False: 0]
  ------------------
  130|   130k|    return *globalChainParams;
  131|   130k|}

_ZN22SaltedCoinsCacheHasherC2Eb:
   23|  4.07k|    : m_hasher{
   24|  4.07k|          deterministic ? 0x8e819f2607a18de6 : FastRandomContext().rand64(),
  ------------------
  |  Branch (24:11): [True: 0, False: 4.07k]
  ------------------
   25|  4.07k|          deterministic ? 0xf4020d2e3983b0eb : FastRandomContext().rand64()}
  ------------------
  |  Branch (25:11): [True: 0, False: 4.07k]
  ------------------
   26|  4.07k|{
   27|  4.07k|}
_ZN14CoinsViewEmpty3GetEv:
   30|  4.07k|{
   31|  4.07k|    static CoinsViewEmpty instance;
   32|  4.07k|    return instance;
   33|  4.07k|}
_ZN15CCoinsViewCacheC2EP10CCoinsViewb:
   44|  4.07k|    CCoinsViewBacked(in_base), m_deterministic(deterministic),
   45|  4.07k|    cacheCoins(0, SaltedCoinsCacheHasher{/*deterministic=*/deterministic}, CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
   46|  4.07k|{
   47|  4.07k|    m_sentinel.second.SelfRef(m_sentinel);
   48|  4.07k|}
_ZNK15CCoinsViewCache17FetchCoinFromBaseERK9COutPoint:
   55|  95.9k|{
   56|  95.9k|    return base->GetCoin(outpoint);
   57|  95.9k|}
_ZNK15CCoinsViewCache9FetchCoinERK9COutPoint:
   59|  95.9k|CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
   60|  95.9k|    const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
   61|  95.9k|    if (inserted) {
  ------------------
  |  Branch (61:9): [True: 95.9k, False: 0]
  ------------------
   62|  95.9k|        if (auto coin{FetchCoinFromBase(outpoint)}) {
  ------------------
  |  Branch (62:18): [True: 0, False: 95.9k]
  ------------------
   63|      0|            ret->second.coin = std::move(*coin);
   64|      0|            cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
   65|      0|            Assert(!ret->second.coin.IsSpent());
  ------------------
  |  |  116|      0|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   66|  95.9k|        } else {
   67|  95.9k|            cacheCoins.erase(ret);
   68|  95.9k|            return cacheCoins.end();
   69|  95.9k|        }
   70|  95.9k|    }
   71|      0|    return ret;
   72|  95.9k|}
_ZNK15CCoinsViewCache10AccessCoinERK9COutPoint:
  170|  95.9k|const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
  171|  95.9k|    CCoinsMap::const_iterator it = FetchCoin(outpoint);
  172|  95.9k|    if (it == cacheCoins.end()) {
  ------------------
  |  Branch (172:9): [True: 95.9k, False: 0]
  ------------------
  173|  95.9k|        return coinEmpty;
  174|  95.9k|    } else {
  175|      0|        return it->second.coin;
  176|      0|    }
  177|  95.9k|}

_ZN16CCoinsCacheEntryC2Ev:
  176|   100k|    CCoinsCacheEntry() noexcept = default;
_ZN16CCoinsCacheEntry7SelfRefERNSt3__14pairIK9COutPointS_EE:
  213|  4.07k|    {
  214|  4.07k|        Assume(&pair.second == this);
  ------------------
  |  |  128|  4.07k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  215|  4.07k|        m_prev = &pair;
  216|  4.07k|        m_next = &pair;
  217|       |        // Set sentinel to DIRTY so we can call Next on it
  218|  4.07k|        m_flags = DIRTY;
  219|  4.07k|    }
_ZNK14CoinsViewEmpty7GetCoinERK9COutPoint:
  402|  95.9k|    std::optional<Coin> GetCoin(const COutPoint&) const override { return {}; }
_ZNK22SaltedCoinsCacheHasherclERK9COutPoint:
  254|  95.9k|    {
  255|  95.9k|        return m_hasher.Hash(id.hash.ToUint256(), uint64_t{id.n});
  256|  95.9k|    }
_ZN10CCoinsViewD2Ev:
  359|  4.07k|    virtual ~CCoinsView() = default;
_ZN16CCoinsViewBackedC2EP10CCoinsView:
  421|  4.07k|    explicit CCoinsViewBacked(CCoinsView* in_view) : base{Assert(in_view)} {}
  ------------------
  |  |  116|  4.07k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
_ZN4CoinC2Ev:
   68|   100k|    Coin() : fCoinBase(false), nHeight(0) { }
_ZN16CCoinsCacheEntryD2Ev:
  179|   100k|    {
  180|   100k|        SetClean();
  181|   100k|    }
_ZN16CCoinsCacheEntry8SetCleanEv:
  187|   100k|    {
  188|   100k|        if (!m_flags) return;
  ------------------
  |  Branch (188:13): [True: 95.9k, False: 4.07k]
  ------------------
  189|  4.07k|        m_next->second.m_prev = m_prev;
  190|  4.07k|        m_prev->second.m_next = m_next;
  191|  4.07k|        m_flags = 0;
  192|  4.07k|        m_prev = m_next = nullptr;
  193|  4.07k|    }

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

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

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

_Z10MoneyRangeRKl:
   27|  53.2k|inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  ------------------
  |  Branch (27:57): [True: 52.7k, False: 454]
  |  Branch (27:72): [True: 51.4k, False: 1.33k]
  ------------------

_Z16CheckTransactionRK12CTransactionR17TxValidationState:
   20|  4.07k|{
   21|       |    // Basic checks that don't depend on any context
   22|  4.07k|    if (tx.vin.empty())
  ------------------
  |  Branch (22:9): [True: 95, False: 3.98k]
  ------------------
   23|     95|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vin-empty");
   24|  3.98k|    if (tx.vout.empty())
  ------------------
  |  Branch (24:9): [True: 1.48k, False: 2.49k]
  ------------------
   25|  1.48k|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-empty");
   26|       |    // Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
   27|  2.49k|    if (::GetSerializeSize(TX_NO_WITNESS(tx)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT) {
  ------------------
  |  Branch (27:9): [True: 1, False: 2.49k]
  ------------------
   28|      1|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-oversize");
   29|      1|    }
   30|       |
   31|       |    // Check for negative or overflow output values (see CVE-2010-5139)
   32|  2.49k|    CAmount nValueOut = 0;
   33|  2.49k|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (33:28): [True: 18.1k, False: 709]
  ------------------
   34|  18.1k|    {
   35|  18.1k|        if (txout.nValue < 0)
  ------------------
  |  Branch (35:13): [True: 454, False: 17.7k]
  ------------------
   36|    454|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-negative");
   37|  17.7k|        if (txout.nValue > MAX_MONEY)
  ------------------
  |  Branch (37:13): [True: 1.32k, False: 16.3k]
  ------------------
   38|  1.32k|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-toolarge");
   39|  16.3k|        nValueOut += txout.nValue;
   40|  16.3k|        if (!MoneyRange(nValueOut))
  ------------------
  |  Branch (40:13): [True: 5, False: 16.3k]
  ------------------
   41|      5|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-txouttotal-toolarge");
   42|  16.3k|    }
   43|       |
   44|       |    // Check for duplicate inputs (see CVE-2018-17144)
   45|       |    // While Consensus::CheckTxInputs does check if all inputs of a tx are available, and UpdateCoins marks all inputs
   46|       |    // of a tx as spent, it does not check if the tx has duplicate inputs.
   47|       |    // Failure to run this check will result in either a crash or an inflation bug, depending on the implementation of
   48|       |    // the underlying coins database.
   49|    709|    std::set<COutPoint> vInOutPoints;
   50|  17.3k|    for (const auto& txin : tx.vin) {
  ------------------
  |  Branch (50:27): [True: 17.3k, False: 686]
  ------------------
   51|  17.3k|        if (!vInOutPoints.insert(txin.prevout).second)
  ------------------
  |  Branch (51:13): [True: 23, False: 17.3k]
  ------------------
   52|     23|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputs-duplicate");
   53|  17.3k|    }
   54|       |
   55|    686|    if (tx.IsCoinBase())
  ------------------
  |  Branch (55:9): [True: 21, False: 665]
  ------------------
   56|     21|    {
   57|     21|        if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
  ------------------
  |  Branch (57:13): [True: 5, False: 16]
  |  Branch (57:47): [True: 12, False: 4]
  ------------------
   58|     17|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cb-length");
   59|     21|    }
   60|    665|    else
   61|    665|    {
   62|    665|        for (const auto& txin : tx.vin)
  ------------------
  |  Branch (62:31): [True: 12.5k, False: 662]
  ------------------
   63|  12.5k|            if (txin.prevout.IsNull())
  ------------------
  |  Branch (63:17): [True: 3, False: 12.5k]
  ------------------
   64|      3|                return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-prevout-null");
   65|    665|    }
   66|       |
   67|    666|    return true;
   68|    686|}

_Z9IsFinalTxRK12CTransactionil:
   24|  4.07k|{
   25|  4.07k|    if (tx.nLockTime == 0)
  ------------------
  |  Branch (25:9): [True: 717, False: 3.35k]
  ------------------
   26|    717|        return true;
   27|  3.35k|    if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
  ------------------
  |  Branch (27:9): [True: 157, False: 3.20k]
  |  Branch (27:34): [True: 1.63k, False: 1.72k]
  ------------------
   28|    157|        return true;
   29|       |
   30|       |    // Even if tx.nLockTime isn't satisfied by nBlockHeight/nBlockTime, a
   31|       |    // transaction is still considered final if all inputs' nSequence ==
   32|       |    // SEQUENCE_FINAL (0xffffffff), in which case nLockTime is ignored.
   33|       |    //
   34|       |    // Because of this behavior OP_CHECKLOCKTIMEVERIFY/CheckLockTime() will
   35|       |    // also check that the spending input's nSequence != SEQUENCE_FINAL,
   36|       |    // ensuring that an unsatisfied nLockTime value will actually cause
   37|       |    // IsFinalTx() to return false here:
   38|  3.66k|    for (const auto& txin : tx.vin) {
  ------------------
  |  Branch (38:27): [True: 3.66k, False: 123]
  ------------------
   39|  3.66k|        if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
  ------------------
  |  Branch (39:13): [True: 3.07k, False: 587]
  ------------------
   40|  3.07k|            return false;
   41|  3.66k|    }
   42|    123|    return true;
   43|  3.20k|}
_Z19GetLegacySigOpCountRK12CTransaction:
  119|  4.07k|{
  120|  4.07k|    unsigned int nSigOps = 0;
  121|  4.07k|    for (const auto& txin : tx.vin)
  ------------------
  |  Branch (121:27): [True: 93.2k, False: 4.07k]
  ------------------
  122|  93.2k|    {
  123|  93.2k|        nSigOps += txin.scriptSig.GetSigOpCount(false);
  124|  93.2k|    }
  125|  4.07k|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (125:28): [True: 624k, False: 4.07k]
  ------------------
  126|   624k|    {
  127|   624k|        nSigOps += txout.scriptPubKey.GetSigOpCount(false);
  128|   624k|    }
  129|  4.07k|    return nSigOps;
  130|  4.07k|}

core_io.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  141|  16.0k|{
  142|  16.0k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  143|  16.0k|}
policy.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  141|  8.38k|{
  142|  8.38k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  143|  8.38k|}
transaction.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  141|  4.07k|{
  142|  4.07k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  143|  4.07k|}
_ZNK15ValidationStateI18TxValidationResultE7IsValidEv:
  113|  4.07k|    bool IsValid() const { return m_mode == ModeState::M_VALID; }
_ZN15ValidationStateI18TxValidationResultE7InvalidES0_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_:
   99|  7.33k|    {
  100|  7.33k|        m_result = result;
  101|  7.33k|        m_reject_reason = reject_reason;
  102|  7.33k|        m_debug_message = debug_message;
  103|  7.33k|        if (m_mode != ModeState::M_ERROR) m_mode = ModeState::M_INVALID;
  ------------------
  |  Branch (103:13): [True: 7.33k, False: 0]
  ------------------
  104|  7.33k|        return false;
  105|  7.33k|    }

_Z15ValueFromAmountl:
  284|   454k|{
  285|   454k|    static_assert(COIN > 1);
  286|   454k|    int64_t quotient = amount / COIN;
  287|   454k|    int64_t remainder = amount % COIN;
  288|   454k|    if (amount < 0) {
  ------------------
  |  Branch (288:9): [True: 25.0k, False: 429k]
  ------------------
  289|  25.0k|        quotient = -quotient;
  290|  25.0k|        remainder = -remainder;
  291|  25.0k|    }
  292|   454k|    return UniValue(UniValue::VNUM,
  293|   454k|            strprintf("%s%d.%08d", amount < 0 ? "-" : "", quotient, remainder));
  ------------------
  |  | 1172|   454k|#define strprintf tfm::format
  ------------------
  |  Branch (293:36): [True: 25.0k, False: 429k]
  ------------------
  294|   454k|}
_Z14ScriptToAsmStrRK7CScriptb:
  356|   575k|{
  357|   575k|    std::string str;
  358|   575k|    opcodetype opcode;
  359|   575k|    std::vector<unsigned char> vch;
  360|   575k|    CScript::const_iterator pc = script.begin();
  361|  6.59M|    while (pc < script.end()) {
  ------------------
  |  Branch (361:12): [True: 6.28M, False: 314k]
  ------------------
  362|  6.28M|        if (!str.empty()) {
  ------------------
  |  Branch (362:13): [True: 5.91M, False: 372k]
  ------------------
  363|  5.91M|            str += " ";
  364|  5.91M|        }
  365|  6.28M|        if (!script.GetOp(pc, opcode, vch)) {
  ------------------
  |  Branch (365:13): [True: 261k, False: 6.02M]
  ------------------
  366|   261k|            str += "[error]";
  367|   261k|            return str;
  368|   261k|        }
  369|  6.02M|        if (0 <= opcode && opcode <= OP_PUSHDATA4) {
  ------------------
  |  Branch (369:13): [True: 6.02M, False: 0]
  |  Branch (369:28): [True: 3.26M, False: 2.75M]
  ------------------
  370|  3.26M|            if (vch.size() <= static_cast<std::vector<unsigned char>::size_type>(4)) {
  ------------------
  |  Branch (370:17): [True: 3.00M, False: 261k]
  ------------------
  371|  3.00M|                str += strprintf("%d", CScriptNum(vch, false).getint());
  ------------------
  |  | 1172|  3.00M|#define strprintf tfm::format
  ------------------
  372|  3.00M|            } else {
  373|       |                // the IsUnspendable check makes sure not to try to decode OP_RETURN data that may match the format of a signature
  374|   261k|                if (fAttemptSighashDecode && !script.IsUnspendable()) {
  ------------------
  |  Branch (374:21): [True: 70.9k, False: 190k]
  |  Branch (374:46): [True: 35.5k, False: 35.4k]
  ------------------
  375|  35.5k|                    std::string strSigHashDecode;
  376|       |                    // goal: only attempt to decode a defined sighash type from data that looks like a signature within a scriptSig.
  377|       |                    // this won't decode correctly formatted public keys in Pubkey or Multisig scripts due to
  378|       |                    // the restrictions on the pubkey formats (see IsCompressedOrUncompressedPubKey) being incongruous with the
  379|       |                    // checks in CheckSignatureEncoding.
  380|  35.5k|                    if (CheckSignatureEncoding(vch, SCRIPT_VERIFY_STRICTENC, nullptr)) {
  ------------------
  |  Branch (380:25): [True: 2.69k, False: 32.8k]
  ------------------
  381|  2.69k|                        const unsigned char chSigHashType = vch.back();
  382|  2.69k|                        const auto it = mapSigHashTypes.find(chSigHashType);
  383|  2.69k|                        if (it != mapSigHashTypes.end()) {
  ------------------
  |  Branch (383:29): [True: 2.69k, False: 0]
  ------------------
  384|  2.69k|                            strSigHashDecode = "[" + it->second + "]";
  385|  2.69k|                            vch.pop_back(); // remove the sighash type byte. it will be replaced by the decode.
  386|  2.69k|                        }
  387|  2.69k|                    }
  388|  35.5k|                    str += HexStr(vch) + strSigHashDecode;
  389|   226k|                } else {
  390|   226k|                    str += HexStr(vch);
  391|   226k|                }
  392|   261k|            }
  393|  3.26M|        } else {
  394|  2.75M|            str += GetOpName(opcode);
  395|  2.75M|        }
  396|  6.02M|    }
  397|   314k|    return str;
  398|   575k|}
_Z11EncodeHexTxRK12CTransaction:
  401|  12.0k|{
  402|  12.0k|    DataStream ssTx;
  403|  12.0k|    ssTx << TX_WITH_WITNESS(tx);
  404|  12.0k|    return HexStr(ssTx);
  405|  12.0k|}
_Z12ScriptToUnivRK7CScriptR8UniValuebbPK15SigningProvider:
  408|   454k|{
  409|   454k|    CTxDestination address;
  410|       |
  411|   454k|    out.pushKV("asm", ScriptToAsmStr(script));
  412|   454k|    if (include_address) {
  ------------------
  |  Branch (412:9): [True: 454k, False: 0]
  ------------------
  413|   454k|        out.pushKV("desc", InferDescriptor(script, provider ? *provider : DUMMY_SIGNING_PROVIDER)->ToString());
  ------------------
  |  Branch (413:52): [True: 0, False: 454k]
  ------------------
  414|   454k|    }
  415|   454k|    if (include_hex) {
  ------------------
  |  Branch (415:9): [True: 454k, False: 0]
  ------------------
  416|   454k|        out.pushKV("hex", HexStr(script));
  417|   454k|    }
  418|       |
  419|   454k|    std::vector<std::vector<unsigned char>> solns;
  420|   454k|    const TxoutType type{Solver(script, solns)};
  421|       |
  422|   454k|    if (include_address && ExtractDestination(script, address) && type != TxoutType::PUBKEY) {
  ------------------
  |  Branch (422:9): [True: 454k, False: 0]
  |  Branch (422:28): [True: 66.8k, False: 387k]
  |  Branch (422:67): [True: 66.8k, False: 0]
  ------------------
  423|  66.8k|        out.pushKV("address", EncodeDestination(address));
  424|  66.8k|    }
  425|   454k|    out.pushKV("type", GetTxnOutputType(type));
  426|   454k|}
_Z8TxToUnivRK12CTransactionRK7uint256R8UniValuebPK7CTxUndo11TxVerbosityNSt3__18functionIFbRK6CTxOutEEE:
  429|  8.02k|{
  430|  8.02k|    CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);
  ------------------
  |  |  113|  8.02k|    inline_check_non_fatal(condition, std::source_location::current(), #condition)
  ------------------
  431|       |
  432|  8.02k|    entry.pushKV("txid", tx.GetHash().GetHex());
  433|  8.02k|    entry.pushKV("hash", tx.GetWitnessHash().GetHex());
  434|  8.02k|    entry.pushKV("version", tx.version);
  435|  8.02k|    entry.pushKV("size", tx.ComputeTotalSize());
  436|  8.02k|    entry.pushKV("vsize", (GetTransactionWeight(tx) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR);
  437|  8.02k|    entry.pushKV("weight", GetTransactionWeight(tx));
  438|  8.02k|    entry.pushKV("locktime", tx.nLockTime);
  439|       |
  440|  8.02k|    UniValue vin{UniValue::VARR};
  441|  8.02k|    vin.reserve(tx.vin.size());
  442|       |
  443|       |    // If available, use Undo data to calculate the fee. Note that txundo == nullptr
  444|       |    // for coinbase transactions and for transactions where undo data is unavailable.
  445|  8.02k|    const bool have_undo = txundo != nullptr;
  446|  8.02k|    CAmount amt_total_in = 0;
  447|  8.02k|    CAmount amt_total_out = 0;
  448|       |
  449|   128k|    for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (449:30): [True: 120k, False: 8.02k]
  ------------------
  450|   120k|        const CTxIn& txin = tx.vin[i];
  451|   120k|        UniValue in(UniValue::VOBJ);
  452|   120k|        if (tx.IsCoinBase()) {
  ------------------
  |  Branch (452:13): [True: 110, False: 120k]
  ------------------
  453|    110|            in.pushKV("coinbase", HexStr(txin.scriptSig));
  454|   120k|        } else {
  455|   120k|            in.pushKV("txid", txin.prevout.hash.GetHex());
  456|   120k|            in.pushKV("vout", txin.prevout.n);
  457|   120k|            UniValue o(UniValue::VOBJ);
  458|   120k|            o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true));
  459|   120k|            o.pushKV("hex", HexStr(txin.scriptSig));
  460|   120k|            in.pushKV("scriptSig", std::move(o));
  461|   120k|        }
  462|   120k|        if (!tx.vin[i].scriptWitness.IsNull()) {
  ------------------
  |  Branch (462:13): [True: 9.48k, False: 111k]
  ------------------
  463|  9.48k|            UniValue txinwitness(UniValue::VARR);
  464|  9.48k|            txinwitness.reserve(tx.vin[i].scriptWitness.stack.size());
  465|  3.94M|            for (const auto& item : tx.vin[i].scriptWitness.stack) {
  ------------------
  |  Branch (465:35): [True: 3.94M, False: 9.48k]
  ------------------
  466|  3.94M|                txinwitness.push_back(HexStr(item));
  467|  3.94M|            }
  468|  9.48k|            in.pushKV("txinwitness", std::move(txinwitness));
  469|  9.48k|        }
  470|   120k|        if (have_undo) {
  ------------------
  |  Branch (470:13): [True: 0, False: 120k]
  ------------------
  471|      0|            const Coin& prev_coin = txundo->vprevout[i];
  472|      0|            const CTxOut& prev_txout = prev_coin.out;
  473|       |
  474|      0|            amt_total_in += prev_txout.nValue;
  475|       |
  476|      0|            if (verbosity == TxVerbosity::SHOW_DETAILS_AND_PREVOUT) {
  ------------------
  |  Branch (476:17): [True: 0, False: 0]
  ------------------
  477|      0|                UniValue o_script_pub_key(UniValue::VOBJ);
  478|      0|                ScriptToUniv(prev_txout.scriptPubKey, /*out=*/o_script_pub_key, /*include_hex=*/true, /*include_address=*/true);
  479|       |
  480|      0|                UniValue p(UniValue::VOBJ);
  481|      0|                p.pushKV("generated", prev_coin.IsCoinBase());
  482|      0|                p.pushKV("height", prev_coin.nHeight);
  483|      0|                p.pushKV("value", ValueFromAmount(prev_txout.nValue));
  484|      0|                p.pushKV("scriptPubKey", std::move(o_script_pub_key));
  485|      0|                in.pushKV("prevout", std::move(p));
  486|      0|            }
  487|      0|        }
  488|   120k|        in.pushKV("sequence", txin.nSequence);
  489|   120k|        vin.push_back(std::move(in));
  490|   120k|    }
  491|  8.02k|    entry.pushKV("vin", std::move(vin));
  492|       |
  493|  8.02k|    UniValue vout(UniValue::VARR);
  494|  8.02k|    vout.reserve(tx.vout.size());
  495|   462k|    for (unsigned int i = 0; i < tx.vout.size(); i++) {
  ------------------
  |  Branch (495:30): [True: 454k, False: 8.02k]
  ------------------
  496|   454k|        const CTxOut& txout = tx.vout[i];
  497|       |
  498|   454k|        UniValue out(UniValue::VOBJ);
  499|       |
  500|   454k|        out.pushKV("value", ValueFromAmount(txout.nValue));
  501|   454k|        out.pushKV("n", i);
  502|       |
  503|   454k|        UniValue o(UniValue::VOBJ);
  504|   454k|        ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
  505|   454k|        out.pushKV("scriptPubKey", std::move(o));
  506|       |
  507|   454k|        if (is_change_func && is_change_func(txout)) {
  ------------------
  |  Branch (507:13): [True: 0, False: 454k]
  |  Branch (507:31): [True: 0, False: 0]
  ------------------
  508|      0|            out.pushKV("ischange", true);
  509|      0|        }
  510|       |
  511|   454k|        vout.push_back(std::move(out));
  512|       |
  513|   454k|        if (have_undo) {
  ------------------
  |  Branch (513:13): [True: 0, False: 454k]
  ------------------
  514|      0|            amt_total_out += txout.nValue;
  515|      0|        }
  516|   454k|    }
  517|  8.02k|    entry.pushKV("vout", std::move(vout));
  518|       |
  519|  8.02k|    if (have_undo) {
  ------------------
  |  Branch (519:9): [True: 0, False: 8.02k]
  ------------------
  520|      0|        const CAmount fee = amt_total_in - amt_total_out;
  521|      0|        CHECK_NONFATAL(MoneyRange(fee));
  ------------------
  |  |  113|      0|    inline_check_non_fatal(condition, std::source_location::current(), #condition)
  ------------------
  522|      0|        entry.pushKV("fee", ValueFromAmount(fee));
  523|      0|    }
  524|       |
  525|  8.02k|    if (!block_hash.IsNull()) {
  ------------------
  |  Branch (525:9): [True: 4.01k, False: 4.01k]
  ------------------
  526|  4.01k|        entry.pushKV("blockhash", block_hash.GetHex());
  527|  4.01k|    }
  528|       |
  529|  8.02k|    if (include_hex) {
  ------------------
  |  Branch (529:9): [True: 8.02k, False: 0]
  ------------------
  530|  8.02k|        entry.pushKV("hex", EncodeHexTx(tx)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".
  531|  8.02k|    }
  532|  8.02k|}

transaction.cpp:_ZL21RecursiveDynamicUsageRK12CTransaction:
   32|  4.07k|static inline size_t RecursiveDynamicUsage(const CTransaction& tx) {
   33|  4.07k|    size_t mem = memusage::DynamicUsage(tx.vin) + memusage::DynamicUsage(tx.vout);
   34|  97.2k|    for (std::vector<CTxIn>::const_iterator it = tx.vin.begin(); it != tx.vin.end(); it++) {
  ------------------
  |  Branch (34:66): [True: 93.2k, False: 4.07k]
  ------------------
   35|  93.2k|        mem += RecursiveDynamicUsage(*it);
   36|  93.2k|    }
   37|   628k|    for (std::vector<CTxOut>::const_iterator it = tx.vout.begin(); it != tx.vout.end(); it++) {
  ------------------
  |  Branch (37:68): [True: 624k, False: 4.07k]
  ------------------
   38|   624k|        mem += RecursiveDynamicUsage(*it);
   39|   624k|    }
   40|  4.07k|    return mem;
   41|  4.07k|}
transaction.cpp:_ZL21RecursiveDynamicUsageRK5CTxIn:
   20|  93.2k|static inline size_t RecursiveDynamicUsage(const CTxIn& in) {
   21|  93.2k|    size_t mem = RecursiveDynamicUsage(in.scriptSig) + RecursiveDynamicUsage(in.prevout) + memusage::DynamicUsage(in.scriptWitness.stack);
   22|  5.66M|    for (std::vector<std::vector<unsigned char> >::const_iterator it = in.scriptWitness.stack.begin(); it != in.scriptWitness.stack.end(); it++) {
  ------------------
  |  Branch (22:104): [True: 5.56M, False: 93.2k]
  ------------------
   23|  5.56M|         mem += memusage::DynamicUsage(*it);
   24|  5.56M|    }
   25|  93.2k|    return mem;
   26|  93.2k|}
transaction.cpp:_ZL21RecursiveDynamicUsageRK7CScript:
   12|   718k|static inline size_t RecursiveDynamicUsage(const CScript& script) {
   13|   718k|    return memusage::DynamicUsage(script);
   14|   718k|}
transaction.cpp:_ZL21RecursiveDynamicUsageRK9COutPoint:
   16|  93.2k|static inline size_t RecursiveDynamicUsage(const COutPoint& out) {
   17|  93.2k|    return 0;
   18|  93.2k|}
transaction.cpp:_ZL21RecursiveDynamicUsageRK6CTxOut:
   28|   624k|static inline size_t RecursiveDynamicUsage(const CTxOut& out) {
   29|   624k|    return RecursiveDynamicUsage(out.scriptPubKey);
   30|   624k|}

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

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

_Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_:
   36|  8.15k|{
   37|  8.15k|    uint64_t x;
   38|  8.15k|    memcpy(&x, ptr, 8);
   39|  8.15k|    return le64toh_internal(x);
   40|  8.15k|}
_Z8ReadLE16ITk8ByteTypehEtPKT_:
   20|  15.6k|{
   21|  15.6k|    uint16_t x;
   22|  15.6k|    memcpy(&x, ptr, 2);
   23|  15.6k|    return le16toh_internal(x);
   24|  15.6k|}
_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|   383k|{
   37|   383k|    uint64_t x;
   38|   383k|    memcpy(&x, ptr, 8);
   39|   383k|    return le64toh_internal(x);
   40|   383k|}
_Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j:
   51|   195k|{
   52|   195k|    uint32_t v = htole32_internal(x);
   53|   195k|    memcpy(ptr, &v, 4);
   54|   195k|}
_Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_:
   28|   168k|{
   29|   168k|    uint32_t x;
   30|   168k|    memcpy(&x, ptr, 4);
   31|   168k|    return le32toh_internal(x);
   32|   168k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|   617k|{
   29|   617k|    uint32_t x;
   30|   617k|    memcpy(&x, ptr, 4);
   31|   617k|    return le32toh_internal(x);
   32|   617k|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|   191k|{
   52|   191k|    uint32_t v = htole32_internal(x);
   53|   191k|    memcpy(ptr, &v, 4);
   54|   191k|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  18.2M|{
   74|  18.2M|    uint32_t x;
   75|  18.2M|    memcpy(&x, ptr, 4);
   76|  18.2M|    return be32toh_internal(x);
   77|  18.2M|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  1.19M|{
   97|  1.19M|    uint32_t v = htobe32_internal(x);
   98|  1.19M|    memcpy(ptr, &v, 4);
   99|  1.19M|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  38.2k|{
   59|  38.2k|    uint64_t v = htole64_internal(x);
   60|  38.2k|    memcpy(ptr, &v, 8);
   61|  38.2k|}
_Z8ReadBE64ITk8ByteTypehEmPKT_:
   81|   130k|{
   82|   130k|    uint64_t x;
   83|   130k|    memcpy(&x, ptr, 8);
   84|   130k|    return be64toh_internal(x);
   85|   130k|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|   223k|{
  104|   223k|    uint64_t v = htobe64_internal(x);
  105|   223k|    memcpy(ptr, &v, 8);
  106|   223k|}

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

_Z6HexStrNSt3__14spanIKSt4byteLm18446744073709551615EEE:
   20|  12.0k|inline std::string HexStr(std::span<const std::byte> s) { return HexStr(MakeUCharSpan(s)); }

_ZN10CRIPEMD160C2Ev:
  243|  38.2k|{
  244|  38.2k|    ripemd160::Initialize(s);
  245|  38.2k|}
_ZN10CRIPEMD1605WriteEPKhm:
  248|   114k|{
  249|   114k|    const unsigned char* end = data + len;
  250|   114k|    size_t bufsize = bytes % 64;
  251|   114k|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (251:9): [True: 76.4k, False: 38.2k]
  |  Branch (251:20): [True: 38.2k, False: 38.2k]
  ------------------
  252|       |        // Fill the buffer, and process it.
  253|  38.2k|        memcpy(buf + bufsize, data, 64 - bufsize);
  254|  38.2k|        bytes += 64 - bufsize;
  255|  38.2k|        data += 64 - bufsize;
  256|  38.2k|        ripemd160::Transform(s, buf);
  257|  38.2k|        bufsize = 0;
  258|  38.2k|    }
  259|   114k|    while (end - data >= 64) {
  ------------------
  |  Branch (259:12): [True: 0, False: 114k]
  ------------------
  260|       |        // Process full chunks directly from the source.
  261|      0|        ripemd160::Transform(s, data);
  262|      0|        bytes += 64;
  263|      0|        data += 64;
  264|      0|    }
  265|   114k|    if (end > data) {
  ------------------
  |  Branch (265:9): [True: 76.4k, False: 38.2k]
  ------------------
  266|       |        // Fill the buffer with what remains.
  267|  76.4k|        memcpy(buf + bufsize, data, end - data);
  268|  76.4k|        bytes += end - data;
  269|  76.4k|    }
  270|   114k|    return *this;
  271|   114k|}
_ZN10CRIPEMD1608FinalizeEPh:
  274|  38.2k|{
  275|  38.2k|    static const unsigned char pad[64] = {0x80};
  276|  38.2k|    unsigned char sizedesc[8];
  277|  38.2k|    WriteLE64(sizedesc, bytes << 3);
  278|  38.2k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  279|  38.2k|    Write(sizedesc, 8);
  280|  38.2k|    WriteLE32(hash, s[0]);
  281|  38.2k|    WriteLE32(hash + 4, s[1]);
  282|  38.2k|    WriteLE32(hash + 8, s[2]);
  283|  38.2k|    WriteLE32(hash + 12, s[3]);
  284|  38.2k|    WriteLE32(hash + 16, s[4]);
  285|  38.2k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd16010InitializeEPj:
   25|  38.2k|{
   26|  38.2k|    s[0] = 0x67452301ul;
   27|  38.2k|    s[1] = 0xEFCDAB89ul;
   28|  38.2k|    s[2] = 0x98BADCFEul;
   29|  38.2k|    s[3] = 0x10325476ul;
   30|  38.2k|    s[4] = 0xC3D2E1F0ul;
   31|  38.2k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1609TransformEPjPKh:
   55|  38.2k|{
   56|  38.2k|    uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
   57|  38.2k|    uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
   58|  38.2k|    uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12);
   59|  38.2k|    uint32_t w4 = ReadLE32(chunk + 16), w5 = ReadLE32(chunk + 20), w6 = ReadLE32(chunk + 24), w7 = ReadLE32(chunk + 28);
   60|  38.2k|    uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44);
   61|  38.2k|    uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60);
   62|       |
   63|  38.2k|    R11(a1, b1, c1, d1, e1, w0, 11);
   64|  38.2k|    R12(a2, b2, c2, d2, e2, w5, 8);
   65|  38.2k|    R11(e1, a1, b1, c1, d1, w1, 14);
   66|  38.2k|    R12(e2, a2, b2, c2, d2, w14, 9);
   67|  38.2k|    R11(d1, e1, a1, b1, c1, w2, 15);
   68|  38.2k|    R12(d2, e2, a2, b2, c2, w7, 9);
   69|  38.2k|    R11(c1, d1, e1, a1, b1, w3, 12);
   70|  38.2k|    R12(c2, d2, e2, a2, b2, w0, 11);
   71|  38.2k|    R11(b1, c1, d1, e1, a1, w4, 5);
   72|  38.2k|    R12(b2, c2, d2, e2, a2, w9, 13);
   73|  38.2k|    R11(a1, b1, c1, d1, e1, w5, 8);
   74|  38.2k|    R12(a2, b2, c2, d2, e2, w2, 15);
   75|  38.2k|    R11(e1, a1, b1, c1, d1, w6, 7);
   76|  38.2k|    R12(e2, a2, b2, c2, d2, w11, 15);
   77|  38.2k|    R11(d1, e1, a1, b1, c1, w7, 9);
   78|  38.2k|    R12(d2, e2, a2, b2, c2, w4, 5);
   79|  38.2k|    R11(c1, d1, e1, a1, b1, w8, 11);
   80|  38.2k|    R12(c2, d2, e2, a2, b2, w13, 7);
   81|  38.2k|    R11(b1, c1, d1, e1, a1, w9, 13);
   82|  38.2k|    R12(b2, c2, d2, e2, a2, w6, 7);
   83|  38.2k|    R11(a1, b1, c1, d1, e1, w10, 14);
   84|  38.2k|    R12(a2, b2, c2, d2, e2, w15, 8);
   85|  38.2k|    R11(e1, a1, b1, c1, d1, w11, 15);
   86|  38.2k|    R12(e2, a2, b2, c2, d2, w8, 11);
   87|  38.2k|    R11(d1, e1, a1, b1, c1, w12, 6);
   88|  38.2k|    R12(d2, e2, a2, b2, c2, w1, 14);
   89|  38.2k|    R11(c1, d1, e1, a1, b1, w13, 7);
   90|  38.2k|    R12(c2, d2, e2, a2, b2, w10, 14);
   91|  38.2k|    R11(b1, c1, d1, e1, a1, w14, 9);
   92|  38.2k|    R12(b2, c2, d2, e2, a2, w3, 12);
   93|  38.2k|    R11(a1, b1, c1, d1, e1, w15, 8);
   94|  38.2k|    R12(a2, b2, c2, d2, e2, w12, 6);
   95|       |
   96|  38.2k|    R21(e1, a1, b1, c1, d1, w7, 7);
   97|  38.2k|    R22(e2, a2, b2, c2, d2, w6, 9);
   98|  38.2k|    R21(d1, e1, a1, b1, c1, w4, 6);
   99|  38.2k|    R22(d2, e2, a2, b2, c2, w11, 13);
  100|  38.2k|    R21(c1, d1, e1, a1, b1, w13, 8);
  101|  38.2k|    R22(c2, d2, e2, a2, b2, w3, 15);
  102|  38.2k|    R21(b1, c1, d1, e1, a1, w1, 13);
  103|  38.2k|    R22(b2, c2, d2, e2, a2, w7, 7);
  104|  38.2k|    R21(a1, b1, c1, d1, e1, w10, 11);
  105|  38.2k|    R22(a2, b2, c2, d2, e2, w0, 12);
  106|  38.2k|    R21(e1, a1, b1, c1, d1, w6, 9);
  107|  38.2k|    R22(e2, a2, b2, c2, d2, w13, 8);
  108|  38.2k|    R21(d1, e1, a1, b1, c1, w15, 7);
  109|  38.2k|    R22(d2, e2, a2, b2, c2, w5, 9);
  110|  38.2k|    R21(c1, d1, e1, a1, b1, w3, 15);
  111|  38.2k|    R22(c2, d2, e2, a2, b2, w10, 11);
  112|  38.2k|    R21(b1, c1, d1, e1, a1, w12, 7);
  113|  38.2k|    R22(b2, c2, d2, e2, a2, w14, 7);
  114|  38.2k|    R21(a1, b1, c1, d1, e1, w0, 12);
  115|  38.2k|    R22(a2, b2, c2, d2, e2, w15, 7);
  116|  38.2k|    R21(e1, a1, b1, c1, d1, w9, 15);
  117|  38.2k|    R22(e2, a2, b2, c2, d2, w8, 12);
  118|  38.2k|    R21(d1, e1, a1, b1, c1, w5, 9);
  119|  38.2k|    R22(d2, e2, a2, b2, c2, w12, 7);
  120|  38.2k|    R21(c1, d1, e1, a1, b1, w2, 11);
  121|  38.2k|    R22(c2, d2, e2, a2, b2, w4, 6);
  122|  38.2k|    R21(b1, c1, d1, e1, a1, w14, 7);
  123|  38.2k|    R22(b2, c2, d2, e2, a2, w9, 15);
  124|  38.2k|    R21(a1, b1, c1, d1, e1, w11, 13);
  125|  38.2k|    R22(a2, b2, c2, d2, e2, w1, 13);
  126|  38.2k|    R21(e1, a1, b1, c1, d1, w8, 12);
  127|  38.2k|    R22(e2, a2, b2, c2, d2, w2, 11);
  128|       |
  129|  38.2k|    R31(d1, e1, a1, b1, c1, w3, 11);
  130|  38.2k|    R32(d2, e2, a2, b2, c2, w15, 9);
  131|  38.2k|    R31(c1, d1, e1, a1, b1, w10, 13);
  132|  38.2k|    R32(c2, d2, e2, a2, b2, w5, 7);
  133|  38.2k|    R31(b1, c1, d1, e1, a1, w14, 6);
  134|  38.2k|    R32(b2, c2, d2, e2, a2, w1, 15);
  135|  38.2k|    R31(a1, b1, c1, d1, e1, w4, 7);
  136|  38.2k|    R32(a2, b2, c2, d2, e2, w3, 11);
  137|  38.2k|    R31(e1, a1, b1, c1, d1, w9, 14);
  138|  38.2k|    R32(e2, a2, b2, c2, d2, w7, 8);
  139|  38.2k|    R31(d1, e1, a1, b1, c1, w15, 9);
  140|  38.2k|    R32(d2, e2, a2, b2, c2, w14, 6);
  141|  38.2k|    R31(c1, d1, e1, a1, b1, w8, 13);
  142|  38.2k|    R32(c2, d2, e2, a2, b2, w6, 6);
  143|  38.2k|    R31(b1, c1, d1, e1, a1, w1, 15);
  144|  38.2k|    R32(b2, c2, d2, e2, a2, w9, 14);
  145|  38.2k|    R31(a1, b1, c1, d1, e1, w2, 14);
  146|  38.2k|    R32(a2, b2, c2, d2, e2, w11, 12);
  147|  38.2k|    R31(e1, a1, b1, c1, d1, w7, 8);
  148|  38.2k|    R32(e2, a2, b2, c2, d2, w8, 13);
  149|  38.2k|    R31(d1, e1, a1, b1, c1, w0, 13);
  150|  38.2k|    R32(d2, e2, a2, b2, c2, w12, 5);
  151|  38.2k|    R31(c1, d1, e1, a1, b1, w6, 6);
  152|  38.2k|    R32(c2, d2, e2, a2, b2, w2, 14);
  153|  38.2k|    R31(b1, c1, d1, e1, a1, w13, 5);
  154|  38.2k|    R32(b2, c2, d2, e2, a2, w10, 13);
  155|  38.2k|    R31(a1, b1, c1, d1, e1, w11, 12);
  156|  38.2k|    R32(a2, b2, c2, d2, e2, w0, 13);
  157|  38.2k|    R31(e1, a1, b1, c1, d1, w5, 7);
  158|  38.2k|    R32(e2, a2, b2, c2, d2, w4, 7);
  159|  38.2k|    R31(d1, e1, a1, b1, c1, w12, 5);
  160|  38.2k|    R32(d2, e2, a2, b2, c2, w13, 5);
  161|       |
  162|  38.2k|    R41(c1, d1, e1, a1, b1, w1, 11);
  163|  38.2k|    R42(c2, d2, e2, a2, b2, w8, 15);
  164|  38.2k|    R41(b1, c1, d1, e1, a1, w9, 12);
  165|  38.2k|    R42(b2, c2, d2, e2, a2, w6, 5);
  166|  38.2k|    R41(a1, b1, c1, d1, e1, w11, 14);
  167|  38.2k|    R42(a2, b2, c2, d2, e2, w4, 8);
  168|  38.2k|    R41(e1, a1, b1, c1, d1, w10, 15);
  169|  38.2k|    R42(e2, a2, b2, c2, d2, w1, 11);
  170|  38.2k|    R41(d1, e1, a1, b1, c1, w0, 14);
  171|  38.2k|    R42(d2, e2, a2, b2, c2, w3, 14);
  172|  38.2k|    R41(c1, d1, e1, a1, b1, w8, 15);
  173|  38.2k|    R42(c2, d2, e2, a2, b2, w11, 14);
  174|  38.2k|    R41(b1, c1, d1, e1, a1, w12, 9);
  175|  38.2k|    R42(b2, c2, d2, e2, a2, w15, 6);
  176|  38.2k|    R41(a1, b1, c1, d1, e1, w4, 8);
  177|  38.2k|    R42(a2, b2, c2, d2, e2, w0, 14);
  178|  38.2k|    R41(e1, a1, b1, c1, d1, w13, 9);
  179|  38.2k|    R42(e2, a2, b2, c2, d2, w5, 6);
  180|  38.2k|    R41(d1, e1, a1, b1, c1, w3, 14);
  181|  38.2k|    R42(d2, e2, a2, b2, c2, w12, 9);
  182|  38.2k|    R41(c1, d1, e1, a1, b1, w7, 5);
  183|  38.2k|    R42(c2, d2, e2, a2, b2, w2, 12);
  184|  38.2k|    R41(b1, c1, d1, e1, a1, w15, 6);
  185|  38.2k|    R42(b2, c2, d2, e2, a2, w13, 9);
  186|  38.2k|    R41(a1, b1, c1, d1, e1, w14, 8);
  187|  38.2k|    R42(a2, b2, c2, d2, e2, w9, 12);
  188|  38.2k|    R41(e1, a1, b1, c1, d1, w5, 6);
  189|  38.2k|    R42(e2, a2, b2, c2, d2, w7, 5);
  190|  38.2k|    R41(d1, e1, a1, b1, c1, w6, 5);
  191|  38.2k|    R42(d2, e2, a2, b2, c2, w10, 15);
  192|  38.2k|    R41(c1, d1, e1, a1, b1, w2, 12);
  193|  38.2k|    R42(c2, d2, e2, a2, b2, w14, 8);
  194|       |
  195|  38.2k|    R51(b1, c1, d1, e1, a1, w4, 9);
  196|  38.2k|    R52(b2, c2, d2, e2, a2, w12, 8);
  197|  38.2k|    R51(a1, b1, c1, d1, e1, w0, 15);
  198|  38.2k|    R52(a2, b2, c2, d2, e2, w15, 5);
  199|  38.2k|    R51(e1, a1, b1, c1, d1, w5, 5);
  200|  38.2k|    R52(e2, a2, b2, c2, d2, w10, 12);
  201|  38.2k|    R51(d1, e1, a1, b1, c1, w9, 11);
  202|  38.2k|    R52(d2, e2, a2, b2, c2, w4, 9);
  203|  38.2k|    R51(c1, d1, e1, a1, b1, w7, 6);
  204|  38.2k|    R52(c2, d2, e2, a2, b2, w1, 12);
  205|  38.2k|    R51(b1, c1, d1, e1, a1, w12, 8);
  206|  38.2k|    R52(b2, c2, d2, e2, a2, w5, 5);
  207|  38.2k|    R51(a1, b1, c1, d1, e1, w2, 13);
  208|  38.2k|    R52(a2, b2, c2, d2, e2, w8, 14);
  209|  38.2k|    R51(e1, a1, b1, c1, d1, w10, 12);
  210|  38.2k|    R52(e2, a2, b2, c2, d2, w7, 6);
  211|  38.2k|    R51(d1, e1, a1, b1, c1, w14, 5);
  212|  38.2k|    R52(d2, e2, a2, b2, c2, w6, 8);
  213|  38.2k|    R51(c1, d1, e1, a1, b1, w1, 12);
  214|  38.2k|    R52(c2, d2, e2, a2, b2, w2, 13);
  215|  38.2k|    R51(b1, c1, d1, e1, a1, w3, 13);
  216|  38.2k|    R52(b2, c2, d2, e2, a2, w13, 6);
  217|  38.2k|    R51(a1, b1, c1, d1, e1, w8, 14);
  218|  38.2k|    R52(a2, b2, c2, d2, e2, w14, 5);
  219|  38.2k|    R51(e1, a1, b1, c1, d1, w11, 11);
  220|  38.2k|    R52(e2, a2, b2, c2, d2, w0, 15);
  221|  38.2k|    R51(d1, e1, a1, b1, c1, w6, 8);
  222|  38.2k|    R52(d2, e2, a2, b2, c2, w3, 13);
  223|  38.2k|    R51(c1, d1, e1, a1, b1, w15, 5);
  224|  38.2k|    R52(c2, d2, e2, a2, b2, w9, 11);
  225|  38.2k|    R51(b1, c1, d1, e1, a1, w13, 6);
  226|  38.2k|    R52(b2, c2, d2, e2, a2, w11, 11);
  227|       |
  228|  38.2k|    uint32_t t = s[0];
  229|  38.2k|    s[0] = s[1] + c1 + d2;
  230|  38.2k|    s[1] = s[2] + d1 + e2;
  231|  38.2k|    s[2] = s[3] + e1 + a2;
  232|  38.2k|    s[3] = s[4] + a1 + b2;
  233|  38.2k|    s[4] = t + b1 + c2;
  234|  38.2k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R11ERjjS1_jjji:
   41|   611k|void inline R11(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1605RoundERjjS1_jjjjji:
   36|  6.11M|{
   37|  6.11M|    a = rol(a + f + x + k, r) + e;
   38|  6.11M|    c = rol(c, 10);
   39|  6.11M|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603rolEji:
   33|  12.2M|uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f1Ejjj:
   17|  1.22M|uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R12ERjjS1_jjji:
   47|   611k|void inline R12(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0x50A28BE6ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f5Ejjj:
   21|  1.22M|uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R21ERjjS1_jjji:
   42|   611k|void inline R21(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x5A827999ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f2Ejjj:
   18|  1.22M|uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R22ERjjS1_jjji:
   48|   611k|void inline R22(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x5C4DD124ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f4Ejjj:
   20|  1.22M|uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R31ERjjS1_jjji:
   43|   611k|void inline R31(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6ED9EBA1ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f3Ejjj:
   19|  1.22M|uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R32ERjjS1_jjji:
   49|   611k|void inline R32(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6D703EF3ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R41ERjjS1_jjji:
   44|   611k|void inline R41(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x8F1BBCDCul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R42ERjjS1_jjji:
   50|   611k|void inline R42(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x7A6D76E9ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R51ERjjS1_jjji:
   45|   611k|void inline R51(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0xA953FD4Eul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R52ERjjS1_jjji:
   51|   611k|void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }

_ZN7CSHA256C2Ev:
  695|  88.2k|{
  696|  88.2k|    sha256::Initialize(s);
  697|  88.2k|}
_ZN7CSHA2565WriteEPKhm:
  700|  8.61M|{
  701|  8.61M|    const unsigned char* end = data + len;
  702|  8.61M|    size_t bufsize = bytes % 64;
  703|  8.61M|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (703:9): [True: 8.34M, False: 277k]
  |  Branch (703:20): [True: 565k, False: 7.77M]
  ------------------
  704|       |        // Fill the buffer, and process it.
  705|   565k|        memcpy(buf + bufsize, data, 64 - bufsize);
  706|   565k|        bytes += 64 - bufsize;
  707|   565k|        data += 64 - bufsize;
  708|   565k|        Transform(s, buf, 1);
  709|   565k|        bufsize = 0;
  710|   565k|    }
  711|  8.61M|    if (end - data >= 64) {
  ------------------
  |  Branch (711:9): [True: 54.4k, False: 8.56M]
  ------------------
  712|  54.4k|        size_t blocks = (end - data) / 64;
  713|  54.4k|        Transform(s, data, blocks);
  714|  54.4k|        data += 64 * blocks;
  715|  54.4k|        bytes += 64 * blocks;
  716|  54.4k|    }
  717|  8.61M|    if (end > data) {
  ------------------
  |  Branch (717:9): [True: 8.34M, False: 277k]
  ------------------
  718|       |        // Fill the buffer with what remains.
  719|  8.34M|        memcpy(buf + bufsize, data, end - data);
  720|  8.34M|        bytes += end - data;
  721|  8.34M|    }
  722|  8.61M|    return *this;
  723|  8.61M|}
_ZN7CSHA2568FinalizeEPh:
  726|   149k|{
  727|   149k|    static const unsigned char pad[64] = {0x80};
  728|   149k|    unsigned char sizedesc[8];
  729|   149k|    WriteBE64(sizedesc, bytes << 3);
  730|   149k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  731|   149k|    Write(sizedesc, 8);
  732|   149k|    WriteBE32(hash, s[0]);
  733|   149k|    WriteBE32(hash + 4, s[1]);
  734|   149k|    WriteBE32(hash + 8, s[2]);
  735|   149k|    WriteBE32(hash + 12, s[3]);
  736|   149k|    WriteBE32(hash + 16, s[4]);
  737|   149k|    WriteBE32(hash + 20, s[5]);
  738|   149k|    WriteBE32(hash + 24, s[6]);
  739|   149k|    WriteBE32(hash + 28, s[7]);
  740|   149k|}
_ZN7CSHA2565ResetEv:
  743|  61.7k|{
  744|  61.7k|    bytes = 0;
  745|  61.7k|    sha256::Initialize(s);
  746|  61.7k|    return *this;
  747|  61.7k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2569TransformEPjPKhm:
  100|   619k|{
  101|  1.75M|    while (blocks--) {
  ------------------
  |  Branch (101:12): [True: 1.13M, False: 619k]
  ------------------
  102|  1.13M|        uint32_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];
  103|  1.13M|        uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
  104|       |
  105|  1.13M|        Round(a, b, c, d, e, f, g, h, 0x428a2f98 + (w0 = ReadBE32(chunk + 0)));
  106|  1.13M|        Round(h, a, b, c, d, e, f, g, 0x71374491 + (w1 = ReadBE32(chunk + 4)));
  107|  1.13M|        Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf + (w2 = ReadBE32(chunk + 8)));
  108|  1.13M|        Round(f, g, h, a, b, c, d, e, 0xe9b5dba5 + (w3 = ReadBE32(chunk + 12)));
  109|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x3956c25b + (w4 = ReadBE32(chunk + 16)));
  110|  1.13M|        Round(d, e, f, g, h, a, b, c, 0x59f111f1 + (w5 = ReadBE32(chunk + 20)));
  111|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x923f82a4 + (w6 = ReadBE32(chunk + 24)));
  112|  1.13M|        Round(b, c, d, e, f, g, h, a, 0xab1c5ed5 + (w7 = ReadBE32(chunk + 28)));
  113|  1.13M|        Round(a, b, c, d, e, f, g, h, 0xd807aa98 + (w8 = ReadBE32(chunk + 32)));
  114|  1.13M|        Round(h, a, b, c, d, e, f, g, 0x12835b01 + (w9 = ReadBE32(chunk + 36)));
  115|  1.13M|        Round(g, h, a, b, c, d, e, f, 0x243185be + (w10 = ReadBE32(chunk + 40)));
  116|  1.13M|        Round(f, g, h, a, b, c, d, e, 0x550c7dc3 + (w11 = ReadBE32(chunk + 44)));
  117|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x72be5d74 + (w12 = ReadBE32(chunk + 48)));
  118|  1.13M|        Round(d, e, f, g, h, a, b, c, 0x80deb1fe + (w13 = ReadBE32(chunk + 52)));
  119|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x9bdc06a7 + (w14 = ReadBE32(chunk + 56)));
  120|  1.13M|        Round(b, c, d, e, f, g, h, a, 0xc19bf174 + (w15 = ReadBE32(chunk + 60)));
  121|       |
  122|  1.13M|        Round(a, b, c, d, e, f, g, h, 0xe49b69c1 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  123|  1.13M|        Round(h, a, b, c, d, e, f, g, 0xefbe4786 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  124|  1.13M|        Round(g, h, a, b, c, d, e, f, 0x0fc19dc6 + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  125|  1.13M|        Round(f, g, h, a, b, c, d, e, 0x240ca1cc + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  126|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x2de92c6f + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  127|  1.13M|        Round(d, e, f, g, h, a, b, c, 0x4a7484aa + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  128|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  129|  1.13M|        Round(b, c, d, e, f, g, h, a, 0x76f988da + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  130|  1.13M|        Round(a, b, c, d, e, f, g, h, 0x983e5152 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  131|  1.13M|        Round(h, a, b, c, d, e, f, g, 0xa831c66d + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  132|  1.13M|        Round(g, h, a, b, c, d, e, f, 0xb00327c8 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  133|  1.13M|        Round(f, g, h, a, b, c, d, e, 0xbf597fc7 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  134|  1.13M|        Round(e, f, g, h, a, b, c, d, 0xc6e00bf3 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  135|  1.13M|        Round(d, e, f, g, h, a, b, c, 0xd5a79147 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  136|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x06ca6351 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  137|  1.13M|        Round(b, c, d, e, f, g, h, a, 0x14292967 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  138|       |
  139|  1.13M|        Round(a, b, c, d, e, f, g, h, 0x27b70a85 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  140|  1.13M|        Round(h, a, b, c, d, e, f, g, 0x2e1b2138 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  141|  1.13M|        Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  142|  1.13M|        Round(f, g, h, a, b, c, d, e, 0x53380d13 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  143|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x650a7354 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  144|  1.13M|        Round(d, e, f, g, h, a, b, c, 0x766a0abb + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  145|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x81c2c92e + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  146|  1.13M|        Round(b, c, d, e, f, g, h, a, 0x92722c85 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  147|  1.13M|        Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  148|  1.13M|        Round(h, a, b, c, d, e, f, g, 0xa81a664b + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  149|  1.13M|        Round(g, h, a, b, c, d, e, f, 0xc24b8b70 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  150|  1.13M|        Round(f, g, h, a, b, c, d, e, 0xc76c51a3 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  151|  1.13M|        Round(e, f, g, h, a, b, c, d, 0xd192e819 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  152|  1.13M|        Round(d, e, f, g, h, a, b, c, 0xd6990624 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  153|  1.13M|        Round(c, d, e, f, g, h, a, b, 0xf40e3585 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  154|  1.13M|        Round(b, c, d, e, f, g, h, a, 0x106aa070 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  155|       |
  156|  1.13M|        Round(a, b, c, d, e, f, g, h, 0x19a4c116 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  157|  1.13M|        Round(h, a, b, c, d, e, f, g, 0x1e376c08 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  158|  1.13M|        Round(g, h, a, b, c, d, e, f, 0x2748774c + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  159|  1.13M|        Round(f, g, h, a, b, c, d, e, 0x34b0bcb5 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  160|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x391c0cb3 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  161|  1.13M|        Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  162|  1.13M|        Round(c, d, e, f, g, h, a, b, 0x5b9cca4f + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  163|  1.13M|        Round(b, c, d, e, f, g, h, a, 0x682e6ff3 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  164|  1.13M|        Round(a, b, c, d, e, f, g, h, 0x748f82ee + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  165|  1.13M|        Round(h, a, b, c, d, e, f, g, 0x78a5636f + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  166|  1.13M|        Round(g, h, a, b, c, d, e, f, 0x84c87814 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  167|  1.13M|        Round(f, g, h, a, b, c, d, e, 0x8cc70208 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  168|  1.13M|        Round(e, f, g, h, a, b, c, d, 0x90befffa + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  169|  1.13M|        Round(d, e, f, g, h, a, b, c, 0xa4506ceb + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  170|  1.13M|        Round(c, d, e, f, g, h, a, b, 0xbef9a3f7 + (w14 + sigma1(w12) + w7 + sigma0(w15)));
  171|  1.13M|        Round(b, c, d, e, f, g, h, a, 0xc67178f2 + (w15 + sigma1(w13) + w8 + sigma0(w0)));
  172|       |
  173|  1.13M|        s[0] += a;
  174|  1.13M|        s[1] += b;
  175|  1.13M|        s[2] += c;
  176|  1.13M|        s[3] += d;
  177|  1.13M|        s[4] += e;
  178|  1.13M|        s[5] += f;
  179|  1.13M|        s[6] += g;
  180|  1.13M|        s[7] += h;
  181|  1.13M|        chunk += 64;
  182|  1.13M|    }
  183|   619k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2565RoundEjjjRjjjjS1_j:
   78|  72.8M|{
   79|  72.8M|    uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
   80|  72.8M|    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
   81|  72.8M|    d += t1;
   82|  72.8M|    h = t1 + t2;
   83|  72.8M|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma1Ej:
   72|  72.8M|uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2562ChEjjj:
   69|  72.8M|uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma0Ej:
   71|  72.8M|uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2563MajEjjj:
   70|  72.8M|uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma1Ej:
   74|  54.6M|uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma0Ej:
   73|  54.6M|uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); }
sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj:
   87|   149k|{
   88|   149k|    s[0] = 0x6a09e667ul;
   89|   149k|    s[1] = 0xbb67ae85ul;
   90|   149k|    s[2] = 0x3c6ef372ul;
   91|   149k|    s[3] = 0xa54ff53aul;
   92|   149k|    s[4] = 0x510e527ful;
   93|   149k|    s[5] = 0x9b05688cul;
   94|   149k|    s[6] = 0x1f83d9abul;
   95|   149k|    s[7] = 0x5be0cd19ul;
   96|   149k|}

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

_ZN13SipHasher13UJC2Emm:
  166|  4.07k|    SipHasher13UJ(uint64_t k0, uint64_t k1) noexcept : m_state{k0, k1} {}
_ZNK13SipHasher13UJ4HashERK7uint256m:
  187|  95.9k|    {
  188|  95.9k|        return m_state.Copy()
  189|  95.9k|                      .Compress1Jumbo(hash)
  190|  95.9k|                      .Compress1(extra)
  191|  95.9k|                      .Finalize3U();
  192|  95.9k|    }
_ZN12SipHashStateC2Emmmm:
   28|   100k|    ALWAYS_INLINE SipHashState(uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) noexcept : m_v0{v0}, m_v1{v1}, m_v2{v2}, m_v3{v3} {}
_ZN12SipHashState8SipRoundEv:
   35|   479k|    {
   36|   479k|        m_v0 += m_v1; m_v1 = std::rotl(m_v1, 13); m_v1 ^= m_v0;
   37|   479k|        m_v0 = std::rotl(m_v0, 32);
   38|   479k|        m_v2 += m_v3; m_v3 = std::rotl(m_v3, 16); m_v3 ^= m_v2;
   39|   479k|        m_v0 += m_v3; m_v3 = std::rotl(m_v3, 21); m_v3 ^= m_v0;
   40|   479k|        m_v2 += m_v1; m_v1 = std::rotl(m_v1, 17); m_v1 ^= m_v2;
   41|   479k|        m_v2 = std::rotl(m_v2, 32);
   42|   479k|    }
_ZN12SipHashStateC2Emm:
   46|  4.07k|    explicit ALWAYS_INLINE SipHashState(uint64_t k0, uint64_t k1) noexcept : SipHashState{C0 ^ k0, C1 ^ k1, C2 ^ k0, C3 ^ k1} {}
_ZNK12SipHashState4CopyEv:
   48|  95.9k|    ALWAYS_INLINE SipHashState Copy() const noexcept { return {m_v0, m_v1, m_v2, m_v3}; }
_ZN12SipHashState9Compress1Em:
   51|  95.9k|    {
   52|  95.9k|        m_v3 ^= data;
   53|  95.9k|        SipRound();
   54|  95.9k|        m_v0 ^= data;
   55|  95.9k|        return *this;
   56|  95.9k|    }
_ZN12SipHashState14Compress1JumboERK7uint256:
   59|  95.9k|    {
   60|  95.9k|        const uint64_t d0{data.GetUint64(0)}, d1{data.GetUint64(1)}, d2{data.GetUint64(2)}, d3{data.GetUint64(3)};
   61|  95.9k|        m_v3 ^= d0; m_v0 ^= d1; m_v1 ^= d2; m_v2 ^= d3;
   62|  95.9k|        SipRound();
   63|  95.9k|        m_v0 ^= d0; m_v1 ^= d1; m_v2 ^= d2; m_v3 ^= d3;
   64|  95.9k|        return *this;
   65|  95.9k|    }
_ZN12SipHashState10Finalize3UEv:
   88|  95.9k|    {
   89|  95.9k|        m_v2 ^= FINALIZER_UNPADDED;
   90|  95.9k|        SipRound();
   91|  95.9k|        SipRound();
   92|  95.9k|        SipRound();
   93|  95.9k|        return m_v0 ^ m_v1 ^ m_v2 ^ m_v3;
   94|  95.9k|    }

_Z9RIPEMD160NSt3__14spanIKhLm18446744073709551615EEE:
  231|  11.7k|{
  232|  11.7k|    uint160 result;
  233|  11.7k|    CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin());
  234|  11.7k|    return result;
  235|  11.7k|}
_Z4HashINSt3__16vectorIhNS0_9allocatorIhEEEEE7uint256RKT_:
   84|  56.4k|{
   85|  56.4k|    uint256 result;
   86|  56.4k|    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
   87|  56.4k|    return result;
   88|  56.4k|}
_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }
_ZN10HashWriterlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
  150|  5.26k|    {
  151|  5.26k|        ::Serialize(*this, obj);
  152|  5.26k|        return *this;
  153|  5.26k|    }
_Z7Hash160INSt3__14spanIKhLm18446744073709551615EEEE7uint160RKT_:
  101|  26.4k|{
  102|  26.4k|    uint160 result;
  103|  26.4k|    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
  104|  26.4k|    return result;
  105|  26.4k|}
_ZN8CHash2565WriteENSt3__14spanIKhLm18446744073709551615EEE:
   45|  56.4k|    CHash256& Write(std::span<const unsigned char> input) {
   46|  56.4k|        sha.Write(input.data(), input.size());
   47|  56.4k|        return *this;
   48|  56.4k|    }
_ZN8CHash2568FinalizeENSt3__14spanIhLm18446744073709551615EEE:
   38|  56.4k|    void Finalize(std::span<unsigned char> output) {
   39|  56.4k|        assert(output.size() == OUTPUT_SIZE);
  ------------------
  |  Branch (39:9): [True: 56.4k, False: 0]
  ------------------
   40|  56.4k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   41|  56.4k|        sha.Finalize(buf);
   42|  56.4k|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   43|  56.4k|    }
_ZN10HashWriter7GetHashEv:
  123|  5.26k|    uint256 GetHash() {
  124|  5.26k|        uint256 result;
  125|  5.26k|        ctx.Finalize(result.begin());
  126|  5.26k|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  127|  5.26k|        return result;
  128|  5.26k|    }
_ZN8CHash1605WriteENSt3__14spanIKhLm18446744073709551615EEE:
   70|  26.4k|    CHash160& Write(std::span<const unsigned char> input) {
   71|  26.4k|        sha.Write(input.data(), input.size());
   72|  26.4k|        return *this;
   73|  26.4k|    }
_ZN8CHash1608FinalizeENSt3__14spanIhLm18446744073709551615EEE:
   63|  26.4k|    void Finalize(std::span<unsigned char> output) {
   64|  26.4k|        assert(output.size() == OUTPUT_SIZE);
  ------------------
  |  Branch (64:9): [True: 26.4k, False: 0]
  ------------------
   65|  26.4k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   66|  26.4k|        sha.Finalize(buf);
   67|  26.4k|        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   68|  26.4k|    }
_ZN10HashWriter5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  115|  8.17M|    {
  116|  8.17M|        ctx.Write(UCharCast(src.data()), src.size());
  117|  8.17M|    }

_ZNK12CChainParams12Base58PrefixENS_10Base58TypeE:
  114|  56.4k|    const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
_ZNK12CChainParams9Bech32HRPEv:
  115|  74.4k|    const std::string& Bech32HRP() const { return bech32_hrp; }

_Z17EncodeDestinationRKNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  296|   130k|{
  297|   130k|    return std::visit(DestinationEncoder(Params()), dest);
  298|   130k|}
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK6PKHash:
   32|  11.9k|    {
   33|  11.9k|        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
   34|  11.9k|        data.insert(data.end(), id.begin(), id.end());
   35|  11.9k|        return EncodeBase58Check(data);
   36|  11.9k|    }
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK10ScriptHash:
   39|  44.5k|    {
   40|  44.5k|        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
   41|  44.5k|        data.insert(data.end(), id.begin(), id.end());
   42|  44.5k|        return EncodeBase58Check(data);
   43|  44.5k|    }
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHash:
   54|  23.5k|    {
   55|  23.5k|        std::vector<unsigned char> data = {0};
   56|  23.5k|        data.reserve(53);
   57|  23.5k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
   58|  23.5k|        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
   59|  23.5k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashENKUlhE_clEh:
   57|  1.22M|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHash:
   46|  27.4k|    {
   47|  27.4k|        std::vector<unsigned char> data = {0};
   48|  27.4k|        data.reserve(33);
   49|  27.4k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
   50|  27.4k|        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
   51|  27.4k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashENKUlhE_clEh:
   49|   879k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1Taproot:
   62|  6.27k|    {
   63|  6.27k|        std::vector<unsigned char> data = {1};
   64|  6.27k|        data.reserve(53);
   65|  6.27k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, tap.begin(), tap.end());
   66|  6.27k|        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
   67|  6.27k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootENKUlhE_clEh:
   65|   326k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, tap.begin(), tap.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknown:
   70|  17.1k|    {
   71|  17.1k|        const std::vector<unsigned char>& program = id.GetWitnessProgram();
   72|  17.1k|        if (id.GetWitnessVersion() < 1 || id.GetWitnessVersion() > 16 || program.size() < 2 || program.size() > 40) {
  ------------------
  |  Branch (72:13): [True: 0, False: 17.1k]
  |  Branch (72:43): [True: 0, False: 17.1k]
  |  Branch (72:74): [True: 0, False: 17.1k]
  |  Branch (72:96): [True: 0, False: 17.1k]
  ------------------
   73|      0|            return {};
   74|      0|        }
   75|  17.1k|        std::vector<unsigned char> data = {(unsigned char)id.GetWitnessVersion()};
   76|  17.1k|        data.reserve(1 + CeilDiv(program.size() * 8, 5u));
   77|  17.1k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());
   78|  17.1k|        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
   79|  17.1k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownENKUlhE_clEh:
   77|   193k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());
key_io.cpp:_ZN12_GLOBAL__N_118DestinationEncoderC2ERK12CChainParams:
   29|   130k|    explicit DestinationEncoder(const CChainParams& params) : m_params(params) {}

_Z11LogInstancev:
   27|  4.76k|{
   28|       |/**
   29|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   30|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   31|       | * since the order of destruction of static/global objects is undefined.
   32|       | * Consider if the logger gets destroyed, and then some later destructor calls
   33|       | * LogInfo, maybe indirectly, and you get a core dump at shutdown trying to
   34|       | * access the logger. When the shutdown sequence is fully audited and tested,
   35|       | * explicit destruction of these objects can be implemented by changing this
   36|       | * from a raw pointer to a std::unique_ptr.
   37|       | * Since the ~Logger() destructor is never called, the Logger class and all
   38|       | * its subclasses must have implicitly-defined destructors.
   39|       | *
   40|       | * This method of initialization was originally introduced in
   41|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   42|       | */
   43|  4.76k|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   44|  4.76k|    return *g_logger;
   45|  4.76k|}
_ZN5BCLog6Logger8LogPrintEN4util3log5EntryE:
  435|  4.76k|{
  436|  4.76k|    STDLOCK(m_cs);
  ------------------
  |  |   41|  4.76k|#define STDLOCK(cs) StdMutex::Guard BITCOIN_UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
  |  |  ------------------
  |  |  |  |   11|  4.76k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  4.76k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  4.76k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  437|  4.76k|    return LogPrint_(std::move(entry));
  438|  4.76k|}
_ZN5BCLog6Logger9LogPrint_EN4util3log5EntryE:
  442|  4.76k|{
  443|  4.76k|    if (m_buffering) {
  ------------------
  |  Branch (443:9): [True: 4.76k, False: 0]
  ------------------
  444|  4.76k|        {
  445|  4.76k|            m_cur_buffer_memusage += MemUsage(entry);
  446|  4.76k|            m_msgs_before_open.push_back(std::move(entry));
  447|  4.76k|        }
  448|       |
  449|  6.06k|        while (m_cur_buffer_memusage > m_max_buffer_memusage) {
  ------------------
  |  Branch (449:16): [True: 1.29k, False: 4.76k]
  ------------------
  450|  1.29k|            if (m_msgs_before_open.empty()) {
  ------------------
  |  Branch (450:17): [True: 0, False: 1.29k]
  ------------------
  451|      0|                m_cur_buffer_memusage = 0;
  452|      0|                break;
  453|      0|            }
  454|  1.29k|            m_cur_buffer_memusage -= MemUsage(m_msgs_before_open.front());
  455|  1.29k|            m_msgs_before_open.pop_front();
  456|  1.29k|            ++m_buffer_lines_discarded;
  457|  1.29k|        }
  458|       |
  459|  4.76k|        return;
  460|  4.76k|    }
  461|       |
  462|      0|    std::string str_prefixed{Format(entry)};
  463|      0|    bool ratelimit{false};
  464|      0|    if (entry.should_ratelimit && m_limiter) {
  ------------------
  |  Branch (464:9): [True: 0, False: 0]
  |  Branch (464:35): [True: 0, False: 0]
  ------------------
  465|      0|        auto status{m_limiter->Consume(entry.source_loc, str_prefixed)};
  466|      0|        if (status == LogRateLimiter::Status::NEWLY_SUPPRESSED) {
  ------------------
  |  Branch (466:13): [True: 0, False: 0]
  ------------------
  467|       |            // NOLINTNEXTLINE(misc-no-recursion)
  468|      0|            LogPrint_({
  469|      0|                .category = LogFlags::ALL,
  470|      0|                .level = Level::Warning,
  471|      0|                .should_ratelimit = false, // with should_ratelimit=false, this cannot lead to infinite recursion
  472|      0|                .source_loc = SourceLocation{__func__},
  473|      0|                .message = strprintf(
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  474|      0|                    "Excessive logging detected from %s:%d (%s): >%d bytes logged during "
  475|      0|                    "the last time window of %is. Suppressing logging to disk from this "
  476|      0|                    "source location until time window resets. Console logging "
  477|      0|                    "unaffected. Last log entry.",
  478|      0|                    entry.source_loc.file_name(), entry.source_loc.line(), entry.source_loc.function_name_short(),
  479|      0|                    m_limiter->m_max_bytes,
  480|      0|                    Ticks<std::chrono::seconds>(m_limiter->m_reset_window)),
  481|      0|            });
  482|      0|        } else if (status == LogRateLimiter::Status::STILL_SUPPRESSED) {
  ------------------
  |  Branch (482:20): [True: 0, False: 0]
  ------------------
  483|      0|            ratelimit = true;
  484|      0|        }
  485|      0|    }
  486|       |
  487|       |    // To avoid confusion caused by dropped log messages when debugging an issue,
  488|       |    // we prefix log lines with "[*]" when there are any suppressed source locations.
  489|      0|    if (m_limiter && m_limiter->SuppressionsActive()) {
  ------------------
  |  Branch (489:9): [True: 0, False: 0]
  |  Branch (489:22): [True: 0, False: 0]
  ------------------
  490|      0|        str_prefixed.insert(0, "[*] ");
  491|      0|    }
  492|       |
  493|      0|    if (m_print_to_console) {
  ------------------
  |  Branch (493:9): [True: 0, False: 0]
  ------------------
  494|       |        // print to console
  495|      0|        fwrite(str_prefixed.data(), 1, str_prefixed.size(), stdout);
  496|      0|        fflush(stdout);
  497|      0|    }
  498|      0|    for (const auto& cb : m_print_callbacks) {
  ------------------
  |  Branch (498:25): [True: 0, False: 0]
  ------------------
  499|      0|        cb(str_prefixed);
  500|      0|    }
  501|      0|    if (m_print_to_file && !ratelimit) {
  ------------------
  |  Branch (501:9): [True: 0, False: 0]
  |  Branch (501:28): [True: 0, False: 0]
  ------------------
  502|      0|        assert(m_fileout != nullptr);
  ------------------
  |  Branch (502:9): [True: 0, False: 0]
  ------------------
  503|       |
  504|       |        // reopen the log file, if requested
  505|      0|        if (m_reopen_file) {
  ------------------
  |  Branch (505:13): [True: 0, False: 0]
  ------------------
  506|      0|            m_reopen_file = false;
  507|      0|            FILE* new_fileout = fsbridge::fopen(m_file_path, "a");
  508|      0|            if (new_fileout) {
  ------------------
  |  Branch (508:17): [True: 0, False: 0]
  ------------------
  509|      0|                setbuf(new_fileout, nullptr); // unbuffered
  510|      0|                fclose(m_fileout);
  511|      0|                m_fileout = new_fileout;
  512|      0|            }
  513|      0|        }
  514|      0|        FileWriteStr(str_prefixed, m_fileout);
  515|      0|    }
  516|      0|}
_ZN4util3log3LogENS0_5EntryE:
  630|  4.76k|{
  631|  4.76k|    BCLog::Logger& logger{LogInstance()};
  632|  4.76k|    if (logger.Enabled()) {
  ------------------
  |  Branch (632:9): [True: 4.76k, False: 0]
  ------------------
  633|  4.76k|        logger.LogPrint(std::move(entry));
  634|  4.76k|    }
  635|  4.76k|}
logging.cpp:_ZL8MemUsageRKN4util3log5EntryE:
  378|  6.06k|{
  379|  6.06k|    return memusage::DynamicUsage(log.message) +
  380|  6.06k|           memusage::DynamicUsage(log.thread_name) +
  381|  6.06k|           memusage::MallocUsage(sizeof(memusage::list_node<util::log::Entry>));
  382|  6.06k|}

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

transaction.cpp:_ZN8memusageL12DynamicUsageI5CTxInNSt3__19allocatorIS1_EEEEmRKNS2_6vectorIT_T0_EE:
   90|  4.07k|{
   91|  4.07k|    return MallocUsage(v.capacity() * sizeof(T));
   92|  4.07k|}
transaction.cpp:_ZN8memusageL11MallocUsageEm:
   53|  6.38M|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  6.38M|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 6.27M, False: 115k]
  ------------------
   56|  6.27M|        return 0;
   57|  6.27M|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [True: 115k, Folded]
  ------------------
   58|   115k|        return ((alloc + 31) >> 4) << 4;
   59|   115k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded, False: 0]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|       |        assert(0);
  ------------------
  |  Branch (62:9): [Folded, False: 0]
  ------------------
   63|      0|    }
   64|  6.38M|}
transaction.cpp:_ZN8memusageL12DynamicUsageI6CTxOutNSt3__19allocatorIS1_EEEEmRKNS2_6vectorIT_T0_EE:
   90|  4.07k|{
   91|  4.07k|    return MallocUsage(v.capacity() * sizeof(T));
   92|  4.07k|}
transaction.cpp:_ZN8memusageL12DynamicUsageILj36EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|   718k|{
  109|   718k|    return MallocUsage(v.allocated_memory());
  110|   718k|}
transaction.cpp:_ZN8memusageL12DynamicUsageINSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEEmRKNS2_IT_T0_EE:
   90|  93.2k|{
   91|  93.2k|    return MallocUsage(v.capacity() * sizeof(T));
   92|  93.2k|}
transaction.cpp:_ZN8memusageL12DynamicUsageIhNSt3__19allocatorIhEEEEmRKNS1_6vectorIT_T0_EE:
   90|  5.56M|{
   91|  5.56M|    return MallocUsage(v.capacity() * sizeof(T));
   92|  5.56M|}
logging.cpp:_ZN8memusageL12DynamicUsageERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   95|  12.1k|{
   96|  12.1k|    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|  12.1k|    if (!std::less{}(s.data(), s_ptr) && !std::greater{}(s.data() + s.size(), s_ptr + sizeof(s))) {
  ------------------
  |  Branch (100:9): [True: 6.82k, False: 5.29k]
  |  Branch (100:9): [True: 6.06k, False: 6.06k]
  |  Branch (100:42): [True: 6.06k, False: 766]
  ------------------
  101|  6.06k|        return 0;
  102|  6.06k|    }
  103|  6.06k|    return MallocUsage(s.capacity());
  104|  12.1k|}
logging.cpp:_ZN8memusageL11MallocUsageEm:
   53|  12.1k|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  12.1k|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 0, False: 12.1k]
  ------------------
   56|      0|        return 0;
   57|  12.1k|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [True: 12.1k, Folded]
  ------------------
   58|  12.1k|        return ((alloc + 31) >> 4) << 4;
   59|  12.1k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded, False: 0]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|       |        assert(0);
  ------------------
  |  Branch (62:9): [Folded, False: 0]
  ------------------
   63|      0|    }
   64|  12.1k|}

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

_ZNK8CFeeRate6GetFeeEi:
   21|  2.09k|{
   22|  2.09k|    Assume(virtual_bytes >= 0);
  ------------------
  |  |  128|  2.09k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
   23|  2.09k|    if (m_feerate.IsEmpty()) { return CAmount(0);}
  ------------------
  |  Branch (23:9): [True: 0, False: 2.09k]
  ------------------
   24|  2.09k|    CAmount nFee = CAmount(m_feerate.EvaluateFeeUp(virtual_bytes));
   25|  2.09k|    if (nFee == 0 && virtual_bytes != 0 && m_feerate.fee < 0) return CAmount(-1);
  ------------------
  |  Branch (25:9): [True: 0, False: 2.09k]
  |  Branch (25:22): [True: 0, False: 0]
  |  Branch (25:44): [True: 0, False: 0]
  ------------------
   26|  2.09k|    return nFee;
   27|  2.09k|}

_ZN8CFeeRateC2ITkNSt3__18integralEjEET_:
   41|  4.07k|    explicit constexpr CFeeRate(const I m_feerate_kvb) : m_feerate(FeePerVSize(m_feerate_kvb, 1000)) {}

_Z16GetDustThresholdRK6CTxOutRK8CFeeRate:
   28|  2.09k|{
   29|       |    // "Dust" is defined in terms of dustRelayFee,
   30|       |    // which has units satoshis-per-kilobyte.
   31|       |    // If you'd pay more in fees than the value of the output
   32|       |    // to spend something, then we consider it dust.
   33|       |    // A typical spendable non-segwit txout is 34 bytes big, and will
   34|       |    // need a CTxIn of at least 148 bytes to spend:
   35|       |    // so dust is a spendable txout less than
   36|       |    // 182*dustRelayFee/1000 (in satoshis).
   37|       |    // 546 satoshis at the default rate of 3000 sat/kvB.
   38|       |    // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
   39|       |    // need a CTxIn of at least 67 bytes to spend:
   40|       |    // so dust is a spendable txout less than
   41|       |    // 98*dustRelayFee/1000 (in satoshis).
   42|       |    // 294 satoshis at the default rate of 3000 sat/kvB.
   43|  2.09k|    if (txout.scriptPubKey.IsUnspendable())
  ------------------
  |  Branch (43:9): [True: 0, False: 2.09k]
  ------------------
   44|      0|        return 0;
   45|       |
   46|  2.09k|    uint64_t nSize{GetSerializeSize(txout)};
   47|  2.09k|    int witnessversion = 0;
   48|  2.09k|    std::vector<unsigned char> witnessprogram;
   49|       |
   50|       |    // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
   51|       |    // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
   52|       |    // satisfaction is lower (a single BIP340 signature) but this computation was
   53|       |    // kept to not further reduce the dust level.
   54|       |    // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
   55|  2.09k|    if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (55:9): [True: 1.38k, False: 711]
  ------------------
   56|       |        // sum the sizes of the parts of a transaction input
   57|       |        // with 75% segwit discount applied to the script size.
   58|  1.38k|        nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
   59|  1.38k|    } else {
   60|    711|        nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
   61|    711|    }
   62|       |
   63|  2.09k|    return dustRelayFeeIn.GetFee(nSize);
   64|  2.09k|}
_Z6IsDustRK6CTxOutRK8CFeeRate:
   67|  2.09k|{
   68|  2.09k|    return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
   69|  2.09k|}
_Z7GetDustRK12CTransaction8CFeeRate:
   72|  1.08k|{
   73|  1.08k|    std::vector<uint32_t> dust_outputs;
   74|  3.17k|    for (uint32_t i{0}; i < tx.vout.size(); ++i) {
  ------------------
  |  Branch (74:25): [True: 2.09k, False: 1.08k]
  ------------------
   75|  2.09k|        if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
  ------------------
  |  Branch (75:13): [True: 378, False: 1.71k]
  ------------------
   76|  2.09k|    }
   77|  1.08k|    return dust_outputs;
   78|  1.08k|}
_Z10IsStandardRK7CScriptR9TxoutType:
   81|  14.2k|{
   82|  14.2k|    std::vector<std::vector<unsigned char> > vSolutions;
   83|  14.2k|    whichType = Solver(scriptPubKey, vSolutions);
   84|       |
   85|  14.2k|    if (whichType == TxoutType::NONSTANDARD) {
  ------------------
  |  Branch (85:9): [True: 1.42k, False: 12.7k]
  ------------------
   86|  1.42k|        return false;
   87|  12.7k|    } else if (whichType == TxoutType::MULTISIG) {
  ------------------
  |  Branch (87:16): [True: 721, False: 12.0k]
  ------------------
   88|    721|        unsigned char m = vSolutions.front()[0];
   89|    721|        unsigned char n = vSolutions.back()[0];
   90|       |        // Support up to x-of-3 multisig txns as standard
   91|    721|        if (n < 1 || n > 3)
  ------------------
  |  Branch (91:13): [True: 0, False: 721]
  |  Branch (91:22): [True: 15, False: 706]
  ------------------
   92|     15|            return false;
   93|    706|        if (m < 1 || m > n)
  ------------------
  |  Branch (93:13): [True: 0, False: 706]
  |  Branch (93:22): [True: 0, False: 706]
  ------------------
   94|      0|            return false;
   95|    706|    }
   96|       |
   97|  12.7k|    return true;
   98|  14.2k|}
_Z12IsStandardTxRK12CTransactionRKNSt3__18optionalIjEEbRK8CFeeRateRNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  101|  8.15k|{
  102|  8.15k|    if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < TX_MIN_STANDARD_VERSION) {
  ------------------
  |  Branch (102:9): [True: 3.74k, False: 4.40k]
  |  Branch (102:49): [True: 100, False: 4.30k]
  ------------------
  103|  3.84k|        reason = "version";
  104|  3.84k|        return false;
  105|  3.84k|    }
  106|       |
  107|       |    // Extremely large transactions with lots of inputs can cost the network
  108|       |    // almost as much to process as they cost the sender in fees, because
  109|       |    // computing signature hashes is O(ninputs*txsize). Limiting transactions
  110|       |    // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
  111|  4.30k|    unsigned int sz = GetTransactionWeight(tx);
  112|  4.30k|    if (sz > MAX_STANDARD_TX_WEIGHT) {
  ------------------
  |  Branch (112:9): [True: 44, False: 4.26k]
  ------------------
  113|     44|        reason = "tx-size";
  114|     44|        return false;
  115|     44|    }
  116|       |
  117|  4.26k|    for (const CTxIn& txin : tx.vin)
  ------------------
  |  Branch (117:28): [True: 18.1k, False: 2.80k]
  ------------------
  118|  18.1k|    {
  119|       |        // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
  120|       |        // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
  121|       |        // redeemScript size). That works out to a (15*(33+1))+3=513 byte
  122|       |        // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
  123|       |        // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
  124|       |        // some minor future-proofing. That's also enough to spend a
  125|       |        // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
  126|       |        // is not considered standard.
  127|  18.1k|        if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
  ------------------
  |  Branch (127:13): [True: 70, False: 18.1k]
  ------------------
  128|     70|            reason = "scriptsig-size";
  129|     70|            return false;
  130|     70|        }
  131|  18.1k|        if (!txin.scriptSig.IsPushOnly()) {
  ------------------
  |  Branch (131:13): [True: 1.39k, False: 16.7k]
  ------------------
  132|  1.39k|            reason = "scriptsig-not-pushonly";
  133|  1.39k|            return false;
  134|  1.39k|        }
  135|  18.1k|    }
  136|       |
  137|  2.80k|    unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
  138|  2.80k|    TxoutType whichType;
  139|  14.2k|    for (const CTxOut& txout : tx.vout) {
  ------------------
  |  Branch (139:30): [True: 14.2k, False: 1.08k]
  ------------------
  140|  14.2k|        if (!::IsStandard(txout.scriptPubKey, whichType)) {
  ------------------
  |  Branch (140:13): [True: 1.43k, False: 12.7k]
  ------------------
  141|  1.43k|            reason = "scriptpubkey";
  142|  1.43k|            return false;
  143|  1.43k|        }
  144|       |
  145|  12.7k|        if (whichType == TxoutType::NULL_DATA) {
  ------------------
  |  Branch (145:13): [True: 56, False: 12.7k]
  ------------------
  146|     56|            unsigned int size = txout.scriptPubKey.size();
  147|     56|            if (size > datacarrier_bytes_left) {
  ------------------
  |  Branch (147:17): [True: 56, False: 0]
  ------------------
  148|     56|                reason = "datacarrier";
  149|     56|                return false;
  150|     56|            }
  151|      0|            datacarrier_bytes_left -= size;
  152|  12.7k|        } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
  ------------------
  |  Branch (152:20): [True: 706, False: 12.0k]
  |  Branch (152:58): [True: 229, False: 477]
  ------------------
  153|    229|            reason = "bare-multisig";
  154|    229|            return false;
  155|    229|        }
  156|  12.7k|    }
  157|       |
  158|       |    // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
  159|  1.08k|    if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
  ------------------
  |  Branch (159:9): [True: 58, False: 1.02k]
  ------------------
  160|     58|        reason = "dust";
  161|     58|        return false;
  162|     58|    }
  163|       |
  164|  1.02k|    return true;
  165|  1.08k|}
_Z26ValidateInputsStandardnessRK12CTransactionRK15CCoinsViewCache:
  215|  4.07k|{
  216|  4.07k|    TxValidationState state;
  217|  4.07k|    if (tx.IsCoinBase()) {
  ------------------
  |  Branch (217:9): [True: 56, False: 4.01k]
  ------------------
  218|     56|        return state; // Coinbases don't use vin normally
  219|     56|    }
  220|       |
  221|  4.01k|    if (!CheckSigopsBIP54(tx, mapInputs)) {
  ------------------
  |  Branch (221:9): [True: 23, False: 3.99k]
  ------------------
  222|     23|        state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", "non-witness sigops exceed bip54 limit");
  223|     23|        return state;
  224|     23|    }
  225|       |
  226|  3.99k|    for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (226:30): [True: 3.90k, False: 95]
  ------------------
  227|  3.90k|        const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  228|       |
  229|  3.90k|        std::vector<std::vector<unsigned char> > vSolutions;
  230|  3.90k|        TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
  231|  3.90k|        if (whichType == TxoutType::NONSTANDARD) {
  ------------------
  |  Branch (231:13): [True: 3.90k, False: 0]
  ------------------
  232|  3.90k|            state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u script unknown", i));
  ------------------
  |  | 1172|  3.90k|#define strprintf tfm::format
  ------------------
  233|  3.90k|            return state;
  234|  3.90k|        } else if (whichType == TxoutType::WITNESS_UNKNOWN) {
  ------------------
  |  Branch (234:20): [True: 0, False: 0]
  ------------------
  235|       |            // WITNESS_UNKNOWN failures are typically also caught with a policy
  236|       |            // flag in the script interpreter, but it can be helpful to catch
  237|       |            // this type of NONSTANDARD transaction earlier in transaction
  238|       |            // validation.
  239|      0|            state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u witness program is undefined", i));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  240|      0|            return state;
  241|      0|        } else if (whichType == TxoutType::SCRIPTHASH) {
  ------------------
  |  Branch (241:20): [True: 0, False: 0]
  ------------------
  242|      0|            std::vector<std::vector<unsigned char> > stack;
  243|      0|            ScriptError serror;
  244|       |            // convert the scriptSig into a stack, so we can inspect the redeemScript
  245|      0|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE, &serror)) {
  ------------------
  |  Branch (245:17): [True: 0, False: 0]
  ------------------
  246|      0|                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh scriptsig malformed (input %u: %s)", i, ScriptErrorString(serror)));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  247|      0|                return state;
  248|      0|            }
  249|      0|            if (stack.empty()) {
  ------------------
  |  Branch (249:17): [True: 0, False: 0]
  ------------------
  250|      0|                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u P2SH redeemscript missing", i));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  251|      0|                return state;
  252|      0|            }
  253|      0|            CScript subscript(stack.back().begin(), stack.back().end());
  254|      0|            unsigned int sigop_count = subscript.GetSigOpCount(true);
  255|      0|            if (sigop_count > MAX_P2SH_SIGOPS) {
  ------------------
  |  Branch (255:17): [True: 0, False: 0]
  ------------------
  256|      0|                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh redeemscript sigops exceed limit (input %u: %u > %u)", i, sigop_count, MAX_P2SH_SIGOPS));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  257|      0|                return state;
  258|      0|            }
  259|      0|        }
  260|  3.90k|    }
  261|       |
  262|     95|    return state;
  263|  3.99k|}
_Z17IsWitnessStandardRK12CTransactionRK15CCoinsViewCache:
  266|  4.07k|{
  267|  4.07k|    if (tx.IsCoinBase())
  ------------------
  |  Branch (267:9): [True: 56, False: 4.01k]
  ------------------
  268|     56|        return true; // Coinbases are skipped
  269|       |
  270|  66.0k|    for (unsigned int i = 0; i < tx.vin.size(); i++)
  ------------------
  |  Branch (270:30): [True: 62.5k, False: 3.53k]
  ------------------
  271|  62.5k|    {
  272|       |        // We don't care if witness for this input is empty, since it must not be bloated.
  273|       |        // If the script is invalid without witness, it would be caught sooner or later during validation.
  274|  62.5k|        if (tx.vin[i].scriptWitness.IsNull())
  ------------------
  |  Branch (274:13): [True: 62.0k, False: 482]
  ------------------
  275|  62.0k|            continue;
  276|       |
  277|    482|        const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  278|       |
  279|       |        // get the scriptPubKey corresponding to this input:
  280|    482|        CScript prevScript = prev.scriptPubKey;
  281|       |
  282|       |        // witness stuffing detected
  283|    482|        if (prevScript.IsPayToAnchor()) {
  ------------------
  |  Branch (283:13): [True: 0, False: 482]
  ------------------
  284|      0|            return false;
  285|      0|        }
  286|       |
  287|    482|        bool p2sh = false;
  288|    482|        if (prevScript.IsPayToScriptHash()) {
  ------------------
  |  Branch (288:13): [True: 0, False: 482]
  ------------------
  289|      0|            std::vector <std::vector<unsigned char> > stack;
  290|       |            // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
  291|       |            // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
  292|       |            // If the check fails at this stage, we know that this txid must be a bad one.
  293|      0|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
  ------------------
  |  Branch (293:17): [True: 0, False: 0]
  ------------------
  294|      0|                return false;
  295|      0|            if (stack.empty())
  ------------------
  |  Branch (295:17): [True: 0, False: 0]
  ------------------
  296|      0|                return false;
  297|      0|            prevScript = CScript(stack.back().begin(), stack.back().end());
  298|      0|            p2sh = true;
  299|      0|        }
  300|       |
  301|    482|        int witnessversion = 0;
  302|    482|        std::vector<unsigned char> witnessprogram;
  303|       |
  304|       |        // Non-witness program must not be associated with any witness
  305|    482|        if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
  ------------------
  |  Branch (305:13): [True: 482, False: 0]
  ------------------
  306|    482|            return false;
  307|       |
  308|       |        // Check P2WSH standard limits
  309|      0|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (309:13): [True: 0, False: 0]
  |  Branch (309:36): [True: 0, False: 0]
  ------------------
  310|      0|            if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
  ------------------
  |  Branch (310:17): [True: 0, False: 0]
  ------------------
  311|      0|                return false;
  312|      0|            size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
  313|      0|            if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
  ------------------
  |  Branch (313:17): [True: 0, False: 0]
  ------------------
  314|      0|                return false;
  315|      0|            for (unsigned int j = 0; j < sizeWitnessStack; j++) {
  ------------------
  |  Branch (315:38): [True: 0, False: 0]
  ------------------
  316|      0|                if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
  ------------------
  |  Branch (316:21): [True: 0, False: 0]
  ------------------
  317|      0|                    return false;
  318|      0|            }
  319|      0|        }
  320|       |
  321|       |        // Check policy limits for Taproot spends:
  322|       |        // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
  323|       |        // - No annexes
  324|      0|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
  ------------------
  |  Branch (324:13): [True: 0, False: 0]
  |  Branch (324:36): [True: 0, False: 0]
  |  Branch (324:88): [True: 0, False: 0]
  ------------------
  325|       |            // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
  326|      0|            std::span stack{tx.vin[i].scriptWitness.stack};
  327|      0|            if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
  ------------------
  |  Branch (327:17): [True: 0, False: 0]
  |  Branch (327:38): [True: 0, False: 0]
  |  Branch (327:63): [True: 0, False: 0]
  ------------------
  328|       |                // Annexes are nonstandard as long as no semantics are defined for them.
  329|      0|                return false;
  330|      0|            }
  331|      0|            if (stack.size() >= 2) {
  ------------------
  |  Branch (331:17): [True: 0, False: 0]
  ------------------
  332|       |                // Script path spend (2 or more stack elements after removing optional annex)
  333|      0|                const auto& control_block = SpanPopBack(stack);
  334|      0|                SpanPopBack(stack); // Ignore script
  335|      0|                if (control_block.empty()) return false; // Empty control block is invalid
  ------------------
  |  Branch (335:21): [True: 0, False: 0]
  ------------------
  336|      0|                if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
  ------------------
  |  Branch (336:21): [True: 0, False: 0]
  ------------------
  337|       |                    // Leaf version 0xc0 (aka Tapscript, see BIP 342)
  338|      0|                    for (const auto& item : stack) {
  ------------------
  |  Branch (338:43): [True: 0, False: 0]
  ------------------
  339|      0|                        if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
  ------------------
  |  Branch (339:29): [True: 0, False: 0]
  ------------------
  340|      0|                    }
  341|      0|                }
  342|      0|            } else if (stack.size() == 1) {
  ------------------
  |  Branch (342:24): [True: 0, False: 0]
  ------------------
  343|       |                // Key path spend (1 stack element after removing optional annex)
  344|       |                // (no policy rules apply)
  345|      0|            } else {
  346|       |                // 0 stack elements; this is already invalid by consensus rules
  347|      0|                return false;
  348|      0|            }
  349|      0|        }
  350|      0|    }
  351|  3.53k|    return true;
  352|  4.01k|}
_Z23GetSigOpsAdjustedWeightllj:
  391|  4.07k|{
  392|  4.07k|    return std::max(weight, sigop_cost * bytes_per_sigop);
  393|  4.07k|}
_Z25GetVirtualTransactionSizellj:
  396|  4.07k|{
  397|  4.07k|    return (GetSigOpsAdjustedWeight(nWeight, nSigOpCost, bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
  398|  4.07k|}
_Z25GetVirtualTransactionSizeRK12CTransactionlj:
  401|  4.07k|{
  402|  4.07k|    return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
  403|  4.07k|}
policy.cpp:_ZL16CheckSigopsBIP54RK12CTransactionRK15CCoinsViewCache:
  171|  4.01k|{
  172|  4.01k|    Assert(!tx.IsCoinBase());
  ------------------
  |  |  116|  4.01k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
  173|       |
  174|  4.01k|    unsigned int sigops{0};
  175|  91.5k|    for (const auto& txin: tx.vin) {
  ------------------
  |  Branch (175:26): [True: 91.5k, False: 3.99k]
  ------------------
  176|  91.5k|        const auto& prev_txo{inputs.AccessCoin(txin.prevout).out};
  177|       |
  178|       |        // Unlike the existing block wide sigop limit which counts sigops present in the block
  179|       |        // itself (including the scriptPubKey which is not executed until spending later), BIP54
  180|       |        // counts sigops in the block where they are potentially executed (only).
  181|       |        // This means sigops in the spent scriptPubKey count toward the limit.
  182|       |        // `fAccurate` means correctly accounting sigops for CHECKMULTISIGs(VERIFY) with 16 pubkeys
  183|       |        // or fewer. This method of accounting was introduced by BIP16, and BIP54 reuses it.
  184|       |        // The GetSigOpCount call on the previous scriptPubKey counts both bare and P2SH sigops.
  185|  91.5k|        sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
  186|  91.5k|        sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
  187|       |
  188|  91.5k|        if (sigops > MAX_TX_LEGACY_SIGOPS) {
  ------------------
  |  Branch (188:13): [True: 23, False: 91.5k]
  ------------------
  189|     23|            return false;
  190|     23|        }
  191|  91.5k|    }
  192|       |
  193|  3.99k|    return true;
  194|  4.01k|}

transaction.cpp:_ZL25GetVirtualTransactionSizeRK12CTransaction:
  186|  4.07k|{
  187|  4.07k|    return GetVirtualTransactionSize(tx, 0, 0);
  188|  4.07k|}

_ZNK9prevectorILj36EhjiE4backEv:
  412|  1.06M|    const T& back() const {
  413|  1.06M|        return *item_ptr(size() - 1);
  414|  1.06M|    }
_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|    }
_ZN9prevectorILj36EhjiEC2EOS0_:
  224|  1.21M|        : _union(std::move(other._union)), _size(other._size)
  225|  1.21M|    {
  226|  1.21M|        other._size = 0;
  227|  1.21M|    }
_ZN9prevectorILj36EhjiE20resize_uninitializedEj:
  349|   412k|    inline void resize_uninitialized(size_type new_size) {
  350|       |        // resize_uninitialized changes the size of the prevector but does not initialize it.
  351|       |        // If size < new_size, the added elements must be initialized explicitly.
  352|   412k|        if (capacity() < new_size) {
  ------------------
  |  Branch (352:13): [True: 75.3k, False: 337k]
  ------------------
  353|  75.3k|            change_capacity(new_size);
  354|  75.3k|            _size += new_size - size();
  355|  75.3k|            return;
  356|  75.3k|        }
  357|   337k|        if (new_size < size()) {
  ------------------
  |  Branch (357:13): [True: 0, False: 337k]
  ------------------
  358|      0|            erase(item_ptr(new_size), end());
  359|   337k|        } else {
  360|   337k|            _size += new_size - size();
  361|   337k|        }
  362|   337k|    }
_ZNK9prevectorILj36EhjiE16allocated_memoryEv:
  456|   718k|    size_t allocated_memory() const {
  457|   718k|        if (is_direct()) {
  ------------------
  |  Branch (457:13): [True: 681k, False: 36.3k]
  ------------------
  458|   681k|            return 0;
  459|   681k|        } else {
  460|  36.3k|            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
  461|  36.3k|        }
  462|   718k|    }
_ZN9prevectorILj36EhjiEaSEOS0_:
  237|   755k|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  238|   755k|        if (!is_direct()) {
  ------------------
  |  Branch (238:13): [True: 0, False: 755k]
  ------------------
  239|      0|            free(_union.indirect_contents.indirect);
  240|      0|        }
  241|   755k|        _union = std::move(other._union);
  242|   755k|        _size = other._size;
  243|   755k|        other._size = 0;
  244|   755k|        return *this;
  245|   755k|    }
_ZNK9prevectorILj36EhjiE5emptyEv:
  251|  11.4M|    bool empty() const {
  252|  11.4M|        return size() == 0;
  253|  11.4M|    }
_ZNK9prevectorILj36EhjiE4dataEv:
  468|  6.53M|    const value_type* data() const {
  469|  6.53M|        return item_ptr(0);
  470|  6.53M|    }
_ZN9prevectorILj36EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  167|  1.19M|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  43.2M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 42.0M, False: 1.19M]
  ------------------
  169|  42.0M|            new(static_cast<void*>(dst)) T(*first);
  170|  42.0M|            ++dst;
  171|  42.0M|            ++first;
  172|  42.0M|        }
  173|  1.19M|    }
_ZNK9prevectorILj36EhjiE14const_iteratoreqES1_:
  102|  43.3M|        bool operator==(const_iterator x) const { return ptr == x.ptr; }
_ZN9prevectorILj36EhjiE14const_iteratorppEv:
   92|  58.8M|        const_iterator& operator++() { ptr++; return *this; }
_ZNK9prevectorILj36EhjiEixEj:
  272|  2.62M|    const T& operator[](size_type pos) const {
  273|  2.62M|        return *item_ptr(pos);
  274|  2.62M|    }
_ZN9prevectorILj36EhjiE8item_ptrEi:
  159|  2.30M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (159:47): [True: 2.09M, False: 214k]
  ------------------
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|   155M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiE10direct_ptrEi:
  122|  2.30M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj36EhjiE12indirect_ptrEi:
  124|   214k|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj36EhjiE15change_capacityEj:
  128|  3.61M|    void change_capacity(size_type new_capacity) {
  129|  3.61M|        if (new_capacity <= N) {
  ------------------
  |  Branch (129:13): [True: 3.40M, False: 214k]
  ------------------
  130|  3.40M|            if (!is_direct()) {
  ------------------
  |  Branch (130:17): [True: 0, False: 3.40M]
  ------------------
  131|      0|                T* indirect = indirect_ptr(0);
  132|      0|                T* src = indirect;
  133|      0|                T* dst = direct_ptr(0);
  134|      0|                memcpy(dst, src, size() * sizeof(T));
  135|      0|                free(indirect);
  136|      0|                _size -= N + 1;
  137|      0|            }
  138|  3.40M|        } else {
  139|   214k|            if (!is_direct()) {
  ------------------
  |  Branch (139:17): [True: 0, False: 214k]
  ------------------
  140|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  141|       |                    success. These should instead use an allocator or new/delete so that handlers
  142|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  143|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  144|      0|                assert(_union.indirect_contents.indirect);
  ------------------
  |  Branch (144:17): [True: 0, False: 0]
  ------------------
  145|      0|                _union.indirect_contents.capacity = new_capacity;
  146|   214k|            } else {
  147|   214k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  148|   214k|                assert(new_indirect);
  ------------------
  |  Branch (148:17): [True: 214k, False: 0]
  ------------------
  149|   214k|                T* src = direct_ptr(0);
  150|   214k|                T* dst = reinterpret_cast<T*>(new_indirect);
  151|   214k|                memcpy(dst, src, size() * sizeof(T));
  152|   214k|                _union.indirect_contents.indirect = new_indirect;
  153|   214k|                _union.indirect_contents.capacity = new_capacity;
  154|   214k|                _size += N + 1;
  155|   214k|            }
  156|   214k|        }
  157|  3.61M|    }
_ZNK9prevectorILj36EhjiE3endEv:
  258|  35.9M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj36EhjiE8item_ptrEi:
  160|  51.0M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (160:59): [True: 17.1M, False: 33.9M]
  ------------------
_ZNK9prevectorILj36EhjiE10direct_ptrEi:
  123|  17.1M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj36EhjiE12indirect_ptrEi:
  125|  33.9M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj36EhjiE4sizeEv:
  247|  89.4M|    size_type size() const {
  248|  89.4M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (248:16): [True: 52.7M, False: 36.7M]
  ------------------
  249|  89.4M|    }
_ZNK9prevectorILj36EhjiE5beginEv:
  256|  4.86M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj36EhjiE14const_iteratordeEv:
   89|   144M|        const T& operator*() const { return *ptr; }
_ZNK9prevectorILj36EhjiEeqERKS0_:
  429|  64.0k|    constexpr bool operator==(const prevector& other) const {
  430|  64.0k|        return std::ranges::equal(*this, other);
  431|  64.0k|    }
_ZNK9prevectorILj36EhjiE14const_iteratorssES1_:
  103|  34.4M|        auto operator<=>(const_iterator x) const { return ptr <=> x.ptr; }
_ZNK9prevectorILj36EhjiE14const_iteratorptEv:
   90|  12.2M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj36EhjiEC2Ev:
  196|  4.06M|    prevector() = default;
_ZN9prevectorILj36EhjiE6insertENS0_8iteratorERKh:
  307|   168k|    iterator insert(iterator pos, const T& value) {
  308|   168k|        size_type p = pos - begin();
  309|   168k|        size_type new_size = size() + 1;
  310|   168k|        if (capacity() < new_size) {
  ------------------
  |  Branch (310:13): [True: 0, False: 168k]
  ------------------
  311|      0|            change_capacity(new_size + (new_size >> 1));
  312|      0|        }
  313|   168k|        T* ptr = item_ptr(p);
  314|   168k|        T* dst = ptr + 1;
  315|   168k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  316|   168k|        _size++;
  317|   168k|        new(static_cast<void*>(ptr)) T(value);
  318|   168k|        return iterator(ptr);
  319|   168k|    }
_ZmiN9prevectorILj36EhjiE8iteratorES1_:
   68|   232k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj36EhjiE8iteratordeEv:
   61|   464k|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj36EhjiE8capacityEv:
  260|   645k|    size_t capacity() const {
  261|   645k|        if (is_direct()) {
  ------------------
  |  Branch (261:13): [True: 645k, False: 0]
  ------------------
  262|   645k|            return N;
  263|   645k|        } else {
  264|      0|            return _union.indirect_contents.capacity;
  265|      0|        }
  266|   645k|    }
_ZN9prevectorILj36EhjiE8iteratorC2EPh:
   60|   633k|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj36EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvNS0_8iteratorET_S8_:
  335|  64.0k|    void insert(iterator pos, InputIterator first, InputIterator last) {
  336|  64.0k|        size_type p = pos - begin();
  337|  64.0k|        difference_type count = last - first;
  338|  64.0k|        size_type new_size = size() + count;
  339|  64.0k|        if (capacity() < new_size) {
  ------------------
  |  Branch (339:13): [True: 242, False: 63.8k]
  ------------------
  340|    242|            change_capacity(new_size + (new_size >> 1));
  341|    242|        }
  342|  64.0k|        T* ptr = item_ptr(p);
  343|  64.0k|        T* dst = ptr + count;
  344|  64.0k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  345|  64.0k|        _size += count;
  346|  64.0k|        fill(ptr, first, last);
  347|  64.0k|    }
_ZN9prevectorILj36EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  167|  64.0k|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  1.39M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 1.32M, False: 64.0k]
  ------------------
  169|  1.32M|            new(static_cast<void*>(dst)) T(*first);
  170|  1.32M|            ++dst;
  171|  1.32M|            ++first;
  172|  1.32M|        }
  173|  64.0k|    }
_ZN9prevectorILj36EhjiEC2ERKS0_:
  216|  1.19M|    prevector(const prevector<N, T, Size, Diff>& other) {
  217|  1.19M|        size_type n = other.size();
  218|  1.19M|        change_capacity(n);
  219|  1.19M|        _size += n;
  220|  1.19M|        fill(item_ptr(0), other.begin(),  other.end());
  221|  1.19M|    }
_ZN9prevectorILj36EhjiE3endEv:
  257|   232k|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj36EhjiE5beginEv:
  255|   232k|    iterator begin() { return iterator(item_ptr(0)); }
_ZN9prevectorILj36EhjiEixEj:
  268|   412k|    T& operator[](size_type pos) {
  269|   412k|        return *item_ptr(pos);
  270|   412k|    }
_ZN9prevectorILj36EhjiE5clearEv:
  303|  5.31M|    void clear() {
  304|  5.31M|        resize(0);
  305|  5.31M|    }
_ZN9prevectorILj36EhjiE6resizeEj:
  276|  5.31M|    void resize(size_type new_size) {
  277|  5.31M|        size_type cur_size = size();
  278|  5.31M|        if (cur_size == new_size) {
  ------------------
  |  Branch (278:13): [True: 5.31M, False: 0]
  ------------------
  279|  5.31M|            return;
  280|  5.31M|        }
  281|      0|        if (cur_size > new_size) {
  ------------------
  |  Branch (281:13): [True: 0, False: 0]
  ------------------
  282|      0|            erase(item_ptr(new_size), end());
  283|      0|            return;
  284|      0|        }
  285|      0|        if (new_size > capacity()) {
  ------------------
  |  Branch (285:13): [True: 0, False: 0]
  ------------------
  286|      0|            change_capacity(new_size);
  287|      0|        }
  288|      0|        ptrdiff_t increase = new_size - cur_size;
  289|      0|        fill(item_ptr(cur_size), increase);
  290|      0|        _size += increase;
  291|      0|    }
_ZN9prevectorILj36EhjiE13shrink_to_fitEv:
  299|  2.34M|    void shrink_to_fit() {
  300|  2.34M|        change_capacity(size());
  301|  2.34M|    }
_ZN9prevectorILj36EhjiED2Ev:
  422|  6.47M|    ~prevector() {
  423|  6.47M|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 214k, False: 6.25M]
  ------------------
  424|   214k|            free(_union.indirect_contents.indirect);
  425|   214k|            _union.indirect_contents.indirect = nullptr;
  426|   214k|        }
  427|  6.47M|    }
_ZN9prevectorILj36EhjiE14const_iteratorC2EPKh:
   87|  47.7M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZNK9prevectorILj36EhjiE14const_iteratorplEj:
   97|  6.95M|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
_ZmiN9prevectorILj36EhjiE14const_iteratorES1_:
   96|  42.9M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj36EhjiE14const_iteratorppEi:
   94|  16.7M|        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }
_ZNK9prevectorILj36EhjiE14const_iteratorixEj:
   91|  21.6k|        const T& operator[](size_type pos) const { return ptr[pos]; }
_ZN9prevectorILj36EhjiE14const_iteratorpLEj:
   99|  11.6M|        const_iterator& operator+=(size_type n) { ptr += n; return *this; }

_ZNK9COutPoint8ToStringEv:
   22|  93.2k|{
   23|  93.2k|    return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10), n);
  ------------------
  |  | 1172|  93.2k|#define strprintf tfm::format
  ------------------
   24|  93.2k|}
_ZNK5CTxIn8ToStringEv:
   41|  93.2k|{
   42|  93.2k|    std::string str;
   43|  93.2k|    str += "CTxIn(";
   44|  93.2k|    str += prevout.ToString();
   45|  93.2k|    if (prevout.IsNull())
  ------------------
  |  Branch (45:9): [True: 177, False: 93.0k]
  ------------------
   46|    177|        str += strprintf(", coinbase %s", HexStr(scriptSig));
  ------------------
  |  | 1172|    177|#define strprintf tfm::format
  ------------------
   47|  93.0k|    else
   48|  93.0k|        str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
  ------------------
  |  | 1172|  93.0k|#define strprintf tfm::format
  ------------------
   49|  93.2k|    if (nSequence != SEQUENCE_FINAL)
  ------------------
  |  Branch (49:9): [True: 91.4k, False: 1.72k]
  ------------------
   50|  91.4k|        str += strprintf(", nSequence=%u", nSequence);
  ------------------
  |  | 1172|  91.4k|#define strprintf tfm::format
  ------------------
   51|  93.2k|    str += ")";
   52|  93.2k|    return str;
   53|  93.2k|}
_ZNK6CTxOut8ToStringEv:
   62|   624k|{
   63|   624k|    return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
  ------------------
  |  | 1172|   624k|#define strprintf tfm::format
  ------------------
   64|   624k|}
_ZN19CMutableTransactionC2Ev:
   66|  5.45k|CMutableTransaction::CMutableTransaction() : version{CTransaction::CURRENT_VERSION}, nLockTime{0} {}
_ZNK12CTransaction17ComputeHasWitnessEv:
   75|  4.76k|{
   76|  4.76k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  4.76k|        return !input.scriptWitness.IsNull();
   78|  4.76k|    });
   79|  4.76k|}
_ZNK12CTransaction11ComputeHashEv:
   82|  4.76k|{
   83|  4.76k|    return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash());
   84|  4.76k|}
_ZNK12CTransaction18ComputeWitnessHashEv:
   87|  4.76k|{
   88|  4.76k|    if (!HasWitness()) {
  ------------------
  |  Branch (88:9): [True: 4.26k, False: 500]
  ------------------
   89|  4.26k|        return Wtxid::FromUint256(hash.ToUint256());
   90|  4.26k|    }
   91|       |
   92|    500|    return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash());
   93|  4.76k|}
_ZN12CTransactionC2EO19CMutableTransaction:
   96|  4.76k|CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
_ZNK12CTransaction11GetValueOutEv:
   99|  4.07k|{
  100|  4.07k|    CAmount nValueOut = 0;
  101|  18.1k|    for (const auto& tx_out : vout) {
  ------------------
  |  Branch (101:29): [True: 18.1k, False: 2.29k]
  ------------------
  102|  18.1k|        if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut + tx_out.nValue))
  ------------------
  |  Branch (102:13): [True: 1.77k, False: 16.3k]
  |  Branch (102:13): [True: 1.78k, False: 16.3k]
  |  Branch (102:43): [True: 5, False: 16.3k]
  ------------------
  103|  1.78k|            throw std::runtime_error(std::string(__func__) + ": value out of range");
  104|  16.3k|        nValueOut += tx_out.nValue;
  105|  16.3k|    }
  106|  4.07k|    assert(MoneyRange(nValueOut));
  ------------------
  |  Branch (106:5): [True: 2.29k, False: 0]
  ------------------
  107|  2.29k|    return nValueOut;
  108|  2.29k|}
_ZNK12CTransaction16ComputeTotalSizeEv:
  111|  16.1k|{
  112|  16.1k|    return ::GetSerializeSize(TX_WITH_WITNESS(*this));
  113|  16.1k|}
_ZNK12CTransaction8ToStringEv:
  116|  4.07k|{
  117|  4.07k|    std::string str;
  118|  4.07k|    str += strprintf("CTransaction(hash=%s, ver=%u, vin.size=%u, vout.size=%u, nLockTime=%u)\n",
  ------------------
  |  | 1172|  4.07k|#define strprintf tfm::format
  ------------------
  119|  4.07k|        GetHash().ToString().substr(0,10),
  120|  4.07k|        version,
  121|  4.07k|        vin.size(),
  122|  4.07k|        vout.size(),
  123|  4.07k|        nLockTime);
  124|  4.07k|    for (const auto& tx_in : vin)
  ------------------
  |  Branch (124:28): [True: 93.2k, False: 4.07k]
  ------------------
  125|  93.2k|        str += "    " + tx_in.ToString() + "\n";
  126|  4.07k|    for (const auto& tx_in : vin)
  ------------------
  |  Branch (126:28): [True: 93.2k, False: 4.07k]
  ------------------
  127|  93.2k|        str += "    " + tx_in.scriptWitness.ToString() + "\n";
  128|  4.07k|    for (const auto& tx_out : vout)
  ------------------
  |  Branch (128:29): [True: 624k, False: 4.07k]
  ------------------
  129|   624k|        str += "    " + tx_out.ToString() + "\n";
  130|  4.07k|    return str;
  131|  4.07k|}
transaction.cpp:_ZZNK12CTransaction17ComputeHasWitnessEvENK3$_0clI5CTxInEEDaRKT_:
   76|  62.5k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  62.5k|        return !input.scriptWitness.IsNull();
   78|  62.5k|    });

_ZN12CTransactionC2I10SpanReaderEE16deserialize_typeRK20TransactionSerParamsRT_:
  320|  4.76k|    CTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) : CTransaction(CMutableTransaction(deserialize, params, s)) {}
_ZN19CMutableTransactionC2I10SpanReaderEE16deserialize_typeRK20TransactionSerParamsRT_:
  378|  4.76k|    CMutableTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) {
  379|  4.76k|        UnserializeTransaction(*this, s, params);
  380|  4.76k|    }
_Z22UnserializeTransactionI10SpanReader19CMutableTransactionEvRT0_RT_RK20TransactionSerParams:
  202|  4.76k|{
  203|  4.76k|    const bool fAllowWitness = params.allow_witness;
  204|       |
  205|  4.76k|    s >> tx.version;
  206|  4.76k|    unsigned char flags = 0;
  207|  4.76k|    tx.vin.clear();
  208|  4.76k|    tx.vout.clear();
  209|       |    /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
  210|  4.76k|    s >> tx.vin;
  211|  4.76k|    if (tx.vin.size() == 0 && fAllowWitness) {
  ------------------
  |  Branch (211:9): [True: 994, False: 3.77k]
  |  Branch (211:31): [True: 994, False: 0]
  ------------------
  212|       |        /* We read a dummy or an empty vin. */
  213|    994|        s >> flags;
  214|    994|        if (flags != 0) {
  ------------------
  |  Branch (214:13): [True: 897, False: 97]
  ------------------
  215|    897|            s >> tx.vin;
  216|    897|            s >> tx.vout;
  217|    897|        }
  218|  3.77k|    } else {
  219|       |        /* We read a non-empty vin. Assume a normal vout follows. */
  220|  3.77k|        s >> tx.vout;
  221|  3.77k|    }
  222|  4.76k|    if ((flags & 1) && fAllowWitness) {
  ------------------
  |  Branch (222:9): [True: 696, False: 4.07k]
  |  Branch (222:24): [True: 696, False: 0]
  ------------------
  223|       |        /* The witness flag is present, and we support witnesses. */
  224|    696|        flags ^= 1;
  225|  41.1k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (225:28): [True: 40.4k, False: 696]
  ------------------
  226|  40.4k|            s >> tx.vin[i].scriptWitness.stack;
  227|  40.4k|        }
  228|    696|        if (!tx.HasWitness()) {
  ------------------
  |  Branch (228:13): [True: 14, False: 682]
  ------------------
  229|       |            /* It's illegal to encode witnesses when all witness stacks are empty. */
  230|     14|            throw std::ios_base::failure("Superfluous witness record");
  231|     14|        }
  232|    696|    }
  233|  4.75k|    if (flags) {
  ------------------
  |  Branch (233:9): [True: 9, False: 4.74k]
  ------------------
  234|       |        /* Unknown flag in the serialization */
  235|      9|        throw std::ios_base::failure("Unknown transaction optional data");
  236|      9|    }
  237|  4.74k|    s >> tx.nLockTime;
  238|  4.74k|}
_ZN5CTxIn16SerializationOpsI10SpanReaderS_17ActionUnserializeEEvRT0_RT_T1_:
  124|   365k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  148|   365k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI10SpanReaderS_17ActionUnserializeEEvRT0_RT_T1_:
   39|   365k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  148|   365k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI10SpanReaderS_17ActionUnserializeEEvRT0_RT_T1_:
  152|  1.12M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|  1.12M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction6IsNullEv:
  324|  4.07k|    bool IsNull() const {
  325|  4.07k|        return vin.empty() && vout.empty();
  ------------------
  |  Branch (325:16): [True: 95, False: 3.98k]
  |  Branch (325:31): [True: 95, False: 0]
  ------------------
  326|  4.07k|    }
_ZN19CMutableTransaction11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  373|  4.76k|    inline void Unserialize(Stream& s) {
  374|  4.76k|        UnserializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  375|  4.76k|    }
_Z22UnserializeTransactionI12ParamsStreamIR10SpanReader20TransactionSerParamsE19CMutableTransactionEvRT0_RT_RKS3_:
  202|  4.76k|{
  203|  4.76k|    const bool fAllowWitness = params.allow_witness;
  204|       |
  205|  4.76k|    s >> tx.version;
  206|  4.76k|    unsigned char flags = 0;
  207|  4.76k|    tx.vin.clear();
  208|  4.76k|    tx.vout.clear();
  209|       |    /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
  210|  4.76k|    s >> tx.vin;
  211|  4.76k|    if (tx.vin.size() == 0 && fAllowWitness) {
  ------------------
  |  Branch (211:9): [True: 994, False: 3.77k]
  |  Branch (211:31): [True: 994, False: 0]
  ------------------
  212|       |        /* We read a dummy or an empty vin. */
  213|    994|        s >> flags;
  214|    994|        if (flags != 0) {
  ------------------
  |  Branch (214:13): [True: 897, False: 97]
  ------------------
  215|    897|            s >> tx.vin;
  216|    897|            s >> tx.vout;
  217|    897|        }
  218|  3.77k|    } else {
  219|       |        /* We read a non-empty vin. Assume a normal vout follows. */
  220|  3.77k|        s >> tx.vout;
  221|  3.77k|    }
  222|  4.76k|    if ((flags & 1) && fAllowWitness) {
  ------------------
  |  Branch (222:9): [True: 696, False: 4.07k]
  |  Branch (222:24): [True: 696, False: 0]
  ------------------
  223|       |        /* The witness flag is present, and we support witnesses. */
  224|    696|        flags ^= 1;
  225|  41.1k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (225:28): [True: 40.4k, False: 696]
  ------------------
  226|  40.4k|            s >> tx.vin[i].scriptWitness.stack;
  227|  40.4k|        }
  228|    696|        if (!tx.HasWitness()) {
  ------------------
  |  Branch (228:13): [True: 14, False: 682]
  ------------------
  229|       |            /* It's illegal to encode witnesses when all witness stacks are empty. */
  230|     14|            throw std::ios_base::failure("Superfluous witness record");
  231|     14|        }
  232|    696|    }
  233|  4.75k|    if (flags) {
  ------------------
  |  Branch (233:9): [True: 9, False: 4.74k]
  ------------------
  234|       |        /* Unknown flag in the serialization */
  235|      9|        throw std::ios_base::failure("Unknown transaction optional data");
  236|      9|    }
  237|  4.74k|    s >> tx.nLockTime;
  238|  4.74k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10SpanReader20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  124|   365k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  148|   365k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10SpanReader20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
   39|   365k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  148|   365k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10SpanReader20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  152|  1.12M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|  1.12M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  124|   214k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  148|   214k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|   214k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  148|   214k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  152|  1.07M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|  1.07M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  313|  12.0k|    inline void Serialize(Stream& s) const {
  314|  12.0k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  315|  12.0k|    }
_Z20SerializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  242|  12.0k|{
  243|  12.0k|    const bool fAllowWitness = params.allow_witness;
  244|       |
  245|  12.0k|    s << tx.version;
  246|  12.0k|    unsigned char flags = 0;
  247|       |    // Consistency check
  248|  12.0k|    if (fAllowWitness) {
  ------------------
  |  Branch (248:9): [True: 12.0k, False: 0]
  ------------------
  249|       |        /* Check whether witnesses need to be serialized. */
  250|  12.0k|        if (tx.HasWitness()) {
  ------------------
  |  Branch (250:13): [True: 1.44k, False: 10.6k]
  ------------------
  251|  1.44k|            flags |= 1;
  252|  1.44k|        }
  253|  12.0k|    }
  254|  12.0k|    if (flags) {
  ------------------
  |  Branch (254:9): [True: 1.44k, False: 10.6k]
  ------------------
  255|       |        /* Use extended format in case witnesses are to be serialized. */
  256|  1.44k|        std::vector<CTxIn> vinDummy;
  257|  1.44k|        s << vinDummy;
  258|  1.44k|        s << flags;
  259|  1.44k|    }
  260|  12.0k|    s << tx.vin;
  261|  12.0k|    s << tx.vout;
  262|  12.0k|    if (flags & 1) {
  ------------------
  |  Branch (262:9): [True: 1.44k, False: 10.6k]
  ------------------
  263|   103k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (263:28): [True: 101k, False: 1.44k]
  ------------------
  264|   101k|            s << tx.vin[i].scriptWitness.stack;
  265|   101k|        }
  266|  1.44k|    }
  267|  12.0k|    s << tx.nLockTime;
  268|  12.0k|}
_ZN6CTxOut16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  152|  2.09k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|  2.09k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN5CTxInC2Ev:
  117|   731k|    {
  118|   731k|        nSequence = SEQUENCE_FINAL;
  119|   731k|    }
_ZNK12CTransaction9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  313|  75.6k|    inline void Serialize(Stream& s) const {
  314|  75.6k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  315|  75.6k|    }
_Z20SerializeTransactionI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  242|  75.6k|{
  243|  75.6k|    const bool fAllowWitness = params.allow_witness;
  244|       |
  245|  75.6k|    s << tx.version;
  246|  75.6k|    unsigned char flags = 0;
  247|       |    // Consistency check
  248|  75.6k|    if (fAllowWitness) {
  ------------------
  |  Branch (248:9): [True: 44.6k, False: 30.9k]
  ------------------
  249|       |        /* Check whether witnesses need to be serialized. */
  250|  44.6k|        if (tx.HasWitness()) {
  ------------------
  |  Branch (250:13): [True: 5.36k, False: 39.3k]
  ------------------
  251|  5.36k|            flags |= 1;
  252|  5.36k|        }
  253|  44.6k|    }
  254|  75.6k|    if (flags) {
  ------------------
  |  Branch (254:9): [True: 5.36k, False: 70.3k]
  ------------------
  255|       |        /* Use extended format in case witnesses are to be serialized. */
  256|  5.36k|        std::vector<CTxIn> vinDummy;
  257|  5.36k|        s << vinDummy;
  258|  5.36k|        s << flags;
  259|  5.36k|    }
  260|  75.6k|    s << tx.vin;
  261|  75.6k|    s << tx.vout;
  262|  75.6k|    if (flags & 1) {
  ------------------
  |  Branch (262:9): [True: 5.36k, False: 70.3k]
  ------------------
  263|   387k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (263:28): [True: 382k, False: 5.36k]
  ------------------
  264|   382k|            s << tx.vin[i].scriptWitness.stack;
  265|   382k|        }
  266|  5.36k|    }
  267|  75.6k|    s << tx.nLockTime;
  268|  75.6k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  124|  1.30M|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  148|  1.30M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|  1.30M|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  148|  1.30M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  152|  7.96M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|  7.96M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction14GetWitnessHashEv:
  329|  12.0k|    const Wtxid& GetWitnessHash() const LIFETIMEBOUND { return m_witness_hash; };
_ZNK12CTransaction10IsCoinBaseEv:
  342|   137k|    {
  343|   137k|        return (vin.size() == 1 && vin[0].prevout.IsNull());
  ------------------
  |  Branch (343:17): [True: 19.5k, False: 118k]
  |  Branch (343:36): [True: 299, False: 19.2k]
  ------------------
  344|   137k|    }
_ZltRK9COutPointS1_:
   45|   388k|    {
   46|   388k|        return std::tie(a.hash, a.n) < std::tie(b.hash, b.n);
   47|   388k|    }
_ZN9COutPointC2Ev:
   36|   735k|    COutPoint(): n(NULL_INDEX) { }
_ZNK9COutPoint6IsNullEv:
   42|   125k|    bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
  ------------------
  |  Branch (42:35): [True: 48.9k, False: 76.3k]
  |  Branch (42:52): [True: 479, False: 48.4k]
  ------------------
_ZNK12CTransaction10HasWitnessEv:
  353|  66.1k|    bool HasWitness() const { return m_has_witness; }
_ZNK12CTransaction7GetHashEv:
  328|  16.1k|    const Txid& GetHash() const LIFETIMEBOUND { return hash; }
_ZNK19CMutableTransaction10HasWitnessEv:
  393|  1.04k|    {
  394|  18.6k|        for (size_t i = 0; i < vin.size(); i++) {
  ------------------
  |  Branch (394:28): [True: 18.6k, False: 28]
  ------------------
  395|  18.6k|            if (!vin[i].scriptWitness.IsNull()) {
  ------------------
  |  Branch (395:17): [True: 1.01k, False: 17.6k]
  ------------------
  396|  1.01k|                return true;
  397|  1.01k|            }
  398|  18.6k|        }
  399|     28|        return false;
  400|  1.04k|    }
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  124|   132k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  148|   132k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|   132k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  148|   132k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  152|   794k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  148|   794k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  313|  5.26k|    inline void Serialize(Stream& s) const {
  314|  5.26k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  315|  5.26k|    }
_Z20SerializeTransactionI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  242|  5.26k|{
  243|  5.26k|    const bool fAllowWitness = params.allow_witness;
  244|       |
  245|  5.26k|    s << tx.version;
  246|  5.26k|    unsigned char flags = 0;
  247|       |    // Consistency check
  248|  5.26k|    if (fAllowWitness) {
  ------------------
  |  Branch (248:9): [True: 500, False: 4.76k]
  ------------------
  249|       |        /* Check whether witnesses need to be serialized. */
  250|    500|        if (tx.HasWitness()) {
  ------------------
  |  Branch (250:13): [True: 500, False: 0]
  ------------------
  251|    500|            flags |= 1;
  252|    500|        }
  253|    500|    }
  254|  5.26k|    if (flags) {
  ------------------
  |  Branch (254:9): [True: 500, False: 4.76k]
  ------------------
  255|       |        /* Use extended format in case witnesses are to be serialized. */
  256|    500|        std::vector<CTxIn> vinDummy;
  257|    500|        s << vinDummy;
  258|    500|        s << flags;
  259|    500|    }
  260|  5.26k|    s << tx.vin;
  261|  5.26k|    s << tx.vout;
  262|  5.26k|    if (flags & 1) {
  ------------------
  |  Branch (262:9): [True: 500, False: 4.76k]
  ------------------
  263|  40.1k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (263:28): [True: 39.6k, False: 500]
  ------------------
  264|  39.6k|            s << tx.vin[i].scriptWitness.stack;
  265|  39.6k|        }
  266|    500|    }
  267|  5.26k|    s << tx.nLockTime;
  268|  5.26k|}
_ZN6CTxOutC2Ev:
  146|  2.34M|    {
  147|  2.34M|        SetNull();
  148|  2.34M|    }
_ZN6CTxOut7SetNullEv:
  155|  2.34M|    {
  156|  2.34M|        nValue = -1;
  157|  2.34M|        scriptPubKey.clear();
  158|  2.34M|    }

_ZNK22transaction_identifierILb0EE8ToStringEv:
   50|  97.2k|    std::string ToString() const { return m_wrapped.ToString(); }
_ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
   56|   365k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZNK22transaction_identifierILb1EE6GetHexEv:
   49|  8.02k|    std::string GetHex() const { return m_wrapped.GetHex(); }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
   55|   214k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb0EE11UnserializeI10SpanReaderEEvRT_:
   56|   365k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZNK22transaction_identifierILb0EE6GetHexEv:
   49|   128k|    std::string GetHex() const { return m_wrapped.GetHex(); }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
   55|  1.30M|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZNK22transaction_identifierILb0EEssERKS0_:
   35|   452k|    constexpr auto operator<=>(const transaction_identifier&) const = default;
_ZN22transaction_identifierILb0EEC2Ev:
   31|   735k|    transaction_identifier() : m_wrapped{} {}
_ZNK22transaction_identifierILb0EE6IsNullEv:
   41|   125k|    constexpr bool IsNull() const { return m_wrapped.IsNull(); }
_ZNK22transaction_identifierILb0EE9ToUint256Ev:
   37|   100k|    const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; }
_ZN22transaction_identifierILb0EE11FromUint256ERK7uint256:
   38|  4.76k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb0EEC2ERK7uint256:
   28|  4.76k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
   55|   132k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb1EE11FromUint256ERK7uint256:
   38|  4.76k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb1EEC2ERK7uint256:
   28|  4.76k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}

_ZNK11XOnlyPubKey11GetCPubKeysEv:
  201|  2.80k|{
  202|  2.80k|    std::vector<CPubKey> out;
  203|  2.80k|    unsigned char b[33] = {0x02};
  204|  2.80k|    std::copy(m_keydata.begin(), m_keydata.end(), b + 1);
  205|  2.80k|    CPubKey fullpubkey;
  206|  2.80k|    fullpubkey.Set(b, b + 33);
  207|  2.80k|    out.push_back(fullpubkey);
  208|  2.80k|    b[0] = 0x03;
  209|  2.80k|    fullpubkey.Set(b, b + 33);
  210|  2.80k|    out.push_back(fullpubkey);
  211|  2.80k|    return out;
  212|  2.80k|}
_ZNK11XOnlyPubKey9GetKeyIDsEv:
  215|  2.80k|{
  216|  2.80k|    std::vector<CKeyID> out;
  217|  5.60k|    for (const CPubKey& pk : GetCPubKeys()) {
  ------------------
  |  Branch (217:28): [True: 5.60k, False: 2.80k]
  ------------------
  218|  5.60k|        out.push_back(pk.GetID());
  219|  5.60k|    }
  220|  2.80k|    return out;
  221|  2.80k|}
_ZNK11XOnlyPubKey27GetEvenCorrespondingCPubKeyEv:
  224|  2.80k|{
  225|  2.80k|    unsigned char full_key[CPubKey::COMPRESSED_SIZE] = {0x02};
  226|  2.80k|    std::copy(begin(), end(), full_key + 1);
  227|  2.80k|    return CPubKey{full_key};
  228|  2.80k|}
_ZNK11XOnlyPubKey12IsFullyValidEv:
  231|  4.53k|{
  232|  4.53k|    secp256k1_xonly_pubkey pubkey;
  233|  4.53k|    return secp256k1_xonly_pubkey_parse(secp256k1_context_static, &pubkey, m_keydata.data());
  234|  4.53k|}

_ZNK7CPubKey16IsValidNonHybridEv:
  198|  23.3k|    {
  199|  23.3k|        return size() > 0 && (vch[0] == 0x02 || vch[0] == 0x03 || vch[0] == 0x04);
  ------------------
  |  Branch (199:16): [True: 23.3k, False: 0]
  |  Branch (199:31): [True: 8.89k, False: 14.4k]
  |  Branch (199:49): [True: 9.51k, False: 4.95k]
  |  Branch (199:67): [True: 2.44k, False: 2.50k]
  ------------------
  200|  23.3k|    }
_ZN7CPubKey9ValidSizeERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
   83|   114k|    bool static ValidSize(const std::vector<unsigned char> &vch) {
   84|   114k|      return vch.size() > 0 && GetLen(vch[0]) == vch.size();
  ------------------
  |  Branch (84:14): [True: 90.9k, False: 23.4k]
  |  Branch (84:32): [True: 86.4k, False: 4.57k]
  ------------------
   85|   114k|    }
_ZNK7CPubKey4dataEv:
  119|  23.1k|    const unsigned char* data() const { return vch; }
_ZN7CPubKey6GetLenEh:
   67|   212k|    {
   68|   212k|        if (chHeader == 2 || chHeader == 3)
  ------------------
  |  Branch (68:13): [True: 85.6k, False: 127k]
  |  Branch (68:30): [True: 82.4k, False: 44.6k]
  ------------------
   69|   168k|            return COMPRESSED_SIZE;
   70|  44.6k|        if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  ------------------
  |  Branch (70:13): [True: 19.4k, False: 25.2k]
  |  Branch (70:30): [True: 11.0k, False: 14.2k]
  |  Branch (70:47): [True: 10.5k, False: 3.68k]
  ------------------
   71|  40.9k|            return SIZE;
   72|  3.68k|        return 0;
   73|  44.6k|    }
_ZN7CPubKey10InvalidateEv:
   77|  22.5k|    {
   78|  22.5k|        vch[0] = 0xFF;
   79|  22.5k|    }
_ZN7CPubKeyC2ENSt3__14spanIKhLm18446744073709551615EEE:
  113|  34.7k|    {
  114|  34.7k|        Set(_vch.begin(), _vch.end());
  115|  34.7k|    }
_ZNK7CPubKey4sizeEv:
  118|  81.4k|    unsigned int size() const { return GetLen(vch[0]); }
_ZNK7CPubKey7IsValidEv:
  192|  8.54k|    {
  193|  8.54k|        return size() > 0;
  194|  8.54k|    }
_ZN7CPubKey3SetINSt3__111__wrap_iterIPKhEEEEvT_S6_:
   96|  34.7k|    {
   97|  34.7k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (97:19): [True: 0, False: 34.7k]
  ------------------
   98|  34.7k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (98:13): [True: 34.7k, False: 0]
  |  Branch (98:20): [True: 34.7k, False: 0]
  ------------------
   99|  34.7k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
  100|      0|        else
  101|      0|            Invalidate();
  102|  34.7k|    }
_ZN7CPubKeyC2Ev:
   89|  22.5k|    {
   90|  22.5k|        Invalidate();
   91|  22.5k|    }
_ZNK7CPubKey5GetIDEv:
  167|  26.4k|    {
  168|  26.4k|        return CKeyID(Hash160(std::span{vch}.first(size())));
  169|  26.4k|    }
_ZN6CKeyIDC2ERK7uint160:
   29|  46.1k|    explicit CKeyID(const uint160& in) : uint160(in) {}
_ZNK11XOnlyPubKey5beginEv:
  301|  10.8k|    const unsigned char* begin() const { return m_keydata.begin(); }
_ZNK11XOnlyPubKey3endEv:
  302|  10.8k|    const unsigned char* end() const { return m_keydata.end(); }
_ZN11XOnlyPubKeyC2Ev:
  244|  15.3k|    XOnlyPubKey() = default;
_ZN11XOnlyPubKey5beginEv:
  304|  10.8k|    unsigned char* begin() { return m_keydata.begin(); }
_ZN7CPubKey3SetIPhEEvT_S2_:
   96|  5.60k|    {
   97|  5.60k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (97:19): [True: 0, False: 5.60k]
  ------------------
   98|  5.60k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (98:13): [True: 5.60k, False: 0]
  |  Branch (98:20): [True: 5.60k, False: 0]
  ------------------
   99|  5.60k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
  100|      0|        else
  101|      0|            Invalidate();
  102|  5.60k|    }

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

_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  8.15k|    constexpr RandomMixin() noexcept = default;
_Z11GetRandHashv:
  464|  8.15k|{
  465|  8.15k|    uint256 hash;
  466|  8.15k|    GetRandBytes(hash);
  467|  8.15k|    return hash;
  468|  8.15k|}
_ZN17FastRandomContext6rand64Ev:
  405|  8.15k|    {
  406|  8.15k|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (406:13): [True: 8.15k, False: 0]
  ------------------
  407|  8.15k|        std::array<std::byte, 8> buf;
  408|  8.15k|        rng.Keystream(buf);
  409|  8.15k|        return ReadLE64(buf.data());
  410|  8.15k|    }

_Z15InferDescriptorRK7CScriptRK15SigningProvider:
 2984|   454k|{
 2985|   454k|    return InferScript(script, ParseScriptContext::TOP, provider);
 2986|   454k|}
descriptor.cpp:_ZN12_GLOBAL__N_118DescriptorChecksumERKNSt3__14spanIKcLm18446744073709551615EEE:
  125|   454k|{
  126|       |    /** A character set designed such that:
  127|       |     *  - The most common 'unprotected' descriptor characters (hex, keypaths) are in the first group of 32.
  128|       |     *  - Case errors cause an offset that's a multiple of 32.
  129|       |     *  - As many alphabetic characters are in the same group (while following the above restrictions).
  130|       |     *
  131|       |     * If p(x) gives the position of a character c in this character set, every group of 3 characters
  132|       |     * (a,b,c) is encoded as the 4 symbols (p(a) & 31, p(b) & 31, p(c) & 31, (p(a) / 32) + 3 * (p(b) / 32) + 9 * (p(c) / 32).
  133|       |     * This means that changes that only affect the lower 5 bits of the position, or only the higher 2 bits, will just
  134|       |     * affect a single symbol.
  135|       |     *
  136|       |     * As a result, within-group-of-32 errors count as 1 symbol, as do cross-group errors that don't affect
  137|       |     * the position within the groups.
  138|       |     */
  139|   454k|    static const std::string INPUT_CHARSET =
  140|   454k|        "0123456789()[],'/*abcdefgh@:$%{}"
  141|   454k|        "IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~"
  142|   454k|        "ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";
  143|       |
  144|       |    /** The character set for the checksum itself (same as bech32). */
  145|   454k|    static const std::string CHECKSUM_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
  146|       |
  147|   454k|    uint64_t c = 1;
  148|   454k|    int cls = 0;
  149|   454k|    int clscount = 0;
  150|  33.4M|    for (auto ch : span) {
  ------------------
  |  Branch (150:18): [True: 33.4M, False: 454k]
  ------------------
  151|  33.4M|        auto pos = INPUT_CHARSET.find(ch);
  152|  33.4M|        if (pos == std::string::npos) return "";
  ------------------
  |  Branch (152:13): [True: 0, False: 33.4M]
  ------------------
  153|  33.4M|        c = PolyMod(c, pos & 31); // Emit a symbol for the position inside the group, for every character.
  154|  33.4M|        cls = cls * 3 + (pos >> 5); // Accumulate the group numbers
  155|  33.4M|        if (++clscount == 3) {
  ------------------
  |  Branch (155:13): [True: 10.9M, False: 22.5M]
  ------------------
  156|       |            // Emit an extra symbol representing the group numbers, for every 3 characters.
  157|  10.9M|            c = PolyMod(c, cls);
  158|  10.9M|            cls = 0;
  159|  10.9M|            clscount = 0;
  160|  10.9M|        }
  161|  33.4M|    }
  162|   454k|    if (clscount > 0) c = PolyMod(c, cls);
  ------------------
  |  Branch (162:9): [True: 423k, False: 31.3k]
  ------------------
  163|  4.09M|    for (int j = 0; j < 8; ++j) c = PolyMod(c, 0); // Shift further to determine the checksum.
  ------------------
  |  Branch (163:21): [True: 3.63M, False: 454k]
  ------------------
  164|   454k|    c ^= 1; // Prevent appending zeroes from not affecting the checksum.
  165|       |
  166|   454k|    std::string ret(8, ' ');
  167|  4.09M|    for (int j = 0; j < 8; ++j) ret[j] = CHECKSUM_CHARSET[(c >> (5 * (7 - j))) & 31];
  ------------------
  |  Branch (167:21): [True: 3.63M, False: 454k]
  ------------------
  168|   454k|    return ret;
  169|   454k|}
descriptor.cpp:_ZN12_GLOBAL__N_17PolyModEmi:
  113|  48.5M|{
  114|  48.5M|    uint8_t c0 = c >> 35;
  115|  48.5M|    c = ((c & 0x7ffffffff) << 5) ^ val;
  116|  48.5M|    if (c0 & 1) c ^= 0xf5dee51989;
  ------------------
  |  Branch (116:9): [True: 23.1M, False: 25.3M]
  ------------------
  117|  48.5M|    if (c0 & 2) c ^= 0xa9fdca3312;
  ------------------
  |  Branch (117:9): [True: 21.8M, False: 26.6M]
  ------------------
  118|  48.5M|    if (c0 & 4) c ^= 0x1bab10e32d;
  ------------------
  |  Branch (118:9): [True: 22.0M, False: 26.5M]
  ------------------
  119|  48.5M|    if (c0 & 8) c ^= 0x3706b1677a;
  ------------------
  |  Branch (119:9): [True: 21.4M, False: 27.0M]
  ------------------
  120|  48.5M|    if (c0 & 16) c ^= 0x644d626ffd;
  ------------------
  |  Branch (120:9): [True: 21.9M, False: 26.5M]
  ------------------
  121|  48.5M|    return c;
  122|  48.5M|}
descriptor.cpp:_ZN12_GLOBAL__N_114PubkeyProviderC2Ej:
  187|  23.6k|    explicit PubkeyProvider(uint32_t exp_index) : m_expr_index(exp_index) {}
descriptor.cpp:_ZN12_GLOBAL__N_114PubkeyProviderD2Ev:
  189|  23.6k|    virtual ~PubkeyProvider() = default;
descriptor.cpp:_ZN12_GLOBAL__N_119ConstPubkeyProviderC2EjRK7CPubKeyb:
  347|  23.6k|    ConstPubkeyProvider(uint32_t exp_index, const CPubKey& pubkey, bool xonly) : PubkeyProvider(exp_index), m_pubkey(pubkey), m_xonly(xonly) {}
descriptor.cpp:_ZNK12_GLOBAL__N_119ConstPubkeyProvider8ToStringENS_14PubkeyProvider10StringTypeE:
  360|  23.1k|    std::string ToString(StringType type) const override { return m_xonly ? HexStr(m_pubkey).substr(2) : HexStr(m_pubkey); }
  ------------------
  |  Branch (360:67): [True: 2.80k, False: 20.3k]
  ------------------
descriptor.cpp:_ZN12_GLOBAL__N_112PKDescriptorC2ENSt3__110unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS3_EEEEb:
 1202|  5.81k|    PKDescriptor(std::unique_ptr<PubkeyProvider> prov, bool xonly = false) : DescriptorImpl(Vector(std::move(prov)), "pk"), m_xonly(xonly) {}
descriptor.cpp:_ZN12_GLOBAL__N_114DescriptorImplC2ENSt3__16vectorINS1_10unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS8_IcEEEE:
  868|   454k|    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_name(name), m_subdescriptor_args() {}
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl8ToStringEb:
  976|   454k|    {
  977|   454k|        std::string ret;
  978|   454k|        ToStringHelper(nullptr, ret, compat_format ? StringType::COMPAT : StringType::PUBLIC);
  ------------------
  |  Branch (978:38): [True: 0, False: 454k]
  ------------------
  979|   454k|        return AddChecksum(ret);
  980|   454k|    }
descriptor.cpp:_ZN12_GLOBAL__N_111AddChecksumERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  171|   454k|std::string AddChecksum(const std::string& str) { return str + "#" + DescriptorChecksum(str); }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl13ToStringExtraEv:
  853|  8.61k|    virtual std::string ToStringExtra() const { return ""; }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl23ToStringSubScriptHelperEPK15SigningProviderRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_10StringTypeEPK15DescriptorCache:
  919|   454k|    {
  920|   454k|        size_t pos = 0;
  921|   454k|        bool is_private{type == StringType::PRIVATE};
  922|       |        // For private string output, track if at least one key has a private key available.
  923|       |        // Initialize to true for non-private types.
  924|   454k|        bool any_success{!is_private};
  925|   454k|        for (const auto& scriptarg : m_subdescriptor_args) {
  ------------------
  |  Branch (925:36): [True: 0, False: 454k]
  ------------------
  926|      0|            if (pos++) ret += ",";
  ------------------
  |  Branch (926:17): [True: 0, False: 0]
  ------------------
  927|      0|            std::string tmp;
  928|      0|            bool subscript_res{scriptarg->ToStringHelper(arg, tmp, type, cache)};
  929|      0|            if (!is_private && !subscript_res) return false;
  ------------------
  |  Branch (929:17): [True: 0, False: 0]
  |  Branch (929:32): [True: 0, False: 0]
  ------------------
  930|      0|            any_success = any_success || subscript_res;
  ------------------
  |  Branch (930:27): [True: 0, False: 0]
  |  Branch (930:42): [True: 0, False: 0]
  ------------------
  931|      0|            ret += tmp;
  932|      0|        }
  933|   454k|        return any_success;
  934|   454k|    }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl14ToStringHelperEPK15SigningProviderRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_10StringTypeEPK15DescriptorCache:
  938|   454k|    {
  939|   454k|        std::string extra = ToStringExtra();
  940|   454k|        size_t pos = extra.size() > 0 ? 1 : 0;
  ------------------
  |  Branch (940:22): [True: 328k, False: 126k]
  ------------------
  941|   454k|        std::string ret = m_name + "(" + extra;
  942|   454k|        bool is_private{type == StringType::PRIVATE};
  943|       |        // For private string output, track if at least one key has a private key available.
  944|       |        // Initialize to true for non-private types.
  945|   454k|        bool any_success{!is_private};
  946|       |
  947|   454k|        for (const auto& pubkey : m_pubkey_args) {
  ------------------
  |  Branch (947:33): [True: 23.1k, False: 454k]
  ------------------
  948|  23.1k|            if (pos++) ret += ",";
  ------------------
  |  Branch (948:17): [True: 14.5k, False: 8.61k]
  ------------------
  949|  23.1k|            std::string tmp;
  950|  23.1k|            switch (type) {
  ------------------
  |  Branch (950:21): [True: 23.1k, False: 0]
  ------------------
  951|      0|                case StringType::NORMALIZED:
  ------------------
  |  Branch (951:17): [True: 0, False: 23.1k]
  ------------------
  952|      0|                    if (!pubkey->ToNormalizedString(*arg, tmp, cache)) return false;
  ------------------
  |  Branch (952:25): [True: 0, False: 0]
  ------------------
  953|      0|                    break;
  954|      0|                case StringType::PRIVATE:
  ------------------
  |  Branch (954:17): [True: 0, False: 23.1k]
  ------------------
  955|      0|                    any_success = pubkey->ToPrivateString(*arg, tmp) || any_success;
  ------------------
  |  Branch (955:35): [True: 0, False: 0]
  |  Branch (955:73): [True: 0, False: 0]
  ------------------
  956|      0|                    break;
  957|  23.1k|                case StringType::PUBLIC:
  ------------------
  |  Branch (957:17): [True: 23.1k, False: 0]
  ------------------
  958|  23.1k|                    tmp = pubkey->ToString();
  959|  23.1k|                    break;
  960|      0|                case StringType::COMPAT:
  ------------------
  |  Branch (960:17): [True: 0, False: 23.1k]
  ------------------
  961|      0|                    tmp = pubkey->ToString(PubkeyProvider::StringType::COMPAT);
  962|      0|                    break;
  963|  23.1k|            }
  964|  23.1k|            ret += tmp;
  965|  23.1k|        }
  966|   454k|        std::string subscript;
  967|   454k|        bool subscript_res{ToStringSubScriptHelper(arg, subscript, type, cache)};
  968|   454k|        if (!is_private && !subscript_res) return false;
  ------------------
  |  Branch (968:13): [True: 454k, False: 0]
  |  Branch (968:28): [True: 0, False: 454k]
  ------------------
  969|   454k|        any_success = any_success || subscript_res;
  ------------------
  |  Branch (969:23): [True: 454k, False: 0]
  |  Branch (969:38): [True: 0, False: 0]
  ------------------
  970|   454k|        if (pos && subscript.size()) ret += ',';
  ------------------
  |  Branch (970:13): [True: 336k, False: 117k]
  |  Branch (970:20): [True: 0, False: 336k]
  ------------------
  971|   454k|        out = std::move(ret) + std::move(subscript) + ")";
  972|   454k|        return any_success;
  973|   454k|    }
descriptor.cpp:_ZN12_GLOBAL__N_118MultisigDescriptorC2EiNSt3__16vectorINS1_10unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEEb:
 1335|  5.02k|    MultisigDescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers, bool sorted = false) : DescriptorImpl(std::move(providers), sorted ? "sortedmulti" : "multi"), m_threshold(threshold), m_sorted(sorted) {}
  ------------------
  |  Branch (1335:155): [True: 0, False: 5.02k]
  ------------------
descriptor.cpp:_ZNK12_GLOBAL__N_118MultisigDescriptor13ToStringExtraEv:
 1325|  5.02k|    std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
  ------------------
  |  | 1172|  5.02k|#define strprintf tfm::format
  ------------------
descriptor.cpp:_ZN12_GLOBAL__N_117AddressDescriptorC2ENSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
 1141|  64.0k|    AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, "addr"), m_destination(std::move(destination)) {}
descriptor.cpp:_ZNK12_GLOBAL__N_117AddressDescriptor13ToStringExtraEv:
 1138|  64.0k|    std::string ToStringExtra() const override { return EncodeDestination(m_destination); }
descriptor.cpp:_ZN12_GLOBAL__N_115RawTRDescriptorC2ENSt3__110unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS3_EEEE:
 1766|  2.80k|    RawTRDescriptor(std::unique_ptr<PubkeyProvider> output_key) : DescriptorImpl(Vector(std::move(output_key)), "rawtr") {}
descriptor.cpp:_ZN12_GLOBAL__N_113RawDescriptorC2E7CScript:
 1166|   376k|    RawDescriptor(CScript script) : DescriptorImpl({}, "raw"), m_script(std::move(script)) {}
descriptor.cpp:_ZNK12_GLOBAL__N_113RawDescriptor13ToStringExtraEv:
 1163|   376k|    std::string ToStringExtra() const override { return HexStr(m_script); }
descriptor.cpp:_ZN12_GLOBAL__N_111InferScriptERK7CScriptNS_18ParseScriptContextERK15SigningProvider:
 2778|   454k|{
 2779|   454k|    if (ctx == ParseScriptContext::P2TR && script.size() == 34 && script[0] == 32 && script[33] == OP_CHECKSIG) {
  ------------------
  |  Branch (2779:9): [True: 0, False: 454k]
  |  Branch (2779:44): [True: 0, False: 0]
  |  Branch (2779:67): [True: 0, False: 0]
  |  Branch (2779:86): [True: 0, False: 0]
  ------------------
 2780|      0|        XOnlyPubKey key{std::span{script}.subspan(1, 32)};
 2781|      0|        return std::make_unique<PKDescriptor>(InferXOnlyPubkey(key, ctx, provider), true);
 2782|      0|    }
 2783|       |
 2784|   454k|    if (ctx == ParseScriptContext::P2TR) {
  ------------------
  |  Branch (2784:9): [True: 0, False: 454k]
  ------------------
 2785|      0|        auto ret = InferMultiA(script, ctx, provider);
 2786|      0|        if (ret) return ret;
  ------------------
  |  Branch (2786:13): [True: 0, False: 0]
  ------------------
 2787|      0|    }
 2788|       |
 2789|   454k|    std::vector<std::vector<unsigned char>> data;
 2790|   454k|    TxoutType txntype = Solver(script, data);
 2791|       |
 2792|   454k|    if (txntype == TxoutType::PUBKEY && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2792:9): [True: 7.17k, False: 447k]
  |  Branch (2792:42): [True: 7.17k, False: 0]
  |  Branch (2792:76): [True: 0, False: 0]
  |  Branch (2792:111): [True: 0, False: 0]
  ------------------
 2793|  7.17k|        CPubKey pubkey(data[0]);
 2794|  7.17k|        if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2794:18): [True: 5.81k, False: 1.36k]
  ------------------
 2795|  5.81k|            return std::make_unique<PKDescriptor>(std::move(pubkey_provider));
 2796|  5.81k|        }
 2797|  7.17k|    }
 2798|   448k|    if (txntype == TxoutType::PUBKEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2798:9): [True: 5.95k, False: 442k]
  |  Branch (2798:46): [True: 5.95k, False: 0]
  |  Branch (2798:80): [True: 0, False: 0]
  |  Branch (2798:115): [True: 0, False: 0]
  ------------------
 2799|  5.95k|        uint160 hash(data[0]);
 2800|  5.95k|        CKeyID keyid(hash);
 2801|  5.95k|        CPubKey pubkey;
 2802|  5.95k|        if (provider.GetPubKey(keyid, pubkey)) {
  ------------------
  |  Branch (2802:13): [True: 0, False: 5.95k]
  ------------------
 2803|      0|            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2803:22): [True: 0, False: 0]
  ------------------
 2804|      0|                return std::make_unique<PKHDescriptor>(std::move(pubkey_provider));
 2805|      0|            }
 2806|      0|        }
 2807|  5.95k|    }
 2808|   448k|    if (txntype == TxoutType::WITNESS_V0_KEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
  ------------------
  |  Branch (2808:9): [True: 13.7k, False: 434k]
  |  Branch (2808:54): [True: 13.7k, False: 0]
  |  Branch (2808:88): [True: 0, False: 0]
  ------------------
 2809|  13.7k|        uint160 hash(data[0]);
 2810|  13.7k|        CKeyID keyid(hash);
 2811|  13.7k|        CPubKey pubkey;
 2812|  13.7k|        if (provider.GetPubKey(keyid, pubkey)) {
  ------------------
  |  Branch (2812:13): [True: 0, False: 13.7k]
  ------------------
 2813|      0|            if (auto pubkey_provider = InferPubkey(pubkey, ParseScriptContext::P2WPKH, provider)) {
  ------------------
  |  Branch (2813:22): [True: 0, False: 0]
  ------------------
 2814|      0|                return std::make_unique<WPKHDescriptor>(std::move(pubkey_provider));
 2815|      0|            }
 2816|      0|        }
 2817|  13.7k|    }
 2818|   448k|    if (txntype == TxoutType::MULTISIG && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2818:9): [True: 6.16k, False: 442k]
  |  Branch (2818:44): [True: 6.16k, False: 0]
  |  Branch (2818:78): [True: 0, False: 0]
  |  Branch (2818:113): [True: 0, False: 0]
  ------------------
 2819|  6.16k|        bool ok = true;
 2820|  6.16k|        std::vector<std::unique_ptr<PubkeyProvider>> providers;
 2821|  21.2k|        for (size_t i = 1; i + 1 < data.size(); ++i) {
  ------------------
  |  Branch (2821:28): [True: 16.1k, False: 5.02k]
  ------------------
 2822|  16.1k|            CPubKey pubkey(data[i]);
 2823|  16.1k|            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2823:22): [True: 15.0k, False: 1.14k]
  ------------------
 2824|  15.0k|                providers.push_back(std::move(pubkey_provider));
 2825|  15.0k|            } else {
 2826|  1.14k|                ok = false;
 2827|  1.14k|                break;
 2828|  1.14k|            }
 2829|  16.1k|        }
 2830|  6.16k|        if (ok) return std::make_unique<MultisigDescriptor>((int)data[0][0], std::move(providers));
  ------------------
  |  Branch (2830:13): [True: 5.02k, False: 1.14k]
  ------------------
 2831|  6.16k|    }
 2832|   443k|    if (txntype == TxoutType::SCRIPTHASH && ctx == ParseScriptContext::TOP) {
  ------------------
  |  Branch (2832:9): [True: 22.2k, False: 421k]
  |  Branch (2832:45): [True: 22.2k, False: 0]
  ------------------
 2833|  22.2k|        uint160 hash(data[0]);
 2834|  22.2k|        CScriptID scriptid(hash);
 2835|  22.2k|        CScript subscript;
 2836|  22.2k|        if (provider.GetCScript(scriptid, subscript)) {
  ------------------
  |  Branch (2836:13): [True: 0, False: 22.2k]
  ------------------
 2837|      0|            auto sub = InferScript(subscript, ParseScriptContext::P2SH, provider);
 2838|      0|            if (sub) return std::make_unique<SHDescriptor>(std::move(sub));
  ------------------
  |  Branch (2838:17): [True: 0, False: 0]
  ------------------
 2839|      0|        }
 2840|  22.2k|    }
 2841|   443k|    if (txntype == TxoutType::WITNESS_V0_SCRIPTHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
  ------------------
  |  Branch (2841:9): [True: 11.7k, False: 431k]
  |  Branch (2841:57): [True: 11.7k, False: 0]
  |  Branch (2841:91): [True: 0, False: 0]
  ------------------
 2842|  11.7k|        CScriptID scriptid{RIPEMD160(data[0])};
 2843|  11.7k|        CScript subscript;
 2844|  11.7k|        if (provider.GetCScript(scriptid, subscript)) {
  ------------------
  |  Branch (2844:13): [True: 0, False: 11.7k]
  ------------------
 2845|      0|            auto sub = InferScript(subscript, ParseScriptContext::P2WSH, provider);
 2846|      0|            if (sub) return std::make_unique<WSHDescriptor>(std::move(sub));
  ------------------
  |  Branch (2846:17): [True: 0, False: 0]
  ------------------
 2847|      0|        }
 2848|  11.7k|    }
 2849|   443k|    if (txntype == TxoutType::WITNESS_V1_TAPROOT && ctx == ParseScriptContext::TOP) {
  ------------------
  |  Branch (2849:9): [True: 4.53k, False: 439k]
  |  Branch (2849:53): [True: 4.53k, False: 0]
  ------------------
 2850|       |        // Extract x-only pubkey from output.
 2851|  4.53k|        XOnlyPubKey pubkey;
 2852|  4.53k|        std::copy(data[0].begin(), data[0].end(), pubkey.begin());
 2853|       |        // Request spending data.
 2854|  4.53k|        TaprootSpendData tap;
 2855|  4.53k|        if (provider.GetTaprootSpendData(pubkey, tap)) {
  ------------------
  |  Branch (2855:13): [True: 0, False: 4.53k]
  ------------------
 2856|       |            // If found, convert it back to tree form.
 2857|      0|            auto tree = InferTaprootTree(tap, pubkey);
 2858|      0|            if (tree) {
  ------------------
  |  Branch (2858:17): [True: 0, False: 0]
  ------------------
 2859|       |                // If that works, try to infer subdescriptors for all leaves.
 2860|      0|                bool ok = true;
 2861|      0|                std::vector<std::unique_ptr<DescriptorImpl>> subscripts; //!< list of script subexpressions
 2862|      0|                std::vector<int> depths; //!< depth in the tree of each subexpression (same length subscripts)
 2863|      0|                for (const auto& [depth, script, leaf_ver] : *tree) {
  ------------------
  |  Branch (2863:60): [True: 0, False: 0]
  ------------------
 2864|      0|                    std::unique_ptr<DescriptorImpl> subdesc;
 2865|      0|                    if (leaf_ver == TAPROOT_LEAF_TAPSCRIPT) {
  ------------------
  |  Branch (2865:25): [True: 0, False: 0]
  ------------------
 2866|      0|                        subdesc = InferScript(CScript(script.begin(), script.end()), ParseScriptContext::P2TR, provider);
 2867|      0|                    }
 2868|      0|                    if (!subdesc) {
  ------------------
  |  Branch (2868:25): [True: 0, False: 0]
  ------------------
 2869|      0|                        ok = false;
 2870|      0|                        break;
 2871|      0|                    } else {
 2872|      0|                        subscripts.push_back(std::move(subdesc));
 2873|      0|                        depths.push_back(depth);
 2874|      0|                    }
 2875|      0|                }
 2876|      0|                if (ok) {
  ------------------
  |  Branch (2876:21): [True: 0, False: 0]
  ------------------
 2877|      0|                    auto key = InferXOnlyPubkey(tap.internal_key, ParseScriptContext::P2TR, provider);
 2878|      0|                    return std::make_unique<TRDescriptor>(std::move(key), std::move(subscripts), std::move(depths));
 2879|      0|                }
 2880|      0|            }
 2881|      0|        }
 2882|       |        // If the above doesn't work, construct a rawtr() descriptor with just the encoded x-only pubkey.
 2883|  4.53k|        if (pubkey.IsFullyValid()) {
  ------------------
  |  Branch (2883:13): [True: 2.80k, False: 1.73k]
  ------------------
 2884|  2.80k|            auto key = InferXOnlyPubkey(pubkey, ParseScriptContext::P2TR, provider);
 2885|  2.80k|            if (key) {
  ------------------
  |  Branch (2885:17): [True: 2.80k, False: 0]
  ------------------
 2886|  2.80k|                return std::make_unique<RawTRDescriptor>(std::move(key));
 2887|  2.80k|            }
 2888|  2.80k|        }
 2889|  4.53k|    }
 2890|       |
 2891|   440k|    if (ctx == ParseScriptContext::P2WSH || ctx == ParseScriptContext::P2TR) {
  ------------------
  |  Branch (2891:9): [True: 0, False: 440k]
  |  Branch (2891:45): [True: 0, False: 440k]
  ------------------
 2892|      0|        const auto script_ctx{ctx == ParseScriptContext::P2WSH ? miniscript::MiniscriptContext::P2WSH : miniscript::MiniscriptContext::TAPSCRIPT};
  ------------------
  |  Branch (2892:31): [True: 0, False: 0]
  ------------------
 2893|      0|        uint32_t key_exp_index = 0;
 2894|      0|        KeyParser parser(/* out = */nullptr, /* in = */&provider, /* ctx = */script_ctx, key_exp_index);
 2895|      0|        auto node = miniscript::FromScript(script, parser);
 2896|      0|        if (node && node->IsSane()) {
  ------------------
  |  Branch (2896:13): [True: 0, False: 0]
  |  Branch (2896:21): [True: 0, False: 0]
  ------------------
 2897|      0|            std::vector<std::unique_ptr<PubkeyProvider>> keys;
 2898|      0|            keys.reserve(parser.m_keys.size());
 2899|      0|            for (auto& key : parser.m_keys) {
  ------------------
  |  Branch (2899:28): [True: 0, False: 0]
  ------------------
 2900|      0|                keys.emplace_back(std::move(key.at(0)));
 2901|      0|            }
 2902|      0|            return std::make_unique<MiniscriptDescriptor>(std::move(keys), std::move(*node));
 2903|      0|        }
 2904|      0|    }
 2905|       |
 2906|       |    // The following descriptors are all top-level only descriptors.
 2907|       |    // So if we are not at the top level, return early.
 2908|   440k|    if (ctx != ParseScriptContext::TOP) return nullptr;
  ------------------
  |  Branch (2908:9): [True: 0, False: 440k]
  ------------------
 2909|       |
 2910|   440k|    CTxDestination dest;
 2911|   440k|    if (ExtractDestination(script, dest)) {
  ------------------
  |  Branch (2911:9): [True: 64.0k, False: 376k]
  ------------------
 2912|  64.0k|        if (GetScriptForDestination(dest) == script) {
  ------------------
  |  Branch (2912:13): [True: 64.0k, False: 0]
  ------------------
 2913|  64.0k|            return std::make_unique<AddressDescriptor>(std::move(dest));
 2914|  64.0k|        }
 2915|  64.0k|    }
 2916|       |
 2917|   376k|    return std::make_unique<RawDescriptor>(script);
 2918|   440k|}
descriptor.cpp:_ZN12_GLOBAL__N_116InferXOnlyPubkeyERK11XOnlyPubKeyNS_18ParseScriptContextERK15SigningProvider:
 2217|  2.80k|{
 2218|  2.80k|    CPubKey pubkey{xkey.GetEvenCorrespondingCPubKey()};
 2219|  2.80k|    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, true);
 2220|  2.80k|    KeyOriginInfo info;
 2221|  2.80k|    if (provider.GetKeyOriginByXOnly(xkey, info)) {
  ------------------
  |  Branch (2221:9): [True: 0, False: 2.80k]
  ------------------
 2222|      0|        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
 2223|      0|    }
 2224|  2.80k|    return key_provider;
 2225|  2.80k|}
descriptor.cpp:_ZN12_GLOBAL__N_111InferPubkeyERK7CPubKeyNS_18ParseScriptContextERK15SigningProvider:
 2199|  23.3k|{
 2200|       |    // Key cannot be hybrid
 2201|  23.3k|    if (!pubkey.IsValidNonHybrid()) {
  ------------------
  |  Branch (2201:9): [True: 2.50k, False: 20.8k]
  ------------------
 2202|  2.50k|        return nullptr;
 2203|  2.50k|    }
 2204|       |    // Uncompressed is only allowed in TOP and P2SH contexts
 2205|  20.8k|    if (ctx != ParseScriptContext::TOP && ctx != ParseScriptContext::P2SH && !pubkey.IsCompressed()) {
  ------------------
  |  Branch (2205:9): [True: 0, False: 20.8k]
  |  Branch (2205:43): [True: 0, False: 0]
  |  Branch (2205:78): [True: 0, False: 0]
  ------------------
 2206|      0|        return nullptr;
 2207|      0|    }
 2208|  20.8k|    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, false);
 2209|  20.8k|    KeyOriginInfo info;
 2210|  20.8k|    if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
  ------------------
  |  Branch (2210:9): [True: 0, False: 20.8k]
  ------------------
 2211|      0|        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
 2212|      0|    }
 2213|  20.8k|    return key_provider;
 2214|  20.8k|}

_ZN10DescriptorD2Ev:
  109|   454k|    virtual ~Descriptor() = default;

_Z22CheckSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE19script_verify_flagsP13ScriptError_t:
  211|  35.5k|bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, script_verify_flags flags, ScriptError* serror) {
  212|       |    // Empty signature. Not strictly DER encoded, but allowed to provide a
  213|       |    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
  214|  35.5k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (214:9): [True: 0, False: 35.5k]
  ------------------
  215|      0|        return true;
  216|      0|    }
  217|  35.5k|    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
  ------------------
  |  Branch (217:9): [True: 35.5k, False: 0]
  |  Branch (217:9): [True: 31.2k, False: 4.30k]
  |  Branch (217:98): [True: 31.2k, False: 4.30k]
  ------------------
  218|  31.2k|        return set_error(serror, SCRIPT_ERR_SIG_DER);
  219|  31.2k|    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
  ------------------
  |  Branch (219:16): [True: 0, False: 4.30k]
  |  Branch (219:16): [True: 0, False: 4.30k]
  |  Branch (219:54): [True: 0, False: 0]
  ------------------
  220|       |        // serror is set
  221|      0|        return false;
  222|  4.30k|    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
  ------------------
  |  Branch (222:16): [True: 4.30k, False: 0]
  |  Branch (222:16): [True: 1.61k, False: 2.69k]
  |  Branch (222:58): [True: 1.61k, False: 2.69k]
  ------------------
  223|  1.61k|        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
  224|  1.61k|    }
  225|  2.69k|    return true;
  226|  35.5k|}
interpreter.cpp:_ZL24IsValidSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  118|  35.5k|bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
  119|       |    // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
  120|       |    // * total-length: 1-byte length descriptor of everything that follows,
  121|       |    //   excluding the sighash byte.
  122|       |    // * R-length: 1-byte length descriptor of the R value that follows.
  123|       |    // * R: arbitrary-length big-endian encoded R value. It must use the shortest
  124|       |    //   possible encoding for a positive integer (which means no null bytes at
  125|       |    //   the start, except a single one when the next byte has its highest bit set).
  126|       |    // * S-length: 1-byte length descriptor of the S value that follows.
  127|       |    // * S: arbitrary-length big-endian encoded S value. The same rules apply.
  128|       |    // * sighash: 1-byte value indicating what data is hashed (not part of the DER
  129|       |    //   signature)
  130|       |
  131|       |    // Minimum and maximum size constraints.
  132|  35.5k|    if (sig.size() < 9) return false;
  ------------------
  |  Branch (132:9): [True: 3.62k, False: 31.9k]
  ------------------
  133|  31.9k|    if (sig.size() > 73) return false;
  ------------------
  |  Branch (133:9): [True: 862, False: 31.0k]
  ------------------
  134|       |
  135|       |    // A signature is of type 0x30 (compound).
  136|  31.0k|    if (sig[0] != 0x30) return false;
  ------------------
  |  Branch (136:9): [True: 21.8k, False: 9.20k]
  ------------------
  137|       |
  138|       |    // Make sure the length covers the entire signature.
  139|  9.20k|    if (sig[1] != sig.size() - 3) return false;
  ------------------
  |  Branch (139:9): [True: 1.05k, False: 8.15k]
  ------------------
  140|       |
  141|       |    // Extract the length of the R element.
  142|  8.15k|    unsigned int lenR = sig[3];
  143|       |
  144|       |    // Make sure the length of the S element is still inside the signature.
  145|  8.15k|    if (5 + lenR >= sig.size()) return false;
  ------------------
  |  Branch (145:9): [True: 540, False: 7.61k]
  ------------------
  146|       |
  147|       |    // Extract the length of the S element.
  148|  7.61k|    unsigned int lenS = sig[5 + lenR];
  149|       |
  150|       |    // Verify that the length of the signature matches the sum of the length
  151|       |    // of the elements.
  152|  7.61k|    if ((size_t)(lenR + lenS + 7) != sig.size()) return false;
  ------------------
  |  Branch (152:9): [True: 646, False: 6.97k]
  ------------------
  153|       |
  154|       |    // Check whether the R element is an integer.
  155|  6.97k|    if (sig[2] != 0x02) return false;
  ------------------
  |  Branch (155:9): [True: 268, False: 6.70k]
  ------------------
  156|       |
  157|       |    // Zero-length integers are not allowed for R.
  158|  6.70k|    if (lenR == 0) return false;
  ------------------
  |  Branch (158:9): [True: 196, False: 6.50k]
  ------------------
  159|       |
  160|       |    // Negative numbers are not allowed for R.
  161|  6.50k|    if (sig[4] & 0x80) return false;
  ------------------
  |  Branch (161:9): [True: 240, False: 6.26k]
  ------------------
  162|       |
  163|       |    // Null bytes at the start of R are not allowed, unless R would
  164|       |    // otherwise be interpreted as a negative number.
  165|  6.26k|    if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) return false;
  ------------------
  |  Branch (165:9): [True: 4.15k, False: 2.10k]
  |  Branch (165:21): [True: 1.96k, False: 2.19k]
  |  Branch (165:41): [True: 586, False: 1.38k]
  ------------------
  166|       |
  167|       |    // Check whether the S element is an integer.
  168|  5.68k|    if (sig[lenR + 4] != 0x02) return false;
  ------------------
  |  Branch (168:9): [True: 254, False: 5.42k]
  ------------------
  169|       |
  170|       |    // Zero-length integers are not allowed for S.
  171|  5.42k|    if (lenS == 0) return false;
  ------------------
  |  Branch (171:9): [True: 306, False: 5.12k]
  ------------------
  172|       |
  173|       |    // Negative numbers are not allowed for S.
  174|  5.12k|    if (sig[lenR + 6] & 0x80) return false;
  ------------------
  |  Branch (174:9): [True: 244, False: 4.87k]
  ------------------
  175|       |
  176|       |    // Null bytes at the start of S are not allowed, unless S would otherwise be
  177|       |    // interpreted as a negative number.
  178|  4.87k|    if (lenS > 1 && (sig[lenR + 6] == 0x00) && !(sig[lenR + 7] & 0x80)) return false;
  ------------------
  |  Branch (178:9): [True: 3.46k, False: 1.41k]
  |  Branch (178:21): [True: 956, False: 2.50k]
  |  Branch (178:48): [True: 568, False: 388]
  ------------------
  179|       |
  180|  4.30k|    return true;
  181|  4.87k|}
interpreter.cpp:_ZN12_GLOBAL__N_19set_errorEP13ScriptError_tS0_:
   38|  32.8k|{
   39|  32.8k|    if (ret)
  ------------------
  |  Branch (39:9): [True: 0, False: 32.8k]
  ------------------
   40|      0|        *ret = serror;
   41|  32.8k|    return false;
   42|  32.8k|}
interpreter.cpp:_ZL26IsDefinedHashtypeSignatureRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  200|  4.30k|bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
  201|  4.30k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (201:9): [True: 0, False: 4.30k]
  ------------------
  202|      0|        return false;
  203|      0|    }
  204|  4.30k|    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
  205|  4.30k|    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
  ------------------
  |  Branch (205:9): [True: 1.00k, False: 3.30k]
  |  Branch (205:36): [True: 602, False: 2.69k]
  ------------------
  206|  1.61k|        return false;
  207|       |
  208|  2.69k|    return true;
  209|  4.30k|}

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

_Z9GetOpName10opcodetype:
   20|  2.75M|{
   21|  2.75M|    switch (opcode)
  ------------------
  |  Branch (21:13): [True: 2.56M, False: 193k]
  ------------------
   22|  2.75M|    {
   23|       |    // push value
   24|      0|    case OP_0                      : return "0";
  ------------------
  |  Branch (24:5): [True: 0, False: 2.75M]
  ------------------
   25|      0|    case OP_PUSHDATA1              : return "OP_PUSHDATA1";
  ------------------
  |  Branch (25:5): [True: 0, False: 2.75M]
  ------------------
   26|      0|    case OP_PUSHDATA2              : return "OP_PUSHDATA2";
  ------------------
  |  Branch (26:5): [True: 0, False: 2.75M]
  ------------------
   27|      0|    case OP_PUSHDATA4              : return "OP_PUSHDATA4";
  ------------------
  |  Branch (27:5): [True: 0, False: 2.75M]
  ------------------
   28|  6.29k|    case OP_1NEGATE                : return "-1";
  ------------------
  |  Branch (28:5): [True: 6.29k, False: 2.75M]
  ------------------
   29|  11.6k|    case OP_RESERVED               : return "OP_RESERVED";
  ------------------
  |  Branch (29:5): [True: 11.6k, False: 2.74M]
  ------------------
   30|  30.1k|    case OP_1                      : return "1";
  ------------------
  |  Branch (30:5): [True: 30.1k, False: 2.72M]
  ------------------
   31|  28.5k|    case OP_2                      : return "2";
  ------------------
  |  Branch (31:5): [True: 28.5k, False: 2.72M]
  ------------------
   32|  7.16k|    case OP_3                      : return "3";
  ------------------
  |  Branch (32:5): [True: 7.16k, False: 2.75M]
  ------------------
   33|  6.00k|    case OP_4                      : return "4";
  ------------------
  |  Branch (33:5): [True: 6.00k, False: 2.75M]
  ------------------
   34|  6.55k|    case OP_5                      : return "5";
  ------------------
  |  Branch (34:5): [True: 6.55k, False: 2.75M]
  ------------------
   35|  3.02k|    case OP_6                      : return "6";
  ------------------
  |  Branch (35:5): [True: 3.02k, False: 2.75M]
  ------------------
   36|  5.04k|    case OP_7                      : return "7";
  ------------------
  |  Branch (36:5): [True: 5.04k, False: 2.75M]
  ------------------
   37|   745k|    case OP_8                      : return "8";
  ------------------
  |  Branch (37:5): [True: 745k, False: 2.01M]
  ------------------
   38|  2.37k|    case OP_9                      : return "9";
  ------------------
  |  Branch (38:5): [True: 2.37k, False: 2.75M]
  ------------------
   39|  3.85k|    case OP_10                     : return "10";
  ------------------
  |  Branch (39:5): [True: 3.85k, False: 2.75M]
  ------------------
   40|  6.61k|    case OP_11                     : return "11";
  ------------------
  |  Branch (40:5): [True: 6.61k, False: 2.75M]
  ------------------
   41|  5.47k|    case OP_12                     : return "12";
  ------------------
  |  Branch (41:5): [True: 5.47k, False: 2.75M]
  ------------------
   42|  12.1k|    case OP_13                     : return "13";
  ------------------
  |  Branch (42:5): [True: 12.1k, False: 2.74M]
  ------------------
   43|  3.49k|    case OP_14                     : return "14";
  ------------------
  |  Branch (43:5): [True: 3.49k, False: 2.75M]
  ------------------
   44|  4.95k|    case OP_15                     : return "15";
  ------------------
  |  Branch (44:5): [True: 4.95k, False: 2.75M]
  ------------------
   45|  3.45k|    case OP_16                     : return "16";
  ------------------
  |  Branch (45:5): [True: 3.45k, False: 2.75M]
  ------------------
   46|       |
   47|       |    // control
   48|   673k|    case OP_NOP                    : return "OP_NOP";
  ------------------
  |  Branch (48:5): [True: 673k, False: 2.08M]
  ------------------
   49|  2.61k|    case OP_VER                    : return "OP_VER";
  ------------------
  |  Branch (49:5): [True: 2.61k, False: 2.75M]
  ------------------
   50|  2.64k|    case OP_IF                     : return "OP_IF";
  ------------------
  |  Branch (50:5): [True: 2.64k, False: 2.75M]
  ------------------
   51|  2.05k|    case OP_NOTIF                  : return "OP_NOTIF";
  ------------------
  |  Branch (51:5): [True: 2.05k, False: 2.75M]
  ------------------
   52|  2.88k|    case OP_VERIF                  : return "OP_VERIF";
  ------------------
  |  Branch (52:5): [True: 2.88k, False: 2.75M]
  ------------------
   53|  6.66k|    case OP_VERNOTIF               : return "OP_VERNOTIF";
  ------------------
  |  Branch (53:5): [True: 6.66k, False: 2.75M]
  ------------------
   54|  2.42k|    case OP_ELSE                   : return "OP_ELSE";
  ------------------
  |  Branch (54:5): [True: 2.42k, False: 2.75M]
  ------------------
   55|  3.64k|    case OP_ENDIF                  : return "OP_ENDIF";
  ------------------
  |  Branch (55:5): [True: 3.64k, False: 2.75M]
  ------------------
   56|  2.49k|    case OP_VERIFY                 : return "OP_VERIFY";
  ------------------
  |  Branch (56:5): [True: 2.49k, False: 2.75M]
  ------------------
   57|  25.3k|    case OP_RETURN                 : return "OP_RETURN";
  ------------------
  |  Branch (57:5): [True: 25.3k, False: 2.73M]
  ------------------
   58|       |
   59|       |    // stack ops
   60|  2.56k|    case OP_TOALTSTACK             : return "OP_TOALTSTACK";
  ------------------
  |  Branch (60:5): [True: 2.56k, False: 2.75M]
  ------------------
   61|  2.11k|    case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
  ------------------
  |  Branch (61:5): [True: 2.11k, False: 2.75M]
  ------------------
   62|  3.24k|    case OP_2DROP                  : return "OP_2DROP";
  ------------------
  |  Branch (62:5): [True: 3.24k, False: 2.75M]
  ------------------
   63|  2.46k|    case OP_2DUP                   : return "OP_2DUP";
  ------------------
  |  Branch (63:5): [True: 2.46k, False: 2.75M]
  ------------------
   64|  4.95k|    case OP_3DUP                   : return "OP_3DUP";
  ------------------
  |  Branch (64:5): [True: 4.95k, False: 2.75M]
  ------------------
   65|  2.78k|    case OP_2OVER                  : return "OP_2OVER";
  ------------------
  |  Branch (65:5): [True: 2.78k, False: 2.75M]
  ------------------
   66|  2.44k|    case OP_2ROT                   : return "OP_2ROT";
  ------------------
  |  Branch (66:5): [True: 2.44k, False: 2.75M]
  ------------------
   67|  6.49k|    case OP_2SWAP                  : return "OP_2SWAP";
  ------------------
  |  Branch (67:5): [True: 6.49k, False: 2.75M]
  ------------------
   68|  3.61k|    case OP_IFDUP                  : return "OP_IFDUP";
  ------------------
  |  Branch (68:5): [True: 3.61k, False: 2.75M]
  ------------------
   69|  3.12k|    case OP_DEPTH                  : return "OP_DEPTH";
  ------------------
  |  Branch (69:5): [True: 3.12k, False: 2.75M]
  ------------------
   70|  2.87k|    case OP_DROP                   : return "OP_DROP";
  ------------------
  |  Branch (70:5): [True: 2.87k, False: 2.75M]
  ------------------
   71|  9.63k|    case OP_DUP                    : return "OP_DUP";
  ------------------
  |  Branch (71:5): [True: 9.63k, False: 2.74M]
  ------------------
   72|  2.56k|    case OP_NIP                    : return "OP_NIP";
  ------------------
  |  Branch (72:5): [True: 2.56k, False: 2.75M]
  ------------------
   73|  3.42k|    case OP_OVER                   : return "OP_OVER";
  ------------------
  |  Branch (73:5): [True: 3.42k, False: 2.75M]
  ------------------
   74|  2.72k|    case OP_PICK                   : return "OP_PICK";
  ------------------
  |  Branch (74:5): [True: 2.72k, False: 2.75M]
  ------------------
   75|  2.48k|    case OP_ROLL                   : return "OP_ROLL";
  ------------------
  |  Branch (75:5): [True: 2.48k, False: 2.75M]
  ------------------
   76|  14.0k|    case OP_ROT                    : return "OP_ROT";
  ------------------
  |  Branch (76:5): [True: 14.0k, False: 2.74M]
  ------------------
   77|   114k|    case OP_SWAP                   : return "OP_SWAP";
  ------------------
  |  Branch (77:5): [True: 114k, False: 2.64M]
  ------------------
   78|  3.50k|    case OP_TUCK                   : return "OP_TUCK";
  ------------------
  |  Branch (78:5): [True: 3.50k, False: 2.75M]
  ------------------
   79|       |
   80|       |    // splice ops
   81|  2.89k|    case OP_CAT                    : return "OP_CAT";
  ------------------
  |  Branch (81:5): [True: 2.89k, False: 2.75M]
  ------------------
   82|  6.51k|    case OP_SUBSTR                 : return "OP_SUBSTR";
  ------------------
  |  Branch (82:5): [True: 6.51k, False: 2.75M]
  ------------------
   83|  8.36k|    case OP_LEFT                   : return "OP_LEFT";
  ------------------
  |  Branch (83:5): [True: 8.36k, False: 2.74M]
  ------------------
   84|  81.2k|    case OP_RIGHT                  : return "OP_RIGHT";
  ------------------
  |  Branch (84:5): [True: 81.2k, False: 2.67M]
  ------------------
   85|  2.20k|    case OP_SIZE                   : return "OP_SIZE";
  ------------------
  |  Branch (85:5): [True: 2.20k, False: 2.75M]
  ------------------
   86|       |
   87|       |    // bit logic
   88|  5.97k|    case OP_INVERT                 : return "OP_INVERT";
  ------------------
  |  Branch (88:5): [True: 5.97k, False: 2.75M]
  ------------------
   89|  4.35k|    case OP_AND                    : return "OP_AND";
  ------------------
  |  Branch (89:5): [True: 4.35k, False: 2.75M]
  ------------------
   90|  5.91k|    case OP_OR                     : return "OP_OR";
  ------------------
  |  Branch (90:5): [True: 5.91k, False: 2.75M]
  ------------------
   91|  3.69k|    case OP_XOR                    : return "OP_XOR";
  ------------------
  |  Branch (91:5): [True: 3.69k, False: 2.75M]
  ------------------
   92|  28.1k|    case OP_EQUAL                  : return "OP_EQUAL";
  ------------------
  |  Branch (92:5): [True: 28.1k, False: 2.72M]
  ------------------
   93|  9.12k|    case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
  ------------------
  |  Branch (93:5): [True: 9.12k, False: 2.74M]
  ------------------
   94|  5.19k|    case OP_RESERVED1              : return "OP_RESERVED1";
  ------------------
  |  Branch (94:5): [True: 5.19k, False: 2.75M]
  ------------------
   95|  5.79k|    case OP_RESERVED2              : return "OP_RESERVED2";
  ------------------
  |  Branch (95:5): [True: 5.79k, False: 2.75M]
  ------------------
   96|       |
   97|       |    // numeric
   98|  2.92k|    case OP_1ADD                   : return "OP_1ADD";
  ------------------
  |  Branch (98:5): [True: 2.92k, False: 2.75M]
  ------------------
   99|  2.37k|    case OP_1SUB                   : return "OP_1SUB";
  ------------------
  |  Branch (99:5): [True: 2.37k, False: 2.75M]
  ------------------
  100|  3.32k|    case OP_2MUL                   : return "OP_2MUL";
  ------------------
  |  Branch (100:5): [True: 3.32k, False: 2.75M]
  ------------------
  101|  1.92k|    case OP_2DIV                   : return "OP_2DIV";
  ------------------
  |  Branch (101:5): [True: 1.92k, False: 2.75M]
  ------------------
  102|  2.63k|    case OP_NEGATE                 : return "OP_NEGATE";
  ------------------
  |  Branch (102:5): [True: 2.63k, False: 2.75M]
  ------------------
  103|  2.21k|    case OP_ABS                    : return "OP_ABS";
  ------------------
  |  Branch (103:5): [True: 2.21k, False: 2.75M]
  ------------------
  104|  4.47k|    case OP_NOT                    : return "OP_NOT";
  ------------------
  |  Branch (104:5): [True: 4.47k, False: 2.75M]
  ------------------
  105|  3.83k|    case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
  ------------------
  |  Branch (105:5): [True: 3.83k, False: 2.75M]
  ------------------
  106|  4.31k|    case OP_ADD                    : return "OP_ADD";
  ------------------
  |  Branch (106:5): [True: 4.31k, False: 2.75M]
  ------------------
  107|  2.51k|    case OP_SUB                    : return "OP_SUB";
  ------------------
  |  Branch (107:5): [True: 2.51k, False: 2.75M]
  ------------------
  108|  21.8k|    case OP_MUL                    : return "OP_MUL";
  ------------------
  |  Branch (108:5): [True: 21.8k, False: 2.73M]
  ------------------
  109|  12.8k|    case OP_DIV                    : return "OP_DIV";
  ------------------
  |  Branch (109:5): [True: 12.8k, False: 2.74M]
  ------------------
  110|  3.00k|    case OP_MOD                    : return "OP_MOD";
  ------------------
  |  Branch (110:5): [True: 3.00k, False: 2.75M]
  ------------------
  111|  8.21k|    case OP_LSHIFT                 : return "OP_LSHIFT";
  ------------------
  |  Branch (111:5): [True: 8.21k, False: 2.74M]
  ------------------
  112|  4.86k|    case OP_RSHIFT                 : return "OP_RSHIFT";
  ------------------
  |  Branch (112:5): [True: 4.86k, False: 2.75M]
  ------------------
  113|  1.92k|    case OP_BOOLAND                : return "OP_BOOLAND";
  ------------------
  |  Branch (113:5): [True: 1.92k, False: 2.75M]
  ------------------
  114|  3.69k|    case OP_BOOLOR                 : return "OP_BOOLOR";
  ------------------
  |  Branch (114:5): [True: 3.69k, False: 2.75M]
  ------------------
  115|  10.9k|    case OP_NUMEQUAL               : return "OP_NUMEQUAL";
  ------------------
  |  Branch (115:5): [True: 10.9k, False: 2.74M]
  ------------------
  116|  4.09k|    case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
  ------------------
  |  Branch (116:5): [True: 4.09k, False: 2.75M]
  ------------------
  117|  2.97k|    case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
  ------------------
  |  Branch (117:5): [True: 2.97k, False: 2.75M]
  ------------------
  118|  2.27k|    case OP_LESSTHAN               : return "OP_LESSTHAN";
  ------------------
  |  Branch (118:5): [True: 2.27k, False: 2.75M]
  ------------------
  119|  2.92k|    case OP_GREATERTHAN            : return "OP_GREATERTHAN";
  ------------------
  |  Branch (119:5): [True: 2.92k, False: 2.75M]
  ------------------
  120|  2.93k|    case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
  ------------------
  |  Branch (120:5): [True: 2.93k, False: 2.75M]
  ------------------
  121|  1.96k|    case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
  ------------------
  |  Branch (121:5): [True: 1.96k, False: 2.75M]
  ------------------
  122|  2.73k|    case OP_MIN                    : return "OP_MIN";
  ------------------
  |  Branch (122:5): [True: 2.73k, False: 2.75M]
  ------------------
  123|  8.54k|    case OP_MAX                    : return "OP_MAX";
  ------------------
  |  Branch (123:5): [True: 8.54k, False: 2.74M]
  ------------------
  124|  3.99k|    case OP_WITHIN                 : return "OP_WITHIN";
  ------------------
  |  Branch (124:5): [True: 3.99k, False: 2.75M]
  ------------------
  125|       |
  126|       |    // crypto
  127|  2.78k|    case OP_RIPEMD160              : return "OP_RIPEMD160";
  ------------------
  |  Branch (127:5): [True: 2.78k, False: 2.75M]
  ------------------
  128|  5.83k|    case OP_SHA1                   : return "OP_SHA1";
  ------------------
  |  Branch (128:5): [True: 5.83k, False: 2.75M]
  ------------------
  129|  3.73k|    case OP_SHA256                 : return "OP_SHA256";
  ------------------
  |  Branch (129:5): [True: 3.73k, False: 2.75M]
  ------------------
  130|  34.4k|    case OP_HASH160                : return "OP_HASH160";
  ------------------
  |  Branch (130:5): [True: 34.4k, False: 2.72M]
  ------------------
  131|  2.99k|    case OP_HASH256                : return "OP_HASH256";
  ------------------
  |  Branch (131:5): [True: 2.99k, False: 2.75M]
  ------------------
  132|  3.44k|    case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
  ------------------
  |  Branch (132:5): [True: 3.44k, False: 2.75M]
  ------------------
  133|  62.1k|    case OP_CHECKSIG               : return "OP_CHECKSIG";
  ------------------
  |  Branch (133:5): [True: 62.1k, False: 2.69M]
  ------------------
  134|  3.99k|    case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
  ------------------
  |  Branch (134:5): [True: 3.99k, False: 2.75M]
  ------------------
  135|   241k|    case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
  ------------------
  |  Branch (135:5): [True: 241k, False: 2.51M]
  ------------------
  136|  16.0k|    case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  ------------------
  |  Branch (136:5): [True: 16.0k, False: 2.74M]
  ------------------
  137|       |
  138|       |    // expansion
  139|  5.57k|    case OP_NOP1                   : return "OP_NOP1";
  ------------------
  |  Branch (139:5): [True: 5.57k, False: 2.75M]
  ------------------
  140|  2.77k|    case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
  ------------------
  |  Branch (140:5): [True: 2.77k, False: 2.75M]
  ------------------
  141|  2.14k|    case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
  ------------------
  |  Branch (141:5): [True: 2.14k, False: 2.75M]
  ------------------
  142|  3.76k|    case OP_NOP4                   : return "OP_NOP4";
  ------------------
  |  Branch (142:5): [True: 3.76k, False: 2.75M]
  ------------------
  143|  3.87k|    case OP_NOP5                   : return "OP_NOP5";
  ------------------
  |  Branch (143:5): [True: 3.87k, False: 2.75M]
  ------------------
  144|  8.00k|    case OP_NOP6                   : return "OP_NOP6";
  ------------------
  |  Branch (144:5): [True: 8.00k, False: 2.74M]
  ------------------
  145|  4.51k|    case OP_NOP7                   : return "OP_NOP7";
  ------------------
  |  Branch (145:5): [True: 4.51k, False: 2.75M]
  ------------------
  146|  4.89k|    case OP_NOP8                   : return "OP_NOP8";
  ------------------
  |  Branch (146:5): [True: 4.89k, False: 2.75M]
  ------------------
  147|  3.15k|    case OP_NOP9                   : return "OP_NOP9";
  ------------------
  |  Branch (147:5): [True: 3.15k, False: 2.75M]
  ------------------
  148|  4.28k|    case OP_NOP10                  : return "OP_NOP10";
  ------------------
  |  Branch (148:5): [True: 4.28k, False: 2.75M]
  ------------------
  149|       |
  150|       |    // Opcode added by BIP 342 (Tapscript)
  151|  4.92k|    case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
  ------------------
  |  Branch (151:5): [True: 4.92k, False: 2.75M]
  ------------------
  152|       |
  153|  33.1k|    case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
  ------------------
  |  Branch (153:5): [True: 33.1k, False: 2.72M]
  ------------------
  154|       |
  155|  2.75M|    } // no default case, so the compiler can warn about missing cases
  156|   193k|    return "OP_UNKNOWN";
  157|  2.75M|}
_ZNK7CScript13GetSigOpCountEb:
  160|   901k|{
  161|   901k|    unsigned int n = 0;
  162|   901k|    const_iterator pc = begin();
  163|   901k|    opcodetype lastOpcode = OP_INVALIDOPCODE;
  164|  9.74M|    while (pc < end())
  ------------------
  |  Branch (164:12): [True: 8.99M, False: 743k]
  ------------------
  165|  8.99M|    {
  166|  8.99M|        opcodetype opcode;
  167|  8.99M|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (167:13): [True: 157k, False: 8.84M]
  ------------------
  168|   157k|            break;
  169|  8.84M|        if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
  ------------------
  |  Branch (169:13): [True: 54.8k, False: 8.78M]
  |  Branch (169:38): [True: 3.16k, False: 8.78M]
  ------------------
  170|  57.9k|            n++;
  171|  8.78M|        else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
  ------------------
  |  Branch (171:18): [True: 153k, False: 8.62M]
  |  Branch (171:48): [True: 11.6k, False: 8.61M]
  ------------------
  172|   164k|        {
  173|   164k|            if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
  ------------------
  |  Branch (173:17): [True: 10.0k, False: 154k]
  |  Branch (173:30): [True: 9.17k, False: 885]
  |  Branch (173:52): [True: 1.36k, False: 7.81k]
  ------------------
  174|  1.36k|                n += DecodeOP_N(lastOpcode);
  175|   163k|            else
  176|   163k|                n += MAX_PUBKEYS_PER_MULTISIG;
  177|   164k|        }
  178|  8.84M|        lastOpcode = opcode;
  179|  8.84M|    }
  180|   901k|    return n;
  181|   901k|}
_ZNK7CScript13GetSigOpCountERKS_:
  184|  91.5k|{
  185|  91.5k|    if (!IsPayToScriptHash())
  ------------------
  |  Branch (185:9): [True: 91.5k, False: 0]
  ------------------
  186|  91.5k|        return GetSigOpCount(true);
  187|       |
  188|       |    // This is a pay-to-script-hash scriptPubKey;
  189|       |    // get the last item that the scriptSig
  190|       |    // pushes onto the stack:
  191|      0|    const_iterator pc = scriptSig.begin();
  192|      0|    std::vector<unsigned char> vData;
  193|      0|    while (pc < scriptSig.end())
  ------------------
  |  Branch (193:12): [True: 0, False: 0]
  ------------------
  194|      0|    {
  195|      0|        opcodetype opcode;
  196|      0|        if (!scriptSig.GetOp(pc, opcode, vData))
  ------------------
  |  Branch (196:13): [True: 0, False: 0]
  ------------------
  197|      0|            return 0;
  198|      0|        if (opcode > OP_16)
  ------------------
  |  Branch (198:13): [True: 0, False: 0]
  ------------------
  199|      0|            return 0;
  200|      0|    }
  201|       |
  202|       |    /// ... and return its opcount:
  203|      0|    CScript subscript(vData.begin(), vData.end());
  204|      0|    return subscript.GetSigOpCount(true);
  205|      0|}
_ZNK7CScript13IsPayToAnchorEv:
  208|  36.6k|{
  209|  36.6k|    return (this->size() == 4 &&
  ------------------
  |  Branch (209:13): [True: 29.1k, False: 7.45k]
  ------------------
  210|  29.1k|        (*this)[0] == OP_1 &&
  ------------------
  |  Branch (210:9): [True: 4.52k, False: 24.6k]
  ------------------
  211|  4.52k|        (*this)[1] == 0x02 &&
  ------------------
  |  Branch (211:9): [True: 4.52k, False: 0]
  ------------------
  212|  4.52k|        (*this)[2] == 0x4e &&
  ------------------
  |  Branch (212:9): [True: 3.83k, False: 689]
  ------------------
  213|  3.83k|        (*this)[3] == 0x73);
  ------------------
  |  Branch (213:9): [True: 3.31k, False: 514]
  ------------------
  214|  36.6k|}
_ZN7CScript13IsPayToAnchorEiRKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  217|  1.58k|{
  218|  1.58k|    return version == 1 &&
  ------------------
  |  Branch (218:12): [True: 1.58k, False: 0]
  ------------------
  219|  1.58k|        program.size() == 2 &&
  ------------------
  |  Branch (219:9): [True: 1.58k, False: 0]
  ------------------
  220|  1.58k|        program[0] == 0x4e &&
  ------------------
  |  Branch (220:9): [True: 1.58k, False: 0]
  ------------------
  221|  1.58k|        program[1] == 0x73;
  ------------------
  |  Branch (221:9): [True: 1.58k, False: 0]
  ------------------
  222|  1.58k|}
_ZNK7CScript17IsPayToScriptHashEv:
  225|  1.91M|{
  226|       |    // Extra-fast test for pay-to-script-hash CScripts:
  227|  1.91M|    return (this->size() == 23 &&
  ------------------
  |  Branch (227:13): [True: 99.6k, False: 1.81M]
  ------------------
  228|  99.6k|            (*this)[0] == OP_HASH160 &&
  ------------------
  |  Branch (228:13): [True: 96.5k, False: 3.06k]
  ------------------
  229|  96.5k|            (*this)[1] == 0x14 &&
  ------------------
  |  Branch (229:13): [True: 94.9k, False: 1.61k]
  ------------------
  230|  94.9k|            (*this)[22] == OP_EQUAL);
  ------------------
  |  Branch (230:13): [True: 90.9k, False: 4.07k]
  ------------------
  231|  1.91M|}
_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  251|  1.73M|{
  252|  1.73M|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (252:9): [True: 1.20M, False: 532k]
  |  Branch (252:29): [True: 192k, False: 339k]
  ------------------
  253|  1.39M|        return false;
  254|  1.39M|    }
  255|   339k|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (255:9): [True: 219k, False: 119k]
  |  Branch (255:32): [True: 97.0k, False: 122k]
  |  Branch (255:53): [True: 65.2k, False: 57.1k]
  ------------------
  256|   162k|        return false;
  257|   162k|    }
  258|   177k|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (258:9): [True: 162k, False: 14.5k]
  ------------------
  259|   162k|        version = DecodeOP_N((opcodetype)(*this)[0]);
  260|   162k|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  261|   162k|        return true;
  262|   162k|    }
  263|  14.5k|    return false;
  264|   177k|}
_ZNK7CScript10IsPushOnlyEN9prevectorILj36EhjiE14const_iteratorE:
  267|  33.1k|{
  268|  1.35M|    while (pc < end())
  ------------------
  |  Branch (268:12): [True: 1.33M, False: 24.3k]
  ------------------
  269|  1.33M|    {
  270|  1.33M|        opcodetype opcode;
  271|  1.33M|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (271:13): [True: 5.46k, False: 1.32M]
  ------------------
  272|  5.46k|            return false;
  273|       |        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
  274|       |        // push-type opcode, however execution of OP_RESERVED fails, so
  275|       |        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
  276|       |        // the P2SH special validation code being executed.
  277|  1.32M|        if (opcode > OP_16)
  ------------------
  |  Branch (277:13): [True: 3.36k, False: 1.32M]
  ------------------
  278|  3.36k|            return false;
  279|  1.32M|    }
  280|  24.3k|    return true;
  281|  33.1k|}
_ZNK7CScript10IsPushOnlyEv:
  284|  18.1k|{
  285|  18.1k|    return this->IsPushOnly(begin());
  286|  18.1k|}
_ZNK14CScriptWitness8ToStringEv:
  289|  93.2k|{
  290|  93.2k|    std::string ret = "CScriptWitness(";
  291|  5.66M|    for (unsigned int i = 0; i < stack.size(); i++) {
  ------------------
  |  Branch (291:30): [True: 5.56M, False: 93.2k]
  ------------------
  292|  5.56M|        if (i) {
  ------------------
  |  Branch (292:13): [True: 5.56M, False: 5.00k]
  ------------------
  293|  5.56M|            ret += ", ";
  294|  5.56M|        }
  295|  5.56M|        ret += HexStr(stack[i]);
  296|  5.56M|    }
  297|  93.2k|    return ret + ")";
  298|  93.2k|}
_Z11GetScriptOpRN9prevectorILj36EhjiE14const_iteratorES1_R10opcodetypePNSt3__16vectorIhNS5_9allocatorIhEEEE:
  314|  16.7M|{
  315|  16.7M|    opcodeRet = OP_INVALIDOPCODE;
  316|  16.7M|    if (pvchRet)
  ------------------
  |  Branch (316:9): [True: 6.42M, False: 10.3M]
  ------------------
  317|  6.42M|        pvchRet->clear();
  318|  16.7M|    if (pc >= end)
  ------------------
  |  Branch (318:9): [True: 184, False: 16.7M]
  ------------------
  319|    184|        return false;
  320|       |
  321|       |    // Read instruction
  322|  16.7M|    if (end - pc < 1)
  ------------------
  |  Branch (322:9): [True: 0, False: 16.7M]
  ------------------
  323|      0|        return false;
  324|  16.7M|    unsigned int opcode = *pc++;
  325|       |
  326|       |    // Immediate operand
  327|  16.7M|    if (opcode <= OP_PUSHDATA4)
  ------------------
  |  Branch (327:9): [True: 11.2M, False: 5.49M]
  ------------------
  328|  11.2M|    {
  329|  11.2M|        unsigned int nSize = 0;
  330|  11.2M|        if (opcode < OP_PUSHDATA1)
  ------------------
  |  Branch (330:13): [True: 11.2M, False: 40.7k]
  ------------------
  331|  11.2M|        {
  332|  11.2M|            nSize = opcode;
  333|  11.2M|        }
  334|  40.7k|        else if (opcode == OP_PUSHDATA1)
  ------------------
  |  Branch (334:18): [True: 11.5k, False: 29.2k]
  ------------------
  335|  11.5k|        {
  336|  11.5k|            if (end - pc < 1)
  ------------------
  |  Branch (336:17): [True: 1.37k, False: 10.1k]
  ------------------
  337|  1.37k|                return false;
  338|  10.1k|            nSize = *pc++;
  339|  10.1k|        }
  340|  29.2k|        else if (opcode == OP_PUSHDATA2)
  ------------------
  |  Branch (340:18): [True: 21.3k, False: 7.87k]
  ------------------
  341|  21.3k|        {
  342|  21.3k|            if (end - pc < 2)
  ------------------
  |  Branch (342:17): [True: 5.73k, False: 15.6k]
  ------------------
  343|  5.73k|                return false;
  344|  15.6k|            nSize = ReadLE16(&pc[0]);
  345|  15.6k|            pc += 2;
  346|  15.6k|        }
  347|  7.87k|        else if (opcode == OP_PUSHDATA4)
  ------------------
  |  Branch (347:18): [True: 7.87k, False: 0]
  ------------------
  348|  7.87k|        {
  349|  7.87k|            if (end - pc < 4)
  ------------------
  |  Branch (349:17): [True: 1.87k, False: 5.99k]
  ------------------
  350|  1.87k|                return false;
  351|  5.99k|            nSize = ReadLE32(&pc[0]);
  352|  5.99k|            pc += 4;
  353|  5.99k|        }
  354|  11.2M|        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  ------------------
  |  Branch (354:13): [True: 0, False: 11.2M]
  |  Branch (354:29): [True: 417k, False: 10.8M]
  ------------------
  355|   417k|            return false;
  356|  10.8M|        if (pvchRet)
  ------------------
  |  Branch (356:13): [True: 3.34M, False: 7.49M]
  ------------------
  357|  3.34M|            pvchRet->assign(pc, pc + nSize);
  358|  10.8M|        pc += nSize;
  359|  10.8M|    }
  360|       |
  361|  16.3M|    opcodeRet = static_cast<opcodetype>(opcode);
  362|  16.3M|    return true;
  363|  16.7M|}
_Z16CheckMinimalPushRKNSt3__16vectorIhNS_9allocatorIhEEEE10opcodetype:
  373|  14.9k|bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
  374|       |    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
  375|  14.9k|    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  ------------------
  |  Branch (375:5): [True: 14.9k, False: 0]
  |  Branch (375:5): [True: 14.9k, False: 0]
  |  Branch (375:5): [True: 14.9k, False: 0]
  ------------------
  376|  14.9k|    if (data.size() == 0) {
  ------------------
  |  Branch (376:9): [True: 392, False: 14.5k]
  ------------------
  377|       |        // Should have used OP_0.
  378|    392|        return opcode == OP_0;
  379|  14.5k|    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  ------------------
  |  Branch (379:16): [True: 4.32k, False: 10.1k]
  |  Branch (379:36): [True: 3.73k, False: 595]
  |  Branch (379:52): [True: 502, False: 3.23k]
  ------------------
  380|       |        // Should have used OP_1 .. OP_16.
  381|    502|        return false;
  382|  14.0k|    } else if (data.size() == 1 && data[0] == 0x81) {
  ------------------
  |  Branch (382:16): [True: 3.82k, False: 10.1k]
  |  Branch (382:36): [True: 72, False: 3.75k]
  ------------------
  383|       |        // Should have used OP_1NEGATE.
  384|     72|        return false;
  385|  13.9k|    } else if (data.size() <= 75) {
  ------------------
  |  Branch (385:16): [True: 13.4k, False: 470]
  ------------------
  386|       |        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
  387|  13.4k|        return opcode == data.size();
  388|  13.4k|    } else if (data.size() <= 255) {
  ------------------
  |  Branch (388:16): [True: 334, False: 136]
  ------------------
  389|       |        // Must have used OP_PUSHDATA.
  390|    334|        return opcode == OP_PUSHDATA1;
  391|    334|    } else if (data.size() <= 65535) {
  ------------------
  |  Branch (391:16): [True: 136, False: 0]
  ------------------
  392|       |        // Must have used OP_PUSHDATA2.
  393|    136|        return opcode == OP_PUSHDATA2;
  394|    136|    }
  395|      0|    return true;
  396|  14.9k|}

_Z12ToByteVectorI6PKHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|  5.95k|{
   70|  5.95k|    return std::vector<unsigned char>(in.begin(), in.end());
   71|  5.95k|}
_Z12ToByteVectorI10ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|  22.2k|{
   70|  22.2k|    return std::vector<unsigned char>(in.begin(), in.end());
   71|  22.2k|}
_Z12ToByteVectorI19WitnessV0ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|  11.7k|{
   70|  11.7k|    return std::vector<unsigned char>(in.begin(), in.end());
   71|  11.7k|}
_Z12ToByteVectorI16WitnessV0KeyHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|  13.7k|{
   70|  13.7k|    return std::vector<unsigned char>(in.begin(), in.end());
   71|  13.7k|}
_Z12ToByteVectorI16WitnessV1TaprootENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|  1.73k|{
   70|  1.73k|    return std::vector<unsigned char>(in.begin(), in.end());
   71|  1.73k|}
_ZN7CScript10EncodeOP_NEi:
  516|  8.58k|    {
  517|  8.58k|        assert(n >= 0 && n <= 16);
  ------------------
  |  Branch (517:9): [True: 8.58k, False: 0]
  |  Branch (517:9): [True: 8.58k, False: 0]
  |  Branch (517:9): [True: 8.58k, False: 0]
  ------------------
  518|  8.58k|        if (n == 0)
  ------------------
  |  Branch (518:13): [True: 0, False: 8.58k]
  ------------------
  519|      0|            return OP_0;
  520|  8.58k|        return (opcodetype)(OP_1+n-1);
  521|  8.58k|    }
_ZN9CScriptIDC2ERK7uint160:
  601|  34.0k|    explicit CScriptID(const uint160& in) : BaseHash(in) {}
_ZN7CScript16SerializationOpsI12ParamsStreamIR10SpanReader20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  456|  1.48M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|  1.48M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  456|  1.29M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|  1.29M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  456|  2.09k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|  2.09k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI10SpanReaderS_17ActionUnserializeEEvRT0_RT_T1_:
  456|  1.48M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|  1.48M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK7CScript13IsUnspendableEv:
  565|  73.0k|    {
  566|  73.0k|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (566:17): [True: 73.0k, False: 0]
  |  Branch (566:31): [True: 998, False: 72.0k]
  |  Branch (566:57): [True: 34.4k, False: 37.6k]
  ------------------
  567|  73.0k|    }
_ZN7CScript16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  456|  9.27M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|  9.27M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN14CScriptWitnessC2Ev:
  584|   731k|    CScriptWitness() = default;
_ZN7CScript16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  456|   927k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  148|   927k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK7CScript5GetOpERN9prevectorILj36EhjiE14const_iteratorER10opcodetypeRNSt3__16vectorIhNS6_9allocatorIhEEEE:
  498|  6.42M|    {
  499|  6.42M|        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
  500|  6.42M|    }
_ZNK7CScript5GetOpERN9prevectorILj36EhjiE14const_iteratorER10opcodetype:
  503|  10.3M|    {
  504|  10.3M|        return GetScriptOp(pc, end(), opcodeRet, nullptr);
  505|  10.3M|    }
_ZN7CScriptC2Ev:
  452|  4.06M|    CScript() = default;
_ZN10CScriptNumC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEEbm:
  248|  3.01M|    {
  249|  3.01M|        if (vch.size() > nMaxNumSize) {
  ------------------
  |  Branch (249:13): [True: 6.40k, False: 3.01M]
  ------------------
  250|  6.40k|            throw scriptnum_error("script number overflow");
  251|  6.40k|        }
  252|  3.01M|        if (fRequireMinimal && vch.size() > 0) {
  ------------------
  |  Branch (252:13): [True: 7.44k, False: 3.00M]
  |  Branch (252:32): [True: 7.44k, False: 0]
  ------------------
  253|       |            // Check that the number is encoded with the minimum possible
  254|       |            // number of bytes.
  255|       |            //
  256|       |            // If the most-significant-byte - excluding the sign bit - is zero
  257|       |            // then we're not minimal. Note how this test also rejects the
  258|       |            // negative-zero encoding, 0x80.
  259|  7.44k|            if ((vch.back() & 0x7f) == 0) {
  ------------------
  |  Branch (259:17): [True: 1.83k, False: 5.61k]
  ------------------
  260|       |                // One exception: if there's more than one byte and the most
  261|       |                // significant bit of the second-most-significant-byte is set
  262|       |                // it would conflict with the sign bit. An example of this case
  263|       |                // is +-255, which encode to 0xff00 and 0xff80 respectively.
  264|       |                // (big-endian).
  265|  1.83k|                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
  ------------------
  |  Branch (265:21): [True: 595, False: 1.24k]
  |  Branch (265:40): [True: 500, False: 742]
  ------------------
  266|  1.09k|                    throw scriptnum_error("non-minimally encoded script number");
  267|  1.09k|                }
  268|  1.83k|            }
  269|  7.44k|        }
  270|  3.01M|        m_value = set_vch(vch);
  271|  3.01M|    }
_ZN15scriptnum_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  224|  7.50k|    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
_ZN10CScriptNum7set_vchERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  377|  3.01M|    {
  378|  3.01M|      if (vch.empty())
  ------------------
  |  Branch (378:11): [True: 2.30M, False: 704k]
  ------------------
  379|  2.30M|          return 0;
  380|       |
  381|   704k|      int64_t result = 0;
  382|  1.51M|      for (size_t i = 0; i != vch.size(); ++i)
  ------------------
  |  Branch (382:26): [True: 805k, False: 704k]
  ------------------
  383|   805k|          result |= static_cast<int64_t>(vch[i]) << 8*i;
  384|       |
  385|       |      // If the input vector's most significant byte is 0x80, remove it from
  386|       |      // the result's msb and return a negative.
  387|   704k|      if (vch.back() & 0x80)
  ------------------
  |  Branch (387:11): [True: 14.1k, False: 690k]
  ------------------
  388|  14.1k|          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
  389|       |
  390|   690k|      return result;
  391|   704k|    }
_ZNK10CScriptNum6getintEv:
  327|  3.01M|    {
  328|  3.01M|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (328:13): [True: 0, False: 3.01M]
  ------------------
  329|      0|            return std::numeric_limits<int>::max();
  330|  3.01M|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (330:18): [True: 0, False: 3.01M]
  ------------------
  331|      0|            return std::numeric_limits<int>::min();
  332|  3.01M|        return m_value;
  333|  3.01M|    }
_ZN7CScriptlsENSt3__14spanIKhLm18446744073709551615EEE:
  493|  64.0k|    {
  494|  64.0k|        return *this << std::as_bytes(b);
  495|  64.0k|    }
_ZN7CScriptlsENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  485|  64.0k|    {
  486|  64.0k|        AppendDataSize(b.size());
  487|  64.0k|        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
  488|  64.0k|        return *this;
  489|  64.0k|    }
_ZN7CScript14AppendDataSizeEj:
  409|  64.0k|    {
  410|  64.0k|        if (size < OP_PUSHDATA1) {
  ------------------
  |  Branch (410:13): [True: 64.0k, False: 0]
  ------------------
  411|  64.0k|            insert(end(), static_cast<value_type>(size));
  412|  64.0k|        } else if (size <= 0xff) {
  ------------------
  |  Branch (412:20): [True: 0, False: 0]
  ------------------
  413|      0|            insert(end(), OP_PUSHDATA1);
  414|      0|            insert(end(), static_cast<value_type>(size));
  415|      0|        } else if (size <= 0xffff) {
  ------------------
  |  Branch (415:20): [True: 0, False: 0]
  ------------------
  416|      0|            insert(end(), OP_PUSHDATA2);
  417|      0|            value_type data[2];
  418|      0|            WriteLE16(data, size);
  419|      0|            insert(end(), std::cbegin(data), std::cend(data));
  420|      0|        } else {
  421|      0|            insert(end(), OP_PUSHDATA4);
  422|      0|            value_type data[4];
  423|      0|            WriteLE32(data, size);
  424|      0|            insert(end(), std::cbegin(data), std::cend(data));
  425|      0|        }
  426|  64.0k|    }
_ZN7CScript10AppendDataENSt3__14spanIKhLm18446744073709551615EEE:
  429|  64.0k|    {
  430|  64.0k|        insert(end(), data.begin(), data.end());
  431|  64.0k|    }
_ZNK14CScriptWitness6IsNullEv:
  586|   264k|    bool IsNull() const { return stack.empty(); }
_ZN7CScriptlsE10opcodetype:
  471|   104k|    {
  472|   104k|        if (opcode < 0 || opcode > 0xff)
  ------------------
  |  Branch (472:13): [True: 0, False: 104k]
  |  Branch (472:27): [True: 0, False: 104k]
  ------------------
  473|      0|            throw std::runtime_error("CScript::operator<<(): invalid opcode");
  474|   104k|        insert(end(), (unsigned char)opcode);
  475|   104k|        return *this;
  476|   104k|    }
_ZN7CScript5clearEv:
  570|  2.34M|    {
  571|       |        // The default prevector::clear() does not release memory
  572|  2.34M|        CScriptBase::clear();
  573|  2.34M|        shrink_to_fit();
  574|  2.34M|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  509|   212k|    {
  510|   212k|        if (opcode == OP_0)
  ------------------
  |  Branch (510:13): [True: 110k, False: 101k]
  ------------------
  511|   110k|            return 0;
  512|   212k|        assert(opcode >= OP_1 && opcode <= OP_16);
  ------------------
  |  Branch (512:9): [True: 101k, False: 0]
  |  Branch (512:9): [True: 101k, False: 0]
  |  Branch (512:9): [True: 101k, False: 0]
  ------------------
  513|   101k|        return (int)opcode - (int)(OP_1 - 1);
  514|   101k|    }

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

_ZNK15SigningProvider19GetKeyOriginByXOnlyERK11XOnlyPubKeyR13KeyOriginInfo:
  202|  2.80k|    {
  203|  5.60k|        for (const auto& id : pubkey.GetKeyIDs()) {
  ------------------
  |  Branch (203:29): [True: 5.60k, False: 2.80k]
  ------------------
  204|  5.60k|            if (GetKeyOrigin(id, info)) return true;
  ------------------
  |  Branch (204:17): [True: 0, False: 5.60k]
  ------------------
  205|  5.60k|        }
  206|  2.80k|        return false;
  207|  2.80k|    }
_ZN15SigningProviderD2Ev:
  170|      2|    virtual ~SigningProvider() = default;
_ZNK15SigningProvider10GetCScriptERK9CScriptIDR7CScript:
  171|  34.0k|    virtual bool GetCScript(const CScriptID &scriptid, CScript& script) const { return false; }
_ZNK15SigningProvider9GetPubKeyERK6CKeyIDR7CPubKey:
  173|  19.7k|    virtual bool GetPubKey(const CKeyID &address, CPubKey& pubkey) const { return false; }
_ZNK15SigningProvider12GetKeyOriginERK6CKeyIDR13KeyOriginInfo:
  176|  26.4k|    virtual bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const { return false; }
_ZNK15SigningProvider19GetTaprootSpendDataERK11XOnlyPubKeyR16TaprootSpendData:
  177|  4.53k|    virtual bool GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const { return false; }

_Z16GetTxnOutputType9TxoutType:
   19|   454k|{
   20|   454k|    switch (t) {
  ------------------
  |  Branch (20:13): [True: 454k, False: 0]
  ------------------
   21|   372k|    case TxoutType::NONSTANDARD: return "nonstandard";
  ------------------
  |  Branch (21:5): [True: 372k, False: 82.1k]
  ------------------
   22|  7.17k|    case TxoutType::PUBKEY: return "pubkey";
  ------------------
  |  Branch (22:5): [True: 7.17k, False: 447k]
  ------------------
   23|  5.95k|    case TxoutType::PUBKEYHASH: return "pubkeyhash";
  ------------------
  |  Branch (23:5): [True: 5.95k, False: 448k]
  ------------------
   24|  22.2k|    case TxoutType::SCRIPTHASH: return "scripthash";
  ------------------
  |  Branch (24:5): [True: 22.2k, False: 432k]
  ------------------
   25|  6.16k|    case TxoutType::MULTISIG: return "multisig";
  ------------------
  |  Branch (25:5): [True: 6.16k, False: 448k]
  ------------------
   26|  1.89k|    case TxoutType::NULL_DATA: return "nulldata";
  ------------------
  |  Branch (26:5): [True: 1.89k, False: 452k]
  ------------------
   27|    790|    case TxoutType::ANCHOR: return "anchor";
  ------------------
  |  Branch (27:5): [True: 790, False: 453k]
  ------------------
   28|  13.7k|    case TxoutType::WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
  ------------------
  |  Branch (28:5): [True: 13.7k, False: 440k]
  ------------------
   29|  11.7k|    case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
  ------------------
  |  Branch (29:5): [True: 11.7k, False: 442k]
  ------------------
   30|  4.53k|    case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
  ------------------
  |  Branch (30:5): [True: 4.53k, False: 449k]
  ------------------
   31|  7.79k|    case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
  ------------------
  |  Branch (31:5): [True: 7.79k, False: 446k]
  ------------------
   32|   454k|    } // no default case, so the compiler can warn about missing cases
   33|   454k|    assert(false);
  ------------------
  |  Branch (33:5): [Folded, False: 0]
  ------------------
   34|      0|}
_Z6SolverRK7CScriptRNSt3__16vectorINS3_IhNS2_9allocatorIhEEEENS4_IS6_EEEE:
  142|  1.82M|{
  143|  1.82M|    vSolutionsRet.clear();
  144|       |
  145|       |    // Shortcut for pay-to-script-hash, which are more constrained than the other types:
  146|       |    // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
  147|  1.82M|    if (scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (147:9): [True: 90.9k, False: 1.73M]
  ------------------
  148|  90.9k|    {
  149|  90.9k|        std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
  150|  90.9k|        vSolutionsRet.push_back(hashBytes);
  151|  90.9k|        return TxoutType::SCRIPTHASH;
  152|  90.9k|    }
  153|       |
  154|  1.73M|    int witnessversion;
  155|  1.73M|    std::vector<unsigned char> witnessprogram;
  156|  1.73M|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (156:9): [True: 161k, False: 1.57M]
  ------------------
  157|   161k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
  ------------------
  |  Branch (157:13): [True: 110k, False: 50.8k]
  |  Branch (157:36): [True: 61.0k, False: 49.3k]
  ------------------
  158|  61.0k|            vSolutionsRet.push_back(std::move(witnessprogram));
  159|  61.0k|            return TxoutType::WITNESS_V0_KEYHASH;
  160|  61.0k|        }
  161|   100k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (161:13): [True: 49.3k, False: 50.8k]
  |  Branch (161:36): [True: 48.3k, False: 1.02k]
  ------------------
  162|  48.3k|            vSolutionsRet.push_back(std::move(witnessprogram));
  163|  48.3k|            return TxoutType::WITNESS_V0_SCRIPTHASH;
  164|  48.3k|        }
  165|  51.8k|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
  ------------------
  |  Branch (165:13): [True: 20.6k, False: 31.1k]
  |  Branch (165:36): [True: 15.7k, False: 4.96k]
  ------------------
  166|  15.7k|            vSolutionsRet.push_back(std::move(witnessprogram));
  167|  15.7k|            return TxoutType::WITNESS_V1_TAPROOT;
  168|  15.7k|        }
  169|  36.1k|        if (scriptPubKey.IsPayToAnchor()) {
  ------------------
  |  Branch (169:13): [True: 3.31k, False: 32.8k]
  ------------------
  170|  3.31k|            return TxoutType::ANCHOR;
  171|  3.31k|        }
  172|  32.8k|        if (witnessversion != 0) {
  ------------------
  |  Branch (172:13): [True: 31.7k, False: 1.02k]
  ------------------
  173|  31.7k|            vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
  174|  31.7k|            vSolutionsRet.push_back(std::move(witnessprogram));
  175|  31.7k|            return TxoutType::WITNESS_UNKNOWN;
  176|  31.7k|        }
  177|  1.02k|        return TxoutType::NONSTANDARD;
  178|  32.8k|    }
  179|       |
  180|       |    // Provably prunable, data-carrying output
  181|       |    //
  182|       |    // So long as script passes the IsUnspendable() test and all but the first
  183|       |    // byte passes the IsPushOnly() test we don't care what exactly is in the
  184|       |    // script.
  185|  1.57M|    if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
  ------------------
  |  Branch (185:9): [True: 1.09M, False: 474k]
  |  Branch (185:9): [True: 7.64k, False: 1.56M]
  |  Branch (185:37): [True: 15.0k, False: 1.08M]
  |  Branch (185:69): [True: 7.64k, False: 7.43k]
  ------------------
  186|  7.64k|        return TxoutType::NULL_DATA;
  187|  7.64k|    }
  188|       |
  189|  1.56M|    std::vector<unsigned char> data;
  190|  1.56M|    if (MatchPayToPubkey(scriptPubKey, data)) {
  ------------------
  |  Branch (190:9): [True: 23.6k, False: 1.53M]
  ------------------
  191|  23.6k|        vSolutionsRet.push_back(std::move(data));
  192|  23.6k|        return TxoutType::PUBKEY;
  193|  23.6k|    }
  194|       |
  195|  1.53M|    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
  ------------------
  |  Branch (195:9): [True: 24.9k, False: 1.51M]
  ------------------
  196|  24.9k|        vSolutionsRet.push_back(std::move(data));
  197|  24.9k|        return TxoutType::PUBKEYHASH;
  198|  24.9k|    }
  199|       |
  200|  1.51M|    int required;
  201|  1.51M|    std::vector<std::vector<unsigned char>> keys;
  202|  1.51M|    if (MatchMultisig(scriptPubKey, required, keys)) {
  ------------------
  |  Branch (202:9): [True: 20.3k, False: 1.49M]
  ------------------
  203|  20.3k|        vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..20
  204|  20.3k|        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
  205|  20.3k|        vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..20
  206|  20.3k|        return TxoutType::MULTISIG;
  207|  20.3k|    }
  208|       |
  209|  1.49M|    vSolutionsRet.clear();
  210|  1.49M|    return TxoutType::NONSTANDARD;
  211|  1.51M|}
solver.cpp:_ZL15GetScriptNumber10opcodetypeNSt3__16vectorIhNS0_9allocatorIhEEEEii:
   67|  76.0k|{
   68|  76.0k|    int count;
   69|  76.0k|    if (IsSmallInteger(opcode)) {
  ------------------
  |  Branch (69:9): [True: 48.7k, False: 27.3k]
  ------------------
   70|  48.7k|        count = CScript::DecodeOP_N(opcode);
   71|  48.7k|    } else if (IsPushdataOp(opcode)) {
  ------------------
  |  Branch (71:16): [True: 14.9k, False: 12.4k]
  ------------------
   72|  14.9k|        if (!CheckMinimalPush(data, opcode)) return {};
  ------------------
  |  Branch (72:13): [True: 1.05k, False: 13.8k]
  ------------------
   73|  13.8k|        try {
   74|  13.8k|            count = CScriptNum(data, /* fRequireMinimal = */ true).getint();
   75|  13.8k|        } catch (const scriptnum_error&) {
   76|  7.50k|            return {};
   77|  7.50k|        }
   78|  13.8k|    } else {
   79|  12.4k|        return {};
   80|  12.4k|    }
   81|  55.1k|    if (count < min || count > max) return {};
  ------------------
  |  Branch (81:9): [True: 3.26k, False: 51.8k]
  |  Branch (81:24): [True: 3.10k, False: 48.7k]
  ------------------
   82|  48.7k|    return count;
   83|  55.1k|}
solver.cpp:_ZL14IsSmallInteger10opcodetype:
   60|  76.0k|{
   61|  76.0k|    return opcode >= OP_1 && opcode <= OP_16;
  ------------------
  |  Branch (61:12): [True: 59.3k, False: 16.7k]
  |  Branch (61:30): [True: 48.7k, False: 10.5k]
  ------------------
   62|  76.0k|}
solver.cpp:_ZL16MatchPayToPubkeyRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   37|  1.56M|{
   38|  1.56M|    if (script.size() == CPubKey::SIZE + 2 && script[0] == CPubKey::SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (38:9): [True: 10.9k, False: 1.55M]
  |  Branch (38:47): [True: 9.31k, False: 1.64k]
  |  Branch (38:77): [True: 8.28k, False: 1.02k]
  ------------------
   39|  8.28k|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::SIZE + 1);
   40|  8.28k|        return CPubKey::ValidSize(pubkey);
   41|  8.28k|    }
   42|  1.55M|    if (script.size() == CPubKey::COMPRESSED_SIZE + 2 && script[0] == CPubKey::COMPRESSED_SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (42:9): [True: 20.6k, False: 1.53M]
  |  Branch (42:58): [True: 18.5k, False: 2.15k]
  |  Branch (42:99): [True: 16.2k, False: 2.28k]
  ------------------
   43|  16.2k|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_SIZE + 1);
   44|  16.2k|        return CPubKey::ValidSize(pubkey);
   45|  16.2k|    }
   46|  1.53M|    return false;
   47|  1.55M|}
solver.cpp:_ZL20MatchPayToPubkeyHashRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   50|  1.53M|{
   51|  1.53M|    if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 && script[2] == 20 && script[23] == OP_EQUALVERIFY && script[24] == OP_CHECKSIG) {
  ------------------
  |  Branch (51:9): [True: 31.1k, False: 1.50M]
  |  Branch (51:32): [True: 29.6k, False: 1.53k]
  |  Branch (51:55): [True: 27.9k, False: 1.63k]
  |  Branch (51:82): [True: 27.1k, False: 802]
  |  Branch (51:101): [True: 25.9k, False: 1.23k]
  |  Branch (51:133): [True: 24.9k, False: 994]
  ------------------
   52|  24.9k|        pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
   53|  24.9k|        return true;
   54|  24.9k|    }
   55|  1.51M|    return false;
   56|  1.53M|}
solver.cpp:_ZL13MatchMultisigRK7CScriptRiRNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEE:
   86|  1.51M|{
   87|  1.51M|    opcodetype opcode;
   88|  1.51M|    valtype data;
   89|       |
   90|  1.51M|    CScript::const_iterator it = script.begin();
   91|  1.51M|    if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
  ------------------
  |  Branch (91:9): [True: 474k, False: 1.03M]
  |  Branch (91:30): [True: 988k, False: 50.8k]
  ------------------
   92|       |
   93|  50.8k|    if (!script.GetOp(it, opcode, data)) return false;
  ------------------
  |  Branch (93:9): [True: 2.43k, False: 48.3k]
  ------------------
   94|  48.3k|    auto req_sigs = GetScriptNumber(opcode, data, 1, MAX_PUBKEYS_PER_MULTISIG);
   95|  48.3k|    if (!req_sigs) return false;
  ------------------
  |  Branch (95:9): [True: 20.6k, False: 27.6k]
  ------------------
   96|  27.6k|    required_sigs = *req_sigs;
   97|  90.4k|    while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
  ------------------
  |  Branch (97:12): [True: 89.9k, False: 512]
  |  Branch (97:46): [True: 62.7k, False: 27.1k]
  ------------------
   98|  62.7k|        pubkeys.emplace_back(std::move(data));
   99|  62.7k|    }
  100|  27.6k|    auto num_keys = GetScriptNumber(opcode, data, required_sigs, MAX_PUBKEYS_PER_MULTISIG);
  101|  27.6k|    if (!num_keys) return false;
  ------------------
  |  Branch (101:9): [True: 6.62k, False: 21.0k]
  ------------------
  102|  21.0k|    if (pubkeys.size() != static_cast<unsigned long>(*num_keys)) return false;
  ------------------
  |  Branch (102:9): [True: 706, False: 20.3k]
  ------------------
  103|       |
  104|  20.3k|    return (it + 1 == script.end());
  105|  21.0k|}

_Z12IsPushdataOp10opcodetype:
   41|  27.3k|{
   42|  27.3k|    return opcode > OP_FALSE && opcode <= OP_PUSHDATA4;
  ------------------
  |  Branch (42:12): [True: 25.9k, False: 1.37k]
  |  Branch (42:33): [True: 14.9k, False: 11.0k]
  ------------------
   43|  27.3k|}

_ZN19script_verify_flagsC2E23script_verify_flag_name:
   25|   150k|    constexpr explicit(false) script_verify_flags(script_verify_flag_name f) : m_value{value_type{1} << static_cast<uint8_t>(f)} { }
_ZN19script_verify_flags8from_intEm:
   35|   115k|    static constexpr script_verify_flags from_int(value_type f) { script_verify_flags r; r.m_value = f; return r; }
_Zor19script_verify_flagsS_:
   40|  71.0k|    friend constexpr script_verify_flags operator|(script_verify_flags a, script_verify_flags b) { return from_int(a.m_value | b.m_value); }
_Zan19script_verify_flagsS_:
   41|  44.1k|    friend constexpr script_verify_flags operator&(script_verify_flags a, script_verify_flags b) { return from_int(a.m_value & b.m_value); }
_ZNK19script_verify_flagseqES_:
   49|  44.1k|    constexpr bool operator==(script_verify_flags other) const { return m_value == other.m_value; }
_Zor23script_verify_flag_nameS_:
   67|  35.5k|{
   68|  35.5k|    return script_verify_flags{f1} | f2;
   69|  35.5k|}

secp256k1.c:secp256k1_fe_impl_sqr:
  317|  1.14M|SECP256K1_FORCE_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
  318|  1.14M|    secp256k1_fe_sqr_inner(r->n, a->n);
  319|  1.14M|}
secp256k1.c:secp256k1_fe_impl_mul:
  313|  62.6k|SECP256K1_FORCE_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
  314|  62.6k|    secp256k1_fe_mul_inner(r->n, a->n, b->n);
  315|  62.6k|}
secp256k1.c:secp256k1_fe_impl_add_int:
  301|  4.47k|SECP256K1_INLINE static void secp256k1_fe_impl_add_int(secp256k1_fe *r, int a) {
  302|  4.47k|    r->n[0] += a;
  303|  4.47k|}
secp256k1.c:secp256k1_fe_impl_add:
  305|  4.47k|SECP256K1_INLINE static void secp256k1_fe_impl_add(secp256k1_fe *r, const secp256k1_fe *a) {
  306|  4.47k|    r->n[0] += a->n[0];
  307|  4.47k|    r->n[1] += a->n[1];
  308|  4.47k|    r->n[2] += a->n[2];
  309|  4.47k|    r->n[3] += a->n[3];
  310|  4.47k|    r->n[4] += a->n[4];
  311|  4.47k|}
secp256k1.c:secp256k1_fe_impl_negate_unchecked:
  278|  6.71k|SECP256K1_INLINE static void secp256k1_fe_impl_negate_unchecked(secp256k1_fe *r, const secp256k1_fe *a, int m) {
  279|       |    /* For all legal values of m (0..31), the following properties hold: */
  280|  6.71k|    VERIFY_CHECK(0xFFFFEFFFFFC2FULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  281|  6.71k|    VERIFY_CHECK(0xFFFFFFFFFFFFFULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  282|  6.71k|    VERIFY_CHECK(0x0FFFFFFFFFFFFULL * 2 * (m + 1) >= 0x0FFFFFFFFFFFFULL * 2 * m);
  283|       |
  284|       |    /* Due to the properties above, the left hand in the subtractions below is never less than
  285|       |     * the right hand. */
  286|  6.71k|    r->n[0] = 0xFFFFEFFFFFC2FULL * 2 * (m + 1) - a->n[0];
  287|  6.71k|    r->n[1] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[1];
  288|  6.71k|    r->n[2] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[2];
  289|  6.71k|    r->n[3] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[3];
  290|  6.71k|    r->n[4] = 0x0FFFFFFFFFFFFULL * 2 * (m + 1) - a->n[4];
  291|  6.71k|}
secp256k1.c:secp256k1_fe_impl_normalizes_to_zero:
  137|  4.47k|static int secp256k1_fe_impl_normalizes_to_zero(const secp256k1_fe *r) {
  138|  4.47k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
  139|       |
  140|       |    /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
  141|  4.47k|    uint64_t z0, z1;
  142|       |
  143|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
  144|  4.47k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  145|       |
  146|       |    /* The first pass ensures the magnitude is 1, ... */
  147|  4.47k|    t0 += x * 0x1000003D1ULL;
  148|  4.47k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL; z0  = t0; z1  = t0 ^ 0x1000003D0ULL;
  149|  4.47k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
  150|  4.47k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
  151|  4.47k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
  152|  4.47k|                                                z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
  153|       |
  154|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
  155|  4.47k|    VERIFY_CHECK(t4 >> 49 == 0);
  156|       |
  157|  4.47k|    return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
  158|  4.47k|}
secp256k1.c:secp256k1_fe_impl_set_b32_limit:
  265|  4.53k|static int secp256k1_fe_impl_set_b32_limit(secp256k1_fe *r, const unsigned char *a) {
  266|  4.53k|    secp256k1_fe_impl_set_b32_mod(r, a);
  267|  4.53k|    return !((r->n[4] == 0x0FFFFFFFFFFFFULL) & ((r->n[3] & r->n[2] & r->n[1]) == 0xFFFFFFFFFFFFFULL) & (r->n[0] >= 0xFFFFEFFFFFC2FULL));
  268|  4.53k|}
secp256k1.c:secp256k1_fe_impl_normalize_var:
   99|  4.47k|static void secp256k1_fe_impl_normalize_var(secp256k1_fe *r) {
  100|  4.47k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
  101|       |
  102|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
  103|  4.47k|    uint64_t m;
  104|  4.47k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  105|       |
  106|       |    /* The first pass ensures the magnitude is 1, ... */
  107|  4.47k|    t0 += x * 0x1000003D1ULL;
  108|  4.47k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  109|  4.47k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
  110|  4.47k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
  111|  4.47k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
  112|       |
  113|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
  114|  4.47k|    VERIFY_CHECK(t4 >> 49 == 0);
  115|       |
  116|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
  117|  4.47k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
  118|  4.47k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
  119|       |
  120|  4.47k|    if (x) {
  ------------------
  |  Branch (120:9): [True: 2, False: 4.47k]
  ------------------
  121|      2|        t0 += 0x1000003D1ULL;
  122|      2|        t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  123|      2|        t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
  124|      2|        t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
  125|      2|        t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
  126|       |
  127|       |        /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
  128|      2|        VERIFY_CHECK(t4 >> 48 == x);
  129|       |
  130|       |        /* Mask off the possible multiple of 2^256 from the final reduction */
  131|      2|        t4 &= 0x0FFFFFFFFFFFFULL;
  132|      2|    }
  133|       |
  134|  4.47k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
  135|  4.47k|}
secp256k1.c:secp256k1_fe_impl_is_odd:
  211|  4.47k|SECP256K1_INLINE static int secp256k1_fe_impl_is_odd(const secp256k1_fe *a) {
  212|  4.47k|    return a->n[0] & 1;
  213|  4.47k|}
secp256k1.c:secp256k1_fe_impl_set_b32_mod:
  228|  4.53k|static void secp256k1_fe_impl_set_b32_mod(secp256k1_fe *r, const unsigned char *a) {
  229|  4.53k|    r->n[0] = (uint64_t)a[31]
  230|  4.53k|            | ((uint64_t)a[30] << 8)
  231|  4.53k|            | ((uint64_t)a[29] << 16)
  232|  4.53k|            | ((uint64_t)a[28] << 24)
  233|  4.53k|            | ((uint64_t)a[27] << 32)
  234|  4.53k|            | ((uint64_t)a[26] << 40)
  235|  4.53k|            | ((uint64_t)(a[25] & 0xF)  << 48);
  236|  4.53k|    r->n[1] = (uint64_t)((a[25] >> 4) & 0xF)
  237|  4.53k|            | ((uint64_t)a[24] << 4)
  238|  4.53k|            | ((uint64_t)a[23] << 12)
  239|  4.53k|            | ((uint64_t)a[22] << 20)
  240|  4.53k|            | ((uint64_t)a[21] << 28)
  241|  4.53k|            | ((uint64_t)a[20] << 36)
  242|  4.53k|            | ((uint64_t)a[19] << 44);
  243|  4.53k|    r->n[2] = (uint64_t)a[18]
  244|  4.53k|            | ((uint64_t)a[17] << 8)
  245|  4.53k|            | ((uint64_t)a[16] << 16)
  246|  4.53k|            | ((uint64_t)a[15] << 24)
  247|  4.53k|            | ((uint64_t)a[14] << 32)
  248|  4.53k|            | ((uint64_t)a[13] << 40)
  249|  4.53k|            | ((uint64_t)(a[12] & 0xF) << 48);
  250|  4.53k|    r->n[3] = (uint64_t)((a[12] >> 4) & 0xF)
  251|  4.53k|            | ((uint64_t)a[11] << 4)
  252|  4.53k|            | ((uint64_t)a[10] << 12)
  253|  4.53k|            | ((uint64_t)a[9]  << 20)
  254|  4.53k|            | ((uint64_t)a[8]  << 28)
  255|  4.53k|            | ((uint64_t)a[7]  << 36)
  256|  4.53k|            | ((uint64_t)a[6]  << 44);
  257|  4.53k|    r->n[4] = (uint64_t)a[5]
  258|  4.53k|            | ((uint64_t)a[4] << 8)
  259|  4.53k|            | ((uint64_t)a[3] << 16)
  260|  4.53k|            | ((uint64_t)a[2] << 24)
  261|  4.53k|            | ((uint64_t)a[1] << 32)
  262|  4.53k|            | ((uint64_t)a[0] << 40);
  263|  4.53k|}
secp256k1.c:secp256k1_fe_impl_normalize:
   43|  5.60k|static void secp256k1_fe_impl_normalize(secp256k1_fe *r) {
   44|  5.60k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
   45|       |
   46|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
   47|  5.60k|    uint64_t m;
   48|  5.60k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
   49|       |
   50|       |    /* The first pass ensures the magnitude is 1, ... */
   51|  5.60k|    t0 += x * 0x1000003D1ULL;
   52|  5.60k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   53|  5.60k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
   54|  5.60k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
   55|  5.60k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
   56|       |
   57|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
   58|  5.60k|    VERIFY_CHECK(t4 >> 49 == 0);
   59|       |
   60|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
   61|  5.60k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
   62|  5.60k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
   63|       |
   64|       |    /* Apply the final reduction (for constant-time behaviour, we do it always) */
   65|  5.60k|    t0 += x * 0x1000003D1ULL;
   66|  5.60k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   67|  5.60k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
   68|  5.60k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
   69|  5.60k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
   70|       |
   71|       |    /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
   72|  5.60k|    VERIFY_CHECK(t4 >> 48 == x);
   73|       |
   74|       |    /* Mask off the possible multiple of 2^256 from the final reduction */
   75|  5.60k|    t4 &= 0x0FFFFFFFFFFFFULL;
   76|       |
   77|  5.60k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
   78|  5.60k|}
secp256k1.c:secp256k1_fe_impl_to_storage:
  402|  5.60k|static void secp256k1_fe_impl_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
  403|  5.60k|    r->n[0] = a->n[0] | a->n[1] << 52;
  404|  5.60k|    r->n[1] = a->n[1] >> 12 | a->n[2] << 40;
  405|  5.60k|    r->n[2] = a->n[2] >> 24 | a->n[3] << 28;
  406|  5.60k|    r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
  407|  5.60k|}

secp256k1.c:secp256k1_fe_sqr_inner:
  154|  1.14M|SECP256K1_FORCE_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
  155|  1.14M|    secp256k1_uint128 c, d;
  156|  1.14M|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
  157|  1.14M|    uint64_t t3, t4, tx, u0;
  158|  1.14M|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
  159|       |
  160|  1.14M|    VERIFY_BITS(a[0], 56);
  161|  1.14M|    VERIFY_BITS(a[1], 56);
  162|  1.14M|    VERIFY_BITS(a[2], 56);
  163|  1.14M|    VERIFY_BITS(a[3], 56);
  164|  1.14M|    VERIFY_BITS(a[4], 52);
  165|       |
  166|       |    /**  [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
  167|       |     *  px is a shorthand for sum(a[i]*a[x-i], i=0..x).
  168|       |     *  Note that [x 0 0 0 0 0] = [x*R].
  169|       |     */
  170|       |
  171|  1.14M|    secp256k1_u128_mul(&d, a0*2, a3);
  172|  1.14M|    secp256k1_u128_accum_mul(&d, a1*2, a2);
  173|  1.14M|    VERIFY_BITS_128(&d, 114);
  174|       |    /* [d 0 0 0] = [p3 0 0 0] */
  175|  1.14M|    secp256k1_u128_mul(&c, a4, a4);
  176|  1.14M|    VERIFY_BITS_128(&c, 112);
  177|       |    /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  178|  1.14M|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
  179|  1.14M|    VERIFY_BITS_128(&d, 115);
  180|  1.14M|    VERIFY_BITS_128(&c, 48);
  181|       |    /* [(c<<12) 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  182|  1.14M|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  183|  1.14M|    VERIFY_BITS(t3, 52);
  184|  1.14M|    VERIFY_BITS_128(&d, 63);
  185|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  186|       |
  187|  1.14M|    a4 *= 2;
  188|  1.14M|    secp256k1_u128_accum_mul(&d, a0, a4);
  189|  1.14M|    secp256k1_u128_accum_mul(&d, a1*2, a3);
  190|  1.14M|    secp256k1_u128_accum_mul(&d, a2, a2);
  191|  1.14M|    VERIFY_BITS_128(&d, 115);
  192|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  193|  1.14M|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
  194|  1.14M|    VERIFY_BITS_128(&d, 116);
  195|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  196|  1.14M|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  197|  1.14M|    VERIFY_BITS(t4, 52);
  198|  1.14M|    VERIFY_BITS_128(&d, 64);
  199|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  200|  1.14M|    tx = (t4 >> 48); t4 &= (M >> 4);
  201|  1.14M|    VERIFY_BITS(tx, 4);
  202|  1.14M|    VERIFY_BITS(t4, 48);
  203|       |    /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  204|       |
  205|  1.14M|    secp256k1_u128_mul(&c, a0, a0);
  206|  1.14M|    VERIFY_BITS_128(&c, 112);
  207|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
  208|  1.14M|    secp256k1_u128_accum_mul(&d, a1, a4);
  209|  1.14M|    secp256k1_u128_accum_mul(&d, a2*2, a3);
  210|  1.14M|    VERIFY_BITS_128(&d, 114);
  211|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  212|  1.14M|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  213|  1.14M|    VERIFY_BITS(u0, 52);
  214|  1.14M|    VERIFY_BITS_128(&d, 62);
  215|       |    /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  216|       |    /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  217|  1.14M|    u0 = (u0 << 4) | tx;
  218|  1.14M|    VERIFY_BITS(u0, 56);
  219|       |    /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  220|  1.14M|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
  221|  1.14M|    VERIFY_BITS_128(&c, 113);
  222|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  223|  1.14M|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  224|  1.14M|    VERIFY_BITS(r[0], 52);
  225|  1.14M|    VERIFY_BITS_128(&c, 61);
  226|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
  227|       |
  228|  1.14M|    a0 *= 2;
  229|  1.14M|    secp256k1_u128_accum_mul(&c, a0, a1);
  230|  1.14M|    VERIFY_BITS_128(&c, 114);
  231|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  232|  1.14M|    secp256k1_u128_accum_mul(&d, a2, a4);
  233|  1.14M|    secp256k1_u128_accum_mul(&d, a3, a3);
  234|  1.14M|    VERIFY_BITS_128(&d, 114);
  235|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  236|  1.14M|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  237|  1.14M|    VERIFY_BITS_128(&c, 115);
  238|  1.14M|    VERIFY_BITS_128(&d, 62);
  239|       |    /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  240|  1.14M|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  241|  1.14M|    VERIFY_BITS(r[1], 52);
  242|  1.14M|    VERIFY_BITS_128(&c, 63);
  243|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  244|       |
  245|  1.14M|    secp256k1_u128_accum_mul(&c, a0, a2);
  246|  1.14M|    secp256k1_u128_accum_mul(&c, a1, a1);
  247|  1.14M|    VERIFY_BITS_128(&c, 114);
  248|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
  249|  1.14M|    secp256k1_u128_accum_mul(&d, a3, a4);
  250|  1.14M|    VERIFY_BITS_128(&d, 114);
  251|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  252|  1.14M|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  253|  1.14M|    VERIFY_BITS_128(&c, 115);
  254|  1.14M|    VERIFY_BITS_128(&d, 50);
  255|       |    /* [(d<<12) 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  256|  1.14M|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  257|  1.14M|    VERIFY_BITS(r[2], 52);
  258|  1.14M|    VERIFY_BITS_128(&c, 63);
  259|       |    /* [(d<<12) 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  260|       |
  261|  1.14M|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  262|  1.14M|    secp256k1_u128_accum_u64(&c, t3);
  263|  1.14M|    VERIFY_BITS_128(&c, 100);
  264|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  265|  1.14M|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  266|  1.14M|    VERIFY_BITS(r[3], 52);
  267|  1.14M|    VERIFY_BITS_128(&c, 48);
  268|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  269|  1.14M|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  270|  1.14M|    VERIFY_BITS(r[4], 49);
  271|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  272|  1.14M|}
secp256k1.c:secp256k1_fe_mul_inner:
   18|  62.6k|SECP256K1_FORCE_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
   19|  62.6k|    secp256k1_uint128 c, d;
   20|  62.6k|    uint64_t t3, t4, tx, u0;
   21|  62.6k|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
   22|  62.6k|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
   23|       |
   24|  62.6k|    VERIFY_BITS(a[0], 56);
   25|  62.6k|    VERIFY_BITS(a[1], 56);
   26|  62.6k|    VERIFY_BITS(a[2], 56);
   27|  62.6k|    VERIFY_BITS(a[3], 56);
   28|  62.6k|    VERIFY_BITS(a[4], 52);
   29|  62.6k|    VERIFY_BITS(b[0], 56);
   30|  62.6k|    VERIFY_BITS(b[1], 56);
   31|  62.6k|    VERIFY_BITS(b[2], 56);
   32|  62.6k|    VERIFY_BITS(b[3], 56);
   33|  62.6k|    VERIFY_BITS(b[4], 52);
   34|  62.6k|    VERIFY_CHECK(r != b);
   35|  62.6k|    VERIFY_CHECK(a != b);
   36|       |
   37|       |    /*  [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
   38|       |     *  for 0 <= x <= 4, px is a shorthand for sum(a[i]*b[x-i], i=0..x).
   39|       |     *  for 4 <= x <= 8, px is a shorthand for sum(a[i]*b[x-i], i=(x-4)..4)
   40|       |     *  Note that [x 0 0 0 0 0] = [x*R].
   41|       |     */
   42|       |
   43|  62.6k|    secp256k1_u128_mul(&d, a0, b[3]);
   44|  62.6k|    secp256k1_u128_accum_mul(&d, a1, b[2]);
   45|  62.6k|    secp256k1_u128_accum_mul(&d, a2, b[1]);
   46|  62.6k|    secp256k1_u128_accum_mul(&d, a3, b[0]);
   47|  62.6k|    VERIFY_BITS_128(&d, 114);
   48|       |    /* [d 0 0 0] = [p3 0 0 0] */
   49|  62.6k|    secp256k1_u128_mul(&c, a4, b[4]);
   50|  62.6k|    VERIFY_BITS_128(&c, 112);
   51|       |    /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   52|  62.6k|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
   53|  62.6k|    VERIFY_BITS_128(&d, 115);
   54|  62.6k|    VERIFY_BITS_128(&c, 48);
   55|       |    /* [(c<<12) 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   56|  62.6k|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   57|  62.6k|    VERIFY_BITS(t3, 52);
   58|  62.6k|    VERIFY_BITS_128(&d, 63);
   59|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   60|       |
   61|  62.6k|    secp256k1_u128_accum_mul(&d, a0, b[4]);
   62|  62.6k|    secp256k1_u128_accum_mul(&d, a1, b[3]);
   63|  62.6k|    secp256k1_u128_accum_mul(&d, a2, b[2]);
   64|  62.6k|    secp256k1_u128_accum_mul(&d, a3, b[1]);
   65|  62.6k|    secp256k1_u128_accum_mul(&d, a4, b[0]);
   66|  62.6k|    VERIFY_BITS_128(&d, 115);
   67|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   68|  62.6k|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
   69|  62.6k|    VERIFY_BITS_128(&d, 116);
   70|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   71|  62.6k|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   72|  62.6k|    VERIFY_BITS(t4, 52);
   73|  62.6k|    VERIFY_BITS_128(&d, 64);
   74|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   75|  62.6k|    tx = (t4 >> 48); t4 &= (M >> 4);
   76|  62.6k|    VERIFY_BITS(tx, 4);
   77|  62.6k|    VERIFY_BITS(t4, 48);
   78|       |    /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   79|       |
   80|  62.6k|    secp256k1_u128_mul(&c, a0, b[0]);
   81|  62.6k|    VERIFY_BITS_128(&c, 112);
   82|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
   83|  62.6k|    secp256k1_u128_accum_mul(&d, a1, b[4]);
   84|  62.6k|    secp256k1_u128_accum_mul(&d, a2, b[3]);
   85|  62.6k|    secp256k1_u128_accum_mul(&d, a3, b[2]);
   86|  62.6k|    secp256k1_u128_accum_mul(&d, a4, b[1]);
   87|  62.6k|    VERIFY_BITS_128(&d, 114);
   88|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   89|  62.6k|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   90|  62.6k|    VERIFY_BITS(u0, 52);
   91|  62.6k|    VERIFY_BITS_128(&d, 62);
   92|       |    /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   93|       |    /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   94|  62.6k|    u0 = (u0 << 4) | tx;
   95|  62.6k|    VERIFY_BITS(u0, 56);
   96|       |    /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   97|  62.6k|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
   98|  62.6k|    VERIFY_BITS_128(&c, 113);
   99|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  100|  62.6k|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  101|  62.6k|    VERIFY_BITS(r[0], 52);
  102|  62.6k|    VERIFY_BITS_128(&c, 61);
  103|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
  104|       |
  105|  62.6k|    secp256k1_u128_accum_mul(&c, a0, b[1]);
  106|  62.6k|    secp256k1_u128_accum_mul(&c, a1, b[0]);
  107|  62.6k|    VERIFY_BITS_128(&c, 114);
  108|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  109|  62.6k|    secp256k1_u128_accum_mul(&d, a2, b[4]);
  110|  62.6k|    secp256k1_u128_accum_mul(&d, a3, b[3]);
  111|  62.6k|    secp256k1_u128_accum_mul(&d, a4, b[2]);
  112|  62.6k|    VERIFY_BITS_128(&d, 114);
  113|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  114|  62.6k|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  115|  62.6k|    VERIFY_BITS_128(&c, 115);
  116|  62.6k|    VERIFY_BITS_128(&d, 62);
  117|       |    /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  118|  62.6k|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  119|  62.6k|    VERIFY_BITS(r[1], 52);
  120|  62.6k|    VERIFY_BITS_128(&c, 63);
  121|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  122|       |
  123|  62.6k|    secp256k1_u128_accum_mul(&c, a0, b[2]);
  124|  62.6k|    secp256k1_u128_accum_mul(&c, a1, b[1]);
  125|  62.6k|    secp256k1_u128_accum_mul(&c, a2, b[0]);
  126|  62.6k|    VERIFY_BITS_128(&c, 114);
  127|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
  128|  62.6k|    secp256k1_u128_accum_mul(&d, a3, b[4]);
  129|  62.6k|    secp256k1_u128_accum_mul(&d, a4, b[3]);
  130|  62.6k|    VERIFY_BITS_128(&d, 114);
  131|       |    /* [d 0 0 t4 t3 c t1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  132|  62.6k|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  133|  62.6k|    VERIFY_BITS_128(&c, 115);
  134|  62.6k|    VERIFY_BITS_128(&d, 50);
  135|       |    /* [(d<<12) 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  136|       |
  137|  62.6k|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  138|  62.6k|    VERIFY_BITS(r[2], 52);
  139|  62.6k|    VERIFY_BITS_128(&c, 63);
  140|       |    /* [(d<<12) 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  141|  62.6k|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  142|  62.6k|    secp256k1_u128_accum_u64(&c, t3);
  143|  62.6k|    VERIFY_BITS_128(&c, 100);
  144|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  145|  62.6k|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  146|  62.6k|    VERIFY_BITS(r[3], 52);
  147|  62.6k|    VERIFY_BITS_128(&c, 48);
  148|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  149|  62.6k|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  150|  62.6k|    VERIFY_BITS(r[4], 49);
  151|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  152|  62.6k|}

secp256k1.c:secp256k1_fe_verify:
  149|  38.0k|static void secp256k1_fe_verify(const secp256k1_fe *a) { (void)a; }
secp256k1.c:secp256k1_fe_verify_magnitude:
  150|  33.5k|static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m) { (void)a; (void)m; }
secp256k1.c:secp256k1_fe_sqrt:
   37|  4.47k|static int secp256k1_fe_sqrt(secp256k1_fe * SECP256K1_RESTRICT r, const secp256k1_fe * SECP256K1_RESTRICT a) {
   38|       |    /** Given that p is congruent to 3 mod 4, we can compute the square root of
   39|       |     *  a mod p as the (p+1)/4'th power of a.
   40|       |     *
   41|       |     *  As (p+1)/4 is an even number, it will have the same result for a and for
   42|       |     *  (-a). Only one of these two numbers actually has a square root however,
   43|       |     *  so we test at the end by squaring and comparing to the input.
   44|       |     *  Also because (p+1)/4 is an even number, the computed square root is
   45|       |     *  itself always a square (a ** ((p+1)/4) is the square of a ** ((p+1)/8)).
   46|       |     */
   47|  4.47k|    secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
   48|  4.47k|    int j, ret;
   49|       |
   50|  4.47k|    VERIFY_CHECK(r != a);
   51|  4.47k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  345|  4.47k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   52|  4.47k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
  ------------------
  |  |  349|  4.47k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   53|       |
   54|       |    /** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
   55|       |     *  { 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
   56|       |     *  1, [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
   57|       |     */
   58|       |
   59|  4.47k|    secp256k1_fe_sqr(&x2, a);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   60|  4.47k|    secp256k1_fe_mul(&x2, &x2, a);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   61|       |
   62|  4.47k|    secp256k1_fe_sqr(&x3, &x2);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   63|  4.47k|    secp256k1_fe_mul(&x3, &x3, a);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   64|       |
   65|  4.47k|    x6 = x3;
   66|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (66:15): [True: 13.4k, False: 4.47k]
  ------------------
   67|  13.4k|        secp256k1_fe_sqr(&x6, &x6);
  ------------------
  |  |   94|  13.4k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   68|  13.4k|    }
   69|  4.47k|    secp256k1_fe_mul(&x6, &x6, &x3);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   70|       |
   71|  4.47k|    x9 = x6;
   72|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (72:15): [True: 13.4k, False: 4.47k]
  ------------------
   73|  13.4k|        secp256k1_fe_sqr(&x9, &x9);
  ------------------
  |  |   94|  13.4k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   74|  13.4k|    }
   75|  4.47k|    secp256k1_fe_mul(&x9, &x9, &x3);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   76|       |
   77|  4.47k|    x11 = x9;
   78|  13.4k|    for (j=0; j<2; j++) {
  ------------------
  |  Branch (78:15): [True: 8.94k, False: 4.47k]
  ------------------
   79|  8.94k|        secp256k1_fe_sqr(&x11, &x11);
  ------------------
  |  |   94|  8.94k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   80|  8.94k|    }
   81|  4.47k|    secp256k1_fe_mul(&x11, &x11, &x2);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   82|       |
   83|  4.47k|    x22 = x11;
   84|  53.6k|    for (j=0; j<11; j++) {
  ------------------
  |  Branch (84:15): [True: 49.1k, False: 4.47k]
  ------------------
   85|  49.1k|        secp256k1_fe_sqr(&x22, &x22);
  ------------------
  |  |   94|  49.1k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   86|  49.1k|    }
   87|  4.47k|    secp256k1_fe_mul(&x22, &x22, &x11);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   88|       |
   89|  4.47k|    x44 = x22;
   90|   102k|    for (j=0; j<22; j++) {
  ------------------
  |  Branch (90:15): [True: 98.3k, False: 4.47k]
  ------------------
   91|  98.3k|        secp256k1_fe_sqr(&x44, &x44);
  ------------------
  |  |   94|  98.3k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   92|  98.3k|    }
   93|  4.47k|    secp256k1_fe_mul(&x44, &x44, &x22);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   94|       |
   95|  4.47k|    x88 = x44;
   96|   201k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (96:15): [True: 196k, False: 4.47k]
  ------------------
   97|   196k|        secp256k1_fe_sqr(&x88, &x88);
  ------------------
  |  |   94|   196k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   98|   196k|    }
   99|  4.47k|    secp256k1_fe_mul(&x88, &x88, &x44);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  100|       |
  101|  4.47k|    x176 = x88;
  102|   398k|    for (j=0; j<88; j++) {
  ------------------
  |  Branch (102:15): [True: 393k, False: 4.47k]
  ------------------
  103|   393k|        secp256k1_fe_sqr(&x176, &x176);
  ------------------
  |  |   94|   393k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  104|   393k|    }
  105|  4.47k|    secp256k1_fe_mul(&x176, &x176, &x88);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  106|       |
  107|  4.47k|    x220 = x176;
  108|   201k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (108:15): [True: 196k, False: 4.47k]
  ------------------
  109|   196k|        secp256k1_fe_sqr(&x220, &x220);
  ------------------
  |  |   94|   196k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  110|   196k|    }
  111|  4.47k|    secp256k1_fe_mul(&x220, &x220, &x44);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  112|       |
  113|  4.47k|    x223 = x220;
  114|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (114:15): [True: 13.4k, False: 4.47k]
  ------------------
  115|  13.4k|        secp256k1_fe_sqr(&x223, &x223);
  ------------------
  |  |   94|  13.4k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  116|  13.4k|    }
  117|  4.47k|    secp256k1_fe_mul(&x223, &x223, &x3);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  118|       |
  119|       |    /* The final result is then assembled using a sliding window over the blocks. */
  120|       |
  121|  4.47k|    t1 = x223;
  122|   107k|    for (j=0; j<23; j++) {
  ------------------
  |  Branch (122:15): [True: 102k, False: 4.47k]
  ------------------
  123|   102k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|   102k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  124|   102k|    }
  125|  4.47k|    secp256k1_fe_mul(&t1, &t1, &x22);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  126|  31.3k|    for (j=0; j<6; j++) {
  ------------------
  |  Branch (126:15): [True: 26.8k, False: 4.47k]
  ------------------
  127|  26.8k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  26.8k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  128|  26.8k|    }
  129|  4.47k|    secp256k1_fe_mul(&t1, &t1, &x2);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  130|  4.47k|    secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  131|  4.47k|    secp256k1_fe_sqr(r, &t1);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  132|       |
  133|       |    /* Check that a square root was actually calculated */
  134|       |
  135|  4.47k|    secp256k1_fe_sqr(&t1, r);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  136|  4.47k|    ret = secp256k1_fe_equal(&t1, a);
  137|       |
  138|       |#ifdef VERIFY
  139|       |    if (!ret) {
  140|       |        secp256k1_fe_negate(&t1, &t1, 1);
  141|       |        secp256k1_fe_normalize_var(&t1);
  142|       |        VERIFY_CHECK(secp256k1_fe_equal(&t1, a));
  143|       |    }
  144|       |#endif
  145|  4.47k|    return ret;
  146|  4.47k|}
secp256k1.c:secp256k1_fe_equal:
   25|  4.47k|SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
   26|  4.47k|    secp256k1_fe na;
   27|  4.47k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  345|  4.47k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   28|  4.47k|    SECP256K1_FE_VERIFY(b);
  ------------------
  |  |  345|  4.47k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   29|  4.47k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 1);
  ------------------
  |  |  349|  4.47k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   30|  4.47k|    SECP256K1_FE_VERIFY_MAGNITUDE(b, 30);
  ------------------
  |  |  349|  4.47k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   31|       |
   32|  4.47k|    secp256k1_fe_negate(&na, a, 1);
  ------------------
  |  |  211|  4.47k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   87|  4.47k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   88|  4.47k|    switch(42) { \
  |  |  |  |   89|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   90|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (90:9): [True: 0, False: 4.47k]
  |  |  |  |  ------------------
  |  |  |  |   91|      0|            break; \
  |  |  |  |   92|  4.47k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (92:9): [True: 4.47k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   93|  4.47k|    } \
  |  |  |  |   94|  4.47k|    stmt; \
  |  |  |  |   95|  4.47k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:9): [Folded, False: 4.47k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   33|  4.47k|    secp256k1_fe_add(&na, b);
  ------------------
  |  |   92|  4.47k|#  define secp256k1_fe_add secp256k1_fe_impl_add
  ------------------
   34|  4.47k|    return secp256k1_fe_normalizes_to_zero(&na);
  ------------------
  |  |   81|  4.47k|#  define secp256k1_fe_normalizes_to_zero secp256k1_fe_impl_normalizes_to_zero
  ------------------
   35|  4.47k|}

secp256k1.c:secp256k1_ge_verify:
   78|  10.0k|static void secp256k1_ge_verify(const secp256k1_ge *a) {
   79|  10.0k|    SECP256K1_FE_VERIFY(&a->x);
  ------------------
  |  |  345|  10.0k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   80|  10.0k|    SECP256K1_FE_VERIFY(&a->y);
  ------------------
  |  |  345|  10.0k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   81|  10.0k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->x, SECP256K1_GE_X_MAGNITUDE_MAX);
  ------------------
  |  |  349|  10.0k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   82|  10.0k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->y, SECP256K1_GE_Y_MAGNITUDE_MAX);
  ------------------
  |  |  349|  10.0k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   83|  10.0k|    VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
   84|  10.0k|    (void)a;
   85|  10.0k|}
secp256k1.c:secp256k1_ge_is_in_correct_subgroup:
  926|  2.80k|static int secp256k1_ge_is_in_correct_subgroup(const secp256k1_ge* ge) {
  927|       |#ifdef EXHAUSTIVE_TEST_ORDER
  928|       |    secp256k1_gej out;
  929|       |    int i;
  930|       |    SECP256K1_GE_VERIFY(ge);
  931|       |
  932|       |    /* A very simple EC multiplication ladder that avoids a dependency on ecmult. */
  933|       |    secp256k1_gej_set_infinity(&out);
  934|       |    for (i = 0; i < 32; ++i) {
  935|       |        secp256k1_gej_double_var(&out, &out, NULL);
  936|       |        if ((((uint32_t)EXHAUSTIVE_TEST_ORDER) >> (31 - i)) & 1) {
  937|       |            secp256k1_gej_add_ge_var(&out, &out, ge, NULL);
  938|       |        }
  939|       |    }
  940|       |    return secp256k1_gej_is_infinity(&out);
  941|       |#else
  942|  2.80k|    SECP256K1_GE_VERIFY(ge);
  ------------------
  |  |  212|  2.80k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  943|       |
  944|  2.80k|    (void)ge;
  945|       |    /* The real secp256k1 group has cofactor 1, so the subgroup is the entire curve. */
  946|  2.80k|    return 1;
  947|  2.80k|#endif
  948|  2.80k|}
secp256k1.c:secp256k1_ge_set_xo_var:
  347|  4.47k|static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd) {
  348|  4.47k|    secp256k1_fe x2, x3;
  349|  4.47k|    int ret;
  350|  4.47k|    SECP256K1_FE_VERIFY(x);
  ------------------
  |  |  345|  4.47k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
  351|       |
  352|  4.47k|    r->x = *x;
  353|  4.47k|    secp256k1_fe_sqr(&x2, x);
  ------------------
  |  |   94|  4.47k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  354|  4.47k|    secp256k1_fe_mul(&x3, x, &x2);
  ------------------
  |  |   93|  4.47k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  355|  4.47k|    r->infinity = 0;
  356|  4.47k|    secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |  102|  4.47k|#  define secp256k1_fe_add_int secp256k1_fe_impl_add_int
  ------------------
                  secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |   73|  4.47k|#define SECP256K1_B 7
  ------------------
  357|  4.47k|    ret = secp256k1_fe_sqrt(&r->y, &x3);
  358|  4.47k|    secp256k1_fe_normalize_var(&r->y);
  ------------------
  |  |   80|  4.47k|#  define secp256k1_fe_normalize_var secp256k1_fe_impl_normalize_var
  ------------------
  359|  4.47k|    if (secp256k1_fe_is_odd(&r->y) != odd) {
  ------------------
  |  |   85|  4.47k|#  define secp256k1_fe_is_odd secp256k1_fe_impl_is_odd
  ------------------
  |  Branch (359:9): [True: 2.23k, False: 2.23k]
  ------------------
  360|  2.23k|        secp256k1_fe_negate(&r->y, &r->y, 1);
  ------------------
  |  |  211|  2.23k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   87|  2.23k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   88|  2.23k|    switch(42) { \
  |  |  |  |   89|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   90|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (90:9): [True: 0, False: 2.23k]
  |  |  |  |  ------------------
  |  |  |  |   91|      0|            break; \
  |  |  |  |   92|  2.23k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (92:9): [True: 2.23k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   93|  2.23k|    } \
  |  |  |  |   94|  2.23k|    stmt; \
  |  |  |  |   95|  2.23k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:9): [Folded, False: 2.23k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  361|  2.23k|    }
  362|       |
  363|  4.47k|    SECP256K1_GE_VERIFY(r);
  ------------------
  |  |  212|  4.47k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  364|  4.47k|    return ret;
  365|  4.47k|}
secp256k1.c:secp256k1_ge_to_bytes:
  977|  2.80k|static void secp256k1_ge_to_bytes(unsigned char *buf, const secp256k1_ge *a) {
  978|  2.80k|    secp256k1_ge_storage s;
  979|       |
  980|       |    /* We require that the secp256k1_ge_storage type is exactly 64 bytes.
  981|       |     * This is formally not guaranteed by the C standard, but should hold on any
  982|       |     * sane compiler in the real world. */
  983|  2.80k|    STATIC_ASSERT(sizeof(secp256k1_ge_storage) == 64);
  ------------------
  |  |   74|  2.80k|#define STATIC_ASSERT(expr) do { \
  |  |   75|  2.80k|    switch(0) { \
  |  |  ------------------
  |  |  |  Branch (75:12): [Folded, False: 0]
  |  |  ------------------
  |  |   76|  2.80k|        case 0: \
  |  |  ------------------
  |  |  |  Branch (76:9): [True: 2.80k, False: 0]
  |  |  ------------------
  |  |   77|  2.80k|        /* If expr evaluates to 0, we have two case labels "0", which is illegal. */ \
  |  |   78|  2.80k|        case /* ERROR: static assertion failed */ (expr): \
  |  |  ------------------
  |  |  |  Branch (78:9): [True: 0, False: 2.80k]
  |  |  ------------------
  |  |   79|  2.80k|        ; \
  |  |   80|  2.80k|    } \
  |  |   81|  2.80k|} while(0)
  |  |  ------------------
  |  |  |  Branch (81:9): [Folded, False: 2.80k]
  |  |  ------------------
  ------------------
  984|  2.80k|    VERIFY_CHECK(!secp256k1_ge_is_infinity(a));
  985|  2.80k|    secp256k1_ge_to_storage(&s, a);
  986|  2.80k|    memcpy(buf, &s, 64);
  987|  2.80k|}
secp256k1.c:secp256k1_ge_to_storage:
  877|  2.80k|static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
  878|  2.80k|    secp256k1_fe x, y;
  879|  2.80k|    SECP256K1_GE_VERIFY(a);
  ------------------
  |  |  212|  2.80k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  880|  2.80k|    VERIFY_CHECK(!a->infinity);
  881|       |
  882|  2.80k|    x = a->x;
  883|  2.80k|    secp256k1_fe_normalize(&x);
  ------------------
  |  |   78|  2.80k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  884|  2.80k|    y = a->y;
  885|  2.80k|    secp256k1_fe_normalize(&y);
  ------------------
  |  |   78|  2.80k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  886|  2.80k|    secp256k1_fe_to_storage(&r->x, &x);
  ------------------
  |  |   96|  2.80k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  887|  2.80k|    secp256k1_fe_to_storage(&r->y, &y);
  ------------------
  |  |   96|  2.80k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  888|  2.80k|}

secp256k1.c:secp256k1_u128_mul:
   11|  3.60M|static SECP256K1_INLINE void secp256k1_u128_mul(secp256k1_uint128 *r, uint64_t a, uint64_t b) {
   12|  3.60M|   *r = (uint128_t)a * b;
   13|  3.60M|}
secp256k1.c:secp256k1_u128_accum_mul:
   15|  22.2M|static SECP256K1_INLINE void secp256k1_u128_accum_mul(secp256k1_uint128 *r, uint64_t a, uint64_t b) {
   16|  22.2M|   *r += (uint128_t)a * b;
   17|  22.2M|}
secp256k1.c:secp256k1_u128_to_u64:
   28|  15.6M|static SECP256K1_INLINE uint64_t secp256k1_u128_to_u64(const secp256k1_uint128 *a) {
   29|  15.6M|   return (uint64_t)(*a);
   30|  15.6M|}
secp256k1.c:secp256k1_u128_rshift:
   23|  12.0M|static SECP256K1_INLINE void secp256k1_u128_rshift(secp256k1_uint128 *r, unsigned int n) {
   24|  12.0M|   VERIFY_CHECK(n < 128);
   25|  12.0M|   *r >>= n;
   26|  12.0M|}
secp256k1.c:secp256k1_u128_accum_u64:
   19|  1.20M|static SECP256K1_INLINE void secp256k1_u128_accum_u64(secp256k1_uint128 *r, uint64_t a) {
   20|  1.20M|   *r += a;
   21|  1.20M|}

secp256k1_xonly_pubkey_parse:
   29|  4.53k|int secp256k1_xonly_pubkey_parse(const secp256k1_context* ctx, secp256k1_xonly_pubkey *pubkey, const unsigned char *input32) {
   30|  4.53k|    secp256k1_ge pk;
   31|  4.53k|    secp256k1_fe x;
   32|       |
   33|  4.53k|    VERIFY_CHECK(ctx != NULL);
   34|  4.53k|    ARG_CHECK(pubkey != NULL);
  ------------------
  |  |   45|  4.53k|#define ARG_CHECK(cond) do { \
  |  |   46|  4.53k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  146|  4.53k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (146:21): [True: 0, False: 4.53k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  4.53k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded, False: 4.53k]
  |  |  ------------------
  ------------------
   35|  4.53k|    memset(pubkey, 0, sizeof(*pubkey));
   36|  4.53k|    ARG_CHECK(input32 != NULL);
  ------------------
  |  |   45|  4.53k|#define ARG_CHECK(cond) do { \
  |  |   46|  4.53k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  146|  4.53k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (146:21): [True: 0, False: 4.53k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  4.53k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded, False: 4.53k]
  |  |  ------------------
  ------------------
   37|       |
   38|  4.53k|    if (!secp256k1_fe_set_b32_limit(&x, input32)) {
  ------------------
  |  |   88|  4.53k|#  define secp256k1_fe_set_b32_limit secp256k1_fe_impl_set_b32_limit
  ------------------
  |  Branch (38:9): [True: 64, False: 4.47k]
  ------------------
   39|     64|        return 0;
   40|     64|    }
   41|  4.47k|    if (!secp256k1_ge_set_xo_var(&pk, &x, 0)) {
  ------------------
  |  Branch (41:9): [True: 1.67k, False: 2.80k]
  ------------------
   42|  1.67k|        return 0;
   43|  1.67k|    }
   44|  2.80k|    if (!secp256k1_ge_is_in_correct_subgroup(&pk)) {
  ------------------
  |  Branch (44:9): [True: 0, False: 2.80k]
  ------------------
   45|      0|        return 0;
   46|      0|    }
   47|  2.80k|    secp256k1_xonly_pubkey_save(pubkey, &pk);
   48|  2.80k|    return 1;
   49|  2.80k|}
secp256k1.c:secp256k1_xonly_pubkey_save:
   18|  2.80k|static SECP256K1_INLINE void secp256k1_xonly_pubkey_save(secp256k1_xonly_pubkey *pubkey, secp256k1_ge *ge) {
   19|       |#ifdef VERIFY
   20|       |    /* ensure that the group element's Y coordinate is even, as per definition of x-only public keys */
   21|       |    secp256k1_fe y = ge->y;
   22|       |    secp256k1_fe_normalize_var(&y);
   23|       |    VERIFY_CHECK(!secp256k1_fe_is_odd(&y));
   24|       |#endif
   25|       |
   26|  2.80k|    secp256k1_pubkey_save((secp256k1_pubkey *) pubkey, ge);
   27|  2.80k|}

secp256k1.c:secp256k1_pubkey_save:
  264|  2.80k|static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
  265|  2.80k|    secp256k1_ge_to_bytes(pubkey->data, ge);
  266|  2.80k|}

block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  81.0k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  75.6k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  491|   382k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  491|  5.65k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  491|  4.38k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_:
  491|  40.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  13.5k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  12.0k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  491|   101k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  491|  5.65k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  491|  4.38k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_:
  491|  40.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10SpanReader5CTxInNSt3__19allocatorIS1_EEEvRT_RNS2_6vectorIT0_T1_EE:
  919|  5.65k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  5.65k|    } else {
  932|  5.65k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  5.65k|    }
  934|  5.65k|}
_Z11UnserializeI10SpanReader7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  776|  5.65k|{
  777|  5.65k|    a.Unserialize(is);
  778|  5.65k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI10SpanReaderEEvRT_:
  477|  5.65k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10SpanReaderNSt3__16vectorI5CTxInNS4_9allocatorIS6_EEEEEEvRT_RT0_:
  680|  5.65k|    {
  681|  5.65k|        Formatter formatter;
  682|  5.65k|        v.clear();
  683|  5.65k|        size_t size = ReadCompactSize(s);
  684|  5.65k|        size_t allocated = 0;
  685|  9.99k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 4.34k, False: 5.65k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  4.34k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  4.34k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  4.34k|            v.reserve(allocated);
  692|   369k|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 365k, False: 4.34k]
  ------------------
  693|   365k|                v.emplace_back();
  694|   365k|                formatter.Unser(s, v.back());
  695|   365k|            }
  696|  4.34k|        }
  697|  5.65k|    };
_ZN16DefaultFormatter5UnserI10SpanReader5CTxInEEvRT_RT0_:
  791|   365k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI10SpanReader6CTxOutNSt3__19allocatorIS1_EEEvRT_RNS2_6vectorIT0_T1_EE:
  919|  4.38k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  4.38k|    } else {
  932|  4.38k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  4.38k|    }
  934|  4.38k|}
_Z11UnserializeI10SpanReader7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  776|  4.38k|{
  777|  4.38k|    a.Unserialize(is);
  778|  4.38k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI10SpanReaderEEvRT_:
  477|  4.38k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10SpanReaderNSt3__16vectorI6CTxOutNS4_9allocatorIS6_EEEEEEvRT_RT0_:
  680|  4.38k|    {
  681|  4.38k|        Formatter formatter;
  682|  4.38k|        v.clear();
  683|  4.38k|        size_t size = ReadCompactSize(s);
  684|  4.38k|        size_t allocated = 0;
  685|  7.08k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 2.70k, False: 4.38k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  2.70k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  2.70k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  2.70k|            v.reserve(allocated);
  692|  1.12M|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 1.12M, False: 2.70k]
  ------------------
  693|  1.12M|                v.emplace_back();
  694|  1.12M|                formatter.Unser(s, v.back());
  695|  1.12M|            }
  696|  2.70k|        }
  697|  4.38k|    };
_ZN16DefaultFormatter5UnserI10SpanReader6CTxOutEEvRT_RT0_:
  791|  1.12M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI10SpanReaderR5CTxInQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_ZN5CTxIn11UnserializeI10SpanReaderEEvRT_:
  220|   365k|    {                                                                                               \
  221|   365k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   365k|        Unser(s, *this);                                                                            \
  223|   365k|    }
_ZN5CTxIn5UnserI10SpanReaderEEvRT_RS_:
  172|   365k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10SpanReaderJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1086|   365k|    {
 1087|   365k|        ::UnserializeMany(s, args...);
 1088|   365k|    }
_Z15UnserializeManyI10SpanReaderJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1054|   365k|{
 1055|   365k|    (::Unserialize(s, args), ...);
 1056|   365k|}
_Z11UnserializeI10SpanReaderR9COutPointQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_ZN9COutPoint11UnserializeI10SpanReaderEEvRT_:
  220|   365k|    {                                                                                               \
  221|   365k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   365k|        Unser(s, *this);                                                                            \
  223|   365k|    }
_ZN9COutPoint5UnserI10SpanReaderEEvRT_RS_:
  172|   365k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10SpanReaderJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1086|   365k|    {
 1087|   365k|        ::UnserializeMany(s, args...);
 1088|   365k|    }
_Z15UnserializeManyI10SpanReaderJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1054|   365k|{
 1055|   365k|    (::Unserialize(s, args), ...);
 1056|   365k|}
_Z9SerializeI10DataStream13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  12.0k|{
  768|  12.0k|    a.Serialize(os);
  769|  12.0k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10DataStreamEEvRT_:
 1253|  12.0k|    {
 1254|  12.0k|        ParamsStream ss{s, m_params};
 1255|  12.0k|        ::Serialize(ss, m_object);
 1256|  12.0k|    }
_Z11UnserializeI10SpanReaderR13ParamsWrapperI20TransactionSerParams19CMutableTransactionEQ14UnserializableIT0_T_EEvRS7_OS6_:
  776|  4.76k|{
  777|  4.76k|    a.Unserialize(is);
  778|  4.76k|}
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionE11UnserializeI10SpanReaderEEvRT_:
 1259|  4.76k|    {
 1260|  4.76k|        ParamsStream ss{s, m_params};
 1261|  4.76k|        ::Unserialize(ss, m_object);
 1262|  4.76k|    }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER19CMutableTransactionQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|  4.76k|{
  777|  4.76k|    a.Unserialize(is);
  778|  4.76k|}
_Z11UnserializeI10SpanReaderR6CTxOutQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|  1.12M|{
  777|  1.12M|    a.Unserialize(is);
  778|  1.12M|}
_ZN6CTxOut11UnserializeI10SpanReaderEEvRT_:
  220|  1.12M|    {                                                                                               \
  221|  1.12M|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|  1.12M|        Unser(s, *this);                                                                            \
  223|  1.12M|    }
_ZN6CTxOut5UnserI10SpanReaderEEvRT_RS_:
  172|  1.12M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10SpanReaderJRlR7CScriptEEEvRT_DpOT0_:
 1086|  1.12M|    {
 1087|  1.12M|        ::UnserializeMany(s, args...);
 1088|  1.12M|    }
_Z15UnserializeManyI10SpanReaderJRlR7CScriptEEvRT_DpOT0_:
 1054|  1.12M|{
 1055|  1.12M|    (::Unserialize(s, args), ...);
 1056|  1.12M|}
_Z11UnserializeI10SpanReaderEvRT_Rl:
  271|  1.12M|template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  5.76k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  491|  5.26k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  491|  39.6k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z16GetSerializeSizeI6CTxOutEmRKT_:
 1158|  2.09k|{
 1159|  2.09k|    return (SizeComputer() << t).size();
 1160|  2.09k|}
_ZN12SizeComputerlsI6CTxOutEERS_RKT_:
 1134|  2.09k|    {
 1135|  2.09k|        ::Serialize(*this, obj);
 1136|  2.09k|        return *this;
 1137|  2.09k|    }
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsEC2ES1_RKS2_:
 1181|  4.76k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z14ser_readdata32I12ParamsStreamIR10SpanReader20TransactionSerParamsEEjRT_:
   94|   740k|{
   95|   740k|    uint32_t obj;
   96|   740k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   97|   740k|    return le32toh_internal(obj);
   98|   740k|}
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsE4readENSt3__14spanISt4byteLm18446744073709551615EEE:
 1190|  14.6M|    void read(std::span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsE9GetStreamEv:
 1208|  14.6M|    {
 1209|       |        if constexpr (ContainsStream<SubStream>) {
 1210|       |            return m_substream.GetStream();
 1211|  14.6M|        } else {
 1212|  14.6M|            return m_substream;
 1213|  14.6M|        }
 1214|  14.6M|    }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEvRT_Rj:
  270|   739k|template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
_Z15ReadCompactSizeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEmRT_b:
  334|  12.1M|{
  335|  12.1M|    uint8_t chSize = ser_readdata8(is);
  336|  12.1M|    uint64_t nSizeRet = 0;
  337|  12.1M|    if (chSize < 253)
  ------------------
  |  Branch (337:9): [True: 12.1M, False: 3.05k]
  ------------------
  338|  12.1M|    {
  339|  12.1M|        nSizeRet = chSize;
  340|  12.1M|    }
  341|  3.05k|    else if (chSize == 253)
  ------------------
  |  Branch (341:14): [True: 2.45k, False: 594]
  ------------------
  342|  2.45k|    {
  343|  2.45k|        nSizeRet = ser_readdata16(is);
  344|  2.45k|        if (nSizeRet < 253)
  ------------------
  |  Branch (344:13): [True: 8, False: 2.44k]
  ------------------
  345|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  346|  2.45k|    }
  347|    594|    else if (chSize == 254)
  ------------------
  |  Branch (347:14): [True: 393, False: 201]
  ------------------
  348|    393|    {
  349|    393|        nSizeRet = ser_readdata32(is);
  350|    393|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (350:13): [True: 17, False: 376]
  ------------------
  351|     17|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    393|    }
  353|    201|    else
  354|    201|    {
  355|    201|        nSizeRet = ser_readdata64(is);
  356|    201|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (356:13): [True: 36, False: 165]
  ------------------
  357|     36|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    201|    }
  359|  12.1M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (359:9): [True: 12.1M, False: 113]
  |  Branch (359:24): [True: 70, False: 12.1M]
  ------------------
  360|     70|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  361|     70|    }
  362|  12.1M|    return nSizeRet;
  363|  12.1M|}
_Z13ser_readdata8I12ParamsStreamIR10SpanReader20TransactionSerParamsEEhRT_:
   82|  12.1M|{
   83|  12.1M|    uint8_t obj;
   84|  12.1M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   85|  12.1M|    return obj;
   86|  12.1M|}
_Z14ser_readdata16I12ParamsStreamIR10SpanReader20TransactionSerParamsEEtRT_:
   88|  2.45k|{
   89|  2.45k|    uint16_t obj;
   90|  2.45k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   91|  2.45k|    return le16toh_internal(obj);
   92|  2.45k|}
_Z14ser_readdata64I12ParamsStreamIR10SpanReader20TransactionSerParamsEEmRT_:
  106|  1.12M|{
  107|  1.12M|    uint64_t obj;
  108|  1.12M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
  109|  1.12M|    return le64toh_internal(obj);
  110|  1.12M|}
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsErsIRjEERS3_OT_:
 1188|  8.84k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsErsIRNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_OT_:
 1188|  5.65k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  919|  5.65k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  5.65k|    } else {
  932|  5.65k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  5.65k|    }
  934|  5.65k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  776|  5.65k|{
  777|  5.65k|    a.Unserialize(is);
  778|  5.65k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  477|  5.65k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RT0_:
  680|  5.65k|    {
  681|  5.65k|        Formatter formatter;
  682|  5.65k|        v.clear();
  683|  5.65k|        size_t size = ReadCompactSize(s);
  684|  5.65k|        size_t allocated = 0;
  685|  9.99k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 4.34k, False: 5.65k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  4.34k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  4.34k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  4.34k|            v.reserve(allocated);
  692|   369k|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 365k, False: 4.34k]
  ------------------
  693|   365k|                v.emplace_back();
  694|   365k|                formatter.Unser(s, v.back());
  695|   365k|            }
  696|  4.34k|        }
  697|  5.65k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsE5CTxInEEvRT_RT0_:
  791|   365k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER5CTxInQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_ZN5CTxIn11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  220|   365k|    {                                                                                               \
  221|   365k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   365k|        Unser(s, *this);                                                                            \
  223|   365k|    }
_ZN5CTxIn5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_RS_:
  172|   365k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1086|   365k|    {
 1087|   365k|        ::UnserializeMany(s, args...);
 1088|   365k|    }
_Z15UnserializeManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1054|   365k|{
 1055|   365k|    (::Unserialize(s, args), ...);
 1056|   365k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER9COutPointQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_ZN9COutPoint11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  220|   365k|    {                                                                                               \
  221|   365k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   365k|        Unser(s, *this);                                                                            \
  223|   365k|    }
_ZN9COutPoint5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_RS_:
  172|   365k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1086|   365k|    {
 1087|   365k|        ::UnserializeMany(s, args...);
 1088|   365k|    }
_Z15UnserializeManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1054|   365k|{
 1055|   365k|    (::Unserialize(s, args), ...);
 1056|   365k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS9_OS8_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER7CScriptQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|  1.48M|{
  777|  1.48M|    a.Unserialize(is);
  778|  1.48M|}
_ZN7CScript11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  220|  1.48M|    {                                                                                               \
  221|  1.48M|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|  1.48M|        Unser(s, *this);                                                                            \
  223|  1.48M|    }
_ZN7CScript5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_RS_:
  172|  1.48M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR9prevectorILj36EhjiEEEEvRT_DpOT0_:
 1086|  1.48M|    {
 1087|  1.48M|        ::UnserializeMany(s, args...);
 1088|  1.48M|    }
_Z15UnserializeManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJR9prevectorILj36EhjiEEEvRT_DpOT0_:
 1054|  1.48M|{
 1055|  1.48M|    (::Unserialize(s, args), ...);
 1056|  1.48M|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsELj36EhEvRT_R9prevectorIXT0_ET1_jiE:
  876|  1.48M|{
  877|  1.48M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  878|       |        // Limit size per read so bogus size value won't cause out of memory
  879|  1.48M|        v.clear();
  880|  1.48M|        unsigned int nSize = ReadCompactSize(is);
  881|  1.48M|        unsigned int i = 0;
  882|  1.69M|        while (i < nSize) {
  ------------------
  |  Branch (882:16): [True: 206k, False: 1.48M]
  ------------------
  883|   206k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  884|   206k|            v.resize_uninitialized(i + blk);
  885|   206k|            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  886|   206k|            i += blk;
  887|   206k|        }
  888|       |    } else {
  889|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  890|       |    }
  891|  1.48M|}
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsErsIRhEERS3_OT_:
 1188|    994|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEvRT_Rh:
  266|    994|template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsErsIRNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_OT_:
 1188|  4.38k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  919|  4.38k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  4.38k|    } else {
  932|  4.38k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  4.38k|    }
  934|  4.38k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  776|  4.38k|{
  777|  4.38k|    a.Unserialize(is);
  778|  4.38k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  477|  4.38k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RT0_:
  680|  4.38k|    {
  681|  4.38k|        Formatter formatter;
  682|  4.38k|        v.clear();
  683|  4.38k|        size_t size = ReadCompactSize(s);
  684|  4.38k|        size_t allocated = 0;
  685|  7.08k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 2.70k, False: 4.38k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  2.70k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  2.70k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  2.70k|            v.reserve(allocated);
  692|  1.12M|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 1.12M, False: 2.70k]
  ------------------
  693|  1.12M|                v.emplace_back();
  694|  1.12M|                formatter.Unser(s, v.back());
  695|  1.12M|            }
  696|  2.70k|        }
  697|  4.38k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsE6CTxOutEEvRT_RT0_:
  791|  1.12M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsER6CTxOutQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|  1.12M|{
  777|  1.12M|    a.Unserialize(is);
  778|  1.12M|}
_ZN6CTxOut11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  220|  1.12M|    {                                                                                               \
  221|  1.12M|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|  1.12M|        Unser(s, *this);                                                                            \
  223|  1.12M|    }
_ZN6CTxOut5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_RS_:
  172|  1.12M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJRlR7CScriptEEEvRT_DpOT0_:
 1086|  1.12M|    {
 1087|  1.12M|        ::UnserializeMany(s, args...);
 1088|  1.12M|    }
_Z15UnserializeManyI12ParamsStreamIR10SpanReader20TransactionSerParamsEJRlR7CScriptEEvRT_DpOT0_:
 1054|  1.12M|{
 1055|  1.12M|    (::Unserialize(s, args), ...);
 1056|  1.12M|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEvRT_Rl:
  271|  1.12M|template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
_ZN12ParamsStreamIR10SpanReader20TransactionSerParamsErsIRNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_OT_:
 1188|  40.4k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RNS6_IT0_T1_EE:
  919|  40.4k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  40.4k|    } else {
  932|  40.4k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  40.4k|    }
  934|  40.4k|}
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ14UnserializableIT0_T_EEvRSJ_OSI_:
  776|  40.4k|{
  777|  40.4k|    a.Unserialize(is);
  778|  40.4k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  477|  40.4k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RT0_:
  680|  40.4k|    {
  681|  40.4k|        Formatter formatter;
  682|  40.4k|        v.clear();
  683|  40.4k|        size_t size = ReadCompactSize(s);
  684|  40.4k|        size_t allocated = 0;
  685|  45.9k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 5.48k, False: 40.4k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  5.48k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  5.48k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  5.48k|            v.reserve(allocated);
  692|  10.6M|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 10.6M, False: 5.48k]
  ------------------
  693|  10.6M|                v.emplace_back();
  694|  10.6M|                formatter.Unser(s, v.back());
  695|  10.6M|            }
  696|  5.48k|        }
  697|  40.4k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10SpanReader20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RT0_:
  791|  10.6M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RNS5_6vectorIT0_T1_EE:
  919|  10.6M|{
  920|  10.6M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|  10.6M|        v.clear();
  923|  10.6M|        unsigned int nSize = ReadCompactSize(is);
  924|  10.6M|        unsigned int i = 0;
  925|  10.6M|        while (i < nSize) {
  ------------------
  |  Branch (925:16): [True: 81.7k, False: 10.6M]
  ------------------
  926|  81.7k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|  81.7k|            v.resize(i + blk);
  928|  81.7k|            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|  81.7k|            i += blk;
  930|  81.7k|        }
  931|       |    } else {
  932|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|       |    }
  934|  10.6M|}
_ZNK12ParamsStreamIR10SpanReader20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1198|  4.76k|    {
 1199|  4.76k|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  4.76k|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  4.76k|    }
_Z15ser_writedata64I12SizeComputerEvRT_m:
   77|  2.09k|{
   78|  2.09k|    obj = htole64_internal(obj);
   79|  2.09k|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|  2.09k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsEC2ES1_RKS2_:
 1181|  12.0k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIjEERS3_RKT_:
 1187|  24.1k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j:
  254|   452k|template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j:
   67|   452k|{
   68|   452k|    obj = htole32_internal(obj);
   69|   452k|    s.write(std::as_bytes(std::span{&obj, 1}));
   70|   452k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1189|  13.3M|    void write(std::span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE9GetStreamEv:
 1208|  13.3M|    {
 1209|       |        if constexpr (ContainsStream<SubStream>) {
 1210|       |            return m_substream.GetStream();
 1211|  13.3M|        } else {
 1212|  13.3M|            return m_substream;
 1213|  13.3M|        }
 1214|  13.3M|    }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  13.5k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  13.5k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  13.5k|    } else {
  912|  13.5k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  13.5k|    }
  914|  13.5k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  13.5k|{
  768|  13.5k|    a.Serialize(os);
  769|  13.5k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  476|  13.5k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  13.5k|    {
  671|  13.5k|        Formatter formatter;
  672|  13.5k|        WriteCompactSize(s, v.size());
  673|   214k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 214k, False: 13.5k]
  ------------------
  674|   214k|            formatter.Ser(s, elem);
  675|   214k|        }
  676|  13.5k|    }
_Z16WriteCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m:
  303|  10.9M|{
  304|  10.9M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 10.9M, False: 6.15k]
  ------------------
  305|  10.9M|    {
  306|  10.9M|        ser_writedata8(os, nSize);
  307|  10.9M|    }
  308|  6.15k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 5.90k, False: 252]
  ------------------
  309|  5.90k|    {
  310|  5.90k|        ser_writedata8(os, 253);
  311|  5.90k|        ser_writedata16(os, nSize);
  312|  5.90k|    }
  313|    252|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 252, False: 0]
  ------------------
  314|    252|    {
  315|    252|        ser_writedata8(os, 254);
  316|    252|        ser_writedata32(os, nSize);
  317|    252|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  10.9M|    return;
  324|  10.9M|}
_Z14ser_writedata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h:
   58|  10.9M|{
   59|  10.9M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  10.9M|}
_Z15ser_writedata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_t:
   62|  5.90k|{
   63|  5.90k|    obj = htole16_internal(obj);
   64|  5.90k|    s.write(std::as_bytes(std::span{&obj, 1}));
   65|  5.90k|}
_Z15ser_writedata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m:
   77|  1.07M|{
   78|  1.07M|    obj = htole64_internal(obj);
   79|  1.07M|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|  1.07M|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  788|   214k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   214k|{
  768|   214k|    a.Serialize(os);
  769|   214k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  214|   214k|    {                                                                                               \
  215|   214k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   214k|        Ser(s, *this);                                                                              \
  217|   214k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  170|   214k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1066|   214k|    {
 1067|   214k|        ::SerializeMany(s, args...);
 1068|   214k|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
 1048|   214k|{
 1049|   214k|    (::Serialize(s, args), ...);
 1050|   214k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   214k|{
  768|   214k|    a.Serialize(os);
  769|   214k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  214|   214k|    {                                                                                               \
  215|   214k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   214k|        Ser(s, *this);                                                                              \
  217|   214k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  170|   214k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1066|   214k|    {
 1067|   214k|        ::SerializeMany(s, args...);
 1068|   214k|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
 1048|   214k|{
 1049|   214k|    (::Serialize(s, args), ...);
 1050|   214k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  767|   214k|{
  768|   214k|    a.Serialize(os);
  769|   214k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__14spanIKhLm32EEEEERS3_RKT_:
 1187|   214k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsETk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|   214k|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  1.29M|{
  768|  1.29M|    a.Serialize(os);
  769|  1.29M|}
_ZNK7CScript9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  214|  1.29M|    {                                                                                               \
  215|  1.29M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.29M|        Ser(s, *this);                                                                              \
  217|  1.29M|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  170|  1.29M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj36EhjiEEEEvRT_DpRKT0_:
 1066|  1.29M|    {
 1067|  1.29M|        ::SerializeMany(s, args...);
 1068|  1.29M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj36EhjiEEEvRT_DpRKT0_:
 1048|  1.29M|{
 1049|  1.29M|    (::Serialize(s, args), ...);
 1050|  1.29M|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj36EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|  1.29M|{
  865|  1.29M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|  1.29M|        WriteCompactSize(os, v.size());
  867|  1.29M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 576k, False: 717k]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|  1.29M|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIhEERS3_RKT_:
 1187|  1.44k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h:
  250|  1.44k|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  12.0k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  12.0k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  12.0k|    } else {
  912|  12.0k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  12.0k|    }
  914|  12.0k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  12.0k|{
  768|  12.0k|    a.Serialize(os);
  769|  12.0k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  476|  12.0k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  12.0k|    {
  671|  12.0k|        Formatter formatter;
  672|  12.0k|        WriteCompactSize(s, v.size());
  673|  1.07M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 1.07M, False: 12.0k]
  ------------------
  674|  1.07M|            formatter.Ser(s, elem);
  675|  1.07M|        }
  676|  12.0k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  788|  1.07M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  1.07M|{
  768|  1.07M|    a.Serialize(os);
  769|  1.07M|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  214|  1.07M|    {                                                                                               \
  215|  1.07M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.07M|        Ser(s, *this);                                                                              \
  217|  1.07M|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  170|  1.07M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1066|  1.07M|    {
 1067|  1.07M|        ::SerializeMany(s, args...);
 1068|  1.07M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
 1048|  1.07M|{
 1049|  1.07M|    (::Serialize(s, args), ...);
 1050|  1.07M|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_l:
  255|  1.07M|template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1187|   101k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  899|   101k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|   101k|    } else {
  912|   101k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|   101k|    }
  914|   101k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  767|   101k|{
  768|   101k|    a.Serialize(os);
  769|   101k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  476|   101k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  670|   101k|    {
  671|   101k|        Formatter formatter;
  672|   101k|        WriteCompactSize(s, v.size());
  673|  9.51M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 9.51M, False: 101k]
  ------------------
  674|  9.51M|            formatter.Ser(s, elem);
  675|  9.51M|        }
  676|   101k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  788|  9.51M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  899|  9.51M|{
  900|  9.51M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|  9.51M|        WriteCompactSize(os, v.size());
  902|  9.51M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (902:13): [True: 129k, False: 9.38M]
  ------------------
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|       |    } else {
  912|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|       |    }
  914|  9.51M|}
_ZNK12ParamsStreamIR10DataStream20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1198|  12.0k|    {
 1199|  12.0k|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  12.0k|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  12.0k|    }
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionEC2ERKS0_RS1_:
 1249|  4.76k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  12.0k|{
  768|  12.0k|    a.Serialize(os);
  769|  12.0k|}
_Z9SerializeI12SizeComputer6CTxOutQ12SerializableIT0_T_EEvRS3_RKS2_:
  767|  2.09k|{
  768|  2.09k|    a.Serialize(os);
  769|  2.09k|}
_ZNK6CTxOut9SerializeI12SizeComputerEEvRT_:
  214|  2.09k|    {                                                                                               \
  215|  2.09k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  2.09k|        Ser(s, *this);                                                                              \
  217|  2.09k|    }                                                                                               \
_ZN6CTxOut3SerI12SizeComputerEEvRT_RKS_:
  170|  2.09k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJl7CScriptEEEvRT_DpRKT0_:
 1066|  2.09k|    {
 1067|  2.09k|        ::SerializeMany(s, args...);
 1068|  2.09k|    }
_Z13SerializeManyI12SizeComputerJl7CScriptEEvRT_DpRKT0_:
 1048|  2.09k|{
 1049|  2.09k|    (::Serialize(s, args), ...);
 1050|  2.09k|}
_Z9SerializeI12SizeComputerEvRT_l:
  255|  2.09k|template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
_Z9SerializeI12SizeComputer7CScriptQ12SerializableIT0_T_EEvRS3_RKS2_:
  767|  2.09k|{
  768|  2.09k|    a.Serialize(os);
  769|  2.09k|}
_ZNK7CScript9SerializeI12SizeComputerEEvRT_:
  214|  2.09k|    {                                                                                               \
  215|  2.09k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  2.09k|        Ser(s, *this);                                                                              \
  217|  2.09k|    }                                                                                               \
_ZN7CScript3SerI12SizeComputerEEvRT_RKS_:
  170|  2.09k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJ9prevectorILj36EhjiEEEEvRT_DpRKT0_:
 1066|  2.09k|    {
 1067|  2.09k|        ::SerializeMany(s, args...);
 1068|  2.09k|    }
_Z13SerializeManyI12SizeComputerJ9prevectorILj36EhjiEEEvRT_DpRKT0_:
 1048|  2.09k|{
 1049|  2.09k|    (::Serialize(s, args), ...);
 1050|  2.09k|}
_Z9SerializeI12SizeComputerLj36EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|  2.09k|{
  865|  2.09k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|  2.09k|        WriteCompactSize(os, v.size());
  867|  2.09k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 2.09k, False: 0]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|  2.09k|}
_ZNK20TransactionSerParamsclIR19CMutableTransactionEEDaOT_:
 1282|  4.76k|    {                                                                                    \
 1283|  4.76k|        return ParamsWrapper{*this, t};                                                  \
 1284|  4.76k|    }
_Z11UnserializeI10SpanReaderEvRT_Rj:
  270|   739k|template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
_Z11UnserializeI10SpanReaderR7CScriptQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|  1.48M|{
  777|  1.48M|    a.Unserialize(is);
  778|  1.48M|}
_ZN7CScript11UnserializeI10SpanReaderEEvRT_:
  220|  1.48M|    {                                                                                               \
  221|  1.48M|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|  1.48M|        Unser(s, *this);                                                                            \
  223|  1.48M|    }
_ZN7CScript5UnserI10SpanReaderEEvRT_RS_:
  172|  1.48M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10SpanReaderJR9prevectorILj36EhjiEEEEvRT_DpOT0_:
 1086|  1.48M|    {
 1087|  1.48M|        ::UnserializeMany(s, args...);
 1088|  1.48M|    }
_Z15UnserializeManyI10SpanReaderJR9prevectorILj36EhjiEEEvRT_DpOT0_:
 1054|  1.48M|{
 1055|  1.48M|    (::Unserialize(s, args), ...);
 1056|  1.48M|}
_Z11UnserializeI10SpanReaderLj36EhEvRT_R9prevectorIXT0_ET1_jiE:
  876|  1.48M|{
  877|  1.48M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  878|       |        // Limit size per read so bogus size value won't cause out of memory
  879|  1.48M|        v.clear();
  880|  1.48M|        unsigned int nSize = ReadCompactSize(is);
  881|  1.48M|        unsigned int i = 0;
  882|  1.69M|        while (i < nSize) {
  ------------------
  |  Branch (882:16): [True: 206k, False: 1.48M]
  ------------------
  883|   206k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  884|   206k|            v.resize_uninitialized(i + blk);
  885|   206k|            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  886|   206k|            i += blk;
  887|   206k|        }
  888|       |    } else {
  889|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  890|       |    }
  891|  1.48M|}
_Z11UnserializeI10SpanReaderNSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEvRT_RNS2_IT0_T1_EE:
  919|  40.4k|{
  920|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|       |        v.clear();
  923|       |        unsigned int nSize = ReadCompactSize(is);
  924|       |        unsigned int i = 0;
  925|       |        while (i < nSize) {
  926|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|       |            v.resize(i + blk);
  928|       |            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|       |            i += blk;
  930|       |        }
  931|  40.4k|    } else {
  932|  40.4k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|  40.4k|    }
  934|  40.4k|}
_Z11UnserializeI10SpanReader7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEQ14UnserializableIT0_T_EEvRSF_OSE_:
  776|  40.4k|{
  777|  40.4k|    a.Unserialize(is);
  778|  40.4k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI10SpanReaderEEvRT_:
  477|  40.4k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10SpanReaderNSt3__16vectorINS5_IhNS4_9allocatorIhEEEENS6_IS8_EEEEEEvRT_RT0_:
  680|  40.4k|    {
  681|  40.4k|        Formatter formatter;
  682|  40.4k|        v.clear();
  683|  40.4k|        size_t size = ReadCompactSize(s);
  684|  40.4k|        size_t allocated = 0;
  685|  45.9k|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 5.48k, False: 40.4k]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|  5.48k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|  5.48k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|  5.48k|            v.reserve(allocated);
  692|  10.6M|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 10.6M, False: 5.48k]
  ------------------
  693|  10.6M|                v.emplace_back();
  694|  10.6M|                formatter.Unser(s, v.back());
  695|  10.6M|            }
  696|  5.48k|        }
  697|  40.4k|    };
_ZN16DefaultFormatter5UnserI10SpanReaderNSt3__16vectorIhNS2_9allocatorIhEEEEEEvRT_RT0_:
  791|  10.6M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI10SpanReaderhNSt3__19allocatorIhEEEvRT_RNS1_6vectorIT0_T1_EE:
  919|  10.6M|{
  920|  10.6M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  921|       |        // Limit size per read so bogus size value won't cause out of memory
  922|  10.6M|        v.clear();
  923|  10.6M|        unsigned int nSize = ReadCompactSize(is);
  924|  10.6M|        unsigned int i = 0;
  925|  10.6M|        while (i < nSize) {
  ------------------
  |  Branch (925:16): [True: 81.7k, False: 10.6M]
  ------------------
  926|  81.7k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  927|  81.7k|            v.resize(i + blk);
  928|  81.7k|            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
  929|  81.7k|            i += blk;
  930|  81.7k|        }
  931|       |    } else {
  932|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  933|       |    }
  934|  10.6M|}
_Z13ser_readdata8I10SpanReaderEhRT_:
   82|  12.1M|{
   83|  12.1M|    uint8_t obj;
   84|  12.1M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   85|  12.1M|    return obj;
   86|  12.1M|}
_Z15ReadCompactSizeI10SpanReaderEmRT_b:
  334|  12.1M|{
  335|  12.1M|    uint8_t chSize = ser_readdata8(is);
  336|  12.1M|    uint64_t nSizeRet = 0;
  337|  12.1M|    if (chSize < 253)
  ------------------
  |  Branch (337:9): [True: 12.1M, False: 3.05k]
  ------------------
  338|  12.1M|    {
  339|  12.1M|        nSizeRet = chSize;
  340|  12.1M|    }
  341|  3.05k|    else if (chSize == 253)
  ------------------
  |  Branch (341:14): [True: 2.45k, False: 594]
  ------------------
  342|  2.45k|    {
  343|  2.45k|        nSizeRet = ser_readdata16(is);
  344|  2.45k|        if (nSizeRet < 253)
  ------------------
  |  Branch (344:13): [True: 8, False: 2.44k]
  ------------------
  345|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  346|  2.45k|    }
  347|    594|    else if (chSize == 254)
  ------------------
  |  Branch (347:14): [True: 393, False: 201]
  ------------------
  348|    393|    {
  349|    393|        nSizeRet = ser_readdata32(is);
  350|    393|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (350:13): [True: 17, False: 376]
  ------------------
  351|     17|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    393|    }
  353|    201|    else
  354|    201|    {
  355|    201|        nSizeRet = ser_readdata64(is);
  356|    201|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (356:13): [True: 36, False: 165]
  ------------------
  357|     36|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    201|    }
  359|  12.1M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (359:9): [True: 12.1M, False: 113]
  |  Branch (359:24): [True: 70, False: 12.1M]
  ------------------
  360|     70|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  361|     70|    }
  362|  12.1M|    return nSizeRet;
  363|  12.1M|}
_Z14ser_readdata16I10SpanReaderEtRT_:
   88|  2.45k|{
   89|  2.45k|    uint16_t obj;
   90|  2.45k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   91|  2.45k|    return le16toh_internal(obj);
   92|  2.45k|}
_Z14ser_readdata32I10SpanReaderEjRT_:
   94|   740k|{
   95|   740k|    uint32_t obj;
   96|   740k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   97|   740k|    return le32toh_internal(obj);
   98|   740k|}
_Z14ser_readdata64I10SpanReaderEmRT_:
  106|  1.12M|{
  107|  1.12M|    uint64_t obj;
  108|  1.12M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
  109|  1.12M|    return le64toh_internal(obj);
  110|  1.12M|}
_Z11UnserializeI10SpanReaderEvRT_Rh:
  266|    994|template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
_Z11UnserializeI10SpanReaderR22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS5_OS4_:
  776|   365k|{
  777|   365k|    a.Unserialize(is);
  778|   365k|}
_Z6AsBaseI9prevectorILj36EhjiE7CScriptERT_RT0_:
  137|  2.97M|{
  138|  2.97M|    static_assert(std::is_base_of_v<Out, In>);
  139|  2.97M|    return x;
  140|  2.97M|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ES9_:
  475|  11.3k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ES9_:
  475|  8.76k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESA_:
  475|  80.9k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK20TransactionSerParamsclIRK12CTransactionEEDaOT_:
 1282|  93.0k|    {                                                                                    \
 1283|  93.0k|        return ParamsWrapper{*this, t};                                                  \
 1284|  93.0k|    }
_Z16GetSerializeSizeI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEmRKT_:
 1158|  75.6k|{
 1159|  75.6k|    return (SizeComputer() << t).size();
 1160|  75.6k|}
_ZN12SizeComputerlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
 1134|  75.6k|    {
 1135|  75.6k|        ::Serialize(*this, obj);
 1136|  75.6k|        return *this;
 1137|  75.6k|    }
_Z9SerializeI12SizeComputer13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  75.6k|{
  768|  75.6k|    a.Serialize(os);
  769|  75.6k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI12SizeComputerEEvRT_:
 1253|  75.6k|    {
 1254|  75.6k|        ParamsStream ss{s, m_params};
 1255|  75.6k|        ::Serialize(ss, m_object);
 1256|  75.6k|    }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  75.6k|{
  768|  75.6k|    a.Serialize(os);
  769|  75.6k|}
_ZNK12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1198|  75.6k|    {
 1199|  75.6k|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  75.6k|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  75.6k|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsIjEERS3_RKT_:
 1187|   151k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
  254|  2.76M|template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
   67|  2.76M|{
   68|  2.76M|    obj = htole32_internal(obj);
   69|  2.76M|    s.write(std::as_bytes(std::span{&obj, 1}));
   70|  2.76M|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetStreamEv:
 1208|  66.8M|    {
 1209|       |        if constexpr (ContainsStream<SubStream>) {
 1210|       |            return m_substream.GetStream();
 1211|  66.8M|        } else {
 1212|  66.8M|            return m_substream;
 1213|  66.8M|        }
 1214|  66.8M|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1189|  66.8M|    void write(std::span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  81.0k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  81.0k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  81.0k|    } else {
  912|  81.0k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  81.0k|    }
  914|  81.0k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  81.0k|{
  768|  81.0k|    a.Serialize(os);
  769|  81.0k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  476|  81.0k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  81.0k|    {
  671|  81.0k|        Formatter formatter;
  672|  81.0k|        WriteCompactSize(s, v.size());
  673|  1.30M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 1.30M, False: 81.0k]
  ------------------
  674|  1.30M|            formatter.Ser(s, elem);
  675|  1.30M|        }
  676|  81.0k|    }
_Z16WriteCompactSizeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
  303|  50.3M|{
  304|  50.3M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 50.3M, False: 35.7k]
  ------------------
  305|  50.3M|    {
  306|  50.3M|        ser_writedata8(os, nSize);
  307|  50.3M|    }
  308|  35.7k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 34.4k, False: 1.28k]
  ------------------
  309|  34.4k|    {
  310|  34.4k|        ser_writedata8(os, 253);
  311|  34.4k|        ser_writedata16(os, nSize);
  312|  34.4k|    }
  313|  1.28k|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 1.28k, False: 0]
  ------------------
  314|  1.28k|    {
  315|  1.28k|        ser_writedata8(os, 254);
  316|  1.28k|        ser_writedata32(os, nSize);
  317|  1.28k|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  50.3M|    return;
  324|  50.3M|}
_Z14ser_writedata8I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
   58|  50.3M|{
   59|  50.3M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  50.3M|}
_Z15ser_writedata16I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_t:
   62|  34.4k|{
   63|  34.4k|    obj = htole16_internal(obj);
   64|  34.4k|    s.write(std::as_bytes(std::span{&obj, 1}));
   65|  34.4k|}
_Z15ser_writedata64I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
   77|  7.96M|{
   78|  7.96M|    obj = htole64_internal(obj);
   79|  7.96M|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|  7.96M|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  788|  1.30M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  1.30M|{
  768|  1.30M|    a.Serialize(os);
  769|  1.30M|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  214|  1.30M|    {                                                                                               \
  215|  1.30M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.30M|        Ser(s, *this);                                                                              \
  217|  1.30M|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  170|  1.30M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1066|  1.30M|    {
 1067|  1.30M|        ::SerializeMany(s, args...);
 1068|  1.30M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
 1048|  1.30M|{
 1049|  1.30M|    (::Serialize(s, args), ...);
 1050|  1.30M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  9.27M|{
  768|  9.27M|    a.Serialize(os);
  769|  9.27M|}
_ZNK7CScript9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  214|  9.27M|    {                                                                                               \
  215|  9.27M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  9.27M|        Ser(s, *this);                                                                              \
  217|  9.27M|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  170|  9.27M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_Z6AsBaseI9prevectorILj36EhjiE7CScriptERKT_RKT0_:
  143|  11.4M|{
  144|  11.4M|    static_assert(std::is_base_of_v<Out, In>);
  145|  11.4M|    return x;
  146|  11.4M|}
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj36EhjiEEEEvRT_DpRKT0_:
 1066|  9.27M|    {
 1067|  9.27M|        ::SerializeMany(s, args...);
 1068|  9.27M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj36EhjiEEEvRT_DpRKT0_:
 1048|  9.27M|{
 1049|  9.27M|    (::Serialize(s, args), ...);
 1050|  9.27M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsELj36EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|  9.27M|{
  865|  9.27M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|  9.27M|        WriteCompactSize(os, v.size());
  867|  9.27M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 3.93M, False: 5.33M]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|  9.27M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  1.30M|{
  768|  1.30M|    a.Serialize(os);
  769|  1.30M|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  214|  1.30M|    {                                                                                               \
  215|  1.30M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.30M|        Ser(s, *this);                                                                              \
  217|  1.30M|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  170|  1.30M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1066|  1.30M|    {
 1067|  1.30M|        ::SerializeMany(s, args...);
 1068|  1.30M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
 1048|  1.30M|{
 1049|  1.30M|    (::Serialize(s, args), ...);
 1050|  1.30M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  767|  1.30M|{
  768|  1.30M|    a.Serialize(os);
  769|  1.30M|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__14spanIKhLm32EEEEERS3_RKT_:
 1187|  1.30M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsETk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|  1.30M|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsIhEERS3_RKT_:
 1187|  5.36k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
  250|  5.36k|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  75.6k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  75.6k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  75.6k|    } else {
  912|  75.6k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  75.6k|    }
  914|  75.6k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  75.6k|{
  768|  75.6k|    a.Serialize(os);
  769|  75.6k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  476|  75.6k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  75.6k|    {
  671|  75.6k|        Formatter formatter;
  672|  75.6k|        WriteCompactSize(s, v.size());
  673|  7.96M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 7.96M, False: 75.6k]
  ------------------
  674|  7.96M|            formatter.Ser(s, elem);
  675|  7.96M|        }
  676|  75.6k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  788|  7.96M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  7.96M|{
  768|  7.96M|    a.Serialize(os);
  769|  7.96M|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  214|  7.96M|    {                                                                                               \
  215|  7.96M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  7.96M|        Ser(s, *this);                                                                              \
  217|  7.96M|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  170|  7.96M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1066|  7.96M|    {
 1067|  7.96M|        ::SerializeMany(s, args...);
 1068|  7.96M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
 1048|  7.96M|{
 1049|  7.96M|    (::Serialize(s, args), ...);
 1050|  7.96M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_l:
  255|  7.96M|template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1187|   382k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  899|   382k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|   382k|    } else {
  912|   382k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|   382k|    }
  914|   382k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  767|   382k|{
  768|   382k|    a.Serialize(os);
  769|   382k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  476|   382k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  670|   382k|    {
  671|   382k|        Formatter formatter;
  672|   382k|        WriteCompactSize(s, v.size());
  673|  40.5M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 40.5M, False: 382k]
  ------------------
  674|  40.5M|            formatter.Ser(s, elem);
  675|  40.5M|        }
  676|   382k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  788|  40.5M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  899|  40.5M|{
  900|  40.5M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|  40.5M|        WriteCompactSize(os, v.size());
  902|  40.5M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (902:13): [True: 494k, False: 40.0M]
  ------------------
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|       |    } else {
  912|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|       |    }
  914|  40.5M|}
_ZN13ParamsWrapperI20TransactionSerParamsK12CTransactionEC2ERKS0_RS2_:
 1249|  93.0k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsEC2ES1_RKS2_:
 1181|  5.26k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIjEERS3_RKT_:
 1187|  10.5k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
  254|   276k|template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
   67|   276k|{
   68|   276k|    obj = htole32_internal(obj);
   69|   276k|    s.write(std::as_bytes(std::span{&obj, 1}));
   70|   276k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1189|  8.17M|    void write(std::span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetStreamEv:
 1208|  8.17M|    {
 1209|       |        if constexpr (ContainsStream<SubStream>) {
 1210|       |            return m_substream.GetStream();
 1211|  8.17M|        } else {
 1212|  8.17M|            return m_substream;
 1213|  8.17M|        }
 1214|  8.17M|    }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  5.76k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  5.76k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  5.76k|    } else {
  912|  5.76k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  5.76k|    }
  914|  5.76k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  5.76k|{
  768|  5.76k|    a.Serialize(os);
  769|  5.76k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  476|  5.76k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  5.76k|    {
  671|  5.76k|        Formatter formatter;
  672|  5.76k|        WriteCompactSize(s, v.size());
  673|   132k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 132k, False: 5.76k]
  ------------------
  674|   132k|            formatter.Ser(s, elem);
  675|   132k|        }
  676|  5.76k|    }
_Z16WriteCompactSizeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
  303|  6.54M|{
  304|  6.54M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 6.54M, False: 3.15k]
  ------------------
  305|  6.54M|    {
  306|  6.54M|        ser_writedata8(os, nSize);
  307|  6.54M|    }
  308|  3.15k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 2.99k, False: 151]
  ------------------
  309|  2.99k|    {
  310|  2.99k|        ser_writedata8(os, 253);
  311|  2.99k|        ser_writedata16(os, nSize);
  312|  2.99k|    }
  313|    151|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 151, False: 0]
  ------------------
  314|    151|    {
  315|    151|        ser_writedata8(os, 254);
  316|    151|        ser_writedata32(os, nSize);
  317|    151|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  6.54M|    return;
  324|  6.54M|}
_Z14ser_writedata8I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
   58|  6.54M|{
   59|  6.54M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  6.54M|}
_Z15ser_writedata16I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_t:
   62|  2.99k|{
   63|  2.99k|    obj = htole16_internal(obj);
   64|  2.99k|    s.write(std::as_bytes(std::span{&obj, 1}));
   65|  2.99k|}
_Z15ser_writedata64I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
   77|   794k|{
   78|   794k|    obj = htole64_internal(obj);
   79|   794k|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|   794k|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  788|   132k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   132k|{
  768|   132k|    a.Serialize(os);
  769|   132k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  214|   132k|    {                                                                                               \
  215|   132k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   132k|        Ser(s, *this);                                                                              \
  217|   132k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  170|   132k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1066|   132k|    {
 1067|   132k|        ::SerializeMany(s, args...);
 1068|   132k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
 1048|   132k|{
 1049|   132k|    (::Serialize(s, args), ...);
 1050|   132k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   132k|{
  768|   132k|    a.Serialize(os);
  769|   132k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  214|   132k|    {                                                                                               \
  215|   132k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   132k|        Ser(s, *this);                                                                              \
  217|   132k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  170|   132k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1066|   132k|    {
 1067|   132k|        ::SerializeMany(s, args...);
 1068|   132k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
 1048|   132k|{
 1049|   132k|    (::Serialize(s, args), ...);
 1050|   132k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  767|   132k|{
  768|   132k|    a.Serialize(os);
  769|   132k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__14spanIKhLm32EEEEERS3_RKT_:
 1187|   132k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsETk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|   132k|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   927k|{
  768|   927k|    a.Serialize(os);
  769|   927k|}
_ZNK7CScript9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  214|   927k|    {                                                                                               \
  215|   927k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   927k|        Ser(s, *this);                                                                              \
  217|   927k|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  170|   927k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj36EhjiEEEEvRT_DpRKT0_:
 1066|   927k|    {
 1067|   927k|        ::SerializeMany(s, args...);
 1068|   927k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj36EhjiEEEvRT_DpRKT0_:
 1048|   927k|{
 1049|   927k|    (::Serialize(s, args), ...);
 1050|   927k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsELj36EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|   927k|{
  865|   927k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|   927k|        WriteCompactSize(os, v.size());
  867|   927k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 349k, False: 577k]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|   927k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ESA_:
  475|   100k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIhEERS3_RKT_:
 1187|    500|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
  250|    500|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1187|  5.26k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  899|  5.26k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  5.26k|    } else {
  912|  5.26k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  5.26k|    }
  914|  5.26k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  767|  5.26k|{
  768|  5.26k|    a.Serialize(os);
  769|  5.26k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  476|  5.26k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  670|  5.26k|    {
  671|  5.26k|        Formatter formatter;
  672|  5.26k|        WriteCompactSize(s, v.size());
  673|   794k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 794k, False: 5.26k]
  ------------------
  674|   794k|            formatter.Ser(s, elem);
  675|   794k|        }
  676|  5.26k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  788|   794k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|   794k|{
  768|   794k|    a.Serialize(os);
  769|   794k|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  214|   794k|    {                                                                                               \
  215|   794k|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|   794k|        Ser(s, *this);                                                                              \
  217|   794k|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  170|   794k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1066|   794k|    {
 1067|   794k|        ::SerializeMany(s, args...);
 1068|   794k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
 1048|   794k|{
 1049|   794k|    (::Serialize(s, args), ...);
 1050|   794k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_l:
  255|   794k|template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ESA_:
  475|  93.0k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1187|  39.6k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  899|  39.6k|{
  900|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|       |        WriteCompactSize(os, v.size());
  902|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|  39.6k|    } else {
  912|  39.6k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|  39.6k|    }
  914|  39.6k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  767|  39.6k|{
  768|  39.6k|    a.Serialize(os);
  769|  39.6k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  476|  39.6k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  670|  39.6k|    {
  671|  39.6k|        Formatter formatter;
  672|  39.6k|        WriteCompactSize(s, v.size());
  673|  5.56M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (673:49): [True: 5.56M, False: 39.6k]
  ------------------
  674|  5.56M|            formatter.Ser(s, elem);
  675|  5.56M|        }
  676|  39.6k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  788|  5.56M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  899|  5.56M|{
  900|  5.56M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|  5.56M|        WriteCompactSize(os, v.size());
  902|  5.56M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (902:13): [True: 68.0k, False: 5.50M]
  ------------------
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|       |    } else {
  912|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|       |    }
  914|  5.56M|}
_ZNK12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1198|  5.26k|    {
 1199|  5.26k|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  5.26k|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  5.26k|    }
_Z9SerializeI10HashWriter13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  5.26k|{
  768|  5.26k|    a.Serialize(os);
  769|  5.26k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10HashWriterEEvRT_:
 1253|  5.26k|    {
 1254|  5.26k|        ParamsStream ss{s, m_params};
 1255|  5.26k|        ::Serialize(ss, m_object);
 1256|  5.26k|    }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  767|  5.26k|{
  768|  5.26k|    a.Serialize(os);
  769|  5.26k|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsEC2ES1_RKS2_:
 1181|  75.6k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN12SizeComputerC2Ev:
 1119|  77.7k|    SizeComputer() = default;
_Z16WriteCompactSizeR12SizeComputerm:
 1152|  2.09k|{
 1153|  2.09k|    s.seek(GetSizeOfCompactSize(nSize));
 1154|  2.09k|}
_ZN12SizeComputer4seekEm:
 1128|  2.09k|    {
 1129|  2.09k|        m_size += num;
 1130|  2.09k|    }
_Z20GetSizeOfCompactSizem:
  292|  2.09k|{
  293|  2.09k|    if (nSize < 253)             return sizeof(unsigned char);
  ------------------
  |  Branch (293:9): [True: 2.09k, False: 0]
  ------------------
  294|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
  ------------------
  |  Branch (294:14): [True: 0, False: 0]
  ------------------
  295|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())  return sizeof(unsigned char) + sizeof(unsigned int);
  ------------------
  |  Branch (295:14): [True: 0, False: 0]
  ------------------
  296|      0|    else                         return sizeof(unsigned char) + sizeof(uint64_t);
  297|  2.09k|}
_ZN12SizeComputer5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1122|  66.8M|    {
 1123|  66.8M|        m_size += src.size();
 1124|  66.8M|    }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESB_:
  475|   523k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK12SizeComputer4sizeEv:
 1140|  77.7k|    {
 1141|  77.7k|        return m_size;
 1142|  77.7k|    }

_Z13MakeUCharSpanINSt3__16vectorIhNS0_9allocatorIhEEEEEDTcl13UCharSpanCasttlNS0_4spanEfp_EEERKT_:
  111|  56.4k|template <typename V> constexpr auto MakeUCharSpan(const V& v) -> decltype(UCharSpanCast(std::span{v})) { return UCharSpanCast(std::span{v}); }
_Z13MakeUCharSpanINSt3__14spanIKSt4byteLm18446744073709551615EEEEDTcl13UCharSpanCasttlS1_fp_EEERKT_:
  111|  12.0k|template <typename V> constexpr auto MakeUCharSpan(const V& v) -> decltype(UCharSpanCast(std::span{v})) { return UCharSpanCast(std::span{v}); }
_Z13UCharSpanCastIKSt4byteLm18446744073709551615EEDaNSt3__14spanIT_XT0_EEE:
  108|  12.0k|template <typename T, size_t N> constexpr auto UCharSpanCast(std::span<T, N> s) { return std::span<std::remove_pointer_t<decltype(UCharCast(s.data()))>, N>{UCharCast(s.data()), s.size()}; }
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEEDaOT_:
   90|   731k|{
   91|   731k|    return std::as_writable_bytes(std::span{std::forward<V>(v)});
   92|   731k|}
_Z12MakeByteSpanI9prevectorILj36EhjiEEDaRKT_:
   85|  4.86M|{
   86|  4.86M|    return std::as_bytes(std::span{v});
   87|  4.86M|}
_Z12MakeByteSpanINSt3__16vectorIhNS0_9allocatorIhEEEEEDaRKT_:
   85|   692k|{
   86|   692k|    return std::as_bytes(std::span{v});
   87|   692k|}
_Z13MakeUCharSpanINSt3__14spanIKhLm18446744073709551615EEEEDTcl13UCharSpanCasttlS1_fp_EEERKT_:
  111|  26.4k|template <typename V> constexpr auto MakeUCharSpan(const V& v) -> decltype(UCharSpanCast(std::span{v})) { return UCharSpanCast(std::span{v}); }
_Z13UCharSpanCastIKhLm18446744073709551615EEDaNSt3__14spanIT_XT0_EEE:
  108|  82.9k|template <typename T, size_t N> constexpr auto UCharSpanCast(std::span<T, N> s) { return std::span<std::remove_pointer_t<decltype(UCharCast(s.data()))>, N>{UCharCast(s.data()), s.size()}; }
_Z9UCharCastPKh:
  100|  82.9k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
_Z12MakeByteSpanI7uint256EDaRKT_:
   85|  12.9k|{
   86|  12.9k|    return std::as_bytes(std::span{v});
   87|  12.9k|}
_Z9UCharCastPKSt4byte:
  102|  8.18M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }

_ZN10SpanReaderrsIRNSt3__16vectorI5CTxInNS1_9allocatorIS3_EEEEEERS_OT_:
   96|  5.65k|    {
   97|  5.65k|        ::Unserialize(*this, obj);
   98|  5.65k|        return (*this);
   99|  5.65k|    }
_ZN10SpanReaderrsIRNSt3__16vectorI6CTxOutNS1_9allocatorIS3_EEEEEERS_OT_:
   96|  4.38k|    {
   97|  4.38k|        ::Unserialize(*this, obj);
   98|  4.38k|        return (*this);
   99|  4.38k|    }
_ZN10SpanReaderrsI13ParamsWrapperI20TransactionSerParams19CMutableTransactionEEERS_OT_:
   96|  4.76k|    {
   97|  4.76k|        ::Unserialize(*this, obj);
   98|  4.76k|        return (*this);
   99|  4.76k|    }
_ZN10DataStreamlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
  252|  12.0k|    {
  253|  12.0k|        ::Serialize(*this, obj);
  254|  12.0k|        return (*this);
  255|  12.0k|    }
_ZN10SpanReaderrsIRjEERS_OT_:
   96|  8.84k|    {
   97|  8.84k|        ::Unserialize(*this, obj);
   98|  8.84k|        return (*this);
   99|  8.84k|    }
_ZN10SpanReaderrsIRhEERS_OT_:
   96|    994|    {
   97|    994|        ::Unserialize(*this, obj);
   98|    994|        return (*this);
   99|    994|    }
_ZN10SpanReaderC2ENSt3__14spanIKhLm18446744073709551615EEE:
   91|  9.53k|    explicit SpanReader(std::span<const unsigned char> data) : m_data{std::as_bytes(data)} {}
_ZN10SpanReaderrsIRNSt3__16vectorINS2_IhNS1_9allocatorIhEEEENS3_IS5_EEEEEERS_OT_:
   96|  40.4k|    {
   97|  40.4k|        ::Unserialize(*this, obj);
   98|  40.4k|        return (*this);
   99|  40.4k|    }
_ZN10DataStream5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  245|  13.3M|    {
  246|       |        // Write to the end of the buffer
  247|  13.3M|        vch.insert(vch.end(), src.begin(), src.end());
  248|  13.3M|    }
_ZN10DataStream4dataEv:
  205|  12.0k|    value_type* data()                               { return vch.data() + m_read_pos; }
_ZNK10DataStream4sizeEv:
  198|  12.0k|    size_type size() const                           { return vch.size() - m_read_pos; }
_ZN10DataStreamC2Ev:
  182|  12.0k|    explicit DataStream() = default;
_ZN10SpanReader4readENSt3__14spanISt4byteLm18446744073709551615EEE:
  105|  29.3M|    {
  106|  29.3M|        if (dst.size() == 0) {
  ------------------
  |  Branch (106:13): [True: 0, False: 29.3M]
  ------------------
  107|      0|            return;
  108|      0|        }
  109|       |
  110|       |        // Read from the beginning of the buffer
  111|  29.3M|        if (dst.size() > m_data.size()) {
  ------------------
  |  Branch (111:13): [True: 1.07k, False: 29.3M]
  ------------------
  112|  1.07k|            throw std::ios_base::failure("SpanReader::read(): end of data");
  113|  1.07k|        }
  114|  29.3M|        memcpy(dst.data(), m_data.data(), dst.size());
  115|  29.3M|        m_data = m_data.subspan(dst.size());
  116|  29.3M|    }

_ZN13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm152ELm8EEC2EP12PoolResourceILm152ELm8EE:
  305|  4.07k|        : m_resource(resource)
  306|  4.07k|    {
  307|  4.07k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm152ELm8EEC2INS0_4pairIKS4_S5_EEEERKS_IT_Lm152ELm8EE:
  314|  4.07k|        : m_resource(other.resource())
  315|  4.07k|    {
  316|  4.07k|    }
_ZNK13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm152ELm8EE8resourceEv:
  344|  8.15k|    {
  345|  8.15k|        return m_resource;
  346|  8.15k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm152ELm8EEC2INS0_4pairIKS3_S4_EEEERKS_IT_Lm152ELm8EE:
  314|  4.07k|        : m_resource(other.resource())
  315|  4.07k|    {
  316|  4.07k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm152ELm8EE8allocateEm:
  331|  3.92k|    {
  332|  3.92k|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  333|  3.92k|    }
_ZN12PoolResourceILm152ELm8EE8AllocateEmm:
  220|  99.8k|    {
  221|  99.8k|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (221:13): [True: 99.8k, False: 0]
  ------------------
  222|  99.8k|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  223|  99.8k|            if (nullptr != m_free_lists[num_alignments]) {
  ------------------
  |  Branch (223:17): [True: 92.0k, False: 7.84k]
  ------------------
  224|       |                // we've already got data in the pool's freelist, unlink one element and return the pointer
  225|       |                // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as
  226|       |                // uninitialized memory.
  227|  92.0k|                ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode));
  ------------------
  |  |  144|  92.0k|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  228|  92.0k|                auto* next{m_free_lists[num_alignments]->m_next};
  229|  92.0k|                ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode));
  ------------------
  |  |  143|  92.0k|#   define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  230|  92.0k|                ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes);
  ------------------
  |  |  144|  92.0k|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  231|  92.0k|                return std::exchange(m_free_lists[num_alignments], next);
  232|  92.0k|            }
  233|       |
  234|       |            // freelist is empty: get one allocation from allocated chunk memory.
  235|  7.84k|            const std::ptrdiff_t round_bytes = static_cast<std::ptrdiff_t>(num_alignments * ELEM_ALIGN_BYTES);
  236|  7.84k|            if (round_bytes > m_available_memory_end - m_available_memory_it) {
  ------------------
  |  Branch (236:17): [True: 0, False: 7.84k]
  ------------------
  237|       |                // slow path, only happens when a new chunk needs to be allocated
  238|      0|                AllocateChunk();
  239|      0|            }
  240|       |
  241|       |            // Make sure we use the right amount of bytes for that freelist (might be rounded up),
  242|  7.84k|            ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes);
  ------------------
  |  |  144|  7.84k|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  243|  7.84k|            return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes);
  244|  99.8k|        }
  245|       |
  246|       |        // Can't use the pool => use operator new()
  247|      0|        return ::operator new (bytes, std::align_val_t{alignment});
  248|  99.8k|    }
_ZN12PoolResourceILm152ELm8EE13AllocateChunkEv:
  157|  4.07k|    {
  158|       |        // if there is still any available memory left, put it into the freelist.
  159|  4.07k|        size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it;
  160|  4.07k|        if (0 != remaining_available_bytes) {
  ------------------
  |  Branch (160:13): [True: 0, False: 4.07k]
  ------------------
  161|      0|            ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode));
  ------------------
  |  |  144|      0|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  162|      0|            PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]);
  163|      0|            ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode));
  ------------------
  |  |  143|      0|#   define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  164|      0|        }
  165|       |
  166|  4.07k|        void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES});
  167|  4.07k|        m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes];
  168|  4.07k|        m_available_memory_end = m_available_memory_it + m_chunk_size_bytes;
  169|  4.07k|        ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes);
  ------------------
  |  |  143|  4.07k|#   define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  170|  4.07k|        m_allocated_chunks.emplace_back(m_available_memory_it);
  171|  4.07k|    }
_ZN12PoolResourceILm152ELm8EEC2Ev:
  193|  4.07k|    PoolResource() : PoolResource(262144) {}
_ZN12PoolResourceILm152ELm8EEC2Em:
  184|  4.07k|        : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES)
  185|  4.07k|    {
  186|  4.07k|        assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES);
  ------------------
  |  Branch (186:9): [True: 4.07k, False: 0]
  ------------------
  187|  4.07k|        AllocateChunk();
  188|  4.07k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm152ELm8EE8allocateEm:
  331|  95.9k|    {
  332|  95.9k|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  333|  95.9k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm152ELm8EE10deallocateEPS7_m:
  339|  95.9k|    {
  340|  95.9k|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  341|  95.9k|    }
_ZN12PoolResourceILm152ELm8EE10DeallocateEPvmm:
  254|  99.8k|    {
  255|  99.8k|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (255:13): [True: 99.8k, False: 0]
  ------------------
  256|  99.8k|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  257|       |            // put the memory block into the linked list. We can placement construct the FreeList
  258|       |            // into the memory since we can be sure the alignment is correct.
  259|  99.8k|            ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode));
  ------------------
  |  |  144|  99.8k|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  260|  99.8k|            PlacementAddToList(p, m_free_lists[num_alignments]);
  261|  99.8k|            ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode)));
  ------------------
  |  |  143|  99.8k|#   define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  262|  99.8k|        } else {
  263|       |            // Can't use the pool => forward deallocation to ::operator delete().
  264|      0|            ::operator delete (p, std::align_val_t{alignment});
  265|      0|        }
  266|  99.8k|    }
_ZN12PoolResourceILm152ELm8EE16IsFreeListUsableEmm:
  138|   199k|    {
  139|   199k|        return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES;
  ------------------
  |  Branch (139:16): [True: 199k, False: 0]
  |  Branch (139:49): [True: 199k, False: 0]
  ------------------
  140|   199k|    }
_ZN12PoolResourceILm152ELm8EE17NumElemAlignBytesEm:
  130|   203k|    {
  131|   203k|        return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0);
  132|   203k|    }
_ZN12PoolResourceILm152ELm8EE18PlacementAddToListEPvRPNS0_8ListNodeE:
  146|  99.8k|    {
  147|  99.8k|        node = new (p) ListNode{node};
  148|  99.8k|    }
_ZN12PoolResourceILm152ELm8EE8ListNodeC2EPS1_:
   84|  99.8k|        explicit ListNode(ListNode* next) : m_next(next) {}
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm152ELm8EE10deallocateEPSB_m:
  339|  3.92k|    {
  340|  3.92k|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  341|  3.92k|    }
_ZN12PoolResourceILm152ELm8EED2Ev:
  207|  4.07k|    {
  208|  4.07k|        for (std::byte* chunk : m_allocated_chunks) {
  ------------------
  |  Branch (208:31): [True: 4.07k, False: 4.07k]
  ------------------
  209|  4.07k|            std::destroy(chunk, chunk + m_chunk_size_bytes);
  210|  4.07k|            ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES});
  211|  4.07k|            ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes);
  ------------------
  |  |  144|  4.07k|#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
  ------------------
  212|  4.07k|        }
  213|  4.07k|    }

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

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

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

_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|  12.9k|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  181|  12.9k|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  182|  12.9k|    {
  183|  12.9k|        if (fTry)
  ------------------
  |  Branch (183:13): [True: 0, False: 12.9k]
  ------------------
  184|      0|            TryEnter(pszName, pszFile, nLine);
  185|  12.9k|        else
  186|  12.9k|            Enter(pszName, pszFile, nLine);
  187|  12.9k|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   67|  12.9k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   68|  12.9k|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  159|  12.9k|    {
  160|  12.9k|        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|  12.9k|        Base::lock();
  167|  12.9k|#endif
  168|  12.9k|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  201|  12.9k|    {
  202|  12.9k|        if (Base::owns_lock())
  ------------------
  |  Branch (202:13): [True: 12.9k, False: 0]
  ------------------
  203|  12.9k|            LeaveCritical();
  204|  12.9k|    }

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

_Z23transaction_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   31|  4.76k|{
   32|  4.76k|    SeedRandomStateForTest(SeedRand::ZEROS);
   33|  4.76k|    SpanReader ds{buffer};
   34|  4.76k|    bool valid_tx = true;
   35|  4.76k|    const CTransaction tx = [&] {
   36|  4.76k|        try {
   37|  4.76k|            return CTransaction(deserialize, TX_WITH_WITNESS, ds);
   38|  4.76k|        } catch (const std::ios_base::failure&) {
   39|  4.76k|            valid_tx = false;
   40|  4.76k|            return CTransaction{CMutableTransaction{}};
   41|  4.76k|        }
   42|  4.76k|    }();
   43|  4.76k|    bool valid_mutable_tx = true;
   44|  4.76k|    CMutableTransaction mutable_tx;
   45|  4.76k|    try {
   46|  4.76k|        SpanReader{buffer} >> TX_WITH_WITNESS(mutable_tx);
   47|  4.76k|    } catch (const std::ios_base::failure&) {
   48|    691|        valid_mutable_tx = false;
   49|    691|    }
   50|  4.76k|    assert(valid_tx == valid_mutable_tx);
  ------------------
  |  Branch (50:5): [True: 4.76k, False: 0]
  ------------------
   51|  4.76k|    if (!valid_tx) {
  ------------------
  |  Branch (51:9): [True: 691, False: 4.07k]
  ------------------
   52|    691|        return;
   53|    691|    }
   54|       |
   55|  4.07k|    {
   56|  4.07k|        TxValidationState state_with_dupe_check;
   57|  4.07k|        const bool res{CheckTransaction(tx, state_with_dupe_check)};
   58|  4.07k|        Assert(res == state_with_dupe_check.IsValid());
  ------------------
  |  |  116|  4.07k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   59|  4.07k|    }
   60|       |
   61|  4.07k|    const CFeeRate dust_relay_fee{DUST_RELAY_TX_FEE};
   62|  4.07k|    std::string reason;
   63|  4.07k|    const bool is_standard_with_permit_bare_multisig = IsStandardTx(tx, std::nullopt, /* permit_bare_multisig= */ true, dust_relay_fee, reason);
   64|  4.07k|    const bool is_standard_without_permit_bare_multisig = IsStandardTx(tx, std::nullopt, /* permit_bare_multisig= */ false, dust_relay_fee, reason);
   65|  4.07k|    if (is_standard_without_permit_bare_multisig) {
  ------------------
  |  Branch (65:9): [True: 503, False: 3.57k]
  ------------------
   66|    503|        assert(is_standard_with_permit_bare_multisig);
  ------------------
  |  Branch (66:9): [True: 503, False: 0]
  ------------------
   67|    503|    }
   68|       |
   69|  4.07k|    (void)tx.GetHash();
   70|  4.07k|    (void)tx.ComputeTotalSize();
   71|  4.07k|    try {
   72|  4.07k|        (void)tx.GetValueOut();
   73|  4.07k|    } catch (const std::runtime_error&) {
   74|  1.78k|    }
   75|  4.07k|    (void)tx.GetWitnessHash();
   76|  4.07k|    (void)tx.HasWitness();
   77|  4.07k|    (void)tx.IsCoinBase();
   78|  4.07k|    (void)tx.IsNull();
   79|  4.07k|    (void)tx.ToString();
   80|       |
   81|  4.07k|    (void)EncodeHexTx(tx);
   82|  4.07k|    (void)GetLegacySigOpCount(tx);
   83|  4.07k|    (void)GetTransactionWeight(tx);
   84|  4.07k|    (void)GetVirtualTransactionSize(tx);
   85|  4.07k|    (void)IsFinalTx(tx, /* nBlockHeight= */ 1024, /* nBlockTime= */ 1024);
   86|  4.07k|    (void)RecursiveDynamicUsage(tx);
   87|  4.07k|    (void)SignalsOptInRBF(tx);
   88|       |
   89|  4.07k|    const CCoinsViewCache coins_view_cache{&CoinsViewEmpty::Get()};
   90|  4.07k|    (void)ValidateInputsStandardness(tx, coins_view_cache);
   91|  4.07k|    (void)IsWitnessStandard(tx, coins_view_cache);
   92|       |
   93|  4.07k|    if (tx.ComputeTotalSize() < 250'000) { // Avoid high memory usage (with msan) due to json encoding
  ------------------
  |  Branch (93:9): [True: 4.01k, False: 63]
  ------------------
   94|  4.01k|        {
   95|  4.01k|            UniValue u{UniValue::VOBJ};
   96|  4.01k|            TxToUniv(tx, /*block_hash=*/uint256::ZERO, /*entry=*/u);
   97|  4.01k|        }
   98|  4.01k|        {
   99|  4.01k|            UniValue u{UniValue::VOBJ};
  100|  4.01k|            TxToUniv(tx, /*block_hash=*/uint256::ONE, /*entry=*/u);
  101|  4.01k|        }
  102|  4.01k|    }
  103|  4.07k|}
transaction.cpp:_ZZ23transaction_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
   35|  4.76k|    const CTransaction tx = [&] {
   36|  4.76k|        try {
   37|  4.76k|            return CTransaction(deserialize, TX_WITH_WITNESS, ds);
   38|  4.76k|        } catch (const std::ios_base::failure&) {
   39|    691|            valid_tx = false;
   40|    691|            return CTransaction{CMutableTransaction{}};
   41|    691|        }
   42|  4.76k|    }();

_ZN12CheckGlobalsC2Ev:
   59|  4.76k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   60|  4.76k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  4.76k|    {
   18|  4.76k|        g_used_g_prng = false;
   19|  4.76k|        g_seeded_g_prng_zero = false;
   20|  4.76k|        g_used_system_time = false;
   21|  4.76k|        SetMockTime(0s);
   22|  4.76k|        MockableSteadyClock::ClearMockTime();
   23|  4.76k|    }
_ZN16CheckGlobalsImplD2Ev:
   25|  4.76k|    {
   26|  4.76k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (26:13): [True: 4.07k, False: 693]
  |  Branch (26:30): [True: 0, False: 4.07k]
  ------------------
   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|  4.76k|        if (g_used_system_time) {
  ------------------
  |  Branch (42:13): [True: 0, False: 4.76k]
  ------------------
   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|  4.76k|    }

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

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

_ZN10tinyformat17FormatStringCheckILj5EEcvPKcEv:
  197|  4.07k|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  3.00M|{
 1089|  3.00M|    std::ostringstream oss;
 1090|  3.00M|    format(oss, fmt, args...);
 1091|  3.00M|    return oss.str();
 1092|  3.00M|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  3.00M|{
 1081|  3.00M|    vformat(out, fmt, makeFormatList(args...));
 1082|  3.00M|}
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  3.00M|{
 1045|  3.00M|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  3.00M|}
_ZN10tinyformat6formatIJPKcllEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   454k|{
 1089|   454k|    std::ostringstream oss;
 1090|   454k|    format(oss, fmt, args...);
 1091|   454k|    return oss.str();
 1092|   454k|}
_ZN10tinyformat6formatIJPKcllEEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   454k|{
 1081|   454k|    vformat(out, fmt, makeFormatList(args...));
 1082|   454k|}
_ZN10tinyformat14makeFormatListIJPKcllEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   454k|{
 1045|   454k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   454k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJPKcllEEEDpRKT_:
  990|   454k|            : FormatList(&m_formatterStore[0], N),
  991|   454k|            m_formatterStore { FormatArg(args)... }
  992|   454k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  95.3k|{
 1089|  95.3k|    std::ostringstream oss;
 1090|  95.3k|    format(oss, fmt, args...);
 1091|  95.3k|    return oss.str();
 1092|  95.3k|}
_ZN10tinyformat6formatIJjEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  95.3k|{
 1081|  95.3k|    vformat(out, fmt, makeFormatList(args...));
 1082|  95.3k|}
_ZN10tinyformat14makeFormatListIJjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  95.3k|{
 1045|  95.3k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  95.3k|}
_ZN10tinyformat6detail9FormatArg10formatImplIjEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|   196k|        {
  559|   196k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   196k|        }
_ZN10tinyformat11formatValueIjEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|   196k|{
  352|   196k|#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|   196k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   196k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   196k|#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|   196k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   196k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   196k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 196k, Folded]
  |  Branch (365:29): [True: 0, False: 196k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   196k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 196k]
  |  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|   196k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 196k]
  ------------------
  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|   196k|    else
  378|   196k|        out << value;
  379|   196k|}
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEES9_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  4.76k|{
 1089|  4.76k|    std::ostringstream oss;
 1090|  4.76k|    format(oss, fmt, args...);
 1091|  4.76k|    return oss.str();
 1092|  4.76k|}
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvRNS3_13basic_ostreamIcS6_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  4.76k|{
 1081|  4.76k|    vformat(out, fmt, makeFormatList(args...));
 1082|  4.76k|}
_ZN10tinyformat14makeFormatListIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  4.76k|{
 1045|  4.76k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  4.76k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJPKcNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEDpRKT_:
  990|  4.76k|            : FormatList(&m_formatterStore[0], N),
  991|  4.76k|            m_formatterStore { FormatArg(args)... }
  992|  4.76k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  2.15M|        {
  559|  2.15M|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  2.15M|        }
_ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  2.15M|{
  352|  2.15M|#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|  2.15M|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  2.15M|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  2.15M|#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|  2.15M|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  2.15M|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  2.15M|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 2.15M, Folded]
  |  Branch (365:29): [True: 0, False: 2.15M]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  2.15M|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 2.15M]
  |  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|  2.15M|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 2.15M]
  ------------------
  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|  2.15M|    else
  378|  2.15M|        out << value;
  379|  2.15M|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|  97.9k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|   820k|        {
  559|   820k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   820k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|   820k|{
  352|   820k|#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|   820k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   820k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   820k|#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|   820k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   820k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   820k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 820k]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   820k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 820k]
  |  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|   820k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 820k]
  ------------------
  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|   820k|    else
  378|   820k|        out << value;
  379|   820k|}
_ZN10tinyformat6detail9FormatArgC2IPKcEERKT_:
  534|   459k|            : m_value(static_cast<const void*>(&value)),
  535|   459k|            m_formatImpl(&formatImpl<T>),
  536|   459k|            m_toIntImpl(&toIntImpl<T>)
  537|   459k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv:
  558|   459k|        {
  559|   459k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   459k|        }
_ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_:
  351|   459k|{
  352|   459k|#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|   459k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   459k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   459k|#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|   459k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   459k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   459k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 459k]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   459k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [True: 459k, Folded]
  |  Branch (367:37): [True: 0, False: 459k]
  ------------------
  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|   459k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 459k]
  ------------------
  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|   459k|    else
  378|   459k|        out << value;
  379|   459k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|  3.00M|            : FormatList(&m_formatterStore[0], N),
  991|  3.00M|            m_formatterStore { FormatArg(args)... }
  992|  3.00M|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  93.2k|{
 1089|  93.2k|    std::ostringstream oss;
 1090|  93.2k|    format(oss, fmt, args...);
 1091|  93.2k|    return oss.str();
 1092|  93.2k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  93.2k|{
 1081|  93.2k|    vformat(out, fmt, makeFormatList(args...));
 1082|  93.2k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  93.2k|{
 1045|  93.2k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  93.2k|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|  3.19M|    operator const char*() { return fmt; }
_ZN10tinyformat17FormatStringCheckILj2EEC2EN4util21ConstevalFormatStringILj2EEE:
  196|  4.76k|    FormatStringCheck(util::ConstevalFormatString<num_params> str) : fmt{str.fmt} {}
_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|  6.65M|        {
  542|  6.65M|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|  6.65M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (542:13): [True: 6.65M, False: 0]
  ------------------
  543|  6.65M|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|  6.65M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (543:13): [True: 6.65M, False: 0]
  ------------------
  544|  6.65M|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|  6.65M|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|  4.37M|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|  1.07M|{
  579|  1.07M|    int i = 0;
  580|  3.23M|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 3.23M, False: 0]
  |  Branch (580:24): [True: 2.15M, False: 1.07M]
  ------------------
  581|  2.15M|        i = 10*i + (*c - '0');
  582|  1.07M|    return i;
  583|  1.07M|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|  5.57M|{
  594|  5.57M|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 5.57M, False: 0]
  |  Branch (594:22): [True: 0, False: 5.57M]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|  5.57M|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 5.57M]
  ------------------
  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|  5.57M|    else {
  618|  5.57M|        return false;
  619|  5.57M|    }
  620|      0|    return true;
  621|  5.57M|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|  11.0M|{
  630|  11.0M|    const char* c = fmt;
  631|  34.8M|    for (;; ++c) {
  632|  34.8M|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 4.37M, False: 30.4M]
  ------------------
  633|  4.37M|            out.write(fmt, c - fmt);
  634|  4.37M|            return c;
  635|  4.37M|        }
  636|  30.4M|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 6.65M, False: 23.7M]
  ------------------
  637|  6.65M|            out.write(fmt, c - fmt);
  638|  6.65M|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 6.65M, False: 0]
  ------------------
  639|  6.65M|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|  34.8M|    }
  644|  11.0M|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|  6.65M|{
  686|  6.65M|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|  6.65M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (686:5): [True: 6.65M, False: 0]
  ------------------
  687|       |    // Reset stream state to defaults.
  688|  6.65M|    out.width(0);
  689|  6.65M|    out.precision(6);
  690|  6.65M|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|  6.65M|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|  6.65M|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|  6.65M|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|  6.65M|    bool precisionSet = false;
  696|  6.65M|    bool widthSet = false;
  697|  6.65M|    int widthExtra = 0;
  698|  6.65M|    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|  6.65M|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 6.65M, False: 0]
  |  Branch (702:22): [True: 1.07M, False: 5.57M]
  ------------------
  703|  1.07M|        const char tmpc = *c;
  704|  1.07M|        int value = parseIntAndAdvance(c);
  705|  1.07M|        if (*c == '$') {
  ------------------
  |  Branch (705:13): [True: 0, False: 1.07M]
  ------------------
  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|  1.07M|        else if (positionalMode) {
  ------------------
  |  Branch (714:18): [True: 0, False: 1.07M]
  ------------------
  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|  1.07M|        else {
  718|  1.07M|            if (tmpc == '0') {
  ------------------
  |  Branch (718:17): [True: 1.07M, False: 0]
  ------------------
  719|       |                // Use internal padding so that numeric values are
  720|       |                // formatted correctly, eg -00010 rather than 000-10
  721|  1.07M|                out.fill('0');
  722|  1.07M|                out.setf(std::ios::internal, std::ios::adjustfield);
  723|  1.07M|            }
  724|  1.07M|            if (value != 0) {
  ------------------
  |  Branch (724:17): [True: 1.07M, False: 0]
  ------------------
  725|       |                // Nonzero value means that we parsed width.
  726|  1.07M|                widthSet = true;
  727|  1.07M|                out.width(value);
  728|  1.07M|            }
  729|  1.07M|        }
  730|  1.07M|    }
  731|  5.57M|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 5.57M]
  ------------------
  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|  6.65M|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 5.57M, False: 1.07M]
  ------------------
  736|       |        // Parse flags
  737|  5.57M|        for (;; ++c) {
  738|  5.57M|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 5.57M]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 5.57M]
  ------------------
  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: 5.57M]
  ------------------
  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: 5.57M]
  ------------------
  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: 5.57M]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|  5.57M|                default:
  ------------------
  |  Branch (765:17): [True: 5.57M, False: 0]
  ------------------
  766|  5.57M|                    break;
  767|  5.57M|            }
  768|  5.57M|            break;
  769|  5.57M|        }
  770|       |        // Parse width
  771|  5.57M|        int width = 0;
  772|  5.57M|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|  5.57M|                                         args, argIndex, numArgs);
  774|  5.57M|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 5.57M]
  ------------------
  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|  5.57M|    }
  784|       |    // 3) Parse precision
  785|  6.65M|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 6.65M]
  ------------------
  786|      0|        ++c;
  787|      0|        int precision = 0;
  788|      0|        parseWidthOrPrecision(precision, c, positionalMode,
  789|      0|                              args, argIndex, numArgs);
  790|       |        // Presence of `.` indicates precision set, unless the inferred value
  791|       |        // was negative in which case the default is used.
  792|      0|        precisionSet = precision >= 0;
  793|      0|        if (precisionSet)
  ------------------
  |  Branch (793:13): [True: 0, False: 0]
  ------------------
  794|      0|            out.precision(precision);
  795|      0|    }
  796|       |    // 4) Ignore any C99 length modifier
  797|  6.65M|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 6.65M]
  |  Branch (797:25): [True: 0, False: 6.65M]
  |  Branch (797:38): [True: 0, False: 6.65M]
  ------------------
  798|  6.65M|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 6.65M]
  |  Branch (798:25): [True: 0, False: 6.65M]
  |  Branch (798:38): [True: 0, False: 6.65M]
  ------------------
  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|  6.65M|    bool intConversion = false;
  805|  6.65M|    switch (*c) {
  806|  5.37M|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 204k, False: 6.44M]
  |  Branch (806:19): [True: 5.16M, False: 1.48M]
  |  Branch (806:29): [True: 5.02k, False: 6.64M]
  ------------------
  807|  5.37M|            out.setf(std::ios::dec, std::ios::basefield);
  808|  5.37M|            intConversion = true;
  809|  5.37M|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|      0|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 0, False: 6.65M]
  |  Branch (817:19): [True: 0, False: 6.65M]
  ------------------
  818|      0|            out.setf(std::ios::hex, std::ios::basefield);
  819|      0|            intConversion = true;
  820|      0|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 6.65M]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 6.65M]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 6.65M]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|  1.27M|        case 's':
  ------------------
  |  Branch (857:9): [True: 1.27M, False: 5.37M]
  ------------------
  858|  1.27M|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 1.27M]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|  1.27M|            out.setf(std::ios::boolalpha);
  862|  1.27M|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  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: 6.65M]
  ------------------
  872|      0|            break;
  873|  6.65M|    }
  874|  6.65M|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 5.37M, False: 1.27M]
  |  Branch (874:26): [True: 0, False: 5.37M]
  |  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|  6.65M|    return c+1;
  884|  6.65M|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|  4.37M|{
  892|       |    // Saved stream state
  893|  4.37M|    std::streamsize origWidth = out.width();
  894|  4.37M|    std::streamsize origPrecision = out.precision();
  895|  4.37M|    std::ios::fmtflags origFlags = out.flags();
  896|  4.37M|    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|  4.37M|    bool positionalMode = false;
  901|  4.37M|    int argIndex = 0;
  902|  11.0M|    while (true) {
  ------------------
  |  Branch (902:12): [True: 11.0M, Folded]
  ------------------
  903|  11.0M|        fmt = printFormatStringLiteral(out, fmt);
  904|  11.0M|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 4.37M, False: 6.65M]
  ------------------
  905|  4.37M|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 4.37M, False: 0]
  |  Branch (905:36): [True: 0, False: 4.37M]
  ------------------
  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|  4.37M|            break;
  909|  4.37M|        }
  910|  6.65M|        bool spacePadPositive = false;
  911|  6.65M|        int ntrunc = -1;
  912|  6.65M|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|  6.65M|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|  6.65M|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 6.65M]
  ------------------
  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|  6.65M|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|  6.65M|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 6.65M, False: 0]
  ------------------
  923|  6.65M|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|  6.65M|        }
  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|  6.65M|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 6.65M, False: 0]
  ------------------
  942|  6.65M|            ++argIndex;
  943|  6.65M|        fmt = fmtEnd;
  944|  6.65M|    }
  945|       |
  946|       |    // Restore stream state
  947|  4.37M|    out.width(origWidth);
  948|  4.37M|    out.precision(origPrecision);
  949|  4.37M|    out.flags(origFlags);
  950|  4.37M|    out.fill(origFill);
  951|  4.37M|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|  4.37M|{
 1071|  4.37M|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|  4.37M|}
_ZN10tinyformat6detail9FormatArg10formatImplImEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  8.15k|        {
  559|  8.15k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  8.15k|        }
_ZN10tinyformat11formatValueImEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  8.15k|{
  352|  8.15k|#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|  8.15k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  8.15k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  8.15k|#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|  8.15k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  8.15k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  8.15k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 8.15k, Folded]
  |  Branch (365:29): [True: 0, False: 8.15k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  8.15k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 8.15k]
  |  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|  8.15k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 8.15k]
  ------------------
  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|  8.15k|    else
  378|  8.15k|        out << value;
  379|  8.15k|}
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  3.00M|        {
  559|  3.00M|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  3.00M|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  3.00M|{
  352|  3.00M|#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.00M|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  3.00M|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  3.00M|#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.00M|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  3.00M|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  3.00M|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 3.00M, Folded]
  |  Branch (365:29): [True: 0, False: 3.00M]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  3.00M|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 3.00M]
  |  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.00M|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 3.00M]
  ------------------
  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.00M|    else
  378|  3.00M|        out << value;
  379|  3.00M|}
_ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv:
  197|  1.07M|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|  3.00M|            : m_value(static_cast<const void*>(&value)),
  535|  3.00M|            m_formatImpl(&formatImpl<T>),
  536|  3.00M|            m_toIntImpl(&toIntImpl<T>)
  537|  3.00M|        { }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  93.2k|{
 1089|  93.2k|    std::ostringstream oss;
 1090|  93.2k|    format(oss, fmt, args...);
 1091|  93.2k|    return oss.str();
 1092|  93.2k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  93.2k|{
 1081|  93.2k|    vformat(out, fmt, makeFormatList(args...));
 1082|  93.2k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  93.2k|{
 1045|  93.2k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  93.2k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjEEEDpRKT_:
  990|  93.2k|            : FormatList(&m_formatterStore[0], N),
  991|  93.2k|            m_formatterStore { FormatArg(args)... }
  992|  93.2k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|   820k|            : m_value(static_cast<const void*>(&value)),
  535|   820k|            m_formatImpl(&formatImpl<T>),
  536|   820k|            m_toIntImpl(&toIntImpl<T>)
  537|   820k|        { }
_ZN10tinyformat6detail9FormatArgC2IjEERKT_:
  534|   196k|            : m_value(static_cast<const void*>(&value)),
  535|   196k|            m_formatImpl(&formatImpl<T>),
  536|   196k|            m_toIntImpl(&toIntImpl<T>)
  537|   196k|        { }
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|  93.2k|            : FormatList(&m_formatterStore[0], N),
  991|  93.2k|            m_formatterStore { FormatArg(args)... }
  992|  93.2k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail11FormatListNILi1EEC2IJjEEEDpRKT_:
  990|  95.3k|            : FormatList(&m_formatterStore[0], N),
  991|  95.3k|            m_formatterStore { FormatArg(args)... }
  992|  95.3k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   624k|{
 1089|   624k|    std::ostringstream oss;
 1090|   624k|    format(oss, fmt, args...);
 1091|   624k|    return oss.str();
 1092|   624k|}
_ZN10tinyformat6formatIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   624k|{
 1081|   624k|    vformat(out, fmt, makeFormatList(args...));
 1082|   624k|}
_ZN10tinyformat14makeFormatListIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   624k|{
 1045|   624k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   624k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJllNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|   624k|            : FormatList(&m_formatterStore[0], N),
  991|   624k|            m_formatterStore { FormatArg(args)... }
  992|   624k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IlEERKT_:
  534|  2.15M|            : m_value(static_cast<const void*>(&value)),
  535|  2.15M|            m_formatImpl(&formatImpl<T>),
  536|  2.15M|            m_toIntImpl(&toIntImpl<T>)
  537|  2.15M|        { }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  4.07k|{
 1089|  4.07k|    std::ostringstream oss;
 1090|  4.07k|    format(oss, fmt, args...);
 1091|  4.07k|    return oss.str();
 1092|  4.07k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  4.07k|{
 1081|  4.07k|    vformat(out, fmt, makeFormatList(args...));
 1082|  4.07k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  4.07k|{
 1045|  4.07k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  4.07k|}
_ZN10tinyformat6detail11FormatListNILi5EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjmmjEEEDpRKT_:
  990|  4.07k|            : FormatList(&m_formatterStore[0], N),
  991|  4.07k|            m_formatterStore { FormatArg(args)... }
  992|  4.07k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2ImEERKT_:
  534|  8.15k|            : m_value(static_cast<const void*>(&value)),
  535|  8.15k|            m_formatImpl(&formatImpl<T>),
  536|  8.15k|            m_toIntImpl(&toIntImpl<T>)
  537|  8.15k|        { }

_ZNK9base_blobILj256EE6GetHexEv:
   12|   242k|{
   13|   242k|    uint8_t m_data_rev[WIDTH];
   14|  8.01M|    for (int i = 0; i < WIDTH; ++i) {
  ------------------
  |  Branch (14:21): [True: 7.77M, False: 242k]
  ------------------
   15|  7.77M|        m_data_rev[i] = m_data[WIDTH - 1 - i];
   16|  7.77M|    }
   17|   242k|    return HexStr(m_data_rev);
   18|   242k|}
_ZNK9base_blobILj256EE8ToStringEv:
   22|  97.2k|{
   23|  97.2k|    return (GetHex());
   24|  97.2k|}

_ZNK9base_blobILj160EE3endEv:
  105|   125k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZN9base_blobILj160EE5beginEv:
  101|  39.2k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_:
  119|   365k|    {
  120|   365k|        s.read(MakeWritableByteSpan(m_data));
  121|   365k|    }
_ZN7uint160C2ENSt3__14spanIKhLm18446744073709551615EEE:
  188|  98.4k|    constexpr explicit uint160(std::span<const unsigned char> vch) : base_blob<160>(vch) {}
_ZN9base_blobILj160EEC2ENSt3__14spanIKhLm18446744073709551615EEE:
   43|  98.4k|    {
   44|  98.4k|        assert(vch.size() == WIDTH);
  ------------------
  |  Branch (44:9): [True: 98.4k, False: 0]
  ------------------
   45|  98.4k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   46|  98.4k|    }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  113|   214k|    {
  114|   214k|        s << std::span(m_data);
  115|   214k|    }
_ZN9base_blobILj256EE11UnserializeI10SpanReaderEEvRT_:
  119|   365k|    {
  120|   365k|        s.read(MakeWritableByteSpan(m_data));
  121|   365k|    }
_ZNK9base_blobILj256EE9GetUint64Ei:
  109|   383k|    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  113|  1.30M|    {
  114|  1.30M|        s << std::span(m_data);
  115|  1.30M|    }
_ZNK9base_blobILj256EEssERKS0_:
   68|   452k|    constexpr std::strong_ordering operator<=>(const base_blob& other) const = default;
_ZNK9base_blobILj256EE6IsNullEv:
   51|   133k|    {
   52|   133k|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   53|   133k|            return val == 0;
   54|   133k|        });
   55|   133k|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   52|  1.87M|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   53|  1.87M|            return val == 0;
   54|  1.87M|        });
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  113|   132k|    {
  114|   132k|        s << std::span(m_data);
  115|   132k|    }
_ZNK9base_blobILj256EE5beginEv:
  104|  48.9k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZNK9base_blobILj256EE3endEv:
  105|  48.9k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZNK9base_blobILj160EE5beginEv:
  104|   125k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
   99|   177k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint160C2Ev:
  187|  65.7k|    constexpr uint160() = default;
_ZN9base_blobILj160EEC2Ev:
   37|  65.7k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj160EE4dataEv:
   99|  26.4k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj160EE4sizeEv:
  107|  26.4k|    static constexpr unsigned int size() { return WIDTH; }
_ZN7uint256C2Ev:
  200|   852k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   37|   852k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EE5beginEv:
  101|  50.1k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE4dataEv:
   98|  17.4k|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|  77.5k|    static constexpr unsigned int size() { return WIDTH; }

univalue_read.cpp:_ZL12json_isspacei:
  193|   736k|{
  194|   736k|    switch (ch) {
  195|      0|    case 0x20:
  ------------------
  |  Branch (195:5): [True: 0, False: 736k]
  ------------------
  196|      0|    case 0x09:
  ------------------
  |  Branch (196:5): [True: 0, False: 736k]
  ------------------
  197|      0|    case 0x0a:
  ------------------
  |  Branch (197:5): [True: 0, False: 736k]
  ------------------
  198|      0|    case 0x0d:
  ------------------
  |  Branch (198:5): [True: 0, False: 736k]
  ------------------
  199|      0|        return true;
  200|       |
  201|   736k|    default:
  ------------------
  |  Branch (201:5): [True: 736k, False: 0]
  ------------------
  202|   736k|        return false;
  203|   736k|    }
  204|       |
  205|       |    // not reached
  206|   736k|}
_ZN8UniValueC2IRKjjTnNSt3__19enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS5_Esr3stdE11is_signed_vIS5_Esr3stdE13is_unsigned_vIS5_Esr3stdE18is_constructible_vINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES5_EEbE4typeELb1EEEOT_:
   40|   257k|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|       |        } else if constexpr (std::is_signed_v<T>) {
   46|       |            setInt(int64_t{val});
   47|   257k|        } else if constexpr (std::is_unsigned_v<T>) {
   48|   257k|            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|   257k|    }
_ZN8UniValueC2IRjjTnNSt3__19enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS4_Esr3stdE11is_signed_vIS4_Esr3stdE13is_unsigned_vIS4_Esr3stdE18is_constructible_vINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES4_EEbE4typeELb1EEEOT_:
   40|   454k|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|       |        } else if constexpr (std::is_signed_v<T>) {
   46|       |            setInt(int64_t{val});
   47|   454k|        } else if constexpr (std::is_unsigned_v<T>) {
   48|   454k|            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|   454k|    }
_ZN8UniValueC2IjjTnNSt3__19enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS3_Esr3stdE11is_signed_vIS3_Esr3stdE13is_unsigned_vIS3_Esr3stdE18is_constructible_vINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES3_EEbE4typeELb1EEEOT_:
   40|  8.02k|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|       |        } else if constexpr (std::is_signed_v<T>) {
   46|       |            setInt(int64_t{val});
   47|  8.02k|        } else if constexpr (std::is_unsigned_v<T>) {
   48|  8.02k|            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|  8.02k|    }
_ZN8UniValueC2IiiTnNSt3__19enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS3_Esr3stdE11is_signed_vIS3_Esr3stdE13is_unsigned_vIS3_Esr3stdE18is_constructible_vINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES3_EEbE4typeELb1EEEOT_:
   40|  16.0k|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|  16.0k|        } else if constexpr (std::is_signed_v<T>) {
   46|  16.0k|            setInt(int64_t{val});
   47|       |        } else if constexpr (std::is_unsigned_v<T>) {
   48|       |            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|  16.0k|    }
_ZN8UniValueC2INSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_TnNS1_9enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS9_Esr3stdE11is_signed_vIS9_Esr3stdE13is_unsigned_vIS9_Esr3stdE18is_constructible_vIS7_S9_EEbE4typeELb1EEEOT_:
   40|  6.21M|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|       |        } else if constexpr (std::is_signed_v<T>) {
   46|       |            setInt(int64_t{val});
   47|       |        } else if constexpr (std::is_unsigned_v<T>) {
   48|       |            setInt(uint64_t{val});
   49|  6.21M|        } else {
   50|  6.21M|            setStr(std::string{std::forward<Ref>(val)});
   51|  6.21M|        }
   52|  6.21M|    }
_ZN8UniValueC2ENS_5VTypeENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   32|  1.63M|    UniValue(UniValue::VType type, std::string str = {}) : typ{type}, val{std::move(str)} {}

_ZN8UniValue5clearEv:
   18|  6.95M|{
   19|  6.95M|    typ = VNULL;
   20|  6.95M|    val.clear();
   21|  6.95M|    keys.clear();
   22|  6.95M|    values.clear();
   23|  6.95M|}
_ZN8UniValue9setNumStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   47|   736k|{
   48|   736k|    if (!validNumStr(str)) {
  ------------------
  |  Branch (48:9): [True: 0, False: 736k]
  ------------------
   49|      0|        throw std::runtime_error{"The string '" + str + "' is not a valid JSON number"};
   50|      0|    }
   51|       |
   52|   736k|    clear();
   53|   736k|    typ = VNUM;
   54|   736k|    val = std::move(str);
   55|   736k|}
_ZN8UniValue6setIntEm:
   58|   720k|{
   59|   720k|    std::ostringstream oss;
   60|       |
   61|   720k|    oss << val_;
   62|       |
   63|   720k|    return setNumStr(oss.str());
   64|   720k|}
_ZN8UniValue6setIntEl:
   67|  16.0k|{
   68|  16.0k|    std::ostringstream oss;
   69|       |
   70|  16.0k|    oss << val_;
   71|       |
   72|  16.0k|    return setNumStr(oss.str());
   73|  16.0k|}
_ZN8UniValue6setStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   85|  6.21M|{
   86|  6.21M|    clear();
   87|  6.21M|    typ = VSTR;
   88|  6.21M|    val = std::move(str);
   89|  6.21M|}
_ZN8UniValue9push_backES_:
  104|  4.51M|{
  105|  4.51M|    checkType(VARR);
  106|       |
  107|  4.51M|    values.push_back(std::move(val));
  108|  4.51M|}
_ZN8UniValue9pushKVEndENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  118|  4.06M|{
  119|  4.06M|    checkType(VOBJ);
  120|       |
  121|  4.06M|    keys.push_back(std::move(key));
  122|  4.06M|    values.push_back(std::move(val));
  123|  4.06M|}
_ZN8UniValue6pushKVENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  126|  4.06M|{
  127|  4.06M|    checkType(VOBJ);
  128|       |
  129|  4.06M|    size_t idx;
  130|  4.06M|    if (findKey(key, idx))
  ------------------
  |  Branch (130:9): [True: 0, False: 4.06M]
  ------------------
  131|      0|        values[idx] = std::move(val);
  132|  4.06M|    else
  133|  4.06M|        pushKVEnd(std::move(key), std::move(val));
  134|  4.06M|}
_ZNK8UniValue7findKeyERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERm:
  156|  4.06M|{
  157|  9.70M|    for (size_t i = 0; i < keys.size(); i++) {
  ------------------
  |  Branch (157:24): [True: 5.64M, False: 4.06M]
  ------------------
  158|  5.64M|        if (keys[i] == key) {
  ------------------
  |  Branch (158:13): [True: 0, False: 5.64M]
  ------------------
  159|      0|            retIdx = i;
  160|      0|            return true;
  161|      0|        }
  162|  5.64M|    }
  163|       |
  164|  4.06M|    return false;
  165|  4.06M|}
_ZNK8UniValue9checkTypeERKNS_5VTypeE:
  210|  12.6M|{
  211|  12.6M|    if (typ != expected) {
  ------------------
  |  Branch (211:9): [True: 0, False: 12.6M]
  ------------------
  212|      0|        throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +
  213|      0|                                 std::string{uvTypeName(expected)}};
  214|      0|    }
  215|  12.6M|}
_ZN8UniValue7reserveEm:
  243|  25.5k|{
  244|  25.5k|    values.reserve(new_cap);
  245|  25.5k|    if (typ == VOBJ) {
  ------------------
  |  Branch (245:9): [True: 0, False: 25.5k]
  ------------------
  246|      0|        keys.reserve(new_cap);
  247|      0|    }
  248|  25.5k|}
univalue.cpp:_ZL11validNumStrRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
   39|   736k|{
   40|   736k|    std::string tokenVal;
   41|   736k|    unsigned int consumed;
   42|   736k|    enum jtokentype tt = getJsonToken(tokenVal, consumed, s.data(), s.data() + s.size());
   43|   736k|    return (tt == JTOK_NUMBER);
   44|   736k|}

_Z12getJsonTokenRNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERjPKcS9_:
   58|   736k|{
   59|   736k|    tokenVal.clear();
   60|   736k|    consumed = 0;
   61|       |
   62|   736k|    const char *rawStart = raw;
   63|       |
   64|   736k|    while (raw < end && (json_isspace(*raw)))          // skip whitespace
  ------------------
  |  Branch (64:12): [True: 736k, False: 0]
  |  Branch (64:25): [True: 0, False: 736k]
  ------------------
   65|      0|        raw++;
   66|       |
   67|   736k|    if (raw >= end)
  ------------------
  |  Branch (67:9): [True: 0, False: 736k]
  ------------------
   68|      0|        return JTOK_NONE;
   69|       |
   70|   736k|    switch (*raw) {
   71|       |
   72|      0|    case '{':
  ------------------
  |  Branch (72:5): [True: 0, False: 736k]
  ------------------
   73|      0|        raw++;
   74|      0|        consumed = (raw - rawStart);
   75|      0|        return JTOK_OBJ_OPEN;
   76|      0|    case '}':
  ------------------
  |  Branch (76:5): [True: 0, False: 736k]
  ------------------
   77|      0|        raw++;
   78|      0|        consumed = (raw - rawStart);
   79|      0|        return JTOK_OBJ_CLOSE;
   80|      0|    case '[':
  ------------------
  |  Branch (80:5): [True: 0, False: 736k]
  ------------------
   81|      0|        raw++;
   82|      0|        consumed = (raw - rawStart);
   83|      0|        return JTOK_ARR_OPEN;
   84|      0|    case ']':
  ------------------
  |  Branch (84:5): [True: 0, False: 736k]
  ------------------
   85|      0|        raw++;
   86|      0|        consumed = (raw - rawStart);
   87|      0|        return JTOK_ARR_CLOSE;
   88|       |
   89|      0|    case ':':
  ------------------
  |  Branch (89:5): [True: 0, False: 736k]
  ------------------
   90|      0|        raw++;
   91|      0|        consumed = (raw - rawStart);
   92|      0|        return JTOK_COLON;
   93|      0|    case ',':
  ------------------
  |  Branch (93:5): [True: 0, False: 736k]
  ------------------
   94|      0|        raw++;
   95|      0|        consumed = (raw - rawStart);
   96|      0|        return JTOK_COMMA;
   97|       |
   98|      0|    case 'n':
  ------------------
  |  Branch (98:5): [True: 0, False: 736k]
  ------------------
   99|      0|    case 't':
  ------------------
  |  Branch (99:5): [True: 0, False: 736k]
  ------------------
  100|      0|    case 'f':
  ------------------
  |  Branch (100:5): [True: 0, False: 736k]
  ------------------
  101|      0|        if (!strncmp(raw, "null", 4)) {
  ------------------
  |  Branch (101:13): [True: 0, False: 0]
  ------------------
  102|      0|            raw += 4;
  103|      0|            consumed = (raw - rawStart);
  104|      0|            return JTOK_KW_NULL;
  105|      0|        } else if (!strncmp(raw, "true", 4)) {
  ------------------
  |  Branch (105:20): [True: 0, False: 0]
  ------------------
  106|      0|            raw += 4;
  107|      0|            consumed = (raw - rawStart);
  108|      0|            return JTOK_KW_TRUE;
  109|      0|        } else if (!strncmp(raw, "false", 5)) {
  ------------------
  |  Branch (109:20): [True: 0, False: 0]
  ------------------
  110|      0|            raw += 5;
  111|      0|            consumed = (raw - rawStart);
  112|      0|            return JTOK_KW_FALSE;
  113|      0|        } else
  114|      0|            return JTOK_ERR;
  115|       |
  116|      0|    case '-':
  ------------------
  |  Branch (116:5): [True: 0, False: 736k]
  ------------------
  117|   104k|    case '0':
  ------------------
  |  Branch (117:5): [True: 104k, False: 631k]
  ------------------
  118|   359k|    case '1':
  ------------------
  |  Branch (118:5): [True: 254k, False: 481k]
  ------------------
  119|   419k|    case '2':
  ------------------
  |  Branch (119:5): [True: 59.8k, False: 676k]
  ------------------
  120|   475k|    case '3':
  ------------------
  |  Branch (120:5): [True: 56.3k, False: 679k]
  ------------------
  121|   546k|    case '4':
  ------------------
  |  Branch (121:5): [True: 70.7k, False: 665k]
  ------------------
  122|   587k|    case '5':
  ------------------
  |  Branch (122:5): [True: 40.7k, False: 695k]
  ------------------
  123|   627k|    case '6':
  ------------------
  |  Branch (123:5): [True: 40.8k, False: 695k]
  ------------------
  124|   664k|    case '7':
  ------------------
  |  Branch (124:5): [True: 36.4k, False: 699k]
  ------------------
  125|   701k|    case '8':
  ------------------
  |  Branch (125:5): [True: 37.3k, False: 698k]
  ------------------
  126|   736k|    case '9': {
  ------------------
  |  Branch (126:5): [True: 34.6k, False: 701k]
  ------------------
  127|       |        // part 1: int
  128|   736k|        std::string numStr;
  129|       |
  130|   736k|        const char *first = raw;
  131|       |
  132|   736k|        const char *firstDigit = first;
  133|   736k|        if (!json_isdigit(*firstDigit))
  ------------------
  |  Branch (133:13): [True: 0, False: 736k]
  ------------------
  134|      0|            firstDigit++;
  135|   736k|        if ((*firstDigit == '0') && json_isdigit(firstDigit[1]))
  ------------------
  |  Branch (135:13): [True: 104k, False: 631k]
  |  Branch (135:37): [True: 0, False: 104k]
  ------------------
  136|      0|            return JTOK_ERR;
  137|       |
  138|   736k|        numStr += *raw;                       // copy first char
  139|   736k|        raw++;
  140|       |
  141|   736k|        if ((*first == '-') && (raw < end) && (!json_isdigit(*raw)))
  ------------------
  |  Branch (141:13): [True: 0, False: 736k]
  |  Branch (141:32): [True: 0, False: 0]
  |  Branch (141:47): [True: 0, False: 0]
  ------------------
  142|      0|            return JTOK_ERR;
  143|       |
  144|  2.76M|        while (raw < end && json_isdigit(*raw)) {  // copy digits
  ------------------
  |  Branch (144:16): [True: 2.03M, False: 736k]
  |  Branch (144:29): [True: 2.03M, False: 0]
  ------------------
  145|  2.03M|            numStr += *raw;
  146|  2.03M|            raw++;
  147|  2.03M|        }
  148|       |
  149|       |        // part 2: frac
  150|   736k|        if (raw < end && *raw == '.') {
  ------------------
  |  Branch (150:13): [True: 0, False: 736k]
  |  Branch (150:26): [True: 0, False: 0]
  ------------------
  151|      0|            numStr += *raw;                   // copy .
  152|      0|            raw++;
  153|       |
  154|      0|            if (raw >= end || !json_isdigit(*raw))
  ------------------
  |  Branch (154:17): [True: 0, False: 0]
  |  Branch (154:31): [True: 0, False: 0]
  ------------------
  155|      0|                return JTOK_ERR;
  156|      0|            while (raw < end && json_isdigit(*raw)) { // copy digits
  ------------------
  |  Branch (156:20): [True: 0, False: 0]
  |  Branch (156:33): [True: 0, False: 0]
  ------------------
  157|      0|                numStr += *raw;
  158|      0|                raw++;
  159|      0|            }
  160|      0|        }
  161|       |
  162|       |        // part 3: exp
  163|   736k|        if (raw < end && (*raw == 'e' || *raw == 'E')) {
  ------------------
  |  Branch (163:13): [True: 0, False: 736k]
  |  Branch (163:27): [True: 0, False: 0]
  |  Branch (163:42): [True: 0, False: 0]
  ------------------
  164|      0|            numStr += *raw;                   // copy E
  165|      0|            raw++;
  166|       |
  167|      0|            if (raw < end && (*raw == '-' || *raw == '+')) { // copy +/-
  ------------------
  |  Branch (167:17): [True: 0, False: 0]
  |  Branch (167:31): [True: 0, False: 0]
  |  Branch (167:46): [True: 0, False: 0]
  ------------------
  168|      0|                numStr += *raw;
  169|      0|                raw++;
  170|      0|            }
  171|       |
  172|      0|            if (raw >= end || !json_isdigit(*raw))
  ------------------
  |  Branch (172:17): [True: 0, False: 0]
  |  Branch (172:31): [True: 0, False: 0]
  ------------------
  173|      0|                return JTOK_ERR;
  174|      0|            while (raw < end && json_isdigit(*raw)) { // copy digits
  ------------------
  |  Branch (174:20): [True: 0, False: 0]
  |  Branch (174:33): [True: 0, False: 0]
  ------------------
  175|      0|                numStr += *raw;
  176|      0|                raw++;
  177|      0|            }
  178|      0|        }
  179|       |
  180|   736k|        tokenVal = numStr;
  181|   736k|        consumed = (raw - rawStart);
  182|   736k|        return JTOK_NUMBER;
  183|   736k|        }
  184|       |
  185|      0|    case '"': {
  ------------------
  |  Branch (185:5): [True: 0, False: 736k]
  ------------------
  186|      0|        raw++;                                // skip "
  187|       |
  188|      0|        std::string valStr;
  189|      0|        JSONUTF8StringFilter writer(valStr);
  190|       |
  191|      0|        while (true) {
  ------------------
  |  Branch (191:16): [True: 0, Folded]
  ------------------
  192|      0|            if (raw >= end || (unsigned char)*raw < 0x20)
  ------------------
  |  Branch (192:17): [True: 0, False: 0]
  |  Branch (192:31): [True: 0, False: 0]
  ------------------
  193|      0|                return JTOK_ERR;
  194|       |
  195|      0|            else if (*raw == '\\') {
  ------------------
  |  Branch (195:22): [True: 0, False: 0]
  ------------------
  196|      0|                raw++;                        // skip backslash
  197|       |
  198|      0|                if (raw >= end)
  ------------------
  |  Branch (198:21): [True: 0, False: 0]
  ------------------
  199|      0|                    return JTOK_ERR;
  200|       |
  201|      0|                switch (*raw) {
  202|      0|                case '"':  writer.push_back('\"'); break;
  ------------------
  |  Branch (202:17): [True: 0, False: 0]
  ------------------
  203|      0|                case '\\': writer.push_back('\\'); break;
  ------------------
  |  Branch (203:17): [True: 0, False: 0]
  ------------------
  204|      0|                case '/':  writer.push_back('/'); break;
  ------------------
  |  Branch (204:17): [True: 0, False: 0]
  ------------------
  205|      0|                case 'b':  writer.push_back('\b'); break;
  ------------------
  |  Branch (205:17): [True: 0, False: 0]
  ------------------
  206|      0|                case 'f':  writer.push_back('\f'); break;
  ------------------
  |  Branch (206:17): [True: 0, False: 0]
  ------------------
  207|      0|                case 'n':  writer.push_back('\n'); break;
  ------------------
  |  Branch (207:17): [True: 0, False: 0]
  ------------------
  208|      0|                case 'r':  writer.push_back('\r'); break;
  ------------------
  |  Branch (208:17): [True: 0, False: 0]
  ------------------
  209|      0|                case 't':  writer.push_back('\t'); break;
  ------------------
  |  Branch (209:17): [True: 0, False: 0]
  ------------------
  210|       |
  211|      0|                case 'u': {
  ------------------
  |  Branch (211:17): [True: 0, False: 0]
  ------------------
  212|      0|                    unsigned int codepoint;
  213|      0|                    if (raw + 1 + 4 >= end ||
  ------------------
  |  Branch (213:25): [True: 0, False: 0]
  ------------------
  214|      0|                        hatoui(raw + 1, raw + 1 + 4, codepoint) !=
  ------------------
  |  Branch (214:25): [True: 0, False: 0]
  ------------------
  215|      0|                               raw + 1 + 4)
  216|      0|                        return JTOK_ERR;
  217|      0|                    writer.push_back_u(codepoint);
  218|      0|                    raw += 4;
  219|      0|                    break;
  220|      0|                    }
  221|      0|                default:
  ------------------
  |  Branch (221:17): [True: 0, False: 0]
  ------------------
  222|      0|                    return JTOK_ERR;
  223|       |
  224|      0|                }
  225|       |
  226|      0|                raw++;                        // skip esc'd char
  227|      0|            }
  228|       |
  229|      0|            else if (*raw == '"') {
  ------------------
  |  Branch (229:22): [True: 0, False: 0]
  ------------------
  230|      0|                raw++;                        // skip "
  231|      0|                break;                        // stop scanning
  232|      0|            }
  233|       |
  234|      0|            else {
  235|      0|                writer.push_back(static_cast<unsigned char>(*raw));
  236|      0|                raw++;
  237|      0|            }
  238|      0|        }
  239|       |
  240|      0|        if (!writer.finalize())
  ------------------
  |  Branch (240:13): [True: 0, False: 0]
  ------------------
  241|      0|            return JTOK_ERR;
  242|      0|        tokenVal = valStr;
  243|      0|        consumed = (raw - rawStart);
  244|      0|        return JTOK_STRING;
  245|      0|        }
  246|       |
  247|      0|    default:
  ------------------
  |  Branch (247:5): [True: 0, False: 736k]
  ------------------
  248|      0|        return JTOK_ERR;
  249|   736k|    }
  250|   736k|}
univalue_read.cpp:_ZL12json_isdigiti:
   25|  2.87M|{
   26|  2.87M|    return ((ch >= '0') && (ch <= '9'));
  ------------------
  |  Branch (26:13): [True: 2.76M, False: 104k]
  |  Branch (26:28): [True: 2.76M, False: 0]
  ------------------
   27|  2.87M|}

_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|  4.76k|{
   91|  4.76k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 4.76k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  4.76k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 4.76k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  4.76k|    }
   96|  4.76k|    return std::forward<T>(val);
   97|  4.76k|}
_Z22inline_assertion_checkILb1ERNSt3__16atomicIbEEEOT0_S5_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|  4.76k|{
   91|  4.76k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 4.76k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  4.76k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 4.76k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  4.76k|    }
   96|  4.76k|    return std::forward<T>(val);
   97|  4.76k|}
_Z21EnableFuzzDeterminismv:
   39|  4.76k|{
   40|  4.76k|    if constexpr (G_FUZZING_BUILD) {
   41|  4.76k|        return true;
   42|       |    } else if constexpr (!G_ABORT_ON_FAILED_ASSUME) {
   43|       |        // Running fuzz tests is always disabled if Assume() doesn't abort
   44|       |        // (ie, non-fuzz non-debug builds), as otherwise tests which
   45|       |        // should fail due to a failing Assume may still pass. As such,
   46|       |        // we also statically disable fuzz determinism in that case.
   47|       |        return false;
   48|       |    } else {
   49|       |        return g_enable_dynamic_fuzz_determinism;
   50|       |    }
   51|  4.76k|}
_Z22inline_check_non_fatalIbEOT_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   73|  8.02k|{
   74|  8.02k|    if (!val) {
  ------------------
  |  Branch (74:9): [True: 0, False: 8.02k]
  ------------------
   75|      0|        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
   76|      0|            assertion_fail(loc, assertion);
   77|      0|        }
   78|      0|        throw NonFatalCheckError{assertion, loc};
   79|      0|    }
   80|  8.02k|    return std::forward<T>(val);
   81|  8.02k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  17.6k|{
   91|  17.6k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 17.6k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  17.6k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 17.6k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  17.6k|    }
   96|  17.6k|    return std::forward<T>(val);
   97|  17.6k|}
_Z22inline_assertion_checkILb1ERP10CCoinsViewEOT0_S4_RKNSt3__115source_locationENS5_17basic_string_viewIcNS5_11char_traitsIcEEEE:
   90|  4.07k|{
   91|  4.07k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 4.07k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  4.07k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 4.07k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  4.07k|    }
   96|  4.07k|    return std::forward<T>(val);
   97|  4.07k|}
_Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  11.9k|{
   91|  11.9k|    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|  11.9k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 11.9k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  11.9k|    }
   96|  11.9k|    return std::forward<T>(val);
   97|  11.9k|}

_ZNK7FeeFrac13EvaluateFeeUpEi:
  176|  2.09k|    int64_t EvaluateFeeUp(int32_t at_size) const noexcept { return EvaluateFee<false>(at_size); }
_ZNK7FeeFrac11EvaluateFeeILb0EEEli:
  156|  2.09k|    {
  157|  2.09k|        Assume(size > 0);
  ------------------
  |  |  128|  2.09k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  158|  2.09k|        Assume(at_size >= 0);
  ------------------
  |  |  128|  2.09k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  159|  2.09k|        if (fee >= 0 && fee < 0x200000000) [[likely]] {
  ------------------
  |  Branch (159:13): [True: 2.09k, False: 0]
  |  Branch (159:25): [True: 2.09k, False: 0]
  ------------------
  160|       |            // Common case where (this->fee * at_size) is guaranteed to fit in a uint64_t.
  161|       |            if constexpr (RoundDown) {
  162|       |                return (uint64_t(fee) * at_size) / uint32_t(size);
  163|  2.09k|            } else {
  164|  2.09k|                return CeilDiv(uint64_t(fee) * at_size, uint32_t(size));
  165|  2.09k|            }
  166|  2.09k|        } else {
  167|       |            // Otherwise, use Mul and Div.
  168|      0|            return Div(Mul(fee, at_size), size, RoundDown);
  169|      0|        }
  170|  2.09k|    }
_ZNK7FeeFrac7IsEmptyEv:
  102|  2.09k|    bool inline IsEmpty() const noexcept {
  103|  2.09k|        return size == 0;
  104|  2.09k|    }
_ZN7FeeFracC2Eli:
   96|  4.07k|    constexpr inline FeeFrac(int64_t f, int32_t s) noexcept : fee{f}, size{s} {}

_ZN8BaseHashI7uint256E5beginEv:
   19|  23.5k|    {
   20|  23.5k|        return m_hash.begin();
   21|  23.5k|    }
_ZNK8BaseHashI7uint160E5beginEv:
   24|   125k|    {
   25|   125k|        return m_hash.begin();
   26|   125k|    }
_ZNK8BaseHashI7uint160E3endEv:
   34|   125k|    {
   35|   125k|        return m_hash.end();
   36|   125k|    }
_ZNK8BaseHashI7uint256E3endEv:
   34|  35.3k|    {
   35|  35.3k|        return m_hash.end();
   36|  35.3k|    }
_ZN8BaseHashI7uint160EC2Ev:
   15|  27.4k|    BaseHash() : m_hash() {}
_ZN8BaseHashI7uint160E5beginEv:
   19|  27.4k|    {
   20|  27.4k|        return m_hash.begin();
   21|  27.4k|    }
_ZN8BaseHashI7uint256EC2Ev:
   15|  23.5k|    BaseHash() : m_hash() {}
_ZNK8BaseHashI7uint256E5beginEv:
   24|  35.3k|    {
   25|  35.3k|        return m_hash.begin();
   26|  35.3k|    }
_ZN8BaseHashI7uint160EC2ERKS0_:
   16|  90.5k|    explicit BaseHash(const HashType& in) : m_hash(in) {}

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

_Z7CeilDivITkNSt3__117unsigned_integralEmTkNS0_17unsigned_integralEjEDaT_T0_:
   71|  19.2k|{
   72|  19.2k|    assert(divisor > 0);
  ------------------
  |  Branch (72:5): [True: 19.2k, False: 0]
  ------------------
   73|  19.2k|    return dividend / divisor + (dividend % divisor != 0);
   74|  19.2k|}
_Z7CeilDivITkNSt3__117unsigned_integralEmTkNS0_17unsigned_integralEmEDaT_T0_:
   71|   203k|{
   72|   203k|    assert(divisor > 0);
  ------------------
  |  Branch (72:5): [True: 203k, False: 0]
  ------------------
   73|   203k|    return dividend / divisor + (dividend % divisor != 0);
   74|   203k|}

_Z15SignalsOptInRBFRK12CTransaction:
   12|  4.07k|{
   13|  5.09k|    for (const CTxIn &txin : tx.vin) {
  ------------------
  |  Branch (13:28): [True: 5.09k, False: 226]
  ------------------
   14|  5.09k|        if (txin.nSequence <= MAX_BIP125_RBF_SEQUENCE) {
  ------------------
  |  Branch (14:13): [True: 3.84k, False: 1.24k]
  ------------------
   15|  3.84k|            return true;
   16|  3.84k|        }
   17|  5.09k|    }
   18|    226|    return false;
   19|  4.07k|}

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

key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|  23.5k|{
  222|  23.5k|    size_t acc = 0;
  223|  23.5k|    size_t bits = 0;
  224|  23.5k|    constexpr size_t maxv = (1 << tobits) - 1;
  225|  23.5k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|   777k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 754k, False: 23.5k]
  ------------------
  227|   754k|        int v = infn(*it);
  228|   754k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 754k]
  ------------------
  229|   754k|        acc = ((acc << frombits) | v) & max_acc;
  230|   754k|        bits += frombits;
  231|  1.95M|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 1.20M, False: 754k]
  ------------------
  232|  1.20M|            bits -= tobits;
  233|  1.20M|            outfn((acc >> bits) & maxv);
  234|  1.20M|        }
  235|   754k|        ++it;
  236|   754k|    }
  237|  23.5k|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 23.5k, Folded]
  ------------------
  238|  23.5k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 23.5k, False: 0]
  ------------------
  239|  23.5k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|  23.5k|    return true;
  243|  23.5k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|  27.4k|{
  222|  27.4k|    size_t acc = 0;
  223|  27.4k|    size_t bits = 0;
  224|  27.4k|    constexpr size_t maxv = (1 << tobits) - 1;
  225|  27.4k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|   577k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 549k, False: 27.4k]
  ------------------
  227|   549k|        int v = infn(*it);
  228|   549k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 549k]
  ------------------
  229|   549k|        acc = ((acc << frombits) | v) & max_acc;
  230|   549k|        bits += frombits;
  231|  1.42M|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 879k, False: 549k]
  ------------------
  232|   879k|            bits -= tobits;
  233|   879k|            outfn((acc >> bits) & maxv);
  234|   879k|        }
  235|   549k|        ++it;
  236|   549k|    }
  237|  27.4k|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 27.4k, Folded]
  ------------------
  238|  27.4k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 0, False: 27.4k]
  ------------------
  239|  27.4k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|  27.4k|    return true;
  243|  27.4k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|  6.27k|{
  222|  6.27k|    size_t acc = 0;
  223|  6.27k|    size_t bits = 0;
  224|  6.27k|    constexpr size_t maxv = (1 << tobits) - 1;
  225|  6.27k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|   206k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 200k, False: 6.27k]
  ------------------
  227|   200k|        int v = infn(*it);
  228|   200k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 200k]
  ------------------
  229|   200k|        acc = ((acc << frombits) | v) & max_acc;
  230|   200k|        bits += frombits;
  231|   520k|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 319k, False: 200k]
  ------------------
  232|   319k|            bits -= tobits;
  233|   319k|            outfn((acc >> bits) & maxv);
  234|   319k|        }
  235|   200k|        ++it;
  236|   200k|    }
  237|  6.27k|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 6.27k, Folded]
  ------------------
  238|  6.27k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 6.27k, False: 0]
  ------------------
  239|  6.27k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|  6.27k|    return true;
  243|  6.27k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownEUlhE_NSt3__111__wrap_iterIPKhEENS6_8identityEEbT2_T3_SD_T4_:
  221|  17.1k|{
  222|  17.1k|    size_t acc = 0;
  223|  17.1k|    size_t bits = 0;
  224|  17.1k|    constexpr size_t maxv = (1 << tobits) - 1;
  225|  17.1k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|   129k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 112k, False: 17.1k]
  ------------------
  227|   112k|        int v = infn(*it);
  228|   112k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 112k]
  ------------------
  229|   112k|        acc = ((acc << frombits) | v) & max_acc;
  230|   112k|        bits += frombits;
  231|   289k|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 176k, False: 112k]
  ------------------
  232|   176k|            bits -= tobits;
  233|   176k|            outfn((acc >> bits) & maxv);
  234|   176k|        }
  235|   112k|        ++it;
  236|   112k|    }
  237|  17.1k|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 17.1k, Folded]
  ------------------
  238|  17.1k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 16.8k, False: 292]
  ------------------
  239|  17.1k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|  17.1k|    return true;
  243|  17.1k|}

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

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

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

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

descriptor.cpp:_Z6VectorIJNSt3__110unique_ptrIN12_GLOBAL__N_114PubkeyProviderENS0_14default_deleteIS3_EEEEEENS0_6vectorINS0_11common_typeIJDpT_EE4typeENS0_9allocatorISC_EEEEDpOS9_:
   24|  8.61k|{
   25|  8.61k|    std::vector<std::common_type_t<Args...>> ret;
   26|  8.61k|    ret.reserve(sizeof...(args));
   27|       |    // The line below uses the trick from https://www.experts-exchange.com/articles/32502/None-recursive-variadic-templates-with-std-initializer-list.html
   28|  8.61k|    (void)std::initializer_list<int>{(ret.emplace_back(std::forward<Args>(args)), 0)...};
   29|  8.61k|    return ret;
   30|  8.61k|}

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