_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEC2Ev:
   68|  1.41k|    DepGraph() noexcept = default;
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE7TxCountEv:
  118|  4.93k|    auto TxCount() const noexcept { return m_used.Count(); }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE9PositionsEv:
  114|  8.26k|    const SetType& Positions() const noexcept { return m_used; }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE9AncestorsEj:
  124|   252k|    const SetType& Ancestors(ClusterIndex i) const noexcept { return entries[i].ancestors; }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE14AddTransactionERK7FeeFrac:
  134|  4.04k|    {
  135|  4.04k|        static constexpr auto ALL_POSITIONS = SetType::Fill(SetType::Size());
  136|  4.04k|        auto available = ALL_POSITIONS - m_used;
  137|  4.04k|        Assume(available.Any());
  ------------------
  |  |   97|  4.04k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  138|  4.04k|        ClusterIndex new_idx = available.First();
  139|  4.04k|        if (new_idx == entries.size()) {
  ------------------
  |  Branch (139:13): [True: 4.04k, False: 0]
  ------------------
  140|  4.04k|            entries.emplace_back(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
  141|  4.04k|        } else {
  142|      0|            entries[new_idx] = Entry(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
  143|      0|        }
  144|  4.04k|        m_used.Set(new_idx);
  145|  4.04k|        return new_idx;
  146|  4.04k|    }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE5EntryC2ERK7FeeFracRKS3_SA_:
   46|  4.04k|        Entry(const FeeFrac& f, const SetType& a, const SetType& d) noexcept : feerate(f), ancestors(a), descendants(d) {}
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE15AddDependenciesERKS3_j:
  178|  8.08k|    {
  179|  8.08k|        Assume(m_used[child]);
  ------------------
  |  |   97|  8.08k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  180|  8.08k|        Assume(parents.IsSubsetOf(m_used));
  ------------------
  |  |   97|  8.08k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  181|       |        // Compute the ancestors of parents that are not already ancestors of child.
  182|  8.08k|        SetType par_anc;
  183|  8.08k|        for (auto par : parents - Ancestors(child)) {
  ------------------
  |  Branch (183:23): [True: 3.44k, False: 8.08k]
  ------------------
  184|  3.44k|            par_anc |= Ancestors(par);
  185|  3.44k|        }
  186|  8.08k|        par_anc -= Ancestors(child);
  187|       |        // Bail out if there are no such ancestors.
  188|  8.08k|        if (par_anc.None()) return;
  ------------------
  |  Branch (188:13): [True: 7.13k, False: 952]
  ------------------
  189|       |        // To each such ancestor, add as descendants the descendants of the child.
  190|    952|        const auto& chl_des = entries[child].descendants;
  191|  4.50k|        for (auto anc_of_par : par_anc) {
  ------------------
  |  Branch (191:30): [True: 4.50k, False: 952]
  ------------------
  192|  4.50k|            entries[anc_of_par].descendants |= chl_des;
  193|  4.50k|        }
  194|       |        // To each descendant of the child, add those ancestors.
  195|    952|        for (auto dec_of_chl : Descendants(child)) {
  ------------------
  |  Branch (195:30): [True: 952, False: 952]
  ------------------
  196|    952|            entries[dec_of_chl].ancestors |= par_anc;
  197|    952|        }
  198|    952|    }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEaSEOS4_:
   72|    705|    DepGraph& operator=(DepGraph&&) noexcept = default;
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEC2ERKS4_4SpanIKjEj:
   89|    705|    DepGraph(const DepGraph<SetType>& depgraph, Span<const ClusterIndex> mapping, ClusterIndex pos_range) noexcept : entries(pos_range)
   90|    705|    {
   91|    705|        Assume(mapping.size() == depgraph.PositionRange());
  ------------------
  |  |   97|    705|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   92|    705|        Assume((pos_range == 0) == (depgraph.TxCount() == 0));
  ------------------
  |  |   97|    705|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   93|  4.04k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (93:29): [True: 4.04k, False: 705]
  ------------------
   94|  4.04k|            auto new_idx = mapping[i];
   95|  4.04k|            Assume(new_idx < pos_range);
  ------------------
  |  |   97|  4.04k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   96|       |            // Add transaction.
   97|  4.04k|            entries[new_idx].ancestors = SetType::Singleton(new_idx);
   98|  4.04k|            entries[new_idx].descendants = SetType::Singleton(new_idx);
   99|  4.04k|            m_used.Set(new_idx);
  100|       |            // Fill in fee and size.
  101|  4.04k|            entries[new_idx].feerate = depgraph.entries[i].feerate;
  102|  4.04k|        }
  103|  4.04k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (103:29): [True: 4.04k, False: 705]
  ------------------
  104|       |            // Fill in dependencies by mapping direct parents.
  105|  4.04k|            SetType parents;
  106|  4.04k|            for (auto j : depgraph.GetReducedParents(i)) parents.Set(mapping[j]);
  ------------------
  |  Branch (106:25): [True: 1.19k, False: 4.04k]
  ------------------
  107|  4.04k|            AddDependencies(parents, mapping[i]);
  108|  4.04k|        }
  109|       |        // Verify that the provided pos_range was correct (no unused positions at the end).
  110|    705|        Assume(m_used.None() ? (pos_range == 0) : (pos_range == m_used.Last() + 1));
  ------------------
  |  |   97|  1.41k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:51): [True: 235, False: 470]
  |  |  ------------------
  ------------------
  111|    705|    }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE5EntryC2Ev:
   44|  12.3k|        Entry() noexcept = default;
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE22FindConnectedComponentERKS3_:
  266|  7.32k|    {
  267|  7.32k|        if (todo.None()) return todo;
  ------------------
  |  Branch (267:13): [True: 705, False: 6.62k]
  ------------------
  268|  6.62k|        auto to_add = SetType::Singleton(todo.First());
  269|  6.62k|        SetType ret;
  270|  15.3k|        do {
  271|  15.3k|            SetType old = ret;
  272|  22.5k|            for (auto add : to_add) {
  ------------------
  |  Branch (272:27): [True: 22.5k, False: 15.3k]
  ------------------
  273|  22.5k|                ret |= Descendants(add);
  274|  22.5k|                ret |= Ancestors(add);
  275|  22.5k|            }
  276|  15.3k|            ret &= todo;
  277|  15.3k|            to_add = ret - old;
  278|  15.3k|        } while (to_add.Any());
  ------------------
  |  Branch (278:18): [True: 8.71k, False: 6.62k]
  ------------------
  279|  6.62k|        return ret;
  280|  7.32k|    }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE11IsConnectedEv:
  295|    470|    bool IsConnected() const noexcept { return IsConnected(m_used); }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE11IsConnectedERKS3_:
  287|  3.54k|    {
  288|  3.54k|        return FindConnectedComponent(subset) == subset;
  289|  3.54k|    }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE11DescendantsEj:
  126|   226k|    const SetType& Descendants(ClusterIndex i) const noexcept { return entries[i].descendants; }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE13PositionRangeEv:
  116|    705|    ClusterIndex PositionRange() const noexcept { return entries.size(); }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE17GetReducedParentsEj:
  209|  4.04k|    {
  210|  4.04k|        SetType parents = Ancestors(i);
  211|  4.04k|        parents.Reset(i);
  212|  4.04k|        for (auto parent : parents) {
  ------------------
  |  Branch (212:26): [True: 2.25k, False: 4.04k]
  ------------------
  213|  2.25k|            if (parents[parent]) {
  ------------------
  |  Branch (213:17): [True: 2.25k, False: 0]
  ------------------
  214|  2.25k|                parents -= Ancestors(parent);
  215|  2.25k|                parents.Set(parent);
  216|  2.25k|            }
  217|  2.25k|        }
  218|  4.04k|        return parents;
  219|  4.04k|    }

_ZN15CheckVarIntModeIL10VarIntMode0EmEC2Ev:
  410|  12.5k|    {
  411|  12.5k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|  12.5k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|  12.5k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmEC2ES3_:
  481|  12.5k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN15CheckVarIntModeIL10VarIntMode1EiEC2Ev:
  410|  4.55k|    {
  411|  4.55k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|  4.55k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|  4.55k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiEC2ES3_:
  481|  4.55k|    explicit Wrapper(T obj) : m_object(obj) {}
cluster_linearize.cpp:_ZL5UsingIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE7WrapperIT_RT0_EOSB_:
  497|    705|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize.cpp:_ZN7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEC2ES8_:
  481|    705|    explicit Wrapper(T obj) : m_object(obj) {}
cluster_linearize.cpp:_Z11UnserializeI10SpanReaderR7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|    705|{
  763|    705|    a.Unserialize(is);
  764|    705|}
cluster_linearize.cpp:_ZN7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE11UnserializeI10SpanReaderEEvRT_:
  483|    705|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_Z11UnserializeI10SpanReaderR7WrapperI15VarIntFormatterIL10VarIntMode1EERiEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  4.55k|{
  763|  4.55k|    a.Unserialize(is);
  764|  4.55k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiE11UnserializeI10SpanReaderEEvRT_:
  483|  4.55k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode1EE5UnserI10SpanReaderiEEvRT_RT0_:
  514|  4.55k|    {
  515|  4.55k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  4.55k|    }
_Z10ReadVarIntI10SpanReaderL10VarIntMode1EiET1_RT_:
  453|  4.55k|{
  454|  4.55k|    CheckVarIntMode<Mode, I>();
  455|  4.55k|    I n = 0;
  456|  5.01k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  5.01k|        unsigned char chData = ser_readdata8(is);
  458|  5.01k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 7, False: 5.00k]
  ------------------
  459|      7|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|      7|        }
  461|  5.00k|        n = (n << 7) | (chData & 0x7F);
  462|  5.00k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 466, False: 4.54k]
  ------------------
  463|    466|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 1, False: 465]
  ------------------
  464|      1|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|      1|            }
  466|    465|            n++;
  467|  4.54k|        } else {
  468|  4.54k|            return n;
  469|  4.54k|        }
  470|  5.00k|    }
  471|  4.55k|}
_Z13ser_readdata8I10SpanReaderEhRT_:
   84|  20.6k|{
   85|  20.6k|    uint8_t obj;
   86|  20.6k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  20.6k|    return obj;
   88|  20.6k|}
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode1EERiE7WrapperIT_RT0_EOS6_:
  497|  4.55k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EERmE7WrapperIT_RT0_EOS6_:
  497|  12.5k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10SpanReaderR7WrapperI15VarIntFormatterIL10VarIntMode0EERmEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  12.5k|{
  763|  12.5k|    a.Unserialize(is);
  764|  12.5k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmE11UnserializeI10SpanReaderEEvRT_:
  483|  12.5k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode0EE5UnserI10SpanReadermEEvRT_RT0_:
  514|  12.5k|    {
  515|  12.5k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  12.5k|    }
_Z10ReadVarIntI10SpanReaderL10VarIntMode0EmET1_RT_:
  453|  12.5k|{
  454|  12.5k|    CheckVarIntMode<Mode, I>();
  455|  12.5k|    I n = 0;
  456|  15.6k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  15.6k|        unsigned char chData = ser_readdata8(is);
  458|  15.6k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 86, False: 15.5k]
  ------------------
  459|     86|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|     86|        }
  461|  15.5k|        n = (n << 7) | (chData & 0x7F);
  462|  15.5k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 3.14k, False: 12.4k]
  ------------------
  463|  3.14k|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 34, False: 3.11k]
  ------------------
  464|     34|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|     34|            }
  466|  3.11k|            n++;
  467|  12.4k|        } else {
  468|  12.4k|            return n;
  469|  12.4k|        }
  470|  15.5k|    }
  471|  12.5k|}

_ZNK4SpanIKhE4sizeEv:
  187|  20.6k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|  20.6k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  17.2k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  75.8k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  17.2k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEm:
  196|  17.2k|    {
  197|  17.2k|        ASSERT_IF_DEBUG(size() >= offset);
  198|  17.2k|        return Span<C>(m_data + offset, m_size - offset);
  199|  17.2k|    }
_ZNK4SpanIhE10size_bytesEv:
  188|  20.6k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  17.2k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  20.6k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  20.6k|{
  265|  20.6k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  20.6k|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  20.6k|    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|    705|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKjEC2INSt3__16vectorIjNS3_9allocatorIjEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|    705|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKjE4sizeEv:
  187|    705|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKjEixEm:
  191|  9.27k|    {
  192|  9.27k|        ASSERT_IF_DEBUG(size() > pos);
  193|  9.27k|        return m_data[pos];
  194|  9.27k|    }

_ZN10SpanReaderC2E4SpanIKhE:
  109|    705|    explicit SpanReader(Span<const unsigned char> data) : m_data{data} {}
_ZN10SpanReader4readE4SpanISt4byteE:
  122|  20.6k|    {
  123|  20.6k|        if (dst.size() == 0) {
  ------------------
  |  Branch (123:13): [True: 0, False: 20.6k]
  ------------------
  124|      0|            return;
  125|      0|        }
  126|       |
  127|       |        // Read from the beginning of the buffer
  128|  20.6k|        if (dst.size() > m_data.size()) {
  ------------------
  |  Branch (128:13): [True: 3.40k, False: 17.2k]
  ------------------
  129|  3.40k|            throw std::ios_base::failure("SpanReader::read(): end of data");
  130|  3.40k|        }
  131|  17.2k|        memcpy(dst.data(), m_data.data(), dst.size());
  132|  17.2k|        m_data = m_data.subspan(dst.size());
  133|  17.2k|    }
cluster_linearize.cpp:_ZN10SpanReaderrsI7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEEERS_OT_:
  113|    705|    {
  114|    705|        ::Unserialize(*this, obj);
  115|    705|        return (*this);
  116|    705|    }
_ZN10SpanReaderrsI7WrapperI15VarIntFormatterIL10VarIntMode1EERiEEERS_OT_:
  113|  4.55k|    {
  114|  4.55k|        ::Unserialize(*this, obj);
  115|  4.55k|        return (*this);
  116|  4.55k|    }
_ZN10SpanReaderrsI7WrapperI15VarIntFormatterIL10VarIntMode0EERmEEERS_OT_:
  113|  12.5k|    {
  114|  12.5k|        ::Unserialize(*this, obj);
  115|  12.5k|        return (*this);
  116|  12.5k|    }

_Z33clusterlin_components_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  414|    705|{
  415|       |    // Verify the behavior of DepGraphs's FindConnectedComponent and IsConnected functions.
  416|       |
  417|       |    // Construct a depgraph.
  418|    705|    SpanReader reader(buffer);
  419|    705|    DepGraph<TestBitSet> depgraph;
  420|    705|    try {
  421|    705|        reader >> Using<DepGraphFormatter>(depgraph);
  422|    705|    } catch (const std::ios_base::failure&) {}
  423|       |
  424|    705|    TestBitSet todo = depgraph.Positions();
  425|  3.78k|    while (todo.Any()) {
  ------------------
  |  Branch (425:12): [True: 3.07k, False: 705]
  ------------------
  426|       |        // Find a connected component inside todo.
  427|  3.07k|        auto component = depgraph.FindConnectedComponent(todo);
  428|       |
  429|       |        // The component must be a subset of todo and non-empty.
  430|  3.07k|        assert(component.IsSubsetOf(todo));
  431|  3.07k|        assert(component.Any());
  432|       |
  433|       |        // If todo is the entire graph, and the entire graph is connected, then the component must
  434|       |        // be the entire graph.
  435|  3.07k|        if (todo == depgraph.Positions()) {
  ------------------
  |  Branch (435:13): [True: 470, False: 2.60k]
  ------------------
  436|    470|            assert((component == todo) == depgraph.IsConnected());
  437|    470|        }
  438|       |
  439|       |        // If subset is connected, then component must match subset.
  440|  3.07k|        assert((component == todo) == depgraph.IsConnected(todo));
  441|       |
  442|       |        // The component cannot have any ancestors or descendants outside of component but in todo.
  443|  7.17k|        for (auto i : component) {
  ------------------
  |  Branch (443:21): [True: 7.17k, False: 3.07k]
  ------------------
  444|  7.17k|            assert((depgraph.Ancestors(i) & todo).IsSubsetOf(component));
  445|  7.17k|            assert((depgraph.Descendants(i) & todo).IsSubsetOf(component));
  446|  7.17k|        }
  447|       |
  448|       |        // Starting from any component element, we must be able to reach every element.
  449|  7.17k|        for (auto i : component) {
  ------------------
  |  Branch (449:21): [True: 7.17k, False: 3.07k]
  ------------------
  450|       |            // Start with just i as reachable.
  451|  7.17k|            TestBitSet reachable = TestBitSet::Singleton(i);
  452|       |            // Add in-todo descendants and ancestors to reachable until it does not change anymore.
  453|  25.0k|            while (true) {
  ------------------
  |  Branch (453:20): [Folded - Ignored]
  ------------------
  454|  25.0k|                TestBitSet new_reachable = reachable;
  455|   195k|                for (auto j : new_reachable) {
  ------------------
  |  Branch (455:29): [True: 195k, False: 25.0k]
  ------------------
  456|   195k|                    new_reachable |= depgraph.Ancestors(j) & todo;
  457|   195k|                    new_reachable |= depgraph.Descendants(j) & todo;
  458|   195k|                }
  459|  25.0k|                if (new_reachable == reachable) break;
  ------------------
  |  Branch (459:21): [True: 7.17k, False: 17.8k]
  ------------------
  460|  17.8k|                reachable = new_reachable;
  461|  17.8k|            }
  462|       |            // Verify that the result is the entire component.
  463|  7.17k|            assert(component == reachable);
  464|  7.17k|        }
  465|       |
  466|       |        // Construct an arbitrary subset of todo.
  467|  3.07k|        uint64_t subset_bits{0};
  468|  3.07k|        try {
  469|  3.07k|            reader >> VARINT(subset_bits);
  ------------------
  |  |  500|  3.07k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  470|  3.07k|        } catch (const std::ios_base::failure&) {}
  471|  3.07k|        TestBitSet subset;
  472|  53.1k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (472:29): [True: 53.1k, False: 3.07k]
  ------------------
  473|  53.1k|            if (todo[i]) {
  ------------------
  |  Branch (473:17): [True: 28.3k, False: 24.7k]
  ------------------
  474|  28.3k|                if (subset_bits & 1) subset.Set(i);
  ------------------
  |  Branch (474:21): [True: 1.11k, False: 27.2k]
  ------------------
  475|  28.3k|                subset_bits >>= 1;
  476|  28.3k|            }
  477|  53.1k|        }
  478|       |        // Which must be non-empty.
  479|  3.07k|        if (subset.None()) subset = TestBitSet::Singleton(todo.First());
  ------------------
  |  Branch (479:13): [True: 2.92k, False: 149]
  ------------------
  480|       |        // Remove it from todo.
  481|  3.07k|        todo -= subset;
  482|  3.07k|    }
  483|       |
  484|       |    // No components can be found in an empty subset.
  485|    705|    assert(depgraph.FindConnectedComponent(todo).None());
  486|    705|}

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

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

cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter5UnserI10SpanReaderN13bitset_detail9IntBitSetIjEEEEvRT_RN17cluster_linearize8DepGraphIT0_EE:
  200|    705|    {
  201|       |        /** The dependency graph which we deserialize into first, with transactions in
  202|       |         *  topological serialization order, not original cluster order. */
  203|    705|        DepGraph<SetType> topo_depgraph;
  204|       |        /** Mapping from serialization order to cluster order, used later to reconstruct the
  205|       |         *  cluster order. */
  206|    705|        std::vector<ClusterIndex> reordering;
  207|       |        /** How big the entries vector in the reconstructed depgraph will be (including holes). */
  208|    705|        ClusterIndex total_size{0};
  209|       |
  210|       |        // Read transactions in topological order.
  211|  4.55k|        while (true) {
  ------------------
  |  Branch (211:16): [Folded - Ignored]
  ------------------
  212|  4.55k|            FeeFrac new_feerate; //!< The new transaction's fee and size.
  213|  4.55k|            SetType new_ancestors; //!< The new transaction's ancestors (excluding itself).
  214|  4.55k|            uint64_t diff{0}; //!< How many potential parents/insertions we have to skip.
  215|  4.55k|            bool read_error{false};
  216|  4.55k|            try {
  217|       |                // Read size. Size 0 signifies the end of the DepGraph.
  218|  4.55k|                int32_t size;
  219|  4.55k|                s >> VARINT_MODE(size, VarIntMode::NONNEGATIVE_SIGNED);
  ------------------
  |  |  499|  4.55k|#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
  ------------------
  220|  4.55k|                size &= 0x3FFFFF; // Enough for size up to 4M.
  221|  4.55k|                static_assert(0x3FFFFF >= 4000000);
  222|  4.55k|                if (size == 0 || topo_depgraph.TxCount() == SetType::Size()) break;
  ------------------
  |  Branch (222:21): [True: 325, False: 4.22k]
  |  Branch (222:34): [True: 2, False: 4.22k]
  ------------------
  223|       |                // Read fee, encoded as an unsigned varint (odd=negative, even=non-negative).
  224|  4.46k|                uint64_t coded_fee;
  225|  4.46k|                s >> VARINT(coded_fee);
  ------------------
  |  |  500|  4.46k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  226|  4.46k|                coded_fee &= 0xFFFFFFFFFFFFF; // Enough for fee between -21M...21M BTC.
  227|  4.46k|                static_assert(0xFFFFFFFFFFFFF > uint64_t{2} * 21000000 * 100000000);
  228|  4.46k|                new_feerate = {UnsignedToSigned(coded_fee), size};
  229|       |                // Read dependency information.
  230|  4.46k|                auto topo_idx = reordering.size();
  231|  4.46k|                s >> VARINT(diff);
  ------------------
  |  |  500|  4.46k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  232|  38.6k|                for (ClusterIndex dep_dist = 0; dep_dist < topo_idx; ++dep_dist) {
  ------------------
  |  Branch (232:49): [True: 34.1k, False: 4.46k]
  ------------------
  233|       |                    /** Which topo_depgraph index we are currently considering as parent of topo_idx. */
  234|  34.1k|                    ClusterIndex dep_topo_idx = topo_idx - 1 - dep_dist;
  235|       |                    // Ignore transactions which are already known ancestors of topo_idx.
  236|  34.1k|                    if (new_ancestors[dep_topo_idx]) continue;
  ------------------
  |  Branch (236:25): [True: 938, False: 33.2k]
  ------------------
  237|  33.2k|                    if (diff == 0) {
  ------------------
  |  Branch (237:25): [True: 1.19k, False: 32.0k]
  ------------------
  238|       |                        // When the skip counter has reached 0, add an actual dependency.
  239|  1.19k|                        new_ancestors |= topo_depgraph.Ancestors(dep_topo_idx);
  240|       |                        // And read the number of skips after it.
  241|  1.19k|                        s >> VARINT(diff);
  ------------------
  |  |  500|  1.19k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  242|  32.0k|                    } else {
  243|       |                        // Otherwise, dep_topo_idx is not a parent. Decrement and continue.
  244|  32.0k|                        --diff;
  245|  32.0k|                    }
  246|  33.2k|                }
  247|  4.46k|            } catch (const std::ios_base::failure&) {
  248|       |                // Continue even if a read error was encountered.
  249|    624|                read_error = true;
  250|    624|            }
  251|       |            // Construct a new transaction whenever we made it past the new_feerate construction.
  252|  4.46k|            if (new_feerate.IsEmpty()) break;
  ------------------
  |  Branch (252:17): [True: 426, False: 4.04k]
  ------------------
  253|  4.04k|            assert(reordering.size() < SetType::Size());
  254|  4.04k|            auto topo_idx = topo_depgraph.AddTransaction(new_feerate);
  255|  4.04k|            topo_depgraph.AddDependencies(new_ancestors, topo_idx);
  256|  4.04k|            if (total_size < SetType::Size()) {
  ------------------
  |  Branch (256:17): [True: 1.47k, False: 2.57k]
  ------------------
  257|       |                // Normal case.
  258|  1.47k|                diff %= SetType::Size();
  259|  1.47k|                if (diff <= total_size) {
  ------------------
  |  Branch (259:21): [True: 856, False: 615]
  ------------------
  260|       |                    // Insert the new transaction at distance diff back from the end.
  261|  3.86k|                    for (auto& pos : reordering) {
  ------------------
  |  Branch (261:36): [True: 3.86k, False: 856]
  ------------------
  262|  3.86k|                        pos += (pos >= total_size - diff);
  263|  3.86k|                    }
  264|    856|                    reordering.push_back(total_size++ - diff);
  265|    856|                } else {
  266|       |                    // Append diff - total_size holes at the end, plus the new transaction.
  267|    615|                    total_size = diff;
  268|    615|                    reordering.push_back(total_size++);
  269|    615|                }
  270|  2.57k|            } else {
  271|       |                // In case total_size == SetType::Size, it is not possible to insert the new
  272|       |                // transaction without exceeding SetType's size. Instead, interpret diff as an
  273|       |                // index into the holes, and overwrite a position there. This branch is never used
  274|       |                // when deserializing the output of the serializer, but gives meaning to otherwise
  275|       |                // invalid input.
  276|  2.57k|                diff %= (SetType::Size() - reordering.size());
  277|  2.57k|                SetType holes = SetType::Fill(SetType::Size());
  278|  30.8k|                for (auto pos : reordering) holes.Reset(pos);
  ------------------
  |  Branch (278:31): [True: 30.8k, False: 2.57k]
  ------------------
  279|  38.4k|                for (auto pos : holes) {
  ------------------
  |  Branch (279:31): [True: 38.4k, False: 0]
  ------------------
  280|  38.4k|                    if (diff == 0) {
  ------------------
  |  Branch (280:25): [True: 2.57k, False: 35.8k]
  ------------------
  281|  2.57k|                        reordering.push_back(pos);
  282|  2.57k|                        break;
  283|  2.57k|                    }
  284|  35.8k|                    --diff;
  285|  35.8k|                }
  286|  2.57k|            }
  287|       |            // Stop if a read error was encountered during deserialization.
  288|  4.04k|            if (read_error) break;
  ------------------
  |  Branch (288:17): [True: 198, False: 3.84k]
  ------------------
  289|  4.04k|        }
  290|       |
  291|       |        // Construct the original cluster order depgraph.
  292|    705|        depgraph = DepGraph(topo_depgraph, reordering, total_size);
  293|    705|    }
cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter16UnsignedToSignedEm:
  125|  4.04k|    {
  126|  4.04k|        if (x & 1) {
  ------------------
  |  Branch (126:13): [True: 2.47k, False: 1.57k]
  ------------------
  127|  2.47k|            return -int64_t(x / 2) - 1;
  128|  2.47k|        } else {
  129|  1.57k|            return int64_t(x / 2);
  130|  1.57k|        }
  131|  4.04k|    }

_ZN13bitset_detail9IntBitSetIjE4SizeEv:
  177|  18.9k|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail9IntBitSetIjEixEj:
  170|  97.6k|    {
  171|  97.6k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|  97.6k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  172|  97.6k|        return (m_val >> pos) & 1U;
  173|  97.6k|    }
_ZN13bitset_detail9IntBitSetIjE3SetEj:
  152|  12.6k|    {
  153|  12.6k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|  12.6k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  154|  12.6k|        m_val |= I{1U} << pos;
  155|  12.6k|    }
_ZN13bitset_detail9IntBitSetIjE5ResetEj:
  164|  34.8k|    {
  165|  34.8k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|  34.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  166|  34.8k|        m_val &= ~I(I{1U} << pos);
  167|  34.8k|    }
_ZN13bitset_detail9IntBitSetIjE9SingletonEj:
  138|  32.9k|    {
  139|  32.9k|        Assume(i < MAX_SIZE);
  ------------------
  |  |   97|  32.9k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  140|  32.9k|        return IntBitSet(I(1U) << i);
  141|  32.9k|    }
_ZN13bitset_detail9IntBitSetIjEC2Ej:
   71|   465k|    IntBitSet(I val) noexcept : m_val{val} {}
_ZNK13bitset_detail9IntBitSetIjE3AnyEv:
  181|  26.2k|    constexpr bool Any() const noexcept { return !None(); }
_ZNK13bitset_detail9IntBitSetIjE4NoneEv:
  179|  46.1k|    constexpr bool None() const noexcept { return m_val == 0; }
_ZNK13bitset_detail9IntBitSetIjE5FirstEv:
  188|  13.5k|    {
  189|  13.5k|        Assume(m_val != 0);
  ------------------
  |  |   97|  13.5k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  190|  13.5k|        return std::countr_zero(m_val);
  191|  13.5k|    }
_ZNK13bitset_detail9IntBitSetIjE4LastEv:
  194|    470|    {
  195|    470|        Assume(m_val != 0);
  ------------------
  |  |   97|    470|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  196|    470|        return std::bit_width(m_val) - 1;
  197|    470|    }
_ZNK13bitset_detail9IntBitSetIjE5CountEv:
  175|  4.93k|    constexpr unsigned Count() const noexcept { return PopCount(m_val); }
_ZN13bitset_detail8PopCountIjEEjT_:
   39|  4.93k|{
   40|  4.93k|    static_assert(std::is_integral_v<I> && std::is_unsigned_v<I> && std::numeric_limits<I>::radix == 2);
   41|  4.93k|    constexpr auto BITS = std::numeric_limits<I>::digits;
   42|       |    // Algorithms from https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation.
   43|       |    // These seem to be faster than std::popcount when compiling for non-SSE4 on x86_64.
   44|  4.93k|    if constexpr (BITS <= 32) {
   45|  4.93k|        v -= (v >> 1) & 0x55555555;
   46|  4.93k|        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
   47|  4.93k|        v = (v + (v >> 4)) & 0x0f0f0f0f;
   48|  4.93k|        if constexpr (BITS > 8) v += v >> 8;
   49|  4.93k|        if constexpr (BITS > 16) v += v >> 16;
   50|  4.93k|        return v & 0x3f;
   51|       |    } else {
   52|       |        static_assert(BITS <= 64);
   53|       |        v -= (v >> 1) & 0x5555555555555555;
   54|       |        v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333);
   55|       |        v = (v + (v >> 4)) & 0x0f0f0f0f0f0f0f0f;
   56|       |        return (v * uint64_t{0x0101010101010101}) >> 56;
   57|       |    }
   58|  4.93k|}
_ZN13bitset_detail9IntBitSetIjEC2Ev:
  119|  55.8k|    constexpr IntBitSet() noexcept : m_val{0} {}
_ZN13bitset_detail9IntBitSetIjE4FillEj:
  144|  2.57k|    {
  145|  2.57k|        IntBitSet ret;
  146|  2.57k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |   97|  2.57k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  147|  2.57k|        if (count) ret.m_val = I(~I{0}) >> (MAX_SIZE - count);
  ------------------
  |  Branch (147:13): [True: 2.57k, False: 0]
  ------------------
  148|  2.57k|        return ret;
  149|  2.57k|    }
_ZNK13bitset_detail9IntBitSetIjE5beginEv:
  183|  71.7k|    constexpr Iterator begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail9IntBitSetIjE8IteratorC2Ej:
   86|  71.7k|        constexpr Iterator(I val) noexcept : m_val(val), m_pos(0)
   87|  71.7k|        {
   88|  71.7k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (88:17): [True: 56.9k, False: 14.7k]
  ------------------
   89|  71.7k|        }
_ZN13bitset_detaileqERKNS_9IntBitSetIjE8IteratorERKNS1_11IteratorEndE:
   98|   413k|        {
   99|   413k|            return a.m_val == 0;
  100|   413k|        }
_ZNK13bitset_detail9IntBitSetIjE3endEv:
  185|  71.7k|    constexpr IteratorEnd end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail9IntBitSetIjE8IteratordeEv:
  111|   344k|        {
  112|   344k|            Assume(m_val != 0);
  ------------------
  |  |   97|   344k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  113|   344k|            return m_pos;
  114|   344k|        }
_ZN13bitset_detail9IntBitSetIjE8IteratorppEv:
  103|   341k|        {
  104|   341k|            Assume(m_val != 0);
  ------------------
  |  |   97|   341k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  105|   341k|            m_val &= m_val - I{1U};
  106|   341k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (106:17): [True: 287k, False: 54.3k]
  ------------------
  107|   341k|            return *this;
  108|   341k|        }
_ZN13bitset_detail9IntBitSetIjEoRERKS1_:
  199|   446k|    constexpr IntBitSet& operator|=(const IntBitSet& a) noexcept { m_val |= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetIjEaNERKS1_:
  201|  15.3k|    constexpr IntBitSet& operator&=(const IntBitSet& a) noexcept { m_val &= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetIjEmIERKS1_:
  203|  13.4k|    constexpr IntBitSet& operator-=(const IntBitSet& a) noexcept { m_val &= ~a.m_val; return *this; }
_ZN13bitset_detailanERKNS_9IntBitSetIjEES3_:
  209|   405k|    friend constexpr IntBitSet operator&(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & b.m_val); }
_ZN13bitset_detailmiERKNS_9IntBitSetIjEES3_:
  213|  27.4k|    friend constexpr IntBitSet operator-(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & ~b.m_val); }
_ZNK13bitset_detail9IntBitSetIjE10IsSubsetOfERKS1_:
  221|  25.5k|    constexpr bool IsSubsetOf(const IntBitSet& a) const noexcept { return (m_val & ~a.m_val) == 0; }
_ZN13bitset_detaileqERKNS_9IntBitSetIjEES3_:
  217|  42.4k|    friend constexpr bool operator==(const IntBitSet& a, const IntBitSet& b) noexcept = default;

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

_ZN7FeeFracC2Ev:
   67|  16.9k|    constexpr inline FeeFrac() noexcept : fee{0}, size{0} {}
_ZN7FeeFracC2Eli:
   70|  4.04k|    constexpr inline FeeFrac(int64_t f, int32_t s) noexcept : fee{f}, size{s} {}
_ZNK7FeeFrac7IsEmptyEv:
   76|  4.46k|    bool inline IsEmpty() const noexcept {
   77|  4.46k|        return size == 0;
   78|  4.46k|    }

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