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

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

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

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

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

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

_Z17internal_bswap_32j:
   54|  34.7k|{
   55|  34.7k|#ifdef bitcoin_builtin_bswap32
   56|  34.7k|    return bitcoin_builtin_bswap32(x);
  ------------------
  |  |   24|  34.7k|#      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|  34.7k|}
_Z17internal_bswap_64m:
   64|  1.25k|{
   65|  1.25k|#ifdef bitcoin_builtin_bswap64
   66|  1.25k|    return bitcoin_builtin_bswap64(x);
  ------------------
  |  |   27|  1.25k|#      define bitcoin_builtin_bswap64(x) __builtin_bswap64(x)
  ------------------
   67|       |#else
   68|       |     return (((x & 0xff00000000000000ull) >> 56)
   69|       |          | ((x & 0x00ff000000000000ull) >> 40)
   70|       |          | ((x & 0x0000ff0000000000ull) >> 24)
   71|       |          | ((x & 0x000000ff00000000ull) >> 8)
   72|       |          | ((x & 0x00000000ff000000ull) << 8)
   73|       |          | ((x & 0x0000000000ff0000ull) << 24)
   74|       |          | ((x & 0x000000000000ff00ull) << 40)
   75|       |          | ((x & 0x00000000000000ffull) << 56));
   76|       |#endif
   77|  1.25k|}

_Z16le16toh_internalt:
   29|  5.92k|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|  5.92k|        else return little_endian_16bits;
   32|  5.92k|}
_Z16be32toh_internalj:
   44|  24.7k|{
   45|  24.7k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
   46|       |        else return big_endian_32bits;
   47|  24.7k|}
_Z16htobe32_internalj:
   34|  10.0k|{
   35|  10.0k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|  10.0k|}
_Z16htole64_internalm:
   59|  1.21k|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  1.21k|        else return host_64bits;
   62|  1.21k|}
_Z16htobe64_internalm:
   54|  1.25k|{
   55|  1.25k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
   56|       |        else return host_64bits;
   57|  1.25k|}
_Z16htole32_internalj:
   39|  6.09k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  6.09k|        else return host_32bits;
   42|  6.09k|}
_Z16le32toh_internalj:
   49|  34.1k|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|  34.1k|        else return little_endian_32bits;
   52|  34.1k|}

_Z12FormatScriptRK7CScript:
  297|  3.62k|{
  298|  3.62k|    std::string ret;
  299|  3.62k|    CScript::const_iterator it = script.begin();
  300|  3.62k|    opcodetype op;
  301|   809k|    while (it != script.end()) {
  ------------------
  |  Branch (301:12): [True: 806k, False: 2.96k]
  ------------------
  302|   806k|        CScript::const_iterator it2 = it;
  303|   806k|        std::vector<unsigned char> vch;
  304|   806k|        if (script.GetOp(it, op, vch)) {
  ------------------
  |  Branch (304:13): [True: 806k, False: 654]
  ------------------
  305|   806k|            if (op == OP_0) {
  ------------------
  |  Branch (305:17): [True: 65.2k, False: 740k]
  ------------------
  306|  65.2k|                ret += "0 ";
  307|  65.2k|                continue;
  308|   740k|            } else if ((op >= OP_1 && op <= OP_16) || op == OP_1NEGATE) {
  ------------------
  |  Branch (308:25): [True: 635k, False: 105k]
  |  Branch (308:39): [True: 46.6k, False: 588k]
  |  Branch (308:55): [True: 623, False: 693k]
  ------------------
  309|  47.2k|                ret += strprintf("%i ", op - OP_1NEGATE - 1);
  ------------------
  |  | 1172|  47.2k|#define strprintf tfm::format
  ------------------
  310|  47.2k|                continue;
  311|   693k|            } else if (op >= OP_NOP && op <= OP_NOP10) {
  ------------------
  |  Branch (311:24): [True: 588k, False: 105k]
  |  Branch (311:40): [True: 569k, False: 18.7k]
  ------------------
  312|   569k|                std::string str(GetOpName(op));
  313|   569k|                if (str.substr(0, 3) == std::string("OP_")) {
  ------------------
  |  Branch (313:21): [True: 569k, False: 0]
  ------------------
  314|   569k|                    ret += str.substr(3, std::string::npos) + " ";
  315|   569k|                    continue;
  316|   569k|                }
  317|   569k|            }
  318|   124k|            if (vch.size() > 0) {
  ------------------
  |  Branch (318:17): [True: 101k, False: 23.0k]
  ------------------
  319|   101k|                ret += strprintf("0x%x 0x%x ", HexStr(std::vector<uint8_t>(it2, it - vch.size())),
  ------------------
  |  | 1172|   101k|#define strprintf tfm::format
  ------------------
  320|   101k|                                               HexStr(std::vector<uint8_t>(it - vch.size(), it)));
  321|   101k|            } else {
  322|  23.0k|                ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, it)));
  ------------------
  |  | 1172|  23.0k|#define strprintf tfm::format
  ------------------
  323|  23.0k|            }
  324|   124k|            continue;
  325|   806k|        }
  326|    654|        ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, script.end())));
  ------------------
  |  | 1172|    654|#define strprintf tfm::format
  ------------------
  327|    654|        break;
  328|   806k|    }
  329|  3.62k|    return ret.substr(0, ret.empty() ? ret.npos : ret.size() - 1);
  ------------------
  |  Branch (329:26): [True: 131, False: 3.49k]
  ------------------
  330|  3.62k|}
_Z14ScriptToAsmStrRK7CScriptb:
  356|  7.24k|{
  357|  7.24k|    std::string str;
  358|  7.24k|    opcodetype opcode;
  359|  7.24k|    std::vector<unsigned char> vch;
  360|  7.24k|    CScript::const_iterator pc = script.begin();
  361|  1.61M|    while (pc < script.end()) {
  ------------------
  |  Branch (361:12): [True: 1.61M, False: 5.93k]
  ------------------
  362|  1.61M|        if (!str.empty()) {
  ------------------
  |  Branch (362:13): [True: 1.60M, False: 6.98k]
  ------------------
  363|  1.60M|            str += " ";
  364|  1.60M|        }
  365|  1.61M|        if (!script.GetOp(pc, opcode, vch)) {
  ------------------
  |  Branch (365:13): [True: 1.30k, False: 1.61M]
  ------------------
  366|  1.30k|            str += "[error]";
  367|  1.30k|            return str;
  368|  1.30k|        }
  369|  1.61M|        if (0 <= opcode && opcode <= OP_PUSHDATA4) {
  ------------------
  |  Branch (369:13): [True: 1.61M, False: 0]
  |  Branch (369:28): [True: 340k, False: 1.27M]
  ------------------
  370|   340k|            if (vch.size() <= static_cast<std::vector<unsigned char>::size_type>(4)) {
  ------------------
  |  Branch (370:17): [True: 180k, False: 159k]
  ------------------
  371|   180k|                str += strprintf("%d", CScriptNum(vch, false).getint());
  ------------------
  |  | 1172|   180k|#define strprintf tfm::format
  ------------------
  372|   180k|            } else {
  373|       |                // the IsUnspendable check makes sure not to try to decode OP_RETURN data that may match the format of a signature
  374|   159k|                if (fAttemptSighashDecode && !script.IsUnspendable()) {
  ------------------
  |  Branch (374:21): [True: 30.0k, False: 129k]
  |  Branch (374:46): [True: 8.57k, False: 21.5k]
  ------------------
  375|  8.57k|                    std::string strSigHashDecode;
  376|       |                    // goal: only attempt to decode a defined sighash type from data that looks like a signature within a scriptSig.
  377|       |                    // this won't decode correctly formatted public keys in Pubkey or Multisig scripts due to
  378|       |                    // the restrictions on the pubkey formats (see IsCompressedOrUncompressedPubKey) being incongruous with the
  379|       |                    // checks in CheckSignatureEncoding.
  380|  8.57k|                    if (CheckSignatureEncoding(vch, SCRIPT_VERIFY_STRICTENC, nullptr)) {
  ------------------
  |  Branch (380:25): [True: 431, False: 8.14k]
  ------------------
  381|    431|                        const unsigned char chSigHashType = vch.back();
  382|    431|                        const auto it = mapSigHashTypes.find(chSigHashType);
  383|    431|                        if (it != mapSigHashTypes.end()) {
  ------------------
  |  Branch (383:29): [True: 431, False: 0]
  ------------------
  384|    431|                            strSigHashDecode = "[" + it->second + "]";
  385|    431|                            vch.pop_back(); // remove the sighash type byte. it will be replaced by the decode.
  386|    431|                        }
  387|    431|                    }
  388|  8.57k|                    str += HexStr(vch) + strSigHashDecode;
  389|   151k|                } else {
  390|   151k|                    str += HexStr(vch);
  391|   151k|                }
  392|   159k|            }
  393|  1.27M|        } else {
  394|  1.27M|            str += GetOpName(opcode);
  395|  1.27M|        }
  396|  1.61M|    }
  397|  5.93k|    return str;
  398|  7.24k|}
_Z12ScriptToUnivRK7CScriptR8UniValuebbPK15SigningProvider:
  408|  3.62k|{
  409|  3.62k|    CTxDestination address;
  410|       |
  411|  3.62k|    out.pushKV("asm", ScriptToAsmStr(script));
  412|  3.62k|    if (include_address) {
  ------------------
  |  Branch (412:9): [True: 895, False: 2.72k]
  ------------------
  413|    895|        out.pushKV("desc", InferDescriptor(script, provider ? *provider : DUMMY_SIGNING_PROVIDER)->ToString());
  ------------------
  |  Branch (413:52): [True: 0, False: 895]
  ------------------
  414|    895|    }
  415|  3.62k|    if (include_hex) {
  ------------------
  |  Branch (415:9): [True: 620, False: 3.00k]
  ------------------
  416|    620|        out.pushKV("hex", HexStr(script));
  417|    620|    }
  418|       |
  419|  3.62k|    std::vector<std::vector<unsigned char>> solns;
  420|  3.62k|    const TxoutType type{Solver(script, solns)};
  421|       |
  422|  3.62k|    if (include_address && ExtractDestination(script, address) && type != TxoutType::PUBKEY) {
  ------------------
  |  Branch (422:9): [True: 895, False: 2.72k]
  |  Branch (422:28): [True: 500, False: 395]
  |  Branch (422:67): [True: 500, False: 0]
  ------------------
  423|    500|        out.pushKV("address", EncodeDestination(address));
  424|    500|    }
  425|  3.62k|    out.pushKV("type", GetTxnOutputType(type));
  426|  3.62k|}

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

_Z8ReadLE16ITk8ByteTypehEtPKT_:
   20|  5.92k|{
   21|  5.92k|    uint16_t x;
   22|  5.92k|    memcpy(&x, ptr, 2);
   23|  5.92k|    return le16toh_internal(x);
   24|  5.92k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|  34.1k|{
   29|  34.1k|    uint32_t x;
   30|  34.1k|    memcpy(&x, ptr, 4);
   31|  34.1k|    return le32toh_internal(x);
   32|  34.1k|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|  6.09k|{
   52|  6.09k|    uint32_t v = htole32_internal(x);
   53|  6.09k|    memcpy(ptr, &v, 4);
   54|  6.09k|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  24.7k|{
   74|  24.7k|    uint32_t x;
   75|  24.7k|    memcpy(&x, ptr, 4);
   76|  24.7k|    return be32toh_internal(x);
   77|  24.7k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  10.0k|{
   97|  10.0k|    uint32_t v = htobe32_internal(x);
   98|  10.0k|    memcpy(ptr, &v, 4);
   99|  10.0k|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  1.21k|{
   59|  1.21k|    uint64_t v = htole64_internal(x);
   60|  1.21k|    memcpy(ptr, &v, 8);
   61|  1.21k|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|  1.25k|{
  104|  1.25k|    uint64_t v = htobe64_internal(x);
  105|  1.25k|    memcpy(ptr, &v, 8);
  106|  1.25k|}

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

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

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

_Z9RIPEMD160NSt3__14spanIKhLm18446744073709551615EEE:
  231|      1|{
  232|      1|    uint160 result;
  233|      1|    CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin());
  234|      1|    return result;
  235|      1|}
_Z4HashINSt3__16vectorIhNS0_9allocatorIhEEEEE7uint256RKT_:
   84|     18|{
   85|     18|    uint256 result;
   86|     18|    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
   87|     18|    return result;
   88|     18|}
_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }
_Z7Hash160INSt3__14spanIKhLm18446744073709551615EEEE7uint160RKT_:
  101|  1.21k|{
  102|  1.21k|    uint160 result;
  103|  1.21k|    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
  104|  1.21k|    return result;
  105|  1.21k|}
_ZN8CHash2565WriteENSt3__14spanIKhLm18446744073709551615EEE:
   45|     18|    CHash256& Write(std::span<const unsigned char> input) {
   46|     18|        sha.Write(input.data(), input.size());
   47|     18|        return *this;
   48|     18|    }
_ZN8CHash2568FinalizeENSt3__14spanIhLm18446744073709551615EEE:
   38|     18|    void Finalize(std::span<unsigned char> output) {
   39|     18|        assert(output.size() == OUTPUT_SIZE);
  ------------------
  |  Branch (39:9): [True: 18, False: 0]
  ------------------
   40|     18|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   41|     18|        sha.Finalize(buf);
   42|     18|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   43|     18|    }
_ZN8CHash1605WriteENSt3__14spanIKhLm18446744073709551615EEE:
   70|  1.21k|    CHash160& Write(std::span<const unsigned char> input) {
   71|  1.21k|        sha.Write(input.data(), input.size());
   72|  1.21k|        return *this;
   73|  1.21k|    }
_ZN8CHash1608FinalizeENSt3__14spanIhLm18446744073709551615EEE:
   63|  1.21k|    void Finalize(std::span<unsigned char> output) {
   64|  1.21k|        assert(output.size() == OUTPUT_SIZE);
  ------------------
  |  Branch (64:9): [True: 1.21k, False: 0]
  ------------------
   65|  1.21k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   66|  1.21k|        sha.Finalize(buf);
   67|  1.21k|        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   68|  1.21k|    }

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

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

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

_ZN9prevectorILj36EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvNS0_8iteratorET_S7_:
  335|   729k|    void insert(iterator pos, InputIterator first, InputIterator last) {
  336|   729k|        size_type p = pos - begin();
  337|   729k|        difference_type count = last - first;
  338|   729k|        size_type new_size = size() + count;
  339|   729k|        if (capacity() < new_size) {
  ------------------
  |  Branch (339:13): [True: 1.96k, False: 727k]
  ------------------
  340|  1.96k|            change_capacity(new_size + (new_size >> 1));
  341|  1.96k|        }
  342|   729k|        T* ptr = item_ptr(p);
  343|   729k|        T* dst = ptr + count;
  344|   729k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  345|   729k|        _size += count;
  346|   729k|        fill(ptr, first, last);
  347|   729k|    }
_ZNK9prevectorILj36EhjiE14const_iteratormiEj:
  100|   202k|        const_iterator operator-(size_type n) const { return const_iterator(ptr - n); }
_ZNK9prevectorILj36EhjiE4backEv:
  412|  4.07k|    const T& back() const {
  413|  4.07k|        return *item_ptr(size() - 1);
  414|  4.07k|    }
_ZNK9prevectorILj16EhjiE9is_directEv:
  126|     16|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  422|     16|    ~prevector() {
  423|     16|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 16]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     16|    }
_ZN9prevectorILj36EhjiEC2EOS0_:
  224|    350|        : _union(std::move(other._union)), _size(other._size)
  225|    350|    {
  226|    350|        other._size = 0;
  227|    350|    }
_ZN9prevectorILj36EhjiE9push_backERKh:
  392|   145k|    void push_back(const T& value) {
  393|   145k|        emplace_back(value);
  394|   145k|    }
_ZN9prevectorILj36EhjiE12emplace_backIJRKhEEEvDpOT_:
  383|   145k|    void emplace_back(Args&&... args) {
  384|   145k|        size_type new_size = size() + 1;
  385|   145k|        if (capacity() < new_size) {
  ------------------
  |  Branch (385:13): [True: 116, False: 145k]
  ------------------
  386|    116|            change_capacity(new_size + (new_size >> 1));
  387|    116|        }
  388|   145k|        new(item_ptr(size())) T(std::forward<Args>(args)...);
  389|   145k|        _size++;
  390|   145k|    }
_ZN9prevectorILj36EhjiEaSEOS0_:
  237|    735|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  238|    735|        if (!is_direct()) {
  ------------------
  |  Branch (238:13): [True: 0, False: 735]
  ------------------
  239|      0|            free(_union.indirect_contents.indirect);
  240|      0|        }
  241|    735|        _union = std::move(other._union);
  242|    735|        _size = other._size;
  243|    735|        other._size = 0;
  244|    735|        return *this;
  245|    735|    }
_ZNK9prevectorILj36EhjiE4dataEv:
  468|    970|    const value_type* data() const {
  469|    970|        return item_ptr(0);
  470|    970|    }
_ZN9prevectorILj36EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  167|  1.26k|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  10.6M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 10.6M, False: 1.26k]
  ------------------
  169|  10.6M|            new(static_cast<void*>(dst)) T(*first);
  170|  10.6M|            ++dst;
  171|  10.6M|            ++first;
  172|  10.6M|        }
  173|  1.26k|    }
_ZNK9prevectorILj36EhjiE14const_iteratoreqES1_:
  102|  11.4M|        bool operator==(const_iterator x) const { return ptr == x.ptr; }
_ZN9prevectorILj36EhjiE14const_iteratorppEv:
   92|  13.2M|        const_iterator& operator++() { ptr++; return *this; }
_ZNK9prevectorILj36EhjiEixEj:
  272|  15.5k|    const T& operator[](size_type pos) const {
  273|  15.5k|        return *item_ptr(pos);
  274|  15.5k|    }
_ZN9prevectorILj36EhjiE8item_ptrEi:
  159|   115M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (159:47): [True: 35.8k, False: 115M]
  ------------------
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|   280M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiE10direct_ptrEi:
  122|  38.7k|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj36EhjiE12indirect_ptrEi:
  124|   115M|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj36EhjiE15change_capacityEj:
  128|  16.1k|    void change_capacity(size_type new_capacity) {
  129|  16.1k|        if (new_capacity <= N) {
  ------------------
  |  Branch (129:13): [True: 433, False: 15.7k]
  ------------------
  130|    433|            if (!is_direct()) {
  ------------------
  |  Branch (130:17): [True: 0, False: 433]
  ------------------
  131|      0|                T* indirect = indirect_ptr(0);
  132|      0|                T* src = indirect;
  133|      0|                T* dst = direct_ptr(0);
  134|      0|                memcpy(dst, src, size() * sizeof(T));
  135|      0|                free(indirect);
  136|      0|                _size -= N + 1;
  137|      0|            }
  138|  15.7k|        } else {
  139|  15.7k|            if (!is_direct()) {
  ------------------
  |  Branch (139:17): [True: 12.8k, False: 2.92k]
  ------------------
  140|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  141|       |                    success. These should instead use an allocator or new/delete so that handlers
  142|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  143|  12.8k|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  144|  12.8k|                assert(_union.indirect_contents.indirect);
  ------------------
  |  Branch (144:17): [True: 12.8k, False: 0]
  ------------------
  145|  12.8k|                _union.indirect_contents.capacity = new_capacity;
  146|  12.8k|            } else {
  147|  2.92k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  148|  2.92k|                assert(new_indirect);
  ------------------
  |  Branch (148:17): [True: 2.92k, False: 0]
  ------------------
  149|  2.92k|                T* src = direct_ptr(0);
  150|  2.92k|                T* dst = reinterpret_cast<T*>(new_indirect);
  151|  2.92k|                memcpy(dst, src, size() * sizeof(T));
  152|  2.92k|                _union.indirect_contents.indirect = new_indirect;
  153|  2.92k|                _union.indirect_contents.capacity = new_capacity;
  154|  2.92k|                _size += N + 1;
  155|  2.92k|            }
  156|  15.7k|        }
  157|  16.1k|    }
_ZNK9prevectorILj36EhjiE3endEv:
  258|  4.95M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj36EhjiE8item_ptrEi:
  160|  5.02M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (160:59): [True: 67.1k, False: 4.96M]
  ------------------
_ZNK9prevectorILj36EhjiE10direct_ptrEi:
  123|  67.1k|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj36EhjiE12indirect_ptrEi:
  125|  4.96M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj36EhjiE4sizeEv:
  247|   121M|    size_type size() const {
  248|   121M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (248:16): [True: 105k, False: 120M]
  ------------------
  249|   121M|    }
_ZNK9prevectorILj36EhjiE5beginEv:
  256|  48.9k|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj36EhjiE14const_iteratordeEv:
   89|  22.2M|        const T& operator*() const { return *ptr; }
_ZNK9prevectorILj36EhjiEeqERKS0_:
  429|    184|    constexpr bool operator==(const prevector& other) const {
  430|    184|        return std::ranges::equal(*this, other);
  431|    184|    }
_ZNK9prevectorILj36EhjiE14const_iteratorssES1_:
  103|  4.14M|        auto operator<=>(const_iterator x) const { return ptr <=> x.ptr; }
_ZNK9prevectorILj36EhjiE14const_iteratorptEv:
   90|  2.27M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj36EhjiEC2Ev:
  196|  8.18k|    prevector() = default;
_ZN9prevectorILj36EhjiE6insertENS0_8iteratorERKh:
  307|  25.0M|    iterator insert(iterator pos, const T& value) {
  308|  25.0M|        size_type p = pos - begin();
  309|  25.0M|        size_type new_size = size() + 1;
  310|  25.0M|        if (capacity() < new_size) {
  ------------------
  |  Branch (310:13): [True: 1.17k, False: 25.0M]
  ------------------
  311|  1.17k|            change_capacity(new_size + (new_size >> 1));
  312|  1.17k|        }
  313|  25.0M|        T* ptr = item_ptr(p);
  314|  25.0M|        T* dst = ptr + 1;
  315|  25.0M|        memmove(dst, ptr, (size() - p) * sizeof(T));
  316|  25.0M|        _size++;
  317|  25.0M|        new(static_cast<void*>(ptr)) T(value);
  318|  25.0M|        return iterator(ptr);
  319|  25.0M|    }
_ZmiN9prevectorILj36EhjiE8iteratorES1_:
   68|  38.5M|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj36EhjiE8iteratordeEv:
   61|  77.1M|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj36EhjiE8capacityEv:
  260|  38.7M|    size_t capacity() const {
  261|  38.7M|        if (is_direct()) {
  ------------------
  |  Branch (261:13): [True: 13.0k, False: 38.6M]
  ------------------
  262|  13.0k|            return N;
  263|  38.6M|        } else {
  264|  38.6M|            return _union.indirect_contents.capacity;
  265|  38.6M|        }
  266|  38.7M|    }
_ZN9prevectorILj36EhjiE8iteratorC2EPh:
   60|   102M|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj36EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvNS0_8iteratorET_S8_:
  335|  12.7M|    void insert(iterator pos, InputIterator first, InputIterator last) {
  336|  12.7M|        size_type p = pos - begin();
  337|  12.7M|        difference_type count = last - first;
  338|  12.7M|        size_type new_size = size() + count;
  339|  12.7M|        if (capacity() < new_size) {
  ------------------
  |  Branch (339:13): [True: 11.6k, False: 12.7M]
  ------------------
  340|  11.6k|            change_capacity(new_size + (new_size >> 1));
  341|  11.6k|        }
  342|  12.7M|        T* ptr = item_ptr(p);
  343|  12.7M|        T* dst = ptr + count;
  344|  12.7M|        memmove(dst, ptr, (size() - p) * sizeof(T));
  345|  12.7M|        _size += count;
  346|  12.7M|        fill(ptr, first, last);
  347|  12.7M|    }
_ZN9prevectorILj36EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  167|  12.7M|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  1.57G|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 1.56G, False: 12.7M]
  ------------------
  169|  1.56G|            new(static_cast<void*>(dst)) T(*first);
  170|  1.56G|            ++dst;
  171|  1.56G|            ++first;
  172|  1.56G|        }
  173|  12.7M|    }
_ZN9prevectorILj36EhjiEC2ERKS0_:
  216|  1.26k|    prevector(const prevector<N, T, Size, Diff>& other) {
  217|  1.26k|        size_type n = other.size();
  218|  1.26k|        change_capacity(n);
  219|  1.26k|        _size += n;
  220|  1.26k|        fill(item_ptr(0), other.begin(),  other.end());
  221|  1.26k|    }
_ZN9prevectorILj36EhjiE3endEv:
  257|  38.5M|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj36EhjiE5beginEv:
  255|  38.5M|    iterator begin() { return iterator(item_ptr(0)); }
_ZN9prevectorILj36EhjiED2Ev:
  422|  9.82k|    ~prevector() {
  423|  9.82k|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 2.92k, False: 6.89k]
  ------------------
  424|  2.92k|            free(_union.indirect_contents.indirect);
  425|  2.92k|            _union.indirect_contents.indirect = nullptr;
  426|  2.92k|        }
  427|  9.82k|    }
_ZN9prevectorILj36EhjiE14const_iteratorC2EPKh:
   87|  6.12M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj36EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvS4_T_S6_:
  167|   729k|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  66.7M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 66.0M, False: 729k]
  ------------------
  169|  66.0M|            new(static_cast<void*>(dst)) T(*first);
  170|  66.0M|            ++dst;
  171|  66.0M|            ++first;
  172|  66.0M|        }
  173|   729k|    }
_ZNK9prevectorILj36EhjiE14const_iteratorplEj:
   97|   918k|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
_ZmiN9prevectorILj36EhjiE14const_iteratorES1_:
   96|  4.48M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj36EhjiE14const_iteratorppEi:
   94|  2.59M|        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }
_ZNK9prevectorILj36EhjiE14const_iteratorixEj:
   91|  20.6k|        const T& operator[](size_type pos) const { return ptr[pos]; }
_ZN9prevectorILj36EhjiE14const_iteratorpLEj:
   99|   777k|        const_iterator& operator+=(size_type n) { ptr += n; return *this; }

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

_ZNK7CPubKey16IsValidNonHybridEv:
  198|    611|    {
  199|    611|        return size() > 0 && (vch[0] == 0x02 || vch[0] == 0x03 || vch[0] == 0x04);
  ------------------
  |  Branch (199:16): [True: 611, False: 0]
  |  Branch (199:31): [True: 123, False: 488]
  |  Branch (199:49): [True: 168, False: 320]
  |  Branch (199:67): [True: 294, False: 26]
  ------------------
  200|    611|    }
_ZN7CPubKey9ValidSizeERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
   83|  3.53k|    bool static ValidSize(const std::vector<unsigned char> &vch) {
   84|  3.53k|      return vch.size() > 0 && GetLen(vch[0]) == vch.size();
  ------------------
  |  Branch (84:14): [True: 3.27k, False: 261]
  |  Branch (84:32): [True: 3.00k, False: 263]
  ------------------
   85|  3.53k|    }
_ZNK7CPubKey4dataEv:
  119|    698|    const unsigned char* data() const { return vch; }
_ZN7CPubKey6GetLenEh:
   67|  7.37k|    {
   68|  7.37k|        if (chHeader == 2 || chHeader == 3)
  ------------------
  |  Branch (68:13): [True: 2.31k, False: 5.05k]
  |  Branch (68:30): [True: 2.13k, False: 2.92k]
  ------------------
   69|  4.45k|            return COMPRESSED_SIZE;
   70|  2.92k|        if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  ------------------
  |  Branch (70:13): [True: 2.29k, False: 629]
  |  Branch (70:30): [True: 242, False: 387]
  |  Branch (70:47): [True: 157, False: 230]
  ------------------
   71|  2.69k|            return SIZE;
   72|    230|        return 0;
   73|  2.92k|    }
_ZN7CPubKey10InvalidateEv:
   77|    321|    {
   78|    321|        vch[0] = 0xFF;
   79|    321|    }
_ZN7CPubKeyC2ENSt3__14spanIKhLm18446744073709551615EEE:
  113|    937|    {
  114|    937|        Set(_vch.begin(), _vch.end());
  115|    937|    }
_ZNK7CPubKey4sizeEv:
  118|  2.53k|    unsigned int size() const { return GetLen(vch[0]); }
_ZNK7CPubKey7IsValidEv:
  192|     10|    {
  193|     10|        return size() > 0;
  194|     10|    }
_ZN7CPubKey3SetINSt3__111__wrap_iterIPKhEEEEvT_S6_:
   96|    937|    {
   97|    937|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (97:19): [True: 0, False: 937]
  ------------------
   98|    937|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (98:13): [True: 937, False: 0]
  |  Branch (98:20): [True: 937, False: 0]
  ------------------
   99|    937|            memcpy(vch, (unsigned char*)&pbegin[0], len);
  100|      0|        else
  101|      0|            Invalidate();
  102|    937|    }
_ZN7CPubKeyC2Ev:
   89|    321|    {
   90|    321|        Invalidate();
   91|    321|    }
_ZNK7CPubKey5GetIDEv:
  167|  1.21k|    {
  168|  1.21k|        return CKeyID(Hash160(std::span{vch}.first(size())));
  169|  1.21k|    }
_ZN6CKeyIDC2ERK7uint160:
   29|  1.22k|    explicit CKeyID(const uint160& in) : uint160(in) {}
_ZNK11XOnlyPubKey5beginEv:
  301|  1.05k|    const unsigned char* begin() const { return m_keydata.begin(); }
_ZNK11XOnlyPubKey3endEv:
  302|  1.05k|    const unsigned char* end() const { return m_keydata.end(); }
_ZN11XOnlyPubKeyC2Ev:
  244|  1.51k|    XOnlyPubKey() = default;
_ZN11XOnlyPubKey5beginEv:
  304|  1.05k|    unsigned char* begin() { return m_keydata.begin(); }
_ZN7CPubKey3SetIPhEEvT_S2_:
   96|    632|    {
   97|    632|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (97:19): [True: 0, False: 632]
  ------------------
   98|    632|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (98:13): [True: 632, False: 0]
  |  Branch (98:20): [True: 632, False: 0]
  ------------------
   99|    632|            memcpy(vch, (unsigned char*)&pbegin[0], len);
  100|      0|        else
  101|      0|            Invalidate();
  102|    632|    }

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

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

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

_Z22CheckSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE19script_verify_flagsP13ScriptError_t:
  211|  8.57k|bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, script_verify_flags flags, ScriptError* serror) {
  212|       |    // Empty signature. Not strictly DER encoded, but allowed to provide a
  213|       |    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
  214|  8.57k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (214:9): [True: 0, False: 8.57k]
  ------------------
  215|      0|        return true;
  216|      0|    }
  217|  8.57k|    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
  ------------------
  |  Branch (217:9): [True: 8.57k, False: 0]
  |  Branch (217:9): [True: 7.40k, False: 1.17k]
  |  Branch (217:98): [True: 7.40k, False: 1.17k]
  ------------------
  218|  7.40k|        return set_error(serror, SCRIPT_ERR_SIG_DER);
  219|  7.40k|    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
  ------------------
  |  Branch (219:16): [True: 0, False: 1.17k]
  |  Branch (219:16): [True: 0, False: 1.17k]
  |  Branch (219:54): [True: 0, False: 0]
  ------------------
  220|       |        // serror is set
  221|      0|        return false;
  222|  1.17k|    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
  ------------------
  |  Branch (222:16): [True: 1.17k, False: 0]
  |  Branch (222:16): [True: 743, False: 431]
  |  Branch (222:58): [True: 743, False: 431]
  ------------------
  223|    743|        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
  224|    743|    }
  225|    431|    return true;
  226|  8.57k|}
interpreter.cpp:_ZL24IsValidSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  118|  8.57k|bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
  119|       |    // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
  120|       |    // * total-length: 1-byte length descriptor of everything that follows,
  121|       |    //   excluding the sighash byte.
  122|       |    // * R-length: 1-byte length descriptor of the R value that follows.
  123|       |    // * R: arbitrary-length big-endian encoded R value. It must use the shortest
  124|       |    //   possible encoding for a positive integer (which means no null bytes at
  125|       |    //   the start, except a single one when the next byte has its highest bit set).
  126|       |    // * S-length: 1-byte length descriptor of the S value that follows.
  127|       |    // * S: arbitrary-length big-endian encoded S value. The same rules apply.
  128|       |    // * sighash: 1-byte value indicating what data is hashed (not part of the DER
  129|       |    //   signature)
  130|       |
  131|       |    // Minimum and maximum size constraints.
  132|  8.57k|    if (sig.size() < 9) return false;
  ------------------
  |  Branch (132:9): [True: 612, False: 7.96k]
  ------------------
  133|  7.96k|    if (sig.size() > 73) return false;
  ------------------
  |  Branch (133:9): [True: 1.08k, False: 6.87k]
  ------------------
  134|       |
  135|       |    // A signature is of type 0x30 (compound).
  136|  6.87k|    if (sig[0] != 0x30) return false;
  ------------------
  |  Branch (136:9): [True: 3.34k, False: 3.52k]
  ------------------
  137|       |
  138|       |    // Make sure the length covers the entire signature.
  139|  3.52k|    if (sig[1] != sig.size() - 3) return false;
  ------------------
  |  Branch (139:9): [True: 228, False: 3.29k]
  ------------------
  140|       |
  141|       |    // Extract the length of the R element.
  142|  3.29k|    unsigned int lenR = sig[3];
  143|       |
  144|       |    // Make sure the length of the S element is still inside the signature.
  145|  3.29k|    if (5 + lenR >= sig.size()) return false;
  ------------------
  |  Branch (145:9): [True: 202, False: 3.09k]
  ------------------
  146|       |
  147|       |    // Extract the length of the S element.
  148|  3.09k|    unsigned int lenS = sig[5 + lenR];
  149|       |
  150|       |    // Verify that the length of the signature matches the sum of the length
  151|       |    // of the elements.
  152|  3.09k|    if ((size_t)(lenR + lenS + 7) != sig.size()) return false;
  ------------------
  |  Branch (152:9): [True: 223, False: 2.87k]
  ------------------
  153|       |
  154|       |    // Check whether the R element is an integer.
  155|  2.87k|    if (sig[2] != 0x02) return false;
  ------------------
  |  Branch (155:9): [True: 215, False: 2.65k]
  ------------------
  156|       |
  157|       |    // Zero-length integers are not allowed for R.
  158|  2.65k|    if (lenR == 0) return false;
  ------------------
  |  Branch (158:9): [True: 208, False: 2.44k]
  ------------------
  159|       |
  160|       |    // Negative numbers are not allowed for R.
  161|  2.44k|    if (sig[4] & 0x80) return false;
  ------------------
  |  Branch (161:9): [True: 206, False: 2.24k]
  ------------------
  162|       |
  163|       |    // Null bytes at the start of R are not allowed, unless R would
  164|       |    // otherwise be interpreted as a negative number.
  165|  2.24k|    if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) return false;
  ------------------
  |  Branch (165:9): [True: 1.08k, False: 1.15k]
  |  Branch (165:21): [True: 488, False: 600]
  |  Branch (165:41): [True: 202, False: 286]
  ------------------
  166|       |
  167|       |    // Check whether the S element is an integer.
  168|  2.04k|    if (sig[lenR + 4] != 0x02) return false;
  ------------------
  |  Branch (168:9): [True: 273, False: 1.76k]
  ------------------
  169|       |
  170|       |    // Zero-length integers are not allowed for S.
  171|  1.76k|    if (lenS == 0) return false;
  ------------------
  |  Branch (171:9): [True: 195, False: 1.57k]
  ------------------
  172|       |
  173|       |    // Negative numbers are not allowed for S.
  174|  1.57k|    if (sig[lenR + 6] & 0x80) return false;
  ------------------
  |  Branch (174:9): [True: 202, False: 1.37k]
  ------------------
  175|       |
  176|       |    // Null bytes at the start of S are not allowed, unless S would otherwise be
  177|       |    // interpreted as a negative number.
  178|  1.37k|    if (lenS > 1 && (sig[lenR + 6] == 0x00) && !(sig[lenR + 7] & 0x80)) return false;
  ------------------
  |  Branch (178:9): [True: 918, False: 453]
  |  Branch (178:21): [True: 408, False: 510]
  |  Branch (178:48): [True: 197, False: 211]
  ------------------
  179|       |
  180|  1.17k|    return true;
  181|  1.37k|}
interpreter.cpp:_ZN12_GLOBAL__N_19set_errorEP13ScriptError_tS0_:
   38|  8.14k|{
   39|  8.14k|    if (ret)
  ------------------
  |  Branch (39:9): [True: 0, False: 8.14k]
  ------------------
   40|      0|        *ret = serror;
   41|  8.14k|    return false;
   42|  8.14k|}
interpreter.cpp:_ZL26IsDefinedHashtypeSignatureRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  200|  1.17k|bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
  201|  1.17k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (201:9): [True: 0, False: 1.17k]
  ------------------
  202|      0|        return false;
  203|      0|    }
  204|  1.17k|    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
  205|  1.17k|    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
  ------------------
  |  Branch (205:9): [True: 228, False: 946]
  |  Branch (205:36): [True: 515, False: 431]
  ------------------
  206|    743|        return false;
  207|       |
  208|    431|    return true;
  209|  1.17k|}

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

_Z9GetOpName10opcodetype:
   20|  1.84M|{
   21|  1.84M|    switch (opcode)
  ------------------
  |  Branch (21:13): [True: 1.82M, False: 12.4k]
  ------------------
   22|  1.84M|    {
   23|       |    // push value
   24|      0|    case OP_0                      : return "0";
  ------------------
  |  Branch (24:5): [True: 0, False: 1.84M]
  ------------------
   25|      0|    case OP_PUSHDATA1              : return "OP_PUSHDATA1";
  ------------------
  |  Branch (25:5): [True: 0, False: 1.84M]
  ------------------
   26|      0|    case OP_PUSHDATA2              : return "OP_PUSHDATA2";
  ------------------
  |  Branch (26:5): [True: 0, False: 1.84M]
  ------------------
   27|      0|    case OP_PUSHDATA4              : return "OP_PUSHDATA4";
  ------------------
  |  Branch (27:5): [True: 0, False: 1.84M]
  ------------------
   28|  1.24k|    case OP_1NEGATE                : return "-1";
  ------------------
  |  Branch (28:5): [True: 1.24k, False: 1.84M]
  ------------------
   29|  1.18k|    case OP_RESERVED               : return "OP_RESERVED";
  ------------------
  |  Branch (29:5): [True: 1.18k, False: 1.84M]
  ------------------
   30|  2.63k|    case OP_1                      : return "1";
  ------------------
  |  Branch (30:5): [True: 2.63k, False: 1.83M]
  ------------------
   31|  1.05k|    case OP_2                      : return "2";
  ------------------
  |  Branch (31:5): [True: 1.05k, False: 1.84M]
  ------------------
   32|    460|    case OP_3                      : return "3";
  ------------------
  |  Branch (32:5): [True: 460, False: 1.84M]
  ------------------
   33|    378|    case OP_4                      : return "4";
  ------------------
  |  Branch (33:5): [True: 378, False: 1.84M]
  ------------------
   34|    888|    case OP_5                      : return "5";
  ------------------
  |  Branch (34:5): [True: 888, False: 1.84M]
  ------------------
   35|    970|    case OP_6                      : return "6";
  ------------------
  |  Branch (35:5): [True: 970, False: 1.84M]
  ------------------
   36|    280|    case OP_7                      : return "7";
  ------------------
  |  Branch (36:5): [True: 280, False: 1.84M]
  ------------------
   37|    470|    case OP_8                      : return "8";
  ------------------
  |  Branch (37:5): [True: 470, False: 1.84M]
  ------------------
   38|  1.09k|    case OP_9                      : return "9";
  ------------------
  |  Branch (38:5): [True: 1.09k, False: 1.84M]
  ------------------
   39|  3.04k|    case OP_10                     : return "10";
  ------------------
  |  Branch (39:5): [True: 3.04k, False: 1.83M]
  ------------------
   40|  76.2k|    case OP_11                     : return "11";
  ------------------
  |  Branch (40:5): [True: 76.2k, False: 1.76M]
  ------------------
   41|    730|    case OP_12                     : return "12";
  ------------------
  |  Branch (41:5): [True: 730, False: 1.84M]
  ------------------
   42|  1.64k|    case OP_13                     : return "13";
  ------------------
  |  Branch (42:5): [True: 1.64k, False: 1.84M]
  ------------------
   43|    448|    case OP_14                     : return "14";
  ------------------
  |  Branch (43:5): [True: 448, False: 1.84M]
  ------------------
   44|  1.00k|    case OP_15                     : return "15";
  ------------------
  |  Branch (44:5): [True: 1.00k, False: 1.84M]
  ------------------
   45|  1.85k|    case OP_16                     : return "16";
  ------------------
  |  Branch (45:5): [True: 1.85k, False: 1.84M]
  ------------------
   46|       |
   47|       |    // control
   48|   918k|    case OP_NOP                    : return "OP_NOP";
  ------------------
  |  Branch (48:5): [True: 918k, False: 924k]
  ------------------
   49|  1.12k|    case OP_VER                    : return "OP_VER";
  ------------------
  |  Branch (49:5): [True: 1.12k, False: 1.84M]
  ------------------
   50|  1.71k|    case OP_IF                     : return "OP_IF";
  ------------------
  |  Branch (50:5): [True: 1.71k, False: 1.84M]
  ------------------
   51|  1.53k|    case OP_NOTIF                  : return "OP_NOTIF";
  ------------------
  |  Branch (51:5): [True: 1.53k, False: 1.84M]
  ------------------
   52|  3.24k|    case OP_VERIF                  : return "OP_VERIF";
  ------------------
  |  Branch (52:5): [True: 3.24k, False: 1.83M]
  ------------------
   53|  1.05k|    case OP_VERNOTIF               : return "OP_VERNOTIF";
  ------------------
  |  Branch (53:5): [True: 1.05k, False: 1.84M]
  ------------------
   54|  1.12k|    case OP_ELSE                   : return "OP_ELSE";
  ------------------
  |  Branch (54:5): [True: 1.12k, False: 1.84M]
  ------------------
   55|  1.26k|    case OP_ENDIF                  : return "OP_ENDIF";
  ------------------
  |  Branch (55:5): [True: 1.26k, False: 1.84M]
  ------------------
   56|  4.50k|    case OP_VERIFY                 : return "OP_VERIFY";
  ------------------
  |  Branch (56:5): [True: 4.50k, False: 1.83M]
  ------------------
   57|  1.81k|    case OP_RETURN                 : return "OP_RETURN";
  ------------------
  |  Branch (57:5): [True: 1.81k, False: 1.84M]
  ------------------
   58|       |
   59|       |    // stack ops
   60|  1.19k|    case OP_TOALTSTACK             : return "OP_TOALTSTACK";
  ------------------
  |  Branch (60:5): [True: 1.19k, False: 1.84M]
  ------------------
   61|  1.22k|    case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
  ------------------
  |  Branch (61:5): [True: 1.22k, False: 1.84M]
  ------------------
   62|  1.31k|    case OP_2DROP                  : return "OP_2DROP";
  ------------------
  |  Branch (62:5): [True: 1.31k, False: 1.84M]
  ------------------
   63|  1.27k|    case OP_2DUP                   : return "OP_2DUP";
  ------------------
  |  Branch (63:5): [True: 1.27k, False: 1.84M]
  ------------------
   64|  1.36k|    case OP_3DUP                   : return "OP_3DUP";
  ------------------
  |  Branch (64:5): [True: 1.36k, False: 1.84M]
  ------------------
   65|  1.58k|    case OP_2OVER                  : return "OP_2OVER";
  ------------------
  |  Branch (65:5): [True: 1.58k, False: 1.84M]
  ------------------
   66|  1.15k|    case OP_2ROT                   : return "OP_2ROT";
  ------------------
  |  Branch (66:5): [True: 1.15k, False: 1.84M]
  ------------------
   67|  1.24k|    case OP_2SWAP                  : return "OP_2SWAP";
  ------------------
  |  Branch (67:5): [True: 1.24k, False: 1.84M]
  ------------------
   68|  1.46k|    case OP_IFDUP                  : return "OP_IFDUP";
  ------------------
  |  Branch (68:5): [True: 1.46k, False: 1.84M]
  ------------------
   69|  6.24k|    case OP_DEPTH                  : return "OP_DEPTH";
  ------------------
  |  Branch (69:5): [True: 6.24k, False: 1.83M]
  ------------------
   70|  6.04k|    case OP_DROP                   : return "OP_DROP";
  ------------------
  |  Branch (70:5): [True: 6.04k, False: 1.83M]
  ------------------
   71|  1.41k|    case OP_DUP                    : return "OP_DUP";
  ------------------
  |  Branch (71:5): [True: 1.41k, False: 1.84M]
  ------------------
   72|  1.29k|    case OP_NIP                    : return "OP_NIP";
  ------------------
  |  Branch (72:5): [True: 1.29k, False: 1.84M]
  ------------------
   73|  3.72k|    case OP_OVER                   : return "OP_OVER";
  ------------------
  |  Branch (73:5): [True: 3.72k, False: 1.83M]
  ------------------
   74|  1.24k|    case OP_PICK                   : return "OP_PICK";
  ------------------
  |  Branch (74:5): [True: 1.24k, False: 1.84M]
  ------------------
   75|  1.43k|    case OP_ROLL                   : return "OP_ROLL";
  ------------------
  |  Branch (75:5): [True: 1.43k, False: 1.84M]
  ------------------
   76|  1.56k|    case OP_ROT                    : return "OP_ROT";
  ------------------
  |  Branch (76:5): [True: 1.56k, False: 1.84M]
  ------------------
   77|  1.59k|    case OP_SWAP                   : return "OP_SWAP";
  ------------------
  |  Branch (77:5): [True: 1.59k, False: 1.84M]
  ------------------
   78|  1.11k|    case OP_TUCK                   : return "OP_TUCK";
  ------------------
  |  Branch (78:5): [True: 1.11k, False: 1.84M]
  ------------------
   79|       |
   80|       |    // splice ops
   81|  1.77k|    case OP_CAT                    : return "OP_CAT";
  ------------------
  |  Branch (81:5): [True: 1.77k, False: 1.84M]
  ------------------
   82|   239k|    case OP_SUBSTR                 : return "OP_SUBSTR";
  ------------------
  |  Branch (82:5): [True: 239k, False: 1.60M]
  ------------------
   83|  2.30k|    case OP_LEFT                   : return "OP_LEFT";
  ------------------
  |  Branch (83:5): [True: 2.30k, False: 1.83M]
  ------------------
   84|  2.02k|    case OP_RIGHT                  : return "OP_RIGHT";
  ------------------
  |  Branch (84:5): [True: 2.02k, False: 1.84M]
  ------------------
   85|  1.28k|    case OP_SIZE                   : return "OP_SIZE";
  ------------------
  |  Branch (85:5): [True: 1.28k, False: 1.84M]
  ------------------
   86|       |
   87|       |    // bit logic
   88|  1.11k|    case OP_INVERT                 : return "OP_INVERT";
  ------------------
  |  Branch (88:5): [True: 1.11k, False: 1.84M]
  ------------------
   89|  1.23k|    case OP_AND                    : return "OP_AND";
  ------------------
  |  Branch (89:5): [True: 1.23k, False: 1.84M]
  ------------------
   90|  1.44k|    case OP_OR                     : return "OP_OR";
  ------------------
  |  Branch (90:5): [True: 1.44k, False: 1.84M]
  ------------------
   91|  1.29k|    case OP_XOR                    : return "OP_XOR";
  ------------------
  |  Branch (91:5): [True: 1.29k, False: 1.84M]
  ------------------
   92|  1.15k|    case OP_EQUAL                  : return "OP_EQUAL";
  ------------------
  |  Branch (92:5): [True: 1.15k, False: 1.84M]
  ------------------
   93|  1.36k|    case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
  ------------------
  |  Branch (93:5): [True: 1.36k, False: 1.84M]
  ------------------
   94|  1.15k|    case OP_RESERVED1              : return "OP_RESERVED1";
  ------------------
  |  Branch (94:5): [True: 1.15k, False: 1.84M]
  ------------------
   95|  1.32k|    case OP_RESERVED2              : return "OP_RESERVED2";
  ------------------
  |  Branch (95:5): [True: 1.32k, False: 1.84M]
  ------------------
   96|       |
   97|       |    // numeric
   98|  1.49k|    case OP_1ADD                   : return "OP_1ADD";
  ------------------
  |  Branch (98:5): [True: 1.49k, False: 1.84M]
  ------------------
   99|  1.17k|    case OP_1SUB                   : return "OP_1SUB";
  ------------------
  |  Branch (99:5): [True: 1.17k, False: 1.84M]
  ------------------
  100|  1.43k|    case OP_2MUL                   : return "OP_2MUL";
  ------------------
  |  Branch (100:5): [True: 1.43k, False: 1.84M]
  ------------------
  101|  1.61k|    case OP_2DIV                   : return "OP_2DIV";
  ------------------
  |  Branch (101:5): [True: 1.61k, False: 1.84M]
  ------------------
  102|  1.57k|    case OP_NEGATE                 : return "OP_NEGATE";
  ------------------
  |  Branch (102:5): [True: 1.57k, False: 1.84M]
  ------------------
  103|  1.24k|    case OP_ABS                    : return "OP_ABS";
  ------------------
  |  Branch (103:5): [True: 1.24k, False: 1.84M]
  ------------------
  104|  1.47k|    case OP_NOT                    : return "OP_NOT";
  ------------------
  |  Branch (104:5): [True: 1.47k, False: 1.84M]
  ------------------
  105|  1.99k|    case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
  ------------------
  |  Branch (105:5): [True: 1.99k, False: 1.84M]
  ------------------
  106|  1.31k|    case OP_ADD                    : return "OP_ADD";
  ------------------
  |  Branch (106:5): [True: 1.31k, False: 1.84M]
  ------------------
  107|  1.50k|    case OP_SUB                    : return "OP_SUB";
  ------------------
  |  Branch (107:5): [True: 1.50k, False: 1.84M]
  ------------------
  108|  1.07k|    case OP_MUL                    : return "OP_MUL";
  ------------------
  |  Branch (108:5): [True: 1.07k, False: 1.84M]
  ------------------
  109|  1.06k|    case OP_DIV                    : return "OP_DIV";
  ------------------
  |  Branch (109:5): [True: 1.06k, False: 1.84M]
  ------------------
  110|  1.09k|    case OP_MOD                    : return "OP_MOD";
  ------------------
  |  Branch (110:5): [True: 1.09k, False: 1.84M]
  ------------------
  111|  1.37k|    case OP_LSHIFT                 : return "OP_LSHIFT";
  ------------------
  |  Branch (111:5): [True: 1.37k, False: 1.84M]
  ------------------
  112|  1.37k|    case OP_RSHIFT                 : return "OP_RSHIFT";
  ------------------
  |  Branch (112:5): [True: 1.37k, False: 1.84M]
  ------------------
  113|  1.42k|    case OP_BOOLAND                : return "OP_BOOLAND";
  ------------------
  |  Branch (113:5): [True: 1.42k, False: 1.84M]
  ------------------
  114|  1.32k|    case OP_BOOLOR                 : return "OP_BOOLOR";
  ------------------
  |  Branch (114:5): [True: 1.32k, False: 1.84M]
  ------------------
  115|  1.17k|    case OP_NUMEQUAL               : return "OP_NUMEQUAL";
  ------------------
  |  Branch (115:5): [True: 1.17k, False: 1.84M]
  ------------------
  116|  1.68k|    case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
  ------------------
  |  Branch (116:5): [True: 1.68k, False: 1.84M]
  ------------------
  117|  1.14k|    case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
  ------------------
  |  Branch (117:5): [True: 1.14k, False: 1.84M]
  ------------------
  118|  1.31k|    case OP_LESSTHAN               : return "OP_LESSTHAN";
  ------------------
  |  Branch (118:5): [True: 1.31k, False: 1.84M]
  ------------------
  119|  1.26k|    case OP_GREATERTHAN            : return "OP_GREATERTHAN";
  ------------------
  |  Branch (119:5): [True: 1.26k, False: 1.84M]
  ------------------
  120|  1.82k|    case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
  ------------------
  |  Branch (120:5): [True: 1.82k, False: 1.84M]
  ------------------
  121|  1.64k|    case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
  ------------------
  |  Branch (121:5): [True: 1.64k, False: 1.84M]
  ------------------
  122|  1.29k|    case OP_MIN                    : return "OP_MIN";
  ------------------
  |  Branch (122:5): [True: 1.29k, False: 1.84M]
  ------------------
  123|  1.11k|    case OP_MAX                    : return "OP_MAX";
  ------------------
  |  Branch (123:5): [True: 1.11k, False: 1.84M]
  ------------------
  124|  1.17k|    case OP_WITHIN                 : return "OP_WITHIN";
  ------------------
  |  Branch (124:5): [True: 1.17k, False: 1.84M]
  ------------------
  125|       |
  126|       |    // crypto
  127|  6.07k|    case OP_RIPEMD160              : return "OP_RIPEMD160";
  ------------------
  |  Branch (127:5): [True: 6.07k, False: 1.83M]
  ------------------
  128|  1.40k|    case OP_SHA1                   : return "OP_SHA1";
  ------------------
  |  Branch (128:5): [True: 1.40k, False: 1.84M]
  ------------------
  129|  2.06k|    case OP_SHA256                 : return "OP_SHA256";
  ------------------
  |  Branch (129:5): [True: 2.06k, False: 1.84M]
  ------------------
  130|  1.79k|    case OP_HASH160                : return "OP_HASH160";
  ------------------
  |  Branch (130:5): [True: 1.79k, False: 1.84M]
  ------------------
  131|  1.54k|    case OP_HASH256                : return "OP_HASH256";
  ------------------
  |  Branch (131:5): [True: 1.54k, False: 1.84M]
  ------------------
  132|  1.40k|    case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
  ------------------
  |  Branch (132:5): [True: 1.40k, False: 1.84M]
  ------------------
  133|  1.29k|    case OP_CHECKSIG               : return "OP_CHECKSIG";
  ------------------
  |  Branch (133:5): [True: 1.29k, False: 1.84M]
  ------------------
  134|  1.77k|    case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
  ------------------
  |  Branch (134:5): [True: 1.77k, False: 1.84M]
  ------------------
  135|  7.26k|    case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
  ------------------
  |  Branch (135:5): [True: 7.26k, False: 1.83M]
  ------------------
  136|  26.6k|    case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  ------------------
  |  Branch (136:5): [True: 26.6k, False: 1.81M]
  ------------------
  137|       |
  138|       |    // expansion
  139|  1.42k|    case OP_NOP1                   : return "OP_NOP1";
  ------------------
  |  Branch (139:5): [True: 1.42k, False: 1.84M]
  ------------------
  140|   356k|    case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
  ------------------
  |  Branch (140:5): [True: 356k, False: 1.48M]
  ------------------
  141|  2.00k|    case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
  ------------------
  |  Branch (141:5): [True: 2.00k, False: 1.84M]
  ------------------
  142|  1.78k|    case OP_NOP4                   : return "OP_NOP4";
  ------------------
  |  Branch (142:5): [True: 1.78k, False: 1.84M]
  ------------------
  143|  22.2k|    case OP_NOP5                   : return "OP_NOP5";
  ------------------
  |  Branch (143:5): [True: 22.2k, False: 1.81M]
  ------------------
  144|  1.53k|    case OP_NOP6                   : return "OP_NOP6";
  ------------------
  |  Branch (144:5): [True: 1.53k, False: 1.84M]
  ------------------
  145|  1.14k|    case OP_NOP7                   : return "OP_NOP7";
  ------------------
  |  Branch (145:5): [True: 1.14k, False: 1.84M]
  ------------------
  146|  1.29k|    case OP_NOP8                   : return "OP_NOP8";
  ------------------
  |  Branch (146:5): [True: 1.29k, False: 1.84M]
  ------------------
  147|  1.10k|    case OP_NOP9                   : return "OP_NOP9";
  ------------------
  |  Branch (147:5): [True: 1.10k, False: 1.84M]
  ------------------
  148|  1.26k|    case OP_NOP10                  : return "OP_NOP10";
  ------------------
  |  Branch (148:5): [True: 1.26k, False: 1.84M]
  ------------------
  149|       |
  150|       |    // Opcode added by BIP 342 (Tapscript)
  151|    406|    case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
  ------------------
  |  Branch (151:5): [True: 406, False: 1.84M]
  ------------------
  152|       |
  153|  24.6k|    case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
  ------------------
  |  Branch (153:5): [True: 24.6k, False: 1.81M]
  ------------------
  154|       |
  155|  1.84M|    } // no default case, so the compiler can warn about missing cases
  156|  12.4k|    return "OP_UNKNOWN";
  157|  1.84M|}
_ZNK7CScript13IsPayToAnchorEv:
  208|    168|{
  209|    168|    return (this->size() == 4 &&
  ------------------
  |  Branch (209:13): [True: 52, False: 116]
  ------------------
  210|     52|        (*this)[0] == OP_1 &&
  ------------------
  |  Branch (210:9): [True: 40, False: 12]
  ------------------
  211|     40|        (*this)[1] == 0x02 &&
  ------------------
  |  Branch (211:9): [True: 40, False: 0]
  ------------------
  212|     40|        (*this)[2] == 0x4e &&
  ------------------
  |  Branch (212:9): [True: 12, False: 28]
  ------------------
  213|     12|        (*this)[3] == 0x73);
  ------------------
  |  Branch (213:9): [True: 5, False: 7]
  ------------------
  214|    168|}
_ZN7CScript13IsPayToAnchorEiRKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  217|      2|{
  218|      2|    return version == 1 &&
  ------------------
  |  Branch (218:12): [True: 2, False: 0]
  ------------------
  219|      2|        program.size() == 2 &&
  ------------------
  |  Branch (219:9): [True: 2, False: 0]
  ------------------
  220|      2|        program[0] == 0x4e &&
  ------------------
  |  Branch (220:9): [True: 2, False: 0]
  ------------------
  221|      2|        program[1] == 0x73;
  ------------------
  |  Branch (221:9): [True: 2, False: 0]
  ------------------
  222|      2|}
_ZNK7CScript17IsPayToScriptHashEv:
  225|  5.94k|{
  226|       |    // Extra-fast test for pay-to-script-hash CScripts:
  227|  5.94k|    return (this->size() == 23 &&
  ------------------
  |  Branch (227:13): [True: 67, False: 5.87k]
  ------------------
  228|     67|            (*this)[0] == OP_HASH160 &&
  ------------------
  |  Branch (228:13): [True: 42, False: 25]
  ------------------
  229|     42|            (*this)[1] == 0x14 &&
  ------------------
  |  Branch (229:13): [True: 29, False: 13]
  ------------------
  230|     29|            (*this)[22] == OP_EQUAL);
  ------------------
  |  Branch (230:13): [True: 21, False: 8]
  ------------------
  231|  5.94k|}
_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  251|  5.92k|{
  252|  5.92k|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (252:9): [True: 591, False: 5.33k]
  |  Branch (252:29): [True: 2.65k, False: 2.67k]
  ------------------
  253|  3.24k|        return false;
  254|  3.24k|    }
  255|  2.67k|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (255:9): [True: 2.63k, False: 44]
  |  Branch (255:32): [True: 667, False: 1.96k]
  |  Branch (255:53): [True: 242, False: 1.72k]
  ------------------
  256|    909|        return false;
  257|    909|    }
  258|  1.76k|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (258:9): [True: 1.69k, False: 75]
  ------------------
  259|  1.69k|        version = DecodeOP_N((opcodetype)(*this)[0]);
  260|  1.69k|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  261|  1.69k|        return true;
  262|  1.69k|    }
  263|     75|    return false;
  264|  1.76k|}
_ZNK7CScript10IsPushOnlyEN9prevectorILj36EhjiE14const_iteratorE:
  267|    271|{
  268|  50.4k|    while (pc < end())
  ------------------
  |  Branch (268:12): [True: 50.4k, False: 64]
  ------------------
  269|  50.4k|    {
  270|  50.4k|        opcodetype opcode;
  271|  50.4k|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (271:13): [True: 138, False: 50.2k]
  ------------------
  272|    138|            return false;
  273|       |        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
  274|       |        // push-type opcode, however execution of OP_RESERVED fails, so
  275|       |        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
  276|       |        // the P2SH special validation code being executed.
  277|  50.2k|        if (opcode > OP_16)
  ------------------
  |  Branch (277:13): [True: 69, False: 50.2k]
  ------------------
  278|     69|            return false;
  279|  50.2k|    }
  280|     64|    return true;
  281|    271|}
_Z11GetScriptOpRN9prevectorILj36EhjiE14const_iteratorES1_R10opcodetypePNSt3__16vectorIhNS5_9allocatorIhEEEE:
  314|  2.47M|{
  315|  2.47M|    opcodeRet = OP_INVALIDOPCODE;
  316|  2.47M|    if (pvchRet)
  ------------------
  |  Branch (316:9): [True: 2.42M, False: 50.4k]
  ------------------
  317|  2.42M|        pvchRet->clear();
  318|  2.47M|    if (pc >= end)
  ------------------
  |  Branch (318:9): [True: 6, False: 2.47M]
  ------------------
  319|      6|        return false;
  320|       |
  321|       |    // Read instruction
  322|  2.47M|    if (end - pc < 1)
  ------------------
  |  Branch (322:9): [True: 0, False: 2.47M]
  ------------------
  323|      0|        return false;
  324|  2.47M|    unsigned int opcode = *pc++;
  325|       |
  326|       |    // Immediate operand
  327|  2.47M|    if (opcode <= OP_PUSHDATA4)
  ------------------
  |  Branch (327:9): [True: 564k, False: 1.91M]
  ------------------
  328|   564k|    {
  329|   564k|        unsigned int nSize = 0;
  330|   564k|        if (opcode < OP_PUSHDATA1)
  ------------------
  |  Branch (330:13): [True: 423k, False: 141k]
  ------------------
  331|   423k|        {
  332|   423k|            nSize = opcode;
  333|   423k|        }
  334|   141k|        else if (opcode == OP_PUSHDATA1)
  ------------------
  |  Branch (334:18): [True: 120k, False: 20.6k]
  ------------------
  335|   120k|        {
  336|   120k|            if (end - pc < 1)
  ------------------
  |  Branch (336:17): [True: 17, False: 120k]
  ------------------
  337|     17|                return false;
  338|   120k|            nSize = *pc++;
  339|   120k|        }
  340|  20.6k|        else if (opcode == OP_PUSHDATA2)
  ------------------
  |  Branch (340:18): [True: 5.94k, False: 14.7k]
  ------------------
  341|  5.94k|        {
  342|  5.94k|            if (end - pc < 2)
  ------------------
  |  Branch (342:17): [True: 28, False: 5.92k]
  ------------------
  343|     28|                return false;
  344|  5.92k|            nSize = ReadLE16(&pc[0]);
  345|  5.92k|            pc += 2;
  346|  5.92k|        }
  347|  14.7k|        else if (opcode == OP_PUSHDATA4)
  ------------------
  |  Branch (347:18): [True: 14.7k, False: 0]
  ------------------
  348|  14.7k|        {
  349|  14.7k|            if (end - pc < 4)
  ------------------
  |  Branch (349:17): [True: 42, False: 14.6k]
  ------------------
  350|     42|                return false;
  351|  14.6k|            nSize = ReadLE32(&pc[0]);
  352|  14.6k|            pc += 4;
  353|  14.6k|        }
  354|   564k|        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  ------------------
  |  Branch (354:13): [True: 0, False: 564k]
  |  Branch (354:29): [True: 2.04k, False: 562k]
  ------------------
  355|  2.04k|            return false;
  356|   562k|        if (pvchRet)
  ------------------
  |  Branch (356:13): [True: 513k, False: 48.6k]
  ------------------
  357|   513k|            pvchRet->assign(pc, pc + nSize);
  358|   562k|        pc += nSize;
  359|   562k|    }
  360|       |
  361|  2.47M|    opcodeRet = static_cast<opcodetype>(opcode);
  362|  2.47M|    return true;
  363|  2.47M|}
_Z16CheckMinimalPushRKNSt3__16vectorIhNS_9allocatorIhEEEE10opcodetype:
  373|    504|bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
  374|       |    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
  375|    504|    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  ------------------
  |  Branch (375:5): [True: 504, False: 0]
  |  Branch (375:5): [True: 504, False: 0]
  |  Branch (375:5): [True: 504, False: 0]
  ------------------
  376|    504|    if (data.size() == 0) {
  ------------------
  |  Branch (376:9): [True: 7, False: 497]
  ------------------
  377|       |        // Should have used OP_0.
  378|      7|        return opcode == OP_0;
  379|    497|    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  ------------------
  |  Branch (379:16): [True: 217, False: 280]
  |  Branch (379:36): [True: 211, False: 6]
  |  Branch (379:52): [True: 12, False: 199]
  ------------------
  380|       |        // Should have used OP_1 .. OP_16.
  381|     12|        return false;
  382|    485|    } else if (data.size() == 1 && data[0] == 0x81) {
  ------------------
  |  Branch (382:16): [True: 205, False: 280]
  |  Branch (382:36): [True: 5, False: 200]
  ------------------
  383|       |        // Should have used OP_1NEGATE.
  384|      5|        return false;
  385|    480|    } else if (data.size() <= 75) {
  ------------------
  |  Branch (385:16): [True: 356, False: 124]
  ------------------
  386|       |        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
  387|    356|        return opcode == data.size();
  388|    356|    } else if (data.size() <= 255) {
  ------------------
  |  Branch (388:16): [True: 39, False: 85]
  ------------------
  389|       |        // Must have used OP_PUSHDATA.
  390|     39|        return opcode == OP_PUSHDATA1;
  391|     85|    } else if (data.size() <= 65535) {
  ------------------
  |  Branch (391:16): [True: 80, False: 5]
  ------------------
  392|       |        // Must have used OP_PUSHDATA2.
  393|     80|        return opcode == OP_PUSHDATA2;
  394|     80|    }
  395|      5|    return true;
  396|    504|}

_Z12ToByteVectorI6PKHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|      4|{
   70|      4|    return std::vector<unsigned char>(in.begin(), in.end());
   71|      4|}
_Z12ToByteVectorI10ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|      5|{
   70|      5|    return std::vector<unsigned char>(in.begin(), in.end());
   71|      5|}
_Z12ToByteVectorI19WitnessV0ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|      1|{
   70|      1|    return std::vector<unsigned char>(in.begin(), in.end());
   71|      1|}
_Z12ToByteVectorI16WitnessV0KeyHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|      1|{
   70|      1|    return std::vector<unsigned char>(in.begin(), in.end());
   71|      1|}
_Z12ToByteVectorI16WitnessV1TaprootENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   69|    141|{
   70|    141|    return std::vector<unsigned char>(in.begin(), in.end());
   71|    141|}
_ZN7CScript10EncodeOP_NEi:
  516|     32|    {
  517|     32|        assert(n >= 0 && n <= 16);
  ------------------
  |  Branch (517:9): [True: 32, False: 0]
  |  Branch (517:9): [True: 32, False: 0]
  |  Branch (517:9): [True: 32, False: 0]
  ------------------
  518|     32|        if (n == 0)
  ------------------
  |  Branch (518:13): [True: 0, False: 32]
  ------------------
  519|      0|            return OP_0;
  520|     32|        return (opcodetype)(OP_1+n-1);
  521|     32|    }
_ZN9CScriptIDC2ERK7uint160:
  601|      6|    explicit CScriptID(const uint160& in) : BaseHash(in) {}
_ZN7CScriptlsERK10CScriptNum:
  479|  26.4k|    {
  480|  26.4k|        *this << b.getvch();
  481|  26.4k|        return *this;
  482|  26.4k|    }
_ZNK7CScript13IsUnspendableEv:
  565|  30.0k|    {
  566|  30.0k|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (566:17): [True: 30.0k, False: 0]
  |  Branch (566:31): [True: 1.62k, False: 28.4k]
  |  Branch (566:57): [True: 19.9k, False: 8.57k]
  ------------------
  567|  30.0k|    }
_ZN7CScriptlsEl:
  468|   215k|    CScript& operator<<(int64_t b) LIFETIMEBOUND { return push_int64(b); }
_ZN7CScript10push_int64El:
  435|   215k|    {
  436|   215k|        if (n == -1 || (n >= 1 && n <= 16))
  ------------------
  |  Branch (436:13): [True: 264, False: 215k]
  |  Branch (436:25): [True: 58.6k, False: 156k]
  |  Branch (436:35): [True: 51.3k, False: 7.31k]
  ------------------
  437|  51.5k|        {
  438|  51.5k|            push_back(n + (OP_1 - 1));
  439|  51.5k|        }
  440|   163k|        else if (n == 0)
  ------------------
  |  Branch (440:18): [True: 93.7k, False: 70.1k]
  ------------------
  441|  93.7k|        {
  442|  93.7k|            push_back(OP_0);
  443|  93.7k|        }
  444|  70.1k|        else
  445|  70.1k|        {
  446|  70.1k|            *this << CScriptNum::serialize(n);
  447|  70.1k|        }
  448|   215k|        return *this;
  449|   215k|    }
_ZNK7CScript5GetOpERN9prevectorILj36EhjiE14const_iteratorER10opcodetypeRNSt3__16vectorIhNS6_9allocatorIhEEEE:
  498|  2.42M|    {
  499|  2.42M|        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
  500|  2.42M|    }
_ZNK7CScript5GetOpERN9prevectorILj36EhjiE14const_iteratorER10opcodetype:
  503|  50.4k|    {
  504|  50.4k|        return GetScriptOp(pc, end(), opcodeRet, nullptr);
  505|  50.4k|    }
_ZN7CScriptC2Ev:
  452|  8.18k|    CScript() = default;
_ZN10CScriptNumC2ERKl:
  240|  26.4k|    {
  241|  26.4k|        m_value = n;
  242|  26.4k|    }
_ZNK10CScriptNum6getvchEv:
  338|  26.4k|    {
  339|  26.4k|        return serialize(m_value);
  340|  26.4k|    }
_ZN10CScriptNum9serializeERKl:
  343|  96.5k|    {
  344|  96.5k|        if(value == 0)
  ------------------
  |  Branch (344:12): [True: 349, False: 96.2k]
  ------------------
  345|    349|            return std::vector<unsigned char>();
  346|       |
  347|  96.2k|        std::vector<unsigned char> result;
  348|  96.2k|        const bool neg = value < 0;
  349|  96.2k|        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
  ------------------
  |  Branch (349:29): [True: 88.0k, False: 8.22k]
  ------------------
  350|       |
  351|   736k|        while(absvalue)
  ------------------
  |  Branch (351:15): [True: 640k, False: 96.2k]
  ------------------
  352|   640k|        {
  353|   640k|            result.push_back(absvalue & 0xff);
  354|   640k|            absvalue >>= 8;
  355|   640k|        }
  356|       |
  357|       |//    - If the most significant byte is >= 0x80 and the value is positive, push a
  358|       |//    new zero-byte to make the significant byte < 0x80 again.
  359|       |
  360|       |//    - If the most significant byte is >= 0x80 and the value is negative, push a
  361|       |//    new 0x80 byte that will be popped off when converting to an integral.
  362|       |
  363|       |//    - If the most significant byte is < 0x80 and the value is negative, add
  364|       |//    0x80 to it, since it will be subtracted and interpreted as a negative when
  365|       |//    converting to an integral.
  366|       |
  367|  96.2k|        if (result.back() & 0x80)
  ------------------
  |  Branch (367:13): [True: 80.8k, False: 15.3k]
  ------------------
  368|  80.8k|            result.push_back(neg ? 0x80 : 0);
  ------------------
  |  Branch (368:30): [True: 80.5k, False: 306]
  ------------------
  369|  15.3k|        else if (neg)
  ------------------
  |  Branch (369:18): [True: 7.45k, False: 7.92k]
  ------------------
  370|  7.45k|            result.back() |= 0x80;
  371|       |
  372|  96.2k|        return result;
  373|  96.5k|    }
_ZN10CScriptNumC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEEbm:
  248|   180k|    {
  249|   180k|        if (vch.size() > nMaxNumSize) {
  ------------------
  |  Branch (249:13): [True: 117, False: 180k]
  ------------------
  250|    117|            throw scriptnum_error("script number overflow");
  251|    117|        }
  252|   180k|        if (fRequireMinimal && vch.size() > 0) {
  ------------------
  |  Branch (252:13): [True: 326, False: 180k]
  |  Branch (252:32): [True: 326, False: 0]
  ------------------
  253|       |            // Check that the number is encoded with the minimum possible
  254|       |            // number of bytes.
  255|       |            //
  256|       |            // If the most-significant-byte - excluding the sign bit - is zero
  257|       |            // then we're not minimal. Note how this test also rejects the
  258|       |            // negative-zero encoding, 0x80.
  259|    326|            if ((vch.back() & 0x7f) == 0) {
  ------------------
  |  Branch (259:17): [True: 34, False: 292]
  ------------------
  260|       |                // One exception: if there's more than one byte and the most
  261|       |                // significant bit of the second-most-significant-byte is set
  262|       |                // it would conflict with the sign bit. An example of this case
  263|       |                // is +-255, which encode to 0xff00 and 0xff80 respectively.
  264|       |                // (big-endian).
  265|     34|                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
  ------------------
  |  Branch (265:21): [True: 6, False: 28]
  |  Branch (265:40): [True: 6, False: 22]
  ------------------
  266|     12|                    throw scriptnum_error("non-minimally encoded script number");
  267|     12|                }
  268|     34|            }
  269|    326|        }
  270|   180k|        m_value = set_vch(vch);
  271|   180k|    }
_ZN15scriptnum_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  224|    129|    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
_ZN10CScriptNum7set_vchERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  377|   180k|    {
  378|   180k|      if (vch.empty())
  ------------------
  |  Branch (378:11): [True: 137k, False: 42.4k]
  ------------------
  379|   137k|          return 0;
  380|       |
  381|  42.4k|      int64_t result = 0;
  382|   103k|      for (size_t i = 0; i != vch.size(); ++i)
  ------------------
  |  Branch (382:26): [True: 60.6k, False: 42.4k]
  ------------------
  383|  60.6k|          result |= static_cast<int64_t>(vch[i]) << 8*i;
  384|       |
  385|       |      // If the input vector's most significant byte is 0x80, remove it from
  386|       |      // the result's msb and return a negative.
  387|  42.4k|      if (vch.back() & 0x80)
  ------------------
  |  Branch (387:11): [True: 23.4k, False: 19.0k]
  ------------------
  388|  23.4k|          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
  389|       |
  390|  19.0k|      return result;
  391|  42.4k|    }
_ZNK10CScriptNum6getintEv:
  327|   180k|    {
  328|   180k|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (328:13): [True: 0, False: 180k]
  ------------------
  329|      0|            return std::numeric_limits<int>::max();
  330|   180k|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (330:18): [True: 0, False: 180k]
  ------------------
  331|      0|            return std::numeric_limits<int>::min();
  332|   180k|        return m_value;
  333|   180k|    }
_ZN7CScriptlsENSt3__14spanIKhLm18446744073709551615EEE:
  493|  12.7M|    {
  494|  12.7M|        return *this << std::as_bytes(b);
  495|  12.7M|    }
_ZN7CScriptlsENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  485|  12.7M|    {
  486|  12.7M|        AppendDataSize(b.size());
  487|  12.7M|        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
  488|  12.7M|        return *this;
  489|  12.7M|    }
_ZN7CScript14AppendDataSizeEj:
  409|  12.7M|    {
  410|  12.7M|        if (size < OP_PUSHDATA1) {
  ------------------
  |  Branch (410:13): [True: 598k, False: 12.1M]
  ------------------
  411|   598k|            insert(end(), static_cast<value_type>(size));
  412|  12.1M|        } else if (size <= 0xff) {
  ------------------
  |  Branch (412:20): [True: 12.1M, False: 0]
  ------------------
  413|  12.1M|            insert(end(), OP_PUSHDATA1);
  414|  12.1M|            insert(end(), static_cast<value_type>(size));
  415|  12.1M|        } else if (size <= 0xffff) {
  ------------------
  |  Branch (415:20): [True: 0, False: 0]
  ------------------
  416|      0|            insert(end(), OP_PUSHDATA2);
  417|      0|            value_type data[2];
  418|      0|            WriteLE16(data, size);
  419|      0|            insert(end(), std::cbegin(data), std::cend(data));
  420|      0|        } else {
  421|      0|            insert(end(), OP_PUSHDATA4);
  422|      0|            value_type data[4];
  423|      0|            WriteLE32(data, size);
  424|      0|            insert(end(), std::cbegin(data), std::cend(data));
  425|      0|        }
  426|  12.7M|    }
_ZN7CScript10AppendDataENSt3__14spanIKhLm18446744073709551615EEE:
  429|  12.7M|    {
  430|  12.7M|        insert(end(), data.begin(), data.end());
  431|  12.7M|    }
_ZN7CScriptlsE10opcodetype:
  471|   144k|    {
  472|   144k|        if (opcode < 0 || opcode > 0xff)
  ------------------
  |  Branch (472:13): [True: 0, False: 144k]
  |  Branch (472:27): [True: 0, False: 144k]
  ------------------
  473|      0|            throw std::runtime_error("CScript::operator<<(): invalid opcode");
  474|   144k|        insert(end(), (unsigned char)opcode);
  475|   144k|        return *this;
  476|   144k|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  509|  2.35k|    {
  510|  2.35k|        if (opcode == OP_0)
  ------------------
  |  Branch (510:13): [True: 25, False: 2.32k]
  ------------------
  511|     25|            return 0;
  512|  2.35k|        assert(opcode >= OP_1 && opcode <= OP_16);
  ------------------
  |  Branch (512:9): [True: 2.32k, False: 0]
  |  Branch (512:9): [True: 2.32k, False: 0]
  |  Branch (512:9): [True: 2.32k, False: 0]
  ------------------
  513|  2.32k|        return (int)opcode - (int)(OP_1 - 1);
  514|  2.32k|    }

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

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

_Z16GetTxnOutputType9TxoutType:
   19|  3.62k|{
   20|  3.62k|    switch (t) {
  ------------------
  |  Branch (20:13): [True: 3.62k, False: 0]
  ------------------
   21|  2.96k|    case TxoutType::NONSTANDARD: return "nonstandard";
  ------------------
  |  Branch (21:5): [True: 2.96k, False: 659]
  ------------------
   22|     12|    case TxoutType::PUBKEY: return "pubkey";
  ------------------
  |  Branch (22:5): [True: 12, False: 3.60k]
  ------------------
   23|      5|    case TxoutType::PUBKEYHASH: return "pubkeyhash";
  ------------------
  |  Branch (23:5): [True: 5, False: 3.61k]
  ------------------
   24|      6|    case TxoutType::SCRIPTHASH: return "scripthash";
  ------------------
  |  Branch (24:5): [True: 6, False: 3.61k]
  ------------------
   25|     77|    case TxoutType::MULTISIG: return "multisig";
  ------------------
  |  Branch (25:5): [True: 77, False: 3.54k]
  ------------------
   26|     40|    case TxoutType::NULL_DATA: return "nulldata";
  ------------------
  |  Branch (26:5): [True: 40, False: 3.58k]
  ------------------
   27|      2|    case TxoutType::ANCHOR: return "anchor";
  ------------------
  |  Branch (27:5): [True: 2, False: 3.61k]
  ------------------
   28|      2|    case TxoutType::WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
  ------------------
  |  Branch (28:5): [True: 2, False: 3.61k]
  ------------------
   29|      2|    case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
  ------------------
  |  Branch (29:5): [True: 2, False: 3.61k]
  ------------------
   30|    458|    case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
  ------------------
  |  Branch (30:5): [True: 458, False: 3.16k]
  ------------------
   31|     55|    case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
  ------------------
  |  Branch (31:5): [True: 55, False: 3.56k]
  ------------------
   32|  3.62k|    } // no default case, so the compiler can warn about missing cases
   33|  3.62k|    assert(false);
  ------------------
  |  Branch (33:5): [Folded, False: 0]
  ------------------
   34|      0|}
_Z6SolverRK7CScriptRNSt3__16vectorINS3_IhNS2_9allocatorIhEEEENS4_IS6_EEEE:
  142|  5.94k|{
  143|  5.94k|    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|  5.94k|    if (scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (147:9): [True: 21, False: 5.92k]
  ------------------
  148|     21|    {
  149|     21|        std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
  150|     21|        vSolutionsRet.push_back(hashBytes);
  151|     21|        return TxoutType::SCRIPTHASH;
  152|     21|    }
  153|       |
  154|  5.92k|    int witnessversion;
  155|  5.92k|    std::vector<unsigned char> witnessprogram;
  156|  5.92k|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (156:9): [True: 1.69k, False: 4.23k]
  ------------------
  157|  1.69k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
  ------------------
  |  Branch (157:13): [True: 25, False: 1.66k]
  |  Branch (157:36): [True: 5, False: 20]
  ------------------
  158|      5|            vSolutionsRet.push_back(std::move(witnessprogram));
  159|      5|            return TxoutType::WITNESS_V0_KEYHASH;
  160|      5|        }
  161|  1.68k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (161:13): [True: 20, False: 1.66k]
  |  Branch (161:36): [True: 5, False: 15]
  ------------------
  162|      5|            vSolutionsRet.push_back(std::move(witnessprogram));
  163|      5|            return TxoutType::WITNESS_V0_SCRIPTHASH;
  164|      5|        }
  165|  1.68k|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
  ------------------
  |  Branch (165:13): [True: 1.60k, False: 79]
  |  Branch (165:36): [True: 1.51k, False: 89]
  ------------------
  166|  1.51k|            vSolutionsRet.push_back(std::move(witnessprogram));
  167|  1.51k|            return TxoutType::WITNESS_V1_TAPROOT;
  168|  1.51k|        }
  169|    168|        if (scriptPubKey.IsPayToAnchor()) {
  ------------------
  |  Branch (169:13): [True: 5, False: 163]
  ------------------
  170|      5|            return TxoutType::ANCHOR;
  171|      5|        }
  172|    163|        if (witnessversion != 0) {
  ------------------
  |  Branch (172:13): [True: 148, False: 15]
  ------------------
  173|    148|            vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
  174|    148|            vSolutionsRet.push_back(std::move(witnessprogram));
  175|    148|            return TxoutType::WITNESS_UNKNOWN;
  176|    148|        }
  177|     15|        return TxoutType::NONSTANDARD;
  178|    163|    }
  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|  4.23k|    if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
  ------------------
  |  Branch (185:9): [True: 4.06k, False: 164]
  |  Branch (185:9): [True: 64, False: 4.16k]
  |  Branch (185:37): [True: 271, False: 3.79k]
  |  Branch (185:69): [True: 64, False: 207]
  ------------------
  186|     64|        return TxoutType::NULL_DATA;
  187|     64|    }
  188|       |
  189|  4.16k|    std::vector<unsigned char> data;
  190|  4.16k|    if (MatchPayToPubkey(scriptPubKey, data)) {
  ------------------
  |  Branch (190:9): [True: 29, False: 4.14k]
  ------------------
  191|     29|        vSolutionsRet.push_back(std::move(data));
  192|     29|        return TxoutType::PUBKEY;
  193|     29|    }
  194|       |
  195|  4.14k|    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
  ------------------
  |  Branch (195:9): [True: 17, False: 4.12k]
  ------------------
  196|     17|        vSolutionsRet.push_back(std::move(data));
  197|     17|        return TxoutType::PUBKEYHASH;
  198|     17|    }
  199|       |
  200|  4.12k|    int required;
  201|  4.12k|    std::vector<std::vector<unsigned char>> keys;
  202|  4.12k|    if (MatchMultisig(scriptPubKey, required, keys)) {
  ------------------
  |  Branch (202:9): [True: 228, False: 3.89k]
  ------------------
  203|    228|        vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..20
  204|    228|        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
  205|    228|        vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..20
  206|    228|        return TxoutType::MULTISIG;
  207|    228|    }
  208|       |
  209|  3.89k|    vSolutionsRet.clear();
  210|  3.89k|    return TxoutType::NONSTANDARD;
  211|  4.12k|}
solver.cpp:_ZL15GetScriptNumber10opcodetypeNSt3__16vectorIhNS0_9allocatorIhEEEEii:
   67|  1.26k|{
   68|  1.26k|    int count;
   69|  1.26k|    if (IsSmallInteger(opcode)) {
  ------------------
  |  Branch (69:9): [True: 663, False: 597]
  ------------------
   70|    663|        count = CScript::DecodeOP_N(opcode);
   71|    663|    } else if (IsPushdataOp(opcode)) {
  ------------------
  |  Branch (71:16): [True: 504, False: 93]
  ------------------
   72|    504|        if (!CheckMinimalPush(data, opcode)) return {};
  ------------------
  |  Branch (72:13): [True: 61, False: 443]
  ------------------
   73|    443|        try {
   74|    443|            count = CScriptNum(data, /* fRequireMinimal = */ true).getint();
   75|    443|        } catch (const scriptnum_error&) {
   76|    129|            return {};
   77|    129|        }
   78|    443|    } else {
   79|     93|        return {};
   80|     93|    }
   81|    977|    if (count < min || count > max) return {};
  ------------------
  |  Branch (81:9): [True: 77, False: 900]
  |  Branch (81:24): [True: 105, False: 795]
  ------------------
   82|    795|    return count;
   83|    977|}
solver.cpp:_ZL14IsSmallInteger10opcodetype:
   60|  1.26k|{
   61|  1.26k|    return opcode >= OP_1 && opcode <= OP_16;
  ------------------
  |  Branch (61:12): [True: 730, False: 530]
  |  Branch (61:30): [True: 663, False: 67]
  ------------------
   62|  1.26k|}
solver.cpp:_ZL16MatchPayToPubkeyRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   37|  4.16k|{
   38|  4.16k|    if (script.size() == CPubKey::SIZE + 2 && script[0] == CPubKey::SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (38:9): [True: 84, False: 4.08k]
  |  Branch (38:47): [True: 60, False: 24]
  |  Branch (38:77): [True: 48, False: 12]
  ------------------
   39|     48|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::SIZE + 1);
   40|     48|        return CPubKey::ValidSize(pubkey);
   41|     48|    }
   42|  4.12k|    if (script.size() == CPubKey::COMPRESSED_SIZE + 2 && script[0] == CPubKey::COMPRESSED_SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (42:9): [True: 72, False: 4.04k]
  |  Branch (42:58): [True: 53, False: 19]
  |  Branch (42:99): [True: 37, False: 16]
  ------------------
   43|     37|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_SIZE + 1);
   44|     37|        return CPubKey::ValidSize(pubkey);
   45|     37|    }
   46|  4.08k|    return false;
   47|  4.12k|}
solver.cpp:_ZL20MatchPayToPubkeyHashRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   50|  4.14k|{
   51|  4.14k|    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: 91, False: 4.04k]
  |  Branch (51:32): [True: 71, False: 20]
  |  Branch (51:55): [True: 59, False: 12]
  |  Branch (51:82): [True: 46, False: 13]
  |  Branch (51:101): [True: 37, False: 9]
  |  Branch (51:133): [True: 17, False: 20]
  ------------------
   52|     17|        pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
   53|     17|        return true;
   54|     17|    }
   55|  4.12k|    return false;
   56|  4.14k|}
solver.cpp:_ZL13MatchMultisigRK7CScriptRiRNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEE:
   86|  4.12k|{
   87|  4.12k|    opcodetype opcode;
   88|  4.12k|    valtype data;
   89|       |
   90|  4.12k|    CScript::const_iterator it = script.begin();
   91|  4.12k|    if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
  ------------------
  |  Branch (91:9): [True: 164, False: 3.95k]
  |  Branch (91:30): [True: 3.18k, False: 770]
  ------------------
   92|       |
   93|    770|    if (!script.GetOp(it, opcode, data)) return false;
  ------------------
  |  Branch (93:9): [True: 10, False: 760]
  ------------------
   94|    760|    auto req_sigs = GetScriptNumber(opcode, data, 1, MAX_PUBKEYS_PER_MULTISIG);
   95|    760|    if (!req_sigs) return false;
  ------------------
  |  Branch (95:9): [True: 260, False: 500]
  ------------------
   96|    500|    required_sigs = *req_sigs;
   97|  3.47k|    while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
  ------------------
  |  Branch (97:12): [True: 3.44k, False: 32]
  |  Branch (97:46): [True: 2.97k, False: 468]
  ------------------
   98|  2.97k|        pubkeys.emplace_back(std::move(data));
   99|  2.97k|    }
  100|    500|    auto num_keys = GetScriptNumber(opcode, data, required_sigs, MAX_PUBKEYS_PER_MULTISIG);
  101|    500|    if (!num_keys) return false;
  ------------------
  |  Branch (101:9): [True: 205, False: 295]
  ------------------
  102|    295|    if (pubkeys.size() != static_cast<unsigned long>(*num_keys)) return false;
  ------------------
  |  Branch (102:9): [True: 61, False: 234]
  ------------------
  103|       |
  104|    234|    return (it + 1 == script.end());
  105|    295|}

_Z12IsPushdataOp10opcodetype:
   41|    597|{
   42|    597|    return opcode > OP_FALSE && opcode <= OP_PUSHDATA4;
  ------------------
  |  Branch (42:12): [True: 573, False: 24]
  |  Branch (42:33): [True: 504, False: 69]
  ------------------
   43|    597|}

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

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

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

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

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

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

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

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

_Z13MakeUCharSpanINSt3__16vectorIhNS0_9allocatorIhEEEEEDTcl13UCharSpanCasttlNS0_4spanEfp_EEERKT_:
  111|     18|template <typename V> constexpr auto MakeUCharSpan(const V& v) -> decltype(UCharSpanCast(std::span{v})) { return UCharSpanCast(std::span{v}); }
_Z13MakeUCharSpanINSt3__14spanIKhLm18446744073709551615EEEEDTcl13UCharSpanCasttlS1_fp_EEERKT_:
  111|  1.21k|template <typename V> constexpr auto MakeUCharSpan(const V& v) -> decltype(UCharSpanCast(std::span{v})) { return UCharSpanCast(std::span{v}); }
_Z13UCharSpanCastIKhLm18446744073709551615EEDaNSt3__14spanIT_XT0_EEE:
  108|  1.23k|template <typename T, size_t N> constexpr auto UCharSpanCast(std::span<T, N> s) { return std::span<std::remove_pointer_t<decltype(UCharCast(s.data()))>, N>{UCharCast(s.data()), s.size()}; }
_Z9UCharCastPKh:
  100|  1.23k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; }

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

_Z14memory_cleansePvm:
   15|     14|{
   16|       |#if defined(WIN32)
   17|       |    /* SecureZeroMemory is guaranteed not to be optimized out. */
   18|       |    SecureZeroMemory(ptr, len);
   19|       |#else
   20|     14|    std::memset(ptr, 0, len);
   21|       |
   22|       |    /* Memory barrier that scares the compiler away from optimizing out the memset.
   23|       |     *
   24|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
   25|       |     * in BoringSSL (ISC License):
   26|       |     *    As best as we can tell, this is sufficient to break any optimisations that
   27|       |     *    might try to eliminate "superfluous" memsets.
   28|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
   29|       |     * is pretty efficient because the compiler can still implement the memset() efficiently,
   30|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
   31|       |     * Yang et al. (USENIX Security 2017) for more background.
   32|       |     */
   33|     14|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
   34|     14|#endif
   35|     14|}

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

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

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

_ZN18FuzzedDataProviderC2EPKhm:
   37|  3.84k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  14.1M|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  14.1M|  return 1 & ConsumeIntegral<uint8_t>();
  291|  14.1M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  14.1M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  14.1M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  14.1M|                                std::numeric_limits<T>::max());
  198|  14.1M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  14.1M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  14.1M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  14.1M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  14.1M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 14.1M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  14.1M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  14.1M|  uint64_t result = 0;
  215|  14.1M|  size_t offset = 0;
  216|       |
  217|  28.3M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 14.1M, False: 14.1M]
  |  Branch (217:43): [True: 14.1M, False: 0]
  ------------------
  218|  14.1M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 14.1M, False: 32.6k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  14.1M|    --remaining_bytes_;
  226|  14.1M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  14.1M|    offset += CHAR_BIT;
  228|  14.1M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  14.1M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 14.1M, False: 0]
  ------------------
  232|  14.1M|    result = result % (range + 1);
  233|       |
  234|  14.1M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  14.1M|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|  17.1k|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) {
  154|       |  // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\"
  155|       |  // followed by anything else to the end of the string. As a result of this
  156|       |  // logic, a fuzzer can insert characters into the string, and the string
  157|       |  // will be lengthened to include those new characters, resulting in a more
  158|       |  // stable fuzzer than picking the length of a string independently from
  159|       |  // picking its contents.
  160|  17.1k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|  17.1k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  1.46M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 1.45M, False: 10.8k]
  |  Branch (164:40): [True: 1.45M, False: 118]
  ------------------
  165|  1.45M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  1.45M|    Advance(1);
  167|  1.45M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 7.29k, False: 1.44M]
  |  Branch (167:25): [True: 7.29k, False: 3]
  ------------------
  168|  7.29k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|  7.29k|      Advance(1);
  170|  7.29k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 6.18k, False: 1.11k]
  ------------------
  171|  6.18k|        break;
  172|  7.29k|    }
  173|  1.44M|    result += next;
  174|  1.44M|  }
  175|       |
  176|  17.1k|  result.shrink_to_fit();
  177|  17.1k|  return result;
  178|  17.1k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  343|  1.46M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  344|  1.46M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (344:7): [True: 0, False: 1.46M]
  ------------------
  345|      0|    abort();
  346|       |
  347|  1.46M|  data_ptr_ += num_bytes;
  348|  1.46M|  remaining_bytes_ -= num_bytes;
  349|  1.46M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  378|  1.46M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  379|  1.46M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  380|  1.46M|  static_assert(!std::numeric_limits<TU>::is_signed,
  381|  1.46M|                "Source type must be unsigned.");
  382|       |
  383|       |  if constexpr (std::numeric_limits<TS>::is_modulo)
  384|       |    return static_cast<TS>(value);
  385|       |
  386|       |  // Avoid using implementation-defined unsigned to signed conversions.
  387|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  388|  1.46M|  constexpr auto TS_max = static_cast<TU>(std::numeric_limits<TS>::max());
  389|  1.46M|  if (value <= TS_max) {
  ------------------
  |  Branch (389:7): [True: 889k, False: 573k]
  ------------------
  390|   889k|    return static_cast<TS>(value);
  391|   889k|  } else {
  392|   573k|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  393|   573k|    return TS_min + static_cast<TS>(value - TS_min);
  394|   573k|  }
  395|  1.46M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  13.7M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  13.7M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  13.7M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  13.7M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 13.7M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  13.7M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  13.7M|  uint64_t result = 0;
  215|  13.7M|  size_t offset = 0;
  216|       |
  217|  27.4M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 27.4M, False: 0]
  |  Branch (217:43): [True: 13.7M, False: 13.7M]
  ------------------
  218|  13.7M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 13.7M, False: 11.3k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  13.7M|    --remaining_bytes_;
  226|  13.7M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  13.7M|    offset += CHAR_BIT;
  228|  13.7M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  13.7M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 13.7M, False: 0]
  ------------------
  232|  13.7M|    result = result % (range + 1);
  233|       |
  234|  13.7M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  13.7M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  13.0M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  13.0M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  13.0M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  13.0M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 13.0M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  13.0M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  13.0M|  uint64_t result = 0;
  215|  13.0M|  size_t offset = 0;
  216|       |
  217|  26.1M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 26.1M, False: 0]
  |  Branch (217:43): [True: 13.0M, False: 13.0M]
  ------------------
  218|  13.0M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 13.0M, False: 167]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  13.0M|    --remaining_bytes_;
  226|  13.0M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  13.0M|    offset += CHAR_BIT;
  228|  13.0M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  13.0M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 13.0M, False: 0]
  ------------------
  232|  13.0M|    result = result % (range + 1);
  233|       |
  234|  13.0M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  13.0M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|  90.3k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  90.3k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  90.3k|                                std::numeric_limits<T>::max());
  198|  90.3k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|   241k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   241k|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|   241k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   241k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 241k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   241k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   241k|  uint64_t result = 0;
  215|   241k|  size_t offset = 0;
  216|       |
  217|  1.11M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.02M, False: 89.9k]
  |  Branch (217:43): [True: 872k, False: 150k]
  ------------------
  218|   872k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 871k, False: 1.13k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|   871k|    --remaining_bytes_;
  226|   871k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   871k|    offset += CHAR_BIT;
  228|   871k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   241k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 151k, False: 90.3k]
  ------------------
  232|   151k|    result = result % (range + 1);
  233|       |
  234|   241k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   241k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|  75.8k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  75.8k|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  75.8k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  75.8k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 75.8k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  75.8k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  75.8k|  uint64_t result = 0;
  215|  75.8k|  size_t offset = 0;
  216|       |
  217|   151k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 151k, False: 0]
  |  Branch (217:43): [True: 75.8k, False: 75.7k]
  ------------------
  218|  75.8k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 75.7k, False: 101]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  75.7k|    --remaining_bytes_;
  226|  75.7k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  75.7k|    offset += CHAR_BIT;
  228|  75.7k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  75.8k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 75.8k, False: 0]
  ------------------
  232|  75.8k|    result = result % (range + 1);
  233|       |
  234|  75.8k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  75.8k|}
_ZN18FuzzedDataProvider16PickValueInArrayIiEET_St16initializer_listIKS1_E:
  316|   445k|T FuzzedDataProvider::PickValueInArray(std::initializer_list<const T> list) {
  317|   445k|  if (!list.size())
  ------------------
  |  Branch (317:7): [True: 0, False: 445k]
  ------------------
  318|      0|    abort();
  319|       |
  320|   445k|  return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
  321|   445k|}

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

_Z25script_format_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   22|  3.84k|{
   23|  3.84k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   24|  3.84k|    const CScript script{ConsumeScript(fuzzed_data_provider)};
   25|  3.84k|    if (script.size() > MAX_STANDARD_TX_WEIGHT / WITNESS_SCALE_FACTOR) {
  ------------------
  |  Branch (25:9): [True: 223, False: 3.62k]
  ------------------
   26|    223|        return;
   27|    223|    }
   28|       |
   29|  3.62k|    (void)FormatScript(script);
   30|  3.62k|    (void)ScriptToAsmStr(script, /*fAttemptSighashDecode=*/fuzzed_data_provider.ConsumeBool());
   31|       |
   32|  3.62k|    UniValue o1(UniValue::VOBJ);
   33|  3.62k|    auto include_hex = fuzzed_data_provider.ConsumeBool();
   34|  3.62k|    auto include_address = fuzzed_data_provider.ConsumeBool();
   35|  3.62k|    ScriptToUniv(script, /*out=*/o1, include_hex, include_address);
   36|  3.62k|}

_Z20ConstructPubKeyBytesR18FuzzedDataProviderNSt3__14spanIKhLm18446744073709551615EEEb:
   17|   445k|{
   18|   445k|    uint8_t pk_type;
   19|   445k|    if (compressed) {
  ------------------
  |  Branch (19:9): [True: 430k, False: 14.3k]
  ------------------
   20|   430k|        pk_type = fuzzed_data_provider.PickValueInArray({0x02, 0x03});
   21|   430k|    } else {
   22|  14.3k|        pk_type = fuzzed_data_provider.PickValueInArray({0x04, 0x06, 0x07});
   23|  14.3k|    }
   24|   445k|    std::vector<uint8_t> pk_data{byte_data.begin(), byte_data.begin() + (compressed ? CPubKey::COMPRESSED_SIZE : CPubKey::SIZE)};
  ------------------
  |  Branch (24:74): [True: 430k, False: 14.3k]
  ------------------
   25|   445k|    pk_data[0] = pk_type;
   26|   445k|    return pk_data;
   27|   445k|}
_Z13ConsumeScriptR18FuzzedDataProviderb:
   94|  3.84k|{
   95|  3.84k|    CScript r_script{};
   96|  3.84k|    {
   97|       |        // Keep a buffer of bytes to allow the fuzz engine to produce smaller
   98|       |        // inputs to generate CScripts with repeated data.
   99|  3.84k|        static constexpr unsigned MAX_BUFFER_SZ{128};
  100|  3.84k|        std::vector<uint8_t> buffer(MAX_BUFFER_SZ, uint8_t{'a'});
  101|  13.2M|        while (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (101:16): [True: 13.2M, False: 3.84k]
  ------------------
  102|  13.2M|            CallOneOf(
  103|  13.2M|                fuzzed_data_provider,
  104|  13.2M|                [&] {
  105|       |                    // Insert byte vector directly to allow malformed or unparsable scripts
  106|  13.2M|                    r_script.insert(r_script.end(), buffer.begin(), buffer.begin() + fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BUFFER_SZ));
  107|  13.2M|                },
  108|  13.2M|                [&] {
  109|       |                    // Push a byte vector from the buffer
  110|  13.2M|                    r_script << std::vector<uint8_t>{buffer.begin(), buffer.begin() + fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BUFFER_SZ)};
  111|  13.2M|                },
  112|  13.2M|                [&] {
  113|       |                    // Push multisig
  114|       |                    // There is a special case for this to aid the fuzz engine
  115|       |                    // navigate the highly structured multisig format.
  116|  13.2M|                    r_script << fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 22);
  117|  13.2M|                    int num_data{fuzzed_data_provider.ConsumeIntegralInRange(1, 22)};
  118|  13.2M|                    while (num_data--) {
  119|  13.2M|                        auto pubkey_bytes{ConstructPubKeyBytes(fuzzed_data_provider, buffer, fuzzed_data_provider.ConsumeBool())};
  120|  13.2M|                        if (fuzzed_data_provider.ConsumeBool()) {
  121|  13.2M|                            pubkey_bytes.back() = num_data; // Make each pubkey different
  122|  13.2M|                        }
  123|  13.2M|                        r_script << pubkey_bytes;
  124|  13.2M|                    }
  125|  13.2M|                    r_script << fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 22);
  126|  13.2M|                },
  127|  13.2M|                [&] {
  128|       |                    // Mutate the buffer
  129|  13.2M|                    const auto vec{ConsumeRandomLengthByteVector(fuzzed_data_provider, /*max_length=*/MAX_BUFFER_SZ)};
  130|  13.2M|                    std::copy(vec.begin(), vec.end(), buffer.begin());
  131|  13.2M|                },
  132|  13.2M|                [&] {
  133|       |                    // Push an integral
  134|  13.2M|                    r_script << fuzzed_data_provider.ConsumeIntegral<int64_t>();
  135|  13.2M|                },
  136|  13.2M|                [&] {
  137|       |                    // Push an opcode
  138|  13.2M|                    r_script << ConsumeOpcodeType(fuzzed_data_provider);
  139|  13.2M|                },
  140|  13.2M|                [&] {
  141|       |                    // Push a scriptnum
  142|  13.2M|                    r_script << ConsumeScriptNum(fuzzed_data_provider);
  143|  13.2M|                });
  144|  13.2M|        }
  145|  3.84k|    }
  146|  3.84k|    if (maybe_p2wsh && fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (146:9): [True: 0, False: 3.84k]
  |  Branch (146:24): [True: 0, False: 0]
  ------------------
  147|      0|        uint256 script_hash;
  148|      0|        CSHA256().Write(r_script.data(), r_script.size()).Finalize(script_hash.begin());
  149|      0|        r_script.clear();
  150|      0|        r_script << OP_0 << ToByteVector(script_hash);
  151|      0|    }
  152|  3.84k|    return r_script;
  153|  3.84k|}
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_0clEv:
  104|   729k|                [&] {
  105|       |                    // Insert byte vector directly to allow malformed or unparsable scripts
  106|   729k|                    r_script.insert(r_script.end(), buffer.begin(), buffer.begin() + fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BUFFER_SZ));
  107|   729k|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_1clEv:
  108|  12.2M|                [&] {
  109|       |                    // Push a byte vector from the buffer
  110|  12.2M|                    r_script << std::vector<uint8_t>{buffer.begin(), buffer.begin() + fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BUFFER_SZ)};
  111|  12.2M|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_2clEv:
  112|  75.8k|                [&] {
  113|       |                    // Push multisig
  114|       |                    // There is a special case for this to aid the fuzz engine
  115|       |                    // navigate the highly structured multisig format.
  116|  75.8k|                    r_script << fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 22);
  117|  75.8k|                    int num_data{fuzzed_data_provider.ConsumeIntegralInRange(1, 22)};
  118|   520k|                    while (num_data--) {
  ------------------
  |  Branch (118:28): [True: 445k, False: 75.8k]
  ------------------
  119|   445k|                        auto pubkey_bytes{ConstructPubKeyBytes(fuzzed_data_provider, buffer, fuzzed_data_provider.ConsumeBool())};
  120|   445k|                        if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (120:29): [True: 431k, False: 13.6k]
  ------------------
  121|   431k|                            pubkey_bytes.back() = num_data; // Make each pubkey different
  122|   431k|                        }
  123|   445k|                        r_script << pubkey_bytes;
  124|   445k|                    }
  125|  75.8k|                    r_script << fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 22);
  126|  75.8k|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_3clEv:
  127|  17.1k|                [&] {
  128|       |                    // Mutate the buffer
  129|  17.1k|                    const auto vec{ConsumeRandomLengthByteVector(fuzzed_data_provider, /*max_length=*/MAX_BUFFER_SZ)};
  130|  17.1k|                    std::copy(vec.begin(), vec.end(), buffer.begin());
  131|  17.1k|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_4clEv:
  132|  63.9k|                [&] {
  133|       |                    // Push an integral
  134|  63.9k|                    r_script << fuzzed_data_provider.ConsumeIntegral<int64_t>();
  135|  63.9k|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_5clEv:
  136|   144k|                [&] {
  137|       |                    // Push an opcode
  138|   144k|                    r_script << ConsumeOpcodeType(fuzzed_data_provider);
  139|   144k|                },
util.cpp:_ZZ13ConsumeScriptR18FuzzedDataProviderbENK3$_6clEv:
  140|  26.4k|                [&] {
  141|       |                    // Push a scriptnum
  142|  26.4k|                    r_script << ConsumeScriptNum(fuzzed_data_provider);
  143|  26.4k|                });

_Z17ConsumeOpcodeTypeR18FuzzedDataProvider:
  155|   144k|{
  156|   144k|    return static_cast<opcodetype>(fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, MAX_OPCODE));
  157|   144k|}
_Z16ConsumeScriptNumR18FuzzedDataProvider:
  182|  26.4k|{
  183|  26.4k|    return CScriptNum{fuzzed_data_provider.ConsumeIntegral<int64_t>()};
  184|  26.4k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   64|  17.1k|{
   65|  17.1k|    static_assert(sizeof(B) == 1);
   66|  17.1k|    const std::string s = max_length ?
  ------------------
  |  Branch (66:27): [True: 17.1k, False: 0]
  ------------------
   67|  17.1k|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   68|  17.1k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   69|  17.1k|    std::vector<B> ret(s.size());
   70|  17.1k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   71|  17.1k|    return ret;
   72|  17.1k|}
util.cpp:_Z9CallOneOfIJZ13ConsumeScriptR18FuzzedDataProviderbE3$_0Z13ConsumeScriptS1_bE3$_1Z13ConsumeScriptS1_bE3$_2Z13ConsumeScriptS1_bE3$_3Z13ConsumeScriptS1_bE3$_4Z13ConsumeScriptS1_bE3$_5Z13ConsumeScriptS1_bE3$_6EEmS1_DpT_:
   38|  13.2M|{
   39|  13.2M|    constexpr size_t call_size{sizeof...(callables)};
   40|  13.2M|    static_assert(call_size >= 1);
   41|  13.2M|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   42|       |
   43|  13.2M|    size_t i{0};
   44|  92.9M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (44:7): [True: 729k, False: 12.5M]
  |  Branch (44:7): [True: 12.2M, False: 1.05M]
  |  Branch (44:7): [True: 75.8k, False: 13.1M]
  |  Branch (44:7): [True: 17.1k, False: 13.2M]
  |  Branch (44:7): [True: 63.9k, False: 13.2M]
  |  Branch (44:7): [True: 144k, False: 13.1M]
  |  Branch (44:7): [True: 26.4k, False: 13.2M]
  ------------------
   45|  13.2M|    return call_size;
   46|  13.2M|}

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

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

_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   227k|{
 1089|   227k|    std::ostringstream oss;
 1090|   227k|    format(oss, fmt, args...);
 1091|   227k|    return oss.str();
 1092|   227k|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   227k|{
 1081|   227k|    vformat(out, fmt, makeFormatList(args...));
 1082|   227k|}
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   227k|{
 1045|   227k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   227k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   101k|{
 1089|   101k|    std::ostringstream oss;
 1090|   101k|    format(oss, fmt, args...);
 1091|   101k|    return oss.str();
 1092|   101k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   101k|{
 1081|   101k|    vformat(out, fmt, makeFormatList(args...));
 1082|   101k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   101k|{
 1045|   101k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   101k|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|   101k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|   225k|        {
  559|   225k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   225k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|   225k|{
  352|   225k|#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|   225k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   225k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   225k|#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|   225k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   225k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   225k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 225k]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   225k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 225k]
  |  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|   225k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 225k]
  ------------------
  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|   225k|    else
  378|   225k|        out << value;
  379|   225k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|   227k|            : FormatList(&m_formatterStore[0], N),
  991|   227k|            m_formatterStore { FormatArg(args)... }
  992|   227k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  23.6k|{
 1089|  23.6k|    std::ostringstream oss;
 1090|  23.6k|    format(oss, fmt, args...);
 1091|  23.6k|    return oss.str();
 1092|  23.6k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  23.6k|{
 1081|  23.6k|    vformat(out, fmt, makeFormatList(args...));
 1082|  23.6k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  23.6k|{
 1045|  23.6k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  23.6k|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|   251k|    operator const char*() { return fmt; }
_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|   453k|        {
  542|   453k|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|   453k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (542:13): [True: 453k, False: 0]
  ------------------
  543|   453k|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|   453k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (543:13): [True: 453k, False: 0]
  ------------------
  544|   453k|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|   453k|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|   352k|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|   453k|{
  594|   453k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 453k, False: 0]
  |  Branch (594:22): [True: 0, False: 453k]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|   453k|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 453k]
  ------------------
  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|   453k|    else {
  618|   453k|        return false;
  619|   453k|    }
  620|      0|    return true;
  621|   453k|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|   805k|{
  630|   805k|    const char* c = fmt;
  631|  1.52M|    for (;; ++c) {
  632|  1.52M|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 352k, False: 1.17M]
  ------------------
  633|   352k|            out.write(fmt, c - fmt);
  634|   352k|            return c;
  635|   352k|        }
  636|  1.17M|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 453k, False: 724k]
  ------------------
  637|   453k|            out.write(fmt, c - fmt);
  638|   453k|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 453k, False: 0]
  ------------------
  639|   453k|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|  1.52M|    }
  644|   805k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|   453k|{
  686|   453k|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|   453k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (686:5): [True: 453k, False: 0]
  ------------------
  687|       |    // Reset stream state to defaults.
  688|   453k|    out.width(0);
  689|   453k|    out.precision(6);
  690|   453k|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|   453k|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|   453k|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|   453k|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|   453k|    bool precisionSet = false;
  696|   453k|    bool widthSet = false;
  697|   453k|    int widthExtra = 0;
  698|   453k|    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|   453k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 453k, False: 0]
  |  Branch (702:22): [True: 0, False: 453k]
  ------------------
  703|      0|        const char tmpc = *c;
  704|      0|        int value = parseIntAndAdvance(c);
  705|      0|        if (*c == '$') {
  ------------------
  |  Branch (705:13): [True: 0, False: 0]
  ------------------
  706|       |            // value is an argument index
  707|      0|            if (value > 0 && value <= numArgs)
  ------------------
  |  Branch (707:17): [True: 0, False: 0]
  |  Branch (707:30): [True: 0, False: 0]
  ------------------
  708|      0|                argIndex = value - 1;
  709|      0|            else
  710|      0|                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  711|      0|            ++c;
  712|      0|            positionalMode = true;
  713|      0|        }
  714|      0|        else if (positionalMode) {
  ------------------
  |  Branch (714:18): [True: 0, False: 0]
  ------------------
  715|      0|            TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  716|      0|        }
  717|      0|        else {
  718|      0|            if (tmpc == '0') {
  ------------------
  |  Branch (718:17): [True: 0, False: 0]
  ------------------
  719|       |                // Use internal padding so that numeric values are
  720|       |                // formatted correctly, eg -00010 rather than 000-10
  721|      0|                out.fill('0');
  722|      0|                out.setf(std::ios::internal, std::ios::adjustfield);
  723|      0|            }
  724|      0|            if (value != 0) {
  ------------------
  |  Branch (724:17): [True: 0, False: 0]
  ------------------
  725|       |                // Nonzero value means that we parsed width.
  726|      0|                widthSet = true;
  727|      0|                out.width(value);
  728|      0|            }
  729|      0|        }
  730|      0|    }
  731|   453k|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 453k]
  ------------------
  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|   453k|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 453k, False: 0]
  ------------------
  736|       |        // Parse flags
  737|   453k|        for (;; ++c) {
  738|   453k|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 453k]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  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: 453k]
  ------------------
  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: 453k]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|   453k|                default:
  ------------------
  |  Branch (765:17): [True: 453k, False: 0]
  ------------------
  766|   453k|                    break;
  767|   453k|            }
  768|   453k|            break;
  769|   453k|        }
  770|       |        // Parse width
  771|   453k|        int width = 0;
  772|   453k|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|   453k|                                         args, argIndex, numArgs);
  774|   453k|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 453k]
  ------------------
  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|   453k|    }
  784|       |    // 3) Parse precision
  785|   453k|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 453k]
  ------------------
  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|   453k|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 453k]
  |  Branch (797:25): [True: 0, False: 453k]
  |  Branch (797:38): [True: 0, False: 453k]
  ------------------
  798|   453k|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 453k]
  |  Branch (798:25): [True: 0, False: 453k]
  |  Branch (798:38): [True: 0, False: 453k]
  ------------------
  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|   453k|    bool intConversion = false;
  805|   453k|    switch (*c) {
  806|   227k|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 0, False: 453k]
  |  Branch (806:19): [True: 180k, False: 273k]
  |  Branch (806:29): [True: 47.2k, False: 405k]
  ------------------
  807|   227k|            out.setf(std::ios::dec, std::ios::basefield);
  808|   227k|            intConversion = true;
  809|   227k|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|   225k|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 225k, False: 227k]
  |  Branch (817:19): [True: 0, False: 453k]
  ------------------
  818|   225k|            out.setf(std::ios::hex, std::ios::basefield);
  819|   225k|            intConversion = true;
  820|   225k|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 453k]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 453k]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 453k]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|      0|        case 's':
  ------------------
  |  Branch (857:9): [True: 0, False: 453k]
  ------------------
  858|      0|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 0]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|      0|            out.setf(std::ios::boolalpha);
  862|      0|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 453k]
  ------------------
  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: 453k]
  ------------------
  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: 453k]
  ------------------
  872|      0|            break;
  873|   453k|    }
  874|   453k|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 453k, False: 0]
  |  Branch (874:26): [True: 0, False: 453k]
  |  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|   453k|    return c+1;
  884|   453k|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|   352k|{
  892|       |    // Saved stream state
  893|   352k|    std::streamsize origWidth = out.width();
  894|   352k|    std::streamsize origPrecision = out.precision();
  895|   352k|    std::ios::fmtflags origFlags = out.flags();
  896|   352k|    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|   352k|    bool positionalMode = false;
  901|   352k|    int argIndex = 0;
  902|   805k|    while (true) {
  ------------------
  |  Branch (902:12): [True: 805k, Folded]
  ------------------
  903|   805k|        fmt = printFormatStringLiteral(out, fmt);
  904|   805k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 352k, False: 453k]
  ------------------
  905|   352k|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 352k, False: 0]
  |  Branch (905:36): [True: 0, False: 352k]
  ------------------
  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|   352k|            break;
  909|   352k|        }
  910|   453k|        bool spacePadPositive = false;
  911|   453k|        int ntrunc = -1;
  912|   453k|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|   453k|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|   453k|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 453k]
  ------------------
  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|   453k|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|   453k|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 453k, False: 0]
  ------------------
  923|   453k|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|   453k|        }
  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|   453k|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 453k, False: 0]
  ------------------
  942|   453k|            ++argIndex;
  943|   453k|        fmt = fmtEnd;
  944|   453k|    }
  945|       |
  946|       |    // Restore stream state
  947|   352k|    out.width(origWidth);
  948|   352k|    out.precision(origPrecision);
  949|   352k|    out.flags(origFlags);
  950|   352k|    out.fill(origFill);
  951|   352k|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|   352k|{
 1071|   352k|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|   352k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_EEEDpRKT_:
  990|   101k|            : FormatList(&m_formatterStore[0], N),
  991|   101k|            m_formatterStore { FormatArg(args)... }
  992|   101k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|   227k|        {
  559|   227k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   227k|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|   227k|{
  352|   227k|#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|   227k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   227k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   227k|#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|   227k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   227k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   227k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 227k, Folded]
  |  Branch (365:29): [True: 0, False: 227k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   227k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 227k]
  |  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|   227k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 227k]
  ------------------
  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|   227k|    else
  378|   227k|        out << value;
  379|   227k|}
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|   227k|            : m_value(static_cast<const void*>(&value)),
  535|   227k|            m_formatImpl(&formatImpl<T>),
  536|   227k|            m_toIntImpl(&toIntImpl<T>)
  537|   227k|        { }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|   225k|            : m_value(static_cast<const void*>(&value)),
  535|   225k|            m_formatImpl(&formatImpl<T>),
  536|   225k|            m_toIntImpl(&toIntImpl<T>)
  537|   225k|        { }
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|  23.6k|            : FormatList(&m_formatterStore[0], N),
  991|  23.6k|            m_formatterStore { FormatArg(args)... }
  992|  23.6k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZNK9base_blobILj160EE3endEv:
  105|     30|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZN9base_blobILj160EE5beginEv:
  101|      3|    constexpr unsigned char* begin() { return m_data.data(); }
_ZN7uint160C2ENSt3__14spanIKhLm18446744073709551615EEE:
  188|     28|    constexpr explicit uint160(std::span<const unsigned char> vch) : base_blob<160>(vch) {}
_ZN9base_blobILj160EEC2ENSt3__14spanIKhLm18446744073709551615EEE:
   43|     28|    {
   44|     28|        assert(vch.size() == WIDTH);
  ------------------
  |  Branch (44:9): [True: 28, False: 0]
  ------------------
   45|     28|        std::copy(vch.begin(), vch.end(), m_data.begin());
   46|     28|    }
_ZNK9base_blobILj256EE5beginEv:
  104|  1.37k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZNK9base_blobILj256EE3endEv:
  105|  1.37k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZNK9base_blobILj160EE5beginEv:
  104|     30|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
   99|     56|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint160C2Ev:
  187|  1.22k|    constexpr uint160() = default;
_ZN9base_blobILj160EEC2Ev:
   37|  1.22k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj160EE4dataEv:
   99|  1.21k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj160EE4sizeEv:
  107|  1.21k|    static constexpr unsigned int size() { return WIDTH; }
_ZN7uint256C2Ev:
  200|  1.98k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   37|  1.98k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EE5beginEv:
  101|  1.05k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE4dataEv:
   98|    457|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|     20|    static constexpr unsigned int size() { return WIDTH; }

_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|  9.25k|    {
   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|  9.25k|        } else {
   50|  9.25k|            setStr(std::string{std::forward<Ref>(val)});
   51|  9.25k|        }
   52|  9.25k|    }
_ZN8UniValueC2ENS_5VTypeENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   32|  3.62k|    UniValue(UniValue::VType type, std::string str = {}) : typ{type}, val{std::move(str)} {}

_ZN8UniValue5clearEv:
   18|  9.25k|{
   19|  9.25k|    typ = VNULL;
   20|  9.25k|    val.clear();
   21|  9.25k|    keys.clear();
   22|  9.25k|    values.clear();
   23|  9.25k|}
_ZN8UniValue6setStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   85|  9.25k|{
   86|  9.25k|    clear();
   87|  9.25k|    typ = VSTR;
   88|  9.25k|    val = std::move(str);
   89|  9.25k|}
_ZN8UniValue9pushKVEndENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  118|  9.25k|{
  119|  9.25k|    checkType(VOBJ);
  120|       |
  121|  9.25k|    keys.push_back(std::move(key));
  122|  9.25k|    values.push_back(std::move(val));
  123|  9.25k|}
_ZN8UniValue6pushKVENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES_:
  126|  9.25k|{
  127|  9.25k|    checkType(VOBJ);
  128|       |
  129|  9.25k|    size_t idx;
  130|  9.25k|    if (findKey(key, idx))
  ------------------
  |  Branch (130:9): [True: 0, False: 9.25k]
  ------------------
  131|      0|        values[idx] = std::move(val);
  132|  9.25k|    else
  133|  9.25k|        pushKVEnd(std::move(key), std::move(val));
  134|  9.25k|}
_ZNK8UniValue7findKeyERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERm:
  156|  9.25k|{
  157|  18.3k|    for (size_t i = 0; i < keys.size(); i++) {
  ------------------
  |  Branch (157:24): [True: 9.04k, False: 9.25k]
  ------------------
  158|  9.04k|        if (keys[i] == key) {
  ------------------
  |  Branch (158:13): [True: 0, False: 9.04k]
  ------------------
  159|      0|            retIdx = i;
  160|      0|            return true;
  161|      0|        }
  162|  9.04k|    }
  163|       |
  164|  9.25k|    return false;
  165|  9.25k|}
_ZNK8UniValue9checkTypeERKNS_5VTypeE:
  210|  18.5k|{
  211|  18.5k|    if (typ != expected) {
  ------------------
  |  Branch (211:9): [True: 0, False: 18.5k]
  ------------------
  212|      0|        throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +
  213|      0|                                 std::string{uvTypeName(expected)}};
  214|      0|    }
  215|  18.5k|}

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

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

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

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

key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|      2|{
  222|      2|    size_t acc = 0;
  223|      2|    size_t bits = 0;
  224|      2|    constexpr size_t maxv = (1 << tobits) - 1;
  225|      2|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|     66|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 64, False: 2]
  ------------------
  227|     64|        int v = infn(*it);
  228|     64|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 64]
  ------------------
  229|     64|        acc = ((acc << frombits) | v) & max_acc;
  230|     64|        bits += frombits;
  231|    166|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 102, False: 64]
  ------------------
  232|    102|            bits -= tobits;
  233|    102|            outfn((acc >> bits) & maxv);
  234|    102|        }
  235|     64|        ++it;
  236|     64|    }
  237|      2|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 2, Folded]
  ------------------
  238|      2|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 2, False: 0]
  ------------------
  239|      2|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|      2|    return true;
  243|      2|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|      2|{
  222|      2|    size_t acc = 0;
  223|      2|    size_t bits = 0;
  224|      2|    constexpr size_t maxv = (1 << tobits) - 1;
  225|      2|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|     42|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 40, False: 2]
  ------------------
  227|     40|        int v = infn(*it);
  228|     40|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 40]
  ------------------
  229|     40|        acc = ((acc << frombits) | v) & max_acc;
  230|     40|        bits += frombits;
  231|    104|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 64, False: 40]
  ------------------
  232|     64|            bits -= tobits;
  233|     64|            outfn((acc >> bits) & maxv);
  234|     64|        }
  235|     40|        ++it;
  236|     40|    }
  237|      2|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 2, Folded]
  ------------------
  238|      2|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 0, False: 2]
  ------------------
  239|      2|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|      2|    return true;
  243|      2|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootEUlhE_PKhNSt3__18identityEEbT2_T3_SB_T4_:
  221|    598|{
  222|    598|    size_t acc = 0;
  223|    598|    size_t bits = 0;
  224|    598|    constexpr size_t maxv = (1 << tobits) - 1;
  225|    598|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|  19.7k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 19.1k, False: 598]
  ------------------
  227|  19.1k|        int v = infn(*it);
  228|  19.1k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 19.1k]
  ------------------
  229|  19.1k|        acc = ((acc << frombits) | v) & max_acc;
  230|  19.1k|        bits += frombits;
  231|  49.6k|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 30.4k, False: 19.1k]
  ------------------
  232|  30.4k|            bits -= tobits;
  233|  30.4k|            outfn((acc >> bits) & maxv);
  234|  30.4k|        }
  235|  19.1k|        ++it;
  236|  19.1k|    }
  237|    598|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 598, Folded]
  ------------------
  238|    598|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 598, False: 0]
  ------------------
  239|    598|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|    598|    return true;
  243|    598|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownEUlhE_NSt3__111__wrap_iterIPKhEENS6_8identityEEbT2_T3_SD_T4_:
  221|     64|{
  222|     64|    size_t acc = 0;
  223|     64|    size_t bits = 0;
  224|     64|    constexpr size_t maxv = (1 << tobits) - 1;
  225|     64|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  226|  1.17k|    while (it != end) {
  ------------------
  |  Branch (226:12): [True: 1.11k, False: 64]
  ------------------
  227|  1.11k|        int v = infn(*it);
  228|  1.11k|        if (v < 0) return false;
  ------------------
  |  Branch (228:13): [True: 0, False: 1.11k]
  ------------------
  229|  1.11k|        acc = ((acc << frombits) | v) & max_acc;
  230|  1.11k|        bits += frombits;
  231|  2.87k|        while (bits >= tobits) {
  ------------------
  |  Branch (231:16): [True: 1.76k, False: 1.11k]
  ------------------
  232|  1.76k|            bits -= tobits;
  233|  1.76k|            outfn((acc >> bits) & maxv);
  234|  1.76k|        }
  235|  1.11k|        ++it;
  236|  1.11k|    }
  237|     64|    if (pad) {
  ------------------
  |  Branch (237:9): [True: 64, Folded]
  ------------------
  238|     64|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (238:13): [True: 52, False: 12]
  ------------------
  239|     64|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  |  Branch (239:36): [True: 0, False: 0]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|     64|    return true;
  243|     64|}

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

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

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

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

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