_Z16htole16_internalt:
   19|    420|{
   20|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
   21|    420|        else return host_16bits;
   22|    420|}
_Z16le16toh_internalt:
   29|    138|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|    138|        else return little_endian_16bits;
   32|    138|}
_Z16htole32_internalj:
   39|  2.39k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  2.39k|        else return host_32bits;
   42|  2.39k|}
_Z16le32toh_internalj:
   49|    940|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|    940|        else return little_endian_32bits;
   52|    940|}
_Z16le64toh_internalm:
   69|     90|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|     90|        else return little_endian_64bits;
   72|     90|}

tx_in.cpp:_ZL25GetTransactionInputWeightRK5CTxIn:
  142|    287|{
  143|       |    // scriptWitness size is added here because witnesses and txins are split up in segwit serialization.
  144|    287|    return ::GetSerializeSize(TX_NO_WITNESS(txin)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(txin)) + ::GetSerializeSize(txin.scriptWitness.stack);
  145|    287|}
policy.cpp:_ZL25GetTransactionInputWeightRK5CTxIn:
  142|    287|{
  143|       |    // scriptWitness size is added here because witnesses and txins are split up in segwit serialization.
  144|    287|    return ::GetSerializeSize(TX_NO_WITNESS(txin)) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(TX_WITH_WITNESS(txin)) + ::GetSerializeSize(txin.scriptWitness.stack);
  145|    287|}

tx_in.cpp:_ZL21RecursiveDynamicUsageRK5CTxIn:
   20|    287|static inline size_t RecursiveDynamicUsage(const CTxIn& in) {
   21|    287|    size_t mem = RecursiveDynamicUsage(in.scriptSig) + RecursiveDynamicUsage(in.prevout) + memusage::DynamicUsage(in.scriptWitness.stack);
   22|    287|    for (std::vector<std::vector<unsigned char> >::const_iterator it = in.scriptWitness.stack.begin(); it != in.scriptWitness.stack.end(); it++) {
  ------------------
  |  Branch (22:104): [True: 0, False: 287]
  ------------------
   23|      0|         mem += memusage::DynamicUsage(*it);
   24|      0|    }
   25|    287|    return mem;
   26|    287|}
tx_in.cpp:_ZL21RecursiveDynamicUsageRK7CScript:
   12|    287|static inline size_t RecursiveDynamicUsage(const CScript& script) {
   13|    287|    return memusage::DynamicUsage(script);
   14|    287|}
tx_in.cpp:_ZL21RecursiveDynamicUsageRK9COutPoint:
   16|    287|static inline size_t RecursiveDynamicUsage(const COutPoint& out) {
   17|    287|    return 0;
   18|    287|}

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

tx_in.cpp:_ZN8memusageL12DynamicUsageILj28EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|    287|{
  109|    287|    return MallocUsage(v.allocated_memory());
  110|    287|}
tx_in.cpp:_ZN8memusageL11MallocUsageEm:
   53|    574|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|    574|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 399, False: 175]
  ------------------
   56|    399|        return 0;
   57|    399|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|    175|        return ((alloc + 31) >> 4) << 4;
   59|    175|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|    574|}
tx_in.cpp:_ZN8memusageL12DynamicUsageINSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEEmRKNS2_IT_T0_EE:
   90|    287|{
   91|    287|    return MallocUsage(v.capacity() * sizeof(T));
   92|    287|}

_Z25GetVirtualTransactionSizellj:
  313|    287|{
  314|    287|    return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
  315|    287|}
_Z30GetVirtualTransactionInputSizeRK5CTxInlj:
  323|    287|{
  324|    287|    return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
  325|    287|}

tx_in.cpp:_ZL30GetVirtualTransactionInputSizeRK5CTxIn:
  180|    287|{
  181|    287|    return GetVirtualTransactionInputSize(tx, 0, 0);
  182|    287|}

_ZN9prevectorILj28EhjiE8item_ptrEi:
  206|    325|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 46, False: 279]
  ------------------
_ZNK9prevectorILj28EhjiE9is_directEv:
  173|  7.52k|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj28EhjiE10direct_ptrEi:
  169|    325|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj28EhjiE12indirect_ptrEi:
  171|    279|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE8capacityEv:
  312|    325|    size_t capacity() const {
  313|    325|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 325, False: 0]
  ------------------
  314|    325|            return N;
  315|    325|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|    325|    }
_ZN9prevectorILj28EhjiE15change_capacityEj:
  175|    279|    void change_capacity(size_type new_capacity) {
  176|    279|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 0, False: 279]
  ------------------
  177|      0|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 0]
  ------------------
  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|    279|        } else {
  186|    279|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 279]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|    279|            } else {
  194|    279|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|    279|                assert(new_indirect);
  196|    279|                T* src = direct_ptr(0);
  197|    279|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|    279|                memcpy(dst, src, size() * sizeof(T));
  199|    279|                _union.indirect_contents.indirect = new_indirect;
  200|    279|                _union.indirect_contents.capacity = new_capacity;
  201|    279|                _size += N + 1;
  202|    279|            }
  203|    279|        }
  204|    279|    }
_ZNK9prevectorILj28EhjiE8item_ptrEi:
  207|  1.13k|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 264, False: 875]
  ------------------
_ZNK9prevectorILj28EhjiE10direct_ptrEi:
  170|    264|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE12indirect_ptrEi:
  172|    875|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE4sizeEv:
  294|  4.62k|    size_type size() const {
  295|  4.62k|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 2.06k, False: 2.55k]
  ------------------
  296|  4.62k|    }
_ZN9prevectorILj28EhjiE5clearEv:
  355|    535|    void clear() {
  356|    535|        resize(0);
  357|    535|    }
_ZN9prevectorILj28EhjiE6resizeEj:
  328|    535|    void resize(size_type new_size) {
  329|    535|        size_type cur_size = size();
  330|    535|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 535, False: 0]
  ------------------
  331|    535|            return;
  332|    535|        }
  333|      0|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 0, False: 0]
  ------------------
  334|      0|            erase(item_ptr(new_size), end());
  335|      0|            return;
  336|      0|        }
  337|      0|        if (new_size > capacity()) {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  ------------------
  338|      0|            change_capacity(new_size);
  339|      0|        }
  340|      0|        ptrdiff_t increase = new_size - cur_size;
  341|      0|        fill(item_ptr(cur_size), increase);
  342|      0|        _size += increase;
  343|      0|    }
_ZNK9prevectorILj28EhjiE4dataEv:
  537|  1.13k|    const value_type* data() const {
  538|  1.13k|        return item_ptr(0);
  539|  1.13k|    }
_ZNK9prevectorILj28EhjiE16allocated_memoryEv:
  525|    287|    size_t allocated_memory() const {
  526|    287|        if (is_direct()) {
  ------------------
  |  Branch (526:13): [True: 112, False: 175]
  ------------------
  527|    112|            return 0;
  528|    175|        } else {
  529|    175|            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
  530|    175|        }
  531|    287|    }
_ZNK9prevectorILj28EhjiE5emptyEv:
  298|  1.14k|    bool empty() const {
  299|  1.14k|        return size() == 0;
  300|  1.14k|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|    546|    ~prevector() {
  475|    546|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 279, False: 267]
  ------------------
  476|    279|            free(_union.indirect_contents.indirect);
  477|    279|            _union.indirect_contents.indirect = nullptr;
  478|    279|        }
  479|    546|    }
_ZN9prevectorILj28EhjiEC2Ev:
  243|    546|    prevector() = default;
_ZN9prevectorILj28EhjiE20resize_uninitializedEj:
  401|    325|    inline void resize_uninitialized(size_type new_size) {
  402|       |        // resize_uninitialized changes the size of the prevector but does not initialize it.
  403|       |        // If size < new_size, the added elements must be initialized explicitly.
  404|    325|        if (capacity() < new_size) {
  ------------------
  |  Branch (404:13): [True: 279, False: 46]
  ------------------
  405|    279|            change_capacity(new_size);
  406|    279|            _size += new_size - size();
  407|    279|            return;
  408|    279|        }
  409|     46|        if (new_size < size()) {
  ------------------
  |  Branch (409:13): [True: 0, False: 46]
  ------------------
  410|      0|            erase(item_ptr(new_size), end());
  411|     46|        } else {
  412|     46|            _size += new_size - size();
  413|     46|        }
  414|     46|    }
_ZN9prevectorILj28EhjiEixEj:
  320|    325|    T& operator[](size_type pos) {
  321|    325|        return *item_ptr(pos);
  322|    325|    }

_ZNK9COutPoint8ToStringEv:
   22|    287|{
   23|    287|    return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10), n);
  ------------------
  |  | 1172|    287|#define strprintf tfm::format
  ------------------
   24|    287|}
_ZNK5CTxIn8ToStringEv:
   41|    287|{
   42|    287|    std::string str;
   43|    287|    str += "CTxIn(";
   44|    287|    str += prevout.ToString();
   45|    287|    if (prevout.IsNull())
  ------------------
  |  Branch (45:9): [True: 74, False: 213]
  ------------------
   46|     74|        str += strprintf(", coinbase %s", HexStr(scriptSig));
  ------------------
  |  | 1172|     74|#define strprintf tfm::format
  ------------------
   47|    213|    else
   48|    213|        str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
  ------------------
  |  | 1172|    213|#define strprintf tfm::format
  ------------------
   49|    287|    if (nSequence != SEQUENCE_FINAL)
  ------------------
  |  Branch (49:9): [True: 257, False: 30]
  ------------------
   50|    257|        str += strprintf(", nSequence=%u", nSequence);
  ------------------
  |  | 1172|    257|#define strprintf tfm::format
  ------------------
   51|    287|    str += ")";
   52|    287|    return str;
   53|    287|}

_ZN9COutPointC2Ev:
   36|    546|    COutPoint(): n(NULL_INDEX) { }
_ZNK9COutPoint6IsNullEv:
   42|    287|    bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
  ------------------
  |  Branch (42:35): [True: 128, False: 159]
  |  Branch (42:52): [True: 74, False: 54]
  ------------------
_ZN5CTxInC2Ev:
  122|    546|    {
  123|    546|        nSequence = SEQUENCE_FINAL;
  124|    546|    }
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|  1.14k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|  1.14k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|  1.14k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|  1.14k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   39|    546|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|    546|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN5CTxIn16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  129|    546|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|    546|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_ZN7CScript16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|  1.14k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  1.14k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScriptC2Ev:
  461|    546|    CScript() = default;
_ZN14CScriptWitnessC2Ev:
  591|    546|    CScriptWitness() = default;
_ZN7CScript16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  465|    535|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|    535|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_Z20GetSizeOfCompactSizem:
  298|    574|{
  299|    574|    if (nSize < 253)             return sizeof(unsigned char);
  ------------------
  |  Branch (299:9): [True: 574, False: 0]
  ------------------
  300|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
  ------------------
  |  Branch (300:14): [True: 0, False: 0]
  ------------------
  301|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())  return sizeof(unsigned char) + sizeof(unsigned int);
  ------------------
  |  Branch (301:14): [True: 0, False: 0]
  ------------------
  302|      0|    else                         return sizeof(unsigned char) + sizeof(uint64_t);
  303|    574|}
_ZN12SizeComputer5writeE4SpanIKSt4byteE:
 1069|  5.96k|    {
 1070|  5.96k|        this->nSize += src.size();
 1071|  5.96k|    }
_ZN12SizeComputer4seekEm:
 1075|    574|    {
 1076|    574|        this->nSize += _nSize;
 1077|    574|    }
_ZNK12SizeComputer4sizeEv:
 1086|  1.72k|    size_t size() const {
 1087|  1.72k|        return nSize;
 1088|  1.72k|    }
_Z16WriteCompactSizeR12SizeComputerm:
 1098|    574|{
 1099|    574|    s.seek(GetSizeOfCompactSize(nSize));
 1100|    574|}
_ZNK20TransactionSerParamsclIRK5CTxInEEDaOT_:
 1228|  1.14k|    {                                                                                    \
 1229|  1.14k|        return ParamsWrapper{*this, t};                                                  \
 1230|  1.14k|    }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
  262|  2.29k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
   69|  2.39k|{
   70|  2.39k|    obj = htole32_internal(obj);
   71|  2.39k|    s.write(AsBytes(Span{&obj, 1}));
   72|  2.39k|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetStreamEv:
 1154|  5.96k|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  5.96k|        } else {
 1158|  5.96k|            return m_substream;
 1159|  5.96k|        }
 1160|  5.96k|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  5.96k|    void write(Span<const std::byte> src) { GetStream().write(src); }
_Z16WriteCompactSizeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
  309|  1.14k|{
  310|  1.14k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 628, False: 520]
  ------------------
  311|    628|    {
  312|    628|        ser_writedata8(os, nSize);
  313|    628|    }
  314|    520|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 420, False: 100]
  ------------------
  315|    420|    {
  316|    420|        ser_writedata8(os, 253);
  317|    420|        ser_writedata16(os, nSize);
  318|    420|    }
  319|    100|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 100, False: 0]
  ------------------
  320|    100|    {
  321|    100|        ser_writedata8(os, 254);
  322|    100|        ser_writedata32(os, nSize);
  323|    100|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  1.14k|    return;
  330|  1.14k|}
_Z14ser_writedata8I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
   55|  1.14k|{
   56|  1.14k|    s.write(AsBytes(Span{&obj, 1}));
   57|  1.14k|}
_Z15ser_writedata16I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_t:
   59|    420|{
   60|    420|    obj = htole16_internal(obj);
   61|    420|    s.write(AsBytes(Span{&obj, 1}));
   62|    420|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.14k|{
  754|  1.14k|    a.Serialize(os);
  755|  1.14k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  1.14k|    {                                                                                               \
  223|  1.14k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.14k|        Ser(s, *this);                                                                              \
  225|  1.14k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  1.14k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|  1.14k|    {
 1014|  1.14k|        ::SerializeMany(s, args...);
 1015|  1.14k|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|  1.14k|{
  996|  1.14k|    (::Serialize(s, args), ...);
  997|  1.14k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.14k|{
  754|  1.14k|    a.Serialize(os);
  755|  1.14k|}
_ZNK7CScript9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  1.14k|    {                                                                                               \
  223|  1.14k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.14k|        Ser(s, *this);                                                                              \
  225|  1.14k|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  1.14k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERKT_RKT0_:
  151|  1.14k|{
  152|  1.14k|    static_assert(std::is_base_of_v<Out, In>);
  153|  1.14k|    return x;
  154|  1.14k|}
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|  1.14k|    {
 1014|  1.14k|        ::SerializeMany(s, args...);
 1015|  1.14k|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|  1.14k|{
  996|  1.14k|    (::Serialize(s, args), ...);
  997|  1.14k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  1.14k|{
  812|  1.14k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  1.14k|        WriteCompactSize(os, v.size());
  814|  1.14k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 852, False: 296]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  1.14k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.14k|{
  754|  1.14k|    a.Serialize(os);
  755|  1.14k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|  1.14k|    {                                                                                               \
  223|  1.14k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.14k|        Ser(s, *this);                                                                              \
  225|  1.14k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|  1.14k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|  1.14k|    {
 1014|  1.14k|        ::SerializeMany(s, args...);
 1015|  1.14k|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|  1.14k|{
  996|  1.14k|    (::Serialize(s, args), ...);
  997|  1.14k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|  1.14k|{
  754|  1.14k|    a.Serialize(os);
  755|  1.14k|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|  1.14k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|  1.14k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z16GetSerializeSizeI13ParamsWrapperI20TransactionSerParamsK5CTxInEEmRKT_:
 1104|  1.14k|{
 1105|  1.14k|    return (SizeComputer() << t).size();
 1106|  1.14k|}
_ZN12SizeComputerlsI13ParamsWrapperI20TransactionSerParamsK5CTxInEEERS_RKT_:
 1081|  1.14k|    {
 1082|  1.14k|        ::Serialize(*this, obj);
 1083|  1.14k|        return (*this);
 1084|  1.14k|    }
_Z9SerializeI12SizeComputer13ParamsWrapperI20TransactionSerParamsK5CTxInEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.14k|{
  754|  1.14k|    a.Serialize(os);
  755|  1.14k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK5CTxInE9SerializeI12SizeComputerEEvRT_:
 1199|  1.14k|    {
 1200|  1.14k|        ParamsStream ss{s, m_params};
 1201|  1.14k|        ::Serialize(ss, m_object);
 1202|  1.14k|    }
_Z16GetSerializeSizeINSt3__16vectorINS1_IhNS0_9allocatorIhEEEENS2_IS4_EEEEEmRKT_:
 1104|    574|{
 1105|    574|    return (SizeComputer() << t).size();
 1106|    574|}
_ZN12SizeComputerlsINSt3__16vectorINS2_IhNS1_9allocatorIhEEEENS3_IS5_EEEEEERS_RKT_:
 1081|    574|    {
 1082|    574|        ::Serialize(*this, obj);
 1083|    574|        return (*this);
 1084|    574|    }
_Z9SerializeI12SizeComputerNSt3__16vectorIhNS1_9allocatorIhEEEENS3_IS5_EEEvRT_RKNS2_IT0_T1_EE:
  846|    574|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|    574|    } else {
  859|    574|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|    574|    }
  861|    574|}
_Z9SerializeI12SizeComputer7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEQ12SerializableIT0_T_EEvRSG_RKSF_:
  753|    574|{
  754|    574|    a.Serialize(os);
  755|    574|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12SizeComputerEEvRT_:
  482|    574|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12SizeComputerNSt3__16vectorINS5_IhNS4_9allocatorIhEEEENS6_IS8_EEEEEEvRT_RKT0_:
  662|    574|    {
  663|    574|        Formatter formatter;
  664|    574|        WriteCompactSize(s, v.size());
  665|    574|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 0, False: 574]
  ------------------
  666|      0|            formatter.Ser(s, elem);
  667|      0|        }
  668|    574|    }
_ZN12SizeComputerC2Ev:
 1066|  1.72k|    SizeComputer() = default;
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsEC2ES1_RKS2_:
 1127|  1.14k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESB_:
  481|    574|    explicit Wrapper(T obj) : m_object(obj) {}
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERT_RT0_:
  145|    535|{
  146|    535|    static_assert(std::is_base_of_v<Out, In>);
  147|    535|    return x;
  148|    535|}
_Z14ser_readdata32I10DataStreamEjRT_:
  102|    947|{
  103|    947|    uint32_t obj;
  104|    947|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|    947|    return le32toh_internal(obj);
  106|    947|}
_Z11UnserializeI10DataStreamEvRT_Rj:
  277|    828|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|    535|{
  341|    535|    uint8_t chSize = ser_readdata8(is);
  342|    535|    uint64_t nSizeRet = 0;
  343|    535|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 185, False: 350]
  ------------------
  344|    185|    {
  345|    185|        nSizeRet = chSize;
  346|    185|    }
  347|    350|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 139, False: 211]
  ------------------
  348|    139|    {
  349|    139|        nSizeRet = ser_readdata16(is);
  350|    139|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 8, False: 131]
  ------------------
  351|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    139|    }
  353|    211|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 119, False: 92]
  ------------------
  354|    119|    {
  355|    119|        nSizeRet = ser_readdata32(is);
  356|    119|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 18, False: 101]
  ------------------
  357|     18|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    119|    }
  359|     92|    else
  360|     92|    {
  361|     92|        nSizeRet = ser_readdata64(is);
  362|     92|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 40, False: 52]
  ------------------
  363|     40|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|     92|    }
  365|    469|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 465, False: 4]
  |  Branch (365:24): [True: 65, False: 400]
  ------------------
  366|     65|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     65|    }
  368|    404|    return nSizeRet;
  369|    469|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|    535|{
   85|    535|    uint8_t obj;
   86|    535|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|    535|    return obj;
   88|    535|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|    139|{
   91|    139|    uint16_t obj;
   92|    139|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|    139|    return le16toh_internal(obj);
   94|    139|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|     91|{
  115|     91|    uint64_t obj;
  116|     91|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|     91|    return le64toh_internal(obj);
  118|     91|}
_Z11UnserializeI10DataStreamR9COutPointQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    546|{
  763|    546|    a.Unserialize(is);
  764|    546|}
_ZN9COutPoint11UnserializeI10DataStreamEEvRT_:
  228|    546|    {                                                                                               \
  229|    546|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    546|        Unser(s, *this);                                                                            \
  231|    546|    }
_ZN9COutPoint5UnserI10DataStreamEEvRT_RS_:
  180|    546|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1033|    546|    {
 1034|    546|        ::UnserializeMany(s, args...);
 1035|    546|    }
_Z15UnserializeManyI10DataStreamJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1001|    546|{
 1002|    546|    (::Unserialize(s, args), ...);
 1003|    546|}
_Z11UnserializeI10DataStreamR22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS5_OS4_:
  762|    546|{
  763|    546|    a.Unserialize(is);
  764|    546|}
_Z11UnserializeI10DataStreamR7CScriptQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    535|{
  763|    535|    a.Unserialize(is);
  764|    535|}
_ZN7CScript11UnserializeI10DataStreamEEvRT_:
  228|    535|    {                                                                                               \
  229|    535|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    535|        Unser(s, *this);                                                                            \
  231|    535|    }
_ZN7CScript5UnserI10DataStreamEEvRT_RS_:
  180|    535|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR9prevectorILj28EhjiEEEEvRT_DpOT0_:
 1033|    535|    {
 1034|    535|        ::UnserializeMany(s, args...);
 1035|    535|    }
_Z15UnserializeManyI10DataStreamJR9prevectorILj28EhjiEEEvRT_DpOT0_:
 1001|    535|{
 1002|    535|    (::Unserialize(s, args), ...);
 1003|    535|}
_Z11UnserializeI10DataStreamLj28EhEvRT_R9prevectorIXT0_ET1_jiE:
  823|    535|{
  824|    535|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  825|       |        // Limit size per read so bogus size value won't cause out of memory
  826|    535|        v.clear();
  827|    535|        unsigned int nSize = ReadCompactSize(is);
  828|    535|        unsigned int i = 0;
  829|    860|        while (i < nSize) {
  ------------------
  |  Branch (829:16): [True: 325, False: 535]
  ------------------
  830|    325|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  831|    325|            v.resize_uninitialized(i + blk);
  832|    325|            is.read(AsWritableBytes(Span{&v[i], blk}));
  833|    325|            i += blk;
  834|    325|        }
  835|       |    } else {
  836|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  837|       |    }
  838|    535|}
_Z11UnserializeI10DataStreamR5CTxInQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    546|{
  763|    546|    a.Unserialize(is);
  764|    546|}
_ZN5CTxIn11UnserializeI10DataStreamEEvRT_:
  228|    546|    {                                                                                               \
  229|    546|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    546|        Unser(s, *this);                                                                            \
  231|    546|    }
_ZN5CTxIn5UnserI10DataStreamEEvRT_RS_:
  180|    546|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1033|    546|    {
 1034|    546|        ::UnserializeMany(s, args...);
 1035|    546|    }
_Z15UnserializeManyI10DataStreamJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1001|    546|{
 1002|    546|    (::Unserialize(s, args), ...);
 1003|    546|}
_ZN13ParamsWrapperI20TransactionSerParamsK5CTxInEC2ERKS0_RS2_:
 1195|  1.14k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
tx_in.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|    287|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
policy.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|    287|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }

_ZNK4SpanIKSt4byteE4sizeEv:
  187|  6.51k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  1.09k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|    574|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|    574|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|    574|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4dataEv:
  174|  2.55k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  2.54k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  7.62k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  2.45k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE10size_bytesEv:
  188|  2.54k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|  2.54k|{
  260|  2.54k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  2.54k|}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  6.51k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZNK4SpanIjE4dataEv:
  174|  3.34k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  3.34k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|  2.39k|{
  260|  2.39k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  2.39k|}
_ZNK4SpanIhE10size_bytesEv:
  188|  2.55k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  1.14k|{
  260|  1.14k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  1.14k|}
_ZNK4SpanItE4dataEv:
  174|    559|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|    559|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|    420|{
  260|    420|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|    420|}
_ZNK4SpanImE4dataEv:
  174|     91|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|     91|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z12MakeByteSpanIRK9prevectorILj28EhjiEE4SpanIKSt4byteEOT_:
  270|    852|{
  271|    852|    return AsBytes(Span{std::forward<V>(v)});
  272|    852|}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  2.58k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  1.40k|{
  265|  1.40k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.40k|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  2.00k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|    139|{
  265|    139|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    139|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|    559|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|    947|{
  265|    947|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    947|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  3.34k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|     91|{
  265|     91|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|     91|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|     91|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__14spanIS0_Lm18446744073709551615EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|    546|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.14k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I9prevectorILj28EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|    852|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|    546|{
  276|    546|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|    546|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|    546|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7CScriptEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|    287|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|    287|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}

_ZN10DataStreamC2E4SpanIKhE:
  165|    546|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|    546|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStream4readE4SpanISt4byteE:
  219|  2.58k|    {
  220|  2.58k|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 2.58k]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  2.58k|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  2.58k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 2.58k]
  |  Branch (224:43): [True: 128, False: 2.45k]
  ------------------
  225|    128|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    128|        }
  227|  2.45k|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  2.45k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 479, False: 1.97k]
  ------------------
  229|    479|            m_read_pos = 0;
  230|    479|            vch.clear();
  231|    479|            return;
  232|    479|        }
  233|  1.97k|        m_read_pos = next_read_pos.value();
  234|  1.97k|    }
_ZN10DataStreamrsIR5CTxInEERS_OT_:
  266|    546|    {
  267|    546|        ::Unserialize(*this, obj);
  268|    546|        return (*this);
  269|    546|    }

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

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

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

_Z17tx_in_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   15|    546|{
   16|    546|    DataStream ds{buffer};
   17|    546|    CTxIn tx_in;
   18|    546|    try {
   19|    546|        ds >> tx_in;
   20|    546|    } catch (const std::ios_base::failure&) {
   21|    259|        return;
   22|    259|    }
   23|       |
   24|    287|    (void)GetTransactionInputWeight(tx_in);
   25|    287|    (void)GetVirtualTransactionInputSize(tx_in);
   26|    287|    (void)RecursiveDynamicUsage(tx_in);
   27|       |
   28|    287|    (void)tx_in.ToString();
   29|    287|}

_ZN12CheckGlobalsC2Ev:
   56|    546|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|    546|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|    546|    {
   18|    546|        g_used_g_prng = false;
   19|    546|        g_seeded_g_prng_zero = false;
   20|    546|        g_used_system_time = false;
   21|    546|        SetMockTime(0s);
   22|    546|    }
_ZN16CheckGlobalsImplD2Ev:
   24|    546|    {
   25|    546|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 0, False: 546]
  |  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|    546|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 546]
  ------------------
   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|    546|    }

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

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

_ZNK9base_blobILj256EE6IsNullEv:
   49|    287|    {
   50|    287|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|    287|            return val == 0;
   52|    287|        });
   53|    287|    }
_ZN7uint256C2Ev:
  205|    546|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|    546|    constexpr base_blob() : m_data() {}
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  127|  1.14k|    {
  128|  1.14k|        s << Span(m_data);
  129|  1.14k|    }
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|    546|    {
  134|    546|        s.read(MakeWritableByteSpan(m_data));
  135|    546|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   50|  5.19k|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|  5.19k|            return val == 0;
   52|  5.19k|        });

_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|    546|{
   53|    546|    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|    546|    ) {
   58|    546|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 546]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    546|    }
   62|    546|    return std::forward<T>(val);
   63|    546|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|    546|{
   53|    546|    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|    546|    ) {
   58|    546|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 546]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    546|    }
   62|    546|    return std::forward<T>(val);
   63|    546|}

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

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

_ZNK22transaction_identifierILb0EE6IsNullEv:
   43|    287|    constexpr bool IsNull() const { return m_wrapped.IsNull(); }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
   57|  1.14k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb0EEC2Ev:
   30|    546|    transaction_identifier() : m_wrapped{} {}
_ZN22transaction_identifierILb0EE11UnserializeI10DataStreamEEvRT_:
   58|    546|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZNK22transaction_identifierILb0EE8ToStringEv:
   52|    287|    std::string ToString() const { return m_wrapped.ToString(); }