magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEENS5_8optionalIS9_EEE4typeENS_15underlying_typeIS7_E4typeE:
 1296|  1.53k|[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
 1297|  1.53k|  using D = std::decay_t<E>;
 1298|       |
 1299|  1.53k|  if constexpr (detail::count_v<D, S> == 0) {
  ------------------
  |  Branch (1299:17): [Folded - Ignored]
  ------------------
 1300|  1.53k|    static_cast<void>(value);
 1301|  1.53k|    return {}; // Empty enum.
 1302|  1.53k|  } else {
 1303|  1.53k|    if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
  ------------------
  |  Branch (1303:19): [Folded - Ignored]
  |  Branch (1303:19): [Folded - Ignored]
  |  Branch (1303:48): [Folded - Ignored]
  ------------------
 1304|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1305|       |      return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
 1306|       |          [](D v) { return optional<D>{v}; },
 1307|       |          static_cast<D>(value),
 1308|       |          detail::default_result_type_lambda<optional<D>>);
 1309|       |#else
 1310|  12.2k|      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1310:31): [True: 10.7k, False: 1.53k]
  ------------------
 1311|  10.7k|        if (value == static_cast<underlying_type_t<D>>(enum_value<D, S>(i))) {
  ------------------
  |  Branch (1311:13): [True: 0, False: 10.7k]
  ------------------
 1312|      0|          return static_cast<D>(value);
 1313|      0|        }
 1314|  10.7k|      }
 1315|  1.53k|      return {}; // Invalid value or out of range.
 1316|  1.53k|#endif
 1317|  1.53k|    } else {
 1318|  1.53k|      if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
 1319|  1.53k|        return static_cast<D>(value);
 1320|  1.53k|      }
 1321|  1.53k|      return {}; // Invalid value or out of range.
 1322|  1.53k|    }
 1323|  1.53k|  }
 1324|  1.53k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_valueIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEES9_E4typeEm:
 1157|  18.9k|[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
 1158|  18.9k|  using D = std::decay_t<E>;
 1159|       |
 1160|  18.9k|  if constexpr (detail::is_sparse_v<D, S>) {
  ------------------
  |  Branch (1160:17): [Folded - Ignored]
  ------------------
 1161|  18.9k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
  ------------------
  |  |   65|  18.9k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
 1162|  18.9k|  } else {
 1163|  18.9k|    constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v<D, S>) : detail::min_v<D, S>;
 1164|       |
 1165|  18.9k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1166|  18.9k|  }
 1167|  18.9k|}
magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0ENSt3__18equal_toIvEEEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINS4_5decayIT_E4typeEEsr3stdE16is_invocable_r_vIbT1_ccEENS4_8optionalISB_EEE4typeENS4_17basic_string_viewIcNS4_11char_traitsIcEEEESC_:
 1329|  1.53k|[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
 1330|  1.53k|  using D = std::decay_t<E>;
 1331|       |
 1332|  1.53k|  if constexpr (detail::count_v<D, S> == 0) {
  ------------------
  |  Branch (1332:17): [Folded - Ignored]
  ------------------
 1333|  1.53k|    static_cast<void>(value);
 1334|  1.53k|    return {}; // Empty enum.
 1335|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1336|       |    } else if constexpr (detail::is_default_predicate<BinaryPredicate>()) {
 1337|       |      return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1338|       |          [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1339|       |          value,
 1340|       |          detail::default_result_type_lambda<optional<D>>,
 1341|       |          [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1342|       |#endif
 1343|  1.53k|    } else {
 1344|  12.2k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1344:29): [True: 10.6k, False: 1.52k]
  ------------------
 1345|  10.6k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1345:11): [True: 13, False: 10.6k]
  ------------------
 1346|     13|        return enum_value<D, S>(i);
 1347|     13|      }
 1348|  10.6k|    }
 1349|  1.52k|    return {}; // Invalid value or out of range.
 1350|  1.53k|  }
 1351|  1.53k|}
_ZN10magic_enum6detail9cmp_equalIRNSt3__18equal_toIvEEEEbNS2_17basic_string_viewIcNS2_11char_traitsIcEEEES9_OT_:
  344|  10.6k|constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable<BinaryPredicate>()) {
  345|       |#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
  346|       |  // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
  347|       |  // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
  348|       |  constexpr bool workaround = true;
  349|       |#else
  350|  10.6k|  constexpr bool workaround = false;
  351|  10.6k|#endif
  352|       |
  353|  10.6k|  if constexpr (!is_default_predicate<BinaryPredicate>() || workaround) {
  ------------------
  |  Branch (353:17): [Folded - Ignored]
  |  Branch (353:17): [Folded - Ignored]
  |  Branch (353:61): [Folded - Ignored]
  ------------------
  354|  10.6k|    if (lhs.size() != rhs.size()) {
  355|  10.6k|      return false;
  356|  10.6k|    }
  357|       |
  358|  10.6k|    const auto size = lhs.size();
  359|  10.6k|    for (std::size_t i = 0; i < size; ++i) {
  360|  10.6k|      if (!p(lhs[i], rhs[i])) {
  361|  10.6k|        return false;
  362|  10.6k|      }
  363|  10.6k|    }
  364|       |
  365|  10.6k|    return true;
  366|  10.6k|  } else {
  367|  10.6k|    return lhs == rhs;
  368|  10.6k|  }
  369|  10.6k|}
magic_enum_fuzzer.cc:_ZN10magic_enum12enum_entriesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEEDT9entries_vIS9_XT0_EEEE4typeEv:
 1286|    512|[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
 1287|    512|  return detail::entries_v<std::decay_t<E>, S>;
 1288|    512|}
magic_enum_fuzzer.cc:_ZN10magic_enum13enum_containsIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEEbE4typeENS_15underlying_typeIS7_E4typeE:
 1373|  1.02k|[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
 1374|  1.02k|  using D = std::decay_t<E>;
 1375|       |
 1376|  1.02k|  return static_cast<bool>(enum_cast<D, S>(value));
 1377|  1.02k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_namesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEEDT7names_vIS9_XT0_EEEE4typeEv:
 1280|    512|[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
 1281|    512|  return detail::names_v<std::decay_t<E>, S>;
 1282|    512|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_countIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEEmE4typeEv:
 1150|  1.02k|[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
 1151|  1.02k|  return detail::count_v<std::decay_t<E>, S>;
 1152|  1.02k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_indexIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vINSt3__15decayIT_E4typeEEL_ZNS5_16is_invocable_r_vIbNS5_8equal_toIvEEJccEEEEENS5_8optionalImEEE4typeES7_:
 1199|  4.09k|[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
 1200|  4.09k|  using D = std::decay_t<E>;
 1201|  4.09k|  using U = underlying_type_t<D>;
 1202|       |
 1203|  4.09k|  if constexpr (detail::count_v<D, S> == 0) {
  ------------------
  |  Branch (1203:17): [Folded - Ignored]
  ------------------
 1204|  4.09k|    static_cast<void>(value);
 1205|  4.09k|    return {}; // Empty enum.
 1206|  4.09k|  } else if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
  ------------------
  |  Branch (1206:24): [Folded - Ignored]
  |  Branch (1206:24): [Folded - Ignored]
  |  Branch (1206:53): [Folded - Ignored]
  ------------------
 1207|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1208|       |    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::index>(
 1209|       |        [](std::size_t i) { return optional<std::size_t>{i}; },
 1210|       |        value,
 1211|       |        detail::default_result_type_lambda<optional<std::size_t>>);
 1212|       |#else
 1213|  8.19k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1213:29): [True: 8.19k, False: 0]
  ------------------
 1214|  8.19k|      if (enum_value<D, S>(i) == value) {
  ------------------
  |  Branch (1214:11): [True: 4.09k, False: 4.09k]
  ------------------
 1215|  4.09k|        return i;
 1216|  4.09k|      }
 1217|  8.19k|    }
 1218|      0|    return {}; // Invalid value or out of range.
 1219|  4.09k|#endif
 1220|  4.09k|  } else {
 1221|  4.09k|    const auto v = static_cast<U>(value);
 1222|  4.09k|    if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
 1223|  4.09k|      return static_cast<std::size_t>(v - detail::min_v<D, S>);
 1224|  4.09k|    }
 1225|  4.09k|    return {}; // Invalid value or out of range.
 1226|  4.09k|  }
 1227|  4.09k|}

magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEEC2ESt16initializer_listIS2_E:
  872|    512|  constexpr set(std::initializer_list<E> ilist) {
  873|  1.02k|    for (auto e : ilist) {
  ------------------
  |  Branch (873:17): [True: 1.02k, False: 512]
  ------------------
  874|  1.02k|      insert(e);
  875|  1.02k|    }
  876|    512|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertERKS2_:
  929|  1.53k|  constexpr std::pair<iterator, bool> insert(const value_type& value) noexcept {
  930|  1.53k|    if (auto i = index_type::at(value)) {
  ------------------
  |  Branch (930:14): [True: 1.53k, False: 0]
  ------------------
  931|  1.53k|      typename container_type::reference ref = a[value];
  932|  1.53k|      bool r = !ref;
  933|  1.53k|      if (r) {
  ------------------
  |  Branch (933:11): [True: 1.53k, False: 0]
  ------------------
  934|  1.53k|        ref = true;
  935|  1.53k|        ++s;
  936|  1.53k|      }
  937|       |
  938|  1.53k|      return {iterator{this, index_type::begin(), index_type::end(), index_type::it(*i)}, r};
  939|  1.53k|    }
  940|      0|    return {end(), false};
  941|  1.53k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2atES3_:
  186|  4.09k|  [[nodiscard]] static constexpr optional<std::size_t> at(E val) noexcept { return enum_index(val); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEixES2_:
  643|  1.53k|  [[nodiscard]] constexpr reference operator[](E pos) {
  644|  1.53k|    auto i = index_type::at(pos);
  645|  1.53k|    return MAGIC_ENUM_ASSERT(i), reference{this, *i};
  ------------------
  |  |   65|  1.53k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  646|  1.53k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_m:
  504|  2.04k|    constexpr reference_impl(parent_t parent, std::size_t ix) noexcept : reference_impl(parent, std::pair{ix / bits_per_base, base_type{1} << (ix % bits_per_base)}) {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_NS5_4pairImhEE:
  506|  2.04k|    constexpr reference_impl(parent_t parent, std::pair<std::size_t, base_type> ix) noexcept : parent(parent), num_index(std::get<0>(ix)), bit_index(std::get<1>(ix)) {}
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EcvbEv:
  526|  1.53k|    [[nodiscard]] constexpr explicit operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EaSEb:
  509|  2.04k|    constexpr reference_impl& operator=(bool v) noexcept {
  510|  2.04k|      if (v) {
  ------------------
  |  Branch (510:11): [True: 2.04k, False: 0]
  ------------------
  511|  2.04k|        parent->a[num_index] |= bit_index;
  512|  2.04k|      } else {
  513|      0|        parent->a[num_index] &= ~bit_index;
  514|      0|      }
  515|  2.04k|      return *this;
  516|  2.04k|    }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE5beginEv:
  180|  1.53k|   [[nodiscard]] static constexpr const E* begin() noexcept { return values.data(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE3endEv:
  182|  1.53k|   [[nodiscard]] static constexpr const E* end() noexcept { return values.data() + values.size(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2itEm:
  184|  1.53k|  [[nodiscard]] static constexpr const E* it(std::size_t i) noexcept { return values.data() + i; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail16FilteredIteratorIPKNS0_3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS4_EEEEPKS4_NS8_6GetterENS8_9PredicateEEC2ESA_SC_SC_SC_SD_SE_:
  268|  1.53k|      : parent(p), first(std::move(begin)), last(std::move(end)), current(std::move(curr)), getter{std::move(getter)}, predicate{std::move(pred)} {
  269|  1.53k|    if (current == first && !predicate(parent, current)) {
  ------------------
  |  Branch (269:9): [True: 512, False: 1.02k]
  |  Branch (269:29): [True: 0, False: 512]
  ------------------
  270|      0|      ++*this;
  271|      0|    }
  272|  1.53k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE9PredicateclEPKS6_PKS2_:
  843|    512|    constexpr bool operator()(const set* h, const E* e) const noexcept { return h->a[*e]; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEixES2_:
  638|    512|  [[nodiscard]] constexpr bool operator[](E pos) const {
  639|    512|    auto i = index_type::at(pos);
  640|    512|    return MAGIC_ENUM_ASSERT(i), static_cast<bool>(const_reference(this, *i));
  ------------------
  |  |   65|    512|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  641|    512|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_m:
  504|    512|    constexpr reference_impl(parent_t parent, std::size_t ix) noexcept : reference_impl(parent, std::pair{ix / bits_per_base, base_type{1} << (ix % bits_per_base)}) {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_NS5_4pairImhEE:
  506|    512|    constexpr reference_impl(parent_t parent, std::pair<std::size_t, base_type> ix) noexcept : parent(parent), num_index(std::get<0>(ix)), bit_index(std::get<1>(ix)) {}
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EcvbEv:
  526|    512|    [[nodiscard]] constexpr explicit operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5emptyEv:
  918|    512|  [[nodiscard]] constexpr bool empty() const noexcept { return s == 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE4sizeEv:
  920|    512|  [[nodiscard]] constexpr size_type size() const noexcept { return s; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertEOS2_:
  943|    512|  constexpr std::pair<iterator, bool> insert(value_type&& value) noexcept { return insert(value); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5clearEv:
  924|    512|  constexpr void clear() noexcept {
  925|    512|    a.reset();
  926|    512|    s = 0;
  927|    512|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5resetEv:
  747|    512|  constexpr bitset& reset() noexcept { return *this = bitset{}; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEC2ENS3_12raw_access_tE:
  557|  1.53k|  constexpr explicit bitset(detail::raw_access_t = raw_access) noexcept : a{{}} {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3setES2_b:
  739|    512|  constexpr bitset& set(E pos, bool value = true) {
  740|    512|    if (auto i = index_type::at(pos)) {
  ------------------
  |  Branch (740:14): [True: 512, False: 0]
  ------------------
  741|    512|      reference{this, *i} = value;
  742|    512|      return *this;
  743|    512|    }
  744|      0|    MAGIC_ENUM_THROW(std::out_of_range("magic_enum::containers::bitset::set: Unrecognized position"));
  ------------------
  |  |   40|      0|#  define MAGIC_ENUM_THROW(...) throw (__VA_ARGS__)
  ------------------
  745|    512|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4sizeEv:
  691|    512|  [[nodiscard]] constexpr std::size_t size() const noexcept { return enum_count<E>(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3allEv:
  655|    512|  [[nodiscard]] constexpr bool all() const noexcept {
  656|    512|    if constexpr (base_type_count == 0) {
  ------------------
  |  Branch (656:19): [Folded - Ignored]
  ------------------
  657|    512|      return true;
  658|    512|    }
  659|       |
  660|    512|    for (std::size_t i = 0; i < base_type_count - (not_interested > 0); ++i) {
  ------------------
  |  Branch (660:29): [True: 0, False: 512]
  ------------------
  661|      0|      auto check = ~a[i];
  662|      0|      if (check) {
  ------------------
  |  Branch (662:11): [True: 0, False: 0]
  ------------------
  663|      0|        return false;
  664|      0|      }
  665|      0|    }
  666|       |
  667|    512|    if constexpr (not_interested > 0) {
  ------------------
  |  Branch (667:19): [Folded - Ignored]
  ------------------
  668|    512|      return a[base_type_count - 1] == last_value_max;
  669|    512|    }
  670|    512|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3anyEv:
  672|  1.02k|  [[nodiscard]] constexpr bool any() const noexcept {
  673|  1.02k|    for (auto& v : a) {
  ------------------
  |  Branch (673:18): [True: 1.02k, False: 0]
  ------------------
  674|  1.02k|      if (v > 0) {
  ------------------
  |  Branch (674:11): [True: 1.02k, False: 0]
  ------------------
  675|  1.02k|        return true;
  676|  1.02k|      }
  677|  1.02k|    }
  678|      0|    return false;
  679|  1.02k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4noneEv:
  681|    512|  [[nodiscard]] constexpr bool none() const noexcept { return !any(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5countEv:
  683|    512|  [[nodiscard]] constexpr std::size_t count() const noexcept {
  684|    512|    std::size_t c = 0;
  685|    512|    for (auto& v : a) {
  ------------------
  |  Branch (685:18): [True: 512, False: 512]
  ------------------
  686|    512|      c += detail::popcount(v);
  687|    512|    }
  688|    512|    return c;
  689|    512|  }
_ZN10magic_enum10containers6detail8popcountIhEEmT_:
   91|    512|constexpr std::size_t popcount(T x) noexcept {
   92|    512|  std::size_t c = 0;
   93|  2.04k|  while (x > 0) {
  ------------------
  |  Branch (93:10): [True: 1.53k, False: 512]
  ------------------
   94|  1.53k|    c += x & 1;
   95|  1.53k|    x >>= 1;
   96|  1.53k|  }
   97|    512|  return c;
   98|    512|}

LLVMFuzzerTestOneInput:
   17|    512|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   18|    512|  FuzzedDataProvider fdp(data, size);
   19|    512|  const char *fuzz_enum_key1 = fdp.ConsumeRandomLengthString().c_str();
   20|    512|  const char *fuzz_enum_key2 = fdp.ConsumeRandomLengthString().c_str();
   21|    512|  const char *fuzz_enum_key3 = fdp.ConsumeRandomLengthString().c_str();
   22|    512|  const char *fuzz_enum_key4 = fdp.ConsumeRandomLengthString().c_str();
   23|    512|  const char *fuzz_enum_key5 = fdp.ConsumeRandomLengthString().c_str();
   24|    512|  const char *fuzz_enum_key6 = fdp.ConsumeRandomLengthString().c_str();
   25|    512|  const char *fuzz_enum_key7 = fdp.ConsumeRandomLengthString().c_str();
   26|    512|  enum class FuzzEnum : int {
   27|    512|    fuzz_enum_key1 = -5,
   28|    512|    fuzz_enum_key2 = 0,
   29|    512|    fuzz_enum_key3 = 10,
   30|    512|    fuzz_enum_key4 = 11,
   31|    512|    fuzz_enum_key5 = 12,
   32|    512|    fuzz_enum_key6 = 13,
   33|    512|    fuzz_enum_key7 = 14,
   34|    512|  };
   35|    512|  constexpr auto &s7 = magic_enum::enum_values<const FuzzEnum>();
   36|       |
   37|    512|  auto c1 = magic_enum::enum_cast<FuzzEnum>(fdp.ConsumeIntegral<int>());
   38|    512|  auto c2 = magic_enum::enum_cast<FuzzEnum>(fdp.ConsumeRandomLengthString());
   39|    512|  auto c3 = magic_enum::enum_entries<FuzzEnum>();
   40|    512|  auto c4 = magic_enum::enum_values<FuzzEnum>();
   41|    512|  auto c5 = magic_enum::enum_contains<FuzzEnum>(fdp.ConsumeIntegral<int>());
   42|    512|  auto c6 = magic_enum::enum_contains<FuzzEnum>(fdp.ConsumeIntegral<int>());
   43|    512|  auto c7 = magic_enum::enum_names<FuzzEnum>();
   44|    512|  auto c8 = magic_enum::is_unscoped_enum<FuzzEnum>::value;
   45|    512|  auto c9 = magic_enum::is_scoped_enum<FuzzEnum>::value;
   46|    512|  auto c10 =
   47|    512|      magic_enum::enum_cast<FuzzEnum>(fdp.ConsumeRandomLengthString().c_str());
   48|    512|  auto c11 = magic_enum::enum_cast<FuzzEnum>(fdp.ConsumeRandomLengthString());
   49|       |
   50|    512|  auto e_count = magic_enum::enum_count<FuzzEnum>();
   51|       |
   52|    512|  magic_enum::containers::set e_set{FuzzEnum::fuzz_enum_key1, FuzzEnum::fuzz_enum_key2};
   53|    512|  auto s1 = e_set.empty();
   54|    512|  auto s2 = e_set.size();
   55|    512|  e_set.insert(FuzzEnum::fuzz_enum_key3);
   56|    512|  e_set.clear();
   57|       |
   58|    512|  auto e_bitset = magic_enum::containers::bitset<FuzzEnum>();
   59|    512|  e_bitset.set(FuzzEnum::fuzz_enum_key3);
   60|    512|  auto b0 = e_bitset.size();
   61|    512|  auto b1 = e_bitset.all();
   62|    512|  auto b2 = e_bitset.any();
   63|    512|  auto b3 = e_bitset.none();
   64|    512|  auto b4 = e_bitset.count();
   65|       |
   66|    512|  return 0;
   67|    512|}