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

_ZN15ChaCha20AlignedD2Ev:
   42|      4|{
   43|      4|    memory_cleanse(input, sizeof(input));
   44|      4|}
_ZN8ChaCha20D2Ev:
  332|      4|{
  333|      4|    memory_cleanse(m_buffer.data(), m_buffer.size());
  334|      4|}

_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }

_ZN11CNetCleanupD2Ev:
 3676|      2|    {
 3677|       |#ifdef WIN32
 3678|       |        // Shutdown Windows Sockets
 3679|       |        WSACleanup();
 3680|       |#endif
 3681|      2|    }

_ZNK9prevectorILj16EhjiE9is_directEv:
  126|     16|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  422|     16|    ~prevector() {
  423|     16|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 16]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     16|    }
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|     14|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiED2Ev:
  422|     14|    ~prevector() {
  423|     14|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 14]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     14|    }

random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev:
  367|      2|    ~RNGState() = default;

_ZN21InsecureRandomContextC2Em:
  439|  17.9k|        : m_s0(SplitMix64(seedval)), m_s1(SplitMix64(seedval)) {}
_ZN11RandomMixinI21InsecureRandomContextEC2Ev:
  195|  17.9k|    constexpr RandomMixin() noexcept = default;
_ZN21InsecureRandomContext10SplitMix64ERm:
  430|  35.8k|    {
  431|  35.8k|        uint64_t z = (seedval += 0x9e3779b97f4a7c15);
  432|  35.8k|        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
  433|  35.8k|        z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
  434|  35.8k|        return z ^ (z >> 31);
  435|  35.8k|    }
_ZN21InsecureRandomContext6rand64Ev:
  449|   135k|    {
  450|   135k|        uint64_t s0 = m_s0, s1 = m_s1;
  451|   135k|        const uint64_t result = std::rotl(s0 + s1, 17) + s0;
  452|   135k|        s1 ^= s0;
  453|   135k|        m_s0 = std::rotl(s0, 49) ^ s1 ^ (s1 << 21);
  454|   135k|        m_s1 = std::rotl(s1, 28);
  455|   135k|        return result;
  456|   135k|    }
_ZN11RandomMixinI21InsecureRandomContextE9randrangeITkNSt3__18integralEjEET_S4_:
  255|   301k|    {
  256|   301k|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|   301k|        Assume(range > 0);
  ------------------
  |  |  128|   301k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  258|   301k|        uint64_t maxval = range - 1U;
  259|   301k|        int bits = std::bit_width(maxval);
  260|   329k|        while (true) {
  ------------------
  |  Branch (260:16): [True: 329k, Folded]
  ------------------
  261|   329k|            uint64_t ret = Impl().randbits(bits);
  262|   329k|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 301k, False: 27.6k]
  ------------------
  263|   329k|        }
  264|   301k|    }
_ZN11RandomMixinI21InsecureRandomContextE4ImplEv:
  185|  6.97M|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }
_ZN11RandomMixinI21InsecureRandomContextE8randbitsEi:
  205|   329k|    {
  206|   329k|        Assume(bits <= 64);
  ------------------
  |  |  128|   329k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  207|       |        // Requests for the full 64 bits are passed through.
  208|   329k|        if (bits == 64) return Impl().rand64();
  ------------------
  |  Branch (208:13): [True: 0, False: 329k]
  ------------------
  209|   329k|        uint64_t ret;
  210|   329k|        if (bits <= bitbuf_size) {
  ------------------
  |  Branch (210:13): [True: 295k, False: 34.1k]
  ------------------
  211|       |            // If there is enough entropy left in bitbuf, return its bottom bits bits.
  212|   295k|            ret = bitbuf;
  213|   295k|            bitbuf >>= bits;
  214|   295k|            bitbuf_size -= bits;
  215|   295k|        } else {
  216|       |            // If not, return all of bitbuf, supplemented with the (bits - bitbuf_size) bottom
  217|       |            // bits of a newly generated 64-bit number on top. The remainder of that generated
  218|       |            // number becomes the new bitbuf.
  219|  34.1k|            uint64_t gen = Impl().rand64();
  220|  34.1k|            ret = (gen << bitbuf_size) | bitbuf;
  221|  34.1k|            bitbuf = gen >> (bits - bitbuf_size);
  222|  34.1k|            bitbuf_size = 64 + bitbuf_size - bits;
  223|  34.1k|        }
  224|       |        // Return the bottom bits bits of ret.
  225|   329k|        return ret & ((uint64_t{1} << bits) - 1);
  226|   329k|    }
_ZN11RandomMixinI21InsecureRandomContextE8randboolEv:
  325|  6.51M|    bool randbool() noexcept { return Impl().template randbits<1>(); }
_ZN11RandomMixinI21InsecureRandomContextE8randbitsILi1EEEmv:
  231|  6.51M|    {
  232|  6.51M|        static_assert(Bits >= 0 && Bits <= 64);
  233|       |        if constexpr (Bits == 64) {
  234|       |            return Impl().rand64();
  235|  6.51M|        } else {
  236|  6.51M|            uint64_t ret;
  237|  6.51M|            if (Bits <= bitbuf_size) {
  ------------------
  |  Branch (237:17): [True: 6.41M, False: 101k]
  ------------------
  238|  6.41M|                ret = bitbuf;
  239|  6.41M|                bitbuf >>= Bits;
  240|  6.41M|                bitbuf_size -= Bits;
  241|  6.41M|            } else {
  242|   101k|                uint64_t gen = Impl().rand64();
  243|   101k|                ret = (gen << bitbuf_size) | bitbuf;
  244|   101k|                bitbuf = gen >> (Bits - bitbuf_size);
  245|   101k|                bitbuf_size = 64 + bitbuf_size - Bits;
  246|   101k|            }
  247|  6.51M|            constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1;
  248|  6.51M|            return ret & MASK;
  249|  6.51M|        }
  250|  6.51M|    }

_ZN20BaseSignatureCheckerD2Ev:
  298|      2|    virtual ~BaseSignatureChecker() = default;

_ZN20BaseSignatureCreatorD2Ev:
   41|      4|    virtual ~BaseSignatureCreator() = default;

_ZN15SigningProviderD2Ev:
  170|      2|    virtual ~SigningProvider() = default;

random.cpp:_ZN16secure_allocatorIN12_GLOBAL__N_18RNGStateEE10deallocateEPS1_m:
   37|      2|    {
   38|      2|        if (p != nullptr) {
  ------------------
  |  Branch (38:13): [True: 2, False: 0]
  ------------------
   39|      2|            memory_cleanse(p, sizeof(T) * n);
   40|      2|        }
   41|      2|        LockedPoolManager::Instance().free(p);
   42|      2|    }

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

_ZN5ArenaD2Ev:
   48|      2|Arena::~Arena() = default;
_ZN5Arena4freeEPv:
   87|      2|{
   88|       |    // Freeing the nullptr pointer is OK.
   89|      2|    if (ptr == nullptr) {
  ------------------
  |  Branch (89:9): [True: 0, False: 2]
  ------------------
   90|      0|        return;
   91|      0|    }
   92|       |
   93|       |    // Remove chunk from used map
   94|      2|    auto i = chunks_used.find(ptr);
   95|      2|    if (i == chunks_used.end()) {
  ------------------
  |  Branch (95:9): [True: 0, False: 2]
  ------------------
   96|      0|        throw std::runtime_error("Arena: invalid or double free");
   97|      0|    }
   98|      2|    auto freed = std::make_pair(static_cast<char*>(i->first), i->second);
   99|      2|    chunks_used.erase(i);
  100|       |
  101|       |    // coalesce freed with previous chunk
  102|      2|    auto prev = chunks_free_end.find(freed.first);
  103|      2|    if (prev != chunks_free_end.end()) {
  ------------------
  |  Branch (103:9): [True: 2, False: 0]
  ------------------
  104|      2|        freed.first -= prev->second->first;
  105|      2|        freed.second += prev->second->first;
  106|      2|        size_to_free_chunk.erase(prev->second);
  107|      2|        chunks_free_end.erase(prev);
  108|      2|    }
  109|       |
  110|       |    // coalesce freed with chunk after freed
  111|      2|    auto next = chunks_free.find(freed.first + freed.second);
  112|      2|    if (next != chunks_free.end()) {
  ------------------
  |  Branch (112:9): [True: 0, False: 2]
  ------------------
  113|      0|        freed.second += next->second->first;
  114|      0|        size_to_free_chunk.erase(next->second);
  115|      0|        chunks_free.erase(next);
  116|      0|    }
  117|       |
  118|       |    // Add/set space with coalesced free chunk
  119|      2|    auto it = size_to_free_chunk.emplace(freed.second, freed.first);
  120|      2|    chunks_free[freed.first] = it;
  121|      2|    chunks_free_end[freed.first + freed.second] = it;
  122|      2|}
_ZN24PosixLockedPageAllocator10FreeLockedEPvm:
  254|      2|{
  255|      2|    len = align_up(len, page_size);
  256|      2|    memory_cleanse(addr, len);
  257|      2|    munlock(addr, len);
  258|      2|    munmap(addr, len);
  259|      2|}
_ZN10LockedPoolD2Ev:
  283|      2|LockedPool::~LockedPool() = default;
_ZN10LockedPool4freeEPv:
  308|      2|{
  309|      2|    std::lock_guard<std::mutex> lock(mutex);
  310|       |    // TODO we can do better than this linear search by keeping a map of arena
  311|       |    // extents to arena, and looking up the address.
  312|      2|    for (auto &arena: arenas) {
  ------------------
  |  Branch (312:21): [True: 2, False: 0]
  ------------------
  313|      2|        if (arena.addressInArena(ptr)) {
  ------------------
  |  Branch (313:13): [True: 2, False: 0]
  ------------------
  314|      2|            arena.free(ptr);
  315|      2|            return;
  316|      2|        }
  317|      2|    }
  318|      0|    throw std::runtime_error("LockedPool: invalid address not pointing to any arena");
  319|      2|}
_ZN10LockedPool15LockedPageArenaD2Ev:
  370|      2|{
  371|      2|    allocator->FreeLocked(base, size);
  372|      2|}
_ZN17LockedPoolManager8InstanceEv:
  405|      2|{
  406|      2|    static std::once_flag init_flag;
  407|      2|    std::call_once(init_flag, LockedPoolManager::CreateInstance);
  408|      2|    return *LockedPoolManager::_instance;
  409|      2|}
lockedpool.cpp:_ZL8align_upmm:
   32|      2|{
   33|      2|    return (x + align - 1) & ~(align - 1);
   34|      2|}

_ZNK5Arena14addressInArenaEPv:
   90|      2|    bool addressInArena(void *ptr) const { return ptr >= base && ptr < end; }
  ------------------
  |  Branch (90:51): [True: 2, False: 0]
  |  Branch (90:66): [True: 2, False: 0]
  ------------------
_ZN19LockedPageAllocatorD2Ev:
   22|      2|    virtual ~LockedPageAllocator() = default;

_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   96|      2|    ~AnnotatedMixin() {
   97|      2|        DeleteLock((void*)this);
   98|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   96|     64|    ~AnnotatedMixin() {
   97|     64|        DeleteLock((void*)this);
   98|     64|    }
_Z10DeleteLockPv:
   74|     66|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  258|     30|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  181|     30|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  182|     30|    {
  183|     30|        if (fTry)
  ------------------
  |  Branch (183:13): [True: 0, False: 30]
  ------------------
  184|      0|            TryEnter(pszName, pszFile, nLine);
  185|     30|        else
  186|     30|            Enter(pszName, pszFile, nLine);
  187|     30|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   67|     30|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   68|     30|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  159|     30|    {
  160|     30|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  161|       |#ifdef DEBUG_LOCKCONTENTION
  162|       |        if (!Base::try_lock()) {
  163|       |            ContendedLock(pszName, pszFile, nLine, static_cast<Base&>(*this));
  164|       |        }
  165|       |#else
  166|     30|        Base::lock();
  167|     30|#endif
  168|     30|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  201|     30|    {
  202|     30|        if (Base::owns_lock())
  ------------------
  |  Branch (202:13): [True: 30, False: 0]
  ------------------
  203|     30|            LeaveCritical();
  204|     30|    }

_Z18bitset_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  283|  10.0k|{
  284|  10.0k|    unsigned typdat = ReadByte(buffer) % 8;
  285|  10.0k|    if (typdat == 0) {
  ------------------
  |  Branch (285:9): [True: 629, False: 9.38k]
  ------------------
  286|       |        /* 16 bits */
  287|    629|        TestType<bitset_detail::IntBitSet<uint16_t>>(buffer);
  288|    629|        TestType<bitset_detail::MultiIntBitSet<uint16_t, 1>>(buffer);
  289|  9.38k|    } else if (typdat == 1) {
  ------------------
  |  Branch (289:16): [True: 933, False: 8.45k]
  ------------------
  290|       |        /* 32 bits */
  291|    933|        TestType<bitset_detail::MultiIntBitSet<uint16_t, 2>>(buffer);
  292|    933|        TestType<bitset_detail::IntBitSet<uint32_t>>(buffer);
  293|  8.45k|    } else if (typdat == 2) {
  ------------------
  |  Branch (293:16): [True: 836, False: 7.61k]
  ------------------
  294|       |        /* 48 bits */
  295|    836|        TestType<bitset_detail::MultiIntBitSet<uint16_t, 3>>(buffer);
  296|  7.61k|    } else if (typdat == 3) {
  ------------------
  |  Branch (296:16): [True: 1.56k, False: 6.04k]
  ------------------
  297|       |        /* 64 bits */
  298|  1.56k|        TestType<bitset_detail::IntBitSet<uint64_t>>(buffer);
  299|  1.56k|        TestType<bitset_detail::MultiIntBitSet<uint64_t, 1>>(buffer);
  300|  1.56k|        TestType<bitset_detail::MultiIntBitSet<uint32_t, 2>>(buffer);
  301|  1.56k|        TestType<bitset_detail::MultiIntBitSet<uint16_t, 4>>(buffer);
  302|  6.04k|    } else if (typdat == 4) {
  ------------------
  |  Branch (302:16): [True: 1.36k, False: 4.68k]
  ------------------
  303|       |        /* 96 bits */
  304|  1.36k|        TestType<bitset_detail::MultiIntBitSet<uint32_t, 3>>(buffer);
  305|  4.68k|    } else if (typdat == 5) {
  ------------------
  |  Branch (305:16): [True: 1.65k, False: 3.02k]
  ------------------
  306|       |        /* 128 bits */
  307|  1.65k|        TestType<bitset_detail::MultiIntBitSet<uint64_t, 2>>(buffer);
  308|  1.65k|        TestType<bitset_detail::MultiIntBitSet<uint32_t, 4>>(buffer);
  309|  3.02k|    } else if (typdat == 6) {
  ------------------
  |  Branch (309:16): [True: 1.58k, False: 1.43k]
  ------------------
  310|       |        /* 192 bits */
  311|  1.58k|        TestType<bitset_detail::MultiIntBitSet<uint64_t, 3>>(buffer);
  312|  1.58k|    } else if (typdat == 7) {
  ------------------
  |  Branch (312:16): [True: 1.43k, False: 0]
  ------------------
  313|       |        /* 256 bits */
  314|  1.43k|        TestType<bitset_detail::MultiIntBitSet<uint64_t, 4>>(buffer);
  315|  1.43k|    }
  316|  10.0k|}
bitset.cpp:_ZN12_GLOBAL__N_18ReadByteERNSt3__14spanIKhLm18446744073709551615EEE:
   17|  3.19M|{
   18|  3.19M|    if (buffer.empty()) return 0;
  ------------------
  |  Branch (18:9): [True: 12.6k, False: 3.17M]
  ------------------
   19|  3.17M|    uint8_t ret = buffer.front();
   20|  3.17M|    buffer = buffer.subspan(1);
   21|  3.17M|    return ret;
   22|  3.19M|}
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetItEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|    629|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|    629|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|    629|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|    629|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|    629|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|    629|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|    629|        auto it = real[idx].begin();
   44|    629|        unsigned first = S::Size();
   45|    629|        unsigned last = S::Size();
   46|    629|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|    629|            bool match = (it != real[idx].end()) && *it == i;
   48|    629|            assert(sim[idx][i] == real[idx][i]);
   49|    629|            assert(match == real[idx][i]);
   50|    629|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|    629|            if (match) {
   52|    629|                ++it;
   53|    629|                if (first == S::Size()) first = i;
   54|    629|                last = i;
   55|    629|            }
   56|    629|        }
   57|    629|        assert(it == real[idx].end());
   58|    629|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|    629|        assert(sim[idx].any() == real[idx].Any());
   61|    629|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|    629|        if (sim[idx].any()) {
   64|    629|            assert(first == real[idx].First());
   65|    629|            assert(last == real[idx].Last());
   66|    629|        }
   67|       |        /* Count */
   68|    629|        assert(sim[idx].count() == real[idx].Count());
   69|    629|    };
   70|       |
   71|  74.6k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|  75.3k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 74.7k, False: 579]
  |  |  |  Branch (23:49): [True: 74.6k, False: 50]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  74.6k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  74.6k|        unsigned args = ReadByte(buffer);
   76|  74.6k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  74.6k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  74.6k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  74.6k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.09k, False: 72.5k]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 74.6k, False: 0]
  ------------------
   81|  74.6k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   157k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 157k, Folded]
  ------------------
   87|   157k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 130k, False: 26.3k]
  |  Branch (87:38): [True: 20.4k, False: 110k]
  ------------------
   88|       |                /* Set() (true) */
   89|  20.4k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  20.4k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 20.4k, False: 0]
  ------------------
   91|  20.4k|                sim[dest].set(val);
   92|  20.4k|                real[dest].Set(val);
   93|  20.4k|                break;
   94|   136k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 110k, False: 26.3k]
  |  Branch (94:45): [True: 2.87k, False: 107k]
  ------------------
   95|       |                /* Reset() */
   96|  2.87k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  2.87k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 2.87k, False: 0]
  ------------------
   98|  2.87k|                sim[dest].reset(val);
   99|  2.87k|                real[dest].Reset(val);
  100|  2.87k|                break;
  101|   133k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 107k, False: 26.3k]
  |  Branch (101:45): [True: 1.33k, False: 106k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  1.33k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  1.33k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 1.33k, False: 0]
  ------------------
  105|  1.33k|                sim[dest].set(val, args >> 7);
  106|  1.33k|                real[dest].Set(val, args >> 7);
  107|  1.33k|                break;
  108|   132k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 80.6k, False: 51.9k]
  |  Branch (108:42): [True: 963, False: 79.6k]
  ------------------
  109|       |                /* Construct empty. */
  110|    963|                sim.resize(sim.size() + 1);
  111|    963|                real.resize(real.size() + 1);
  112|    963|                break;
  113|   131k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 79.6k, False: 51.9k]
  |  Branch (113:42): [True: 763, False: 78.9k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    763|                unsigned val = ReadByte(buffer) % S::Size();
  116|    763|                std::bitset<S::Size()> newset;
  117|    763|                newset[val] = true;
  118|    763|                sim.push_back(newset);
  119|    763|                real.push_back(S::Singleton(val));
  120|    763|                break;
  121|   130k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 105k, False: 25.1k]
  |  Branch (121:45): [True: 5.29k, False: 100k]
  ------------------
  122|       |                /* Make random. */
  123|  5.29k|                compare_fn(dest);
  124|  5.29k|                sim[dest].reset();
  125|  5.29k|                real[dest] = S{};
  126|  89.9k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 84.6k, False: 5.29k]
  ------------------
  127|  84.6k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 42.2k, False: 42.3k]
  ------------------
  128|  42.2k|                        sim[dest][i] = true;
  129|  42.2k|                        real[dest].Set(i);
  130|  42.2k|                    }
  131|  84.6k|                }
  132|  5.29k|                break;
  133|   125k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 100k, False: 25.1k]
  |  Branch (133:45): [True: 6.52k, False: 93.8k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  6.52k|                unsigned r1 = rng.randrange(S::Size());
  136|  6.52k|                unsigned r2 = rng.randrange(S::Size());
  137|  6.52k|                unsigned r3 = rng.randrange(S::Size());
  138|  6.52k|                compare_fn(dest);
  139|  6.52k|                sim[dest].reset();
  140|  6.52k|                real[dest] = {r1, r2, r3};
  141|  6.52k|                sim[dest].set(r1);
  142|  6.52k|                sim[dest].set(r2);
  143|  6.52k|                sim[dest].set(r3);
  144|  6.52k|                break;
  145|   119k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 93.8k, False: 25.1k]
  |  Branch (145:40): [True: 3.15k, False: 90.7k]
  ------------------
  146|       |                /* Destruct. */
  147|  3.15k|                compare_fn(sim.size() - 1);
  148|  3.15k|                sim.pop_back();
  149|  3.15k|                real.pop_back();
  150|  3.15k|                break;
  151|   115k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 67.6k, False: 48.2k]
  |  Branch (151:42): [True: 42.5k, False: 25.1k]
  |  Branch (151:62): [True: 432, False: 42.0k]
  ------------------
  152|       |                /* Copy construct. */
  153|    432|                sim.emplace_back(sim[src]);
  154|    432|                real.emplace_back(real[src]);
  155|    432|                break;
  156|   115k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 90.3k, False: 25.1k]
  |  Branch (156:44): [True: 90.3k, False: 0]
  |  Branch (156:65): [True: 2.13k, False: 88.1k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.13k|                compare_fn(dest);
  159|  2.13k|                sim[dest] = sim[src];
  160|  2.13k|                real[dest] = real[src];
  161|  2.13k|                break;
  162|   113k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 88.1k, False: 25.1k]
  |  Branch (162:44): [True: 88.1k, False: 0]
  |  Branch (162:65): [True: 1.53k, False: 86.6k]
  ------------------
  163|       |                /* swap() function. */
  164|  1.53k|                swap(sim[dest], sim[src]);
  165|  1.53k|                swap(real[dest], real[src]);
  166|  1.53k|                break;
  167|   111k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 66.0k, False: 45.6k]
  |  Branch (167:42): [True: 1.20k, False: 64.8k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  1.20k|                unsigned r1 = rng.randrange(S::Size());
  170|  1.20k|                unsigned r2 = rng.randrange(S::Size());
  171|  1.20k|                sim.emplace_back();
  172|  1.20k|                sim.back().set(r1);
  173|  1.20k|                sim.back().set(r2);
  174|  1.20k|                real.push_back(S{r1, r2});
  175|  1.20k|                break;
  176|   110k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 86.2k, False: 24.2k]
  |  Branch (176:45): [True: 1.77k, False: 84.4k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  1.77k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  1.77k|                compare_fn(dest);
  180|  1.77k|                sim[dest].reset();
  181|  14.9k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 13.1k, False: 1.77k]
  ------------------
  182|  1.77k|                real[dest] = S::Fill(len);
  183|  1.77k|                break;
  184|   108k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 84.4k, False: 24.2k]
  |  Branch (184:44): [True: 3.87k, False: 80.6k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  3.87k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  3.87k|                auto it = real[src].begin(), it_copy = it;
  189|  65.7k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 61.9k, False: 3.87k]
  ------------------
  190|  61.9k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 3.87k, False: 58.0k]
  ------------------
  191|  61.9k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 37.2k, False: 24.7k]
  |  Branch (191:61): [True: 10.6k, False: 26.5k]
  ------------------
  192|  61.9k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 61.9k, False: 0]
  ------------------
  193|  61.9k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 10.6k, False: 51.2k]
  ------------------
  194|  61.9k|                }
  195|  3.87k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 3.87k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|  22.7k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 18.8k, False: 3.87k]
  ------------------
  198|  18.8k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 10.1k, False: 8.69k]
  |  Branch (198:66): [True: 4.81k, False: 5.35k]
  ------------------
  199|  18.8k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 18.8k, False: 0]
  ------------------
  200|  18.8k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 4.81k, False: 14.0k]
  ------------------
  201|  18.8k|                }
  202|  3.87k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 3.87k, False: 0]
  ------------------
  203|  3.87k|                break;
  204|   104k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 80.6k, False: 24.2k]
  |  Branch (204:44): [True: 80.6k, False: 0]
  |  Branch (204:65): [True: 2.22k, False: 78.4k]
  ------------------
  205|       |                /* operator|= */
  206|  2.22k|                compare_fn(dest);
  207|  2.22k|                sim[dest] |= sim[src];
  208|  2.22k|                real[dest] |= real[src];
  209|  2.22k|                break;
  210|   102k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 78.4k, False: 24.2k]
  |  Branch (210:44): [True: 78.4k, False: 0]
  |  Branch (210:65): [True: 2.37k, False: 76.0k]
  ------------------
  211|       |                /* operator&= */
  212|  2.37k|                compare_fn(dest);
  213|  2.37k|                sim[dest] &= sim[src];
  214|  2.37k|                real[dest] &= real[src];
  215|  2.37k|                break;
  216|   100k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 76.0k, False: 24.2k]
  |  Branch (216:44): [True: 76.0k, False: 0]
  |  Branch (216:65): [True: 1.52k, False: 74.4k]
  ------------------
  217|       |                /* operator-= */
  218|  1.52k|                compare_fn(dest);
  219|  1.52k|                sim[dest] &= ~sim[src];
  220|  1.52k|                real[dest] -= real[src];
  221|  1.52k|                break;
  222|  98.7k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 74.4k, False: 24.2k]
  |  Branch (222:44): [True: 74.4k, False: 0]
  |  Branch (222:65): [True: 1.56k, False: 72.9k]
  ------------------
  223|       |                /* operator^= */
  224|  1.56k|                compare_fn(dest);
  225|  1.56k|                sim[dest] ^= sim[src];
  226|  1.56k|                real[dest] ^= real[src];
  227|  1.56k|                break;
  228|  97.2k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 72.9k, False: 24.2k]
  |  Branch (228:44): [True: 72.9k, False: 0]
  |  Branch (228:65): [True: 72.9k, False: 0]
  |  Branch (228:85): [True: 4.03k, False: 68.8k]
  ------------------
  229|       |                /* operator| */
  230|  4.03k|                compare_fn(dest);
  231|  4.03k|                sim[dest] = sim[src] | sim[aux];
  232|  4.03k|                real[dest] = real[src] | real[aux];
  233|  4.03k|                break;
  234|  93.1k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 68.8k, False: 24.2k]
  |  Branch (234:44): [True: 68.8k, False: 0]
  |  Branch (234:65): [True: 68.8k, False: 0]
  |  Branch (234:85): [True: 948, False: 67.9k]
  ------------------
  235|       |                /* operator& */
  236|    948|                compare_fn(dest);
  237|    948|                sim[dest] = sim[src] & sim[aux];
  238|    948|                real[dest] = real[src] & real[aux];
  239|    948|                break;
  240|  92.2k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 67.9k, False: 24.2k]
  |  Branch (240:44): [True: 67.9k, False: 0]
  |  Branch (240:65): [True: 67.9k, False: 0]
  |  Branch (240:85): [True: 1.28k, False: 66.6k]
  ------------------
  241|       |                /* operator- */
  242|  1.28k|                compare_fn(dest);
  243|  1.28k|                sim[dest] = sim[src] & ~sim[aux];
  244|  1.28k|                real[dest] = real[src] - real[aux];
  245|  1.28k|                break;
  246|  90.9k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 66.6k, False: 24.2k]
  |  Branch (246:44): [True: 66.6k, False: 0]
  |  Branch (246:65): [True: 66.6k, False: 0]
  |  Branch (246:85): [True: 972, False: 65.6k]
  ------------------
  247|       |                /* operator^ */
  248|    972|                compare_fn(dest);
  249|    972|                sim[dest] = sim[src] ^ sim[aux];
  250|    972|                real[dest] = real[src] ^ real[aux];
  251|    972|                break;
  252|  89.9k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 65.6k, False: 24.2k]
  |  Branch (252:44): [True: 65.6k, False: 0]
  |  Branch (252:64): [True: 2.20k, False: 63.4k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  2.20k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  2.20k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  2.20k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 2.20k, False: 0]
  ------------------
  257|  2.20k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 2.20k, False: 0]
  ------------------
  258|  2.20k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 2.20k, False: 0]
  ------------------
  259|  2.20k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 2.20k, False: 0]
  ------------------
  260|  2.20k|                break;
  261|  87.7k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 63.4k, False: 24.2k]
  |  Branch (261:44): [True: 63.4k, False: 0]
  |  Branch (261:64): [True: 2.66k, False: 60.8k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.66k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.66k, False: 0]
  ------------------
  264|  2.66k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.66k, False: 0]
  ------------------
  265|  2.66k|                break;
  266|  85.1k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 60.8k, False: 24.2k]
  |  Branch (266:44): [True: 60.8k, False: 0]
  |  Branch (266:64): [True: 2.61k, False: 58.2k]
  ------------------
  267|       |                /* Overlaps() */
  268|  2.61k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 2.61k, False: 0]
  ------------------
  269|  2.61k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 2.61k, False: 0]
  ------------------
  270|  2.61k|                break;
  271|  2.61k|            }
  272|   157k|        }
  273|  74.6k|    }
  274|       |    /* Fully compare the final state. */
  275|  2.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 1.46k, False: 629]
  ------------------
  276|  1.46k|        compare_fn(i);
  277|  1.46k|    }
  278|    629|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetItEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  35.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  35.2k|        auto it = real[idx].begin();
   44|  35.2k|        unsigned first = S::Size();
   45|  35.2k|        unsigned last = S::Size();
   46|   599k|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 564k, False: 35.2k]
  ------------------
   47|   564k|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 330k, False: 233k]
  |  Branch (47:53): [True: 156k, False: 173k]
  ------------------
   48|   564k|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 564k, False: 0]
  ------------------
   49|   564k|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 564k, False: 0]
  ------------------
   50|   564k|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 564k, False: 0]
  ------------------
   51|   564k|            if (match) {
  ------------------
  |  Branch (51:17): [True: 156k, False: 407k]
  ------------------
   52|   156k|                ++it;
   53|   156k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 26.1k, False: 130k]
  ------------------
   54|   156k|                last = i;
   55|   156k|            }
   56|   564k|        }
   57|  35.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 35.2k, False: 0]
  ------------------
   58|  35.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 35.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  35.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 35.2k, False: 0]
  ------------------
   61|  35.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 35.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  35.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 26.1k, False: 9.10k]
  ------------------
   64|  26.1k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 26.1k, False: 0]
  ------------------
   65|  26.1k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 26.1k, False: 0]
  ------------------
   66|  26.1k|        }
   67|       |        /* Count */
   68|  35.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 35.2k, False: 0]
  ------------------
   69|  35.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj1EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|    629|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|    629|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|    629|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|    629|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|    629|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|    629|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|    629|        auto it = real[idx].begin();
   44|    629|        unsigned first = S::Size();
   45|    629|        unsigned last = S::Size();
   46|    629|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|    629|            bool match = (it != real[idx].end()) && *it == i;
   48|    629|            assert(sim[idx][i] == real[idx][i]);
   49|    629|            assert(match == real[idx][i]);
   50|    629|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|    629|            if (match) {
   52|    629|                ++it;
   53|    629|                if (first == S::Size()) first = i;
   54|    629|                last = i;
   55|    629|            }
   56|    629|        }
   57|    629|        assert(it == real[idx].end());
   58|    629|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|    629|        assert(sim[idx].any() == real[idx].Any());
   61|    629|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|    629|        if (sim[idx].any()) {
   64|    629|            assert(first == real[idx].First());
   65|    629|            assert(last == real[idx].Last());
   66|    629|        }
   67|       |        /* Count */
   68|    629|        assert(sim[idx].count() == real[idx].Count());
   69|    629|    };
   70|       |
   71|  74.6k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|  75.3k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 74.7k, False: 579]
  |  |  |  Branch (23:49): [True: 74.6k, False: 50]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  74.6k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  74.6k|        unsigned args = ReadByte(buffer);
   76|  74.6k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  74.6k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  74.6k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  74.6k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.09k, False: 72.5k]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 2.09k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 72.5k, False: 0]
  |  Branch (80:9): [True: 74.6k, False: 0]
  ------------------
   81|  74.6k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   157k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 157k, Folded]
  ------------------
   87|   157k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 130k, False: 26.3k]
  |  Branch (87:38): [True: 20.4k, False: 110k]
  ------------------
   88|       |                /* Set() (true) */
   89|  20.4k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  20.4k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 20.4k, False: 0]
  ------------------
   91|  20.4k|                sim[dest].set(val);
   92|  20.4k|                real[dest].Set(val);
   93|  20.4k|                break;
   94|   136k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 110k, False: 26.3k]
  |  Branch (94:45): [True: 2.87k, False: 107k]
  ------------------
   95|       |                /* Reset() */
   96|  2.87k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  2.87k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 2.87k, False: 0]
  ------------------
   98|  2.87k|                sim[dest].reset(val);
   99|  2.87k|                real[dest].Reset(val);
  100|  2.87k|                break;
  101|   133k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 107k, False: 26.3k]
  |  Branch (101:45): [True: 1.33k, False: 106k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  1.33k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  1.33k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 1.33k, False: 0]
  ------------------
  105|  1.33k|                sim[dest].set(val, args >> 7);
  106|  1.33k|                real[dest].Set(val, args >> 7);
  107|  1.33k|                break;
  108|   132k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 80.6k, False: 51.9k]
  |  Branch (108:42): [True: 963, False: 79.6k]
  ------------------
  109|       |                /* Construct empty. */
  110|    963|                sim.resize(sim.size() + 1);
  111|    963|                real.resize(real.size() + 1);
  112|    963|                break;
  113|   131k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 79.6k, False: 51.9k]
  |  Branch (113:42): [True: 763, False: 78.9k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    763|                unsigned val = ReadByte(buffer) % S::Size();
  116|    763|                std::bitset<S::Size()> newset;
  117|    763|                newset[val] = true;
  118|    763|                sim.push_back(newset);
  119|    763|                real.push_back(S::Singleton(val));
  120|    763|                break;
  121|   130k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 105k, False: 25.1k]
  |  Branch (121:45): [True: 5.29k, False: 100k]
  ------------------
  122|       |                /* Make random. */
  123|  5.29k|                compare_fn(dest);
  124|  5.29k|                sim[dest].reset();
  125|  5.29k|                real[dest] = S{};
  126|  89.9k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 84.6k, False: 5.29k]
  ------------------
  127|  84.6k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 42.2k, False: 42.3k]
  ------------------
  128|  42.2k|                        sim[dest][i] = true;
  129|  42.2k|                        real[dest].Set(i);
  130|  42.2k|                    }
  131|  84.6k|                }
  132|  5.29k|                break;
  133|   125k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 100k, False: 25.1k]
  |  Branch (133:45): [True: 6.52k, False: 93.8k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  6.52k|                unsigned r1 = rng.randrange(S::Size());
  136|  6.52k|                unsigned r2 = rng.randrange(S::Size());
  137|  6.52k|                unsigned r3 = rng.randrange(S::Size());
  138|  6.52k|                compare_fn(dest);
  139|  6.52k|                sim[dest].reset();
  140|  6.52k|                real[dest] = {r1, r2, r3};
  141|  6.52k|                sim[dest].set(r1);
  142|  6.52k|                sim[dest].set(r2);
  143|  6.52k|                sim[dest].set(r3);
  144|  6.52k|                break;
  145|   119k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 93.8k, False: 25.1k]
  |  Branch (145:40): [True: 3.15k, False: 90.7k]
  ------------------
  146|       |                /* Destruct. */
  147|  3.15k|                compare_fn(sim.size() - 1);
  148|  3.15k|                sim.pop_back();
  149|  3.15k|                real.pop_back();
  150|  3.15k|                break;
  151|   115k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 67.6k, False: 48.2k]
  |  Branch (151:42): [True: 42.5k, False: 25.1k]
  |  Branch (151:62): [True: 432, False: 42.0k]
  ------------------
  152|       |                /* Copy construct. */
  153|    432|                sim.emplace_back(sim[src]);
  154|    432|                real.emplace_back(real[src]);
  155|    432|                break;
  156|   115k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 90.3k, False: 25.1k]
  |  Branch (156:44): [True: 90.3k, False: 0]
  |  Branch (156:65): [True: 2.13k, False: 88.1k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.13k|                compare_fn(dest);
  159|  2.13k|                sim[dest] = sim[src];
  160|  2.13k|                real[dest] = real[src];
  161|  2.13k|                break;
  162|   113k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 88.1k, False: 25.1k]
  |  Branch (162:44): [True: 88.1k, False: 0]
  |  Branch (162:65): [True: 1.53k, False: 86.6k]
  ------------------
  163|       |                /* swap() function. */
  164|  1.53k|                swap(sim[dest], sim[src]);
  165|  1.53k|                swap(real[dest], real[src]);
  166|  1.53k|                break;
  167|   111k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 66.0k, False: 45.6k]
  |  Branch (167:42): [True: 1.20k, False: 64.8k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  1.20k|                unsigned r1 = rng.randrange(S::Size());
  170|  1.20k|                unsigned r2 = rng.randrange(S::Size());
  171|  1.20k|                sim.emplace_back();
  172|  1.20k|                sim.back().set(r1);
  173|  1.20k|                sim.back().set(r2);
  174|  1.20k|                real.push_back(S{r1, r2});
  175|  1.20k|                break;
  176|   110k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 86.2k, False: 24.2k]
  |  Branch (176:45): [True: 1.77k, False: 84.4k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  1.77k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  1.77k|                compare_fn(dest);
  180|  1.77k|                sim[dest].reset();
  181|  14.9k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 13.1k, False: 1.77k]
  ------------------
  182|  1.77k|                real[dest] = S::Fill(len);
  183|  1.77k|                break;
  184|   108k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 84.4k, False: 24.2k]
  |  Branch (184:44): [True: 3.87k, False: 80.6k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  3.87k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  3.87k|                auto it = real[src].begin(), it_copy = it;
  189|  65.7k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 61.9k, False: 3.87k]
  ------------------
  190|  61.9k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 3.87k, False: 58.0k]
  ------------------
  191|  61.9k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 37.2k, False: 24.7k]
  |  Branch (191:61): [True: 10.6k, False: 26.5k]
  ------------------
  192|  61.9k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 61.9k, False: 0]
  ------------------
  193|  61.9k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 10.6k, False: 51.2k]
  ------------------
  194|  61.9k|                }
  195|  3.87k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 3.87k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|  22.7k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 18.8k, False: 3.87k]
  ------------------
  198|  18.8k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 10.1k, False: 8.69k]
  |  Branch (198:66): [True: 4.81k, False: 5.35k]
  ------------------
  199|  18.8k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 18.8k, False: 0]
  ------------------
  200|  18.8k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 4.81k, False: 14.0k]
  ------------------
  201|  18.8k|                }
  202|  3.87k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 3.87k, False: 0]
  ------------------
  203|  3.87k|                break;
  204|   104k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 80.6k, False: 24.2k]
  |  Branch (204:44): [True: 80.6k, False: 0]
  |  Branch (204:65): [True: 2.22k, False: 78.4k]
  ------------------
  205|       |                /* operator|= */
  206|  2.22k|                compare_fn(dest);
  207|  2.22k|                sim[dest] |= sim[src];
  208|  2.22k|                real[dest] |= real[src];
  209|  2.22k|                break;
  210|   102k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 78.4k, False: 24.2k]
  |  Branch (210:44): [True: 78.4k, False: 0]
  |  Branch (210:65): [True: 2.37k, False: 76.0k]
  ------------------
  211|       |                /* operator&= */
  212|  2.37k|                compare_fn(dest);
  213|  2.37k|                sim[dest] &= sim[src];
  214|  2.37k|                real[dest] &= real[src];
  215|  2.37k|                break;
  216|   100k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 76.0k, False: 24.2k]
  |  Branch (216:44): [True: 76.0k, False: 0]
  |  Branch (216:65): [True: 1.52k, False: 74.4k]
  ------------------
  217|       |                /* operator-= */
  218|  1.52k|                compare_fn(dest);
  219|  1.52k|                sim[dest] &= ~sim[src];
  220|  1.52k|                real[dest] -= real[src];
  221|  1.52k|                break;
  222|  98.7k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 74.4k, False: 24.2k]
  |  Branch (222:44): [True: 74.4k, False: 0]
  |  Branch (222:65): [True: 1.56k, False: 72.9k]
  ------------------
  223|       |                /* operator^= */
  224|  1.56k|                compare_fn(dest);
  225|  1.56k|                sim[dest] ^= sim[src];
  226|  1.56k|                real[dest] ^= real[src];
  227|  1.56k|                break;
  228|  97.2k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 72.9k, False: 24.2k]
  |  Branch (228:44): [True: 72.9k, False: 0]
  |  Branch (228:65): [True: 72.9k, False: 0]
  |  Branch (228:85): [True: 4.03k, False: 68.8k]
  ------------------
  229|       |                /* operator| */
  230|  4.03k|                compare_fn(dest);
  231|  4.03k|                sim[dest] = sim[src] | sim[aux];
  232|  4.03k|                real[dest] = real[src] | real[aux];
  233|  4.03k|                break;
  234|  93.1k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 68.8k, False: 24.2k]
  |  Branch (234:44): [True: 68.8k, False: 0]
  |  Branch (234:65): [True: 68.8k, False: 0]
  |  Branch (234:85): [True: 948, False: 67.9k]
  ------------------
  235|       |                /* operator& */
  236|    948|                compare_fn(dest);
  237|    948|                sim[dest] = sim[src] & sim[aux];
  238|    948|                real[dest] = real[src] & real[aux];
  239|    948|                break;
  240|  92.2k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 67.9k, False: 24.2k]
  |  Branch (240:44): [True: 67.9k, False: 0]
  |  Branch (240:65): [True: 67.9k, False: 0]
  |  Branch (240:85): [True: 1.28k, False: 66.6k]
  ------------------
  241|       |                /* operator- */
  242|  1.28k|                compare_fn(dest);
  243|  1.28k|                sim[dest] = sim[src] & ~sim[aux];
  244|  1.28k|                real[dest] = real[src] - real[aux];
  245|  1.28k|                break;
  246|  90.9k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 66.6k, False: 24.2k]
  |  Branch (246:44): [True: 66.6k, False: 0]
  |  Branch (246:65): [True: 66.6k, False: 0]
  |  Branch (246:85): [True: 972, False: 65.6k]
  ------------------
  247|       |                /* operator^ */
  248|    972|                compare_fn(dest);
  249|    972|                sim[dest] = sim[src] ^ sim[aux];
  250|    972|                real[dest] = real[src] ^ real[aux];
  251|    972|                break;
  252|  89.9k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 65.6k, False: 24.2k]
  |  Branch (252:44): [True: 65.6k, False: 0]
  |  Branch (252:64): [True: 2.20k, False: 63.4k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  2.20k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  2.20k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  2.20k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 2.20k, False: 0]
  ------------------
  257|  2.20k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 2.20k, False: 0]
  ------------------
  258|  2.20k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 2.20k, False: 0]
  ------------------
  259|  2.20k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 2.20k, False: 0]
  ------------------
  260|  2.20k|                break;
  261|  87.7k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 63.4k, False: 24.2k]
  |  Branch (261:44): [True: 63.4k, False: 0]
  |  Branch (261:64): [True: 2.66k, False: 60.8k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.66k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.66k, False: 0]
  ------------------
  264|  2.66k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.66k, False: 0]
  ------------------
  265|  2.66k|                break;
  266|  85.1k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 60.8k, False: 24.2k]
  |  Branch (266:44): [True: 60.8k, False: 0]
  |  Branch (266:64): [True: 2.61k, False: 58.2k]
  ------------------
  267|       |                /* Overlaps() */
  268|  2.61k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 2.61k, False: 0]
  ------------------
  269|  2.61k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 2.61k, False: 0]
  ------------------
  270|  2.61k|                break;
  271|  2.61k|            }
  272|   157k|        }
  273|  74.6k|    }
  274|       |    /* Fully compare the final state. */
  275|  2.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 1.46k, False: 629]
  ------------------
  276|  1.46k|        compare_fn(i);
  277|  1.46k|    }
  278|    629|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj1EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  35.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  35.2k|        auto it = real[idx].begin();
   44|  35.2k|        unsigned first = S::Size();
   45|  35.2k|        unsigned last = S::Size();
   46|   599k|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 564k, False: 35.2k]
  ------------------
   47|   564k|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 330k, False: 233k]
  |  Branch (47:53): [True: 156k, False: 173k]
  ------------------
   48|   564k|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 564k, False: 0]
  ------------------
   49|   564k|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 564k, False: 0]
  ------------------
   50|   564k|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 564k, False: 0]
  ------------------
   51|   564k|            if (match) {
  ------------------
  |  Branch (51:17): [True: 156k, False: 407k]
  ------------------
   52|   156k|                ++it;
   53|   156k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 26.1k, False: 130k]
  ------------------
   54|   156k|                last = i;
   55|   156k|            }
   56|   564k|        }
   57|  35.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 35.2k, False: 0]
  ------------------
   58|  35.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 35.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  35.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 35.2k, False: 0]
  ------------------
   61|  35.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 35.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  35.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 26.1k, False: 9.10k]
  ------------------
   64|  26.1k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 26.1k, False: 0]
  ------------------
   65|  26.1k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 26.1k, False: 0]
  ------------------
   66|  26.1k|        }
   67|       |        /* Count */
   68|  35.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 35.2k, False: 0]
  ------------------
   69|  35.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|    933|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|    933|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|    933|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|    933|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|    933|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|    933|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|    933|        auto it = real[idx].begin();
   44|    933|        unsigned first = S::Size();
   45|    933|        unsigned last = S::Size();
   46|    933|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|    933|            bool match = (it != real[idx].end()) && *it == i;
   48|    933|            assert(sim[idx][i] == real[idx][i]);
   49|    933|            assert(match == real[idx][i]);
   50|    933|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|    933|            if (match) {
   52|    933|                ++it;
   53|    933|                if (first == S::Size()) first = i;
   54|    933|                last = i;
   55|    933|            }
   56|    933|        }
   57|    933|        assert(it == real[idx].end());
   58|    933|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|    933|        assert(sim[idx].any() == real[idx].Any());
   61|    933|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|    933|        if (sim[idx].any()) {
   64|    933|            assert(first == real[idx].First());
   65|    933|            assert(last == real[idx].Last());
   66|    933|        }
   67|       |        /* Count */
   68|    933|        assert(sim[idx].count() == real[idx].Count());
   69|    933|    };
   70|       |
   71|   104k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   105k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 104k, False: 862]
  |  |  |  Branch (23:49): [True: 104k, False: 71]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   104k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   104k|        unsigned args = ReadByte(buffer);
   76|   104k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   104k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   104k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   104k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.69k, False: 101k]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 104k, False: 0]
  ------------------
   81|   104k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   212k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 212k, Folded]
  ------------------
   87|   212k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 185k, False: 27.6k]
  |  Branch (87:38): [True: 25.9k, False: 159k]
  ------------------
   88|       |                /* Set() (true) */
   89|  25.9k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  25.9k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 25.9k, False: 0]
  ------------------
   91|  25.9k|                sim[dest].set(val);
   92|  25.9k|                real[dest].Set(val);
   93|  25.9k|                break;
   94|   187k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 159k, False: 27.6k]
  |  Branch (94:45): [True: 7.04k, False: 152k]
  ------------------
   95|       |                /* Reset() */
   96|  7.04k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  7.04k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 7.04k, False: 0]
  ------------------
   98|  7.04k|                sim[dest].reset(val);
   99|  7.04k|                real[dest].Reset(val);
  100|  7.04k|                break;
  101|   179k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 152k, False: 27.6k]
  |  Branch (101:45): [True: 2.79k, False: 149k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  2.79k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  2.79k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 2.79k, False: 0]
  ------------------
  105|  2.79k|                sim[dest].set(val, args >> 7);
  106|  2.79k|                real[dest].Set(val, args >> 7);
  107|  2.79k|                break;
  108|   177k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 86.0k, False: 91.1k]
  |  Branch (108:42): [True: 1.32k, False: 84.6k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.32k|                sim.resize(sim.size() + 1);
  111|  1.32k|                real.resize(real.size() + 1);
  112|  1.32k|                break;
  113|   175k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 84.6k, False: 91.1k]
  |  Branch (113:42): [True: 900, False: 83.7k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    900|                unsigned val = ReadByte(buffer) % S::Size();
  116|    900|                std::bitset<S::Size()> newset;
  117|    900|                newset[val] = true;
  118|    900|                sim.push_back(newset);
  119|    900|                real.push_back(S::Singleton(val));
  120|    900|                break;
  121|   174k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 148k, False: 26.4k]
  |  Branch (121:45): [True: 5.09k, False: 143k]
  ------------------
  122|       |                /* Make random. */
  123|  5.09k|                compare_fn(dest);
  124|  5.09k|                sim[dest].reset();
  125|  5.09k|                real[dest] = S{};
  126|   167k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 162k, False: 5.09k]
  ------------------
  127|   162k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 81.4k, False: 81.4k]
  ------------------
  128|  81.4k|                        sim[dest][i] = true;
  129|  81.4k|                        real[dest].Set(i);
  130|  81.4k|                    }
  131|   162k|                }
  132|  5.09k|                break;
  133|   169k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 143k, False: 26.4k]
  |  Branch (133:45): [True: 5.38k, False: 138k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.38k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.38k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.38k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.38k|                compare_fn(dest);
  139|  5.38k|                sim[dest].reset();
  140|  5.38k|                real[dest] = {r1, r2, r3};
  141|  5.38k|                sim[dest].set(r1);
  142|  5.38k|                sim[dest].set(r2);
  143|  5.38k|                sim[dest].set(r3);
  144|  5.38k|                break;
  145|   164k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 138k, False: 26.4k]
  |  Branch (145:40): [True: 4.46k, False: 133k]
  ------------------
  146|       |                /* Destruct. */
  147|  4.46k|                compare_fn(sim.size() - 1);
  148|  4.46k|                sim.pop_back();
  149|  4.46k|                real.pop_back();
  150|  4.46k|                break;
  151|   160k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 75.0k, False: 84.9k]
  |  Branch (151:42): [True: 48.6k, False: 26.4k]
  |  Branch (151:62): [True: 730, False: 47.9k]
  ------------------
  152|       |                /* Copy construct. */
  153|    730|                sim.emplace_back(sim[src]);
  154|    730|                real.emplace_back(real[src]);
  155|    730|                break;
  156|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 132k, False: 26.4k]
  |  Branch (156:44): [True: 132k, False: 0]
  |  Branch (156:65): [True: 2.29k, False: 130k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.29k|                compare_fn(dest);
  159|  2.29k|                sim[dest] = sim[src];
  160|  2.29k|                real[dest] = real[src];
  161|  2.29k|                break;
  162|   157k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 130k, False: 26.4k]
  |  Branch (162:44): [True: 130k, False: 0]
  |  Branch (162:65): [True: 3.22k, False: 127k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.22k|                swap(sim[dest], sim[src]);
  165|  3.22k|                swap(real[dest], real[src]);
  166|  3.22k|                break;
  167|   153k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 72.6k, False: 81.1k]
  |  Branch (167:42): [True: 1.86k, False: 70.7k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  1.86k|                unsigned r1 = rng.randrange(S::Size());
  170|  1.86k|                unsigned r2 = rng.randrange(S::Size());
  171|  1.86k|                sim.emplace_back();
  172|  1.86k|                sim.back().set(r1);
  173|  1.86k|                sim.back().set(r2);
  174|  1.86k|                real.push_back(S{r1, r2});
  175|  1.86k|                break;
  176|   151k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 126k, False: 24.9k]
  |  Branch (176:45): [True: 3.52k, False: 123k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  3.52k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  3.52k|                compare_fn(dest);
  180|  3.52k|                sim[dest].reset();
  181|  54.9k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 51.4k, False: 3.52k]
  ------------------
  182|  3.52k|                real[dest] = S::Fill(len);
  183|  3.52k|                break;
  184|   148k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 123k, False: 24.9k]
  |  Branch (184:44): [True: 6.26k, False: 117k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.26k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.26k|                auto it = real[src].begin(), it_copy = it;
  189|   206k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 200k, False: 6.26k]
  ------------------
  190|   200k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.26k, False: 194k]
  ------------------
  191|   200k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 112k, False: 87.5k]
  |  Branch (191:61): [True: 49.3k, False: 63.4k]
  ------------------
  192|   200k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 200k, False: 0]
  ------------------
  193|   200k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 49.3k, False: 150k]
  ------------------
  194|   200k|                }
  195|  6.26k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.26k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|  74.9k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 68.7k, False: 6.26k]
  ------------------
  198|  68.7k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 34.1k, False: 34.5k]
  |  Branch (198:66): [True: 16.2k, False: 17.8k]
  ------------------
  199|  68.7k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 68.7k, False: 0]
  ------------------
  200|  68.7k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 16.2k, False: 52.4k]
  ------------------
  201|  68.7k|                }
  202|  6.26k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.26k, False: 0]
  ------------------
  203|  6.26k|                break;
  204|   142k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 117k, False: 24.9k]
  |  Branch (204:44): [True: 117k, False: 0]
  |  Branch (204:65): [True: 3.21k, False: 113k]
  ------------------
  205|       |                /* operator|= */
  206|  3.21k|                compare_fn(dest);
  207|  3.21k|                sim[dest] |= sim[src];
  208|  3.21k|                real[dest] |= real[src];
  209|  3.21k|                break;
  210|   138k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 113k, False: 24.9k]
  |  Branch (210:44): [True: 113k, False: 0]
  |  Branch (210:65): [True: 3.29k, False: 110k]
  ------------------
  211|       |                /* operator&= */
  212|  3.29k|                compare_fn(dest);
  213|  3.29k|                sim[dest] &= sim[src];
  214|  3.29k|                real[dest] &= real[src];
  215|  3.29k|                break;
  216|   135k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 110k, False: 24.9k]
  |  Branch (216:44): [True: 110k, False: 0]
  |  Branch (216:65): [True: 5.86k, False: 104k]
  ------------------
  217|       |                /* operator-= */
  218|  5.86k|                compare_fn(dest);
  219|  5.86k|                sim[dest] &= ~sim[src];
  220|  5.86k|                real[dest] -= real[src];
  221|  5.86k|                break;
  222|   129k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 104k, False: 24.9k]
  |  Branch (222:44): [True: 104k, False: 0]
  |  Branch (222:65): [True: 2.28k, False: 102k]
  ------------------
  223|       |                /* operator^= */
  224|  2.28k|                compare_fn(dest);
  225|  2.28k|                sim[dest] ^= sim[src];
  226|  2.28k|                real[dest] ^= real[src];
  227|  2.28k|                break;
  228|   127k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 102k, False: 24.9k]
  |  Branch (228:44): [True: 102k, False: 0]
  |  Branch (228:65): [True: 102k, False: 0]
  |  Branch (228:85): [True: 2.96k, False: 99.5k]
  ------------------
  229|       |                /* operator| */
  230|  2.96k|                compare_fn(dest);
  231|  2.96k|                sim[dest] = sim[src] | sim[aux];
  232|  2.96k|                real[dest] = real[src] | real[aux];
  233|  2.96k|                break;
  234|   124k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 99.5k, False: 24.9k]
  |  Branch (234:44): [True: 99.5k, False: 0]
  |  Branch (234:65): [True: 99.5k, False: 0]
  |  Branch (234:85): [True: 1.88k, False: 97.6k]
  ------------------
  235|       |                /* operator& */
  236|  1.88k|                compare_fn(dest);
  237|  1.88k|                sim[dest] = sim[src] & sim[aux];
  238|  1.88k|                real[dest] = real[src] & real[aux];
  239|  1.88k|                break;
  240|   122k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 97.6k, False: 24.9k]
  |  Branch (240:44): [True: 97.6k, False: 0]
  |  Branch (240:65): [True: 97.6k, False: 0]
  |  Branch (240:85): [True: 2.38k, False: 95.2k]
  ------------------
  241|       |                /* operator- */
  242|  2.38k|                compare_fn(dest);
  243|  2.38k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.38k|                real[dest] = real[src] - real[aux];
  245|  2.38k|                break;
  246|   120k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 95.2k, False: 24.9k]
  |  Branch (246:44): [True: 95.2k, False: 0]
  |  Branch (246:65): [True: 95.2k, False: 0]
  |  Branch (246:85): [True: 1.97k, False: 93.2k]
  ------------------
  247|       |                /* operator^ */
  248|  1.97k|                compare_fn(dest);
  249|  1.97k|                sim[dest] = sim[src] ^ sim[aux];
  250|  1.97k|                real[dest] = real[src] ^ real[aux];
  251|  1.97k|                break;
  252|   118k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 93.2k, False: 24.9k]
  |  Branch (252:44): [True: 93.2k, False: 0]
  |  Branch (252:64): [True: 4.31k, False: 88.9k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  4.31k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  4.31k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  4.31k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 4.31k, False: 0]
  ------------------
  257|  4.31k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 4.31k, False: 0]
  ------------------
  258|  4.31k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 4.31k, False: 0]
  ------------------
  259|  4.31k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 4.31k, False: 0]
  ------------------
  260|  4.31k|                break;
  261|   113k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 88.9k, False: 24.9k]
  |  Branch (261:44): [True: 88.9k, False: 0]
  |  Branch (261:64): [True: 2.33k, False: 86.6k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.33k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.33k, False: 0]
  ------------------
  264|  2.33k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.33k, False: 0]
  ------------------
  265|  2.33k|                break;
  266|   111k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 86.6k, False: 24.9k]
  |  Branch (266:44): [True: 86.6k, False: 0]
  |  Branch (266:64): [True: 3.06k, False: 83.5k]
  ------------------
  267|       |                /* Overlaps() */
  268|  3.06k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 3.06k, False: 0]
  ------------------
  269|  3.06k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 3.06k, False: 0]
  ------------------
  270|  3.06k|                break;
  271|  3.06k|            }
  272|   212k|        }
  273|   104k|    }
  274|       |    /* Fully compare the final state. */
  275|  3.15k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 2.22k, False: 933]
  ------------------
  276|  2.22k|        compare_fn(i);
  277|  2.22k|    }
  278|    933|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  46.8k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  46.8k|        auto it = real[idx].begin();
   44|  46.8k|        unsigned first = S::Size();
   45|  46.8k|        unsigned last = S::Size();
   46|  1.54M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 1.49M, False: 46.8k]
  ------------------
   47|  1.49M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 784k, False: 714k]
  |  Branch (47:53): [True: 318k, False: 466k]
  ------------------
   48|  1.49M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 1.49M, False: 0]
  ------------------
   49|  1.49M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 1.49M, False: 0]
  ------------------
   50|  1.49M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 1.49M, False: 0]
  ------------------
   51|  1.49M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 318k, False: 1.18M]
  ------------------
   52|   318k|                ++it;
   53|   318k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 32.5k, False: 285k]
  ------------------
   54|   318k|                last = i;
   55|   318k|            }
   56|  1.49M|        }
   57|  46.8k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 46.8k, False: 0]
  ------------------
   58|  46.8k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 46.8k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  46.8k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 46.8k, False: 0]
  ------------------
   61|  46.8k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 46.8k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  46.8k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 32.5k, False: 14.3k]
  ------------------
   64|  32.5k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 32.5k, False: 0]
  ------------------
   65|  32.5k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 32.5k, False: 0]
  ------------------
   66|  32.5k|        }
   67|       |        /* Count */
   68|  46.8k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 46.8k, False: 0]
  ------------------
   69|  46.8k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetIjEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|    933|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|    933|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|    933|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|    933|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|    933|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|    933|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|    933|        auto it = real[idx].begin();
   44|    933|        unsigned first = S::Size();
   45|    933|        unsigned last = S::Size();
   46|    933|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|    933|            bool match = (it != real[idx].end()) && *it == i;
   48|    933|            assert(sim[idx][i] == real[idx][i]);
   49|    933|            assert(match == real[idx][i]);
   50|    933|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|    933|            if (match) {
   52|    933|                ++it;
   53|    933|                if (first == S::Size()) first = i;
   54|    933|                last = i;
   55|    933|            }
   56|    933|        }
   57|    933|        assert(it == real[idx].end());
   58|    933|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|    933|        assert(sim[idx].any() == real[idx].Any());
   61|    933|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|    933|        if (sim[idx].any()) {
   64|    933|            assert(first == real[idx].First());
   65|    933|            assert(last == real[idx].Last());
   66|    933|        }
   67|       |        /* Count */
   68|    933|        assert(sim[idx].count() == real[idx].Count());
   69|    933|    };
   70|       |
   71|   104k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   105k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 104k, False: 862]
  |  |  |  Branch (23:49): [True: 104k, False: 71]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   104k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   104k|        unsigned args = ReadByte(buffer);
   76|   104k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   104k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   104k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   104k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.69k, False: 101k]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 2.69k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 104k, False: 0]
  ------------------
   81|   104k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   212k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 212k, Folded]
  ------------------
   87|   212k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 185k, False: 27.6k]
  |  Branch (87:38): [True: 25.9k, False: 159k]
  ------------------
   88|       |                /* Set() (true) */
   89|  25.9k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  25.9k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 25.9k, False: 0]
  ------------------
   91|  25.9k|                sim[dest].set(val);
   92|  25.9k|                real[dest].Set(val);
   93|  25.9k|                break;
   94|   187k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 159k, False: 27.6k]
  |  Branch (94:45): [True: 7.04k, False: 152k]
  ------------------
   95|       |                /* Reset() */
   96|  7.04k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  7.04k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 7.04k, False: 0]
  ------------------
   98|  7.04k|                sim[dest].reset(val);
   99|  7.04k|                real[dest].Reset(val);
  100|  7.04k|                break;
  101|   179k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 152k, False: 27.6k]
  |  Branch (101:45): [True: 2.79k, False: 149k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  2.79k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  2.79k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 2.79k, False: 0]
  ------------------
  105|  2.79k|                sim[dest].set(val, args >> 7);
  106|  2.79k|                real[dest].Set(val, args >> 7);
  107|  2.79k|                break;
  108|   177k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 86.0k, False: 91.1k]
  |  Branch (108:42): [True: 1.32k, False: 84.6k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.32k|                sim.resize(sim.size() + 1);
  111|  1.32k|                real.resize(real.size() + 1);
  112|  1.32k|                break;
  113|   175k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 84.6k, False: 91.1k]
  |  Branch (113:42): [True: 900, False: 83.7k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    900|                unsigned val = ReadByte(buffer) % S::Size();
  116|    900|                std::bitset<S::Size()> newset;
  117|    900|                newset[val] = true;
  118|    900|                sim.push_back(newset);
  119|    900|                real.push_back(S::Singleton(val));
  120|    900|                break;
  121|   174k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 148k, False: 26.4k]
  |  Branch (121:45): [True: 5.09k, False: 143k]
  ------------------
  122|       |                /* Make random. */
  123|  5.09k|                compare_fn(dest);
  124|  5.09k|                sim[dest].reset();
  125|  5.09k|                real[dest] = S{};
  126|   167k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 162k, False: 5.09k]
  ------------------
  127|   162k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 81.4k, False: 81.4k]
  ------------------
  128|  81.4k|                        sim[dest][i] = true;
  129|  81.4k|                        real[dest].Set(i);
  130|  81.4k|                    }
  131|   162k|                }
  132|  5.09k|                break;
  133|   169k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 143k, False: 26.4k]
  |  Branch (133:45): [True: 5.38k, False: 138k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.38k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.38k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.38k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.38k|                compare_fn(dest);
  139|  5.38k|                sim[dest].reset();
  140|  5.38k|                real[dest] = {r1, r2, r3};
  141|  5.38k|                sim[dest].set(r1);
  142|  5.38k|                sim[dest].set(r2);
  143|  5.38k|                sim[dest].set(r3);
  144|  5.38k|                break;
  145|   164k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 138k, False: 26.4k]
  |  Branch (145:40): [True: 4.46k, False: 133k]
  ------------------
  146|       |                /* Destruct. */
  147|  4.46k|                compare_fn(sim.size() - 1);
  148|  4.46k|                sim.pop_back();
  149|  4.46k|                real.pop_back();
  150|  4.46k|                break;
  151|   160k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 75.0k, False: 84.9k]
  |  Branch (151:42): [True: 48.6k, False: 26.4k]
  |  Branch (151:62): [True: 730, False: 47.9k]
  ------------------
  152|       |                /* Copy construct. */
  153|    730|                sim.emplace_back(sim[src]);
  154|    730|                real.emplace_back(real[src]);
  155|    730|                break;
  156|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 132k, False: 26.4k]
  |  Branch (156:44): [True: 132k, False: 0]
  |  Branch (156:65): [True: 2.29k, False: 130k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.29k|                compare_fn(dest);
  159|  2.29k|                sim[dest] = sim[src];
  160|  2.29k|                real[dest] = real[src];
  161|  2.29k|                break;
  162|   157k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 130k, False: 26.4k]
  |  Branch (162:44): [True: 130k, False: 0]
  |  Branch (162:65): [True: 3.22k, False: 127k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.22k|                swap(sim[dest], sim[src]);
  165|  3.22k|                swap(real[dest], real[src]);
  166|  3.22k|                break;
  167|   153k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 72.6k, False: 81.1k]
  |  Branch (167:42): [True: 1.86k, False: 70.7k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  1.86k|                unsigned r1 = rng.randrange(S::Size());
  170|  1.86k|                unsigned r2 = rng.randrange(S::Size());
  171|  1.86k|                sim.emplace_back();
  172|  1.86k|                sim.back().set(r1);
  173|  1.86k|                sim.back().set(r2);
  174|  1.86k|                real.push_back(S{r1, r2});
  175|  1.86k|                break;
  176|   151k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 126k, False: 24.9k]
  |  Branch (176:45): [True: 3.52k, False: 123k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  3.52k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  3.52k|                compare_fn(dest);
  180|  3.52k|                sim[dest].reset();
  181|  54.9k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 51.4k, False: 3.52k]
  ------------------
  182|  3.52k|                real[dest] = S::Fill(len);
  183|  3.52k|                break;
  184|   148k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 123k, False: 24.9k]
  |  Branch (184:44): [True: 6.26k, False: 117k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.26k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.26k|                auto it = real[src].begin(), it_copy = it;
  189|   206k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 200k, False: 6.26k]
  ------------------
  190|   200k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.26k, False: 194k]
  ------------------
  191|   200k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 112k, False: 87.5k]
  |  Branch (191:61): [True: 49.3k, False: 63.4k]
  ------------------
  192|   200k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 200k, False: 0]
  ------------------
  193|   200k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 49.3k, False: 150k]
  ------------------
  194|   200k|                }
  195|  6.26k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.26k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|  74.9k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 68.7k, False: 6.26k]
  ------------------
  198|  68.7k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 34.1k, False: 34.5k]
  |  Branch (198:66): [True: 16.2k, False: 17.8k]
  ------------------
  199|  68.7k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 68.7k, False: 0]
  ------------------
  200|  68.7k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 16.2k, False: 52.4k]
  ------------------
  201|  68.7k|                }
  202|  6.26k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.26k, False: 0]
  ------------------
  203|  6.26k|                break;
  204|   142k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 117k, False: 24.9k]
  |  Branch (204:44): [True: 117k, False: 0]
  |  Branch (204:65): [True: 3.21k, False: 113k]
  ------------------
  205|       |                /* operator|= */
  206|  3.21k|                compare_fn(dest);
  207|  3.21k|                sim[dest] |= sim[src];
  208|  3.21k|                real[dest] |= real[src];
  209|  3.21k|                break;
  210|   138k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 113k, False: 24.9k]
  |  Branch (210:44): [True: 113k, False: 0]
  |  Branch (210:65): [True: 3.29k, False: 110k]
  ------------------
  211|       |                /* operator&= */
  212|  3.29k|                compare_fn(dest);
  213|  3.29k|                sim[dest] &= sim[src];
  214|  3.29k|                real[dest] &= real[src];
  215|  3.29k|                break;
  216|   135k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 110k, False: 24.9k]
  |  Branch (216:44): [True: 110k, False: 0]
  |  Branch (216:65): [True: 5.86k, False: 104k]
  ------------------
  217|       |                /* operator-= */
  218|  5.86k|                compare_fn(dest);
  219|  5.86k|                sim[dest] &= ~sim[src];
  220|  5.86k|                real[dest] -= real[src];
  221|  5.86k|                break;
  222|   129k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 104k, False: 24.9k]
  |  Branch (222:44): [True: 104k, False: 0]
  |  Branch (222:65): [True: 2.28k, False: 102k]
  ------------------
  223|       |                /* operator^= */
  224|  2.28k|                compare_fn(dest);
  225|  2.28k|                sim[dest] ^= sim[src];
  226|  2.28k|                real[dest] ^= real[src];
  227|  2.28k|                break;
  228|   127k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 102k, False: 24.9k]
  |  Branch (228:44): [True: 102k, False: 0]
  |  Branch (228:65): [True: 102k, False: 0]
  |  Branch (228:85): [True: 2.96k, False: 99.5k]
  ------------------
  229|       |                /* operator| */
  230|  2.96k|                compare_fn(dest);
  231|  2.96k|                sim[dest] = sim[src] | sim[aux];
  232|  2.96k|                real[dest] = real[src] | real[aux];
  233|  2.96k|                break;
  234|   124k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 99.5k, False: 24.9k]
  |  Branch (234:44): [True: 99.5k, False: 0]
  |  Branch (234:65): [True: 99.5k, False: 0]
  |  Branch (234:85): [True: 1.88k, False: 97.6k]
  ------------------
  235|       |                /* operator& */
  236|  1.88k|                compare_fn(dest);
  237|  1.88k|                sim[dest] = sim[src] & sim[aux];
  238|  1.88k|                real[dest] = real[src] & real[aux];
  239|  1.88k|                break;
  240|   122k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 97.6k, False: 24.9k]
  |  Branch (240:44): [True: 97.6k, False: 0]
  |  Branch (240:65): [True: 97.6k, False: 0]
  |  Branch (240:85): [True: 2.38k, False: 95.2k]
  ------------------
  241|       |                /* operator- */
  242|  2.38k|                compare_fn(dest);
  243|  2.38k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.38k|                real[dest] = real[src] - real[aux];
  245|  2.38k|                break;
  246|   120k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 95.2k, False: 24.9k]
  |  Branch (246:44): [True: 95.2k, False: 0]
  |  Branch (246:65): [True: 95.2k, False: 0]
  |  Branch (246:85): [True: 1.97k, False: 93.2k]
  ------------------
  247|       |                /* operator^ */
  248|  1.97k|                compare_fn(dest);
  249|  1.97k|                sim[dest] = sim[src] ^ sim[aux];
  250|  1.97k|                real[dest] = real[src] ^ real[aux];
  251|  1.97k|                break;
  252|   118k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 93.2k, False: 24.9k]
  |  Branch (252:44): [True: 93.2k, False: 0]
  |  Branch (252:64): [True: 4.31k, False: 88.9k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  4.31k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  4.31k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  4.31k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 4.31k, False: 0]
  ------------------
  257|  4.31k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 4.31k, False: 0]
  ------------------
  258|  4.31k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 4.31k, False: 0]
  ------------------
  259|  4.31k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 4.31k, False: 0]
  ------------------
  260|  4.31k|                break;
  261|   113k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 88.9k, False: 24.9k]
  |  Branch (261:44): [True: 88.9k, False: 0]
  |  Branch (261:64): [True: 2.33k, False: 86.6k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.33k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.33k, False: 0]
  ------------------
  264|  2.33k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.33k, False: 0]
  ------------------
  265|  2.33k|                break;
  266|   111k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 86.6k, False: 24.9k]
  |  Branch (266:44): [True: 86.6k, False: 0]
  |  Branch (266:64): [True: 3.06k, False: 83.5k]
  ------------------
  267|       |                /* Overlaps() */
  268|  3.06k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 3.06k, False: 0]
  ------------------
  269|  3.06k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 3.06k, False: 0]
  ------------------
  270|  3.06k|                break;
  271|  3.06k|            }
  272|   212k|        }
  273|   104k|    }
  274|       |    /* Fully compare the final state. */
  275|  3.15k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 2.22k, False: 933]
  ------------------
  276|  2.22k|        compare_fn(i);
  277|  2.22k|    }
  278|    933|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetIjEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  46.8k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  46.8k|        auto it = real[idx].begin();
   44|  46.8k|        unsigned first = S::Size();
   45|  46.8k|        unsigned last = S::Size();
   46|  1.54M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 1.49M, False: 46.8k]
  ------------------
   47|  1.49M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 784k, False: 714k]
  |  Branch (47:53): [True: 318k, False: 466k]
  ------------------
   48|  1.49M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 1.49M, False: 0]
  ------------------
   49|  1.49M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 1.49M, False: 0]
  ------------------
   50|  1.49M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 1.49M, False: 0]
  ------------------
   51|  1.49M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 318k, False: 1.18M]
  ------------------
   52|   318k|                ++it;
   53|   318k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 32.5k, False: 285k]
  ------------------
   54|   318k|                last = i;
   55|   318k|            }
   56|  1.49M|        }
   57|  46.8k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 46.8k, False: 0]
  ------------------
   58|  46.8k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 46.8k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  46.8k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 46.8k, False: 0]
  ------------------
   61|  46.8k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 46.8k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  46.8k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 32.5k, False: 14.3k]
  ------------------
   64|  32.5k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 32.5k, False: 0]
  ------------------
   65|  32.5k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 32.5k, False: 0]
  ------------------
   66|  32.5k|        }
   67|       |        /* Count */
   68|  46.8k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 46.8k, False: 0]
  ------------------
   69|  46.8k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|    836|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|    836|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|    836|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|    836|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|    836|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|    836|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|    836|        auto it = real[idx].begin();
   44|    836|        unsigned first = S::Size();
   45|    836|        unsigned last = S::Size();
   46|    836|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|    836|            bool match = (it != real[idx].end()) && *it == i;
   48|    836|            assert(sim[idx][i] == real[idx][i]);
   49|    836|            assert(match == real[idx][i]);
   50|    836|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|    836|            if (match) {
   52|    836|                ++it;
   53|    836|                if (first == S::Size()) first = i;
   54|    836|                last = i;
   55|    836|            }
   56|    836|        }
   57|    836|        assert(it == real[idx].end());
   58|    836|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|    836|        assert(sim[idx].any() == real[idx].Any());
   61|    836|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|    836|        if (sim[idx].any()) {
   64|    836|            assert(first == real[idx].First());
   65|    836|            assert(last == real[idx].Last());
   66|    836|        }
   67|       |        /* Count */
   68|    836|        assert(sim[idx].count() == real[idx].Count());
   69|    836|    };
   70|       |
   71|  60.4k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|  61.3k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 60.5k, False: 806]
  |  |  |  Branch (23:49): [True: 60.4k, False: 30]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  60.4k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  60.4k|        unsigned args = ReadByte(buffer);
   76|  60.4k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  60.4k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  60.4k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  60.4k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.83k, False: 57.6k]
  |  Branch (80:9): [True: 2.83k, False: 0]
  |  Branch (80:9): [True: 2.83k, False: 0]
  |  Branch (80:9): [True: 2.83k, False: 0]
  |  Branch (80:9): [True: 57.6k, False: 0]
  |  Branch (80:9): [True: 57.6k, False: 0]
  |  Branch (80:9): [True: 57.6k, False: 0]
  |  Branch (80:9): [True: 57.6k, False: 0]
  |  Branch (80:9): [True: 60.4k, False: 0]
  ------------------
   81|  60.4k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   146k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 146k, Folded]
  ------------------
   87|   146k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 114k, False: 31.7k]
  |  Branch (87:38): [True: 9.55k, False: 105k]
  ------------------
   88|       |                /* Set() (true) */
   89|  9.55k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  9.55k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 9.55k, False: 0]
  ------------------
   91|  9.55k|                sim[dest].set(val);
   92|  9.55k|                real[dest].Set(val);
   93|  9.55k|                break;
   94|   136k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 105k, False: 31.7k]
  |  Branch (94:45): [True: 1.99k, False: 103k]
  ------------------
   95|       |                /* Reset() */
   96|  1.99k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  1.99k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 1.99k, False: 0]
  ------------------
   98|  1.99k|                sim[dest].reset(val);
   99|  1.99k|                real[dest].Reset(val);
  100|  1.99k|                break;
  101|   134k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 103k, False: 31.7k]
  |  Branch (101:45): [True: 1.43k, False: 101k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  1.43k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  1.43k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 1.43k, False: 0]
  ------------------
  105|  1.43k|                sim[dest].set(val, args >> 7);
  106|  1.43k|                real[dest].Set(val, args >> 7);
  107|  1.43k|                break;
  108|   133k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 89.2k, False: 44.1k]
  |  Branch (108:42): [True: 768, False: 88.5k]
  ------------------
  109|       |                /* Construct empty. */
  110|    768|                sim.resize(sim.size() + 1);
  111|    768|                real.resize(real.size() + 1);
  112|    768|                break;
  113|   132k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 88.5k, False: 44.1k]
  |  Branch (113:42): [True: 1.25k, False: 87.2k]
  ------------------
  114|       |                /* Construct singleton. */
  115|  1.25k|                unsigned val = ReadByte(buffer) % S::Size();
  116|  1.25k|                std::bitset<S::Size()> newset;
  117|  1.25k|                newset[val] = true;
  118|  1.25k|                sim.push_back(newset);
  119|  1.25k|                real.push_back(S::Singleton(val));
  120|  1.25k|                break;
  121|   131k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 100k, False: 30.8k]
  |  Branch (121:45): [True: 4.88k, False: 95.7k]
  ------------------
  122|       |                /* Make random. */
  123|  4.88k|                compare_fn(dest);
  124|  4.88k|                sim[dest].reset();
  125|  4.88k|                real[dest] = S{};
  126|   239k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 234k, False: 4.88k]
  ------------------
  127|   234k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 116k, False: 117k]
  ------------------
  128|   116k|                        sim[dest][i] = true;
  129|   116k|                        real[dest].Set(i);
  130|   116k|                    }
  131|   234k|                }
  132|  4.88k|                break;
  133|   126k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 95.7k, False: 30.8k]
  |  Branch (133:45): [True: 6.61k, False: 89.1k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  6.61k|                unsigned r1 = rng.randrange(S::Size());
  136|  6.61k|                unsigned r2 = rng.randrange(S::Size());
  137|  6.61k|                unsigned r3 = rng.randrange(S::Size());
  138|  6.61k|                compare_fn(dest);
  139|  6.61k|                sim[dest].reset();
  140|  6.61k|                real[dest] = {r1, r2, r3};
  141|  6.61k|                sim[dest].set(r1);
  142|  6.61k|                sim[dest].set(r2);
  143|  6.61k|                sim[dest].set(r3);
  144|  6.61k|                break;
  145|   119k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 89.1k, False: 30.8k]
  |  Branch (145:40): [True: 4.61k, False: 84.5k]
  ------------------
  146|       |                /* Destruct. */
  147|  4.61k|                compare_fn(sim.size() - 1);
  148|  4.61k|                sim.pop_back();
  149|  4.61k|                real.pop_back();
  150|  4.61k|                break;
  151|   115k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 75.1k, False: 40.1k]
  |  Branch (151:42): [True: 44.3k, False: 30.8k]
  |  Branch (151:62): [True: 559, False: 43.8k]
  ------------------
  152|       |                /* Copy construct. */
  153|    559|                sim.emplace_back(sim[src]);
  154|    559|                real.emplace_back(real[src]);
  155|    559|                break;
  156|   114k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 83.9k, False: 30.8k]
  |  Branch (156:44): [True: 83.9k, False: 0]
  |  Branch (156:65): [True: 1.09k, False: 82.8k]
  ------------------
  157|       |                /* Copy assign. */
  158|  1.09k|                compare_fn(dest);
  159|  1.09k|                sim[dest] = sim[src];
  160|  1.09k|                real[dest] = real[src];
  161|  1.09k|                break;
  162|   113k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 82.8k, False: 30.8k]
  |  Branch (162:44): [True: 82.8k, False: 0]
  |  Branch (162:65): [True: 1.21k, False: 81.6k]
  ------------------
  163|       |                /* swap() function. */
  164|  1.21k|                swap(sim[dest], sim[src]);
  165|  1.21k|                swap(real[dest], real[src]);
  166|  1.21k|                break;
  167|   112k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 73.5k, False: 38.9k]
  |  Branch (167:42): [True: 2.26k, False: 71.2k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.26k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.26k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.26k|                sim.emplace_back();
  172|  2.26k|                sim.back().set(r1);
  173|  2.26k|                sim.back().set(r2);
  174|  2.26k|                real.push_back(S{r1, r2});
  175|  2.26k|                break;
  176|   110k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 81.2k, False: 28.9k]
  |  Branch (176:45): [True: 2.35k, False: 78.9k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  2.35k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  2.35k|                compare_fn(dest);
  180|  2.35k|                sim[dest].reset();
  181|  50.1k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 47.7k, False: 2.35k]
  ------------------
  182|  2.35k|                real[dest] = S::Fill(len);
  183|  2.35k|                break;
  184|   107k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 78.9k, False: 28.9k]
  |  Branch (184:44): [True: 3.21k, False: 75.6k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  3.21k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  3.21k|                auto it = real[src].begin(), it_copy = it;
  189|   157k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 154k, False: 3.21k]
  ------------------
  190|   154k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 3.21k, False: 151k]
  ------------------
  191|   154k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 79.4k, False: 74.9k]
  |  Branch (191:61): [True: 24.0k, False: 55.3k]
  ------------------
  192|   154k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 154k, False: 0]
  ------------------
  193|   154k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 24.0k, False: 130k]
  ------------------
  194|   154k|                }
  195|  3.21k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 3.21k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   100k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 97.7k, False: 3.21k]
  ------------------
  198|  97.7k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 43.9k, False: 53.7k]
  |  Branch (198:66): [True: 14.7k, False: 29.2k]
  ------------------
  199|  97.7k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 97.7k, False: 0]
  ------------------
  200|  97.7k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 14.7k, False: 83.0k]
  ------------------
  201|  97.7k|                }
  202|  3.21k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 3.21k, False: 0]
  ------------------
  203|  3.21k|                break;
  204|   104k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 75.6k, False: 28.9k]
  |  Branch (204:44): [True: 75.6k, False: 0]
  |  Branch (204:65): [True: 1.98k, False: 73.7k]
  ------------------
  205|       |                /* operator|= */
  206|  1.98k|                compare_fn(dest);
  207|  1.98k|                sim[dest] |= sim[src];
  208|  1.98k|                real[dest] |= real[src];
  209|  1.98k|                break;
  210|   102k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 73.7k, False: 28.9k]
  |  Branch (210:44): [True: 73.7k, False: 0]
  |  Branch (210:65): [True: 1.22k, False: 72.4k]
  ------------------
  211|       |                /* operator&= */
  212|  1.22k|                compare_fn(dest);
  213|  1.22k|                sim[dest] &= sim[src];
  214|  1.22k|                real[dest] &= real[src];
  215|  1.22k|                break;
  216|   101k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 72.4k, False: 28.9k]
  |  Branch (216:44): [True: 72.4k, False: 0]
  |  Branch (216:65): [True: 1.67k, False: 70.8k]
  ------------------
  217|       |                /* operator-= */
  218|  1.67k|                compare_fn(dest);
  219|  1.67k|                sim[dest] &= ~sim[src];
  220|  1.67k|                real[dest] -= real[src];
  221|  1.67k|                break;
  222|  99.7k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 70.8k, False: 28.9k]
  |  Branch (222:44): [True: 70.8k, False: 0]
  |  Branch (222:65): [True: 1.66k, False: 69.1k]
  ------------------
  223|       |                /* operator^= */
  224|  1.66k|                compare_fn(dest);
  225|  1.66k|                sim[dest] ^= sim[src];
  226|  1.66k|                real[dest] ^= real[src];
  227|  1.66k|                break;
  228|  98.0k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 69.1k, False: 28.9k]
  |  Branch (228:44): [True: 69.1k, False: 0]
  |  Branch (228:65): [True: 69.1k, False: 0]
  |  Branch (228:85): [True: 2.81k, False: 66.3k]
  ------------------
  229|       |                /* operator| */
  230|  2.81k|                compare_fn(dest);
  231|  2.81k|                sim[dest] = sim[src] | sim[aux];
  232|  2.81k|                real[dest] = real[src] | real[aux];
  233|  2.81k|                break;
  234|  95.2k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 66.3k, False: 28.9k]
  |  Branch (234:44): [True: 66.3k, False: 0]
  |  Branch (234:65): [True: 66.3k, False: 0]
  |  Branch (234:85): [True: 1.51k, False: 64.8k]
  ------------------
  235|       |                /* operator& */
  236|  1.51k|                compare_fn(dest);
  237|  1.51k|                sim[dest] = sim[src] & sim[aux];
  238|  1.51k|                real[dest] = real[src] & real[aux];
  239|  1.51k|                break;
  240|  93.7k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 64.8k, False: 28.9k]
  |  Branch (240:44): [True: 64.8k, False: 0]
  |  Branch (240:65): [True: 64.8k, False: 0]
  |  Branch (240:85): [True: 1.36k, False: 63.4k]
  ------------------
  241|       |                /* operator- */
  242|  1.36k|                compare_fn(dest);
  243|  1.36k|                sim[dest] = sim[src] & ~sim[aux];
  244|  1.36k|                real[dest] = real[src] - real[aux];
  245|  1.36k|                break;
  246|  92.3k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 63.4k, False: 28.9k]
  |  Branch (246:44): [True: 63.4k, False: 0]
  |  Branch (246:65): [True: 63.4k, False: 0]
  |  Branch (246:85): [True: 945, False: 62.5k]
  ------------------
  247|       |                /* operator^ */
  248|    945|                compare_fn(dest);
  249|    945|                sim[dest] = sim[src] ^ sim[aux];
  250|    945|                real[dest] = real[src] ^ real[aux];
  251|    945|                break;
  252|  91.4k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 62.5k, False: 28.9k]
  |  Branch (252:44): [True: 62.5k, False: 0]
  |  Branch (252:64): [True: 1.99k, False: 60.5k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  1.99k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  1.99k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  1.99k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 1.99k, False: 0]
  ------------------
  257|  1.99k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 1.99k, False: 0]
  ------------------
  258|  1.99k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 1.99k, False: 0]
  ------------------
  259|  1.99k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 1.99k, False: 0]
  ------------------
  260|  1.99k|                break;
  261|  89.4k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 60.5k, False: 28.9k]
  |  Branch (261:44): [True: 60.5k, False: 0]
  |  Branch (261:64): [True: 1.52k, False: 58.9k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  1.52k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 1.52k, False: 0]
  ------------------
  264|  1.52k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 1.52k, False: 0]
  ------------------
  265|  1.52k|                break;
  266|  87.9k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 58.9k, False: 28.9k]
  |  Branch (266:44): [True: 58.9k, False: 0]
  |  Branch (266:64): [True: 1.94k, False: 57.0k]
  ------------------
  267|       |                /* Overlaps() */
  268|  1.94k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 1.94k, False: 0]
  ------------------
  269|  1.94k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 1.94k, False: 0]
  ------------------
  270|  1.94k|                break;
  271|  1.94k|            }
  272|   146k|        }
  273|  60.4k|    }
  274|       |    /* Fully compare the final state. */
  275|  2.73k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 1.90k, False: 836]
  ------------------
  276|  1.90k|        compare_fn(i);
  277|  1.90k|    }
  278|    836|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  34.6k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  34.6k|        auto it = real[idx].begin();
   44|  34.6k|        unsigned first = S::Size();
   45|  34.6k|        unsigned last = S::Size();
   46|  1.69M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 1.66M, False: 34.6k]
  ------------------
   47|  1.66M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 873k, False: 789k]
  |  Branch (47:53): [True: 311k, False: 562k]
  ------------------
   48|  1.66M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 1.66M, False: 0]
  ------------------
   49|  1.66M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 1.66M, False: 0]
  ------------------
   50|  1.66M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 1.66M, False: 0]
  ------------------
   51|  1.66M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 311k, False: 1.35M]
  ------------------
   52|   311k|                ++it;
   53|   311k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 25.6k, False: 285k]
  ------------------
   54|   311k|                last = i;
   55|   311k|            }
   56|  1.66M|        }
   57|  34.6k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 34.6k, False: 0]
  ------------------
   58|  34.6k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 34.6k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  34.6k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 34.6k, False: 0]
  ------------------
   61|  34.6k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 34.6k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  34.6k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 25.6k, False: 8.97k]
  ------------------
   64|  25.6k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 25.6k, False: 0]
  ------------------
   65|  25.6k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 25.6k, False: 0]
  ------------------
   66|  25.6k|        }
   67|       |        /* Count */
   68|  34.6k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 34.6k, False: 0]
  ------------------
   69|  34.6k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetImEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.56k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.56k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.56k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.56k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.56k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.56k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.56k|        auto it = real[idx].begin();
   44|  1.56k|        unsigned first = S::Size();
   45|  1.56k|        unsigned last = S::Size();
   46|  1.56k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.56k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.56k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.56k|            assert(match == real[idx][i]);
   50|  1.56k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.56k|            if (match) {
   52|  1.56k|                ++it;
   53|  1.56k|                if (first == S::Size()) first = i;
   54|  1.56k|                last = i;
   55|  1.56k|            }
   56|  1.56k|        }
   57|  1.56k|        assert(it == real[idx].end());
   58|  1.56k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.56k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.56k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.56k|        if (sim[idx].any()) {
   64|  1.56k|            assert(first == real[idx].First());
   65|  1.56k|            assert(last == real[idx].Last());
   66|  1.56k|        }
   67|       |        /* Count */
   68|  1.56k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.56k|    };
   70|       |
   71|   120k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   121k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 120k, False: 1.48k]
  |  |  |  Branch (23:49): [True: 120k, False: 83]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   120k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   120k|        unsigned args = ReadByte(buffer);
   76|   120k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   120k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   120k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   120k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.79k, False: 117k]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 120k, False: 0]
  ------------------
   81|   120k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   250k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 250k, Folded]
  ------------------
   87|   250k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 216k, False: 33.4k]
  |  Branch (87:38): [True: 28.1k, False: 188k]
  ------------------
   88|       |                /* Set() (true) */
   89|  28.1k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  28.1k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 28.1k, False: 0]
  ------------------
   91|  28.1k|                sim[dest].set(val);
   92|  28.1k|                real[dest].Set(val);
   93|  28.1k|                break;
   94|   222k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 188k, False: 33.4k]
  |  Branch (94:45): [True: 4.31k, False: 184k]
  ------------------
   95|       |                /* Reset() */
   96|  4.31k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  4.31k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 4.31k, False: 0]
  ------------------
   98|  4.31k|                sim[dest].reset(val);
   99|  4.31k|                real[dest].Reset(val);
  100|  4.31k|                break;
  101|   217k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 184k, False: 33.4k]
  |  Branch (101:45): [True: 3.92k, False: 180k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  3.92k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  3.92k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 3.92k, False: 0]
  ------------------
  105|  3.92k|                sim[dest].set(val, args >> 7);
  106|  3.92k|                real[dest].Set(val, args >> 7);
  107|  3.92k|                break;
  108|   214k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 114k, False: 99.6k]
  |  Branch (108:42): [True: 1.24k, False: 113k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.24k|                sim.resize(sim.size() + 1);
  111|  1.24k|                real.resize(real.size() + 1);
  112|  1.24k|                break;
  113|   212k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 113k, False: 99.6k]
  |  Branch (113:42): [True: 1.32k, False: 111k]
  ------------------
  114|       |                /* Construct singleton. */
  115|  1.32k|                unsigned val = ReadByte(buffer) % S::Size();
  116|  1.32k|                std::bitset<S::Size()> newset;
  117|  1.32k|                newset[val] = true;
  118|  1.32k|                sim.push_back(newset);
  119|  1.32k|                real.push_back(S::Singleton(val));
  120|  1.32k|                break;
  121|   211k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 178k, False: 32.5k]
  |  Branch (121:45): [True: 4.95k, False: 173k]
  ------------------
  122|       |                /* Make random. */
  123|  4.95k|                compare_fn(dest);
  124|  4.95k|                sim[dest].reset();
  125|  4.95k|                real[dest] = S{};
  126|   322k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 317k, False: 4.95k]
  ------------------
  127|   317k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 158k, False: 158k]
  ------------------
  128|   158k|                        sim[dest][i] = true;
  129|   158k|                        real[dest].Set(i);
  130|   158k|                    }
  131|   317k|                }
  132|  4.95k|                break;
  133|   206k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 173k, False: 32.5k]
  |  Branch (133:45): [True: 5.56k, False: 168k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.56k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.56k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.56k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.56k|                compare_fn(dest);
  139|  5.56k|                sim[dest].reset();
  140|  5.56k|                real[dest] = {r1, r2, r3};
  141|  5.56k|                sim[dest].set(r1);
  142|  5.56k|                sim[dest].set(r2);
  143|  5.56k|                sim[dest].set(r3);
  144|  5.56k|                break;
  145|   200k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 168k, False: 32.5k]
  |  Branch (145:40): [True: 5.79k, False: 162k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.79k|                compare_fn(sim.size() - 1);
  148|  5.79k|                sim.pop_back();
  149|  5.79k|                real.pop_back();
  150|  5.79k|                break;
  151|   195k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 102k, False: 93.1k]
  |  Branch (151:42): [True: 69.5k, False: 32.5k]
  |  Branch (151:62): [True: 1.10k, False: 68.4k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.10k|                sim.emplace_back(sim[src]);
  154|  1.10k|                real.emplace_back(real[src]);
  155|  1.10k|                break;
  156|   194k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 161k, False: 32.5k]
  |  Branch (156:44): [True: 161k, False: 0]
  |  Branch (156:65): [True: 4.17k, False: 157k]
  ------------------
  157|       |                /* Copy assign. */
  158|  4.17k|                compare_fn(dest);
  159|  4.17k|                sim[dest] = sim[src];
  160|  4.17k|                real[dest] = real[src];
  161|  4.17k|                break;
  162|   189k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 157k, False: 32.5k]
  |  Branch (162:44): [True: 157k, False: 0]
  |  Branch (162:65): [True: 3.93k, False: 153k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.93k|                swap(sim[dest], sim[src]);
  165|  3.93k|                swap(real[dest], real[src]);
  166|  3.93k|                break;
  167|   185k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 97.6k, False: 88.2k]
  |  Branch (167:42): [True: 2.51k, False: 95.1k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.51k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.51k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.51k|                sim.emplace_back();
  172|  2.51k|                sim.back().set(r1);
  173|  2.51k|                sim.back().set(r2);
  174|  2.51k|                real.push_back(S{r1, r2});
  175|  2.51k|                break;
  176|   183k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 152k, False: 30.6k]
  |  Branch (176:45): [True: 5.59k, False: 147k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  5.59k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  5.59k|                compare_fn(dest);
  180|  5.59k|                sim[dest].reset();
  181|   177k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 172k, False: 5.59k]
  ------------------
  182|  5.59k|                real[dest] = S::Fill(len);
  183|  5.59k|                break;
  184|   177k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 147k, False: 30.6k]
  |  Branch (184:44): [True: 6.47k, False: 140k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.47k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.47k|                auto it = real[src].begin(), it_copy = it;
  189|   420k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 414k, False: 6.47k]
  ------------------
  190|   414k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.47k, False: 407k]
  ------------------
  191|   414k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 218k, False: 195k]
  |  Branch (191:61): [True: 96.5k, False: 122k]
  ------------------
  192|   414k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 414k, False: 0]
  ------------------
  193|   414k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 96.5k, False: 317k]
  ------------------
  194|   414k|                }
  195|  6.47k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.47k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   153k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 147k, False: 6.47k]
  ------------------
  198|   147k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 74.4k, False: 72.9k]
  |  Branch (198:66): [True: 42.4k, False: 31.9k]
  ------------------
  199|   147k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 147k, False: 0]
  ------------------
  200|   147k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 42.4k, False: 104k]
  ------------------
  201|   147k|                }
  202|  6.47k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.47k, False: 0]
  ------------------
  203|  6.47k|                break;
  204|   171k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 140k, False: 30.6k]
  |  Branch (204:44): [True: 140k, False: 0]
  |  Branch (204:65): [True: 4.70k, False: 135k]
  ------------------
  205|       |                /* operator|= */
  206|  4.70k|                compare_fn(dest);
  207|  4.70k|                sim[dest] |= sim[src];
  208|  4.70k|                real[dest] |= real[src];
  209|  4.70k|                break;
  210|   166k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 135k, False: 30.6k]
  |  Branch (210:44): [True: 135k, False: 0]
  |  Branch (210:65): [True: 3.16k, False: 132k]
  ------------------
  211|       |                /* operator&= */
  212|  3.16k|                compare_fn(dest);
  213|  3.16k|                sim[dest] &= sim[src];
  214|  3.16k|                real[dest] &= real[src];
  215|  3.16k|                break;
  216|   163k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 132k, False: 30.6k]
  |  Branch (216:44): [True: 132k, False: 0]
  |  Branch (216:65): [True: 3.99k, False: 128k]
  ------------------
  217|       |                /* operator-= */
  218|  3.99k|                compare_fn(dest);
  219|  3.99k|                sim[dest] &= ~sim[src];
  220|  3.99k|                real[dest] -= real[src];
  221|  3.99k|                break;
  222|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 128k, False: 30.6k]
  |  Branch (222:44): [True: 128k, False: 0]
  |  Branch (222:65): [True: 3.59k, False: 125k]
  ------------------
  223|       |                /* operator^= */
  224|  3.59k|                compare_fn(dest);
  225|  3.59k|                sim[dest] ^= sim[src];
  226|  3.59k|                real[dest] ^= real[src];
  227|  3.59k|                break;
  228|   155k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 125k, False: 30.6k]
  |  Branch (228:44): [True: 125k, False: 0]
  |  Branch (228:65): [True: 125k, False: 0]
  |  Branch (228:85): [True: 4.54k, False: 120k]
  ------------------
  229|       |                /* operator| */
  230|  4.54k|                compare_fn(dest);
  231|  4.54k|                sim[dest] = sim[src] | sim[aux];
  232|  4.54k|                real[dest] = real[src] | real[aux];
  233|  4.54k|                break;
  234|   151k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 120k, False: 30.6k]
  |  Branch (234:44): [True: 120k, False: 0]
  |  Branch (234:65): [True: 120k, False: 0]
  |  Branch (234:85): [True: 3.21k, False: 117k]
  ------------------
  235|       |                /* operator& */
  236|  3.21k|                compare_fn(dest);
  237|  3.21k|                sim[dest] = sim[src] & sim[aux];
  238|  3.21k|                real[dest] = real[src] & real[aux];
  239|  3.21k|                break;
  240|   148k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 117k, False: 30.6k]
  |  Branch (240:44): [True: 117k, False: 0]
  |  Branch (240:65): [True: 117k, False: 0]
  |  Branch (240:85): [True: 2.82k, False: 114k]
  ------------------
  241|       |                /* operator- */
  242|  2.82k|                compare_fn(dest);
  243|  2.82k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.82k|                real[dest] = real[src] - real[aux];
  245|  2.82k|                break;
  246|   145k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 114k, False: 30.6k]
  |  Branch (246:44): [True: 114k, False: 0]
  |  Branch (246:65): [True: 114k, False: 0]
  |  Branch (246:85): [True: 2.60k, False: 111k]
  ------------------
  247|       |                /* operator^ */
  248|  2.60k|                compare_fn(dest);
  249|  2.60k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.60k|                real[dest] = real[src] ^ real[aux];
  251|  2.60k|                break;
  252|   142k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 111k, False: 30.6k]
  |  Branch (252:44): [True: 111k, False: 0]
  |  Branch (252:64): [True: 5.27k, False: 106k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  5.27k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  5.27k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  5.27k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 5.27k, False: 0]
  ------------------
  257|  5.27k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 5.27k, False: 0]
  ------------------
  258|  5.27k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 5.27k, False: 0]
  ------------------
  259|  5.27k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 5.27k, False: 0]
  ------------------
  260|  5.27k|                break;
  261|   137k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 106k, False: 30.6k]
  |  Branch (261:44): [True: 106k, False: 0]
  |  Branch (261:64): [True: 3.18k, False: 103k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.18k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.18k, False: 0]
  ------------------
  264|  3.18k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.18k, False: 0]
  ------------------
  265|  3.18k|                break;
  266|   134k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 103k, False: 30.6k]
  |  Branch (266:44): [True: 103k, False: 0]
  |  Branch (266:64): [True: 4.10k, False: 99.4k]
  ------------------
  267|       |                /* Overlaps() */
  268|  4.10k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 4.10k, False: 0]
  ------------------
  269|  4.10k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 4.10k, False: 0]
  ------------------
  270|  4.10k|                break;
  271|  4.10k|            }
  272|   250k|        }
  273|   120k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.52k, False: 1.56k]
  ------------------
  276|  3.52k|        compare_fn(i);
  277|  3.52k|    }
  278|  1.56k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail9IntBitSetImEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  58.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  58.2k|        auto it = real[idx].begin();
   44|  58.2k|        unsigned first = S::Size();
   45|  58.2k|        unsigned last = S::Size();
   46|  3.78M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 3.72M, False: 58.2k]
  ------------------
   47|  3.72M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 1.83M, False: 1.89M]
  |  Branch (47:53): [True: 743k, False: 1.09M]
  ------------------
   48|  3.72M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 3.72M, False: 0]
  ------------------
   49|  3.72M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 3.72M, False: 0]
  ------------------
   50|  3.72M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 3.72M, False: 0]
  ------------------
   51|  3.72M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 743k, False: 2.98M]
  ------------------
   52|   743k|                ++it;
   53|   743k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 39.2k, False: 703k]
  ------------------
   54|   743k|                last = i;
   55|   743k|            }
   56|  3.72M|        }
   57|  58.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 58.2k, False: 0]
  ------------------
   58|  58.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 58.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  58.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 58.2k, False: 0]
  ------------------
   61|  58.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 58.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  58.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 39.2k, False: 18.9k]
  ------------------
   64|  39.2k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 39.2k, False: 0]
  ------------------
   65|  39.2k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 39.2k, False: 0]
  ------------------
   66|  39.2k|        }
   67|       |        /* Count */
   68|  58.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 58.2k, False: 0]
  ------------------
   69|  58.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj1EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.56k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.56k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.56k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.56k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.56k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.56k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.56k|        auto it = real[idx].begin();
   44|  1.56k|        unsigned first = S::Size();
   45|  1.56k|        unsigned last = S::Size();
   46|  1.56k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.56k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.56k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.56k|            assert(match == real[idx][i]);
   50|  1.56k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.56k|            if (match) {
   52|  1.56k|                ++it;
   53|  1.56k|                if (first == S::Size()) first = i;
   54|  1.56k|                last = i;
   55|  1.56k|            }
   56|  1.56k|        }
   57|  1.56k|        assert(it == real[idx].end());
   58|  1.56k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.56k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.56k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.56k|        if (sim[idx].any()) {
   64|  1.56k|            assert(first == real[idx].First());
   65|  1.56k|            assert(last == real[idx].Last());
   66|  1.56k|        }
   67|       |        /* Count */
   68|  1.56k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.56k|    };
   70|       |
   71|   120k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   121k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 120k, False: 1.48k]
  |  |  |  Branch (23:49): [True: 120k, False: 83]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   120k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   120k|        unsigned args = ReadByte(buffer);
   76|   120k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   120k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   120k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   120k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.79k, False: 117k]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 120k, False: 0]
  ------------------
   81|   120k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   250k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 250k, Folded]
  ------------------
   87|   250k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 216k, False: 33.4k]
  |  Branch (87:38): [True: 28.1k, False: 188k]
  ------------------
   88|       |                /* Set() (true) */
   89|  28.1k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  28.1k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 28.1k, False: 0]
  ------------------
   91|  28.1k|                sim[dest].set(val);
   92|  28.1k|                real[dest].Set(val);
   93|  28.1k|                break;
   94|   222k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 188k, False: 33.4k]
  |  Branch (94:45): [True: 4.31k, False: 184k]
  ------------------
   95|       |                /* Reset() */
   96|  4.31k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  4.31k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 4.31k, False: 0]
  ------------------
   98|  4.31k|                sim[dest].reset(val);
   99|  4.31k|                real[dest].Reset(val);
  100|  4.31k|                break;
  101|   217k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 184k, False: 33.4k]
  |  Branch (101:45): [True: 3.92k, False: 180k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  3.92k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  3.92k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 3.92k, False: 0]
  ------------------
  105|  3.92k|                sim[dest].set(val, args >> 7);
  106|  3.92k|                real[dest].Set(val, args >> 7);
  107|  3.92k|                break;
  108|   214k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 114k, False: 99.6k]
  |  Branch (108:42): [True: 1.24k, False: 113k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.24k|                sim.resize(sim.size() + 1);
  111|  1.24k|                real.resize(real.size() + 1);
  112|  1.24k|                break;
  113|   212k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 113k, False: 99.6k]
  |  Branch (113:42): [True: 1.32k, False: 111k]
  ------------------
  114|       |                /* Construct singleton. */
  115|  1.32k|                unsigned val = ReadByte(buffer) % S::Size();
  116|  1.32k|                std::bitset<S::Size()> newset;
  117|  1.32k|                newset[val] = true;
  118|  1.32k|                sim.push_back(newset);
  119|  1.32k|                real.push_back(S::Singleton(val));
  120|  1.32k|                break;
  121|   211k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 178k, False: 32.5k]
  |  Branch (121:45): [True: 4.95k, False: 173k]
  ------------------
  122|       |                /* Make random. */
  123|  4.95k|                compare_fn(dest);
  124|  4.95k|                sim[dest].reset();
  125|  4.95k|                real[dest] = S{};
  126|   322k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 317k, False: 4.95k]
  ------------------
  127|   317k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 158k, False: 158k]
  ------------------
  128|   158k|                        sim[dest][i] = true;
  129|   158k|                        real[dest].Set(i);
  130|   158k|                    }
  131|   317k|                }
  132|  4.95k|                break;
  133|   206k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 173k, False: 32.5k]
  |  Branch (133:45): [True: 5.56k, False: 168k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.56k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.56k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.56k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.56k|                compare_fn(dest);
  139|  5.56k|                sim[dest].reset();
  140|  5.56k|                real[dest] = {r1, r2, r3};
  141|  5.56k|                sim[dest].set(r1);
  142|  5.56k|                sim[dest].set(r2);
  143|  5.56k|                sim[dest].set(r3);
  144|  5.56k|                break;
  145|   200k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 168k, False: 32.5k]
  |  Branch (145:40): [True: 5.79k, False: 162k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.79k|                compare_fn(sim.size() - 1);
  148|  5.79k|                sim.pop_back();
  149|  5.79k|                real.pop_back();
  150|  5.79k|                break;
  151|   195k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 102k, False: 93.1k]
  |  Branch (151:42): [True: 69.5k, False: 32.5k]
  |  Branch (151:62): [True: 1.10k, False: 68.4k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.10k|                sim.emplace_back(sim[src]);
  154|  1.10k|                real.emplace_back(real[src]);
  155|  1.10k|                break;
  156|   194k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 161k, False: 32.5k]
  |  Branch (156:44): [True: 161k, False: 0]
  |  Branch (156:65): [True: 4.17k, False: 157k]
  ------------------
  157|       |                /* Copy assign. */
  158|  4.17k|                compare_fn(dest);
  159|  4.17k|                sim[dest] = sim[src];
  160|  4.17k|                real[dest] = real[src];
  161|  4.17k|                break;
  162|   189k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 157k, False: 32.5k]
  |  Branch (162:44): [True: 157k, False: 0]
  |  Branch (162:65): [True: 3.93k, False: 153k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.93k|                swap(sim[dest], sim[src]);
  165|  3.93k|                swap(real[dest], real[src]);
  166|  3.93k|                break;
  167|   185k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 97.6k, False: 88.2k]
  |  Branch (167:42): [True: 2.51k, False: 95.1k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.51k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.51k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.51k|                sim.emplace_back();
  172|  2.51k|                sim.back().set(r1);
  173|  2.51k|                sim.back().set(r2);
  174|  2.51k|                real.push_back(S{r1, r2});
  175|  2.51k|                break;
  176|   183k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 152k, False: 30.6k]
  |  Branch (176:45): [True: 5.59k, False: 147k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  5.59k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  5.59k|                compare_fn(dest);
  180|  5.59k|                sim[dest].reset();
  181|   177k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 172k, False: 5.59k]
  ------------------
  182|  5.59k|                real[dest] = S::Fill(len);
  183|  5.59k|                break;
  184|   177k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 147k, False: 30.6k]
  |  Branch (184:44): [True: 6.47k, False: 140k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.47k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.47k|                auto it = real[src].begin(), it_copy = it;
  189|   420k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 414k, False: 6.47k]
  ------------------
  190|   414k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.47k, False: 407k]
  ------------------
  191|   414k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 218k, False: 195k]
  |  Branch (191:61): [True: 96.5k, False: 122k]
  ------------------
  192|   414k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 414k, False: 0]
  ------------------
  193|   414k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 96.5k, False: 317k]
  ------------------
  194|   414k|                }
  195|  6.47k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.47k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   153k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 147k, False: 6.47k]
  ------------------
  198|   147k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 74.4k, False: 72.9k]
  |  Branch (198:66): [True: 42.4k, False: 31.9k]
  ------------------
  199|   147k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 147k, False: 0]
  ------------------
  200|   147k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 42.4k, False: 104k]
  ------------------
  201|   147k|                }
  202|  6.47k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.47k, False: 0]
  ------------------
  203|  6.47k|                break;
  204|   171k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 140k, False: 30.6k]
  |  Branch (204:44): [True: 140k, False: 0]
  |  Branch (204:65): [True: 4.70k, False: 135k]
  ------------------
  205|       |                /* operator|= */
  206|  4.70k|                compare_fn(dest);
  207|  4.70k|                sim[dest] |= sim[src];
  208|  4.70k|                real[dest] |= real[src];
  209|  4.70k|                break;
  210|   166k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 135k, False: 30.6k]
  |  Branch (210:44): [True: 135k, False: 0]
  |  Branch (210:65): [True: 3.16k, False: 132k]
  ------------------
  211|       |                /* operator&= */
  212|  3.16k|                compare_fn(dest);
  213|  3.16k|                sim[dest] &= sim[src];
  214|  3.16k|                real[dest] &= real[src];
  215|  3.16k|                break;
  216|   163k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 132k, False: 30.6k]
  |  Branch (216:44): [True: 132k, False: 0]
  |  Branch (216:65): [True: 3.99k, False: 128k]
  ------------------
  217|       |                /* operator-= */
  218|  3.99k|                compare_fn(dest);
  219|  3.99k|                sim[dest] &= ~sim[src];
  220|  3.99k|                real[dest] -= real[src];
  221|  3.99k|                break;
  222|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 128k, False: 30.6k]
  |  Branch (222:44): [True: 128k, False: 0]
  |  Branch (222:65): [True: 3.59k, False: 125k]
  ------------------
  223|       |                /* operator^= */
  224|  3.59k|                compare_fn(dest);
  225|  3.59k|                sim[dest] ^= sim[src];
  226|  3.59k|                real[dest] ^= real[src];
  227|  3.59k|                break;
  228|   155k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 125k, False: 30.6k]
  |  Branch (228:44): [True: 125k, False: 0]
  |  Branch (228:65): [True: 125k, False: 0]
  |  Branch (228:85): [True: 4.54k, False: 120k]
  ------------------
  229|       |                /* operator| */
  230|  4.54k|                compare_fn(dest);
  231|  4.54k|                sim[dest] = sim[src] | sim[aux];
  232|  4.54k|                real[dest] = real[src] | real[aux];
  233|  4.54k|                break;
  234|   151k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 120k, False: 30.6k]
  |  Branch (234:44): [True: 120k, False: 0]
  |  Branch (234:65): [True: 120k, False: 0]
  |  Branch (234:85): [True: 3.21k, False: 117k]
  ------------------
  235|       |                /* operator& */
  236|  3.21k|                compare_fn(dest);
  237|  3.21k|                sim[dest] = sim[src] & sim[aux];
  238|  3.21k|                real[dest] = real[src] & real[aux];
  239|  3.21k|                break;
  240|   148k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 117k, False: 30.6k]
  |  Branch (240:44): [True: 117k, False: 0]
  |  Branch (240:65): [True: 117k, False: 0]
  |  Branch (240:85): [True: 2.82k, False: 114k]
  ------------------
  241|       |                /* operator- */
  242|  2.82k|                compare_fn(dest);
  243|  2.82k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.82k|                real[dest] = real[src] - real[aux];
  245|  2.82k|                break;
  246|   145k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 114k, False: 30.6k]
  |  Branch (246:44): [True: 114k, False: 0]
  |  Branch (246:65): [True: 114k, False: 0]
  |  Branch (246:85): [True: 2.60k, False: 111k]
  ------------------
  247|       |                /* operator^ */
  248|  2.60k|                compare_fn(dest);
  249|  2.60k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.60k|                real[dest] = real[src] ^ real[aux];
  251|  2.60k|                break;
  252|   142k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 111k, False: 30.6k]
  |  Branch (252:44): [True: 111k, False: 0]
  |  Branch (252:64): [True: 5.27k, False: 106k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  5.27k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  5.27k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  5.27k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 5.27k, False: 0]
  ------------------
  257|  5.27k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 5.27k, False: 0]
  ------------------
  258|  5.27k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 5.27k, False: 0]
  ------------------
  259|  5.27k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 5.27k, False: 0]
  ------------------
  260|  5.27k|                break;
  261|   137k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 106k, False: 30.6k]
  |  Branch (261:44): [True: 106k, False: 0]
  |  Branch (261:64): [True: 3.18k, False: 103k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.18k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.18k, False: 0]
  ------------------
  264|  3.18k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.18k, False: 0]
  ------------------
  265|  3.18k|                break;
  266|   134k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 103k, False: 30.6k]
  |  Branch (266:44): [True: 103k, False: 0]
  |  Branch (266:64): [True: 4.10k, False: 99.4k]
  ------------------
  267|       |                /* Overlaps() */
  268|  4.10k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 4.10k, False: 0]
  ------------------
  269|  4.10k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 4.10k, False: 0]
  ------------------
  270|  4.10k|                break;
  271|  4.10k|            }
  272|   250k|        }
  273|   120k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.52k, False: 1.56k]
  ------------------
  276|  3.52k|        compare_fn(i);
  277|  3.52k|    }
  278|  1.56k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj1EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  58.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  58.2k|        auto it = real[idx].begin();
   44|  58.2k|        unsigned first = S::Size();
   45|  58.2k|        unsigned last = S::Size();
   46|  3.78M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 3.72M, False: 58.2k]
  ------------------
   47|  3.72M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 1.83M, False: 1.89M]
  |  Branch (47:53): [True: 743k, False: 1.09M]
  ------------------
   48|  3.72M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 3.72M, False: 0]
  ------------------
   49|  3.72M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 3.72M, False: 0]
  ------------------
   50|  3.72M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 3.72M, False: 0]
  ------------------
   51|  3.72M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 743k, False: 2.98M]
  ------------------
   52|   743k|                ++it;
   53|   743k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 39.2k, False: 703k]
  ------------------
   54|   743k|                last = i;
   55|   743k|            }
   56|  3.72M|        }
   57|  58.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 58.2k, False: 0]
  ------------------
   58|  58.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 58.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  58.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 58.2k, False: 0]
  ------------------
   61|  58.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 58.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  58.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 39.2k, False: 18.9k]
  ------------------
   64|  39.2k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 39.2k, False: 0]
  ------------------
   65|  39.2k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 39.2k, False: 0]
  ------------------
   66|  39.2k|        }
   67|       |        /* Count */
   68|  58.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 58.2k, False: 0]
  ------------------
   69|  58.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.56k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.56k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.56k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.56k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.56k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.56k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.56k|        auto it = real[idx].begin();
   44|  1.56k|        unsigned first = S::Size();
   45|  1.56k|        unsigned last = S::Size();
   46|  1.56k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.56k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.56k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.56k|            assert(match == real[idx][i]);
   50|  1.56k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.56k|            if (match) {
   52|  1.56k|                ++it;
   53|  1.56k|                if (first == S::Size()) first = i;
   54|  1.56k|                last = i;
   55|  1.56k|            }
   56|  1.56k|        }
   57|  1.56k|        assert(it == real[idx].end());
   58|  1.56k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.56k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.56k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.56k|        if (sim[idx].any()) {
   64|  1.56k|            assert(first == real[idx].First());
   65|  1.56k|            assert(last == real[idx].Last());
   66|  1.56k|        }
   67|       |        /* Count */
   68|  1.56k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.56k|    };
   70|       |
   71|   120k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   121k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 120k, False: 1.48k]
  |  |  |  Branch (23:49): [True: 120k, False: 83]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   120k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   120k|        unsigned args = ReadByte(buffer);
   76|   120k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   120k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   120k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   120k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.79k, False: 117k]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 120k, False: 0]
  ------------------
   81|   120k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   250k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 250k, Folded]
  ------------------
   87|   250k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 216k, False: 33.4k]
  |  Branch (87:38): [True: 28.1k, False: 188k]
  ------------------
   88|       |                /* Set() (true) */
   89|  28.1k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  28.1k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 28.1k, False: 0]
  ------------------
   91|  28.1k|                sim[dest].set(val);
   92|  28.1k|                real[dest].Set(val);
   93|  28.1k|                break;
   94|   222k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 188k, False: 33.4k]
  |  Branch (94:45): [True: 4.31k, False: 184k]
  ------------------
   95|       |                /* Reset() */
   96|  4.31k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  4.31k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 4.31k, False: 0]
  ------------------
   98|  4.31k|                sim[dest].reset(val);
   99|  4.31k|                real[dest].Reset(val);
  100|  4.31k|                break;
  101|   217k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 184k, False: 33.4k]
  |  Branch (101:45): [True: 3.92k, False: 180k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  3.92k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  3.92k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 3.92k, False: 0]
  ------------------
  105|  3.92k|                sim[dest].set(val, args >> 7);
  106|  3.92k|                real[dest].Set(val, args >> 7);
  107|  3.92k|                break;
  108|   214k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 114k, False: 99.6k]
  |  Branch (108:42): [True: 1.24k, False: 113k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.24k|                sim.resize(sim.size() + 1);
  111|  1.24k|                real.resize(real.size() + 1);
  112|  1.24k|                break;
  113|   212k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 113k, False: 99.6k]
  |  Branch (113:42): [True: 1.32k, False: 111k]
  ------------------
  114|       |                /* Construct singleton. */
  115|  1.32k|                unsigned val = ReadByte(buffer) % S::Size();
  116|  1.32k|                std::bitset<S::Size()> newset;
  117|  1.32k|                newset[val] = true;
  118|  1.32k|                sim.push_back(newset);
  119|  1.32k|                real.push_back(S::Singleton(val));
  120|  1.32k|                break;
  121|   211k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 178k, False: 32.5k]
  |  Branch (121:45): [True: 4.95k, False: 173k]
  ------------------
  122|       |                /* Make random. */
  123|  4.95k|                compare_fn(dest);
  124|  4.95k|                sim[dest].reset();
  125|  4.95k|                real[dest] = S{};
  126|   322k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 317k, False: 4.95k]
  ------------------
  127|   317k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 158k, False: 158k]
  ------------------
  128|   158k|                        sim[dest][i] = true;
  129|   158k|                        real[dest].Set(i);
  130|   158k|                    }
  131|   317k|                }
  132|  4.95k|                break;
  133|   206k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 173k, False: 32.5k]
  |  Branch (133:45): [True: 5.56k, False: 168k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.56k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.56k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.56k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.56k|                compare_fn(dest);
  139|  5.56k|                sim[dest].reset();
  140|  5.56k|                real[dest] = {r1, r2, r3};
  141|  5.56k|                sim[dest].set(r1);
  142|  5.56k|                sim[dest].set(r2);
  143|  5.56k|                sim[dest].set(r3);
  144|  5.56k|                break;
  145|   200k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 168k, False: 32.5k]
  |  Branch (145:40): [True: 5.79k, False: 162k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.79k|                compare_fn(sim.size() - 1);
  148|  5.79k|                sim.pop_back();
  149|  5.79k|                real.pop_back();
  150|  5.79k|                break;
  151|   195k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 102k, False: 93.1k]
  |  Branch (151:42): [True: 69.5k, False: 32.5k]
  |  Branch (151:62): [True: 1.10k, False: 68.4k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.10k|                sim.emplace_back(sim[src]);
  154|  1.10k|                real.emplace_back(real[src]);
  155|  1.10k|                break;
  156|   194k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 161k, False: 32.5k]
  |  Branch (156:44): [True: 161k, False: 0]
  |  Branch (156:65): [True: 4.17k, False: 157k]
  ------------------
  157|       |                /* Copy assign. */
  158|  4.17k|                compare_fn(dest);
  159|  4.17k|                sim[dest] = sim[src];
  160|  4.17k|                real[dest] = real[src];
  161|  4.17k|                break;
  162|   189k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 157k, False: 32.5k]
  |  Branch (162:44): [True: 157k, False: 0]
  |  Branch (162:65): [True: 3.93k, False: 153k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.93k|                swap(sim[dest], sim[src]);
  165|  3.93k|                swap(real[dest], real[src]);
  166|  3.93k|                break;
  167|   185k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 97.6k, False: 88.2k]
  |  Branch (167:42): [True: 2.51k, False: 95.1k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.51k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.51k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.51k|                sim.emplace_back();
  172|  2.51k|                sim.back().set(r1);
  173|  2.51k|                sim.back().set(r2);
  174|  2.51k|                real.push_back(S{r1, r2});
  175|  2.51k|                break;
  176|   183k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 152k, False: 30.6k]
  |  Branch (176:45): [True: 5.59k, False: 147k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  5.59k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  5.59k|                compare_fn(dest);
  180|  5.59k|                sim[dest].reset();
  181|   177k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 172k, False: 5.59k]
  ------------------
  182|  5.59k|                real[dest] = S::Fill(len);
  183|  5.59k|                break;
  184|   177k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 147k, False: 30.6k]
  |  Branch (184:44): [True: 6.47k, False: 140k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.47k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.47k|                auto it = real[src].begin(), it_copy = it;
  189|   420k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 414k, False: 6.47k]
  ------------------
  190|   414k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.47k, False: 407k]
  ------------------
  191|   414k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 218k, False: 195k]
  |  Branch (191:61): [True: 96.5k, False: 122k]
  ------------------
  192|   414k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 414k, False: 0]
  ------------------
  193|   414k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 96.5k, False: 317k]
  ------------------
  194|   414k|                }
  195|  6.47k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.47k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   153k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 147k, False: 6.47k]
  ------------------
  198|   147k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 74.4k, False: 72.9k]
  |  Branch (198:66): [True: 42.4k, False: 31.9k]
  ------------------
  199|   147k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 147k, False: 0]
  ------------------
  200|   147k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 42.4k, False: 104k]
  ------------------
  201|   147k|                }
  202|  6.47k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.47k, False: 0]
  ------------------
  203|  6.47k|                break;
  204|   171k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 140k, False: 30.6k]
  |  Branch (204:44): [True: 140k, False: 0]
  |  Branch (204:65): [True: 4.70k, False: 135k]
  ------------------
  205|       |                /* operator|= */
  206|  4.70k|                compare_fn(dest);
  207|  4.70k|                sim[dest] |= sim[src];
  208|  4.70k|                real[dest] |= real[src];
  209|  4.70k|                break;
  210|   166k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 135k, False: 30.6k]
  |  Branch (210:44): [True: 135k, False: 0]
  |  Branch (210:65): [True: 3.16k, False: 132k]
  ------------------
  211|       |                /* operator&= */
  212|  3.16k|                compare_fn(dest);
  213|  3.16k|                sim[dest] &= sim[src];
  214|  3.16k|                real[dest] &= real[src];
  215|  3.16k|                break;
  216|   163k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 132k, False: 30.6k]
  |  Branch (216:44): [True: 132k, False: 0]
  |  Branch (216:65): [True: 3.99k, False: 128k]
  ------------------
  217|       |                /* operator-= */
  218|  3.99k|                compare_fn(dest);
  219|  3.99k|                sim[dest] &= ~sim[src];
  220|  3.99k|                real[dest] -= real[src];
  221|  3.99k|                break;
  222|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 128k, False: 30.6k]
  |  Branch (222:44): [True: 128k, False: 0]
  |  Branch (222:65): [True: 3.59k, False: 125k]
  ------------------
  223|       |                /* operator^= */
  224|  3.59k|                compare_fn(dest);
  225|  3.59k|                sim[dest] ^= sim[src];
  226|  3.59k|                real[dest] ^= real[src];
  227|  3.59k|                break;
  228|   155k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 125k, False: 30.6k]
  |  Branch (228:44): [True: 125k, False: 0]
  |  Branch (228:65): [True: 125k, False: 0]
  |  Branch (228:85): [True: 4.54k, False: 120k]
  ------------------
  229|       |                /* operator| */
  230|  4.54k|                compare_fn(dest);
  231|  4.54k|                sim[dest] = sim[src] | sim[aux];
  232|  4.54k|                real[dest] = real[src] | real[aux];
  233|  4.54k|                break;
  234|   151k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 120k, False: 30.6k]
  |  Branch (234:44): [True: 120k, False: 0]
  |  Branch (234:65): [True: 120k, False: 0]
  |  Branch (234:85): [True: 3.21k, False: 117k]
  ------------------
  235|       |                /* operator& */
  236|  3.21k|                compare_fn(dest);
  237|  3.21k|                sim[dest] = sim[src] & sim[aux];
  238|  3.21k|                real[dest] = real[src] & real[aux];
  239|  3.21k|                break;
  240|   148k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 117k, False: 30.6k]
  |  Branch (240:44): [True: 117k, False: 0]
  |  Branch (240:65): [True: 117k, False: 0]
  |  Branch (240:85): [True: 2.82k, False: 114k]
  ------------------
  241|       |                /* operator- */
  242|  2.82k|                compare_fn(dest);
  243|  2.82k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.82k|                real[dest] = real[src] - real[aux];
  245|  2.82k|                break;
  246|   145k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 114k, False: 30.6k]
  |  Branch (246:44): [True: 114k, False: 0]
  |  Branch (246:65): [True: 114k, False: 0]
  |  Branch (246:85): [True: 2.60k, False: 111k]
  ------------------
  247|       |                /* operator^ */
  248|  2.60k|                compare_fn(dest);
  249|  2.60k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.60k|                real[dest] = real[src] ^ real[aux];
  251|  2.60k|                break;
  252|   142k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 111k, False: 30.6k]
  |  Branch (252:44): [True: 111k, False: 0]
  |  Branch (252:64): [True: 5.27k, False: 106k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  5.27k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  5.27k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  5.27k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 5.27k, False: 0]
  ------------------
  257|  5.27k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 5.27k, False: 0]
  ------------------
  258|  5.27k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 5.27k, False: 0]
  ------------------
  259|  5.27k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 5.27k, False: 0]
  ------------------
  260|  5.27k|                break;
  261|   137k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 106k, False: 30.6k]
  |  Branch (261:44): [True: 106k, False: 0]
  |  Branch (261:64): [True: 3.18k, False: 103k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.18k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.18k, False: 0]
  ------------------
  264|  3.18k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.18k, False: 0]
  ------------------
  265|  3.18k|                break;
  266|   134k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 103k, False: 30.6k]
  |  Branch (266:44): [True: 103k, False: 0]
  |  Branch (266:64): [True: 4.10k, False: 99.4k]
  ------------------
  267|       |                /* Overlaps() */
  268|  4.10k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 4.10k, False: 0]
  ------------------
  269|  4.10k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 4.10k, False: 0]
  ------------------
  270|  4.10k|                break;
  271|  4.10k|            }
  272|   250k|        }
  273|   120k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.52k, False: 1.56k]
  ------------------
  276|  3.52k|        compare_fn(i);
  277|  3.52k|    }
  278|  1.56k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  58.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  58.2k|        auto it = real[idx].begin();
   44|  58.2k|        unsigned first = S::Size();
   45|  58.2k|        unsigned last = S::Size();
   46|  3.78M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 3.72M, False: 58.2k]
  ------------------
   47|  3.72M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 1.83M, False: 1.89M]
  |  Branch (47:53): [True: 743k, False: 1.09M]
  ------------------
   48|  3.72M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 3.72M, False: 0]
  ------------------
   49|  3.72M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 3.72M, False: 0]
  ------------------
   50|  3.72M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 3.72M, False: 0]
  ------------------
   51|  3.72M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 743k, False: 2.98M]
  ------------------
   52|   743k|                ++it;
   53|   743k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 39.2k, False: 703k]
  ------------------
   54|   743k|                last = i;
   55|   743k|            }
   56|  3.72M|        }
   57|  58.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 58.2k, False: 0]
  ------------------
   58|  58.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 58.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  58.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 58.2k, False: 0]
  ------------------
   61|  58.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 58.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  58.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 39.2k, False: 18.9k]
  ------------------
   64|  39.2k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 39.2k, False: 0]
  ------------------
   65|  39.2k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 39.2k, False: 0]
  ------------------
   66|  39.2k|        }
   67|       |        /* Count */
   68|  58.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 58.2k, False: 0]
  ------------------
   69|  58.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.56k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.56k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.56k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.56k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.56k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.56k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.56k|        auto it = real[idx].begin();
   44|  1.56k|        unsigned first = S::Size();
   45|  1.56k|        unsigned last = S::Size();
   46|  1.56k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.56k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.56k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.56k|            assert(match == real[idx][i]);
   50|  1.56k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.56k|            if (match) {
   52|  1.56k|                ++it;
   53|  1.56k|                if (first == S::Size()) first = i;
   54|  1.56k|                last = i;
   55|  1.56k|            }
   56|  1.56k|        }
   57|  1.56k|        assert(it == real[idx].end());
   58|  1.56k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.56k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.56k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.56k|        if (sim[idx].any()) {
   64|  1.56k|            assert(first == real[idx].First());
   65|  1.56k|            assert(last == real[idx].Last());
   66|  1.56k|        }
   67|       |        /* Count */
   68|  1.56k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.56k|    };
   70|       |
   71|   120k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   121k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 120k, False: 1.48k]
  |  |  |  Branch (23:49): [True: 120k, False: 83]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   120k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   120k|        unsigned args = ReadByte(buffer);
   76|   120k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   120k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   120k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   120k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.79k, False: 117k]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 2.79k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 117k, False: 0]
  |  Branch (80:9): [True: 120k, False: 0]
  ------------------
   81|   120k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   250k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 250k, Folded]
  ------------------
   87|   250k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 216k, False: 33.4k]
  |  Branch (87:38): [True: 28.1k, False: 188k]
  ------------------
   88|       |                /* Set() (true) */
   89|  28.1k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  28.1k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 28.1k, False: 0]
  ------------------
   91|  28.1k|                sim[dest].set(val);
   92|  28.1k|                real[dest].Set(val);
   93|  28.1k|                break;
   94|   222k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 188k, False: 33.4k]
  |  Branch (94:45): [True: 4.31k, False: 184k]
  ------------------
   95|       |                /* Reset() */
   96|  4.31k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  4.31k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 4.31k, False: 0]
  ------------------
   98|  4.31k|                sim[dest].reset(val);
   99|  4.31k|                real[dest].Reset(val);
  100|  4.31k|                break;
  101|   217k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 184k, False: 33.4k]
  |  Branch (101:45): [True: 3.92k, False: 180k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  3.92k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  3.92k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 3.92k, False: 0]
  ------------------
  105|  3.92k|                sim[dest].set(val, args >> 7);
  106|  3.92k|                real[dest].Set(val, args >> 7);
  107|  3.92k|                break;
  108|   214k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 114k, False: 99.6k]
  |  Branch (108:42): [True: 1.24k, False: 113k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.24k|                sim.resize(sim.size() + 1);
  111|  1.24k|                real.resize(real.size() + 1);
  112|  1.24k|                break;
  113|   212k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 113k, False: 99.6k]
  |  Branch (113:42): [True: 1.32k, False: 111k]
  ------------------
  114|       |                /* Construct singleton. */
  115|  1.32k|                unsigned val = ReadByte(buffer) % S::Size();
  116|  1.32k|                std::bitset<S::Size()> newset;
  117|  1.32k|                newset[val] = true;
  118|  1.32k|                sim.push_back(newset);
  119|  1.32k|                real.push_back(S::Singleton(val));
  120|  1.32k|                break;
  121|   211k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 178k, False: 32.5k]
  |  Branch (121:45): [True: 4.95k, False: 173k]
  ------------------
  122|       |                /* Make random. */
  123|  4.95k|                compare_fn(dest);
  124|  4.95k|                sim[dest].reset();
  125|  4.95k|                real[dest] = S{};
  126|   322k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 317k, False: 4.95k]
  ------------------
  127|   317k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 158k, False: 158k]
  ------------------
  128|   158k|                        sim[dest][i] = true;
  129|   158k|                        real[dest].Set(i);
  130|   158k|                    }
  131|   317k|                }
  132|  4.95k|                break;
  133|   206k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 173k, False: 32.5k]
  |  Branch (133:45): [True: 5.56k, False: 168k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.56k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.56k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.56k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.56k|                compare_fn(dest);
  139|  5.56k|                sim[dest].reset();
  140|  5.56k|                real[dest] = {r1, r2, r3};
  141|  5.56k|                sim[dest].set(r1);
  142|  5.56k|                sim[dest].set(r2);
  143|  5.56k|                sim[dest].set(r3);
  144|  5.56k|                break;
  145|   200k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 168k, False: 32.5k]
  |  Branch (145:40): [True: 5.79k, False: 162k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.79k|                compare_fn(sim.size() - 1);
  148|  5.79k|                sim.pop_back();
  149|  5.79k|                real.pop_back();
  150|  5.79k|                break;
  151|   195k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 102k, False: 93.1k]
  |  Branch (151:42): [True: 69.5k, False: 32.5k]
  |  Branch (151:62): [True: 1.10k, False: 68.4k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.10k|                sim.emplace_back(sim[src]);
  154|  1.10k|                real.emplace_back(real[src]);
  155|  1.10k|                break;
  156|   194k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 161k, False: 32.5k]
  |  Branch (156:44): [True: 161k, False: 0]
  |  Branch (156:65): [True: 4.17k, False: 157k]
  ------------------
  157|       |                /* Copy assign. */
  158|  4.17k|                compare_fn(dest);
  159|  4.17k|                sim[dest] = sim[src];
  160|  4.17k|                real[dest] = real[src];
  161|  4.17k|                break;
  162|   189k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 157k, False: 32.5k]
  |  Branch (162:44): [True: 157k, False: 0]
  |  Branch (162:65): [True: 3.93k, False: 153k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.93k|                swap(sim[dest], sim[src]);
  165|  3.93k|                swap(real[dest], real[src]);
  166|  3.93k|                break;
  167|   185k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 97.6k, False: 88.2k]
  |  Branch (167:42): [True: 2.51k, False: 95.1k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.51k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.51k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.51k|                sim.emplace_back();
  172|  2.51k|                sim.back().set(r1);
  173|  2.51k|                sim.back().set(r2);
  174|  2.51k|                real.push_back(S{r1, r2});
  175|  2.51k|                break;
  176|   183k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 152k, False: 30.6k]
  |  Branch (176:45): [True: 5.59k, False: 147k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  5.59k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  5.59k|                compare_fn(dest);
  180|  5.59k|                sim[dest].reset();
  181|   177k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 172k, False: 5.59k]
  ------------------
  182|  5.59k|                real[dest] = S::Fill(len);
  183|  5.59k|                break;
  184|   177k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 147k, False: 30.6k]
  |  Branch (184:44): [True: 6.47k, False: 140k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.47k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.47k|                auto it = real[src].begin(), it_copy = it;
  189|   420k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 414k, False: 6.47k]
  ------------------
  190|   414k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.47k, False: 407k]
  ------------------
  191|   414k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 218k, False: 195k]
  |  Branch (191:61): [True: 96.5k, False: 122k]
  ------------------
  192|   414k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 414k, False: 0]
  ------------------
  193|   414k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 96.5k, False: 317k]
  ------------------
  194|   414k|                }
  195|  6.47k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.47k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   153k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 147k, False: 6.47k]
  ------------------
  198|   147k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 74.4k, False: 72.9k]
  |  Branch (198:66): [True: 42.4k, False: 31.9k]
  ------------------
  199|   147k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 147k, False: 0]
  ------------------
  200|   147k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 42.4k, False: 104k]
  ------------------
  201|   147k|                }
  202|  6.47k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.47k, False: 0]
  ------------------
  203|  6.47k|                break;
  204|   171k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 140k, False: 30.6k]
  |  Branch (204:44): [True: 140k, False: 0]
  |  Branch (204:65): [True: 4.70k, False: 135k]
  ------------------
  205|       |                /* operator|= */
  206|  4.70k|                compare_fn(dest);
  207|  4.70k|                sim[dest] |= sim[src];
  208|  4.70k|                real[dest] |= real[src];
  209|  4.70k|                break;
  210|   166k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 135k, False: 30.6k]
  |  Branch (210:44): [True: 135k, False: 0]
  |  Branch (210:65): [True: 3.16k, False: 132k]
  ------------------
  211|       |                /* operator&= */
  212|  3.16k|                compare_fn(dest);
  213|  3.16k|                sim[dest] &= sim[src];
  214|  3.16k|                real[dest] &= real[src];
  215|  3.16k|                break;
  216|   163k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 132k, False: 30.6k]
  |  Branch (216:44): [True: 132k, False: 0]
  |  Branch (216:65): [True: 3.99k, False: 128k]
  ------------------
  217|       |                /* operator-= */
  218|  3.99k|                compare_fn(dest);
  219|  3.99k|                sim[dest] &= ~sim[src];
  220|  3.99k|                real[dest] -= real[src];
  221|  3.99k|                break;
  222|   159k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 128k, False: 30.6k]
  |  Branch (222:44): [True: 128k, False: 0]
  |  Branch (222:65): [True: 3.59k, False: 125k]
  ------------------
  223|       |                /* operator^= */
  224|  3.59k|                compare_fn(dest);
  225|  3.59k|                sim[dest] ^= sim[src];
  226|  3.59k|                real[dest] ^= real[src];
  227|  3.59k|                break;
  228|   155k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 125k, False: 30.6k]
  |  Branch (228:44): [True: 125k, False: 0]
  |  Branch (228:65): [True: 125k, False: 0]
  |  Branch (228:85): [True: 4.54k, False: 120k]
  ------------------
  229|       |                /* operator| */
  230|  4.54k|                compare_fn(dest);
  231|  4.54k|                sim[dest] = sim[src] | sim[aux];
  232|  4.54k|                real[dest] = real[src] | real[aux];
  233|  4.54k|                break;
  234|   151k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 120k, False: 30.6k]
  |  Branch (234:44): [True: 120k, False: 0]
  |  Branch (234:65): [True: 120k, False: 0]
  |  Branch (234:85): [True: 3.21k, False: 117k]
  ------------------
  235|       |                /* operator& */
  236|  3.21k|                compare_fn(dest);
  237|  3.21k|                sim[dest] = sim[src] & sim[aux];
  238|  3.21k|                real[dest] = real[src] & real[aux];
  239|  3.21k|                break;
  240|   148k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 117k, False: 30.6k]
  |  Branch (240:44): [True: 117k, False: 0]
  |  Branch (240:65): [True: 117k, False: 0]
  |  Branch (240:85): [True: 2.82k, False: 114k]
  ------------------
  241|       |                /* operator- */
  242|  2.82k|                compare_fn(dest);
  243|  2.82k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.82k|                real[dest] = real[src] - real[aux];
  245|  2.82k|                break;
  246|   145k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 114k, False: 30.6k]
  |  Branch (246:44): [True: 114k, False: 0]
  |  Branch (246:65): [True: 114k, False: 0]
  |  Branch (246:85): [True: 2.60k, False: 111k]
  ------------------
  247|       |                /* operator^ */
  248|  2.60k|                compare_fn(dest);
  249|  2.60k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.60k|                real[dest] = real[src] ^ real[aux];
  251|  2.60k|                break;
  252|   142k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 111k, False: 30.6k]
  |  Branch (252:44): [True: 111k, False: 0]
  |  Branch (252:64): [True: 5.27k, False: 106k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  5.27k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  5.27k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  5.27k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 5.27k, False: 0]
  ------------------
  257|  5.27k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 5.27k, False: 0]
  ------------------
  258|  5.27k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 5.27k, False: 0]
  ------------------
  259|  5.27k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 5.27k, False: 0]
  ------------------
  260|  5.27k|                break;
  261|   137k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 106k, False: 30.6k]
  |  Branch (261:44): [True: 106k, False: 0]
  |  Branch (261:64): [True: 3.18k, False: 103k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.18k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.18k, False: 0]
  ------------------
  264|  3.18k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.18k, False: 0]
  ------------------
  265|  3.18k|                break;
  266|   134k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 103k, False: 30.6k]
  |  Branch (266:44): [True: 103k, False: 0]
  |  Branch (266:64): [True: 4.10k, False: 99.4k]
  ------------------
  267|       |                /* Overlaps() */
  268|  4.10k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 4.10k, False: 0]
  ------------------
  269|  4.10k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 4.10k, False: 0]
  ------------------
  270|  4.10k|                break;
  271|  4.10k|            }
  272|   250k|        }
  273|   120k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.09k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.52k, False: 1.56k]
  ------------------
  276|  3.52k|        compare_fn(i);
  277|  3.52k|    }
  278|  1.56k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetItLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  58.2k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  58.2k|        auto it = real[idx].begin();
   44|  58.2k|        unsigned first = S::Size();
   45|  58.2k|        unsigned last = S::Size();
   46|  3.78M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 3.72M, False: 58.2k]
  ------------------
   47|  3.72M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 1.83M, False: 1.89M]
  |  Branch (47:53): [True: 743k, False: 1.09M]
  ------------------
   48|  3.72M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 3.72M, False: 0]
  ------------------
   49|  3.72M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 3.72M, False: 0]
  ------------------
   50|  3.72M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 3.72M, False: 0]
  ------------------
   51|  3.72M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 743k, False: 2.98M]
  ------------------
   52|   743k|                ++it;
   53|   743k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 39.2k, False: 703k]
  ------------------
   54|   743k|                last = i;
   55|   743k|            }
   56|  3.72M|        }
   57|  58.2k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 58.2k, False: 0]
  ------------------
   58|  58.2k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 58.2k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  58.2k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 58.2k, False: 0]
  ------------------
   61|  58.2k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 58.2k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  58.2k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 39.2k, False: 18.9k]
  ------------------
   64|  39.2k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 39.2k, False: 0]
  ------------------
   65|  39.2k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 39.2k, False: 0]
  ------------------
   66|  39.2k|        }
   67|       |        /* Count */
   68|  58.2k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 58.2k, False: 0]
  ------------------
   69|  58.2k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.36k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.36k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.36k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.36k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.36k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.36k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.36k|        auto it = real[idx].begin();
   44|  1.36k|        unsigned first = S::Size();
   45|  1.36k|        unsigned last = S::Size();
   46|  1.36k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.36k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.36k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.36k|            assert(match == real[idx][i]);
   50|  1.36k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.36k|            if (match) {
   52|  1.36k|                ++it;
   53|  1.36k|                if (first == S::Size()) first = i;
   54|  1.36k|                last = i;
   55|  1.36k|            }
   56|  1.36k|        }
   57|  1.36k|        assert(it == real[idx].end());
   58|  1.36k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.36k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.36k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.36k|        if (sim[idx].any()) {
   64|  1.36k|            assert(first == real[idx].First());
   65|  1.36k|            assert(last == real[idx].Last());
   66|  1.36k|        }
   67|       |        /* Count */
   68|  1.36k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.36k|    };
   70|       |
   71|  64.3k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|  65.7k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 64.4k, False: 1.32k]
  |  |  |  Branch (23:49): [True: 64.3k, False: 33]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  64.3k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  64.3k|        unsigned args = ReadByte(buffer);
   76|  64.3k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  64.3k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  64.3k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  64.3k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 3.09k, False: 61.2k]
  |  Branch (80:9): [True: 3.09k, False: 0]
  |  Branch (80:9): [True: 3.09k, False: 0]
  |  Branch (80:9): [True: 3.09k, False: 0]
  |  Branch (80:9): [True: 61.2k, False: 0]
  |  Branch (80:9): [True: 61.2k, False: 0]
  |  Branch (80:9): [True: 61.2k, False: 0]
  |  Branch (80:9): [True: 61.2k, False: 0]
  |  Branch (80:9): [True: 64.3k, False: 0]
  ------------------
   81|  64.3k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   161k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 161k, Folded]
  ------------------
   87|   161k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 123k, False: 37.7k]
  |  Branch (87:38): [True: 7.68k, False: 116k]
  ------------------
   88|       |                /* Set() (true) */
   89|  7.68k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  7.68k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 7.68k, False: 0]
  ------------------
   91|  7.68k|                sim[dest].set(val);
   92|  7.68k|                real[dest].Set(val);
   93|  7.68k|                break;
   94|   153k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 116k, False: 37.7k]
  |  Branch (94:45): [True: 2.25k, False: 114k]
  ------------------
   95|       |                /* Reset() */
   96|  2.25k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  2.25k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 2.25k, False: 0]
  ------------------
   98|  2.25k|                sim[dest].reset(val);
   99|  2.25k|                real[dest].Reset(val);
  100|  2.25k|                break;
  101|   151k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 114k, False: 37.7k]
  |  Branch (101:45): [True: 1.53k, False: 112k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  1.53k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  1.53k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 1.53k, False: 0]
  ------------------
  105|  1.53k|                sim[dest].set(val, args >> 7);
  106|  1.53k|                real[dest].Set(val, args >> 7);
  107|  1.53k|                break;
  108|   150k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 97.8k, False: 52.3k]
  |  Branch (108:42): [True: 950, False: 96.8k]
  ------------------
  109|       |                /* Construct empty. */
  110|    950|                sim.resize(sim.size() + 1);
  111|    950|                real.resize(real.size() + 1);
  112|    950|                break;
  113|   149k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 96.8k, False: 52.3k]
  |  Branch (113:42): [True: 549, False: 96.3k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    549|                unsigned val = ReadByte(buffer) % S::Size();
  116|    549|                std::bitset<S::Size()> newset;
  117|    549|                newset[val] = true;
  118|    549|                sim.push_back(newset);
  119|    549|                real.push_back(S::Singleton(val));
  120|    549|                break;
  121|   148k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 111k, False: 36.8k]
  |  Branch (121:45): [True: 4.02k, False: 107k]
  ------------------
  122|       |                /* Make random. */
  123|  4.02k|                compare_fn(dest);
  124|  4.02k|                sim[dest].reset();
  125|  4.02k|                real[dest] = S{};
  126|   390k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 386k, False: 4.02k]
  ------------------
  127|   386k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 193k, False: 192k]
  ------------------
  128|   193k|                        sim[dest][i] = true;
  129|   193k|                        real[dest].Set(i);
  130|   193k|                    }
  131|   386k|                }
  132|  4.02k|                break;
  133|   144k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 107k, False: 36.8k]
  |  Branch (133:45): [True: 5.86k, False: 102k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.86k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.86k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.86k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.86k|                compare_fn(dest);
  139|  5.86k|                sim[dest].reset();
  140|  5.86k|                real[dest] = {r1, r2, r3};
  141|  5.86k|                sim[dest].set(r1);
  142|  5.86k|                sim[dest].set(r2);
  143|  5.86k|                sim[dest].set(r3);
  144|  5.86k|                break;
  145|   138k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 102k, False: 36.8k]
  |  Branch (145:40): [True: 4.43k, False: 97.5k]
  ------------------
  146|       |                /* Destruct. */
  147|  4.43k|                compare_fn(sim.size() - 1);
  148|  4.43k|                sim.pop_back();
  149|  4.43k|                real.pop_back();
  150|  4.43k|                break;
  151|   134k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 86.0k, False: 48.3k]
  |  Branch (151:42): [True: 49.2k, False: 36.8k]
  |  Branch (151:62): [True: 643, False: 48.6k]
  ------------------
  152|       |                /* Copy construct. */
  153|    643|                sim.emplace_back(sim[src]);
  154|    643|                real.emplace_back(real[src]);
  155|    643|                break;
  156|   133k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 96.9k, False: 36.8k]
  |  Branch (156:44): [True: 96.9k, False: 0]
  |  Branch (156:65): [True: 2.22k, False: 94.7k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.22k|                compare_fn(dest);
  159|  2.22k|                sim[dest] = sim[src];
  160|  2.22k|                real[dest] = real[src];
  161|  2.22k|                break;
  162|   131k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 94.7k, False: 36.8k]
  |  Branch (162:44): [True: 94.7k, False: 0]
  |  Branch (162:65): [True: 1.91k, False: 92.7k]
  ------------------
  163|       |                /* swap() function. */
  164|  1.91k|                swap(sim[dest], sim[src]);
  165|  1.91k|                swap(real[dest], real[src]);
  166|  1.91k|                break;
  167|   129k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 83.7k, False: 45.8k]
  |  Branch (167:42): [True: 2.61k, False: 81.0k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.61k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.61k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.61k|                sim.emplace_back();
  172|  2.61k|                sim.back().set(r1);
  173|  2.61k|                sim.back().set(r2);
  174|  2.61k|                real.push_back(S{r1, r2});
  175|  2.61k|                break;
  176|   126k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 92.3k, False: 34.6k]
  |  Branch (176:45): [True: 3.01k, False: 89.3k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  3.01k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  3.01k|                compare_fn(dest);
  180|  3.01k|                sim[dest].reset();
  181|   141k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 138k, False: 3.01k]
  ------------------
  182|  3.01k|                real[dest] = S::Fill(len);
  183|  3.01k|                break;
  184|   123k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 89.3k, False: 34.6k]
  |  Branch (184:44): [True: 4.61k, False: 84.7k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  4.61k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  4.61k|                auto it = real[src].begin(), it_copy = it;
  189|   447k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 442k, False: 4.61k]
  ------------------
  190|   442k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 4.61k, False: 438k]
  ------------------
  191|   442k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 284k, False: 158k]
  |  Branch (191:61): [True: 127k, False: 156k]
  ------------------
  192|   442k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 442k, False: 0]
  ------------------
  193|   442k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 127k, False: 315k]
  ------------------
  194|   442k|                }
  195|  4.61k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 4.61k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   254k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 250k, False: 4.61k]
  ------------------
  198|   250k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 149k, False: 101k]
  |  Branch (198:66): [True: 72.9k, False: 76.2k]
  ------------------
  199|   250k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 250k, False: 0]
  ------------------
  200|   250k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 72.9k, False: 177k]
  ------------------
  201|   250k|                }
  202|  4.61k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 4.61k, False: 0]
  ------------------
  203|  4.61k|                break;
  204|   119k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 84.7k, False: 34.6k]
  |  Branch (204:44): [True: 84.7k, False: 0]
  |  Branch (204:65): [True: 2.12k, False: 82.6k]
  ------------------
  205|       |                /* operator|= */
  206|  2.12k|                compare_fn(dest);
  207|  2.12k|                sim[dest] |= sim[src];
  208|  2.12k|                real[dest] |= real[src];
  209|  2.12k|                break;
  210|   117k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 82.6k, False: 34.6k]
  |  Branch (210:44): [True: 82.6k, False: 0]
  |  Branch (210:65): [True: 1.57k, False: 81.0k]
  ------------------
  211|       |                /* operator&= */
  212|  1.57k|                compare_fn(dest);
  213|  1.57k|                sim[dest] &= sim[src];
  214|  1.57k|                real[dest] &= real[src];
  215|  1.57k|                break;
  216|   115k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 81.0k, False: 34.6k]
  |  Branch (216:44): [True: 81.0k, False: 0]
  |  Branch (216:65): [True: 1.65k, False: 79.3k]
  ------------------
  217|       |                /* operator-= */
  218|  1.65k|                compare_fn(dest);
  219|  1.65k|                sim[dest] &= ~sim[src];
  220|  1.65k|                real[dest] -= real[src];
  221|  1.65k|                break;
  222|   114k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 79.3k, False: 34.6k]
  |  Branch (222:44): [True: 79.3k, False: 0]
  |  Branch (222:65): [True: 1.27k, False: 78.1k]
  ------------------
  223|       |                /* operator^= */
  224|  1.27k|                compare_fn(dest);
  225|  1.27k|                sim[dest] ^= sim[src];
  226|  1.27k|                real[dest] ^= real[src];
  227|  1.27k|                break;
  228|   112k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 78.1k, False: 34.6k]
  |  Branch (228:44): [True: 78.1k, False: 0]
  |  Branch (228:65): [True: 78.1k, False: 0]
  |  Branch (228:85): [True: 3.44k, False: 74.6k]
  ------------------
  229|       |                /* operator| */
  230|  3.44k|                compare_fn(dest);
  231|  3.44k|                sim[dest] = sim[src] | sim[aux];
  232|  3.44k|                real[dest] = real[src] | real[aux];
  233|  3.44k|                break;
  234|   109k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 74.6k, False: 34.6k]
  |  Branch (234:44): [True: 74.6k, False: 0]
  |  Branch (234:65): [True: 74.6k, False: 0]
  |  Branch (234:85): [True: 1.40k, False: 73.2k]
  ------------------
  235|       |                /* operator& */
  236|  1.40k|                compare_fn(dest);
  237|  1.40k|                sim[dest] = sim[src] & sim[aux];
  238|  1.40k|                real[dest] = real[src] & real[aux];
  239|  1.40k|                break;
  240|   107k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 73.2k, False: 34.6k]
  |  Branch (240:44): [True: 73.2k, False: 0]
  |  Branch (240:65): [True: 73.2k, False: 0]
  |  Branch (240:85): [True: 1.35k, False: 71.9k]
  ------------------
  241|       |                /* operator- */
  242|  1.35k|                compare_fn(dest);
  243|  1.35k|                sim[dest] = sim[src] & ~sim[aux];
  244|  1.35k|                real[dest] = real[src] - real[aux];
  245|  1.35k|                break;
  246|   106k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 71.9k, False: 34.6k]
  |  Branch (246:44): [True: 71.9k, False: 0]
  |  Branch (246:65): [True: 71.9k, False: 0]
  |  Branch (246:85): [True: 1.74k, False: 70.1k]
  ------------------
  247|       |                /* operator^ */
  248|  1.74k|                compare_fn(dest);
  249|  1.74k|                sim[dest] = sim[src] ^ sim[aux];
  250|  1.74k|                real[dest] = real[src] ^ real[aux];
  251|  1.74k|                break;
  252|   104k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 70.1k, False: 34.6k]
  |  Branch (252:44): [True: 70.1k, False: 0]
  |  Branch (252:64): [True: 3.38k, False: 66.7k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  3.38k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  3.38k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  3.38k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 3.38k, False: 0]
  ------------------
  257|  3.38k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 3.38k, False: 0]
  ------------------
  258|  3.38k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 3.38k, False: 0]
  ------------------
  259|  3.38k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 3.38k, False: 0]
  ------------------
  260|  3.38k|                break;
  261|   101k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 66.7k, False: 34.6k]
  |  Branch (261:44): [True: 66.7k, False: 0]
  |  Branch (261:64): [True: 2.15k, False: 64.6k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.15k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.15k, False: 0]
  ------------------
  264|  2.15k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.15k, False: 0]
  ------------------
  265|  2.15k|                break;
  266|  99.2k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 64.6k, False: 34.6k]
  |  Branch (266:44): [True: 64.6k, False: 0]
  |  Branch (266:64): [True: 1.95k, False: 62.6k]
  ------------------
  267|       |                /* Overlaps() */
  268|  1.95k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 1.95k, False: 0]
  ------------------
  269|  1.95k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 1.95k, False: 0]
  ------------------
  270|  1.95k|                break;
  271|  1.95k|            }
  272|   161k|        }
  273|  64.3k|    }
  274|       |    /* Fully compare the final state. */
  275|  4.40k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.04k, False: 1.36k]
  ------------------
  276|  3.04k|        compare_fn(i);
  277|  3.04k|    }
  278|  1.36k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  37.1k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  37.1k|        auto it = real[idx].begin();
   44|  37.1k|        unsigned first = S::Size();
   45|  37.1k|        unsigned last = S::Size();
   46|  3.60M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 3.56M, False: 37.1k]
  ------------------
   47|  3.56M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 1.93M, False: 1.62M]
  |  Branch (47:53): [True: 735k, False: 1.20M]
  ------------------
   48|  3.56M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 3.56M, False: 0]
  ------------------
   49|  3.56M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 3.56M, False: 0]
  ------------------
   50|  3.56M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 3.56M, False: 0]
  ------------------
   51|  3.56M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 735k, False: 2.83M]
  ------------------
   52|   735k|                ++it;
   53|   735k|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 27.1k, False: 708k]
  ------------------
   54|   735k|                last = i;
   55|   735k|            }
   56|  3.56M|        }
   57|  37.1k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 37.1k, False: 0]
  ------------------
   58|  37.1k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 37.1k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  37.1k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 37.1k, False: 0]
  ------------------
   61|  37.1k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 37.1k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  37.1k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 27.1k, False: 10.0k]
  ------------------
   64|  27.1k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 27.1k, False: 0]
  ------------------
   65|  27.1k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 27.1k, False: 0]
  ------------------
   66|  27.1k|        }
   67|       |        /* Count */
   68|  37.1k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 37.1k, False: 0]
  ------------------
   69|  37.1k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.65k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.65k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.65k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.65k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.65k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.65k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.65k|        auto it = real[idx].begin();
   44|  1.65k|        unsigned first = S::Size();
   45|  1.65k|        unsigned last = S::Size();
   46|  1.65k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.65k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.65k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.65k|            assert(match == real[idx][i]);
   50|  1.65k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.65k|            if (match) {
   52|  1.65k|                ++it;
   53|  1.65k|                if (first == S::Size()) first = i;
   54|  1.65k|                last = i;
   55|  1.65k|            }
   56|  1.65k|        }
   57|  1.65k|        assert(it == real[idx].end());
   58|  1.65k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.65k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.65k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.65k|        if (sim[idx].any()) {
   64|  1.65k|            assert(first == real[idx].First());
   65|  1.65k|            assert(last == real[idx].Last());
   66|  1.65k|        }
   67|       |        /* Count */
   68|  1.65k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.65k|    };
   70|       |
   71|  99.9k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   101k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 99.9k, False: 1.60k]
  |  |  |  Branch (23:49): [True: 99.9k, False: 54]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  99.9k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  99.9k|        unsigned args = ReadByte(buffer);
   76|  99.9k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  99.9k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  99.9k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  99.9k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.50k, False: 97.4k]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 99.9k, False: 0]
  ------------------
   81|  99.9k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   220k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 220k, Folded]
  ------------------
   87|   220k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 189k, False: 31.1k]
  |  Branch (87:38): [True: 18.0k, False: 170k]
  ------------------
   88|       |                /* Set() (true) */
   89|  18.0k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  18.0k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 18.0k, False: 0]
  ------------------
   91|  18.0k|                sim[dest].set(val);
   92|  18.0k|                real[dest].Set(val);
   93|  18.0k|                break;
   94|   202k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 170k, False: 31.1k]
  |  Branch (94:45): [True: 3.29k, False: 167k]
  ------------------
   95|       |                /* Reset() */
   96|  3.29k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  3.29k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 3.29k, False: 0]
  ------------------
   98|  3.29k|                sim[dest].reset(val);
   99|  3.29k|                real[dest].Reset(val);
  100|  3.29k|                break;
  101|   198k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 167k, False: 31.1k]
  |  Branch (101:45): [True: 2.81k, False: 164k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  2.81k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  2.81k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 2.81k, False: 0]
  ------------------
  105|  2.81k|                sim[dest].set(val, args >> 7);
  106|  2.81k|                real[dest].Set(val, args >> 7);
  107|  2.81k|                break;
  108|   196k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 101k, False: 94.3k]
  |  Branch (108:42): [True: 1.38k, False: 100k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.38k|                sim.resize(sim.size() + 1);
  111|  1.38k|                real.resize(real.size() + 1);
  112|  1.38k|                break;
  113|   194k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 100k, False: 94.3k]
  |  Branch (113:42): [True: 761, False: 99.5k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    761|                unsigned val = ReadByte(buffer) % S::Size();
  116|    761|                std::bitset<S::Size()> newset;
  117|    761|                newset[val] = true;
  118|    761|                sim.push_back(newset);
  119|    761|                real.push_back(S::Singleton(val));
  120|    761|                break;
  121|   193k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 163k, False: 30.1k]
  |  Branch (121:45): [True: 7.45k, False: 156k]
  ------------------
  122|       |                /* Make random. */
  123|  7.45k|                compare_fn(dest);
  124|  7.45k|                sim[dest].reset();
  125|  7.45k|                real[dest] = S{};
  126|   961k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 953k, False: 7.45k]
  ------------------
  127|   953k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 477k, False: 476k]
  ------------------
  128|   477k|                        sim[dest][i] = true;
  129|   477k|                        real[dest].Set(i);
  130|   477k|                    }
  131|   953k|                }
  132|  7.45k|                break;
  133|   186k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 156k, False: 30.1k]
  |  Branch (133:45): [True: 5.04k, False: 151k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.04k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.04k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.04k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.04k|                compare_fn(dest);
  139|  5.04k|                sim[dest].reset();
  140|  5.04k|                real[dest] = {r1, r2, r3};
  141|  5.04k|                sim[dest].set(r1);
  142|  5.04k|                sim[dest].set(r2);
  143|  5.04k|                sim[dest].set(r3);
  144|  5.04k|                break;
  145|   181k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 151k, False: 30.1k]
  |  Branch (145:40): [True: 5.04k, False: 146k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.04k|                compare_fn(sim.size() - 1);
  148|  5.04k|                sim.pop_back();
  149|  5.04k|                real.pop_back();
  150|  5.04k|                break;
  151|   176k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 89.5k, False: 86.7k]
  |  Branch (151:42): [True: 59.4k, False: 30.1k]
  |  Branch (151:62): [True: 1.15k, False: 58.2k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.15k|                sim.emplace_back(sim[src]);
  154|  1.15k|                real.emplace_back(real[src]);
  155|  1.15k|                break;
  156|   175k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 145k, False: 30.1k]
  |  Branch (156:44): [True: 145k, False: 0]
  |  Branch (156:65): [True: 2.74k, False: 142k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.74k|                compare_fn(dest);
  159|  2.74k|                sim[dest] = sim[src];
  160|  2.74k|                real[dest] = real[src];
  161|  2.74k|                break;
  162|   172k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 142k, False: 30.1k]
  |  Branch (162:44): [True: 142k, False: 0]
  |  Branch (162:65): [True: 2.59k, False: 139k]
  ------------------
  163|       |                /* swap() function. */
  164|  2.59k|                swap(sim[dest], sim[src]);
  165|  2.59k|                swap(real[dest], real[src]);
  166|  2.59k|                break;
  167|   169k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 86.4k, False: 83.3k]
  |  Branch (167:42): [True: 2.23k, False: 84.2k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.23k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.23k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.23k|                sim.emplace_back();
  172|  2.23k|                sim.back().set(r1);
  173|  2.23k|                sim.back().set(r2);
  174|  2.23k|                real.push_back(S{r1, r2});
  175|  2.23k|                break;
  176|   167k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 138k, False: 28.6k]
  |  Branch (176:45): [True: 4.13k, False: 134k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  4.13k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  4.13k|                compare_fn(dest);
  180|  4.13k|                sim[dest].reset();
  181|   267k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 263k, False: 4.13k]
  ------------------
  182|  4.13k|                real[dest] = S::Fill(len);
  183|  4.13k|                break;
  184|   163k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 134k, False: 28.6k]
  |  Branch (184:44): [True: 6.34k, False: 128k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.34k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.34k|                auto it = real[src].begin(), it_copy = it;
  189|   818k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 812k, False: 6.34k]
  ------------------
  190|   812k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.34k, False: 805k]
  ------------------
  191|   812k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 424k, False: 388k]
  |  Branch (191:61): [True: 186k, False: 238k]
  ------------------
  192|   812k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 812k, False: 0]
  ------------------
  193|   812k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 186k, False: 626k]
  ------------------
  194|   812k|                }
  195|  6.34k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.34k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   302k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 296k, False: 6.34k]
  ------------------
  198|   296k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 139k, False: 156k]
  |  Branch (198:66): [True: 69.9k, False: 70.0k]
  ------------------
  199|   296k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 296k, False: 0]
  ------------------
  200|   296k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 69.9k, False: 226k]
  ------------------
  201|   296k|                }
  202|  6.34k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.34k, False: 0]
  ------------------
  203|  6.34k|                break;
  204|   157k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 128k, False: 28.6k]
  |  Branch (204:44): [True: 128k, False: 0]
  |  Branch (204:65): [True: 2.87k, False: 125k]
  ------------------
  205|       |                /* operator|= */
  206|  2.87k|                compare_fn(dest);
  207|  2.87k|                sim[dest] |= sim[src];
  208|  2.87k|                real[dest] |= real[src];
  209|  2.87k|                break;
  210|   154k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 125k, False: 28.6k]
  |  Branch (210:44): [True: 125k, False: 0]
  |  Branch (210:65): [True: 4.48k, False: 121k]
  ------------------
  211|       |                /* operator&= */
  212|  4.48k|                compare_fn(dest);
  213|  4.48k|                sim[dest] &= sim[src];
  214|  4.48k|                real[dest] &= real[src];
  215|  4.48k|                break;
  216|   149k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 121k, False: 28.6k]
  |  Branch (216:44): [True: 121k, False: 0]
  |  Branch (216:65): [True: 2.53k, False: 118k]
  ------------------
  217|       |                /* operator-= */
  218|  2.53k|                compare_fn(dest);
  219|  2.53k|                sim[dest] &= ~sim[src];
  220|  2.53k|                real[dest] -= real[src];
  221|  2.53k|                break;
  222|   147k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 118k, False: 28.6k]
  |  Branch (222:44): [True: 118k, False: 0]
  |  Branch (222:65): [True: 2.58k, False: 115k]
  ------------------
  223|       |                /* operator^= */
  224|  2.58k|                compare_fn(dest);
  225|  2.58k|                sim[dest] ^= sim[src];
  226|  2.58k|                real[dest] ^= real[src];
  227|  2.58k|                break;
  228|   144k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 115k, False: 28.6k]
  |  Branch (228:44): [True: 115k, False: 0]
  |  Branch (228:65): [True: 115k, False: 0]
  |  Branch (228:85): [True: 6.16k, False: 109k]
  ------------------
  229|       |                /* operator| */
  230|  6.16k|                compare_fn(dest);
  231|  6.16k|                sim[dest] = sim[src] | sim[aux];
  232|  6.16k|                real[dest] = real[src] | real[aux];
  233|  6.16k|                break;
  234|   138k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 109k, False: 28.6k]
  |  Branch (234:44): [True: 109k, False: 0]
  |  Branch (234:65): [True: 109k, False: 0]
  |  Branch (234:85): [True: 2.06k, False: 107k]
  ------------------
  235|       |                /* operator& */
  236|  2.06k|                compare_fn(dest);
  237|  2.06k|                sim[dest] = sim[src] & sim[aux];
  238|  2.06k|                real[dest] = real[src] & real[aux];
  239|  2.06k|                break;
  240|   136k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 107k, False: 28.6k]
  |  Branch (240:44): [True: 107k, False: 0]
  |  Branch (240:65): [True: 107k, False: 0]
  |  Branch (240:85): [True: 3.56k, False: 104k]
  ------------------
  241|       |                /* operator- */
  242|  3.56k|                compare_fn(dest);
  243|  3.56k|                sim[dest] = sim[src] & ~sim[aux];
  244|  3.56k|                real[dest] = real[src] - real[aux];
  245|  3.56k|                break;
  246|   132k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 104k, False: 28.6k]
  |  Branch (246:44): [True: 104k, False: 0]
  |  Branch (246:65): [True: 104k, False: 0]
  |  Branch (246:85): [True: 2.21k, False: 101k]
  ------------------
  247|       |                /* operator^ */
  248|  2.21k|                compare_fn(dest);
  249|  2.21k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.21k|                real[dest] = real[src] ^ real[aux];
  251|  2.21k|                break;
  252|   130k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 101k, False: 28.6k]
  |  Branch (252:44): [True: 101k, False: 0]
  |  Branch (252:64): [True: 4.45k, False: 97.5k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  4.45k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  4.45k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  4.45k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 4.45k, False: 0]
  ------------------
  257|  4.45k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 4.45k, False: 0]
  ------------------
  258|  4.45k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 4.45k, False: 0]
  ------------------
  259|  4.45k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 4.45k, False: 0]
  ------------------
  260|  4.45k|                break;
  261|   126k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 97.5k, False: 28.6k]
  |  Branch (261:44): [True: 97.5k, False: 0]
  |  Branch (261:64): [True: 3.02k, False: 94.4k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.02k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.02k, False: 0]
  ------------------
  264|  3.02k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.02k, False: 0]
  ------------------
  265|  3.02k|                break;
  266|   123k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 94.4k, False: 28.6k]
  |  Branch (266:44): [True: 94.4k, False: 0]
  |  Branch (266:64): [True: 2.86k, False: 91.6k]
  ------------------
  267|       |                /* Overlaps() */
  268|  2.86k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 2.86k, False: 0]
  ------------------
  269|  2.86k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 2.86k, False: 0]
  ------------------
  270|  2.86k|                break;
  271|  2.86k|            }
  272|   220k|        }
  273|  99.9k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.46k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.80k, False: 1.65k]
  ------------------
  276|  3.80k|        compare_fn(i);
  277|  3.80k|    }
  278|  1.65k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj2EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  54.7k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  54.7k|        auto it = real[idx].begin();
   44|  54.7k|        unsigned first = S::Size();
   45|  54.7k|        unsigned last = S::Size();
   46|  7.05M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 7.00M, False: 54.7k]
  ------------------
   47|  7.00M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 3.84M, False: 3.16M]
  |  Branch (47:53): [True: 1.61M, False: 2.23M]
  ------------------
   48|  7.00M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 7.00M, False: 0]
  ------------------
   49|  7.00M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 7.00M, False: 0]
  ------------------
   50|  7.00M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 7.00M, False: 0]
  ------------------
   51|  7.00M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 1.61M, False: 5.39M]
  ------------------
   52|  1.61M|                ++it;
   53|  1.61M|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 37.9k, False: 1.57M]
  ------------------
   54|  1.61M|                last = i;
   55|  1.61M|            }
   56|  7.00M|        }
   57|  54.7k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 54.7k, False: 0]
  ------------------
   58|  54.7k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 54.7k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  54.7k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 54.7k, False: 0]
  ------------------
   61|  54.7k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 54.7k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  54.7k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 37.9k, False: 16.7k]
  ------------------
   64|  37.9k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 37.9k, False: 0]
  ------------------
   65|  37.9k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 37.9k, False: 0]
  ------------------
   66|  37.9k|        }
   67|       |        /* Count */
   68|  54.7k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 54.7k, False: 0]
  ------------------
   69|  54.7k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.65k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.65k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.65k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.65k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.65k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.65k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.65k|        auto it = real[idx].begin();
   44|  1.65k|        unsigned first = S::Size();
   45|  1.65k|        unsigned last = S::Size();
   46|  1.65k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.65k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.65k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.65k|            assert(match == real[idx][i]);
   50|  1.65k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.65k|            if (match) {
   52|  1.65k|                ++it;
   53|  1.65k|                if (first == S::Size()) first = i;
   54|  1.65k|                last = i;
   55|  1.65k|            }
   56|  1.65k|        }
   57|  1.65k|        assert(it == real[idx].end());
   58|  1.65k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.65k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.65k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.65k|        if (sim[idx].any()) {
   64|  1.65k|            assert(first == real[idx].First());
   65|  1.65k|            assert(last == real[idx].Last());
   66|  1.65k|        }
   67|       |        /* Count */
   68|  1.65k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.65k|    };
   70|       |
   71|  99.9k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   101k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 99.9k, False: 1.60k]
  |  |  |  Branch (23:49): [True: 99.9k, False: 54]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  99.9k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  99.9k|        unsigned args = ReadByte(buffer);
   76|  99.9k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  99.9k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  99.9k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  99.9k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.50k, False: 97.4k]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 2.50k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 97.4k, False: 0]
  |  Branch (80:9): [True: 99.9k, False: 0]
  ------------------
   81|  99.9k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   220k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 220k, Folded]
  ------------------
   87|   220k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 189k, False: 31.1k]
  |  Branch (87:38): [True: 18.0k, False: 170k]
  ------------------
   88|       |                /* Set() (true) */
   89|  18.0k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  18.0k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 18.0k, False: 0]
  ------------------
   91|  18.0k|                sim[dest].set(val);
   92|  18.0k|                real[dest].Set(val);
   93|  18.0k|                break;
   94|   202k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 170k, False: 31.1k]
  |  Branch (94:45): [True: 3.29k, False: 167k]
  ------------------
   95|       |                /* Reset() */
   96|  3.29k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  3.29k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 3.29k, False: 0]
  ------------------
   98|  3.29k|                sim[dest].reset(val);
   99|  3.29k|                real[dest].Reset(val);
  100|  3.29k|                break;
  101|   198k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 167k, False: 31.1k]
  |  Branch (101:45): [True: 2.81k, False: 164k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  2.81k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  2.81k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 2.81k, False: 0]
  ------------------
  105|  2.81k|                sim[dest].set(val, args >> 7);
  106|  2.81k|                real[dest].Set(val, args >> 7);
  107|  2.81k|                break;
  108|   196k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 101k, False: 94.3k]
  |  Branch (108:42): [True: 1.38k, False: 100k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.38k|                sim.resize(sim.size() + 1);
  111|  1.38k|                real.resize(real.size() + 1);
  112|  1.38k|                break;
  113|   194k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 100k, False: 94.3k]
  |  Branch (113:42): [True: 761, False: 99.5k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    761|                unsigned val = ReadByte(buffer) % S::Size();
  116|    761|                std::bitset<S::Size()> newset;
  117|    761|                newset[val] = true;
  118|    761|                sim.push_back(newset);
  119|    761|                real.push_back(S::Singleton(val));
  120|    761|                break;
  121|   193k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 163k, False: 30.1k]
  |  Branch (121:45): [True: 7.45k, False: 156k]
  ------------------
  122|       |                /* Make random. */
  123|  7.45k|                compare_fn(dest);
  124|  7.45k|                sim[dest].reset();
  125|  7.45k|                real[dest] = S{};
  126|   961k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 953k, False: 7.45k]
  ------------------
  127|   953k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 477k, False: 476k]
  ------------------
  128|   477k|                        sim[dest][i] = true;
  129|   477k|                        real[dest].Set(i);
  130|   477k|                    }
  131|   953k|                }
  132|  7.45k|                break;
  133|   186k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 156k, False: 30.1k]
  |  Branch (133:45): [True: 5.04k, False: 151k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  5.04k|                unsigned r1 = rng.randrange(S::Size());
  136|  5.04k|                unsigned r2 = rng.randrange(S::Size());
  137|  5.04k|                unsigned r3 = rng.randrange(S::Size());
  138|  5.04k|                compare_fn(dest);
  139|  5.04k|                sim[dest].reset();
  140|  5.04k|                real[dest] = {r1, r2, r3};
  141|  5.04k|                sim[dest].set(r1);
  142|  5.04k|                sim[dest].set(r2);
  143|  5.04k|                sim[dest].set(r3);
  144|  5.04k|                break;
  145|   181k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 151k, False: 30.1k]
  |  Branch (145:40): [True: 5.04k, False: 146k]
  ------------------
  146|       |                /* Destruct. */
  147|  5.04k|                compare_fn(sim.size() - 1);
  148|  5.04k|                sim.pop_back();
  149|  5.04k|                real.pop_back();
  150|  5.04k|                break;
  151|   176k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 89.5k, False: 86.7k]
  |  Branch (151:42): [True: 59.4k, False: 30.1k]
  |  Branch (151:62): [True: 1.15k, False: 58.2k]
  ------------------
  152|       |                /* Copy construct. */
  153|  1.15k|                sim.emplace_back(sim[src]);
  154|  1.15k|                real.emplace_back(real[src]);
  155|  1.15k|                break;
  156|   175k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 145k, False: 30.1k]
  |  Branch (156:44): [True: 145k, False: 0]
  |  Branch (156:65): [True: 2.74k, False: 142k]
  ------------------
  157|       |                /* Copy assign. */
  158|  2.74k|                compare_fn(dest);
  159|  2.74k|                sim[dest] = sim[src];
  160|  2.74k|                real[dest] = real[src];
  161|  2.74k|                break;
  162|   172k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 142k, False: 30.1k]
  |  Branch (162:44): [True: 142k, False: 0]
  |  Branch (162:65): [True: 2.59k, False: 139k]
  ------------------
  163|       |                /* swap() function. */
  164|  2.59k|                swap(sim[dest], sim[src]);
  165|  2.59k|                swap(real[dest], real[src]);
  166|  2.59k|                break;
  167|   169k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 86.4k, False: 83.3k]
  |  Branch (167:42): [True: 2.23k, False: 84.2k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  2.23k|                unsigned r1 = rng.randrange(S::Size());
  170|  2.23k|                unsigned r2 = rng.randrange(S::Size());
  171|  2.23k|                sim.emplace_back();
  172|  2.23k|                sim.back().set(r1);
  173|  2.23k|                sim.back().set(r2);
  174|  2.23k|                real.push_back(S{r1, r2});
  175|  2.23k|                break;
  176|   167k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 138k, False: 28.6k]
  |  Branch (176:45): [True: 4.13k, False: 134k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  4.13k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  4.13k|                compare_fn(dest);
  180|  4.13k|                sim[dest].reset();
  181|   267k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 263k, False: 4.13k]
  ------------------
  182|  4.13k|                real[dest] = S::Fill(len);
  183|  4.13k|                break;
  184|   163k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 134k, False: 28.6k]
  |  Branch (184:44): [True: 6.34k, False: 128k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  6.34k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  6.34k|                auto it = real[src].begin(), it_copy = it;
  189|   818k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 812k, False: 6.34k]
  ------------------
  190|   812k|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 6.34k, False: 805k]
  ------------------
  191|   812k|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 424k, False: 388k]
  |  Branch (191:61): [True: 186k, False: 238k]
  ------------------
  192|   812k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 812k, False: 0]
  ------------------
  193|   812k|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 186k, False: 626k]
  ------------------
  194|   812k|                }
  195|  6.34k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 6.34k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   302k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 296k, False: 6.34k]
  ------------------
  198|   296k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 139k, False: 156k]
  |  Branch (198:66): [True: 69.9k, False: 70.0k]
  ------------------
  199|   296k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 296k, False: 0]
  ------------------
  200|   296k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 69.9k, False: 226k]
  ------------------
  201|   296k|                }
  202|  6.34k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 6.34k, False: 0]
  ------------------
  203|  6.34k|                break;
  204|   157k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 128k, False: 28.6k]
  |  Branch (204:44): [True: 128k, False: 0]
  |  Branch (204:65): [True: 2.87k, False: 125k]
  ------------------
  205|       |                /* operator|= */
  206|  2.87k|                compare_fn(dest);
  207|  2.87k|                sim[dest] |= sim[src];
  208|  2.87k|                real[dest] |= real[src];
  209|  2.87k|                break;
  210|   154k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 125k, False: 28.6k]
  |  Branch (210:44): [True: 125k, False: 0]
  |  Branch (210:65): [True: 4.48k, False: 121k]
  ------------------
  211|       |                /* operator&= */
  212|  4.48k|                compare_fn(dest);
  213|  4.48k|                sim[dest] &= sim[src];
  214|  4.48k|                real[dest] &= real[src];
  215|  4.48k|                break;
  216|   149k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 121k, False: 28.6k]
  |  Branch (216:44): [True: 121k, False: 0]
  |  Branch (216:65): [True: 2.53k, False: 118k]
  ------------------
  217|       |                /* operator-= */
  218|  2.53k|                compare_fn(dest);
  219|  2.53k|                sim[dest] &= ~sim[src];
  220|  2.53k|                real[dest] -= real[src];
  221|  2.53k|                break;
  222|   147k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 118k, False: 28.6k]
  |  Branch (222:44): [True: 118k, False: 0]
  |  Branch (222:65): [True: 2.58k, False: 115k]
  ------------------
  223|       |                /* operator^= */
  224|  2.58k|                compare_fn(dest);
  225|  2.58k|                sim[dest] ^= sim[src];
  226|  2.58k|                real[dest] ^= real[src];
  227|  2.58k|                break;
  228|   144k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 115k, False: 28.6k]
  |  Branch (228:44): [True: 115k, False: 0]
  |  Branch (228:65): [True: 115k, False: 0]
  |  Branch (228:85): [True: 6.16k, False: 109k]
  ------------------
  229|       |                /* operator| */
  230|  6.16k|                compare_fn(dest);
  231|  6.16k|                sim[dest] = sim[src] | sim[aux];
  232|  6.16k|                real[dest] = real[src] | real[aux];
  233|  6.16k|                break;
  234|   138k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 109k, False: 28.6k]
  |  Branch (234:44): [True: 109k, False: 0]
  |  Branch (234:65): [True: 109k, False: 0]
  |  Branch (234:85): [True: 2.06k, False: 107k]
  ------------------
  235|       |                /* operator& */
  236|  2.06k|                compare_fn(dest);
  237|  2.06k|                sim[dest] = sim[src] & sim[aux];
  238|  2.06k|                real[dest] = real[src] & real[aux];
  239|  2.06k|                break;
  240|   136k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 107k, False: 28.6k]
  |  Branch (240:44): [True: 107k, False: 0]
  |  Branch (240:65): [True: 107k, False: 0]
  |  Branch (240:85): [True: 3.56k, False: 104k]
  ------------------
  241|       |                /* operator- */
  242|  3.56k|                compare_fn(dest);
  243|  3.56k|                sim[dest] = sim[src] & ~sim[aux];
  244|  3.56k|                real[dest] = real[src] - real[aux];
  245|  3.56k|                break;
  246|   132k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 104k, False: 28.6k]
  |  Branch (246:44): [True: 104k, False: 0]
  |  Branch (246:65): [True: 104k, False: 0]
  |  Branch (246:85): [True: 2.21k, False: 101k]
  ------------------
  247|       |                /* operator^ */
  248|  2.21k|                compare_fn(dest);
  249|  2.21k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.21k|                real[dest] = real[src] ^ real[aux];
  251|  2.21k|                break;
  252|   130k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 101k, False: 28.6k]
  |  Branch (252:44): [True: 101k, False: 0]
  |  Branch (252:64): [True: 4.45k, False: 97.5k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  4.45k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  4.45k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  4.45k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 4.45k, False: 0]
  ------------------
  257|  4.45k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 4.45k, False: 0]
  ------------------
  258|  4.45k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 4.45k, False: 0]
  ------------------
  259|  4.45k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 4.45k, False: 0]
  ------------------
  260|  4.45k|                break;
  261|   126k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 97.5k, False: 28.6k]
  |  Branch (261:44): [True: 97.5k, False: 0]
  |  Branch (261:64): [True: 3.02k, False: 94.4k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  3.02k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 3.02k, False: 0]
  ------------------
  264|  3.02k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 3.02k, False: 0]
  ------------------
  265|  3.02k|                break;
  266|   123k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 94.4k, False: 28.6k]
  |  Branch (266:44): [True: 94.4k, False: 0]
  |  Branch (266:64): [True: 2.86k, False: 91.6k]
  ------------------
  267|       |                /* Overlaps() */
  268|  2.86k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 2.86k, False: 0]
  ------------------
  269|  2.86k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 2.86k, False: 0]
  ------------------
  270|  2.86k|                break;
  271|  2.86k|            }
  272|   220k|        }
  273|  99.9k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.46k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.80k, False: 1.65k]
  ------------------
  276|  3.80k|        compare_fn(i);
  277|  3.80k|    }
  278|  1.65k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetIjLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  54.7k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  54.7k|        auto it = real[idx].begin();
   44|  54.7k|        unsigned first = S::Size();
   45|  54.7k|        unsigned last = S::Size();
   46|  7.05M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 7.00M, False: 54.7k]
  ------------------
   47|  7.00M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 3.84M, False: 3.16M]
  |  Branch (47:53): [True: 1.61M, False: 2.23M]
  ------------------
   48|  7.00M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 7.00M, False: 0]
  ------------------
   49|  7.00M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 7.00M, False: 0]
  ------------------
   50|  7.00M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 7.00M, False: 0]
  ------------------
   51|  7.00M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 1.61M, False: 5.39M]
  ------------------
   52|  1.61M|                ++it;
   53|  1.61M|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 37.9k, False: 1.57M]
  ------------------
   54|  1.61M|                last = i;
   55|  1.61M|            }
   56|  7.00M|        }
   57|  54.7k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 54.7k, False: 0]
  ------------------
   58|  54.7k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 54.7k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  54.7k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 54.7k, False: 0]
  ------------------
   61|  54.7k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 54.7k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  54.7k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 37.9k, False: 16.7k]
  ------------------
   64|  37.9k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 37.9k, False: 0]
  ------------------
   65|  37.9k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 37.9k, False: 0]
  ------------------
   66|  37.9k|        }
   67|       |        /* Count */
   68|  54.7k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 54.7k, False: 0]
  ------------------
   69|  54.7k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.58k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.58k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.58k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.58k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.58k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.58k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.58k|        auto it = real[idx].begin();
   44|  1.58k|        unsigned first = S::Size();
   45|  1.58k|        unsigned last = S::Size();
   46|  1.58k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.58k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.58k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.58k|            assert(match == real[idx][i]);
   50|  1.58k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.58k|            if (match) {
   52|  1.58k|                ++it;
   53|  1.58k|                if (first == S::Size()) first = i;
   54|  1.58k|                last = i;
   55|  1.58k|            }
   56|  1.58k|        }
   57|  1.58k|        assert(it == real[idx].end());
   58|  1.58k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.58k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.58k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.58k|        if (sim[idx].any()) {
   64|  1.58k|            assert(first == real[idx].First());
   65|  1.58k|            assert(last == real[idx].Last());
   66|  1.58k|        }
   67|       |        /* Count */
   68|  1.58k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.58k|    };
   70|       |
   71|   105k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|   106k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 105k, False: 1.52k]
  |  |  |  Branch (23:49): [True: 105k, False: 64]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|   105k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|   105k|        unsigned args = ReadByte(buffer);
   76|   105k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|   105k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|   105k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|   105k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 4.04k, False: 101k]
  |  Branch (80:9): [True: 4.04k, False: 0]
  |  Branch (80:9): [True: 4.04k, False: 0]
  |  Branch (80:9): [True: 4.04k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 101k, False: 0]
  |  Branch (80:9): [True: 105k, False: 0]
  ------------------
   81|   105k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   240k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 240k, Folded]
  ------------------
   87|   240k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 193k, False: 46.5k]
  |  Branch (87:38): [True: 16.1k, False: 177k]
  ------------------
   88|       |                /* Set() (true) */
   89|  16.1k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  16.1k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 16.1k, False: 0]
  ------------------
   91|  16.1k|                sim[dest].set(val);
   92|  16.1k|                real[dest].Set(val);
   93|  16.1k|                break;
   94|   224k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 177k, False: 46.5k]
  |  Branch (94:45): [True: 3.35k, False: 174k]
  ------------------
   95|       |                /* Reset() */
   96|  3.35k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  3.35k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 3.35k, False: 0]
  ------------------
   98|  3.35k|                sim[dest].reset(val);
   99|  3.35k|                real[dest].Reset(val);
  100|  3.35k|                break;
  101|   220k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 174k, False: 46.5k]
  |  Branch (101:45): [True: 3.24k, False: 171k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  3.24k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  3.24k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 3.24k, False: 0]
  ------------------
  105|  3.24k|                sim[dest].set(val, args >> 7);
  106|  3.24k|                real[dest].Set(val, args >> 7);
  107|  3.24k|                break;
  108|   217k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 122k, False: 95.6k]
  |  Branch (108:42): [True: 1.15k, False: 120k]
  ------------------
  109|       |                /* Construct empty. */
  110|  1.15k|                sim.resize(sim.size() + 1);
  111|  1.15k|                real.resize(real.size() + 1);
  112|  1.15k|                break;
  113|   216k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 120k, False: 95.6k]
  |  Branch (113:42): [True: 932, False: 119k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    932|                unsigned val = ReadByte(buffer) % S::Size();
  116|    932|                std::bitset<S::Size()> newset;
  117|    932|                newset[val] = true;
  118|    932|                sim.push_back(newset);
  119|    932|                real.push_back(S::Singleton(val));
  120|    932|                break;
  121|   215k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 170k, False: 45.5k]
  |  Branch (121:45): [True: 6.58k, False: 163k]
  ------------------
  122|       |                /* Make random. */
  123|  6.58k|                compare_fn(dest);
  124|  6.58k|                sim[dest].reset();
  125|  6.58k|                real[dest] = S{};
  126|  1.27M|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 1.26M, False: 6.58k]
  ------------------
  127|  1.26M|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 632k, False: 631k]
  ------------------
  128|   632k|                        sim[dest][i] = true;
  129|   632k|                        real[dest].Set(i);
  130|   632k|                    }
  131|  1.26M|                }
  132|  6.58k|                break;
  133|   209k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 163k, False: 45.5k]
  |  Branch (133:45): [True: 7.16k, False: 156k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  7.16k|                unsigned r1 = rng.randrange(S::Size());
  136|  7.16k|                unsigned r2 = rng.randrange(S::Size());
  137|  7.16k|                unsigned r3 = rng.randrange(S::Size());
  138|  7.16k|                compare_fn(dest);
  139|  7.16k|                sim[dest].reset();
  140|  7.16k|                real[dest] = {r1, r2, r3};
  141|  7.16k|                sim[dest].set(r1);
  142|  7.16k|                sim[dest].set(r2);
  143|  7.16k|                sim[dest].set(r3);
  144|  7.16k|                break;
  145|   201k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 156k, False: 45.5k]
  |  Branch (145:40): [True: 6.34k, False: 150k]
  ------------------
  146|       |                /* Destruct. */
  147|  6.34k|                compare_fn(sim.size() - 1);
  148|  6.34k|                sim.pop_back();
  149|  6.34k|                real.pop_back();
  150|  6.34k|                break;
  151|   195k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 106k, False: 88.8k]
  |  Branch (151:42): [True: 61.1k, False: 45.5k]
  |  Branch (151:62): [True: 968, False: 60.1k]
  ------------------
  152|       |                /* Copy construct. */
  153|    968|                sim.emplace_back(sim[src]);
  154|    968|                real.emplace_back(real[src]);
  155|    968|                break;
  156|   194k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 149k, False: 45.5k]
  |  Branch (156:44): [True: 149k, False: 0]
  |  Branch (156:65): [True: 3.13k, False: 145k]
  ------------------
  157|       |                /* Copy assign. */
  158|  3.13k|                compare_fn(dest);
  159|  3.13k|                sim[dest] = sim[src];
  160|  3.13k|                real[dest] = real[src];
  161|  3.13k|                break;
  162|   191k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 145k, False: 45.5k]
  |  Branch (162:44): [True: 145k, False: 0]
  |  Branch (162:65): [True: 3.65k, False: 142k]
  ------------------
  163|       |                /* swap() function. */
  164|  3.65k|                swap(sim[dest], sim[src]);
  165|  3.65k|                swap(real[dest], real[src]);
  166|  3.65k|                break;
  167|   187k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 103k, False: 83.9k]
  |  Branch (167:42): [True: 3.75k, False: 100k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  3.75k|                unsigned r1 = rng.randrange(S::Size());
  170|  3.75k|                unsigned r2 = rng.randrange(S::Size());
  171|  3.75k|                sim.emplace_back();
  172|  3.75k|                sim.back().set(r1);
  173|  3.75k|                sim.back().set(r2);
  174|  3.75k|                real.push_back(S{r1, r2});
  175|  3.75k|                break;
  176|   184k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 141k, False: 42.5k]
  |  Branch (176:45): [True: 4.66k, False: 136k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  4.66k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  4.66k|                compare_fn(dest);
  180|  4.66k|                sim[dest].reset();
  181|   389k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 384k, False: 4.66k]
  ------------------
  182|  4.66k|                real[dest] = S::Fill(len);
  183|  4.66k|                break;
  184|   179k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 136k, False: 42.5k]
  |  Branch (184:44): [True: 5.69k, False: 131k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  5.69k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  5.69k|                auto it = real[src].begin(), it_copy = it;
  189|  1.09M|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 1.09M, False: 5.69k]
  ------------------
  190|  1.09M|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 5.69k, False: 1.08M]
  ------------------
  191|  1.09M|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 542k, False: 550k]
  |  Branch (191:61): [True: 228k, False: 313k]
  ------------------
  192|  1.09M|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 1.09M, False: 0]
  ------------------
  193|  1.09M|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 228k, False: 864k]
  ------------------
  194|  1.09M|                }
  195|  5.69k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 5.69k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   720k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 714k, False: 5.69k]
  ------------------
  198|   714k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 314k, False: 400k]
  |  Branch (198:66): [True: 139k, False: 175k]
  ------------------
  199|   714k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 714k, False: 0]
  ------------------
  200|   714k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 139k, False: 575k]
  ------------------
  201|   714k|                }
  202|  5.69k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 5.69k, False: 0]
  ------------------
  203|  5.69k|                break;
  204|   173k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 131k, False: 42.5k]
  |  Branch (204:44): [True: 131k, False: 0]
  |  Branch (204:65): [True: 3.69k, False: 127k]
  ------------------
  205|       |                /* operator|= */
  206|  3.69k|                compare_fn(dest);
  207|  3.69k|                sim[dest] |= sim[src];
  208|  3.69k|                real[dest] |= real[src];
  209|  3.69k|                break;
  210|   169k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 127k, False: 42.5k]
  |  Branch (210:44): [True: 127k, False: 0]
  |  Branch (210:65): [True: 3.23k, False: 124k]
  ------------------
  211|       |                /* operator&= */
  212|  3.23k|                compare_fn(dest);
  213|  3.23k|                sim[dest] &= sim[src];
  214|  3.23k|                real[dest] &= real[src];
  215|  3.23k|                break;
  216|   166k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 124k, False: 42.5k]
  |  Branch (216:44): [True: 124k, False: 0]
  |  Branch (216:65): [True: 3.64k, False: 120k]
  ------------------
  217|       |                /* operator-= */
  218|  3.64k|                compare_fn(dest);
  219|  3.64k|                sim[dest] &= ~sim[src];
  220|  3.64k|                real[dest] -= real[src];
  221|  3.64k|                break;
  222|   163k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 120k, False: 42.5k]
  |  Branch (222:44): [True: 120k, False: 0]
  |  Branch (222:65): [True: 2.69k, False: 117k]
  ------------------
  223|       |                /* operator^= */
  224|  2.69k|                compare_fn(dest);
  225|  2.69k|                sim[dest] ^= sim[src];
  226|  2.69k|                real[dest] ^= real[src];
  227|  2.69k|                break;
  228|   160k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 117k, False: 42.5k]
  |  Branch (228:44): [True: 117k, False: 0]
  |  Branch (228:65): [True: 117k, False: 0]
  |  Branch (228:85): [True: 4.51k, False: 113k]
  ------------------
  229|       |                /* operator| */
  230|  4.51k|                compare_fn(dest);
  231|  4.51k|                sim[dest] = sim[src] | sim[aux];
  232|  4.51k|                real[dest] = real[src] | real[aux];
  233|  4.51k|                break;
  234|   155k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 113k, False: 42.5k]
  |  Branch (234:44): [True: 113k, False: 0]
  |  Branch (234:65): [True: 113k, False: 0]
  |  Branch (234:85): [True: 2.55k, False: 110k]
  ------------------
  235|       |                /* operator& */
  236|  2.55k|                compare_fn(dest);
  237|  2.55k|                sim[dest] = sim[src] & sim[aux];
  238|  2.55k|                real[dest] = real[src] & real[aux];
  239|  2.55k|                break;
  240|   153k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 110k, False: 42.5k]
  |  Branch (240:44): [True: 110k, False: 0]
  |  Branch (240:65): [True: 110k, False: 0]
  |  Branch (240:85): [True: 2.47k, False: 108k]
  ------------------
  241|       |                /* operator- */
  242|  2.47k|                compare_fn(dest);
  243|  2.47k|                sim[dest] = sim[src] & ~sim[aux];
  244|  2.47k|                real[dest] = real[src] - real[aux];
  245|  2.47k|                break;
  246|   150k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 108k, False: 42.5k]
  |  Branch (246:44): [True: 108k, False: 0]
  |  Branch (246:65): [True: 108k, False: 0]
  |  Branch (246:85): [True: 2.43k, False: 105k]
  ------------------
  247|       |                /* operator^ */
  248|  2.43k|                compare_fn(dest);
  249|  2.43k|                sim[dest] = sim[src] ^ sim[aux];
  250|  2.43k|                real[dest] = real[src] ^ real[aux];
  251|  2.43k|                break;
  252|   148k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 105k, False: 42.5k]
  |  Branch (252:44): [True: 105k, False: 0]
  |  Branch (252:64): [True: 6.47k, False: 99.4k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  6.47k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  6.47k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  6.47k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 6.47k, False: 0]
  ------------------
  257|  6.47k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 6.47k, False: 0]
  ------------------
  258|  6.47k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 6.47k, False: 0]
  ------------------
  259|  6.47k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 6.47k, False: 0]
  ------------------
  260|  6.47k|                break;
  261|   141k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 99.4k, False: 42.5k]
  |  Branch (261:44): [True: 99.4k, False: 0]
  |  Branch (261:64): [True: 2.93k, False: 96.5k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  2.93k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 2.93k, False: 0]
  ------------------
  264|  2.93k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 2.93k, False: 0]
  ------------------
  265|  2.93k|                break;
  266|   139k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 96.5k, False: 42.5k]
  |  Branch (266:44): [True: 96.5k, False: 0]
  |  Branch (266:64): [True: 3.92k, False: 92.5k]
  ------------------
  267|       |                /* Overlaps() */
  268|  3.92k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 3.92k, False: 0]
  ------------------
  269|  3.92k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 3.92k, False: 0]
  ------------------
  270|  3.92k|                break;
  271|  3.92k|            }
  272|   240k|        }
  273|   105k|    }
  274|       |    /* Fully compare the final state. */
  275|  5.22k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.64k, False: 1.58k]
  ------------------
  276|  3.64k|        compare_fn(i);
  277|  3.64k|    }
  278|  1.58k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj3EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  56.7k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  56.7k|        auto it = real[idx].begin();
   44|  56.7k|        unsigned first = S::Size();
   45|  56.7k|        unsigned last = S::Size();
   46|  10.9M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 10.9M, False: 56.7k]
  ------------------
   47|  10.9M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 5.83M, False: 5.06M]
  |  Branch (47:53): [True: 2.05M, False: 3.77M]
  ------------------
   48|  10.9M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 10.9M, False: 0]
  ------------------
   49|  10.9M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 10.9M, False: 0]
  ------------------
   50|  10.9M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 10.9M, False: 0]
  ------------------
   51|  10.9M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 2.05M, False: 8.84M]
  ------------------
   52|  2.05M|                ++it;
   53|  2.05M|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 41.5k, False: 2.01M]
  ------------------
   54|  2.05M|                last = i;
   55|  2.05M|            }
   56|  10.9M|        }
   57|  56.7k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 56.7k, False: 0]
  ------------------
   58|  56.7k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 56.7k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  56.7k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 56.7k, False: 0]
  ------------------
   61|  56.7k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 56.7k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  56.7k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 41.5k, False: 15.2k]
  ------------------
   64|  41.5k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 41.5k, False: 0]
  ------------------
   65|  41.5k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 41.5k, False: 0]
  ------------------
   66|  41.5k|        }
   67|       |        /* Count */
   68|  56.7k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 56.7k, False: 0]
  ------------------
   69|  56.7k|    };
bitset.cpp:_ZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEE:
   27|  1.43k|{
   28|       |    /** This fuzz test's design is based on the assumption that the actual bits stored in the
   29|       |     *  bitsets and their simulations do not matter for the purpose of detecting edge cases, thus
   30|       |     *  these are taken from a deterministically-seeded RNG instead. To provide some level of
   31|       |     *  variation however, pick the seed based on the buffer size and size of the chosen bitset. */
   32|  1.43k|    InsecureRandomContext rng(buffer.size() + 0x10000 * S::Size());
   33|       |
   34|  1.43k|    using Sim = std::bitset<S::Size()>;
   35|       |    // Up to 4 real BitSets (initially 2).
   36|  1.43k|    std::vector<S> real(2);
   37|       |    // Up to 4 std::bitsets with the same corresponding contents.
   38|  1.43k|    std::vector<Sim> sim(2);
   39|       |
   40|       |    /* Compare sim[idx] with real[idx], using all inspector operations. */
   41|  1.43k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  1.43k|        auto it = real[idx].begin();
   44|  1.43k|        unsigned first = S::Size();
   45|  1.43k|        unsigned last = S::Size();
   46|  1.43k|        for (unsigned i = 0; i < S::Size(); ++i) {
   47|  1.43k|            bool match = (it != real[idx].end()) && *it == i;
   48|  1.43k|            assert(sim[idx][i] == real[idx][i]);
   49|  1.43k|            assert(match == real[idx][i]);
   50|  1.43k|            assert((it == real[idx].end()) != (it != real[idx].end()));
   51|  1.43k|            if (match) {
   52|  1.43k|                ++it;
   53|  1.43k|                if (first == S::Size()) first = i;
   54|  1.43k|                last = i;
   55|  1.43k|            }
   56|  1.43k|        }
   57|  1.43k|        assert(it == real[idx].end());
   58|  1.43k|        assert(!(it != real[idx].end()));
   59|       |        /* Any / None */
   60|  1.43k|        assert(sim[idx].any() == real[idx].Any());
   61|  1.43k|        assert(sim[idx].none() == real[idx].None());
   62|       |        /* First / Last */
   63|  1.43k|        if (sim[idx].any()) {
   64|  1.43k|            assert(first == real[idx].First());
   65|  1.43k|            assert(last == real[idx].Last());
   66|  1.43k|        }
   67|       |        /* Count */
   68|  1.43k|        assert(sim[idx].count() == real[idx].Count());
   69|  1.43k|    };
   70|       |
   71|  61.2k|    LIMITED_WHILE (buffer.size() > 0, 1000) {
  ------------------
  |  |   23|  62.6k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 61.2k, False: 1.41k]
  |  |  |  Branch (23:49): [True: 61.2k, False: 28]
  |  |  ------------------
  ------------------
   72|       |        // Read one byte to determine which operation to execute on the BitSets.
   73|  61.2k|        int command = ReadByte(buffer) % 64;
   74|       |        // Read another byte that determines which bitsets will be involved.
   75|  61.2k|        unsigned args = ReadByte(buffer);
   76|  61.2k|        unsigned dest = ((args & 7) * sim.size()) >> 3;
   77|  61.2k|        unsigned src = (((args >> 3) & 7) * sim.size()) >> 3;
   78|  61.2k|        unsigned aux = (((args >> 6) & 3) * sim.size()) >> 2;
   79|       |        // Args are in range for non-empty sim, or sim is completely empty and will be grown
   80|  61.2k|        assert((sim.empty() && dest == 0 && src == 0 && aux == 0) ||
  ------------------
  |  Branch (80:9): [True: 2.67k, False: 58.5k]
  |  Branch (80:9): [True: 2.67k, False: 0]
  |  Branch (80:9): [True: 2.67k, False: 0]
  |  Branch (80:9): [True: 2.67k, False: 0]
  |  Branch (80:9): [True: 58.5k, False: 0]
  |  Branch (80:9): [True: 58.5k, False: 0]
  |  Branch (80:9): [True: 58.5k, False: 0]
  |  Branch (80:9): [True: 58.5k, False: 0]
  |  Branch (80:9): [True: 61.2k, False: 0]
  ------------------
   81|  61.2k|            (!sim.empty() &&  dest < sim.size() && src < sim.size() && aux < sim.size()));
   82|       |
   83|       |        // Pick one operation based on value of command. Not all operations are always applicable.
   84|       |        // Loop through the applicable ones until command reaches 0 (which avoids the need to
   85|       |        // compute the number of applicable commands ahead of time).
   86|   158k|        while (true) {
  ------------------
  |  Branch (86:16): [True: 158k, Folded]
  ------------------
   87|   158k|            if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (87:17): [True: 119k, False: 39.8k]
  |  Branch (87:38): [True: 6.03k, False: 113k]
  ------------------
   88|       |                /* Set() (true) */
   89|  6.03k|                unsigned val = ReadByte(buffer) % S::Size();
   90|  6.03k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (90:17): [True: 6.03k, False: 0]
  ------------------
   91|  6.03k|                sim[dest].set(val);
   92|  6.03k|                real[dest].Set(val);
   93|  6.03k|                break;
   94|   152k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (94:24): [True: 113k, False: 39.8k]
  |  Branch (94:45): [True: 1.30k, False: 111k]
  ------------------
   95|       |                /* Reset() */
   96|  1.30k|                unsigned val = ReadByte(buffer) % S::Size();
   97|  1.30k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (97:17): [True: 1.30k, False: 0]
  ------------------
   98|  1.30k|                sim[dest].reset(val);
   99|  1.30k|                real[dest].Reset(val);
  100|  1.30k|                break;
  101|   151k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (101:24): [True: 111k, False: 39.8k]
  |  Branch (101:45): [True: 1.39k, False: 110k]
  ------------------
  102|       |                /* Set() (conditional) */
  103|  1.39k|                unsigned val = ReadByte(buffer) % S::Size();
  104|  1.39k|                assert(sim[dest][val] == real[dest][val]);
  ------------------
  |  Branch (104:17): [True: 1.39k, False: 0]
  ------------------
  105|  1.39k|                sim[dest].set(val, args >> 7);
  106|  1.39k|                real[dest].Set(val, args >> 7);
  107|  1.39k|                break;
  108|   150k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (108:24): [True: 107k, False: 42.5k]
  |  Branch (108:42): [True: 999, False: 106k]
  ------------------
  109|       |                /* Construct empty. */
  110|    999|                sim.resize(sim.size() + 1);
  111|    999|                real.resize(real.size() + 1);
  112|    999|                break;
  113|   149k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (113:24): [True: 106k, False: 42.5k]
  |  Branch (113:42): [True: 749, False: 105k]
  ------------------
  114|       |                /* Construct singleton. */
  115|    749|                unsigned val = ReadByte(buffer) % S::Size();
  116|    749|                std::bitset<S::Size()> newset;
  117|    749|                newset[val] = true;
  118|    749|                sim.push_back(newset);
  119|    749|                real.push_back(S::Singleton(val));
  120|    749|                break;
  121|   148k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (121:24): [True: 109k, False: 38.5k]
  |  Branch (121:45): [True: 3.73k, False: 106k]
  ------------------
  122|       |                /* Make random. */
  123|  3.73k|                compare_fn(dest);
  124|  3.73k|                sim[dest].reset();
  125|  3.73k|                real[dest] = S{};
  126|   960k|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (126:38): [True: 956k, False: 3.73k]
  ------------------
  127|   956k|                    if (rng.randbool()) {
  ------------------
  |  Branch (127:25): [True: 479k, False: 477k]
  ------------------
  128|   479k|                        sim[dest][i] = true;
  129|   479k|                        real[dest].Set(i);
  130|   479k|                    }
  131|   956k|                }
  132|  3.73k|                break;
  133|   144k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (133:24): [True: 106k, False: 38.5k]
  |  Branch (133:45): [True: 4.08k, False: 102k]
  ------------------
  134|       |                /* Assign initializer list. */
  135|  4.08k|                unsigned r1 = rng.randrange(S::Size());
  136|  4.08k|                unsigned r2 = rng.randrange(S::Size());
  137|  4.08k|                unsigned r3 = rng.randrange(S::Size());
  138|  4.08k|                compare_fn(dest);
  139|  4.08k|                sim[dest].reset();
  140|  4.08k|                real[dest] = {r1, r2, r3};
  141|  4.08k|                sim[dest].set(r1);
  142|  4.08k|                sim[dest].set(r2);
  143|  4.08k|                sim[dest].set(r3);
  144|  4.08k|                break;
  145|   140k|            } else if (!sim.empty() && command-- == 0) {
  ------------------
  |  Branch (145:24): [True: 102k, False: 38.5k]
  |  Branch (145:40): [True: 3.69k, False: 98.3k]
  ------------------
  146|       |                /* Destruct. */
  147|  3.69k|                compare_fn(sim.size() - 1);
  148|  3.69k|                sim.pop_back();
  149|  3.69k|                real.pop_back();
  150|  3.69k|                break;
  151|   136k|            } else if (sim.size() < 4 && src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (151:24): [True: 97.0k, False: 39.9k]
  |  Branch (151:42): [True: 58.4k, False: 38.5k]
  |  Branch (151:62): [True: 475, False: 57.9k]
  ------------------
  152|       |                /* Copy construct. */
  153|    475|                sim.emplace_back(sim[src]);
  154|    475|                real.emplace_back(real[src]);
  155|    475|                break;
  156|   136k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (156:24): [True: 97.9k, False: 38.5k]
  |  Branch (156:44): [True: 97.9k, False: 0]
  |  Branch (156:65): [True: 1.89k, False: 96.0k]
  ------------------
  157|       |                /* Copy assign. */
  158|  1.89k|                compare_fn(dest);
  159|  1.89k|                sim[dest] = sim[src];
  160|  1.89k|                real[dest] = real[src];
  161|  1.89k|                break;
  162|   134k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (162:24): [True: 96.0k, False: 38.5k]
  |  Branch (162:44): [True: 96.0k, False: 0]
  |  Branch (162:65): [True: 2.32k, False: 93.6k]
  ------------------
  163|       |                /* swap() function. */
  164|  2.32k|                swap(sim[dest], sim[src]);
  165|  2.32k|                swap(real[dest], real[src]);
  166|  2.32k|                break;
  167|   132k|            } else if (sim.size() < 4 && command-- == 0) {
  ------------------
  |  Branch (167:24): [True: 94.5k, False: 37.7k]
  |  Branch (167:42): [True: 1.73k, False: 92.7k]
  ------------------
  168|       |                /* Construct with initializer list. */
  169|  1.73k|                unsigned r1 = rng.randrange(S::Size());
  170|  1.73k|                unsigned r2 = rng.randrange(S::Size());
  171|  1.73k|                sim.emplace_back();
  172|  1.73k|                sim.back().set(r1);
  173|  1.73k|                sim.back().set(r2);
  174|  1.73k|                real.push_back(S{r1, r2});
  175|  1.73k|                break;
  176|   130k|            } else if (dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (176:24): [True: 93.3k, False: 37.2k]
  |  Branch (176:45): [True: 2.60k, False: 90.7k]
  ------------------
  177|       |                /* Fill() + copy assign. */
  178|  2.60k|                unsigned len = ReadByte(buffer) % S::Size();
  179|  2.60k|                compare_fn(dest);
  180|  2.60k|                sim[dest].reset();
  181|   297k|                for (unsigned i = 0; i < len; ++i) sim[dest][i] = true;
  ------------------
  |  Branch (181:38): [True: 295k, False: 2.60k]
  ------------------
  182|  2.60k|                real[dest] = S::Fill(len);
  183|  2.60k|                break;
  184|   127k|            } else if (src < sim.size() && command-- == 0) {
  ------------------
  |  Branch (184:24): [True: 90.7k, False: 37.2k]
  |  Branch (184:44): [True: 8.96k, False: 81.7k]
  ------------------
  185|       |                /* Iterator copy based compare. */
  186|  8.96k|                unsigned val = ReadByte(buffer) % S::Size();
  187|       |                /* In a first loop, compare begin..end, and copy to it_copy at some point. */
  188|  8.96k|                auto it = real[src].begin(), it_copy = it;
  189|  2.30M|                for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (189:38): [True: 2.29M, False: 8.96k]
  ------------------
  190|  2.29M|                    if (i == val) it_copy = it;
  ------------------
  |  Branch (190:25): [True: 8.96k, False: 2.28M]
  ------------------
  191|  2.29M|                    bool match = (it != real[src].end()) && *it == i;
  ------------------
  |  Branch (191:34): [True: 978k, False: 1.31M]
  |  Branch (191:61): [True: 173k, False: 804k]
  ------------------
  192|  2.29M|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (192:21): [True: 2.29M, False: 0]
  ------------------
  193|  2.29M|                    if (match) ++it;
  ------------------
  |  Branch (193:25): [True: 173k, False: 2.12M]
  ------------------
  194|  2.29M|                }
  195|  8.96k|                assert(it == real[src].end());
  ------------------
  |  Branch (195:17): [True: 8.96k, False: 0]
  ------------------
  196|       |                /* Then compare from the copied point again to end. */
  197|   635k|                for (unsigned i = val; i < S::Size(); ++i) {
  ------------------
  |  Branch (197:40): [True: 626k, False: 8.96k]
  ------------------
  198|   626k|                    bool match = (it_copy != real[src].end()) && *it_copy == i;
  ------------------
  |  Branch (198:34): [True: 306k, False: 320k]
  |  Branch (198:66): [True: 83.4k, False: 223k]
  ------------------
  199|   626k|                    assert(match == sim[src][i]);
  ------------------
  |  Branch (199:21): [True: 626k, False: 0]
  ------------------
  200|   626k|                    if (match) ++it_copy;
  ------------------
  |  Branch (200:25): [True: 83.4k, False: 543k]
  ------------------
  201|   626k|                }
  202|  8.96k|                assert(it_copy == real[src].end());
  ------------------
  |  Branch (202:17): [True: 8.96k, False: 0]
  ------------------
  203|  8.96k|                break;
  204|   118k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (204:24): [True: 81.7k, False: 37.2k]
  |  Branch (204:44): [True: 81.7k, False: 0]
  |  Branch (204:65): [True: 1.74k, False: 80.0k]
  ------------------
  205|       |                /* operator|= */
  206|  1.74k|                compare_fn(dest);
  207|  1.74k|                sim[dest] |= sim[src];
  208|  1.74k|                real[dest] |= real[src];
  209|  1.74k|                break;
  210|   117k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (210:24): [True: 80.0k, False: 37.2k]
  |  Branch (210:44): [True: 80.0k, False: 0]
  |  Branch (210:65): [True: 1.57k, False: 78.4k]
  ------------------
  211|       |                /* operator&= */
  212|  1.57k|                compare_fn(dest);
  213|  1.57k|                sim[dest] &= sim[src];
  214|  1.57k|                real[dest] &= real[src];
  215|  1.57k|                break;
  216|   115k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (216:24): [True: 78.4k, False: 37.2k]
  |  Branch (216:44): [True: 78.4k, False: 0]
  |  Branch (216:65): [True: 3.11k, False: 75.3k]
  ------------------
  217|       |                /* operator-= */
  218|  3.11k|                compare_fn(dest);
  219|  3.11k|                sim[dest] &= ~sim[src];
  220|  3.11k|                real[dest] -= real[src];
  221|  3.11k|                break;
  222|   112k|            } else if (src < sim.size() && dest < sim.size() && command-- == 0) {
  ------------------
  |  Branch (222:24): [True: 75.3k, False: 37.2k]
  |  Branch (222:44): [True: 75.3k, False: 0]
  |  Branch (222:65): [True: 1.46k, False: 73.8k]
  ------------------
  223|       |                /* operator^= */
  224|  1.46k|                compare_fn(dest);
  225|  1.46k|                sim[dest] ^= sim[src];
  226|  1.46k|                real[dest] ^= real[src];
  227|  1.46k|                break;
  228|   111k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (228:24): [True: 73.8k, False: 37.2k]
  |  Branch (228:44): [True: 73.8k, False: 0]
  |  Branch (228:65): [True: 73.8k, False: 0]
  |  Branch (228:85): [True: 2.84k, False: 71.0k]
  ------------------
  229|       |                /* operator| */
  230|  2.84k|                compare_fn(dest);
  231|  2.84k|                sim[dest] = sim[src] | sim[aux];
  232|  2.84k|                real[dest] = real[src] | real[aux];
  233|  2.84k|                break;
  234|   108k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (234:24): [True: 71.0k, False: 37.2k]
  |  Branch (234:44): [True: 71.0k, False: 0]
  |  Branch (234:65): [True: 71.0k, False: 0]
  |  Branch (234:85): [True: 1.62k, False: 69.3k]
  ------------------
  235|       |                /* operator& */
  236|  1.62k|                compare_fn(dest);
  237|  1.62k|                sim[dest] = sim[src] & sim[aux];
  238|  1.62k|                real[dest] = real[src] & real[aux];
  239|  1.62k|                break;
  240|   106k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (240:24): [True: 69.3k, False: 37.2k]
  |  Branch (240:44): [True: 69.3k, False: 0]
  |  Branch (240:65): [True: 69.3k, False: 0]
  |  Branch (240:85): [True: 1.40k, False: 67.9k]
  ------------------
  241|       |                /* operator- */
  242|  1.40k|                compare_fn(dest);
  243|  1.40k|                sim[dest] = sim[src] & ~sim[aux];
  244|  1.40k|                real[dest] = real[src] - real[aux];
  245|  1.40k|                break;
  246|   105k|            } else if (src < sim.size() && dest < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (246:24): [True: 67.9k, False: 37.2k]
  |  Branch (246:44): [True: 67.9k, False: 0]
  |  Branch (246:65): [True: 67.9k, False: 0]
  |  Branch (246:85): [True: 1.41k, False: 66.5k]
  ------------------
  247|       |                /* operator^ */
  248|  1.41k|                compare_fn(dest);
  249|  1.41k|                sim[dest] = sim[src] ^ sim[aux];
  250|  1.41k|                real[dest] = real[src] ^ real[aux];
  251|  1.41k|                break;
  252|   103k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (252:24): [True: 66.5k, False: 37.2k]
  |  Branch (252:44): [True: 66.5k, False: 0]
  |  Branch (252:64): [True: 2.41k, False: 64.1k]
  ------------------
  253|       |                /* IsSupersetOf() and IsSubsetOf() */
  254|  2.41k|                bool is_superset = (sim[aux] & ~sim[src]).none();
  255|  2.41k|                bool is_subset = (sim[src] & ~sim[aux]).none();
  256|  2.41k|                assert(real[src].IsSupersetOf(real[aux]) == is_superset);
  ------------------
  |  Branch (256:17): [True: 2.41k, False: 0]
  ------------------
  257|  2.41k|                assert(real[src].IsSubsetOf(real[aux]) == is_subset);
  ------------------
  |  Branch (257:17): [True: 2.41k, False: 0]
  ------------------
  258|  2.41k|                assert(real[aux].IsSupersetOf(real[src]) == is_subset);
  ------------------
  |  Branch (258:17): [True: 2.41k, False: 0]
  ------------------
  259|  2.41k|                assert(real[aux].IsSubsetOf(real[src]) == is_superset);
  ------------------
  |  Branch (259:17): [True: 2.41k, False: 0]
  ------------------
  260|  2.41k|                break;
  261|   101k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (261:24): [True: 64.1k, False: 37.2k]
  |  Branch (261:44): [True: 64.1k, False: 0]
  |  Branch (261:64): [True: 1.49k, False: 62.6k]
  ------------------
  262|       |                /* operator== and operator!= */
  263|  1.49k|                assert((sim[src] == sim[aux]) == (real[src] == real[aux]));
  ------------------
  |  Branch (263:17): [True: 1.49k, False: 0]
  ------------------
  264|  1.49k|                assert((sim[src] != sim[aux]) == (real[src] != real[aux]));
  ------------------
  |  Branch (264:17): [True: 1.49k, False: 0]
  ------------------
  265|  1.49k|                break;
  266|  99.8k|            } else if (src < sim.size() && aux < sim.size() && command-- == 0) {
  ------------------
  |  Branch (266:24): [True: 62.6k, False: 37.2k]
  |  Branch (266:44): [True: 62.6k, False: 0]
  |  Branch (266:64): [True: 2.13k, False: 60.5k]
  ------------------
  267|       |                /* Overlaps() */
  268|  2.13k|                assert((sim[src] & sim[aux]).any() == real[src].Overlaps(real[aux]));
  ------------------
  |  Branch (268:17): [True: 2.13k, False: 0]
  ------------------
  269|  2.13k|                assert((sim[src] & sim[aux]).any() == real[aux].Overlaps(real[src]));
  ------------------
  |  Branch (269:17): [True: 2.13k, False: 0]
  ------------------
  270|  2.13k|                break;
  271|  2.13k|            }
  272|   158k|        }
  273|  61.2k|    }
  274|       |    /* Fully compare the final state. */
  275|  4.57k|    for (unsigned i = 0; i < sim.size(); ++i) {
  ------------------
  |  Branch (275:26): [True: 3.13k, False: 1.43k]
  ------------------
  276|  3.13k|        compare_fn(i);
  277|  3.13k|    }
  278|  1.43k|}
bitset.cpp:_ZZN12_GLOBAL__N_18TestTypeIN13bitset_detail14MultiIntBitSetImLj4EEEEEvNSt3__14spanIKhLm18446744073709551615EEEENKUljE_clEj:
   41|  34.3k|    auto compare_fn = [&](unsigned idx) {
   42|       |        /* iterators and operator[] */
   43|  34.3k|        auto it = real[idx].begin();
   44|  34.3k|        unsigned first = S::Size();
   45|  34.3k|        unsigned last = S::Size();
   46|  8.83M|        for (unsigned i = 0; i < S::Size(); ++i) {
  ------------------
  |  Branch (46:30): [True: 8.79M, False: 34.3k]
  ------------------
   47|  8.79M|            bool match = (it != real[idx].end()) && *it == i;
  ------------------
  |  Branch (47:26): [True: 3.93M, False: 4.86M]
  |  Branch (47:53): [True: 1.27M, False: 2.66M]
  ------------------
   48|  8.79M|            assert(sim[idx][i] == real[idx][i]);
  ------------------
  |  Branch (48:13): [True: 8.79M, False: 0]
  ------------------
   49|  8.79M|            assert(match == real[idx][i]);
  ------------------
  |  Branch (49:13): [True: 8.79M, False: 0]
  ------------------
   50|  8.79M|            assert((it == real[idx].end()) != (it != real[idx].end()));
  ------------------
  |  Branch (50:13): [True: 8.79M, False: 0]
  ------------------
   51|  8.79M|            if (match) {
  ------------------
  |  Branch (51:17): [True: 1.27M, False: 7.52M]
  ------------------
   52|  1.27M|                ++it;
   53|  1.27M|                if (first == S::Size()) first = i;
  ------------------
  |  Branch (53:21): [True: 20.4k, False: 1.25M]
  ------------------
   54|  1.27M|                last = i;
   55|  1.27M|            }
   56|  8.79M|        }
   57|  34.3k|        assert(it == real[idx].end());
  ------------------
  |  Branch (57:9): [True: 34.3k, False: 0]
  ------------------
   58|  34.3k|        assert(!(it != real[idx].end()));
  ------------------
  |  Branch (58:9): [True: 34.3k, False: 0]
  ------------------
   59|       |        /* Any / None */
   60|  34.3k|        assert(sim[idx].any() == real[idx].Any());
  ------------------
  |  Branch (60:9): [True: 34.3k, False: 0]
  ------------------
   61|  34.3k|        assert(sim[idx].none() == real[idx].None());
  ------------------
  |  Branch (61:9): [True: 34.3k, False: 0]
  ------------------
   62|       |        /* First / Last */
   63|  34.3k|        if (sim[idx].any()) {
  ------------------
  |  Branch (63:13): [True: 20.4k, False: 13.8k]
  ------------------
   64|  20.4k|            assert(first == real[idx].First());
  ------------------
  |  Branch (64:13): [True: 20.4k, False: 0]
  ------------------
   65|  20.4k|            assert(last == real[idx].Last());
  ------------------
  |  Branch (65:13): [True: 20.4k, False: 0]
  ------------------
   66|  20.4k|        }
   67|       |        /* Count */
   68|  34.3k|        assert(sim[idx].count() == real[idx].Count());
  ------------------
  |  Branch (68:9): [True: 34.3k, False: 0]
  ------------------
   69|  34.3k|    };

LLVMFuzzerTestOneInput:
  213|  10.0k|{
  214|  10.0k|    test_one_input({data, size});
  215|  10.0k|    return 0;
  216|  10.0k|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   84|  10.0k|{
   85|  10.0k|    CheckGlobals check{};
   86|  10.0k|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |  116|  10.0k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   87|  10.0k|}

_ZN12CheckGlobalsC2Ev:
   59|  10.0k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   60|  10.0k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  10.0k|    {
   18|  10.0k|        g_used_g_prng = false;
   19|  10.0k|        g_seeded_g_prng_zero = false;
   20|  10.0k|        g_used_system_time = false;
   21|  10.0k|        SetMockTime(0s);
   22|  10.0k|        MockableSteadyClock::ClearMockTime();
   23|  10.0k|    }
_ZN16CheckGlobalsImplD2Ev:
   25|  10.0k|    {
   26|  10.0k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (26:13): [True: 0, False: 10.0k]
  |  Branch (26:30): [True: 0, False: 0]
  ------------------
   27|      0|            std::cerr << "\n\n"
   28|      0|                         "The current fuzz target used the global random state.\n\n"
   29|       |
   30|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   31|      0|                         "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n"
   32|      0|                         "of the FUZZ_TARGET function.\n\n"
   33|       |
   34|      0|                         "An alternative solution would be to avoid any use of globals.\n\n"
   35|       |
   36|      0|                         "Without a solution, fuzz instability and non-determinism can lead \n"
   37|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   38|      0|                      << std::endl;
   39|      0|            std::abort(); // Abort, because AFL may try to recover from a std::exit
   40|      0|        }
   41|       |
   42|  10.0k|        if (g_used_system_time) {
  ------------------
  |  Branch (42:13): [True: 0, False: 10.0k]
  ------------------
   43|      0|            std::cerr << "\n\n"
   44|      0|                         "The current fuzz target accessed system time.\n\n"
   45|       |
   46|      0|                         "This is acceptable, but requires the fuzz target to use \n"
   47|      0|                         "a FakeNodeClock, FakeSteadyClock or call \n"
   48|      0|                         "SetMockTime() at the \n" "beginning of processing the \n"
   49|      0|                         "fuzz input.\n\n"
   50|       |
   51|      0|                         "Without setting mock time, time-dependent behavior can lead \n"
   52|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   53|      0|                      << std::endl;
   54|      0|            std::abort();
   55|      0|        }
   56|  10.0k|    }

__gcov_reset:
   13|      2|extern "C" __attribute__((weak)) void __gcov_reset(void) {}

_ZN9base_blobILj256EE4dataEv:
   99|      2|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|      2|    static constexpr unsigned int size() { return WIDTH; }

_ZN13bitset_detail9IntBitSetItE4SizeEv:
  178|  1.05M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail9IntBitSetItEixEj:
  171|  1.15M|    {
  172|  1.15M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.15M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  173|  1.15M|        return (m_val >> pos) & 1U;
  174|  1.15M|    }
_ZN13bitset_detail9IntBitSetItE3SetEj:
  153|  84.6k|    {
  154|  84.6k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  84.6k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  155|  84.6k|        m_val |= I{1U} << pos;
  156|  84.6k|    }
_ZN13bitset_detail9IntBitSetItE5ResetEj:
  165|  2.87k|    {
  166|  2.87k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.87k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  167|  2.87k|        m_val &= ~I(I{1U} << pos);
  168|  2.87k|    }
_ZN13bitset_detail9IntBitSetItE3SetEjb:
  159|  1.33k|    {
  160|  1.33k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.33k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  161|  1.33k|        m_val = (m_val & ~I(I{1U} << pos)) | (I(val) << pos);
  162|  1.33k|    }
_ZN13bitset_detail9IntBitSetItE9SingletonEj:
  139|    763|    {
  140|    763|        Assume(i < MAX_SIZE);
  ------------------
  |  |  128|    763|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  141|    763|        return IntBitSet(I(1U) << i);
  142|    763|    }
_ZN13bitset_detail9IntBitSetItEC2Et:
   72|  8.00k|    IntBitSet(I val) noexcept : m_val{val} {}
_ZNK13bitset_detail9IntBitSetItE3AnyEv:
  182|  35.2k|    constexpr bool Any() const noexcept { return !None(); }
_ZNK13bitset_detail9IntBitSetItE4NoneEv:
  180|  70.5k|    constexpr bool None() const noexcept { return m_val == 0; }
_ZNK13bitset_detail9IntBitSetItE5FirstEv:
  189|  26.1k|    {
  190|  26.1k|        Assume(m_val != 0);
  ------------------
  |  |  128|  26.1k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  191|  26.1k|        return std::countr_zero(m_val);
  192|  26.1k|    }
_ZNK13bitset_detail9IntBitSetItE4LastEv:
  195|  26.1k|    {
  196|  26.1k|        Assume(m_val != 0);
  ------------------
  |  |  128|  26.1k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  197|  26.1k|        return std::bit_width(m_val) - 1;
  198|  26.1k|    }
_ZNK13bitset_detail9IntBitSetItE5CountEv:
  176|  35.2k|    constexpr unsigned Count() const noexcept { return PopCount(m_val); }
_ZN13bitset_detail8PopCountItEEjT_:
   40|   501k|{
   41|   501k|    static_assert(std::is_integral_v<I> && std::is_unsigned_v<I> && std::numeric_limits<I>::radix == 2);
   42|   501k|    constexpr auto BITS = std::numeric_limits<I>::digits;
   43|       |    // Algorithms from https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation.
   44|       |    // These seem to be faster than std::popcount when compiling for non-SSE4 on x86_64.
   45|   501k|    if constexpr (BITS <= 32) {
   46|   501k|        v -= (v >> 1) & 0x55555555;
   47|   501k|        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
   48|   501k|        v = (v + (v >> 4)) & 0x0f0f0f0f;
   49|   501k|        if constexpr (BITS > 8) v += v >> 8;
   50|       |        if constexpr (BITS > 16) v += v >> 16;
   51|   501k|        return v & 0x3f;
   52|       |    } else {
   53|       |        static_assert(BITS <= 64);
   54|       |        v -= (v >> 1) & 0x5555555555555555;
   55|       |        v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333);
   56|       |        v = (v + (v >> 4)) & 0x0f0f0f0f0f0f0f0f;
   57|       |        return (v * uint64_t{0x0101010101010101}) >> 56;
   58|       |    }
   59|   501k|}
_ZN13bitset_detail9IntBitSetItEC2Ev:
  120|  9.28k|    constexpr IntBitSet() noexcept : m_val{0} {}
_ZN13bitset_detail9IntBitSetItEaSESt16initializer_listIjE:
  132|  6.52k|    {
  133|  6.52k|        m_val = 0;
  134|  19.5k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (134:23): [True: 19.5k, False: 6.52k]
  ------------------
  135|  6.52k|        return *this;
  136|  6.52k|    }
_ZN13bitset_detail4swapERNS_9IntBitSetItEES2_:
  224|  1.53k|    friend constexpr void swap(IntBitSet& a, IntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail9IntBitSetItEC2ESt16initializer_listIjE:
  124|  1.20k|    constexpr IntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val(0)
  125|  1.20k|    {
  126|  2.40k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (126:23): [True: 2.40k, False: 1.20k]
  ------------------
  127|  1.20k|    }
_ZN13bitset_detail9IntBitSetItE4FillEj:
  145|  1.77k|    {
  146|  1.77k|        IntBitSet ret;
  147|  1.77k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  1.77k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  148|  1.77k|        if (count) ret.m_val = I(~I{0}) >> (MAX_SIZE - count);
  ------------------
  |  Branch (148:13): [True: 1.42k, False: 349]
  ------------------
  149|  1.77k|        return ret;
  150|  1.77k|    }
_ZNK13bitset_detail9IntBitSetItE5beginEv:
  184|  39.1k|    constexpr Iterator begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail9IntBitSetItE8IteratorC2Et:
   87|  39.1k|        constexpr Iterator(I val) noexcept : m_val(val), m_pos(0)
   88|  39.1k|        {
   89|  39.1k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (89:17): [True: 28.9k, False: 10.1k]
  ------------------
   90|  39.1k|        }
_ZN13bitset_detaileqERKNS_9IntBitSetItE8IteratorERKNS1_11IteratorEndE:
   99|  1.85M|        {
  100|  1.85M|            return a.m_val == 0;
  101|  1.85M|        }
_ZNK13bitset_detail9IntBitSetItE3endEv:
  186|  1.85M|    constexpr IteratorEnd end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail9IntBitSetItE8IteratordeEv:
  112|   378k|        {
  113|   378k|            Assume(m_val != 0);
  ------------------
  |  |  128|   378k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  114|   378k|            return m_pos;
  115|   378k|        }
_ZN13bitset_detail9IntBitSetItE8IteratorppEv:
  104|   172k|        {
  105|   172k|            Assume(m_val != 0);
  ------------------
  |  |  128|   172k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  106|   172k|            m_val &= m_val - I{1U};
  107|   172k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (107:17): [True: 141k, False: 31.0k]
  ------------------
  108|   172k|            return *this;
  109|   172k|        }
_ZN13bitset_detail9IntBitSetItEoRERKS1_:
  200|  2.22k|    constexpr IntBitSet& operator|=(const IntBitSet& a) noexcept { m_val |= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetItEaNERKS1_:
  202|  2.37k|    constexpr IntBitSet& operator&=(const IntBitSet& a) noexcept { m_val &= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetItEmIERKS1_:
  204|  1.52k|    constexpr IntBitSet& operator-=(const IntBitSet& a) noexcept { m_val &= ~a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetItEeOERKS1_:
  206|  1.56k|    constexpr IntBitSet& operator^=(const IntBitSet& a) noexcept { m_val ^= a.m_val; return *this; }
_ZN13bitset_detailorERKNS_9IntBitSetItEES3_:
  212|  4.03k|    friend constexpr IntBitSet operator|(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val | b.m_val); }
_ZN13bitset_detailanERKNS_9IntBitSetItEES3_:
  210|    948|    friend constexpr IntBitSet operator&(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & b.m_val); }
_ZN13bitset_detailmiERKNS_9IntBitSetItEES3_:
  214|  1.28k|    friend constexpr IntBitSet operator-(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & ~b.m_val); }
_ZN13bitset_detaileoERKNS_9IntBitSetItEES3_:
  216|    972|    friend constexpr IntBitSet operator^(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val ^ b.m_val); }
_ZNK13bitset_detail9IntBitSetItE12IsSupersetOfERKS1_:
  220|  4.41k|    constexpr bool IsSupersetOf(const IntBitSet& a) const noexcept { return (a.m_val & ~m_val) == 0; }
_ZNK13bitset_detail9IntBitSetItE10IsSubsetOfERKS1_:
  222|  4.41k|    constexpr bool IsSubsetOf(const IntBitSet& a) const noexcept { return (m_val & ~a.m_val) == 0; }
_ZN13bitset_detaileqERKNS_9IntBitSetItEES3_:
  218|  5.32k|    friend constexpr bool operator==(const IntBitSet& a, const IntBitSet& b) noexcept = default;
_ZNK13bitset_detail9IntBitSetItE8OverlapsERKS1_:
  208|  5.23k|    constexpr bool Overlaps(const IntBitSet& a) const noexcept { return m_val & a.m_val; }
_ZN13bitset_detail14MultiIntBitSetItLj1EE4SizeEv:
  378|  1.05M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetItLj1EEixEj:
  350|  1.15M|    {
  351|  1.15M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.15M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  1.15M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  1.15M|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EE3SetEj:
  319|  84.6k|    {
  320|  84.6k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  84.6k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|  84.6k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|  84.6k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EE5ResetEj:
  344|  2.87k|    {
  345|  2.87k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.87k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  2.87k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  2.87k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EE3SetEjb:
  325|  1.33k|    {
  326|  1.33k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.33k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  1.33k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  1.33k|                                 (I{val} << (pos % LIMB_BITS));
  329|  1.33k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EE9SingletonEj:
  356|    763|    {
  357|    763|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    763|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    763|        MultiIntBitSet ret;
  359|    763|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    763|        return ret;
  361|    763|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE3AnyEv:
  395|  35.2k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE4NoneEv:
  388|  70.5k|    {
  389|  70.5k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 70.5k, False: 18.2k]
  ------------------
  390|  70.5k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 52.3k, False: 18.2k]
  ------------------
  391|  70.5k|        }
  392|  18.2k|        return true;
  393|  70.5k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE5FirstEv:
  402|  26.1k|    {
  403|  26.1k|        unsigned p = 0;
  404|  26.1k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 0, False: 26.1k]
  ------------------
  405|      0|            ++p;
  406|      0|            Assume(p < N);
  ------------------
  |  |  128|      0|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|      0|        }
  408|  26.1k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  26.1k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE4LastEv:
  412|  26.1k|    {
  413|  26.1k|        unsigned p = N - 1;
  414|  26.1k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 0, False: 26.1k]
  ------------------
  415|      0|            Assume(p > 0);
  ------------------
  |  |  128|      0|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|      0|            --p;
  417|      0|        }
  418|  26.1k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  26.1k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE5CountEv:
  381|  35.2k|    {
  382|  35.2k|        unsigned ret{0};
  383|  35.2k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 35.2k, False: 35.2k]
  ------------------
  384|  35.2k|        return ret;
  385|  35.2k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EEC2Ev:
  312|  17.2k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetItLj1EEaSESt16initializer_listIjE:
  337|  6.52k|    {
  338|  6.52k|        m_val.fill(0);
  339|  19.5k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 19.5k, False: 6.52k]
  ------------------
  340|  6.52k|        return *this;
  341|  6.52k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetItLj1EEES2_:
  515|  1.53k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj1EEC2ESt16initializer_listIjE:
  331|  1.20k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  1.20k|    {
  333|  2.40k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 2.40k, False: 1.20k]
  ------------------
  334|  1.20k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EE4FillEj:
  364|  1.77k|    {
  365|  1.77k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  1.77k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  1.77k|        MultiIntBitSet ret;
  367|  1.77k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 1.42k, False: 349]
  ------------------
  368|  1.42k|            unsigned i = 0;
  369|  1.42k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 0, False: 1.42k]
  ------------------
  370|      0|                ret.m_val[i++] = I(~I{0});
  371|      0|                count -= LIMB_BITS;
  372|      0|            }
  373|  1.42k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  1.42k|        }
  375|  1.77k|        return ret;
  376|  1.77k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE5beginEv:
  397|  39.1k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj1EE8IteratorC2ERKNSt3__15arrayItLm1EEE:
  259|  39.1k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  39.1k|        {
  261|  39.1k|            do {
  262|  39.1k|                m_val = (*m_ptr)[m_idx];
  263|  39.1k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 28.9k, False: 10.1k]
  ------------------
  264|  28.9k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  28.9k|                    break;
  266|  28.9k|                }
  267|  10.1k|                ++m_idx;
  268|  10.1k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 0, False: 10.1k]
  ------------------
  269|  39.1k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj1EE8IteratorERKNS1_11IteratorEndE:
  279|  1.85M|        {
  280|  1.85M|            return a.m_idx == N;
  281|  1.85M|        }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE3endEv:
  399|  1.85M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE8IteratordeEv:
  304|   378k|        {
  305|   378k|            Assume(m_idx < N);
  ------------------
  |  |  128|   378k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|   378k|            return m_pos;
  307|   378k|        }
_ZN13bitset_detail14MultiIntBitSetItLj1EE8IteratorppEv:
  284|   172k|        {
  285|   172k|            Assume(m_idx < N);
  ------------------
  |  |  128|   172k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   172k|            m_val &= m_val - I{1U};
  287|   172k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 31.0k, False: 141k]
  ------------------
  288|  31.0k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 31.0k, Folded]
  ------------------
  289|  31.0k|                    ++m_idx;
  290|  31.0k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 31.0k, False: 0]
  ------------------
  291|      0|                    m_val = (*m_ptr)[m_idx];
  292|      0|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 0, False: 0]
  ------------------
  293|      0|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|      0|                        break;
  295|      0|                    }
  296|      0|                }
  297|   141k|            } else {
  298|   141k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   141k|            }
  300|   172k|            return *this;
  301|   172k|        }
_ZN13bitset_detail14MultiIntBitSetItLj1EEoRERKS1_:
  422|  2.22k|    {
  423|  4.44k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 2.22k, False: 2.22k]
  ------------------
  424|  2.22k|            m_val[i] |= a.m_val[i];
  425|  2.22k|        }
  426|  2.22k|        return *this;
  427|  2.22k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EEaNERKS1_:
  430|  2.37k|    {
  431|  4.75k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 2.37k, False: 2.37k]
  ------------------
  432|  2.37k|            m_val[i] &= a.m_val[i];
  433|  2.37k|        }
  434|  2.37k|        return *this;
  435|  2.37k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EEmIERKS1_:
  438|  1.52k|    {
  439|  3.05k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 1.52k, False: 1.52k]
  ------------------
  440|  1.52k|            m_val[i] &= ~a.m_val[i];
  441|  1.52k|        }
  442|  1.52k|        return *this;
  443|  1.52k|    }
_ZN13bitset_detail14MultiIntBitSetItLj1EEeOERKS1_:
  446|  1.56k|    {
  447|  3.12k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 1.56k, False: 1.56k]
  ------------------
  448|  1.56k|            m_val[i] ^= a.m_val[i];
  449|  1.56k|        }
  450|  1.56k|        return *this;
  451|  1.56k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetItLj1EEES3_:
  471|  4.03k|    {
  472|  4.03k|        MultiIntBitSet r;
  473|  8.07k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 4.03k, False: 4.03k]
  ------------------
  474|  4.03k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  4.03k|        }
  476|  4.03k|        return r;
  477|  4.03k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetItLj1EEES3_:
  462|    948|    {
  463|    948|        MultiIntBitSet r;
  464|  1.89k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 948, False: 948]
  ------------------
  465|    948|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|    948|        }
  467|    948|        return r;
  468|    948|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetItLj1EEES3_:
  480|  1.28k|    {
  481|  1.28k|        MultiIntBitSet r;
  482|  2.56k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 1.28k, False: 1.28k]
  ------------------
  483|  1.28k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  1.28k|        }
  485|  1.28k|        return r;
  486|  1.28k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetItLj1EEES3_:
  489|    972|    {
  490|    972|        MultiIntBitSet r;
  491|  1.94k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 972, False: 972]
  ------------------
  492|    972|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|    972|        }
  494|    972|        return r;
  495|    972|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE12IsSupersetOfERKS1_:
  498|  4.41k|    {
  499|  6.86k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 4.41k, False: 2.44k]
  ------------------
  500|  4.41k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 1.96k, False: 2.44k]
  ------------------
  501|  4.41k|        }
  502|  2.44k|        return true;
  503|  4.41k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj1EE10IsSubsetOfERKS1_:
  506|  4.41k|    {
  507|  6.86k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 4.41k, False: 2.44k]
  ------------------
  508|  4.41k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 1.96k, False: 2.44k]
  ------------------
  509|  4.41k|        }
  510|  2.44k|        return true;
  511|  4.41k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj1EEES3_:
  513|  5.32k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetItLj1EE8OverlapsERKS1_:
  454|  5.23k|    {
  455|  7.18k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 5.23k, False: 1.94k]
  ------------------
  456|  5.23k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 3.29k, False: 1.94k]
  ------------------
  457|  5.23k|        }
  458|  1.94k|        return false;
  459|  5.23k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE4SizeEv:
  378|  2.47M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetItLj2EEixEj:
  350|  3.03M|    {
  351|  3.03M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.03M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  3.03M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  3.03M|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE3SetEj:
  319|   127k|    {
  320|   127k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   127k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   127k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   127k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE5ResetEj:
  344|  7.04k|    {
  345|  7.04k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.04k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  7.04k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  7.04k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE3SetEjb:
  325|  2.79k|    {
  326|  2.79k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.79k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  2.79k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  2.79k|                                 (I{val} << (pos % LIMB_BITS));
  329|  2.79k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE9SingletonEj:
  356|    900|    {
  357|    900|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    900|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    900|        MultiIntBitSet ret;
  359|    900|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    900|        return ret;
  361|    900|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE3AnyEv:
  395|  46.8k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE4NoneEv:
  388|  93.7k|    {
  389|   128k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 128k, False: 28.6k]
  ------------------
  390|   128k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 65.1k, False: 63.8k]
  ------------------
  391|   128k|        }
  392|  28.6k|        return true;
  393|  93.7k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE5FirstEv:
  402|  32.5k|    {
  403|  32.5k|        unsigned p = 0;
  404|  35.8k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 3.32k, False: 32.5k]
  ------------------
  405|  3.32k|            ++p;
  406|  3.32k|            Assume(p < N);
  ------------------
  |  |  128|  3.32k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  3.32k|        }
  408|  32.5k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  32.5k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE4LastEv:
  412|  32.5k|    {
  413|  32.5k|        unsigned p = N - 1;
  414|  39.2k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 6.65k, False: 32.5k]
  ------------------
  415|  6.65k|            Assume(p > 0);
  ------------------
  |  |  128|  6.65k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  6.65k|            --p;
  417|  6.65k|        }
  418|  32.5k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  32.5k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE5CountEv:
  381|  46.8k|    {
  382|  46.8k|        unsigned ret{0};
  383|  93.7k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 93.7k, False: 46.8k]
  ------------------
  384|  46.8k|        return ret;
  385|  46.8k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EEC2Ev:
  312|  21.9k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetItLj2EEaSESt16initializer_listIjE:
  337|  5.38k|    {
  338|  5.38k|        m_val.fill(0);
  339|  16.1k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 16.1k, False: 5.38k]
  ------------------
  340|  5.38k|        return *this;
  341|  5.38k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetItLj2EEES2_:
  515|  3.22k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj2EEC2ESt16initializer_listIjE:
  331|  1.86k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  1.86k|    {
  333|  3.73k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 3.73k, False: 1.86k]
  ------------------
  334|  1.86k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EE4FillEj:
  364|  3.52k|    {
  365|  3.52k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  3.52k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  3.52k|        MultiIntBitSet ret;
  367|  3.52k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 3.12k, False: 399]
  ------------------
  368|  3.12k|            unsigned i = 0;
  369|  4.65k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 1.52k, False: 3.12k]
  ------------------
  370|  1.52k|                ret.m_val[i++] = I(~I{0});
  371|  1.52k|                count -= LIMB_BITS;
  372|  1.52k|            }
  373|  3.12k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  3.12k|        }
  375|  3.52k|        return ret;
  376|  3.52k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE5beginEv:
  397|  53.1k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj2EE8IteratorC2ERKNSt3__15arrayItLm2EEE:
  259|  53.1k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  53.1k|        {
  261|  73.1k|            do {
  262|  73.1k|                m_val = (*m_ptr)[m_idx];
  263|  73.1k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 37.2k, False: 35.9k]
  ------------------
  264|  37.2k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  37.2k|                    break;
  266|  37.2k|                }
  267|  35.9k|                ++m_idx;
  268|  35.9k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 20.0k, False: 15.8k]
  ------------------
  269|  53.1k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj2EE8IteratorERKNS1_11IteratorEndE:
  279|  4.87M|        {
  280|  4.87M|            return a.m_idx == N;
  281|  4.87M|        }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE3endEv:
  399|  4.87M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE8IteratordeEv:
  304|   931k|        {
  305|   931k|            Assume(m_idx < N);
  ------------------
  |  |  128|   931k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|   931k|            return m_pos;
  307|   931k|        }
_ZN13bitset_detail14MultiIntBitSetItLj2EE8IteratorppEv:
  284|   383k|        {
  285|   383k|            Assume(m_idx < N);
  ------------------
  |  |  128|   383k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   383k|            m_val &= m_val - I{1U};
  287|   383k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 66.5k, False: 317k]
  ------------------
  288|  75.2k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 75.2k, Folded]
  ------------------
  289|  75.2k|                    ++m_idx;
  290|  75.2k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 40.3k, False: 34.8k]
  ------------------
  291|  34.8k|                    m_val = (*m_ptr)[m_idx];
  292|  34.8k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 26.1k, False: 8.65k]
  ------------------
  293|  26.1k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  26.1k|                        break;
  295|  26.1k|                    }
  296|  34.8k|                }
  297|   317k|            } else {
  298|   317k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   317k|            }
  300|   383k|            return *this;
  301|   383k|        }
_ZN13bitset_detail14MultiIntBitSetItLj2EEoRERKS1_:
  422|  3.21k|    {
  423|  9.65k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 6.43k, False: 3.21k]
  ------------------
  424|  6.43k|            m_val[i] |= a.m_val[i];
  425|  6.43k|        }
  426|  3.21k|        return *this;
  427|  3.21k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EEaNERKS1_:
  430|  3.29k|    {
  431|  9.89k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 6.59k, False: 3.29k]
  ------------------
  432|  6.59k|            m_val[i] &= a.m_val[i];
  433|  6.59k|        }
  434|  3.29k|        return *this;
  435|  3.29k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EEmIERKS1_:
  438|  5.86k|    {
  439|  17.5k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 11.7k, False: 5.86k]
  ------------------
  440|  11.7k|            m_val[i] &= ~a.m_val[i];
  441|  11.7k|        }
  442|  5.86k|        return *this;
  443|  5.86k|    }
_ZN13bitset_detail14MultiIntBitSetItLj2EEeOERKS1_:
  446|  2.28k|    {
  447|  6.86k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 4.57k, False: 2.28k]
  ------------------
  448|  4.57k|            m_val[i] ^= a.m_val[i];
  449|  4.57k|        }
  450|  2.28k|        return *this;
  451|  2.28k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetItLj2EEES3_:
  471|  2.96k|    {
  472|  2.96k|        MultiIntBitSet r;
  473|  8.89k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 5.93k, False: 2.96k]
  ------------------
  474|  5.93k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  5.93k|        }
  476|  2.96k|        return r;
  477|  2.96k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetItLj2EEES3_:
  462|  1.88k|    {
  463|  1.88k|        MultiIntBitSet r;
  464|  5.64k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 3.76k, False: 1.88k]
  ------------------
  465|  3.76k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  3.76k|        }
  467|  1.88k|        return r;
  468|  1.88k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetItLj2EEES3_:
  480|  2.38k|    {
  481|  2.38k|        MultiIntBitSet r;
  482|  7.14k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 4.76k, False: 2.38k]
  ------------------
  483|  4.76k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  4.76k|        }
  485|  2.38k|        return r;
  486|  2.38k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetItLj2EEES3_:
  489|  1.97k|    {
  490|  1.97k|        MultiIntBitSet r;
  491|  5.92k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 3.94k, False: 1.97k]
  ------------------
  492|  3.94k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  3.94k|        }
  494|  1.97k|        return r;
  495|  1.97k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE12IsSupersetOfERKS1_:
  498|  8.62k|    {
  499|  19.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 14.4k, False: 5.07k]
  ------------------
  500|  14.4k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 3.54k, False: 10.8k]
  ------------------
  501|  14.4k|        }
  502|  5.07k|        return true;
  503|  8.62k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj2EE10IsSubsetOfERKS1_:
  506|  8.62k|    {
  507|  19.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 14.4k, False: 5.07k]
  ------------------
  508|  14.4k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 3.54k, False: 10.8k]
  ------------------
  509|  14.4k|        }
  510|  5.07k|        return true;
  511|  8.62k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj2EEES3_:
  513|  4.66k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetItLj2EE8OverlapsERKS1_:
  454|  6.12k|    {
  455|  11.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 8.92k, False: 2.32k]
  ------------------
  456|  8.92k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 3.80k, False: 5.11k]
  ------------------
  457|  8.92k|        }
  458|  2.32k|        return false;
  459|  6.12k|    }
_ZN13bitset_detail9IntBitSetIjE3SetEjb:
  159|  2.79k|    {
  160|  2.79k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.79k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  161|  2.79k|        m_val = (m_val & ~I(I{1U} << pos)) | (I(val) << pos);
  162|  2.79k|    }
_ZN13bitset_detail4swapERNS_9IntBitSetIjEES2_:
  224|  3.22k|    friend constexpr void swap(IntBitSet& a, IntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail9IntBitSetIjEC2ESt16initializer_listIjE:
  124|  1.86k|    constexpr IntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val(0)
  125|  1.86k|    {
  126|  3.73k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (126:23): [True: 3.73k, False: 1.86k]
  ------------------
  127|  1.86k|    }
_ZN13bitset_detail9IntBitSetIjEeOERKS1_:
  206|  2.28k|    constexpr IntBitSet& operator^=(const IntBitSet& a) noexcept { m_val ^= a.m_val; return *this; }
_ZN13bitset_detaileoERKNS_9IntBitSetIjEES3_:
  216|  1.97k|    friend constexpr IntBitSet operator^(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val ^ b.m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj3EE4SizeEv:
  378|  2.62M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetItLj3EEixEj:
  350|  3.33M|    {
  351|  3.33M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.33M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  3.33M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  3.33M|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EE3SetEj:
  319|   150k|    {
  320|   150k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   150k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   150k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   150k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EE5ResetEj:
  344|  1.99k|    {
  345|  1.99k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.99k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  1.99k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  1.99k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EE3SetEjb:
  325|  1.43k|    {
  326|  1.43k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.43k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  1.43k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  1.43k|                                 (I{val} << (pos % LIMB_BITS));
  329|  1.43k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EE9SingletonEj:
  356|  1.25k|    {
  357|  1.25k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.25k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|  1.25k|        MultiIntBitSet ret;
  359|  1.25k|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|  1.25k|        return ret;
  361|  1.25k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE3AnyEv:
  395|  34.6k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE4NoneEv:
  388|  69.2k|    {
  389|   116k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 116k, False: 17.9k]
  ------------------
  390|   116k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 51.3k, False: 64.9k]
  ------------------
  391|   116k|        }
  392|  17.9k|        return true;
  393|  69.2k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE5FirstEv:
  402|  25.6k|    {
  403|  25.6k|        unsigned p = 0;
  404|  31.2k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 5.57k, False: 25.6k]
  ------------------
  405|  5.57k|            ++p;
  406|  5.57k|            Assume(p < N);
  ------------------
  |  |  128|  5.57k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  5.57k|        }
  408|  25.6k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  25.6k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE4LastEv:
  412|  25.6k|    {
  413|  25.6k|        unsigned p = N - 1;
  414|  39.3k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 13.7k, False: 25.6k]
  ------------------
  415|  13.7k|            Assume(p > 0);
  ------------------
  |  |  128|  13.7k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  13.7k|            --p;
  417|  13.7k|        }
  418|  25.6k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  25.6k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE5CountEv:
  381|  34.6k|    {
  382|  34.6k|        unsigned ret{0};
  383|   103k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 103k, False: 34.6k]
  ------------------
  384|  34.6k|        return ret;
  385|  34.6k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EEC2Ev:
  312|  17.5k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetItLj3EEaSESt16initializer_listIjE:
  337|  6.61k|    {
  338|  6.61k|        m_val.fill(0);
  339|  19.8k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 19.8k, False: 6.61k]
  ------------------
  340|  6.61k|        return *this;
  341|  6.61k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetItLj3EEES2_:
  515|  1.21k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj3EEC2ESt16initializer_listIjE:
  331|  2.26k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.26k|    {
  333|  4.53k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 4.53k, False: 2.26k]
  ------------------
  334|  2.26k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EE4FillEj:
  364|  2.35k|    {
  365|  2.35k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  2.35k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  2.35k|        MultiIntBitSet ret;
  367|  2.35k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 2.09k, False: 259]
  ------------------
  368|  2.09k|            unsigned i = 0;
  369|  3.86k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 1.77k, False: 2.09k]
  ------------------
  370|  1.77k|                ret.m_val[i++] = I(~I{0});
  371|  1.77k|                count -= LIMB_BITS;
  372|  1.77k|            }
  373|  2.09k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  2.09k|        }
  375|  2.35k|        return ret;
  376|  2.35k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE5beginEv:
  397|  37.8k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj3EE8IteratorC2ERKNSt3__15arrayItLm3EEE:
  259|  37.8k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  37.8k|        {
  261|  63.9k|            do {
  262|  63.9k|                m_val = (*m_ptr)[m_idx];
  263|  63.9k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 27.8k, False: 36.1k]
  ------------------
  264|  27.8k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  27.8k|                    break;
  266|  27.8k|                }
  267|  36.1k|                ++m_idx;
  268|  36.1k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 26.1k, False: 10.0k]
  ------------------
  269|  37.8k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj3EE8IteratorERKNS1_11IteratorEndE:
  279|  5.31M|        {
  280|  5.31M|            return a.m_idx == N;
  281|  5.31M|        }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE3endEv:
  399|  5.31M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE8IteratordeEv:
  304|   997k|        {
  305|   997k|            Assume(m_idx < N);
  ------------------
  |  |  128|   997k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|   997k|            return m_pos;
  307|   997k|        }
_ZN13bitset_detail14MultiIntBitSetItLj3EE8IteratorppEv:
  284|   350k|        {
  285|   350k|            Assume(m_idx < N);
  ------------------
  |  |  128|   350k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   350k|            m_val &= m_val - I{1U};
  287|   350k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 63.1k, False: 287k]
  ------------------
  288|  81.5k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 81.5k, Folded]
  ------------------
  289|  81.5k|                    ++m_idx;
  290|  81.5k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 29.8k, False: 51.7k]
  ------------------
  291|  51.7k|                    m_val = (*m_ptr)[m_idx];
  292|  51.7k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 33.2k, False: 18.4k]
  ------------------
  293|  33.2k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  33.2k|                        break;
  295|  33.2k|                    }
  296|  51.7k|                }
  297|   287k|            } else {
  298|   287k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   287k|            }
  300|   350k|            return *this;
  301|   350k|        }
_ZN13bitset_detail14MultiIntBitSetItLj3EEoRERKS1_:
  422|  1.98k|    {
  423|  7.94k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 5.96k, False: 1.98k]
  ------------------
  424|  5.96k|            m_val[i] |= a.m_val[i];
  425|  5.96k|        }
  426|  1.98k|        return *this;
  427|  1.98k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EEaNERKS1_:
  430|  1.22k|    {
  431|  4.90k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 3.67k, False: 1.22k]
  ------------------
  432|  3.67k|            m_val[i] &= a.m_val[i];
  433|  3.67k|        }
  434|  1.22k|        return *this;
  435|  1.22k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EEmIERKS1_:
  438|  1.67k|    {
  439|  6.70k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 5.03k, False: 1.67k]
  ------------------
  440|  5.03k|            m_val[i] &= ~a.m_val[i];
  441|  5.03k|        }
  442|  1.67k|        return *this;
  443|  1.67k|    }
_ZN13bitset_detail14MultiIntBitSetItLj3EEeOERKS1_:
  446|  1.66k|    {
  447|  6.64k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 4.98k, False: 1.66k]
  ------------------
  448|  4.98k|            m_val[i] ^= a.m_val[i];
  449|  4.98k|        }
  450|  1.66k|        return *this;
  451|  1.66k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetItLj3EEES3_:
  471|  2.81k|    {
  472|  2.81k|        MultiIntBitSet r;
  473|  11.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 8.43k, False: 2.81k]
  ------------------
  474|  8.43k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  8.43k|        }
  476|  2.81k|        return r;
  477|  2.81k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetItLj3EEES3_:
  462|  1.51k|    {
  463|  1.51k|        MultiIntBitSet r;
  464|  6.04k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 4.53k, False: 1.51k]
  ------------------
  465|  4.53k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  4.53k|        }
  467|  1.51k|        return r;
  468|  1.51k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetItLj3EEES3_:
  480|  1.36k|    {
  481|  1.36k|        MultiIntBitSet r;
  482|  5.46k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 4.09k, False: 1.36k]
  ------------------
  483|  4.09k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  4.09k|        }
  485|  1.36k|        return r;
  486|  1.36k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetItLj3EEES3_:
  489|    945|    {
  490|    945|        MultiIntBitSet r;
  491|  3.78k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 2.83k, False: 945]
  ------------------
  492|  2.83k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  2.83k|        }
  494|    945|        return r;
  495|    945|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE12IsSupersetOfERKS1_:
  498|  3.98k|    {
  499|  10.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 8.77k, False: 2.04k]
  ------------------
  500|  8.77k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 1.93k, False: 6.84k]
  ------------------
  501|  8.77k|        }
  502|  2.04k|        return true;
  503|  3.98k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj3EE10IsSubsetOfERKS1_:
  506|  3.98k|    {
  507|  10.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 8.77k, False: 2.04k]
  ------------------
  508|  8.77k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 1.93k, False: 6.84k]
  ------------------
  509|  8.77k|        }
  510|  2.04k|        return true;
  511|  3.98k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj3EEES3_:
  513|  3.05k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetItLj3EE8OverlapsERKS1_:
  454|  3.89k|    {
  455|  9.04k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 7.69k, False: 1.35k]
  ------------------
  456|  7.69k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 2.54k, False: 5.14k]
  ------------------
  457|  7.69k|        }
  458|  1.35k|        return false;
  459|  3.89k|    }
_ZN13bitset_detail9IntBitSetImE4SizeEv:
  178|  5.61M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZN13bitset_detail9IntBitSetImE3SetEjb:
  159|  3.92k|    {
  160|  3.92k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.92k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  161|  3.92k|        m_val = (m_val & ~I(I{1U} << pos)) | (I(val) << pos);
  162|  3.92k|    }
_ZNK13bitset_detail9IntBitSetImE4LastEv:
  195|  39.2k|    {
  196|  39.2k|        Assume(m_val != 0);
  ------------------
  |  |  128|  39.2k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  197|  39.2k|        return std::bit_width(m_val) - 1;
  198|  39.2k|    }
_ZN13bitset_detail9IntBitSetImEaSESt16initializer_listIjE:
  132|  5.56k|    {
  133|  5.56k|        m_val = 0;
  134|  16.6k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (134:23): [True: 16.6k, False: 5.56k]
  ------------------
  135|  5.56k|        return *this;
  136|  5.56k|    }
_ZN13bitset_detail4swapERNS_9IntBitSetImEES2_:
  224|  3.93k|    friend constexpr void swap(IntBitSet& a, IntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail9IntBitSetImEC2ESt16initializer_listIjE:
  124|  2.51k|    constexpr IntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val(0)
  125|  2.51k|    {
  126|  5.03k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (126:23): [True: 5.03k, False: 2.51k]
  ------------------
  127|  2.51k|    }
_ZN13bitset_detail9IntBitSetImEeOERKS1_:
  206|  3.59k|    constexpr IntBitSet& operator^=(const IntBitSet& a) noexcept { m_val ^= a.m_val; return *this; }
_ZN13bitset_detailorERKNS_9IntBitSetImEES3_:
  212|  4.54k|    friend constexpr IntBitSet operator|(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val | b.m_val); }
_ZN13bitset_detaileoERKNS_9IntBitSetImEES3_:
  216|  2.60k|    friend constexpr IntBitSet operator^(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val ^ b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj1EE4SizeEv:
  378|  5.61M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetImLj1EEixEj:
  350|  7.49M|    {
  351|  7.49M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.49M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  7.49M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  7.49M|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EE3SetEj:
  319|   208k|    {
  320|   208k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   208k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   208k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   208k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EE5ResetEj:
  344|  4.31k|    {
  345|  4.31k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  4.31k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  4.31k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  4.31k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EE3SetEjb:
  325|  3.92k|    {
  326|  3.92k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.92k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  3.92k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  3.92k|                                 (I{val} << (pos % LIMB_BITS));
  329|  3.92k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EE9SingletonEj:
  356|  1.32k|    {
  357|  1.32k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.32k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|  1.32k|        MultiIntBitSet ret;
  359|  1.32k|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|  1.32k|        return ret;
  361|  1.32k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE3AnyEv:
  395|  58.2k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE4NoneEv:
  388|   116k|    {
  389|   116k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 116k, False: 37.9k]
  ------------------
  390|   116k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 78.5k, False: 37.9k]
  ------------------
  391|   116k|        }
  392|  37.9k|        return true;
  393|   116k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE5FirstEv:
  402|  39.2k|    {
  403|  39.2k|        unsigned p = 0;
  404|  39.2k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 0, False: 39.2k]
  ------------------
  405|      0|            ++p;
  406|      0|            Assume(p < N);
  ------------------
  |  |  128|      0|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|      0|        }
  408|  39.2k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE4LastEv:
  412|  39.2k|    {
  413|  39.2k|        unsigned p = N - 1;
  414|  39.2k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 0, False: 39.2k]
  ------------------
  415|      0|            Assume(p > 0);
  ------------------
  |  |  128|      0|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|      0|            --p;
  417|      0|        }
  418|  39.2k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE5CountEv:
  381|  58.2k|    {
  382|  58.2k|        unsigned ret{0};
  383|  58.2k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 58.2k, False: 58.2k]
  ------------------
  384|  58.2k|        return ret;
  385|  58.2k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EEC2Ev:
  312|  29.4k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetImLj1EEaSESt16initializer_listIjE:
  337|  5.56k|    {
  338|  5.56k|        m_val.fill(0);
  339|  16.6k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 16.6k, False: 5.56k]
  ------------------
  340|  5.56k|        return *this;
  341|  5.56k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetImLj1EEES2_:
  515|  3.93k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj1EEC2ESt16initializer_listIjE:
  331|  2.51k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.51k|    {
  333|  5.03k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 5.03k, False: 2.51k]
  ------------------
  334|  2.51k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EE4FillEj:
  364|  5.59k|    {
  365|  5.59k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  5.59k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  5.59k|        MultiIntBitSet ret;
  367|  5.59k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 5.06k, False: 535]
  ------------------
  368|  5.06k|            unsigned i = 0;
  369|  5.06k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 0, False: 5.06k]
  ------------------
  370|      0|                ret.m_val[i++] = I(~I{0});
  371|      0|                count -= LIMB_BITS;
  372|      0|            }
  373|  5.06k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  5.06k|        }
  375|  5.59k|        return ret;
  376|  5.59k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE5beginEv:
  397|  64.7k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj1EE8IteratorC2ERKNSt3__15arrayImLm1EEE:
  259|  64.7k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  64.7k|        {
  261|  64.7k|            do {
  262|  64.7k|                m_val = (*m_ptr)[m_idx];
  263|  64.7k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 43.8k, False: 20.9k]
  ------------------
  264|  43.8k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  43.8k|                    break;
  266|  43.8k|                }
  267|  20.9k|                ++m_idx;
  268|  20.9k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 0, False: 20.9k]
  ------------------
  269|  64.7k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj1EE8IteratorERKNS1_11IteratorEndE:
  279|  11.8M|        {
  280|  11.8M|            return a.m_idx == N;
  281|  11.8M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE3endEv:
  399|  11.8M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE8IteratordeEv:
  304|  2.13M|        {
  305|  2.13M|            Assume(m_idx < N);
  ------------------
  |  |  128|  2.13M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  2.13M|            return m_pos;
  307|  2.13M|        }
_ZN13bitset_detail14MultiIntBitSetImLj1EE8IteratorppEv:
  284|   882k|        {
  285|   882k|            Assume(m_idx < N);
  ------------------
  |  |  128|   882k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   882k|            m_val &= m_val - I{1U};
  287|   882k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 46.8k, False: 835k]
  ------------------
  288|  46.8k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 46.8k, Folded]
  ------------------
  289|  46.8k|                    ++m_idx;
  290|  46.8k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 46.8k, False: 0]
  ------------------
  291|      0|                    m_val = (*m_ptr)[m_idx];
  292|      0|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 0, False: 0]
  ------------------
  293|      0|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|      0|                        break;
  295|      0|                    }
  296|      0|                }
  297|   835k|            } else {
  298|   835k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   835k|            }
  300|   882k|            return *this;
  301|   882k|        }
_ZN13bitset_detail14MultiIntBitSetImLj1EEoRERKS1_:
  422|  4.70k|    {
  423|  9.41k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 4.70k, False: 4.70k]
  ------------------
  424|  4.70k|            m_val[i] |= a.m_val[i];
  425|  4.70k|        }
  426|  4.70k|        return *this;
  427|  4.70k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EEaNERKS1_:
  430|  3.16k|    {
  431|  6.33k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 3.16k, False: 3.16k]
  ------------------
  432|  3.16k|            m_val[i] &= a.m_val[i];
  433|  3.16k|        }
  434|  3.16k|        return *this;
  435|  3.16k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EEmIERKS1_:
  438|  3.99k|    {
  439|  7.99k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 3.99k, False: 3.99k]
  ------------------
  440|  3.99k|            m_val[i] &= ~a.m_val[i];
  441|  3.99k|        }
  442|  3.99k|        return *this;
  443|  3.99k|    }
_ZN13bitset_detail14MultiIntBitSetImLj1EEeOERKS1_:
  446|  3.59k|    {
  447|  7.18k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 3.59k, False: 3.59k]
  ------------------
  448|  3.59k|            m_val[i] ^= a.m_val[i];
  449|  3.59k|        }
  450|  3.59k|        return *this;
  451|  3.59k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetImLj1EEES3_:
  471|  4.54k|    {
  472|  4.54k|        MultiIntBitSet r;
  473|  9.09k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 4.54k, False: 4.54k]
  ------------------
  474|  4.54k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  4.54k|        }
  476|  4.54k|        return r;
  477|  4.54k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetImLj1EEES3_:
  462|  3.21k|    {
  463|  3.21k|        MultiIntBitSet r;
  464|  6.43k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 3.21k, False: 3.21k]
  ------------------
  465|  3.21k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  3.21k|        }
  467|  3.21k|        return r;
  468|  3.21k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetImLj1EEES3_:
  480|  2.82k|    {
  481|  2.82k|        MultiIntBitSet r;
  482|  5.64k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 2.82k, False: 2.82k]
  ------------------
  483|  2.82k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  2.82k|        }
  485|  2.82k|        return r;
  486|  2.82k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetImLj1EEES3_:
  489|  2.60k|    {
  490|  2.60k|        MultiIntBitSet r;
  491|  5.21k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 2.60k, False: 2.60k]
  ------------------
  492|  2.60k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  2.60k|        }
  494|  2.60k|        return r;
  495|  2.60k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE12IsSupersetOfERKS1_:
  498|  10.5k|    {
  499|  15.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 10.5k, False: 5.38k]
  ------------------
  500|  10.5k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 5.16k, False: 5.38k]
  ------------------
  501|  10.5k|        }
  502|  5.38k|        return true;
  503|  10.5k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj1EE10IsSubsetOfERKS1_:
  506|  10.5k|    {
  507|  15.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 10.5k, False: 5.38k]
  ------------------
  508|  10.5k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 5.16k, False: 5.38k]
  ------------------
  509|  10.5k|        }
  510|  5.38k|        return true;
  511|  10.5k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj1EEES3_:
  513|  6.37k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetImLj1EE8OverlapsERKS1_:
  454|  8.21k|    {
  455|  11.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 8.21k, False: 3.49k]
  ------------------
  456|  8.21k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 4.71k, False: 3.49k]
  ------------------
  457|  8.21k|        }
  458|  3.49k|        return false;
  459|  8.21k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE4SizeEv:
  378|  5.61M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EEixEj:
  350|  7.49M|    {
  351|  7.49M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.49M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  7.49M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  7.49M|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE3SetEj:
  319|   208k|    {
  320|   208k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   208k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   208k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   208k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE5ResetEj:
  344|  4.31k|    {
  345|  4.31k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  4.31k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  4.31k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  4.31k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE3SetEjb:
  325|  3.92k|    {
  326|  3.92k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.92k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  3.92k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  3.92k|                                 (I{val} << (pos % LIMB_BITS));
  329|  3.92k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE9SingletonEj:
  356|  1.32k|    {
  357|  1.32k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.32k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|  1.32k|        MultiIntBitSet ret;
  359|  1.32k|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|  1.32k|        return ret;
  361|  1.32k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE3AnyEv:
  395|  58.2k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE4NoneEv:
  388|   116k|    {
  389|   163k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 163k, False: 37.9k]
  ------------------
  390|   163k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 78.5k, False: 84.7k]
  ------------------
  391|   163k|        }
  392|  37.9k|        return true;
  393|   116k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE5FirstEv:
  402|  39.2k|    {
  403|  39.2k|        unsigned p = 0;
  404|  43.6k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 4.39k, False: 39.2k]
  ------------------
  405|  4.39k|            ++p;
  406|  4.39k|            Assume(p < N);
  ------------------
  |  |  128|  4.39k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  4.39k|        }
  408|  39.2k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE4LastEv:
  412|  39.2k|    {
  413|  39.2k|        unsigned p = N - 1;
  414|  48.5k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 9.27k, False: 39.2k]
  ------------------
  415|  9.27k|            Assume(p > 0);
  ------------------
  |  |  128|  9.27k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  9.27k|            --p;
  417|  9.27k|        }
  418|  39.2k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE5CountEv:
  381|  58.2k|    {
  382|  58.2k|        unsigned ret{0};
  383|   116k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 116k, False: 58.2k]
  ------------------
  384|  58.2k|        return ret;
  385|  58.2k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEC2Ev:
  312|  29.4k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetIjLj2EEaSESt16initializer_listIjE:
  337|  5.56k|    {
  338|  5.56k|        m_val.fill(0);
  339|  16.6k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 16.6k, False: 5.56k]
  ------------------
  340|  5.56k|        return *this;
  341|  5.56k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetIjLj2EEES2_:
  515|  3.93k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEC2ESt16initializer_listIjE:
  331|  2.51k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.51k|    {
  333|  5.03k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 5.03k, False: 2.51k]
  ------------------
  334|  2.51k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE4FillEj:
  364|  5.59k|    {
  365|  5.59k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  5.59k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  5.59k|        MultiIntBitSet ret;
  367|  5.59k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 5.06k, False: 535]
  ------------------
  368|  5.06k|            unsigned i = 0;
  369|  7.59k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 2.53k, False: 5.06k]
  ------------------
  370|  2.53k|                ret.m_val[i++] = I(~I{0});
  371|  2.53k|                count -= LIMB_BITS;
  372|  2.53k|            }
  373|  5.06k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  5.06k|        }
  375|  5.59k|        return ret;
  376|  5.59k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE5beginEv:
  397|  64.7k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE8IteratorC2ERKNSt3__15arrayIjLm2EEE:
  259|  64.7k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  64.7k|        {
  261|  90.9k|            do {
  262|  90.9k|                m_val = (*m_ptr)[m_idx];
  263|  90.9k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 43.8k, False: 47.1k]
  ------------------
  264|  43.8k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  43.8k|                    break;
  266|  43.8k|                }
  267|  47.1k|                ++m_idx;
  268|  47.1k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 26.1k, False: 20.9k]
  ------------------
  269|  64.7k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj2EE8IteratorERKNS1_11IteratorEndE:
  279|  11.8M|        {
  280|  11.8M|            return a.m_idx == N;
  281|  11.8M|        }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE3endEv:
  399|  11.8M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE8IteratordeEv:
  304|  2.13M|        {
  305|  2.13M|            Assume(m_idx < N);
  ------------------
  |  |  128|  2.13M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  2.13M|            return m_pos;
  307|  2.13M|        }
_ZN13bitset_detail14MultiIntBitSetIjLj2EE8IteratorppEv:
  284|   882k|        {
  285|   882k|            Assume(m_idx < N);
  ------------------
  |  |  128|   882k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   882k|            m_val &= m_val - I{1U};
  287|   882k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 76.3k, False: 805k]
  ------------------
  288|  86.9k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 86.9k, Folded]
  ------------------
  289|  86.9k|                    ++m_idx;
  290|  86.9k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 46.8k, False: 40.0k]
  ------------------
  291|  40.0k|                    m_val = (*m_ptr)[m_idx];
  292|  40.0k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 29.5k, False: 10.5k]
  ------------------
  293|  29.5k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  29.5k|                        break;
  295|  29.5k|                    }
  296|  40.0k|                }
  297|   805k|            } else {
  298|   805k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   805k|            }
  300|   882k|            return *this;
  301|   882k|        }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEoRERKS1_:
  422|  4.70k|    {
  423|  14.1k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 9.41k, False: 4.70k]
  ------------------
  424|  9.41k|            m_val[i] |= a.m_val[i];
  425|  9.41k|        }
  426|  4.70k|        return *this;
  427|  4.70k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEaNERKS1_:
  430|  3.16k|    {
  431|  9.50k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 6.33k, False: 3.16k]
  ------------------
  432|  6.33k|            m_val[i] &= a.m_val[i];
  433|  6.33k|        }
  434|  3.16k|        return *this;
  435|  3.16k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEmIERKS1_:
  438|  3.99k|    {
  439|  11.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 7.99k, False: 3.99k]
  ------------------
  440|  7.99k|            m_val[i] &= ~a.m_val[i];
  441|  7.99k|        }
  442|  3.99k|        return *this;
  443|  3.99k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj2EEeOERKS1_:
  446|  3.59k|    {
  447|  10.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 7.18k, False: 3.59k]
  ------------------
  448|  7.18k|            m_val[i] ^= a.m_val[i];
  449|  7.18k|        }
  450|  3.59k|        return *this;
  451|  3.59k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetIjLj2EEES3_:
  471|  4.54k|    {
  472|  4.54k|        MultiIntBitSet r;
  473|  13.6k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 9.09k, False: 4.54k]
  ------------------
  474|  9.09k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  9.09k|        }
  476|  4.54k|        return r;
  477|  4.54k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetIjLj2EEES3_:
  462|  3.21k|    {
  463|  3.21k|        MultiIntBitSet r;
  464|  9.65k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 6.43k, False: 3.21k]
  ------------------
  465|  6.43k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  6.43k|        }
  467|  3.21k|        return r;
  468|  3.21k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetIjLj2EEES3_:
  480|  2.82k|    {
  481|  2.82k|        MultiIntBitSet r;
  482|  8.46k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 5.64k, False: 2.82k]
  ------------------
  483|  5.64k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  5.64k|        }
  485|  2.82k|        return r;
  486|  2.82k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetIjLj2EEES3_:
  489|  2.60k|    {
  490|  2.60k|        MultiIntBitSet r;
  491|  7.81k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 5.21k, False: 2.60k]
  ------------------
  492|  5.21k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  5.21k|        }
  494|  2.60k|        return r;
  495|  2.60k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE12IsSupersetOfERKS1_:
  498|  10.5k|    {
  499|  22.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 16.9k, False: 5.38k]
  ------------------
  500|  16.9k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 5.16k, False: 11.7k]
  ------------------
  501|  16.9k|        }
  502|  5.38k|        return true;
  503|  10.5k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE10IsSubsetOfERKS1_:
  506|  10.5k|    {
  507|  22.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 16.9k, False: 5.38k]
  ------------------
  508|  16.9k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 5.16k, False: 11.7k]
  ------------------
  509|  16.9k|        }
  510|  5.38k|        return true;
  511|  10.5k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj2EEES3_:
  513|  6.37k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetIjLj2EE8OverlapsERKS1_:
  454|  8.21k|    {
  455|  15.6k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 12.1k, False: 3.49k]
  ------------------
  456|  12.1k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 4.71k, False: 7.40k]
  ------------------
  457|  12.1k|        }
  458|  3.49k|        return false;
  459|  8.21k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE4SizeEv:
  378|  5.61M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetItLj4EEixEj:
  350|  7.49M|    {
  351|  7.49M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.49M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  7.49M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  7.49M|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE3SetEj:
  319|   208k|    {
  320|   208k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   208k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   208k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   208k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE5ResetEj:
  344|  4.31k|    {
  345|  4.31k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  4.31k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  4.31k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  4.31k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE3SetEjb:
  325|  3.92k|    {
  326|  3.92k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.92k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  3.92k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  3.92k|                                 (I{val} << (pos % LIMB_BITS));
  329|  3.92k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE9SingletonEj:
  356|  1.32k|    {
  357|  1.32k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.32k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|  1.32k|        MultiIntBitSet ret;
  359|  1.32k|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|  1.32k|        return ret;
  361|  1.32k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE3AnyEv:
  395|  58.2k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE4NoneEv:
  388|   116k|    {
  389|   259k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 259k, False: 37.9k]
  ------------------
  390|   259k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 78.5k, False: 181k]
  ------------------
  391|   259k|        }
  392|  37.9k|        return true;
  393|   116k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE5FirstEv:
  402|  39.2k|    {
  403|  39.2k|        unsigned p = 0;
  404|  53.9k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 14.6k, False: 39.2k]
  ------------------
  405|  14.6k|            ++p;
  406|  14.6k|            Assume(p < N);
  ------------------
  |  |  128|  14.6k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  14.6k|        }
  408|  39.2k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE4LastEv:
  412|  39.2k|    {
  413|  39.2k|        unsigned p = N - 1;
  414|  69.0k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 29.7k, False: 39.2k]
  ------------------
  415|  29.7k|            Assume(p > 0);
  ------------------
  |  |  128|  29.7k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  29.7k|            --p;
  417|  29.7k|        }
  418|  39.2k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  39.2k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE5CountEv:
  381|  58.2k|    {
  382|  58.2k|        unsigned ret{0};
  383|   233k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 233k, False: 58.2k]
  ------------------
  384|  58.2k|        return ret;
  385|  58.2k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EEC2Ev:
  312|  29.4k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetItLj4EEaSESt16initializer_listIjE:
  337|  5.56k|    {
  338|  5.56k|        m_val.fill(0);
  339|  16.6k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 16.6k, False: 5.56k]
  ------------------
  340|  5.56k|        return *this;
  341|  5.56k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetItLj4EEES2_:
  515|  3.93k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj4EEC2ESt16initializer_listIjE:
  331|  2.51k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.51k|    {
  333|  5.03k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 5.03k, False: 2.51k]
  ------------------
  334|  2.51k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EE4FillEj:
  364|  5.59k|    {
  365|  5.59k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  5.59k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  5.59k|        MultiIntBitSet ret;
  367|  5.59k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 5.06k, False: 535]
  ------------------
  368|  5.06k|            unsigned i = 0;
  369|  12.8k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 7.74k, False: 5.06k]
  ------------------
  370|  7.74k|                ret.m_val[i++] = I(~I{0});
  371|  7.74k|                count -= LIMB_BITS;
  372|  7.74k|            }
  373|  5.06k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  5.06k|        }
  375|  5.59k|        return ret;
  376|  5.59k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE5beginEv:
  397|  64.7k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetItLj4EE8IteratorC2ERKNSt3__15arrayItLm4EEE:
  259|  64.7k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  64.7k|        {
  261|   144k|            do {
  262|   144k|                m_val = (*m_ptr)[m_idx];
  263|   144k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 43.8k, False: 100k]
  ------------------
  264|  43.8k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  43.8k|                    break;
  266|  43.8k|                }
  267|   100k|                ++m_idx;
  268|   100k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 79.9k, False: 20.9k]
  ------------------
  269|  64.7k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj4EE8IteratorERKNS1_11IteratorEndE:
  279|  11.8M|        {
  280|  11.8M|            return a.m_idx == N;
  281|  11.8M|        }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE3endEv:
  399|  11.8M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE8IteratordeEv:
  304|  2.13M|        {
  305|  2.13M|            Assume(m_idx < N);
  ------------------
  |  |  128|  2.13M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  2.13M|            return m_pos;
  307|  2.13M|        }
_ZN13bitset_detail14MultiIntBitSetItLj4EE8IteratorppEv:
  284|   882k|        {
  285|   882k|            Assume(m_idx < N);
  ------------------
  |  |  128|   882k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   882k|            m_val &= m_val - I{1U};
  287|   882k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 122k, False: 759k]
  ------------------
  288|   165k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 165k, Folded]
  ------------------
  289|   165k|                    ++m_idx;
  290|   165k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 46.8k, False: 118k]
  ------------------
  291|   118k|                    m_val = (*m_ptr)[m_idx];
  292|   118k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 75.5k, False: 43.3k]
  ------------------
  293|  75.5k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  75.5k|                        break;
  295|  75.5k|                    }
  296|   118k|                }
  297|   759k|            } else {
  298|   759k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   759k|            }
  300|   882k|            return *this;
  301|   882k|        }
_ZN13bitset_detail14MultiIntBitSetItLj4EEoRERKS1_:
  422|  4.70k|    {
  423|  23.5k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 18.8k, False: 4.70k]
  ------------------
  424|  18.8k|            m_val[i] |= a.m_val[i];
  425|  18.8k|        }
  426|  4.70k|        return *this;
  427|  4.70k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EEaNERKS1_:
  430|  3.16k|    {
  431|  15.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 12.6k, False: 3.16k]
  ------------------
  432|  12.6k|            m_val[i] &= a.m_val[i];
  433|  12.6k|        }
  434|  3.16k|        return *this;
  435|  3.16k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EEmIERKS1_:
  438|  3.99k|    {
  439|  19.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 15.9k, False: 3.99k]
  ------------------
  440|  15.9k|            m_val[i] &= ~a.m_val[i];
  441|  15.9k|        }
  442|  3.99k|        return *this;
  443|  3.99k|    }
_ZN13bitset_detail14MultiIntBitSetItLj4EEeOERKS1_:
  446|  3.59k|    {
  447|  17.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 14.3k, False: 3.59k]
  ------------------
  448|  14.3k|            m_val[i] ^= a.m_val[i];
  449|  14.3k|        }
  450|  3.59k|        return *this;
  451|  3.59k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetItLj4EEES3_:
  471|  4.54k|    {
  472|  4.54k|        MultiIntBitSet r;
  473|  22.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 18.1k, False: 4.54k]
  ------------------
  474|  18.1k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  18.1k|        }
  476|  4.54k|        return r;
  477|  4.54k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetItLj4EEES3_:
  462|  3.21k|    {
  463|  3.21k|        MultiIntBitSet r;
  464|  16.0k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 12.8k, False: 3.21k]
  ------------------
  465|  12.8k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  12.8k|        }
  467|  3.21k|        return r;
  468|  3.21k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetItLj4EEES3_:
  480|  2.82k|    {
  481|  2.82k|        MultiIntBitSet r;
  482|  14.1k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 11.2k, False: 2.82k]
  ------------------
  483|  11.2k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  11.2k|        }
  485|  2.82k|        return r;
  486|  2.82k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetItLj4EEES3_:
  489|  2.60k|    {
  490|  2.60k|        MultiIntBitSet r;
  491|  13.0k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 10.4k, False: 2.60k]
  ------------------
  492|  10.4k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  10.4k|        }
  494|  2.60k|        return r;
  495|  2.60k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE12IsSupersetOfERKS1_:
  498|  10.5k|    {
  499|  35.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 29.8k, False: 5.38k]
  ------------------
  500|  29.8k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 5.16k, False: 24.6k]
  ------------------
  501|  29.8k|        }
  502|  5.38k|        return true;
  503|  10.5k|    }
_ZNK13bitset_detail14MultiIntBitSetItLj4EE10IsSubsetOfERKS1_:
  506|  10.5k|    {
  507|  35.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 29.8k, False: 5.38k]
  ------------------
  508|  29.8k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 5.16k, False: 24.6k]
  ------------------
  509|  29.8k|        }
  510|  5.38k|        return true;
  511|  10.5k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetItLj4EEES3_:
  513|  6.37k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetItLj4EE8OverlapsERKS1_:
  454|  8.21k|    {
  455|  23.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 20.2k, False: 3.49k]
  ------------------
  456|  20.2k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 4.71k, False: 15.5k]
  ------------------
  457|  20.2k|        }
  458|  3.49k|        return false;
  459|  8.21k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE4SizeEv:
  378|  5.55M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EEixEj:
  350|  7.14M|    {
  351|  7.14M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.14M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  7.14M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  7.14M|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE3SetEj:
  319|   224k|    {
  320|   224k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   224k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   224k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   224k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE5ResetEj:
  344|  2.25k|    {
  345|  2.25k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.25k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  2.25k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  2.25k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE3SetEjb:
  325|  1.53k|    {
  326|  1.53k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.53k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  1.53k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  1.53k|                                 (I{val} << (pos % LIMB_BITS));
  329|  1.53k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE9SingletonEj:
  356|    549|    {
  357|    549|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    549|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    549|        MultiIntBitSet ret;
  359|    549|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    549|        return ret;
  361|    549|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE3AnyEv:
  395|  37.1k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE4NoneEv:
  388|  74.3k|    {
  389|   125k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 125k, False: 20.0k]
  ------------------
  390|   125k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 54.2k, False: 71.6k]
  ------------------
  391|   125k|        }
  392|  20.0k|        return true;
  393|  74.3k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE5FirstEv:
  402|  27.1k|    {
  403|  27.1k|        unsigned p = 0;
  404|  32.8k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 5.74k, False: 27.1k]
  ------------------
  405|  5.74k|            ++p;
  406|  5.74k|            Assume(p < N);
  ------------------
  |  |  128|  5.74k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  5.74k|        }
  408|  27.1k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  27.1k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE4LastEv:
  412|  27.1k|    {
  413|  27.1k|        unsigned p = N - 1;
  414|  39.7k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 12.6k, False: 27.1k]
  ------------------
  415|  12.6k|            Assume(p > 0);
  ------------------
  |  |  128|  12.6k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  12.6k|            --p;
  417|  12.6k|        }
  418|  27.1k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  27.1k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE5CountEv:
  381|  37.1k|    {
  382|  37.1k|        unsigned ret{0};
  383|   111k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 111k, False: 37.1k]
  ------------------
  384|  37.1k|        return ret;
  385|  37.1k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEC2Ev:
  312|  19.2k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetIjLj3EEaSESt16initializer_listIjE:
  337|  5.86k|    {
  338|  5.86k|        m_val.fill(0);
  339|  17.5k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 17.5k, False: 5.86k]
  ------------------
  340|  5.86k|        return *this;
  341|  5.86k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetIjLj3EEES2_:
  515|  1.91k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEC2ESt16initializer_listIjE:
  331|  2.61k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.61k|    {
  333|  5.22k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 5.22k, False: 2.61k]
  ------------------
  334|  2.61k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE4FillEj:
  364|  3.01k|    {
  365|  3.01k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  3.01k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  3.01k|        MultiIntBitSet ret;
  367|  3.01k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 2.74k, False: 273]
  ------------------
  368|  2.74k|            unsigned i = 0;
  369|  5.50k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 2.76k, False: 2.74k]
  ------------------
  370|  2.76k|                ret.m_val[i++] = I(~I{0});
  371|  2.76k|                count -= LIMB_BITS;
  372|  2.76k|            }
  373|  2.74k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  2.74k|        }
  375|  3.01k|        return ret;
  376|  3.01k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE5beginEv:
  397|  41.7k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE8IteratorC2ERKNSt3__15arrayIjLm3EEE:
  259|  41.7k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  41.7k|        {
  261|  69.9k|            do {
  262|  69.9k|                m_val = (*m_ptr)[m_idx];
  263|  69.9k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 30.8k, False: 39.0k]
  ------------------
  264|  30.8k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  30.8k|                    break;
  266|  30.8k|                }
  267|  39.0k|                ++m_idx;
  268|  39.0k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 28.1k, False: 10.9k]
  ------------------
  269|  41.7k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj3EE8IteratorERKNS1_11IteratorEndE:
  279|  11.4M|        {
  280|  11.4M|            return a.m_idx == N;
  281|  11.4M|        }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE3endEv:
  399|  11.4M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE8IteratordeEv:
  304|  2.37M|        {
  305|  2.37M|            Assume(m_idx < N);
  ------------------
  |  |  128|  2.37M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  2.37M|            return m_pos;
  307|  2.37M|        }
_ZN13bitset_detail14MultiIntBitSetIjLj3EE8IteratorppEv:
  284|   936k|        {
  285|   936k|            Assume(m_idx < N);
  ------------------
  |  |  128|   936k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|   936k|            m_val &= m_val - I{1U};
  287|   936k|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 75.8k, False: 860k]
  ------------------
  288|  93.4k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 93.4k, Folded]
  ------------------
  289|  93.4k|                    ++m_idx;
  290|  93.4k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 34.2k, False: 59.2k]
  ------------------
  291|  59.2k|                    m_val = (*m_ptr)[m_idx];
  292|  59.2k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 41.6k, False: 17.6k]
  ------------------
  293|  41.6k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  41.6k|                        break;
  295|  41.6k|                    }
  296|  59.2k|                }
  297|   860k|            } else {
  298|   860k|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|   860k|            }
  300|   936k|            return *this;
  301|   936k|        }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEoRERKS1_:
  422|  2.12k|    {
  423|  8.48k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 6.36k, False: 2.12k]
  ------------------
  424|  6.36k|            m_val[i] |= a.m_val[i];
  425|  6.36k|        }
  426|  2.12k|        return *this;
  427|  2.12k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEaNERKS1_:
  430|  1.57k|    {
  431|  6.30k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 4.73k, False: 1.57k]
  ------------------
  432|  4.73k|            m_val[i] &= a.m_val[i];
  433|  4.73k|        }
  434|  1.57k|        return *this;
  435|  1.57k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEmIERKS1_:
  438|  1.65k|    {
  439|  6.61k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 4.95k, False: 1.65k]
  ------------------
  440|  4.95k|            m_val[i] &= ~a.m_val[i];
  441|  4.95k|        }
  442|  1.65k|        return *this;
  443|  1.65k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj3EEeOERKS1_:
  446|  1.27k|    {
  447|  5.08k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 3.81k, False: 1.27k]
  ------------------
  448|  3.81k|            m_val[i] ^= a.m_val[i];
  449|  3.81k|        }
  450|  1.27k|        return *this;
  451|  1.27k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetIjLj3EEES3_:
  471|  3.44k|    {
  472|  3.44k|        MultiIntBitSet r;
  473|  13.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 10.3k, False: 3.44k]
  ------------------
  474|  10.3k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  10.3k|        }
  476|  3.44k|        return r;
  477|  3.44k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetIjLj3EEES3_:
  462|  1.40k|    {
  463|  1.40k|        MultiIntBitSet r;
  464|  5.63k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 4.22k, False: 1.40k]
  ------------------
  465|  4.22k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  4.22k|        }
  467|  1.40k|        return r;
  468|  1.40k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetIjLj3EEES3_:
  480|  1.35k|    {
  481|  1.35k|        MultiIntBitSet r;
  482|  5.41k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 4.05k, False: 1.35k]
  ------------------
  483|  4.05k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  4.05k|        }
  485|  1.35k|        return r;
  486|  1.35k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetIjLj3EEES3_:
  489|  1.74k|    {
  490|  1.74k|        MultiIntBitSet r;
  491|  6.97k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 5.23k, False: 1.74k]
  ------------------
  492|  5.23k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  5.23k|        }
  494|  1.74k|        return r;
  495|  1.74k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE12IsSupersetOfERKS1_:
  498|  6.77k|    {
  499|  19.1k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 15.6k, False: 3.50k]
  ------------------
  500|  15.6k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 3.26k, False: 12.3k]
  ------------------
  501|  15.6k|        }
  502|  3.50k|        return true;
  503|  6.77k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE10IsSubsetOfERKS1_:
  506|  6.77k|    {
  507|  19.1k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 15.6k, False: 3.50k]
  ------------------
  508|  15.6k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 3.26k, False: 12.3k]
  ------------------
  509|  15.6k|        }
  510|  3.50k|        return true;
  511|  6.77k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj3EEES3_:
  513|  4.30k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetIjLj3EE8OverlapsERKS1_:
  454|  3.91k|    {
  455|  9.47k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 8.05k, False: 1.42k]
  ------------------
  456|  8.05k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 2.49k, False: 5.56k]
  ------------------
  457|  8.05k|        }
  458|  1.42k|        return false;
  459|  3.91k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EE4SizeEv:
  378|  10.9M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZN13bitset_detail14MultiIntBitSetImLj2EE3SetEjb:
  325|  2.81k|    {
  326|  2.81k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.81k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  2.81k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  2.81k|                                 (I{val} << (pos % LIMB_BITS));
  329|  2.81k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE4LastEv:
  412|  37.9k|    {
  413|  37.9k|        unsigned p = N - 1;
  414|  44.2k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 6.30k, False: 37.9k]
  ------------------
  415|  6.30k|            Assume(p > 0);
  ------------------
  |  |  128|  6.30k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  6.30k|            --p;
  417|  6.30k|        }
  418|  37.9k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  37.9k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EEaSESt16initializer_listIjE:
  337|  5.04k|    {
  338|  5.04k|        m_val.fill(0);
  339|  15.1k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 15.1k, False: 5.04k]
  ------------------
  340|  5.04k|        return *this;
  341|  5.04k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetImLj2EEES2_:
  515|  2.59k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj2EEC2ESt16initializer_listIjE:
  331|  2.23k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.23k|    {
  333|  4.46k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 4.46k, False: 2.23k]
  ------------------
  334|  2.23k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EEeOERKS1_:
  446|  2.58k|    {
  447|  7.76k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 5.17k, False: 2.58k]
  ------------------
  448|  5.17k|            m_val[i] ^= a.m_val[i];
  449|  5.17k|        }
  450|  2.58k|        return *this;
  451|  2.58k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetImLj2EEES3_:
  489|  2.21k|    {
  490|  2.21k|        MultiIntBitSet r;
  491|  6.63k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 4.42k, False: 2.21k]
  ------------------
  492|  4.42k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  4.42k|        }
  494|  2.21k|        return r;
  495|  2.21k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE12IsSupersetOfERKS1_:
  498|  8.90k|    {
  499|  18.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 14.3k, False: 4.55k]
  ------------------
  500|  14.3k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 4.35k, False: 10.0k]
  ------------------
  501|  14.3k|        }
  502|  4.55k|        return true;
  503|  8.90k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE4SizeEv:
  378|  10.9M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EEixEj:
  350|  14.0M|    {
  351|  14.0M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  14.0M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  14.0M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  14.0M|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE3SetEj:
  319|   514k|    {
  320|   514k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   514k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   514k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   514k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE5ResetEj:
  344|  3.29k|    {
  345|  3.29k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.29k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  3.29k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  3.29k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE3SetEjb:
  325|  2.81k|    {
  326|  2.81k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  2.81k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  2.81k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  2.81k|                                 (I{val} << (pos % LIMB_BITS));
  329|  2.81k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE9SingletonEj:
  356|    761|    {
  357|    761|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    761|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    761|        MultiIntBitSet ret;
  359|    761|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    761|        return ret;
  361|    761|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE3AnyEv:
  395|  54.7k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE4NoneEv:
  388|   109k|    {
  389|   235k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 235k, False: 33.5k]
  ------------------
  390|   235k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 75.9k, False: 160k]
  ------------------
  391|   235k|        }
  392|  33.5k|        return true;
  393|   109k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE5FirstEv:
  402|  37.9k|    {
  403|  37.9k|        unsigned p = 0;
  404|  50.9k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 12.9k, False: 37.9k]
  ------------------
  405|  12.9k|            ++p;
  406|  12.9k|            Assume(p < N);
  ------------------
  |  |  128|  12.9k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  12.9k|        }
  408|  37.9k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  37.9k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE4LastEv:
  412|  37.9k|    {
  413|  37.9k|        unsigned p = N - 1;
  414|  59.0k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 21.1k, False: 37.9k]
  ------------------
  415|  21.1k|            Assume(p > 0);
  ------------------
  |  |  128|  21.1k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  21.1k|            --p;
  417|  21.1k|        }
  418|  37.9k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  37.9k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE5CountEv:
  381|  54.7k|    {
  382|  54.7k|        unsigned ret{0};
  383|   218k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 218k, False: 54.7k]
  ------------------
  384|  54.7k|        return ret;
  385|  54.7k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEC2Ev:
  312|  31.0k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetIjLj4EEaSESt16initializer_listIjE:
  337|  5.04k|    {
  338|  5.04k|        m_val.fill(0);
  339|  15.1k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 15.1k, False: 5.04k]
  ------------------
  340|  5.04k|        return *this;
  341|  5.04k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetIjLj4EEES2_:
  515|  2.59k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEC2ESt16initializer_listIjE:
  331|  2.23k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  2.23k|    {
  333|  4.46k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 4.46k, False: 2.23k]
  ------------------
  334|  2.23k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE4FillEj:
  364|  4.13k|    {
  365|  4.13k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  4.13k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  4.13k|        MultiIntBitSet ret;
  367|  4.13k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 3.82k, False: 310]
  ------------------
  368|  3.82k|            unsigned i = 0;
  369|  10.0k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 6.18k, False: 3.82k]
  ------------------
  370|  6.18k|                ret.m_val[i++] = I(~I{0});
  371|  6.18k|                count -= LIMB_BITS;
  372|  6.18k|            }
  373|  3.82k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  3.82k|        }
  375|  4.13k|        return ret;
  376|  4.13k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE5beginEv:
  397|  61.0k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE8IteratorC2ERKNSt3__15arrayIjLm4EEE:
  259|  61.0k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  61.0k|        {
  261|   132k|            do {
  262|   132k|                m_val = (*m_ptr)[m_idx];
  263|   132k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 42.3k, False: 90.3k]
  ------------------
  264|  42.3k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  42.3k|                    break;
  266|  42.3k|                }
  267|  90.3k|                ++m_idx;
  268|  90.3k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 71.6k, False: 18.7k]
  ------------------
  269|  61.0k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj4EE8IteratorERKNS1_11IteratorEndE:
  279|  22.2M|        {
  280|  22.2M|            return a.m_idx == N;
  281|  22.2M|        }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE3endEv:
  399|  22.2M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE8IteratordeEv:
  304|  4.40M|        {
  305|  4.40M|            Assume(m_idx < N);
  ------------------
  |  |  128|  4.40M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  4.40M|            return m_pos;
  307|  4.40M|        }
_ZN13bitset_detail14MultiIntBitSetIjLj4EE8IteratorppEv:
  284|  1.86M|        {
  285|  1.86M|            Assume(m_idx < N);
  ------------------
  |  |  128|  1.86M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|  1.86M|            m_val &= m_val - I{1U};
  287|  1.86M|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 127k, False: 1.73M]
  ------------------
  288|   161k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 161k, Folded]
  ------------------
  289|   161k|                    ++m_idx;
  290|   161k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 45.5k, False: 115k]
  ------------------
  291|   115k|                    m_val = (*m_ptr)[m_idx];
  292|   115k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 82.0k, False: 33.6k]
  ------------------
  293|  82.0k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  82.0k|                        break;
  295|  82.0k|                    }
  296|   115k|                }
  297|  1.73M|            } else {
  298|  1.73M|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|  1.73M|            }
  300|  1.86M|            return *this;
  301|  1.86M|        }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEoRERKS1_:
  422|  2.87k|    {
  423|  14.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 11.5k, False: 2.87k]
  ------------------
  424|  11.5k|            m_val[i] |= a.m_val[i];
  425|  11.5k|        }
  426|  2.87k|        return *this;
  427|  2.87k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEaNERKS1_:
  430|  4.48k|    {
  431|  22.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 17.9k, False: 4.48k]
  ------------------
  432|  17.9k|            m_val[i] &= a.m_val[i];
  433|  17.9k|        }
  434|  4.48k|        return *this;
  435|  4.48k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEmIERKS1_:
  438|  2.53k|    {
  439|  12.6k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 10.1k, False: 2.53k]
  ------------------
  440|  10.1k|            m_val[i] &= ~a.m_val[i];
  441|  10.1k|        }
  442|  2.53k|        return *this;
  443|  2.53k|    }
_ZN13bitset_detail14MultiIntBitSetIjLj4EEeOERKS1_:
  446|  2.58k|    {
  447|  12.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 10.3k, False: 2.58k]
  ------------------
  448|  10.3k|            m_val[i] ^= a.m_val[i];
  449|  10.3k|        }
  450|  2.58k|        return *this;
  451|  2.58k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetIjLj4EEES3_:
  471|  6.16k|    {
  472|  6.16k|        MultiIntBitSet r;
  473|  30.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 24.6k, False: 6.16k]
  ------------------
  474|  24.6k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  24.6k|        }
  476|  6.16k|        return r;
  477|  6.16k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetIjLj4EEES3_:
  462|  2.06k|    {
  463|  2.06k|        MultiIntBitSet r;
  464|  10.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 8.25k, False: 2.06k]
  ------------------
  465|  8.25k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  8.25k|        }
  467|  2.06k|        return r;
  468|  2.06k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetIjLj4EEES3_:
  480|  3.56k|    {
  481|  3.56k|        MultiIntBitSet r;
  482|  17.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 14.2k, False: 3.56k]
  ------------------
  483|  14.2k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  14.2k|        }
  485|  3.56k|        return r;
  486|  3.56k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetIjLj4EEES3_:
  489|  2.21k|    {
  490|  2.21k|        MultiIntBitSet r;
  491|  11.0k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 8.84k, False: 2.21k]
  ------------------
  492|  8.84k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  8.84k|        }
  494|  2.21k|        return r;
  495|  2.21k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE12IsSupersetOfERKS1_:
  498|  8.90k|    {
  499|  29.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 25.1k, False: 4.55k]
  ------------------
  500|  25.1k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 4.35k, False: 20.8k]
  ------------------
  501|  25.1k|        }
  502|  4.55k|        return true;
  503|  8.90k|    }
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE10IsSubsetOfERKS1_:
  506|  8.90k|    {
  507|  29.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 25.1k, False: 4.55k]
  ------------------
  508|  25.1k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 4.35k, False: 20.8k]
  ------------------
  509|  25.1k|        }
  510|  4.55k|        return true;
  511|  8.90k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetIjLj4EEES3_:
  513|  6.04k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetIjLj4EE8OverlapsERKS1_:
  454|  5.72k|    {
  455|  15.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 13.6k, False: 2.16k]
  ------------------
  456|  13.6k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 3.55k, False: 10.1k]
  ------------------
  457|  13.6k|        }
  458|  2.16k|        return false;
  459|  5.72k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE4SizeEv:
  378|  16.2M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetImLj3EEixEj:
  350|  21.8M|    {
  351|  21.8M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  21.8M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  21.8M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  21.8M|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE3SetEj:
  319|   677k|    {
  320|   677k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   677k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   677k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   677k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE5ResetEj:
  344|  3.35k|    {
  345|  3.35k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.35k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  3.35k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  3.35k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE3SetEjb:
  325|  3.24k|    {
  326|  3.24k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.24k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  3.24k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  3.24k|                                 (I{val} << (pos % LIMB_BITS));
  329|  3.24k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE9SingletonEj:
  356|    932|    {
  357|    932|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    932|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    932|        MultiIntBitSet ret;
  359|    932|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    932|        return ret;
  361|    932|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE3AnyEv:
  395|  56.7k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE4NoneEv:
  388|   113k|    {
  389|   191k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 191k, False: 30.5k]
  ------------------
  390|   191k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 83.0k, False: 108k]
  ------------------
  391|   191k|        }
  392|  30.5k|        return true;
  393|   113k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE5FirstEv:
  402|  41.5k|    {
  403|  41.5k|        unsigned p = 0;
  404|  50.0k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 8.58k, False: 41.5k]
  ------------------
  405|  8.58k|            ++p;
  406|  8.58k|            Assume(p < N);
  ------------------
  |  |  128|  8.58k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  8.58k|        }
  408|  41.5k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  41.5k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE4LastEv:
  412|  41.5k|    {
  413|  41.5k|        unsigned p = N - 1;
  414|  62.1k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 20.6k, False: 41.5k]
  ------------------
  415|  20.6k|            Assume(p > 0);
  ------------------
  |  |  128|  20.6k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  20.6k|            --p;
  417|  20.6k|        }
  418|  41.5k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  41.5k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE5CountEv:
  381|  56.7k|    {
  382|  56.7k|        unsigned ret{0};
  383|   170k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 170k, False: 56.7k]
  ------------------
  384|  56.7k|        return ret;
  385|  56.7k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EEC2Ev:
  312|  28.4k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetImLj3EEaSESt16initializer_listIjE:
  337|  7.16k|    {
  338|  7.16k|        m_val.fill(0);
  339|  21.4k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 21.4k, False: 7.16k]
  ------------------
  340|  7.16k|        return *this;
  341|  7.16k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetImLj3EEES2_:
  515|  3.65k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj3EEC2ESt16initializer_listIjE:
  331|  3.75k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  3.75k|    {
  333|  7.50k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 7.50k, False: 3.75k]
  ------------------
  334|  3.75k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EE4FillEj:
  364|  4.66k|    {
  365|  4.66k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  4.66k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  4.66k|        MultiIntBitSet ret;
  367|  4.66k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 4.35k, False: 308]
  ------------------
  368|  4.35k|            unsigned i = 0;
  369|  7.99k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 3.63k, False: 4.35k]
  ------------------
  370|  3.63k|                ret.m_val[i++] = I(~I{0});
  371|  3.63k|                count -= LIMB_BITS;
  372|  3.63k|            }
  373|  4.35k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  4.35k|        }
  375|  4.66k|        return ret;
  376|  4.66k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE5beginEv:
  397|  62.4k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj3EE8IteratorC2ERKNSt3__15arrayImLm3EEE:
  259|  62.4k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  62.4k|        {
  261|   105k|            do {
  262|   105k|                m_val = (*m_ptr)[m_idx];
  263|   105k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 45.4k, False: 60.5k]
  ------------------
  264|  45.4k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  45.4k|                    break;
  266|  45.4k|                }
  267|  60.5k|                ++m_idx;
  268|  60.5k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 43.5k, False: 17.0k]
  ------------------
  269|  62.4k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj3EE8IteratorERKNS1_11IteratorEndE:
  279|  34.6M|        {
  280|  34.6M|            return a.m_idx == N;
  281|  34.6M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE3endEv:
  399|  34.6M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE8IteratordeEv:
  304|  6.68M|        {
  305|  6.68M|            Assume(m_idx < N);
  ------------------
  |  |  128|  6.68M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  6.68M|            return m_pos;
  307|  6.68M|        }
_ZN13bitset_detail14MultiIntBitSetImLj3EE8IteratorppEv:
  284|  2.42M|        {
  285|  2.42M|            Assume(m_idx < N);
  ------------------
  |  |  128|  2.42M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|  2.42M|            m_val &= m_val - I{1U};
  287|  2.42M|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 106k, False: 2.31M]
  ------------------
  288|   134k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 134k, Folded]
  ------------------
  289|   134k|                    ++m_idx;
  290|   134k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 48.7k, False: 85.7k]
  ------------------
  291|  85.7k|                    m_val = (*m_ptr)[m_idx];
  292|  85.7k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 57.6k, False: 28.0k]
  ------------------
  293|  57.6k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  57.6k|                        break;
  295|  57.6k|                    }
  296|  85.7k|                }
  297|  2.31M|            } else {
  298|  2.31M|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|  2.31M|            }
  300|  2.42M|            return *this;
  301|  2.42M|        }
_ZN13bitset_detail14MultiIntBitSetImLj3EEoRERKS1_:
  422|  3.69k|    {
  423|  14.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 11.0k, False: 3.69k]
  ------------------
  424|  11.0k|            m_val[i] |= a.m_val[i];
  425|  11.0k|        }
  426|  3.69k|        return *this;
  427|  3.69k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EEaNERKS1_:
  430|  3.23k|    {
  431|  12.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 9.70k, False: 3.23k]
  ------------------
  432|  9.70k|            m_val[i] &= a.m_val[i];
  433|  9.70k|        }
  434|  3.23k|        return *this;
  435|  3.23k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EEmIERKS1_:
  438|  3.64k|    {
  439|  14.5k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 10.9k, False: 3.64k]
  ------------------
  440|  10.9k|            m_val[i] &= ~a.m_val[i];
  441|  10.9k|        }
  442|  3.64k|        return *this;
  443|  3.64k|    }
_ZN13bitset_detail14MultiIntBitSetImLj3EEeOERKS1_:
  446|  2.69k|    {
  447|  10.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 8.08k, False: 2.69k]
  ------------------
  448|  8.08k|            m_val[i] ^= a.m_val[i];
  449|  8.08k|        }
  450|  2.69k|        return *this;
  451|  2.69k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetImLj3EEES3_:
  471|  4.51k|    {
  472|  4.51k|        MultiIntBitSet r;
  473|  18.0k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 13.5k, False: 4.51k]
  ------------------
  474|  13.5k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  13.5k|        }
  476|  4.51k|        return r;
  477|  4.51k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetImLj3EEES3_:
  462|  2.55k|    {
  463|  2.55k|        MultiIntBitSet r;
  464|  10.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 7.66k, False: 2.55k]
  ------------------
  465|  7.66k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  7.66k|        }
  467|  2.55k|        return r;
  468|  2.55k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetImLj3EEES3_:
  480|  2.47k|    {
  481|  2.47k|        MultiIntBitSet r;
  482|  9.88k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 7.41k, False: 2.47k]
  ------------------
  483|  7.41k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  7.41k|        }
  485|  2.47k|        return r;
  486|  2.47k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetImLj3EEES3_:
  489|  2.43k|    {
  490|  2.43k|        MultiIntBitSet r;
  491|  9.72k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 7.29k, False: 2.43k]
  ------------------
  492|  7.29k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  7.29k|        }
  494|  2.43k|        return r;
  495|  2.43k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE12IsSupersetOfERKS1_:
  498|  12.9k|    {
  499|  33.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 27.4k, False: 5.97k]
  ------------------
  500|  27.4k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 6.97k, False: 20.4k]
  ------------------
  501|  27.4k|        }
  502|  5.97k|        return true;
  503|  12.9k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj3EE10IsSubsetOfERKS1_:
  506|  12.9k|    {
  507|  33.3k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 27.4k, False: 5.97k]
  ------------------
  508|  27.4k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 6.97k, False: 20.4k]
  ------------------
  509|  27.4k|        }
  510|  5.97k|        return true;
  511|  12.9k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj3EEES3_:
  513|  5.86k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetImLj3EE8OverlapsERKS1_:
  454|  7.84k|    {
  455|  15.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 13.3k, False: 2.43k]
  ------------------
  456|  13.3k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 5.41k, False: 7.88k]
  ------------------
  457|  13.3k|        }
  458|  2.43k|        return false;
  459|  7.84k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE4SizeEv:
  378|  14.1M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZNK13bitset_detail14MultiIntBitSetImLj4EEixEj:
  350|  17.6M|    {
  351|  17.6M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  17.6M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  17.6M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  17.6M|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE3SetEj:
  319|   501k|    {
  320|   501k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   501k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   501k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   501k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE5ResetEj:
  344|  1.30k|    {
  345|  1.30k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.30k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  1.30k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  1.30k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE3SetEjb:
  325|  1.39k|    {
  326|  1.39k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  1.39k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  327|  1.39k|        m_val[pos / LIMB_BITS] = (m_val[pos / LIMB_BITS] & ~I(I{1U} << (pos % LIMB_BITS))) |
  328|  1.39k|                                 (I{val} << (pos % LIMB_BITS));
  329|  1.39k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE9SingletonEj:
  356|    749|    {
  357|    749|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    749|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    749|        MultiIntBitSet ret;
  359|    749|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    749|        return ret;
  361|    749|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE3AnyEv:
  395|  34.3k|    bool constexpr Any() const noexcept { return !None(); }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE4NoneEv:
  388|  68.7k|    {
  389|   169k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 169k, False: 27.7k]
  ------------------
  390|   169k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 40.9k, False: 128k]
  ------------------
  391|   169k|        }
  392|  27.7k|        return true;
  393|  68.7k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE5FirstEv:
  402|  20.4k|    {
  403|  20.4k|        unsigned p = 0;
  404|  29.3k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 8.85k, False: 20.4k]
  ------------------
  405|  8.85k|            ++p;
  406|  8.85k|            Assume(p < N);
  ------------------
  |  |  128|  8.85k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  8.85k|        }
  408|  20.4k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  20.4k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE4LastEv:
  412|  20.4k|    {
  413|  20.4k|        unsigned p = N - 1;
  414|  34.3k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (414:16): [True: 13.8k, False: 20.4k]
  ------------------
  415|  13.8k|            Assume(p > 0);
  ------------------
  |  |  128|  13.8k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  416|  13.8k|            --p;
  417|  13.8k|        }
  418|  20.4k|        return std::bit_width(m_val[p]) - 1 + p * LIMB_BITS;
  419|  20.4k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE5CountEv:
  381|  34.3k|    {
  382|  34.3k|        unsigned ret{0};
  383|   137k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 137k, False: 34.3k]
  ------------------
  384|  34.3k|        return ret;
  385|  34.3k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EEC2Ev:
  312|  18.2k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetImLj4EEaSESt16initializer_listIjE:
  337|  4.08k|    {
  338|  4.08k|        m_val.fill(0);
  339|  12.2k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (339:23): [True: 12.2k, False: 4.08k]
  ------------------
  340|  4.08k|        return *this;
  341|  4.08k|    }
_ZN13bitset_detail4swapERNS_14MultiIntBitSetImLj4EEES2_:
  515|  2.32k|    friend constexpr void swap(MultiIntBitSet& a, MultiIntBitSet& b) noexcept { std::swap(a.m_val, b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj4EEC2ESt16initializer_listIjE:
  331|  1.73k|    constexpr MultiIntBitSet(std::initializer_list<unsigned> ilist) noexcept : m_val{}
  332|  1.73k|    {
  333|  3.47k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (333:23): [True: 3.47k, False: 1.73k]
  ------------------
  334|  1.73k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EE4FillEj:
  364|  2.60k|    {
  365|  2.60k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  2.60k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  2.60k|        MultiIntBitSet ret;
  367|  2.60k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 2.34k, False: 255]
  ------------------
  368|  2.34k|            unsigned i = 0;
  369|  5.57k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 3.22k, False: 2.34k]
  ------------------
  370|  3.22k|                ret.m_val[i++] = I(~I{0});
  371|  3.22k|                count -= LIMB_BITS;
  372|  3.22k|            }
  373|  2.34k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  2.34k|        }
  375|  2.60k|        return ret;
  376|  2.60k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE5beginEv:
  397|  43.3k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj4EE8IteratorC2ERKNSt3__15arrayImLm4EEE:
  259|  43.3k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  43.3k|        {
  261|   111k|            do {
  262|   111k|                m_val = (*m_ptr)[m_idx];
  263|   111k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 26.1k, False: 84.9k]
  ------------------
  264|  26.1k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  26.1k|                    break;
  266|  26.1k|                }
  267|  84.9k|                ++m_idx;
  268|  84.9k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 67.7k, False: 17.2k]
  ------------------
  269|  43.3k|        }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj4EE8IteratorERKNS1_11IteratorEndE:
  279|  29.3M|        {
  280|  29.3M|            return a.m_idx == N;
  281|  29.3M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE3endEv:
  399|  29.3M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE8IteratordeEv:
  304|  5.21M|        {
  305|  5.21M|            Assume(m_idx < N);
  ------------------
  |  |  128|  5.21M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  5.21M|            return m_pos;
  307|  5.21M|        }
_ZN13bitset_detail14MultiIntBitSetImLj4EE8IteratorppEv:
  284|  1.52M|        {
  285|  1.52M|            Assume(m_idx < N);
  ------------------
  |  |  128|  1.52M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|  1.52M|            m_val &= m_val - I{1U};
  287|  1.52M|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 68.8k, False: 1.45M]
  ------------------
  288|  94.8k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 94.8k, Folded]
  ------------------
  289|  94.8k|                    ++m_idx;
  290|  94.8k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 29.8k, False: 64.9k]
  ------------------
  291|  64.9k|                    m_val = (*m_ptr)[m_idx];
  292|  64.9k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 38.9k, False: 26.0k]
  ------------------
  293|  38.9k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  38.9k|                        break;
  295|  38.9k|                    }
  296|  64.9k|                }
  297|  1.45M|            } else {
  298|  1.45M|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|  1.45M|            }
  300|  1.52M|            return *this;
  301|  1.52M|        }
_ZN13bitset_detail14MultiIntBitSetImLj4EEoRERKS1_:
  422|  1.74k|    {
  423|  8.74k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 6.99k, False: 1.74k]
  ------------------
  424|  6.99k|            m_val[i] |= a.m_val[i];
  425|  6.99k|        }
  426|  1.74k|        return *this;
  427|  1.74k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EEaNERKS1_:
  430|  1.57k|    {
  431|  7.85k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 6.28k, False: 1.57k]
  ------------------
  432|  6.28k|            m_val[i] &= a.m_val[i];
  433|  6.28k|        }
  434|  1.57k|        return *this;
  435|  1.57k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EEmIERKS1_:
  438|  3.11k|    {
  439|  15.5k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 12.4k, False: 3.11k]
  ------------------
  440|  12.4k|            m_val[i] &= ~a.m_val[i];
  441|  12.4k|        }
  442|  3.11k|        return *this;
  443|  3.11k|    }
_ZN13bitset_detail14MultiIntBitSetImLj4EEeOERKS1_:
  446|  1.46k|    {
  447|  7.33k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (447:30): [True: 5.86k, False: 1.46k]
  ------------------
  448|  5.86k|            m_val[i] ^= a.m_val[i];
  449|  5.86k|        }
  450|  1.46k|        return *this;
  451|  1.46k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetImLj4EEES3_:
  471|  2.84k|    {
  472|  2.84k|        MultiIntBitSet r;
  473|  14.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 11.3k, False: 2.84k]
  ------------------
  474|  11.3k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  11.3k|        }
  476|  2.84k|        return r;
  477|  2.84k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetImLj4EEES3_:
  462|  1.62k|    {
  463|  1.62k|        MultiIntBitSet r;
  464|  8.13k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 6.50k, False: 1.62k]
  ------------------
  465|  6.50k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  6.50k|        }
  467|  1.62k|        return r;
  468|  1.62k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetImLj4EEES3_:
  480|  1.40k|    {
  481|  1.40k|        MultiIntBitSet r;
  482|  7.04k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 5.63k, False: 1.40k]
  ------------------
  483|  5.63k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  5.63k|        }
  485|  1.40k|        return r;
  486|  1.40k|    }
_ZN13bitset_detaileoERKNS_14MultiIntBitSetImLj4EEES3_:
  489|  1.41k|    {
  490|  1.41k|        MultiIntBitSet r;
  491|  7.08k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (491:30): [True: 5.66k, False: 1.41k]
  ------------------
  492|  5.66k|            r.m_val[i] = a.m_val[i] ^ b.m_val[i];
  493|  5.66k|        }
  494|  1.41k|        return r;
  495|  1.41k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE12IsSupersetOfERKS1_:
  498|  4.83k|    {
  499|  17.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (499:30): [True: 14.8k, False: 3.02k]
  ------------------
  500|  14.8k|            if (a.m_val[i] & ~m_val[i]) return false;
  ------------------
  |  Branch (500:17): [True: 1.80k, False: 13.0k]
  ------------------
  501|  14.8k|        }
  502|  3.02k|        return true;
  503|  4.83k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj4EE10IsSubsetOfERKS1_:
  506|  4.83k|    {
  507|  17.8k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 14.8k, False: 3.02k]
  ------------------
  508|  14.8k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 1.80k, False: 13.0k]
  ------------------
  509|  14.8k|        }
  510|  3.02k|        return true;
  511|  4.83k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj4EEES3_:
  513|  2.99k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZNK13bitset_detail14MultiIntBitSetImLj4EE8OverlapsERKS1_:
  454|  4.27k|    {
  455|  14.2k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 11.9k, False: 2.27k]
  ------------------
  456|  11.9k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 1.99k, False: 9.93k]
  ------------------
  457|  11.9k|        }
  458|  2.27k|        return false;
  459|  4.27k|    }
_ZN13bitset_detail9IntBitSetIjE4SizeEv:
  178|  2.47M|    static constexpr unsigned Size() noexcept { return MAX_SIZE; }
_ZN13bitset_detail9IntBitSetIjE9SingletonEj:
  139|    900|    {
  140|    900|        Assume(i < MAX_SIZE);
  ------------------
  |  |  128|    900|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  141|    900|        return IntBitSet(I(1U) << i);
  142|    900|    }
_ZN13bitset_detail9IntBitSetIjEC2Ej:
   72|  10.1k|    IntBitSet(I val) noexcept : m_val{val} {}
_ZN13bitset_detail9IntBitSetIjEoRERKS1_:
  200|  3.21k|    constexpr IntBitSet& operator|=(const IntBitSet& a) noexcept { m_val |= a.m_val; return *this; }
_ZNK13bitset_detail9IntBitSetIjE5beginEv:
  184|  53.1k|    constexpr Iterator begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail9IntBitSetIjE8IteratorC2Ej:
   87|  53.1k|        constexpr Iterator(I val) noexcept : m_val(val), m_pos(0)
   88|  53.1k|        {
   89|  53.1k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (89:17): [True: 37.2k, False: 15.8k]
  ------------------
   90|  53.1k|        }
_ZNK13bitset_detail9IntBitSetIjE3endEv:
  186|  4.87M|    constexpr IteratorEnd end() const noexcept { return IteratorEnd(); }
_ZN13bitset_detaileqERKNS_9IntBitSetIjE8IteratorERKNS1_11IteratorEndE:
   99|  4.87M|        {
  100|  4.87M|            return a.m_val == 0;
  101|  4.87M|        }
_ZNK13bitset_detail9IntBitSetIjE8IteratordeEv:
  112|   931k|        {
  113|   931k|            Assume(m_val != 0);
  ------------------
  |  |  128|   931k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  114|   931k|            return m_pos;
  115|   931k|        }
_ZN13bitset_detail9IntBitSetIjE8IteratorppEv:
  104|   383k|        {
  105|   383k|            Assume(m_val != 0);
  ------------------
  |  |  128|   383k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  106|   383k|            m_val &= m_val - I{1U};
  107|   383k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (107:17): [True: 343k, False: 40.3k]
  ------------------
  108|   383k|            return *this;
  109|   383k|        }
_ZNK13bitset_detail9IntBitSetIjEixEj:
  171|  3.03M|    {
  172|  3.03M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.03M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  173|  3.03M|        return (m_val >> pos) & 1U;
  174|  3.03M|    }
_ZN13bitset_detail9IntBitSetIjEmIERKS1_:
  204|  5.86k|    constexpr IntBitSet& operator-=(const IntBitSet& a) noexcept { m_val &= ~a.m_val; return *this; }
_ZN13bitset_detailmiERKNS_9IntBitSetIjEES3_:
  214|  2.38k|    friend constexpr IntBitSet operator-(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & ~b.m_val); }
_ZNK13bitset_detail9IntBitSetIjE4NoneEv:
  180|  93.7k|    constexpr bool None() const noexcept { return m_val == 0; }
_ZNK13bitset_detail9IntBitSetIjE5CountEv:
  176|  46.8k|    constexpr unsigned Count() const noexcept { return PopCount(m_val); }
_ZN13bitset_detail8PopCountIjEEjT_:
   40|   493k|{
   41|   493k|    static_assert(std::is_integral_v<I> && std::is_unsigned_v<I> && std::numeric_limits<I>::radix == 2);
   42|   493k|    constexpr auto BITS = std::numeric_limits<I>::digits;
   43|       |    // Algorithms from https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation.
   44|       |    // These seem to be faster than std::popcount when compiling for non-SSE4 on x86_64.
   45|   493k|    if constexpr (BITS <= 32) {
   46|   493k|        v -= (v >> 1) & 0x55555555;
   47|   493k|        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
   48|   493k|        v = (v + (v >> 4)) & 0x0f0f0f0f;
   49|   493k|        if constexpr (BITS > 8) v += v >> 8;
   50|   493k|        if constexpr (BITS > 16) v += v >> 16;
   51|   493k|        return v & 0x3f;
   52|       |    } else {
   53|       |        static_assert(BITS <= 64);
   54|       |        v -= (v >> 1) & 0x5555555555555555;
   55|       |        v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333);
   56|       |        v = (v + (v >> 4)) & 0x0f0f0f0f0f0f0f0f;
   57|       |        return (v * uint64_t{0x0101010101010101}) >> 56;
   58|       |    }
   59|   493k|}
_ZNK13bitset_detail9IntBitSetIjE3AnyEv:
  182|  46.8k|    constexpr bool Any() const noexcept { return !None(); }
_ZNK13bitset_detail9IntBitSetIjE10IsSubsetOfERKS1_:
  222|  8.62k|    constexpr bool IsSubsetOf(const IntBitSet& a) const noexcept { return (m_val & ~a.m_val) == 0; }
_ZN13bitset_detaileqERKNS_9IntBitSetIjEES3_:
  218|  4.66k|    friend constexpr bool operator==(const IntBitSet& a, const IntBitSet& b) noexcept = default;
_ZN13bitset_detailanERKNS_9IntBitSetIjEES3_:
  210|  1.88k|    friend constexpr IntBitSet operator&(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & b.m_val); }
_ZN13bitset_detail9IntBitSetIjEC2Ev:
  120|  11.8k|    constexpr IntBitSet() noexcept : m_val{0} {}
_ZN13bitset_detail9IntBitSetIjE3SetEj:
  153|   127k|    {
  154|   127k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   127k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  155|   127k|        m_val |= I{1U} << pos;
  156|   127k|    }
_ZNK13bitset_detail9IntBitSetIjE5FirstEv:
  189|  32.5k|    {
  190|  32.5k|        Assume(m_val != 0);
  ------------------
  |  |  128|  32.5k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  191|  32.5k|        return std::countr_zero(m_val);
  192|  32.5k|    }
_ZNK13bitset_detail9IntBitSetIjE12IsSupersetOfERKS1_:
  220|  8.62k|    constexpr bool IsSupersetOf(const IntBitSet& a) const noexcept { return (a.m_val & ~m_val) == 0; }
_ZN13bitset_detail9IntBitSetIjE5ResetEj:
  165|  7.04k|    {
  166|  7.04k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.04k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  167|  7.04k|        m_val &= ~I(I{1U} << pos);
  168|  7.04k|    }
_ZNK13bitset_detail9IntBitSetIjE8OverlapsERKS1_:
  208|  6.12k|    constexpr bool Overlaps(const IntBitSet& a) const noexcept { return m_val & a.m_val; }
_ZN13bitset_detail9IntBitSetIjEaSESt16initializer_listIjE:
  132|  5.38k|    {
  133|  5.38k|        m_val = 0;
  134|  16.1k|        for (auto pos : ilist) Set(pos);
  ------------------
  |  Branch (134:23): [True: 16.1k, False: 5.38k]
  ------------------
  135|  5.38k|        return *this;
  136|  5.38k|    }
_ZNK13bitset_detail9IntBitSetIjE4LastEv:
  195|  32.5k|    {
  196|  32.5k|        Assume(m_val != 0);
  ------------------
  |  |  128|  32.5k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  197|  32.5k|        return std::bit_width(m_val) - 1;
  198|  32.5k|    }
_ZN13bitset_detail9IntBitSetIjEaNERKS1_:
  202|  3.29k|    constexpr IntBitSet& operator&=(const IntBitSet& a) noexcept { m_val &= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetIjE4FillEj:
  145|  3.52k|    {
  146|  3.52k|        IntBitSet ret;
  147|  3.52k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  3.52k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  148|  3.52k|        if (count) ret.m_val = I(~I{0}) >> (MAX_SIZE - count);
  ------------------
  |  Branch (148:13): [True: 3.12k, False: 399]
  ------------------
  149|  3.52k|        return ret;
  150|  3.52k|    }
_ZN13bitset_detailorERKNS_9IntBitSetIjEES3_:
  212|  2.96k|    friend constexpr IntBitSet operator|(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val | b.m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj2EE9SingletonEj:
  356|    761|    {
  357|    761|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|    761|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  358|    761|        MultiIntBitSet ret;
  359|    761|        ret.m_val[pos / LIMB_BITS] = I{1U} << (pos % LIMB_BITS);
  360|    761|        return ret;
  361|    761|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EEixEj:
  350|  14.0M|    {
  351|  14.0M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  14.0M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  352|  14.0M|        return (m_val[pos / LIMB_BITS] >> (pos % LIMB_BITS)) & 1U;
  353|  14.0M|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EEaNERKS1_:
  430|  4.48k|    {
  431|  13.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (431:30): [True: 8.96k, False: 4.48k]
  ------------------
  432|  8.96k|            m_val[i] &= a.m_val[i];
  433|  8.96k|        }
  434|  4.48k|        return *this;
  435|  4.48k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE5CountEv:
  381|  54.7k|    {
  382|  54.7k|        unsigned ret{0};
  383|   109k|        for (I v : m_val) ret += PopCount(v);
  ------------------
  |  Branch (383:18): [True: 109k, False: 54.7k]
  ------------------
  384|  54.7k|        return ret;
  385|  54.7k|    }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj2EEES3_:
  513|  6.04k|    friend constexpr bool operator==(const MultiIntBitSet& a, const MultiIntBitSet& b) noexcept = default;
_ZN13bitset_detail14MultiIntBitSetImLj2EEC2Ev:
  312|  31.0k|    constexpr MultiIntBitSet() noexcept : m_val{} {}
_ZN13bitset_detail14MultiIntBitSetImLj2EEoRERKS1_:
  422|  2.87k|    {
  423|  8.62k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (423:30): [True: 5.75k, False: 2.87k]
  ------------------
  424|  5.75k|            m_val[i] |= a.m_val[i];
  425|  5.75k|        }
  426|  2.87k|        return *this;
  427|  2.87k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EE5ResetEj:
  344|  3.29k|    {
  345|  3.29k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  3.29k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  346|  3.29k|        m_val[pos / LIMB_BITS] &= ~I(I{1U} << (pos % LIMB_BITS));
  347|  3.29k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE8OverlapsERKS1_:
  454|  5.72k|    {
  455|  10.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (455:30): [True: 8.31k, False: 2.16k]
  ------------------
  456|  8.31k|            if (m_val[i] & a.m_val[i]) return true;
  ------------------
  |  Branch (456:17): [True: 3.55k, False: 4.75k]
  ------------------
  457|  8.31k|        }
  458|  2.16k|        return false;
  459|  5.72k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE4NoneEv:
  388|   109k|    {
  389|   150k|        for (auto v : m_val) {
  ------------------
  |  Branch (389:21): [True: 150k, False: 33.5k]
  ------------------
  390|   150k|            if (v != 0) return false;
  ------------------
  |  Branch (390:17): [True: 75.9k, False: 74.9k]
  ------------------
  391|   150k|        }
  392|  33.5k|        return true;
  393|   109k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE5beginEv:
  397|  61.0k|    Iterator constexpr begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail14MultiIntBitSetImLj2EE8IteratorC2ERKNSt3__15arrayImLm2EEE:
  259|  61.0k|        constexpr Iterator(const std::array<I, N>& ref) noexcept : m_ptr(&ref), m_idx(0)
  260|  61.0k|        {
  261|  84.5k|            do {
  262|  84.5k|                m_val = (*m_ptr)[m_idx];
  263|  84.5k|                if (m_val) {
  ------------------
  |  Branch (263:21): [True: 42.3k, False: 42.2k]
  ------------------
  264|  42.3k|                    m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  265|  42.3k|                    break;
  266|  42.3k|                }
  267|  42.2k|                ++m_idx;
  268|  42.2k|            } while(m_idx < N);
  ------------------
  |  Branch (268:21): [True: 23.4k, False: 18.7k]
  ------------------
  269|  61.0k|        }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE3endEv:
  399|  22.2M|    IteratorEnd constexpr end() const noexcept { return IteratorEnd(); }
_ZN13bitset_detaileqERKNS_14MultiIntBitSetImLj2EE8IteratorERKNS1_11IteratorEndE:
  279|  22.2M|        {
  280|  22.2M|            return a.m_idx == N;
  281|  22.2M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE8IteratordeEv:
  304|  4.40M|        {
  305|  4.40M|            Assume(m_idx < N);
  ------------------
  |  |  128|  4.40M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  306|  4.40M|            return m_pos;
  307|  4.40M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE10IsSubsetOfERKS1_:
  506|  8.90k|    {
  507|  18.9k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (507:30): [True: 14.3k, False: 4.55k]
  ------------------
  508|  14.3k|            if (m_val[i] & ~a.m_val[i]) return false;
  ------------------
  |  Branch (508:17): [True: 4.35k, False: 10.0k]
  ------------------
  509|  14.3k|        }
  510|  4.55k|        return true;
  511|  8.90k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EE8IteratorppEv:
  284|  1.86M|        {
  285|  1.86M|            Assume(m_idx < N);
  ------------------
  |  |  128|  1.86M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  286|  1.86M|            m_val &= m_val - I{1U};
  287|  1.86M|            if (m_val == 0) {
  ------------------
  |  Branch (287:17): [True: 76.7k, False: 1.79M]
  ------------------
  288|  84.6k|                while (true) {
  ------------------
  |  Branch (288:24): [True: 84.6k, Folded]
  ------------------
  289|  84.6k|                    ++m_idx;
  290|  84.6k|                    if (m_idx == N) break;
  ------------------
  |  Branch (290:25): [True: 45.5k, False: 39.0k]
  ------------------
  291|  39.0k|                    m_val = (*m_ptr)[m_idx];
  292|  39.0k|                    if (m_val) {
  ------------------
  |  Branch (292:25): [True: 31.1k, False: 7.89k]
  ------------------
  293|  31.1k|                        m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  294|  31.1k|                        break;
  295|  31.1k|                    }
  296|  39.0k|                }
  297|  1.79M|            } else {
  298|  1.79M|                m_pos = std::countr_zero(m_val) + m_idx * LIMB_BITS;
  299|  1.79M|            }
  300|  1.86M|            return *this;
  301|  1.86M|        }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE3AnyEv:
  395|  54.7k|    bool constexpr Any() const noexcept { return !None(); }
_ZN13bitset_detail14MultiIntBitSetImLj2EE3SetEj:
  319|   514k|    {
  320|   514k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   514k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  321|   514k|        m_val[pos / LIMB_BITS] |= I{1U} << (pos % LIMB_BITS);
  322|   514k|    }
_ZNK13bitset_detail14MultiIntBitSetImLj2EE5FirstEv:
  402|  37.9k|    {
  403|  37.9k|        unsigned p = 0;
  404|  41.9k|        while (m_val[p] == 0) {
  ------------------
  |  Branch (404:16): [True: 3.95k, False: 37.9k]
  ------------------
  405|  3.95k|            ++p;
  406|  3.95k|            Assume(p < N);
  ------------------
  |  |  128|  3.95k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  407|  3.95k|        }
  408|  37.9k|        return std::countr_zero(m_val[p]) + p * LIMB_BITS;
  409|  37.9k|    }
_ZN13bitset_detailorERKNS_14MultiIntBitSetImLj2EEES3_:
  471|  6.16k|    {
  472|  6.16k|        MultiIntBitSet r;
  473|  18.4k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (473:30): [True: 12.3k, False: 6.16k]
  ------------------
  474|  12.3k|            r.m_val[i] = a.m_val[i] | b.m_val[i];
  475|  12.3k|        }
  476|  6.16k|        return r;
  477|  6.16k|    }
_ZN13bitset_detailmiERKNS_14MultiIntBitSetImLj2EEES3_:
  480|  3.56k|    {
  481|  3.56k|        MultiIntBitSet r;
  482|  10.7k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (482:30): [True: 7.13k, False: 3.56k]
  ------------------
  483|  7.13k|            r.m_val[i] = a.m_val[i] & ~b.m_val[i];
  484|  7.13k|        }
  485|  3.56k|        return r;
  486|  3.56k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EEmIERKS1_:
  438|  2.53k|    {
  439|  7.60k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (439:30): [True: 5.07k, False: 2.53k]
  ------------------
  440|  5.07k|            m_val[i] &= ~a.m_val[i];
  441|  5.07k|        }
  442|  2.53k|        return *this;
  443|  2.53k|    }
_ZN13bitset_detail14MultiIntBitSetImLj2EE4FillEj:
  364|  4.13k|    {
  365|  4.13k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  4.13k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  366|  4.13k|        MultiIntBitSet ret;
  367|  4.13k|        if (count) {
  ------------------
  |  Branch (367:13): [True: 3.82k, False: 310]
  ------------------
  368|  3.82k|            unsigned i = 0;
  369|  5.93k|            while (count > LIMB_BITS) {
  ------------------
  |  Branch (369:20): [True: 2.11k, False: 3.82k]
  ------------------
  370|  2.11k|                ret.m_val[i++] = I(~I{0});
  371|  2.11k|                count -= LIMB_BITS;
  372|  2.11k|            }
  373|  3.82k|            ret.m_val[i] = I(~I{0}) >> (LIMB_BITS - count);
  374|  3.82k|        }
  375|  4.13k|        return ret;
  376|  4.13k|    }
_ZN13bitset_detailanERKNS_14MultiIntBitSetImLj2EEES3_:
  462|  2.06k|    {
  463|  2.06k|        MultiIntBitSet r;
  464|  6.18k|        for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (464:30): [True: 4.12k, False: 2.06k]
  ------------------
  465|  4.12k|            r.m_val[i] = a.m_val[i] & b.m_val[i];
  466|  4.12k|        }
  467|  2.06k|        return r;
  468|  2.06k|    }
_ZN13bitset_detaileqERKNS_9IntBitSetImEES3_:
  218|  6.37k|    friend constexpr bool operator==(const IntBitSet& a, const IntBitSet& b) noexcept = default;
_ZN13bitset_detail9IntBitSetImEC2Ev:
  120|  14.9k|    constexpr IntBitSet() noexcept : m_val{0} {}
_ZN13bitset_detail9IntBitSetImE4FillEj:
  145|  5.59k|    {
  146|  5.59k|        IntBitSet ret;
  147|  5.59k|        Assume(count <= MAX_SIZE);
  ------------------
  |  |  128|  5.59k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  148|  5.59k|        if (count) ret.m_val = I(~I{0}) >> (MAX_SIZE - count);
  ------------------
  |  Branch (148:13): [True: 5.06k, False: 535]
  ------------------
  149|  5.59k|        return ret;
  150|  5.59k|    }
_ZN13bitset_detailmiERKNS_9IntBitSetImEES3_:
  214|  2.82k|    friend constexpr IntBitSet operator-(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & ~b.m_val); }
_ZN13bitset_detail9IntBitSetImEC2Em:
   72|  14.5k|    IntBitSet(I val) noexcept : m_val{val} {}
_ZNK13bitset_detail9IntBitSetImE3AnyEv:
  182|  58.2k|    constexpr bool Any() const noexcept { return !None(); }
_ZNK13bitset_detail9IntBitSetImE4NoneEv:
  180|   116k|    constexpr bool None() const noexcept { return m_val == 0; }
_ZNK13bitset_detail9IntBitSetImE5FirstEv:
  189|  39.2k|    {
  190|  39.2k|        Assume(m_val != 0);
  ------------------
  |  |  128|  39.2k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  191|  39.2k|        return std::countr_zero(m_val);
  192|  39.2k|    }
_ZN13bitset_detail9IntBitSetImE9SingletonEj:
  139|  1.32k|    {
  140|  1.32k|        Assume(i < MAX_SIZE);
  ------------------
  |  |  128|  1.32k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  141|  1.32k|        return IntBitSet(I(1U) << i);
  142|  1.32k|    }
_ZN13bitset_detail9IntBitSetImE3SetEj:
  153|   208k|    {
  154|   208k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|   208k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  155|   208k|        m_val |= I{1U} << pos;
  156|   208k|    }
_ZNK13bitset_detail9IntBitSetImEixEj:
  171|  7.49M|    {
  172|  7.49M|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  7.49M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  173|  7.49M|        return (m_val >> pos) & 1U;
  174|  7.49M|    }
_ZNK13bitset_detail9IntBitSetImE10IsSubsetOfERKS1_:
  222|  10.5k|    constexpr bool IsSubsetOf(const IntBitSet& a) const noexcept { return (m_val & ~a.m_val) == 0; }
_ZNK13bitset_detail9IntBitSetImE5beginEv:
  184|  64.7k|    constexpr Iterator begin() const noexcept { return Iterator(m_val); }
_ZN13bitset_detail9IntBitSetImE8IteratorC2Em:
   87|  64.7k|        constexpr Iterator(I val) noexcept : m_val(val), m_pos(0)
   88|  64.7k|        {
   89|  64.7k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (89:17): [True: 43.8k, False: 20.9k]
  ------------------
   90|  64.7k|        }
_ZNK13bitset_detail9IntBitSetImE3endEv:
  186|  11.8M|    constexpr IteratorEnd end() const noexcept { return IteratorEnd(); }
_ZN13bitset_detaileqERKNS_9IntBitSetImE8IteratorERKNS1_11IteratorEndE:
   99|  11.8M|        {
  100|  11.8M|            return a.m_val == 0;
  101|  11.8M|        }
_ZNK13bitset_detail9IntBitSetImE8IteratordeEv:
  112|  2.13M|        {
  113|  2.13M|            Assume(m_val != 0);
  ------------------
  |  |  128|  2.13M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  114|  2.13M|            return m_pos;
  115|  2.13M|        }
_ZN13bitset_detail9IntBitSetImEoRERKS1_:
  200|  4.70k|    constexpr IntBitSet& operator|=(const IntBitSet& a) noexcept { m_val |= a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetImE8IteratorppEv:
  104|   882k|        {
  105|   882k|            Assume(m_val != 0);
  ------------------
  |  |  128|   882k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  106|   882k|            m_val &= m_val - I{1U};
  107|   882k|            if (m_val != 0) m_pos = std::countr_zero(m_val);
  ------------------
  |  Branch (107:17): [True: 835k, False: 46.8k]
  ------------------
  108|   882k|            return *this;
  109|   882k|        }
_ZN13bitset_detail9IntBitSetImEmIERKS1_:
  204|  3.99k|    constexpr IntBitSet& operator-=(const IntBitSet& a) noexcept { m_val &= ~a.m_val; return *this; }
_ZN13bitset_detail9IntBitSetImE5ResetEj:
  165|  4.31k|    {
  166|  4.31k|        Assume(pos < MAX_SIZE);
  ------------------
  |  |  128|  4.31k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  167|  4.31k|        m_val &= ~I(I{1U} << pos);
  168|  4.31k|    }
_ZNK13bitset_detail9IntBitSetImE8OverlapsERKS1_:
  208|  8.21k|    constexpr bool Overlaps(const IntBitSet& a) const noexcept { return m_val & a.m_val; }
_ZNK13bitset_detail9IntBitSetImE5CountEv:
  176|  58.2k|    constexpr unsigned Count() const noexcept { return PopCount(m_val); }
_ZN13bitset_detail8PopCountImEEjT_:
   40|   533k|{
   41|   533k|    static_assert(std::is_integral_v<I> && std::is_unsigned_v<I> && std::numeric_limits<I>::radix == 2);
   42|   533k|    constexpr auto BITS = std::numeric_limits<I>::digits;
   43|       |    // Algorithms from https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation.
   44|       |    // These seem to be faster than std::popcount when compiling for non-SSE4 on x86_64.
   45|       |    if constexpr (BITS <= 32) {
   46|       |        v -= (v >> 1) & 0x55555555;
   47|       |        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
   48|       |        v = (v + (v >> 4)) & 0x0f0f0f0f;
   49|       |        if constexpr (BITS > 8) v += v >> 8;
   50|       |        if constexpr (BITS > 16) v += v >> 16;
   51|       |        return v & 0x3f;
   52|   533k|    } else {
   53|   533k|        static_assert(BITS <= 64);
   54|   533k|        v -= (v >> 1) & 0x5555555555555555;
   55|   533k|        v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333);
   56|   533k|        v = (v + (v >> 4)) & 0x0f0f0f0f0f0f0f0f;
   57|   533k|        return (v * uint64_t{0x0101010101010101}) >> 56;
   58|   533k|    }
   59|   533k|}
_ZN13bitset_detail9IntBitSetImEaNERKS1_:
  202|  3.16k|    constexpr IntBitSet& operator&=(const IntBitSet& a) noexcept { m_val &= a.m_val; return *this; }
_ZN13bitset_detailanERKNS_9IntBitSetImEES3_:
  210|  3.21k|    friend constexpr IntBitSet operator&(const IntBitSet& a, const IntBitSet& b) noexcept { return I(a.m_val & b.m_val); }
_ZNK13bitset_detail9IntBitSetImE12IsSupersetOfERKS1_:
  220|  10.5k|    constexpr bool IsSupersetOf(const IntBitSet& a) const noexcept { return (a.m_val & ~m_val) == 0; }

_ZN10btcsignals6signalIFvvENS_10null_valueEED2Ev:
  175|      6|    ~signal() = default;
_ZN10btcsignals6signalIFv20SynchronizationStatellbENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFv20SynchronizationStateRK11CBlockIndexdENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvbENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFviENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFbRK13bilingual_strRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjENS_6any_ofEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRK13bilingual_strjENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;

_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|  10.0k|{
   91|  10.0k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 10.0k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  10.0k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 10.0k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  10.0k|    }
   96|  10.0k|    return std::forward<T>(val);
   97|  10.0k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  10.0k|{
   91|  10.0k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 10.0k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  10.0k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 10.0k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  10.0k|    }
   96|  10.0k|    return std::forward<T>(val);
   97|  10.0k|}
_Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|   170M|{
   91|   170M|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [Folded, False: 0]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|   170M|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 170M]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|   170M|    }
   96|   170M|    return std::forward<T>(val);
   97|   170M|}

_ZN16CThreadInterruptD2Ev:
   32|      4|    virtual ~CThreadInterrupt() = default;

_ZN10ThreadPoolD2Ev:
   93|     10|    {
   94|     10|        Stop(); // In case it hasn't been stopped.
   95|     10|    }
_ZN10ThreadPool4StopEv:
  129|     10|    {
  130|       |        // Notify workers and join them
  131|     10|        std::vector<std::thread> threads_to_join;
  132|     10|        {
  133|     10|            LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  134|       |            // Ensure Stop() is not called from a worker thread while workers are still registered,
  135|       |            // otherwise a self-join deadlock would occur.
  136|     10|            auto id = std::this_thread::get_id();
  137|     10|            for (const auto& worker : m_workers) assert(worker.get_id() != id);
  ------------------
  |  Branch (137:37): [True: 0, False: 10]
  |  Branch (137:50): [True: 0, False: 0]
  ------------------
  138|       |            // Early shutdown to return right away on any concurrent Submit() call
  139|     10|            m_interrupt = true;
  140|     10|            threads_to_join.swap(m_workers);
  141|     10|        }
  142|      0|        m_cv.notify_all();
  143|       |        // Help draining queue
  144|     10|        while (ProcessTask()) {}
  ------------------
  |  Branch (144:16): [True: 0, False: 10]
  ------------------
  145|       |        // Free resources
  146|     10|        for (auto& worker : threads_to_join) worker.join();
  ------------------
  |  Branch (146:27): [True: 0, False: 10]
  ------------------
  147|       |
  148|       |        // Since we currently wait for tasks completion, sanity-check empty queue
  149|     10|        LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|     10|        Assume(m_work_queue.empty());
  ------------------
  |  |  128|     10|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  151|       |        // Re-allow Start() now that all workers have exited
  152|     10|        m_interrupt = false;
  153|     10|    }
_ZN10ThreadPool11ProcessTaskEv:
  244|     10|    {
  245|     10|        std::packaged_task<void()> task;
  246|     10|        {
  247|     10|            LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  248|     10|            if (m_work_queue.empty()) return false;
  ------------------
  |  Branch (248:17): [True: 10, False: 0]
  ------------------
  249|       |
  250|       |            // Pop the task
  251|      0|            task = std::move(m_work_queue.front());
  252|      0|            m_work_queue.pop();
  253|      0|        }
  254|      0|        task();
  255|      0|        return true;
  256|     10|    }

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   54|  10.0k|{
   55|  10.0k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |  116|  10.0k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   56|  10.0k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   57|  10.0k|}
_ZN19MockableSteadyClock13ClearMockTimeEv:
   84|  10.0k|{
   85|  10.0k|    g_mock_steady_time.store(0ms, std::memory_order_relaxed);
   86|  10.0k|}

_ZN19WalletInitInterfaceD2Ev:
   25|      2|    virtual ~WalletInitInterface() = default;