_ZN24BlockTransactionsRequest16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   51|    465|    {
   52|    465|        READWRITE(obj.blockhash, Using<VectorFormatter<DifferenceFormatter>>(obj.indexes));
  ------------------
  |  |  156|    465|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   53|    465|    }
_ZN19DifferenceFormatter5UnserI10DataStreamtEEvRT_RT0_:
   36|  1.03M|    {
   37|  1.03M|        uint64_t n = ReadCompactSize(s);
   38|  1.03M|        m_shift += n;
   39|  1.03M|        if (m_shift < n || m_shift >= std::numeric_limits<uint64_t>::max() || m_shift < std::numeric_limits<I>::min() || m_shift > std::numeric_limits<I>::max()) throw std::ios_base::failure("differential value overflow");
  ------------------
  |  Branch (39:13): [True: 143, False: 1.03M]
  |  Branch (39:28): [True: 0, False: 1.03M]
  |  Branch (39:79): [True: 0, False: 1.03M]
  |  Branch (39:122): [True: 41, False: 1.03M]
  ------------------
   40|  1.03M|        v = I(m_shift++);
   41|  1.03M|    }
_ZN24BlockTransactionsRequest16SerializationOpsI10DataStreamKS_15ActionSerializeEEvRT0_RT_T1_:
   51|    124|    {
   52|    124|        READWRITE(obj.blockhash, Using<VectorFormatter<DifferenceFormatter>>(obj.indexes));
  ------------------
  |  |  156|    124|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   53|    124|    }
_ZN19DifferenceFormatter3SerI10DataStreamtEEvRT_T0_:
   29|   377k|    {
   30|   377k|        if (v < m_shift || v >= std::numeric_limits<uint64_t>::max()) throw std::ios_base::failure("differential value overflow");
  ------------------
  |  Branch (30:13): [True: 0, False: 377k]
  |  Branch (30:28): [True: 0, False: 377k]
  ------------------
   31|   377k|        WriteCompactSize(s, v - m_shift);
   32|   377k|        m_shift = uint64_t(v) + 1;
   33|   377k|    }

_ZN11ArgsManagerD2Ev:
  134|      2|ArgsManager::~ArgsManager() = default;

_ZN11ArgsManager9ClearArgsEv:
  362|      2|    void ClearArgs() {
  363|      2|        LOCK(cs_args);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  364|      2|        m_available_args.clear();
  365|      2|        m_network_only_args.clear();
  366|      2|    }

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

_ZN15ChaCha20AlignedD2Ev:
   43|      2|{
   44|      2|    memory_cleanse(input, sizeof(input));
   45|      2|}
_ZN8ChaCha20D2Ev:
  333|      2|{
  334|      2|    memory_cleanse(m_buffer.data(), m_buffer.size());
  335|      2|}

_ZN10interfaces5ChainD2Ev:
  131|      2|    virtual ~Chain() = default;

_ZN11ECC_ContextD2Ev:
  482|      2|{
  483|      2|    ECC_Stop();
  484|      2|}
key.cpp:_ZL8ECC_Stopv:
  467|      2|static void ECC_Stop() {
  468|      2|    secp256k1_context *ctx = secp256k1_context_sign;
  469|      2|    secp256k1_context_sign = nullptr;
  470|       |
  471|      2|    if (ctx) {
  ------------------
  |  Branch (471:9): [True: 2, False: 0]
  ------------------
  472|      2|        secp256k1_context_destroy(ctx);
  473|      2|    }
  474|      2|}

_Z11LogInstancev:
   25|      2|{
   26|       |/**
   27|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   28|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   29|       | * since the order of destruction of static/global objects is undefined.
   30|       | * Consider if the logger gets destroyed, and then some later destructor calls
   31|       | * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
   32|       | * access the logger. When the shutdown sequence is fully audited and tested,
   33|       | * explicit destruction of these objects can be implemented by changing this
   34|       | * from a raw pointer to a std::unique_ptr.
   35|       | * Since the ~Logger() destructor is never called, the Logger class and all
   36|       | * its subclasses must have implicitly-defined destructors.
   37|       | *
   38|       | * This method of initialization was originally introduced in
   39|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   40|       | */
   41|      2|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|      2|    return *g_logger;
   43|      2|}
_ZN5BCLog6Logger20DisconnectTestLoggerEv:
   97|      2|{
   98|      2|    StdLockGuard scoped_lock(m_cs);
   99|      2|    m_buffering = true;
  100|      2|    if (m_fileout != nullptr) fclose(m_fileout);
  ------------------
  |  Branch (100:9): [True: 0, False: 2]
  ------------------
  101|      2|    m_fileout = nullptr;
  102|      2|    m_print_callbacks.clear();
  103|      2|    m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
  104|      2|    m_cur_buffer_memusage = 0;
  105|      2|    m_buffer_lines_discarded = 0;
  106|      2|    m_msgs_before_open.clear();
  107|      2|}

_ZN4node11NodeContextD2Ev:
   26|      2|NodeContext::~NodeContext() = default;

secp256k1.c:secp256k1_ecmult_gen_context_clear:
   26|      2|static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context *ctx) {
   27|      2|    ctx->built = 0;
   28|      2|    secp256k1_scalar_clear(&ctx->scalar_offset);
   29|      2|    secp256k1_ge_clear(&ctx->ge_offset);
   30|      2|    secp256k1_fe_clear(&ctx->proj_blind);
   31|      2|}
secp256k1.c:secp256k1_ecmult_gen_context_is_built:
   22|      4|static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx) {
   23|      4|    return ctx->built;
   24|      4|}

secp256k1.c:secp256k1_fe_clear:
   21|      2|SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
   22|      2|    secp256k1_memclear(a, sizeof(secp256k1_fe));
   23|      2|}

secp256k1.c:secp256k1_ge_clear:
  305|      2|static void secp256k1_ge_clear(secp256k1_ge *r) {
  306|      2|    secp256k1_memclear(r, sizeof(secp256k1_ge));
  307|      2|}

secp256k1.c:secp256k1_scalar_clear:
   30|      2|SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
   31|      2|    secp256k1_memclear(r, sizeof(secp256k1_scalar));
   32|      2|}

secp256k1_context_preallocated_destroy:
  176|      2|void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  177|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  178|       |
  179|       |    /* Defined as noop */
  180|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (180:9): [True: 0, False: 2]
  ------------------
  181|      0|        return;
  182|      0|    }
  183|       |
  184|      2|    secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
  185|      2|}
secp256k1_context_destroy:
  187|      2|void secp256k1_context_destroy(secp256k1_context* ctx) {
  188|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|       |
  190|       |    /* Defined as noop */
  191|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (191:9): [True: 0, False: 2]
  ------------------
  192|      0|        return;
  193|      0|    }
  194|       |
  195|      2|    secp256k1_context_preallocated_destroy(ctx);
  196|      2|    free(ctx);
  197|      2|}
secp256k1.c:secp256k1_context_is_proper:
   82|      4|static int secp256k1_context_is_proper(const secp256k1_context* ctx) {
   83|      4|    return secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx);
   84|      4|}

secp256k1.c:secp256k1_memclear:
  223|      6|static SECP256K1_INLINE void secp256k1_memclear(void *ptr, size_t len) {
  224|       |#if defined(_MSC_VER)
  225|       |    /* SecureZeroMemory is guaranteed not to be optimized out by MSVC. */
  226|       |    SecureZeroMemory(ptr, len);
  227|       |#elif defined(__GNUC__)
  228|       |    /* We use a memory barrier that scares the compiler away from optimizing out the memset.
  229|       |     *
  230|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
  231|       |     * in BoringSSL (ISC License):
  232|       |     *    As best as we can tell, this is sufficient to break any optimisations that
  233|       |     *    might try to eliminate "superfluous" memsets.
  234|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
  235|       |     * is pretty efficient, because the compiler can still implement the memset() efficently,
  236|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
  237|       |     * Yang et al. (USENIX Security 2017) for more background.
  238|       |     */
  239|      6|    memset(ptr, 0, len);
  240|      6|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
  241|       |#else
  242|       |    void *(*volatile const volatile_memset)(void *, int, size_t) = memset;
  243|       |    volatile_memset(ptr, 0, len);
  244|       |#endif
  245|       |#ifdef VERIFY
  246|       |    SECP256K1_CHECKMEM_UNDEFINE(ptr, len);
  247|       |#endif
  248|      6|}

_Z14ser_readdata32I10DataStreamEjRT_:
  102|    136|{
  103|    136|    uint32_t obj;
  104|    136|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|    136|    return le32toh_internal(obj);
  106|    136|}
_Z11UnserializeI10DataStreamR7uint256Q14UnserializableIT0_T_EEvRS4_OS3_:
  762|    465|{
  763|    465|    a.Unserialize(is);
  764|    465|}
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|  1.03M|{
  341|  1.03M|    uint8_t chSize = ser_readdata8(is);
  342|  1.03M|    uint64_t nSizeRet = 0;
  343|  1.03M|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 1.03M, False: 1.71k]
  ------------------
  344|  1.03M|    {
  345|  1.03M|        nSizeRet = chSize;
  346|  1.03M|    }
  347|  1.71k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 1.33k, False: 380]
  ------------------
  348|  1.33k|    {
  349|  1.33k|        nSizeRet = ser_readdata16(is);
  350|  1.33k|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 8, False: 1.33k]
  ------------------
  351|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|  1.33k|    }
  353|    380|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 136, False: 244]
  ------------------
  354|    136|    {
  355|    136|        nSizeRet = ser_readdata32(is);
  356|    136|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 18, False: 118]
  ------------------
  357|     18|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    136|    }
  359|    244|    else
  360|    244|    {
  361|    244|        nSizeRet = ser_readdata64(is);
  362|    244|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 40, False: 204]
  ------------------
  363|     40|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    244|    }
  365|  1.03M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 1.03M, False: 148]
  |  Branch (365:24): [True: 78, False: 1.03M]
  ------------------
  366|     78|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     78|    }
  368|  1.03M|    return nSizeRet;
  369|  1.03M|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|  1.03M|{
   85|  1.03M|    uint8_t obj;
   86|  1.03M|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  1.03M|    return obj;
   88|  1.03M|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|  1.33k|{
   91|  1.33k|    uint16_t obj;
   92|  1.33k|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|  1.33k|    return le16toh_internal(obj);
   94|  1.33k|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|    112|{
  115|    112|    uint64_t obj;
  116|    112|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|    112|    return le64toh_internal(obj);
  118|    112|}
_Z14ser_writedata8I10DataStreamEvRT_h:
   55|   377k|{
   56|   377k|    s.write(AsBytes(Span{&obj, 1}));
   57|   377k|}
_Z9SerializeI10DataStream7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|    124|{
  754|    124|    a.Serialize(os);
  755|    124|}
_Z9SerializeI10DataStreamTk9BasicByteKhEvRT_4SpanIT0_E:
  268|    124|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z16WriteCompactSizeI10DataStreamEvRT_m:
  309|   377k|{
  310|   377k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 376k, False: 1.05k]
  ------------------
  311|   376k|    {
  312|   376k|        ser_writedata8(os, nSize);
  313|   376k|    }
  314|  1.05k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 1.05k, False: 1]
  ------------------
  315|  1.05k|    {
  316|  1.05k|        ser_writedata8(os, 253);
  317|  1.05k|        ser_writedata16(os, nSize);
  318|  1.05k|    }
  319|      1|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 1, False: 0]
  ------------------
  320|      1|    {
  321|      1|        ser_writedata8(os, 254);
  322|      1|        ser_writedata32(os, nSize);
  323|      1|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|   377k|    return;
  330|   377k|}
_Z15ser_writedata16I10DataStreamEvRT_t:
   59|  1.05k|{
   60|  1.05k|    obj = htole16_internal(obj);
   61|  1.05k|    s.write(AsBytes(Span{&obj, 1}));
   62|  1.05k|}
_Z15ser_writedata32I10DataStreamEvRT_j:
   69|      1|{
   70|      1|    obj = htole32_internal(obj);
   71|      1|    s.write(AsBytes(Span{&obj, 1}));
   72|      1|}
_Z11UnserializeI10DataStreamR24BlockTransactionsRequestQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|    465|{
  763|    465|    a.Unserialize(is);
  764|    465|}
_ZN24BlockTransactionsRequest11UnserializeI10DataStreamEEvRT_:
  228|    465|    {                                                                                               \
  229|    465|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|    465|        Unser(s, *this);                                                                            \
  231|    465|    }
_ZN24BlockTransactionsRequest5UnserI10DataStreamEEvRT_RS_:
  180|    465|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR7uint2567WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS8_9allocatorItEEEEEEEEvRT_DpOT0_:
 1033|    465|    {
 1034|    465|        ::UnserializeMany(s, args...);
 1035|    465|    }
_Z15UnserializeManyI10DataStreamJR7uint256R7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS7_9allocatorItEEEEEEEvRT_DpOT0_:
 1001|    465|{
 1002|    465|    (::Unserialize(s, args), ...);
 1003|    465|}
_Z11UnserializeI10DataStreamR7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS5_9allocatorItEEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|    457|{
  763|    457|    a.Unserialize(is);
  764|    457|}
_ZN7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEE11UnserializeI10DataStreamEEvRT_:
  483|    457|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI19DifferenceFormatterE5UnserI10DataStreamNSt3__16vectorItNS4_9allocatorItEEEEEEvRT_RT0_:
  672|    457|    {
  673|    457|        Formatter formatter;
  674|    457|        v.clear();
  675|    457|        size_t size = ReadCompactSize(s);
  676|    457|        size_t allocated = 0;
  677|    751|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 294, False: 457]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|    294|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|    294|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|    294|            v.reserve(allocated);
  684|  1.03M|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 1.03M, False: 294]
  ------------------
  685|  1.03M|                v.emplace_back();
  686|  1.03M|                formatter.Unser(s, v.back());
  687|  1.03M|            }
  688|    294|        }
  689|    457|    };
deserialize.cpp:_ZL5UsingI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEE7WrapperIT_RT0_EOSB_:
  497|    465|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEEC2ES8_:
  481|    465|    explicit Wrapper(T obj) : m_object(obj) {}
_Z9SerializeI10DataStream24BlockTransactionsRequestQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|    124|{
  754|    124|    a.Serialize(os);
  755|    124|}
_ZNK24BlockTransactionsRequest9SerializeI10DataStreamEEvRT_:
  222|    124|    {                                                                                               \
  223|    124|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|    124|        Ser(s, *this);                                                                              \
  225|    124|    }                                                                                               \
_ZN24BlockTransactionsRequest3SerI10DataStreamEEvRT_RKS_:
  178|    124|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI10DataStreamJ7uint2567WrapperI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS7_9allocatorItEEEEEEEEvRT_DpRKT0_:
 1013|    124|    {
 1014|    124|        ::SerializeMany(s, args...);
 1015|    124|    }
_Z13SerializeManyI10DataStreamJ7uint2567WrapperI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS6_9allocatorItEEEEEEEvRT_DpRKT0_:
  995|    124|{
  996|    124|    (::Serialize(s, args), ...);
  997|    124|}
_Z9SerializeI10DataStream7WrapperI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS5_9allocatorItEEEEEQ12SerializableIT0_T_EEvRSE_RKSD_:
  753|    124|{
  754|    124|    a.Serialize(os);
  755|    124|}
_ZNK7WrapperI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS3_9allocatorItEEEEE9SerializeI10DataStreamEEvRT_:
  482|    124|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI19DifferenceFormatterE3SerI10DataStreamNSt3__16vectorItNS4_9allocatorItEEEEEEvRT_RKT0_:
  662|    124|    {
  663|    124|        Formatter formatter;
  664|    124|        WriteCompactSize(s, v.size());
  665|   377k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 377k, False: 124]
  ------------------
  666|   377k|            formatter.Ser(s, elem);
  667|   377k|        }
  668|    124|    }
deserialize.cpp:_ZL5UsingI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS3_9allocatorItEEEEE7WrapperIT_RT0_EOSC_:
  497|    124|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI19DifferenceFormatterERKNSt3__16vectorItNS3_9allocatorItEEEEEC2ES9_:
  481|    124|    explicit Wrapper(T obj) : m_object(obj) {}

_ZNK4SpanIKSt4byteE4sizeEv:
  187|    465|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|    930|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIhE4dataEv:
  174|  1.41M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|    589|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  3.11M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  1.03M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE5beginEv:
  175|   378k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE3endEv:
  176|   378k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIKhE10size_bytesEv:
  188|    589|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|    589|{
  260|    589|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|    589|}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|   378k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZNK4SpanIjE4dataEv:
  174|    137|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|    137|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|      1|{
  260|      1|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|      1|}
_ZNK4SpanIhE10size_bytesEv:
  188|  1.41M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|   377k|{
  260|   377k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   377k|}
_ZNK4SpanItE4dataEv:
  174|  2.39k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|  2.39k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|  1.05k|{
  260|  1.05k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  1.05k|}
_ZNK4SpanImE4dataEv:
  174|    112|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|    112|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  1.03M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  1.03M|{
  265|  1.03M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.03M|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  1.41M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|  1.33k|{
  265|  1.33k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.33k|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|  2.39k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|    136|{
  265|    136|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    136|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|    137|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|    112|{
  265|    112|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    112|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|    112|    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|    465|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|    124|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|    465|{
  276|    465|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|    465|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|    465|        : m_data(other.data()), m_size(other.size()){}

_ZN10DataStreamC2E4SpanIKhE:
  165|    465|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|    465|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZNK10DataStream5emptyEv:
  182|    124|    bool empty() const                               { return vch.size() == m_read_pos; }
_ZN10DataStream4readE4SpanISt4byteE:
  219|  1.03M|    {
  220|  1.03M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 1.03M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  1.03M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  1.03M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 1.03M]
  |  Branch (224:43): [True: 156, False: 1.03M]
  ------------------
  225|    156|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    156|        }
  227|  1.03M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  1.03M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 421, False: 1.03M]
  ------------------
  229|    421|            m_read_pos = 0;
  230|    421|            vch.clear();
  231|    421|            return;
  232|    421|        }
  233|  1.03M|        m_read_pos = next_read_pos.value();
  234|  1.03M|    }
_ZN10DataStream5writeE4SpanIKSt4byteE:
  252|   378k|    {
  253|       |        // Write to the end of the buffer
  254|   378k|        vch.insert(vch.end(), src.begin(), src.end());
  255|   378k|    }
_ZN10DataStreamC2Ev:
  164|    124|    explicit DataStream() = default;
_ZN10DataStreamlsI4SpanIKhEEERS_RKT_:
  259|    124|    {
  260|    124|        ::Serialize(*this, obj);
  261|    124|        return (*this);
  262|    124|    }
_ZN10DataStreamrsIR24BlockTransactionsRequestEERS_OT_:
  266|    465|    {
  267|    465|        ::Unserialize(*this, obj);
  268|    465|        return (*this);
  269|    465|    }
_ZN10DataStreamlsI24BlockTransactionsRequestEERS_RKT_:
  259|    124|    {
  260|    124|        ::Serialize(*this, obj);
  261|    124|        return (*this);
  262|    124|    }

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

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

_Z13LeaveCriticalv:
   76|      2|inline void LeaveCritical() {}
_Z10DeleteLockPv:
   82|      4|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_:
  253|      2|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; }
_Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b:
   75|      2|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i:
  157|      2|    {
  158|      2|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  159|       |#ifdef DEBUG_LOCKCONTENTION
  160|       |        if (Base::try_lock()) return;
  161|       |        LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK);
  162|       |#endif
  163|      2|        Base::lock();
  164|      2|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib:
  177|      2|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|      2|    {
  179|      2|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 2]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|      2|        else
  182|      2|            Enter(pszName, pszFile, nLine);
  183|      2|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev:
  197|      2|    {
  198|      2|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 2, False: 0]
  ------------------
  199|      2|            LeaveCritical();
  200|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   94|      2|    ~AnnotatedMixin() {
   95|      2|        DeleteLock((void*)this);
   96|      2|    }
_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   94|      2|    ~AnnotatedMixin() {
   95|      2|        DeleteLock((void*)this);
   96|      2|    }

_Z48blocktransactionsrequest_deserialize_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   51|    465|    {                                                      \
   52|    465|        try {                                              \
   53|    465|            code                                           \
   54|    465|        } catch (const invalid_fuzzing_input_exception&) { \
   55|    341|        }                                                  \
   56|    465|    }
deserialize.cpp:_ZN12_GLOBAL__N_127DeserializeFromFuzzingInputIR24BlockTransactionsRequestEEvNSt3__14spanIKhLm18446744073709551615EEEOT_:
  109|    465|{
  110|    465|    DataStream ds{buffer};
  111|    465|    try {
  112|    465|        ds >> obj;
  113|    465|    } catch (const std::ios_base::failure&) {
  114|    341|        throw invalid_fuzzing_input_exception();
  115|    341|    }
  116|    124|    assert(buffer.empty() || !Serialize(obj).empty());
  117|    124|}
deserialize.cpp:_ZN12_GLOBAL__N_19SerializeI24BlockTransactionsRequestEE10DataStreamRKT_:
   93|    124|{
   94|    124|    DataStream ds{};
   95|    124|    ds << obj;
   96|    124|    return ds;
   97|    124|}

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

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

_ZN17BasicTestingSetupD2Ev:
  199|      2|{
  200|      2|    m_node.ecc_context.reset();
  201|      2|    m_node.kernel.reset();
  202|       |    if constexpr (!G_FUZZING) {
  203|       |        SetMockTime(0s); // Reset mocktime for following tests
  204|       |    }
  205|      2|    LogInstance().DisconnectTestLogger();
  206|      2|    if (m_has_custom_datadir) {
  ------------------
  |  Branch (206:9): [True: 0, False: 2]
  ------------------
  207|       |        // Only remove the lock file, preserve the data directory.
  208|      0|        UnlockDirectory(m_path_lock, ".lock");
  209|      0|        fs::remove(m_path_lock / ".lock");
  210|      2|    } else {
  211|      2|        fs::remove_all(m_path_root);
  212|      2|    }
  213|      2|    gArgs.ClearArgs();
  214|      2|}

_ZN12StdLockGuardC2ER8StdMutex:
   73|      2|    explicit StdLockGuard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard<StdMutex>(cs) {}

_ZN7uint256C2Ev:
  205|    465|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|    465|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|    465|    {
  134|    465|        s.read(MakeWritableByteSpan(m_data));
  135|    465|    }
_ZNK9base_blobILj256EE9SerializeI10DataStreamEEvRT_:
  127|    124|    {
  128|    124|        s << Span(m_data);
  129|    124|    }

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

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

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

_ZN12TokenPipeEndD2Ev:
   34|      4|{
   35|      4|    Close();
   36|      4|}
_ZN12TokenPipeEnd5CloseEv:
   77|      4|{
   78|      4|    if (m_fd != -1) close(m_fd);
  ------------------
  |  Branch (78:9): [True: 4, False: 0]
  ------------------
   79|      4|    m_fd = -1;
   80|      4|}