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:
 1851|  3.11k|[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
 1852|  3.11k|  using D = std::decay_t<E>;
 1853|  3.11k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1854|       |
 1855|  3.11k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1856|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1857|       |    return detail::hash_switch_values<D, S, detail::case_call_t::value>(
 1858|       |        [](D v) { return optional<D>{v}; },
 1859|       |        value,
 1860|       |        detail::default_result_type_lambda<optional<D>>,
 1861|       |        [](D lhs, underlying_type_t<D> rhs) { return detail::enum_value_equal(lhs, rhs); });
 1862|       |#else
 1863|  24.8k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1863:29): [True: 21.7k, False: 3.11k]
  ------------------
 1864|  21.7k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1864:11): [True: 0, False: 21.7k]
  ------------------
 1865|      0|        return static_cast<D>(value);
 1866|      0|      }
 1867|  21.7k|    }
 1868|  3.11k|    return {}; // Invalid value or out of range.
 1869|  3.11k|#endif
 1870|       |  } else {
 1871|       |    if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
 1872|       |      return static_cast<D>(value);
 1873|       |    }
 1874|       |    return {}; // Invalid value or out of range.
 1875|       |  }
 1876|  3.11k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_u17__underlying_typeIS3_E:
  327|  21.7k|constexpr bool enum_value_equal(E lhs, std::underlying_type_t<E> rhs) noexcept {
  328|  21.7k|  return static_cast<std::underlying_type_t<E>>(lhs) == rhs;
  329|  21.7k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_valueIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJccEEEEES6_E4typeEm:
 1697|  38.3k|[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
 1698|  38.3k|  using D = std::decay_t<E>;
 1699|  38.3k|  using U = underlying_type_t<D>;
 1700|  38.3k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1701|       |
 1702|  38.3k|  if constexpr (detail::is_sparse_v<D, S>) {
 1703|  38.3k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
  ------------------
  |  |   86|  38.3k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (1703:12): [True: 38.3k, False: 0]
  ------------------
 1704|       |  } else if constexpr (S == detail::enum_subtype::flags) {
 1705|       |    using V = detail::make_unsigned_t<U>;
 1706|       |    constexpr auto min = detail::log2(static_cast<V>(detail::min_v<D, S>));
 1707|       |
 1708|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1709|       |  } else {
 1710|       |    constexpr auto min = detail::min_v<D, S>;
 1711|       |
 1712|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1713|       |  }
 1714|  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_:
 1881|  3.11k|[[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> {
 1882|  3.11k|  using D = std::decay_t<E>;
 1883|  3.11k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1884|       |
 1885|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1886|       |  using hash_t = detail::constexpr_hash_t<string_view>;
 1887|       |  if constexpr (detail::is_default_predicate_v<BinaryPredicate> && detail::has_usable_hash_v<&detail::names_v<D, S>, hash_t>) {
 1888|       |    return detail::hash_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1889|       |        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1890|       |        value,
 1891|       |        detail::default_result_type_lambda<optional<D>>,
 1892|       |        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1893|       |  } else {
 1894|       |#endif
 1895|  24.8k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1895:29): [True: 21.7k, False: 3.09k]
  ------------------
 1896|  21.7k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1896:11): [True: 15, False: 21.6k]
  ------------------
 1897|     15|        return enum_value<D, S>(i);
 1898|     15|      }
 1899|  21.7k|    }
 1900|  3.09k|    return {}; // Invalid value or out of range.
 1901|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1902|       |  }
 1903|       |#endif
 1904|  3.11k|}
_ZN10magic_enum6detail9cmp_equalIRNSt3__18equal_toIvEEEEbNS2_17basic_string_viewIcNS2_11char_traitsIcEEEES9_OT_:
  485|  21.7k|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|  21.7k|  constexpr bool workaround = false;
  492|  21.7k|#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|  21.7k|  } else {
  508|  21.7k|    return lhs == rhs;
  509|  21.7k|  }
  510|  21.7k|}
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:
 1838|  1.03k|[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
 1839|  1.03k|  using D = std::decay_t<E>;
 1840|  1.03k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1841|       |
 1842|  1.03k|  return detail::entries_v<D, S>;
 1843|  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:
 1923|  2.07k|[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
 1924|  2.07k|  using D = std::decay_t<E>;
 1925|       |
 1926|  2.07k|  return static_cast<bool>(enum_cast<D, S>(value));
 1927|  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:
 1829|  1.03k|[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
 1830|  1.03k|  using D = std::decay_t<E>;
 1831|  1.03k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1832|       |
 1833|  1.03k|  return detail::names_v<D, S>;
 1834|  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:
 1690|  7.25k|[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
 1691|  7.25k|  return detail::count_v<std::decay_t<E>, S>;
 1692|  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_:
 1750|  8.29k|[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
 1751|  8.29k|  using D = std::decay_t<E>;
 1752|  8.29k|  using U = underlying_type_t<D>;
 1753|  8.29k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1754|       |
 1755|  8.29k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1756|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1757|       |    return detail::hash_switch_values<D, S, detail::case_call_t::index>(
 1758|       |        [](std::size_t i) { return optional<std::size_t>{i}; },
 1759|       |        value,
 1760|       |        detail::default_result_type_lambda<optional<std::size_t>>,
 1761|       |        [](D lhs, D rhs) { return detail::enum_value_equal(lhs, rhs); });
 1762|       |#else
 1763|  16.5k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1763:29): [True: 16.5k, False: 0]
  ------------------
 1764|  16.5k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1764:11): [True: 8.29k, False: 8.29k]
  ------------------
 1765|  8.29k|        return i;
 1766|  8.29k|      }
 1767|  16.5k|    }
 1768|      0|    return {}; // Invalid value or out of range.
 1769|  8.29k|#endif
 1770|       |  } else {
 1771|       |    const auto v = static_cast<U>(value);
 1772|       |    if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
 1773|       |      return static_cast<std::size_t>(v - detail::min_v<D, S>);
 1774|       |    }
 1775|       |    return {}; // Invalid value or out of range.
 1776|       |  }
 1777|  8.29k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_S3_:
  321|  16.5k|constexpr bool enum_value_equal(E lhs, E rhs) noexcept {
  322|  16.5k|  using U = std::underlying_type_t<E>;
  323|  16.5k|  return static_cast<U>(lhs) == static_cast<U>(rhs);
  324|  16.5k|}

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