diff --git a/.github/workflows/ci_linux_arm.yml b/.github/workflows/ci_linux_arm.yml
index d9230349..454044f3 100644
--- a/.github/workflows/ci_linux_arm.yml
+++ b/.github/workflows/ci_linux_arm.yml
@@ -41,7 +41,7 @@ jobs:
                       apt-get -y install qtbase5-dev libqt5svg5-dev
                       apt-get -y install libxcb-cursor0  # Dependencies for "xcb" Qt plugin(actually needed for Qt6)
                       apt-get -y install libocct-data-exchange-dev libocct-draw-dev occt-misc
-                      apt-get -y install libtbb2-dev libxi-dev  # Dependencies for OpenCascade v7.5
+                      apt-get -y install libtbb-dev libxi-dev  # Dependencies for OpenCascade
                       apt-get -y install libassimp-dev
                       ;;
                   fedora*)
diff --git a/.github/workflows/ci_macos.yml b/.github/workflows/ci_macos.yml
index 7234961a..b74f3c2d 100644
--- a/.github/workflows/ci_macos.yml
+++ b/.github/workflows/ci_macos.yml
@@ -11,18 +11,13 @@ jobs:
           uses: actions/checkout@v2
 
         - name: Install Qt
-          uses: jurplel/install-qt-action@v3
-          with:
-              cache: true
-              cache-key-prefix: QtCache
+          run: brew install qt@5
 
         - name: Install OpenCascade
-          run: |
-              brew install opencascade
+          run: brew install opencascade
 
         - name: Install Assimp
-          run: |
-              brew install assimp
+          run: brew install assimp
 
         - name: Get count of CPU cores
           uses: SimenB/github-actions-cpu-cores@v1
@@ -35,7 +30,8 @@ jobs:
               cmake --version
               cmake .. \
                     -DMayo_BuildTests=ON \
-                    -DMayo_BuildPluginAssimp=ON
+                    -DMayo_BuildPluginAssimp=ON \
+                    -DQT_DIR=$(brew --prefix qt5)/lib/cmake/Qt5
               cmake --build . \
                     --config Release \
                     --parallel ${{steps.cpu-cores.outputs.count}}
diff --git a/.github/workflows/ci_windows.yml b/.github/workflows/ci_windows.yml
index 78527c47..83fac0a8 100644
--- a/.github/workflows/ci_windows.yml
+++ b/.github/workflows/ci_windows.yml
@@ -83,6 +83,7 @@ jobs:
               cmake .. ^
                     -DMayo_BuildTests=ON ^
                     -DMayo_BuildPluginAssimp=ON ^
+                    -DMayo_PostBuildCopyRuntimeDLLs=ON ^
                     -DOpenCASCADE_DIR=../OpenCASCADE-${{matrix.occ_version}}-vc14-64/opencascade-${{matrix.occ_version}} ^
                     -Dassimp_DIR=${{github.workspace}}/assimp-5.3.1/lib/cmake/assimp-5.3
               cmake --build . ^
@@ -93,7 +94,5 @@ jobs:
           working-directory: ${{github.workspace}}/build
           shell: cmd
           run: |
-              call ..\OpenCASCADE-${{matrix.occ_version}}-vc14-64\opencascade-${{matrix.occ_version}}\env.bat
-              set PATH=${{github.workspace}}\assimp-5.3.1\bin;%PATH%
               release\mayo.exe --runtests -o utests-output.txt
               more utests-output.txt
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5e0558b8..c5449b89 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -300,10 +300,16 @@ endif()
 if(OpenCASCADE_FOUND)
     message(STATUS "OpenCascade version ${OpenCASCADE_VERSION}")
 
-    # Silent warnings C4996 and STL4015: the std::iterator class template(used as a base class to
-    # provide typedefs) is deprecated in C++17
-    if(MSVC AND OpenCASCADE_VERSION VERSION_LESS 7.7.0)
-        list(APPEND Mayo_CompileDefinitions _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)
+    # std::iterator class template(used as a base class to provide typedefs) is deprecated in C++17
+    # OpenCascade < 7.7.0 uses std::iterator for NCollection_StlIterator and this is causing many
+    # deprecation warnings
+    if(OpenCASCADE_VERSION VERSION_LESS 7.7.0)
+        if(MSVC)
+            # Silent warnings C4996 and STL4015
+            list(APPEND Mayo_CompileDefinitions _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)
+        elseif((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12))
+            list(APPEND Mayo_CompileOptions -Wno-deprecated-declarations)
+        endif()
     endif()
 
     # Add OpenCASCADE libraries
diff --git a/src/3rdparty/commit_magic_enum.txt b/src/3rdparty/commit_magic_enum.txt
index d5682268..80ff3874 100644
--- a/src/3rdparty/commit_magic_enum.txt
+++ b/src/3rdparty/commit_magic_enum.txt
@@ -1 +1 @@
-caa2f9e6ef882671bc8be84dd98a225ad12d62bf
\ No newline at end of file
+ec11ae0c285773e691a1e8372e4984189a6bed1e
diff --git a/src/3rdparty/magic_enum/magic_enum.hpp b/src/3rdparty/magic_enum/magic_enum.hpp
index ac163058..d3c3ab64 100644
--- a/src/3rdparty/magic_enum/magic_enum.hpp
+++ b/src/3rdparty/magic_enum/magic_enum.hpp
@@ -5,11 +5,11 @@
 // | |  | | (_| | (_| | | (__  | |____| | | | |_| | | | | | | | |____|_|   |_|
 // |_|  |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_|  \_____|
 //                __/ | https://github.com/Neargye/magic_enum
-//               |___/  version 0.7.0
+//               |___/  version 0.9.5
 //
 // Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 // SPDX-License-Identifier: MIT
-// Copyright (c) 2019 - 2020 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
 //
 // Permission is hereby  granted, free of charge, to any  person obtaining a copy
 // of this software and associated  documentation files (the "Software"), to deal
@@ -33,40 +33,57 @@
 #define NEARGYE_MAGIC_ENUM_HPP
 
 #define MAGIC_ENUM_VERSION_MAJOR 0
-#define MAGIC_ENUM_VERSION_MINOR 7
-#define MAGIC_ENUM_VERSION_PATCH 0
+#define MAGIC_ENUM_VERSION_MINOR 9
+#define MAGIC_ENUM_VERSION_PATCH 5
 
 #include <array>
-#include <cassert>
-#include <cstdint>
 #include <cstddef>
-#include <iosfwd>
+#include <cstdint>
+#include <functional>
 #include <limits>
 #include <type_traits>
 #include <utility>
 
+#if defined(MAGIC_ENUM_CONFIG_FILE)
+#  include MAGIC_ENUM_CONFIG_FILE
+#endif
+
 #if !defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL)
-#include <optional>
+#  include <optional>
 #endif
 #if !defined(MAGIC_ENUM_USING_ALIAS_STRING)
-#include <string>
+#  include <string>
 #endif
 #if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW)
-#include <string_view>
+#  include <string_view>
+#endif
+
+#if defined(MAGIC_ENUM_NO_ASSERT)
+#  define MAGIC_ENUM_ASSERT(...) static_cast<void>(0)
+#elif !defined(MAGIC_ENUM_ASSERT)
+#  include <cassert>
+#  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
 #endif
 
 #if defined(__clang__)
 #  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wunknown-warning-option"
+#  pragma clang diagnostic ignored "-Wenum-constexpr-conversion"
+#  pragma clang diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast<char_type>('\0')' for char_type = char (common on Linux).
 #elif defined(__GNUC__)
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'.
+#  pragma GCC diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast<char_type>('\0')' for char_type = char (common on Linux).
 #elif defined(_MSC_VER)
 #  pragma warning(push)
-#  pragma warning(disable : 26495) // Variable 'static_string<N>::chars' is uninitialized.
+#  pragma warning(disable : 26495) // Variable 'static_str<N>::chars_' is uninitialized.
+#  pragma warning(disable : 28020) // Arithmetic overflow: Using operator '-' on a 4 byte value and then casting the result to a 8 byte value.
+#  pragma warning(disable : 26451) // The expression '0<=_Param_(1)&&_Param_(1)<=1-1' is not true at this call.
+#  pragma warning(disable : 4514) // Unreferenced inline function has been removed.
 #endif
 
 // Checks magic_enum compiler compatibility.
-#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1910
+#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1910 || defined(__RESHARPER__)
 #  undef  MAGIC_ENUM_SUPPORTED
 #  define MAGIC_ENUM_SUPPORTED 1
 #endif
@@ -86,7 +103,20 @@
 // Enum value must be less or equals than MAGIC_ENUM_RANGE_MAX. By default MAGIC_ENUM_RANGE_MAX = 128.
 // If need another max range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MAX.
 #if !defined(MAGIC_ENUM_RANGE_MAX)
-#  define MAGIC_ENUM_RANGE_MAX 128
+#  define MAGIC_ENUM_RANGE_MAX 127
+#endif
+
+// Improve ReSharper C++ intellisense performance with builtins, avoiding unnecessary template instantiations.
+#if defined(__RESHARPER__)
+#  undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN
+#  undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN
+#  if __RESHARPER__ >= 20230100
+#    define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) __rscpp_enumerator_name(V)
+#    define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) __rscpp_type_name<T>()
+#  else
+#    define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) nullptr
+#    define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) nullptr
+#  endif
 #endif
 
 namespace magic_enum {
@@ -95,24 +125,40 @@ namespace magic_enum {
 #if defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL)
 MAGIC_ENUM_USING_ALIAS_OPTIONAL
 #else
-template <typename T>
-using optional = std::optional<T>;
+using std::optional;
 #endif
 
-// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW.
+// If need another string_view type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW.
 #if defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW)
-MAGIC_ENUM_USING_ALIAS_STRING_VIEW
+    MAGIC_ENUM_USING_ALIAS_STRING_VIEW
 #else
-using string_view = std::string_view;
+using std::string_view;
 #endif
 
-// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_STRING.
+// If need another string type, define the macro MAGIC_ENUM_USING_ALIAS_STRING.
 #if defined(MAGIC_ENUM_USING_ALIAS_STRING)
-MAGIC_ENUM_USING_ALIAS_STRING
+        MAGIC_ENUM_USING_ALIAS_STRING
 #else
-using string = std::string;
+using std::string;
 #endif
 
+    using char_type = string_view::value_type;
+static_assert(std::is_same_v<string_view::value_type, string::value_type>, "magic_enum::customize requires same string_view::value_type and string::value_type");
+static_assert([] {
+    if constexpr (std::is_same_v<char_type, wchar_t>) {
+        constexpr const char     c[] =  "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|";
+        constexpr const wchar_t wc[] = L"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|";
+        static_assert(std::size(c) == std::size(wc), "magic_enum::customize identifier characters are multichars in wchar_t.");
+
+        for (std::size_t i = 0; i < std::size(c); ++i) {
+            if (c[i] != wc[i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+} (), "magic_enum::customize wchar_t is not compatible with ASCII.");
+
 namespace customize {
 
 // Enum value must be in range [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]. By default MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 128.
@@ -120,26 +166,46 @@ namespace customize {
 // If need another range for specific enum type, add specialization enum_range for necessary enum type.
 template <typename E>
 struct enum_range {
-  static_assert(std::is_enum_v<E>, "magic_enum::customize::enum_range requires enum type.");
-  inline static constexpr int min = MAGIC_ENUM_RANGE_MIN;
-  inline static constexpr int max = MAGIC_ENUM_RANGE_MAX;
-  static_assert(max > min, "magic_enum::customize::enum_range requires max > min.");
+    static constexpr int min = MAGIC_ENUM_RANGE_MIN;
+    static constexpr int max = MAGIC_ENUM_RANGE_MAX;
 };
 
-static_assert(MAGIC_ENUM_RANGE_MIN <= 0, "MAGIC_ENUM_RANGE_MIN must be less or equals than 0.");
-static_assert(MAGIC_ENUM_RANGE_MIN > (std::numeric_limits<std::int16_t>::min)(), "MAGIC_ENUM_RANGE_MIN must be greater than INT16_MIN.");
+static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN.");
+
+namespace detail {
 
-static_assert(MAGIC_ENUM_RANGE_MAX > 0, "MAGIC_ENUM_RANGE_MAX must be greater than 0.");
-static_assert(MAGIC_ENUM_RANGE_MAX < (std::numeric_limits<std::int16_t>::max)(), "MAGIC_ENUM_RANGE_MAX must be less than INT16_MAX.");
+enum class customize_tag {
+    default_tag,
+    invalid_tag,
+    custom_tag
+};
 
-static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN.");
+} // namespace magic_enum::customize::detail
 
-// If need cunstom names for enum type, add specialization enum_name for necessary enum type.
+class customize_t : public std::pair<detail::customize_tag, string_view> {
+public:
+    constexpr customize_t(string_view srt) : std::pair<detail::customize_tag, string_view>{detail::customize_tag::custom_tag, srt} {}
+    constexpr customize_t(const char_type* srt) : customize_t{string_view{srt}} {}
+    constexpr customize_t(detail::customize_tag tag) : std::pair<detail::customize_tag, string_view>{tag, string_view{}} {
+        MAGIC_ENUM_ASSERT(tag != detail::customize_tag::custom_tag);
+    }
+};
+
+// Default customize.
+inline constexpr auto default_tag = customize_t{detail::customize_tag::default_tag};
+// Invalid customize.
+inline constexpr auto invalid_tag = customize_t{detail::customize_tag::invalid_tag};
+
+// If need custom names for enum, add specialization enum_name for necessary enum type.
 template <typename E>
-constexpr string_view enum_name(E) noexcept {
-  static_assert(std::is_enum_v<E>, "magic_enum::customize::enum_name requires enum type.");
+constexpr customize_t enum_name(E) noexcept {
+    return default_tag;
+}
 
-  return {};
+// If need custom type name for enum, add specialization enum_type_name for necessary enum type.
+template <typename E>
+constexpr customize_t enum_type_name() noexcept {
+    return default_tag;
 }
 
 } // namespace magic_enum::customize
@@ -154,422 +220,675 @@ struct supported
     : std::false_type {};
 #endif
 
-template <std::size_t N>
-struct static_string {
-  constexpr explicit static_string(string_view str) noexcept : static_string{str, std::make_index_sequence<N>{}} {
-    assert(str.size() == N);
-  }
+template <auto V, typename E = std::decay_t<decltype(V)>, std::enable_if_t<std::is_enum_v<E>, int> = 0>
+using enum_constant = std::integral_constant<E, V>;
+
+template <typename... T>
+inline constexpr bool always_false_v = false;
+
+template <typename T, typename = void>
+struct has_is_flags : std::false_type {};
+
+template <typename T>
+struct has_is_flags<T, std::void_t<decltype(customize::enum_range<T>::is_flags)>> : std::bool_constant<std::is_same_v<bool, std::decay_t<decltype(customize::enum_range<T>::is_flags)>>> {};
 
-  constexpr const char* data() const noexcept { return chars.data(); }
+template <typename T, typename = void>
+struct range_min : std::integral_constant<int, MAGIC_ENUM_RANGE_MIN> {};
 
-  constexpr std::size_t size() const noexcept { return N; }
+template <typename T>
+struct range_min<T, std::void_t<decltype(customize::enum_range<T>::min)>> : std::integral_constant<decltype(customize::enum_range<T>::min), customize::enum_range<T>::min> {};
 
-  constexpr operator string_view() const noexcept { return {data(), size()}; }
+template <typename T, typename = void>
+struct range_max : std::integral_constant<int, MAGIC_ENUM_RANGE_MAX> {};
 
- private:
-  template <std::size_t... I>
-  constexpr static_string(string_view str, std::index_sequence<I...>) noexcept : chars{{str[I]..., '\0'}} {}
+template <typename T>
+struct range_max<T, std::void_t<decltype(customize::enum_range<T>::max)>> : std::integral_constant<decltype(customize::enum_range<T>::max), customize::enum_range<T>::max> {};
 
-  const std::array<char, N + 1> chars;
+struct str_view {
+    const char* str_ = nullptr;
+    std::size_t size_ = 0;
 };
 
-template <>
-struct static_string<0> {
-  constexpr explicit static_string(string_view) noexcept {}
+template <std::uint16_t N>
+class static_str {
+public:
+    constexpr explicit static_str(str_view str) noexcept : static_str{str.str_, std::make_integer_sequence<std::uint16_t, N>{}} {
+        MAGIC_ENUM_ASSERT(str.size_ == N);
+    }
+
+    constexpr explicit static_str(string_view str) noexcept : static_str{str.data(), std::make_integer_sequence<std::uint16_t, N>{}} {
+        MAGIC_ENUM_ASSERT(str.size() == N);
+    }
 
-  constexpr const char* data() const noexcept { return nullptr; }
+    constexpr const char_type* data() const noexcept { return chars_; }
 
-  constexpr std::size_t size() const noexcept { return 0; }
+    constexpr std::uint16_t size() const noexcept { return N; }
 
-  constexpr operator string_view() const noexcept { return {}; }
+    constexpr operator string_view() const noexcept { return {data(), size()}; }
+
+private:
+    template <std::uint16_t... I>
+    constexpr static_str(const char* str, std::integer_sequence<std::uint16_t, I...>) noexcept : chars_{static_cast<char_type>(str[I])..., static_cast<char_type>('\0')} {}
+
+    template <std::uint16_t... I>
+    constexpr static_str(string_view str, std::integer_sequence<std::uint16_t, I...>) noexcept : chars_{str[I]..., static_cast<char_type>('\0')} {}
+
+    char_type chars_[static_cast<std::size_t>(N) + 1];
 };
 
-struct char_equal_to {
-  constexpr bool operator()(char lhs, char rhs) const noexcept {
-    return lhs == rhs;
-  }
+template <>
+class static_str<0> {
+public:
+    constexpr explicit static_str() = default;
+
+    constexpr explicit static_str(str_view) noexcept {}
+
+    constexpr explicit static_str(string_view) noexcept {}
+
+    constexpr const char_type* data() const noexcept { return nullptr; }
+
+    constexpr std::uint16_t size() const noexcept { return 0; }
+
+    constexpr operator string_view() const noexcept { return {}; }
 };
 
-constexpr string_view pretty_name(string_view name) noexcept {
-  for (std::size_t i = name.size(); i > 0; --i) {
-    if (!((name[i - 1] >= '0' && name[i - 1] <= '9') ||
-          (name[i - 1] >= 'a' && name[i - 1] <= 'z') ||
-          (name[i - 1] >= 'A' && name[i - 1] <= 'Z') ||
-          (name[i - 1] == '_'))) {
-      name.remove_prefix(i);
-      break;
+template <typename Op = std::equal_to<>>
+class case_insensitive {
+    static constexpr char_type to_lower(char_type c) noexcept {
+        return (c >= static_cast<char_type>('A') && c <= static_cast<char_type>('Z')) ? static_cast<char_type>(c + (static_cast<char_type>('a') - static_cast<char_type>('A'))) : c;
     }
-  }
-
-  if (name.size() > 0 && ((name.front() >= 'a' && name.front() <= 'z') ||
-                          (name.front() >= 'A' && name.front() <= 'Z') ||
-                          (name.front() == '_'))) {
-    return name;
-  }
 
-  return {}; // Invalid name.
-}
+public:
+    template <typename L, typename R>
+    constexpr auto operator()(L lhs, R rhs) const noexcept -> std::enable_if_t<std::is_same_v<std::decay_t<L>, char_type> && std::is_same_v<std::decay_t<R>, char_type>, bool> {
+        return Op{}(to_lower(lhs), to_lower(rhs));
+    }
+};
 
-constexpr std::size_t find(string_view str, char c) noexcept {
-#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || defined(_MSC_VER) && _MSC_VER < 1920
-// https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc
-// https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
-  constexpr auto workaroung = true;
+constexpr std::size_t find(string_view str, char_type c) noexcept {
+#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
+    // https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc
+    // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
+    constexpr bool workaround = true;
 #else
-  constexpr auto workaroung = false;
+    constexpr bool workaround = false;
 #endif
-  if constexpr (workaroung) {
-    for (std::size_t i = 0; i < str.size(); ++i) {
-      if (str[i] == c) {
-        return i;
-      }
+
+    if constexpr (workaround) {
+        for (std::size_t i = 0; i < str.size(); ++i) {
+            if (str[i] == c) {
+                return i;
+            }
+        }
+
+        return string_view::npos;
+    } else {
+        return str.find(c);
     }
+}
+
+template <typename BinaryPredicate>
+constexpr bool is_default_predicate() noexcept {
+    return std::is_same_v<std::decay_t<BinaryPredicate>, std::equal_to<string_view::value_type>> ||
+           std::is_same_v<std::decay_t<BinaryPredicate>, std::equal_to<>>;
+}
 
-    return string_view::npos;
-  } else {
-    return str.find_first_of(c);
-  }
+template <typename BinaryPredicate>
+constexpr bool is_nothrow_invocable() {
+    return is_default_predicate<BinaryPredicate>() ||
+           std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char_type, char_type>;
 }
 
 template <typename BinaryPredicate>
-constexpr bool cmp_equal(string_view lhs, string_view rhs, BinaryPredicate&& p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) {
-#if defined(_MSC_VER) && _MSC_VER < 1920
-  // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
-  // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
-  constexpr auto workaroung = true;
+constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable<BinaryPredicate>()) {
+#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
+    // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html
+    // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html
+    constexpr bool workaround = true;
 #else
-  constexpr auto workaroung = false;
+    constexpr bool workaround = false;
 #endif
-  if constexpr (std::is_same_v<std::decay_t<BinaryPredicate>, char_equal_to> && !workaroung) {
-    static_cast<void>(p);
-    return lhs == rhs;
-  } else {
-    if (lhs.size() != rhs.size()) {
-      return false;
-    }
 
-    const auto size = lhs.size();
-    for (std::size_t i = 0; i < size; ++i) {
-      if (!p(lhs[i], rhs[i])) {
-        return false;
-      }
-    }
+    if constexpr (!is_default_predicate<BinaryPredicate>() || workaround) {
+        if (lhs.size() != rhs.size()) {
+            return false;
+        }
 
-    return true;
-  }
+        const auto size = lhs.size();
+        for (std::size_t i = 0; i < size; ++i) {
+            if (!p(lhs[i], rhs[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    } else {
+        return lhs == rhs;
+    }
 }
 
 template <typename L, typename R>
 constexpr bool cmp_less(L lhs, R rhs) noexcept {
-  static_assert(std::is_integral_v<L> && std::is_integral_v<R>, "magic_enum::detail::cmp_less requires integral type.");
-
-  if constexpr (std::is_signed_v<L> == std::is_signed_v<R>) {
-    // If same signedness (both signed or both unsigned).
-    return lhs < rhs;
-  } else if constexpr (std::is_signed_v<R>) {
-    // If 'right' is negative, then result is 'false', otherwise cast & compare.
-    return rhs > 0 && lhs < static_cast<std::make_unsigned_t<R>>(rhs);
-  } else {
-    // If 'left' is negative, then result is 'true', otherwise cast & compare.
-    return lhs < 0 || static_cast<std::make_unsigned_t<L>>(lhs) < rhs;
-  }
+    static_assert(std::is_integral_v<L> && std::is_integral_v<R>, "magic_enum::detail::cmp_less requires integral type.");
+
+    if constexpr (std::is_signed_v<L> == std::is_signed_v<R>) {
+        // If same signedness (both signed or both unsigned).
+        return lhs < rhs;
+    } else if constexpr (std::is_same_v<L, bool>) { // bool special case
+        return static_cast<R>(lhs) < rhs;
+    } else if constexpr (std::is_same_v<R, bool>) { // bool special case
+        return lhs < static_cast<L>(rhs);
+    } else if constexpr (std::is_signed_v<R>) {
+        // If 'right' is negative, then result is 'false', otherwise cast & compare.
+        return rhs > 0 && lhs < static_cast<std::make_unsigned_t<R>>(rhs);
+    } else {
+        // If 'left' is negative, then result is 'true', otherwise cast & compare.
+        return lhs < 0 || static_cast<std::make_unsigned_t<L>>(lhs) < rhs;
+    }
 }
 
 template <typename I>
 constexpr I log2(I value) noexcept {
-  static_assert(std::is_integral_v<I>, "magic_enum::detail::log2 requires integral type.");
+    static_assert(std::is_integral_v<I>, "magic_enum::detail::log2 requires integral type.");
 
-  auto ret = I{0};
-  for (; value > I{1}; value >>= I{1}, ++ret) {}
+    if constexpr (std::is_same_v<I, bool>) { // bool special case
+        return MAGIC_ENUM_ASSERT(false), value;
+    } else {
+        auto ret = I{0};
+        for (; value > I{1}; value >>= I{1}, ++ret) {}
 
-  return ret;
+        return ret;
+    }
 }
 
-template <typename I>
-constexpr bool is_pow2(I x) noexcept {
-  static_assert(std::is_integral_v<I>, "magic_enum::detail::is_pow2 requires integral type.");
-
-  return x != 0 && (x & (x - 1)) == 0;
+#if defined(__cpp_lib_array_constexpr) && __cpp_lib_array_constexpr >= 201603L
+#  define MAGIC_ENUM_ARRAY_CONSTEXPR 1
+#else
+template <typename T, std::size_t N, std::size_t... I>
+constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N], std::index_sequence<I...>) noexcept {
+    return {{a[I]...}};
 }
+#endif
 
 template <typename T>
 inline constexpr bool is_enum_v = std::is_enum_v<T> && std::is_same_v<T, std::decay_t<T>>;
 
 template <typename E>
 constexpr auto n() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::n requires enum type.");
-#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED
-#  if defined(__clang__)
-  constexpr string_view name{__PRETTY_FUNCTION__ + 34, sizeof(__PRETTY_FUNCTION__) - 36};
-#  elif defined(__GNUC__)
-  constexpr string_view name{__PRETTY_FUNCTION__ + 49, sizeof(__PRETTY_FUNCTION__) - 51};
-#  elif defined(_MSC_VER)
-  constexpr string_view name{__FUNCSIG__ + 40, sizeof(__FUNCSIG__) - 57};
-#  endif
-  return static_string<name.size()>{name};
+    static_assert(is_enum_v<E>, "magic_enum::detail::n requires enum type.");
+
+    if constexpr (supported<E>::value) {
+#if defined(MAGIC_ENUM_GET_TYPE_NAME_BUILTIN)
+        constexpr auto name_ptr = MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(E);
+        constexpr auto name = name_ptr ? str_view{name_ptr, std::char_traits<char>::length(name_ptr)} : str_view{};
+#elif defined(__clang__)
+        str_view name;
+        if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+            static_assert(always_false_v<E>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+            return str_view{};
+        } else {
+            name.size_ = sizeof(__PRETTY_FUNCTION__) - 36;
+            name.str_ = __PRETTY_FUNCTION__ + 34;
+        }
+#elif defined(__GNUC__)
+        auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1};
+        if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+            static_assert(always_false_v<E>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+            return str_view{};
+        } else if (name.str_[name.size_ - 1] == ']') {
+            name.size_ -= 50;
+            name.str_ += 49;
+        } else {
+            name.size_ -= 40;
+            name.str_ += 37;
+        }
+#elif defined(_MSC_VER)
+        // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284).
+        str_view name;
+        name.str_ = __FUNCSIG__;
+        name.str_ += 40;
+        name.size_ += sizeof(__FUNCSIG__) - 57;
 #else
-  return string_view{}; // Unsupported compiler.
+        auto name = str_view{};
 #endif
+        std::size_t p = 0;
+        for (std::size_t i = name.size_; i > 0; --i) {
+            if (name.str_[i] == ':') {
+                p = i + 1;
+                break;
+            }
+        }
+        if (p > 0) {
+            name.size_ -= p;
+            name.str_ += p;
+        }
+        return name;
+    } else {
+        return str_view{}; // Unsupported compiler or Invalid customize.
+    }
 }
 
 template <typename E>
-inline constexpr auto type_name_v = n<E>();
+constexpr auto type_name() noexcept {
+    [[maybe_unused]] constexpr auto custom = customize::enum_type_name<E>();
+    static_assert(std::is_same_v<std::decay_t<decltype(custom)>, customize::customize_t>, "magic_enum::customize requires customize_t type.");
+    if constexpr (custom.first == customize::detail::customize_tag::custom_tag) {
+        constexpr auto name = custom.second;
+        static_assert(!name.empty(), "magic_enum::customize requires not empty string.");
+        return static_str<name.size()>{name};
+    } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) {
+        return static_str<0>{};
+    } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) {
+        constexpr auto name = n<E>();
+        return static_str<name.size_>{name};
+    } else {
+        static_assert(always_false_v<E>, "magic_enum::customize invalid.");
+    }
+}
+
+template <typename E>
+inline constexpr auto type_name_v = type_name<E>();
+
+template <auto V>
+constexpr auto n() noexcept {
+    static_assert(is_enum_v<decltype(V)>, "magic_enum::detail::n requires enum type.");
+
+    if constexpr (supported<decltype(V)>::value) {
+#if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN)
+        constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V);
+        auto name = name_ptr ? str_view{name_ptr, std::char_traits<char>::length(name_ptr)} : str_view{};
+#elif defined(__clang__)
+        str_view name;
+        if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+            static_assert(always_false_v<decltype(V)>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+            return str_view{};
+        } else {
+            name.size_ = sizeof(__PRETTY_FUNCTION__) - 36;
+            name.str_ = __PRETTY_FUNCTION__ + 34;
+        }
+        if (name.size_ > 22 && name.str_[0] == '(' && name.str_[1] == 'a' && name.str_[10] == ' ' && name.str_[22] == ':') {
+            name.size_ -= 23;
+            name.str_ += 23;
+        }
+        if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) {
+            name = str_view{};
+        }
+#elif defined(__GNUC__)
+        auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1};
+        if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+            static_assert(always_false_v<decltype(V)>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+            return str_view{};
+        } else if (name.str_[name.size_ - 1] == ']') {
+            name.size_ -= 55;
+            name.str_ += 54;
+        } else {
+            name.size_ -= 40;
+            name.str_ += 37;
+        }
+        if (name.str_[0] == '(') {
+            name = str_view{};
+        }
+#elif defined(_MSC_VER)
+        str_view name;
+        if ((__FUNCSIG__[5] == '_' && __FUNCSIG__[35] != '(') || (__FUNCSIG__[5] == 'c' && __FUNCSIG__[41] != '(')) {
+            // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284).
+            name.str_ = __FUNCSIG__;
+            name.str_ += 35;
+            name.size_ = sizeof(__FUNCSIG__) - 52;
+        }
+#else
+        auto name = str_view{};
+#endif
+        std::size_t p = 0;
+        for (std::size_t i = name.size_; i > 0; --i) {
+            if (name.str_[i] == ':') {
+                p = i + 1;
+                break;
+            }
+        }
+        if (p > 0) {
+            name.size_ -= p;
+            name.str_ += p;
+        }
+        return name;
+    } else {
+        return str_view{}; // Unsupported compiler or Invalid customize.
+    }
+}
 
+#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920
+#  define MAGIC_ENUM_VS_2017_WORKAROUND 1
+#endif
+
+#if defined(MAGIC_ENUM_VS_2017_WORKAROUND)
 template <typename E, E V>
 constexpr auto n() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::n requires enum type.");
-  constexpr auto custom_name = customize::enum_name<E>(V);
-
-  if constexpr (custom_name.empty()) {
-    static_cast<void>(custom_name);
-#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED
-#  if defined(__clang__) || defined(__GNUC__)
-    constexpr auto name = pretty_name({__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 2});
-#  elif defined(_MSC_VER)
-    constexpr auto name = pretty_name({__FUNCSIG__, sizeof(__FUNCSIG__) - 17});
+    static_assert(is_enum_v<E>, "magic_enum::detail::n requires enum type.");
+
+#  if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN)
+    constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V);
+    auto name = name_ptr ? str_view{name_ptr, std::char_traits<char>::length(name_ptr)} : str_view{};
+#  else
+    // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284).
+    str_view name;
+    name.str_ = __FUNCSIG__;
+    name.size_ = sizeof(__FUNCSIG__) - 17;
+    std::size_t p = 0;
+    for (std::size_t i = name.size_; i > 0; --i) {
+        if (name.str_[i] == ',' || name.str_[i] == ':') {
+            p = i + 1;
+            break;
+        }
+    }
+    if (p > 0) {
+        name.size_ -= p;
+        name.str_ += p;
+    }
+    if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) {
+        name = str_view{};
+    }
+    return name;
 #  endif
-    return static_string<name.size()>{name};
+}
+#endif
+
+template <typename E, E V>
+constexpr auto enum_name() noexcept {
+    [[maybe_unused]] constexpr auto custom = customize::enum_name<E>(V);
+    static_assert(std::is_same_v<std::decay_t<decltype(custom)>, customize::customize_t>, "magic_enum::customize requires customize_t type.");
+    if constexpr (custom.first == customize::detail::customize_tag::custom_tag) {
+        constexpr auto name = custom.second;
+        static_assert(!name.empty(), "magic_enum::customize requires not empty string.");
+        return static_str<name.size()>{name};
+    } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) {
+        return static_str<0>{};
+    } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) {
+#if defined(MAGIC_ENUM_VS_2017_WORKAROUND)
+        constexpr auto name = n<E, V>();
 #else
-    return string_view{}; // Unsupported compiler.
+        constexpr auto name = n<V>();
 #endif
-  } else {
-    return static_string<custom_name.size()>{custom_name};
-  }
+        return static_str<name.size_>{name};
+    } else {
+        static_assert(always_false_v<E>, "magic_enum::customize invalid.");
+    }
 }
 
 template <typename E, E V>
-inline constexpr auto enum_name_v = n<E, V>();
+inline constexpr auto enum_name_v = enum_name<E, V>();
 
 template <typename E, auto V>
 constexpr bool is_valid() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::is_valid requires enum type.");
-
-  return n<E, static_cast<E>(V)>().size() != 0;
-}
-
-template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr int reflected_min() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::reflected_min requires enum type.");
-
-  if constexpr (IsFlags) {
-    return 0;
-  } else {
-    constexpr auto lhs = customize::enum_range<E>::min;
-    static_assert(lhs > (std::numeric_limits<std::int16_t>::min)(), "magic_enum::enum_range requires min must be greater than INT16_MIN.");
-    constexpr auto rhs = (std::numeric_limits<U>::min)();
-
-    if constexpr (cmp_less(lhs, rhs)) {
-      return rhs;
+#if defined(__clang__) && __clang_major__ >= 16
+    // https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307
+    constexpr E v = __builtin_bit_cast(E, V);
+#else
+    constexpr E v = static_cast<E>(V);
+#endif
+    [[maybe_unused]] constexpr auto custom = customize::enum_name<E>(v);
+    static_assert(std::is_same_v<std::decay_t<decltype(custom)>, customize::customize_t>, "magic_enum::customize requires customize_t type.");
+    if constexpr (custom.first == customize::detail::customize_tag::custom_tag) {
+        constexpr auto name = custom.second;
+        static_assert(!name.empty(), "magic_enum::customize requires not empty string.");
+        return name.size() != 0;
+    } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) {
+#if defined(MAGIC_ENUM_VS_2017_WORKAROUND)
+        return n<E, v>().size_ != 0;
+#else
+        return n<v>().size_ != 0;
+#endif
     } else {
-      return lhs;
+        return false;
     }
-  }
 }
 
-template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr int reflected_max() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::reflected_max requires enum type.");
+enum class enum_subtype {
+    common,
+    flags
+};
 
-  if constexpr (IsFlags) {
-    return std::numeric_limits<U>::digits - 1;
-  } else {
-    constexpr auto lhs = customize::enum_range<E>::max;
-    static_assert(lhs < (std::numeric_limits<std::int16_t>::max)(), "magic_enum::enum_range requires max must be less than INT16_MAX.");
-    constexpr auto rhs = (std::numeric_limits<U>::max)();
+template <typename E, int O, enum_subtype S, typename U = std::underlying_type_t<E>>
+constexpr U ualue(std::size_t i) noexcept {
+    if constexpr (std::is_same_v<U, bool>) { // bool special case
+        static_assert(O == 0, "magic_enum::detail::ualue requires valid offset.");
 
-    if constexpr (cmp_less(lhs, rhs)) {
-      return lhs;
+        return static_cast<U>(i);
+    } else if constexpr (S == enum_subtype::flags) {
+        return static_cast<U>(U{1} << static_cast<U>(static_cast<int>(i) + O));
     } else {
-      return rhs;
+        return static_cast<U>(static_cast<int>(i) + O);
     }
-  }
 }
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto reflected_min_v = reflected_min<E, IsFlags>();
-
-template <typename E, bool IsFlags = false>
-inline constexpr auto reflected_max_v = reflected_max<E, IsFlags>();
-
-template <typename E, int O, bool IsFlags = false, typename U = std::underlying_type_t<E>>
+template <typename E, int O, enum_subtype S, typename U = std::underlying_type_t<E>>
 constexpr E value(std::size_t i) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::value requires enum type.");
+    return static_cast<E>(ualue<E, O, S>(i));
+}
 
-  if constexpr (IsFlags) {
-    return static_cast<E>(U{1} << static_cast<U>(static_cast<int>(i) + O));
-  } else {
-    return static_cast<E>(static_cast<int>(i) + O);
-  }
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
+constexpr int reflected_min() noexcept {
+    if constexpr (S == enum_subtype::flags) {
+        return 0;
+    } else {
+        constexpr auto lhs = range_min<E>::value;
+        constexpr auto rhs = (std::numeric_limits<U>::min)();
+
+        if constexpr (cmp_less(rhs, lhs)) {
+            return lhs;
+        } else {
+            return rhs;
+        }
+    }
 }
 
-template <typename E, bool IsFlags, int Min, std::size_t... I>
-constexpr auto values(std::index_sequence<I...>) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::values requires enum type.");
-  constexpr std::array<bool, sizeof...(I)> valid{{is_valid<E, value<E, Min, IsFlags>(I)>()...}};
-  constexpr std::size_t count = [](decltype((valid)) valid_) constexpr noexcept -> std::size_t {
-    auto count_ = std::size_t{0};
-    for (std::size_t i_ = 0; i_ < valid_.size(); ++i_) {
-      if (valid_[i_]) {
-        ++count_;
-      }
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
+constexpr int reflected_max() noexcept {
+    if constexpr (S == enum_subtype::flags) {
+        return std::numeric_limits<U>::digits - 1;
+    } else {
+        constexpr auto lhs = range_max<E>::value;
+        constexpr auto rhs = (std::numeric_limits<U>::max)();
+
+        if constexpr (cmp_less(lhs, rhs)) {
+            return lhs;
+        } else {
+            return rhs;
+        }
     }
-    return count_;
-  }(valid);
+}
 
-  std::array<E, count> values{};
-  for (std::size_t i = 0, v = 0; v < count; ++i) {
-    if (valid[i]) {
-      values[v++] = value<E, Min, IsFlags>(i);
+#define MAGIC_ENUM_FOR_EACH_256(T)                                                                                                                                                                 \
+T(  0)T(  1)T(  2)T(  3)T(  4)T(  5)T(  6)T(  7)T(  8)T(  9)T( 10)T( 11)T( 12)T( 13)T( 14)T( 15)T( 16)T( 17)T( 18)T( 19)T( 20)T( 21)T( 22)T( 23)T( 24)T( 25)T( 26)T( 27)T( 28)T( 29)T( 30)T( 31) \
+    T( 32)T( 33)T( 34)T( 35)T( 36)T( 37)T( 38)T( 39)T( 40)T( 41)T( 42)T( 43)T( 44)T( 45)T( 46)T( 47)T( 48)T( 49)T( 50)T( 51)T( 52)T( 53)T( 54)T( 55)T( 56)T( 57)T( 58)T( 59)T( 60)T( 61)T( 62)T( 63) \
+    T( 64)T( 65)T( 66)T( 67)T( 68)T( 69)T( 70)T( 71)T( 72)T( 73)T( 74)T( 75)T( 76)T( 77)T( 78)T( 79)T( 80)T( 81)T( 82)T( 83)T( 84)T( 85)T( 86)T( 87)T( 88)T( 89)T( 90)T( 91)T( 92)T( 93)T( 94)T( 95) \
+    T( 96)T( 97)T( 98)T( 99)T(100)T(101)T(102)T(103)T(104)T(105)T(106)T(107)T(108)T(109)T(110)T(111)T(112)T(113)T(114)T(115)T(116)T(117)T(118)T(119)T(120)T(121)T(122)T(123)T(124)T(125)T(126)T(127) \
+    T(128)T(129)T(130)T(131)T(132)T(133)T(134)T(135)T(136)T(137)T(138)T(139)T(140)T(141)T(142)T(143)T(144)T(145)T(146)T(147)T(148)T(149)T(150)T(151)T(152)T(153)T(154)T(155)T(156)T(157)T(158)T(159) \
+    T(160)T(161)T(162)T(163)T(164)T(165)T(166)T(167)T(168)T(169)T(170)T(171)T(172)T(173)T(174)T(175)T(176)T(177)T(178)T(179)T(180)T(181)T(182)T(183)T(184)T(185)T(186)T(187)T(188)T(189)T(190)T(191) \
+    T(192)T(193)T(194)T(195)T(196)T(197)T(198)T(199)T(200)T(201)T(202)T(203)T(204)T(205)T(206)T(207)T(208)T(209)T(210)T(211)T(212)T(213)T(214)T(215)T(216)T(217)T(218)T(219)T(220)T(221)T(222)T(223) \
+    T(224)T(225)T(226)T(227)T(228)T(229)T(230)T(231)T(232)T(233)T(234)T(235)T(236)T(237)T(238)T(239)T(240)T(241)T(242)T(243)T(244)T(245)T(246)T(247)T(248)T(249)T(250)T(251)T(252)T(253)T(254)T(255)
+
+    template <typename E, enum_subtype S, std::size_t Size, int Min, std::size_t I>
+    constexpr void valid_count(bool* valid, std::size_t& count) noexcept {
+#define MAGIC_ENUM_V(O)                                     \
+    if constexpr ((I + O) < Size) {                           \
+            if constexpr (is_valid<E, ualue<E, Min, S>(I + O)>()) { \
+                valid[I + O] = true;                                  \
+                ++count;                                              \
+        }                                                       \
     }
-  }
 
-  return values;
+    MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V)
+
+    if constexpr ((I + 256) < Size) {
+        valid_count<E, S, Size, Min, I + 256>(valid, count);
+    }
+#undef MAGIC_ENUM_V
 }
 
-template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr auto values() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::values requires enum type.");
-  constexpr auto range_size = reflected_max_v<E, IsFlags> - reflected_min_v<E, IsFlags> + 1;
-  static_assert(range_size > 0, "magic_enum::enum_range requires valid size.");
-  static_assert(range_size < (std::numeric_limits<std::uint16_t>::max)(), "magic_enum::enum_range requires valid size.");
+template <std::size_t N>
+struct valid_count_t {
+    std::size_t count = 0;
+    bool valid[N] = {};
+};
 
-  return values<E, IsFlags, reflected_min_v<E, IsFlags>>(std::make_index_sequence<range_size>{});
+template <typename E, enum_subtype S, std::size_t Size, int Min>
+constexpr auto valid_count() noexcept {
+    valid_count_t<Size> vc;
+    valid_count<E, S, Size, Min, 0>(vc.valid, vc.count);
+    return vc;
 }
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto values_v = values<E, IsFlags>();
-
-template <typename E, bool IsFlags = false, typename D = std::decay_t<E>>
-using values_t = decltype((values_v<D, IsFlags>));
+template <typename E, enum_subtype S, std::size_t Size, int Min>
+constexpr auto values() noexcept {
+    constexpr auto vc = valid_count<E, S, Size, Min>();
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto count_v = values_v<E, IsFlags>.size();
+    if constexpr (vc.count > 0) {
+#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR)
+        std::array<E, vc.count> values = {};
+#else
+        E values[vc.count] = {};
+#endif
+        for (std::size_t i = 0, v = 0; v < vc.count; ++i) {
+            if (vc.valid[i]) {
+                values[v++] = value<E, Min, S>(i);
+            }
+        }
+#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR)
+        return values;
+#else
+        return to_array(values, std::make_index_sequence<vc.count>{});
+#endif
+    } else {
+        return std::array<E, 0>{};
+    }
+}
 
-template <typename E, bool IsFlags = false, typename U = std::underlying_type_t<E>>
-inline constexpr auto min_v = static_cast<U>(values_v<E, IsFlags>.front());
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
+constexpr auto values() noexcept {
+    constexpr auto min = reflected_min<E, S>();
+    constexpr auto max = reflected_max<E, S>();
+    constexpr auto range_size = max - min + 1;
+    static_assert(range_size > 0, "magic_enum::enum_range requires valid size.");
 
-template <typename E, bool IsFlags = false, typename U = std::underlying_type_t<E>>
-inline constexpr auto max_v = static_cast<U>(values_v<E, IsFlags>.back());
+    return values<E, S, range_size, min>();
+}
 
-template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr std::size_t range_size() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::range_size requires enum type.");
-  constexpr auto max = IsFlags ? log2(max_v<E, IsFlags>) : max_v<E, IsFlags>;
-  constexpr auto min = IsFlags ? log2(min_v<E, IsFlags>) : min_v<E, IsFlags>;
-  constexpr auto range_size = max - min + U{1};
-  static_assert(range_size > 0, "magic_enum::enum_range requires valid size.");
-  static_assert(range_size < (std::numeric_limits<std::uint16_t>::max)(), "magic_enum::enum_range requires valid size.");
+template <typename E, typename U = std::underlying_type_t<E>>
+constexpr enum_subtype subtype(std::true_type) noexcept {
+    if constexpr (std::is_same_v<U, bool>) { // bool special case
+        return enum_subtype::common;
+    } else if constexpr (has_is_flags<E>::value) {
+        return customize::enum_range<E>::is_flags ? enum_subtype::flags : enum_subtype::common;
+    } else {
+#if defined(MAGIC_ENUM_AUTO_IS_FLAGS)
+        constexpr auto flags_values = values<E, enum_subtype::flags>();
+        constexpr auto default_values = values<E, enum_subtype::common>();
+        if (flags_values.size() == 0 || default_values.size() > flags_values.size()) {
+            return enum_subtype::common;
+        }
+        for (std::size_t i = 0; i < default_values.size(); ++i) {
+            const auto v = static_cast<U>(default_values[i]);
+            if (v != 0 && (v & (v - 1)) != 0) {
+                return enum_subtype::common;
+            }
+        }
+        return enum_subtype::flags;
+#else
+        return enum_subtype::common;
+#endif
+    }
+}
 
-  return static_cast<std::size_t>(range_size);
+template <typename T>
+constexpr enum_subtype subtype(std::false_type) noexcept {
+    // For non-enum type return default common subtype.
+    return enum_subtype::common;
 }
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto range_size_v = range_size<E, IsFlags>();
+template <typename E, typename D = std::decay_t<E>>
+inline constexpr auto subtype_v = subtype<D>(std::is_enum<D>{});
 
-template <typename E, bool IsFlags = false>
-using index_t = std::conditional_t<range_size_v<E, IsFlags> < (std::numeric_limits<std::uint8_t>::max)(), std::uint8_t, std::uint16_t>;
+template <typename E, enum_subtype S>
+inline constexpr auto values_v = values<E, S>();
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto invalid_index_v = (std::numeric_limits<index_t<E, IsFlags>>::max)();
+template <typename E, enum_subtype S, typename D = std::decay_t<E>>
+using values_t = decltype((values_v<D, S>));
 
-template <typename E, bool IsFlags, std::size_t... I>
-constexpr auto indexes(std::index_sequence<I...>) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::indexes requires enum type.");
-  constexpr auto min = IsFlags ? log2(min_v<E, IsFlags>) : min_v<E, IsFlags>;
-  [[maybe_unused]] auto i = index_t<E, IsFlags>{0};
+template <typename E, enum_subtype S>
+inline constexpr auto count_v = values_v<E, S>.size();
 
-  return std::array<decltype(i), sizeof...(I)>{{(is_valid<E, value<E, min, IsFlags>(I)>() ? i++ : invalid_index_v<E, IsFlags>)...}};
-}
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
+inline constexpr auto min_v = (count_v<E, S> > 0) ? static_cast<U>(values_v<E, S>.front()) : U{0};
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto indexes_v = indexes<E, IsFlags>(std::make_index_sequence<range_size_v<E, IsFlags>>{});
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
+inline constexpr auto max_v = (count_v<E, S> > 0) ? static_cast<U>(values_v<E, S>.back()) : U{0};
 
-template <typename E, bool IsFlags, std::size_t... I>
+template <typename E, enum_subtype S, std::size_t... I>
 constexpr auto names(std::index_sequence<I...>) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::names requires enum type.");
-
-  return std::array<string_view, sizeof...(I)>{{enum_name_v<E, values_v<E, IsFlags>[I]>...}};
+    constexpr auto names = std::array<string_view, sizeof...(I)>{{enum_name_v<E, values_v<E, S>[I]>...}};
+    return names;
 }
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto names_v = names<E, IsFlags>(std::make_index_sequence<count_v<E, IsFlags>>{});
+template <typename E, enum_subtype S>
+inline constexpr auto names_v = names<E, S>(std::make_index_sequence<count_v<E, S>>{});
 
-template <typename E, bool IsFlags = false, typename D = std::decay_t<E>>
-using names_t = decltype((names_v<D, IsFlags>));
+template <typename E, enum_subtype S, typename D = std::decay_t<E>>
+using names_t = decltype((names_v<D, S>));
 
-template <typename E, bool IsFlags, std::size_t... I>
+template <typename E, enum_subtype S, std::size_t... I>
 constexpr auto entries(std::index_sequence<I...>) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::entries requires enum type.");
-
-  return std::array<std::pair<E, string_view>, sizeof...(I)>{{{values_v<E, IsFlags>[I], enum_name_v<E, values_v<E, IsFlags>[I]>}...}};
+    constexpr auto entries = std::array<std::pair<E, string_view>, sizeof...(I)>{{{values_v<E, S>[I], enum_name_v<E, values_v<E, S>[I]>}...}};
+    return entries;
 }
 
-template <typename E, bool IsFlags = false>
-inline constexpr auto entries_v = entries<E, IsFlags>(std::make_index_sequence<count_v<E, IsFlags>>{});
+template <typename E, enum_subtype S>
+inline constexpr auto entries_v = entries<E, S>(std::make_index_sequence<count_v<E, S>>{});
 
-template <typename E, bool IsFlags = false, typename D = std::decay_t<E>>
-using entries_t = decltype((entries_v<D, IsFlags>));
+template <typename E, enum_subtype S, typename D = std::decay_t<E>>
+using entries_t = decltype((entries_v<D, S>));
 
-template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
+template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
 constexpr bool is_sparse() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::is_sparse requires enum type.");
-
-  return range_size_v<E, IsFlags> != count_v<E, IsFlags>;
-}
-
-template <typename E, bool IsFlags = false>
-inline constexpr bool is_sparse_v = is_sparse<E, IsFlags>();
-
-template <typename E, typename U = std::underlying_type_t<E>>
-constexpr std::size_t undex(U value) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::undex requires enum type.");
-
-  if (const auto i = static_cast<std::size_t>(value - min_v<E>); value >= min_v<E> && value <= max_v<E>) {
-    if constexpr (is_sparse_v<E>) {
-      if (const auto idx = indexes_v<E>[i]; idx != invalid_index_v<E>) {
-        return idx;
-      }
+    if constexpr (count_v<E, S> == 0) {
+        return false;
+    } else if constexpr (std::is_same_v<U, bool>) { // bool special case
+        return false;
     } else {
-      return i;
-    }
-  }
-
-  return invalid_index_v<E>; // Value out of range.
-}
-
-template <typename E, typename U = std::underlying_type_t<E>>
-constexpr std::size_t endex(E value) noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::endex requires enum type.");
+        constexpr auto max = (S == enum_subtype::flags) ? log2(max_v<E, S>) : max_v<E, S>;
+        constexpr auto min = (S == enum_subtype::flags) ? log2(min_v<E, S>) : min_v<E, S>;
+        constexpr auto range_size = max - min + 1;
 
-  return undex<E>(static_cast<U>(value));
+        return range_size != count_v<E, S>;
+    }
 }
 
-template <typename E, typename U = std::underlying_type_t<E>>
-constexpr U value_ors() noexcept {
-  static_assert(is_enum_v<E>, "magic_enum::detail::endex requires enum type.");
+template <typename E, enum_subtype S = subtype_v<E>>
+inline constexpr bool is_sparse_v = is_sparse<E, S>();
 
-  auto value = U{0};
-  for (std::size_t i = 0; i < count_v<E, true>; ++i) {
-    value |= static_cast<U>(values_v<E, true>[i]);
-  }
+template <typename E, enum_subtype S>
+struct is_reflected
+#if defined(MAGIC_ENUM_NO_CHECK_REFLECTED_ENUM)
+    : std::true_type {};
+#else
+    : std::bool_constant<std::is_enum_v<E> && (count_v<E, S> != 0)> {};
+#endif
 
-  return value;
-}
+template <typename E, enum_subtype S>
+inline constexpr bool is_reflected_v = is_reflected<std::decay_t<E>, S>{};
 
-template <bool, typename T, typename R>
+template <bool, typename R>
 struct enable_if_enum {};
 
-template <typename T, typename R>
-struct enable_if_enum<true, T, R> {
-  using type = R;
-  using D = std::decay_t<T>;
-  static_assert(supported<D>::value, "magic_enum unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility).");
+template <typename R>
+struct enable_if_enum<true, R> {
+    using type = R;
+    static_assert(supported<R>::value, "magic_enum unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility).");
 };
 
-template <typename T, typename R = void>
-using enable_if_enum_t = std::enable_if_t<std::is_enum_v<std::decay_t<T>>, R>;
+template <typename T, typename R, typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>
+using enable_if_t = typename enable_if_enum<std::is_enum_v<D> && std::is_invocable_r_v<bool, BinaryPredicate, char_type, char_type>, R>::type;
 
-template <typename T, typename Enable = std::enable_if_t<std::is_enum_v<std::decay_t<T>>>>
+template <typename T, std::enable_if_t<std::is_enum_v<std::decay_t<T>>, int> = 0>
 using enum_concept = T;
 
 template <typename T, bool = std::is_enum_v<T>>
@@ -590,6 +909,217 @@ struct underlying_type {};
 template <typename T>
 struct underlying_type<T, true> : std::underlying_type<std::decay_t<T>> {};
 
+#if defined(MAGIC_ENUM_ENABLE_HASH) || defined(MAGIC_ENUM_ENABLE_HASH_SWITCH)
+
+template <typename Value, typename = void>
+struct constexpr_hash_t;
+
+template <typename Value>
+struct constexpr_hash_t<Value, std::enable_if_t<is_enum_v<Value>>> {
+    constexpr auto operator()(Value value) const noexcept {
+        using U = typename underlying_type<Value>::type;
+        if constexpr (std::is_same_v<U, bool>) { // bool special case
+            return static_cast<std::size_t>(value);
+        } else {
+            return static_cast<U>(value);
+        }
+    }
+    using secondary_hash = constexpr_hash_t;
+};
+
+template <typename Value>
+struct constexpr_hash_t<Value, std::enable_if_t<std::is_same_v<Value, string_view>>> {
+    static constexpr std::uint32_t crc_table[256] {
+        0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
+        0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
+        0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
+        0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
+        0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+        0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
+        0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
+        0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
+        0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
+        0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+        0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
+        0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
+        0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
+        0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
+        0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+        0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
+        0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
+        0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
+        0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
+        0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+        0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
+        0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
+        0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
+        0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
+        0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+        0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
+        0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
+        0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
+        0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
+        0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+        0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
+        0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
+    };
+    constexpr std::uint32_t operator()(string_view value) const noexcept {
+        auto crc = static_cast<std::uint32_t>(0xffffffffL);
+        for (const auto c : value) {
+            crc = (crc >> 8) ^ crc_table[(crc ^ static_cast<std::uint32_t>(c)) & 0xff];
+        }
+        return crc ^ 0xffffffffL;
+    }
+
+    struct secondary_hash {
+        constexpr std::uint32_t operator()(string_view value) const noexcept {
+            auto acc = static_cast<std::uint64_t>(2166136261ULL);
+            for (const auto c : value) {
+                acc = ((acc ^ static_cast<std::uint64_t>(c)) * static_cast<std::uint64_t>(16777619ULL)) & (std::numeric_limits<std::uint32_t>::max)();
+            }
+            return static_cast<std::uint32_t>(acc);
+        }
+    };
+};
+
+template <typename Hash>
+inline constexpr Hash hash_v{};
+
+template <auto* GlobValues, typename Hash>
+constexpr auto calculate_cases(std::size_t Page) noexcept {
+    constexpr std::array values = *GlobValues;
+    constexpr std::size_t size = values.size();
+
+    using switch_t = std::invoke_result_t<Hash, typename decltype(values)::value_type>;
+    static_assert(std::is_integral_v<switch_t> && !std::is_same_v<switch_t, bool>);
+    const std::size_t values_to = (std::min)(static_cast<std::size_t>(256), size - Page);
+
+    std::array<switch_t, 256> result{};
+    auto fill = result.begin();
+    {
+        auto first = values.begin() + static_cast<std::ptrdiff_t>(Page);
+        auto last = values.begin() + static_cast<std::ptrdiff_t>(Page + values_to);
+        while (first != last) {
+            *fill++ = hash_v<Hash>(*first++);
+        }
+    }
+
+    // dead cases, try to avoid case collisions
+    for (switch_t last_value = result[values_to - 1]; fill != result.end() && last_value != (std::numeric_limits<switch_t>::max)(); *fill++ = ++last_value) {
+    }
+
+    {
+        auto it = result.begin();
+        auto last_value = (std::numeric_limits<switch_t>::min)();
+        for (; fill != result.end(); *fill++ = last_value++) {
+            while (last_value == *it) {
+                ++last_value, ++it;
+            }
+        }
+    }
+
+    return result;
+}
+
+template <typename R, typename F, typename... Args>
+constexpr R invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>) {
+    if constexpr (std::is_void_v<R>) {
+        std::forward<F>(f)(std::forward<Args>(args)...);
+    } else {
+        return static_cast<R>(std::forward<F>(f)(std::forward<Args>(args)...));
+    }
+}
+
+enum class case_call_t {
+    index,
+    value
+};
+
+template <typename T = void>
+inline constexpr auto default_result_type_lambda = []() noexcept(std::is_nothrow_default_constructible_v<T>) { return T{}; };
+
+template <>
+inline constexpr auto default_result_type_lambda<void> = []() noexcept {};
+
+template <auto* Arr, typename Hash>
+constexpr bool has_duplicate() noexcept {
+    using value_t = std::decay_t<decltype((*Arr)[0])>;
+    using hash_value_t = std::invoke_result_t<Hash, value_t>;
+    std::array<hash_value_t, Arr->size()> hashes{};
+    std::size_t size = 0;
+    for (auto elem : *Arr) {
+        hashes[size] = hash_v<Hash>(elem);
+        for (auto i = size++; i > 0; --i) {
+            if (hashes[i] < hashes[i - 1]) {
+                auto tmp = hashes[i];
+                hashes[i] = hashes[i - 1];
+                hashes[i - 1] = tmp;
+            } else if (hashes[i] == hashes[i - 1]) {
+                return false;
+            } else {
+                break;
+            }
+        }
+    }
+    return true;
+}
+
+#define MAGIC_ENUM_CASE(val)                                                                                                  \
+case cases[val]:                                                                                                            \
+    if constexpr ((val) + Page < size) {                                                                                      \
+        if (!pred(values[val + Page], searched)) {                                                                              \
+            break;                                                                                                                \
+    }                                                                                                                       \
+        if constexpr (CallValue == case_call_t::index) {                                                                        \
+            if constexpr (std::is_invocable_r_v<result_t, Lambda, std::integral_constant<std::size_t, val + Page>>) {             \
+                return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), std::integral_constant<std::size_t, val + Page>{}); \
+        } else if constexpr (std::is_invocable_v<Lambda, std::integral_constant<std::size_t, val + Page>>) {                  \
+                MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type.");                                         \
+        }                                                                                                                     \
+    } else if constexpr (CallValue == case_call_t::value) {                                                                 \
+            if constexpr (std::is_invocable_r_v<result_t, Lambda, enum_constant<values[val + Page]>>) {                           \
+                return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), enum_constant<values[val + Page]>{});               \
+        } else if constexpr (std::is_invocable_r_v<result_t, Lambda, enum_constant<values[val + Page]>>) {                    \
+                MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type.");                                         \
+        }                                                                                                                     \
+    }                                                                                                                       \
+        break;                                                                                                                  \
+} else [[fallthrough]];
+
+template <auto* GlobValues,
+         case_call_t CallValue,
+         std::size_t Page = 0,
+         typename Hash = constexpr_hash_t<typename std::decay_t<decltype(*GlobValues)>::value_type>,
+         typename BinaryPredicate = std::equal_to<>,
+         typename Lambda,
+         typename ResultGetterType>
+constexpr decltype(auto) constexpr_switch(
+    Lambda&& lambda,
+    typename std::decay_t<decltype(*GlobValues)>::value_type searched,
+    ResultGetterType&& def,
+    BinaryPredicate&& pred = {}) {
+    using result_t = std::invoke_result_t<ResultGetterType>;
+    using hash_t = std::conditional_t<has_duplicate<GlobValues, Hash>(), Hash, typename Hash::secondary_hash>;
+    static_assert(has_duplicate<GlobValues, hash_t>(), "magic_enum::detail::constexpr_switch duplicated hash found, please report it: https://github.com/Neargye/magic_enum/issues.");
+    constexpr std::array values = *GlobValues;
+    constexpr std::size_t size = values.size();
+    constexpr std::array cases = calculate_cases<GlobValues, hash_t>(Page);
+
+    switch (hash_v<hash_t>(searched)) {
+        MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE)
+    default:
+        if constexpr (size > 256 + Page) {
+            return constexpr_switch<GlobValues, CallValue, Page + 256, Hash>(std::forward<Lambda>(lambda), searched, std::forward<ResultGetterType>(def));
+        }
+        break;
+    }
+    return def();
+}
+
+#undef MAGIC_ENUM_CASE
+
+#endif
+
 } // namespace magic_enum::detail
 
 // Checks is magic_enum supported compiler.
@@ -622,477 +1152,308 @@ struct underlying_type : detail::underlying_type<T> {};
 template <typename T>
 using underlying_type_t = typename underlying_type<T>::type;
 
+template <auto V>
+using enum_constant = detail::enum_constant<V>;
+
 // Returns type name of enum.
 template <typename E>
-[[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_enum_t<E, string_view> {
-  using D = std::decay_t<E>;
-  constexpr string_view name = detail::type_name_v<D>;
-  static_assert(name.size() > 0, "Enum type does not have a name.");
+[[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_t<E, string_view> {
+    constexpr string_view name = detail::type_name_v<std::decay_t<E>>;
+    static_assert(!name.empty(), "magic_enum::enum_type_name enum type does not have a name.");
 
-  return name;
+    return name;
 }
 
 // Returns number of enum values.
-template <typename E>
-[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_enum_t<E, std::size_t> {
-  using D = std::decay_t<E>;
-
-  return detail::count_v<D>;
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t<E, std::size_t> {
+    return detail::count_v<std::decay_t<E>, S>;
 }
 
 // Returns enum value at specified index.
 // No bounds checking is performed: the behavior is undefined if index >= number of enum values.
-template <typename E>
-[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_enum_t<E, std::decay_t<E>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D> > 0, "magic_enum requires enum implementation and valid max and min.");
-
-  if constexpr (detail::is_sparse_v<D>) {
-    return assert((index < detail::count_v<D>)), detail::values_v<D>[index];
-  } else {
-    return assert((index < detail::count_v<D>)), detail::value<D, detail::min_v<D>>(index);
-  }
-}
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-// Returns std::array with enum values, sorted by enum value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_enum_t<E, detail::values_t<E>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D> > 0, "magic_enum requires enum implementation and valid max and min.");
-
-  return detail::values_v<D>;
-}
-
-// Returns name from static storage enum variable.
-// This version is much lighter on the compile times and is not restricted to the enum_range limitation.
-template <auto V>
-[[nodiscard]] constexpr auto enum_name() noexcept -> detail::enable_if_enum_t<decltype(V), string_view> {
-  using D = std::decay_t<decltype(V)>;
-  constexpr string_view name = detail::enum_name_v<D, V>;
-  static_assert(name.size() > 0, "Enum value does not have a name.");
+    if constexpr (detail::is_sparse_v<D, S>) {
+        return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
+    } else {
+        constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v<D, S>) : detail::min_v<D, S>;
 
-  return name;
+        return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::value<D, min, S>(index);
+    }
 }
 
-// Returns name from enum value.
-// If enum value does not have name or value out of range, returns empty string.
-template <typename E>
-[[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_enum_t<E, string_view> {
-  using D = std::decay_t<E>;
-
-  if (const auto i = detail::endex<D>(value); i != detail::invalid_index_v<D>) {
-    return detail::names_v<D>[i];
-  }
+// Returns enum value at specified index.
+template <typename E, std::size_t I, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+    static_assert(I < detail::count_v<D, S>, "magic_enum::enum_value out of range.");
 
-  return {}; // Invalid value or out of range.
+    return enum_value<D, S>(I);
 }
 
-// Returns std::array with names, sorted by enum value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_enum_t<E, detail::names_t<E>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D> > 0, "magic_enum requires enum implementation and valid max and min.");
+// Returns std::array with enum values, sorted by enum value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_t<E, detail::values_t<E, S>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  return detail::names_v<D>;
+    return detail::values_v<D, S>;
 }
 
-// Returns std::array with pairs (value, name), sorted by enum value.
+// Returns integer value from enum value.
 template <typename E>
-[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_enum_t<E, detail::entries_t<E>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D> > 0, "magic_enum requires enum implementation and valid max and min.");
-
-  return detail::entries_v<D>;
+[[nodiscard]] constexpr auto enum_integer(E value) noexcept -> detail::enable_if_t<E, underlying_type_t<E>> {
+    return static_cast<underlying_type_t<E>>(value);
 }
 
-// Obtains enum value from integer value.
-// Returns optional with enum value.
+// Returns underlying value from enum value.
 template <typename E>
-[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  using D = std::decay_t<E>;
-
-  if (detail::undex<D>(value) != detail::invalid_index_v<D>) {
-    return static_cast<D>(value);
-  }
-
-  return {}; // Invalid value or out of range.
+[[nodiscard]] constexpr auto enum_underlying(E value) noexcept -> detail::enable_if_t<E, underlying_type_t<E>> {
+    return static_cast<underlying_type_t<E>>(value);
 }
 
-// Obtains enum value from name.
-// Returns optional with enum value.
-template <typename E, typename BinaryPredicate>
-[[nodiscard]] constexpr auto enum_cast(string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::enum_cast requires bool(char, char) invocable predicate.");
-  using D = std::decay_t<E>;
-
-  for (std::size_t i = 0; i < detail::count_v<D>; ++i) {
-    if (detail::cmp_equal(value, detail::names_v<D>[i], p)) {
-      return enum_value<D>(i);
+// Obtains index in enum values from enum value.
+// Returns optional with index.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
+    using D = std::decay_t<E>;
+    using U = underlying_type_t<D>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+    if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
+#if defined(MAGIC_ENUM_ENABLE_HASH)
+        return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::index>(
+            [](std::size_t i) { return optional<std::size_t>{i}; },
+            value,
+            detail::default_result_type_lambda<optional<std::size_t>>);
+#else
+        for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+            if (enum_value<D, S>(i) == value) {
+                return i;
+            }
+        }
+        return {}; // Invalid value or out of range.
+#endif
+    } else {
+        const auto v = static_cast<U>(value);
+        if (v >= detail::min_v<D, S> && v <= detail::max_v<D, S>) {
+            return static_cast<std::size_t>(v - detail::min_v<D, S>);
+        }
+        return {}; // Invalid value or out of range.
     }
-  }
-
-  return {}; // Invalid value or out of range.
-}
-
-// Obtains enum value from name.
-// Returns optional with enum value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_cast(string_view value) noexcept -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  using D = std::decay_t<E>;
-
-  return enum_cast<D>(value, detail::char_equal_to{});
-}
-
-// Returns integer value from enum value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_integer(E value) noexcept -> detail::enable_if_enum_t<E, underlying_type_t<E>> {
-  return static_cast<underlying_type_t<E>>(value);
 }
 
 // Obtains index in enum values from enum value.
 // Returns optional with index.
-template <typename E>
-[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_enum_t<E, optional<std::size_t>> {
-  using D = std::decay_t<E>;
-
-  if (const auto i = detail::endex<D>(value); i != detail::invalid_index_v<D>) {
-    return i;
-  }
-
-  return {}; // Invalid value or out of range.
-}
-
-// Checks whether enum contains enumerator with such enum value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
+template <detail::enum_subtype S, typename E>
+[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  return detail::endex<D>(value) != detail::invalid_index_v<D>;
+    return enum_index<D, S>(value);
 }
 
-// Checks whether enum contains enumerator with such integer value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
+// Obtains index in enum values from static storage enum variable.
+template <auto V, detail::enum_subtype S = detail::subtype_v<std::decay_t<decltype(V)>>>
+[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t<decltype(V), std::size_t> {\
+        using D = std::decay_t<decltype(V)>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+    constexpr auto index = enum_index<D, S>(V);
+    static_assert(index, "magic_enum::enum_index enum value does not have a index.");
 
-  return detail::undex<D>(value) != detail::invalid_index_v<D>;
+    return *index;
 }
 
-// Checks whether enum contains enumerator with such name.
-template <typename E, typename BinaryPredicate>
-[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
-  static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::enum_contains requires bool(char, char) invocable predicate.");
-
-  return enum_cast<D>(value, std::move_if_noexcept(p)).has_value();
-}
-
-// Checks whether enum contains enumerator with such name.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(string_view value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
+// Returns name from static storage enum variable.
+// This version is much lighter on the compile times and is not restricted to the enum_range limitation.
+template <auto V>
+[[nodiscard]] constexpr auto enum_name() noexcept -> detail::enable_if_t<decltype(V), string_view> {
+    constexpr string_view name = detail::enum_name_v<std::decay_t<decltype(V)>, V>;
+    static_assert(!name.empty(), "magic_enum::enum_name enum value does not have a name.");
 
-  return enum_cast<D>(value).has_value();
+    return name;
 }
 
-namespace ostream_operators {
+// Returns name from enum value.
+// If enum value does not have name or value out of range, returns empty string.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t<E, string_view> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-template <typename Char, typename Traits, typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, E value) {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED
-  if (const auto name = magic_enum::enum_name<D>(value); !name.empty()) {
-    for (const auto c : name) {
-      os.put(c);
+    if (const auto i = enum_index<D, S>(value)) {
+        return detail::names_v<D, S>[*i];
     }
-    return os;
-  }
-#endif
-  return (os << static_cast<U>(value));
+    return {};
 }
 
-template <typename Char, typename Traits, typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, optional<E> value) {
-  return value.has_value() ? (os << value.value()) : os;
-}
-
-} // namespace magic_enum::ostream_operators
-
-namespace bitwise_operators {
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E operator~(E rhs) noexcept {
-  return static_cast<E>(~static_cast<underlying_type_t<E>>(rhs));
-}
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E operator|(E lhs, E rhs) noexcept {
-  return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) | static_cast<underlying_type_t<E>>(rhs));
-}
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E operator&(E lhs, E rhs) noexcept {
-  return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) & static_cast<underlying_type_t<E>>(rhs));
-}
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E operator^(E lhs, E rhs) noexcept {
-  return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) ^ static_cast<underlying_type_t<E>>(rhs));
-}
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E& operator|=(E& lhs, E rhs) noexcept {
-  return lhs = (lhs | rhs);
-}
-
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E& operator&=(E& lhs, E rhs) noexcept {
-  return lhs = (lhs & rhs);
-}
+// Returns name from enum value.
+// If enum value does not have name or value out of range, returns empty string.
+template <detail::enum_subtype S, typename E>
+[[nodiscard]] constexpr auto enum_name(E value) -> detail::enable_if_t<E, string_view> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-template <typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-constexpr E& operator^=(E& lhs, E rhs) noexcept {
-  return lhs = (lhs ^ rhs);
+    return enum_name<D, S>(value);
 }
 
-} // namespace magic_enum::bitwise_operators
-
-namespace flags {
-
-// Returns type name of enum.
-using magic_enum::enum_type_name;
-
-// Returns number of enum-flags values.
-template <typename E>
-[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_enum_t<E, std::size_t> {
-  using D = std::decay_t<E>;
+// Returns std::array with names, sorted by enum value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  return detail::count_v<D, true>;
+    return detail::names_v<D, S>;
 }
 
-// Returns enum-flags value at specified index.
-// No bounds checking is performed: the behavior is undefined if index >= number of enum-flags values.
-template <typename E>
-[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_enum_t<E, std::decay_t<E>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D, true> > 0, "magic_enum::flags requires enum-flags implementation.");
-
-  if constexpr (detail::is_sparse_v<D, true>) {
-    return assert((index < detail::count_v<D, true>)), detail::values_v<D, true>[index];
-  } else {
-    constexpr auto min = detail::log2(detail::min_v<D, true>);
+// Returns std::array with pairs (value, name), sorted by enum value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-    return assert((index < detail::count_v<D, true>)), detail::value<D, min, true>(index);
-  }
+    return detail::entries_v<D, S>;
 }
 
-// Returns std::array with enum-flags values, sorted by enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_enum_t<E, detail::values_t<E, true>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D, true> > 0, "magic_enum::flags requires enum-flags implementation.");
+// Allows you to write magic_enum::enum_cast<foo>("bar", magic_enum::case_insensitive);
+inline constexpr auto case_insensitive = detail::case_insensitive<>{};
 
-  return detail::values_v<D, true>;
+// Obtains enum value from integer value.
+// Returns optional with enum value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+    if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
+#if defined(MAGIC_ENUM_ENABLE_HASH)
+        return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
+            [](D v) { return optional<D>{v}; },
+            static_cast<D>(value),
+            detail::default_result_type_lambda<optional<D>>);
+#else
+        for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+            if (value == static_cast<underlying_type_t<D>>(enum_value<D, S>(i))) {
+                return static_cast<D>(value);
+            }
+        }
+        return {}; // Invalid value or out of range.
+#endif
+    } else {
+        if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
+            return static_cast<D>(value);
+        }
+        return {}; // Invalid value or out of range.
+    }
 }
 
-// Returns name from enum-flags value.
-// If enum-flags value does not have name or value out of range, returns empty string.
-template <typename E>
-[[nodiscard]] auto enum_name(E value) -> detail::enable_if_enum_t<E, string> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  string name;
-  auto check_value = U{0};
-  for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
-    if (const auto v = static_cast<U>(enum_value<D>(i)); (static_cast<U>(value) & v) != 0) {
-      check_value |= v;
-      const auto n = detail::names_v<D, true>[i];
-      if (!name.empty()) {
-        name.append(1, '|');
-      }
-      name.append(n.data(), n.size());
+// Obtains enum value from name.
+// Returns optional with enum value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename BinaryPredicate = std::equal_to<>>
+[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
+    using D = std::decay_t<E>;
+    static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+#if defined(MAGIC_ENUM_ENABLE_HASH)
+    if constexpr (detail::is_default_predicate<BinaryPredicate>()) {
+        return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
+            [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
+            value,
+            detail::default_result_type_lambda<optional<D>>,
+            [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
     }
-  }
-
-  if (check_value != 0 && check_value == static_cast<U>(value)) {
-    return name;
-  }
-
-  return {}; // Invalid value or out of range.
+#endif
+    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+        if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
+            return enum_value<D, S>(i);
+        }
+    }
+    return {}; // Invalid value or out of range.
 }
 
-// Returns std::array with string names, sorted by enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_enum_t<E, detail::names_t<E, true>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D, true> > 0, "magic_enum::flags requires enum-flags implementation.");
+// Checks whether enum contains value with such value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t<E, bool> {
+    using D = std::decay_t<E>;
+    using U = underlying_type_t<D>;
 
-  return detail::names_v<D, true>;
+    return static_cast<bool>(enum_cast<D, S>(static_cast<U>(value)));
 }
 
-// Returns std::array with pairs (value, name), sorted by enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_enum_t<E, detail::entries_t<E, true>> {
-  using D = std::decay_t<E>;
-  static_assert(detail::count_v<D, true> > 0, "magic_enum::flags requires enum-flags implementation.");
+// Checks whether enum contains value with such value.
+template <detail::enum_subtype S, typename E>
+[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t<E, bool> {
+    using D = std::decay_t<E>;
+    using U = underlying_type_t<D>;
 
-  return detail::entries_v<D, true>;
+    return static_cast<bool>(enum_cast<D, S>(static_cast<U>(value)));
 }
 
-// Obtains enum-flags value from integer value.
-// Returns optional with enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  if constexpr (detail::is_sparse_v<D, true>) {
-    auto check_value = U{0};
-    for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
-      if (const auto v = static_cast<U>(enum_value<D>(i)); (value & v) != 0) {
-        check_value |= v;
-      }
-    }
-
-    if (check_value != 0 && check_value == value) {
-      return static_cast<D>(value);
-    }
-  } else {
-    constexpr auto min = detail::min_v<D, true>;
-    constexpr auto max = detail::value_ors<D>();
+// Checks whether enum contains value with such integer value.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
+[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
+    using D = std::decay_t<E>;
 
-    if (value >= min && value <= max) {
-      return static_cast<D>(value);
-    }
-  }
-
-  return {}; // Invalid value or out of range.
+    return static_cast<bool>(enum_cast<D, S>(value));
 }
 
-// Obtains enum-flags value from name.
-// Returns optional with enum-flags value.
-template <typename E, typename BinaryPredicate>
-[[nodiscard]] constexpr auto enum_cast(string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::flags::enum_cast requires bool(char, char) invocable predicate.");
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  auto result = U{0};
-  while (!value.empty()) {
-    const auto d = detail::find(value, '|');
-    const auto s = (d == string_view::npos) ? value : value.substr(0, d);
-    auto f = U{0};
-    for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
-      if (detail::cmp_equal(s, detail::names_v<D, true>[i], p)) {
-        f = static_cast<U>(enum_value<D>(i));
-        result |= f;
-        break;
-      }
-    }
-    if (f == U{0}) {
-      return {}; // Invalid value or out of range.
-    }
-    value.remove_prefix((d == string_view::npos) ? value.size() : d + 1);
-  }
+// Checks whether enum contains enumerator with such name.
+template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename BinaryPredicate = std::equal_to<>>
+[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, bool, BinaryPredicate> {
+    using D = std::decay_t<E>;
 
-  if (result == U{0}) {
-    return {}; // Invalid value or out of range.
-  } else {
-    return static_cast<D>(result);
-  }
+    return static_cast<bool>(enum_cast<D, S>(value, std::move(p)));
 }
 
-// Obtains enum-flags value from name.
-// Returns optional with enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_cast(string_view value) noexcept -> detail::enable_if_enum_t<E, optional<std::decay_t<E>>> {
-  using D = std::decay_t<E>;
+template <bool AsFlags = true>
+inline constexpr auto as_flags = AsFlags ? detail::enum_subtype::flags : detail::enum_subtype::common;
 
-  return enum_cast<D>(value, detail::char_equal_to{});
-}
+template <bool AsFlags = true>
+inline constexpr auto as_common = AsFlags ? detail::enum_subtype::common : detail::enum_subtype::flags;
 
-// Returns integer value from enum value.
-using magic_enum::enum_integer;
-
-// Obtains index in enum-flags values from enum-flags value.
-// Returns optional with index.
-template <typename E>
-[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_enum_t<E, optional<std::size_t>> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  if (detail::is_pow2(static_cast<U>(value))) {
-    for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
-      if (enum_value<D>(i) == value) {
-        return i;
-      }
-    }
-  }
+namespace bitwise_operators {
 
-  return {}; // Invalid value or out of range.
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E operator~(E rhs) noexcept {
+    return static_cast<E>(~static_cast<underlying_type_t<E>>(rhs));
 }
 
-// Checks whether enum-flags contains enumerator with such enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  return enum_cast<D>(static_cast<U>(value)).has_value();
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E operator|(E lhs, E rhs) noexcept {
+    return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) | static_cast<underlying_type_t<E>>(rhs));
 }
 
-// Checks whether enum-flags contains enumerator with such integer value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
-
-  return enum_cast<D>(value).has_value();
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E operator&(E lhs, E rhs) noexcept {
+    return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) & static_cast<underlying_type_t<E>>(rhs));
 }
 
-// Checks whether enum-flags contains enumerator with such name.
-template <typename E, typename BinaryPredicate>
-[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_t<E, bool> {
-  static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::flags::enum_contains requires bool(char, char) invocable predicate.");
-  using D = std::decay_t<E>;
-
-  return enum_cast<D>(value, std::move_if_noexcept(p)).has_value();
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E operator^(E lhs, E rhs) noexcept {
+    return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) ^ static_cast<underlying_type_t<E>>(rhs));
 }
 
-// Checks whether enum-flags contains enumerator with such name.
-template <typename E>
-[[nodiscard]] constexpr auto enum_contains(string_view value) noexcept -> detail::enable_if_enum_t<E, bool> {
-  using D = std::decay_t<E>;
-
-  return enum_cast<D>(value).has_value();
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E& operator|=(E& lhs, E rhs) noexcept {
+    return lhs = (lhs | rhs);
 }
 
-} // namespace magic_enum::flags
-
-namespace flags::ostream_operators {
-
-template <typename Char, typename Traits, typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, E value) {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED
-  if (const auto name = magic_enum::flags::enum_name<D>(value); !name.empty()) {
-    for (const auto c : name) {
-      os.put(c);
-    }
-    return os;
-  }
-#endif
-  return (os << static_cast<U>(value));
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E& operator&=(E& lhs, E rhs) noexcept {
+    return lhs = (lhs & rhs);
 }
 
-template <typename Char, typename Traits, typename E, std::enable_if_t<std::is_enum_v<E>, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, optional<E> value) {
-  return value.has_value() ? (os << value.value()) : os;
+template <typename E, detail::enable_if_t<E, int> = 0>
+constexpr E& operator^=(E& lhs, E rhs) noexcept {
+    return lhs = (lhs ^ rhs);
 }
 
-} // namespace magic_enum::flags::ostream_operators
+} // namespace magic_enum::bitwise_operators
 
 } // namespace magic_enum
 
@@ -1104,4 +1465,10 @@ std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& o
 #  pragma warning(pop)
 #endif
 
+#undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN
+#undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN
+#undef MAGIC_ENUM_VS_2017_WORKAROUND
+#undef MAGIC_ENUM_ARRAY_CONSTEXPR
+#undef MAGIC_ENUM_FOR_EACH_256
+
 #endif // NEARGYE_MAGIC_ENUM_HPP
diff --git a/src/base/property.cpp b/src/base/property.cpp
index d98acb31..61b9c623 100644
--- a/src/base/property.cpp
+++ b/src/base/property.cpp
@@ -7,6 +7,8 @@
 #include "property.h"
 
 #include "property_enumeration.h"
+
+#include <algorithm>
 #include <cassert>
 
 namespace Mayo {
diff --git a/src/base/property_enumeration.cpp b/src/base/property_enumeration.cpp
index 556c3e8e..1ef57091 100644
--- a/src/base/property_enumeration.cpp
+++ b/src/base/property_enumeration.cpp
@@ -6,12 +6,14 @@
 
 #include "property_enumeration.h"
 
+#include <algorithm>
 #include <stdexcept>
 
 namespace Mayo {
 
 PropertyEnumeration::PropertyEnumeration(
-        PropertyGroup* grp, const TextId& name, const Enumeration* enumeration)
+        PropertyGroup* grp, const TextId& name, const Enumeration* enumeration
+    )
     : Property(grp, name),
       m_enumeration(enumeration),
       m_value(enumeration && enumeration->empty() ? enumeration->itemAt(0).value : -1)
diff --git a/src/io_dxf/io_dxf.cpp b/src/io_dxf/io_dxf.cpp
index c911d79e..b602f4d4 100644
--- a/src/io_dxf/io_dxf.cpp
+++ b/src/io_dxf/io_dxf.cpp
@@ -500,29 +500,19 @@ void DxfReader::Internal::OnReadText(const Dxf_TEXT& text)
     // See doc https://ezdxf.readthedocs.io/en/stable/tutorials/text.html
     const DxfHJustification hjust = text.horizontalJustification;
     Graphic3d_HorizontalTextAlignment hAlign = Graphic3d_HTA_LEFT;
-    switch (hjust) {
-    case DxfHJustification::Center:
-    case DxfHJustification::Middle:
+    if (hjust == DxfHJustification::Center || hjust == DxfHJustification::Middle)
         hAlign = Graphic3d_HTA_CENTER;
-        break;
-    case DxfHJustification::Right:
+    else if (hjust == DxfHJustification::Right)
         hAlign = Graphic3d_HTA_RIGHT;
-        break;
-    }
 
     const DxfVJustification vjust = text.verticalJustification;
     Graphic3d_VerticalTextAlignment vAlign = Graphic3d_VTA_TOP;
-    switch (vjust) {
-    case DxfVJustification::Baseline:
+    if (vjust == DxfVJustification::Baseline)
         vAlign = Graphic3d_VTA_TOPFIRSTLINE;
-        break;
-    case DxfVJustification::Bottom:
+    else if (vjust == DxfVJustification::Bottom)
         vAlign = Graphic3d_VTA_BOTTOM;
-        break;
-    case DxfVJustification::Middle:
+    else if (vjust == DxfVJustification::Middle)
         vAlign = Graphic3d_VTA_CENTER;
-        break;
-    }
 
     // Ensure non-null extrusion direction
     gp_Vec extDir = toOccVec(text.extrusionDirection);
diff --git a/src/io_image/io_image.cpp b/src/io_image/io_image.cpp
index a8dc7731..88f09b6a 100644
--- a/src/io_image/io_image.cpp
+++ b/src/io_image/io_image.cpp
@@ -57,11 +57,13 @@ class ImageWriter::Properties : public PropertyGroup {
         this->height.setRange(0, std::numeric_limits<int>::max());
 
         this->cameraOrientation.setDescription(
-                    ImageWriterI18N::textIdTr("Camera orientation expressed in Z-up convention as a unit vector"));
+            ImageWriterI18N::textIdTr("Camera orientation expressed in Z-up convention as a unit vector")
+        );
         this->cameraProjection.mutableEnumeration().changeTrContext(ImageWriterI18N::textIdContext());
     }
 
-    void restoreDefaults() override {
+    void restoreDefaults() override
+    {
         const Parameters defaults;
         this->width.setValue(defaults.width);
         this->height.setValue(defaults.height);