_ZN11CuckooCache23bit_packed_atomic_flagsC2Ej:
   64|  1.38k|    {
   65|       |        // pad out the size if needed
   66|  1.38k|        size = (size + 7) / 8;
   67|  1.38k|        mem.reset(new std::atomic<uint8_t>[size]);
   68|   119M|        for (uint32_t i = 0; i < size; ++i)
  ------------------
  |  Branch (68:30): [True: 119M, False: 1.38k]
  ------------------
   69|   119M|            mem[i].store(0xFF);
   70|  1.38k|    };
_ZN11CuckooCache23bit_packed_atomic_flags5setupEj:
   82|    692|    {
   83|    692|        bit_packed_atomic_flags d(b);
   84|    692|        std::swap(mem, d.mem);
   85|    692|    }
_ZN11CuckooCache23bit_packed_atomic_flags7bit_setEj:
   94|  4.12k|    {
   95|  4.12k|        mem[s >> 3].fetch_or(uint8_t(1 << (s & 7)), std::memory_order_relaxed);
   96|  4.12k|    }
_ZN11CuckooCache23bit_packed_atomic_flags9bit_unsetEj:
  105|  95.2k|    {
  106|  95.2k|        mem[s >> 3].fetch_and(uint8_t(~(1 << (s & 7))), std::memory_order_relaxed);
  107|  95.2k|    }
_ZNK11CuckooCache23bit_packed_atomic_flags10bit_is_setEj:
  115|  52.3k|    {
  116|  52.3k|        return (1 << (s & 7)) & mem[s >> 3].load(std::memory_order_relaxed);
  117|  52.3k|    }
cuckoocache.cpp:_ZN11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEEC2Ev:
  324|    692|    cache() : table(), collection_flags(0), epoch_flags(), hash_function()
  325|    692|    {
  326|    692|    }
cuckoocache.cpp:_ZN11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE11setup_bytesEm:
  365|    475|    {
  366|    475|        uint32_t requested_num_elems(std::min<size_t>(
  367|    475|            bytes / sizeof(Element),
  368|    475|            std::numeric_limits<uint32_t>::max()));
  369|       |
  370|    475|        auto num_elems = setup(requested_num_elems);
  371|       |
  372|    475|        size_t approx_size_bytes = num_elems * sizeof(Element);
  373|    475|        return std::make_pair(num_elems, approx_size_bytes);
  374|    475|    }
cuckoocache.cpp:_ZN11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE5setupEj:
  337|    692|    {
  338|       |        // depth_limit must be at least one otherwise errors can occur.
  339|    692|        size = std::max<uint32_t>(2, new_size);
  340|    692|        depth_limit = static_cast<uint8_t>(std::log2(static_cast<float>(size)));
  341|    692|        table.resize(size);
  342|    692|        collection_flags.setup(size);
  343|    692|        epoch_flags.resize(size);
  344|       |        // Set to 45% as described above
  345|    692|        epoch_size = std::max(uint32_t{1}, (45 * size) / 100);
  346|       |        // Initially set to wait for a whole epoch
  347|    692|        epoch_heuristic_counter = epoch_size;
  348|    692|        return size;
  349|    692|    }
cuckoocache.cpp:_ZN11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE6insertEi:
  398|  95.9k|    {
  399|  95.9k|        epoch_check();
  400|  95.9k|        uint32_t last_loc = invalid();
  401|  95.9k|        bool last_epoch = true;
  402|  95.9k|        std::array<uint32_t, 8> locs = compute_hashes(e);
  403|       |        // Make sure we have not already inserted this element
  404|       |        // If we have, make sure that it does not get deleted
  405|  95.9k|        for (const uint32_t loc : locs)
  ------------------
  |  Branch (405:33): [True: 123k, False: 2.88k]
  ------------------
  406|   123k|            if (table[loc] == e) {
  ------------------
  |  Branch (406:17): [True: 93.0k, False: 30.4k]
  ------------------
  407|  93.0k|                please_keep(loc);
  408|  93.0k|                epoch_flags[loc] = last_epoch;
  409|  93.0k|                return;
  410|  93.0k|            }
  411|  7.82k|        for (uint8_t depth = 0; depth < depth_limit; ++depth) {
  ------------------
  |  Branch (411:33): [True: 7.07k, False: 750]
  ------------------
  412|       |            // First try to insert to an empty slot, if one exists
  413|  44.1k|            for (const uint32_t loc : locs) {
  ------------------
  |  Branch (413:37): [True: 44.1k, False: 4.94k]
  ------------------
  414|  44.1k|                if (!collection_flags.bit_is_set(loc))
  ------------------
  |  Branch (414:21): [True: 42.0k, False: 2.13k]
  ------------------
  415|  42.0k|                    continue;
  416|  2.13k|                table[loc] = std::move(e);
  417|  2.13k|                please_keep(loc);
  418|  2.13k|                epoch_flags[loc] = last_epoch;
  419|  2.13k|                return;
  420|  44.1k|            }
  421|       |            /** Swap with the element at the location that was
  422|       |            * not the last one looked at. Example:
  423|       |            *
  424|       |            * 1. On first iteration, last_loc == invalid(), find returns last, so
  425|       |            *    last_loc defaults to locs[0].
  426|       |            * 2. On further iterations, where last_loc == locs[k], last_loc will
  427|       |            *    go to locs[k+1 % 8], i.e., next of the 8 indices wrapping around
  428|       |            *    to 0 if needed.
  429|       |            *
  430|       |            * This prevents moving the element we just put in.
  431|       |            *
  432|       |            * The swap is not a move -- we must switch onto the evicted element
  433|       |            * for the next iteration.
  434|       |            */
  435|  4.94k|            last_loc = locs[(1 + (std::find(locs.begin(), locs.end(), last_loc) - locs.begin())) & 7];
  436|  4.94k|            std::swap(table[last_loc], e);
  437|       |            // Can't std::swap a std::vector<bool>::reference and a bool&.
  438|  4.94k|            bool epoch = last_epoch;
  439|  4.94k|            last_epoch = epoch_flags[last_loc];
  440|  4.94k|            epoch_flags[last_loc] = epoch;
  441|       |
  442|       |            // Recompute the locs -- unfortunately happens one too many times!
  443|  4.94k|            locs = compute_hashes(e);
  444|  4.94k|        }
  445|  2.88k|    }
cuckoocache.cpp:_ZN11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE11epoch_checkEv:
  287|  95.9k|    {
  288|  95.9k|        if (epoch_heuristic_counter != 0) {
  ------------------
  |  Branch (288:13): [True: 91.6k, False: 4.27k]
  ------------------
  289|  91.6k|            --epoch_heuristic_counter;
  290|  91.6k|            return;
  291|  91.6k|        }
  292|       |        // count the number of elements from the latest epoch which
  293|       |        // have not been erased.
  294|  4.27k|        uint32_t epoch_unused_count = 0;
  295|  49.6k|        for (uint32_t i = 0; i < size; ++i)
  ------------------
  |  Branch (295:30): [True: 45.3k, False: 4.27k]
  ------------------
  296|  45.3k|            epoch_unused_count += epoch_flags[i] &&
  ------------------
  |  Branch (296:35): [True: 8.13k, False: 37.1k]
  ------------------
  297|  45.3k|                                  !collection_flags.bit_is_set(i);
  ------------------
  |  Branch (297:35): [True: 8.12k, False: 13]
  ------------------
  298|       |        // If there are more non-deleted entries in the current epoch than the
  299|       |        // epoch size, then allow_erase on all elements in the old epoch (marked
  300|       |        // false) and move all elements in the current epoch to the old epoch
  301|       |        // but do not call allow_erase on their indices.
  302|  4.27k|        if (epoch_unused_count >= epoch_size) {
  ------------------
  |  Branch (302:13): [True: 3.50k, False: 773]
  ------------------
  303|  11.5k|            for (uint32_t i = 0; i < size; ++i)
  ------------------
  |  Branch (303:34): [True: 8.00k, False: 3.50k]
  ------------------
  304|  8.00k|                if (epoch_flags[i])
  ------------------
  |  Branch (304:21): [True: 4.20k, False: 3.79k]
  ------------------
  305|  4.20k|                    epoch_flags[i] = false;
  306|  3.79k|                else
  307|  3.79k|                    allow_erase(i);
  308|  3.50k|            epoch_heuristic_counter = epoch_size;
  309|  3.50k|        } else
  310|       |            // reset the epoch_heuristic_counter to next do a scan when worst
  311|       |            // case behavior (no intermittent erases) would exceed epoch size,
  312|       |            // with a reasonable minimum scan size.
  313|       |            // Ordinarily, we would have to sanity check std::min(epoch_size,
  314|       |            // epoch_unused_count), but we already know that `epoch_unused_count
  315|       |            // < epoch_size` in this branch
  316|    773|            epoch_heuristic_counter = std::max(1u, std::max(epoch_size / 16,
  317|    773|                        epoch_size - epoch_unused_count));
  318|  4.27k|    }
cuckoocache.cpp:_ZNK11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE11allow_eraseEj:
  264|  4.12k|    {
  265|  4.12k|        collection_flags.bit_set(n);
  266|  4.12k|    }
cuckoocache.cpp:_ZNK11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE7invalidEv:
  255|  95.9k|    {
  256|  95.9k|        return ~(uint32_t)0;
  257|  95.9k|    }
cuckoocache.cpp:_ZNK11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE14compute_hashesERKi:
  241|   102k|    {
  242|   102k|        return {{FastRange32(hash_function.template operator()<0>(e), size),
  243|   102k|                 FastRange32(hash_function.template operator()<1>(e), size),
  244|   102k|                 FastRange32(hash_function.template operator()<2>(e), size),
  245|   102k|                 FastRange32(hash_function.template operator()<3>(e), size),
  246|   102k|                 FastRange32(hash_function.template operator()<4>(e), size),
  247|   102k|                 FastRange32(hash_function.template operator()<5>(e), size),
  248|   102k|                 FastRange32(hash_function.template operator()<6>(e), size),
  249|   102k|                 FastRange32(hash_function.template operator()<7>(e), size)}};
  250|   102k|    }
cuckoocache.cpp:_ZNK11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE11please_keepEj:
  273|  95.2k|    {
  274|  95.2k|        collection_flags.bit_unset(n);
  275|  95.2k|    }
cuckoocache.cpp:_ZNK11CuckooCache5cacheIiN12_GLOBAL__N_112RandomHasherEE8containsERKib:
  475|  1.79k|    {
  476|  1.79k|        std::array<uint32_t, 8> locs = compute_hashes(e);
  477|  1.79k|        for (const uint32_t loc : locs)
  ------------------
  |  Branch (477:33): [True: 6.57k, False: 548]
  ------------------
  478|  6.57k|            if (table[loc] == e) {
  ------------------
  |  Branch (478:17): [True: 1.24k, False: 5.33k]
  ------------------
  479|  1.24k|                if (erase)
  ------------------
  |  Branch (479:21): [True: 332, False: 910]
  ------------------
  480|    332|                    allow_erase(loc);
  481|  1.24k|                return true;
  482|  1.24k|            }
  483|    548|        return false;
  484|  1.79k|    }

_ZN18FuzzedDataProviderC2EPKhm:
   37|    692|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|    475|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|    475|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|    475|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|    475|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 475]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|    475|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|    475|  uint64_t result = 0;
  215|    475|  size_t offset = 0;
  216|       |
  217|    949|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 949, False: 0]
  |  Branch (217:43): [True: 475, False: 474]
  ------------------
  218|    949|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 474, False: 1]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|    474|    --remaining_bytes_;
  226|    474|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    474|    offset += CHAR_BIT;
  228|    474|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|    475|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 475, False: 0]
  ------------------
  232|    475|    result = result % (range + 1);
  233|       |
  234|    475|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|    475|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|   821k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   821k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   821k|                                std::numeric_limits<T>::max());
  198|   821k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|   821k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   821k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   821k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   821k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 821k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   821k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   821k|  uint64_t result = 0;
  215|   821k|  size_t offset = 0;
  216|       |
  217|  4.06M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.25M, False: 810k]
  |  Branch (217:43): [True: 3.25M, False: 195]
  ------------------
  218|  4.06M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 3.24M, False: 11.2k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  3.24M|    --remaining_bytes_;
  226|  3.24M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  3.24M|    offset += CHAR_BIT;
  228|  3.24M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   821k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 821k, False: 0]
  ------------------
  232|   821k|    result = result % (range + 1);
  233|       |
  234|   821k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   821k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|   296k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   296k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   296k|                                std::numeric_limits<T>::max());
  198|   296k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|   296k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   296k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   296k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   296k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 296k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   296k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   296k|  uint64_t result = 0;
  215|   296k|  size_t offset = 0;
  216|       |
  217|   592k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 296k, False: 295k]
  |  Branch (217:43): [True: 296k, False: 0]
  ------------------
  218|   592k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 295k, False: 792]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|   295k|    --remaining_bytes_;
  226|   295k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   295k|    offset += CHAR_BIT;
  228|   295k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   296k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 296k, False: 0]
  ------------------
  232|   296k|    result = result % (range + 1);
  233|       |
  234|   296k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   296k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|   296k|inline bool FuzzedDataProvider::ConsumeBool() {
  290|   296k|  return 1 & ConsumeIntegral<uint8_t>();
  291|   296k|}

_Z23cuckoocache_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   30|    692|{
   31|    692|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   32|    692|    fuzzed_data_provider_ptr = &fuzzed_data_provider;
   33|    692|    CuckooCache::cache<int, RandomHasher> cuckoo_cache{};
   34|    692|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (34:9): [True: 475, False: 217]
  ------------------
   35|    475|        const size_t megabytes = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 16);
   36|    475|        cuckoo_cache.setup_bytes(megabytes << 20);
   37|    475|    } else {
   38|    217|        cuckoo_cache.setup(fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, 4096));
   39|    217|    }
   40|  97.7k|    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|  98.4k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 97.7k, False: 688]
  |  |  |  Branch (23:49): [True: 97.7k, False: 4]
  |  |  ------------------
  ------------------
   41|  97.7k|        if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (41:13): [True: 95.9k, False: 1.79k]
  ------------------
   42|  95.9k|            cuckoo_cache.insert(fuzzed_data_provider.ConsumeBool());
   43|  95.9k|        } else {
   44|  1.79k|            auto e = fuzzed_data_provider.ConsumeBool();
   45|  1.79k|            auto erase = fuzzed_data_provider.ConsumeBool();
   46|  1.79k|            cuckoo_cache.contains(e, erase);
   47|  1.79k|        }
   48|  97.7k|    }
   49|    692|    fuzzed_data_provider_ptr = nullptr;
   50|    692|}
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh0EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh1EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh2EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh3EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh4EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh5EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh6EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }
cuckoocache.cpp:_ZNK12_GLOBAL__N_112RandomHasherclILh7EEEjRKb:
   22|   102k|    {
   23|   102k|        assert(fuzzed_data_provider_ptr != nullptr);
   24|   102k|        return fuzzed_data_provider_ptr->ConsumeIntegral<uint32_t>();
   25|   102k|    }

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

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

_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|    692|{
   53|    692|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|    692|    ) {
   58|    692|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 692]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    692|    }
   62|    692|    return std::forward<T>(val);
   63|    692|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|    692|{
   53|    692|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|    692|    ) {
   58|    692|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 692]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    692|    }
   62|    692|    return std::forward<T>(val);
   63|    692|}

cuckoocache.cpp:_ZL11FastRange32jj:
   20|   821k|{
   21|   821k|    return (uint64_t{x} * n) >> 32;
   22|   821k|}

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