_Z18ExtractDestinationRK7CScriptRNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
   50|  1.08M|{
   51|  1.08M|    std::vector<valtype> vSolutions;
   52|  1.08M|    TxoutType whichType = Solver(scriptPubKey, vSolutions);
   53|       |
   54|  1.08M|    switch (whichType) {
  ------------------
  |  Branch (54:13): [True: 0, False: 1.08M]
  ------------------
   55|  10.8k|    case TxoutType::PUBKEY: {
  ------------------
  |  Branch (55:5): [True: 10.8k, False: 1.07M]
  ------------------
   56|  10.8k|        CPubKey pubKey(vSolutions[0]);
   57|  10.8k|        if (!pubKey.IsValid()) {
  ------------------
  |  Branch (57:13): [True: 0, False: 10.8k]
  ------------------
   58|      0|            addressRet = CNoDestination(scriptPubKey);
   59|  10.8k|        } else {
   60|  10.8k|            addressRet = PubKeyDestination(pubKey);
   61|  10.8k|        }
   62|  10.8k|        return false;
   63|      0|    }
   64|  16.2k|    case TxoutType::PUBKEYHASH: {
  ------------------
  |  Branch (64:5): [True: 16.2k, False: 1.07M]
  ------------------
   65|  16.2k|        addressRet = PKHash(uint160(vSolutions[0]));
   66|  16.2k|        return true;
   67|      0|    }
   68|  75.6k|    case TxoutType::SCRIPTHASH: {
  ------------------
  |  Branch (68:5): [True: 75.6k, False: 1.01M]
  ------------------
   69|  75.6k|        addressRet = ScriptHash(uint160(vSolutions[0]));
   70|  75.6k|        return true;
   71|      0|    }
   72|  38.4k|    case TxoutType::WITNESS_V0_KEYHASH: {
  ------------------
  |  Branch (72:5): [True: 38.4k, False: 1.04M]
  ------------------
   73|  38.4k|        WitnessV0KeyHash hash;
   74|  38.4k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
   75|  38.4k|        addressRet = hash;
   76|  38.4k|        return true;
   77|      0|    }
   78|  42.0k|    case TxoutType::WITNESS_V0_SCRIPTHASH: {
  ------------------
  |  Branch (78:5): [True: 42.0k, False: 1.04M]
  ------------------
   79|  42.0k|        WitnessV0ScriptHash hash;
   80|  42.0k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
   81|  42.0k|        addressRet = hash;
   82|  42.0k|        return true;
   83|      0|    }
   84|  10.0k|    case TxoutType::WITNESS_V1_TAPROOT: {
  ------------------
  |  Branch (84:5): [True: 10.0k, False: 1.07M]
  ------------------
   85|  10.0k|        WitnessV1Taproot tap;
   86|  10.0k|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
   87|  10.0k|        addressRet = tap;
   88|  10.0k|        return true;
   89|      0|    }
   90|     36|    case TxoutType::ANCHOR: {
  ------------------
  |  Branch (90:5): [True: 36, False: 1.08M]
  ------------------
   91|     36|        addressRet = PayToAnchor();
   92|     36|        return true;
   93|      0|    }
   94|  21.8k|    case TxoutType::WITNESS_UNKNOWN: {
  ------------------
  |  Branch (94:5): [True: 21.8k, False: 1.06M]
  ------------------
   95|  21.8k|        addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};
   96|  21.8k|        return true;
   97|      0|    }
   98|  9.14k|    case TxoutType::MULTISIG:
  ------------------
  |  Branch (98:5): [True: 9.14k, False: 1.07M]
  ------------------
   99|  12.2k|    case TxoutType::NULL_DATA:
  ------------------
  |  Branch (99:5): [True: 3.09k, False: 1.08M]
  ------------------
  100|   871k|    case TxoutType::NONSTANDARD:
  ------------------
  |  Branch (100:5): [True: 859k, False: 227k]
  ------------------
  101|   871k|        addressRet = CNoDestination(scriptPubKey);
  102|   871k|        return false;
  103|  1.08M|    } // no default case, so the compiler can warn about missing cases
  104|      0|    assert(false);
  105|      0|}
_Z23GetScriptForDestinationRKNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  167|   100k|{
  168|   100k|    return std::visit(CScriptVisitor(), dest);
  169|   100k|}
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK6PKHash:
  122|  8.14k|    {
  123|  8.14k|        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
  124|  8.14k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK10ScriptHash:
  127|  37.8k|    {
  128|  37.8k|        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
  129|  37.8k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK19WitnessV0ScriptHash:
  137|  21.0k|    {
  138|  21.0k|        return CScript() << OP_0 << ToByteVector(id);
  139|  21.0k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK16WitnessV0KeyHash:
  132|  19.2k|    {
  133|  19.2k|        return CScript() << OP_0 << ToByteVector(id);
  134|  19.2k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK16WitnessV1Taproot:
  142|  3.39k|    {
  143|  3.39k|        return CScript() << OP_1 << ToByteVector(tap);
  144|  3.39k|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK14WitnessUnknown:
  147|  10.9k|    {
  148|  10.9k|        return CScript() << CScript::EncodeOP_N(id.GetWitnessVersion()) << id.GetWitnessProgram();
  149|  10.9k|    }

_ZN14CNoDestinationC2ERK7CScript:
   26|   871k|    explicit CNoDestination(const CScript& script) : m_script(script) {}
_ZN17PubKeyDestinationC2ERK7CPubKey:
   39|  10.8k|    explicit PubKeyDestination(const CPubKey& pubkey) : m_pubkey(pubkey) {}
_ZN6PKHashC2ERK7uint160:
   50|  16.2k|    explicit PKHash(const uint160& hash) : BaseHash(hash) {}
_ZN10ScriptHashC2ERK7uint160:
   66|  75.6k|    explicit ScriptHash(const uint160& hash) : BaseHash(hash) {}
_ZN19WitnessV0ScriptHashC2Ev:
   74|  42.0k|    WitnessV0ScriptHash() : BaseHash() {}
_ZN16WitnessV0KeyHashC2Ev:
   81|  38.4k|    WitnessV0KeyHash() : BaseHash() {}
_ZN16WitnessV1TaprootC2Ev:
   90|  10.0k|    WitnessV1Taproot() : XOnlyPubKey() {}
_ZN14WitnessUnknownC2EiRKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  103|  21.9k|    WitnessUnknown(int version, const std::vector<unsigned char>& program) : m_version(static_cast<unsigned int>(version)), m_program(program) {}
_ZNK14WitnessUnknown17GetWitnessVersionEv:
  105|  76.7k|    unsigned int GetWitnessVersion() const { return m_version; }
_ZNK14WitnessUnknown17GetWitnessProgramEv:
  106|  32.8k|    const std::vector<unsigned char>& GetWitnessProgram() const LIFETIMEBOUND { return m_program; }
_ZN11PayToAnchorC2Ev:
  122|     36|    PayToAnchor() : WitnessUnknown(1, {0x4e, 0x73}) {
  123|     36|        Assume(CScript::IsPayToAnchor(1, {0x4e, 0x73}));
  ------------------
  |  |   97|     36|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  124|     36|    };
_ZN14CNoDestinationC2Ev:
   25|  1.08M|    CNoDestination() = default;

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

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

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

_ZNK10CCoinsView7GetCoinERK9COutPoint:
   16|  3.97k|std::optional<Coin> CCoinsView::GetCoin(const COutPoint& outpoint) const { return std::nullopt; }
_ZN16CCoinsViewBackedC2EP10CCoinsView:
   27|  3.57k|CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
_ZN15CCoinsViewCacheC2EP10CCoinsViewb:
   38|  3.57k|    CCoinsViewBacked(baseIn), m_deterministic(deterministic),
   39|  3.57k|    cacheCoins(0, SaltedOutpointHasher(/*deterministic=*/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
   40|  3.57k|{
   41|  3.57k|    m_sentinel.second.SelfRef(m_sentinel);
   42|  3.57k|}
_ZNK15CCoinsViewCache9FetchCoinERK9COutPoint:
   48|  3.97k|CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
   49|  3.97k|    const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
   50|  3.97k|    if (inserted) {
  ------------------
  |  Branch (50:9): [True: 3.97k, False: 0]
  ------------------
   51|  3.97k|        if (auto coin{base->GetCoin(outpoint)}) {
  ------------------
  |  Branch (51:18): [True: 0, False: 3.97k]
  ------------------
   52|      0|            ret->second.coin = std::move(*coin);
   53|      0|            cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
   54|      0|            if (ret->second.coin.IsSpent()) { // TODO GetCoin cannot return spent coins
  ------------------
  |  Branch (54:17): [True: 0, False: 0]
  ------------------
   55|       |                // The parent only has an empty entry for this outpoint; we can consider our version as fresh.
   56|      0|                CCoinsCacheEntry::SetFresh(*ret, m_sentinel);
   57|      0|            }
   58|  3.97k|        } else {
   59|  3.97k|            cacheCoins.erase(ret);
   60|  3.97k|            return cacheCoins.end();
   61|  3.97k|        }
   62|  3.97k|    }
   63|      0|    return ret;
   64|  3.97k|}
_ZNK15CCoinsViewCache10AccessCoinERK9COutPoint:
  154|  3.97k|const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
  155|  3.97k|    CCoinsMap::const_iterator it = FetchCoin(outpoint);
  156|  3.97k|    if (it == cacheCoins.end()) {
  ------------------
  |  Branch (156:9): [True: 3.97k, False: 0]
  ------------------
  157|  3.97k|        return coinEmpty;
  158|  3.97k|    } else {
  159|      0|        return it->second.coin;
  160|      0|    }
  161|  3.97k|}

_ZN4CoinC2Ev:
   55|  7.55k|    Coin() : fCoinBase(false), nHeight(0) { }
_ZN16CCoinsCacheEntryD2Ev:
  173|  7.55k|    {
  174|  7.55k|        SetClean();
  175|  7.55k|    }
_ZN16CCoinsCacheEntry8SetCleanEv:
  181|  7.55k|    {
  182|  7.55k|        if (!m_flags) return;
  ------------------
  |  Branch (182:13): [True: 3.97k, False: 3.57k]
  ------------------
  183|  3.57k|        m_next->second.m_prev = m_prev;
  184|  3.57k|        m_prev->second.m_next = m_next;
  185|  3.57k|        m_flags = 0;
  186|  3.57k|        m_prev = m_next = nullptr;
  187|  3.57k|    }
_ZN16CCoinsCacheEntry7SelfRefERNSt3__14pairIK9COutPointS_EE:
  207|  3.57k|    {
  208|  3.57k|        Assume(&pair.second == this);
  ------------------
  |  |   97|  3.57k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  209|  3.57k|        m_prev = &pair;
  210|  3.57k|        m_next = &pair;
  211|       |        // Set sentinel to DIRTY so we can call Next on it
  212|  3.57k|        m_flags = DIRTY;
  213|  3.57k|    }
_ZN10CCoinsViewD2Ev:
  335|  3.57k|    virtual ~CCoinsView() = default;
_ZN16CCoinsCacheEntryC2Ev:
  170|  7.55k|    CCoinsCacheEntry() noexcept = default;

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

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

_Z10MoneyRangeRKl:
   27|  76.8k|inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  ------------------
  |  Branch (27:57): [True: 76.3k, False: 476]
  |  Branch (27:72): [True: 75.0k, False: 1.30k]
  ------------------

_Z16CheckTransactionRK12CTransactionR17TxValidationState:
   12|  3.57k|{
   13|       |    // Basic checks that don't depend on any context
   14|  3.57k|    if (tx.vin.empty())
  ------------------
  |  Branch (14:9): [True: 87, False: 3.49k]
  ------------------
   15|     87|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vin-empty");
   16|  3.49k|    if (tx.vout.empty())
  ------------------
  |  Branch (16:9): [True: 924, False: 2.56k]
  ------------------
   17|    924|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-empty");
   18|       |    // Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
   19|  2.56k|    if (::GetSerializeSize(TX_NO_WITNESS(tx)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT) {
  ------------------
  |  Branch (19:9): [True: 2, False: 2.56k]
  ------------------
   20|      2|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-oversize");
   21|      2|    }
   22|       |
   23|       |    // Check for negative or overflow output values (see CVE-2010-5139)
   24|  2.56k|    CAmount nValueOut = 0;
   25|  2.56k|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (25:28): [True: 26.1k, False: 787]
  ------------------
   26|  26.1k|    {
   27|  26.1k|        if (txout.nValue < 0)
  ------------------
  |  Branch (27:13): [True: 476, False: 25.7k]
  ------------------
   28|    476|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-negative");
   29|  25.7k|        if (txout.nValue > MAX_MONEY)
  ------------------
  |  Branch (29:13): [True: 1.29k, False: 24.4k]
  ------------------
   30|  1.29k|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-toolarge");
   31|  24.4k|        nValueOut += txout.nValue;
   32|  24.4k|        if (!MoneyRange(nValueOut))
  ------------------
  |  Branch (32:13): [True: 2, False: 24.4k]
  ------------------
   33|      2|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-txouttotal-toolarge");
   34|  24.4k|    }
   35|       |
   36|       |    // Check for duplicate inputs (see CVE-2018-17144)
   37|       |    // While Consensus::CheckTxInputs does check if all inputs of a tx are available, and UpdateCoins marks all inputs
   38|       |    // of a tx as spent, it does not check if the tx has duplicate inputs.
   39|       |    // Failure to run this check will result in either a crash or an inflation bug, depending on the implementation of
   40|       |    // the underlying coins database.
   41|    787|    std::set<COutPoint> vInOutPoints;
   42|  19.0k|    for (const auto& txin : tx.vin) {
  ------------------
  |  Branch (42:27): [True: 19.0k, False: 768]
  ------------------
   43|  19.0k|        if (!vInOutPoints.insert(txin.prevout).second)
  ------------------
  |  Branch (43:13): [True: 19, False: 19.0k]
  ------------------
   44|     19|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputs-duplicate");
   45|  19.0k|    }
   46|       |
   47|    768|    if (tx.IsCoinBase())
  ------------------
  |  Branch (47:9): [True: 16, False: 752]
  ------------------
   48|     16|    {
   49|     16|        if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
  ------------------
  |  Branch (49:13): [True: 2, False: 14]
  |  Branch (49:47): [True: 9, False: 5]
  ------------------
   50|     11|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cb-length");
   51|     16|    }
   52|    752|    else
   53|    752|    {
   54|    752|        for (const auto& txin : tx.vin)
  ------------------
  |  Branch (54:31): [True: 17.6k, False: 749]
  ------------------
   55|  17.6k|            if (txin.prevout.IsNull())
  ------------------
  |  Branch (55:17): [True: 3, False: 17.6k]
  ------------------
   56|      3|                return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-prevout-null");
   57|    752|    }
   58|       |
   59|    754|    return true;
   60|    768|}

_Z9IsFinalTxRK12CTransactionil:
   18|  3.57k|{
   19|  3.57k|    if (tx.nLockTime == 0)
  ------------------
  |  Branch (19:9): [True: 645, False: 2.93k]
  ------------------
   20|    645|        return true;
   21|  2.93k|    if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
  ------------------
  |  Branch (21:9): [True: 143, False: 2.78k]
  |  Branch (21:34): [True: 1.44k, False: 1.49k]
  ------------------
   22|    143|        return true;
   23|       |
   24|       |    // Even if tx.nLockTime isn't satisfied by nBlockHeight/nBlockTime, a
   25|       |    // transaction is still considered final if all inputs' nSequence ==
   26|       |    // SEQUENCE_FINAL (0xffffffff), in which case nLockTime is ignored.
   27|       |    //
   28|       |    // Because of this behavior OP_CHECKLOCKTIMEVERIFY/CheckLockTime() will
   29|       |    // also check that the spending input's nSequence != SEQUENCE_FINAL,
   30|       |    // ensuring that an unsatisfied nLockTime value will actually cause
   31|       |    // IsFinalTx() to return false here:
   32|  3.47k|    for (const auto& txin : tx.vin) {
  ------------------
  |  Branch (32:27): [True: 3.47k, False: 105]
  ------------------
   33|  3.47k|        if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
  ------------------
  |  Branch (33:13): [True: 2.68k, False: 794]
  ------------------
   34|  2.68k|            return false;
   35|  3.47k|    }
   36|    105|    return true;
   37|  2.78k|}
_Z19GetLegacySigOpCountRK12CTransaction:
  113|  3.57k|{
  114|  3.57k|    unsigned int nSigOps = 0;
  115|  3.57k|    for (const auto& txin : tx.vin)
  ------------------
  |  Branch (115:27): [True: 102k, False: 3.57k]
  ------------------
  116|   102k|    {
  117|   102k|        nSigOps += txin.scriptSig.GetSigOpCount(false);
  118|   102k|    }
  119|  3.57k|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (119:28): [True: 420k, False: 3.57k]
  ------------------
  120|   420k|    {
  121|   420k|        nSigOps += txout.scriptPubKey.GetSigOpCount(false);
  122|   420k|    }
  123|  3.57k|    return nSigOps;
  124|  3.57k|}

_ZNK15ValidationStateI18TxValidationResultE7IsValidEv:
  106|  3.57k|    bool IsValid() const { return m_mode == ModeState::M_VALID; }
transaction.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  134|  3.57k|{
  135|  3.57k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  136|  3.57k|}
_ZN15ValidationStateI18TxValidationResultE7InvalidES0_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_:
   92|  2.82k|    {
   93|  2.82k|        m_result = result;
   94|  2.82k|        m_reject_reason = reject_reason;
   95|  2.82k|        m_debug_message = debug_message;
   96|  2.82k|        if (m_mode != ModeState::M_ERROR) m_mode = ModeState::M_INVALID;
  ------------------
  |  Branch (96:13): [True: 2.82k, False: 0]
  ------------------
   97|  2.82k|        return false;
   98|  2.82k|    }
core_write.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  134|  14.0k|{
  135|  14.0k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  136|  14.0k|}
policy.cpp:_ZL20GetTransactionWeightRK12CTransaction:
  134|  7.48k|{
  135|  7.48k|    return ::GetSerializeSize(TX_NO_WITNESS(tx)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(tx));
  136|  7.48k|}

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

_Z15ValueFromAmountl:
   27|   553k|{
   28|   553k|    static_assert(COIN > 1);
   29|   553k|    int64_t quotient = amount / COIN;
   30|   553k|    int64_t remainder = amount % COIN;
   31|   553k|    if (amount < 0) {
  ------------------
  |  Branch (31:9): [True: 31.0k, False: 522k]
  ------------------
   32|  31.0k|        quotient = -quotient;
   33|  31.0k|        remainder = -remainder;
   34|  31.0k|    }
   35|   553k|    return UniValue(UniValue::VNUM,
   36|   553k|            strprintf("%s%d.%08d", amount < 0 ? "-" : "", quotient, remainder));
  ------------------
  |  | 1172|   553k|#define strprintf tfm::format
  ------------------
  |  Branch (36:36): [True: 31.0k, False: 522k]
  ------------------
   37|   553k|}
_Z14ScriptToAsmStrRK7CScriptb:
   99|   670k|{
  100|   670k|    std::string str;
  101|   670k|    opcodetype opcode;
  102|   670k|    std::vector<unsigned char> vch;
  103|   670k|    CScript::const_iterator pc = script.begin();
  104|  6.33M|    while (pc < script.end()) {
  ------------------
  |  Branch (104:12): [True: 5.97M, False: 366k]
  ------------------
  105|  5.97M|        if (!str.empty()) {
  ------------------
  |  Branch (105:13): [True: 5.51M, False: 458k]
  ------------------
  106|  5.51M|            str += " ";
  107|  5.51M|        }
  108|  5.97M|        if (!script.GetOp(pc, opcode, vch)) {
  ------------------
  |  Branch (108:13): [True: 303k, False: 5.66M]
  ------------------
  109|   303k|            str += "[error]";
  110|   303k|            return str;
  111|   303k|        }
  112|  5.66M|        if (0 <= opcode && opcode <= OP_PUSHDATA4) {
  ------------------
  |  Branch (112:13): [True: 5.66M, False: 0]
  |  Branch (112:28): [True: 3.58M, False: 2.08M]
  ------------------
  113|  3.58M|            if (vch.size() <= static_cast<std::vector<unsigned char>::size_type>(4)) {
  ------------------
  |  Branch (113:17): [True: 3.22M, False: 362k]
  ------------------
  114|  3.22M|                str += strprintf("%d", CScriptNum(vch, false).getint());
  ------------------
  |  | 1172|  3.22M|#define strprintf tfm::format
  ------------------
  115|  3.22M|            } else {
  116|       |                // the IsUnspendable check makes sure not to try to decode OP_RETURN data that may match the format of a signature
  117|   362k|                if (fAttemptSighashDecode && !script.IsUnspendable()) {
  ------------------
  |  Branch (117:21): [True: 61.4k, False: 300k]
  |  Branch (117:46): [True: 31.9k, False: 29.5k]
  ------------------
  118|  31.9k|                    std::string strSigHashDecode;
  119|       |                    // goal: only attempt to decode a defined sighash type from data that looks like a signature within a scriptSig.
  120|       |                    // this won't decode correctly formatted public keys in Pubkey or Multisig scripts due to
  121|       |                    // the restrictions on the pubkey formats (see IsCompressedOrUncompressedPubKey) being incongruous with the
  122|       |                    // checks in CheckSignatureEncoding.
  123|  31.9k|                    if (CheckSignatureEncoding(vch, SCRIPT_VERIFY_STRICTENC, nullptr)) {
  ------------------
  |  Branch (123:25): [True: 4.35k, False: 27.5k]
  ------------------
  124|  4.35k|                        const unsigned char chSigHashType = vch.back();
  125|  4.35k|                        const auto it = mapSigHashTypes.find(chSigHashType);
  126|  4.35k|                        if (it != mapSigHashTypes.end()) {
  ------------------
  |  Branch (126:29): [True: 4.35k, False: 0]
  ------------------
  127|  4.35k|                            strSigHashDecode = "[" + it->second + "]";
  128|  4.35k|                            vch.pop_back(); // remove the sighash type byte. it will be replaced by the decode.
  129|  4.35k|                        }
  130|  4.35k|                    }
  131|  31.9k|                    str += HexStr(vch) + strSigHashDecode;
  132|   330k|                } else {
  133|   330k|                    str += HexStr(vch);
  134|   330k|                }
  135|   362k|            }
  136|  3.58M|        } else {
  137|  2.08M|            str += GetOpName(opcode);
  138|  2.08M|        }
  139|  5.66M|    }
  140|   366k|    return str;
  141|   670k|}
_Z11EncodeHexTxRK12CTransaction:
  144|  10.5k|{
  145|  10.5k|    DataStream ssTx;
  146|  10.5k|    ssTx << TX_WITH_WITNESS(tx);
  147|  10.5k|    return HexStr(ssTx);
  148|  10.5k|}
_Z12ScriptToUnivRK7CScriptR8UniValuebbPK15SigningProvider:
  151|   553k|{
  152|   553k|    CTxDestination address;
  153|       |
  154|   553k|    out.pushKV("asm", ScriptToAsmStr(script));
  155|   553k|    if (include_address) {
  ------------------
  |  Branch (155:9): [True: 553k, False: 0]
  ------------------
  156|   553k|        out.pushKV("desc", InferDescriptor(script, provider ? *provider : DUMMY_SIGNING_PROVIDER)->ToString());
  ------------------
  |  Branch (156:52): [True: 0, False: 553k]
  ------------------
  157|   553k|    }
  158|   553k|    if (include_hex) {
  ------------------
  |  Branch (158:9): [True: 553k, False: 0]
  ------------------
  159|   553k|        out.pushKV("hex", HexStr(script));
  160|   553k|    }
  161|       |
  162|   553k|    std::vector<std::vector<unsigned char>> solns;
  163|   553k|    const TxoutType type{Solver(script, solns)};
  164|       |
  165|   553k|    if (include_address && ExtractDestination(script, address) && type != TxoutType::PUBKEY) {
  ------------------
  |  Branch (165:9): [True: 553k, False: 0]
  |  Branch (165:28): [True: 103k, False: 449k]
  |  Branch (165:67): [True: 103k, False: 0]
  ------------------
  166|   103k|        out.pushKV("address", EncodeDestination(address));
  167|   103k|    }
  168|   553k|    out.pushKV("type", GetTxnOutputType(type));
  169|   553k|}
_Z8TxToUnivRK12CTransactionRK7uint256R8UniValuebPK7CTxUndo11TxVerbosity:
  172|  7.01k|{
  173|  7.01k|    CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);
  ------------------
  |  |   82|  7.01k|    inline_check_non_fatal(condition, __FILE__, __LINE__, __func__, #condition)
  ------------------
  174|       |
  175|  7.01k|    entry.pushKV("txid", tx.GetHash().GetHex());
  176|  7.01k|    entry.pushKV("hash", tx.GetWitnessHash().GetHex());
  177|  7.01k|    entry.pushKV("version", tx.version);
  178|  7.01k|    entry.pushKV("size", tx.GetTotalSize());
  179|  7.01k|    entry.pushKV("vsize", (GetTransactionWeight(tx) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR);
  180|  7.01k|    entry.pushKV("weight", GetTransactionWeight(tx));
  181|  7.01k|    entry.pushKV("locktime", (int64_t)tx.nLockTime);
  182|       |
  183|  7.01k|    UniValue vin{UniValue::VARR};
  184|       |
  185|       |    // If available, use Undo data to calculate the fee. Note that txundo == nullptr
  186|       |    // for coinbase transactions and for transactions where undo data is unavailable.
  187|  7.01k|    const bool have_undo = txundo != nullptr;
  188|  7.01k|    CAmount amt_total_in = 0;
  189|  7.01k|    CAmount amt_total_out = 0;
  190|       |
  191|   124k|    for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (191:30): [True: 117k, False: 7.01k]
  ------------------
  192|   117k|        const CTxIn& txin = tx.vin[i];
  193|   117k|        UniValue in(UniValue::VOBJ);
  194|   117k|        if (tx.IsCoinBase()) {
  ------------------
  |  Branch (194:13): [True: 82, False: 116k]
  ------------------
  195|     82|            in.pushKV("coinbase", HexStr(txin.scriptSig));
  196|   116k|        } else {
  197|   116k|            in.pushKV("txid", txin.prevout.hash.GetHex());
  198|   116k|            in.pushKV("vout", (int64_t)txin.prevout.n);
  199|   116k|            UniValue o(UniValue::VOBJ);
  200|   116k|            o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true));
  201|   116k|            o.pushKV("hex", HexStr(txin.scriptSig));
  202|   116k|            in.pushKV("scriptSig", std::move(o));
  203|   116k|        }
  204|   117k|        if (!tx.vin[i].scriptWitness.IsNull()) {
  ------------------
  |  Branch (204:13): [True: 9.75k, False: 107k]
  ------------------
  205|  9.75k|            UniValue txinwitness(UniValue::VARR);
  206|  2.77M|            for (const auto& item : tx.vin[i].scriptWitness.stack) {
  ------------------
  |  Branch (206:35): [True: 2.77M, False: 9.75k]
  ------------------
  207|  2.77M|                txinwitness.push_back(HexStr(item));
  208|  2.77M|            }
  209|  9.75k|            in.pushKV("txinwitness", std::move(txinwitness));
  210|  9.75k|        }
  211|   117k|        if (have_undo) {
  ------------------
  |  Branch (211:13): [True: 0, False: 117k]
  ------------------
  212|      0|            const Coin& prev_coin = txundo->vprevout[i];
  213|      0|            const CTxOut& prev_txout = prev_coin.out;
  214|       |
  215|      0|            amt_total_in += prev_txout.nValue;
  216|       |
  217|      0|            if (verbosity == TxVerbosity::SHOW_DETAILS_AND_PREVOUT) {
  ------------------
  |  Branch (217:17): [True: 0, False: 0]
  ------------------
  218|      0|                UniValue o_script_pub_key(UniValue::VOBJ);
  219|      0|                ScriptToUniv(prev_txout.scriptPubKey, /*out=*/o_script_pub_key, /*include_hex=*/true, /*include_address=*/true);
  220|       |
  221|      0|                UniValue p(UniValue::VOBJ);
  222|      0|                p.pushKV("generated", bool(prev_coin.fCoinBase));
  223|      0|                p.pushKV("height", uint64_t(prev_coin.nHeight));
  224|      0|                p.pushKV("value", ValueFromAmount(prev_txout.nValue));
  225|      0|                p.pushKV("scriptPubKey", std::move(o_script_pub_key));
  226|      0|                in.pushKV("prevout", std::move(p));
  227|      0|            }
  228|      0|        }
  229|   117k|        in.pushKV("sequence", (int64_t)txin.nSequence);
  230|   117k|        vin.push_back(std::move(in));
  231|   117k|    }
  232|  7.01k|    entry.pushKV("vin", std::move(vin));
  233|       |
  234|  7.01k|    UniValue vout(UniValue::VARR);
  235|   560k|    for (unsigned int i = 0; i < tx.vout.size(); i++) {
  ------------------
  |  Branch (235:30): [True: 553k, False: 7.01k]
  ------------------
  236|   553k|        const CTxOut& txout = tx.vout[i];
  237|       |
  238|   553k|        UniValue out(UniValue::VOBJ);
  239|       |
  240|   553k|        out.pushKV("value", ValueFromAmount(txout.nValue));
  241|   553k|        out.pushKV("n", (int64_t)i);
  242|       |
  243|   553k|        UniValue o(UniValue::VOBJ);
  244|   553k|        ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
  245|   553k|        out.pushKV("scriptPubKey", std::move(o));
  246|   553k|        vout.push_back(std::move(out));
  247|       |
  248|   553k|        if (have_undo) {
  ------------------
  |  Branch (248:13): [True: 0, False: 553k]
  ------------------
  249|      0|            amt_total_out += txout.nValue;
  250|      0|        }
  251|   553k|    }
  252|  7.01k|    entry.pushKV("vout", std::move(vout));
  253|       |
  254|  7.01k|    if (have_undo) {
  ------------------
  |  Branch (254:9): [True: 0, False: 7.01k]
  ------------------
  255|      0|        const CAmount fee = amt_total_in - amt_total_out;
  256|      0|        CHECK_NONFATAL(MoneyRange(fee));
  ------------------
  |  |   82|      0|    inline_check_non_fatal(condition, __FILE__, __LINE__, __func__, #condition)
  ------------------
  257|      0|        entry.pushKV("fee", ValueFromAmount(fee));
  258|      0|    }
  259|       |
  260|  7.01k|    if (!block_hash.IsNull()) {
  ------------------
  |  Branch (260:9): [True: 3.50k, False: 3.50k]
  ------------------
  261|  3.50k|        entry.pushKV("blockhash", block_hash.GetHex());
  262|  3.50k|    }
  263|       |
  264|  7.01k|    if (include_hex) {
  ------------------
  |  Branch (264:9): [True: 7.01k, False: 0]
  ------------------
  265|  7.01k|        entry.pushKV("hex", EncodeHexTx(tx)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".
  266|  7.01k|    }
  267|  7.01k|}

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

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

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  15.8k|{
   37|  15.8k|    uint64_t x;
   38|  15.8k|    memcpy(&x, ptr, 8);
   39|  15.8k|    return le64toh_internal(x);
   40|  15.8k|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|   293k|{
   52|   293k|    uint32_t v = htole32_internal(x);
   53|   293k|    memcpy(ptr, &v, 4);
   54|   293k|}
_Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_:
   36|  7.15k|{
   37|  7.15k|    uint64_t x;
   38|  7.15k|    memcpy(&x, ptr, 8);
   39|  7.15k|    return le64toh_internal(x);
   40|  7.15k|}
_Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j:
   51|   171k|{
   52|   171k|    uint32_t v = htole32_internal(x);
   53|   171k|    memcpy(ptr, &v, 4);
   54|   171k|}
_Z8ReadLE16ITk8ByteTypehEtPKT_:
   20|  14.9k|{
   21|  14.9k|    uint16_t x;
   22|  14.9k|    memcpy(&x, ptr, 2);
   23|  14.9k|    return le16toh_internal(x);
   24|  14.9k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|   944k|{
   29|   944k|    uint32_t x;
   30|   944k|    memcpy(&x, ptr, 4);
   31|   944k|    return le32toh_internal(x);
   32|   944k|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  58.6k|{
   59|  58.6k|    uint64_t v = htole64_internal(x);
   60|  58.6k|    memcpy(ptr, &v, 8);
   61|  58.6k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  1.84M|{
   97|  1.84M|    uint32_t v = htobe32_internal(x);
   98|  1.84M|    memcpy(ptr, &v, 4);
   99|  1.84M|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  22.5M|{
   74|  22.5M|    uint32_t x;
   75|  22.5M|    memcpy(&x, ptr, 4);
   76|  22.5M|    return be32toh_internal(x);
   77|  22.5M|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|   295k|{
  104|   295k|    uint64_t v = htobe64_internal(x);
  105|   295k|    memcpy(ptr, &v, 8);
  106|   295k|}
_Z8ReadBE64ITk8ByteTypehEmPKT_:
   81|   114k|{
   82|   114k|    uint64_t x;
   83|   114k|    memcpy(&x, ptr, 8);
   84|   114k|    return be64toh_internal(x);
   85|   114k|}
_Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_:
   28|   148k|{
   29|   148k|    uint32_t x;
   30|   148k|    memcpy(&x, ptr, 4);
   31|   148k|    return le32toh_internal(x);
   32|   148k|}

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

_Z6HexStr4SpanIKSt4byteE:
   19|  10.5k|inline std::string HexStr(const Span<const std::byte> s) { return HexStr(MakeUCharSpan(s)); }

_ZN10CRIPEMD160C2Ev:
  243|  58.6k|{
  244|  58.6k|    ripemd160::Initialize(s);
  245|  58.6k|}
_ZN10CRIPEMD1605WriteEPKhm:
  248|   176k|{
  249|   176k|    const unsigned char* end = data + len;
  250|   176k|    size_t bufsize = bytes % 64;
  251|   176k|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (251:9): [True: 117k, False: 58.6k]
  |  Branch (251:20): [True: 58.6k, False: 58.6k]
  ------------------
  252|       |        // Fill the buffer, and process it.
  253|  58.6k|        memcpy(buf + bufsize, data, 64 - bufsize);
  254|  58.6k|        bytes += 64 - bufsize;
  255|  58.6k|        data += 64 - bufsize;
  256|  58.6k|        ripemd160::Transform(s, buf);
  257|  58.6k|        bufsize = 0;
  258|  58.6k|    }
  259|   176k|    while (end - data >= 64) {
  ------------------
  |  Branch (259:12): [True: 0, False: 176k]
  ------------------
  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|   176k|    if (end > data) {
  ------------------
  |  Branch (265:9): [True: 117k, False: 58.6k]
  ------------------
  266|       |        // Fill the buffer with what remains.
  267|   117k|        memcpy(buf + bufsize, data, end - data);
  268|   117k|        bytes += end - data;
  269|   117k|    }
  270|   176k|    return *this;
  271|   176k|}
_ZN10CRIPEMD1608FinalizeEPh:
  274|  58.6k|{
  275|  58.6k|    static const unsigned char pad[64] = {0x80};
  276|  58.6k|    unsigned char sizedesc[8];
  277|  58.6k|    WriteLE64(sizedesc, bytes << 3);
  278|  58.6k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  279|  58.6k|    Write(sizedesc, 8);
  280|  58.6k|    WriteLE32(hash, s[0]);
  281|  58.6k|    WriteLE32(hash + 4, s[1]);
  282|  58.6k|    WriteLE32(hash + 8, s[2]);
  283|  58.6k|    WriteLE32(hash + 12, s[3]);
  284|  58.6k|    WriteLE32(hash + 16, s[4]);
  285|  58.6k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd16010InitializeEPj:
   25|  58.6k|{
   26|  58.6k|    s[0] = 0x67452301ul;
   27|  58.6k|    s[1] = 0xEFCDAB89ul;
   28|  58.6k|    s[2] = 0x98BADCFEul;
   29|  58.6k|    s[3] = 0x10325476ul;
   30|  58.6k|    s[4] = 0xC3D2E1F0ul;
   31|  58.6k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1609TransformEPjPKh:
   55|  58.6k|{
   56|  58.6k|    uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
   57|  58.6k|    uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
   58|  58.6k|    uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12);
   59|  58.6k|    uint32_t w4 = ReadLE32(chunk + 16), w5 = ReadLE32(chunk + 20), w6 = ReadLE32(chunk + 24), w7 = ReadLE32(chunk + 28);
   60|  58.6k|    uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44);
   61|  58.6k|    uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60);
   62|       |
   63|  58.6k|    R11(a1, b1, c1, d1, e1, w0, 11);
   64|  58.6k|    R12(a2, b2, c2, d2, e2, w5, 8);
   65|  58.6k|    R11(e1, a1, b1, c1, d1, w1, 14);
   66|  58.6k|    R12(e2, a2, b2, c2, d2, w14, 9);
   67|  58.6k|    R11(d1, e1, a1, b1, c1, w2, 15);
   68|  58.6k|    R12(d2, e2, a2, b2, c2, w7, 9);
   69|  58.6k|    R11(c1, d1, e1, a1, b1, w3, 12);
   70|  58.6k|    R12(c2, d2, e2, a2, b2, w0, 11);
   71|  58.6k|    R11(b1, c1, d1, e1, a1, w4, 5);
   72|  58.6k|    R12(b2, c2, d2, e2, a2, w9, 13);
   73|  58.6k|    R11(a1, b1, c1, d1, e1, w5, 8);
   74|  58.6k|    R12(a2, b2, c2, d2, e2, w2, 15);
   75|  58.6k|    R11(e1, a1, b1, c1, d1, w6, 7);
   76|  58.6k|    R12(e2, a2, b2, c2, d2, w11, 15);
   77|  58.6k|    R11(d1, e1, a1, b1, c1, w7, 9);
   78|  58.6k|    R12(d2, e2, a2, b2, c2, w4, 5);
   79|  58.6k|    R11(c1, d1, e1, a1, b1, w8, 11);
   80|  58.6k|    R12(c2, d2, e2, a2, b2, w13, 7);
   81|  58.6k|    R11(b1, c1, d1, e1, a1, w9, 13);
   82|  58.6k|    R12(b2, c2, d2, e2, a2, w6, 7);
   83|  58.6k|    R11(a1, b1, c1, d1, e1, w10, 14);
   84|  58.6k|    R12(a2, b2, c2, d2, e2, w15, 8);
   85|  58.6k|    R11(e1, a1, b1, c1, d1, w11, 15);
   86|  58.6k|    R12(e2, a2, b2, c2, d2, w8, 11);
   87|  58.6k|    R11(d1, e1, a1, b1, c1, w12, 6);
   88|  58.6k|    R12(d2, e2, a2, b2, c2, w1, 14);
   89|  58.6k|    R11(c1, d1, e1, a1, b1, w13, 7);
   90|  58.6k|    R12(c2, d2, e2, a2, b2, w10, 14);
   91|  58.6k|    R11(b1, c1, d1, e1, a1, w14, 9);
   92|  58.6k|    R12(b2, c2, d2, e2, a2, w3, 12);
   93|  58.6k|    R11(a1, b1, c1, d1, e1, w15, 8);
   94|  58.6k|    R12(a2, b2, c2, d2, e2, w12, 6);
   95|       |
   96|  58.6k|    R21(e1, a1, b1, c1, d1, w7, 7);
   97|  58.6k|    R22(e2, a2, b2, c2, d2, w6, 9);
   98|  58.6k|    R21(d1, e1, a1, b1, c1, w4, 6);
   99|  58.6k|    R22(d2, e2, a2, b2, c2, w11, 13);
  100|  58.6k|    R21(c1, d1, e1, a1, b1, w13, 8);
  101|  58.6k|    R22(c2, d2, e2, a2, b2, w3, 15);
  102|  58.6k|    R21(b1, c1, d1, e1, a1, w1, 13);
  103|  58.6k|    R22(b2, c2, d2, e2, a2, w7, 7);
  104|  58.6k|    R21(a1, b1, c1, d1, e1, w10, 11);
  105|  58.6k|    R22(a2, b2, c2, d2, e2, w0, 12);
  106|  58.6k|    R21(e1, a1, b1, c1, d1, w6, 9);
  107|  58.6k|    R22(e2, a2, b2, c2, d2, w13, 8);
  108|  58.6k|    R21(d1, e1, a1, b1, c1, w15, 7);
  109|  58.6k|    R22(d2, e2, a2, b2, c2, w5, 9);
  110|  58.6k|    R21(c1, d1, e1, a1, b1, w3, 15);
  111|  58.6k|    R22(c2, d2, e2, a2, b2, w10, 11);
  112|  58.6k|    R21(b1, c1, d1, e1, a1, w12, 7);
  113|  58.6k|    R22(b2, c2, d2, e2, a2, w14, 7);
  114|  58.6k|    R21(a1, b1, c1, d1, e1, w0, 12);
  115|  58.6k|    R22(a2, b2, c2, d2, e2, w15, 7);
  116|  58.6k|    R21(e1, a1, b1, c1, d1, w9, 15);
  117|  58.6k|    R22(e2, a2, b2, c2, d2, w8, 12);
  118|  58.6k|    R21(d1, e1, a1, b1, c1, w5, 9);
  119|  58.6k|    R22(d2, e2, a2, b2, c2, w12, 7);
  120|  58.6k|    R21(c1, d1, e1, a1, b1, w2, 11);
  121|  58.6k|    R22(c2, d2, e2, a2, b2, w4, 6);
  122|  58.6k|    R21(b1, c1, d1, e1, a1, w14, 7);
  123|  58.6k|    R22(b2, c2, d2, e2, a2, w9, 15);
  124|  58.6k|    R21(a1, b1, c1, d1, e1, w11, 13);
  125|  58.6k|    R22(a2, b2, c2, d2, e2, w1, 13);
  126|  58.6k|    R21(e1, a1, b1, c1, d1, w8, 12);
  127|  58.6k|    R22(e2, a2, b2, c2, d2, w2, 11);
  128|       |
  129|  58.6k|    R31(d1, e1, a1, b1, c1, w3, 11);
  130|  58.6k|    R32(d2, e2, a2, b2, c2, w15, 9);
  131|  58.6k|    R31(c1, d1, e1, a1, b1, w10, 13);
  132|  58.6k|    R32(c2, d2, e2, a2, b2, w5, 7);
  133|  58.6k|    R31(b1, c1, d1, e1, a1, w14, 6);
  134|  58.6k|    R32(b2, c2, d2, e2, a2, w1, 15);
  135|  58.6k|    R31(a1, b1, c1, d1, e1, w4, 7);
  136|  58.6k|    R32(a2, b2, c2, d2, e2, w3, 11);
  137|  58.6k|    R31(e1, a1, b1, c1, d1, w9, 14);
  138|  58.6k|    R32(e2, a2, b2, c2, d2, w7, 8);
  139|  58.6k|    R31(d1, e1, a1, b1, c1, w15, 9);
  140|  58.6k|    R32(d2, e2, a2, b2, c2, w14, 6);
  141|  58.6k|    R31(c1, d1, e1, a1, b1, w8, 13);
  142|  58.6k|    R32(c2, d2, e2, a2, b2, w6, 6);
  143|  58.6k|    R31(b1, c1, d1, e1, a1, w1, 15);
  144|  58.6k|    R32(b2, c2, d2, e2, a2, w9, 14);
  145|  58.6k|    R31(a1, b1, c1, d1, e1, w2, 14);
  146|  58.6k|    R32(a2, b2, c2, d2, e2, w11, 12);
  147|  58.6k|    R31(e1, a1, b1, c1, d1, w7, 8);
  148|  58.6k|    R32(e2, a2, b2, c2, d2, w8, 13);
  149|  58.6k|    R31(d1, e1, a1, b1, c1, w0, 13);
  150|  58.6k|    R32(d2, e2, a2, b2, c2, w12, 5);
  151|  58.6k|    R31(c1, d1, e1, a1, b1, w6, 6);
  152|  58.6k|    R32(c2, d2, e2, a2, b2, w2, 14);
  153|  58.6k|    R31(b1, c1, d1, e1, a1, w13, 5);
  154|  58.6k|    R32(b2, c2, d2, e2, a2, w10, 13);
  155|  58.6k|    R31(a1, b1, c1, d1, e1, w11, 12);
  156|  58.6k|    R32(a2, b2, c2, d2, e2, w0, 13);
  157|  58.6k|    R31(e1, a1, b1, c1, d1, w5, 7);
  158|  58.6k|    R32(e2, a2, b2, c2, d2, w4, 7);
  159|  58.6k|    R31(d1, e1, a1, b1, c1, w12, 5);
  160|  58.6k|    R32(d2, e2, a2, b2, c2, w13, 5);
  161|       |
  162|  58.6k|    R41(c1, d1, e1, a1, b1, w1, 11);
  163|  58.6k|    R42(c2, d2, e2, a2, b2, w8, 15);
  164|  58.6k|    R41(b1, c1, d1, e1, a1, w9, 12);
  165|  58.6k|    R42(b2, c2, d2, e2, a2, w6, 5);
  166|  58.6k|    R41(a1, b1, c1, d1, e1, w11, 14);
  167|  58.6k|    R42(a2, b2, c2, d2, e2, w4, 8);
  168|  58.6k|    R41(e1, a1, b1, c1, d1, w10, 15);
  169|  58.6k|    R42(e2, a2, b2, c2, d2, w1, 11);
  170|  58.6k|    R41(d1, e1, a1, b1, c1, w0, 14);
  171|  58.6k|    R42(d2, e2, a2, b2, c2, w3, 14);
  172|  58.6k|    R41(c1, d1, e1, a1, b1, w8, 15);
  173|  58.6k|    R42(c2, d2, e2, a2, b2, w11, 14);
  174|  58.6k|    R41(b1, c1, d1, e1, a1, w12, 9);
  175|  58.6k|    R42(b2, c2, d2, e2, a2, w15, 6);
  176|  58.6k|    R41(a1, b1, c1, d1, e1, w4, 8);
  177|  58.6k|    R42(a2, b2, c2, d2, e2, w0, 14);
  178|  58.6k|    R41(e1, a1, b1, c1, d1, w13, 9);
  179|  58.6k|    R42(e2, a2, b2, c2, d2, w5, 6);
  180|  58.6k|    R41(d1, e1, a1, b1, c1, w3, 14);
  181|  58.6k|    R42(d2, e2, a2, b2, c2, w12, 9);
  182|  58.6k|    R41(c1, d1, e1, a1, b1, w7, 5);
  183|  58.6k|    R42(c2, d2, e2, a2, b2, w2, 12);
  184|  58.6k|    R41(b1, c1, d1, e1, a1, w15, 6);
  185|  58.6k|    R42(b2, c2, d2, e2, a2, w13, 9);
  186|  58.6k|    R41(a1, b1, c1, d1, e1, w14, 8);
  187|  58.6k|    R42(a2, b2, c2, d2, e2, w9, 12);
  188|  58.6k|    R41(e1, a1, b1, c1, d1, w5, 6);
  189|  58.6k|    R42(e2, a2, b2, c2, d2, w7, 5);
  190|  58.6k|    R41(d1, e1, a1, b1, c1, w6, 5);
  191|  58.6k|    R42(d2, e2, a2, b2, c2, w10, 15);
  192|  58.6k|    R41(c1, d1, e1, a1, b1, w2, 12);
  193|  58.6k|    R42(c2, d2, e2, a2, b2, w14, 8);
  194|       |
  195|  58.6k|    R51(b1, c1, d1, e1, a1, w4, 9);
  196|  58.6k|    R52(b2, c2, d2, e2, a2, w12, 8);
  197|  58.6k|    R51(a1, b1, c1, d1, e1, w0, 15);
  198|  58.6k|    R52(a2, b2, c2, d2, e2, w15, 5);
  199|  58.6k|    R51(e1, a1, b1, c1, d1, w5, 5);
  200|  58.6k|    R52(e2, a2, b2, c2, d2, w10, 12);
  201|  58.6k|    R51(d1, e1, a1, b1, c1, w9, 11);
  202|  58.6k|    R52(d2, e2, a2, b2, c2, w4, 9);
  203|  58.6k|    R51(c1, d1, e1, a1, b1, w7, 6);
  204|  58.6k|    R52(c2, d2, e2, a2, b2, w1, 12);
  205|  58.6k|    R51(b1, c1, d1, e1, a1, w12, 8);
  206|  58.6k|    R52(b2, c2, d2, e2, a2, w5, 5);
  207|  58.6k|    R51(a1, b1, c1, d1, e1, w2, 13);
  208|  58.6k|    R52(a2, b2, c2, d2, e2, w8, 14);
  209|  58.6k|    R51(e1, a1, b1, c1, d1, w10, 12);
  210|  58.6k|    R52(e2, a2, b2, c2, d2, w7, 6);
  211|  58.6k|    R51(d1, e1, a1, b1, c1, w14, 5);
  212|  58.6k|    R52(d2, e2, a2, b2, c2, w6, 8);
  213|  58.6k|    R51(c1, d1, e1, a1, b1, w1, 12);
  214|  58.6k|    R52(c2, d2, e2, a2, b2, w2, 13);
  215|  58.6k|    R51(b1, c1, d1, e1, a1, w3, 13);
  216|  58.6k|    R52(b2, c2, d2, e2, a2, w13, 6);
  217|  58.6k|    R51(a1, b1, c1, d1, e1, w8, 14);
  218|  58.6k|    R52(a2, b2, c2, d2, e2, w14, 5);
  219|  58.6k|    R51(e1, a1, b1, c1, d1, w11, 11);
  220|  58.6k|    R52(e2, a2, b2, c2, d2, w0, 15);
  221|  58.6k|    R51(d1, e1, a1, b1, c1, w6, 8);
  222|  58.6k|    R52(d2, e2, a2, b2, c2, w3, 13);
  223|  58.6k|    R51(c1, d1, e1, a1, b1, w15, 5);
  224|  58.6k|    R52(c2, d2, e2, a2, b2, w9, 11);
  225|  58.6k|    R51(b1, c1, d1, e1, a1, w13, 6);
  226|  58.6k|    R52(b2, c2, d2, e2, a2, w11, 11);
  227|       |
  228|  58.6k|    uint32_t t = s[0];
  229|  58.6k|    s[0] = s[1] + c1 + d2;
  230|  58.6k|    s[1] = s[2] + d1 + e2;
  231|  58.6k|    s[2] = s[3] + e1 + a2;
  232|  58.6k|    s[3] = s[4] + a1 + b2;
  233|  58.6k|    s[4] = t + b1 + c2;
  234|  58.6k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R11ERjjS1_jjji:
   41|   939k|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|  9.39M|{
   37|  9.39M|    a = rol(a + f + x + k, r) + e;
   38|  9.39M|    c = rol(c, 10);
   39|  9.39M|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603rolEji:
   33|  18.7M|uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f1Ejjj:
   17|  1.87M|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|   939k|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.87M|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|   939k|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.87M|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|   939k|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.87M|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|   939k|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.87M|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|   939k|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|   939k|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|   939k|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|   939k|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|   939k|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:
  697|   134k|{
  698|   134k|    sha256::Initialize(s);
  699|   134k|}
_ZN7CSHA2565WriteEPKhm:
  702|  11.4M|{
  703|  11.4M|    const unsigned char* end = data + len;
  704|  11.4M|    size_t bufsize = bytes % 64;
  705|  11.4M|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (705:9): [True: 11.0M, False: 399k]
  |  Branch (705:20): [True: 764k, False: 10.2M]
  ------------------
  706|       |        // Fill the buffer, and process it.
  707|   764k|        memcpy(buf + bufsize, data, 64 - bufsize);
  708|   764k|        bytes += 64 - bufsize;
  709|   764k|        data += 64 - bufsize;
  710|   764k|        Transform(s, buf, 1);
  711|   764k|        bufsize = 0;
  712|   764k|    }
  713|  11.4M|    if (end - data >= 64) {
  ------------------
  |  Branch (713:9): [True: 80.7k, False: 11.3M]
  ------------------
  714|  80.7k|        size_t blocks = (end - data) / 64;
  715|  80.7k|        Transform(s, data, blocks);
  716|  80.7k|        data += 64 * blocks;
  717|  80.7k|        bytes += 64 * blocks;
  718|  80.7k|    }
  719|  11.4M|    if (end > data) {
  ------------------
  |  Branch (719:9): [True: 11.0M, False: 399k]
  ------------------
  720|       |        // Fill the buffer with what remains.
  721|  11.0M|        memcpy(buf + bufsize, data, end - data);
  722|  11.0M|        bytes += end - data;
  723|  11.0M|    }
  724|  11.4M|    return *this;
  725|  11.4M|}
_ZN7CSHA2568FinalizeEPh:
  728|   231k|{
  729|   231k|    static const unsigned char pad[64] = {0x80};
  730|   231k|    unsigned char sizedesc[8];
  731|   231k|    WriteBE64(sizedesc, bytes << 3);
  732|   231k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  733|   231k|    Write(sizedesc, 8);
  734|   231k|    WriteBE32(hash, s[0]);
  735|   231k|    WriteBE32(hash + 4, s[1]);
  736|   231k|    WriteBE32(hash + 8, s[2]);
  737|   231k|    WriteBE32(hash + 12, s[3]);
  738|   231k|    WriteBE32(hash + 16, s[4]);
  739|   231k|    WriteBE32(hash + 20, s[5]);
  740|   231k|    WriteBE32(hash + 24, s[6]);
  741|   231k|    WriteBE32(hash + 28, s[7]);
  742|   231k|}
_ZN7CSHA2565ResetEv:
  745|  96.6k|{
  746|  96.6k|    bytes = 0;
  747|  96.6k|    sha256::Initialize(s);
  748|  96.6k|    return *this;
  749|  96.6k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2569TransformEPjPKhm:
  102|   845k|{
  103|  2.25M|    while (blocks--) {
  ------------------
  |  Branch (103:12): [True: 1.40M, False: 845k]
  ------------------
  104|  1.40M|        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];
  105|  1.40M|        uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
  106|       |
  107|  1.40M|        Round(a, b, c, d, e, f, g, h, 0x428a2f98 + (w0 = ReadBE32(chunk + 0)));
  108|  1.40M|        Round(h, a, b, c, d, e, f, g, 0x71374491 + (w1 = ReadBE32(chunk + 4)));
  109|  1.40M|        Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf + (w2 = ReadBE32(chunk + 8)));
  110|  1.40M|        Round(f, g, h, a, b, c, d, e, 0xe9b5dba5 + (w3 = ReadBE32(chunk + 12)));
  111|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x3956c25b + (w4 = ReadBE32(chunk + 16)));
  112|  1.40M|        Round(d, e, f, g, h, a, b, c, 0x59f111f1 + (w5 = ReadBE32(chunk + 20)));
  113|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x923f82a4 + (w6 = ReadBE32(chunk + 24)));
  114|  1.40M|        Round(b, c, d, e, f, g, h, a, 0xab1c5ed5 + (w7 = ReadBE32(chunk + 28)));
  115|  1.40M|        Round(a, b, c, d, e, f, g, h, 0xd807aa98 + (w8 = ReadBE32(chunk + 32)));
  116|  1.40M|        Round(h, a, b, c, d, e, f, g, 0x12835b01 + (w9 = ReadBE32(chunk + 36)));
  117|  1.40M|        Round(g, h, a, b, c, d, e, f, 0x243185be + (w10 = ReadBE32(chunk + 40)));
  118|  1.40M|        Round(f, g, h, a, b, c, d, e, 0x550c7dc3 + (w11 = ReadBE32(chunk + 44)));
  119|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x72be5d74 + (w12 = ReadBE32(chunk + 48)));
  120|  1.40M|        Round(d, e, f, g, h, a, b, c, 0x80deb1fe + (w13 = ReadBE32(chunk + 52)));
  121|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x9bdc06a7 + (w14 = ReadBE32(chunk + 56)));
  122|  1.40M|        Round(b, c, d, e, f, g, h, a, 0xc19bf174 + (w15 = ReadBE32(chunk + 60)));
  123|       |
  124|  1.40M|        Round(a, b, c, d, e, f, g, h, 0xe49b69c1 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  125|  1.40M|        Round(h, a, b, c, d, e, f, g, 0xefbe4786 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  126|  1.40M|        Round(g, h, a, b, c, d, e, f, 0x0fc19dc6 + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  127|  1.40M|        Round(f, g, h, a, b, c, d, e, 0x240ca1cc + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  128|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x2de92c6f + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  129|  1.40M|        Round(d, e, f, g, h, a, b, c, 0x4a7484aa + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  130|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  131|  1.40M|        Round(b, c, d, e, f, g, h, a, 0x76f988da + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  132|  1.40M|        Round(a, b, c, d, e, f, g, h, 0x983e5152 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  133|  1.40M|        Round(h, a, b, c, d, e, f, g, 0xa831c66d + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  134|  1.40M|        Round(g, h, a, b, c, d, e, f, 0xb00327c8 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  135|  1.40M|        Round(f, g, h, a, b, c, d, e, 0xbf597fc7 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  136|  1.40M|        Round(e, f, g, h, a, b, c, d, 0xc6e00bf3 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  137|  1.40M|        Round(d, e, f, g, h, a, b, c, 0xd5a79147 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  138|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x06ca6351 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  139|  1.40M|        Round(b, c, d, e, f, g, h, a, 0x14292967 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  140|       |
  141|  1.40M|        Round(a, b, c, d, e, f, g, h, 0x27b70a85 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  142|  1.40M|        Round(h, a, b, c, d, e, f, g, 0x2e1b2138 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  143|  1.40M|        Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  144|  1.40M|        Round(f, g, h, a, b, c, d, e, 0x53380d13 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  145|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x650a7354 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  146|  1.40M|        Round(d, e, f, g, h, a, b, c, 0x766a0abb + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  147|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x81c2c92e + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  148|  1.40M|        Round(b, c, d, e, f, g, h, a, 0x92722c85 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  149|  1.40M|        Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  150|  1.40M|        Round(h, a, b, c, d, e, f, g, 0xa81a664b + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  151|  1.40M|        Round(g, h, a, b, c, d, e, f, 0xc24b8b70 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  152|  1.40M|        Round(f, g, h, a, b, c, d, e, 0xc76c51a3 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  153|  1.40M|        Round(e, f, g, h, a, b, c, d, 0xd192e819 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  154|  1.40M|        Round(d, e, f, g, h, a, b, c, 0xd6990624 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  155|  1.40M|        Round(c, d, e, f, g, h, a, b, 0xf40e3585 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  156|  1.40M|        Round(b, c, d, e, f, g, h, a, 0x106aa070 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  157|       |
  158|  1.40M|        Round(a, b, c, d, e, f, g, h, 0x19a4c116 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  159|  1.40M|        Round(h, a, b, c, d, e, f, g, 0x1e376c08 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  160|  1.40M|        Round(g, h, a, b, c, d, e, f, 0x2748774c + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  161|  1.40M|        Round(f, g, h, a, b, c, d, e, 0x34b0bcb5 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  162|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x391c0cb3 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  163|  1.40M|        Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  164|  1.40M|        Round(c, d, e, f, g, h, a, b, 0x5b9cca4f + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  165|  1.40M|        Round(b, c, d, e, f, g, h, a, 0x682e6ff3 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  166|  1.40M|        Round(a, b, c, d, e, f, g, h, 0x748f82ee + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  167|  1.40M|        Round(h, a, b, c, d, e, f, g, 0x78a5636f + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  168|  1.40M|        Round(g, h, a, b, c, d, e, f, 0x84c87814 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  169|  1.40M|        Round(f, g, h, a, b, c, d, e, 0x8cc70208 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  170|  1.40M|        Round(e, f, g, h, a, b, c, d, 0x90befffa + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  171|  1.40M|        Round(d, e, f, g, h, a, b, c, 0xa4506ceb + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  172|  1.40M|        Round(c, d, e, f, g, h, a, b, 0xbef9a3f7 + (w14 + sigma1(w12) + w7 + sigma0(w15)));
  173|  1.40M|        Round(b, c, d, e, f, g, h, a, 0xc67178f2 + (w15 + sigma1(w13) + w8 + sigma0(w0)));
  174|       |
  175|  1.40M|        s[0] += a;
  176|  1.40M|        s[1] += b;
  177|  1.40M|        s[2] += c;
  178|  1.40M|        s[3] += d;
  179|  1.40M|        s[4] += e;
  180|  1.40M|        s[5] += f;
  181|  1.40M|        s[6] += g;
  182|  1.40M|        s[7] += h;
  183|  1.40M|        chunk += 64;
  184|  1.40M|    }
  185|   845k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2565RoundEjjjRjjjjS1_j:
   80|  90.0M|{
   81|  90.0M|    uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
   82|  90.0M|    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
   83|  90.0M|    d += t1;
   84|  90.0M|    h = t1 + t2;
   85|  90.0M|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma1Ej:
   74|  90.0M|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:
   71|  90.0M|uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma0Ej:
   73|  90.0M|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:
   72|  90.0M|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:
   76|  67.5M|uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma0Ej:
   75|  67.5M|uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); }
sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj:
   89|   231k|{
   90|   231k|    s[0] = 0x6a09e667ul;
   91|   231k|    s[1] = 0xbb67ae85ul;
   92|   231k|    s[2] = 0x3c6ef372ul;
   93|   231k|    s[3] = 0xa54ff53aul;
   94|   231k|    s[4] = 0x510e527ful;
   95|   231k|    s[5] = 0x9b05688cul;
   96|   231k|    s[6] = 0x1f83d9abul;
   97|   231k|    s[7] = 0x5be0cd19ul;
   98|   231k|}

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

_Z19SipHashUint256ExtrammRK7uint256j:
  136|  3.97k|{
  137|       |    /* Specialized implementation for efficiency */
  138|  3.97k|    uint64_t d = val.GetUint64(0);
  139|       |
  140|  3.97k|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
  141|  3.97k|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
  142|  3.97k|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
  143|  3.97k|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
  144|       |
  145|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  147|  3.97k|    v0 ^= d;
  148|  3.97k|    d = val.GetUint64(1);
  149|  3.97k|    v3 ^= d;
  150|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  151|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  152|  3.97k|    v0 ^= d;
  153|  3.97k|    d = val.GetUint64(2);
  154|  3.97k|    v3 ^= d;
  155|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  156|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|  3.97k|    v0 ^= d;
  158|  3.97k|    d = val.GetUint64(3);
  159|  3.97k|    v3 ^= d;
  160|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  161|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  162|  3.97k|    v0 ^= d;
  163|  3.97k|    d = ((uint64_t{36}) << 56) | extra;
  164|  3.97k|    v3 ^= d;
  165|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  166|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  167|  3.97k|    v0 ^= d;
  168|  3.97k|    v2 ^= 0xFF;
  169|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  170|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  171|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  172|  3.97k|    SIPROUND;
  ------------------
  |  |    9|  3.97k|#define SIPROUND do { \
  |  |   10|  3.97k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.97k|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.97k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.97k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.97k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.97k|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.97k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  173|  3.97k|    return v0 ^ v1 ^ v2 ^ v3;
  174|  3.97k|}

_ZN8CHash2568FinalizeE4SpanIhE:
   30|  91.9k|    void Finalize(Span<unsigned char> output) {
   31|  91.9k|        assert(output.size() == OUTPUT_SIZE);
   32|  91.9k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   33|  91.9k|        sha.Finalize(buf);
   34|  91.9k|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   35|  91.9k|    }
_ZN8CHash2565WriteE4SpanIKhE:
   37|  91.9k|    CHash256& Write(Span<const unsigned char> input) {
   38|  91.9k|        sha.Write(input.data(), input.size());
   39|  91.9k|        return *this;
   40|  91.9k|    }
_ZN8CHash1608FinalizeE4SpanIhE:
   55|  37.6k|    void Finalize(Span<unsigned char> output) {
   56|  37.6k|        assert(output.size() == OUTPUT_SIZE);
   57|  37.6k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   58|  37.6k|        sha.Finalize(buf);
   59|  37.6k|        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   60|  37.6k|    }
_ZN8CHash1605WriteE4SpanIKhE:
   62|  37.6k|    CHash160& Write(Span<const unsigned char> input) {
   63|  37.6k|        sha.Write(input.data(), input.size());
   64|  37.6k|        return *this;
   65|  37.6k|    }
_ZN10HashWriter5writeE4SpanIKSt4byteE:
  107|  10.7M|    {
  108|  10.7M|        ctx.Write(UCharCast(src.data()), src.size());
  109|  10.7M|    }
_ZN10HashWriter7GetHashEv:
  115|  4.74k|    uint256 GetHash() {
  116|  4.74k|        uint256 result;
  117|  4.74k|        ctx.Finalize(result.begin());
  118|  4.74k|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  119|  4.74k|        return result;
  120|  4.74k|    }
_Z9RIPEMD1604SpanIKhE:
  223|  21.0k|{
  224|  21.0k|    uint160 result;
  225|  21.0k|    CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin());
  226|  21.0k|    return result;
  227|  21.0k|}
_Z7Hash160I4SpanIKhEE7uint160RKT_:
   93|  37.6k|{
   94|  37.6k|    uint160 result;
   95|  37.6k|    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
   96|  37.6k|    return result;
   97|  37.6k|}
_Z4HashINSt3__16vectorIhNS0_9allocatorIhEEEEE7uint256RKT_:
   76|  91.9k|{
   77|  91.9k|    uint256 result;
   78|  91.9k|    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
   79|  91.9k|    return result;
   80|  91.9k|}
_ZN10HashWriterlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
  142|  4.74k|    {
  143|  4.74k|        ::Serialize(*this, obj);
  144|  4.74k|        return *this;
  145|  4.74k|    }

_ZNK12CChainParams12Base58PrefixENS_10Base58TypeE:
  118|  91.9k|    const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
_ZNK12CChainParams9Bech32HRPEv:
  119|   112k|    const std::string& Bech32HRP() const { return bech32_hrp; }

_Z17EncodeDestinationRKNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  295|   204k|{
  296|   204k|    return std::visit(DestinationEncoder(Params()), dest);
  297|   204k|}
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK6PKHash:
   31|  16.2k|    {
   32|  16.2k|        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
   33|  16.2k|        data.insert(data.end(), id.begin(), id.end());
   34|  16.2k|        return EncodeBase58Check(data);
   35|  16.2k|    }
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK10ScriptHash:
   38|  75.6k|    {
   39|  75.6k|        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
   40|  75.6k|        data.insert(data.end(), id.begin(), id.end());
   41|  75.6k|        return EncodeBase58Check(data);
   42|  75.6k|    }
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHash:
   53|  42.0k|    {
   54|  42.0k|        std::vector<unsigned char> data = {0};
   55|  42.0k|        data.reserve(53);
   56|  42.0k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
   57|  42.0k|        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
   58|  42.0k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashENKUlhE_clEh:
   56|  2.18M|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHash:
   45|  38.4k|    {
   46|  38.4k|        std::vector<unsigned char> data = {0};
   47|  38.4k|        data.reserve(33);
   48|  38.4k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
   49|  38.4k|        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
   50|  38.4k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashENKUlhE_clEh:
   48|  1.23M|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1Taproot:
   61|  10.0k|    {
   62|  10.0k|        std::vector<unsigned char> data = {1};
   63|  10.0k|        data.reserve(53);
   64|  10.0k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, tap.begin(), tap.end());
   65|  10.0k|        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
   66|  10.0k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootENKUlhE_clEh:
   64|   520k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, tap.begin(), tap.end());
key_io.cpp:_ZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknown:
   69|  21.9k|    {
   70|  21.9k|        const std::vector<unsigned char>& program = id.GetWitnessProgram();
   71|  21.9k|        if (id.GetWitnessVersion() < 1 || id.GetWitnessVersion() > 16 || program.size() < 2 || program.size() > 40) {
  ------------------
  |  Branch (71:13): [True: 0, False: 21.9k]
  |  Branch (71:43): [True: 0, False: 21.9k]
  |  Branch (71:74): [True: 0, False: 21.9k]
  |  Branch (71:96): [True: 0, False: 21.9k]
  ------------------
   72|      0|            return {};
   73|      0|        }
   74|  21.9k|        std::vector<unsigned char> data = {(unsigned char)id.GetWitnessVersion()};
   75|  21.9k|        data.reserve(1 + (program.size() * 8 + 4) / 5);
   76|  21.9k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());
   77|  21.9k|        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
   78|  21.9k|    }
key_io.cpp:_ZZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownENKUlhE_clEh:
   76|   427k|        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());
key_io.cpp:_ZN12_GLOBAL__N_118DestinationEncoderC2ERK12CChainParams:
   28|   204k|    explicit DestinationEncoder(const CChainParams& params) : m_params(params) {}

_Z11LogInstancev:
   25|  8.40k|{
   26|       |/**
   27|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   28|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   29|       | * since the order of destruction of static/global objects is undefined.
   30|       | * Consider if the logger gets destroyed, and then some later destructor calls
   31|       | * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
   32|       | * access the logger. When the shutdown sequence is fully audited and tested,
   33|       | * explicit destruction of these objects can be implemented by changing this
   34|       | * from a raw pointer to a std::unique_ptr.
   35|       | * Since the ~Logger() destructor is never called, the Logger class and all
   36|       | * its subclasses must have implicitly-defined destructors.
   37|       | *
   38|       | * This method of initialization was originally introduced in
   39|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   40|       | */
   41|  8.40k|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|  8.40k|    return *g_logger;
   43|  8.40k|}
_ZN5BCLog16LogEscapeMessageENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  325|  4.20k|    std::string LogEscapeMessage(std::string_view str) {
  326|  4.20k|        std::string ret;
  327|   512k|        for (char ch_in : str) {
  ------------------
  |  Branch (327:25): [True: 512k, False: 4.20k]
  ------------------
  328|   512k|            uint8_t ch = (uint8_t)ch_in;
  329|   512k|            if ((ch >= 32 || ch == '\n') && ch != '\x7f') {
  ------------------
  |  Branch (329:18): [True: 508k, False: 4.20k]
  |  Branch (329:30): [True: 4.20k, False: 0]
  |  Branch (329:45): [True: 512k, False: 0]
  ------------------
  330|   512k|                ret += ch_in;
  331|   512k|            } else {
  332|      0|                ret += strprintf("\\x%02x", ch);
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  333|      0|            }
  334|   512k|        }
  335|  4.20k|        return ret;
  336|  4.20k|    }
_ZN5BCLog6Logger11LogPrintStrENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_S5_iNS_8LogFlagsENS_5LevelE:
  388|  4.20k|{
  389|  4.20k|    StdLockGuard scoped_lock(m_cs);
  390|  4.20k|    return LogPrintStr_(str, logging_function, source_file, source_line, category, level);
  391|  4.20k|}
_ZN5BCLog6Logger12LogPrintStr_ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_S5_iNS_8LogFlagsENS_5LevelE:
  394|  4.20k|{
  395|  4.20k|    std::string str_prefixed = LogEscapeMessage(str);
  396|       |
  397|  4.20k|    if (m_buffering) {
  ------------------
  |  Branch (397:9): [True: 4.20k, False: 0]
  ------------------
  398|  4.20k|        {
  399|  4.20k|            BufferedLog buf{
  400|  4.20k|                .now=SystemClock::now(),
  401|  4.20k|                .mocktime=GetMockTime(),
  402|  4.20k|                .str=str_prefixed,
  403|  4.20k|                .logging_function=std::string(logging_function),
  404|  4.20k|                .source_file=std::string(source_file),
  405|  4.20k|                .threadname=util::ThreadGetInternalName(),
  406|  4.20k|                .source_line=source_line,
  407|  4.20k|                .category=category,
  408|  4.20k|                .level=level,
  409|  4.20k|            };
  410|  4.20k|            m_cur_buffer_memusage += MemUsage(buf);
  411|  4.20k|            m_msgs_before_open.push_back(std::move(buf));
  412|  4.20k|        }
  413|       |
  414|  5.46k|        while (m_cur_buffer_memusage > m_max_buffer_memusage) {
  ------------------
  |  Branch (414:16): [True: 1.26k, False: 4.20k]
  ------------------
  415|  1.26k|            if (m_msgs_before_open.empty()) {
  ------------------
  |  Branch (415:17): [True: 0, False: 1.26k]
  ------------------
  416|      0|                m_cur_buffer_memusage = 0;
  417|      0|                break;
  418|      0|            }
  419|  1.26k|            m_cur_buffer_memusage -= MemUsage(m_msgs_before_open.front());
  420|  1.26k|            m_msgs_before_open.pop_front();
  421|  1.26k|            ++m_buffer_lines_discarded;
  422|  1.26k|        }
  423|       |
  424|  4.20k|        return;
  425|  4.20k|    }
  426|       |
  427|      0|    FormatLogStrInPlace(str_prefixed, category, level, source_file, source_line, logging_function, util::ThreadGetInternalName(), SystemClock::now(), GetMockTime());
  428|       |
  429|      0|    if (m_print_to_console) {
  ------------------
  |  Branch (429:9): [True: 0, False: 0]
  ------------------
  430|       |        // print to console
  431|      0|        fwrite(str_prefixed.data(), 1, str_prefixed.size(), stdout);
  432|      0|        fflush(stdout);
  433|      0|    }
  434|      0|    for (const auto& cb : m_print_callbacks) {
  ------------------
  |  Branch (434:25): [True: 0, False: 0]
  ------------------
  435|      0|        cb(str_prefixed);
  436|      0|    }
  437|      0|    if (m_print_to_file) {
  ------------------
  |  Branch (437:9): [True: 0, False: 0]
  ------------------
  438|      0|        assert(m_fileout != nullptr);
  439|       |
  440|       |        // reopen the log file, if requested
  441|      0|        if (m_reopen_file) {
  ------------------
  |  Branch (441:13): [True: 0, False: 0]
  ------------------
  442|      0|            m_reopen_file = false;
  443|      0|            FILE* new_fileout = fsbridge::fopen(m_file_path, "a");
  444|      0|            if (new_fileout) {
  ------------------
  |  Branch (444:17): [True: 0, False: 0]
  ------------------
  445|      0|                setbuf(new_fileout, nullptr); // unbuffered
  446|      0|                fclose(m_fileout);
  447|      0|                m_fileout = new_fileout;
  448|      0|            }
  449|      0|        }
  450|      0|        FileWriteStr(str_prefixed, m_fileout);
  451|      0|    }
  452|      0|}
logging.cpp:_ZL8MemUsageRKN5BCLog6Logger11BufferedLogE:
  366|  5.46k|{
  367|  5.46k|    return buflog.str.size() + buflog.logging_function.size() + buflog.source_file.size() + buflog.threadname.size() + memusage::MallocUsage(sizeof(memusage::list_node<BCLog::Logger::BufferedLog>));
  368|  5.46k|}

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

transaction.cpp:_ZN8memusageL12DynamicUsageI5CTxInNSt3__19allocatorIS1_EEEEmRKNS2_6vectorIT_T0_EE:
   90|  3.57k|{
   91|  3.57k|    return MallocUsage(v.capacity() * sizeof(T));
   92|  3.57k|}
transaction.cpp:_ZN8memusageL11MallocUsageEm:
   53|  8.83M|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  8.83M|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 8.63M, False: 193k]
  ------------------
   56|  8.63M|        return 0;
   57|  8.63M|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|   193k|        return ((alloc + 31) >> 4) << 4;
   59|   193k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|  8.83M|}
transaction.cpp:_ZN8memusageL12DynamicUsageI6CTxOutNSt3__19allocatorIS1_EEEEmRKNS2_6vectorIT_T0_EE:
   90|  3.57k|{
   91|  3.57k|    return MallocUsage(v.capacity() * sizeof(T));
   92|  3.57k|}
transaction.cpp:_ZN8memusageL12DynamicUsageILj28EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|   522k|{
  109|   522k|    return MallocUsage(v.allocated_memory());
  110|   522k|}
transaction.cpp:_ZN8memusageL12DynamicUsageINSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEEmRKNS2_IT_T0_EE:
   90|   102k|{
   91|   102k|    return MallocUsage(v.capacity() * sizeof(T));
   92|   102k|}
transaction.cpp:_ZN8memusageL12DynamicUsageIhNSt3__19allocatorIhEEEEmRKNS1_6vectorIT_T0_EE:
   90|  8.19M|{
   91|  8.19M|    return MallocUsage(v.capacity() * sizeof(T));
   92|  8.19M|}
logging.cpp:_ZN8memusageL11MallocUsageEm:
   53|  5.46k|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  5.46k|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 0, False: 5.46k]
  ------------------
   56|      0|        return 0;
   57|  5.46k|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|  5.46k|        return ((alloc + 31) >> 4) << 4;
   59|  5.46k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|  5.46k|}

_ZNK8CFeeRate6GetFeeEj:
   24|  1.39k|{
   25|  1.39k|    const int64_t nSize{num_bytes};
   26|       |
   27|       |    // Be explicit that we're converting from a double to int64_t (CAmount) here.
   28|       |    // We've previously had issues with the silent double->int64_t conversion.
   29|  1.39k|    CAmount nFee{static_cast<CAmount>(std::ceil(nSatoshisPerK * nSize / 1000.0))};
   30|       |
   31|  1.39k|    if (nFee == 0 && nSize != 0) {
  ------------------
  |  Branch (31:9): [True: 0, False: 1.39k]
  |  Branch (31:22): [True: 0, False: 0]
  ------------------
   32|      0|        if (nSatoshisPerK > 0) nFee = CAmount(1);
  ------------------
  |  Branch (32:13): [True: 0, False: 0]
  ------------------
   33|      0|        if (nSatoshisPerK < 0) nFee = CAmount(-1);
  ------------------
  |  Branch (33:13): [True: 0, False: 0]
  ------------------
   34|      0|    }
   35|       |
   36|  1.39k|    return nFee;
   37|  1.39k|}

_ZN8CFeeRateC2ITkNSt3__18integralEjEET_:
   42|  3.57k|    explicit CFeeRate(const I _nSatoshisPerK): nSatoshisPerK(_nSatoshisPerK) {
   43|  3.57k|    }

_Z16GetDustThresholdRK6CTxOutRK8CFeeRate:
   27|  1.39k|{
   28|       |    // "Dust" is defined in terms of dustRelayFee,
   29|       |    // which has units satoshis-per-kilobyte.
   30|       |    // If you'd pay more in fees than the value of the output
   31|       |    // to spend something, then we consider it dust.
   32|       |    // A typical spendable non-segwit txout is 34 bytes big, and will
   33|       |    // need a CTxIn of at least 148 bytes to spend:
   34|       |    // so dust is a spendable txout less than
   35|       |    // 182*dustRelayFee/1000 (in satoshis).
   36|       |    // 546 satoshis at the default rate of 3000 sat/kvB.
   37|       |    // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
   38|       |    // need a CTxIn of at least 67 bytes to spend:
   39|       |    // so dust is a spendable txout less than
   40|       |    // 98*dustRelayFee/1000 (in satoshis).
   41|       |    // 294 satoshis at the default rate of 3000 sat/kvB.
   42|  1.39k|    if (txout.scriptPubKey.IsUnspendable())
  ------------------
  |  Branch (42:9): [True: 0, False: 1.39k]
  ------------------
   43|      0|        return 0;
   44|       |
   45|  1.39k|    size_t nSize = GetSerializeSize(txout);
   46|  1.39k|    int witnessversion = 0;
   47|  1.39k|    std::vector<unsigned char> witnessprogram;
   48|       |
   49|       |    // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
   50|       |    // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
   51|       |    // satisfaction is lower (a single BIP340 signature) but this computation was
   52|       |    // kept to not further reduce the dust level.
   53|       |    // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
   54|  1.39k|    if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (54:9): [True: 1.14k, False: 250]
  ------------------
   55|       |        // sum the sizes of the parts of a transaction input
   56|       |        // with 75% segwit discount applied to the script size.
   57|  1.14k|        nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
   58|  1.14k|    } else {
   59|    250|        nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
   60|    250|    }
   61|       |
   62|  1.39k|    return dustRelayFeeIn.GetFee(nSize);
   63|  1.39k|}
_Z6IsDustRK6CTxOutRK8CFeeRate:
   66|  1.39k|{
   67|  1.39k|    return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
   68|  1.39k|}
_Z7GetDustRK12CTransaction8CFeeRate:
   71|    900|{
   72|    900|    std::vector<uint32_t> dust_outputs;
   73|  2.29k|    for (uint32_t i{0}; i < tx.vout.size(); ++i) {
  ------------------
  |  Branch (73:25): [True: 1.39k, False: 900]
  ------------------
   74|  1.39k|        if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
  ------------------
  |  Branch (74:13): [True: 194, False: 1.19k]
  ------------------
   75|  1.39k|    }
   76|    900|    return dust_outputs;
   77|    900|}
_Z10IsStandardRK7CScriptRKNSt3__18optionalIjEER9TxoutType:
   80|  14.7k|{
   81|  14.7k|    std::vector<std::vector<unsigned char> > vSolutions;
   82|  14.7k|    whichType = Solver(scriptPubKey, vSolutions);
   83|       |
   84|  14.7k|    if (whichType == TxoutType::NONSTANDARD) {
  ------------------
  |  Branch (84:9): [True: 1.43k, False: 13.2k]
  ------------------
   85|  1.43k|        return false;
   86|  13.2k|    } else if (whichType == TxoutType::MULTISIG) {
  ------------------
  |  Branch (86:16): [True: 709, False: 12.5k]
  ------------------
   87|    709|        unsigned char m = vSolutions.front()[0];
   88|    709|        unsigned char n = vSolutions.back()[0];
   89|       |        // Support up to x-of-3 multisig txns as standard
   90|    709|        if (n < 1 || n > 3)
  ------------------
  |  Branch (90:13): [True: 0, False: 709]
  |  Branch (90:22): [True: 16, False: 693]
  ------------------
   91|     16|            return false;
   92|    693|        if (m < 1 || m > n)
  ------------------
  |  Branch (92:13): [True: 0, False: 693]
  |  Branch (92:22): [True: 0, False: 693]
  ------------------
   93|      0|            return false;
   94|  12.5k|    } else if (whichType == TxoutType::NULL_DATA) {
  ------------------
  |  Branch (94:16): [True: 51, False: 12.5k]
  ------------------
   95|     51|        if (!max_datacarrier_bytes || scriptPubKey.size() > *max_datacarrier_bytes) {
  ------------------
  |  Branch (95:13): [True: 51, False: 0]
  |  Branch (95:39): [True: 0, False: 0]
  ------------------
   96|     51|            return false;
   97|     51|        }
   98|     51|    }
   99|       |
  100|  13.2k|    return true;
  101|  14.7k|}
_Z12IsStandardTxRK12CTransactionRKNSt3__18optionalIjEEbRK8CFeeRateRNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  104|  7.15k|{
  105|  7.15k|    if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < 1) {
  ------------------
  |  Branch (105:9): [True: 3.08k, False: 4.06k]
  |  Branch (105:49): [True: 156, False: 3.91k]
  ------------------
  106|  3.24k|        reason = "version";
  107|  3.24k|        return false;
  108|  3.24k|    }
  109|       |
  110|       |    // Extremely large transactions with lots of inputs can cost the network
  111|       |    // almost as much to process as they cost the sender in fees, because
  112|       |    // computing signature hashes is O(ninputs*txsize). Limiting transactions
  113|       |    // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
  114|  3.91k|    unsigned int sz = GetTransactionWeight(tx);
  115|  3.91k|    if (sz > MAX_STANDARD_TX_WEIGHT) {
  ------------------
  |  Branch (115:9): [True: 72, False: 3.83k]
  ------------------
  116|     72|        reason = "tx-size";
  117|     72|        return false;
  118|     72|    }
  119|       |
  120|  3.83k|    for (const CTxIn& txin : tx.vin)
  ------------------
  |  Branch (120:28): [True: 16.5k, False: 2.65k]
  ------------------
  121|  16.5k|    {
  122|       |        // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
  123|       |        // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
  124|       |        // redeemScript size). That works out to a (15*(33+1))+3=513 byte
  125|       |        // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
  126|       |        // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
  127|       |        // some minor future-proofing. That's also enough to spend a
  128|       |        // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
  129|       |        // is not considered standard.
  130|  16.5k|        if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
  ------------------
  |  Branch (130:13): [True: 38, False: 16.5k]
  ------------------
  131|     38|            reason = "scriptsig-size";
  132|     38|            return false;
  133|     38|        }
  134|  16.5k|        if (!txin.scriptSig.IsPushOnly()) {
  ------------------
  |  Branch (134:13): [True: 1.15k, False: 15.3k]
  ------------------
  135|  1.15k|            reason = "scriptsig-not-pushonly";
  136|  1.15k|            return false;
  137|  1.15k|        }
  138|  16.5k|    }
  139|       |
  140|  2.65k|    unsigned int nDataOut = 0;
  141|  2.65k|    TxoutType whichType;
  142|  14.7k|    for (const CTxOut& txout : tx.vout) {
  ------------------
  |  Branch (142:30): [True: 14.7k, False: 900]
  ------------------
  143|  14.7k|        if (!::IsStandard(txout.scriptPubKey, max_datacarrier_bytes, whichType)) {
  ------------------
  |  Branch (143:13): [True: 1.50k, False: 13.2k]
  ------------------
  144|  1.50k|            reason = "scriptpubkey";
  145|  1.50k|            return false;
  146|  1.50k|        }
  147|       |
  148|  13.2k|        if (whichType == TxoutType::NULL_DATA)
  ------------------
  |  Branch (148:13): [True: 0, False: 13.2k]
  ------------------
  149|      0|            nDataOut++;
  150|  13.2k|        else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
  ------------------
  |  Branch (150:18): [True: 693, False: 12.5k]
  |  Branch (150:56): [True: 246, False: 447]
  ------------------
  151|    246|            reason = "bare-multisig";
  152|    246|            return false;
  153|    246|        }
  154|  13.2k|    }
  155|       |
  156|       |    // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
  157|    900|    if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
  ------------------
  |  Branch (157:9): [True: 31, False: 869]
  ------------------
  158|     31|        reason = "dust";
  159|     31|        return false;
  160|     31|    }
  161|       |
  162|       |    // only one OP_RETURN txout is permitted
  163|    869|    if (nDataOut > 1) {
  ------------------
  |  Branch (163:9): [True: 0, False: 869]
  ------------------
  164|      0|        reason = "multi-op-return";
  165|      0|        return false;
  166|      0|    }
  167|       |
  168|    869|    return true;
  169|    869|}
_Z17AreInputsStandardRK12CTransactionRK15CCoinsViewCache:
  190|  3.57k|{
  191|  3.57k|    if (tx.IsCoinBase()) {
  ------------------
  |  Branch (191:9): [True: 42, False: 3.53k]
  ------------------
  192|     42|        return true; // Coinbases don't use vin normally
  193|     42|    }
  194|       |
  195|  3.53k|    for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (195:30): [True: 3.44k, False: 87]
  ------------------
  196|  3.44k|        const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  197|       |
  198|  3.44k|        std::vector<std::vector<unsigned char> > vSolutions;
  199|  3.44k|        TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
  200|  3.44k|        if (whichType == TxoutType::NONSTANDARD || whichType == TxoutType::WITNESS_UNKNOWN) {
  ------------------
  |  Branch (200:13): [True: 3.44k, False: 0]
  |  Branch (200:52): [True: 0, False: 0]
  ------------------
  201|       |            // WITNESS_UNKNOWN failures are typically also caught with a policy
  202|       |            // flag in the script interpreter, but it can be helpful to catch
  203|       |            // this type of NONSTANDARD transaction earlier in transaction
  204|       |            // validation.
  205|  3.44k|            return false;
  206|  3.44k|        } else if (whichType == TxoutType::SCRIPTHASH) {
  ------------------
  |  Branch (206:20): [True: 0, False: 0]
  ------------------
  207|      0|            std::vector<std::vector<unsigned char> > stack;
  208|       |            // convert the scriptSig into a stack, so we can inspect the redeemScript
  209|      0|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
  ------------------
  |  Branch (209:17): [True: 0, False: 0]
  ------------------
  210|      0|                return false;
  211|      0|            if (stack.empty())
  ------------------
  |  Branch (211:17): [True: 0, False: 0]
  ------------------
  212|      0|                return false;
  213|      0|            CScript subscript(stack.back().begin(), stack.back().end());
  214|      0|            if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
  ------------------
  |  Branch (214:17): [True: 0, False: 0]
  ------------------
  215|      0|                return false;
  216|      0|            }
  217|      0|        }
  218|  3.44k|    }
  219|       |
  220|     87|    return true;
  221|  3.53k|}
_Z17IsWitnessStandardRK12CTransactionRK15CCoinsViewCache:
  224|  3.57k|{
  225|  3.57k|    if (tx.IsCoinBase())
  ------------------
  |  Branch (225:9): [True: 42, False: 3.53k]
  ------------------
  226|     42|        return true; // Coinbases are skipped
  227|       |
  228|  67.8k|    for (unsigned int i = 0; i < tx.vin.size(); i++)
  ------------------
  |  Branch (228:30): [True: 64.8k, False: 3.01k]
  ------------------
  229|  64.8k|    {
  230|       |        // We don't care if witness for this input is empty, since it must not be bloated.
  231|       |        // If the script is invalid without witness, it would be caught sooner or later during validation.
  232|  64.8k|        if (tx.vin[i].scriptWitness.IsNull())
  ------------------
  |  Branch (232:13): [True: 64.3k, False: 525]
  ------------------
  233|  64.3k|            continue;
  234|       |
  235|    525|        const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  236|       |
  237|       |        // get the scriptPubKey corresponding to this input:
  238|    525|        CScript prevScript = prev.scriptPubKey;
  239|       |
  240|       |        // witness stuffing detected
  241|    525|        if (prevScript.IsPayToAnchor()) {
  ------------------
  |  Branch (241:13): [True: 0, False: 525]
  ------------------
  242|      0|            return false;
  243|      0|        }
  244|       |
  245|    525|        bool p2sh = false;
  246|    525|        if (prevScript.IsPayToScriptHash()) {
  ------------------
  |  Branch (246:13): [True: 0, False: 525]
  ------------------
  247|      0|            std::vector <std::vector<unsigned char> > stack;
  248|       |            // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
  249|       |            // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
  250|       |            // If the check fails at this stage, we know that this txid must be a bad one.
  251|      0|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
  ------------------
  |  Branch (251:17): [True: 0, False: 0]
  ------------------
  252|      0|                return false;
  253|      0|            if (stack.empty())
  ------------------
  |  Branch (253:17): [True: 0, False: 0]
  ------------------
  254|      0|                return false;
  255|      0|            prevScript = CScript(stack.back().begin(), stack.back().end());
  256|      0|            p2sh = true;
  257|      0|        }
  258|       |
  259|    525|        int witnessversion = 0;
  260|    525|        std::vector<unsigned char> witnessprogram;
  261|       |
  262|       |        // Non-witness program must not be associated with any witness
  263|    525|        if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
  ------------------
  |  Branch (263:13): [True: 525, False: 0]
  ------------------
  264|    525|            return false;
  265|       |
  266|       |        // Check P2WSH standard limits
  267|      0|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (267:13): [True: 0, False: 0]
  |  Branch (267:36): [True: 0, False: 0]
  ------------------
  268|      0|            if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
  ------------------
  |  Branch (268:17): [True: 0, False: 0]
  ------------------
  269|      0|                return false;
  270|      0|            size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
  271|      0|            if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
  ------------------
  |  Branch (271:17): [True: 0, False: 0]
  ------------------
  272|      0|                return false;
  273|      0|            for (unsigned int j = 0; j < sizeWitnessStack; j++) {
  ------------------
  |  Branch (273:38): [True: 0, False: 0]
  ------------------
  274|      0|                if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
  ------------------
  |  Branch (274:21): [True: 0, False: 0]
  ------------------
  275|      0|                    return false;
  276|      0|            }
  277|      0|        }
  278|       |
  279|       |        // Check policy limits for Taproot spends:
  280|       |        // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
  281|       |        // - No annexes
  282|      0|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
  ------------------
  |  Branch (282:13): [True: 0, False: 0]
  |  Branch (282:36): [True: 0, False: 0]
  |  Branch (282:88): [True: 0, False: 0]
  ------------------
  283|       |            // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
  284|      0|            Span stack{tx.vin[i].scriptWitness.stack};
  285|      0|            if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
  ------------------
  |  Branch (285:17): [True: 0, False: 0]
  |  Branch (285:38): [True: 0, False: 0]
  |  Branch (285:63): [True: 0, False: 0]
  ------------------
  286|       |                // Annexes are nonstandard as long as no semantics are defined for them.
  287|      0|                return false;
  288|      0|            }
  289|      0|            if (stack.size() >= 2) {
  ------------------
  |  Branch (289:17): [True: 0, False: 0]
  ------------------
  290|       |                // Script path spend (2 or more stack elements after removing optional annex)
  291|      0|                const auto& control_block = SpanPopBack(stack);
  292|      0|                SpanPopBack(stack); // Ignore script
  293|      0|                if (control_block.empty()) return false; // Empty control block is invalid
  ------------------
  |  Branch (293:21): [True: 0, False: 0]
  ------------------
  294|      0|                if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
  ------------------
  |  Branch (294:21): [True: 0, False: 0]
  ------------------
  295|       |                    // Leaf version 0xc0 (aka Tapscript, see BIP 342)
  296|      0|                    for (const auto& item : stack) {
  ------------------
  |  Branch (296:43): [True: 0, False: 0]
  ------------------
  297|      0|                        if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
  ------------------
  |  Branch (297:29): [True: 0, False: 0]
  ------------------
  298|      0|                    }
  299|      0|                }
  300|      0|            } else if (stack.size() == 1) {
  ------------------
  |  Branch (300:24): [True: 0, False: 0]
  ------------------
  301|       |                // Key path spend (1 stack element after removing optional annex)
  302|       |                // (no policy rules apply)
  303|      0|            } else {
  304|       |                // 0 stack elements; this is already invalid by consensus rules
  305|      0|                return false;
  306|      0|            }
  307|      0|        }
  308|      0|    }
  309|  3.01k|    return true;
  310|  3.53k|}
_Z25GetVirtualTransactionSizellj:
  313|  3.57k|{
  314|  3.57k|    return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
  315|  3.57k|}
_Z25GetVirtualTransactionSizeRK12CTransactionlj:
  318|  3.57k|{
  319|  3.57k|    return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
  320|  3.57k|}

transaction.cpp:_ZL25GetVirtualTransactionSizeRK12CTransaction:
  175|  3.57k|{
  176|  3.57k|    return GetVirtualTransactionSize(tx, 0, 0);
  177|  3.57k|}

_ZN9prevectorILj28EhjiE3endEv:
  304|   363k|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj28EhjiE8item_ptrEi:
  206|  2.98M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 2.59M, False: 397k]
  ------------------
_ZNK9prevectorILj28EhjiE9is_directEv:
  173|   134M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj28EhjiE10direct_ptrEi:
  169|  2.98M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj28EhjiE12indirect_ptrEi:
  171|   397k|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj28EhjiE6insertENS0_8iteratorERKh:
  359|   263k|    iterator insert(iterator pos, const T& value) {
  360|   263k|        size_type p = pos - begin();
  361|   263k|        size_type new_size = size() + 1;
  362|   263k|        if (capacity() < new_size) {
  ------------------
  |  Branch (362:13): [True: 0, False: 263k]
  ------------------
  363|      0|            change_capacity(new_size + (new_size >> 1));
  364|      0|        }
  365|   263k|        T* ptr = item_ptr(p);
  366|   263k|        T* dst = ptr + 1;
  367|   263k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  368|   263k|        _size++;
  369|   263k|        new(static_cast<void*>(ptr)) T(value);
  370|   263k|        return iterator(ptr);
  371|   263k|    }
_ZN9prevectorILj28EhjiE5beginEv:
  302|   363k|    iterator begin() { return iterator(item_ptr(0)); }
_ZmiN9prevectorILj28EhjiE8iteratorES1_:
   66|   363k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj28EhjiE8iteratordeEv:
   59|   727k|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj28EhjiE8capacityEv:
  312|   854k|    size_t capacity() const {
  313|   854k|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 854k, False: 0]
  ------------------
  314|   854k|            return N;
  315|   854k|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|   854k|    }
_ZN9prevectorILj28EhjiE15change_capacityEj:
  175|  2.43M|    void change_capacity(size_type new_capacity) {
  176|  2.43M|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 2.03M, False: 397k]
  ------------------
  177|  2.03M|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 2.03M]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|  2.03M|        } else {
  186|   397k|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 397k]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|   397k|            } else {
  194|   397k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|   397k|                assert(new_indirect);
  196|   397k|                T* src = direct_ptr(0);
  197|   397k|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|   397k|                memcpy(dst, src, size() * sizeof(T));
  199|   397k|                _union.indirect_contents.indirect = new_indirect;
  200|   397k|                _union.indirect_contents.capacity = new_capacity;
  201|   397k|                _size += N + 1;
  202|   397k|            }
  203|   397k|        }
  204|  2.43M|    }
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvNS0_8iteratorET_S8_:
  387|   100k|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|   100k|        size_type p = pos - begin();
  389|   100k|        difference_type count = last - first;
  390|   100k|        size_type new_size = size() + count;
  391|   100k|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 27.8k, False: 72.7k]
  ------------------
  392|  27.8k|            change_capacity(new_size + (new_size >> 1));
  393|  27.8k|        }
  394|   100k|        T* ptr = item_ptr(p);
  395|   100k|        T* dst = ptr + count;
  396|   100k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|   100k|        _size += count;
  398|   100k|        fill(ptr, first, last);
  399|   100k|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  214|   100k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  2.31M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 2.21M, False: 100k]
  ------------------
  216|  2.21M|            new(static_cast<void*>(dst)) T(*first);
  217|  2.21M|            ++dst;
  218|  2.21M|            ++first;
  219|  2.21M|        }
  220|   100k|    }
_ZNK9prevectorILj28EhjiE3endEv:
  305|  27.4M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj28EhjiE8item_ptrEi:
  207|  45.0M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 17.0M, False: 27.9M]
  ------------------
_ZNK9prevectorILj28EhjiE10direct_ptrEi:
  170|  17.0M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE12indirect_ptrEi:
  172|  27.9M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE4sizeEv:
  294|  77.9M|    size_type size() const {
  295|  77.9M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 45.1M, False: 32.8M]
  ------------------
  296|  77.9M|    }
_ZNK9prevectorILj28EhjiE5beginEv:
  303|  5.31M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj28EhjiE14const_iteratordeEv:
  111|   135M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj28EhjiE5clearEv:
  355|  1.92M|    void clear() {
  356|  1.92M|        resize(0);
  357|  1.92M|    }
_ZN9prevectorILj28EhjiE6resizeEj:
  328|  1.92M|    void resize(size_type new_size) {
  329|  1.92M|        size_type cur_size = size();
  330|  1.92M|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 1.92M, False: 0]
  ------------------
  331|  1.92M|            return;
  332|  1.92M|        }
  333|      0|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 0, False: 0]
  ------------------
  334|      0|            erase(item_ptr(new_size), end());
  335|      0|            return;
  336|      0|        }
  337|      0|        if (new_size > capacity()) {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  ------------------
  338|      0|            change_capacity(new_size);
  339|      0|        }
  340|      0|        ptrdiff_t increase = new_size - cur_size;
  341|      0|        fill(item_ptr(cur_size), increase);
  342|      0|        _size += increase;
  343|      0|    }
_ZN9prevectorILj28EhjiE13shrink_to_fitEv:
  351|   859k|    void shrink_to_fit() {
  352|   859k|        change_capacity(size());
  353|   859k|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  214|  1.40M|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  51.9M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 50.5M, False: 1.40M]
  ------------------
  216|  50.5M|            new(static_cast<void*>(dst)) T(*first);
  217|  50.5M|            ++dst;
  218|  50.5M|            ++first;
  219|  50.5M|        }
  220|  1.40M|    }
_ZNK9prevectorILj28EhjiE14const_iteratorneES1_:
  125|  54.5M|        bool operator!=(const_iterator x) const { return ptr != x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEv:
  114|  68.0M|        const_iterator& operator++() { ptr++; return *this; }
_ZNK9prevectorILj28EhjiEeqERKS0_:
  481|   100k|    bool operator==(const prevector<N, T, Size, Diff>& other) const {
  482|   100k|        if (other.size() != size()) {
  ------------------
  |  Branch (482:13): [True: 0, False: 100k]
  ------------------
  483|      0|            return false;
  484|      0|        }
  485|   100k|        const_iterator b1 = begin();
  486|   100k|        const_iterator b2 = other.begin();
  487|   100k|        const_iterator e1 = end();
  488|  2.57M|        while (b1 != e1) {
  ------------------
  |  Branch (488:16): [True: 2.47M, False: 100k]
  ------------------
  489|  2.47M|            if ((*b1) != (*b2)) {
  ------------------
  |  Branch (489:17): [True: 0, False: 2.47M]
  ------------------
  490|      0|                return false;
  491|      0|            }
  492|  2.47M|            ++b1;
  493|  2.47M|            ++b2;
  494|  2.47M|        }
  495|   100k|        return true;
  496|   100k|    }
_ZNK9prevectorILj28EhjiE4dataEv:
  537|  7.54M|    const value_type* data() const {
  538|  7.54M|        return item_ptr(0);
  539|  7.54M|    }
_ZNK9prevectorILj28EhjiE16allocated_memoryEv:
  525|   522k|    size_t allocated_memory() const {
  526|   522k|        if (is_direct()) {
  ------------------
  |  Branch (526:13): [True: 453k, False: 69.1k]
  ------------------
  527|   453k|            return 0;
  528|   453k|        } else {
  529|  69.1k|            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
  530|  69.1k|        }
  531|   522k|    }
_ZNK9prevectorILj28EhjiE5emptyEv:
  298|  10.2M|    bool empty() const {
  299|  10.2M|        return size() == 0;
  300|  10.2M|    }
_ZNK9prevectorILj28EhjiEixEj:
  324|  3.47M|    const T& operator[](size_type pos) const {
  325|  3.47M|        return *item_ptr(pos);
  326|  3.47M|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|  4.15M|    ~prevector() {
  475|  4.15M|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 397k, False: 3.76M]
  ------------------
  476|   397k|            free(_union.indirect_contents.indirect);
  477|   397k|            _union.indirect_contents.indirect = nullptr;
  478|   397k|        }
  479|  4.15M|    }
_ZN9prevectorILj28EhjiEC2EOS0_:
  271|   433k|        : _union(std::move(other._union)), _size(other._size)
  272|   433k|    {
  273|   433k|        other._size = 0;
  274|   433k|    }
_ZN9prevectorILj28EhjiEC2Ev:
  243|  2.31M|    prevector() = default;
_ZN9prevectorILj28EhjiE8iteratorC2EPh:
   58|   991k|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiE20resize_uninitializedEj:
  401|   490k|    inline void resize_uninitialized(size_type new_size) {
  402|       |        // resize_uninitialized changes the size of the prevector but does not initialize it.
  403|       |        // If size < new_size, the added elements must be initialized explicitly.
  404|   490k|        if (capacity() < new_size) {
  ------------------
  |  Branch (404:13): [True: 139k, False: 351k]
  ------------------
  405|   139k|            change_capacity(new_size);
  406|   139k|            _size += new_size - size();
  407|   139k|            return;
  408|   139k|        }
  409|   351k|        if (new_size < size()) {
  ------------------
  |  Branch (409:13): [True: 0, False: 351k]
  ------------------
  410|      0|            erase(item_ptr(new_size), end());
  411|   351k|        } else {
  412|   351k|            _size += new_size - size();
  413|   351k|        }
  414|   351k|    }
_ZN9prevectorILj28EhjiEixEj:
  320|   490k|    T& operator[](size_type pos) {
  321|   490k|        return *item_ptr(pos);
  322|   490k|    }
_ZN9prevectorILj28EhjiE14const_iteratorC2EPKh:
  109|  40.5M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiEC2ERKS0_:
  263|  1.40M|    prevector(const prevector<N, T, Size, Diff>& other) {
  264|  1.40M|        size_type n = other.size();
  265|  1.40M|        change_capacity(n);
  266|  1.40M|        _size += n;
  267|  1.40M|        fill(item_ptr(0), other.begin(),  other.end());
  268|  1.40M|    }
_ZmiN9prevectorILj28EhjiE14const_iteratorES1_:
  118|  33.4M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj28EhjiEaSEOS0_:
  284|   871k|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  285|   871k|        if (!is_direct()) {
  ------------------
  |  Branch (285:13): [True: 0, False: 871k]
  ------------------
  286|      0|            free(_union.indirect_contents.indirect);
  287|      0|        }
  288|   871k|        _union = std::move(other._union);
  289|   871k|        _size = other._size;
  290|   871k|        other._size = 0;
  291|   871k|        return *this;
  292|   871k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorptEv:
  112|  13.7M|        const T* operator->() const { return ptr; }
_ZNK9prevectorILj28EhjiE14const_iteratorltES1_:
  129|  13.1M|        bool operator<(const_iterator x) const { return ptr < x.ptr; }
_ZNK9prevectorILj28EhjiE4backEv:
  464|  1.25M|    const T& back() const {
  465|  1.25M|        return *item_ptr(size() - 1);
  466|  1.25M|    }
_ZNK9prevectorILj28EhjiE14const_iteratorplEj:
  119|  7.79M|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
_ZNK9prevectorILj28EhjiE14const_iteratoreqES1_:
  124|  26.2k|        bool operator==(const_iterator x) const { return ptr == x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorpLEj:
  121|  8.99M|        const_iterator& operator+=(size_type n) { ptr += n; return *this; }
_ZNK9prevectorILj28EhjiE14const_iteratorixEj:
  113|  20.1k|        const T& operator[](size_type pos) const { return ptr[pos]; }
_ZNK9prevectorILj28EhjiE14const_iteratorgeES1_:
  126|  12.5M|        bool operator>=(const_iterator x) const { return ptr >= x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEi:
  116|  12.5M|        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }

_ZNK9COutPoint8ToStringEv:
   22|   102k|{
   23|   102k|    return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10), n);
  ------------------
  |  | 1172|   102k|#define strprintf tfm::format
  ------------------
   24|   102k|}
_ZNK5CTxIn8ToStringEv:
   41|   102k|{
   42|   102k|    std::string str;
   43|   102k|    str += "CTxIn(";
   44|   102k|    str += prevout.ToString();
   45|   102k|    if (prevout.IsNull())
  ------------------
  |  Branch (45:9): [True: 96, False: 101k]
  ------------------
   46|     96|        str += strprintf(", coinbase %s", HexStr(scriptSig));
  ------------------
  |  | 1172|     96|#define strprintf tfm::format
  ------------------
   47|   101k|    else
   48|   101k|        str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
  ------------------
  |  | 1172|   101k|#define strprintf tfm::format
  ------------------
   49|   102k|    if (nSequence != SEQUENCE_FINAL)
  ------------------
  |  Branch (49:9): [True: 99.0k, False: 3.00k]
  ------------------
   50|  99.0k|        str += strprintf(", nSequence=%u", nSequence);
  ------------------
  |  | 1172|  99.0k|#define strprintf tfm::format
  ------------------
   51|   102k|    str += ")";
   52|   102k|    return str;
   53|   102k|}
_ZNK6CTxOut8ToStringEv:
   62|   420k|{
   63|   420k|    return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
  ------------------
  |  | 1172|   420k|#define strprintf tfm::format
  ------------------
   64|   420k|}
_ZN19CMutableTransactionC2Ev:
   66|  4.83k|CMutableTransaction::CMutableTransaction() : version{CTransaction::CURRENT_VERSION}, nLockTime{0} {}
_ZNK12CTransaction17ComputeHasWitnessEv:
   75|  4.20k|{
   76|  4.20k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  4.20k|        return !input.scriptWitness.IsNull();
   78|  4.20k|    });
   79|  4.20k|}
_ZNK12CTransaction11ComputeHashEv:
   82|  4.20k|{
   83|  4.20k|    return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash());
   84|  4.20k|}
_ZNK12CTransaction18ComputeWitnessHashEv:
   87|  4.20k|{
   88|  4.20k|    if (!HasWitness()) {
  ------------------
  |  Branch (88:9): [True: 3.66k, False: 539]
  ------------------
   89|  3.66k|        return Wtxid::FromUint256(hash.ToUint256());
   90|  3.66k|    }
   91|       |
   92|    539|    return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash());
   93|  4.20k|}
_ZN12CTransactionC2EO19CMutableTransaction:
   96|  4.20k|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|  3.57k|{
  100|  3.57k|    CAmount nValueOut = 0;
  101|  26.1k|    for (const auto& tx_out : vout) {
  ------------------
  |  Branch (101:29): [True: 26.1k, False: 1.79k]
  ------------------
  102|  26.1k|        if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut + tx_out.nValue))
  ------------------
  |  Branch (102:13): [True: 1.77k, False: 24.4k]
  |  Branch (102:13): [True: 1.77k, False: 24.4k]
  |  Branch (102:43): [True: 2, False: 24.4k]
  ------------------
  103|  1.77k|            throw std::runtime_error(std::string(__func__) + ": value out of range");
  104|  24.4k|        nValueOut += tx_out.nValue;
  105|  24.4k|    }
  106|  1.79k|    assert(MoneyRange(nValueOut));
  107|  1.79k|    return nValueOut;
  108|  1.79k|}
_ZNK12CTransaction12GetTotalSizeEv:
  111|  14.1k|{
  112|  14.1k|    return ::GetSerializeSize(TX_WITH_WITNESS(*this));
  113|  14.1k|}
_ZNK12CTransaction8ToStringEv:
  116|  3.57k|{
  117|  3.57k|    std::string str;
  118|  3.57k|    str += strprintf("CTransaction(hash=%s, ver=%u, vin.size=%u, vout.size=%u, nLockTime=%u)\n",
  ------------------
  |  | 1172|  3.57k|#define strprintf tfm::format
  ------------------
  119|  3.57k|        GetHash().ToString().substr(0,10),
  120|  3.57k|        version,
  121|  3.57k|        vin.size(),
  122|  3.57k|        vout.size(),
  123|  3.57k|        nLockTime);
  124|  3.57k|    for (const auto& tx_in : vin)
  ------------------
  |  Branch (124:28): [True: 102k, False: 3.57k]
  ------------------
  125|   102k|        str += "    " + tx_in.ToString() + "\n";
  126|  3.57k|    for (const auto& tx_in : vin)
  ------------------
  |  Branch (126:28): [True: 102k, False: 3.57k]
  ------------------
  127|   102k|        str += "    " + tx_in.scriptWitness.ToString() + "\n";
  128|  3.57k|    for (const auto& tx_out : vout)
  ------------------
  |  Branch (128:29): [True: 420k, False: 3.57k]
  ------------------
  129|   420k|        str += "    " + tx_out.ToString() + "\n";
  130|  3.57k|    return str;
  131|  3.57k|}
transaction.cpp:_ZZNK12CTransaction17ComputeHasWitnessEvENK3$_0clI5CTxInEEDaRKT_:
   76|  64.8k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  64.8k|        return !input.scriptWitness.IsNull();
   78|  64.8k|    });

_ZN9COutPointC2Ev:
   36|   216k|    COutPoint(): n(NULL_INDEX) { }
_ZNK9COutPoint6IsNullEv:
   42|   132k|    bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
  ------------------
  |  Branch (42:35): [True: 55.9k, False: 76.7k]
  |  Branch (42:52): [True: 323, False: 55.6k]
  ------------------
_ZltRK9COutPointS1_:
   45|   465k|    {
   46|   465k|        return std::tie(a.hash, a.n) < std::tie(b.hash, b.n);
   47|   465k|    }
_ZN5CTxInC2Ev:
  122|   212k|    {
  123|   212k|        nSequence = SEQUENCE_FINAL;
  124|   212k|    }
_ZN6CTxOutC2Ev:
  156|   859k|    {
  157|   859k|        SetNull();
  158|   859k|    }
_ZN6CTxOut7SetNullEv:
  165|   859k|    {
  166|   859k|        nValue = -1;
  167|   859k|        scriptPubKey.clear();
  168|   859k|    }
_ZNK12CTransaction6IsNullEv:
  339|  3.57k|    bool IsNull() const {
  340|  3.57k|        return vin.empty() && vout.empty();
  ------------------
  |  Branch (340:16): [True: 87, False: 3.49k]
  |  Branch (340:31): [True: 87, False: 0]
  ------------------
  341|  3.57k|    }
_ZNK12CTransaction7GetHashEv:
  343|  14.1k|    const Txid& GetHash() const LIFETIMEBOUND { return hash; }
_ZNK12CTransaction14GetWitnessHashEv:
  344|  10.5k|    const Wtxid& GetWitnessHash() const LIFETIMEBOUND { return m_witness_hash; };
_ZNK12CTransaction10IsCoinBaseEv:
  357|   128k|    {
  358|   128k|        return (vin.size() == 1 && vin[0].prevout.IsNull());
  ------------------
  |  Branch (358:17): [True: 13.0k, False: 115k]
  |  Branch (358:36): [True: 224, False: 12.8k]
  ------------------
  359|   128k|    }
_ZNK12CTransaction10HasWitnessEv:
  373|  58.1k|    bool HasWitness() const { return m_has_witness; }
_ZNK19CMutableTransaction10HasWitnessEv:
  413|  1.11k|    {
  414|  72.0k|        for (size_t i = 0; i < vin.size(); i++) {
  ------------------
  |  Branch (414:28): [True: 72.0k, False: 32]
  ------------------
  415|  72.0k|            if (!vin[i].scriptWitness.IsNull()) {
  ------------------
  |  Branch (415:17): [True: 1.08k, False: 70.9k]
  ------------------
  416|  1.08k|                return true;
  417|  1.08k|            }
  418|  72.0k|        }
  419|     32|        return false;
  420|  1.11k|    }
_ZNK12CTransaction9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  328|  66.9k|    inline void Serialize(Stream& s) const {
  329|  66.9k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  330|  66.9k|    }
_Z20SerializeTransactionI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  257|  66.9k|{
  258|  66.9k|    const bool fAllowWitness = params.allow_witness;
  259|       |
  260|  66.9k|    s << tx.version;
  261|  66.9k|    unsigned char flags = 0;
  262|       |    // Consistency check
  263|  66.9k|    if (fAllowWitness) {
  ------------------
  |  Branch (263:9): [True: 39.2k, False: 27.6k]
  ------------------
  264|       |        /* Check whether witnesses need to be serialized. */
  265|  39.2k|        if (tx.HasWitness()) {
  ------------------
  |  Branch (265:13): [True: 5.73k, False: 33.5k]
  ------------------
  266|  5.73k|            flags |= 1;
  267|  5.73k|        }
  268|  39.2k|    }
  269|  66.9k|    if (flags) {
  ------------------
  |  Branch (269:9): [True: 5.73k, False: 61.1k]
  ------------------
  270|       |        /* Use extended format in case witnesses are to be serialized. */
  271|  5.73k|        std::vector<CTxIn> vinDummy;
  272|  5.73k|        s << vinDummy;
  273|  5.73k|        s << flags;
  274|  5.73k|    }
  275|  66.9k|    s << tx.vin;
  276|  66.9k|    s << tx.vout;
  277|  66.9k|    if (flags & 1) {
  ------------------
  |  Branch (277:9): [True: 5.73k, False: 61.1k]
  ------------------
  278|   539k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (278:28): [True: 533k, False: 5.73k]
  ------------------
  279|   533k|            s << tx.vin[i].scriptWitness.stack;
  280|   533k|        }
  281|  5.73k|    }
  282|  66.9k|    s << tx.nLockTime;
  283|  66.9k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|  1.34M|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|  1.34M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|  1.34M|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|  1.34M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  162|  6.95M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|  6.95M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN19CMutableTransaction11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  393|  4.20k|    inline void Unserialize(Stream& s) {
  394|  4.20k|        UnserializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  395|  4.20k|    }
_Z22UnserializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE19CMutableTransactionEvRT0_RT_RKS3_:
  217|  4.20k|{
  218|  4.20k|    const bool fAllowWitness = params.allow_witness;
  219|       |
  220|  4.20k|    s >> tx.version;
  221|  4.20k|    unsigned char flags = 0;
  222|  4.20k|    tx.vin.clear();
  223|  4.20k|    tx.vout.clear();
  224|       |    /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
  225|  4.20k|    s >> tx.vin;
  226|  4.20k|    if (tx.vin.size() == 0 && fAllowWitness) {
  ------------------
  |  Branch (226:9): [True: 994, False: 3.21k]
  |  Branch (226:31): [True: 994, False: 0]
  ------------------
  227|       |        /* We read a dummy or an empty vin. */
  228|    994|        s >> flags;
  229|    994|        if (flags != 0) {
  ------------------
  |  Branch (229:13): [True: 905, False: 89]
  ------------------
  230|    905|            s >> tx.vin;
  231|    905|            s >> tx.vout;
  232|    905|        }
  233|  3.21k|    } else {
  234|       |        /* We read a non-empty vin. Assume a normal vout follows. */
  235|  3.21k|        s >> tx.vout;
  236|  3.21k|    }
  237|  4.20k|    if ((flags & 1) && fAllowWitness) {
  ------------------
  |  Branch (237:9): [True: 718, False: 3.48k]
  |  Branch (237:24): [True: 718, False: 0]
  ------------------
  238|       |        /* The witness flag is present, and we support witnesses. */
  239|    718|        flags ^= 1;
  240|  74.3k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (240:28): [True: 73.6k, False: 718]
  ------------------
  241|  73.6k|            s >> tx.vin[i].scriptWitness.stack;
  242|  73.6k|        }
  243|    718|        if (!tx.HasWitness()) {
  ------------------
  |  Branch (243:13): [True: 16, False: 702]
  ------------------
  244|       |            /* It's illegal to encode witnesses when all witness stacks are empty. */
  245|     16|            throw std::ios_base::failure("Superfluous witness record");
  246|     16|        }
  247|    718|    }
  248|  4.18k|    if (flags) {
  ------------------
  |  Branch (248:9): [True: 9, False: 4.17k]
  ------------------
  249|       |        /* Unknown flag in the serialization */
  250|      9|        throw std::ios_base::failure("Unknown transaction optional data");
  251|      9|    }
  252|  4.17k|    s >> tx.nLockTime;
  253|  4.17k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  129|   106k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   106k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
   39|   106k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   106k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  162|   426k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|   426k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   39|   106k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   106k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  328|  10.5k|    inline void Serialize(Stream& s) const {
  329|  10.5k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  330|  10.5k|    }
_Z20SerializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  257|  10.5k|{
  258|  10.5k|    const bool fAllowWitness = params.allow_witness;
  259|       |
  260|  10.5k|    s << tx.version;
  261|  10.5k|    unsigned char flags = 0;
  262|       |    // Consistency check
  263|  10.5k|    if (fAllowWitness) {
  ------------------
  |  Branch (263:9): [True: 10.5k, False: 0]
  ------------------
  264|       |        /* Check whether witnesses need to be serialized. */
  265|  10.5k|        if (tx.HasWitness()) {
  ------------------
  |  Branch (265:13): [True: 1.53k, False: 9.05k]
  ------------------
  266|  1.53k|            flags |= 1;
  267|  1.53k|        }
  268|  10.5k|    }
  269|  10.5k|    if (flags) {
  ------------------
  |  Branch (269:9): [True: 1.53k, False: 9.05k]
  ------------------
  270|       |        /* Use extended format in case witnesses are to be serialized. */
  271|  1.53k|        std::vector<CTxIn> vinDummy;
  272|  1.53k|        s << vinDummy;
  273|  1.53k|        s << flags;
  274|  1.53k|    }
  275|  10.5k|    s << tx.vin;
  276|  10.5k|    s << tx.vout;
  277|  10.5k|    if (flags & 1) {
  ------------------
  |  Branch (277:9): [True: 1.53k, False: 9.05k]
  ------------------
  278|   141k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (278:28): [True: 140k, False: 1.53k]
  ------------------
  279|   140k|            s << tx.vin[i].scriptWitness.stack;
  280|   140k|        }
  281|  1.53k|    }
  282|  10.5k|    s << tx.nLockTime;
  283|  10.5k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|   219k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   219k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|   219k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   219k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  162|   973k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|   973k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN5CTxIn16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  129|   106k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   106k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  162|   426k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|   426k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  162|  1.39k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|  1.39k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN12CTransactionC2I10DataStreamEE16deserialize_typeRK20TransactionSerParamsRT_:
  335|  4.20k|    CTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) : CTransaction(CMutableTransaction(deserialize, params, s)) {}
_ZN19CMutableTransactionC2I10DataStreamEE16deserialize_typeRK20TransactionSerParamsRT_:
  398|  4.20k|    CMutableTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) {
  399|  4.20k|        UnserializeTransaction(*this, s, params);
  400|  4.20k|    }
_Z22UnserializeTransactionI10DataStream19CMutableTransactionEvRT0_RT_RK20TransactionSerParams:
  217|  4.20k|{
  218|  4.20k|    const bool fAllowWitness = params.allow_witness;
  219|       |
  220|  4.20k|    s >> tx.version;
  221|  4.20k|    unsigned char flags = 0;
  222|  4.20k|    tx.vin.clear();
  223|  4.20k|    tx.vout.clear();
  224|       |    /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
  225|  4.20k|    s >> tx.vin;
  226|  4.20k|    if (tx.vin.size() == 0 && fAllowWitness) {
  ------------------
  |  Branch (226:9): [True: 994, False: 3.21k]
  |  Branch (226:31): [True: 994, False: 0]
  ------------------
  227|       |        /* We read a dummy or an empty vin. */
  228|    994|        s >> flags;
  229|    994|        if (flags != 0) {
  ------------------
  |  Branch (229:13): [True: 905, False: 89]
  ------------------
  230|    905|            s >> tx.vin;
  231|    905|            s >> tx.vout;
  232|    905|        }
  233|  3.21k|    } else {
  234|       |        /* We read a non-empty vin. Assume a normal vout follows. */
  235|  3.21k|        s >> tx.vout;
  236|  3.21k|    }
  237|  4.20k|    if ((flags & 1) && fAllowWitness) {
  ------------------
  |  Branch (237:9): [True: 718, False: 3.48k]
  |  Branch (237:24): [True: 718, False: 0]
  ------------------
  238|       |        /* The witness flag is present, and we support witnesses. */
  239|    718|        flags ^= 1;
  240|  74.3k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (240:28): [True: 73.6k, False: 718]
  ------------------
  241|  73.6k|            s >> tx.vin[i].scriptWitness.stack;
  242|  73.6k|        }
  243|    718|        if (!tx.HasWitness()) {
  ------------------
  |  Branch (243:13): [True: 16, False: 702]
  ------------------
  244|       |            /* It's illegal to encode witnesses when all witness stacks are empty. */
  245|     16|            throw std::ios_base::failure("Superfluous witness record");
  246|     16|        }
  247|    718|    }
  248|  4.18k|    if (flags) {
  ------------------
  |  Branch (248:9): [True: 9, False: 4.17k]
  ------------------
  249|       |        /* Unknown flag in the serialization */
  250|      9|        throw std::ios_base::failure("Unknown transaction optional data");
  251|      9|    }
  252|  4.17k|    s >> tx.nLockTime;
  253|  4.17k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|   172k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   172k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|   172k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   172k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  162|   626k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|   626k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  328|  4.74k|    inline void Serialize(Stream& s) const {
  329|  4.74k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  330|  4.74k|    }
_Z20SerializeTransactionI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  257|  4.74k|{
  258|  4.74k|    const bool fAllowWitness = params.allow_witness;
  259|       |
  260|  4.74k|    s << tx.version;
  261|  4.74k|    unsigned char flags = 0;
  262|       |    // Consistency check
  263|  4.74k|    if (fAllowWitness) {
  ------------------
  |  Branch (263:9): [True: 539, False: 4.20k]
  ------------------
  264|       |        /* Check whether witnesses need to be serialized. */
  265|    539|        if (tx.HasWitness()) {
  ------------------
  |  Branch (265:13): [True: 539, False: 0]
  ------------------
  266|    539|            flags |= 1;
  267|    539|        }
  268|    539|    }
  269|  4.74k|    if (flags) {
  ------------------
  |  Branch (269:9): [True: 539, False: 4.20k]
  ------------------
  270|       |        /* Use extended format in case witnesses are to be serialized. */
  271|    539|        std::vector<CTxIn> vinDummy;
  272|    539|        s << vinDummy;
  273|    539|        s << flags;
  274|    539|    }
  275|  4.74k|    s << tx.vin;
  276|  4.74k|    s << tx.vout;
  277|  4.74k|    if (flags & 1) {
  ------------------
  |  Branch (277:9): [True: 539, False: 4.20k]
  ------------------
  278|  70.6k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (278:28): [True: 70.0k, False: 539]
  ------------------
  279|  70.0k|            s << tx.vin[i].scriptWitness.stack;
  280|  70.0k|        }
  281|    539|    }
  282|  4.74k|    s << tx.nLockTime;
  283|  4.74k|}

_ZNK11XOnlyPubKey9GetKeyIDsEv:
  201|  3.23k|{
  202|  3.23k|    std::vector<CKeyID> out;
  203|       |    // For now, use the old full pubkey-based key derivation logic. As it is indexed by
  204|       |    // Hash160(full pubkey), we need to return both a version prefixed with 0x02, and one
  205|       |    // with 0x03.
  206|  3.23k|    unsigned char b[33] = {0x02};
  207|  3.23k|    std::copy(m_keydata.begin(), m_keydata.end(), b + 1);
  208|  3.23k|    CPubKey fullpubkey;
  209|  3.23k|    fullpubkey.Set(b, b + 33);
  210|  3.23k|    out.push_back(fullpubkey.GetID());
  211|  3.23k|    b[0] = 0x03;
  212|  3.23k|    fullpubkey.Set(b, b + 33);
  213|  3.23k|    out.push_back(fullpubkey.GetID());
  214|  3.23k|    return out;
  215|  3.23k|}
_ZNK11XOnlyPubKey27GetEvenCorrespondingCPubKeyEv:
  218|  3.23k|{
  219|  3.23k|    unsigned char full_key[CPubKey::COMPRESSED_SIZE] = {0x02};
  220|  3.23k|    std::copy(begin(), end(), full_key + 1);
  221|  3.23k|    return CPubKey{full_key};
  222|  3.23k|}
_ZNK11XOnlyPubKey12IsFullyValidEv:
  225|  6.62k|{
  226|  6.62k|    secp256k1_xonly_pubkey pubkey;
  227|  6.62k|    return secp256k1_xonly_pubkey_parse(secp256k1_context_static, &pubkey, m_keydata.data());
  228|  6.62k|}

_ZN6CKeyIDC2ERK7uint160:
   27|  65.0k|    explicit CKeyID(const uint160& in) : uint160(in) {}
_ZN7CPubKey6GetLenEh:
   61|   289k|    {
   62|   289k|        if (chHeader == 2 || chHeader == 3)
  ------------------
  |  Branch (62:13): [True: 127k, False: 162k]
  |  Branch (62:30): [True: 120k, False: 42.1k]
  ------------------
   63|   247k|            return COMPRESSED_SIZE;
   64|  42.1k|        if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  ------------------
  |  Branch (64:13): [True: 21.0k, False: 21.1k]
  |  Branch (64:30): [True: 8.37k, False: 12.7k]
  |  Branch (64:47): [True: 8.47k, False: 4.29k]
  ------------------
   65|  37.8k|            return SIZE;
   66|  4.29k|        return 0;
   67|  42.1k|    }
_ZN7CPubKey10InvalidateEv:
   71|  30.6k|    {
   72|  30.6k|        vch[0] = 0xFF;
   73|  30.6k|    }
_ZN7CPubKey9ValidSizeERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
   77|   148k|    bool static ValidSize(const std::vector<unsigned char> &vch) {
   78|   148k|      return vch.size() > 0 && GetLen(vch[0]) == vch.size();
  ------------------
  |  Branch (78:14): [True: 119k, False: 28.2k]
  |  Branch (78:32): [True: 114k, False: 5.13k]
  ------------------
   79|   148k|    }
_ZN7CPubKeyC2Ev:
   83|  30.6k|    {
   84|  30.6k|        Invalidate();
   85|  30.6k|    }
_ZN7CPubKeyC2E4SpanIKhE:
  107|  47.3k|    {
  108|  47.3k|        Set(_vch.begin(), _vch.end());
  109|  47.3k|    }
_ZNK7CPubKey4sizeEv:
  112|   115k|    unsigned int size() const { return GetLen(vch[0]); }
_ZNK7CPubKey4dataEv:
  113|  34.0k|    const unsigned char* data() const { return vch; }
_ZNK7CPubKey5GetIDEv:
  165|  37.6k|    {
  166|  37.6k|        return CKeyID(Hash160(Span{vch}.first(size())));
  167|  37.6k|    }
_ZNK7CPubKey7IsValidEv:
  190|  10.8k|    {
  191|  10.8k|        return size() > 0;
  192|  10.8k|    }
_ZNK7CPubKey16IsValidNonHybridEv:
  196|  33.1k|    {
  197|  33.1k|        return size() > 0 && (vch[0] == 0x02 || vch[0] == 0x03 || vch[0] == 0x04);
  ------------------
  |  Branch (197:16): [True: 33.1k, False: 0]
  |  Branch (197:31): [True: 14.2k, False: 18.9k]
  |  Branch (197:49): [True: 14.3k, False: 4.63k]
  |  Branch (197:67): [True: 2.66k, False: 1.97k]
  ------------------
  198|  33.1k|    }
_ZNK11XOnlyPubKey5beginEv:
  295|  16.6k|    const unsigned char* begin() const { return m_keydata.begin(); }
_ZNK11XOnlyPubKey3endEv:
  296|  16.6k|    const unsigned char* end() const { return m_keydata.end(); }
_ZN11XOnlyPubKey5beginEv:
  298|  16.6k|    unsigned char* begin() { return m_keydata.begin(); }
_ZN7CPubKey3SetIPKhEEvT_S3_:
   90|  47.3k|    {
   91|  47.3k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 47.3k]
  ------------------
   92|  47.3k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 47.3k, False: 0]
  |  Branch (92:20): [True: 47.3k, False: 0]
  ------------------
   93|  47.3k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|  47.3k|    }
_ZN11XOnlyPubKeyC2Ev:
  242|  23.2k|    XOnlyPubKey() = default;
_ZN7CPubKey3SetIPhEEvT_S2_:
   90|  6.46k|    {
   91|  6.46k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 6.46k]
  ------------------
   92|  6.46k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 6.46k, False: 0]
  |  Branch (92:20): [True: 6.46k, False: 0]
  ------------------
   93|  6.46k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|  6.46k|    }

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

_ZN17FastRandomContext6rand64Ev:
  396|  7.15k|    {
  397|  7.15k|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (397:13): [True: 7.15k, False: 0]
  ------------------
  398|  7.15k|        std::array<std::byte, 8> buf;
  399|  7.15k|        rng.Keystream(buf);
  400|  7.15k|        return ReadLE64(buf.data());
  401|  7.15k|    }
_Z11GetRandHashv:
  455|  7.15k|{
  456|  7.15k|    uint256 hash;
  457|  7.15k|    GetRandBytes(hash);
  458|  7.15k|    return hash;
  459|  7.15k|}
_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  7.15k|    constexpr RandomMixin() noexcept = default;

_Z15InferDescriptorRK7CScriptRK15SigningProvider:
 2384|   553k|{
 2385|   553k|    return InferScript(script, ParseScriptContext::TOP, provider);
 2386|   553k|}
descriptor.cpp:_ZN12_GLOBAL__N_118DescriptorChecksumERK4SpanIKcE:
  106|   553k|{
  107|       |    /** A character set designed such that:
  108|       |     *  - The most common 'unprotected' descriptor characters (hex, keypaths) are in the first group of 32.
  109|       |     *  - Case errors cause an offset that's a multiple of 32.
  110|       |     *  - As many alphabetic characters are in the same group (while following the above restrictions).
  111|       |     *
  112|       |     * If p(x) gives the position of a character c in this character set, every group of 3 characters
  113|       |     * (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).
  114|       |     * This means that changes that only affect the lower 5 bits of the position, or only the higher 2 bits, will just
  115|       |     * affect a single symbol.
  116|       |     *
  117|       |     * As a result, within-group-of-32 errors count as 1 symbol, as do cross-group errors that don't affect
  118|       |     * the position within the groups.
  119|       |     */
  120|   553k|    static const std::string INPUT_CHARSET =
  121|   553k|        "0123456789()[],'/*abcdefgh@:$%{}"
  122|   553k|        "IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~"
  123|   553k|        "ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";
  124|       |
  125|       |    /** The character set for the checksum itself (same as bech32). */
  126|   553k|    static const std::string CHECKSUM_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
  127|       |
  128|   553k|    uint64_t c = 1;
  129|   553k|    int cls = 0;
  130|   553k|    int clscount = 0;
  131|  41.2M|    for (auto ch : span) {
  ------------------
  |  Branch (131:18): [True: 41.2M, False: 553k]
  ------------------
  132|  41.2M|        auto pos = INPUT_CHARSET.find(ch);
  133|  41.2M|        if (pos == std::string::npos) return "";
  ------------------
  |  Branch (133:13): [True: 0, False: 41.2M]
  ------------------
  134|  41.2M|        c = PolyMod(c, pos & 31); // Emit a symbol for the position inside the group, for every character.
  135|  41.2M|        cls = cls * 3 + (pos >> 5); // Accumulate the group numbers
  136|  41.2M|        if (++clscount == 3) {
  ------------------
  |  Branch (136:13): [True: 13.5M, False: 27.7M]
  ------------------
  137|       |            // Emit an extra symbol representing the group numbers, for every 3 characters.
  138|  13.5M|            c = PolyMod(c, cls);
  139|  13.5M|            cls = 0;
  140|  13.5M|            clscount = 0;
  141|  13.5M|        }
  142|  41.2M|    }
  143|   553k|    if (clscount > 0) c = PolyMod(c, cls);
  ------------------
  |  Branch (143:9): [True: 506k, False: 46.8k]
  ------------------
  144|  4.97M|    for (int j = 0; j < 8; ++j) c = PolyMod(c, 0); // Shift further to determine the checksum.
  ------------------
  |  Branch (144:21): [True: 4.42M, False: 553k]
  ------------------
  145|   553k|    c ^= 1; // Prevent appending zeroes from not affecting the checksum.
  146|       |
  147|   553k|    std::string ret(8, ' ');
  148|  4.97M|    for (int j = 0; j < 8; ++j) ret[j] = CHECKSUM_CHARSET[(c >> (5 * (7 - j))) & 31];
  ------------------
  |  Branch (148:21): [True: 4.42M, False: 553k]
  ------------------
  149|   553k|    return ret;
  150|   553k|}
descriptor.cpp:_ZN12_GLOBAL__N_17PolyModEmi:
   94|  59.6M|{
   95|  59.6M|    uint8_t c0 = c >> 35;
   96|  59.6M|    c = ((c & 0x7ffffffff) << 5) ^ val;
   97|  59.6M|    if (c0 & 1) c ^= 0xf5dee51989;
  ------------------
  |  Branch (97:9): [True: 28.5M, False: 31.1M]
  ------------------
   98|  59.6M|    if (c0 & 2) c ^= 0xa9fdca3312;
  ------------------
  |  Branch (98:9): [True: 26.9M, False: 32.7M]
  ------------------
   99|  59.6M|    if (c0 & 4) c ^= 0x1bab10e32d;
  ------------------
  |  Branch (99:9): [True: 27.0M, False: 32.6M]
  ------------------
  100|  59.6M|    if (c0 & 8) c ^= 0x3706b1677a;
  ------------------
  |  Branch (100:9): [True: 26.5M, False: 33.1M]
  ------------------
  101|  59.6M|    if (c0 & 16) c ^= 0x644d626ffd;
  ------------------
  |  Branch (101:9): [True: 26.9M, False: 32.7M]
  ------------------
  102|  59.6M|    return c;
  103|  59.6M|}
descriptor.cpp:_ZN12_GLOBAL__N_119ConstPubkeyProviderC2EjRK7CPubKeyb:
  300|  34.4k|    ConstPubkeyProvider(uint32_t exp_index, const CPubKey& pubkey, bool xonly) : PubkeyProvider(exp_index), m_pubkey(pubkey), m_xonly(xonly) {}
descriptor.cpp:_ZN12_GLOBAL__N_114PubkeyProviderC2Ej:
  169|  34.4k|    explicit PubkeyProvider(uint32_t exp_index) : m_expr_index(exp_index) {}
descriptor.cpp:_ZN12_GLOBAL__N_114PubkeyProviderD2Ev:
  171|  34.4k|    virtual ~PubkeyProvider() = default;
descriptor.cpp:_ZNK12_GLOBAL__N_119ConstPubkeyProvider8ToStringENS_14PubkeyProvider10StringTypeE:
  311|  34.0k|    std::string ToString(StringType type) const override { return m_xonly ? HexStr(m_pubkey).substr(2) : HexStr(m_pubkey); }
  ------------------
  |  Branch (311:67): [True: 3.23k, False: 30.8k]
  ------------------
descriptor.cpp:_ZN12_GLOBAL__N_112PKDescriptorC2ENSt3__110unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS3_EEEEb:
  856|  8.79k|    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:
  601|   553k|    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:
  680|   553k|    {
  681|   553k|        std::string ret;
  682|   553k|        ToStringHelper(nullptr, ret, compat_format ? StringType::COMPAT : StringType::PUBLIC);
  ------------------
  |  Branch (682:38): [True: 0, False: 553k]
  ------------------
  683|   553k|        return AddChecksum(ret);
  684|   553k|    }
descriptor.cpp:_ZN12_GLOBAL__N_111AddChecksumERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  152|   553k|std::string AddChecksum(const std::string& str) { return str + "#" + DescriptorChecksum(str); }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl13ToStringExtraEv:
  586|  12.0k|    virtual std::string ToStringExtra() const { return ""; }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl23ToStringSubScriptHelperEPK15SigningProviderRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_10StringTypeEPK15DescriptorCache:
  636|   553k|    {
  637|   553k|        size_t pos = 0;
  638|   553k|        for (const auto& scriptarg : m_subdescriptor_args) {
  ------------------
  |  Branch (638:36): [True: 0, False: 553k]
  ------------------
  639|      0|            if (pos++) ret += ",";
  ------------------
  |  Branch (639:17): [True: 0, False: 0]
  ------------------
  640|      0|            std::string tmp;
  641|      0|            if (!scriptarg->ToStringHelper(arg, tmp, type, cache)) return false;
  ------------------
  |  Branch (641:17): [True: 0, False: 0]
  ------------------
  642|      0|            ret += tmp;
  643|      0|        }
  644|   553k|        return true;
  645|   553k|    }
descriptor.cpp:_ZNK12_GLOBAL__N_114DescriptorImpl14ToStringHelperEPK15SigningProviderRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS0_10StringTypeEPK15DescriptorCache:
  649|   553k|    {
  650|   553k|        std::string extra = ToStringExtra();
  651|   553k|        size_t pos = extra.size() > 0 ? 1 : 0;
  ------------------
  |  Branch (651:22): [True: 410k, False: 142k]
  ------------------
  652|   553k|        std::string ret = m_name + "(" + extra;
  653|   553k|        for (const auto& pubkey : m_pubkey_args) {
  ------------------
  |  Branch (653:33): [True: 34.0k, False: 553k]
  ------------------
  654|  34.0k|            if (pos++) ret += ",";
  ------------------
  |  Branch (654:17): [True: 22.0k, False: 12.0k]
  ------------------
  655|  34.0k|            std::string tmp;
  656|  34.0k|            switch (type) {
  ------------------
  |  Branch (656:21): [True: 0, False: 34.0k]
  ------------------
  657|      0|                case StringType::NORMALIZED:
  ------------------
  |  Branch (657:17): [True: 0, False: 34.0k]
  ------------------
  658|      0|                    if (!pubkey->ToNormalizedString(*arg, tmp, cache)) return false;
  ------------------
  |  Branch (658:25): [True: 0, False: 0]
  ------------------
  659|      0|                    break;
  660|      0|                case StringType::PRIVATE:
  ------------------
  |  Branch (660:17): [True: 0, False: 34.0k]
  ------------------
  661|      0|                    if (!pubkey->ToPrivateString(*arg, tmp)) return false;
  ------------------
  |  Branch (661:25): [True: 0, False: 0]
  ------------------
  662|      0|                    break;
  663|  34.0k|                case StringType::PUBLIC:
  ------------------
  |  Branch (663:17): [True: 34.0k, False: 0]
  ------------------
  664|  34.0k|                    tmp = pubkey->ToString();
  665|  34.0k|                    break;
  666|      0|                case StringType::COMPAT:
  ------------------
  |  Branch (666:17): [True: 0, False: 34.0k]
  ------------------
  667|      0|                    tmp = pubkey->ToString(PubkeyProvider::StringType::COMPAT);
  668|      0|                    break;
  669|  34.0k|            }
  670|  34.0k|            ret += tmp;
  671|  34.0k|        }
  672|   553k|        std::string subscript;
  673|   553k|        if (!ToStringSubScriptHelper(arg, subscript, type, cache)) return false;
  ------------------
  |  Branch (673:13): [True: 0, False: 553k]
  ------------------
  674|   553k|        if (pos && subscript.size()) ret += ',';
  ------------------
  |  Branch (674:13): [True: 422k, False: 130k]
  |  Branch (674:20): [True: 0, False: 422k]
  ------------------
  675|   553k|        out = std::move(ret) + std::move(subscript) + ")";
  676|   553k|        return true;
  677|   553k|    }
descriptor.cpp:_ZN12_GLOBAL__N_118MultisigDescriptorC2EiNSt3__16vectorINS1_10unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEEb:
  992|  7.28k|    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 (992:155): [True: 0, False: 7.28k]
  ------------------
descriptor.cpp:_ZNK12_GLOBAL__N_118MultisigDescriptor13ToStringExtraEv:
  982|  7.28k|    std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
  ------------------
  |  | 1172|  7.28k|#define strprintf tfm::format
  ------------------
descriptor.cpp:_ZN12_GLOBAL__N_117AddressDescriptorC2ENSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  795|   100k|    AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, "addr"), m_destination(std::move(destination)) {}
descriptor.cpp:_ZNK12_GLOBAL__N_117AddressDescriptor13ToStringExtraEv:
  792|   100k|    std::string ToStringExtra() const override { return EncodeDestination(m_destination); }
descriptor.cpp:_ZN12_GLOBAL__N_115RawTRDescriptorC2ENSt3__110unique_ptrINS_14PubkeyProviderENS1_14default_deleteIS3_EEEE:
 1373|  3.23k|    RawTRDescriptor(std::unique_ptr<PubkeyProvider> output_key) : DescriptorImpl(Vector(std::move(output_key)), "rawtr") {}
descriptor.cpp:_ZN12_GLOBAL__N_113RawDescriptorC2E7CScript:
  820|   433k|    RawDescriptor(CScript script) : DescriptorImpl({}, "raw"), m_script(std::move(script)) {}
descriptor.cpp:_ZNK12_GLOBAL__N_113RawDescriptor13ToStringExtraEv:
  817|   433k|    std::string ToStringExtra() const override { return HexStr(m_script); }
descriptor.cpp:_ZN12_GLOBAL__N_111InferScriptERK7CScriptNS_18ParseScriptContextERK15SigningProvider:
 2179|   553k|{
 2180|   553k|    if (ctx == ParseScriptContext::P2TR && script.size() == 34 && script[0] == 32 && script[33] == OP_CHECKSIG) {
  ------------------
  |  Branch (2180:9): [True: 0, False: 553k]
  |  Branch (2180:44): [True: 0, False: 0]
  |  Branch (2180:67): [True: 0, False: 0]
  |  Branch (2180:86): [True: 0, False: 0]
  ------------------
 2181|      0|        XOnlyPubKey key{Span{script}.subspan(1, 32)};
 2182|      0|        return std::make_unique<PKDescriptor>(InferXOnlyPubkey(key, ctx, provider), true);
 2183|      0|    }
 2184|       |
 2185|   553k|    if (ctx == ParseScriptContext::P2TR) {
  ------------------
  |  Branch (2185:9): [True: 0, False: 553k]
  ------------------
 2186|      0|        auto ret = InferMultiA(script, ctx, provider);
 2187|      0|        if (ret) return ret;
  ------------------
  |  Branch (2187:13): [True: 0, False: 0]
  ------------------
 2188|      0|    }
 2189|       |
 2190|   553k|    std::vector<std::vector<unsigned char>> data;
 2191|   553k|    TxoutType txntype = Solver(script, data);
 2192|       |
 2193|   553k|    if (txntype == TxoutType::PUBKEY && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2193:9): [True: 9.84k, False: 543k]
  |  Branch (2193:42): [True: 9.84k, False: 0]
  |  Branch (2193:76): [True: 0, False: 0]
  |  Branch (2193:111): [True: 0, False: 0]
  ------------------
 2194|  9.84k|        CPubKey pubkey(data[0]);
 2195|  9.84k|        if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2195:18): [True: 8.79k, False: 1.04k]
  ------------------
 2196|  8.79k|            return std::make_unique<PKDescriptor>(std::move(pubkey_provider));
 2197|  8.79k|        }
 2198|  9.84k|    }
 2199|   544k|    if (txntype == TxoutType::PUBKEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2199:9): [True: 8.14k, False: 536k]
  |  Branch (2199:46): [True: 8.14k, False: 0]
  |  Branch (2199:80): [True: 0, False: 0]
  |  Branch (2199:115): [True: 0, False: 0]
  ------------------
 2200|  8.14k|        uint160 hash(data[0]);
 2201|  8.14k|        CKeyID keyid(hash);
 2202|  8.14k|        CPubKey pubkey;
 2203|  8.14k|        if (provider.GetPubKey(keyid, pubkey)) {
  ------------------
  |  Branch (2203:13): [True: 0, False: 8.14k]
  ------------------
 2204|      0|            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2204:22): [True: 0, False: 0]
  ------------------
 2205|      0|                return std::make_unique<PKHDescriptor>(std::move(pubkey_provider));
 2206|      0|            }
 2207|      0|        }
 2208|  8.14k|    }
 2209|   544k|    if (txntype == TxoutType::WITNESS_V0_KEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
  ------------------
  |  Branch (2209:9): [True: 19.2k, False: 525k]
  |  Branch (2209:54): [True: 19.2k, False: 0]
  |  Branch (2209:88): [True: 0, False: 0]
  ------------------
 2210|  19.2k|        uint160 hash(data[0]);
 2211|  19.2k|        CKeyID keyid(hash);
 2212|  19.2k|        CPubKey pubkey;
 2213|  19.2k|        if (provider.GetPubKey(keyid, pubkey)) {
  ------------------
  |  Branch (2213:13): [True: 0, False: 19.2k]
  ------------------
 2214|      0|            if (auto pubkey_provider = InferPubkey(pubkey, ParseScriptContext::P2WPKH, provider)) {
  ------------------
  |  Branch (2214:22): [True: 0, False: 0]
  ------------------
 2215|      0|                return std::make_unique<WPKHDescriptor>(std::move(pubkey_provider));
 2216|      0|            }
 2217|      0|        }
 2218|  19.2k|    }
 2219|   544k|    if (txntype == TxoutType::MULTISIG && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
  ------------------
  |  Branch (2219:9): [True: 8.21k, False: 536k]
  |  Branch (2219:44): [True: 8.21k, False: 0]
  |  Branch (2219:78): [True: 0, False: 0]
  |  Branch (2219:113): [True: 0, False: 0]
  ------------------
 2220|  8.21k|        bool ok = true;
 2221|  8.21k|        std::vector<std::unique_ptr<PubkeyProvider>> providers;
 2222|  30.6k|        for (size_t i = 1; i + 1 < data.size(); ++i) {
  ------------------
  |  Branch (2222:28): [True: 23.3k, False: 7.28k]
  ------------------
 2223|  23.3k|            CPubKey pubkey(data[i]);
 2224|  23.3k|            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
  ------------------
  |  Branch (2224:22): [True: 22.4k, False: 928]
  ------------------
 2225|  22.4k|                providers.push_back(std::move(pubkey_provider));
 2226|  22.4k|            } else {
 2227|    928|                ok = false;
 2228|    928|                break;
 2229|    928|            }
 2230|  23.3k|        }
 2231|  8.21k|        if (ok) return std::make_unique<MultisigDescriptor>((int)data[0][0], std::move(providers));
  ------------------
  |  Branch (2231:13): [True: 7.28k, False: 928]
  ------------------
 2232|  8.21k|    }
 2233|   536k|    if (txntype == TxoutType::SCRIPTHASH && ctx == ParseScriptContext::TOP) {
  ------------------
  |  Branch (2233:9): [True: 37.8k, False: 499k]
  |  Branch (2233:45): [True: 37.8k, False: 0]
  ------------------
 2234|  37.8k|        uint160 hash(data[0]);
 2235|  37.8k|        CScriptID scriptid(hash);
 2236|  37.8k|        CScript subscript;
 2237|  37.8k|        if (provider.GetCScript(scriptid, subscript)) {
  ------------------
  |  Branch (2237:13): [True: 0, False: 37.8k]
  ------------------
 2238|      0|            auto sub = InferScript(subscript, ParseScriptContext::P2SH, provider);
 2239|      0|            if (sub) return std::make_unique<SHDescriptor>(std::move(sub));
  ------------------
  |  Branch (2239:17): [True: 0, False: 0]
  ------------------
 2240|      0|        }
 2241|  37.8k|    }
 2242|   536k|    if (txntype == TxoutType::WITNESS_V0_SCRIPTHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
  ------------------
  |  Branch (2242:9): [True: 21.0k, False: 515k]
  |  Branch (2242:57): [True: 21.0k, False: 0]
  |  Branch (2242:91): [True: 0, False: 0]
  ------------------
 2243|  21.0k|        CScriptID scriptid{RIPEMD160(data[0])};
 2244|  21.0k|        CScript subscript;
 2245|  21.0k|        if (provider.GetCScript(scriptid, subscript)) {
  ------------------
  |  Branch (2245:13): [True: 0, False: 21.0k]
  ------------------
 2246|      0|            auto sub = InferScript(subscript, ParseScriptContext::P2WSH, provider);
 2247|      0|            if (sub) return std::make_unique<WSHDescriptor>(std::move(sub));
  ------------------
  |  Branch (2247:17): [True: 0, False: 0]
  ------------------
 2248|      0|        }
 2249|  21.0k|    }
 2250|   536k|    if (txntype == TxoutType::WITNESS_V1_TAPROOT && ctx == ParseScriptContext::TOP) {
  ------------------
  |  Branch (2250:9): [True: 6.62k, False: 530k]
  |  Branch (2250:53): [True: 6.62k, False: 0]
  ------------------
 2251|       |        // Extract x-only pubkey from output.
 2252|  6.62k|        XOnlyPubKey pubkey;
 2253|  6.62k|        std::copy(data[0].begin(), data[0].end(), pubkey.begin());
 2254|       |        // Request spending data.
 2255|  6.62k|        TaprootSpendData tap;
 2256|  6.62k|        if (provider.GetTaprootSpendData(pubkey, tap)) {
  ------------------
  |  Branch (2256:13): [True: 0, False: 6.62k]
  ------------------
 2257|       |            // If found, convert it back to tree form.
 2258|      0|            auto tree = InferTaprootTree(tap, pubkey);
 2259|      0|            if (tree) {
  ------------------
  |  Branch (2259:17): [True: 0, False: 0]
  ------------------
 2260|       |                // If that works, try to infer subdescriptors for all leaves.
 2261|      0|                bool ok = true;
 2262|      0|                std::vector<std::unique_ptr<DescriptorImpl>> subscripts; //!< list of script subexpressions
 2263|      0|                std::vector<int> depths; //!< depth in the tree of each subexpression (same length subscripts)
 2264|      0|                for (const auto& [depth, script, leaf_ver] : *tree) {
  ------------------
  |  Branch (2264:60): [True: 0, False: 0]
  ------------------
 2265|      0|                    std::unique_ptr<DescriptorImpl> subdesc;
 2266|      0|                    if (leaf_ver == TAPROOT_LEAF_TAPSCRIPT) {
  ------------------
  |  Branch (2266:25): [True: 0, False: 0]
  ------------------
 2267|      0|                        subdesc = InferScript(CScript(script.begin(), script.end()), ParseScriptContext::P2TR, provider);
 2268|      0|                    }
 2269|      0|                    if (!subdesc) {
  ------------------
  |  Branch (2269:25): [True: 0, False: 0]
  ------------------
 2270|      0|                        ok = false;
 2271|      0|                        break;
 2272|      0|                    } else {
 2273|      0|                        subscripts.push_back(std::move(subdesc));
 2274|      0|                        depths.push_back(depth);
 2275|      0|                    }
 2276|      0|                }
 2277|      0|                if (ok) {
  ------------------
  |  Branch (2277:21): [True: 0, False: 0]
  ------------------
 2278|      0|                    auto key = InferXOnlyPubkey(tap.internal_key, ParseScriptContext::P2TR, provider);
 2279|      0|                    return std::make_unique<TRDescriptor>(std::move(key), std::move(subscripts), std::move(depths));
 2280|      0|                }
 2281|      0|            }
 2282|      0|        }
 2283|       |        // If the above doesn't work, construct a rawtr() descriptor with just the encoded x-only pubkey.
 2284|  6.62k|        if (pubkey.IsFullyValid()) {
  ------------------
  |  Branch (2284:13): [True: 3.23k, False: 3.39k]
  ------------------
 2285|  3.23k|            auto key = InferXOnlyPubkey(pubkey, ParseScriptContext::P2TR, provider);
 2286|  3.23k|            if (key) {
  ------------------
  |  Branch (2286:17): [True: 3.23k, False: 0]
  ------------------
 2287|  3.23k|                return std::make_unique<RawTRDescriptor>(std::move(key));
 2288|  3.23k|            }
 2289|  3.23k|        }
 2290|  6.62k|    }
 2291|       |
 2292|   533k|    if (ctx == ParseScriptContext::P2WSH || ctx == ParseScriptContext::P2TR) {
  ------------------
  |  Branch (2292:9): [True: 0, False: 533k]
  |  Branch (2292:45): [True: 0, False: 533k]
  ------------------
 2293|      0|        const auto script_ctx{ctx == ParseScriptContext::P2WSH ? miniscript::MiniscriptContext::P2WSH : miniscript::MiniscriptContext::TAPSCRIPT};
  ------------------
  |  Branch (2293:31): [True: 0, False: 0]
  ------------------
 2294|      0|        KeyParser parser(/* out = */nullptr, /* in = */&provider, /* ctx = */script_ctx);
 2295|      0|        auto node = miniscript::FromScript(script, parser);
 2296|      0|        if (node && node->IsSane()) {
  ------------------
  |  Branch (2296:13): [True: 0, False: 0]
  |  Branch (2296:21): [True: 0, False: 0]
  ------------------
 2297|      0|            std::vector<std::unique_ptr<PubkeyProvider>> keys;
 2298|      0|            keys.reserve(parser.m_keys.size());
 2299|      0|            for (auto& key : parser.m_keys) {
  ------------------
  |  Branch (2299:28): [True: 0, False: 0]
  ------------------
 2300|      0|                keys.emplace_back(std::move(key.at(0)));
 2301|      0|            }
 2302|      0|            return std::make_unique<MiniscriptDescriptor>(std::move(keys), std::move(node));
 2303|      0|        }
 2304|      0|    }
 2305|       |
 2306|       |    // The following descriptors are all top-level only descriptors.
 2307|       |    // So if we are not at the top level, return early.
 2308|   533k|    if (ctx != ParseScriptContext::TOP) return nullptr;
  ------------------
  |  Branch (2308:9): [True: 0, False: 533k]
  ------------------
 2309|       |
 2310|   533k|    CTxDestination dest;
 2311|   533k|    if (ExtractDestination(script, dest)) {
  ------------------
  |  Branch (2311:9): [True: 100k, False: 433k]
  ------------------
 2312|   100k|        if (GetScriptForDestination(dest) == script) {
  ------------------
  |  Branch (2312:13): [True: 100k, False: 0]
  ------------------
 2313|   100k|            return std::make_unique<AddressDescriptor>(std::move(dest));
 2314|   100k|        }
 2315|   100k|    }
 2316|       |
 2317|   433k|    return std::make_unique<RawDescriptor>(script);
 2318|   533k|}
descriptor.cpp:_ZN12_GLOBAL__N_116InferXOnlyPubkeyERK11XOnlyPubKeyNS_18ParseScriptContextERK15SigningProvider:
 1645|  3.23k|{
 1646|  3.23k|    CPubKey pubkey{xkey.GetEvenCorrespondingCPubKey()};
 1647|  3.23k|    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, true);
 1648|  3.23k|    KeyOriginInfo info;
 1649|  3.23k|    if (provider.GetKeyOriginByXOnly(xkey, info)) {
  ------------------
  |  Branch (1649:9): [True: 0, False: 3.23k]
  ------------------
 1650|      0|        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
 1651|      0|    }
 1652|  3.23k|    return key_provider;
 1653|  3.23k|}
descriptor.cpp:_ZN12_GLOBAL__N_111InferPubkeyERK7CPubKeyNS_18ParseScriptContextERK15SigningProvider:
 1627|  33.1k|{
 1628|       |    // Key cannot be hybrid
 1629|  33.1k|    if (!pubkey.IsValidNonHybrid()) {
  ------------------
  |  Branch (1629:9): [True: 1.97k, False: 31.2k]
  ------------------
 1630|  1.97k|        return nullptr;
 1631|  1.97k|    }
 1632|       |    // Uncompressed is only allowed in TOP and P2SH contexts
 1633|  31.2k|    if (ctx != ParseScriptContext::TOP && ctx != ParseScriptContext::P2SH && !pubkey.IsCompressed()) {
  ------------------
  |  Branch (1633:9): [True: 0, False: 31.2k]
  |  Branch (1633:43): [True: 0, False: 0]
  |  Branch (1633:78): [True: 0, False: 0]
  ------------------
 1634|      0|        return nullptr;
 1635|      0|    }
 1636|  31.2k|    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, false);
 1637|  31.2k|    KeyOriginInfo info;
 1638|  31.2k|    if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
  ------------------
  |  Branch (1638:9): [True: 0, False: 31.2k]
  ------------------
 1639|      0|        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
 1640|      0|    }
 1641|  31.2k|    return key_provider;
 1642|  31.2k|}

_ZN10DescriptorD2Ev:
   99|   553k|    virtual ~Descriptor() = default;

_Z22CheckSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEEjP13ScriptError_t:
  200|  31.9k|bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror) {
  201|       |    // Empty signature. Not strictly DER encoded, but allowed to provide a
  202|       |    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
  203|  31.9k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (203:9): [True: 0, False: 31.9k]
  ------------------
  204|      0|        return true;
  205|      0|    }
  206|  31.9k|    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
  ------------------
  |  Branch (206:9): [True: 31.9k, False: 0]
  |  Branch (206:98): [True: 26.3k, False: 5.53k]
  ------------------
  207|  26.3k|        return set_error(serror, SCRIPT_ERR_SIG_DER);
  208|  26.3k|    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
  ------------------
  |  Branch (208:16): [True: 0, False: 5.53k]
  |  Branch (208:54): [True: 0, False: 0]
  ------------------
  209|       |        // serror is set
  210|      0|        return false;
  211|  5.53k|    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
  ------------------
  |  Branch (211:16): [True: 5.53k, False: 0]
  |  Branch (211:58): [True: 1.18k, False: 4.35k]
  ------------------
  212|  1.18k|        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
  213|  1.18k|    }
  214|  4.35k|    return true;
  215|  31.9k|}
interpreter.cpp:_ZL24IsValidSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  107|  31.9k|bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
  108|       |    // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
  109|       |    // * total-length: 1-byte length descriptor of everything that follows,
  110|       |    //   excluding the sighash byte.
  111|       |    // * R-length: 1-byte length descriptor of the R value that follows.
  112|       |    // * R: arbitrary-length big-endian encoded R value. It must use the shortest
  113|       |    //   possible encoding for a positive integer (which means no null bytes at
  114|       |    //   the start, except a single one when the next byte has its highest bit set).
  115|       |    // * S-length: 1-byte length descriptor of the S value that follows.
  116|       |    // * S: arbitrary-length big-endian encoded S value. The same rules apply.
  117|       |    // * sighash: 1-byte value indicating what data is hashed (not part of the DER
  118|       |    //   signature)
  119|       |
  120|       |    // Minimum and maximum size constraints.
  121|  31.9k|    if (sig.size() < 9) return false;
  ------------------
  |  Branch (121:9): [True: 2.86k, False: 29.0k]
  ------------------
  122|  29.0k|    if (sig.size() > 73) return false;
  ------------------
  |  Branch (122:9): [True: 1.20k, False: 27.8k]
  ------------------
  123|       |
  124|       |    // A signature is of type 0x30 (compound).
  125|  27.8k|    if (sig[0] != 0x30) return false;
  ------------------
  |  Branch (125:9): [True: 19.1k, False: 8.70k]
  ------------------
  126|       |
  127|       |    // Make sure the length covers the entire signature.
  128|  8.70k|    if (sig[1] != sig.size() - 3) return false;
  ------------------
  |  Branch (128:9): [True: 878, False: 7.82k]
  ------------------
  129|       |
  130|       |    // Extract the length of the R element.
  131|  7.82k|    unsigned int lenR = sig[3];
  132|       |
  133|       |    // Make sure the length of the S element is still inside the signature.
  134|  7.82k|    if (5 + lenR >= sig.size()) return false;
  ------------------
  |  Branch (134:9): [True: 552, False: 7.27k]
  ------------------
  135|       |
  136|       |    // Extract the length of the S element.
  137|  7.27k|    unsigned int lenS = sig[5 + lenR];
  138|       |
  139|       |    // Verify that the length of the signature matches the sum of the length
  140|       |    // of the elements.
  141|  7.27k|    if ((size_t)(lenR + lenS + 7) != sig.size()) return false;
  ------------------
  |  Branch (141:9): [True: 604, False: 6.66k]
  ------------------
  142|       |
  143|       |    // Check whether the R element is an integer.
  144|  6.66k|    if (sig[2] != 0x02) return false;
  ------------------
  |  Branch (144:9): [True: 126, False: 6.54k]
  ------------------
  145|       |
  146|       |    // Zero-length integers are not allowed for R.
  147|  6.54k|    if (lenR == 0) return false;
  ------------------
  |  Branch (147:9): [True: 232, False: 6.30k]
  ------------------
  148|       |
  149|       |    // Negative numbers are not allowed for R.
  150|  6.30k|    if (sig[4] & 0x80) return false;
  ------------------
  |  Branch (150:9): [True: 116, False: 6.19k]
  ------------------
  151|       |
  152|       |    // Null bytes at the start of R are not allowed, unless R would
  153|       |    // otherwise be interpreted as a negative number.
  154|  6.19k|    if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) return false;
  ------------------
  |  Branch (154:9): [True: 4.42k, False: 1.77k]
  |  Branch (154:21): [True: 2.20k, False: 2.22k]
  |  Branch (154:41): [True: 94, False: 2.10k]
  ------------------
  155|       |
  156|       |    // Check whether the S element is an integer.
  157|  6.09k|    if (sig[lenR + 4] != 0x02) return false;
  ------------------
  |  Branch (157:9): [True: 230, False: 5.86k]
  ------------------
  158|       |
  159|       |    // Zero-length integers are not allowed for S.
  160|  5.86k|    if (lenS == 0) return false;
  ------------------
  |  Branch (160:9): [True: 100, False: 5.76k]
  ------------------
  161|       |
  162|       |    // Negative numbers are not allowed for S.
  163|  5.76k|    if (sig[lenR + 6] & 0x80) return false;
  ------------------
  |  Branch (163:9): [True: 106, False: 5.66k]
  ------------------
  164|       |
  165|       |    // Null bytes at the start of S are not allowed, unless S would otherwise be
  166|       |    // interpreted as a negative number.
  167|  5.66k|    if (lenS > 1 && (sig[lenR + 6] == 0x00) && !(sig[lenR + 7] & 0x80)) return false;
  ------------------
  |  Branch (167:9): [True: 4.53k, False: 1.12k]
  |  Branch (167:21): [True: 700, False: 3.83k]
  |  Branch (167:48): [True: 128, False: 572]
  ------------------
  168|       |
  169|  5.53k|    return true;
  170|  5.66k|}
interpreter.cpp:_ZN12_GLOBAL__N_19set_errorEP13ScriptError_tS0_:
   27|  27.5k|{
   28|  27.5k|    if (ret)
  ------------------
  |  Branch (28:9): [True: 0, False: 27.5k]
  ------------------
   29|      0|        *ret = serror;
   30|  27.5k|    return false;
   31|  27.5k|}
interpreter.cpp:_ZL26IsDefinedHashtypeSignatureRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  189|  5.53k|bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
  190|  5.53k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (190:9): [True: 0, False: 5.53k]
  ------------------
  191|      0|        return false;
  192|      0|    }
  193|  5.53k|    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
  194|  5.53k|    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
  ------------------
  |  Branch (194:9): [True: 526, False: 5.00k]
  |  Branch (194:36): [True: 654, False: 4.35k]
  ------------------
  195|  1.18k|        return false;
  196|       |
  197|  4.35k|    return true;
  198|  5.53k|}

_Z9GetOpName10opcodetype:
   19|  2.08M|{
   20|  2.08M|    switch (opcode)
   21|  2.08M|    {
   22|       |    // push value
   23|      0|    case OP_0                      : return "0";
  ------------------
  |  Branch (23:5): [True: 0, False: 2.08M]
  ------------------
   24|      0|    case OP_PUSHDATA1              : return "OP_PUSHDATA1";
  ------------------
  |  Branch (24:5): [True: 0, False: 2.08M]
  ------------------
   25|      0|    case OP_PUSHDATA2              : return "OP_PUSHDATA2";
  ------------------
  |  Branch (25:5): [True: 0, False: 2.08M]
  ------------------
   26|      0|    case OP_PUSHDATA4              : return "OP_PUSHDATA4";
  ------------------
  |  Branch (26:5): [True: 0, False: 2.08M]
  ------------------
   27|  2.60k|    case OP_1NEGATE                : return "-1";
  ------------------
  |  Branch (27:5): [True: 2.60k, False: 2.07M]
  ------------------
   28|  3.21k|    case OP_RESERVED               : return "OP_RESERVED";
  ------------------
  |  Branch (28:5): [True: 3.21k, False: 2.07M]
  ------------------
   29|  15.6k|    case OP_1                      : return "1";
  ------------------
  |  Branch (29:5): [True: 15.6k, False: 2.06M]
  ------------------
   30|  17.4k|    case OP_2                      : return "2";
  ------------------
  |  Branch (30:5): [True: 17.4k, False: 2.06M]
  ------------------
   31|  11.3k|    case OP_3                      : return "3";
  ------------------
  |  Branch (31:5): [True: 11.3k, False: 2.07M]
  ------------------
   32|  6.00k|    case OP_4                      : return "4";
  ------------------
  |  Branch (32:5): [True: 6.00k, False: 2.07M]
  ------------------
   33|  4.97k|    case OP_5                      : return "5";
  ------------------
  |  Branch (33:5): [True: 4.97k, False: 2.07M]
  ------------------
   34|  2.43k|    case OP_6                      : return "6";
  ------------------
  |  Branch (34:5): [True: 2.43k, False: 2.07M]
  ------------------
   35|  1.87k|    case OP_7                      : return "7";
  ------------------
  |  Branch (35:5): [True: 1.87k, False: 2.08M]
  ------------------
   36|   332k|    case OP_8                      : return "8";
  ------------------
  |  Branch (36:5): [True: 332k, False: 1.74M]
  ------------------
   37|  2.31k|    case OP_9                      : return "9";
  ------------------
  |  Branch (37:5): [True: 2.31k, False: 2.07M]
  ------------------
   38|  3.08k|    case OP_10                     : return "10";
  ------------------
  |  Branch (38:5): [True: 3.08k, False: 2.07M]
  ------------------
   39|  13.0k|    case OP_11                     : return "11";
  ------------------
  |  Branch (39:5): [True: 13.0k, False: 2.06M]
  ------------------
   40|  5.04k|    case OP_12                     : return "12";
  ------------------
  |  Branch (40:5): [True: 5.04k, False: 2.07M]
  ------------------
   41|  16.2k|    case OP_13                     : return "13";
  ------------------
  |  Branch (41:5): [True: 16.2k, False: 2.06M]
  ------------------
   42|  2.34k|    case OP_14                     : return "14";
  ------------------
  |  Branch (42:5): [True: 2.34k, False: 2.07M]
  ------------------
   43|  3.37k|    case OP_15                     : return "15";
  ------------------
  |  Branch (43:5): [True: 3.37k, False: 2.07M]
  ------------------
   44|  2.39k|    case OP_16                     : return "16";
  ------------------
  |  Branch (44:5): [True: 2.39k, False: 2.07M]
  ------------------
   45|       |
   46|       |    // control
   47|   450k|    case OP_NOP                    : return "OP_NOP";
  ------------------
  |  Branch (47:5): [True: 450k, False: 1.63M]
  ------------------
   48|  3.45k|    case OP_VER                    : return "OP_VER";
  ------------------
  |  Branch (48:5): [True: 3.45k, False: 2.07M]
  ------------------
   49|  3.86k|    case OP_IF                     : return "OP_IF";
  ------------------
  |  Branch (49:5): [True: 3.86k, False: 2.07M]
  ------------------
   50|  2.58k|    case OP_NOTIF                  : return "OP_NOTIF";
  ------------------
  |  Branch (50:5): [True: 2.58k, False: 2.07M]
  ------------------
   51|  2.72k|    case OP_VERIF                  : return "OP_VERIF";
  ------------------
  |  Branch (51:5): [True: 2.72k, False: 2.07M]
  ------------------
   52|  3.41k|    case OP_VERNOTIF               : return "OP_VERNOTIF";
  ------------------
  |  Branch (52:5): [True: 3.41k, False: 2.07M]
  ------------------
   53|  2.47k|    case OP_ELSE                   : return "OP_ELSE";
  ------------------
  |  Branch (53:5): [True: 2.47k, False: 2.07M]
  ------------------
   54|  3.36k|    case OP_ENDIF                  : return "OP_ENDIF";
  ------------------
  |  Branch (54:5): [True: 3.36k, False: 2.07M]
  ------------------
   55|  2.94k|    case OP_VERIFY                 : return "OP_VERIFY";
  ------------------
  |  Branch (55:5): [True: 2.94k, False: 2.07M]
  ------------------
   56|  23.1k|    case OP_RETURN                 : return "OP_RETURN";
  ------------------
  |  Branch (56:5): [True: 23.1k, False: 2.05M]
  ------------------
   57|       |
   58|       |    // stack ops
   59|  2.88k|    case OP_TOALTSTACK             : return "OP_TOALTSTACK";
  ------------------
  |  Branch (59:5): [True: 2.88k, False: 2.07M]
  ------------------
   60|  2.03k|    case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
  ------------------
  |  Branch (60:5): [True: 2.03k, False: 2.07M]
  ------------------
   61|  3.01k|    case OP_2DROP                  : return "OP_2DROP";
  ------------------
  |  Branch (61:5): [True: 3.01k, False: 2.07M]
  ------------------
   62|  1.86k|    case OP_2DUP                   : return "OP_2DUP";
  ------------------
  |  Branch (62:5): [True: 1.86k, False: 2.08M]
  ------------------
   63|  3.84k|    case OP_3DUP                   : return "OP_3DUP";
  ------------------
  |  Branch (63:5): [True: 3.84k, False: 2.07M]
  ------------------
   64|  3.40k|    case OP_2OVER                  : return "OP_2OVER";
  ------------------
  |  Branch (64:5): [True: 3.40k, False: 2.07M]
  ------------------
   65|  1.92k|    case OP_2ROT                   : return "OP_2ROT";
  ------------------
  |  Branch (65:5): [True: 1.92k, False: 2.07M]
  ------------------
   66|  2.61k|    case OP_2SWAP                  : return "OP_2SWAP";
  ------------------
  |  Branch (66:5): [True: 2.61k, False: 2.07M]
  ------------------
   67|  2.46k|    case OP_IFDUP                  : return "OP_IFDUP";
  ------------------
  |  Branch (67:5): [True: 2.46k, False: 2.07M]
  ------------------
   68|  3.70k|    case OP_DEPTH                  : return "OP_DEPTH";
  ------------------
  |  Branch (68:5): [True: 3.70k, False: 2.07M]
  ------------------
   69|  2.53k|    case OP_DROP                   : return "OP_DROP";
  ------------------
  |  Branch (69:5): [True: 2.53k, False: 2.07M]
  ------------------
   70|  13.4k|    case OP_DUP                    : return "OP_DUP";
  ------------------
  |  Branch (70:5): [True: 13.4k, False: 2.06M]
  ------------------
   71|  2.72k|    case OP_NIP                    : return "OP_NIP";
  ------------------
  |  Branch (71:5): [True: 2.72k, False: 2.07M]
  ------------------
   72|  1.94k|    case OP_OVER                   : return "OP_OVER";
  ------------------
  |  Branch (72:5): [True: 1.94k, False: 2.07M]
  ------------------
   73|  1.40k|    case OP_PICK                   : return "OP_PICK";
  ------------------
  |  Branch (73:5): [True: 1.40k, False: 2.08M]
  ------------------
   74|  3.66k|    case OP_ROLL                   : return "OP_ROLL";
  ------------------
  |  Branch (74:5): [True: 3.66k, False: 2.07M]
  ------------------
   75|  13.4k|    case OP_ROT                    : return "OP_ROT";
  ------------------
  |  Branch (75:5): [True: 13.4k, False: 2.06M]
  ------------------
   76|  39.6k|    case OP_SWAP                   : return "OP_SWAP";
  ------------------
  |  Branch (76:5): [True: 39.6k, False: 2.04M]
  ------------------
   77|  2.88k|    case OP_TUCK                   : return "OP_TUCK";
  ------------------
  |  Branch (77:5): [True: 2.88k, False: 2.07M]
  ------------------
   78|       |
   79|       |    // splice ops
   80|  2.95k|    case OP_CAT                    : return "OP_CAT";
  ------------------
  |  Branch (80:5): [True: 2.95k, False: 2.07M]
  ------------------
   81|  5.71k|    case OP_SUBSTR                 : return "OP_SUBSTR";
  ------------------
  |  Branch (81:5): [True: 5.71k, False: 2.07M]
  ------------------
   82|  12.2k|    case OP_LEFT                   : return "OP_LEFT";
  ------------------
  |  Branch (82:5): [True: 12.2k, False: 2.06M]
  ------------------
   83|  81.4k|    case OP_RIGHT                  : return "OP_RIGHT";
  ------------------
  |  Branch (83:5): [True: 81.4k, False: 2.00M]
  ------------------
   84|  2.26k|    case OP_SIZE                   : return "OP_SIZE";
  ------------------
  |  Branch (84:5): [True: 2.26k, False: 2.07M]
  ------------------
   85|       |
   86|       |    // bit logic
   87|  4.06k|    case OP_INVERT                 : return "OP_INVERT";
  ------------------
  |  Branch (87:5): [True: 4.06k, False: 2.07M]
  ------------------
   88|  5.64k|    case OP_AND                    : return "OP_AND";
  ------------------
  |  Branch (88:5): [True: 5.64k, False: 2.07M]
  ------------------
   89|  1.66k|    case OP_OR                     : return "OP_OR";
  ------------------
  |  Branch (89:5): [True: 1.66k, False: 2.08M]
  ------------------
   90|  1.63k|    case OP_XOR                    : return "OP_XOR";
  ------------------
  |  Branch (90:5): [True: 1.63k, False: 2.08M]
  ------------------
   91|  45.1k|    case OP_EQUAL                  : return "OP_EQUAL";
  ------------------
  |  Branch (91:5): [True: 45.1k, False: 2.03M]
  ------------------
   92|  11.0k|    case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
  ------------------
  |  Branch (92:5): [True: 11.0k, False: 2.07M]
  ------------------
   93|  2.11k|    case OP_RESERVED1              : return "OP_RESERVED1";
  ------------------
  |  Branch (93:5): [True: 2.11k, False: 2.07M]
  ------------------
   94|  4.40k|    case OP_RESERVED2              : return "OP_RESERVED2";
  ------------------
  |  Branch (94:5): [True: 4.40k, False: 2.07M]
  ------------------
   95|       |
   96|       |    // numeric
   97|  2.06k|    case OP_1ADD                   : return "OP_1ADD";
  ------------------
  |  Branch (97:5): [True: 2.06k, False: 2.07M]
  ------------------
   98|  2.11k|    case OP_1SUB                   : return "OP_1SUB";
  ------------------
  |  Branch (98:5): [True: 2.11k, False: 2.07M]
  ------------------
   99|  2.47k|    case OP_2MUL                   : return "OP_2MUL";
  ------------------
  |  Branch (99:5): [True: 2.47k, False: 2.07M]
  ------------------
  100|  2.85k|    case OP_2DIV                   : return "OP_2DIV";
  ------------------
  |  Branch (100:5): [True: 2.85k, False: 2.07M]
  ------------------
  101|  1.42k|    case OP_NEGATE                 : return "OP_NEGATE";
  ------------------
  |  Branch (101:5): [True: 1.42k, False: 2.08M]
  ------------------
  102|  2.34k|    case OP_ABS                    : return "OP_ABS";
  ------------------
  |  Branch (102:5): [True: 2.34k, False: 2.07M]
  ------------------
  103|  2.51k|    case OP_NOT                    : return "OP_NOT";
  ------------------
  |  Branch (103:5): [True: 2.51k, False: 2.07M]
  ------------------
  104|  4.15k|    case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
  ------------------
  |  Branch (104:5): [True: 4.15k, False: 2.07M]
  ------------------
  105|  4.47k|    case OP_ADD                    : return "OP_ADD";
  ------------------
  |  Branch (105:5): [True: 4.47k, False: 2.07M]
  ------------------
  106|  3.08k|    case OP_SUB                    : return "OP_SUB";
  ------------------
  |  Branch (106:5): [True: 3.08k, False: 2.07M]
  ------------------
  107|  10.3k|    case OP_MUL                    : return "OP_MUL";
  ------------------
  |  Branch (107:5): [True: 10.3k, False: 2.07M]
  ------------------
  108|  17.6k|    case OP_DIV                    : return "OP_DIV";
  ------------------
  |  Branch (108:5): [True: 17.6k, False: 2.06M]
  ------------------
  109|  2.76k|    case OP_MOD                    : return "OP_MOD";
  ------------------
  |  Branch (109:5): [True: 2.76k, False: 2.07M]
  ------------------
  110|  11.1k|    case OP_LSHIFT                 : return "OP_LSHIFT";
  ------------------
  |  Branch (110:5): [True: 11.1k, False: 2.07M]
  ------------------
  111|  2.23k|    case OP_RSHIFT                 : return "OP_RSHIFT";
  ------------------
  |  Branch (111:5): [True: 2.23k, False: 2.07M]
  ------------------
  112|  3.12k|    case OP_BOOLAND                : return "OP_BOOLAND";
  ------------------
  |  Branch (112:5): [True: 3.12k, False: 2.07M]
  ------------------
  113|  2.60k|    case OP_BOOLOR                 : return "OP_BOOLOR";
  ------------------
  |  Branch (113:5): [True: 2.60k, False: 2.07M]
  ------------------
  114|  3.37k|    case OP_NUMEQUAL               : return "OP_NUMEQUAL";
  ------------------
  |  Branch (114:5): [True: 3.37k, False: 2.07M]
  ------------------
  115|  1.96k|    case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
  ------------------
  |  Branch (115:5): [True: 1.96k, False: 2.07M]
  ------------------
  116|  1.92k|    case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
  ------------------
  |  Branch (116:5): [True: 1.92k, False: 2.07M]
  ------------------
  117|  1.48k|    case OP_LESSTHAN               : return "OP_LESSTHAN";
  ------------------
  |  Branch (117:5): [True: 1.48k, False: 2.08M]
  ------------------
  118|  2.17k|    case OP_GREATERTHAN            : return "OP_GREATERTHAN";
  ------------------
  |  Branch (118:5): [True: 2.17k, False: 2.07M]
  ------------------
  119|  1.95k|    case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
  ------------------
  |  Branch (119:5): [True: 1.95k, False: 2.07M]
  ------------------
  120|  2.04k|    case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
  ------------------
  |  Branch (120:5): [True: 2.04k, False: 2.07M]
  ------------------
  121|  1.89k|    case OP_MIN                    : return "OP_MIN";
  ------------------
  |  Branch (121:5): [True: 1.89k, False: 2.07M]
  ------------------
  122|  2.34k|    case OP_MAX                    : return "OP_MAX";
  ------------------
  |  Branch (122:5): [True: 2.34k, False: 2.07M]
  ------------------
  123|  2.99k|    case OP_WITHIN                 : return "OP_WITHIN";
  ------------------
  |  Branch (123:5): [True: 2.99k, False: 2.07M]
  ------------------
  124|       |
  125|       |    // crypto
  126|  2.75k|    case OP_RIPEMD160              : return "OP_RIPEMD160";
  ------------------
  |  Branch (126:5): [True: 2.75k, False: 2.07M]
  ------------------
  127|  3.15k|    case OP_SHA1                   : return "OP_SHA1";
  ------------------
  |  Branch (127:5): [True: 3.15k, False: 2.07M]
  ------------------
  128|  1.85k|    case OP_SHA256                 : return "OP_SHA256";
  ------------------
  |  Branch (128:5): [True: 1.85k, False: 2.08M]
  ------------------
  129|  51.4k|    case OP_HASH160                : return "OP_HASH160";
  ------------------
  |  Branch (129:5): [True: 51.4k, False: 2.03M]
  ------------------
  130|  3.54k|    case OP_HASH256                : return "OP_HASH256";
  ------------------
  |  Branch (130:5): [True: 3.54k, False: 2.07M]
  ------------------
  131|  2.91k|    case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
  ------------------
  |  Branch (131:5): [True: 2.91k, False: 2.07M]
  ------------------
  132|  46.8k|    case OP_CHECKSIG               : return "OP_CHECKSIG";
  ------------------
  |  Branch (132:5): [True: 46.8k, False: 2.03M]
  ------------------
  133|  4.51k|    case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
  ------------------
  |  Branch (133:5): [True: 4.51k, False: 2.07M]
  ------------------
  134|   313k|    case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
  ------------------
  |  Branch (134:5): [True: 313k, False: 1.76M]
  ------------------
  135|  19.2k|    case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  ------------------
  |  Branch (135:5): [True: 19.2k, False: 2.06M]
  ------------------
  136|       |
  137|       |    // expansion
  138|  6.85k|    case OP_NOP1                   : return "OP_NOP1";
  ------------------
  |  Branch (138:5): [True: 6.85k, False: 2.07M]
  ------------------
  139|  2.66k|    case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
  ------------------
  |  Branch (139:5): [True: 2.66k, False: 2.07M]
  ------------------
  140|  3.03k|    case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
  ------------------
  |  Branch (140:5): [True: 3.03k, False: 2.07M]
  ------------------
  141|  4.43k|    case OP_NOP4                   : return "OP_NOP4";
  ------------------
  |  Branch (141:5): [True: 4.43k, False: 2.07M]
  ------------------
  142|  4.23k|    case OP_NOP5                   : return "OP_NOP5";
  ------------------
  |  Branch (142:5): [True: 4.23k, False: 2.07M]
  ------------------
  143|  3.38k|    case OP_NOP6                   : return "OP_NOP6";
  ------------------
  |  Branch (143:5): [True: 3.38k, False: 2.07M]
  ------------------
  144|  2.59k|    case OP_NOP7                   : return "OP_NOP7";
  ------------------
  |  Branch (144:5): [True: 2.59k, False: 2.07M]
  ------------------
  145|  6.47k|    case OP_NOP8                   : return "OP_NOP8";
  ------------------
  |  Branch (145:5): [True: 6.47k, False: 2.07M]
  ------------------
  146|  3.17k|    case OP_NOP9                   : return "OP_NOP9";
  ------------------
  |  Branch (146:5): [True: 3.17k, False: 2.07M]
  ------------------
  147|  3.07k|    case OP_NOP10                  : return "OP_NOP10";
  ------------------
  |  Branch (147:5): [True: 3.07k, False: 2.07M]
  ------------------
  148|       |
  149|       |    // Opcode added by BIP 342 (Tapscript)
  150|  3.03k|    case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
  ------------------
  |  Branch (150:5): [True: 3.03k, False: 2.07M]
  ------------------
  151|       |
  152|  35.3k|    case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
  ------------------
  |  Branch (152:5): [True: 35.3k, False: 2.04M]
  ------------------
  153|       |
  154|   219k|    default:
  ------------------
  |  Branch (154:5): [True: 219k, False: 1.86M]
  ------------------
  155|   219k|        return "OP_UNKNOWN";
  156|  2.08M|    }
  157|  2.08M|}
_ZNK7CScript13GetSigOpCountEb:
  160|   522k|{
  161|   522k|    unsigned int n = 0;
  162|   522k|    const_iterator pc = begin();
  163|   522k|    opcodetype lastOpcode = OP_INVALIDOPCODE;
  164|  5.57M|    while (pc < end())
  ------------------
  |  Branch (164:12): [True: 5.21M, False: 360k]
  ------------------
  165|  5.21M|    {
  166|  5.21M|        opcodetype opcode;
  167|  5.21M|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (167:13): [True: 161k, False: 5.05M]
  ------------------
  168|   161k|            break;
  169|  5.05M|        if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
  ------------------
  |  Branch (169:13): [True: 33.3k, False: 5.02M]
  |  Branch (169:38): [True: 2.37k, False: 5.01M]
  ------------------
  170|  35.7k|            n++;
  171|  5.01M|        else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
  ------------------
  |  Branch (171:18): [True: 174k, False: 4.84M]
  |  Branch (171:48): [True: 9.82k, False: 4.83M]
  ------------------
  172|   183k|        {
  173|   183k|            if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
  ------------------
  |  Branch (173:17): [True: 0, False: 183k]
  |  Branch (173:30): [True: 0, False: 0]
  |  Branch (173:52): [True: 0, False: 0]
  ------------------
  174|      0|                n += DecodeOP_N(lastOpcode);
  175|   183k|            else
  176|   183k|                n += MAX_PUBKEYS_PER_MULTISIG;
  177|   183k|        }
  178|  5.05M|        lastOpcode = opcode;
  179|  5.05M|    }
  180|   522k|    return n;
  181|   522k|}
_ZNK7CScript13IsPayToAnchorEv:
  208|  46.2k|{
  209|  46.2k|    return (this->size() == 4 &&
  ------------------
  |  Branch (209:13): [True: 29.4k, False: 16.7k]
  ------------------
  210|  46.2k|        (*this)[0] == OP_1 &&
  ------------------
  |  Branch (210:9): [True: 296, False: 29.1k]
  ------------------
  211|  46.2k|        (*this)[1] == 0x02 &&
  ------------------
  |  Branch (211:9): [True: 296, False: 0]
  ------------------
  212|  46.2k|        (*this)[2] == 0x4e &&
  ------------------
  |  Branch (212:9): [True: 146, False: 150]
  ------------------
  213|  46.2k|        (*this)[3] == 0x73);
  ------------------
  |  Branch (213:9): [True: 74, False: 72]
  ------------------
  214|  46.2k|}
_ZN7CScript13IsPayToAnchorEiRKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  217|     36|{
  218|     36|    return version == 1 &&
  ------------------
  |  Branch (218:12): [True: 36, False: 0]
  ------------------
  219|     36|        program.size() == 2 &&
  ------------------
  |  Branch (219:9): [True: 36, False: 0]
  ------------------
  220|     36|        program[0] == 0x4e &&
  ------------------
  |  Branch (220:9): [True: 36, False: 0]
  ------------------
  221|     36|        program[1] == 0x73;
  ------------------
  |  Branch (221:9): [True: 36, False: 0]
  ------------------
  222|     36|}
_ZNK7CScript17IsPayToScriptHashEv:
  225|  2.21M|{
  226|       |    // Extra-fast test for pay-to-script-hash CScripts:
  227|  2.21M|    return (this->size() == 23 &&
  ------------------
  |  Branch (227:13): [True: 164k, False: 2.04M]
  ------------------
  228|  2.21M|            (*this)[0] == OP_HASH160 &&
  ------------------
  |  Branch (228:13): [True: 160k, False: 3.54k]
  ------------------
  229|  2.21M|            (*this)[1] == 0x14 &&
  ------------------
  |  Branch (229:13): [True: 158k, False: 2.16k]
  ------------------
  230|  2.21M|            (*this)[22] == OP_EQUAL);
  ------------------
  |  Branch (230:13): [True: 153k, False: 5.13k]
  ------------------
  231|  2.21M|}
_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  244|  2.05M|{
  245|  2.05M|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (245:9): [True: 1.32M, False: 731k]
  |  Branch (245:29): [True: 246k, False: 485k]
  ------------------
  246|  1.57M|        return false;
  247|  1.57M|    }
  248|   485k|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (248:9): [True: 300k, False: 184k]
  |  Branch (248:32): [True: 134k, False: 166k]
  |  Branch (248:53): [True: 91.0k, False: 74.9k]
  ------------------
  249|   225k|        return false;
  250|   225k|    }
  251|   259k|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (251:9): [True: 239k, False: 20.2k]
  ------------------
  252|   239k|        version = DecodeOP_N((opcodetype)(*this)[0]);
  253|   239k|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  254|   239k|        return true;
  255|   239k|    }
  256|  20.2k|    return false;
  257|   259k|}
_ZNK7CScript10IsPushOnlyEN9prevectorILj28EhjiE14const_iteratorE:
  260|  30.4k|{
  261|  1.20M|    while (pc < end())
  ------------------
  |  Branch (261:12): [True: 1.18M, False: 21.6k]
  ------------------
  262|  1.18M|    {
  263|  1.18M|        opcodetype opcode;
  264|  1.18M|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (264:13): [True: 5.87k, False: 1.18M]
  ------------------
  265|  5.87k|            return false;
  266|       |        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
  267|       |        // push-type opcode, however execution of OP_RESERVED fails, so
  268|       |        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
  269|       |        // the P2SH special validation code being executed.
  270|  1.18M|        if (opcode > OP_16)
  ------------------
  |  Branch (270:13): [True: 2.92k, False: 1.17M]
  ------------------
  271|  2.92k|            return false;
  272|  1.18M|    }
  273|  21.6k|    return true;
  274|  30.4k|}
_ZNK7CScript10IsPushOnlyEv:
  277|  16.5k|{
  278|  16.5k|    return this->IsPushOnly(begin());
  279|  16.5k|}
_ZNK14CScriptWitness8ToStringEv:
  282|   102k|{
  283|   102k|    std::string ret = "CScriptWitness(";
  284|  8.30M|    for (unsigned int i = 0; i < stack.size(); i++) {
  ------------------
  |  Branch (284:30): [True: 8.19M, False: 102k]
  ------------------
  285|  8.19M|        if (i) {
  ------------------
  |  Branch (285:13): [True: 8.19M, False: 5.21k]
  ------------------
  286|  8.19M|            ret += ", ";
  287|  8.19M|        }
  288|  8.19M|        ret += HexStr(stack[i]);
  289|  8.19M|    }
  290|   102k|    return ret + ")";
  291|   102k|}
_Z11GetScriptOpRN9prevectorILj28EhjiE14const_iteratorES1_R10opcodetypePNSt3__16vectorIhNS5_9allocatorIhEEEE:
  307|  12.5M|{
  308|  12.5M|    opcodeRet = OP_INVALIDOPCODE;
  309|  12.5M|    if (pvchRet)
  ------------------
  |  Branch (309:9): [True: 6.14M, False: 6.40M]
  ------------------
  310|  6.14M|        pvchRet->clear();
  311|  12.5M|    if (pc >= end)
  ------------------
  |  Branch (311:9): [True: 56, False: 12.5M]
  ------------------
  312|     56|        return false;
  313|       |
  314|       |    // Read instruction
  315|  12.5M|    if (end - pc < 1)
  ------------------
  |  Branch (315:9): [True: 0, False: 12.5M]
  ------------------
  316|      0|        return false;
  317|  12.5M|    unsigned int opcode = *pc++;
  318|       |
  319|       |    // Immediate operand
  320|  12.5M|    if (opcode <= OP_PUSHDATA4)
  ------------------
  |  Branch (320:9): [True: 8.37M, False: 4.17M]
  ------------------
  321|  8.37M|    {
  322|  8.37M|        unsigned int nSize = 0;
  323|  8.37M|        if (opcode < OP_PUSHDATA1)
  ------------------
  |  Branch (323:13): [True: 8.33M, False: 41.1k]
  ------------------
  324|  8.33M|        {
  325|  8.33M|            nSize = opcode;
  326|  8.33M|        }
  327|  41.1k|        else if (opcode == OP_PUSHDATA1)
  ------------------
  |  Branch (327:18): [True: 13.1k, False: 28.0k]
  ------------------
  328|  13.1k|        {
  329|  13.1k|            if (end - pc < 1)
  ------------------
  |  Branch (329:17): [True: 1.39k, False: 11.7k]
  ------------------
  330|  1.39k|                return false;
  331|  11.7k|            nSize = *pc++;
  332|  11.7k|        }
  333|  28.0k|        else if (opcode == OP_PUSHDATA2)
  ------------------
  |  Branch (333:18): [True: 21.3k, False: 6.69k]
  ------------------
  334|  21.3k|        {
  335|  21.3k|            if (end - pc < 2)
  ------------------
  |  Branch (335:17): [True: 6.40k, False: 14.9k]
  ------------------
  336|  6.40k|                return false;
  337|  14.9k|            nSize = ReadLE16(&pc[0]);
  338|  14.9k|            pc += 2;
  339|  14.9k|        }
  340|  6.69k|        else if (opcode == OP_PUSHDATA4)
  ------------------
  |  Branch (340:18): [True: 6.69k, False: 0]
  ------------------
  341|  6.69k|        {
  342|  6.69k|            if (end - pc < 4)
  ------------------
  |  Branch (342:17): [True: 1.47k, False: 5.22k]
  ------------------
  343|  1.47k|                return false;
  344|  5.22k|            nSize = ReadLE32(&pc[0]);
  345|  5.22k|            pc += 4;
  346|  5.22k|        }
  347|  8.36M|        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  ------------------
  |  Branch (347:13): [True: 0, False: 8.36M]
  |  Branch (347:29): [True: 465k, False: 7.89M]
  ------------------
  348|   465k|            return false;
  349|  7.89M|        if (pvchRet)
  ------------------
  |  Branch (349:13): [True: 3.68M, False: 4.21M]
  ------------------
  350|  3.68M|            pvchRet->assign(pc, pc + nSize);
  351|  7.89M|        pc += nSize;
  352|  7.89M|    }
  353|       |
  354|  12.0M|    opcodeRet = static_cast<opcodetype>(opcode);
  355|  12.0M|    return true;
  356|  12.5M|}
_Z16CheckMinimalPushRKNSt3__16vectorIhNS_9allocatorIhEEEE10opcodetype:
  366|  14.9k|bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
  367|       |    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
  368|  14.9k|    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  369|  14.9k|    if (data.size() == 0) {
  ------------------
  |  Branch (369:9): [True: 648, False: 14.2k]
  ------------------
  370|       |        // Should have used OP_0.
  371|    648|        return opcode == OP_0;
  372|  14.2k|    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  ------------------
  |  Branch (372:16): [True: 3.55k, False: 10.7k]
  |  Branch (372:36): [True: 2.49k, False: 1.05k]
  |  Branch (372:52): [True: 953, False: 1.54k]
  ------------------
  373|       |        // Should have used OP_1 .. OP_16.
  374|    953|        return false;
  375|  13.3k|    } else if (data.size() == 1 && data[0] == 0x81) {
  ------------------
  |  Branch (375:16): [True: 2.60k, False: 10.7k]
  |  Branch (375:36): [True: 90, False: 2.51k]
  ------------------
  376|       |        // Should have used OP_1NEGATE.
  377|     90|        return false;
  378|  13.2k|    } else if (data.size() <= 75) {
  ------------------
  |  Branch (378:16): [True: 13.0k, False: 194]
  ------------------
  379|       |        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
  380|  13.0k|        return opcode == data.size();
  381|  13.0k|    } else if (data.size() <= 255) {
  ------------------
  |  Branch (381:16): [True: 82, False: 112]
  ------------------
  382|       |        // Must have used OP_PUSHDATA.
  383|     82|        return opcode == OP_PUSHDATA1;
  384|    112|    } else if (data.size() <= 65535) {
  ------------------
  |  Branch (384:16): [True: 112, False: 0]
  ------------------
  385|       |        // Must have used OP_PUSHDATA2.
  386|    112|        return opcode == OP_PUSHDATA2;
  387|    112|    }
  388|      0|    return true;
  389|  14.9k|}

_ZN15scriptnum_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  223|  7.71k|    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
_ZN10CScriptNumC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEEbm:
  247|  3.23M|    {
  248|  3.23M|        if (vch.size() > nMaxNumSize) {
  ------------------
  |  Branch (248:13): [True: 6.30k, False: 3.23M]
  ------------------
  249|  6.30k|            throw scriptnum_error("script number overflow");
  250|  6.30k|        }
  251|  3.23M|        if (fRequireMinimal && vch.size() > 0) {
  ------------------
  |  Branch (251:13): [True: 6.89k, False: 3.22M]
  |  Branch (251:32): [True: 6.89k, False: 0]
  ------------------
  252|       |            // Check that the number is encoded with the minimum possible
  253|       |            // number of bytes.
  254|       |            //
  255|       |            // If the most-significant-byte - excluding the sign bit - is zero
  256|       |            // then we're not minimal. Note how this test also rejects the
  257|       |            // negative-zero encoding, 0x80.
  258|  6.89k|            if ((vch.back() & 0x7f) == 0) {
  ------------------
  |  Branch (258:17): [True: 1.77k, False: 5.12k]
  ------------------
  259|       |                // One exception: if there's more than one byte and the most
  260|       |                // significant bit of the second-most-significant-byte is set
  261|       |                // it would conflict with the sign bit. An example of this case
  262|       |                // is +-255, which encode to 0xff00 and 0xff80 respectively.
  263|       |                // (big-endian).
  264|  1.77k|                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
  ------------------
  |  Branch (264:21): [True: 1.05k, False: 716]
  |  Branch (264:40): [True: 358, False: 358]
  ------------------
  265|  1.41k|                    throw scriptnum_error("non-minimally encoded script number");
  266|  1.41k|                }
  267|  1.77k|            }
  268|  6.89k|        }
  269|  3.23M|        m_value = set_vch(vch);
  270|  3.23M|    }
_ZNK10CScriptNum6getintEv:
  334|  3.23M|    {
  335|  3.23M|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (335:13): [True: 0, False: 3.23M]
  ------------------
  336|      0|            return std::numeric_limits<int>::max();
  337|  3.23M|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (337:18): [True: 0, False: 3.23M]
  ------------------
  338|      0|            return std::numeric_limits<int>::min();
  339|  3.23M|        return m_value;
  340|  3.23M|    }
_ZN10CScriptNum7set_vchERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  384|  3.23M|    {
  385|  3.23M|      if (vch.empty())
  ------------------
  |  Branch (385:11): [True: 2.27M, False: 953k]
  ------------------
  386|  2.27M|          return 0;
  387|       |
  388|   953k|      int64_t result = 0;
  389|  2.07M|      for (size_t i = 0; i != vch.size(); ++i)
  ------------------
  |  Branch (389:26): [True: 1.11M, False: 953k]
  ------------------
  390|  1.11M|          result |= static_cast<int64_t>(vch[i]) << 8*i;
  391|       |
  392|       |      // If the input vector's most significant byte is 0x80, remove it from
  393|       |      // the result's msb and return a negative.
  394|   953k|      if (vch.back() & 0x80)
  ------------------
  |  Branch (394:11): [True: 12.5k, False: 940k]
  ------------------
  395|  12.5k|          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
  396|       |
  397|   940k|      return result;
  398|   953k|    }
_ZN7CScript14AppendDataSizeEj:
  418|   100k|    {
  419|   100k|        if (size < OP_PUSHDATA1) {
  ------------------
  |  Branch (419:13): [True: 100k, False: 0]
  ------------------
  420|   100k|            insert(end(), static_cast<value_type>(size));
  421|   100k|        } else if (size <= 0xff) {
  ------------------
  |  Branch (421:20): [True: 0, False: 0]
  ------------------
  422|      0|            insert(end(), OP_PUSHDATA1);
  423|      0|            insert(end(), static_cast<value_type>(size));
  424|      0|        } else if (size <= 0xffff) {
  ------------------
  |  Branch (424:20): [True: 0, False: 0]
  ------------------
  425|      0|            insert(end(), OP_PUSHDATA2);
  426|      0|            value_type data[2];
  427|      0|            WriteLE16(data, size);
  428|      0|            insert(end(), std::cbegin(data), std::cend(data));
  429|      0|        } else {
  430|      0|            insert(end(), OP_PUSHDATA4);
  431|      0|            value_type data[4];
  432|      0|            WriteLE32(data, size);
  433|      0|            insert(end(), std::cbegin(data), std::cend(data));
  434|      0|        }
  435|   100k|    }
_ZN7CScript10AppendDataENSt3__14spanIKhLm18446744073709551615EEE:
  438|   100k|    {
  439|   100k|        insert(end(), data.begin(), data.end());
  440|   100k|    }
_ZN7CScriptlsE10opcodetype:
  480|   162k|    {
  481|   162k|        if (opcode < 0 || opcode > 0xff)
  ------------------
  |  Branch (481:13): [True: 0, False: 162k]
  |  Branch (481:27): [True: 0, False: 162k]
  ------------------
  482|      0|            throw std::runtime_error("CScript::operator<<(): invalid opcode");
  483|   162k|        insert(end(), (unsigned char)opcode);
  484|   162k|        return *this;
  485|   162k|    }
_ZN7CScriptlsENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  494|   100k|    {
  495|   100k|        AppendDataSize(b.size());
  496|   100k|        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
  497|   100k|        return *this;
  498|   100k|    }
_ZN7CScriptlsENSt3__14spanIKhLm18446744073709551615EEE:
  502|   100k|    {
  503|   100k|        return *this << std::as_bytes(b);
  504|   100k|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetypeRNSt3__16vectorIhNS6_9allocatorIhEEEE:
  507|  6.14M|    {
  508|  6.14M|        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
  509|  6.14M|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetype:
  512|  6.40M|    {
  513|  6.40M|        return GetScriptOp(pc, end(), opcodeRet, nullptr);
  514|  6.40M|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  518|   298k|    {
  519|   298k|        if (opcode == OP_0)
  ------------------
  |  Branch (519:13): [True: 171k, False: 127k]
  ------------------
  520|   171k|            return 0;
  521|   127k|        assert(opcode >= OP_1 && opcode <= OP_16);
  522|   127k|        return (int)opcode - (int)(OP_1 - 1);
  523|   127k|    }
_ZN7CScript10EncodeOP_NEi:
  525|  10.9k|    {
  526|  10.9k|        assert(n >= 0 && n <= 16);
  527|  10.9k|        if (n == 0)
  ------------------
  |  Branch (527:13): [True: 0, False: 10.9k]
  ------------------
  528|      0|            return OP_0;
  529|  10.9k|        return (opcodetype)(OP_1+n-1);
  530|  10.9k|    }
_ZNK7CScript13IsUnspendableEv:
  572|  62.8k|    {
  573|  62.8k|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (573:17): [True: 62.8k, False: 0]
  |  Branch (573:31): [True: 318, False: 62.5k]
  |  Branch (573:57): [True: 29.2k, False: 33.3k]
  ------------------
  574|  62.8k|    }
_ZN7CScript5clearEv:
  577|   859k|    {
  578|       |        // The default prevector::clear() does not release memory
  579|   859k|        CScriptBase::clear();
  580|   859k|        shrink_to_fit();
  581|   859k|    }
_ZNK14CScriptWitness6IsNullEv:
  593|   318k|    bool IsNull() const { return stack.empty(); }
_ZN9CScriptIDC2ERK7uint160:
  606|  58.8k|    explicit CScriptID(const uint160& in) : BaseHash(in) {}
_ZN7CScript16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|  8.30M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  8.30M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScriptC2Ev:
  461|  2.31M|    CScript() = default;
_ZN14CScriptWitnessC2Ev:
  591|   212k|    CScriptWitness() = default;
_ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  465|   532k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|   532k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|  1.19M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  1.19M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  465|   532k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|   532k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  465|  1.39k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  1.39k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_Z12ToByteVectorI6PKHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|  8.14k|{
   69|  8.14k|    return std::vector<unsigned char>(in.begin(), in.end());
   70|  8.14k|}
_Z12ToByteVectorI10ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|  37.8k|{
   69|  37.8k|    return std::vector<unsigned char>(in.begin(), in.end());
   70|  37.8k|}
_Z12ToByteVectorI19WitnessV0ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|  21.0k|{
   69|  21.0k|    return std::vector<unsigned char>(in.begin(), in.end());
   70|  21.0k|}
_Z12ToByteVectorI16WitnessV0KeyHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|  19.2k|{
   69|  19.2k|    return std::vector<unsigned char>(in.begin(), in.end());
   70|  19.2k|}
_Z12ToByteVectorI16WitnessV1TaprootENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|  3.39k|{
   69|  3.39k|    return std::vector<unsigned char>(in.begin(), in.end());
   70|  3.39k|}
_ZN7CScript16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|   798k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|   798k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_ZNK15SigningProvider10GetCScriptERK9CScriptIDR7CScript:
  156|  58.8k|    virtual bool GetCScript(const CScriptID &scriptid, CScript& script) const { return false; }
_ZNK15SigningProvider9GetPubKeyERK6CKeyIDR7CPubKey:
  158|  27.3k|    virtual bool GetPubKey(const CKeyID &address, CPubKey& pubkey) const { return false; }
_ZNK15SigningProvider12GetKeyOriginERK6CKeyIDR13KeyOriginInfo:
  161|  37.6k|    virtual bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const { return false; }
_ZNK15SigningProvider19GetTaprootSpendDataERK11XOnlyPubKeyR16TaprootSpendData:
  162|  6.62k|    virtual bool GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const { return false; }
_ZNK15SigningProvider19GetKeyOriginByXOnlyERK11XOnlyPubKeyR13KeyOriginInfo:
  182|  3.23k|    {
  183|  6.46k|        for (const auto& id : pubkey.GetKeyIDs()) {
  ------------------
  |  Branch (183:29): [True: 6.46k, False: 3.23k]
  ------------------
  184|  6.46k|            if (GetKeyOrigin(id, info)) return true;
  ------------------
  |  Branch (184:17): [True: 0, False: 6.46k]
  ------------------
  185|  6.46k|        }
  186|  3.23k|        return false;
  187|  3.23k|    }

_Z16GetTxnOutputType9TxoutType:
   19|   553k|{
   20|   553k|    switch (t) {
  ------------------
  |  Branch (20:13): [True: 0, False: 553k]
  ------------------
   21|   429k|    case TxoutType::NONSTANDARD: return "nonstandard";
  ------------------
  |  Branch (21:5): [True: 429k, False: 123k]
  ------------------
   22|  9.84k|    case TxoutType::PUBKEY: return "pubkey";
  ------------------
  |  Branch (22:5): [True: 9.84k, False: 543k]
  ------------------
   23|  8.14k|    case TxoutType::PUBKEYHASH: return "pubkeyhash";
  ------------------
  |  Branch (23:5): [True: 8.14k, False: 544k]
  ------------------
   24|  37.8k|    case TxoutType::SCRIPTHASH: return "scripthash";
  ------------------
  |  Branch (24:5): [True: 37.8k, False: 515k]
  ------------------
   25|  8.21k|    case TxoutType::MULTISIG: return "multisig";
  ------------------
  |  Branch (25:5): [True: 8.21k, False: 544k]
  ------------------
   26|  1.54k|    case TxoutType::NULL_DATA: return "nulldata";
  ------------------
  |  Branch (26:5): [True: 1.54k, False: 551k]
  ------------------
   27|     18|    case TxoutType::ANCHOR: return "anchor";
  ------------------
  |  Branch (27:5): [True: 18, False: 553k]
  ------------------
   28|  19.2k|    case TxoutType::WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
  ------------------
  |  Branch (28:5): [True: 19.2k, False: 533k]
  ------------------
   29|  21.0k|    case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
  ------------------
  |  Branch (29:5): [True: 21.0k, False: 532k]
  ------------------
   30|  6.62k|    case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
  ------------------
  |  Branch (30:5): [True: 6.62k, False: 546k]
  ------------------
   31|  10.9k|    case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
  ------------------
  |  Branch (31:5): [True: 10.9k, False: 542k]
  ------------------
   32|   553k|    } // no default case, so the compiler can warn about missing cases
   33|      0|    assert(false);
   34|      0|}
_Z6SolverRK7CScriptRNSt3__16vectorINS3_IhNS2_9allocatorIhEEEENS4_IS6_EEEE:
  142|  2.21M|{
  143|  2.21M|    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|  2.21M|    if (scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (147:9): [True: 153k, False: 2.05M]
  ------------------
  148|   153k|    {
  149|   153k|        std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
  150|   153k|        vSolutionsRet.push_back(hashBytes);
  151|   153k|        return TxoutType::SCRIPTHASH;
  152|   153k|    }
  153|       |
  154|  2.05M|    int witnessversion;
  155|  2.05M|    std::vector<unsigned char> witnessprogram;
  156|  2.05M|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (156:9): [True: 238k, False: 1.81M]
  ------------------
  157|   238k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
  ------------------
  |  Branch (157:13): [True: 170k, False: 67.8k]
  |  Branch (157:36): [True: 83.5k, False: 87.1k]
  ------------------
  158|  83.5k|            vSolutionsRet.push_back(std::move(witnessprogram));
  159|  83.5k|            return TxoutType::WITNESS_V0_KEYHASH;
  160|  83.5k|        }
  161|   155k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (161:13): [True: 87.1k, False: 67.8k]
  |  Branch (161:36): [True: 85.6k, False: 1.57k]
  ------------------
  162|  85.6k|            vSolutionsRet.push_back(std::move(witnessprogram));
  163|  85.6k|            return TxoutType::WITNESS_V0_SCRIPTHASH;
  164|  85.6k|        }
  165|  69.4k|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
  ------------------
  |  Branch (165:13): [True: 24.3k, False: 45.1k]
  |  Branch (165:36): [True: 23.6k, False: 648]
  ------------------
  166|  23.6k|            vSolutionsRet.push_back(std::move(witnessprogram));
  167|  23.6k|            return TxoutType::WITNESS_V1_TAPROOT;
  168|  23.6k|        }
  169|  45.7k|        if (scriptPubKey.IsPayToAnchor()) {
  ------------------
  |  Branch (169:13): [True: 74, False: 45.6k]
  ------------------
  170|     74|            return TxoutType::ANCHOR;
  171|     74|        }
  172|  45.6k|        if (witnessversion != 0) {
  ------------------
  |  Branch (172:13): [True: 44.1k, False: 1.57k]
  ------------------
  173|  44.1k|            vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
  174|  44.1k|            vSolutionsRet.push_back(std::move(witnessprogram));
  175|  44.1k|            return TxoutType::WITNESS_UNKNOWN;
  176|  44.1k|        }
  177|  1.57k|        return TxoutType::NONSTANDARD;
  178|  45.6k|    }
  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.81M|    if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
  ------------------
  |  Branch (185:9): [True: 1.29M, False: 525k]
  |  Branch (185:9): [True: 6.24k, False: 1.81M]
  |  Branch (185:37): [True: 13.8k, False: 1.27M]
  |  Branch (185:69): [True: 6.24k, False: 7.64k]
  ------------------
  186|  6.24k|        return TxoutType::NULL_DATA;
  187|  6.24k|    }
  188|       |
  189|  1.81M|    std::vector<unsigned char> data;
  190|  1.81M|    if (MatchPayToPubkey(scriptPubKey, data)) {
  ------------------
  |  Branch (190:9): [True: 31.2k, False: 1.78M]
  ------------------
  191|  31.2k|        vSolutionsRet.push_back(std::move(data));
  192|  31.2k|        return TxoutType::PUBKEY;
  193|  31.2k|    }
  194|       |
  195|  1.78M|    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
  ------------------
  |  Branch (195:9): [True: 33.3k, False: 1.74M]
  ------------------
  196|  33.3k|        vSolutionsRet.push_back(std::move(data));
  197|  33.3k|        return TxoutType::PUBKEYHASH;
  198|  33.3k|    }
  199|       |
  200|  1.74M|    int required;
  201|  1.74M|    std::vector<std::vector<unsigned char>> keys;
  202|  1.74M|    if (MatchMultisig(scriptPubKey, required, keys)) {
  ------------------
  |  Branch (202:9): [True: 26.2k, False: 1.72M]
  ------------------
  203|  26.2k|        vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..20
  204|  26.2k|        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
  205|  26.2k|        vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..20
  206|  26.2k|        return TxoutType::MULTISIG;
  207|  26.2k|    }
  208|       |
  209|  1.72M|    vSolutionsRet.clear();
  210|  1.72M|    return TxoutType::NONSTANDARD;
  211|  1.74M|}
solver.cpp:_ZL15GetScriptNumber10opcodetypeNSt3__16vectorIhNS0_9allocatorIhEEEEii:
   67|  85.9k|{
   68|  85.9k|    int count;
   69|  85.9k|    if (IsSmallInteger(opcode)) {
  ------------------
  |  Branch (69:9): [True: 59.0k, False: 26.8k]
  ------------------
   70|  59.0k|        count = CScript::DecodeOP_N(opcode);
   71|  59.0k|    } else if (IsPushdataOp(opcode)) {
  ------------------
  |  Branch (71:16): [True: 14.9k, False: 11.9k]
  ------------------
   72|  14.9k|        if (!CheckMinimalPush(data, opcode)) return {};
  ------------------
  |  Branch (72:13): [True: 1.73k, False: 13.2k]
  ------------------
   73|  13.2k|        try {
   74|  13.2k|            count = CScriptNum(data, /* fRequireMinimal = */ true).getint();
   75|  13.2k|        } catch (const scriptnum_error&) {
   76|  7.71k|            return {};
   77|  7.71k|        }
   78|  13.2k|    } else {
   79|  11.9k|        return {};
   80|  11.9k|    }
   81|  64.5k|    if (count < min || count > max) return {};
  ------------------
  |  Branch (81:9): [True: 1.67k, False: 62.8k]
  |  Branch (81:24): [True: 3.72k, False: 59.1k]
  ------------------
   82|  59.1k|    return count;
   83|  64.5k|}
solver.cpp:_ZL14IsSmallInteger10opcodetype:
   60|  85.9k|{
   61|  85.9k|    return opcode >= OP_1 && opcode <= OP_16;
  ------------------
  |  Branch (61:12): [True: 69.8k, False: 16.0k]
  |  Branch (61:30): [True: 59.0k, False: 10.8k]
  ------------------
   62|  85.9k|}
solver.cpp:_ZL16MatchPayToPubkeyRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   37|  1.81M|{
   38|  1.81M|    if (script.size() == CPubKey::SIZE + 2 && script[0] == CPubKey::SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (38:9): [True: 8.35k, False: 1.80M]
  |  Branch (38:47): [True: 7.45k, False: 898]
  |  Branch (38:77): [True: 6.84k, False: 614]
  ------------------
   39|  6.84k|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::SIZE + 1);
   40|  6.84k|        return CPubKey::ValidSize(pubkey);
   41|  6.84k|    }
   42|  1.80M|    if (script.size() == CPubKey::COMPRESSED_SIZE + 2 && script[0] == CPubKey::COMPRESSED_SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (42:9): [True: 31.8k, False: 1.77M]
  |  Branch (42:58): [True: 27.6k, False: 4.19k]
  |  Branch (42:99): [True: 25.6k, False: 1.97k]
  ------------------
   43|  25.6k|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_SIZE + 1);
   44|  25.6k|        return CPubKey::ValidSize(pubkey);
   45|  25.6k|    }
   46|  1.78M|    return false;
   47|  1.80M|}
solver.cpp:_ZL20MatchPayToPubkeyHashRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   50|  1.78M|{
   51|  1.78M|    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: 38.5k, False: 1.74M]
  |  Branch (51:32): [True: 37.0k, False: 1.50k]
  |  Branch (51:55): [True: 35.7k, False: 1.29k]
  |  Branch (51:82): [True: 35.1k, False: 567]
  |  Branch (51:101): [True: 33.9k, False: 1.22k]
  |  Branch (51:133): [True: 33.3k, False: 658]
  ------------------
   52|  33.3k|        pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
   53|  33.3k|        return true;
   54|  33.3k|    }
   55|  1.74M|    return false;
   56|  1.78M|}
solver.cpp:_ZL13MatchMultisigRK7CScriptRiRNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEE:
   86|  1.74M|{
   87|  1.74M|    opcodetype opcode;
   88|  1.74M|    valtype data;
   89|       |
   90|  1.74M|    CScript::const_iterator it = script.begin();
   91|  1.74M|    if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
  ------------------
  |  Branch (91:9): [True: 525k, False: 1.22M]
  |  Branch (91:30): [True: 1.16M, False: 56.4k]
  ------------------
   92|       |
   93|  56.4k|    if (!script.GetOp(it, opcode, data)) return false;
  ------------------
  |  Branch (93:9): [True: 2.97k, False: 53.4k]
  ------------------
   94|  53.4k|    auto req_sigs = GetScriptNumber(opcode, data, 1, MAX_PUBKEYS_PER_MULTISIG);
   95|  53.4k|    if (!req_sigs) return false;
  ------------------
  |  Branch (95:9): [True: 20.9k, False: 32.5k]
  ------------------
   96|  32.5k|    required_sigs = *req_sigs;
   97|   116k|    while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
  ------------------
  |  Branch (97:12): [True: 115k, False: 346]
  |  Branch (97:46): [True: 83.6k, False: 32.1k]
  ------------------
   98|  83.6k|        pubkeys.emplace_back(std::move(data));
   99|  83.6k|    }
  100|  32.5k|    auto num_keys = GetScriptNumber(opcode, data, required_sigs, MAX_PUBKEYS_PER_MULTISIG);
  101|  32.5k|    if (!num_keys) return false;
  ------------------
  |  Branch (101:9): [True: 5.90k, False: 26.6k]
  ------------------
  102|  26.6k|    if (pubkeys.size() != static_cast<unsigned long>(*num_keys)) return false;
  ------------------
  |  Branch (102:9): [True: 333, False: 26.2k]
  ------------------
  103|       |
  104|  26.2k|    return (it + 1 == script.end());
  105|  26.6k|}

_Z12IsPushdataOp10opcodetype:
   41|  26.8k|{
   42|  26.8k|    return opcode > OP_FALSE && opcode <= OP_PUSHDATA4;
  ------------------
  |  Branch (42:12): [True: 25.8k, False: 1.07k]
  |  Branch (42:33): [True: 14.9k, False: 10.8k]
  ------------------
   43|  26.8k|}

secp256k1.c:secp256k1_fe_impl_sqr:
  345|  1.67M|SECP256K1_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
  346|  1.67M|    secp256k1_fe_sqr_inner(r->n, a->n);
  347|  1.67M|}
secp256k1.c:secp256k1_fe_impl_mul:
  341|  91.7k|SECP256K1_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
  342|  91.7k|    secp256k1_fe_mul_inner(r->n, a->n, b->n);
  343|  91.7k|}
secp256k1.c:secp256k1_fe_impl_add_int:
  329|  6.55k|SECP256K1_INLINE static void secp256k1_fe_impl_add_int(secp256k1_fe *r, int a) {
  330|  6.55k|    r->n[0] += a;
  331|  6.55k|}
secp256k1.c:secp256k1_fe_impl_to_storage:
  428|  6.46k|static void secp256k1_fe_impl_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
  429|  6.46k|    r->n[0] = a->n[0] | a->n[1] << 52;
  430|  6.46k|    r->n[1] = a->n[1] >> 12 | a->n[2] << 40;
  431|  6.46k|    r->n[2] = a->n[2] >> 24 | a->n[3] << 28;
  432|  6.46k|    r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
  433|  6.46k|}
secp256k1.c:secp256k1_fe_impl_add:
  333|  6.55k|SECP256K1_INLINE static void secp256k1_fe_impl_add(secp256k1_fe *r, const secp256k1_fe *a) {
  334|  6.55k|    r->n[0] += a->n[0];
  335|  6.55k|    r->n[1] += a->n[1];
  336|  6.55k|    r->n[2] += a->n[2];
  337|  6.55k|    r->n[3] += a->n[3];
  338|  6.55k|    r->n[4] += a->n[4];
  339|  6.55k|}
secp256k1.c:secp256k1_fe_impl_negate_unchecked:
  306|  9.93k|SECP256K1_INLINE static void secp256k1_fe_impl_negate_unchecked(secp256k1_fe *r, const secp256k1_fe *a, int m) {
  307|       |    /* For all legal values of m (0..31), the following properties hold: */
  308|  9.93k|    VERIFY_CHECK(0xFFFFEFFFFFC2FULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  309|  9.93k|    VERIFY_CHECK(0xFFFFFFFFFFFFFULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  310|  9.93k|    VERIFY_CHECK(0x0FFFFFFFFFFFFULL * 2 * (m + 1) >= 0x0FFFFFFFFFFFFULL * 2 * m);
  311|       |
  312|       |    /* Due to the properties above, the left hand in the subtractions below is never less than
  313|       |     * the right hand. */
  314|  9.93k|    r->n[0] = 0xFFFFEFFFFFC2FULL * 2 * (m + 1) - a->n[0];
  315|  9.93k|    r->n[1] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[1];
  316|  9.93k|    r->n[2] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[2];
  317|  9.93k|    r->n[3] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[3];
  318|  9.93k|    r->n[4] = 0x0FFFFFFFFFFFFULL * 2 * (m + 1) - a->n[4];
  319|  9.93k|}
secp256k1.c:secp256k1_fe_impl_normalizes_to_zero:
  137|  6.55k|static int secp256k1_fe_impl_normalizes_to_zero(const secp256k1_fe *r) {
  138|  6.55k|    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|  6.55k|    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|  6.55k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  145|       |
  146|       |    /* The first pass ensures the magnitude is 1, ... */
  147|  6.55k|    t0 += x * 0x1000003D1ULL;
  148|  6.55k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL; z0  = t0; z1  = t0 ^ 0x1000003D0ULL;
  149|  6.55k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
  150|  6.55k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
  151|  6.55k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
  152|  6.55k|                                                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|  6.55k|    VERIFY_CHECK(t4 >> 49 == 0);
  156|       |
  157|  6.55k|    return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
  158|  6.55k|}
secp256k1.c:secp256k1_fe_impl_set_b32_limit:
  265|  6.62k|static int secp256k1_fe_impl_set_b32_limit(secp256k1_fe *r, const unsigned char *a) {
  266|  6.62k|    secp256k1_fe_impl_set_b32_mod(r, a);
  267|  6.62k|    return !((r->n[4] == 0x0FFFFFFFFFFFFULL) & ((r->n[3] & r->n[2] & r->n[1]) == 0xFFFFFFFFFFFFFULL) & (r->n[0] >= 0xFFFFEFFFFFC2FULL));
  268|  6.62k|}
secp256k1.c:secp256k1_fe_impl_normalize_var:
   99|  6.55k|static void secp256k1_fe_impl_normalize_var(secp256k1_fe *r) {
  100|  6.55k|    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|  6.55k|    uint64_t m;
  104|  6.55k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  105|       |
  106|       |    /* The first pass ensures the magnitude is 1, ... */
  107|  6.55k|    t0 += x * 0x1000003D1ULL;
  108|  6.55k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  109|  6.55k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
  110|  6.55k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
  111|  6.55k|    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|  6.55k|    VERIFY_CHECK(t4 >> 49 == 0);
  115|       |
  116|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
  117|  6.55k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
  118|  6.55k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
  119|       |
  120|  6.55k|    if (x) {
  ------------------
  |  Branch (120:9): [True: 0, False: 6.55k]
  ------------------
  121|      0|        t0 += 0x1000003D1ULL;
  122|      0|        t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  123|      0|        t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
  124|      0|        t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
  125|      0|        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|      0|        VERIFY_CHECK(t4 >> 48 == x);
  129|       |
  130|       |        /* Mask off the possible multiple of 2^256 from the final reduction */
  131|      0|        t4 &= 0x0FFFFFFFFFFFFULL;
  132|      0|    }
  133|       |
  134|  6.55k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
  135|  6.55k|}
secp256k1.c:secp256k1_fe_impl_is_odd:
  211|  6.55k|SECP256K1_INLINE static int secp256k1_fe_impl_is_odd(const secp256k1_fe *a) {
  212|  6.55k|    return a->n[0] & 1;
  213|  6.55k|}
secp256k1.c:secp256k1_fe_impl_set_b32_mod:
  228|  6.62k|static void secp256k1_fe_impl_set_b32_mod(secp256k1_fe *r, const unsigned char *a) {
  229|  6.62k|    r->n[0] = (uint64_t)a[31]
  230|  6.62k|            | ((uint64_t)a[30] << 8)
  231|  6.62k|            | ((uint64_t)a[29] << 16)
  232|  6.62k|            | ((uint64_t)a[28] << 24)
  233|  6.62k|            | ((uint64_t)a[27] << 32)
  234|  6.62k|            | ((uint64_t)a[26] << 40)
  235|  6.62k|            | ((uint64_t)(a[25] & 0xF)  << 48);
  236|  6.62k|    r->n[1] = (uint64_t)((a[25] >> 4) & 0xF)
  237|  6.62k|            | ((uint64_t)a[24] << 4)
  238|  6.62k|            | ((uint64_t)a[23] << 12)
  239|  6.62k|            | ((uint64_t)a[22] << 20)
  240|  6.62k|            | ((uint64_t)a[21] << 28)
  241|  6.62k|            | ((uint64_t)a[20] << 36)
  242|  6.62k|            | ((uint64_t)a[19] << 44);
  243|  6.62k|    r->n[2] = (uint64_t)a[18]
  244|  6.62k|            | ((uint64_t)a[17] << 8)
  245|  6.62k|            | ((uint64_t)a[16] << 16)
  246|  6.62k|            | ((uint64_t)a[15] << 24)
  247|  6.62k|            | ((uint64_t)a[14] << 32)
  248|  6.62k|            | ((uint64_t)a[13] << 40)
  249|  6.62k|            | ((uint64_t)(a[12] & 0xF) << 48);
  250|  6.62k|    r->n[3] = (uint64_t)((a[12] >> 4) & 0xF)
  251|  6.62k|            | ((uint64_t)a[11] << 4)
  252|  6.62k|            | ((uint64_t)a[10] << 12)
  253|  6.62k|            | ((uint64_t)a[9]  << 20)
  254|  6.62k|            | ((uint64_t)a[8]  << 28)
  255|  6.62k|            | ((uint64_t)a[7]  << 36)
  256|  6.62k|            | ((uint64_t)a[6]  << 44);
  257|  6.62k|    r->n[4] = (uint64_t)a[5]
  258|  6.62k|            | ((uint64_t)a[4] << 8)
  259|  6.62k|            | ((uint64_t)a[3] << 16)
  260|  6.62k|            | ((uint64_t)a[2] << 24)
  261|  6.62k|            | ((uint64_t)a[1] << 32)
  262|  6.62k|            | ((uint64_t)a[0] << 40);
  263|  6.62k|}
secp256k1.c:secp256k1_fe_impl_normalize:
   43|  6.46k|static void secp256k1_fe_impl_normalize(secp256k1_fe *r) {
   44|  6.46k|    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|  6.46k|    uint64_t m;
   48|  6.46k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
   49|       |
   50|       |    /* The first pass ensures the magnitude is 1, ... */
   51|  6.46k|    t0 += x * 0x1000003D1ULL;
   52|  6.46k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   53|  6.46k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
   54|  6.46k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
   55|  6.46k|    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|  6.46k|    VERIFY_CHECK(t4 >> 49 == 0);
   59|       |
   60|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
   61|  6.46k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
   62|  6.46k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
   63|       |
   64|       |    /* Apply the final reduction (for constant-time behaviour, we do it always) */
   65|  6.46k|    t0 += x * 0x1000003D1ULL;
   66|  6.46k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   67|  6.46k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
   68|  6.46k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
   69|  6.46k|    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|  6.46k|    VERIFY_CHECK(t4 >> 48 == x);
   73|       |
   74|       |    /* Mask off the possible multiple of 2^256 from the final reduction */
   75|  6.46k|    t4 &= 0x0FFFFFFFFFFFFULL;
   76|       |
   77|  6.46k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
   78|  6.46k|}

secp256k1.c:secp256k1_fe_sqr_inner:
  154|  1.67M|SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
  155|  1.67M|    secp256k1_uint128 c, d;
  156|  1.67M|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
  157|  1.67M|    uint64_t t3, t4, tx, u0;
  158|  1.67M|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
  159|       |
  160|  1.67M|    VERIFY_BITS(a[0], 56);
  161|  1.67M|    VERIFY_BITS(a[1], 56);
  162|  1.67M|    VERIFY_BITS(a[2], 56);
  163|  1.67M|    VERIFY_BITS(a[3], 56);
  164|  1.67M|    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.67M|    secp256k1_u128_mul(&d, a0*2, a3);
  172|  1.67M|    secp256k1_u128_accum_mul(&d, a1*2, a2);
  173|  1.67M|    VERIFY_BITS_128(&d, 114);
  174|       |    /* [d 0 0 0] = [p3 0 0 0] */
  175|  1.67M|    secp256k1_u128_mul(&c, a4, a4);
  176|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
  179|  1.67M|    VERIFY_BITS_128(&d, 115);
  180|  1.67M|    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.67M|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  183|  1.67M|    VERIFY_BITS(t3, 52);
  184|  1.67M|    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.67M|    a4 *= 2;
  188|  1.67M|    secp256k1_u128_accum_mul(&d, a0, a4);
  189|  1.67M|    secp256k1_u128_accum_mul(&d, a1*2, a3);
  190|  1.67M|    secp256k1_u128_accum_mul(&d, a2, a2);
  191|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
  194|  1.67M|    VERIFY_BITS_128(&d, 116);
  195|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  196|  1.67M|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  197|  1.67M|    VERIFY_BITS(t4, 52);
  198|  1.67M|    VERIFY_BITS_128(&d, 64);
  199|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  200|  1.67M|    tx = (t4 >> 48); t4 &= (M >> 4);
  201|  1.67M|    VERIFY_BITS(tx, 4);
  202|  1.67M|    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.67M|    secp256k1_u128_mul(&c, a0, a0);
  206|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&d, a1, a4);
  209|  1.67M|    secp256k1_u128_accum_mul(&d, a2*2, a3);
  210|  1.67M|    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.67M|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  213|  1.67M|    VERIFY_BITS(u0, 52);
  214|  1.67M|    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.67M|    u0 = (u0 << 4) | tx;
  218|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
  221|  1.67M|    VERIFY_BITS_128(&c, 113);
  222|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  223|  1.67M|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  224|  1.67M|    VERIFY_BITS(r[0], 52);
  225|  1.67M|    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.67M|    a0 *= 2;
  229|  1.67M|    secp256k1_u128_accum_mul(&c, a0, a1);
  230|  1.67M|    VERIFY_BITS_128(&c, 114);
  231|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  232|  1.67M|    secp256k1_u128_accum_mul(&d, a2, a4);
  233|  1.67M|    secp256k1_u128_accum_mul(&d, a3, a3);
  234|  1.67M|    VERIFY_BITS_128(&d, 114);
  235|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  236|  1.67M|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  237|  1.67M|    VERIFY_BITS_128(&c, 115);
  238|  1.67M|    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.67M|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  241|  1.67M|    VERIFY_BITS(r[1], 52);
  242|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&c, a0, a2);
  246|  1.67M|    secp256k1_u128_accum_mul(&c, a1, a1);
  247|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&d, a3, a4);
  250|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  253|  1.67M|    VERIFY_BITS_128(&c, 115);
  254|  1.67M|    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.67M|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  257|  1.67M|    VERIFY_BITS(r[2], 52);
  258|  1.67M|    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.67M|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  262|  1.67M|    secp256k1_u128_accum_u64(&c, t3);
  263|  1.67M|    VERIFY_BITS_128(&c, 100);
  264|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  265|  1.67M|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  266|  1.67M|    VERIFY_BITS(r[3], 52);
  267|  1.67M|    VERIFY_BITS_128(&c, 48);
  268|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  269|  1.67M|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  270|  1.67M|    VERIFY_BITS(r[4], 49);
  271|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  272|  1.67M|}
secp256k1.c:secp256k1_fe_mul_inner:
   18|  91.7k|SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
   19|  91.7k|    secp256k1_uint128 c, d;
   20|  91.7k|    uint64_t t3, t4, tx, u0;
   21|  91.7k|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
   22|  91.7k|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
   23|       |
   24|  91.7k|    VERIFY_BITS(a[0], 56);
   25|  91.7k|    VERIFY_BITS(a[1], 56);
   26|  91.7k|    VERIFY_BITS(a[2], 56);
   27|  91.7k|    VERIFY_BITS(a[3], 56);
   28|  91.7k|    VERIFY_BITS(a[4], 52);
   29|  91.7k|    VERIFY_BITS(b[0], 56);
   30|  91.7k|    VERIFY_BITS(b[1], 56);
   31|  91.7k|    VERIFY_BITS(b[2], 56);
   32|  91.7k|    VERIFY_BITS(b[3], 56);
   33|  91.7k|    VERIFY_BITS(b[4], 52);
   34|  91.7k|    VERIFY_CHECK(r != b);
   35|  91.7k|    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|  91.7k|    secp256k1_u128_mul(&d, a0, b[3]);
   44|  91.7k|    secp256k1_u128_accum_mul(&d, a1, b[2]);
   45|  91.7k|    secp256k1_u128_accum_mul(&d, a2, b[1]);
   46|  91.7k|    secp256k1_u128_accum_mul(&d, a3, b[0]);
   47|  91.7k|    VERIFY_BITS_128(&d, 114);
   48|       |    /* [d 0 0 0] = [p3 0 0 0] */
   49|  91.7k|    secp256k1_u128_mul(&c, a4, b[4]);
   50|  91.7k|    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|  91.7k|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
   53|  91.7k|    VERIFY_BITS_128(&d, 115);
   54|  91.7k|    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|  91.7k|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   57|  91.7k|    VERIFY_BITS(t3, 52);
   58|  91.7k|    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|  91.7k|    secp256k1_u128_accum_mul(&d, a0, b[4]);
   62|  91.7k|    secp256k1_u128_accum_mul(&d, a1, b[3]);
   63|  91.7k|    secp256k1_u128_accum_mul(&d, a2, b[2]);
   64|  91.7k|    secp256k1_u128_accum_mul(&d, a3, b[1]);
   65|  91.7k|    secp256k1_u128_accum_mul(&d, a4, b[0]);
   66|  91.7k|    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|  91.7k|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
   69|  91.7k|    VERIFY_BITS_128(&d, 116);
   70|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   71|  91.7k|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   72|  91.7k|    VERIFY_BITS(t4, 52);
   73|  91.7k|    VERIFY_BITS_128(&d, 64);
   74|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   75|  91.7k|    tx = (t4 >> 48); t4 &= (M >> 4);
   76|  91.7k|    VERIFY_BITS(tx, 4);
   77|  91.7k|    VERIFY_BITS(t4, 48);
   78|       |    /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   79|       |
   80|  91.7k|    secp256k1_u128_mul(&c, a0, b[0]);
   81|  91.7k|    VERIFY_BITS_128(&c, 112);
   82|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
   83|  91.7k|    secp256k1_u128_accum_mul(&d, a1, b[4]);
   84|  91.7k|    secp256k1_u128_accum_mul(&d, a2, b[3]);
   85|  91.7k|    secp256k1_u128_accum_mul(&d, a3, b[2]);
   86|  91.7k|    secp256k1_u128_accum_mul(&d, a4, b[1]);
   87|  91.7k|    VERIFY_BITS_128(&d, 114);
   88|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   89|  91.7k|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   90|  91.7k|    VERIFY_BITS(u0, 52);
   91|  91.7k|    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|  91.7k|    u0 = (u0 << 4) | tx;
   95|  91.7k|    VERIFY_BITS(u0, 56);
   96|       |    /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   97|  91.7k|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
   98|  91.7k|    VERIFY_BITS_128(&c, 113);
   99|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  100|  91.7k|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  101|  91.7k|    VERIFY_BITS(r[0], 52);
  102|  91.7k|    VERIFY_BITS_128(&c, 61);
  103|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
  104|       |
  105|  91.7k|    secp256k1_u128_accum_mul(&c, a0, b[1]);
  106|  91.7k|    secp256k1_u128_accum_mul(&c, a1, b[0]);
  107|  91.7k|    VERIFY_BITS_128(&c, 114);
  108|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  109|  91.7k|    secp256k1_u128_accum_mul(&d, a2, b[4]);
  110|  91.7k|    secp256k1_u128_accum_mul(&d, a3, b[3]);
  111|  91.7k|    secp256k1_u128_accum_mul(&d, a4, b[2]);
  112|  91.7k|    VERIFY_BITS_128(&d, 114);
  113|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  114|  91.7k|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  115|  91.7k|    VERIFY_BITS_128(&c, 115);
  116|  91.7k|    VERIFY_BITS_128(&d, 62);
  117|       |    /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  118|  91.7k|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  119|  91.7k|    VERIFY_BITS(r[1], 52);
  120|  91.7k|    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|  91.7k|    secp256k1_u128_accum_mul(&c, a0, b[2]);
  124|  91.7k|    secp256k1_u128_accum_mul(&c, a1, b[1]);
  125|  91.7k|    secp256k1_u128_accum_mul(&c, a2, b[0]);
  126|  91.7k|    VERIFY_BITS_128(&c, 114);
  127|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
  128|  91.7k|    secp256k1_u128_accum_mul(&d, a3, b[4]);
  129|  91.7k|    secp256k1_u128_accum_mul(&d, a4, b[3]);
  130|  91.7k|    VERIFY_BITS_128(&d, 114);
  131|       |    /* [d 0 0 t4 t3 c t1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  132|  91.7k|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  133|  91.7k|    VERIFY_BITS_128(&c, 115);
  134|  91.7k|    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|  91.7k|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  138|  91.7k|    VERIFY_BITS(r[2], 52);
  139|  91.7k|    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|  91.7k|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  142|  91.7k|    secp256k1_u128_accum_u64(&c, t3);
  143|  91.7k|    VERIFY_BITS_128(&c, 100);
  144|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  145|  91.7k|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  146|  91.7k|    VERIFY_BITS(r[3], 52);
  147|  91.7k|    VERIFY_BITS_128(&c, 48);
  148|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  149|  91.7k|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  150|  91.7k|    VERIFY_BITS(r[4], 49);
  151|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  152|  91.7k|}

secp256k1.c:secp256k1_fe_verify:
  149|  52.2k|static void secp256k1_fe_verify(const secp256k1_fe *a) { (void)a; }
secp256k1.c:secp256k1_fe_verify_magnitude:
  150|  45.7k|static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m) { (void)a; (void)m; }
secp256k1.c:secp256k1_fe_sqrt:
   37|  6.55k|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|  6.55k|    secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
   48|  6.55k|    int j, ret;
   49|       |
   50|  6.55k|    VERIFY_CHECK(r != a);
   51|  6.55k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  344|  6.55k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   52|  6.55k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
  ------------------
  |  |  348|  6.55k|#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|  6.55k|    secp256k1_fe_sqr(&x2, a);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   60|  6.55k|    secp256k1_fe_mul(&x2, &x2, a);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   61|       |
   62|  6.55k|    secp256k1_fe_sqr(&x3, &x2);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   63|  6.55k|    secp256k1_fe_mul(&x3, &x3, a);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   64|       |
   65|  6.55k|    x6 = x3;
   66|  26.2k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (66:15): [True: 19.6k, False: 6.55k]
  ------------------
   67|  19.6k|        secp256k1_fe_sqr(&x6, &x6);
  ------------------
  |  |   94|  19.6k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   68|  19.6k|    }
   69|  6.55k|    secp256k1_fe_mul(&x6, &x6, &x3);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   70|       |
   71|  6.55k|    x9 = x6;
   72|  26.2k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (72:15): [True: 19.6k, False: 6.55k]
  ------------------
   73|  19.6k|        secp256k1_fe_sqr(&x9, &x9);
  ------------------
  |  |   94|  19.6k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   74|  19.6k|    }
   75|  6.55k|    secp256k1_fe_mul(&x9, &x9, &x3);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   76|       |
   77|  6.55k|    x11 = x9;
   78|  19.6k|    for (j=0; j<2; j++) {
  ------------------
  |  Branch (78:15): [True: 13.1k, False: 6.55k]
  ------------------
   79|  13.1k|        secp256k1_fe_sqr(&x11, &x11);
  ------------------
  |  |   94|  13.1k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   80|  13.1k|    }
   81|  6.55k|    secp256k1_fe_mul(&x11, &x11, &x2);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   82|       |
   83|  6.55k|    x22 = x11;
   84|  78.6k|    for (j=0; j<11; j++) {
  ------------------
  |  Branch (84:15): [True: 72.0k, False: 6.55k]
  ------------------
   85|  72.0k|        secp256k1_fe_sqr(&x22, &x22);
  ------------------
  |  |   94|  72.0k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   86|  72.0k|    }
   87|  6.55k|    secp256k1_fe_mul(&x22, &x22, &x11);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   88|       |
   89|  6.55k|    x44 = x22;
   90|   150k|    for (j=0; j<22; j++) {
  ------------------
  |  Branch (90:15): [True: 144k, False: 6.55k]
  ------------------
   91|   144k|        secp256k1_fe_sqr(&x44, &x44);
  ------------------
  |  |   94|   144k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   92|   144k|    }
   93|  6.55k|    secp256k1_fe_mul(&x44, &x44, &x22);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   94|       |
   95|  6.55k|    x88 = x44;
   96|   294k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (96:15): [True: 288k, False: 6.55k]
  ------------------
   97|   288k|        secp256k1_fe_sqr(&x88, &x88);
  ------------------
  |  |   94|   288k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   98|   288k|    }
   99|  6.55k|    secp256k1_fe_mul(&x88, &x88, &x44);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  100|       |
  101|  6.55k|    x176 = x88;
  102|   583k|    for (j=0; j<88; j++) {
  ------------------
  |  Branch (102:15): [True: 576k, False: 6.55k]
  ------------------
  103|   576k|        secp256k1_fe_sqr(&x176, &x176);
  ------------------
  |  |   94|   576k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  104|   576k|    }
  105|  6.55k|    secp256k1_fe_mul(&x176, &x176, &x88);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  106|       |
  107|  6.55k|    x220 = x176;
  108|   294k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (108:15): [True: 288k, False: 6.55k]
  ------------------
  109|   288k|        secp256k1_fe_sqr(&x220, &x220);
  ------------------
  |  |   94|   288k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  110|   288k|    }
  111|  6.55k|    secp256k1_fe_mul(&x220, &x220, &x44);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  112|       |
  113|  6.55k|    x223 = x220;
  114|  26.2k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (114:15): [True: 19.6k, False: 6.55k]
  ------------------
  115|  19.6k|        secp256k1_fe_sqr(&x223, &x223);
  ------------------
  |  |   94|  19.6k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  116|  19.6k|    }
  117|  6.55k|    secp256k1_fe_mul(&x223, &x223, &x3);
  ------------------
  |  |   93|  6.55k|#  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|  6.55k|    t1 = x223;
  122|   157k|    for (j=0; j<23; j++) {
  ------------------
  |  Branch (122:15): [True: 150k, False: 6.55k]
  ------------------
  123|   150k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|   150k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  124|   150k|    }
  125|  6.55k|    secp256k1_fe_mul(&t1, &t1, &x22);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  126|  45.8k|    for (j=0; j<6; j++) {
  ------------------
  |  Branch (126:15): [True: 39.3k, False: 6.55k]
  ------------------
  127|  39.3k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  39.3k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  128|  39.3k|    }
  129|  6.55k|    secp256k1_fe_mul(&t1, &t1, &x2);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  130|  6.55k|    secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  131|  6.55k|    secp256k1_fe_sqr(r, &t1);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  132|       |
  133|       |    /* Check that a square root was actually calculated */
  134|       |
  135|  6.55k|    secp256k1_fe_sqr(&t1, r);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  136|  6.55k|    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|  6.55k|    return ret;
  146|  6.55k|}
secp256k1.c:secp256k1_fe_equal:
   25|  6.55k|SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
   26|  6.55k|    secp256k1_fe na;
   27|  6.55k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  344|  6.55k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   28|  6.55k|    SECP256K1_FE_VERIFY(b);
  ------------------
  |  |  344|  6.55k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   29|  6.55k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 1);
  ------------------
  |  |  348|  6.55k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   30|  6.55k|    SECP256K1_FE_VERIFY_MAGNITUDE(b, 31);
  ------------------
  |  |  348|  6.55k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   31|       |
   32|  6.55k|    secp256k1_fe_negate(&na, a, 1);
  ------------------
  |  |  211|  6.55k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   77|  6.55k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   78|  6.55k|    switch(42) { \
  |  |  |  |   79|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   80|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:9): [True: 0, False: 6.55k]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|            break; \
  |  |  |  |   82|  6.55k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:9): [True: 6.55k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   83|  6.55k|    } \
  |  |  |  |   84|  6.55k|    stmt; \
  |  |  |  |   85|  6.55k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   33|  6.55k|    secp256k1_fe_add(&na, b);
  ------------------
  |  |   92|  6.55k|#  define secp256k1_fe_add secp256k1_fe_impl_add
  ------------------
   34|  6.55k|    return secp256k1_fe_normalizes_to_zero(&na);
  ------------------
  |  |   81|  6.55k|#  define secp256k1_fe_normalizes_to_zero secp256k1_fe_impl_normalizes_to_zero
  ------------------
   35|  6.55k|}

secp256k1.c:secp256k1_ge_verify:
   78|  13.0k|static void secp256k1_ge_verify(const secp256k1_ge *a) {
   79|  13.0k|    SECP256K1_FE_VERIFY(&a->x);
  ------------------
  |  |  344|  13.0k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   80|  13.0k|    SECP256K1_FE_VERIFY(&a->y);
  ------------------
  |  |  344|  13.0k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   81|  13.0k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->x, SECP256K1_GE_X_MAGNITUDE_MAX);
  ------------------
  |  |  348|  13.0k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   82|  13.0k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->y, SECP256K1_GE_Y_MAGNITUDE_MAX);
  ------------------
  |  |  348|  13.0k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   83|  13.0k|    VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
   84|  13.0k|    (void)a;
   85|  13.0k|}
secp256k1.c:secp256k1_ge_is_in_correct_subgroup:
  886|  3.23k|static int secp256k1_ge_is_in_correct_subgroup(const secp256k1_ge* ge) {
  887|       |#ifdef EXHAUSTIVE_TEST_ORDER
  888|       |    secp256k1_gej out;
  889|       |    int i;
  890|       |    SECP256K1_GE_VERIFY(ge);
  891|       |
  892|       |    /* A very simple EC multiplication ladder that avoids a dependency on ecmult. */
  893|       |    secp256k1_gej_set_infinity(&out);
  894|       |    for (i = 0; i < 32; ++i) {
  895|       |        secp256k1_gej_double_var(&out, &out, NULL);
  896|       |        if ((((uint32_t)EXHAUSTIVE_TEST_ORDER) >> (31 - i)) & 1) {
  897|       |            secp256k1_gej_add_ge_var(&out, &out, ge, NULL);
  898|       |        }
  899|       |    }
  900|       |    return secp256k1_gej_is_infinity(&out);
  901|       |#else
  902|  3.23k|    SECP256K1_GE_VERIFY(ge);
  ------------------
  |  |  206|  3.23k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  903|       |
  904|  3.23k|    (void)ge;
  905|       |    /* The real secp256k1 group has cofactor 1, so the subgroup is the entire curve. */
  906|  3.23k|    return 1;
  907|  3.23k|#endif
  908|  3.23k|}
secp256k1.c:secp256k1_ge_to_bytes:
  937|  3.23k|static void secp256k1_ge_to_bytes(unsigned char *buf, const secp256k1_ge *a) {
  938|  3.23k|    secp256k1_ge_storage s;
  939|       |
  940|       |    /* We require that the secp256k1_ge_storage type is exactly 64 bytes.
  941|       |     * This is formally not guaranteed by the C standard, but should hold on any
  942|       |     * sane compiler in the real world. */
  943|  3.23k|    STATIC_ASSERT(sizeof(secp256k1_ge_storage) == 64);
  ------------------
  |  |   64|  3.23k|#define STATIC_ASSERT(expr) do { \
  |  |   65|  3.23k|    switch(0) { \
  |  |  ------------------
  |  |  |  Branch (65:12): [Folded - Ignored]
  |  |  ------------------
  |  |   66|  3.23k|        case 0: \
  |  |  ------------------
  |  |  |  Branch (66:9): [True: 3.23k, False: 0]
  |  |  ------------------
  |  |   67|  3.23k|        /* If expr evaluates to 0, we have two case labels "0", which is illegal. */ \
  |  |   68|  3.23k|        case /* ERROR: static assertion failed */ (expr): \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 0, False: 3.23k]
  |  |  ------------------
  |  |   69|  3.23k|        ; \
  |  |   70|  3.23k|    } \
  |  |   71|  3.23k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  944|  3.23k|    VERIFY_CHECK(!secp256k1_ge_is_infinity(a));
  945|  3.23k|    secp256k1_ge_to_storage(&s, a);
  946|  3.23k|    memcpy(buf, &s, 64);
  947|  3.23k|}
secp256k1.c:secp256k1_ge_to_storage:
  839|  3.23k|static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
  840|  3.23k|    secp256k1_fe x, y;
  841|  3.23k|    SECP256K1_GE_VERIFY(a);
  ------------------
  |  |  206|  3.23k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  842|  3.23k|    VERIFY_CHECK(!a->infinity);
  843|       |
  844|  3.23k|    x = a->x;
  845|  3.23k|    secp256k1_fe_normalize(&x);
  ------------------
  |  |   78|  3.23k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  846|  3.23k|    y = a->y;
  847|  3.23k|    secp256k1_fe_normalize(&y);
  ------------------
  |  |   78|  3.23k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  848|  3.23k|    secp256k1_fe_to_storage(&r->x, &x);
  ------------------
  |  |   96|  3.23k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  849|  3.23k|    secp256k1_fe_to_storage(&r->y, &y);
  ------------------
  |  |   96|  3.23k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  850|  3.23k|}
secp256k1.c:secp256k1_ge_set_xo_var:
  309|  6.55k|static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd) {
  310|  6.55k|    secp256k1_fe x2, x3;
  311|  6.55k|    int ret;
  312|  6.55k|    SECP256K1_FE_VERIFY(x);
  ------------------
  |  |  344|  6.55k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
  313|       |
  314|  6.55k|    r->x = *x;
  315|  6.55k|    secp256k1_fe_sqr(&x2, x);
  ------------------
  |  |   94|  6.55k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  316|  6.55k|    secp256k1_fe_mul(&x3, x, &x2);
  ------------------
  |  |   93|  6.55k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  317|  6.55k|    r->infinity = 0;
  318|  6.55k|    secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |  102|  6.55k|#  define secp256k1_fe_add_int secp256k1_fe_impl_add_int
  ------------------
                  secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |   73|  6.55k|#define SECP256K1_B 7
  ------------------
  319|  6.55k|    ret = secp256k1_fe_sqrt(&r->y, &x3);
  320|  6.55k|    secp256k1_fe_normalize_var(&r->y);
  ------------------
  |  |   80|  6.55k|#  define secp256k1_fe_normalize_var secp256k1_fe_impl_normalize_var
  ------------------
  321|  6.55k|    if (secp256k1_fe_is_odd(&r->y) != odd) {
  ------------------
  |  |   85|  6.55k|#  define secp256k1_fe_is_odd secp256k1_fe_impl_is_odd
  ------------------
  |  Branch (321:9): [True: 3.38k, False: 3.17k]
  ------------------
  322|  3.38k|        secp256k1_fe_negate(&r->y, &r->y, 1);
  ------------------
  |  |  211|  3.38k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   77|  3.38k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   78|  3.38k|    switch(42) { \
  |  |  |  |   79|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   80|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:9): [True: 0, False: 3.38k]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|            break; \
  |  |  |  |   82|  3.38k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:9): [True: 3.38k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   83|  3.38k|    } \
  |  |  |  |   84|  3.38k|    stmt; \
  |  |  |  |   85|  3.38k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  323|  3.38k|    }
  324|       |
  325|  6.55k|    SECP256K1_GE_VERIFY(r);
  ------------------
  |  |  206|  6.55k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  326|  6.55k|    return ret;
  327|  6.55k|}

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

secp256k1_xonly_pubkey_parse:
   22|  6.62k|int secp256k1_xonly_pubkey_parse(const secp256k1_context* ctx, secp256k1_xonly_pubkey *pubkey, const unsigned char *input32) {
   23|  6.62k|    secp256k1_ge pk;
   24|  6.62k|    secp256k1_fe x;
   25|       |
   26|  6.62k|    VERIFY_CHECK(ctx != NULL);
   27|  6.62k|    ARG_CHECK(pubkey != NULL);
  ------------------
  |  |   45|  6.62k|#define ARG_CHECK(cond) do { \
  |  |   46|  6.62k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  6.62k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 6.62k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  6.62k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
   28|  6.62k|    memset(pubkey, 0, sizeof(*pubkey));
   29|  6.62k|    ARG_CHECK(input32 != NULL);
  ------------------
  |  |   45|  6.62k|#define ARG_CHECK(cond) do { \
  |  |   46|  6.62k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  6.62k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 6.62k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  6.62k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
   30|       |
   31|  6.62k|    if (!secp256k1_fe_set_b32_limit(&x, input32)) {
  ------------------
  |  |   88|  6.62k|#  define secp256k1_fe_set_b32_limit secp256k1_fe_impl_set_b32_limit
  ------------------
  |  Branch (31:9): [True: 72, False: 6.55k]
  ------------------
   32|     72|        return 0;
   33|     72|    }
   34|  6.55k|    if (!secp256k1_ge_set_xo_var(&pk, &x, 0)) {
  ------------------
  |  Branch (34:9): [True: 3.32k, False: 3.23k]
  ------------------
   35|  3.32k|        return 0;
   36|  3.32k|    }
   37|  3.23k|    if (!secp256k1_ge_is_in_correct_subgroup(&pk)) {
  ------------------
  |  Branch (37:9): [True: 0, False: 3.23k]
  ------------------
   38|      0|        return 0;
   39|      0|    }
   40|  3.23k|    secp256k1_xonly_pubkey_save(pubkey, &pk);
   41|  3.23k|    return 1;
   42|  3.23k|}
secp256k1.c:secp256k1_xonly_pubkey_save:
   18|  3.23k|static SECP256K1_INLINE void secp256k1_xonly_pubkey_save(secp256k1_xonly_pubkey *pubkey, secp256k1_ge *ge) {
   19|  3.23k|    secp256k1_pubkey_save((secp256k1_pubkey *) pubkey, ge);
   20|  3.23k|}

secp256k1.c:secp256k1_pubkey_save:
  246|  3.23k|static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
  247|  3.23k|    secp256k1_ge_to_bytes(pubkey->data, ge);
  248|  3.23k|}

_Z20GetSizeOfCompactSizem:
  298|  1.39k|{
  299|  1.39k|    if (nSize < 253)             return sizeof(unsigned char);
  ------------------
  |  Branch (299:9): [True: 1.39k, False: 0]
  ------------------
  300|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
  ------------------
  |  Branch (300:14): [True: 0, False: 0]
  ------------------
  301|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())  return sizeof(unsigned char) + sizeof(unsigned int);
  ------------------
  |  Branch (301:14): [True: 0, False: 0]
  ------------------
  302|      0|    else                         return sizeof(unsigned char) + sizeof(uint64_t);
  303|  1.39k|}
_ZN12SizeComputer5writeE4SpanIKSt4byteE:
 1069|  78.4M|    {
 1070|  78.4M|        this->nSize += src.size();
 1071|  78.4M|    }
_ZN12SizeComputer4seekEm:
 1075|  1.39k|    {
 1076|  1.39k|        this->nSize += _nSize;
 1077|  1.39k|    }
_ZNK12SizeComputer4sizeEv:
 1086|  68.3k|    size_t size() const {
 1087|  68.3k|        return nSize;
 1088|  68.3k|    }
_Z16WriteCompactSizeR12SizeComputerm:
 1098|  1.39k|{
 1099|  1.39k|    s.seek(GetSizeOfCompactSize(nSize));
 1100|  1.39k|}
_ZNK20TransactionSerParamsclIRK12CTransactionEEDaOT_:
 1228|  82.2k|    {                                                                                    \
 1229|  82.2k|        return ParamsWrapper{*this, t};                                                  \
 1230|  82.2k|    }
_Z16GetSerializeSizeI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEmRKT_:
 1104|  66.9k|{
 1105|  66.9k|    return (SizeComputer() << t).size();
 1106|  66.9k|}
_ZN12SizeComputerlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
 1081|  66.9k|    {
 1082|  66.9k|        ::Serialize(*this, obj);
 1083|  66.9k|        return (*this);
 1084|  66.9k|    }
_Z9SerializeI12SizeComputer13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  66.9k|{
  754|  66.9k|    a.Serialize(os);
  755|  66.9k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI12SizeComputerEEvRT_:
 1199|  66.9k|    {
 1200|  66.9k|        ParamsStream ss{s, m_params};
 1201|  66.9k|        ::Serialize(ss, m_object);
 1202|  66.9k|    }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  66.9k|{
  754|  66.9k|    a.Serialize(os);
  755|  66.9k|}
_ZNK12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|  66.9k|    {
 1145|  66.9k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  66.9k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  66.9k|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsIjEERS3_RKT_:
 1133|   133k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
  262|  2.82M|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
   69|  2.82M|{
   70|  2.82M|    obj = htole32_internal(obj);
   71|  2.82M|    s.write(AsBytes(Span{&obj, 1}));
   72|  2.82M|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetStreamEv:
 1154|  78.4M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  78.4M|        } else {
 1158|  78.4M|            return m_substream;
 1159|  78.4M|        }
 1160|  78.4M|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  78.4M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  72.6k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  72.6k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  72.6k|    } else {
  859|  72.6k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  72.6k|    }
  861|  72.6k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  72.6k|{
  754|  72.6k|    a.Serialize(os);
  755|  72.6k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  482|  72.6k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  72.6k|    {
  663|  72.6k|        Formatter formatter;
  664|  72.6k|        WriteCompactSize(s, v.size());
  665|  1.34M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 1.34M, False: 72.6k]
  ------------------
  666|  1.34M|            formatter.Ser(s, elem);
  667|  1.34M|        }
  668|  72.6k|    }
_Z16WriteCompactSizeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
  309|  61.7M|{
  310|  61.7M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 61.7M, False: 38.3k]
  ------------------
  311|  61.7M|    {
  312|  61.7M|        ser_writedata8(os, nSize);
  313|  61.7M|    }
  314|  38.3k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 37.2k, False: 1.09k]
  ------------------
  315|  37.2k|    {
  316|  37.2k|        ser_writedata8(os, 253);
  317|  37.2k|        ser_writedata16(os, nSize);
  318|  37.2k|    }
  319|  1.09k|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 1.09k, False: 0]
  ------------------
  320|  1.09k|    {
  321|  1.09k|        ser_writedata8(os, 254);
  322|  1.09k|        ser_writedata32(os, nSize);
  323|  1.09k|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  61.7M|    return;
  330|  61.7M|}
_Z14ser_writedata8I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
   55|  61.7M|{
   56|  61.7M|    s.write(AsBytes(Span{&obj, 1}));
   57|  61.7M|}
_Z15ser_writedata16I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_t:
   59|  37.2k|{
   60|  37.2k|    obj = htole16_internal(obj);
   61|  37.2k|    s.write(AsBytes(Span{&obj, 1}));
   62|  37.2k|}
_Z15ser_writedata64I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
   79|  6.95M|{
   80|  6.95M|    obj = htole64_internal(obj);
   81|  6.95M|    s.write(AsBytes(Span{&obj, 1}));
   82|  6.95M|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  774|  1.34M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.34M|{
  754|  1.34M|    a.Serialize(os);
  755|  1.34M|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  1.34M|    {                                                                                               \
  223|  1.34M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.34M|        Ser(s, *this);                                                                              \
  225|  1.34M|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  1.34M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|  1.34M|    {
 1014|  1.34M|        ::SerializeMany(s, args...);
 1015|  1.34M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|  1.34M|{
  996|  1.34M|    (::Serialize(s, args), ...);
  997|  1.34M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  8.30M|{
  754|  8.30M|    a.Serialize(os);
  755|  8.30M|}
_ZNK7CScript9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  8.30M|    {                                                                                               \
  223|  8.30M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  8.30M|        Ser(s, *this);                                                                              \
  225|  8.30M|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  8.30M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERKT_RKT0_:
  151|  10.2M|{
  152|  10.2M|    static_assert(std::is_base_of_v<Out, In>);
  153|  10.2M|    return x;
  154|  10.2M|}
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|  8.30M|    {
 1014|  8.30M|        ::SerializeMany(s, args...);
 1015|  8.30M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|  8.30M|{
  996|  8.30M|    (::Serialize(s, args), ...);
  997|  8.30M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  8.30M|{
  812|  8.30M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  8.30M|        WriteCompactSize(os, v.size());
  814|  8.30M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 4.79M, False: 3.51M]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  8.30M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.34M|{
  754|  1.34M|    a.Serialize(os);
  755|  1.34M|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  1.34M|    {                                                                                               \
  223|  1.34M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.34M|        Ser(s, *this);                                                                              \
  225|  1.34M|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  1.34M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|  1.34M|    {
 1014|  1.34M|        ::SerializeMany(s, args...);
 1015|  1.34M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|  1.34M|{
  996|  1.34M|    (::Serialize(s, args), ...);
  997|  1.34M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|  1.34M|{
  754|  1.34M|    a.Serialize(os);
  755|  1.34M|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|  1.34M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|  1.34M|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsIhEERS3_RKT_:
 1133|  5.73k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
  258|  5.73k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  66.9k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  66.9k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  66.9k|    } else {
  859|  66.9k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  66.9k|    }
  861|  66.9k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  66.9k|{
  754|  66.9k|    a.Serialize(os);
  755|  66.9k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  482|  66.9k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  66.9k|    {
  663|  66.9k|        Formatter formatter;
  664|  66.9k|        WriteCompactSize(s, v.size());
  665|  6.95M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 6.95M, False: 66.9k]
  ------------------
  666|  6.95M|            formatter.Ser(s, elem);
  667|  6.95M|        }
  668|  66.9k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  774|  6.95M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  6.95M|{
  754|  6.95M|    a.Serialize(os);
  755|  6.95M|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  6.95M|    {                                                                                               \
  223|  6.95M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  6.95M|        Ser(s, *this);                                                                              \
  225|  6.95M|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  6.95M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1013|  6.95M|    {
 1014|  6.95M|        ::SerializeMany(s, args...);
 1015|  6.95M|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
  995|  6.95M|{
  996|  6.95M|    (::Serialize(s, args), ...);
  997|  6.95M|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_l:
  263|  6.95M|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1133|   533k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  846|   533k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|   533k|    } else {
  859|   533k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|   533k|    }
  861|   533k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  753|   533k|{
  754|   533k|    a.Serialize(os);
  755|   533k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  482|   533k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  662|   533k|    {
  663|   533k|        Formatter formatter;
  664|   533k|        WriteCompactSize(s, v.size());
  665|  52.8M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 52.8M, False: 533k]
  ------------------
  666|  52.8M|            formatter.Ser(s, elem);
  667|  52.8M|        }
  668|   533k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  774|  52.8M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  846|  52.8M|{
  847|  52.8M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  52.8M|        WriteCompactSize(os, v.size());
  849|  52.8M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 698k, False: 52.1M]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  52.8M|}
_ZNK20TransactionSerParamsclIR19CMutableTransactionEEDaOT_:
 1228|  4.20k|    {                                                                                    \
 1229|  4.20k|        return ParamsWrapper{*this, t};                                                  \
 1230|  4.20k|    }
_ZN12SizeComputerC2Ev:
 1066|  68.3k|    SizeComputer() = default;
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsEC2ES1_RKS2_:
 1127|  66.9k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  72.6k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ESA_:
  481|  90.0k|    explicit Wrapper(T obj) : m_object(obj) {}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  66.9k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ESA_:
  481|  82.2k|    explicit Wrapper(T obj) : m_object(obj) {}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|   533k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESB_:
  481|   744k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsEC2ES1_RKS2_:
 1127|  14.7k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z14ser_readdata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEjRT_:
  102|   220k|{
  103|   220k|    uint32_t obj;
  104|   220k|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|   220k|    return le32toh_internal(obj);
  106|   220k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE4readE4SpanISt4byteE:
 1136|  13.8M|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE9GetStreamEv:
 1154|  28.7M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  28.7M|        } else {
 1158|  28.7M|            return m_substream;
 1159|  28.7M|        }
 1160|  28.7M|    }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rj:
  277|   220k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_b:
  340|  12.7M|{
  341|  12.7M|    uint8_t chSize = ser_readdata8(is);
  342|  12.7M|    uint64_t nSizeRet = 0;
  343|  12.7M|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 12.7M, False: 3.14k]
  ------------------
  344|  12.7M|    {
  345|  12.7M|        nSizeRet = chSize;
  346|  12.7M|    }
  347|  3.14k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 2.58k, False: 564]
  ------------------
  348|  2.58k|    {
  349|  2.58k|        nSizeRet = ser_readdata16(is);
  350|  2.58k|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 8, False: 2.57k]
  ------------------
  351|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|  2.58k|    }
  353|    564|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 381, False: 183]
  ------------------
  354|    381|    {
  355|    381|        nSizeRet = ser_readdata32(is);
  356|    381|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 18, False: 363]
  ------------------
  357|     18|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    381|    }
  359|    183|    else
  360|    183|    {
  361|    183|        nSizeRet = ser_readdata64(is);
  362|    183|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 35, False: 148]
  ------------------
  363|     35|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    183|    }
  365|  12.7M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 12.7M, False: 102]
  |  Branch (365:24): [True: 64, False: 12.7M]
  ------------------
  366|     64|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     64|    }
  368|  12.7M|    return nSizeRet;
  369|  12.7M|}
_Z13ser_readdata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEhRT_:
   84|  12.7M|{
   85|  12.7M|    uint8_t obj;
   86|  12.7M|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  12.7M|    return obj;
   88|  12.7M|}
_Z14ser_readdata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEtRT_:
   90|  2.58k|{
   91|  2.58k|    uint16_t obj;
   92|  2.58k|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|  2.58k|    return le16toh_internal(obj);
   94|  2.58k|}
_Z14ser_readdata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_:
  114|   426k|{
  115|   426k|    uint64_t obj;
  116|   426k|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|   426k|    return le64toh_internal(obj);
  118|   426k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRjEERS3_OT_:
 1134|  7.78k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_OT_:
 1134|  5.10k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  866|  5.10k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  5.10k|    } else {
  879|  5.10k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  5.10k|    }
  881|  5.10k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  762|  5.10k|{
  763|  5.10k|    a.Unserialize(is);
  764|  5.10k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  5.10k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RT0_:
  672|  5.10k|    {
  673|  5.10k|        Formatter formatter;
  674|  5.10k|        v.clear();
  675|  5.10k|        size_t size = ReadCompactSize(s);
  676|  5.10k|        size_t allocated = 0;
  677|  8.90k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 3.79k, False: 5.10k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  3.79k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  3.79k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  3.79k|            v.reserve(allocated);
  684|   110k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 106k, False: 3.79k]
  ------------------
  685|   106k|                v.emplace_back();
  686|   106k|                formatter.Unser(s, v.back());
  687|   106k|            }
  688|  3.79k|        }
  689|  5.10k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RT0_:
  777|   106k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER5CTxInQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_ZN5CTxIn11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   106k|    {                                                                                               \
  229|   106k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   106k|        Unser(s, *this);                                                                            \
  231|   106k|    }
_ZN5CTxIn5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   106k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1033|   106k|    {
 1034|   106k|        ::UnserializeMany(s, args...);
 1035|   106k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1001|   106k|{
 1002|   106k|    (::Unserialize(s, args), ...);
 1003|   106k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER9COutPointQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_ZN9COutPoint11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   106k|    {                                                                                               \
  229|   106k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   106k|        Unser(s, *this);                                                                            \
  231|   106k|    }
_ZN9COutPoint5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   106k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1033|   106k|    {
 1034|   106k|        ::UnserializeMany(s, args...);
 1035|   106k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1001|   106k|{
 1002|   106k|    (::Unserialize(s, args), ...);
 1003|   106k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER7CScriptQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   532k|{
  763|   532k|    a.Unserialize(is);
  764|   532k|}
_ZN7CScript11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   532k|    {                                                                                               \
  229|   532k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   532k|        Unser(s, *this);                                                                            \
  231|   532k|    }
_ZN7CScript5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   532k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEEvRT_DpOT0_:
 1033|   532k|    {
 1034|   532k|        ::UnserializeMany(s, args...);
 1035|   532k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEvRT_DpOT0_:
 1001|   532k|{
 1002|   532k|    (::Unserialize(s, args), ...);
 1003|   532k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj28EhEvRT_R9prevectorIXT0_ET1_jiE:
  823|   532k|{
  824|   532k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  825|       |        // Limit size per read so bogus size value won't cause out of memory
  826|   532k|        v.clear();
  827|   532k|        unsigned int nSize = ReadCompactSize(is);
  828|   532k|        unsigned int i = 0;
  829|   777k|        while (i < nSize) {
  ------------------
  |  Branch (829:16): [True: 245k, False: 532k]
  ------------------
  830|   245k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  831|   245k|            v.resize_uninitialized(i + blk);
  832|   245k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  833|   245k|            i += blk;
  834|   245k|        }
  835|       |    } else {
  836|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  837|       |    }
  838|   532k|}
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERT_RT0_:
  145|  1.06M|{
  146|  1.06M|    static_assert(std::is_base_of_v<Out, In>);
  147|  1.06M|    return x;
  148|  1.06M|}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  5.10k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ES9_:
  481|  10.2k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRhEERS3_OT_:
 1134|    994|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rh:
  273|    994|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_OT_:
 1134|  3.85k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  866|  3.85k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  3.85k|    } else {
  879|  3.85k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  3.85k|    }
  881|  3.85k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  762|  3.85k|{
  763|  3.85k|    a.Unserialize(is);
  764|  3.85k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  3.85k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RT0_:
  672|  3.85k|    {
  673|  3.85k|        Formatter formatter;
  674|  3.85k|        v.clear();
  675|  3.85k|        size_t size = ReadCompactSize(s);
  676|  3.85k|        size_t allocated = 0;
  677|  6.61k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 2.76k, False: 3.85k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  2.76k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  2.76k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  2.76k|            v.reserve(allocated);
  684|   428k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 426k, False: 2.76k]
  ------------------
  685|   426k|                v.emplace_back();
  686|   426k|                formatter.Unser(s, v.back());
  687|   426k|            }
  688|  2.76k|        }
  689|  3.85k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RT0_:
  777|   426k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER6CTxOutQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   426k|{
  763|   426k|    a.Unserialize(is);
  764|   426k|}
_ZN6CTxOut11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   426k|    {                                                                                               \
  229|   426k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   426k|        Unser(s, *this);                                                                            \
  231|   426k|    }
_ZN6CTxOut5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   426k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEEvRT_DpOT0_:
 1033|   426k|    {
 1034|   426k|        ::UnserializeMany(s, args...);
 1035|   426k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEvRT_DpOT0_:
 1001|   426k|{
 1002|   426k|    (::Unserialize(s, args), ...);
 1003|   426k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rl:
  278|   426k|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  3.85k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ES9_:
  481|  7.71k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_OT_:
 1134|  73.6k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RNS6_IT0_T1_EE:
  866|  73.6k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  73.6k|    } else {
  879|  73.6k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  73.6k|    }
  881|  73.6k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ14UnserializableIT0_T_EEvRSJ_OSI_:
  762|  73.6k|{
  763|  73.6k|    a.Unserialize(is);
  764|  73.6k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  73.6k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RT0_:
  672|  73.6k|    {
  673|  73.6k|        Formatter formatter;
  674|  73.6k|        v.clear();
  675|  73.6k|        size_t size = ReadCompactSize(s);
  676|  73.6k|        size_t allocated = 0;
  677|  79.2k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 5.59k, False: 73.6k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  5.59k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  5.59k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  5.59k|            v.reserve(allocated);
  684|  12.1M|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 12.1M, False: 5.59k]
  ------------------
  685|  12.1M|                v.emplace_back();
  686|  12.1M|                formatter.Unser(s, v.back());
  687|  12.1M|            }
  688|  5.59k|        }
  689|  73.6k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RT0_:
  777|  12.1M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RNS5_6vectorIT0_T1_EE:
  866|  12.1M|{
  867|  12.1M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|  12.1M|        v.clear();
  870|  12.1M|        unsigned int nSize = ReadCompactSize(is);
  871|  12.1M|        unsigned int i = 0;
  872|  12.2M|        while (i < nSize) {
  ------------------
  |  Branch (872:16): [True: 119k, False: 12.1M]
  ------------------
  873|   119k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|   119k|            v.resize(i + blk);
  875|   119k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|   119k|            i += blk;
  877|   119k|        }
  878|       |    } else {
  879|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|       |    }
  881|  12.1M|}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_:
  497|  73.6k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESA_:
  481|   147k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK12ParamsStreamIR10DataStream20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|  14.7k|    {
 1145|  14.7k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  14.7k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  14.7k|    }
_Z14ser_readdata32I10DataStreamEjRT_:
  102|   220k|{
  103|   220k|    uint32_t obj;
  104|   220k|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|   220k|    return le32toh_internal(obj);
  106|   220k|}
_Z11UnserializeI10DataStreamEvRT_Rj:
  277|   220k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|  12.7M|{
  341|  12.7M|    uint8_t chSize = ser_readdata8(is);
  342|  12.7M|    uint64_t nSizeRet = 0;
  343|  12.7M|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 12.7M, False: 3.14k]
  ------------------
  344|  12.7M|    {
  345|  12.7M|        nSizeRet = chSize;
  346|  12.7M|    }
  347|  3.14k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 2.58k, False: 564]
  ------------------
  348|  2.58k|    {
  349|  2.58k|        nSizeRet = ser_readdata16(is);
  350|  2.58k|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 8, False: 2.57k]
  ------------------
  351|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|  2.58k|    }
  353|    564|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 381, False: 183]
  ------------------
  354|    381|    {
  355|    381|        nSizeRet = ser_readdata32(is);
  356|    381|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 18, False: 363]
  ------------------
  357|     18|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    381|    }
  359|    183|    else
  360|    183|    {
  361|    183|        nSizeRet = ser_readdata64(is);
  362|    183|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 35, False: 148]
  ------------------
  363|     35|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    183|    }
  365|  12.7M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 12.7M, False: 102]
  |  Branch (365:24): [True: 64, False: 12.7M]
  ------------------
  366|     64|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     64|    }
  368|  12.7M|    return nSizeRet;
  369|  12.7M|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|  12.7M|{
   85|  12.7M|    uint8_t obj;
   86|  12.7M|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  12.7M|    return obj;
   88|  12.7M|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|  2.58k|{
   91|  2.58k|    uint16_t obj;
   92|  2.58k|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|  2.58k|    return le16toh_internal(obj);
   94|  2.58k|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|   426k|{
  115|   426k|    uint64_t obj;
  116|   426k|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|   426k|    return le64toh_internal(obj);
  118|   426k|}
_Z11UnserializeI10DataStreamEvRT_Rh:
  273|    994|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_Z11UnserializeI10DataStreamhNSt3__19allocatorIhEEEvRT_RNS1_6vectorIT0_T1_EE:
  866|  12.1M|{
  867|  12.1M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|  12.1M|        v.clear();
  870|  12.1M|        unsigned int nSize = ReadCompactSize(is);
  871|  12.1M|        unsigned int i = 0;
  872|  12.2M|        while (i < nSize) {
  ------------------
  |  Branch (872:16): [True: 119k, False: 12.1M]
  ------------------
  873|   119k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|   119k|            v.resize(i + blk);
  875|   119k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|   119k|            i += blk;
  877|   119k|        }
  878|       |    } else {
  879|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|       |    }
  881|  12.1M|}
_Z11UnserializeI10DataStreamR9COutPointQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_ZN9COutPoint11UnserializeI10DataStreamEEvRT_:
  228|   106k|    {                                                                                               \
  229|   106k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   106k|        Unser(s, *this);                                                                            \
  231|   106k|    }
_ZN9COutPoint5UnserI10DataStreamEEvRT_RS_:
  180|   106k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1033|   106k|    {
 1034|   106k|        ::UnserializeMany(s, args...);
 1035|   106k|    }
_Z15UnserializeManyI10DataStreamJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1001|   106k|{
 1002|   106k|    (::Unserialize(s, args), ...);
 1003|   106k|}
_Z11UnserializeI10DataStreamR22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS5_OS4_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_Z11UnserializeI10DataStreamR13ParamsWrapperI20TransactionSerParams19CMutableTransactionEQ14UnserializableIT0_T_EEvRS7_OS6_:
  762|  4.20k|{
  763|  4.20k|    a.Unserialize(is);
  764|  4.20k|}
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionE11UnserializeI10DataStreamEEvRT_:
 1205|  4.20k|    {
 1206|  4.20k|        ParamsStream ss{s, m_params};
 1207|  4.20k|        ::Unserialize(ss, m_object);
 1208|  4.20k|    }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER19CMutableTransactionQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  4.20k|{
  763|  4.20k|    a.Unserialize(is);
  764|  4.20k|}
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionEC2ERKS0_RS1_:
 1195|  4.20k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  10.5k|{
  754|  10.5k|    a.Serialize(os);
  755|  10.5k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIjEERS3_RKT_:
 1133|  21.1k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j:
  262|   459k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j:
   69|   459k|{
   70|   459k|    obj = htole32_internal(obj);
   71|   459k|    s.write(AsBytes(Span{&obj, 1}));
   72|   459k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  14.8M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  12.1k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  12.1k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  12.1k|    } else {
  859|  12.1k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  12.1k|    }
  861|  12.1k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  12.1k|{
  754|  12.1k|    a.Serialize(os);
  755|  12.1k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  482|  12.1k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  12.1k|    {
  663|  12.1k|        Formatter formatter;
  664|  12.1k|        WriteCompactSize(s, v.size());
  665|   219k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 219k, False: 12.1k]
  ------------------
  666|   219k|            formatter.Ser(s, elem);
  667|   219k|        }
  668|  12.1k|    }
_Z16WriteCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m:
  309|  12.3M|{
  310|  12.3M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 12.3M, False: 6.72k]
  ------------------
  311|  12.3M|    {
  312|  12.3M|        ser_writedata8(os, nSize);
  313|  12.3M|    }
  314|  6.72k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 6.51k, False: 214]
  ------------------
  315|  6.51k|    {
  316|  6.51k|        ser_writedata8(os, 253);
  317|  6.51k|        ser_writedata16(os, nSize);
  318|  6.51k|    }
  319|    214|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 214, False: 0]
  ------------------
  320|    214|    {
  321|    214|        ser_writedata8(os, 254);
  322|    214|        ser_writedata32(os, nSize);
  323|    214|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  12.3M|    return;
  330|  12.3M|}
_Z14ser_writedata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h:
   55|  12.3M|{
   56|  12.3M|    s.write(AsBytes(Span{&obj, 1}));
   57|  12.3M|}
_Z15ser_writedata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_t:
   59|  6.51k|{
   60|  6.51k|    obj = htole16_internal(obj);
   61|  6.51k|    s.write(AsBytes(Span{&obj, 1}));
   62|  6.51k|}
_Z15ser_writedata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m:
   79|   973k|{
   80|   973k|    obj = htole64_internal(obj);
   81|   973k|    s.write(AsBytes(Span{&obj, 1}));
   82|   973k|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  774|   219k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   219k|{
  754|   219k|    a.Serialize(os);
  755|   219k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  222|   219k|    {                                                                                               \
  223|   219k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   219k|        Ser(s, *this);                                                                              \
  225|   219k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  178|   219k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|   219k|    {
 1014|   219k|        ::SerializeMany(s, args...);
 1015|   219k|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|   219k|{
  996|   219k|    (::Serialize(s, args), ...);
  997|   219k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   219k|{
  754|   219k|    a.Serialize(os);
  755|   219k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  222|   219k|    {                                                                                               \
  223|   219k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   219k|        Ser(s, *this);                                                                              \
  225|   219k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  178|   219k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|   219k|    {
 1014|   219k|        ::SerializeMany(s, args...);
 1015|   219k|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|   219k|{
  996|   219k|    (::Serialize(s, args), ...);
  997|   219k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|   219k|{
  754|   219k|    a.Serialize(os);
  755|   219k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|   219k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|   219k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.19M|{
  754|  1.19M|    a.Serialize(os);
  755|  1.19M|}
_ZNK7CScript9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  222|  1.19M|    {                                                                                               \
  223|  1.19M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.19M|        Ser(s, *this);                                                                              \
  225|  1.19M|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  178|  1.19M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|  1.19M|    {
 1014|  1.19M|        ::SerializeMany(s, args...);
 1015|  1.19M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|  1.19M|{
  996|  1.19M|    (::Serialize(s, args), ...);
  997|  1.19M|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  1.19M|{
  812|  1.19M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  1.19M|        WriteCompactSize(os, v.size());
  814|  1.19M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 702k, False: 490k]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  1.19M|}
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  12.1k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIhEERS3_RKT_:
 1133|  1.53k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h:
  258|  1.53k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  10.5k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  10.5k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  10.5k|    } else {
  859|  10.5k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  10.5k|    }
  861|  10.5k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  10.5k|{
  754|  10.5k|    a.Serialize(os);
  755|  10.5k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  482|  10.5k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  10.5k|    {
  663|  10.5k|        Formatter formatter;
  664|  10.5k|        WriteCompactSize(s, v.size());
  665|   973k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 973k, False: 10.5k]
  ------------------
  666|   973k|            formatter.Ser(s, elem);
  667|   973k|        }
  668|  10.5k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  774|   973k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   973k|{
  754|   973k|    a.Serialize(os);
  755|   973k|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  222|   973k|    {                                                                                               \
  223|   973k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   973k|        Ser(s, *this);                                                                              \
  225|   973k|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_:
  178|   973k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1013|   973k|    {
 1014|   973k|        ::SerializeMany(s, args...);
 1015|   973k|    }
_Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
  995|   973k|{
  996|   973k|    (::Serialize(s, args), ...);
  997|   973k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_l:
  263|   973k|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  10.5k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1133|   140k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  846|   140k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|   140k|    } else {
  859|   140k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|   140k|    }
  861|   140k|}
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  753|   140k|{
  754|   140k|    a.Serialize(os);
  755|   140k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  482|   140k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  662|   140k|    {
  663|   140k|        Formatter formatter;
  664|   140k|        WriteCompactSize(s, v.size());
  665|  10.9M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 10.9M, False: 140k]
  ------------------
  666|  10.9M|            formatter.Ser(s, elem);
  667|  10.9M|        }
  668|   140k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  774|  10.9M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  846|  10.9M|{
  847|  10.9M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  10.9M|        WriteCompactSize(os, v.size());
  849|  10.9M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 180k, False: 10.7M]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  10.9M|}
deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|   140k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStreamEvRT_Rl:
  278|   426k|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
_Z11UnserializeI10DataStreamR7CScriptQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|   532k|{
  763|   532k|    a.Unserialize(is);
  764|   532k|}
_ZN7CScript11UnserializeI10DataStreamEEvRT_:
  228|   532k|    {                                                                                               \
  229|   532k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   532k|        Unser(s, *this);                                                                            \
  231|   532k|    }
_ZN7CScript5UnserI10DataStreamEEvRT_RS_:
  180|   532k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR9prevectorILj28EhjiEEEEvRT_DpOT0_:
 1033|   532k|    {
 1034|   532k|        ::UnserializeMany(s, args...);
 1035|   532k|    }
_Z15UnserializeManyI10DataStreamJR9prevectorILj28EhjiEEEvRT_DpOT0_:
 1001|   532k|{
 1002|   532k|    (::Unserialize(s, args), ...);
 1003|   532k|}
_Z11UnserializeI10DataStreamLj28EhEvRT_R9prevectorIXT0_ET1_jiE:
  823|   532k|{
  824|   532k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  825|       |        // Limit size per read so bogus size value won't cause out of memory
  826|   532k|        v.clear();
  827|   532k|        unsigned int nSize = ReadCompactSize(is);
  828|   532k|        unsigned int i = 0;
  829|   777k|        while (i < nSize) {
  ------------------
  |  Branch (829:16): [True: 245k, False: 532k]
  ------------------
  830|   245k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  831|   245k|            v.resize_uninitialized(i + blk);
  832|   245k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  833|   245k|            i += blk;
  834|   245k|        }
  835|       |    } else {
  836|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  837|       |    }
  838|   532k|}
_Z11UnserializeI10DataStreamR5CTxInQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|   106k|{
  763|   106k|    a.Unserialize(is);
  764|   106k|}
_ZN5CTxIn11UnserializeI10DataStreamEEvRT_:
  228|   106k|    {                                                                                               \
  229|   106k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   106k|        Unser(s, *this);                                                                            \
  231|   106k|    }
_ZN5CTxIn5UnserI10DataStreamEEvRT_RS_:
  180|   106k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1033|   106k|    {
 1034|   106k|        ::UnserializeMany(s, args...);
 1035|   106k|    }
_Z15UnserializeManyI10DataStreamJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1001|   106k|{
 1002|   106k|    (::Unserialize(s, args), ...);
 1003|   106k|}
_Z11UnserializeI10DataStreamR6CTxOutQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|   426k|{
  763|   426k|    a.Unserialize(is);
  764|   426k|}
_ZN6CTxOut11UnserializeI10DataStreamEEvRT_:
  228|   426k|    {                                                                                               \
  229|   426k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   426k|        Unser(s, *this);                                                                            \
  231|   426k|    }
_ZN6CTxOut5UnserI10DataStreamEEvRT_RS_:
  180|   426k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJRlR7CScriptEEEvRT_DpOT0_:
 1033|   426k|    {
 1034|   426k|        ::UnserializeMany(s, args...);
 1035|   426k|    }
_Z15UnserializeManyI10DataStreamJRlR7CScriptEEvRT_DpOT0_:
 1001|   426k|{
 1002|   426k|    (::Unserialize(s, args), ...);
 1003|   426k|}
_Z11UnserializeI10DataStreamNSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEvRT_RNS2_IT0_T1_EE:
  866|  73.6k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  73.6k|    } else {
  879|  73.6k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  73.6k|    }
  881|  73.6k|}
_Z11UnserializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEQ14UnserializableIT0_T_EEvRSF_OSE_:
  762|  73.6k|{
  763|  73.6k|    a.Unserialize(is);
  764|  73.6k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI10DataStreamEEvRT_:
  483|  73.6k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10DataStreamNSt3__16vectorINS5_IhNS4_9allocatorIhEEEENS6_IS8_EEEEEEvRT_RT0_:
  672|  73.6k|    {
  673|  73.6k|        Formatter formatter;
  674|  73.6k|        v.clear();
  675|  73.6k|        size_t size = ReadCompactSize(s);
  676|  73.6k|        size_t allocated = 0;
  677|  79.2k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 5.59k, False: 73.6k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  5.59k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  5.59k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  5.59k|            v.reserve(allocated);
  684|  12.1M|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 12.1M, False: 5.59k]
  ------------------
  685|  12.1M|                v.emplace_back();
  686|  12.1M|                formatter.Unser(s, v.back());
  687|  12.1M|            }
  688|  5.59k|        }
  689|  73.6k|    };
_ZN16DefaultFormatter5UnserI10DataStreamNSt3__16vectorIhNS2_9allocatorIhEEEEEEvRT_RT0_:
  777|  12.1M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z15ser_writedata64I12SizeComputerEvRT_m:
   79|  1.39k|{
   80|  1.39k|    obj = htole64_internal(obj);
   81|  1.39k|    s.write(AsBytes(Span{&obj, 1}));
   82|  1.39k|}
_Z9SerializeI12SizeComputer6CTxOutQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|  1.39k|{
  754|  1.39k|    a.Serialize(os);
  755|  1.39k|}
_ZNK6CTxOut9SerializeI12SizeComputerEEvRT_:
  222|  1.39k|    {                                                                                               \
  223|  1.39k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.39k|        Ser(s, *this);                                                                              \
  225|  1.39k|    }                                                                                               \
_ZN6CTxOut3SerI12SizeComputerEEvRT_RKS_:
  178|  1.39k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJl7CScriptEEEvRT_DpRKT0_:
 1013|  1.39k|    {
 1014|  1.39k|        ::SerializeMany(s, args...);
 1015|  1.39k|    }
_Z13SerializeManyI12SizeComputerJl7CScriptEEvRT_DpRKT0_:
  995|  1.39k|{
  996|  1.39k|    (::Serialize(s, args), ...);
  997|  1.39k|}
_Z9SerializeI12SizeComputerEvRT_l:
  263|  1.39k|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_Z9SerializeI12SizeComputer7CScriptQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|  1.39k|{
  754|  1.39k|    a.Serialize(os);
  755|  1.39k|}
_ZNK7CScript9SerializeI12SizeComputerEEvRT_:
  222|  1.39k|    {                                                                                               \
  223|  1.39k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.39k|        Ser(s, *this);                                                                              \
  225|  1.39k|    }                                                                                               \
_ZN7CScript3SerI12SizeComputerEEvRT_RKS_:
  178|  1.39k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|  1.39k|    {
 1014|  1.39k|        ::SerializeMany(s, args...);
 1015|  1.39k|    }
_Z13SerializeManyI12SizeComputerJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|  1.39k|{
  996|  1.39k|    (::Serialize(s, args), ...);
  997|  1.39k|}
_Z9SerializeI12SizeComputerLj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  1.39k|{
  812|  1.39k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  1.39k|        WriteCompactSize(os, v.size());
  814|  1.39k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 1.39k, False: 0]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  1.39k|}
_Z11UnserializeI10DataStream5CTxInNSt3__19allocatorIS1_EEEvRT_RNS2_6vectorIT0_T1_EE:
  866|  5.10k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  5.10k|    } else {
  879|  5.10k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  5.10k|    }
  881|  5.10k|}
_Z11UnserializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|  5.10k|{
  763|  5.10k|    a.Unserialize(is);
  764|  5.10k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI10DataStreamEEvRT_:
  483|  5.10k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10DataStreamNSt3__16vectorI5CTxInNS4_9allocatorIS6_EEEEEEvRT_RT0_:
  672|  5.10k|    {
  673|  5.10k|        Formatter formatter;
  674|  5.10k|        v.clear();
  675|  5.10k|        size_t size = ReadCompactSize(s);
  676|  5.10k|        size_t allocated = 0;
  677|  8.90k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 3.79k, False: 5.10k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  3.79k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  3.79k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  3.79k|            v.reserve(allocated);
  684|   110k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 106k, False: 3.79k]
  ------------------
  685|   106k|                v.emplace_back();
  686|   106k|                formatter.Unser(s, v.back());
  687|   106k|            }
  688|  3.79k|        }
  689|  5.10k|    };
_ZN16DefaultFormatter5UnserI10DataStream5CTxInEEvRT_RT0_:
  777|   106k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  5.10k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStream6CTxOutNSt3__19allocatorIS1_EEEvRT_RNS2_6vectorIT0_T1_EE:
  866|  3.85k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  3.85k|    } else {
  879|  3.85k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  3.85k|    }
  881|  3.85k|}
_Z11UnserializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|  3.85k|{
  763|  3.85k|    a.Unserialize(is);
  764|  3.85k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI10DataStreamEEvRT_:
  483|  3.85k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10DataStreamNSt3__16vectorI6CTxOutNS4_9allocatorIS6_EEEEEEvRT_RT0_:
  672|  3.85k|    {
  673|  3.85k|        Formatter formatter;
  674|  3.85k|        v.clear();
  675|  3.85k|        size_t size = ReadCompactSize(s);
  676|  3.85k|        size_t allocated = 0;
  677|  6.61k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 2.76k, False: 3.85k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  2.76k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  2.76k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  2.76k|            v.reserve(allocated);
  684|   428k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 426k, False: 2.76k]
  ------------------
  685|   426k|                v.emplace_back();
  686|   426k|                formatter.Unser(s, v.back());
  687|   426k|            }
  688|  2.76k|        }
  689|  3.85k|    };
_ZN16DefaultFormatter5UnserI10DataStream6CTxOutEEvRT_RT0_:
  777|   426k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  3.85k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_flags.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_:
  497|  73.6k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  5.28k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  4.74k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|  70.0k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN13ParamsWrapperI20TransactionSerParamsK12CTransactionEC2ERKS0_RS2_:
 1195|  82.2k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z16GetSerializeSizeI6CTxOutEmRKT_:
 1104|  1.39k|{
 1105|  1.39k|    return (SizeComputer() << t).size();
 1106|  1.39k|}
_ZN12SizeComputerlsI6CTxOutEERS_RKT_:
 1081|  1.39k|    {
 1082|  1.39k|        ::Serialize(*this, obj);
 1083|  1.39k|        return (*this);
 1084|  1.39k|    }
_Z9SerializeI10DataStream13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  10.5k|{
  754|  10.5k|    a.Serialize(os);
  755|  10.5k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10DataStreamEEvRT_:
 1199|  10.5k|    {
 1200|  10.5k|        ParamsStream ss{s, m_params};
 1201|  10.5k|        ::Serialize(ss, m_object);
 1202|  10.5k|    }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsEC2ES1_RKS2_:
 1127|  4.74k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIjEERS3_RKT_:
 1133|  9.48k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
  262|   353k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
   69|   353k|{
   70|   353k|    obj = htole32_internal(obj);
   71|   353k|    s.write(AsBytes(Span{&obj, 1}));
   72|   353k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  10.7M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetStreamEv:
 1154|  10.7M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  10.7M|        } else {
 1158|  10.7M|            return m_substream;
 1159|  10.7M|        }
 1160|  10.7M|    }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  5.28k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  5.28k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  5.28k|    } else {
  859|  5.28k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  5.28k|    }
  861|  5.28k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  5.28k|{
  754|  5.28k|    a.Serialize(os);
  755|  5.28k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  5.28k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  5.28k|    {
  663|  5.28k|        Formatter formatter;
  664|  5.28k|        WriteCompactSize(s, v.size());
  665|   172k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 172k, False: 5.28k]
  ------------------
  666|   172k|            formatter.Ser(s, elem);
  667|   172k|        }
  668|  5.28k|    }
_Z16WriteCompactSizeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
  309|  9.07M|{
  310|  9.07M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 9.07M, False: 3.26k]
  ------------------
  311|  9.07M|    {
  312|  9.07M|        ser_writedata8(os, nSize);
  313|  9.07M|    }
  314|  3.26k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 3.12k, False: 140]
  ------------------
  315|  3.12k|    {
  316|  3.12k|        ser_writedata8(os, 253);
  317|  3.12k|        ser_writedata16(os, nSize);
  318|  3.12k|    }
  319|    140|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 140, False: 0]
  ------------------
  320|    140|    {
  321|    140|        ser_writedata8(os, 254);
  322|    140|        ser_writedata32(os, nSize);
  323|    140|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  9.07M|    return;
  330|  9.07M|}
_Z14ser_writedata8I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
   55|  9.07M|{
   56|  9.07M|    s.write(AsBytes(Span{&obj, 1}));
   57|  9.07M|}
_Z15ser_writedata16I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_t:
   59|  3.12k|{
   60|  3.12k|    obj = htole16_internal(obj);
   61|  3.12k|    s.write(AsBytes(Span{&obj, 1}));
   62|  3.12k|}
_Z15ser_writedata64I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
   79|   626k|{
   80|   626k|    obj = htole64_internal(obj);
   81|   626k|    s.write(AsBytes(Span{&obj, 1}));
   82|   626k|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  774|   172k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   172k|{
  754|   172k|    a.Serialize(os);
  755|   172k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   172k|    {                                                                                               \
  223|   172k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   172k|        Ser(s, *this);                                                                              \
  225|   172k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   172k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|   172k|    {
 1014|   172k|        ::SerializeMany(s, args...);
 1015|   172k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|   172k|{
  996|   172k|    (::Serialize(s, args), ...);
  997|   172k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   172k|{
  754|   172k|    a.Serialize(os);
  755|   172k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   172k|    {                                                                                               \
  223|   172k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   172k|        Ser(s, *this);                                                                              \
  225|   172k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   172k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|   172k|    {
 1014|   172k|        ::SerializeMany(s, args...);
 1015|   172k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|   172k|{
  996|   172k|    (::Serialize(s, args), ...);
  997|   172k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|   172k|{
  754|   172k|    a.Serialize(os);
  755|   172k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|   172k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|   172k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   798k|{
  754|   798k|    a.Serialize(os);
  755|   798k|}
_ZNK7CScript9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   798k|    {                                                                                               \
  223|   798k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   798k|        Ser(s, *this);                                                                              \
  225|   798k|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   798k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|   798k|    {
 1014|   798k|        ::SerializeMany(s, args...);
 1015|   798k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|   798k|{
  996|   798k|    (::Serialize(s, args), ...);
  997|   798k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|   798k|{
  812|   798k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|   798k|        WriteCompactSize(os, v.size());
  814|   798k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 426k, False: 372k]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|   798k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIhEERS3_RKT_:
 1133|    539|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
  258|    539|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  4.74k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  4.74k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  4.74k|    } else {
  859|  4.74k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  4.74k|    }
  861|  4.74k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  4.74k|{
  754|  4.74k|    a.Serialize(os);
  755|  4.74k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  4.74k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  4.74k|    {
  663|  4.74k|        Formatter formatter;
  664|  4.74k|        WriteCompactSize(s, v.size());
  665|   626k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 626k, False: 4.74k]
  ------------------
  666|   626k|            formatter.Ser(s, elem);
  667|   626k|        }
  668|  4.74k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  774|   626k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   626k|{
  754|   626k|    a.Serialize(os);
  755|   626k|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   626k|    {                                                                                               \
  223|   626k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   626k|        Ser(s, *this);                                                                              \
  225|   626k|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   626k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1013|   626k|    {
 1014|   626k|        ::SerializeMany(s, args...);
 1015|   626k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
  995|   626k|{
  996|   626k|    (::Serialize(s, args), ...);
  997|   626k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_l:
  263|   626k|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1133|  70.0k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  846|  70.0k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  70.0k|    } else {
  859|  70.0k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  70.0k|    }
  861|  70.0k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  753|  70.0k|{
  754|  70.0k|    a.Serialize(os);
  755|  70.0k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  70.0k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  662|  70.0k|    {
  663|  70.0k|        Formatter formatter;
  664|  70.0k|        WriteCompactSize(s, v.size());
  665|  8.19M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 8.19M, False: 70.0k]
  ------------------
  666|  8.19M|            formatter.Ser(s, elem);
  667|  8.19M|        }
  668|  70.0k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  774|  8.19M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  846|  8.19M|{
  847|  8.19M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  8.19M|        WriteCompactSize(os, v.size());
  849|  8.19M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 113k, False: 8.08M]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  8.19M|}
_ZNK12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|  4.74k|    {
 1145|  4.74k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  4.74k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  4.74k|    }
_Z9SerializeI10HashWriter13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  4.74k|{
  754|  4.74k|    a.Serialize(os);
  755|  4.74k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10HashWriterEEvRT_:
 1199|  4.74k|    {
 1200|  4.74k|        ParamsStream ss{s, m_params};
 1201|  4.74k|        ::Serialize(ss, m_object);
 1202|  4.74k|    }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  4.74k|{
  754|  4.74k|    a.Serialize(os);
  755|  4.74k|}

_Z9UCharCastPKh:
  285|   129k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
_Z9UCharCastPKSt4byte:
  287|  10.7M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|  89.2M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  10.9M|    constexpr C* data() const noexcept { return m_data; }
_Z13UCharSpanCastIKSt4byteE4SpanINSt3__114remove_pointerIDTcl9UCharCastcldtfp_4dataEEEE4typeEES2_IT_E:
  293|  10.5k|template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
_Z13MakeUCharSpanIRK4SpanIKSt4byteEEDTcl13UCharSpanCasttlS0_clsr3stdE7forwardIT_Efp_EEEEOS6_:
  296|  10.5k|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZNK4SpanIKcE5beginEv:
  175|   553k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKcE3endEv:
  176|   553k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIKhE4sizeEv:
  187|  16.2M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|  13.5M|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|  13.5M|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|   136k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|   109M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  8.94M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE5firstEm:
  206|  37.6k|    {
  207|  37.6k|        ASSERT_IF_DEBUG(size() >= count);
  208|  37.6k|        return Span<C>(m_data, count);
  209|  37.6k|    }
_ZNK4SpanISt4byteE4sizeEv:
  187|  83.3M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  27.7M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEm:
  196|  2.29M|    {
  197|  2.29M|        ASSERT_IF_DEBUG(size() >= offset);
  198|  2.29M|        return Span<C>(m_data + offset, m_size - offset);
  199|  2.29M|    }
_ZNK4SpanIKSt4byteE5beginEv:
  175|  14.8M|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE3endEv:
  176|  14.8M|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanISt4byteE7subspanEm:
  196|  3.57k|    {
  197|  3.57k|        ASSERT_IF_DEBUG(size() >= offset);
  198|  3.57k|        return Span<C>(m_data + offset, m_size - offset);
  199|  3.57k|    }
_Z13UCharSpanCastIKhE4SpanINSt3__114remove_pointerIDTcl9UCharCastcldtfp_4dataEEEE4typeEES1_IT_E:
  293|   129k|template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
_Z13MakeUCharSpanIRK4SpanIKhEEDTcl13UCharSpanCasttlS0_clsr3stdE7forwardIT_Efp_EEEEOS5_:
  296|  37.6k|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZNK4SpanIKhE10size_bytesEv:
  188|  8.66M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|  8.66M|{
  260|  8.66M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  8.66M|}
_Z12MakeByteSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanIKSt4byteEOT_:
  270|   991k|{
  271|   991k|    return AsBytes(Span{std::forward<V>(v)});
  272|   991k|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|  12.0M|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|   104M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|   768k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm8EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  7.15k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIjE4dataEv:
  174|  4.08M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  4.08M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|  3.64M|{
  260|  3.64M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  3.64M|}
_ZNK4SpanIhE10size_bytesEv:
  188|   109M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  83.2M|{
  260|  83.2M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  83.2M|}
_ZNK4SpanItE4dataEv:
  174|  52.0k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|  52.0k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|  46.9k|{
  260|  46.9k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  46.9k|}
_ZNK4SpanImE4dataEv:
  174|  9.40M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|  9.40M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|  8.55M|{
  260|  8.55M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  8.55M|}
_Z12MakeByteSpanIRK9prevectorILj28EhjiEE4SpanIKSt4byteEOT_:
  270|  5.92M|{
  271|  5.92M|    return AsBytes(Span{std::forward<V>(v)});
  272|  5.92M|}
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  2.47M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  27.7M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  26.4M|{
  265|  26.4M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  26.4M|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|   109M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|  5.16k|{
  265|  5.16k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  5.16k|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|  52.0k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|   441k|{
  265|   441k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   441k|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  4.08M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|   852k|{
  265|   852k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   852k|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|  9.40M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKcEC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanISA_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISC_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISC_EE4sizeEEmEE5valueEDnE4typeE:
  172|   553k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__14spanIS0_Lm18446744073709551615EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  8.40k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2INSt3__15arrayIS0_Lm32EEEEERKT_NS4_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  172|  7.15k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.73M|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I9prevectorILj28EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|  5.92M|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|   212k|{
  276|   212k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|   212k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|   212k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7uint256EERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  4.20k|        : m_data(other.data()), m_size(other.size()){}
_Z13MakeUCharSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEEDTcl13UCharSpanCasttl4Spanclsr3stdE7forwardIT_Efp_EEEEOS8_:
  296|  91.9k|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|   106k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I7uint160EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  37.6k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi65EEERAT__S0_:
  151|  37.6k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2I7CPubKeyEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  34.0k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7CScriptEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.62M|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|   244k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZNK4SpanISt4byteE5beginEv:
  175|  14.3k|    constexpr C* begin() const noexcept { return m_data; }
_ZN4SpanIKSt4byteEC2I10DataStreamEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|  10.5k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKhEixEm:
  191|  2.39M|    {
  192|  2.39M|        ASSERT_IF_DEBUG(size() > pos);
  193|  2.39M|        return m_data[pos];
  194|  2.39M|    }
_ZN4SpanIKhEC2ILi33EEERAT__S0_:
  151|  3.23k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_Z12MakeByteSpanIRK7uint256E4SpanIKSt4byteEOT_:
  270|  4.20k|{
  271|  4.20k|    return AsBytes(Span{std::forward<V>(v)});
  272|  4.20k|}
_Z12MakeByteSpanIR7uint256E4SpanIKSt4byteEOT_:
  270|  7.15k|{
  271|  7.15k|    return AsBytes(Span{std::forward<V>(v)});
  272|  7.15k|}
_ZNK4SpanISt4byteE5emptyEv:
  189|  28.6k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm64EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  10.7k|        : m_data(other.data()), m_size(other.size()){}

_ZN10DataStreamC2E4SpanIKhE:
  165|  8.40k|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|  8.40k|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZNK10DataStream4sizeEv:
  181|  10.5k|    size_type size() const                           { return vch.size() - m_read_pos; }
_ZN10DataStream4dataEv:
  188|  10.5k|    value_type* data()                               { return vch.data() + m_read_pos; }
_ZN10DataStream4readE4SpanISt4byteE:
  219|  27.7M|    {
  220|  27.7M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 27.7M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  27.7M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  27.7M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 27.7M]
  |  Branch (224:43): [True: 954, False: 27.7M]
  ------------------
  225|    954|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    954|        }
  227|  27.7M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  27.7M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 5.14k, False: 27.7M]
  ------------------
  229|  5.14k|            m_read_pos = 0;
  230|  5.14k|            vch.clear();
  231|  5.14k|            return;
  232|  5.14k|        }
  233|  27.7M|        m_read_pos = next_read_pos.value();
  234|  27.7M|    }
_ZN10DataStream5writeE4SpanIKSt4byteE:
  252|  14.8M|    {
  253|       |        // Write to the end of the buffer
  254|  14.8M|        vch.insert(vch.end(), src.begin(), src.end());
  255|  14.8M|    }
_ZN10DataStreamC2Ev:
  164|  10.5k|    explicit DataStream() = default;
_ZN10DataStreamrsIRhEERS_OT_:
  266|    994|    {
  267|    994|        ::Unserialize(*this, obj);
  268|    994|        return (*this);
  269|    994|    }
_ZN10DataStreamrsI13ParamsWrapperI20TransactionSerParams19CMutableTransactionEEERS_OT_:
  266|  4.20k|    {
  267|  4.20k|        ::Unserialize(*this, obj);
  268|  4.20k|        return (*this);
  269|  4.20k|    }
_ZN10DataStreamrsIRjEERS_OT_:
  266|  7.78k|    {
  267|  7.78k|        ::Unserialize(*this, obj);
  268|  7.78k|        return (*this);
  269|  7.78k|    }
_ZN10DataStreamrsIRNSt3__16vectorI5CTxInNS1_9allocatorIS3_EEEEEERS_OT_:
  266|  5.10k|    {
  267|  5.10k|        ::Unserialize(*this, obj);
  268|  5.10k|        return (*this);
  269|  5.10k|    }
_ZN10DataStreamrsIRNSt3__16vectorI6CTxOutNS1_9allocatorIS3_EEEEEERS_OT_:
  266|  3.85k|    {
  267|  3.85k|        ::Unserialize(*this, obj);
  268|  3.85k|        return (*this);
  269|  3.85k|    }
_ZN10DataStreamrsIRNSt3__16vectorINS2_IhNS1_9allocatorIhEEEENS3_IS5_EEEEEERS_OT_:
  266|  73.6k|    {
  267|  73.6k|        ::Unserialize(*this, obj);
  268|  73.6k|        return (*this);
  269|  73.6k|    }
_ZN10DataStreamlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
  259|  10.5k|    {
  260|  10.5k|        ::Serialize(*this, obj);
  261|  10.5k|        return (*this);
  262|  10.5k|    }

_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EE10deallocateEPS7_m:
  325|  3.97k|    {
  326|  3.97k|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  327|  3.97k|    }
_ZN12PoolResourceILm144ELm8EE16IsFreeListUsableEmm:
  135|  14.8k|    {
  136|  14.8k|        return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES;
  ------------------
  |  Branch (136:16): [True: 14.8k, False: 0]
  |  Branch (136:49): [True: 14.8k, False: 0]
  ------------------
  137|  14.8k|    }
_ZN12PoolResourceILm144ELm8EE17NumElemAlignBytesEm:
  127|  18.4k|    {
  128|  18.4k|        return (bytes + ELEM_ALIGN_BYTES - 1) / ELEM_ALIGN_BYTES + (bytes == 0);
  129|  18.4k|    }
_ZN12PoolResourceILm144ELm8EE10DeallocateEPvmm:
  242|  7.42k|    {
  243|  7.42k|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (243:13): [True: 7.42k, False: 0]
  ------------------
  244|  7.42k|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  245|       |            // put the memory block into the linked list. We can placement construct the FreeList
  246|       |            // into the memory since we can be sure the alignment is correct.
  247|  7.42k|            PlacementAddToList(p, m_free_lists[num_alignments]);
  248|  7.42k|        } else {
  249|       |            // Can't use the pool => forward deallocation to ::operator delete().
  250|      0|            ::operator delete (p, std::align_val_t{alignment});
  251|      0|        }
  252|  7.42k|    }
_ZN12PoolResourceILm144ELm8EE18PlacementAddToListEPvRPNS0_8ListNodeE:
  143|  7.42k|    {
  144|  7.42k|        node = new (p) ListNode{node};
  145|  7.42k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EE10deallocateEPSB_m:
  325|  3.44k|    {
  326|  3.44k|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  327|  3.44k|    }
_ZN12PoolResourceILm144ELm8EE8ListNodeC2EPS1_:
   81|  7.42k|        explicit ListNode(ListNode* next) : m_next(next) {}
_ZN12PoolResourceILm144ELm8EED2Ev:
  201|  3.57k|    {
  202|  3.57k|        for (std::byte* chunk : m_allocated_chunks) {
  ------------------
  |  Branch (202:31): [True: 3.57k, False: 3.57k]
  ------------------
  203|  3.57k|            std::destroy(chunk, chunk + m_chunk_size_bytes);
  204|  3.57k|            ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES});
  205|  3.57k|        }
  206|  3.57k|    }
_ZN12PoolResourceILm144ELm8EEC2Ev:
  187|  3.57k|    PoolResource() : PoolResource(262144) {}
_ZN12PoolResourceILm144ELm8EEC2Em:
  178|  3.57k|        : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES)
  179|  3.57k|    {
  180|  3.57k|        assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES);
  181|  3.57k|        AllocateChunk();
  182|  3.57k|    }
_ZN12PoolResourceILm144ELm8EE13AllocateChunkEv:
  154|  3.57k|    {
  155|       |        // if there is still any available memory left, put it into the freelist.
  156|  3.57k|        size_t remaining_available_bytes = std::distance(m_available_memory_it, m_available_memory_end);
  157|  3.57k|        if (0 != remaining_available_bytes) {
  ------------------
  |  Branch (157:13): [True: 0, False: 3.57k]
  ------------------
  158|      0|            PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]);
  159|      0|        }
  160|       |
  161|  3.57k|        void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES});
  162|  3.57k|        m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes];
  163|  3.57k|        m_available_memory_end = m_available_memory_it + m_chunk_size_bytes;
  164|  3.57k|        m_allocated_chunks.emplace_back(m_available_memory_it);
  165|  3.57k|    }
_ZN13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm144ELm8EEC2EP12PoolResourceILm144ELm8EE:
  291|  3.57k|        : m_resource(resource)
  292|  3.57k|    {
  293|  3.57k|    }
_ZN13PoolAllocatorINSt3__117__hash_value_typeI9COutPoint16CCoinsCacheEntryEELm144ELm8EEC2INS0_4pairIKS2_S3_EEEERKS_IT_Lm144ELm8EE:
  300|  3.57k|        : m_resource(other.resource())
  301|  3.57k|    {
  302|  3.57k|    }
_ZNK13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm144ELm8EE8resourceEv:
  330|  3.57k|    {
  331|  3.57k|        return m_resource;
  332|  3.57k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EEC2IS6_EERKS_IT_Lm144ELm8EE:
  300|  3.57k|        : m_resource(other.resource())
  301|  3.57k|    {
  302|  3.57k|    }
_ZNK13PoolAllocatorINSt3__117__hash_value_typeI9COutPoint16CCoinsCacheEntryEELm144ELm8EE8resourceEv:
  330|  7.15k|    {
  331|  7.15k|        return m_resource;
  332|  7.15k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EEC2IS5_EERKS_IT_Lm144ELm8EE:
  300|  3.57k|        : m_resource(other.resource())
  301|  3.57k|    {
  302|  3.57k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EE8allocateEm:
  317|  3.44k|    {
  318|  3.44k|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  319|  3.44k|    }
_ZN12PoolResourceILm144ELm8EE8AllocateEmm:
  213|  7.42k|    {
  214|  7.42k|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (214:13): [True: 7.42k, False: 0]
  ------------------
  215|  7.42k|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  216|  7.42k|            if (nullptr != m_free_lists[num_alignments]) {
  ------------------
  |  Branch (216:17): [True: 525, False: 6.89k]
  ------------------
  217|       |                // we've already got data in the pool's freelist, unlink one element and return the pointer
  218|       |                // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as
  219|       |                // uninitialized memory.
  220|    525|                return std::exchange(m_free_lists[num_alignments], m_free_lists[num_alignments]->m_next);
  221|    525|            }
  222|       |
  223|       |            // freelist is empty: get one allocation from allocated chunk memory.
  224|  6.89k|            const std::ptrdiff_t round_bytes = static_cast<std::ptrdiff_t>(num_alignments * ELEM_ALIGN_BYTES);
  225|  6.89k|            if (round_bytes > m_available_memory_end - m_available_memory_it) {
  ------------------
  |  Branch (225:17): [True: 0, False: 6.89k]
  ------------------
  226|       |                // slow path, only happens when a new chunk needs to be allocated
  227|      0|                AllocateChunk();
  228|      0|            }
  229|       |
  230|       |            // Make sure we use the right amount of bytes for that freelist (might be rounded up),
  231|  6.89k|            return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes);
  232|  7.42k|        }
  233|       |
  234|       |        // Can't use the pool => use operator new()
  235|      0|        return ::operator new (bytes, std::align_val_t{alignment});
  236|  7.42k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EE8allocateEm:
  317|  3.97k|    {
  318|  3.97k|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  319|  3.97k|    }

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

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

_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  247|  11.3k|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  177|  11.3k|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|  11.3k|    {
  179|  11.3k|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 11.3k]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|  11.3k|        else
  182|  11.3k|            Enter(pszName, pszFile, nLine);
  183|  11.3k|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   75|  11.3k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   76|  11.3k|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  157|  11.3k|    {
  158|  11.3k|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  159|       |#ifdef DEBUG_LOCKCONTENTION
  160|       |        if (Base::try_lock()) return;
  161|       |        LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK);
  162|       |#endif
  163|  11.3k|        Base::lock();
  164|  11.3k|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  197|  11.3k|    {
  198|  11.3k|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 11.3k, False: 0]
  ------------------
  199|  11.3k|            LeaveCritical();
  200|  11.3k|    }

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

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

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

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

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

_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|  6.58M|        {
  542|  6.58M|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|  6.58M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  543|  6.58M|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|  6.58M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  544|  6.58M|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|  6.58M|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|  4.51M|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|   973k|{
  579|   973k|    int i = 0;
  580|  2.92M|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 2.92M, False: 0]
  |  Branch (580:24): [True: 1.94M, False: 973k]
  ------------------
  581|  1.94M|        i = 10*i + (*c - '0');
  582|   973k|    return i;
  583|   973k|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|  5.61M|{
  594|  5.61M|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 5.61M, False: 0]
  |  Branch (594:22): [True: 0, False: 5.61M]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|  5.61M|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 5.61M]
  ------------------
  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.61M|    else {
  618|  5.61M|        return false;
  619|  5.61M|    }
  620|      0|    return true;
  621|  5.61M|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|  11.1M|{
  630|  11.1M|    const char* c = fmt;
  631|  28.8M|    for (;; ++c) {
  632|  28.8M|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 4.51M, False: 24.3M]
  ------------------
  633|  4.51M|            out.write(fmt, c - fmt);
  634|  4.51M|            return c;
  635|  4.51M|        }
  636|  24.3M|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 6.58M, False: 17.7M]
  ------------------
  637|  6.58M|            out.write(fmt, c - fmt);
  638|  6.58M|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 6.58M, False: 0]
  ------------------
  639|  6.58M|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|  28.8M|    }
  644|  11.1M|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|  6.58M|{
  686|  6.58M|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|  6.58M|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  687|       |    // Reset stream state to defaults.
  688|  6.58M|    out.width(0);
  689|  6.58M|    out.precision(6);
  690|  6.58M|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|  6.58M|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|  6.58M|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|  6.58M|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|  6.58M|    bool precisionSet = false;
  696|  6.58M|    bool widthSet = false;
  697|  6.58M|    int widthExtra = 0;
  698|  6.58M|    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.58M|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 6.58M, False: 0]
  |  Branch (702:22): [True: 973k, False: 5.61M]
  ------------------
  703|   973k|        const char tmpc = *c;
  704|   973k|        int value = parseIntAndAdvance(c);
  705|   973k|        if (*c == '$') {
  ------------------
  |  Branch (705:13): [True: 0, False: 973k]
  ------------------
  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|   973k|        else if (positionalMode) {
  ------------------
  |  Branch (714:18): [True: 0, False: 973k]
  ------------------
  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|   973k|        else {
  718|   973k|            if (tmpc == '0') {
  ------------------
  |  Branch (718:17): [True: 973k, False: 0]
  ------------------
  719|       |                // Use internal padding so that numeric values are
  720|       |                // formatted correctly, eg -00010 rather than 000-10
  721|   973k|                out.fill('0');
  722|   973k|                out.setf(std::ios::internal, std::ios::adjustfield);
  723|   973k|            }
  724|   973k|            if (value != 0) {
  ------------------
  |  Branch (724:17): [True: 973k, False: 0]
  ------------------
  725|       |                // Nonzero value means that we parsed width.
  726|   973k|                widthSet = true;
  727|   973k|                out.width(value);
  728|   973k|            }
  729|   973k|        }
  730|   973k|    }
  731|  5.61M|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 5.61M]
  ------------------
  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.58M|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 5.61M, False: 973k]
  ------------------
  736|       |        // Parse flags
  737|  5.61M|        for (;; ++c) {
  738|  5.61M|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 5.61M]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 5.61M]
  ------------------
  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.61M]
  ------------------
  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.61M]
  ------------------
  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.61M]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|  5.61M|                default:
  ------------------
  |  Branch (765:17): [True: 5.61M, False: 0]
  ------------------
  766|  5.61M|                    break;
  767|  5.61M|            }
  768|  5.61M|            break;
  769|  5.61M|        }
  770|       |        // Parse width
  771|  5.61M|        int width = 0;
  772|  5.61M|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|  5.61M|                                         args, argIndex, numArgs);
  774|  5.61M|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 5.61M]
  ------------------
  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.61M|    }
  784|       |    // 3) Parse precision
  785|  6.58M|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 6.58M]
  ------------------
  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.58M|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 6.58M]
  |  Branch (797:25): [True: 0, False: 6.58M]
  |  Branch (797:38): [True: 0, False: 6.58M]
  ------------------
  798|  6.58M|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 6.58M]
  |  Branch (798:25): [True: 0, False: 6.58M]
  |  Branch (798:38): [True: 0, False: 6.58M]
  ------------------
  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.58M|    bool intConversion = false;
  805|  6.58M|    switch (*c) {
  806|  5.39M|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 215k, False: 6.37M]
  |  Branch (806:19): [True: 5.17M, False: 1.41M]
  |  Branch (806:29): [True: 7.28k, False: 6.57M]
  ------------------
  807|  5.39M|            out.setf(std::ios::dec, std::ios::basefield);
  808|  5.39M|            intConversion = true;
  809|  5.39M|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|      0|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 0, False: 6.58M]
  |  Branch (817:19): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 6.58M]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 6.58M]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|  1.18M|        case 's':
  ------------------
  |  Branch (857:9): [True: 1.18M, False: 5.39M]
  ------------------
  858|  1.18M|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 1.18M]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|  1.18M|            out.setf(std::ios::boolalpha);
  862|  1.18M|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 6.58M]
  ------------------
  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.58M]
  ------------------
  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.58M]
  ------------------
  872|      0|            break;
  873|  6.58M|    }
  874|  6.58M|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 5.39M, False: 1.18M]
  |  Branch (874:26): [True: 0, False: 5.39M]
  |  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.58M|    return c+1;
  884|  6.58M|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|  4.51M|{
  892|       |    // Saved stream state
  893|  4.51M|    std::streamsize origWidth = out.width();
  894|  4.51M|    std::streamsize origPrecision = out.precision();
  895|  4.51M|    std::ios::fmtflags origFlags = out.flags();
  896|  4.51M|    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.51M|    bool positionalMode = false;
  901|  4.51M|    int argIndex = 0;
  902|  11.1M|    while (true) {
  ------------------
  |  Branch (902:12): [Folded - Ignored]
  ------------------
  903|  11.1M|        fmt = printFormatStringLiteral(out, fmt);
  904|  11.1M|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 4.51M, False: 6.58M]
  ------------------
  905|  4.51M|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 4.51M, False: 0]
  |  Branch (905:36): [True: 0, False: 4.51M]
  ------------------
  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.51M|            break;
  909|  4.51M|        }
  910|  6.58M|        bool spacePadPositive = false;
  911|  6.58M|        int ntrunc = -1;
  912|  6.58M|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|  6.58M|                                                   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.58M|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 6.58M]
  ------------------
  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.58M|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|  6.58M|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 6.58M, False: 0]
  ------------------
  923|  6.58M|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|  6.58M|        }
  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.58M|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 6.58M, False: 0]
  ------------------
  942|  6.58M|            ++argIndex;
  943|  6.58M|        fmt = fmtEnd;
  944|  6.58M|    }
  945|       |
  946|       |    // Restore stream state
  947|  4.51M|    out.width(origWidth);
  948|  4.51M|    out.precision(origPrecision);
  949|  4.51M|    out.flags(origFlags);
  950|  4.51M|    out.fill(origFill);
  951|  4.51M|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|  4.51M|{
 1071|  4.51M|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|  4.51M|}
_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  3.23M|{
 1089|  3.23M|    std::ostringstream oss;
 1090|  3.23M|    format(oss, fmt, args...);
 1091|  3.23M|    return oss.str();
 1092|  3.23M|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  3.23M|{
 1081|  3.23M|    vformat(out, fmt, makeFormatList(args...));
 1082|  3.23M|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|  3.43M|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  3.23M|{
 1045|  3.23M|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  3.23M|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|  3.23M|            : FormatList(&m_formatterStore[0], N),
  991|  3.23M|            m_formatterStore { FormatArg(args)... }
  992|  3.23M|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|  3.23M|            : m_value(static_cast<const void*>(&value)),
  535|  3.23M|            m_formatImpl(&formatImpl<T>),
  536|  3.23M|            m_toIntImpl(&toIntImpl<T>)
  537|  3.23M|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  3.23M|        {
  559|  3.23M|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  3.23M|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  3.23M|{
  352|  3.23M|#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.23M|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  3.23M|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  3.23M|#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.23M|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  3.23M|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  3.23M|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 3.23M]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  3.23M|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  3.23M|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 3.23M]
  ------------------
  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.23M|    else
  378|  3.23M|        out << value;
  379|  3.23M|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|   106k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2ImEERKT_:
  534|  7.15k|            : m_value(static_cast<const void*>(&value)),
  535|  7.15k|            m_formatImpl(&formatImpl<T>),
  536|  7.15k|            m_toIntImpl(&toIntImpl<T>)
  537|  7.15k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplImEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  7.15k|        {
  559|  7.15k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  7.15k|        }
_ZN10tinyformat11formatValueImEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  7.15k|{
  352|  7.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|  7.15k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  7.15k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  7.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|  7.15k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  7.15k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  7.15k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 7.15k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  7.15k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  7.15k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 7.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|  7.15k|    else
  378|  7.15k|        out << value;
  379|  7.15k|}
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|   632k|            : m_value(static_cast<const void*>(&value)),
  535|   632k|            m_formatImpl(&formatImpl<T>),
  536|   632k|            m_toIntImpl(&toIntImpl<T>)
  537|   632k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|   632k|        {
  559|   632k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   632k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|   632k|{
  352|   632k|#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|   632k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   632k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   632k|#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|   632k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   632k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   632k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   632k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|   632k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 632k]
  ------------------
  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|   632k|    else
  378|   632k|        out << value;
  379|   632k|}
_ZN10tinyformat6detail9FormatArgC2IlEERKT_:
  534|  1.94M|            : m_value(static_cast<const void*>(&value)),
  535|  1.94M|            m_formatImpl(&formatImpl<T>),
  536|  1.94M|            m_toIntImpl(&toIntImpl<T>)
  537|  1.94M|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  1.94M|        {
  559|  1.94M|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.94M|        }
_ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  1.94M|{
  352|  1.94M|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.94M|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.94M|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.94M|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.94M|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.94M|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.94M|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 1.94M]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.94M|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.94M|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.94M]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.94M|    else
  378|  1.94M|        out << value;
  379|  1.94M|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   102k|{
 1089|   102k|    std::ostringstream oss;
 1090|   102k|    format(oss, fmt, args...);
 1091|   102k|    return oss.str();
 1092|   102k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   102k|{
 1081|   102k|    vformat(out, fmt, makeFormatList(args...));
 1082|   102k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   102k|{
 1045|   102k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   102k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|   102k|            : FormatList(&m_formatterStore[0], N),
  991|   102k|            m_formatterStore { FormatArg(args)... }
  992|   102k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IPKcEERKT_:
  534|   557k|            : m_value(static_cast<const void*>(&value)),
  535|   557k|            m_formatImpl(&formatImpl<T>),
  536|   557k|            m_toIntImpl(&toIntImpl<T>)
  537|   557k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv:
  558|   557k|        {
  559|   557k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   557k|        }
_ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_:
  351|   557k|{
  352|   557k|#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|   557k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   557k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   557k|#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|   557k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   557k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   557k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   557k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 557k]
  ------------------
  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|   557k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 557k]
  ------------------
  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|   557k|    else
  378|   557k|        out << value;
  379|   557k|}
_ZN10tinyformat6formatIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  99.0k|{
 1089|  99.0k|    std::ostringstream oss;
 1090|  99.0k|    format(oss, fmt, args...);
 1091|  99.0k|    return oss.str();
 1092|  99.0k|}
_ZN10tinyformat6formatIJjEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  99.0k|{
 1081|  99.0k|    vformat(out, fmt, makeFormatList(args...));
 1082|  99.0k|}
_ZN10tinyformat14makeFormatListIJjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  99.0k|{
 1045|  99.0k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  99.0k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJjEEEDpRKT_:
  990|  99.0k|            : FormatList(&m_formatterStore[0], N),
  991|  99.0k|            m_formatterStore { FormatArg(args)... }
  992|  99.0k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IjEERKT_:
  534|   208k|            : m_value(static_cast<const void*>(&value)),
  535|   208k|            m_formatImpl(&formatImpl<T>),
  536|   208k|            m_toIntImpl(&toIntImpl<T>)
  537|   208k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIjEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|   208k|        {
  559|   208k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   208k|        }
_ZN10tinyformat11formatValueIjEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|   208k|{
  352|   208k|#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|   208k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   208k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   208k|#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|   208k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   208k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   208k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 208k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   208k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|   208k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 208k]
  ------------------
  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|   208k|    else
  378|   208k|        out << value;
  379|   208k|}
_ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv:
  197|   973k|    operator const char*() { return fmt; }
_ZN10tinyformat17FormatStringCheckILj2EEC2EN4util21ConstevalFormatStringILj2EEE:
  196|  4.20k|    FormatStringCheck(util::ConstevalFormatString<num_params> str) : fmt{str.fmt} {}
_ZN10tinyformat6formatIJPKcllEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   553k|{
 1089|   553k|    std::ostringstream oss;
 1090|   553k|    format(oss, fmt, args...);
 1091|   553k|    return oss.str();
 1092|   553k|}
_ZN10tinyformat6formatIJPKcllEEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   553k|{
 1081|   553k|    vformat(out, fmt, makeFormatList(args...));
 1082|   553k|}
_ZN10tinyformat14makeFormatListIJPKcllEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   553k|{
 1045|   553k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   553k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJPKcllEEEDpRKT_:
  990|   553k|            : FormatList(&m_formatterStore[0], N),
  991|   553k|            m_formatterStore { FormatArg(args)... }
  992|   553k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   420k|{
 1089|   420k|    std::ostringstream oss;
 1090|   420k|    format(oss, fmt, args...);
 1091|   420k|    return oss.str();
 1092|   420k|}
_ZN10tinyformat6formatIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   420k|{
 1081|   420k|    vformat(out, fmt, makeFormatList(args...));
 1082|   420k|}
_ZN10tinyformat14makeFormatListIJllNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   420k|{
 1045|   420k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   420k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJllNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|   420k|            : FormatList(&m_formatterStore[0], N),
  991|   420k|            m_formatterStore { FormatArg(args)... }
  992|   420k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat17FormatStringCheckILj5EEcvPKcEv:
  197|  3.57k|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   102k|{
 1089|   102k|    std::ostringstream oss;
 1090|   102k|    format(oss, fmt, args...);
 1091|   102k|    return oss.str();
 1092|   102k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   102k|{
 1081|   102k|    vformat(out, fmt, makeFormatList(args...));
 1082|   102k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   102k|{
 1045|   102k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   102k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjEEEDpRKT_:
  990|   102k|            : FormatList(&m_formatterStore[0], N),
  991|   102k|            m_formatterStore { FormatArg(args)... }
  992|   102k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEES9_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  4.20k|{
 1089|  4.20k|    std::ostringstream oss;
 1090|  4.20k|    format(oss, fmt, args...);
 1091|  4.20k|    return oss.str();
 1092|  4.20k|}
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvRNS3_13basic_ostreamIcS6_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  4.20k|{
 1081|  4.20k|    vformat(out, fmt, makeFormatList(args...));
 1082|  4.20k|}
_ZN10tinyformat14makeFormatListIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  4.20k|{
 1045|  4.20k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  4.20k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJPKcNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEDpRKT_:
  990|  4.20k|            : FormatList(&m_formatterStore[0], N),
  991|  4.20k|            m_formatterStore { FormatArg(args)... }
  992|  4.20k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  3.57k|{
 1089|  3.57k|    std::ostringstream oss;
 1090|  3.57k|    format(oss, fmt, args...);
 1091|  3.57k|    return oss.str();
 1092|  3.57k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  3.57k|{
 1081|  3.57k|    vformat(out, fmt, makeFormatList(args...));
 1082|  3.57k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjmmjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  3.57k|{
 1045|  3.57k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  3.57k|}
_ZN10tinyformat6detail11FormatListNILi5EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjmmjEEEDpRKT_:
  990|  3.57k|            : FormatList(&m_formatterStore[0], N),
  991|  3.57k|            m_formatterStore { FormatArg(args)... }
  992|  3.57k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZNK9base_blobILj256EE6GetHexEv:
   12|   244k|{
   13|   244k|    uint8_t m_data_rev[WIDTH];
   14|  8.06M|    for (int i = 0; i < WIDTH; ++i) {
  ------------------
  |  Branch (14:21): [True: 7.81M, False: 244k]
  ------------------
   15|  7.81M|        m_data_rev[i] = m_data[WIDTH - 1 - i];
   16|  7.81M|    }
   17|   244k|    return HexStr(m_data_rev);
   18|   244k|}
_ZNK9base_blobILj256EE8ToStringEv:
   48|   105k|{
   49|   105k|    return (GetHex());
   50|   105k|}

_ZN7uint160C2E4SpanIKhE:
  193|   157k|    constexpr explicit uint160(Span<const unsigned char> vch) : base_blob<160>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|  72.8k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZN9base_blobILj160EE5beginEv:
  115|  59.4k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE6IsNullEv:
   49|   139k|    {
   50|   139k|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|   139k|            return val == 0;
   52|   139k|        });
   53|   139k|    }
_ZNK9base_blobILj256EE5beginEv:
  118|  82.8k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  121|   110k|    static constexpr unsigned int size() { return WIDTH; }
_ZNK9base_blobILj256EE3endEv:
  119|  82.8k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZNK9base_blobILj256EE7CompareERKS0_:
   64|   888k|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZNK9base_blobILj256EE4dataEv:
  112|  10.8k|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj160EE4sizeEv:
  121|  37.6k|    static constexpr unsigned int size() { return WIDTH; }
_ZN9base_blobILj160EE4dataEv:
  113|  37.6k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
  113|   290k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint256C2Ev:
  205|   395k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|   395k|    constexpr base_blob() : m_data() {}
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  127|  1.34M|    {
  128|  1.34M|        s << Span(m_data);
  129|  1.34M|    }
_ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  133|   106k|    {
  134|   106k|        s.read(MakeWritableByteSpan(m_data));
  135|   106k|    }
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|   106k|    {
  134|   106k|        s.read(MakeWritableByteSpan(m_data));
  135|   106k|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   50|  2.08M|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|  2.08M|            return val == 0;
   52|  2.08M|        });
_ZNK9base_blobILj256EE9GetUint64Ei:
  123|  15.8k|    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
_ZN7uint160C2Ev:
  192|  97.1k|    constexpr uint160() = default;
_ZN9base_blobILj160EEC2Ev:
   35|  97.1k|    constexpr base_blob() : m_data() {}
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  127|   219k|    {
  128|   219k|        s << Span(m_data);
  129|   219k|    }
_ZN9base_blobILj160EEC2E4SpanIKhE:
   41|   157k|    {
   42|   157k|        assert(vch.size() == WIDTH);
   43|   157k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|   157k|    }
_ZNK9base_blobILj160EE5beginEv:
  118|   195k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZNK9base_blobILj160EE3endEv:
  119|   195k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  127|   172k|    {
  128|   172k|        s << Span(m_data);
  129|   172k|    }

_ZN8UniValueC2ENS_5VTypeENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   32|  1.92M|    UniValue(UniValue::VType type, std::string str = {}) : typ{type}, val{std::move(str)} {}
_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|  5.46M|    {
   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|  5.46M|        } else {
   50|  5.46M|            setStr(std::string{std::forward<Ref>(val)});
   51|  5.46M|        }
   52|  5.46M|    }
_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|  7.01k|    {
   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|  7.01k|        } else if constexpr (std::is_unsigned_v<T>) {
   48|  7.01k|            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|  7.01k|    }
_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|  7.01k|    {
   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|  7.01k|        } else if constexpr (std::is_unsigned_v<T>) {
   48|  7.01k|            setInt(uint64_t{val});
   49|       |        } else {
   50|       |            setStr(std::string{std::forward<Ref>(val)});
   51|       |        }
   52|  7.01k|    }
_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|  14.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|  14.0k|        } else if constexpr (std::is_signed_v<T>) {
   46|  14.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|  14.0k|    }
_ZN8UniValueC2IllTnNSt3__19enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbS3_Esr3stdE11is_signed_vIS3_Esr3stdE13is_unsigned_vIS3_Esr3stdE18is_constructible_vINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES3_EEbE4typeELb1EEEOT_:
   40|   794k|    {
   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|   794k|        } else if constexpr (std::is_signed_v<T>) {
   46|   794k|            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|   794k|    }
univalue_read.cpp:_ZL12json_isspacei:
  188|   822k|{
  189|   822k|    switch (ch) {
  190|      0|    case 0x20:
  ------------------
  |  Branch (190:5): [True: 0, False: 822k]
  ------------------
  191|      0|    case 0x09:
  ------------------
  |  Branch (191:5): [True: 0, False: 822k]
  ------------------
  192|      0|    case 0x0a:
  ------------------
  |  Branch (192:5): [True: 0, False: 822k]
  ------------------
  193|      0|    case 0x0d:
  ------------------
  |  Branch (193:5): [True: 0, False: 822k]
  ------------------
  194|      0|        return true;
  195|       |
  196|   822k|    default:
  ------------------
  |  Branch (196:5): [True: 822k, False: 0]
  ------------------
  197|   822k|        return false;
  198|   822k|    }
  199|       |
  200|       |    // not reached
  201|   822k|}

_ZN8UniValue5clearEv:
   19|  6.28M|{
   20|  6.28M|    typ = VNULL;
   21|  6.28M|    val.clear();
   22|  6.28M|    keys.clear();
   23|  6.28M|    values.clear();
   24|  6.28M|}
_ZN8UniValue9setNumStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   48|   822k|{
   49|   822k|    if (!validNumStr(str)) {
  ------------------
  |  Branch (49:9): [True: 0, False: 822k]
  ------------------
   50|      0|        throw std::runtime_error{"The string '" + str + "' is not a valid JSON number"};
   51|      0|    }
   52|       |
   53|   822k|    clear();
   54|   822k|    typ = VNUM;
   55|   822k|    val = std::move(str);
   56|   822k|}
_ZN8UniValue6setIntEm:
   59|  14.0k|{
   60|  14.0k|    std::ostringstream oss;
   61|       |
   62|  14.0k|    oss << val_;
   63|       |
   64|  14.0k|    return setNumStr(oss.str());
   65|  14.0k|}
_ZN8UniValue6setIntEl:
   68|   808k|{
   69|   808k|    std::ostringstream oss;
   70|       |
   71|   808k|    oss << val_;
   72|       |
   73|   808k|    return setNumStr(oss.str());
   74|   808k|}
_ZN8UniValue6setStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   86|  5.46M|{
   87|  5.46M|    clear();
   88|  5.46M|    typ = VSTR;
   89|  5.46M|    val = std::move(str);
   90|  5.46M|}
_ZN8UniValue9push_backES_:
  105|  3.44M|{
  106|  3.44M|    checkType(VARR);
  107|       |
  108|  3.44M|    values.push_back(std::move(val));
  109|  3.44M|}
_ZN8UniValue9pushKVEndENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  119|  4.76M|{
  120|  4.76M|    checkType(VOBJ);
  121|       |
  122|  4.76M|    keys.push_back(std::move(key));
  123|  4.76M|    values.push_back(std::move(val));
  124|  4.76M|}
_ZN8UniValue6pushKVENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  127|  4.76M|{
  128|  4.76M|    checkType(VOBJ);
  129|       |
  130|  4.76M|    size_t idx;
  131|  4.76M|    if (findKey(key, idx))
  ------------------
  |  Branch (131:9): [True: 0, False: 4.76M]
  ------------------
  132|      0|        values[idx] = std::move(val);
  133|  4.76M|    else
  134|  4.76M|        pushKVEnd(std::move(key), std::move(val));
  135|  4.76M|}
_ZNK8UniValue7findKeyERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERm:
  157|  4.76M|{
  158|  11.3M|    for (size_t i = 0; i < keys.size(); i++) {
  ------------------
  |  Branch (158:24): [True: 6.60M, False: 4.76M]
  ------------------
  159|  6.60M|        if (keys[i] == key) {
  ------------------
  |  Branch (159:13): [True: 0, False: 6.60M]
  ------------------
  160|      0|            retIdx = i;
  161|      0|            return true;
  162|      0|        }
  163|  6.60M|    }
  164|       |
  165|  4.76M|    return false;
  166|  4.76M|}
_ZNK8UniValue9checkTypeERKNS_5VTypeE:
  211|  12.9M|{
  212|  12.9M|    if (typ != expected) {
  ------------------
  |  Branch (212:9): [True: 0, False: 12.9M]
  ------------------
  213|      0|        throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +
  214|      0|                                 std::string{uvTypeName(expected)}};
  215|      0|    }
  216|  12.9M|}
univalue.cpp:_ZL11validNumStrRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
   40|   822k|{
   41|   822k|    std::string tokenVal;
   42|   822k|    unsigned int consumed;
   43|   822k|    enum jtokentype tt = getJsonToken(tokenVal, consumed, s.data(), s.data() + s.size());
   44|   822k|    return (tt == JTOK_NUMBER);
   45|   822k|}

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

_Z22inline_assertion_checkILb0EbEOT0_S1_PKciS3_S3_:
   52|  3.61k|{
   53|  3.61k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  3.61k|    ) {
   58|  3.61k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 3.61k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  3.61k|    }
   62|  3.61k|    return std::forward<T>(val);
   63|  3.61k|}
_Z22inline_check_non_fatalIbEOT_S1_PKciS3_S3_:
   35|  7.01k|{
   36|  7.01k|    if (!val) {
  ------------------
  |  Branch (36:9): [True: 0, False: 7.01k]
  ------------------
   37|      0|        throw NonFatalCheckError{assertion, file, line, func};
   38|      0|    }
   39|  7.01k|    return std::forward<T>(val);
   40|  7.01k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  11.9k|{
   53|  11.9k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  11.9k|    ) {
   58|  11.9k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 11.9k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  11.9k|    }
   62|  11.9k|    return std::forward<T>(val);
   63|  11.9k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  4.20k|{
   53|  4.20k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  4.20k|    ) {
   58|  4.20k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 4.20k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  4.20k|    }
   62|  4.20k|    return std::forward<T>(val);
   63|  4.20k|}
_Z22inline_assertion_checkILb1ERNSt3__16atomicIbEEEOT0_S5_PKciS7_S7_:
   52|  4.20k|{
   53|  4.20k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  4.20k|    ) {
   58|  4.20k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 4.20k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  4.20k|    }
   62|  4.20k|    return std::forward<T>(val);
   63|  4.20k|}

_ZN8BaseHashI7uint160EC2ERKS0_:
   16|   150k|    explicit BaseHash(const HashType& in) : m_hash(in) {}
_ZN8BaseHashI7uint256E5beginEv:
   19|  42.0k|    {
   20|  42.0k|        return m_hash.begin();
   21|  42.0k|    }
_ZN8BaseHashI7uint160EC2Ev:
   15|  38.4k|    BaseHash() : m_hash() {}
_ZNK8BaseHashI7uint160E5beginEv:
   24|   195k|    {
   25|   195k|        return m_hash.begin();
   26|   195k|    }
_ZNK8BaseHashI7uint160E3endEv:
   34|   195k|    {
   35|   195k|        return m_hash.end();
   36|   195k|    }
_ZNK8BaseHashI7uint256E5beginEv:
   24|  63.0k|    {
   25|  63.0k|        return m_hash.begin();
   26|  63.0k|    }
_ZNK8BaseHashI7uint256E3endEv:
   34|  63.0k|    {
   35|  63.0k|        return m_hash.end();
   36|  63.0k|    }
_ZN8BaseHashI7uint256EC2Ev:
   15|  42.0k|    BaseHash() : m_hash() {}
_ZN8BaseHashI7uint160E5beginEv:
   19|  38.4k|    {
   20|  38.4k|        return m_hash.begin();
   21|  38.4k|    }

_ZN20SaltedOutpointHasherC2Eb:
   15|  3.57k|    k0{deterministic ? 0x8e819f2607a18de6 : FastRandomContext().rand64()},
  ------------------
  |  Branch (15:8): [True: 0, False: 3.57k]
  ------------------
   16|  3.57k|    k1{deterministic ? 0xf4020d2e3983b0eb : FastRandomContext().rand64()}
  ------------------
  |  Branch (16:8): [True: 0, False: 3.57k]
  ------------------
   17|  3.57k|{}

_ZNK20SaltedOutpointHasherclERK9COutPoint:
   49|  3.97k|    size_t operator()(const COutPoint& id) const noexcept {
   50|  3.97k|        return SipHashUint256Extra(k0, k1, id.hash, id.n);
   51|  3.97k|    }

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

_Z15SignalsOptInRBFRK12CTransaction:
   10|  3.57k|{
   11|  14.9k|    for (const CTxIn &txin : tx.vin) {
  ------------------
  |  Branch (11:28): [True: 14.9k, False: 234]
  ------------------
   12|  14.9k|        if (txin.nSequence <= MAX_BIP125_RBF_SEQUENCE) {
  ------------------
  |  Branch (12:13): [True: 3.34k, False: 11.6k]
  ------------------
   13|  3.34k|            return true;
   14|  3.34k|        }
   15|  14.9k|    }
   16|    234|    return false;
   17|  3.57k|}

key_io.cpp:_ZNK12_GLOBAL__N_111IntIdentityclEi:
  263|  2.69M|    [[maybe_unused]] int operator()(int x) const { return x; }
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|  42.0k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  42.0k|    size_t acc = 0;
  272|  42.0k|    size_t bits = 0;
  273|  42.0k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  42.0k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|  1.38M|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 1.34M, False: 42.0k]
  ------------------
  276|  1.34M|        int v = infn(*it);
  277|  1.34M|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 1.34M]
  ------------------
  278|  1.34M|        acc = ((acc << frombits) | v) & max_acc;
  279|  1.34M|        bits += frombits;
  280|  3.48M|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 2.14M, False: 1.34M]
  ------------------
  281|  2.14M|            bits -= tobits;
  282|  2.14M|            outfn((acc >> bits) & maxv);
  283|  2.14M|        }
  284|  1.34M|        ++it;
  285|  1.34M|    }
  286|  42.0k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|  42.0k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 42.0k, False: 0]
  ------------------
  288|  42.0k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|  42.0k|    return true;
  292|  42.0k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|  38.4k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  38.4k|    size_t acc = 0;
  272|  38.4k|    size_t bits = 0;
  273|  38.4k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  38.4k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|   808k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 769k, False: 38.4k]
  ------------------
  276|   769k|        int v = infn(*it);
  277|   769k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 769k]
  ------------------
  278|   769k|        acc = ((acc << frombits) | v) & max_acc;
  279|   769k|        bits += frombits;
  280|  2.00M|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 1.23M, False: 769k]
  ------------------
  281|  1.23M|            bits -= tobits;
  282|  1.23M|            outfn((acc >> bits) & maxv);
  283|  1.23M|        }
  284|   769k|        ++it;
  285|   769k|    }
  286|  38.4k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|  38.4k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 0, False: 38.4k]
  ------------------
  288|  38.4k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|  38.4k|    return true;
  292|  38.4k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|  10.0k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  10.0k|    size_t acc = 0;
  272|  10.0k|    size_t bits = 0;
  273|  10.0k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  10.0k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|   330k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 320k, False: 10.0k]
  ------------------
  276|   320k|        int v = infn(*it);
  277|   320k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 320k]
  ------------------
  278|   320k|        acc = ((acc << frombits) | v) & max_acc;
  279|   320k|        bits += frombits;
  280|   831k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 510k, False: 320k]
  ------------------
  281|   510k|            bits -= tobits;
  282|   510k|            outfn((acc >> bits) & maxv);
  283|   510k|        }
  284|   320k|        ++it;
  285|   320k|    }
  286|  10.0k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|  10.0k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 10.0k, False: 0]
  ------------------
  288|  10.0k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|  10.0k|    return true;
  292|  10.0k|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownEUlhE_NSt3__111__wrap_iterIPKhEENS0_11IntIdentityEEbT2_T3_SD_T4_:
  270|  21.9k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  21.9k|    size_t acc = 0;
  272|  21.9k|    size_t bits = 0;
  273|  21.9k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  21.9k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|   278k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 256k, False: 21.9k]
  ------------------
  276|   256k|        int v = infn(*it);
  277|   256k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 256k]
  ------------------
  278|   256k|        acc = ((acc << frombits) | v) & max_acc;
  279|   256k|        bits += frombits;
  280|   662k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 406k, False: 256k]
  ------------------
  281|   406k|            bits -= tobits;
  282|   406k|            outfn((acc >> bits) & maxv);
  283|   406k|        }
  284|   256k|        ++it;
  285|   256k|    }
  286|  21.9k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|  21.9k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 21.6k, False: 248]
  ------------------
  288|  21.9k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|  21.9k|    return true;
  292|  21.9k|}

_ZN4util21ThreadGetInternalNameEv:
   47|  4.20k|std::string util::ThreadGetInternalName() { return g_thread_name; }

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  4.20k|{
   43|  4.20k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  4.20k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  4.20k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  4.20k|}
_Z11GetMockTimev:
   48|  4.20k|{
   49|  4.20k|    return g_mock_time.load(std::memory_order_relaxed);
   50|  4.20k|}

_ZNK22transaction_identifierILb0EE6IsNullEv:
   43|   132k|    constexpr bool IsNull() const { return m_wrapped.IsNull(); }
_ZNK22transaction_identifierILb0EE7CompareERKS0_:
   21|   888k|    constexpr int Compare(const transaction_identifier<has_witness>& other) const { return m_wrapped.Compare(other.m_wrapped); }
_ZNK22transaction_identifierILb0EEltIS0_EEbRKT_:
   37|   888k|    bool operator<(const Other& other) const { return Compare(other) < 0; }
_ZNK22transaction_identifierILb0EEcvRK7uint256Ev:
   67|  3.97k|    operator const uint256&() const LIFETIMEBOUND { return m_wrapped; }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
   57|  1.34M|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb0EEC2Ev:
   30|   216k|    transaction_identifier() : m_wrapped{} {}
_ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
   58|   106k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZN22transaction_identifierILb0EE11UnserializeI10DataStreamEEvRT_:
   58|   106k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZN22transaction_identifierILb0EE11FromUint256ERK7uint256:
   40|  4.20k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb0EEC2ERK7uint256:
   16|  4.20k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
   57|   219k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb1EE11FromUint256ERK7uint256:
   40|  4.20k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb1EEC2ERK7uint256:
   16|  4.20k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}
_ZNK22transaction_identifierILb0EE9ToUint256Ev:
   39|  3.66k|    const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; }
_ZNK22transaction_identifierILb0EE8ToStringEv:
   52|   105k|    std::string ToString() const { return m_wrapped.ToString(); }
_ZNK22transaction_identifierILb0EE6GetHexEv:
   51|   124k|    std::string GetHex() const { return m_wrapped.GetHex(); }
_ZNK22transaction_identifierILb1EE6GetHexEv:
   51|  7.01k|    std::string GetHex() const { return m_wrapped.GetHex(); }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
   57|   172k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }

descriptor.cpp:_Z6VectorIJNSt3__110unique_ptrIN12_GLOBAL__N_114PubkeyProviderENS0_14default_deleteIS3_EEEEEENS0_6vectorINS0_11common_typeIJDpT_EE4typeENS0_9allocatorISC_EEEEDpOS9_:
   24|  12.0k|{
   25|  12.0k|    std::vector<typename std::common_type<Args...>::type> ret;
   26|  12.0k|    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|  12.0k|    (void)std::initializer_list<int>{(ret.emplace_back(std::forward<Args>(args)), 0)...};
   29|  12.0k|    return ret;
   30|  12.0k|}