_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEC2Ev:
   68|  6.51k|    DepGraph() noexcept = default;
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE7TxCountEv:
  118|  35.4k|    auto TxCount() const noexcept { return m_used.Count(); }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE9PositionsEv:
  114|  35.1k|    const SetType& Positions() const noexcept { return m_used; }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE9AncestorsEj:
  124|  1.36M|    const SetType& Ancestors(ClusterIndex i) const noexcept { return entries[i].ancestors; }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE14AddTransactionERK7FeeFrac:
  134|  29.8k|    {
  135|  29.8k|        static constexpr auto ALL_POSITIONS = SetType::Fill(SetType::Size());
  136|  29.8k|        auto available = ALL_POSITIONS - m_used;
  137|  29.8k|        Assume(available.Any());
  ------------------
  |  |   97|  29.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  138|  29.8k|        ClusterIndex new_idx = available.First();
  139|  29.8k|        if (new_idx == entries.size()) {
  ------------------
  |  Branch (139:13): [True: 29.8k, False: 0]
  ------------------
  140|  29.8k|            entries.emplace_back(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
  141|  29.8k|        } else {
  142|      0|            entries[new_idx] = Entry(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
  143|      0|        }
  144|  29.8k|        m_used.Set(new_idx);
  145|  29.8k|        return new_idx;
  146|  29.8k|    }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE5EntryC2ERK7FeeFracRKS3_SA_:
   46|  29.8k|        Entry(const FeeFrac& f, const SetType& a, const SetType& d) noexcept : feerate(f), ancestors(a), descendants(d) {}
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE15AddDependenciesERKS3_j:
  178|  59.7k|    {
  179|  59.7k|        Assume(m_used[child]);
  ------------------
  |  |   97|  59.7k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  180|  59.7k|        Assume(parents.IsSubsetOf(m_used));
  ------------------
  |  |   97|  59.7k|#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|  59.7k|        SetType par_anc;
  183|  84.8k|        for (auto par : parents - Ancestors(child)) {
  ------------------
  |  Branch (183:23): [True: 84.8k, False: 59.7k]
  ------------------
  184|  84.8k|            par_anc |= Ancestors(par);
  185|  84.8k|        }
  186|  59.7k|        par_anc -= Ancestors(child);
  187|       |        // Bail out if there are no such ancestors.
  188|  59.7k|        if (par_anc.None()) return;
  ------------------
  |  Branch (188:13): [True: 36.6k, False: 23.0k]
  ------------------
  189|       |        // To each such ancestor, add as descendants the descendants of the child.
  190|  23.0k|        const auto& chl_des = entries[child].descendants;
  191|   135k|        for (auto anc_of_par : par_anc) {
  ------------------
  |  Branch (191:30): [True: 135k, False: 23.0k]
  ------------------
  192|   135k|            entries[anc_of_par].descendants |= chl_des;
  193|   135k|        }
  194|       |        // To each descendant of the child, add those ancestors.
  195|  23.0k|        for (auto dec_of_chl : Descendants(child)) {
  ------------------
  |  Branch (195:30): [True: 23.0k, False: 23.0k]
  ------------------
  196|  23.0k|            entries[dec_of_chl].ancestors |= par_anc;
  197|  23.0k|        }
  198|  23.0k|    }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE7FeeRateEj:
  120|  19.9k|    const FeeFrac& FeeRate(ClusterIndex i) const noexcept { return entries[i].feerate; }
_ZN17cluster_linearizeeqERKNS_8DepGraphIN13bitset_detail9IntBitSetIjEEEES6_:
   58|  2.17k|    {
   59|  2.17k|        if (a.m_used != b.m_used) return false;
  ------------------
  |  Branch (59:13): [True: 0, False: 2.17k]
  ------------------
   60|       |        // Only compare the used positions within the entries vector.
   61|  19.9k|        for (auto idx : a.m_used) {
  ------------------
  |  Branch (61:23): [True: 19.9k, False: 2.17k]
  ------------------
   62|  19.9k|            if (a.entries[idx] != b.entries[idx]) return false;
  ------------------
  |  Branch (62:17): [True: 0, False: 19.9k]
  ------------------
   63|  19.9k|        }
   64|  2.17k|        return true;
   65|  2.17k|    }
_ZN17cluster_linearizeeqERKNS_8DepGraphIN13bitset_detail9IntBitSetIjEEE5EntryES7_:
   41|   398k|        friend bool operator==(const Entry&, const Entry&) noexcept = default;
  ------------------
  |  Branch (41:77): [True: 79.6k, False: 0]
  |  Branch (41:77): [True: 79.6k, False: 0]
  |  Branch (41:77): [True: 79.6k, False: 0]
  ------------------
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEaSEOS4_:
   72|  4.34k|    DepGraph& operator=(DepGraph&&) noexcept = default;
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEC2ERKS4_4SpanIKjEj:
   89|  3.25k|    DepGraph(const DepGraph<SetType>& depgraph, Span<const ClusterIndex> mapping, ClusterIndex pos_range) noexcept : entries(pos_range)
   90|  3.25k|    {
   91|  3.25k|        Assume(mapping.size() == depgraph.PositionRange());
  ------------------
  |  |   97|  3.25k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   92|  3.25k|        Assume((pos_range == 0) == (depgraph.TxCount() == 0));
  ------------------
  |  |   97|  3.25k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   93|  29.8k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (93:29): [True: 29.8k, False: 3.25k]
  ------------------
   94|  29.8k|            auto new_idx = mapping[i];
   95|  29.8k|            Assume(new_idx < pos_range);
  ------------------
  |  |   97|  29.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   96|       |            // Add transaction.
   97|  29.8k|            entries[new_idx].ancestors = SetType::Singleton(new_idx);
   98|  29.8k|            entries[new_idx].descendants = SetType::Singleton(new_idx);
   99|  29.8k|            m_used.Set(new_idx);
  100|       |            // Fill in fee and size.
  101|  29.8k|            entries[new_idx].feerate = depgraph.entries[i].feerate;
  102|  29.8k|        }
  103|  29.8k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (103:29): [True: 29.8k, False: 3.25k]
  ------------------
  104|       |            // Fill in dependencies by mapping direct parents.
  105|  29.8k|            SetType parents;
  106|  29.8k|            for (auto j : depgraph.GetReducedParents(i)) parents.Set(mapping[j]);
  ------------------
  |  Branch (106:25): [True: 17.2k, False: 29.8k]
  ------------------
  107|  29.8k|            AddDependencies(parents, mapping[i]);
  108|  29.8k|        }
  109|       |        // Verify that the provided pos_range was correct (no unused positions at the end).
  110|  3.25k|        Assume(m_used.None() ? (pos_range == 0) : (pos_range == m_used.Last() + 1));
  ------------------
  |  |   97|  6.51k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:51): [True: 729, False: 2.52k]
  |  |  ------------------
  ------------------
  111|  3.25k|    }
_ZN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE5EntryC2Ev:
   44|  60.5k|        Entry() noexcept = default;
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE11DescendantsEj:
  126|   420k|    const SetType& Descendants(ClusterIndex i) const noexcept { return entries[i].descendants; }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE13PositionRangeEv:
  116|  6.51k|    ClusterIndex PositionRange() const noexcept { return entries.size(); }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE18GetReducedChildrenEj:
  230|  19.9k|    {
  231|  19.9k|        SetType children = Descendants(i);
  232|  19.9k|        children.Reset(i);
  233|  45.0k|        for (auto child : children) {
  ------------------
  |  Branch (233:25): [True: 45.0k, False: 19.9k]
  ------------------
  234|  45.0k|            if (children[child]) {
  ------------------
  |  Branch (234:17): [True: 16.6k, False: 28.4k]
  ------------------
  235|  16.6k|                children -= Descendants(child);
  236|  16.6k|                children.Set(child);
  237|  16.6k|            }
  238|  45.0k|        }
  239|  19.9k|        return children;
  240|  19.9k|    }
_ZNK17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEE17GetReducedParentsEj:
  209|  49.7k|    {
  210|  49.7k|        SetType parents = Ancestors(i);
  211|  49.7k|        parents.Reset(i);
  212|   112k|        for (auto parent : parents) {
  ------------------
  |  Branch (212:26): [True: 112k, False: 49.7k]
  ------------------
  213|   112k|            if (parents[parent]) {
  ------------------
  |  Branch (213:17): [True: 97.1k, False: 15.4k]
  ------------------
  214|  97.1k|                parents -= Ancestors(parent);
  215|  97.1k|                parents.Set(parent);
  216|  97.1k|            }
  217|   112k|        }
  218|  49.7k|        return parents;
  219|  49.7k|    }

_ZN15CheckVarIntModeIL10VarIntMode0EmEC2Ev:
  410|   102k|    {
  411|   102k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|   102k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|   102k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmEC2ES3_:
  481|   102k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN15CheckVarIntModeIL10VarIntMode1EiEC2Ev:
  410|  42.5k|    {
  411|  42.5k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|  42.5k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|  42.5k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiEC2ES3_:
  481|  32.5k|    explicit Wrapper(T obj) : m_object(obj) {}
cluster_linearize.cpp:_Z9SerializeI12VectorWriter7WrapperIN12_GLOBAL__N_117DepGraphFormatterERKN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEQ12SerializableIT0_T_EEvRSE_RKSD_:
  753|  1.08k|{
  754|  1.08k|    a.Serialize(os);
  755|  1.08k|}
cluster_linearize.cpp:_ZNK7WrapperIN12_GLOBAL__N_117DepGraphFormatterERKN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE9SerializeI12VectorWriterEEvRT_:
  482|  1.08k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_Z9SerializeI12VectorWriter7WrapperI15VarIntFormatterIL10VarIntMode1EERKiEQ12SerializableIT0_T_EEvRS9_RKS8_:
  753|  9.95k|{
  754|  9.95k|    a.Serialize(os);
  755|  9.95k|}
_ZNK7WrapperI15VarIntFormatterIL10VarIntMode1EERKiE9SerializeI12VectorWriterEEvRT_:
  482|  9.95k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode1EE3SerI12VectorWriteriEEvRT_T0_:
  509|  9.95k|    {
  510|  9.95k|        WriteVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s, v);
  511|  9.95k|    }
_Z11WriteVarIntI12VectorWriterL10VarIntMode1EiEvRT_T1_:
  435|  9.95k|{
  436|  9.95k|    CheckVarIntMode<Mode, I>();
  437|  9.95k|    unsigned char tmp[(sizeof(n)*8+6)/7];
  438|  9.95k|    int len=0;
  439|  10.4k|    while(true) {
  ------------------
  |  Branch (439:11): [Folded - Ignored]
  ------------------
  440|  10.4k|        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
  ------------------
  |  Branch (440:34): [True: 465, False: 9.95k]
  ------------------
  441|  10.4k|        if (n <= 0x7F)
  ------------------
  |  Branch (441:13): [True: 9.95k, False: 465]
  ------------------
  442|  9.95k|            break;
  443|    465|        n = (n >> 7) - 1;
  444|    465|        len++;
  445|    465|    }
  446|  10.4k|    do {
  447|  10.4k|        ser_writedata8(os, tmp[len]);
  448|  10.4k|    } while(len--);
  ------------------
  |  Branch (448:13): [True: 465, False: 9.95k]
  ------------------
  449|  9.95k|}
_Z14ser_writedata8I12VectorWriterEvRT_h:
   55|  39.1k|{
   56|  39.1k|    s.write(AsBytes(Span{&obj, 1}));
   57|  39.1k|}
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode1EERKiE7WrapperIT_RT0_EOS7_:
  497|  9.95k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERKiEC2ES4_:
  481|  9.95k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z9SerializeI12VectorWriter7WrapperI15VarIntFormatterIL10VarIntMode0EERmEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|  25.6k|{
  754|  25.6k|    a.Serialize(os);
  755|  25.6k|}
_ZNK7WrapperI15VarIntFormatterIL10VarIntMode0EERmE9SerializeI12VectorWriterEEvRT_:
  482|  25.6k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode0EE3SerI12VectorWritermEEvRT_T0_:
  509|  25.6k|    {
  510|  25.6k|        WriteVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s, v);
  511|  25.6k|    }
_Z11WriteVarIntI12VectorWriterL10VarIntMode0EmEvRT_T1_:
  435|  25.6k|{
  436|  25.6k|    CheckVarIntMode<Mode, I>();
  437|  25.6k|    unsigned char tmp[(sizeof(n)*8+6)/7];
  438|  25.6k|    int len=0;
  439|  27.5k|    while(true) {
  ------------------
  |  Branch (439:11): [Folded - Ignored]
  ------------------
  440|  27.5k|        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
  ------------------
  |  Branch (440:34): [True: 1.91k, False: 25.6k]
  ------------------
  441|  27.5k|        if (n <= 0x7F)
  ------------------
  |  Branch (441:13): [True: 25.6k, False: 1.91k]
  ------------------
  442|  25.6k|            break;
  443|  1.91k|        n = (n >> 7) - 1;
  444|  1.91k|        len++;
  445|  1.91k|    }
  446|  27.5k|    do {
  447|  27.5k|        ser_writedata8(os, tmp[len]);
  448|  27.5k|    } while(len--);
  ------------------
  |  Branch (448:13): [True: 1.91k, False: 25.6k]
  ------------------
  449|  25.6k|}
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EEmE7WrapperIT_RT0_EOS5_:
  497|  19.9k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z9SerializeI12VectorWriterEvRT_h:
  258|  1.08k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
cluster_linearize.cpp:_ZL5UsingIN12_GLOBAL__N_117DepGraphFormatterERKN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE7WrapperIT_RT0_EOSC_:
  497|  1.08k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize.cpp:_ZN7WrapperIN12_GLOBAL__N_117DepGraphFormatterERKN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEC2ES9_:
  481|  1.08k|    explicit Wrapper(T obj) : m_object(obj) {}
cluster_linearize.cpp:_ZL5UsingIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE7WrapperIT_RT0_EOSB_:
  497|  3.25k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize.cpp:_ZN7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEC2ES8_:
  481|  3.25k|    explicit Wrapper(T obj) : m_object(obj) {}
cluster_linearize.cpp:_Z11UnserializeI10SpanReaderR7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|  3.25k|{
  763|  3.25k|    a.Unserialize(is);
  764|  3.25k|}
cluster_linearize.cpp:_ZN7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEE11UnserializeI10SpanReaderEEvRT_:
  483|  3.25k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_Z11UnserializeI10SpanReaderR7WrapperI15VarIntFormatterIL10VarIntMode1EERiEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  32.5k|{
  763|  32.5k|    a.Unserialize(is);
  764|  32.5k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiE11UnserializeI10SpanReaderEEvRT_:
  483|  32.5k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode1EE5UnserI10SpanReaderiEEvRT_RT0_:
  514|  32.5k|    {
  515|  32.5k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  32.5k|    }
_Z10ReadVarIntI10SpanReaderL10VarIntMode1EiET1_RT_:
  453|  32.5k|{
  454|  32.5k|    CheckVarIntMode<Mode, I>();
  455|  32.5k|    I n = 0;
  456|  34.2k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  34.2k|        unsigned char chData = ser_readdata8(is);
  458|  34.2k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 17, False: 34.2k]
  ------------------
  459|     17|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|     17|        }
  461|  34.2k|        n = (n << 7) | (chData & 0x7F);
  462|  34.2k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 1.73k, False: 32.5k]
  ------------------
  463|  1.73k|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 1, False: 1.73k]
  ------------------
  464|      1|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|      1|            }
  466|  1.73k|            n++;
  467|  32.5k|        } else {
  468|  32.5k|            return n;
  469|  32.5k|        }
  470|  34.2k|    }
  471|  32.5k|}
_Z13ser_readdata8I10SpanReaderEhRT_:
   84|   119k|{
   85|   119k|    uint8_t obj;
   86|   119k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|   119k|    return obj;
   88|   119k|}
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode1EERiE7WrapperIT_RT0_EOS6_:
  497|  32.5k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EERmE7WrapperIT_RT0_EOS6_:
  497|  82.9k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10SpanReaderR7WrapperI15VarIntFormatterIL10VarIntMode0EERmEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  77.2k|{
  763|  77.2k|    a.Unserialize(is);
  764|  77.2k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmE11UnserializeI10SpanReaderEEvRT_:
  483|  77.2k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode0EE5UnserI10SpanReadermEEvRT_RT0_:
  514|  77.2k|    {
  515|  77.2k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  77.2k|    }
_Z10ReadVarIntI10SpanReaderL10VarIntMode0EmET1_RT_:
  453|  77.2k|{
  454|  77.2k|    CheckVarIntMode<Mode, I>();
  455|  77.2k|    I n = 0;
  456|  85.0k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  85.0k|        unsigned char chData = ser_readdata8(is);
  458|  85.0k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 14, False: 85.0k]
  ------------------
  459|     14|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|     14|        }
  461|  85.0k|        n = (n << 7) | (chData & 0x7F);
  462|  85.0k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 7.87k, False: 77.2k]
  ------------------
  463|  7.87k|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 1, False: 7.86k]
  ------------------
  464|      1|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|      1|            }
  466|  7.86k|            n++;
  467|  77.2k|        } else {
  468|  77.2k|            return n;
  469|  77.2k|        }
  470|  85.0k|    }
  471|  77.2k|}

_Z9UCharCastPKSt4byte:
  287|  78.2k|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|   156k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  78.2k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|   121k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|   158k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|   117k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|   473k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5emptyEv:
  189|  2.17k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZNK4SpanISt4byteE4dataEv:
  174|   117k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEm:
  196|   117k|    {
  197|   117k|        ASSERT_IF_DEBUG(size() >= offset);
  198|   117k|        return Span<C>(m_data + offset, m_size - offset);
  199|   117k|    }
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  39.1k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|  2.17k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIhE10size_bytesEv:
  188|   158k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  39.1k|{
  260|  39.1k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  39.1k|}
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|   117k|    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|   119k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|   119k|{
  265|   119k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   119k|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|   158k|    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|  1.08k|        : 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|  3.25k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKjE4sizeEv:
  187|  3.25k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKjEixEm:
  191|  77.0k|    {
  192|  77.0k|        ASSERT_IF_DEBUG(size() > pos);
  193|  77.0k|        return m_data[pos];
  194|  77.0k|    }

_ZN12VectorWriterC2ERNSt3__16vectorIhNS0_9allocatorIhEEEEm:
   60|  1.08k|    VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}
   61|  1.08k|    {
   62|  1.08k|        if(nPos > vchData.size())
  ------------------
  |  Branch (62:12): [True: 0, False: 1.08k]
  ------------------
   63|      0|            vchData.resize(nPos);
   64|  1.08k|    }
_ZN12VectorWriter5writeE4SpanIKSt4byteE:
   75|  39.1k|    {
   76|  39.1k|        assert(nPos <= vchData.size());
   77|  39.1k|        size_t nOverwrite = std::min(src.size(), vchData.size() - nPos);
   78|  39.1k|        if (nOverwrite) {
  ------------------
  |  Branch (78:13): [True: 0, False: 39.1k]
  ------------------
   79|      0|            memcpy(vchData.data() + nPos, src.data(), nOverwrite);
   80|      0|        }
   81|  39.1k|        if (nOverwrite < src.size()) {
  ------------------
  |  Branch (81:13): [True: 39.1k, False: 0]
  ------------------
   82|  39.1k|            vchData.insert(vchData.end(), UCharCast(src.data()) + nOverwrite, UCharCast(src.data() + src.size()));
   83|  39.1k|        }
   84|  39.1k|        nPos += src.size();
   85|  39.1k|    }
_ZN10SpanReaderC2E4SpanIKhE:
  109|  3.25k|    explicit SpanReader(Span<const unsigned char> data) : m_data{data} {}
_ZNK10SpanReader5emptyEv:
  119|  2.17k|    bool empty() const { return m_data.empty(); }
_ZN10SpanReader4readE4SpanISt4byteE:
  122|   119k|    {
  123|   119k|        if (dst.size() == 0) {
  ------------------
  |  Branch (123:13): [True: 0, False: 119k]
  ------------------
  124|      0|            return;
  125|      0|        }
  126|       |
  127|       |        // Read from the beginning of the buffer
  128|   119k|        if (dst.size() > m_data.size()) {
  ------------------
  |  Branch (128:13): [True: 2.12k, False: 117k]
  ------------------
  129|  2.12k|            throw std::ios_base::failure("SpanReader::read(): end of data");
  130|  2.12k|        }
  131|   117k|        memcpy(dst.data(), m_data.data(), dst.size());
  132|   117k|        m_data = m_data.subspan(dst.size());
  133|   117k|    }
cluster_linearize.cpp:_ZN12VectorWriterlsI7WrapperIN12_GLOBAL__N_117DepGraphFormatterERKN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEEERS_RKT_:
   88|  1.08k|    {
   89|  1.08k|        ::Serialize(*this, obj);
   90|  1.08k|        return (*this);
   91|  1.08k|    }
_ZN12VectorWriterlsI7WrapperI15VarIntFormatterIL10VarIntMode1EERKiEEERS_RKT_:
   88|  9.95k|    {
   89|  9.95k|        ::Serialize(*this, obj);
   90|  9.95k|        return (*this);
   91|  9.95k|    }
_ZN12VectorWriterlsI7WrapperI15VarIntFormatterIL10VarIntMode0EERmEEERS_RKT_:
   88|  25.6k|    {
   89|  25.6k|        ::Serialize(*this, obj);
   90|  25.6k|        return (*this);
   91|  25.6k|    }
_ZN12VectorWriterlsIhEERS_RKT_:
   88|  1.08k|    {
   89|  1.08k|        ::Serialize(*this, obj);
   90|  1.08k|        return (*this);
   91|  1.08k|    }
cluster_linearize.cpp:_ZN10SpanReaderrsI7WrapperIN12_GLOBAL__N_117DepGraphFormatterERN17cluster_linearize8DepGraphIN13bitset_detail9IntBitSetIjEEEEEEERS_OT_:
  113|  3.25k|    {
  114|  3.25k|        ::Unserialize(*this, obj);
  115|  3.25k|        return (*this);
  116|  3.25k|    }
_ZN10SpanReaderrsI7WrapperI15VarIntFormatterIL10VarIntMode1EERiEEERS_OT_:
  113|  32.5k|    {
  114|  32.5k|        ::Unserialize(*this, obj);
  115|  32.5k|        return (*this);
  116|  32.5k|    }
_ZN10SpanReaderrsI7WrapperI15VarIntFormatterIL10VarIntMode0EERmEEERS_OT_:
  113|  77.2k|    {
  114|  77.2k|        ::Unserialize(*this, obj);
  115|  77.2k|        return (*this);
  116|  77.2k|    }

_Z45clusterlin_depgraph_serialization_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  398|  1.08k|{
  399|       |    // Verify that any deserialized depgraph is acyclic and roundtrips to an identical depgraph.
  400|       |
  401|       |    // Construct a graph by deserializing.
  402|  1.08k|    SpanReader reader(buffer);
  403|  1.08k|    DepGraph<TestBitSet> depgraph;
  404|  1.08k|    try {
  405|  1.08k|        reader >> Using<DepGraphFormatter>(depgraph);
  406|  1.08k|    } catch (const std::ios_base::failure&) {}
  407|  1.08k|    SanityCheck(depgraph);
  408|       |
  409|       |    // Verify the graph is a DAG.
  410|  1.08k|    assert(IsAcyclic(depgraph));
  411|  1.08k|}

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

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

cluster_linearize.cpp:_ZN12_GLOBAL__N_111SanityCheckIN13bitset_detail9IntBitSetIjEEEEvRKN17cluster_linearize8DepGraphIT_EE:
  299|  1.08k|{
  300|       |    // Verify Positions and PositionRange consistency.
  301|  1.08k|    ClusterIndex num_positions{0};
  302|  1.08k|    ClusterIndex position_range{0};
  303|  9.95k|    for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (303:25): [True: 9.95k, False: 1.08k]
  ------------------
  304|  9.95k|        ++num_positions;
  305|  9.95k|        position_range = i + 1;
  306|  9.95k|    }
  307|  1.08k|    assert(num_positions == depgraph.TxCount());
  308|  1.08k|    assert(position_range == depgraph.PositionRange());
  309|  1.08k|    assert(position_range >= num_positions);
  310|  1.08k|    assert(position_range <= SetType::Size());
  311|       |    // Consistency check between ancestors internally.
  312|  9.95k|    for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (312:25): [True: 9.95k, False: 1.08k]
  ------------------
  313|       |        // Transactions include themselves as ancestors.
  314|  9.95k|        assert(depgraph.Ancestors(i)[i]);
  315|       |        // If a is an ancestor of b, then b's ancestors must include all of a's ancestors.
  316|  32.4k|        for (auto a : depgraph.Ancestors(i)) {
  ------------------
  |  Branch (316:21): [True: 32.4k, False: 9.95k]
  ------------------
  317|  32.4k|            assert(depgraph.Ancestors(i).IsSupersetOf(depgraph.Ancestors(a)));
  318|  32.4k|        }
  319|  9.95k|    }
  320|       |    // Consistency check between ancestors and descendants.
  321|  9.95k|    for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (321:25): [True: 9.95k, False: 1.08k]
  ------------------
  322|   220k|        for (ClusterIndex j : depgraph.Positions()) {
  ------------------
  |  Branch (322:29): [True: 220k, False: 9.95k]
  ------------------
  323|   220k|            assert(depgraph.Ancestors(i)[j] == depgraph.Descendants(j)[i]);
  324|   220k|        }
  325|       |        // No transaction is a parent or child of itself.
  326|  9.95k|        auto parents = depgraph.GetReducedParents(i);
  327|  9.95k|        auto children = depgraph.GetReducedChildren(i);
  328|  9.95k|        assert(!parents[i]);
  329|  9.95k|        assert(!children[i]);
  330|       |        // Parents of a transaction do not have ancestors inside those parents (except itself).
  331|       |        // Note that even the transaction itself may be missing (if it is part of a cycle).
  332|  9.95k|        for (auto parent : parents) {
  ------------------
  |  Branch (332:26): [True: 5.76k, False: 9.95k]
  ------------------
  333|  5.76k|            assert((depgraph.Ancestors(parent) & parents).IsSubsetOf(SetType::Singleton(parent)));
  334|  5.76k|        }
  335|       |        // Similar for children and descendants.
  336|  9.95k|        for (auto child : children) {
  ------------------
  |  Branch (336:25): [True: 5.76k, False: 9.95k]
  ------------------
  337|  5.76k|            assert((depgraph.Descendants(child) & children).IsSubsetOf(SetType::Singleton(child)));
  338|  5.76k|        }
  339|  9.95k|    }
  340|  1.08k|    if (IsAcyclic(depgraph)) {
  ------------------
  |  Branch (340:9): [True: 1.08k, False: 0]
  ------------------
  341|       |        // If DepGraph is acyclic, serialize + deserialize must roundtrip.
  342|  1.08k|        std::vector<unsigned char> ser;
  343|  1.08k|        VectorWriter writer(ser, 0);
  344|  1.08k|        writer << Using<DepGraphFormatter>(depgraph);
  345|  1.08k|        SpanReader reader(ser);
  346|  1.08k|        DepGraph<TestBitSet> decoded_depgraph;
  347|  1.08k|        reader >> Using<DepGraphFormatter>(decoded_depgraph);
  348|  1.08k|        assert(depgraph == decoded_depgraph);
  349|  1.08k|        assert(reader.empty());
  350|       |        // It must also deserialize correctly without the terminal 0 byte (as the deserializer
  351|       |        // will upon EOF still return what it read so far).
  352|  1.08k|        assert(ser.size() >= 1 && ser.back() == 0);
  353|  1.08k|        ser.pop_back();
  354|  1.08k|        reader = SpanReader{ser};
  355|  1.08k|        decoded_depgraph = {};
  356|  1.08k|        reader >> Using<DepGraphFormatter>(decoded_depgraph);
  357|  1.08k|        assert(depgraph == decoded_depgraph);
  358|  1.08k|        assert(reader.empty());
  359|       |
  360|       |        // In acyclic graphs, the union of parents with parents of parents etc. yields the
  361|       |        // full ancestor set (and similar for children and descendants).
  362|  1.08k|        std::vector<SetType> parents(depgraph.PositionRange()), children(depgraph.PositionRange());
  363|  9.95k|        for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (363:29): [True: 9.95k, False: 1.08k]
  ------------------
  364|  9.95k|            parents[i] = depgraph.GetReducedParents(i);
  365|  9.95k|            children[i] = depgraph.GetReducedChildren(i);
  366|  9.95k|        }
  367|  9.95k|        for (auto i : depgraph.Positions()) {
  ------------------
  |  Branch (367:21): [True: 9.95k, False: 1.08k]
  ------------------
  368|       |            // Initialize the set of ancestors with just the current transaction itself.
  369|  9.95k|            SetType ancestors = SetType::Singleton(i);
  370|       |            // Iteratively add parents of all transactions in the ancestor set to itself.
  371|  27.5k|            while (true) {
  ------------------
  |  Branch (371:20): [Folded - Ignored]
  ------------------
  372|  27.5k|                const auto old_ancestors = ancestors;
  373|   143k|                for (auto j : ancestors) ancestors |= parents[j];
  ------------------
  |  Branch (373:29): [True: 143k, False: 27.5k]
  ------------------
  374|       |                // Stop when no more changes are being made.
  375|  27.5k|                if (old_ancestors == ancestors) break;
  ------------------
  |  Branch (375:21): [True: 9.95k, False: 17.5k]
  ------------------
  376|  27.5k|            }
  377|  9.95k|            assert(ancestors == depgraph.Ancestors(i));
  378|       |
  379|       |            // Initialize the set of descendants with just the current transaction itself.
  380|  9.95k|            SetType descendants = SetType::Singleton(i);
  381|       |            // Iteratively add children of all transactions in the descendant set to itself.
  382|  26.4k|            while (true) {
  ------------------
  |  Branch (382:20): [Folded - Ignored]
  ------------------
  383|  26.4k|                const auto old_descendants = descendants;
  384|   141k|                for (auto j : descendants) descendants |= children[j];
  ------------------
  |  Branch (384:29): [True: 141k, False: 26.4k]
  ------------------
  385|       |                // Stop when no more changes are being made.
  386|  26.4k|                if (old_descendants == descendants) break;
  ------------------
  |  Branch (386:21): [True: 9.95k, False: 16.4k]
  ------------------
  387|  26.4k|            }
  388|  9.95k|            assert(descendants == depgraph.Descendants(i));
  389|  9.95k|        }
  390|  1.08k|    }
  391|  1.08k|}
cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter3SerI12VectorWriterN13bitset_detail9IntBitSetIjEEEEvRT_RKN17cluster_linearize8DepGraphIT0_EE:
  135|  1.08k|    {
  136|       |        /** Construct a topological order to serialize the transactions in. */
  137|  1.08k|        std::vector<ClusterIndex> topo_order;
  138|  1.08k|        topo_order.reserve(depgraph.TxCount());
  139|  9.95k|        for (auto i : depgraph.Positions()) topo_order.push_back(i);
  ------------------
  |  Branch (139:21): [True: 9.95k, False: 1.08k]
  ------------------
  140|  1.08k|        std::sort(topo_order.begin(), topo_order.end(), [&](ClusterIndex a, ClusterIndex b) {
  141|  1.08k|            auto anc_a = depgraph.Ancestors(a).Count(), anc_b = depgraph.Ancestors(b).Count();
  142|  1.08k|            if (anc_a != anc_b) return anc_a < anc_b;
  143|  1.08k|            return a < b;
  144|  1.08k|        });
  145|       |
  146|       |        /** Which positions (incl. holes) the deserializer already knows when it has deserialized
  147|       |         *  what has been serialized here so far. */
  148|  1.08k|        SetType done;
  149|       |
  150|       |        // Loop over the transactions in topological order.
  151|  11.0k|        for (ClusterIndex topo_idx = 0; topo_idx < topo_order.size(); ++topo_idx) {
  ------------------
  |  Branch (151:41): [True: 9.95k, False: 1.08k]
  ------------------
  152|       |            /** Which depgraph index we are currently writing. */
  153|  9.95k|            ClusterIndex idx = topo_order[topo_idx];
  154|       |            // Write size, which must be larger than 0.
  155|  9.95k|            s << VARINT_MODE(depgraph.FeeRate(idx).size, VarIntMode::NONNEGATIVE_SIGNED);
  ------------------
  |  |  499|  9.95k|#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
  ------------------
  156|       |            // Write fee, encoded as an unsigned varint (odd=negative, even=non-negative).
  157|  9.95k|            s << VARINT(SignedToUnsigned(depgraph.FeeRate(idx).fee));
  ------------------
  |  |  500|  9.95k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  158|       |            // Write dependency information.
  159|  9.95k|            SetType written_parents;
  160|  9.95k|            uint64_t diff = 0; //!< How many potential parent/child relations we have skipped over.
  161|   115k|            for (ClusterIndex dep_dist = 0; dep_dist < topo_idx; ++dep_dist) {
  ------------------
  |  Branch (161:45): [True: 105k, False: 9.95k]
  ------------------
  162|       |                /** Which depgraph index we are currently considering as parent of idx. */
  163|   105k|                ClusterIndex dep_idx = topo_order[topo_idx - 1 - dep_dist];
  164|       |                // Ignore transactions which are already known to be ancestors.
  165|   105k|                if (depgraph.Descendants(dep_idx).Overlaps(written_parents)) continue;
  ------------------
  |  Branch (165:21): [True: 16.7k, False: 88.4k]
  ------------------
  166|  88.4k|                if (depgraph.Ancestors(idx)[dep_idx]) {
  ------------------
  |  Branch (166:21): [True: 5.76k, False: 82.6k]
  ------------------
  167|       |                    // When an actual parent is encountered, encode how many non-parents were skipped
  168|       |                    // before it.
  169|  5.76k|                    s << VARINT(diff);
  ------------------
  |  |  500|  5.76k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  170|  5.76k|                    diff = 0;
  171|  5.76k|                    written_parents.Set(dep_idx);
  172|  82.6k|                } else {
  173|       |                    // When a non-parent is encountered, increment the skip counter.
  174|  82.6k|                    ++diff;
  175|  82.6k|                }
  176|  88.4k|            }
  177|       |            // Write position information.
  178|  9.95k|            auto add_holes = SetType::Fill(idx) - done - depgraph.Positions();
  179|  9.95k|            if (add_holes.None()) {
  ------------------
  |  Branch (179:17): [True: 8.28k, False: 1.67k]
  ------------------
  180|       |                // The new transaction is to be inserted N positions back from the end of the
  181|       |                // cluster. Emit N to indicate that that many insertion choices are skipped.
  182|  8.28k|                auto skips = (done - SetType::Fill(idx)).Count();
  183|  8.28k|                s << VARINT(diff + skips);
  ------------------
  |  |  500|  8.28k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  184|  8.28k|            } else {
  185|       |                // The new transaction is to be appended at the end of the cluster, after N holes.
  186|       |                // Emit current_cluster_size + N, to indicate all insertion choices are skipped,
  187|       |                // plus N possibilities for the number of holes.
  188|  1.67k|                s << VARINT(diff + done.Count() + add_holes.Count());
  ------------------
  |  |  500|  1.67k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  189|  1.67k|                done |= add_holes;
  190|  1.67k|            }
  191|  9.95k|            done.Set(idx);
  192|  9.95k|        }
  193|       |
  194|       |        // Output a final 0 to denote the end of the graph.
  195|  1.08k|        s << uint8_t{0};
  196|  1.08k|    }
cluster_linearize.cpp:_ZZN12_GLOBAL__N_117DepGraphFormatter3SerI12VectorWriterN13bitset_detail9IntBitSetIjEEEEvRT_RKN17cluster_linearize8DepGraphIT0_EEENKUljjE_clEjj:
  140|   282k|        std::sort(topo_order.begin(), topo_order.end(), [&](ClusterIndex a, ClusterIndex b) {
  141|   282k|            auto anc_a = depgraph.Ancestors(a).Count(), anc_b = depgraph.Ancestors(b).Count();
  142|   282k|            if (anc_a != anc_b) return anc_a < anc_b;
  ------------------
  |  Branch (142:17): [True: 116k, False: 166k]
  ------------------
  143|   166k|            return a < b;
  144|   282k|        });
cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter16SignedToUnsignedEl:
  115|  9.95k|    {
  116|  9.95k|        if (x < 0) {
  ------------------
  |  Branch (116:13): [True: 5.63k, False: 4.32k]
  ------------------
  117|  5.63k|            return 2 * uint64_t(-(x + 1)) + 1;
  118|  5.63k|        } else {
  119|  4.32k|            return 2 * uint64_t(x);
  120|  4.32k|        }
  121|  9.95k|    }
cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter5UnserI10SpanReaderN13bitset_detail9IntBitSetIjEEEEvRT_RN17cluster_linearize8DepGraphIT0_EE:
  200|  3.25k|    {
  201|       |        /** The dependency graph which we deserialize into first, with transactions in
  202|       |         *  topological serialization order, not original cluster order. */
  203|  3.25k|        DepGraph<SetType> topo_depgraph;
  204|       |        /** Mapping from serialization order to cluster order, used later to reconstruct the
  205|       |         *  cluster order. */
  206|  3.25k|        std::vector<ClusterIndex> reordering;
  207|       |        /** How big the entries vector in the reconstructed depgraph will be (including holes). */
  208|  3.25k|        ClusterIndex total_size{0};
  209|       |
  210|       |        // Read transactions in topological order.
  211|  32.5k|        while (true) {
  ------------------
  |  Branch (211:16): [Folded - Ignored]
  ------------------
  212|  32.5k|            FeeFrac new_feerate; //!< The new transaction's fee and size.
  213|  32.5k|            SetType new_ancestors; //!< The new transaction's ancestors (excluding itself).
  214|  32.5k|            uint64_t diff{0}; //!< How many potential parents/insertions we have to skip.
  215|  32.5k|            bool read_error{false};
  216|  32.5k|            try {
  217|       |                // Read size. Size 0 signifies the end of the DepGraph.
  218|  32.5k|                int32_t size;
  219|  32.5k|                s >> VARINT_MODE(size, VarIntMode::NONNEGATIVE_SIGNED);
  ------------------
  |  |  499|  32.5k|#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
  ------------------
  220|  32.5k|                size &= 0x3FFFFF; // Enough for size up to 4M.
  221|  32.5k|                static_assert(0x3FFFFF >= 4000000);
  222|  32.5k|                if (size == 0 || topo_depgraph.TxCount() == SetType::Size()) break;
  ------------------
  |  Branch (222:21): [True: 2.48k, False: 30.0k]
  |  Branch (222:34): [True: 7, False: 30.0k]
  ------------------
  223|       |                // Read fee, encoded as an unsigned varint (odd=negative, even=non-negative).
  224|  31.4k|                uint64_t coded_fee;
  225|  31.4k|                s >> VARINT(coded_fee);
  ------------------
  |  |  500|  31.4k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  226|  31.4k|                coded_fee &= 0xFFFFFFFFFFFFF; // Enough for fee between -21M...21M BTC.
  227|  31.4k|                static_assert(0xFFFFFFFFFFFFF > uint64_t{2} * 21000000 * 100000000);
  228|  31.4k|                new_feerate = {UnsignedToSigned(coded_fee), size};
  229|       |                // Read dependency information.
  230|  31.4k|                auto topo_idx = reordering.size();
  231|  31.4k|                s >> VARINT(diff);
  ------------------
  |  |  500|  31.4k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  232|   341k|                for (ClusterIndex dep_dist = 0; dep_dist < topo_idx; ++dep_dist) {
  ------------------
  |  Branch (232:49): [True: 310k, False: 31.4k]
  ------------------
  233|       |                    /** Which topo_depgraph index we are currently considering as parent of topo_idx. */
  234|   310k|                    ClusterIndex dep_topo_idx = topo_idx - 1 - dep_dist;
  235|       |                    // Ignore transactions which are already known ancestors of topo_idx.
  236|   310k|                    if (new_ancestors[dep_topo_idx]) continue;
  ------------------
  |  Branch (236:25): [True: 49.0k, False: 261k]
  ------------------
  237|   261k|                    if (diff == 0) {
  ------------------
  |  Branch (237:25): [True: 17.2k, False: 243k]
  ------------------
  238|       |                        // When the skip counter has reached 0, add an actual dependency.
  239|  17.2k|                        new_ancestors |= topo_depgraph.Ancestors(dep_topo_idx);
  240|       |                        // And read the number of skips after it.
  241|  17.2k|                        s >> VARINT(diff);
  ------------------
  |  |  500|  17.2k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  242|   243k|                    } else {
  243|       |                        // Otherwise, dep_topo_idx is not a parent. Decrement and continue.
  244|   243k|                        --diff;
  245|   243k|                    }
  246|   261k|                }
  247|  31.4k|            } catch (const std::ios_base::failure&) {
  248|       |                // Continue even if a read error was encountered.
  249|  2.15k|                read_error = true;
  250|  2.15k|            }
  251|       |            // Construct a new transaction whenever we made it past the new_feerate construction.
  252|  31.4k|            if (new_feerate.IsEmpty()) break;
  ------------------
  |  Branch (252:17): [True: 1.57k, False: 29.8k]
  ------------------
  253|  29.8k|            assert(reordering.size() < SetType::Size());
  254|  29.8k|            auto topo_idx = topo_depgraph.AddTransaction(new_feerate);
  255|  29.8k|            topo_depgraph.AddDependencies(new_ancestors, topo_idx);
  256|  29.8k|            if (total_size < SetType::Size()) {
  ------------------
  |  Branch (256:17): [True: 24.4k, False: 5.44k]
  ------------------
  257|       |                // Normal case.
  258|  24.4k|                diff %= SetType::Size();
  259|  24.4k|                if (diff <= total_size) {
  ------------------
  |  Branch (259:21): [True: 19.8k, False: 4.57k]
  ------------------
  260|       |                    // Insert the new transaction at distance diff back from the end.
  261|   214k|                    for (auto& pos : reordering) {
  ------------------
  |  Branch (261:36): [True: 214k, False: 19.8k]
  ------------------
  262|   214k|                        pos += (pos >= total_size - diff);
  263|   214k|                    }
  264|  19.8k|                    reordering.push_back(total_size++ - diff);
  265|  19.8k|                } else {
  266|       |                    // Append diff - total_size holes at the end, plus the new transaction.
  267|  4.57k|                    total_size = diff;
  268|  4.57k|                    reordering.push_back(total_size++);
  269|  4.57k|                }
  270|  24.4k|            } 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|  5.44k|                diff %= (SetType::Size() - reordering.size());
  277|  5.44k|                SetType holes = SetType::Fill(SetType::Size());
  278|  80.2k|                for (auto pos : reordering) holes.Reset(pos);
  ------------------
  |  Branch (278:31): [True: 80.2k, False: 5.44k]
  ------------------
  279|  57.2k|                for (auto pos : holes) {
  ------------------
  |  Branch (279:31): [True: 57.2k, False: 0]
  ------------------
  280|  57.2k|                    if (diff == 0) {
  ------------------
  |  Branch (280:25): [True: 5.44k, False: 51.8k]
  ------------------
  281|  5.44k|                        reordering.push_back(pos);
  282|  5.44k|                        break;
  283|  5.44k|                    }
  284|  51.8k|                    --diff;
  285|  51.8k|                }
  286|  5.44k|            }
  287|       |            // Stop if a read error was encountered during deserialization.
  288|  29.8k|            if (read_error) break;
  ------------------
  |  Branch (288:17): [True: 578, False: 29.2k]
  ------------------
  289|  29.8k|        }
  290|       |
  291|       |        // Construct the original cluster order depgraph.
  292|  3.25k|        depgraph = DepGraph(topo_depgraph, reordering, total_size);
  293|  3.25k|    }
cluster_linearize.cpp:_ZN12_GLOBAL__N_117DepGraphFormatter16UnsignedToSignedEm:
  125|  29.8k|    {
  126|  29.8k|        if (x & 1) {
  ------------------
  |  Branch (126:13): [True: 16.8k, False: 12.9k]
  ------------------
  127|  16.8k|            return -int64_t(x / 2) - 1;
  128|  16.8k|        } else {
  129|  12.9k|            return int64_t(x / 2);
  130|  12.9k|        }
  131|  29.8k|    }
cluster_linearize.cpp:_ZN12_GLOBAL__N_19IsAcyclicIN13bitset_detail9IntBitSetIjEEEEbRKN17cluster_linearize8DepGraphIT_EE:
   29|  2.17k|{
   30|  19.9k|    for (ClusterIndex i : depgraph.Positions()) {
  ------------------
  |  Branch (30:25): [True: 19.9k, False: 2.17k]
  ------------------
   31|  19.9k|        if ((depgraph.Ancestors(i) & depgraph.Descendants(i)) != SetType::Singleton(i)) {
  ------------------
  |  Branch (31:13): [True: 0, False: 19.9k]
  ------------------
   32|      0|            return false;
   33|      0|        }
   34|  19.9k|    }
   35|  2.17k|    return true;
   36|  2.17k|}

_ZN13bitset_detail9IntBitSetIjE4SizeEv:
  177|   126k|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail9IntBitSetIjEixEj:
  170|  1.08M|    {
  171|  1.08M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|  1.08M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  172|  1.08M|        return (m_val >> pos) & 1U;
  173|  1.08M|    }
_ZN13bitset_detail9IntBitSetIjE3SetEj:
  152|   206k|    {
  153|   206k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|   206k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  154|   206k|        m_val |= I{1U} << pos;
  155|   206k|    }
_ZN13bitset_detail9IntBitSetIjE5ResetEj:
  164|   149k|    {
  165|   149k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |   97|   149k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  166|   149k|        m_val &= ~I(I{1U} << pos);
  167|   149k|    }
_ZN13bitset_detail9IntBitSetIjE9SingletonEj:
  138|   170k|    {
  139|   170k|        Assume(i < MAX_SIZE);
  ------------------
  |  |   97|   170k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  140|   170k|        return IntBitSet(I(1U) << i);
  141|   170k|    }
_ZN13bitset_detail9IntBitSetIjEC2Ej:
   71|   320k|    IntBitSet(I val) noexcept : m_val{val} {}
_ZNK13bitset_detail9IntBitSetIjE3AnyEv:
  181|  29.8k|    constexpr bool Any() const noexcept { return !None(); }
_ZNK13bitset_detail9IntBitSetIjE4NoneEv:
  179|   102k|    constexpr bool None() const noexcept { return m_val == 0; }
_ZNK13bitset_detail9IntBitSetIjE5FirstEv:
  188|  29.8k|    {
  189|  29.8k|        Assume(m_val != 0);
  ------------------
  |  |   97|  29.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  190|  29.8k|        return std::countr_zero(m_val);
  191|  29.8k|    }
_ZNK13bitset_detail9IntBitSetIjE4LastEv:
  194|  2.52k|    {
  195|  2.52k|        Assume(m_val != 0);
  ------------------
  |  |   97|  2.52k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  196|  2.52k|        return std::bit_width(m_val) - 1;
  197|  2.52k|    }
_ZNK13bitset_detail9IntBitSetIjE5CountEv:
  175|   613k|    constexpr unsigned Count() const noexcept { return PopCount(m_val); }
_ZN13bitset_detail8PopCountIjEEjT_:
   39|   613k|{
   40|   613k|    static_assert(std::is_integral_v<I> && std::is_unsigned_v<I> && std::numeric_limits<I>::radix == 2);
   41|   613k|    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|   613k|    if constexpr (BITS <= 32) {
   45|   613k|        v -= (v >> 1) & 0x55555555;
   46|   613k|        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
   47|   613k|        v = (v + (v >> 4)) & 0x0f0f0f0f;
   48|   613k|        if constexpr (BITS > 8) v += v >> 8;
   49|   613k|        if constexpr (BITS > 16) v += v >> 16;
   50|   613k|        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|   613k|}
_ZN13bitset_detail9IntBitSetIjEC2Ev:
  119|   328k|    constexpr IntBitSet() noexcept : m_val{0} {}
_ZN13bitset_detail9IntBitSetIjE4FillEj:
  144|  23.6k|    {
  145|  23.6k|        IntBitSet ret;
  146|  23.6k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |   97|  23.6k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  147|  23.6k|        if (count) ret.m_val = I(~I{0}) >> (MAX_SIZE - count);
  ------------------
  |  Branch (147:13): [True: 22.5k, False: 1.14k]
  ------------------
  148|  23.6k|        return ret;
  149|  23.6k|    }
_ZNK13bitset_detail9IntBitSetIjE5beginEv:
  183|   322k|    constexpr Iterator begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail9IntBitSetIjE8IteratorC2Ej:
   86|   322k|        constexpr Iterator(I val) noexcept : m_val(val), m_pos(0)
   87|   322k|        {
   88|   322k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (88:17): [True: 208k, False: 113k]
  ------------------
   89|   322k|        }
_ZN13bitset_detaileqERKNS_9IntBitSetIjE8IteratorERKNS1_11IteratorEndE:
   98|  1.50M|        {
   99|  1.50M|            return a.m_val == 0;
  100|  1.50M|        }
_ZNK13bitset_detail9IntBitSetIjE3endEv:
  185|   322k|    constexpr IteratorEnd end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail9IntBitSetIjE8IteratordeEv:
  111|  1.18M|        {
  112|  1.18M|            Assume(m_val != 0);
  ------------------
  |  |   97|  1.18M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  113|  1.18M|            return m_pos;
  114|  1.18M|        }
_ZN13bitset_detail9IntBitSetIjE8IteratorppEv:
  103|  1.17M|        {
  104|  1.17M|            Assume(m_val != 0);
  ------------------
  |  |   97|  1.17M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  105|  1.17M|            m_val &= m_val - I{1U};
  106|  1.17M|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (106:17): [True: 975k, False: 203k]
  ------------------
  107|  1.17M|            return *this;
  108|  1.17M|        }
_ZN13bitset_detail9IntBitSetIjEoRERKS1_:
  199|   547k|    constexpr IntBitSet& operator|=(const IntBitSet& a) noexcept { m_val |= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetIjEmIERKS1_:
  203|   173k|    constexpr IntBitSet& operator-=(const IntBitSet& a) noexcept { m_val &= ~a.m_val; return *this; }
_ZN13bitset_detailanERKNS_9IntBitSetIjEES3_:
  209|  31.4k|    friend constexpr IntBitSet operator&(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & b.m_val); }
_ZN13bitset_detailmiERKNS_9IntBitSetIjEES3_:
  213|   117k|    friend constexpr IntBitSet operator-(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & ~b.m_val); }
_ZNK13bitset_detail9IntBitSetIjE12IsSupersetOfERKS1_:
  219|  32.4k|    constexpr bool IsSupersetOf(const IntBitSet& a) const noexcept { return (a.m_val & ~m_val) == 0; }
_ZNK13bitset_detail9IntBitSetIjE10IsSubsetOfERKS1_:
  221|  71.2k|    constexpr bool IsSubsetOf(const IntBitSet& a) const noexcept { return (m_val & ~a.m_val) == 0; }
_ZN13bitset_detaileqERKNS_9IntBitSetIjEES3_:
  217|   135k|    friend constexpr bool operator==(const IntBitSet& a, const IntBitSet& b) noexcept = default;
_ZNK13bitset_detail9IntBitSetIjE8OverlapsERKS1_:
  207|   105k|    constexpr bool Overlaps(const IntBitSet& a) const noexcept { return m_val & a.m_val; }

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

_ZN7FeeFracC2Ev:
   67|  93.1k|    constexpr inline FeeFrac() noexcept : fee{0}, size{0} {}
_ZN7FeeFracC2Eli:
   70|  29.8k|    constexpr inline FeeFrac(int64_t f, int32_t s) noexcept : fee{f}, size{s} {}
_ZNK7FeeFrac7IsEmptyEv:
   76|  31.4k|    bool inline IsEmpty() const noexcept {
   77|  31.4k|        return size == 0;
   78|  31.4k|    }
_ZeqRK7FeeFracS1_:
  108|  19.9k|    {
  109|  19.9k|        return a.fee == b.fee && a.size == b.size;
  ------------------
  |  Branch (109:16): [True: 19.9k, False: 0]
  |  Branch (109:34): [True: 19.9k, False: 0]
  ------------------
  110|  19.9k|    }

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