_Z18ExtractDestinationRK7CScriptRNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
   50|  1.36k|{
   51|  1.36k|    std::vector<valtype> vSolutions;
   52|  1.36k|    TxoutType whichType = Solver(scriptPubKey, vSolutions);
   53|       |
   54|  1.36k|    switch (whichType) {
  ------------------
  |  Branch (54:13): [True: 0, False: 1.36k]
  ------------------
   55|      7|    case TxoutType::PUBKEY: {
  ------------------
  |  Branch (55:5): [True: 7, False: 1.35k]
  ------------------
   56|      7|        CPubKey pubKey(vSolutions[0]);
   57|      7|        if (!pubKey.IsValid()) {
  ------------------
  |  Branch (57:13): [True: 0, False: 7]
  ------------------
   58|      0|            addressRet = CNoDestination(scriptPubKey);
   59|      7|        } else {
   60|      7|            addressRet = PubKeyDestination(pubKey);
   61|      7|        }
   62|      7|        return false;
   63|      0|    }
   64|      4|    case TxoutType::PUBKEYHASH: {
  ------------------
  |  Branch (64:5): [True: 4, False: 1.36k]
  ------------------
   65|      4|        addressRet = PKHash(uint160(vSolutions[0]));
   66|      4|        return true;
   67|      0|    }
   68|     12|    case TxoutType::SCRIPTHASH: {
  ------------------
  |  Branch (68:5): [True: 12, False: 1.35k]
  ------------------
   69|     12|        addressRet = ScriptHash(uint160(vSolutions[0]));
   70|     12|        return true;
   71|      0|    }
   72|      2|    case TxoutType::WITNESS_V0_KEYHASH: {
  ------------------
  |  Branch (72:5): [True: 2, False: 1.36k]
  ------------------
   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.36k]
  ------------------
   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|    571|    case TxoutType::WITNESS_V1_TAPROOT: {
  ------------------
  |  Branch (84:5): [True: 571, False: 794]
  ------------------
   85|    571|        WitnessV1Taproot tap;
   86|    571|        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
   87|    571|        addressRet = tap;
   88|    571|        return true;
   89|      0|    }
   90|      2|    case TxoutType::ANCHOR: {
  ------------------
  |  Branch (90:5): [True: 2, False: 1.36k]
  ------------------
   91|      2|        addressRet = PayToAnchor();
   92|      2|        return true;
   93|      0|    }
   94|     52|    case TxoutType::WITNESS_UNKNOWN: {
  ------------------
  |  Branch (94:5): [True: 52, False: 1.31k]
  ------------------
   95|     52|        addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};
   96|     52|        return true;
   97|      0|    }
   98|    103|    case TxoutType::MULTISIG:
  ------------------
  |  Branch (98:5): [True: 103, False: 1.26k]
  ------------------
   99|    123|    case TxoutType::NULL_DATA:
  ------------------
  |  Branch (99:5): [True: 20, False: 1.34k]
  ------------------
  100|    713|    case TxoutType::NONSTANDARD:
  ------------------
  |  Branch (100:5): [True: 590, False: 775]
  ------------------
  101|    713|        addressRet = CNoDestination(scriptPubKey);
  102|    713|        return false;
  103|  1.36k|    } // no default case, so the compiler can warn about missing cases
  104|      0|    assert(false);
  105|      0|}
_Z23GetScriptForDestinationRKNSt3__17variantIJ14CNoDestination17PubKeyDestination6PKHash10ScriptHash19WitnessV0ScriptHash16WitnessV0KeyHash16WitnessV1Taproot11PayToAnchor14WitnessUnknownEEE:
  167|    176|{
  168|    176|    return std::visit(CScriptVisitor(), dest);
  169|    176|}
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK6PKHash:
  122|      2|    {
  123|      2|        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
  124|      2|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK10ScriptHash:
  127|      6|    {
  128|      6|        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
  129|      6|    }
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|    139|    {
  143|    139|        return CScript() << OP_1 << ToByteVector(tap);
  144|    139|    }
addresstype.cpp:_ZNK12_GLOBAL__N_114CScriptVisitorclERK14WitnessUnknown:
  147|     27|    {
  148|     27|        return CScript() << CScript::EncodeOP_N(id.GetWitnessVersion()) << id.GetWitnessProgram();
  149|     27|    }

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

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

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

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

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

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

_Z12FormatScriptRK7CScript:
   40|  2.83k|{
   41|  2.83k|    std::string ret;
   42|  2.83k|    CScript::const_iterator it = script.begin();
   43|  2.83k|    opcodetype op;
   44|   764k|    while (it != script.end()) {
  ------------------
  |  Branch (44:12): [True: 762k, False: 2.52k]
  ------------------
   45|   762k|        CScript::const_iterator it2 = it;
   46|   762k|        std::vector<unsigned char> vch;
   47|   762k|        if (script.GetOp(it, op, vch)) {
  ------------------
  |  Branch (47:13): [True: 761k, False: 304]
  ------------------
   48|   761k|            if (op == OP_0) {
  ------------------
  |  Branch (48:17): [True: 21.5k, False: 740k]
  ------------------
   49|  21.5k|                ret += "0 ";
   50|  21.5k|                continue;
   51|   740k|            } else if ((op >= OP_1 && op <= OP_16) || op == OP_1NEGATE) {
  ------------------
  |  Branch (51:25): [True: 606k, False: 134k]
  |  Branch (51:39): [True: 7.41k, False: 598k]
  |  Branch (51:55): [True: 597, False: 732k]
  ------------------
   52|  8.01k|                ret += strprintf("%i ", op - OP_1NEGATE - 1);
  ------------------
  |  | 1172|  8.01k|#define strprintf tfm::format
  ------------------
   53|  8.01k|                continue;
   54|   732k|            } else if (op >= OP_NOP && op <= OP_NOP10) {
  ------------------
  |  Branch (54:24): [True: 598k, False: 133k]
  |  Branch (54:40): [True: 492k, False: 106k]
  ------------------
   55|   492k|                std::string str(GetOpName(op));
   56|   492k|                if (str.substr(0, 3) == std::string("OP_")) {
  ------------------
  |  Branch (56:21): [True: 492k, False: 0]
  ------------------
   57|   492k|                    ret += str.substr(3, std::string::npos) + " ";
   58|   492k|                    continue;
   59|   492k|                }
   60|   492k|            }
   61|   240k|            if (vch.size() > 0) {
  ------------------
  |  Branch (61:17): [True: 132k, False: 107k]
  ------------------
   62|   132k|                ret += strprintf("0x%x 0x%x ", HexStr(std::vector<uint8_t>(it2, it - vch.size())),
  ------------------
  |  | 1172|   132k|#define strprintf tfm::format
  ------------------
   63|   132k|                                               HexStr(std::vector<uint8_t>(it - vch.size(), it)));
   64|   132k|            } else {
   65|   107k|                ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, it)));
  ------------------
  |  | 1172|   107k|#define strprintf tfm::format
  ------------------
   66|   107k|            }
   67|   240k|            continue;
   68|   761k|        }
   69|    304|        ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, script.end())));
  ------------------
  |  | 1172|    304|#define strprintf tfm::format
  ------------------
   70|    304|        break;
   71|   762k|    }
   72|  2.83k|    return ret.substr(0, ret.empty() ? ret.npos : ret.size() - 1);
  ------------------
  |  Branch (72:26): [True: 147, False: 2.68k]
  ------------------
   73|  2.83k|}
_Z14ScriptToAsmStrRK7CScriptb:
   99|  5.66k|{
  100|  5.66k|    std::string str;
  101|  5.66k|    opcodetype opcode;
  102|  5.66k|    std::vector<unsigned char> vch;
  103|  5.66k|    CScript::const_iterator pc = script.begin();
  104|  1.52M|    while (pc < script.end()) {
  ------------------
  |  Branch (104:12): [True: 1.52M, False: 5.05k]
  ------------------
  105|  1.52M|        if (!str.empty()) {
  ------------------
  |  Branch (105:13): [True: 1.51M, False: 5.37k]
  ------------------
  106|  1.51M|            str += " ";
  107|  1.51M|        }
  108|  1.52M|        if (!script.GetOp(pc, opcode, vch)) {
  ------------------
  |  Branch (108:13): [True: 608, False: 1.52M]
  ------------------
  109|    608|            str += "[error]";
  110|    608|            return str;
  111|    608|        }
  112|  1.52M|        if (0 <= opcode && opcode <= OP_PUSHDATA4) {
  ------------------
  |  Branch (112:13): [True: 1.52M, False: 0]
  |  Branch (112:28): [True: 309k, False: 1.21M]
  ------------------
  113|   309k|            if (vch.size() <= static_cast<std::vector<unsigned char>::size_type>(4)) {
  ------------------
  |  Branch (113:17): [True: 144k, False: 165k]
  ------------------
  114|   144k|                str += strprintf("%d", CScriptNum(vch, false).getint());
  ------------------
  |  | 1172|   144k|#define strprintf tfm::format
  ------------------
  115|   165k|            } else {
  116|       |                // the IsUnspendable check makes sure not to try to decode OP_RETURN data that may match the format of a signature
  117|   165k|                if (fAttemptSighashDecode && !script.IsUnspendable()) {
  ------------------
  |  Branch (117:21): [True: 28.5k, False: 136k]
  |  Branch (117:46): [True: 7.64k, False: 20.9k]
  ------------------
  118|  7.64k|                    std::string strSigHashDecode;
  119|       |                    // goal: only attempt to decode a defined sighash type from data that looks like a signature within a scriptSig.
  120|       |                    // this won't decode correctly formatted public keys in Pubkey or Multisig scripts due to
  121|       |                    // the restrictions on the pubkey formats (see IsCompressedOrUncompressedPubKey) being incongruous with the
  122|       |                    // checks in CheckSignatureEncoding.
  123|  7.64k|                    if (CheckSignatureEncoding(vch, SCRIPT_VERIFY_STRICTENC, nullptr)) {
  ------------------
  |  Branch (123:25): [True: 424, False: 7.22k]
  ------------------
  124|    424|                        const unsigned char chSigHashType = vch.back();
  125|    424|                        const auto it = mapSigHashTypes.find(chSigHashType);
  126|    424|                        if (it != mapSigHashTypes.end()) {
  ------------------
  |  Branch (126:29): [True: 424, False: 0]
  ------------------
  127|    424|                            strSigHashDecode = "[" + it->second + "]";
  128|    424|                            vch.pop_back(); // remove the sighash type byte. it will be replaced by the decode.
  129|    424|                        }
  130|    424|                    }
  131|  7.64k|                    str += HexStr(vch) + strSigHashDecode;
  132|   157k|                } else {
  133|   157k|                    str += HexStr(vch);
  134|   157k|                }
  135|   165k|            }
  136|  1.21M|        } else {
  137|  1.21M|            str += GetOpName(opcode);
  138|  1.21M|        }
  139|  1.52M|    }
  140|  5.05k|    return str;
  141|  5.66k|}
_Z12ScriptToUnivRK7CScriptR8UniValuebbPK15SigningProvider:
  151|  2.83k|{
  152|  2.83k|    CTxDestination address;
  153|       |
  154|  2.83k|    out.pushKV("asm", ScriptToAsmStr(script));
  155|  2.83k|    if (include_address) {
  ------------------
  |  Branch (155:9): [True: 850, False: 1.98k]
  ------------------
  156|    850|        out.pushKV("desc", InferDescriptor(script, provider ? *provider : DUMMY_SIGNING_PROVIDER)->ToString());
  ------------------
  |  Branch (156:52): [True: 0, False: 850]
  ------------------
  157|    850|    }
  158|  2.83k|    if (include_hex) {
  ------------------
  |  Branch (158:9): [True: 599, False: 2.23k]
  ------------------
  159|    599|        out.pushKV("hex", HexStr(script));
  160|    599|    }
  161|       |
  162|  2.83k|    std::vector<std::vector<unsigned char>> solns;
  163|  2.83k|    const TxoutType type{Solver(script, solns)};
  164|       |
  165|  2.83k|    if (include_address && ExtractDestination(script, address) && type != TxoutType::PUBKEY) {
  ------------------
  |  Branch (165:9): [True: 850, False: 1.98k]
  |  Branch (165:28): [True: 469, False: 381]
  |  Branch (165:67): [True: 469, False: 0]
  ------------------
  166|    469|        out.pushKV("address", EncodeDestination(address));
  167|    469|    }
  168|  2.83k|    out.pushKV("type", GetTxnOutputType(type));
  169|  2.83k|}

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

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

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

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

_ZN8CHash2568FinalizeE4SpanIhE:
   30|     16|    void Finalize(Span<unsigned char> output) {
   31|     16|        assert(output.size() == OUTPUT_SIZE);
   32|     16|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   33|     16|        sha.Finalize(buf);
   34|     16|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   35|     16|    }
_ZN8CHash2565WriteE4SpanIKhE:
   37|     16|    CHash256& Write(Span<const unsigned char> input) {
   38|     16|        sha.Write(input.data(), input.size());
   39|     16|        return *this;
   40|     16|    }
_ZN8CHash1608FinalizeE4SpanIhE:
   55|  1.14k|    void Finalize(Span<unsigned char> output) {
   56|  1.14k|        assert(output.size() == OUTPUT_SIZE);
   57|  1.14k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   58|  1.14k|        sha.Finalize(buf);
   59|  1.14k|        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   60|  1.14k|    }
_ZN8CHash1605WriteE4SpanIKhE:
   62|  1.14k|    CHash160& Write(Span<const unsigned char> input) {
   63|  1.14k|        sha.Write(input.data(), input.size());
   64|  1.14k|        return *this;
   65|  1.14k|    }
_Z9RIPEMD1604SpanIKhE:
  223|      1|{
  224|      1|    uint160 result;
  225|      1|    CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin());
  226|      1|    return result;
  227|      1|}
_Z7Hash160I4SpanIKhEE7uint160RKT_:
   93|  1.14k|{
   94|  1.14k|    uint160 result;
   95|  1.14k|    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
   96|  1.14k|    return result;
   97|  1.14k|}
_Z4HashINSt3__16vectorIhNS0_9allocatorIhEEEEE7uint256RKT_:
   76|     16|{
   77|     16|    uint256 result;
   78|     16|    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
   79|     16|    return result;
   80|     16|}

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

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

_ZN9prevectorILj28EhjiE3endEv:
  304|  39.5M|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj28EhjiE8item_ptrEi:
  206|   118M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 27.1k, False: 118M]
  ------------------
_ZNK9prevectorILj28EhjiE9is_directEv:
  173|   286M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj28EhjiE10direct_ptrEi:
  169|  30.3k|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj28EhjiE12indirect_ptrEi:
  171|   118M|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj28EhjiE6insertENS0_8iteratorERKh:
  359|  25.8M|    iterator insert(iterator pos, const T& value) {
  360|  25.8M|        size_type p = pos - begin();
  361|  25.8M|        size_type new_size = size() + 1;
  362|  25.8M|        if (capacity() < new_size) {
  ------------------
  |  Branch (362:13): [True: 1.21k, False: 25.8M]
  ------------------
  363|  1.21k|            change_capacity(new_size + (new_size >> 1));
  364|  1.21k|        }
  365|  25.8M|        T* ptr = item_ptr(p);
  366|  25.8M|        T* dst = ptr + 1;
  367|  25.8M|        memmove(dst, ptr, (size() - p) * sizeof(T));
  368|  25.8M|        _size++;
  369|  25.8M|        new(static_cast<void*>(ptr)) T(value);
  370|  25.8M|        return iterator(ptr);
  371|  25.8M|    }
_ZN9prevectorILj28EhjiE5beginEv:
  302|  39.5M|    iterator begin() { return iterator(item_ptr(0)); }
_ZmiN9prevectorILj28EhjiE8iteratorES1_:
   66|  39.5M|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj28EhjiE8iteratordeEv:
   59|  79.1M|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj28EhjiE8capacityEv:
  312|  39.6M|    size_t capacity() const {
  313|  39.6M|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 10.0k, False: 39.6M]
  ------------------
  314|  10.0k|            return N;
  315|  39.6M|        } else {
  316|  39.6M|            return _union.indirect_contents.capacity;
  317|  39.6M|        }
  318|  39.6M|    }
_ZN9prevectorILj28EhjiE15change_capacityEj:
  175|  15.3k|    void change_capacity(size_type new_capacity) {
  176|  15.3k|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 250, False: 15.0k]
  ------------------
  177|    250|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 250]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|  15.0k|        } else {
  186|  15.0k|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 11.8k, False: 3.29k]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|  11.8k|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|  11.8k|                assert(_union.indirect_contents.indirect);
  192|  11.8k|                _union.indirect_contents.capacity = new_capacity;
  193|  11.8k|            } else {
  194|  3.29k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|  3.29k|                assert(new_indirect);
  196|  3.29k|                T* src = direct_ptr(0);
  197|  3.29k|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|  3.29k|                memcpy(dst, src, size() * sizeof(T));
  199|  3.29k|                _union.indirect_contents.indirect = new_indirect;
  200|  3.29k|                _union.indirect_contents.capacity = new_capacity;
  201|  3.29k|                _size += N + 1;
  202|  3.29k|            }
  203|  15.0k|        }
  204|  15.3k|    }
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvNS0_8iteratorET_S8_:
  387|  13.2M|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|  13.2M|        size_type p = pos - begin();
  389|  13.2M|        difference_type count = last - first;
  390|  13.2M|        size_type new_size = size() + count;
  391|  13.2M|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 11.0k, False: 13.1M]
  ------------------
  392|  11.0k|            change_capacity(new_size + (new_size >> 1));
  393|  11.0k|        }
  394|  13.2M|        T* ptr = item_ptr(p);
  395|  13.2M|        T* dst = ptr + count;
  396|  13.2M|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|  13.2M|        _size += count;
  398|  13.2M|        fill(ptr, first, last);
  399|  13.2M|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  214|  13.2M|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  1.59G|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 1.58G, False: 13.2M]
  ------------------
  216|  1.58G|            new(static_cast<void*>(dst)) T(*first);
  217|  1.58G|            ++dst;
  218|  1.58G|            ++first;
  219|  1.58G|        }
  220|  13.2M|    }
_ZN9prevectorILj28EhjiE9push_backERKh:
  444|  70.3k|    void push_back(const T& value) {
  445|  70.3k|        emplace_back(value);
  446|  70.3k|    }
_ZN9prevectorILj28EhjiE12emplace_backIJRKhEEEvDpOT_:
  435|  70.3k|    void emplace_back(Args&&... args) {
  436|  70.3k|        size_type new_size = size() + 1;
  437|  70.3k|        if (capacity() < new_size) {
  ------------------
  |  Branch (437:13): [True: 53, False: 70.3k]
  ------------------
  438|     53|            change_capacity(new_size + (new_size >> 1));
  439|     53|        }
  440|  70.3k|        new(item_ptr(size())) T(std::forward<Args>(args)...);
  441|  70.3k|        _size++;
  442|  70.3k|    }
_ZNK9prevectorILj28EhjiE3endEv:
  305|  4.69M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj28EhjiE8item_ptrEi:
  207|  4.75M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 29.4k, False: 4.72M]
  ------------------
_ZNK9prevectorILj28EhjiE10direct_ptrEi:
  170|  29.4k|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE12indirect_ptrEi:
  172|  4.72M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE4sizeEv:
  294|   123M|    size_type size() const {
  295|   123M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 62.1k, False: 123M]
  ------------------
  296|   123M|    }
_ZNK9prevectorILj28EhjiE5beginEv:
  303|  44.1k|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj28EhjiE14const_iteratordeEv:
  111|  22.6M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  214|  1.22k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  11.3M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 11.3M, False: 1.22k]
  ------------------
  216|  11.3M|            new(static_cast<void*>(dst)) T(*first);
  217|  11.3M|            ++dst;
  218|  11.3M|            ++first;
  219|  11.3M|        }
  220|  1.22k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorneES1_:
  125|  12.1M|        bool operator!=(const_iterator x) const { return ptr != x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEv:
  114|  13.8M|        const_iterator& operator++() { ptr++; return *this; }
_ZNK9prevectorILj28EhjiEeqERKS0_:
  481|    176|    bool operator==(const prevector<N, T, Size, Diff>& other) const {
  482|    176|        if (other.size() != size()) {
  ------------------
  |  Branch (482:13): [True: 0, False: 176]
  ------------------
  483|      0|            return false;
  484|      0|        }
  485|    176|        const_iterator b1 = begin();
  486|    176|        const_iterator b2 = other.begin();
  487|    176|        const_iterator e1 = end();
  488|  5.67k|        while (b1 != e1) {
  ------------------
  |  Branch (488:16): [True: 5.49k, False: 176]
  ------------------
  489|  5.49k|            if ((*b1) != (*b2)) {
  ------------------
  |  Branch (489:17): [True: 0, False: 5.49k]
  ------------------
  490|      0|                return false;
  491|      0|            }
  492|  5.49k|            ++b1;
  493|  5.49k|            ++b2;
  494|  5.49k|        }
  495|    176|        return true;
  496|    176|    }
_ZNK9prevectorILj28EhjiE4dataEv:
  537|    938|    const value_type* data() const {
  538|    938|        return item_ptr(0);
  539|    938|    }
_ZNK9prevectorILj28EhjiEixEj:
  324|  13.6k|    const T& operator[](size_type pos) const {
  325|  13.6k|        return *item_ptr(pos);
  326|  13.6k|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|  8.17k|    ~prevector() {
  475|  8.17k|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 3.29k, False: 4.88k]
  ------------------
  476|  3.29k|            free(_union.indirect_contents.indirect);
  477|  3.29k|            _union.indirect_contents.indirect = nullptr;
  478|  3.29k|        }
  479|  8.17k|    }
_ZN9prevectorILj28EhjiEC2EOS0_:
  271|    339|        : _union(std::move(other._union)), _size(other._size)
  272|    339|    {
  273|    339|        other._size = 0;
  274|    339|    }
_ZN9prevectorILj28EhjiEC2Ev:
  243|  6.60k|    prevector() = default;
_ZN9prevectorILj28EhjiE8iteratorC2EPh:
   58|   104M|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiE14const_iteratorC2EPKh:
  109|  5.80M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiEC2ERKS0_:
  263|  1.22k|    prevector(const prevector<N, T, Size, Diff>& other) {
  264|  1.22k|        size_type n = other.size();
  265|  1.22k|        change_capacity(n);
  266|  1.22k|        _size += n;
  267|  1.22k|        fill(item_ptr(0), other.begin(),  other.end());
  268|  1.22k|    }
_ZmiN9prevectorILj28EhjiE14const_iteratorES1_:
  118|  4.38M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj28EhjiEaSEOS0_:
  284|    713|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  285|    713|        if (!is_direct()) {
  ------------------
  |  Branch (285:13): [True: 0, False: 713]
  ------------------
  286|      0|            free(_union.indirect_contents.indirect);
  287|      0|        }
  288|    713|        _union = std::move(other._union);
  289|    713|        _size = other._size;
  290|    713|        other._size = 0;
  291|    713|        return *this;
  292|    713|    }
_ZNK9prevectorILj28EhjiE14const_iteratorptEv:
  112|  2.52M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvS4_T_S6_:
  214|   546k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  50.0M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 49.4M, False: 546k]
  ------------------
  216|  49.4M|            new(static_cast<void*>(dst)) T(*first);
  217|  49.4M|            ++dst;
  218|  49.4M|            ++first;
  219|  49.4M|        }
  220|   546k|    }
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvNS0_8iteratorET_S7_:
  387|   546k|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|   546k|        size_type p = pos - begin();
  389|   546k|        difference_type count = last - first;
  390|   546k|        size_type new_size = size() + count;
  391|   546k|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 1.84k, False: 544k]
  ------------------
  392|  1.84k|            change_capacity(new_size + (new_size >> 1));
  393|  1.84k|        }
  394|   546k|        T* ptr = item_ptr(p);
  395|   546k|        T* dst = ptr + count;
  396|   546k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|   546k|        _size += count;
  398|   546k|        fill(ptr, first, last);
  399|   546k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorltES1_:
  129|  1.58M|        bool operator<(const_iterator x) const { return ptr < x.ptr; }
_ZNK9prevectorILj28EhjiE14const_iteratormiEj:
  122|   264k|        const_iterator operator-(size_type n) const { return const_iterator(ptr - n); }
_ZNK9prevectorILj28EhjiE4backEv:
  464|  3.24k|    const T& back() const {
  465|  3.24k|        return *item_ptr(size() - 1);
  466|  3.24k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorplEj:
  119|   796k|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
_ZNK9prevectorILj28EhjiE14const_iteratoreqES1_:
  124|    274|        bool operator==(const_iterator x) const { return ptr == x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorpLEj:
  121|   784k|        const_iterator& operator+=(size_type n) { ptr += n; return *this; }
_ZNK9prevectorILj28EhjiE14const_iteratorixEj:
  113|  5.58k|        const T& operator[](size_type pos) const { return ptr[pos]; }
_ZNK9prevectorILj28EhjiE14const_iteratorgeES1_:
  126|  2.34M|        bool operator>=(const_iterator x) const { return ptr >= x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEi:
  116|  2.49M|        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }

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

_ZN6CKeyIDC2ERK7uint160:
   27|  1.14k|    explicit CKeyID(const uint160& in) : uint160(in) {}
_ZN7CPubKey6GetLenEh:
   61|  6.85k|    {
   62|  6.85k|        if (chHeader == 2 || chHeader == 3)
  ------------------
  |  Branch (62:13): [True: 2.21k, False: 4.64k]
  |  Branch (62:30): [True: 2.07k, False: 2.56k]
  ------------------
   63|  4.28k|            return COMPRESSED_SIZE;
   64|  2.56k|        if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  ------------------
  |  Branch (64:13): [True: 1.91k, False: 649]
  |  Branch (64:30): [True: 287, False: 362]
  |  Branch (64:47): [True: 210, False: 152]
  ------------------
   65|  2.41k|            return SIZE;
   66|    152|        return 0;
   67|  2.56k|    }
_ZN7CPubKey10InvalidateEv:
   71|    296|    {
   72|    296|        vch[0] = 0xFF;
   73|    296|    }
_ZN7CPubKey9ValidSizeERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
   77|  3.28k|    bool static ValidSize(const std::vector<unsigned char> &vch) {
   78|  3.28k|      return vch.size() > 0 && GetLen(vch[0]) == vch.size();
  ------------------
  |  Branch (78:14): [True: 2.99k, False: 294]
  |  Branch (78:32): [True: 2.81k, False: 178]
  ------------------
   79|  3.28k|    }
_ZN7CPubKeyC2Ev:
   83|    296|    {
   84|    296|        Invalidate();
   85|    296|    }
_ZN7CPubKeyC2E4SpanIKhE:
  107|    889|    {
  108|    889|        Set(_vch.begin(), _vch.end());
  109|    889|    }
_ZNK7CPubKey4sizeEv:
  112|  2.38k|    unsigned int size() const { return GetLen(vch[0]); }
_ZNK7CPubKey4dataEv:
  113|    645|    const unsigned char* data() const { return vch; }
_ZNK7CPubKey5GetIDEv:
  165|  1.14k|    {
  166|  1.14k|        return CKeyID(Hash160(Span{vch}.first(size())));
  167|  1.14k|    }
_ZNK7CPubKey7IsValidEv:
  190|      7|    {
  191|      7|        return size() > 0;
  192|      7|    }
_ZNK7CPubKey16IsValidNonHybridEv:
  196|    589|    {
  197|    589|        return size() > 0 && (vch[0] == 0x02 || vch[0] == 0x03 || vch[0] == 0x04);
  ------------------
  |  Branch (197:16): [True: 589, False: 0]
  |  Branch (197:31): [True: 131, False: 458]
  |  Branch (197:49): [True: 181, False: 277]
  |  Branch (197:67): [True: 243, False: 34]
  ------------------
  198|    589|    }
_ZNK11XOnlyPubKey5beginEv:
  295|  1.00k|    const unsigned char* begin() const { return m_keydata.begin(); }
_ZNK11XOnlyPubKey3endEv:
  296|  1.00k|    const unsigned char* end() const { return m_keydata.end(); }
_ZN11XOnlyPubKey5beginEv:
  298|  1.00k|    unsigned char* begin() { return m_keydata.begin(); }
_ZN7CPubKey3SetIPKhEEvT_S3_:
   90|    889|    {
   91|    889|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 889]
  ------------------
   92|    889|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 889, False: 0]
  |  Branch (92:20): [True: 889, False: 0]
  ------------------
   93|    889|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|    889|    }
_ZN11XOnlyPubKeyC2Ev:
  242|  1.43k|    XOnlyPubKey() = default;
_ZN7CPubKey3SetIPhEEvT_S2_:
   90|    586|    {
   91|    586|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 586]
  ------------------
   92|    586|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 586, False: 0]
  |  Branch (92:20): [True: 586, False: 0]
  ------------------
   93|    586|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|    586|    }

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

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

_Z22CheckSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEEjP13ScriptError_t:
  200|  7.64k|bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror) {
  201|       |    // Empty signature. Not strictly DER encoded, but allowed to provide a
  202|       |    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
  203|  7.64k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (203:9): [True: 0, False: 7.64k]
  ------------------
  204|      0|        return true;
  205|      0|    }
  206|  7.64k|    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
  ------------------
  |  Branch (206:9): [True: 7.64k, False: 0]
  |  Branch (206:98): [True: 6.51k, False: 1.12k]
  ------------------
  207|  6.51k|        return set_error(serror, SCRIPT_ERR_SIG_DER);
  208|  6.51k|    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
  ------------------
  |  Branch (208:16): [True: 0, False: 1.12k]
  |  Branch (208:54): [True: 0, False: 0]
  ------------------
  209|       |        // serror is set
  210|      0|        return false;
  211|  1.12k|    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
  ------------------
  |  Branch (211:16): [True: 1.12k, False: 0]
  |  Branch (211:58): [True: 703, False: 424]
  ------------------
  212|    703|        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
  213|    703|    }
  214|    424|    return true;
  215|  7.64k|}
interpreter.cpp:_ZL24IsValidSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  107|  7.64k|bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
  108|       |    // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
  109|       |    // * total-length: 1-byte length descriptor of everything that follows,
  110|       |    //   excluding the sighash byte.
  111|       |    // * R-length: 1-byte length descriptor of the R value that follows.
  112|       |    // * R: arbitrary-length big-endian encoded R value. It must use the shortest
  113|       |    //   possible encoding for a positive integer (which means no null bytes at
  114|       |    //   the start, except a single one when the next byte has its highest bit set).
  115|       |    // * S-length: 1-byte length descriptor of the S value that follows.
  116|       |    // * S: arbitrary-length big-endian encoded S value. The same rules apply.
  117|       |    // * sighash: 1-byte value indicating what data is hashed (not part of the DER
  118|       |    //   signature)
  119|       |
  120|       |    // Minimum and maximum size constraints.
  121|  7.64k|    if (sig.size() < 9) return false;
  ------------------
  |  Branch (121:9): [True: 510, False: 7.13k]
  ------------------
  122|  7.13k|    if (sig.size() > 73) return false;
  ------------------
  |  Branch (122:9): [True: 935, False: 6.20k]
  ------------------
  123|       |
  124|       |    // A signature is of type 0x30 (compound).
  125|  6.20k|    if (sig[0] != 0x30) return false;
  ------------------
  |  Branch (125:9): [True: 2.42k, False: 3.77k]
  ------------------
  126|       |
  127|       |    // Make sure the length covers the entire signature.
  128|  3.77k|    if (sig[1] != sig.size() - 3) return false;
  ------------------
  |  Branch (128:9): [True: 328, False: 3.44k]
  ------------------
  129|       |
  130|       |    // Extract the length of the R element.
  131|  3.44k|    unsigned int lenR = sig[3];
  132|       |
  133|       |    // Make sure the length of the S element is still inside the signature.
  134|  3.44k|    if (5 + lenR >= sig.size()) return false;
  ------------------
  |  Branch (134:9): [True: 269, False: 3.17k]
  ------------------
  135|       |
  136|       |    // Extract the length of the S element.
  137|  3.17k|    unsigned int lenS = sig[5 + lenR];
  138|       |
  139|       |    // Verify that the length of the signature matches the sum of the length
  140|       |    // of the elements.
  141|  3.17k|    if ((size_t)(lenR + lenS + 7) != sig.size()) return false;
  ------------------
  |  Branch (141:9): [True: 268, False: 2.90k]
  ------------------
  142|       |
  143|       |    // Check whether the R element is an integer.
  144|  2.90k|    if (sig[2] != 0x02) return false;
  ------------------
  |  Branch (144:9): [True: 211, False: 2.69k]
  ------------------
  145|       |
  146|       |    // Zero-length integers are not allowed for R.
  147|  2.69k|    if (lenR == 0) return false;
  ------------------
  |  Branch (147:9): [True: 197, False: 2.49k]
  ------------------
  148|       |
  149|       |    // Negative numbers are not allowed for R.
  150|  2.49k|    if (sig[4] & 0x80) return false;
  ------------------
  |  Branch (150:9): [True: 202, False: 2.29k]
  ------------------
  151|       |
  152|       |    // Null bytes at the start of R are not allowed, unless R would
  153|       |    // otherwise be interpreted as a negative number.
  154|  2.29k|    if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) return false;
  ------------------
  |  Branch (154:9): [True: 1.01k, False: 1.28k]
  |  Branch (154:21): [True: 459, False: 557]
  |  Branch (154:41): [True: 199, False: 260]
  ------------------
  155|       |
  156|       |    // Check whether the S element is an integer.
  157|  2.09k|    if (sig[lenR + 4] != 0x02) return false;
  ------------------
  |  Branch (157:9): [True: 274, False: 1.82k]
  ------------------
  158|       |
  159|       |    // Zero-length integers are not allowed for S.
  160|  1.82k|    if (lenS == 0) return false;
  ------------------
  |  Branch (160:9): [True: 265, False: 1.55k]
  ------------------
  161|       |
  162|       |    // Negative numbers are not allowed for S.
  163|  1.55k|    if (sig[lenR + 6] & 0x80) return false;
  ------------------
  |  Branch (163:9): [True: 202, False: 1.35k]
  ------------------
  164|       |
  165|       |    // Null bytes at the start of S are not allowed, unless S would otherwise be
  166|       |    // interpreted as a negative number.
  167|  1.35k|    if (lenS > 1 && (sig[lenR + 6] == 0x00) && !(sig[lenR + 7] & 0x80)) return false;
  ------------------
  |  Branch (167:9): [True: 1.04k, False: 308]
  |  Branch (167:21): [True: 516, False: 533]
  |  Branch (167:48): [True: 230, False: 286]
  ------------------
  168|       |
  169|  1.12k|    return true;
  170|  1.35k|}
interpreter.cpp:_ZN12_GLOBAL__N_19set_errorEP13ScriptError_tS0_:
   27|  7.22k|{
   28|  7.22k|    if (ret)
  ------------------
  |  Branch (28:9): [True: 0, False: 7.22k]
  ------------------
   29|      0|        *ret = serror;
   30|  7.22k|    return false;
   31|  7.22k|}
interpreter.cpp:_ZL26IsDefinedHashtypeSignatureRKNSt3__16vectorIhNS_9allocatorIhEEEE:
  189|  1.12k|bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
  190|  1.12k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (190:9): [True: 0, False: 1.12k]
  ------------------
  191|      0|        return false;
  192|      0|    }
  193|  1.12k|    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
  194|  1.12k|    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
  ------------------
  |  Branch (194:9): [True: 210, False: 917]
  |  Branch (194:36): [True: 493, False: 424]
  ------------------
  195|    703|        return false;
  196|       |
  197|    424|    return true;
  198|  1.12k|}

_Z9GetOpName10opcodetype:
   19|  1.70M|{
   20|  1.70M|    switch (opcode)
   21|  1.70M|    {
   22|       |    // push value
   23|      0|    case OP_0                      : return "0";
  ------------------
  |  Branch (23:5): [True: 0, False: 1.70M]
  ------------------
   24|      0|    case OP_PUSHDATA1              : return "OP_PUSHDATA1";
  ------------------
  |  Branch (24:5): [True: 0, False: 1.70M]
  ------------------
   25|      0|    case OP_PUSHDATA2              : return "OP_PUSHDATA2";
  ------------------
  |  Branch (25:5): [True: 0, False: 1.70M]
  ------------------
   26|      0|    case OP_PUSHDATA4              : return "OP_PUSHDATA4";
  ------------------
  |  Branch (26:5): [True: 0, False: 1.70M]
  ------------------
   27|  1.19k|    case OP_1NEGATE                : return "-1";
  ------------------
  |  Branch (27:5): [True: 1.19k, False: 1.70M]
  ------------------
   28|    388|    case OP_RESERVED               : return "OP_RESERVED";
  ------------------
  |  Branch (28:5): [True: 388, False: 1.70M]
  ------------------
   29|  1.24k|    case OP_1                      : return "1";
  ------------------
  |  Branch (29:5): [True: 1.24k, False: 1.70M]
  ------------------
   30|    270|    case OP_2                      : return "2";
  ------------------
  |  Branch (30:5): [True: 270, False: 1.70M]
  ------------------
   31|     66|    case OP_3                      : return "3";
  ------------------
  |  Branch (31:5): [True: 66, False: 1.70M]
  ------------------
   32|     88|    case OP_4                      : return "4";
  ------------------
  |  Branch (32:5): [True: 88, False: 1.70M]
  ------------------
   33|    172|    case OP_5                      : return "5";
  ------------------
  |  Branch (33:5): [True: 172, False: 1.70M]
  ------------------
   34|    106|    case OP_6                      : return "6";
  ------------------
  |  Branch (34:5): [True: 106, False: 1.70M]
  ------------------
   35|    104|    case OP_7                      : return "7";
  ------------------
  |  Branch (35:5): [True: 104, False: 1.70M]
  ------------------
   36|    318|    case OP_8                      : return "8";
  ------------------
  |  Branch (36:5): [True: 318, False: 1.70M]
  ------------------
   37|  2.35k|    case OP_9                      : return "9";
  ------------------
  |  Branch (37:5): [True: 2.35k, False: 1.70M]
  ------------------
   38|    988|    case OP_10                     : return "10";
  ------------------
  |  Branch (38:5): [True: 988, False: 1.70M]
  ------------------
   39|  5.05k|    case OP_11                     : return "11";
  ------------------
  |  Branch (39:5): [True: 5.05k, False: 1.70M]
  ------------------
   40|  1.66k|    case OP_12                     : return "12";
  ------------------
  |  Branch (40:5): [True: 1.66k, False: 1.70M]
  ------------------
   41|    484|    case OP_13                     : return "13";
  ------------------
  |  Branch (41:5): [True: 484, False: 1.70M]
  ------------------
   42|    238|    case OP_14                     : return "14";
  ------------------
  |  Branch (42:5): [True: 238, False: 1.70M]
  ------------------
   43|    212|    case OP_15                     : return "15";
  ------------------
  |  Branch (43:5): [True: 212, False: 1.70M]
  ------------------
   44|  1.47k|    case OP_16                     : return "16";
  ------------------
  |  Branch (44:5): [True: 1.47k, False: 1.70M]
  ------------------
   45|       |
   46|       |    // control
   47|   925k|    case OP_NOP                    : return "OP_NOP";
  ------------------
  |  Branch (47:5): [True: 925k, False: 780k]
  ------------------
   48|    525|    case OP_VER                    : return "OP_VER";
  ------------------
  |  Branch (48:5): [True: 525, False: 1.70M]
  ------------------
   49|     30|    case OP_IF                     : return "OP_IF";
  ------------------
  |  Branch (49:5): [True: 30, False: 1.70M]
  ------------------
   50|     69|    case OP_NOTIF                  : return "OP_NOTIF";
  ------------------
  |  Branch (50:5): [True: 69, False: 1.70M]
  ------------------
   51|     99|    case OP_VERIF                  : return "OP_VERIF";
  ------------------
  |  Branch (51:5): [True: 99, False: 1.70M]
  ------------------
   52|     87|    case OP_VERNOTIF               : return "OP_VERNOTIF";
  ------------------
  |  Branch (52:5): [True: 87, False: 1.70M]
  ------------------
   53|      6|    case OP_ELSE                   : return "OP_ELSE";
  ------------------
  |  Branch (53:5): [True: 6, False: 1.70M]
  ------------------
   54|    102|    case OP_ENDIF                  : return "OP_ENDIF";
  ------------------
  |  Branch (54:5): [True: 102, False: 1.70M]
  ------------------
   55|    342|    case OP_VERIFY                 : return "OP_VERIFY";
  ------------------
  |  Branch (55:5): [True: 342, False: 1.70M]
  ------------------
   56|  1.75k|    case OP_RETURN                 : return "OP_RETURN";
  ------------------
  |  Branch (56:5): [True: 1.75k, False: 1.70M]
  ------------------
   57|       |
   58|       |    // stack ops
   59|  1.04k|    case OP_TOALTSTACK             : return "OP_TOALTSTACK";
  ------------------
  |  Branch (59:5): [True: 1.04k, False: 1.70M]
  ------------------
   60|    234|    case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
  ------------------
  |  Branch (60:5): [True: 234, False: 1.70M]
  ------------------
   61|  6.03k|    case OP_2DROP                  : return "OP_2DROP";
  ------------------
  |  Branch (61:5): [True: 6.03k, False: 1.69M]
  ------------------
   62|     36|    case OP_2DUP                   : return "OP_2DUP";
  ------------------
  |  Branch (62:5): [True: 36, False: 1.70M]
  ------------------
   63|     18|    case OP_3DUP                   : return "OP_3DUP";
  ------------------
  |  Branch (63:5): [True: 18, False: 1.70M]
  ------------------
   64|     45|    case OP_2OVER                  : return "OP_2OVER";
  ------------------
  |  Branch (64:5): [True: 45, False: 1.70M]
  ------------------
   65|     78|    case OP_2ROT                   : return "OP_2ROT";
  ------------------
  |  Branch (65:5): [True: 78, False: 1.70M]
  ------------------
   66|      3|    case OP_2SWAP                  : return "OP_2SWAP";
  ------------------
  |  Branch (66:5): [True: 3, False: 1.70M]
  ------------------
   67|     30|    case OP_IFDUP                  : return "OP_IFDUP";
  ------------------
  |  Branch (67:5): [True: 30, False: 1.70M]
  ------------------
   68|  6.18k|    case OP_DEPTH                  : return "OP_DEPTH";
  ------------------
  |  Branch (68:5): [True: 6.18k, False: 1.69M]
  ------------------
   69|    141|    case OP_DROP                   : return "OP_DROP";
  ------------------
  |  Branch (69:5): [True: 141, False: 1.70M]
  ------------------
   70|  1.14k|    case OP_DUP                    : return "OP_DUP";
  ------------------
  |  Branch (70:5): [True: 1.14k, False: 1.70M]
  ------------------
   71|    219|    case OP_NIP                    : return "OP_NIP";
  ------------------
  |  Branch (71:5): [True: 219, False: 1.70M]
  ------------------
   72|     69|    case OP_OVER                   : return "OP_OVER";
  ------------------
  |  Branch (72:5): [True: 69, False: 1.70M]
  ------------------
   73|    558|    case OP_PICK                   : return "OP_PICK";
  ------------------
  |  Branch (73:5): [True: 558, False: 1.70M]
  ------------------
   74|    642|    case OP_ROLL                   : return "OP_ROLL";
  ------------------
  |  Branch (74:5): [True: 642, False: 1.70M]
  ------------------
   75|  1.36k|    case OP_ROT                    : return "OP_ROT";
  ------------------
  |  Branch (75:5): [True: 1.36k, False: 1.70M]
  ------------------
   76|     18|    case OP_SWAP                   : return "OP_SWAP";
  ------------------
  |  Branch (76:5): [True: 18, False: 1.70M]
  ------------------
   77|    522|    case OP_TUCK                   : return "OP_TUCK";
  ------------------
  |  Branch (77:5): [True: 522, False: 1.70M]
  ------------------
   78|       |
   79|       |    // splice ops
   80|     24|    case OP_CAT                    : return "OP_CAT";
  ------------------
  |  Branch (80:5): [True: 24, False: 1.70M]
  ------------------
   81|  20.9k|    case OP_SUBSTR                 : return "OP_SUBSTR";
  ------------------
  |  Branch (81:5): [True: 20.9k, False: 1.68M]
  ------------------
   82|    531|    case OP_LEFT                   : return "OP_LEFT";
  ------------------
  |  Branch (82:5): [True: 531, False: 1.70M]
  ------------------
   83|    114|    case OP_RIGHT                  : return "OP_RIGHT";
  ------------------
  |  Branch (83:5): [True: 114, False: 1.70M]
  ------------------
   84|     21|    case OP_SIZE                   : return "OP_SIZE";
  ------------------
  |  Branch (84:5): [True: 21, False: 1.70M]
  ------------------
   85|       |
   86|       |    // bit logic
   87|    189|    case OP_INVERT                 : return "OP_INVERT";
  ------------------
  |  Branch (87:5): [True: 189, False: 1.70M]
  ------------------
   88|     12|    case OP_AND                    : return "OP_AND";
  ------------------
  |  Branch (88:5): [True: 12, False: 1.70M]
  ------------------
   89|     93|    case OP_OR                     : return "OP_OR";
  ------------------
  |  Branch (89:5): [True: 93, False: 1.70M]
  ------------------
   90|     15|    case OP_XOR                    : return "OP_XOR";
  ------------------
  |  Branch (90:5): [True: 15, False: 1.70M]
  ------------------
   91|     21|    case OP_EQUAL                  : return "OP_EQUAL";
  ------------------
  |  Branch (91:5): [True: 21, False: 1.70M]
  ------------------
   92|     24|    case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
  ------------------
  |  Branch (92:5): [True: 24, False: 1.70M]
  ------------------
   93|    123|    case OP_RESERVED1              : return "OP_RESERVED1";
  ------------------
  |  Branch (93:5): [True: 123, False: 1.70M]
  ------------------
   94|    336|    case OP_RESERVED2              : return "OP_RESERVED2";
  ------------------
  |  Branch (94:5): [True: 336, False: 1.70M]
  ------------------
   95|       |
   96|       |    // numeric
   97|     42|    case OP_1ADD                   : return "OP_1ADD";
  ------------------
  |  Branch (97:5): [True: 42, False: 1.70M]
  ------------------
   98|     21|    case OP_1SUB                   : return "OP_1SUB";
  ------------------
  |  Branch (98:5): [True: 21, False: 1.70M]
  ------------------
   99|      0|    case OP_2MUL                   : return "OP_2MUL";
  ------------------
  |  Branch (99:5): [True: 0, False: 1.70M]
  ------------------
  100|     48|    case OP_2DIV                   : return "OP_2DIV";
  ------------------
  |  Branch (100:5): [True: 48, False: 1.70M]
  ------------------
  101|    378|    case OP_NEGATE                 : return "OP_NEGATE";
  ------------------
  |  Branch (101:5): [True: 378, False: 1.70M]
  ------------------
  102|    789|    case OP_ABS                    : return "OP_ABS";
  ------------------
  |  Branch (102:5): [True: 789, False: 1.70M]
  ------------------
  103|     39|    case OP_NOT                    : return "OP_NOT";
  ------------------
  |  Branch (103:5): [True: 39, False: 1.70M]
  ------------------
  104|    138|    case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
  ------------------
  |  Branch (104:5): [True: 138, False: 1.70M]
  ------------------
  105|      9|    case OP_ADD                    : return "OP_ADD";
  ------------------
  |  Branch (105:5): [True: 9, False: 1.70M]
  ------------------
  106|    771|    case OP_SUB                    : return "OP_SUB";
  ------------------
  |  Branch (106:5): [True: 771, False: 1.70M]
  ------------------
  107|     18|    case OP_MUL                    : return "OP_MUL";
  ------------------
  |  Branch (107:5): [True: 18, False: 1.70M]
  ------------------
  108|      6|    case OP_DIV                    : return "OP_DIV";
  ------------------
  |  Branch (108:5): [True: 6, False: 1.70M]
  ------------------
  109|    138|    case OP_MOD                    : return "OP_MOD";
  ------------------
  |  Branch (109:5): [True: 138, False: 1.70M]
  ------------------
  110|     54|    case OP_LSHIFT                 : return "OP_LSHIFT";
  ------------------
  |  Branch (110:5): [True: 54, False: 1.70M]
  ------------------
  111|    192|    case OP_RSHIFT                 : return "OP_RSHIFT";
  ------------------
  |  Branch (111:5): [True: 192, False: 1.70M]
  ------------------
  112|     75|    case OP_BOOLAND                : return "OP_BOOLAND";
  ------------------
  |  Branch (112:5): [True: 75, False: 1.70M]
  ------------------
  113|    129|    case OP_BOOLOR                 : return "OP_BOOLOR";
  ------------------
  |  Branch (113:5): [True: 129, False: 1.70M]
  ------------------
  114|      3|    case OP_NUMEQUAL               : return "OP_NUMEQUAL";
  ------------------
  |  Branch (114:5): [True: 3, False: 1.70M]
  ------------------
  115|     27|    case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
  ------------------
  |  Branch (115:5): [True: 27, False: 1.70M]
  ------------------
  116|    105|    case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
  ------------------
  |  Branch (116:5): [True: 105, False: 1.70M]
  ------------------
  117|  7.33k|    case OP_LESSTHAN               : return "OP_LESSTHAN";
  ------------------
  |  Branch (117:5): [True: 7.33k, False: 1.69M]
  ------------------
  118|    153|    case OP_GREATERTHAN            : return "OP_GREATERTHAN";
  ------------------
  |  Branch (118:5): [True: 153, False: 1.70M]
  ------------------
  119|    546|    case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
  ------------------
  |  Branch (119:5): [True: 546, False: 1.70M]
  ------------------
  120|     24|    case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
  ------------------
  |  Branch (120:5): [True: 24, False: 1.70M]
  ------------------
  121|  1.57k|    case OP_MIN                    : return "OP_MIN";
  ------------------
  |  Branch (121:5): [True: 1.57k, False: 1.70M]
  ------------------
  122|     33|    case OP_MAX                    : return "OP_MAX";
  ------------------
  |  Branch (122:5): [True: 33, False: 1.70M]
  ------------------
  123|     21|    case OP_WITHIN                 : return "OP_WITHIN";
  ------------------
  |  Branch (123:5): [True: 21, False: 1.70M]
  ------------------
  124|       |
  125|       |    // crypto
  126|  6.12k|    case OP_RIPEMD160              : return "OP_RIPEMD160";
  ------------------
  |  Branch (126:5): [True: 6.12k, False: 1.69M]
  ------------------
  127|     33|    case OP_SHA1                   : return "OP_SHA1";
  ------------------
  |  Branch (127:5): [True: 33, False: 1.70M]
  ------------------
  128|  1.03k|    case OP_SHA256                 : return "OP_SHA256";
  ------------------
  |  Branch (128:5): [True: 1.03k, False: 1.70M]
  ------------------
  129|    576|    case OP_HASH160                : return "OP_HASH160";
  ------------------
  |  Branch (129:5): [True: 576, False: 1.70M]
  ------------------
  130|     75|    case OP_HASH256                : return "OP_HASH256";
  ------------------
  |  Branch (130:5): [True: 75, False: 1.70M]
  ------------------
  131|     21|    case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
  ------------------
  |  Branch (131:5): [True: 21, False: 1.70M]
  ------------------
  132|    141|    case OP_CHECKSIG               : return "OP_CHECKSIG";
  ------------------
  |  Branch (132:5): [True: 141, False: 1.70M]
  ------------------
  133|    357|    case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
  ------------------
  |  Branch (133:5): [True: 357, False: 1.70M]
  ------------------
  134|  7.04k|    case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
  ------------------
  |  Branch (134:5): [True: 7.04k, False: 1.69M]
  ------------------
  135|    396|    case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  ------------------
  |  Branch (135:5): [True: 396, False: 1.70M]
  ------------------
  136|       |
  137|       |    // expansion
  138|    183|    case OP_NOP1                   : return "OP_NOP1";
  ------------------
  |  Branch (138:5): [True: 183, False: 1.70M]
  ------------------
  139|   476k|    case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
  ------------------
  |  Branch (139:5): [True: 476k, False: 1.22M]
  ------------------
  140|    678|    case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
  ------------------
  |  Branch (140:5): [True: 678, False: 1.70M]
  ------------------
  141|    543|    case OP_NOP4                   : return "OP_NOP4";
  ------------------
  |  Branch (141:5): [True: 543, False: 1.70M]
  ------------------
  142|    537|    case OP_NOP5                   : return "OP_NOP5";
  ------------------
  |  Branch (142:5): [True: 537, False: 1.70M]
  ------------------
  143|     84|    case OP_NOP6                   : return "OP_NOP6";
  ------------------
  |  Branch (143:5): [True: 84, False: 1.70M]
  ------------------
  144|    117|    case OP_NOP7                   : return "OP_NOP7";
  ------------------
  |  Branch (144:5): [True: 117, False: 1.70M]
  ------------------
  145|      9|    case OP_NOP8                   : return "OP_NOP8";
  ------------------
  |  Branch (145:5): [True: 9, False: 1.70M]
  ------------------
  146|      6|    case OP_NOP9                   : return "OP_NOP9";
  ------------------
  |  Branch (146:5): [True: 6, False: 1.70M]
  ------------------
  147|     63|    case OP_NOP10                  : return "OP_NOP10";
  ------------------
  |  Branch (147:5): [True: 63, False: 1.70M]
  ------------------
  148|       |
  149|       |    // Opcode added by BIP 342 (Tapscript)
  150|     78|    case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
  ------------------
  |  Branch (150:5): [True: 78, False: 1.70M]
  ------------------
  151|       |
  152|  4.19k|    case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
  ------------------
  |  Branch (152:5): [True: 4.19k, False: 1.70M]
  ------------------
  153|       |
  154|   209k|    default:
  ------------------
  |  Branch (154:5): [True: 209k, False: 1.49M]
  ------------------
  155|   209k|        return "OP_UNKNOWN";
  156|  1.70M|    }
  157|  1.70M|}
_ZNK7CScript13IsPayToAnchorEv:
  208|    144|{
  209|    144|    return (this->size() == 4 &&
  ------------------
  |  Branch (209:13): [True: 36, False: 108]
  ------------------
  210|    144|        (*this)[0] == OP_1 &&
  ------------------
  |  Branch (210:9): [True: 24, False: 12]
  ------------------
  211|    144|        (*this)[1] == 0x02 &&
  ------------------
  |  Branch (211:9): [True: 24, False: 0]
  ------------------
  212|    144|        (*this)[2] == 0x4e &&
  ------------------
  |  Branch (212:9): [True: 16, False: 8]
  ------------------
  213|    144|        (*this)[3] == 0x73);
  ------------------
  |  Branch (213:9): [True: 5, False: 11]
  ------------------
  214|    144|}
_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.04k|{
  226|       |    // Extra-fast test for pay-to-script-hash CScripts:
  227|  5.04k|    return (this->size() == 23 &&
  ------------------
  |  Branch (227:13): [True: 74, False: 4.97k]
  ------------------
  228|  5.04k|            (*this)[0] == OP_HASH160 &&
  ------------------
  |  Branch (228:13): [True: 48, False: 26]
  ------------------
  229|  5.04k|            (*this)[1] == 0x14 &&
  ------------------
  |  Branch (229:13): [True: 32, False: 16]
  ------------------
  230|  5.04k|            (*this)[22] == OP_EQUAL);
  ------------------
  |  Branch (230:13): [True: 25, False: 7]
  ------------------
  231|  5.04k|}
_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  244|  5.02k|{
  245|  5.02k|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (245:9): [True: 389, False: 4.63k]
  |  Branch (245:29): [True: 2.22k, False: 2.40k]
  ------------------
  246|  2.61k|        return false;
  247|  2.61k|    }
  248|  2.40k|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (248:9): [True: 2.37k, False: 39]
  |  Branch (248:32): [True: 558, False: 1.81k]
  |  Branch (248:53): [True: 219, False: 1.59k]
  ------------------
  249|    777|        return false;
  250|    777|    }
  251|  1.63k|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (251:9): [True: 1.59k, False: 42]
  ------------------
  252|  1.59k|        version = DecodeOP_N((opcodetype)(*this)[0]);
  253|  1.59k|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  254|  1.59k|        return true;
  255|  1.59k|    }
  256|     42|    return false;
  257|  1.63k|}
_ZNK7CScript10IsPushOnlyEN9prevectorILj28EhjiE14const_iteratorE:
  260|    340|{
  261|  55.0k|    while (pc < end())
  ------------------
  |  Branch (261:12): [True: 54.9k, False: 76]
  ------------------
  262|  54.9k|    {
  263|  54.9k|        opcodetype opcode;
  264|  54.9k|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (264:13): [True: 158, False: 54.8k]
  ------------------
  265|    158|            return false;
  266|       |        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
  267|       |        // push-type opcode, however execution of OP_RESERVED fails, so
  268|       |        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
  269|       |        // the P2SH special validation code being executed.
  270|  54.8k|        if (opcode > OP_16)
  ------------------
  |  Branch (270:13): [True: 106, False: 54.7k]
  ------------------
  271|    106|            return false;
  272|  54.8k|    }
  273|     76|    return true;
  274|    340|}
_Z11GetScriptOpRN9prevectorILj28EhjiE14const_iteratorES1_R10opcodetypePNSt3__16vectorIhNS5_9allocatorIhEEEE:
  307|  2.34M|{
  308|  2.34M|    opcodeRet = OP_INVALIDOPCODE;
  309|  2.34M|    if (pvchRet)
  ------------------
  |  Branch (309:9): [True: 2.28M, False: 54.9k]
  ------------------
  310|  2.28M|        pvchRet->clear();
  311|  2.34M|    if (pc >= end)
  ------------------
  |  Branch (311:9): [True: 0, False: 2.34M]
  ------------------
  312|      0|        return false;
  313|       |
  314|       |    // Read instruction
  315|  2.34M|    if (end - pc < 1)
  ------------------
  |  Branch (315:9): [True: 0, False: 2.34M]
  ------------------
  316|      0|        return false;
  317|  2.34M|    unsigned int opcode = *pc++;
  318|       |
  319|       |    // Immediate operand
  320|  2.34M|    if (opcode <= OP_PUSHDATA4)
  ------------------
  |  Branch (320:9): [True: 521k, False: 1.82M]
  ------------------
  321|   521k|    {
  322|   521k|        unsigned int nSize = 0;
  323|   521k|        if (opcode < OP_PUSHDATA1)
  ------------------
  |  Branch (323:13): [True: 369k, False: 151k]
  ------------------
  324|   369k|        {
  325|   369k|            nSize = opcode;
  326|   369k|        }
  327|   151k|        else if (opcode == OP_PUSHDATA1)
  ------------------
  |  Branch (327:18): [True: 146k, False: 5.64k]
  ------------------
  328|   146k|        {
  329|   146k|            if (end - pc < 1)
  ------------------
  |  Branch (329:17): [True: 17, False: 146k]
  ------------------
  330|     17|                return false;
  331|   146k|            nSize = *pc++;
  332|   146k|        }
  333|  5.64k|        else if (opcode == OP_PUSHDATA2)
  ------------------
  |  Branch (333:18): [True: 3.36k, False: 2.27k]
  ------------------
  334|  3.36k|        {
  335|  3.36k|            if (end - pc < 2)
  ------------------
  |  Branch (335:17): [True: 28, False: 3.34k]
  ------------------
  336|     28|                return false;
  337|  3.34k|            nSize = ReadLE16(&pc[0]);
  338|  3.34k|            pc += 2;
  339|  3.34k|        }
  340|  2.27k|        else if (opcode == OP_PUSHDATA4)
  ------------------
  |  Branch (340:18): [True: 2.27k, False: 0]
  ------------------
  341|  2.27k|        {
  342|  2.27k|            if (end - pc < 4)
  ------------------
  |  Branch (342:17): [True: 31, False: 2.24k]
  ------------------
  343|     31|                return false;
  344|  2.24k|            nSize = ReadLE32(&pc[0]);
  345|  2.24k|            pc += 4;
  346|  2.24k|        }
  347|   521k|        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  ------------------
  |  Branch (347:13): [True: 0, False: 521k]
  |  Branch (347:29): [True: 1.01k, False: 520k]
  ------------------
  348|  1.01k|            return false;
  349|   520k|        if (pvchRet)
  ------------------
  |  Branch (349:13): [True: 467k, False: 52.7k]
  ------------------
  350|   467k|            pvchRet->assign(pc, pc + nSize);
  351|   520k|        pc += nSize;
  352|   520k|    }
  353|       |
  354|  2.34M|    opcodeRet = static_cast<opcodetype>(opcode);
  355|  2.34M|    return true;
  356|  2.34M|}
_Z16CheckMinimalPushRKNSt3__16vectorIhNS_9allocatorIhEEEE10opcodetype:
  366|    413|bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
  367|       |    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
  368|    413|    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  369|    413|    if (data.size() == 0) {
  ------------------
  |  Branch (369:9): [True: 6, False: 407]
  ------------------
  370|       |        // Should have used OP_0.
  371|      6|        return opcode == OP_0;
  372|    407|    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  ------------------
  |  Branch (372:16): [True: 166, False: 241]
  |  Branch (372:36): [True: 160, False: 6]
  |  Branch (372:52): [True: 10, False: 150]
  ------------------
  373|       |        // Should have used OP_1 .. OP_16.
  374|     10|        return false;
  375|    397|    } else if (data.size() == 1 && data[0] == 0x81) {
  ------------------
  |  Branch (375:16): [True: 156, False: 241]
  |  Branch (375:36): [True: 5, False: 151]
  ------------------
  376|       |        // Should have used OP_1NEGATE.
  377|      5|        return false;
  378|    392|    } else if (data.size() <= 75) {
  ------------------
  |  Branch (378:16): [True: 288, False: 104]
  ------------------
  379|       |        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
  380|    288|        return opcode == data.size();
  381|    288|    } else if (data.size() <= 255) {
  ------------------
  |  Branch (381:16): [True: 38, False: 66]
  ------------------
  382|       |        // Must have used OP_PUSHDATA.
  383|     38|        return opcode == OP_PUSHDATA1;
  384|     66|    } else if (data.size() <= 65535) {
  ------------------
  |  Branch (384:16): [True: 61, False: 5]
  ------------------
  385|       |        // Must have used OP_PUSHDATA2.
  386|     61|        return opcode == OP_PUSHDATA2;
  387|     61|    }
  388|      5|    return true;
  389|    413|}

_ZN15scriptnum_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  223|    122|    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
_ZN10CScriptNumC2ERKl:
  239|  55.4k|    {
  240|  55.4k|        m_value = n;
  241|  55.4k|    }
_ZN10CScriptNumC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEEbm:
  247|   144k|    {
  248|   144k|        if (vch.size() > nMaxNumSize) {
  ------------------
  |  Branch (248:13): [True: 110, False: 144k]
  ------------------
  249|    110|            throw scriptnum_error("script number overflow");
  250|    110|        }
  251|   144k|        if (fRequireMinimal && vch.size() > 0) {
  ------------------
  |  Branch (251:13): [True: 267, False: 144k]
  |  Branch (251:32): [True: 267, False: 0]
  ------------------
  252|       |            // Check that the number is encoded with the minimum possible
  253|       |            // number of bytes.
  254|       |            //
  255|       |            // If the most-significant-byte - excluding the sign bit - is zero
  256|       |            // then we're not minimal. Note how this test also rejects the
  257|       |            // negative-zero encoding, 0x80.
  258|    267|            if ((vch.back() & 0x7f) == 0) {
  ------------------
  |  Branch (258:17): [True: 27, False: 240]
  ------------------
  259|       |                // One exception: if there's more than one byte and the most
  260|       |                // significant bit of the second-most-significant-byte is set
  261|       |                // it would conflict with the sign bit. An example of this case
  262|       |                // is +-255, which encode to 0xff00 and 0xff80 respectively.
  263|       |                // (big-endian).
  264|     27|                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
  ------------------
  |  Branch (264:21): [True: 6, False: 21]
  |  Branch (264:40): [True: 6, False: 15]
  ------------------
  265|     12|                    throw scriptnum_error("non-minimally encoded script number");
  266|     12|                }
  267|     27|            }
  268|    267|        }
  269|   144k|        m_value = set_vch(vch);
  270|   144k|    }
_ZNK10CScriptNum6getintEv:
  334|   144k|    {
  335|   144k|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (335:13): [True: 0, False: 144k]
  ------------------
  336|      0|            return std::numeric_limits<int>::max();
  337|   144k|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (337:18): [True: 0, False: 144k]
  ------------------
  338|      0|            return std::numeric_limits<int>::min();
  339|   144k|        return m_value;
  340|   144k|    }
_ZNK10CScriptNum6getvchEv:
  345|  55.4k|    {
  346|  55.4k|        return serialize(m_value);
  347|  55.4k|    }
_ZN10CScriptNum9serializeERKl:
  350|   161k|    {
  351|   161k|        if(value == 0)
  ------------------
  |  Branch (351:12): [True: 212, False: 161k]
  ------------------
  352|    212|            return std::vector<unsigned char>();
  353|       |
  354|   161k|        std::vector<unsigned char> result;
  355|   161k|        const bool neg = value < 0;
  356|   161k|        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
  ------------------
  |  Branch (356:29): [True: 151k, False: 10.6k]
  ------------------
  357|       |
  358|  1.29M|        while(absvalue)
  ------------------
  |  Branch (358:15): [True: 1.13M, False: 161k]
  ------------------
  359|  1.13M|        {
  360|  1.13M|            result.push_back(absvalue & 0xff);
  361|  1.13M|            absvalue >>= 8;
  362|  1.13M|        }
  363|       |
  364|       |//    - If the most significant byte is >= 0x80 and the value is positive, push a
  365|       |//    new zero-byte to make the significant byte < 0x80 again.
  366|       |
  367|       |//    - If the most significant byte is >= 0x80 and the value is negative, push a
  368|       |//    new 0x80 byte that will be popped off when converting to an integral.
  369|       |
  370|       |//    - If the most significant byte is < 0x80 and the value is negative, add
  371|       |//    0x80 to it, since it will be subtracted and interpreted as a negative when
  372|       |//    converting to an integral.
  373|       |
  374|   161k|        if (result.back() & 0x80)
  ------------------
  |  Branch (374:13): [True: 126k, False: 35.6k]
  ------------------
  375|   126k|            result.push_back(neg ? 0x80 : 0);
  ------------------
  |  Branch (375:30): [True: 125k, False: 338]
  ------------------
  376|  35.6k|        else if (neg)
  ------------------
  |  Branch (376:18): [True: 25.4k, False: 10.2k]
  ------------------
  377|  25.4k|            result.back() |= 0x80;
  378|       |
  379|   161k|        return result;
  380|   161k|    }
_ZN10CScriptNum7set_vchERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  384|   144k|    {
  385|   144k|      if (vch.empty())
  ------------------
  |  Branch (385:11): [True: 44.9k, False: 99.8k]
  ------------------
  386|  44.9k|          return 0;
  387|       |
  388|  99.8k|      int64_t result = 0;
  389|   208k|      for (size_t i = 0; i != vch.size(); ++i)
  ------------------
  |  Branch (389:26): [True: 108k, False: 99.8k]
  ------------------
  390|   108k|          result |= static_cast<int64_t>(vch[i]) << 8*i;
  391|       |
  392|       |      // If the input vector's most significant byte is 0x80, remove it from
  393|       |      // the result's msb and return a negative.
  394|  99.8k|      if (vch.back() & 0x80)
  ------------------
  |  Branch (394:11): [True: 1.69k, False: 98.1k]
  ------------------
  395|  1.69k|          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
  396|       |
  397|  98.1k|      return result;
  398|  99.8k|    }
_ZN7CScript14AppendDataSizeEj:
  418|  13.2M|    {
  419|  13.2M|        if (size < OP_PUSHDATA1) {
  ------------------
  |  Branch (419:13): [True: 822k, False: 12.3M]
  ------------------
  420|   822k|            insert(end(), static_cast<value_type>(size));
  421|  12.3M|        } else if (size <= 0xff) {
  ------------------
  |  Branch (421:20): [True: 12.3M, False: 0]
  ------------------
  422|  12.3M|            insert(end(), OP_PUSHDATA1);
  423|  12.3M|            insert(end(), static_cast<value_type>(size));
  424|  12.3M|        } else if (size <= 0xffff) {
  ------------------
  |  Branch (424:20): [True: 0, False: 0]
  ------------------
  425|      0|            insert(end(), OP_PUSHDATA2);
  426|      0|            value_type data[2];
  427|      0|            WriteLE16(data, size);
  428|      0|            insert(end(), std::cbegin(data), std::cend(data));
  429|      0|        } else {
  430|      0|            insert(end(), OP_PUSHDATA4);
  431|      0|            value_type data[4];
  432|      0|            WriteLE32(data, size);
  433|      0|            insert(end(), std::cbegin(data), std::cend(data));
  434|      0|        }
  435|  13.2M|    }
_ZN7CScript10AppendDataENSt3__14spanIKhLm18446744073709551615EEE:
  438|  13.2M|    {
  439|  13.2M|        insert(end(), data.begin(), data.end());
  440|  13.2M|    }
_ZN7CScript10push_int64El:
  444|   176k|    {
  445|   176k|        if (n == -1 || (n >= 1 && n <= 16))
  ------------------
  |  Branch (445:13): [True: 350, False: 176k]
  |  Branch (445:25): [True: 19.0k, False: 157k]
  |  Branch (445:35): [True: 13.0k, False: 6.01k]
  ------------------
  446|  13.3k|        {
  447|  13.3k|            push_back(n + (OP_1 - 1));
  448|  13.3k|        }
  449|   163k|        else if (n == 0)
  ------------------
  |  Branch (449:18): [True: 56.9k, False: 106k]
  ------------------
  450|  56.9k|        {
  451|  56.9k|            push_back(OP_0);
  452|  56.9k|        }
  453|   106k|        else
  454|   106k|        {
  455|   106k|            *this << CScriptNum::serialize(n);
  456|   106k|        }
  457|   176k|        return *this;
  458|   176k|    }
_ZN7CScriptlsEl:
  477|   176k|    CScript& operator<<(int64_t b) LIFETIMEBOUND { return push_int64(b); }
_ZN7CScriptlsE10opcodetype:
  480|   226k|    {
  481|   226k|        if (opcode < 0 || opcode > 0xff)
  ------------------
  |  Branch (481:13): [True: 0, False: 226k]
  |  Branch (481:27): [True: 0, False: 226k]
  ------------------
  482|      0|            throw std::runtime_error("CScript::operator<<(): invalid opcode");
  483|   226k|        insert(end(), (unsigned char)opcode);
  484|   226k|        return *this;
  485|   226k|    }
_ZN7CScriptlsERK10CScriptNum:
  488|  55.4k|    {
  489|  55.4k|        *this << b.getvch();
  490|  55.4k|        return *this;
  491|  55.4k|    }
_ZN7CScriptlsENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  494|  13.2M|    {
  495|  13.2M|        AppendDataSize(b.size());
  496|  13.2M|        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
  497|  13.2M|        return *this;
  498|  13.2M|    }
_ZN7CScriptlsENSt3__14spanIKhLm18446744073709551615EEE:
  502|  13.2M|    {
  503|  13.2M|        return *this << std::as_bytes(b);
  504|  13.2M|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetypeRNSt3__16vectorIhNS6_9allocatorIhEEEE:
  507|  2.28M|    {
  508|  2.28M|        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
  509|  2.28M|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetype:
  512|  54.9k|    {
  513|  54.9k|        return GetScriptOp(pc, end(), opcodeRet, nullptr);
  514|  54.9k|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  518|  2.24k|    {
  519|  2.24k|        if (opcode == OP_0)
  ------------------
  |  Branch (519:13): [True: 27, False: 2.21k]
  ------------------
  520|     27|            return 0;
  521|  2.21k|        assert(opcode >= OP_1 && opcode <= OP_16);
  522|  2.21k|        return (int)opcode - (int)(OP_1 - 1);
  523|  2.21k|    }
_ZN7CScript10EncodeOP_NEi:
  525|     27|    {
  526|     27|        assert(n >= 0 && n <= 16);
  527|     27|        if (n == 0)
  ------------------
  |  Branch (527:13): [True: 0, False: 27]
  ------------------
  528|      0|            return OP_0;
  529|     27|        return (opcodetype)(OP_1+n-1);
  530|     27|    }
_ZNK7CScript13IsUnspendableEv:
  572|  28.5k|    {
  573|  28.5k|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (573:17): [True: 28.5k, False: 0]
  |  Branch (573:31): [True: 4.35k, False: 24.2k]
  |  Branch (573:57): [True: 16.5k, False: 7.64k]
  ------------------
  574|  28.5k|    }
_ZN9CScriptIDC2ERK7uint160:
  606|      7|    explicit CScriptID(const uint160& in) : BaseHash(in) {}
_ZN7CScriptC2Ev:
  461|  6.60k|    CScript() = default;
_Z12ToByteVectorI6PKHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|      2|{
   69|      2|    return std::vector<unsigned char>(in.begin(), in.end());
   70|      2|}
_Z12ToByteVectorI10ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|      6|{
   69|      6|    return std::vector<unsigned char>(in.begin(), in.end());
   70|      6|}
_Z12ToByteVectorI19WitnessV0ScriptHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|      1|{
   69|      1|    return std::vector<unsigned char>(in.begin(), in.end());
   70|      1|}
_Z12ToByteVectorI16WitnessV0KeyHashENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|      1|{
   69|      1|    return std::vector<unsigned char>(in.begin(), in.end());
   70|      1|}
_Z12ToByteVectorI16WitnessV1TaprootENSt3__16vectorIhNS1_9allocatorIhEEEERKT_:
   68|    139|{
   69|    139|    return std::vector<unsigned char>(in.begin(), in.end());
   70|    139|}

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

_Z16GetTxnOutputType9TxoutType:
   19|  2.83k|{
   20|  2.83k|    switch (t) {
  ------------------
  |  Branch (20:13): [True: 0, False: 2.83k]
  ------------------
   21|  2.19k|    case TxoutType::NONSTANDARD: return "nonstandard";
  ------------------
  |  Branch (21:5): [True: 2.19k, False: 634]
  ------------------
   22|     10|    case TxoutType::PUBKEY: return "pubkey";
  ------------------
  |  Branch (22:5): [True: 10, False: 2.82k]
  ------------------
   23|      3|    case TxoutType::PUBKEYHASH: return "pubkeyhash";
  ------------------
  |  Branch (23:5): [True: 3, False: 2.83k]
  ------------------
   24|      7|    case TxoutType::SCRIPTHASH: return "scripthash";
  ------------------
  |  Branch (24:5): [True: 7, False: 2.82k]
  ------------------
   25|     85|    case TxoutType::MULTISIG: return "multisig";
  ------------------
  |  Branch (25:5): [True: 85, False: 2.74k]
  ------------------
   26|     46|    case TxoutType::NULL_DATA: return "nulldata";
  ------------------
  |  Branch (26:5): [True: 46, False: 2.78k]
  ------------------
   27|      2|    case TxoutType::ANCHOR: return "anchor";
  ------------------
  |  Branch (27:5): [True: 2, False: 2.83k]
  ------------------
   28|      2|    case TxoutType::WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
  ------------------
  |  Branch (28:5): [True: 2, False: 2.83k]
  ------------------
   29|      2|    case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
  ------------------
  |  Branch (29:5): [True: 2, False: 2.83k]
  ------------------
   30|    433|    case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
  ------------------
  |  Branch (30:5): [True: 433, False: 2.40k]
  ------------------
   31|     44|    case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
  ------------------
  |  Branch (31:5): [True: 44, False: 2.78k]
  ------------------
   32|  2.83k|    } // no default case, so the compiler can warn about missing cases
   33|      0|    assert(false);
   34|      0|}
_Z6SolverRK7CScriptRNSt3__16vectorINS3_IhNS2_9allocatorIhEEEENS4_IS6_EEEE:
  142|  5.04k|{
  143|  5.04k|    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.04k|    if (scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (147:9): [True: 25, False: 5.02k]
  ------------------
  148|     25|    {
  149|     25|        std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
  150|     25|        vSolutionsRet.push_back(hashBytes);
  151|     25|        return TxoutType::SCRIPTHASH;
  152|     25|    }
  153|       |
  154|  5.02k|    int witnessversion;
  155|  5.02k|    std::vector<unsigned char> witnessprogram;
  156|  5.02k|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (156:9): [True: 1.59k, False: 3.43k]
  ------------------
  157|  1.59k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
  ------------------
  |  Branch (157:13): [True: 27, False: 1.56k]
  |  Branch (157:36): [True: 5, False: 22]
  ------------------
  158|      5|            vSolutionsRet.push_back(std::move(witnessprogram));
  159|      5|            return TxoutType::WITNESS_V0_KEYHASH;
  160|      5|        }
  161|  1.58k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (161:13): [True: 22, False: 1.56k]
  |  Branch (161:36): [True: 5, False: 17]
  ------------------
  162|      5|            vSolutionsRet.push_back(std::move(witnessprogram));
  163|      5|            return TxoutType::WITNESS_V0_SCRIPTHASH;
  164|      5|        }
  165|  1.58k|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
  ------------------
  |  Branch (165:13): [True: 1.49k, False: 82]
  |  Branch (165:36): [True: 1.43k, False: 62]
  ------------------
  166|  1.43k|            vSolutionsRet.push_back(std::move(witnessprogram));
  167|  1.43k|            return TxoutType::WITNESS_V1_TAPROOT;
  168|  1.43k|        }
  169|    144|        if (scriptPubKey.IsPayToAnchor()) {
  ------------------
  |  Branch (169:13): [True: 5, False: 139]
  ------------------
  170|      5|            return TxoutType::ANCHOR;
  171|      5|        }
  172|    139|        if (witnessversion != 0) {
  ------------------
  |  Branch (172:13): [True: 122, False: 17]
  ------------------
  173|    122|            vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
  174|    122|            vSolutionsRet.push_back(std::move(witnessprogram));
  175|    122|            return TxoutType::WITNESS_UNKNOWN;
  176|    122|        }
  177|     17|        return TxoutType::NONSTANDARD;
  178|    139|    }
  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|  3.43k|    if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
  ------------------
  |  Branch (185:9): [True: 3.24k, False: 192]
  |  Branch (185:9): [True: 76, False: 3.35k]
  |  Branch (185:37): [True: 340, False: 2.90k]
  |  Branch (185:69): [True: 76, False: 264]
  ------------------
  186|     76|        return TxoutType::NULL_DATA;
  187|     76|    }
  188|       |
  189|  3.35k|    std::vector<unsigned char> data;
  190|  3.35k|    if (MatchPayToPubkey(scriptPubKey, data)) {
  ------------------
  |  Branch (190:9): [True: 22, False: 3.33k]
  ------------------
  191|     22|        vSolutionsRet.push_back(std::move(data));
  192|     22|        return TxoutType::PUBKEY;
  193|     22|    }
  194|       |
  195|  3.33k|    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
  ------------------
  |  Branch (195:9): [True: 9, False: 3.32k]
  ------------------
  196|      9|        vSolutionsRet.push_back(std::move(data));
  197|      9|        return TxoutType::PUBKEYHASH;
  198|      9|    }
  199|       |
  200|  3.32k|    int required;
  201|  3.32k|    std::vector<std::vector<unsigned char>> keys;
  202|  3.32k|    if (MatchMultisig(scriptPubKey, required, keys)) {
  ------------------
  |  Branch (202:9): [True: 259, False: 3.06k]
  ------------------
  203|    259|        vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..20
  204|    259|        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
  205|    259|        vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..20
  206|    259|        return TxoutType::MULTISIG;
  207|    259|    }
  208|       |
  209|  3.06k|    vSolutionsRet.clear();
  210|  3.06k|    return TxoutType::NONSTANDARD;
  211|  3.32k|}
solver.cpp:_ZL15GetScriptNumber10opcodetypeNSt3__16vectorIhNS0_9allocatorIhEEEEii:
   67|  1.12k|{
   68|  1.12k|    int count;
   69|  1.12k|    if (IsSmallInteger(opcode)) {
  ------------------
  |  Branch (69:9): [True: 651, False: 472]
  ------------------
   70|    651|        count = CScript::DecodeOP_N(opcode);
   71|    651|    } else if (IsPushdataOp(opcode)) {
  ------------------
  |  Branch (71:16): [True: 413, False: 59]
  ------------------
   72|    413|        if (!CheckMinimalPush(data, opcode)) return {};
  ------------------
  |  Branch (72:13): [True: 36, False: 377]
  ------------------
   73|    377|        try {
   74|    377|            count = CScriptNum(data, /* fRequireMinimal = */ true).getint();
   75|    377|        } catch (const scriptnum_error&) {
   76|    122|            return {};
   77|    122|        }
   78|    377|    } else {
   79|     59|        return {};
   80|     59|    }
   81|    906|    if (count < min || count > max) return {};
  ------------------
  |  Branch (81:9): [True: 61, False: 845]
  |  Branch (81:24): [True: 99, False: 746]
  ------------------
   82|    746|    return count;
   83|    906|}
solver.cpp:_ZL14IsSmallInteger10opcodetype:
   60|  1.12k|{
   61|  1.12k|    return opcode >= OP_1 && opcode <= OP_16;
  ------------------
  |  Branch (61:12): [True: 695, False: 428]
  |  Branch (61:30): [True: 651, False: 44]
  ------------------
   62|  1.12k|}
solver.cpp:_ZL16MatchPayToPubkeyRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   37|  3.35k|{
   38|  3.35k|    if (script.size() == CPubKey::SIZE + 2 && script[0] == CPubKey::SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (38:9): [True: 72, False: 3.28k]
  |  Branch (38:47): [True: 52, False: 20]
  |  Branch (38:77): [True: 38, False: 14]
  ------------------
   39|     38|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::SIZE + 1);
   40|     38|        return CPubKey::ValidSize(pubkey);
   41|     38|    }
   42|  3.31k|    if (script.size() == CPubKey::COMPRESSED_SIZE + 2 && script[0] == CPubKey::COMPRESSED_SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (42:9): [True: 80, False: 3.23k]
  |  Branch (42:58): [True: 58, False: 22]
  |  Branch (42:99): [True: 37, False: 21]
  ------------------
   43|     37|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_SIZE + 1);
   44|     37|        return CPubKey::ValidSize(pubkey);
   45|     37|    }
   46|  3.28k|    return false;
   47|  3.31k|}
solver.cpp:_ZL20MatchPayToPubkeyHashRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   50|  3.33k|{
   51|  3.33k|    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: 71, False: 3.26k]
  |  Branch (51:32): [True: 53, False: 18]
  |  Branch (51:55): [True: 39, False: 14]
  |  Branch (51:82): [True: 27, False: 12]
  |  Branch (51:101): [True: 17, False: 10]
  |  Branch (51:133): [True: 9, False: 8]
  ------------------
   52|      9|        pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
   53|      9|        return true;
   54|      9|    }
   55|  3.32k|    return false;
   56|  3.33k|}
solver.cpp:_ZL13MatchMultisigRK7CScriptRiRNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEE:
   86|  3.32k|{
   87|  3.32k|    opcodetype opcode;
   88|  3.32k|    valtype data;
   89|       |
   90|  3.32k|    CScript::const_iterator it = script.begin();
   91|  3.32k|    if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
  ------------------
  |  Branch (91:9): [True: 192, False: 3.13k]
  |  Branch (91:30): [True: 2.42k, False: 705]
  ------------------
   92|       |
   93|    705|    if (!script.GetOp(it, opcode, data)) return false;
  ------------------
  |  Branch (93:9): [True: 12, False: 693]
  ------------------
   94|    693|    auto req_sigs = GetScriptNumber(opcode, data, 1, MAX_PUBKEYS_PER_MULTISIG);
   95|    693|    if (!req_sigs) return false;
  ------------------
  |  Branch (95:9): [True: 263, False: 430]
  ------------------
   96|    430|    required_sigs = *req_sigs;
   97|  3.22k|    while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
  ------------------
  |  Branch (97:12): [True: 3.21k, False: 11]
  |  Branch (97:46): [True: 2.79k, False: 419]
  ------------------
   98|  2.79k|        pubkeys.emplace_back(std::move(data));
   99|  2.79k|    }
  100|    430|    auto num_keys = GetScriptNumber(opcode, data, required_sigs, MAX_PUBKEYS_PER_MULTISIG);
  101|    430|    if (!num_keys) return false;
  ------------------
  |  Branch (101:9): [True: 114, False: 316]
  ------------------
  102|    316|    if (pubkeys.size() != static_cast<unsigned long>(*num_keys)) return false;
  ------------------
  |  Branch (102:9): [True: 42, False: 274]
  ------------------
  103|       |
  104|    274|    return (it + 1 == script.end());
  105|    316|}

_Z12IsPushdataOp10opcodetype:
   41|    472|{
   42|    472|    return opcode > OP_FALSE && opcode <= OP_PUSHDATA4;
  ------------------
  |  Branch (42:12): [True: 459, False: 13]
  |  Branch (42:33): [True: 413, False: 46]
  ------------------
   43|    472|}

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

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

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

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

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

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

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

_Z9UCharCastPKh:
  285|  1.15k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
_ZNK4SpanIKcE5beginEv:
  175|    850|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKcE3endEv:
  176|    850|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIKhE4sizeEv:
  187|   542k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|   938k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|   540k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|  1.15k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|  1.15k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  2.31k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE5firstEm:
  206|  1.14k|    {
  207|  1.14k|        ASSERT_IF_DEBUG(size() >= count);
  208|  1.14k|        return Span<C>(m_data, count);
  209|  1.14k|    }
_ZNK4SpanIKhE7subspanEm:
  196|    400|    {
  197|    400|        ASSERT_IF_DEBUG(size() >= offset);
  198|    400|        return Span<C>(m_data + offset, m_size - offset);
  199|    400|    }
_Z13UCharSpanCastIKhE4SpanINSt3__114remove_pointerIDTcl9UCharCastcldtfp_4dataEEEE4typeEES1_IT_E:
  293|  1.15k|template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
_Z13MakeUCharSpanIRK4SpanIKhEEDTcl13UCharSpanCasttlS0_clsr3stdE7forwardIT_Efp_EEEEOS5_:
  296|  1.14k|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|   372k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|   364k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  2.69k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKcEC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanISA_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISC_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISC_EE4sizeEEmEE5valueEDnE4typeE:
  172|    850|        : m_data(other.data()), m_size(other.size()){}
_Z13MakeUCharSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEEDTcl13UCharSpanCasttl4Spanclsr3stdE7forwardIT_Efp_EEEEOS8_:
  296|     16|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|     16|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I7uint160EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  1.14k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi65EEERAT__S0_:
  151|  1.14k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2I7CPubKeyEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|    645|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7CScriptEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|    938|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKhEixEm:
  191|    416|    {
  192|    416|        ASSERT_IF_DEBUG(size() > pos);
  193|    416|        return m_data[pos];
  194|    416|    }
_ZN4SpanIKhEC2ILi33EEERAT__S0_:
  151|    293|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}

_ZN18FuzzedDataProviderC2EPKhm:
   37|  3.07k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|   157k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   157k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   157k|                                std::numeric_limits<T>::max());
  198|   157k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|   232k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   232k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   232k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   232k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 232k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   232k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   232k|  uint64_t result = 0;
  215|   232k|  size_t offset = 0;
  216|       |
  217|  1.56M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.40M, False: 156k]
  |  Branch (217:43): [True: 1.33M, False: 74.8k]
  ------------------
  218|  1.56M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.32M, False: 693]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  1.32M|    --remaining_bytes_;
  226|  1.32M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.32M|    offset += CHAR_BIT;
  228|  1.32M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   232k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 75.2k, False: 157k]
  ------------------
  232|  75.2k|    result = result % (range + 1);
  233|       |
  234|   232k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   232k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  14.0M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  14.0M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  14.0M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  14.0M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 14.0M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  14.0M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  14.0M|  uint64_t result = 0;
  215|  14.0M|  size_t offset = 0;
  216|       |
  217|  28.0M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 28.0M, False: 0]
  |  Branch (217:43): [True: 14.0M, False: 14.0M]
  ------------------
  218|  28.0M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 14.0M, False: 4.04k]
  ------------------
  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.0M|    --remaining_bytes_;
  226|  14.0M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  14.0M|    offset += CHAR_BIT;
  228|  14.0M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  14.0M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 14.0M, False: 0]
  ------------------
  232|  14.0M|    result = result % (range + 1);
  233|       |
  234|  14.0M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  14.0M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|  37.6k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  37.6k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  37.6k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  37.6k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 37.6k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  37.6k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  37.6k|  uint64_t result = 0;
  215|  37.6k|  size_t offset = 0;
  216|       |
  217|  75.1k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 75.1k, False: 0]
  |  Branch (217:43): [True: 37.6k, False: 37.5k]
  ------------------
  218|  75.1k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 37.5k, False: 99]
  ------------------
  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|  37.5k|    --remaining_bytes_;
  226|  37.5k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  37.5k|    offset += CHAR_BIT;
  228|  37.5k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  37.6k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 37.6k, False: 0]
  ------------------
  232|  37.6k|    result = result % (range + 1);
  233|       |
  234|  37.6k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  37.6k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  13.6M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  13.6M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  13.6M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  13.6M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 13.6M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  13.6M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  13.6M|  uint64_t result = 0;
  215|  13.6M|  size_t offset = 0;
  216|       |
  217|  27.2M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 27.2M, False: 0]
  |  Branch (217:43): [True: 13.6M, False: 13.6M]
  ------------------
  218|  27.2M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 13.6M, False: 196]
  ------------------
  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.6M|    --remaining_bytes_;
  226|  13.6M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  13.6M|    offset += CHAR_BIT;
  228|  13.6M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  13.6M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 13.6M, False: 0]
  ------------------
  232|  13.6M|    result = result % (range + 1);
  233|       |
  234|  13.6M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  13.6M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  14.2M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  14.2M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  14.2M|                                std::numeric_limits<T>::max());
  198|  14.2M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  14.2M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  14.2M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  14.2M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  14.2M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 14.2M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  14.2M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  14.2M|  uint64_t result = 0;
  215|  14.2M|  size_t offset = 0;
  216|       |
  217|  28.4M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 14.2M, False: 14.2M]
  |  Branch (217:43): [True: 14.2M, False: 0]
  ------------------
  218|  28.4M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 14.2M, False: 14.9k]
  ------------------
  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.2M|    --remaining_bytes_;
  226|  14.2M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  14.2M|    offset += CHAR_BIT;
  228|  14.2M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  14.2M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 14.2M, False: 0]
  ------------------
  232|  14.2M|    result = result % (range + 1);
  233|       |
  234|  14.2M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  14.2M|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|  14.7k|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|  14.7k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|  14.7k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  1.48M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 1.47M, False: 11.1k]
  |  Branch (164:40): [True: 1.47M, False: 111]
  ------------------
  165|  1.47M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  1.47M|    Advance(1);
  167|  1.47M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 3.67k, False: 1.47M]
  |  Branch (167:25): [True: 3.67k, False: 2]
  ------------------
  168|  3.67k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|  3.67k|      Advance(1);
  170|  3.67k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 3.42k, False: 247]
  ------------------
  171|  3.42k|        break;
  172|  3.67k|    }
  173|  1.47M|    result += next;
  174|  1.47M|  }
  175|       |
  176|  14.7k|  result.shrink_to_fit();
  177|  14.7k|  return result;
  178|  14.7k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  14.2M|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  14.2M|  return 1 & ConsumeIntegral<uint8_t>();
  291|  14.2M|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  1.48M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  1.48M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 1.48M]
  ------------------
  346|      0|    abort();
  347|       |
  348|  1.48M|  data_ptr_ += num_bytes;
  349|  1.48M|  remaining_bytes_ -= num_bytes;
  350|  1.48M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  379|  1.48M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  380|  1.48M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  381|  1.48M|  static_assert(!std::numeric_limits<TU>::is_signed,
  382|  1.48M|                "Source type must be unsigned.");
  383|       |
  384|       |  // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
  385|  1.48M|  if (std::numeric_limits<TS>::is_modulo)
  ------------------
  |  Branch (385:7): [Folded - Ignored]
  ------------------
  386|      0|    return static_cast<TS>(value);
  387|       |
  388|       |  // Avoid using implementation-defined unsigned to signed conversions.
  389|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  390|  1.48M|  if (value <= std::numeric_limits<TS>::max()) {
  ------------------
  |  Branch (390:7): [True: 909k, False: 571k]
  ------------------
  391|   909k|    return static_cast<TS>(value);
  392|   909k|  } else {
  393|   571k|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  394|   571k|    return TS_min + static_cast<TS>(value - TS_min);
  395|   571k|  }
  396|  1.48M|}
_ZN18FuzzedDataProvider16PickValueInArrayIiEET_St16initializer_listIKS1_E:
  316|   198k|T FuzzedDataProvider::PickValueInArray(std::initializer_list<const T> list) {
  317|       |  // TODO(Dor1s): switch to static_assert once C++14 is allowed.
  318|   198k|  if (!list.size())
  ------------------
  |  Branch (318:7): [True: 0, False: 198k]
  ------------------
  319|      0|    abort();
  320|       |
  321|   198k|  return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
  322|   198k|}

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

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

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

_Z17ConsumeOpcodeTypeR18FuzzedDataProvider:
  141|   226k|{
  142|   226k|    return static_cast<opcodetype>(fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, MAX_OPCODE));
  143|   226k|}
_Z16ConsumeScriptNumR18FuzzedDataProvider:
  158|  55.4k|{
  159|  55.4k|    return CScriptNum{fuzzed_data_provider.ConsumeIntegral<int64_t>()};
  160|  55.4k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   58|  14.7k|{
   59|  14.7k|    static_assert(sizeof(B) == 1);
   60|  14.7k|    const std::string s = max_length ?
  ------------------
  |  Branch (60:27): [True: 14.7k, False: 0]
  ------------------
   61|  14.7k|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   62|  14.7k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   63|  14.7k|    std::vector<B> ret(s.size());
   64|  14.7k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   65|  14.7k|    return ret;
   66|  14.7k|}
util.cpp:_Z9CallOneOfIJZ13ConsumeScriptR18FuzzedDataProviderbE3$_0Z13ConsumeScriptS1_bE3$_1Z13ConsumeScriptS1_bE3$_2Z13ConsumeScriptS1_bE3$_3Z13ConsumeScriptS1_bE3$_4Z13ConsumeScriptS1_bE3$_5Z13ConsumeScriptS1_bE3$_6EEmS1_DpT_:
   36|  13.8M|{
   37|  13.8M|    constexpr size_t call_size{sizeof...(callables)};
   38|  13.8M|    static_assert(call_size >= 1);
   39|  13.8M|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|  13.8M|    size_t i{0};
   42|  96.7M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 546k, False: 13.2M]
  |  Branch (42:7): [True: 12.8M, False: 981k]
  |  Branch (42:7): [True: 37.6k, False: 13.7M]
  |  Branch (42:7): [True: 14.7k, False: 13.8M]
  |  Branch (42:7): [True: 101k, False: 13.7M]
  |  Branch (42:7): [True: 226k, False: 13.6M]
  |  Branch (42:7): [True: 55.4k, False: 13.7M]
  ------------------
   43|  13.8M|    return call_size;
   44|  13.8M|}

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

_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|   525k|        {
  542|   525k|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|   525k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  543|   525k|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|   525k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  544|   525k|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|   525k|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|   392k|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|   525k|{
  594|   525k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 525k, False: 0]
  |  Branch (594:22): [True: 0, False: 525k]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|   525k|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 525k]
  ------------------
  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|   525k|    else {
  618|   525k|        return false;
  619|   525k|    }
  620|      0|    return true;
  621|   525k|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|   918k|{
  630|   918k|    const char* c = fmt;
  631|  2.04M|    for (;; ++c) {
  632|  2.04M|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 392k, False: 1.65M]
  ------------------
  633|   392k|            out.write(fmt, c - fmt);
  634|   392k|            return c;
  635|   392k|        }
  636|  1.65M|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 525k, False: 1.12M]
  ------------------
  637|   525k|            out.write(fmt, c - fmt);
  638|   525k|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 525k, False: 0]
  ------------------
  639|   525k|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|  2.04M|    }
  644|   918k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|   525k|{
  686|   525k|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|   525k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  687|       |    // Reset stream state to defaults.
  688|   525k|    out.width(0);
  689|   525k|    out.precision(6);
  690|   525k|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|   525k|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|   525k|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|   525k|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|   525k|    bool precisionSet = false;
  696|   525k|    bool widthSet = false;
  697|   525k|    int widthExtra = 0;
  698|   525k|    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|   525k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 525k, False: 0]
  |  Branch (702:22): [True: 0, False: 525k]
  ------------------
  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|   525k|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 525k]
  ------------------
  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|   525k|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 525k, False: 0]
  ------------------
  736|       |        // Parse flags
  737|   525k|        for (;; ++c) {
  738|   525k|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 525k]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  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: 525k]
  ------------------
  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: 525k]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|   525k|                default:
  ------------------
  |  Branch (765:17): [True: 525k, False: 0]
  ------------------
  766|   525k|                    break;
  767|   525k|            }
  768|   525k|            break;
  769|   525k|        }
  770|       |        // Parse width
  771|   525k|        int width = 0;
  772|   525k|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|   525k|                                         args, argIndex, numArgs);
  774|   525k|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 525k]
  ------------------
  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|   525k|    }
  784|       |    // 3) Parse precision
  785|   525k|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 525k]
  ------------------
  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|   525k|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 525k]
  |  Branch (797:25): [True: 0, False: 525k]
  |  Branch (797:38): [True: 0, False: 525k]
  ------------------
  798|   525k|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 525k]
  |  Branch (798:25): [True: 0, False: 525k]
  |  Branch (798:38): [True: 0, False: 525k]
  ------------------
  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|   525k|    bool intConversion = false;
  805|   525k|    switch (*c) {
  806|   152k|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 0, False: 525k]
  |  Branch (806:19): [True: 144k, False: 380k]
  |  Branch (806:29): [True: 8.05k, False: 517k]
  ------------------
  807|   152k|            out.setf(std::ios::dec, std::ios::basefield);
  808|   152k|            intConversion = true;
  809|   152k|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|   372k|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 372k, False: 152k]
  |  Branch (817:19): [True: 0, False: 525k]
  ------------------
  818|   372k|            out.setf(std::ios::hex, std::ios::basefield);
  819|   372k|            intConversion = true;
  820|   372k|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 525k]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 525k]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 525k]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|      0|        case 's':
  ------------------
  |  Branch (857:9): [True: 0, False: 525k]
  ------------------
  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: 525k]
  ------------------
  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: 525k]
  ------------------
  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: 525k]
  ------------------
  872|      0|            break;
  873|   525k|    }
  874|   525k|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 525k, False: 0]
  |  Branch (874:26): [True: 0, False: 525k]
  |  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|   525k|    return c+1;
  884|   525k|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|   392k|{
  892|       |    // Saved stream state
  893|   392k|    std::streamsize origWidth = out.width();
  894|   392k|    std::streamsize origPrecision = out.precision();
  895|   392k|    std::ios::fmtflags origFlags = out.flags();
  896|   392k|    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|   392k|    bool positionalMode = false;
  901|   392k|    int argIndex = 0;
  902|   918k|    while (true) {
  ------------------
  |  Branch (902:12): [Folded - Ignored]
  ------------------
  903|   918k|        fmt = printFormatStringLiteral(out, fmt);
  904|   918k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 392k, False: 525k]
  ------------------
  905|   392k|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 392k, False: 0]
  |  Branch (905:36): [True: 0, False: 392k]
  ------------------
  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|   392k|            break;
  909|   392k|        }
  910|   525k|        bool spacePadPositive = false;
  911|   525k|        int ntrunc = -1;
  912|   525k|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|   525k|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|   525k|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 525k]
  ------------------
  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|   525k|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|   525k|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 525k, False: 0]
  ------------------
  923|   525k|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|   525k|        }
  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|   525k|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 525k, False: 0]
  ------------------
  942|   525k|            ++argIndex;
  943|   525k|        fmt = fmtEnd;
  944|   525k|    }
  945|       |
  946|       |    // Restore stream state
  947|   392k|    out.width(origWidth);
  948|   392k|    out.precision(origPrecision);
  949|   392k|    out.flags(origFlags);
  950|   392k|    out.fill(origFill);
  951|   392k|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|   392k|{
 1071|   392k|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|   392k|}
_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   152k|{
 1089|   152k|    std::ostringstream oss;
 1090|   152k|    format(oss, fmt, args...);
 1091|   152k|    return oss.str();
 1092|   152k|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   152k|{
 1081|   152k|    vformat(out, fmt, makeFormatList(args...));
 1082|   152k|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|   260k|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   152k|{
 1045|   152k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   152k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|   152k|            : FormatList(&m_formatterStore[0], N),
  991|   152k|            m_formatterStore { FormatArg(args)... }
  992|   152k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|   152k|            : m_value(static_cast<const void*>(&value)),
  535|   152k|            m_formatImpl(&formatImpl<T>),
  536|   152k|            m_toIntImpl(&toIntImpl<T>)
  537|   152k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|   152k|        {
  559|   152k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   152k|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|   152k|{
  352|   152k|#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|   152k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   152k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   152k|#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|   152k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   152k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   152k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 152k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   152k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|   152k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 152k]
  ------------------
  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|   152k|    else
  378|   152k|        out << value;
  379|   152k|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|   132k|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   132k|{
 1089|   132k|    std::ostringstream oss;
 1090|   132k|    format(oss, fmt, args...);
 1091|   132k|    return oss.str();
 1092|   132k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   132k|{
 1081|   132k|    vformat(out, fmt, makeFormatList(args...));
 1082|   132k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   132k|{
 1045|   132k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   132k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_EEEDpRKT_:
  990|   132k|            : FormatList(&m_formatterStore[0], N),
  991|   132k|            m_formatterStore { FormatArg(args)... }
  992|   132k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|   372k|            : m_value(static_cast<const void*>(&value)),
  535|   372k|            m_formatImpl(&formatImpl<T>),
  536|   372k|            m_toIntImpl(&toIntImpl<T>)
  537|   372k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|   372k|        {
  559|   372k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|   372k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|   372k|{
  352|   372k|#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|   372k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|   372k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|   372k|#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|   372k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|   372k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|   372k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|   372k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|   372k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 372k]
  ------------------
  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|   372k|    else
  378|   372k|        out << value;
  379|   372k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|   108k|{
 1089|   108k|    std::ostringstream oss;
 1090|   108k|    format(oss, fmt, args...);
 1091|   108k|    return oss.str();
 1092|   108k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|   108k|{
 1081|   108k|    vformat(out, fmt, makeFormatList(args...));
 1082|   108k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|   108k|{
 1045|   108k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|   108k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|   108k|            : FormatList(&m_formatterStore[0], N),
  991|   108k|            m_formatterStore { FormatArg(args)... }
  992|   108k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZN7uint160C2E4SpanIKhE:
  193|     25|    constexpr explicit uint160(Span<const unsigned char> vch) : base_blob<160>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|  1.00k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZN9base_blobILj160EE5beginEv:
  115|      3|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE5beginEv:
  118|  1.29k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  121|     16|    static constexpr unsigned int size() { return WIDTH; }
_ZNK9base_blobILj256EE3endEv:
  119|  1.29k|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
_ZNK9base_blobILj256EE4dataEv:
  112|    432|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj160EE4sizeEv:
  121|  1.14k|    static constexpr unsigned int size() { return WIDTH; }
_ZN9base_blobILj160EE4dataEv:
  113|  1.14k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
  113|     48|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint256C2Ev:
  205|  1.88k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|  1.88k|    constexpr base_blob() : m_data() {}
_ZN7uint160C2Ev:
  192|  1.14k|    constexpr uint160() = default;
_ZN9base_blobILj160EEC2Ev:
   35|  1.14k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj160EEC2E4SpanIKhE:
   41|     25|    {
   42|     25|        assert(vch.size() == WIDTH);
   43|     25|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|     25|    }
_ZNK9base_blobILj160EE5beginEv:
  118|     27|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZNK9base_blobILj160EE3endEv:
  119|     27|    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }

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

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

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

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

key_io.cpp:_ZNK12_GLOBAL__N_111IntIdentityclEi:
  263|  19.3k|    [[maybe_unused]] int operator()(int x) const { return x; }
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK19WitnessV0ScriptHashEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|      2|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|      2|    size_t acc = 0;
  272|      2|    size_t bits = 0;
  273|      2|    constexpr size_t maxv = (1 << tobits) - 1;
  274|      2|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|     66|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 64, False: 2]
  ------------------
  276|     64|        int v = infn(*it);
  277|     64|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 64]
  ------------------
  278|     64|        acc = ((acc << frombits) | v) & max_acc;
  279|     64|        bits += frombits;
  280|    166|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 102, False: 64]
  ------------------
  281|    102|            bits -= tobits;
  282|    102|            outfn((acc >> bits) & maxv);
  283|    102|        }
  284|     64|        ++it;
  285|     64|    }
  286|      2|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|      2|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 2, False: 0]
  ------------------
  288|      2|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|      2|    return true;
  292|      2|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV0KeyHashEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|      2|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|      2|    size_t acc = 0;
  272|      2|    size_t bits = 0;
  273|      2|    constexpr size_t maxv = (1 << tobits) - 1;
  274|      2|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|     42|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 40, False: 2]
  ------------------
  276|     40|        int v = infn(*it);
  277|     40|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 40]
  ------------------
  278|     40|        acc = ((acc << frombits) | v) & max_acc;
  279|     40|        bits += frombits;
  280|    104|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 64, False: 40]
  ------------------
  281|     64|            bits -= tobits;
  282|     64|            outfn((acc >> bits) & maxv);
  283|     64|        }
  284|     40|        ++it;
  285|     40|    }
  286|      2|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|      2|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 0, False: 2]
  ------------------
  288|      2|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|      2|    return true;
  292|      2|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK16WitnessV1TaprootEUlhE_PKhNS0_11IntIdentityEEbT2_T3_SA_T4_:
  270|    571|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|    571|    size_t acc = 0;
  272|    571|    size_t bits = 0;
  273|    571|    constexpr size_t maxv = (1 << tobits) - 1;
  274|    571|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|  18.8k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 18.2k, False: 571]
  ------------------
  276|  18.2k|        int v = infn(*it);
  277|  18.2k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 18.2k]
  ------------------
  278|  18.2k|        acc = ((acc << frombits) | v) & max_acc;
  279|  18.2k|        bits += frombits;
  280|  47.3k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 29.1k, False: 18.2k]
  ------------------
  281|  29.1k|            bits -= tobits;
  282|  29.1k|            outfn((acc >> bits) & maxv);
  283|  29.1k|        }
  284|  18.2k|        ++it;
  285|  18.2k|    }
  286|    571|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|    571|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 571, False: 0]
  ------------------
  288|    571|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|    571|    return true;
  292|    571|}
key_io.cpp:_Z11ConvertBitsILi8ELi5ELb1EZNK12_GLOBAL__N_118DestinationEncoderclERK14WitnessUnknownEUlhE_NSt3__111__wrap_iterIPKhEENS0_11IntIdentityEEbT2_T3_SD_T4_:
  270|     54|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|     54|    size_t acc = 0;
  272|     54|    size_t bits = 0;
  273|     54|    constexpr size_t maxv = (1 << tobits) - 1;
  274|     54|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|    998|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 944, False: 54]
  ------------------
  276|    944|        int v = infn(*it);
  277|    944|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 944]
  ------------------
  278|    944|        acc = ((acc << frombits) | v) & max_acc;
  279|    944|        bits += frombits;
  280|  2.43k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 1.49k, False: 944]
  ------------------
  281|  1.49k|            bits -= tobits;
  282|  1.49k|            outfn((acc >> bits) & maxv);
  283|  1.49k|        }
  284|    944|        ++it;
  285|    944|    }
  286|     54|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|     54|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 42, False: 12]
  ------------------
  288|     54|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|     54|    return true;
  292|     54|}

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

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