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:
 1769|  2.90k|[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
 1770|  2.90k|  using D = std::decay_t<E>;
 1771|  2.90k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1772|       |
 1773|  2.90k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1774|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1775|       |    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
 1776|       |        [](D v) { return optional<D>{v}; },
 1777|       |        value,
 1778|       |        detail::default_result_type_lambda<optional<D>>,
 1779|       |        [](D lhs, underlying_type_t<D> rhs) { return detail::enum_value_equal(lhs, rhs); });
 1780|       |#else
 1781|  23.2k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1781:29): [True: 20.3k, False: 2.90k]
  ------------------
 1782|  20.3k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1782:11): [True: 0, False: 20.3k]
  ------------------
 1783|      0|        return static_cast<D>(value);
 1784|      0|      }
 1785|  20.3k|    }
 1786|  2.90k|    return {}; // Invalid value or out of range.
 1787|  2.90k|#endif
 1788|       |  } else {
 1789|       |    if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
 1790|       |      return static_cast<D>(value);
 1791|       |    }
 1792|       |    return {}; // Invalid value or out of range.
 1793|       |  }
 1794|  2.90k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_u17__underlying_typeIS3_E:
  327|  20.3k|constexpr bool enum_value_equal(E lhs, std::underlying_type_t<E> rhs) noexcept {
  328|  20.3k|  return static_cast<std::underlying_type_t<E>>(lhs) == rhs;
  329|  20.3k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_valueIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEES6_E4typeEm:
 1615|  35.8k|[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
 1616|  35.8k|  using D = std::decay_t<E>;
 1617|  35.8k|  using U = underlying_type_t<D>;
 1618|  35.8k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1619|       |
 1620|  35.8k|  if constexpr (detail::is_sparse_v<D, S>) {
 1621|  35.8k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
  ------------------
  |  |   86|  35.8k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (1621:12): [True: 35.8k, False: 0]
  ------------------
 1622|       |  } else if constexpr (S == detail::enum_subtype::flags) {
 1623|       |    using V = detail::make_unsigned_t<U>;
 1624|       |    constexpr auto min = detail::log2(static_cast<V>(detail::min_v<D, S>));
 1625|       |
 1626|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1627|       |  } else {
 1628|       |    constexpr auto min = detail::min_v<D, S>;
 1629|       |
 1630|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1631|       |  }
 1632|  35.8k|}
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_:
 1799|  2.90k|[[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> {
 1800|  2.90k|  using D = std::decay_t<E>;
 1801|  2.90k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1802|       |
 1803|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1804|       |  using hash_t = detail::constexpr_hash_t<string_view>;
 1805|       |  if constexpr (detail::is_default_predicate_v<BinaryPredicate> && detail::has_usable_hash_v<&detail::names_v<D, S>, hash_t>) {
 1806|       |    return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1807|       |        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1808|       |        value,
 1809|       |        detail::default_result_type_lambda<optional<D>>,
 1810|       |        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1811|       |  } else {
 1812|       |#endif
 1813|  23.1k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1813:29): [True: 20.2k, False: 2.89k]
  ------------------
 1814|  20.2k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1814:11): [True: 17, False: 20.2k]
  ------------------
 1815|     17|        return enum_value<D, S>(i);
 1816|     17|      }
 1817|  20.2k|    }
 1818|  2.89k|    return {}; // Invalid value or out of range.
 1819|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1820|       |  }
 1821|       |#endif
 1822|  2.90k|}
_ZN10magic_enum6detail9cmp_equalIRNSt3__18equal_toIvEEEEbNS2_17basic_string_viewIcNS2_11char_traitsIcEEEES9_OT_:
  485|  20.2k|constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable_v<BinaryPredicate>) {
  486|       |#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
  487|       |  // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
  488|       |  // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
  489|       |  constexpr bool workaround = true;
  490|       |#else
  491|  20.2k|  constexpr bool workaround = false;
  492|  20.2k|#endif
  493|       |
  494|       |  if constexpr (!is_default_predicate_v<BinaryPredicate> || workaround) {
  495|       |    if (lhs.size() != rhs.size()) {
  496|       |      return false;
  497|       |    }
  498|       |
  499|       |    const auto size = lhs.size();
  500|       |    for (std::size_t i = 0; i < size; ++i) {
  501|       |      if (!p(lhs[i], rhs[i])) {
  502|       |        return false;
  503|       |      }
  504|       |    }
  505|       |
  506|       |    return true;
  507|  20.2k|  } else {
  508|  20.2k|    return lhs == rhs;
  509|  20.2k|  }
  510|  20.2k|}
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:
 1756|    969|[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
 1757|    969|  using D = std::decay_t<E>;
 1758|    969|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1759|       |
 1760|    969|  return detail::entries_v<D, S>;
 1761|    969|}
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:
 1841|  1.93k|[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
 1842|  1.93k|  using D = std::decay_t<E>;
 1843|       |
 1844|  1.93k|  return static_cast<bool>(enum_cast<D, S>(value));
 1845|  1.93k|}
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:
 1747|    969|[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
 1748|    969|  using D = std::decay_t<E>;
 1749|    969|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1750|       |
 1751|    969|  return detail::names_v<D, S>;
 1752|    969|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_countIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEEmE4typeEv:
 1608|  6.78k|[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
 1609|  6.78k|  return detail::count_v<std::decay_t<E>, S>;
 1610|  6.78k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_indexIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEENS7_8optionalImEEE4typeES5_:
 1668|  7.75k|[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
 1669|  7.75k|  using D = std::decay_t<E>;
 1670|  7.75k|  using U = underlying_type_t<D>;
 1671|  7.75k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1672|       |
 1673|  7.75k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1674|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1675|       |    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::index>(
 1676|       |        [](std::size_t i) { return optional<std::size_t>{i}; },
 1677|       |        value,
 1678|       |        detail::default_result_type_lambda<optional<std::size_t>>,
 1679|       |        [](D lhs, D rhs) { return detail::enum_value_equal(lhs, rhs); });
 1680|       |#else
 1681|  15.5k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1681:29): [True: 15.5k, False: 0]
  ------------------
 1682|  15.5k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1682:11): [True: 7.75k, False: 7.75k]
  ------------------
 1683|  7.75k|        return i;
 1684|  7.75k|      }
 1685|  15.5k|    }
 1686|      0|    return {}; // Invalid value or out of range.
 1687|  7.75k|#endif
 1688|       |  } else {
 1689|       |    const auto v = static_cast<U>(value);
 1690|       |    if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
 1691|       |      return static_cast<std::size_t>(v - detail::min_v<D, S>);
 1692|       |    }
 1693|       |    return {}; // Invalid value or out of range.
 1694|       |  }
 1695|  7.75k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_S3_:
  321|  15.5k|constexpr bool enum_value_equal(E lhs, E rhs) noexcept {
  322|  15.5k|  using U = std::underlying_type_t<E>;
  323|  15.5k|  return static_cast<U>(lhs) == static_cast<U>(rhs);
  324|  15.5k|}

magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEEC2ESt16initializer_listIS2_E:
 1134|    969|  constexpr set(std::initializer_list<E> ilist) {
 1135|  1.93k|    for (auto e : ilist) {
  ------------------
  |  Branch (1135:17): [True: 1.93k, False: 969]
  ------------------
 1136|  1.93k|      insert(e);
 1137|  1.93k|    }
 1138|    969|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertERKS2_:
 1193|  2.90k|  constexpr std::pair<iterator, bool> insert(const value_type& value) noexcept {
 1194|  2.90k|    if (auto i = index_type::at(value)) {
  ------------------
  |  Branch (1194:14): [True: 2.90k, False: 0]
  ------------------
 1195|  2.90k|      auto ref = a[value];
 1196|  2.90k|      const bool res = !ref;
 1197|  2.90k|      if (res) {
  ------------------
  |  Branch (1197:11): [True: 2.90k, False: 0]
  ------------------
 1198|  2.90k|        ref = true;
 1199|  2.90k|        ++s;
 1200|  2.90k|      }
 1201|       |
 1202|  2.90k|      return {iterator{this, index_type::begin(), index_type::end(), index_type::it(*i)}, res};
 1203|  2.90k|    }
 1204|      0|    return {end(), false};
 1205|  2.90k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2atES3_:
  224|  7.75k|  [[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_:
  887|  2.90k|  [[nodiscard]] constexpr reference operator[](E pos) {
  888|  2.90k|    auto i = index_type::at(pos);
  889|  2.90k|    return MAGIC_ENUM_ASSERT(i && *i < size()), reference{this, *i};
  ------------------
  |  |   86|  2.90k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (889:12): [True: 2.90k, False: 0]
  |  Branch (889:12): [True: 2.90k, False: 0]
  |  Branch (889:12): [True: 2.90k, False: 0]
  ------------------
  890|  2.90k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_m:
  644|  3.87k|    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:
  627|  4.84k|  [[nodiscard]] static constexpr base_type bit_mask(std::size_t index) noexcept {
  628|  4.84k|    return static_cast<base_type>(base_type{1} << (index % bits_per_base));
  629|  4.84k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_mh:
  646|  3.87k|    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:
  666|  2.90k|    [[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:
  649|  3.87k|    constexpr reference_impl& operator=(bool v) noexcept {
  650|  3.87k|      if (v) {
  ------------------
  |  Branch (650:11): [True: 3.87k, False: 0]
  ------------------
  651|  3.87k|        parent->a[num_index] |= bit_index;
  652|  3.87k|      } else {
  653|      0|        parent->a[num_index] &= ~bit_index;
  654|      0|      }
  655|  3.87k|      return *this;
  656|  3.87k|    }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE5beginEv:
  218|  2.90k|  [[nodiscard]] static constexpr const E* begin() noexcept { return values.data(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE3endEv:
  220|  2.90k|  [[nodiscard]] static constexpr const E* end() noexcept { return values.data() + values.size(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2itEm:
  222|  2.90k|  [[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_:
  312|  2.90k|      : parent(p), first(std::move(begin)), last(std::move(end)), current(std::move(curr)), getter{std::move(get)}, predicate{std::move(pred)} {
  313|  2.90k|    if (current == first && !predicate(parent, current)) {
  ------------------
  |  Branch (313:9): [True: 969, False: 1.93k]
  |  Branch (313:29): [True: 0, False: 969]
  ------------------
  314|      0|      ++*this;
  315|      0|    }
  316|  2.90k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE9PredicateclEPKS6_PKS2_:
 1105|    969|    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_:
  882|    969|  [[nodiscard]] constexpr bool operator[](E pos) const {
  883|    969|    auto i = index_type::at(pos);
  884|    969|    return MAGIC_ENUM_ASSERT(i && *i < size()), static_cast<bool>(const_reference(this, *i));
  ------------------
  |  |   86|    969|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (884:12): [True: 969, False: 0]
  |  Branch (884:12): [True: 969, False: 0]
  |  Branch (884:12): [True: 969, False: 0]
  ------------------
  885|    969|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_m:
  644|    969|    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:
  646|    969|    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:
  666|    969|    [[nodiscard]] constexpr operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5emptyEv:
 1182|    969|  [[nodiscard]] constexpr bool empty() const noexcept { return s == 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE4sizeEv:
 1184|    969|  [[nodiscard]] constexpr size_type size() const noexcept { return s; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertEOS2_:
 1207|    969|  constexpr std::pair<iterator, bool> insert(value_type&& value) noexcept { return insert(value); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5clearEv:
 1188|    969|  constexpr void clear() noexcept {
 1189|    969|    a.reset();
 1190|    969|    s = 0;
 1191|    969|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5resetEv:
 1000|    969|  constexpr bitset& reset() noexcept { return *this = bitset{}; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEC2ENS3_12raw_access_tE:
  802|  2.90k|  constexpr explicit bitset(detail::raw_access_t = raw_access) noexcept : a{{}} {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3setES2_b:
  992|    969|  constexpr bitset& set(E pos, bool value = true) {
  993|    969|    if (auto i = index_type::at(pos); i && *i < size()) {
  ------------------
  |  Branch (993:39): [True: 969, False: 0]
  |  Branch (993:44): [True: 969, False: 0]
  ------------------
  994|    969|      reference{this, *i} = value;
  995|    969|      return *this;
  996|    969|    }
  997|      0|    MAGIC_ENUM_CONTAINERS_THROW(std::out_of_range("magic_enum::containers::bitset::set: Unrecognized position"));
  ------------------
  |  |   62|      0|#  define MAGIC_ENUM_CONTAINERS_THROW(...) throw (__VA_ARGS__)
  ------------------
  998|    969|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4sizeEv:
  953|  5.81k|  [[nodiscard]] constexpr std::size_t size() const noexcept { return enum_count<E>(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3allEv:
  925|    969|  [[nodiscard]] constexpr bool all() const noexcept {
  926|    969|    for (std::size_t i = 0; i + 1 < base_type_count; ++i) {
  ------------------
  |  Branch (926:29): [True: 0, False: 969]
  ------------------
  927|      0|      if (a[i] != (std::numeric_limits<base_type>::max)()) {
  ------------------
  |  Branch (927:11): [True: 0, False: 0]
  ------------------
  928|      0|        return false;
  929|      0|      }
  930|      0|    }
  931|    969|    return a[base_type_count - 1] == last_value_max;
  932|    969|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE3anyEv:
  934|  1.93k|  [[nodiscard]] constexpr bool any() const noexcept {
  935|  1.93k|    for (auto& v : a) {
  ------------------
  |  Branch (935:18): [True: 1.93k, False: 0]
  ------------------
  936|  1.93k|      if (v > 0) {
  ------------------
  |  Branch (936:11): [True: 1.93k, False: 0]
  ------------------
  937|  1.93k|        return true;
  938|  1.93k|      }
  939|  1.93k|    }
  940|      0|    return false;
  941|  1.93k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4noneEv:
  943|    969|  [[nodiscard]] constexpr bool none() const noexcept { return !any(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5countEv:
  945|    969|  [[nodiscard]] constexpr std::size_t count() const noexcept {
  946|    969|    std::size_t c = 0;
  947|    969|    for (auto& v : a) {
  ------------------
  |  Branch (947:18): [True: 969, False: 969]
  ------------------
  948|    969|      c += detail::popcount(v);
  949|    969|    }
  950|    969|    return c;
  951|    969|  }
_ZN10magic_enum10containers6detail8popcountIhEEmT_:
  115|    969|constexpr std::size_t popcount(T x) noexcept {
  116|       |#if defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
  117|       |  return static_cast<std::size_t>(std::popcount(x));
  118|       |#else
  119|    969|  std::size_t c = 0;
  120|  1.93k|  while (x > 0) {
  ------------------
  |  Branch (120:10): [True: 969, False: 969]
  ------------------
  121|    969|    x &= x - 1;
  122|    969|    ++c;
  123|    969|  }
  124|    969|  return c;
  125|    969|#endif
  126|    969|}

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