magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEENS7_8optionalIS6_EEE4typeENS_15underlying_typeIS5_E4typeE:
 1885|  3.12k|[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
 1886|  3.12k|  using D = std::decay_t<E>;
 1887|  3.12k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1888|       |
 1889|  3.12k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1890|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1891|       |    return detail::hash_switch_values<D, S, detail::case_call_t::value>(
 1892|       |        [](D v) { return optional<D>{v}; },
 1893|       |        value,
 1894|       |        detail::default_result_type_lambda<optional<D>>,
 1895|       |        [](D lhs, underlying_type_t<D> rhs) { return detail::enum_value_equal(lhs, rhs); });
 1896|       |#else
 1897|  25.0k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1897:29): [True: 21.8k, False: 3.12k]
  ------------------
 1898|  21.8k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1898:11): [True: 0, False: 21.8k]
  ------------------
 1899|      0|        return static_cast<D>(value);
 1900|      0|      }
 1901|  21.8k|    }
 1902|  3.12k|    return {}; // Invalid value or out of range.
 1903|  3.12k|#endif
 1904|       |  } else {
 1905|       |    if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
 1906|       |      return static_cast<D>(value);
 1907|       |    }
 1908|       |    return {}; // Invalid value or out of range.
 1909|       |  }
 1910|  3.12k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_u17__underlying_typeIS3_E:
  327|  21.8k|constexpr bool enum_value_equal(E lhs, std::underlying_type_t<E> rhs) noexcept {
  328|  21.8k|  return static_cast<std::underlying_type_t<E>>(lhs) == rhs;
  329|  21.8k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_valueIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEES6_E4typeEm:
 1731|  38.5k|[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
 1732|  38.5k|  using D = std::decay_t<E>;
 1733|  38.5k|  using U = underlying_type_t<D>;
 1734|  38.5k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1735|       |
 1736|  38.5k|  if constexpr (detail::is_sparse_v<D, S>) {
 1737|  38.5k|    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
  ------------------
  |  |   86|  38.5k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (1737:12): [True: 38.5k, False: 0]
  ------------------
 1738|       |  } else if constexpr (S == detail::enum_subtype::flags) {
 1739|       |    using V = detail::make_unsigned_t<U>;
 1740|       |    constexpr auto min = detail::log2(static_cast<V>(detail::min_v<D, S>));
 1741|       |
 1742|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1743|       |  } else {
 1744|       |    constexpr auto min = detail::min_v<D, S>;
 1745|       |
 1746|       |    return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
 1747|       |  }
 1748|  38.5k|}
magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0ENSt3__18equal_toIvEENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnNS4_9enable_ifIXsr6detailE15is_name_input_vIT2_EEiE4typeELi0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEsr3stdE16is_invocable_r_vIbRT1_RKcSN_EENS4_8optionalISJ_EEE4typeEOSE_SK_:
 1915|  2.08k|[[nodiscard]] constexpr auto enum_cast(String&& name, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable_v<BinaryPredicate> && std::is_nothrow_constructible_v<string_view, String>) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
 1916|  2.08k|  string_view value(std::forward<String>(name));
 1917|  2.08k|  using D = std::decay_t<E>;
 1918|  2.08k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1919|       |
 1920|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1921|       |  using hash_t = detail::constexpr_hash_t<string_view>;
 1922|       |  if constexpr (detail::is_default_predicate_v<BinaryPredicate> && detail::has_usable_hash_v<&detail::names_v<D, S>, hash_t>) {
 1923|       |    return detail::hash_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1924|       |        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1925|       |        value,
 1926|       |        detail::default_result_type_lambda<optional<D>>,
 1927|       |        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1928|       |  } else {
 1929|       |#endif
 1930|  16.6k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1930:29): [True: 14.5k, False: 2.07k]
  ------------------
 1931|  14.5k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1931:11): [True: 10, False: 14.5k]
  ------------------
 1932|     10|        return enum_value<D, S>(i);
 1933|     10|      }
 1934|  14.5k|    }
 1935|  2.07k|    return {}; // Invalid value or out of range.
 1936|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1937|       |  }
 1938|       |#endif
 1939|  2.08k|}
_ZN10magic_enum6detail9cmp_equalIRNSt3__18equal_toIvEEEEbNS2_17basic_string_viewIcNS2_11char_traitsIcEEEES9_OT_:
  488|  21.8k|constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable_v<BinaryPredicate>) {
  489|       |#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
  490|       |  // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
  491|       |  // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
  492|       |  constexpr bool workaround = true;
  493|       |#else
  494|  21.8k|  constexpr bool workaround = false;
  495|  21.8k|#endif
  496|       |
  497|       |  if constexpr (!is_default_predicate_v<BinaryPredicate> || workaround) {
  498|       |    if (lhs.size() != rhs.size()) {
  499|       |      return false;
  500|       |    }
  501|       |
  502|       |    const auto size = lhs.size();
  503|       |    for (std::size_t i = 0; i < size; ++i) {
  504|       |      if (!p(lhs[i], rhs[i])) {
  505|       |        return false;
  506|       |      }
  507|       |    }
  508|       |
  509|       |    return true;
  510|  21.8k|  } else {
  511|  21.8k|    return lhs == rhs;
  512|  21.8k|  }
  513|  21.8k|}
magic_enum_fuzzer.cc:_ZN10magic_enum12enum_entriesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEEDT9entries_vIS6_XT0_EEEE4typeEv:
 1872|  1.04k|[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
 1873|  1.04k|  using D = std::decay_t<E>;
 1874|  1.04k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1875|       |
 1876|  1.04k|  return detail::entries_v<D, S>;
 1877|  1.04k|}
magic_enum_fuzzer.cc:_ZN10magic_enum13enum_containsIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEEbE4typeENS_15underlying_typeIS5_E4typeE:
 1958|  2.08k|[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
 1959|  2.08k|  using D = std::decay_t<E>;
 1960|       |
 1961|  2.08k|  return static_cast<bool>(enum_cast<D, S>(value));
 1962|  2.08k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_namesIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEEDT7names_vIS6_XT0_EEEE4typeEv:
 1863|  1.04k|[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
 1864|  1.04k|  using D = std::decay_t<E>;
 1865|  1.04k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1866|       |
 1867|  1.04k|  return detail::names_v<D, S>;
 1868|  1.04k|}
magic_enum_fuzzer.cc:_ZN10magic_enum9enum_castIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0ENSt3__18equal_toIvEEPKcTnNS4_9enable_ifIXsr6detailE15is_name_input_vIT2_EEiE4typeELi0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEsr3stdE16is_invocable_r_vIbRT1_RS7_SI_EENS4_8optionalISF_EEE4typeEOSA_SG_:
 1915|  1.04k|[[nodiscard]] constexpr auto enum_cast(String&& name, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable_v<BinaryPredicate> && std::is_nothrow_constructible_v<string_view, String>) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
 1916|  1.04k|  string_view value(std::forward<String>(name));
 1917|  1.04k|  using D = std::decay_t<E>;
 1918|  1.04k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1919|       |
 1920|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1921|       |  using hash_t = detail::constexpr_hash_t<string_view>;
 1922|       |  if constexpr (detail::is_default_predicate_v<BinaryPredicate> && detail::has_usable_hash_v<&detail::names_v<D, S>, hash_t>) {
 1923|       |    return detail::hash_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
 1924|       |        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
 1925|       |        value,
 1926|       |        detail::default_result_type_lambda<optional<D>>,
 1927|       |        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
 1928|       |  } else {
 1929|       |#endif
 1930|  8.31k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1930:29): [True: 7.27k, False: 1.03k]
  ------------------
 1931|  7.27k|      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
  ------------------
  |  Branch (1931:11): [True: 4, False: 7.27k]
  ------------------
 1932|      4|        return enum_value<D, S>(i);
 1933|      4|      }
 1934|  7.27k|    }
 1935|  1.03k|    return {}; // Invalid value or out of range.
 1936|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1937|       |  }
 1938|       |#endif
 1939|  1.04k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_countIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEEmE4typeEv:
 1706|  7.29k|[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
 1707|  7.29k|  return detail::count_v<std::decay_t<E>, S>;
 1708|  7.29k|}
magic_enum_fuzzer.cc:_ZN10magic_enum10enum_indexIZ22LLVMFuzzerTestOneInputE8FuzzEnumLNS_6detail12enum_subtypeE0EEENS2_14enable_if_enumIXaasr3stdE9is_enum_vIu7__decayIT_EEL_ZNSt3__116is_invocable_r_vIbRNS7_8equal_toIvEEJRKcSD_EEEEENS7_8optionalImEEE4typeES5_:
 1784|  8.33k|[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
 1785|  8.33k|  using D = std::decay_t<E>;
 1786|  8.33k|  using U = underlying_type_t<D>;
 1787|  8.33k|  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 1788|       |
 1789|  8.33k|  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 1790|       |#if defined(MAGIC_ENUM_ENABLE_HASH)
 1791|       |    return detail::hash_switch_values<D, S, detail::case_call_t::index>(
 1792|       |        [](std::size_t i) { return optional<std::size_t>{i}; },
 1793|       |        value,
 1794|       |        detail::default_result_type_lambda<optional<std::size_t>>,
 1795|       |        [](D lhs, D rhs) { return detail::enum_value_equal(lhs, rhs); });
 1796|       |#else
 1797|  16.6k|    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
  ------------------
  |  Branch (1797:29): [True: 16.6k, False: 0]
  ------------------
 1798|  16.6k|      if (detail::enum_value_equal(enum_value<D, S>(i), value)) {
  ------------------
  |  Branch (1798:11): [True: 8.33k, False: 8.33k]
  ------------------
 1799|  8.33k|        return i;
 1800|  8.33k|      }
 1801|  16.6k|    }
 1802|      0|    return {}; // Invalid value or out of range.
 1803|  8.33k|#endif
 1804|       |  } else {
 1805|       |    const auto v = static_cast<U>(value);
 1806|       |    if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
 1807|       |      return static_cast<std::size_t>(v - detail::min_v<D, S>);
 1808|       |    }
 1809|       |    return {}; // Invalid value or out of range.
 1810|       |  }
 1811|  8.33k|}
magic_enum_fuzzer.cc:_ZN10magic_enum6detail16enum_value_equalIZ22LLVMFuzzerTestOneInputE8FuzzEnumEEbT_S3_:
  321|  16.6k|constexpr bool enum_value_equal(E lhs, E rhs) noexcept {
  322|  16.6k|  using U = std::underlying_type_t<E>;
  323|  16.6k|  return static_cast<U>(lhs) == static_cast<U>(rhs);
  324|  16.6k|}

magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEEC2ESt16initializer_listIS2_E:
 1149|  1.04k|  constexpr set(std::initializer_list<E> ilist) {
 1150|  2.08k|    for (auto e : ilist) {
  ------------------
  |  Branch (1150:17): [True: 2.08k, False: 1.04k]
  ------------------
 1151|  2.08k|      insert(e);
 1152|  2.08k|    }
 1153|  1.04k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEEC2ENS3_12raw_access_tE:
  817|  2.08k|  constexpr explicit bitset(detail::raw_access_t = raw_access) noexcept : a{{}} {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertERKS2_:
 1208|  3.12k|  constexpr std::pair<iterator, bool> insert(const value_type& value) noexcept {
 1209|  3.12k|    if (auto i = index_type::at(value)) {
  ------------------
  |  Branch (1209:14): [True: 3.12k, False: 0]
  ------------------
 1210|  3.12k|      auto ref = a[value];
 1211|  3.12k|      const bool res = !ref;
 1212|  3.12k|      if (res) {
  ------------------
  |  Branch (1212:11): [True: 3.12k, False: 0]
  ------------------
 1213|  3.12k|        ref = true;
 1214|  3.12k|        ++s;
 1215|  3.12k|      }
 1216|       |
 1217|  3.12k|      return {iterator{this, index_type::begin(), index_type::end(), index_type::it(*i)}, res};
 1218|  3.12k|    }
 1219|      0|    return {end(), false};
 1220|  3.12k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2atES3_:
  239|  7.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_:
  902|  3.12k|  [[nodiscard]] constexpr reference operator[](E pos) {
  903|  3.12k|    auto i = index_type::at(pos);
  904|  3.12k|    return MAGIC_ENUM_ASSERT(i && *i < size()), reference{this, *i};
  ------------------
  |  |   86|  3.12k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (904:12): [True: 3.12k, False: 0]
  |  Branch (904:12): [True: 3.12k, False: 0]
  |  Branch (904:12): [True: 3.12k, False: 0]
  ------------------
  905|  3.12k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE4sizeEv:
  968|  4.16k|  [[nodiscard]] constexpr std::size_t size() const noexcept { return enum_count<E>(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_m:
  659|  3.12k|    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:
  642|  4.16k|  [[nodiscard]] static constexpr base_type bit_mask(std::size_t index) noexcept {
  643|  4.16k|    return static_cast<base_type>(base_type{1} << (index % bits_per_base));
  644|  4.16k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPS9_EC2ESB_mh:
  661|  3.12k|    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:
  681|  3.12k|    [[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:
  664|  3.12k|    constexpr reference_impl& operator=(bool v) noexcept {
  665|  3.12k|      if (v) {
  ------------------
  |  Branch (665:11): [True: 3.12k, False: 0]
  ------------------
  666|  3.12k|        parent->a[num_index] |= bit_index;
  667|  3.12k|      } else {
  668|      0|        parent->a[num_index] &= ~bit_index;
  669|      0|      }
  670|  3.12k|      return *this;
  671|  3.12k|    }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE5beginEv:
  233|  3.12k|  [[nodiscard]] static constexpr const E* begin() noexcept { return values.data(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE3endEv:
  235|  3.12k|  [[nodiscard]] static constexpr const E* end() noexcept { return values.data() + values.size(); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS3_EEvE2itEm:
  237|  3.12k|  [[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_:
  327|  3.12k|      : parent(p), first(std::move(begin)), last(std::move(end)), current(std::move(curr)), getter{std::move(get)}, predicate{std::move(pred)} {
  328|  3.12k|    if (current == first && !predicate(parent, current)) {
  ------------------
  |  Branch (328:9): [True: 1.04k, False: 2.08k]
  |  Branch (328:29): [True: 0, False: 1.04k]
  ------------------
  329|      0|      ++*this;
  330|      0|    }
  331|  3.12k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE9PredicateclEPKS6_PKS2_:
 1120|  1.04k|    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_:
  897|  1.04k|  [[nodiscard]] constexpr bool operator[](E pos) const {
  898|  1.04k|    auto i = index_type::at(pos);
  899|  1.04k|    return MAGIC_ENUM_ASSERT(i && *i < size()), static_cast<bool>(const_reference(this, *i));
  ------------------
  |  |   86|  1.04k|#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
  ------------------
  |  Branch (899:12): [True: 1.04k, False: 0]
  |  Branch (899:12): [True: 1.04k, False: 0]
  |  Branch (899:12): [True: 1.04k, False: 0]
  ------------------
  900|  1.04k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE14reference_implIPKS9_EC2ESC_m:
  659|  1.04k|    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:
  661|  1.04k|    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:
  681|  1.04k|    [[nodiscard]] constexpr operator bool() const noexcept { return (parent->a[num_index] & bit_index) > 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5emptyEv:
 1197|  1.04k|  [[nodiscard]] constexpr bool empty() const noexcept { return s == 0; }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE4sizeEv:
 1199|  1.04k|  [[nodiscard]] constexpr size_type size() const noexcept { return s; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE6insertEOS2_:
 1222|  1.04k|  constexpr std::pair<iterator, bool> insert(value_type&& value) noexcept { return insert(value); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers3setIZ22LLVMFuzzerTestOneInputE8FuzzEnumNSt3__14lessIS2_EEE5clearEv:
 1203|  1.04k|  constexpr void clear() noexcept {
 1204|  1.04k|    a.reset();
 1205|  1.04k|    s = 0;
 1206|  1.04k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_NSt3__14lessIS2_EEvEEE5resetEv:
 1015|  1.04k|  constexpr bitset& reset() noexcept { return *this = bitset{}; }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEEC2ENS3_12raw_access_tE:
  817|  1.04k|  constexpr explicit bitset(detail::raw_access_t = raw_access) noexcept : a{{}} {}
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE3setES2_b:
 1007|  1.04k|  constexpr bitset& set(E pos, bool value = true) {
 1008|  1.04k|    if (auto i = index_type::at(pos); i && *i < size()) {
  ------------------
  |  Branch (1008:39): [True: 1.04k, False: 0]
  |  Branch (1008:44): [True: 1.04k, False: 0]
  ------------------
 1009|  1.04k|      reference{this, *i} = value;
 1010|  1.04k|      return *this;
 1011|  1.04k|    }
 1012|      0|    MAGIC_ENUM_CONTAINERS_THROW(std::out_of_range("magic_enum::containers::bitset::set: Unrecognized position"));
  ------------------
  |  |   63|      0|#  define MAGIC_ENUM_CONTAINERS_THROW(...) throw (__VA_ARGS__)
  ------------------
 1013|  1.04k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6detail8indexingIZ22LLVMFuzzerTestOneInputE8FuzzEnumvvE2atES3_:
  239|  1.04k|  [[nodiscard]] static constexpr optional<std::size_t> at(E val) noexcept { return enum_index(val); }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE14reference_implIPS6_EC2ES8_m:
  659|  1.04k|    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_vvEEE8bit_maskEm:
  642|  1.04k|  [[nodiscard]] static constexpr base_type bit_mask(std::size_t index) noexcept {
  643|  1.04k|    return static_cast<base_type>(base_type{1} << (index % bits_per_base));
  644|  1.04k|  }
magic_enum_fuzzer.cc:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE14reference_implIPS6_EC2ES8_mh:
  661|  1.04k|    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:_ZN10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE14reference_implIPS6_EaSEb:
  664|  1.04k|    constexpr reference_impl& operator=(bool v) noexcept {
  665|  1.04k|      if (v) {
  ------------------
  |  Branch (665:11): [True: 1.04k, False: 0]
  ------------------
  666|  1.04k|        parent->a[num_index] |= bit_index;
  667|  1.04k|      } else {
  668|      0|        parent->a[num_index] &= ~bit_index;
  669|      0|      }
  670|  1.04k|      return *this;
  671|  1.04k|    }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE4sizeEv:
  968|  2.08k|  [[nodiscard]] constexpr std::size_t size() const noexcept { return enum_count<E>(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE3allEv:
  940|  1.04k|  [[nodiscard]] constexpr bool all() const noexcept {
  941|  1.04k|    for (std::size_t i = 0; i + 1 < base_type_count; ++i) {
  ------------------
  |  Branch (941:29): [True: 0, False: 1.04k]
  ------------------
  942|      0|      if (a[i] != (std::numeric_limits<base_type>::max)()) {
  ------------------
  |  Branch (942:11): [True: 0, False: 0]
  ------------------
  943|      0|        return false;
  944|      0|      }
  945|      0|    }
  946|  1.04k|    return a[base_type_count - 1] == last_value_max;
  947|  1.04k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE3anyEv:
  949|  2.08k|  [[nodiscard]] constexpr bool any() const noexcept {
  950|  2.08k|    for (auto& v : a) {
  ------------------
  |  Branch (950:18): [True: 2.08k, False: 0]
  ------------------
  951|  2.08k|      if (v > 0) {
  ------------------
  |  Branch (951:11): [True: 2.08k, False: 0]
  ------------------
  952|  2.08k|        return true;
  953|  2.08k|      }
  954|  2.08k|    }
  955|      0|    return false;
  956|  2.08k|  }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE4noneEv:
  958|  1.04k|  [[nodiscard]] constexpr bool none() const noexcept { return !any(); }
magic_enum_fuzzer.cc:_ZNK10magic_enum10containers6bitsetIZ22LLVMFuzzerTestOneInputE8FuzzEnumNS0_6detail8indexingIS2_vvEEE5countEv:
  960|  1.04k|  [[nodiscard]] constexpr std::size_t count() const noexcept {
  961|  1.04k|    std::size_t c = 0;
  962|  1.04k|    for (auto& v : a) {
  ------------------
  |  Branch (962:18): [True: 1.04k, False: 1.04k]
  ------------------
  963|  1.04k|      c += detail::popcount(v);
  964|  1.04k|    }
  965|  1.04k|    return c;
  966|  1.04k|  }
_ZN10magic_enum10containers6detail8popcountIhEEmT_:
  116|  1.04k|constexpr std::size_t popcount(T x) noexcept {
  117|       |#if defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
  118|       |  return static_cast<std::size_t>(std::popcount(x));
  119|       |#else
  120|  1.04k|  std::size_t c = 0;
  121|  2.08k|  while (x > 0) {
  ------------------
  |  Branch (121:10): [True: 1.04k, False: 1.04k]
  ------------------
  122|  1.04k|    x &= x - 1;
  123|  1.04k|    ++c;
  124|  1.04k|  }
  125|  1.04k|  return c;
  126|  1.04k|#endif
  127|  1.04k|}

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