_Z16le16toh_internalt:
   29|    117|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|    117|        else return little_endian_16bits;
   32|    117|}
_Z16le32toh_internalj:
   49|    127|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|    127|        else return little_endian_32bits;
   52|    127|}
_Z16htole64_internalm:
   59|    536|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|    536|        else return host_64bits;
   62|    536|}
_Z16le64toh_internalm:
   69|    691|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|    691|        else return little_endian_64bits;
   72|    691|}

tx_out.cpp:_ZL21RecursiveDynamicUsageRK6CTxOut:
   28|    322|static inline size_t RecursiveDynamicUsage(const CTxOut& out) {
   29|    322|    return RecursiveDynamicUsage(out.scriptPubKey);
   30|    322|}
tx_out.cpp:_ZL21RecursiveDynamicUsageRK7CScript:
   12|    322|static inline size_t RecursiveDynamicUsage(const CScript& script) {
   13|    322|    return memusage::DynamicUsage(script);
   14|    322|}

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

tx_out.cpp:_ZN8memusageL12DynamicUsageILj28EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|    322|{
  109|    322|    return MallocUsage(v.allocated_memory());
  110|    322|}
tx_out.cpp:_ZN8memusageL11MallocUsageEm:
   53|    322|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|    322|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 170, False: 152]
  ------------------
   56|    170|        return 0;
   57|    170|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|    152|        return ((alloc + 31) >> 4) << 4;
   59|    152|    } 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|    322|}

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

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

_Z16GetDustThresholdRK6CTxOutRK8CFeeRate:
   27|    644|{
   28|       |    // "Dust" is defined in terms of dustRelayFee,
   29|       |    // which has units satoshis-per-kilobyte.
   30|       |    // If you'd pay more in fees than the value of the output
   31|       |    // to spend something, then we consider it dust.
   32|       |    // A typical spendable non-segwit txout is 34 bytes big, and will
   33|       |    // need a CTxIn of at least 148 bytes to spend:
   34|       |    // so dust is a spendable txout less than
   35|       |    // 182*dustRelayFee/1000 (in satoshis).
   36|       |    // 546 satoshis at the default rate of 3000 sat/kvB.
   37|       |    // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
   38|       |    // need a CTxIn of at least 67 bytes to spend:
   39|       |    // so dust is a spendable txout less than
   40|       |    // 98*dustRelayFee/1000 (in satoshis).
   41|       |    // 294 satoshis at the default rate of 3000 sat/kvB.
   42|    644|    if (txout.scriptPubKey.IsUnspendable())
  ------------------
  |  Branch (42:9): [True: 108, False: 536]
  ------------------
   43|    108|        return 0;
   44|       |
   45|    536|    size_t nSize = GetSerializeSize(txout);
   46|    536|    int witnessversion = 0;
   47|    536|    std::vector<unsigned char> witnessprogram;
   48|       |
   49|       |    // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
   50|       |    // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
   51|       |    // satisfaction is lower (a single BIP340 signature) but this computation was
   52|       |    // kept to not further reduce the dust level.
   53|       |    // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
   54|    536|    if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (54:9): [True: 58, False: 478]
  ------------------
   55|       |        // sum the sizes of the parts of a transaction input
   56|       |        // with 75% segwit discount applied to the script size.
   57|     58|        nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
   58|    478|    } else {
   59|    478|        nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
   60|    478|    }
   61|       |
   62|    536|    return dustRelayFeeIn.GetFee(nSize);
   63|    644|}
_Z6IsDustRK6CTxOutRK8CFeeRate:
   66|    322|{
   67|    322|    return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
   68|    322|}

_ZN9prevectorILj28EhjiE3endEv:
  304|    452|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj28EhjiE8item_ptrEi:
  206|  1.02k|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 303, False: 722]
  ------------------
_ZNK9prevectorILj28EhjiE9is_directEv:
  173|  12.8k|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj28EhjiE10direct_ptrEi:
  169|    721|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj28EhjiE12indirect_ptrEi:
  171|    874|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZmiN9prevectorILj28EhjiE8iteratorES1_:
   66|    226|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj28EhjiE8iteratordeEv:
   59|  1.35k|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj28EhjiE8capacityEv:
  312|    347|    size_t capacity() const {
  313|    347|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 347, False: 0]
  ------------------
  314|    347|            return N;
  315|    347|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|    347|    }
_ZN9prevectorILj28EhjiE15change_capacityEj:
  175|  1.18k|    void change_capacity(size_type new_capacity) {
  176|  1.18k|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 917, False: 266]
  ------------------
  177|    917|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 152, False: 765]
  ------------------
  178|    152|                T* indirect = indirect_ptr(0);
  179|    152|                T* src = indirect;
  180|    152|                T* dst = direct_ptr(0);
  181|    152|                memcpy(dst, src, size() * sizeof(T));
  182|    152|                free(indirect);
  183|    152|                _size -= N + 1;
  184|    152|            }
  185|    917|        } else {
  186|    266|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 266]
  ------------------
  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|    266|            } else {
  194|    266|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|    266|                assert(new_indirect);
  196|    266|                T* src = direct_ptr(0);
  197|    266|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|    266|                memcpy(dst, src, size() * sizeof(T));
  199|    266|                _union.indirect_contents.indirect = new_indirect;
  200|    266|                _union.indirect_contents.capacity = new_capacity;
  201|    266|                _size += N + 1;
  202|    266|            }
  203|    266|        }
  204|  1.18k|    }
_ZNK9prevectorILj28EhjiE3endEv:
  305|     58|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj28EhjiE8item_ptrEi:
  207|  1.65k|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 906, False: 750]
  ------------------
_ZNK9prevectorILj28EhjiE10direct_ptrEi:
  170|    906|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE12indirect_ptrEi:
  172|    750|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE4sizeEv:
  294|  7.73k|    size_type size() const {
  295|  7.73k|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 4.92k, False: 2.81k]
  ------------------
  296|  7.73k|    }
_ZNK9prevectorILj28EhjiE5beginEv:
  303|    510|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj28EhjiE14const_iteratordeEv:
  111|    568|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj28EhjiE5clearEv:
  355|  1.50k|    void clear() {
  356|  1.50k|        resize(0);
  357|  1.50k|    }
_ZN9prevectorILj28EhjiE6resizeEj:
  328|  1.50k|    void resize(size_type new_size) {
  329|  1.50k|        size_type cur_size = size();
  330|  1.50k|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 1.28k, False: 226]
  ------------------
  331|  1.28k|            return;
  332|  1.28k|        }
  333|    226|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 226, False: 0]
  ------------------
  334|    226|            erase(item_ptr(new_size), end());
  335|    226|            return;
  336|    226|        }
  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|    }
_ZN9prevectorILj28EhjiE5eraseENS0_8iteratorES1_:
  420|    226|    iterator erase(iterator first, iterator last) {
  421|       |        // Erase is not allowed to the change the object's capacity. That means
  422|       |        // that when starting with an indirectly allocated prevector with
  423|       |        // size and capacity > N, the result may be a still indirectly allocated
  424|       |        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
  425|       |        // necessary to switch to the (more efficient) directly allocated
  426|       |        // representation (with capacity N and size <= N).
  427|    226|        iterator p = first;
  428|    226|        char* endp = (char*)&(*end());
  429|    226|        _size -= last - p;
  430|    226|        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
  431|    226|        return first;
  432|    226|    }
_ZN9prevectorILj28EhjiE13shrink_to_fitEv:
  351|    917|    void shrink_to_fit() {
  352|    917|        change_capacity(size());
  353|    917|    }
_ZNK9prevectorILj28EhjiE4dataEv:
  537|    666|    const value_type* data() const {
  538|    666|        return item_ptr(0);
  539|    666|    }
_ZNK9prevectorILj28EhjiE16allocated_memoryEv:
  525|    322|    size_t allocated_memory() const {
  526|    322|        if (is_direct()) {
  ------------------
  |  Branch (526:13): [True: 170, False: 152]
  ------------------
  527|    170|            return 0;
  528|    170|        } else {
  529|    152|            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
  530|    152|        }
  531|    322|    }
_ZNK9prevectorILj28EhjiE5emptyEv:
  298|    536|    bool empty() const {
  299|    536|        return size() == 0;
  300|    536|    }
_ZNK9prevectorILj28EhjiEixEj:
  324|    422|    const T& operator[](size_type pos) const {
  325|    422|        return *item_ptr(pos);
  326|    422|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|    595|    ~prevector() {
  475|    595|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 114, False: 481]
  ------------------
  476|    114|            free(_union.indirect_contents.indirect);
  477|    114|            _union.indirect_contents.indirect = nullptr;
  478|    114|        }
  479|    595|    }
_ZN9prevectorILj28EhjiEC2Ev:
  243|    595|    prevector() = default;
_ZN9prevectorILj28EhjiE8iteratorC2EPh:
   58|    678|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiE20resize_uninitializedEj:
  401|    347|    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|    347|        if (capacity() < new_size) {
  ------------------
  |  Branch (404:13): [True: 266, False: 81]
  ------------------
  405|    266|            change_capacity(new_size);
  406|    266|            _size += new_size - size();
  407|    266|            return;
  408|    266|        }
  409|     81|        if (new_size < size()) {
  ------------------
  |  Branch (409:13): [True: 0, False: 81]
  ------------------
  410|      0|            erase(item_ptr(new_size), end());
  411|     81|        } else {
  412|     81|            _size += new_size - size();
  413|     81|        }
  414|     81|    }
_ZN9prevectorILj28EhjiEixEj:
  320|    347|    T& operator[](size_type pos) {
  321|    347|        return *item_ptr(pos);
  322|    347|    }
_ZN9prevectorILj28EhjiE14const_iteratorC2EPKh:
  109|    626|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZmiN9prevectorILj28EhjiE14const_iteratorES1_:
  118|     58|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj28EhjiE14const_iteratorptEv:
  112|    116|        const T* operator->() const { return ptr; }
_ZNK9prevectorILj28EhjiE14const_iteratorplEj:
  119|     58|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }

_ZNK6CTxOut8ToStringEv:
   62|    322|{
   63|    322|    return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
  ------------------
  |  | 1172|    322|#define strprintf tfm::format
  ------------------
   64|    322|}

_ZN6CTxOutC2Ev:
  156|    595|    {
  157|    595|        SetNull();
  158|    595|    }
_ZN6CTxOut7SetNullEv:
  165|    917|    {
  166|    917|        nValue = -1;
  167|    917|        scriptPubKey.clear();
  168|    917|    }
_ZNK6CTxOut6IsNullEv:
  171|    644|    {
  172|    644|        return (nValue == -1);
  173|    644|    }
_ZN6CTxOut16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  162|    595|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|    595|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  162|    536|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|    536|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  244|    536|{
  245|    536|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (245:9): [True: 222, False: 314]
  |  Branch (245:29): [True: 178, False: 136]
  ------------------
  246|    400|        return false;
  247|    400|    }
  248|    136|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (248:9): [True: 82, False: 54]
  |  Branch (248:32): [True: 22, False: 60]
  |  Branch (248:53): [True: 28, False: 32]
  ------------------
  249|     50|        return false;
  250|     50|    }
  251|     86|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (251:9): [True: 58, False: 28]
  ------------------
  252|     58|        version = DecodeOP_N((opcodetype)(*this)[0]);
  253|     58|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  254|     58|        return true;
  255|     58|    }
  256|     28|    return false;
  257|     86|}

_ZN7CScript10DecodeOP_NE10opcodetype:
  518|     58|    {
  519|     58|        if (opcode == OP_0)
  ------------------
  |  Branch (519:13): [True: 32, False: 26]
  ------------------
  520|     32|            return 0;
  521|     26|        assert(opcode >= OP_1 && opcode <= OP_16);
  522|     26|        return (int)opcode - (int)(OP_1 - 1);
  523|     26|    }
_ZNK7CScript13IsUnspendableEv:
  572|    644|    {
  573|    644|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (573:17): [True: 452, False: 192]
  |  Branch (573:31): [True: 6, False: 446]
  |  Branch (573:57): [True: 102, False: 536]
  ------------------
  574|    644|    }
_ZN7CScript5clearEv:
  577|    917|    {
  578|       |        // The default prevector::clear() does not release memory
  579|    917|        CScriptBase::clear();
  580|    917|        shrink_to_fit();
  581|    917|    }
_ZN7CScriptC2Ev:
  461|    595|    CScript() = default;
_ZN7CScript16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
  465|    591|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|    591|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScript16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_:
  465|    536|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|    536|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_Z20GetSizeOfCompactSizem:
  298|    536|{
  299|    536|    if (nSize < 253)             return sizeof(unsigned char);
  ------------------
  |  Branch (299:9): [True: 430, False: 106]
  ------------------
  300|    106|    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
  ------------------
  |  Branch (300:14): [True: 106, 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|    536|}
_ZN12SizeComputer5writeE4SpanIKSt4byteE:
 1069|    880|    {
 1070|    880|        this->nSize += src.size();
 1071|    880|    }
_ZN12SizeComputer4seekEm:
 1075|    536|    {
 1076|    536|        this->nSize += _nSize;
 1077|    536|    }
_ZNK12SizeComputer4sizeEv:
 1086|    536|    size_t size() const {
 1087|    536|        return nSize;
 1088|    536|    }
_Z16WriteCompactSizeR12SizeComputerm:
 1098|    536|{
 1099|    536|    s.seek(GetSizeOfCompactSize(nSize));
 1100|    536|}
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERKT_RKT0_:
  151|    536|{
  152|    536|    static_assert(std::is_base_of_v<Out, In>);
  153|    536|    return x;
  154|    536|}
_ZN12SizeComputerC2Ev:
 1066|    536|    SizeComputer() = default;
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERT_RT0_:
  145|    591|{
  146|    591|    static_assert(std::is_base_of_v<Out, In>);
  147|    591|    return x;
  148|    591|}
_Z14ser_readdata32I10DataStreamEjRT_:
  102|    128|{
  103|    128|    uint32_t obj;
  104|    128|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|    128|    return le32toh_internal(obj);
  106|    128|}
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|    591|{
  341|    591|    uint8_t chSize = ser_readdata8(is);
  342|    591|    uint64_t nSizeRet = 0;
  343|    591|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 243, False: 348]
  ------------------
  344|    243|    {
  345|    243|        nSizeRet = chSize;
  346|    243|    }
  347|    348|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 118, False: 230]
  ------------------
  348|    118|    {
  349|    118|        nSizeRet = ser_readdata16(is);
  350|    118|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 8, False: 110]
  ------------------
  351|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    118|    }
  353|    230|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 128, False: 102]
  ------------------
  354|    128|    {
  355|    128|        nSizeRet = ser_readdata32(is);
  356|    128|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 19, False: 109]
  ------------------
  357|     19|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    128|    }
  359|    102|    else
  360|    102|    {
  361|    102|        nSizeRet = ser_readdata64(is);
  362|    102|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 40, False: 62]
  ------------------
  363|     40|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    102|    }
  365|    524|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 520, False: 4]
  |  Branch (365:24): [True: 77, False: 443]
  ------------------
  366|     77|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     77|    }
  368|    447|    return nSizeRet;
  369|    524|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|    591|{
   85|    591|    uint8_t obj;
   86|    591|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|    591|    return obj;
   88|    591|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|    118|{
   91|    118|    uint16_t obj;
   92|    118|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|    118|    return le16toh_internal(obj);
   94|    118|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|    696|{
  115|    696|    uint64_t obj;
  116|    696|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|    696|    return le64toh_internal(obj);
  118|    696|}
_Z11UnserializeI10DataStreamEvRT_Rl:
  278|    595|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
_Z11UnserializeI10DataStreamR7CScriptQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    591|{
  763|    591|    a.Unserialize(is);
  764|    591|}
_ZN7CScript11UnserializeI10DataStreamEEvRT_:
  228|    591|    {                                                                                               \
  229|    591|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    591|        Unser(s, *this);                                                                            \
  231|    591|    }
_ZN7CScript5UnserI10DataStreamEEvRT_RS_:
  180|    591|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR9prevectorILj28EhjiEEEEvRT_DpOT0_:
 1033|    591|    {
 1034|    591|        ::UnserializeMany(s, args...);
 1035|    591|    }
_Z15UnserializeManyI10DataStreamJR9prevectorILj28EhjiEEEvRT_DpOT0_:
 1001|    591|{
 1002|    591|    (::Unserialize(s, args), ...);
 1003|    591|}
_Z11UnserializeI10DataStreamLj28EhEvRT_R9prevectorIXT0_ET1_jiE:
  823|    591|{
  824|    591|    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|    591|        v.clear();
  827|    591|        unsigned int nSize = ReadCompactSize(is);
  828|    591|        unsigned int i = 0;
  829|    938|        while (i < nSize) {
  ------------------
  |  Branch (829:16): [True: 347, False: 591]
  ------------------
  830|    347|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  831|    347|            v.resize_uninitialized(i + blk);
  832|    347|            is.read(AsWritableBytes(Span{&v[i], blk}));
  833|    347|            i += blk;
  834|    347|        }
  835|       |    } else {
  836|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  837|       |    }
  838|    591|}
_Z11UnserializeI10DataStreamR6CTxOutQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    595|{
  763|    595|    a.Unserialize(is);
  764|    595|}
_ZN6CTxOut11UnserializeI10DataStreamEEvRT_:
  228|    595|    {                                                                                               \
  229|    595|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    595|        Unser(s, *this);                                                                            \
  231|    595|    }
_ZN6CTxOut5UnserI10DataStreamEEvRT_RS_:
  180|    595|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJRlR7CScriptEEEvRT_DpOT0_:
 1033|    595|    {
 1034|    595|        ::UnserializeMany(s, args...);
 1035|    595|    }
_Z15UnserializeManyI10DataStreamJRlR7CScriptEEvRT_DpOT0_:
 1001|    595|{
 1002|    595|    (::Unserialize(s, args), ...);
 1003|    595|}
_Z15ser_writedata64I12SizeComputerEvRT_m:
   79|    536|{
   80|    536|    obj = htole64_internal(obj);
   81|    536|    s.write(AsBytes(Span{&obj, 1}));
   82|    536|}
_Z9SerializeI12SizeComputer6CTxOutQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|    536|{
  754|    536|    a.Serialize(os);
  755|    536|}
_ZNK6CTxOut9SerializeI12SizeComputerEEvRT_:
  222|    536|    {                                                                                               \
  223|    536|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|    536|        Ser(s, *this);                                                                              \
  225|    536|    }                                                                                               \
_ZN6CTxOut3SerI12SizeComputerEEvRT_RKS_:
  178|    536|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJl7CScriptEEEvRT_DpRKT0_:
 1013|    536|    {
 1014|    536|        ::SerializeMany(s, args...);
 1015|    536|    }
_Z13SerializeManyI12SizeComputerJl7CScriptEEvRT_DpRKT0_:
  995|    536|{
  996|    536|    (::Serialize(s, args), ...);
  997|    536|}
_Z9SerializeI12SizeComputerEvRT_l:
  263|    536|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_Z9SerializeI12SizeComputer7CScriptQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|    536|{
  754|    536|    a.Serialize(os);
  755|    536|}
_ZNK7CScript9SerializeI12SizeComputerEEvRT_:
  222|    536|    {                                                                                               \
  223|    536|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|    536|        Ser(s, *this);                                                                              \
  225|    536|    }                                                                                               \
_ZN7CScript3SerI12SizeComputerEEvRT_RKS_:
  178|    536|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12SizeComputerJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|    536|    {
 1014|    536|        ::SerializeMany(s, args...);
 1015|    536|    }
_Z13SerializeManyI12SizeComputerJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|    536|{
  996|    536|    (::Serialize(s, args), ...);
  997|    536|}
_Z9SerializeI12SizeComputerLj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|    536|{
  812|    536|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|    536|        WriteCompactSize(os, v.size());
  814|    536|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 344, False: 192]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|    536|}
_Z16GetSerializeSizeI6CTxOutEmRKT_:
 1104|    536|{
 1105|    536|    return (SizeComputer() << t).size();
 1106|    536|}
_ZN12SizeComputerlsI6CTxOutEERS_RKT_:
 1081|    536|    {
 1082|    536|        ::Serialize(*this, obj);
 1083|    536|        return (*this);
 1084|    536|    }

_ZNK4SpanIKSt4byteE4sizeEv:
  187|  1.47k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  1.19k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|    322|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|    322|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|    322|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4dataEv:
  174|    938|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|    939|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  5.51k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  1.75k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE10size_bytesEv:
  188|    939|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|    939|{
  260|    939|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|    939|}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  1.47k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZNK4SpanIjE4dataEv:
  174|    128|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|    128|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZNK4SpanIhE10size_bytesEv:
  188|    938|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZNK4SpanItE4dataEv:
  174|    118|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|    118|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZNK4SpanImE4dataEv:
  174|  1.23k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|  1.23k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|    536|{
  260|    536|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|    536|}
_Z12MakeByteSpanIRK9prevectorILj28EhjiEE4SpanIKSt4byteEOT_:
  270|    344|{
  271|    344|    return AsBytes(Span{std::forward<V>(v)});
  272|    344|}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  1.88k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|    938|{
  265|    938|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    938|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|    938|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|    118|{
  265|    118|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    118|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|    118|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|    128|{
  265|    128|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    128|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|    128|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|    696|{
  265|    696|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    696|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|  1.23k|    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|    595|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I9prevectorILj28EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|    344|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7CScriptEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|    322|        : m_data(other.data()), m_size(other.size()){}

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

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

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

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

_Z18tx_out_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   14|    595|{
   15|    595|    DataStream ds{buffer};
   16|    595|    CTxOut tx_out;
   17|    595|    try {
   18|    595|        ds >> tx_out;
   19|    595|    } catch (const std::ios_base::failure&) {
   20|    273|        return;
   21|    273|    }
   22|       |
   23|    322|    const CFeeRate dust_relay_fee{DUST_RELAY_TX_FEE};
   24|    322|    (void)GetDustThreshold(tx_out, dust_relay_fee);
   25|    322|    (void)IsDust(tx_out, dust_relay_fee);
   26|    322|    (void)RecursiveDynamicUsage(tx_out);
   27|       |
   28|    322|    (void)tx_out.ToString();
   29|    322|    (void)tx_out.IsNull();
   30|    322|    tx_out.SetNull();
   31|    322|    assert(tx_out.IsNull());
   32|    322|}

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

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

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

_Z16AdditionOverflowImEbT_S0_:
   16|  1.88k|{
   17|  1.88k|    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|  1.88k|    return std::numeric_limits<T>::max() - i < j;
   23|  1.88k|}
_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   27|  1.88k|{
   28|  1.88k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 0, False: 1.88k]
  ------------------
   29|      0|        return std::nullopt;
   30|      0|    }
   31|  1.88k|    return i + j;
   32|  1.88k|}

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