magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEENS7_8optionalIS6_EEE4typeENS_15underlying_typeIS5_E4typeE:
 1425|  3.10k|[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
 1426|  3.10k|  using D = std::decay_t<E>;
 1427|  3.10k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1428|       |
 1429|  3.10k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1430|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1431|       |    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
 1432|       |        [](D v) { return optional<D>{v}; },
 1433|       |        static_cast<D>(value),
 1434|       |        detail::default_result_type_lambda<optional<D>>);
 1435|       |#else
 1436|  24.8k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1436:29): [True: 21.7k, False: 3.10k]
  ------------------
 1437|  21.7k|      if (value == static_cast<underlying_type_t<D>>(enum_value<D, S>(i))) {
  ------------------
  |  Branch (1437:11): [True: 0, False: 21.7k]
  ------------------
 1438|      0|        return static_cast<D>(value);
 1439|      0|      }
 1440|  21.7k|    }
 1441|  3.10k|    return {}; // Invalid value or out of range.
 1442|  3.10k|#endif
 1443|       |  } else {
 1444|       |    if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
 1445|       |      return static_cast<D>(value);
 1446|       |    }
 1447|       |    return {}; // Invalid value or out of range.
 1448|       |  }
 1449|  3.10k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_valueIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEES6_E4typeEm:
 1272|  38.3k|[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
 1273|  38.3k|  using D = std::decay_t<E>;
 1274|  38.3k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1275|       |
 1276|  38.3k|  if constexpr (detail::is_sparse_v<D, S>) {
 1277|  38.3k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
  ------------------
  |  |   69|  38.3k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (1277:12): [True: 38.3k, False: 0]
  ------------------
 1278|       |  } else {
 1279|       |    constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v<D, S>) : detail::min_v<D, S>;
 1280|       |
 1281|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1282|       |  }
 1283|  38.3k|}
magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0ENSt3__18equal_toIvEEEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEsr3stdE16is_invocable_r_vIbRT1_ccEENS4_8optionalIS9_EEE4typeENS4_17basic_string_viewIcNS4_11char_traitsIcEEEESA_:
 1454|  3.10k|[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable_v<BinaryPredicate>) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
 1455|  3.10k|  using D = std::decay_t<E>;
 1456|  3.10k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1457|       |
 1458|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1459|       |  if constexpr (detail::is_default_predicate_v<BinaryPredicate>) {
 1460|       |    return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1461|       |        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1462|       |        value,
 1463|       |        detail::default_result_type_lambda<optional<D>>,
 1464|       |        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1465|       |  } else {
 1466|       |#endif
 1467|  24.7k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1467:29): [True: 21.6k, False: 3.09k]
  ------------------
 1468|  21.6k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1468:11): [True: 15, False: 21.6k]
  ------------------
 1469|     15|        return enum_value<D, S>(i);
 1470|     15|      }
 1471|  21.6k|    }
 1472|  3.09k|    return {}; // Invalid value or out of range.
 1473|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1474|       |  }
 1475|       |#endif
 1476|  3.10k|}
_ZN10magic_enum6detail9cmp_equalIRNSt3__18equal_toIvEEEEbNS2_17basic_string_viewIcNS2_11char_traitsIcEEEES9_OT_:
  392|  21.6k|constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable_v<BinaryPredicate>) {
  393|       |#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
  394|       |  // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
  395|       |  // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
  396|       |  constexpr bool workaround = true;
  397|       |#else
  398|  21.6k|  constexpr bool workaround = false;
  399|  21.6k|#endif
  400|       |
  401|       |  if constexpr (!is_default_predicate_v<BinaryPredicate> || workaround) {
  402|       |    if (lhs.size() != rhs.size()) {
  403|       |      return false;
  404|       |    }
  405|       |
  406|       |    const auto size = lhs.size();
  407|       |    for (std::size_t i = 0; i < size; ++i) {
  408|       |      if (!p(lhs[i], rhs[i])) {
  409|       |        return false;
  410|       |      }
  411|       |    }
  412|       |
  413|       |    return true;
  414|  21.6k|  } else {
  415|  21.6k|    return lhs == rhs;
  416|  21.6k|  }
  417|  21.6k|}
magic_enum_fuzzer.cc:_ZN10magic_enum12enum_entriesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEEDT9entries_vIS6_XT0_EEEE4typeEv:
 1412|  1.03k|[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
 1413|  1.03k|  using D = std::decay_t<E>;
 1414|  1.03k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1415|       |
 1416|  1.03k|  return detail::entries_v<D, S>;
 1417|  1.03k|}
magic_enum_fuzzer.cc:_ZN10magic_enum13enum_containsIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEEbE4typeENS_15underlying_typeIS5_E4typeE:
 1498|  2.07k|[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
 1499|  2.07k|  using D = std::decay_t<E>;
 1500|       |
 1501|  2.07k|  return static_cast<bool>(enum_cast<D, S>(value));
 1502|  2.07k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_namesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEEDT7names_vIS6_XT0_EEEE4typeEv:
 1403|  1.03k|[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
 1404|  1.03k|  using D = std::decay_t<E>;
 1405|  1.03k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1406|       |
 1407|  1.03k|  return detail::names_v<D, S>;
 1408|  1.03k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_countIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEEmE4typeEv:
 1265|  7.25k|[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
 1266|  7.25k|  return detail::count_v<std::decay_t<E>, S>;
 1267|  7.25k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_indexIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEENS7_8optionalImEEE4typeES5_:
 1319|  8.28k|[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
 1320|  8.28k|  using D = std::decay_t<E>;
 1321|  8.28k|  using U = underlying_type_t<D>;
 1322|  8.28k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1323|       |
 1324|  8.28k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1325|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1326|       |    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::index>(
 1327|       |        [](std::size_t i) { return optional<std::size_t>{i}; },
 1328|       |        value,
 1329|       |        detail::default_result_type_lambda<optional<std::size_t>>);
 1330|       |#else
 1331|  16.5k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1331:29): [True: 16.5k, False: 0]
  ------------------
 1332|  16.5k|      if (enum_value<D, S>(i) == value) {
  ------------------
  |  Branch (1332:11): [True: 8.28k, False: 8.28k]
  ------------------
 1333|  8.28k|        return i;
 1334|  8.28k|      }
 1335|  16.5k|    }
 1336|      0|    return {}; // Invalid value or out of range.
 1337|  8.28k|#endif
 1338|       |  } else {
 1339|       |    const auto v = static_cast<U>(value);
 1340|       |    if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
 1341|       |      return static_cast<std::size_t>(v - detail::min_v<D, S>);
 1342|       |    }
 1343|       |    return {}; // Invalid value or out of range.
 1344|       |  }
 1345|  8.28k|}

magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEEC2ESt16initializer_listIS2_E:
 1133|  1.03k|  constexpr set(std::initializer_list<E> ilist) {
 1134|  2.07k|    for (auto e : ilist) {
  ------------------
  |  Branch (1134:17): [True: 2.07k, False: 1.03k]
  ------------------
 1135|  2.07k|      insert(e);
 1136|  2.07k|    }
 1137|  1.03k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertERKS2_:
 1192|  3.10k|  constexpr std::pair<iterator, bool> insert(const value_type& value) noexcept {
 1193|  3.10k|    if (auto i = index_type::at(value)) {
  ------------------
  |  Branch (1193:14): [True: 3.10k, False: 0]
  ------------------
 1194|  3.10k|      auto ref = a[value];
 1195|  3.10k|      const bool res = !ref;
 1196|  3.10k|      if (res) {
  ------------------
  |  Branch (1196:11): [True: 3.10k, False: 0]
  ------------------
 1197|  3.10k|        ref = true;
 1198|  3.10k|        ++s;
 1199|  3.10k|      }
 1200|       |
 1201|  3.10k|      return {iterator{this, index_type::begin(), index_type::end(), index_type::it(*i)}, res};
 1202|  3.10k|    }
 1203|      0|    return {end(), false};
 1204|  3.10k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2atES3_:
  223|  8.28k|  [[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_:
  886|  3.10k|  [[nodiscard]] constexpr reference operator[](E pos) {
  887|  3.10k|    auto i = index_type::at(pos);
  888|  3.10k|    return MAGIC_ENUM_ASSERT(i && *i < size()), reference{this, *i};
  ------------------
  |  |   69|  3.10k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (888:12): [True: 3.10k, False: 0]
  |  Branch (888:12): [True: 3.10k, False: 0]
  |  Branch (888:12): [True: 3.10k, False: 0]
  ------------------
  889|  3.10k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_m:
  643|  4.14k|    constexpr reference_impl(parent_t p, std::size_t i) noexcept : reference_impl(p, i / bits_per_base, bit_mask(i)) {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE8bit_maskEm:
  626|  5.18k|  [[nodiscard]] static constexpr base_type bit_mask(std::size_t index) noexcept {
  627|  5.18k|    return static_cast<base_type>(base_type{1} << (index % bits_per_base));
  628|  5.18k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_mh:
  645|  4.14k|    constexpr reference_impl(parent_t p, std::size_t num, base_type bit) noexcept : parent(p), num_index(num), bit_index(bit) {}
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EcvbEv:
  665|  3.10k|    [[nodiscard]] constexpr operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EaSEb:
  648|  4.14k|    constexpr reference_impl& operator=(bool v) noexcept {
  649|  4.14k|      if (v) {
  ------------------
  |  Branch (649:11): [True: 4.14k, False: 0]
  ------------------
  650|  4.14k|        parent->a[num_index] |= bit_index;
  651|  4.14k|      } else {
  652|      0|        parent->a[num_index] &= ~bit_index;
  653|      0|      }
  654|  4.14k|      return *this;
  655|  4.14k|    }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE5beginEv:
  217|  3.10k|  [[nodiscard]] static constexpr const E* begin() noexcept { return values.data(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE3endEv:
  219|  3.10k|  [[nodiscard]] static constexpr const E* end() noexcept { return values.data() + values.size(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2itEm:
  221|  3.10k|  [[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_:
  311|  3.10k|      : parent(p), first(std::move(begin)), last(std::move(end)), current(std::move(curr)), getter{std::move(get)}, predicate{std::move(pred)} {
  312|  3.10k|    if (current == first && !predicate(parent, current)) {
  ------------------
  |  Branch (312:9): [True: 1.03k, False: 2.07k]
  |  Branch (312:29): [True: 0, False: 1.03k]
  ------------------
  313|      0|      ++*this;
  314|      0|    }
  315|  3.10k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE9PredicateclEPKS6_PKS2_:
 1104|  1.03k|    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_:
  881|  1.03k|  [[nodiscard]] constexpr bool operator[](E pos) const {
  882|  1.03k|    auto i = index_type::at(pos);
  883|  1.03k|    return MAGIC_ENUM_ASSERT(i && *i < size()), static_cast<bool>(const_reference(this, *i));
  ------------------
  |  |   69|  1.03k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (883:12): [True: 1.03k, False: 0]
  |  Branch (883:12): [True: 1.03k, False: 0]
  |  Branch (883:12): [True: 1.03k, False: 0]
  ------------------
  884|  1.03k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_m:
  643|  1.03k|    constexpr reference_impl(parent_t p, std::size_t i) noexcept : reference_impl(p, i / bits_per_base, bit_mask(i)) {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_mh:
  645|  1.03k|    constexpr reference_impl(parent_t p, std::size_t num, base_type bit) noexcept : parent(p), num_index(num), bit_index(bit) {}
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EcvbEv:
  665|  1.03k|    [[nodiscard]] constexpr operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5emptyEv:
 1181|  1.03k|  [[nodiscard]] constexpr bool empty() const noexcept { return s == 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE4sizeEv:
 1183|  1.03k|  [[nodiscard]] constexpr size_type size() const noexcept { return s; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertEOS2_:
 1206|  1.03k|  constexpr std::pair<iterator, bool> insert(value_type&& value) noexcept { return insert(value); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5clearEv:
 1187|  1.03k|  constexpr void clear() noexcept {
 1188|  1.03k|    a.reset();
 1189|  1.03k|    s = 0;
 1190|  1.03k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5resetEv:
  999|  1.03k|  constexpr bitset& reset() noexcept { return *this = bitset{}; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEC2ENS3_12raw_access_tE:
  801|  3.10k|  constexpr explicit bitset(detail::raw_access_t = raw_access) noexcept : a{{}} {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3setES2_b:
  991|  1.03k|  constexpr bitset& set(E pos, bool value = true) {
  992|  1.03k|    if (auto i = index_type::at(pos); i && *i < size()) {
  ------------------
  |  Branch (992:39): [True: 1.03k, False: 0]
  |  Branch (992:44): [True: 1.03k, False: 0]
  ------------------
  993|  1.03k|      reference{this, *i} = value;
  994|  1.03k|      return *this;
  995|  1.03k|    }
  996|      0|    MAGIC_ENUM_CONTAINERS_THROW(std::out_of_range("magic_enum::containers::bitset::set: Unrecognized position"));
  ------------------
  |  |   61|      0|#  define MAGIC_ENUM_CONTAINERS_THROW(...) throw (__VA_ARGS__)
  ------------------
  997|  1.03k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4sizeEv:
  952|  6.21k|  [[nodiscard]] constexpr std::size_t size() const noexcept { return enum_count<E>(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3allEv:
  924|  1.03k|  [[nodiscard]] constexpr bool all() const noexcept {
  925|  1.03k|    for (std::size_t i = 0; i + 1 < base_type_count; ++i) {
  ------------------
  |  Branch (925:29): [True: 0, False: 1.03k]
  ------------------
  926|      0|      if (a[i] != (std::numeric_limits<base_type>::max)()) {
  ------------------
  |  Branch (926:11): [True: 0, False: 0]
  ------------------
  927|      0|        return false;
  928|      0|      }
  929|      0|    }
  930|  1.03k|    return a[base_type_count - 1] == last_value_max;
  931|  1.03k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3anyEv:
  933|  2.07k|  [[nodiscard]] constexpr bool any() const noexcept {
  934|  2.07k|    for (auto& v : a) {
  ------------------
  |  Branch (934:18): [True: 2.07k, False: 0]
  ------------------
  935|  2.07k|      if (v > 0) {
  ------------------
  |  Branch (935:11): [True: 2.07k, False: 0]
  ------------------
  936|  2.07k|        return true;
  937|  2.07k|      }
  938|  2.07k|    }
  939|      0|    return false;
  940|  2.07k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4noneEv:
  942|  1.03k|  [[nodiscard]] constexpr bool none() const noexcept { return !any(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5countEv:
  944|  1.03k|  [[nodiscard]] constexpr std::size_t count() const noexcept {
  945|  1.03k|    std::size_t c = 0;
  946|  1.03k|    for (auto& v : a) {
  ------------------
  |  Branch (946:18): [True: 1.03k, False: 1.03k]
  ------------------
  947|  1.03k|      c += detail::popcount(v);
  948|  1.03k|    }
  949|  1.03k|    return c;
  950|  1.03k|  }
_ZN10magic_enum10containers6detail8popcountIhEEmT_:
  114|  1.03k|constexpr std::size_t popcount(T x) noexcept {
  115|       |#if defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
  116|       |  return static_cast<std::size_t>(std::popcount(x));
  117|       |#else
  118|  1.03k|  std::size_t c = 0;
  119|  2.07k|  while (x > 0) {
  ------------------
  |  Branch (119:10): [True: 1.03k, False: 1.03k]
  ------------------
  120|  1.03k|    x &= x - 1;
  121|  1.03k|    ++c;
  122|  1.03k|  }
  123|  1.03k|  return c;
  124|  1.03k|#endif
  125|  1.03k|}

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