enum class color { red, green, blue };

constexpr auto colors = std::array{
  mph::pair{"red", color::red}, // same as std::pair{mph::fixed_string{"red", color::red}}
  mph::pair{"green", color::green},
  mph::pair{"blue", color::blue},
};

static_assert(color::green == *mph::hash<colors>("green"));
static_assert(color::red   == *mph::hash<colors>("red"));
static_assert(color::blue  == *mph::hash<colors>("blue"));

assert(mph::hash<colors>("green"));
std::print("{}", *mph::hash<colors>("green")); // prints 1

constexpr auto primes = std::array{
  std::pair{2, 0}, std::pair{3, 1}, std::pair{5, 2},
  std::pair{7, 3}, std::pair{11, 4}, std::pair{13, 5},
  std::pair{17, 6}, std::pair{19, 7}, std::pair{23, 8},
  std::pair{29, 9}, std::pair{31, 10}, std::pair{37, 11},
  std::pair{41, 12}, std::pair{43, 13}, std::pair{47, 14},
};

constexpr auto hash = mph::hash<primes>;

static_assert(*hash(2) == 0 and *hash(3) == 1 and 
              *hash(5) == 2 and *hash(7) == 3 and
              *hash(11) == 4 and *hash(13) == 5 and 
              *hash(17) == 6 and *hash(19) == 7 and 
              *hash(23) == 8 and *hash(29) == 9 and
              *hash(31) == 10 and *hash(37) == 11 and
              *hash(41) == 12 and *hash(43) == 13 and
              *hash(47) == 14);

assert(hash(41));
std::print("{}", *hash(41)); // prints 12

int main(int argc, const char** argv) {
 constexpr auto symbols = std::array{
   mph::pair{"AAPL    ", 0},
   mph::pair{"AMZN    ", 1},
   mph::pair{"GOOGL   ", 2},
   mph::pair{"MSFT    ", 3},
   mph::pair{"NVDA    ", 4}
 };

  static_assert(0 == *mph::hash<symbols>("AAPL    "));
  static_assert(1 == *mph::hash<symbols>("AMZN    "));
  static_assert(2 == *mph::hash<symbols>("GOOGL   "));
  static_assert(3 == *mph::hash<symbols>("MSFT    "));
  static_assert(4 == *mph::hash<symbols>("NVDA    "));

  return *mph::hash<symbols>(std::span<const char, 8u>(argv[1], argv[1] + 8u));
}

int main(int argc, [[maybe_unused]] const char** argv) {
  static constexpr auto symbols = std::array{
    std::pair{std::array{'A', 'A', 'P', 'L', ' ', ' ', ' ', ' '}, 0},
    std::pair{std::array{'A', 'M', 'Z', 'N', ' ', ' ', ' ', ' '}, 1},
    std::pair{std::array{'G', 'O', 'O', 'G', 'L', ' ', ' ', ' '}, 2},
    std::pair{std::array{'M', 'S', 'F', 'T', ' ', ' ', ' ', ' '}, 3},
    std::pair{std::array{'N', 'V', 'D', 'A', ' ', ' ', ' ', ' '}, 4},
  };

  constexpr auto policies = []<const auto...ts>(auto&&... args) {
    return mph::pext<7u, mph::unconditional>{}.template operator()<ts...>(std::forward<decltype(args)>(args)...);
  };

  assert(argc >= 0 and argc < std::size(symbols));
  return *mph::hash<symbols, policies>(symbols[argc].first);
}

|  ns/op |            op/s |  err% |  total | benchmark
|-------:|----------------:|------:|-------:|:----------
|  25.14 |   39,778,176.57 |  0.2% |   0.30 | `random_strings_5_len_4.std.map`
|  25.16 |   39,739,318.14 |  0.6% |   0.30 | `random_strings_5_len_4.std.unordered_map`
|   8.22 |  121,703,338.98 |  0.5% |   0.10 | `random_strings_5_len_4.boost.unordered_map`
|  27.77 |   36,010,157.40 |  0.3% |   0.33 | `random_strings_5_len_4.boost.flat_map`
|  16.13 |   61,985,582.63 |  0.4% |   0.19 | `random_strings_5_len_4.gperf`
|   2.66 |  376,360,632.83 |  0.2% |   0.03 | `random_strings_5_len_4.mph`
|  30.27 |   33,034,412.64 |  0.6% |   0.36 | `random_strings_5_len_8.std.map`
|  19.75 |   50,645,196.71 |  0.1% |   0.24 | `random_strings_5_len_8.std.unordered_map`
|  18.43 |   54,258,799.08 |  0.1% |   0.22 | `random_strings_5_len_8.boost.unordered_map`
|  33.27 |   30,054,048.78 |  0.4% |   0.40 | `random_strings_5_len_8.boost.flat_map`
|  16.53 |   60,479,393.81 |  0.2% |   0.20 | `random_strings_5_len_8.gperf`
|   2.66 |  375,638,666.00 |  0.3% |   0.03 | `random_strings_5_len_8.mph`
|  42.61 |   23,467,168.55 |  0.1% |   0.51 | `random_strings_6_len_2_5.std.map`
|  33.27 |   30,060,501.50 |  1.6% |   0.40 | `random_strings_6_len_2_5.std.unordered_map`
|  26.66 |   37,509,837.59 |  0.1% |   0.32 | `random_strings_6_len_2_5.boost.unordered_map`
|  51.79 |   19,308,040.23 |  0.4% |   0.62 | `random_strings_6_len_2_5.boost.flat_map`
|   6.20 |  161,281,897.93 |  0.1% |   0.07 | `random_strings_6_len_2_5.gperf`
|   4.09 |  244,671,904.00 |  0.6% |   0.05 | `random_strings_6_len_2_5.mph`
|  61.95 |   16,140,954.78 |  0.1% |   0.74 | `random_strings_100_len_8.std.map`
|  28.82 |   34,692,661.89 |  0.0% |   0.35 | `random_strings_100_len_8.std.unordered_map`
|  20.08 |   49,792,117.35 |  0.5% |   0.24 | `random_strings_100_len_8.boost.unordered_map`
|  65.47 |   15,274,329.71 |  0.2% |   0.78 | `random_strings_100_len_8.boost.flat_map`
|  17.80 |   56,174,321.04 |  0.1% |   0.21 | `random_strings_100_len_8.gperf`
|   3.64 |  274,444,635.44 |  0.4% |   0.04 | `random_strings_100_len_8.mph`
|  99.79 |   10,020,949.63 |  0.2% |   1.19 | `random_strings_100_len_1_8.std.map`
|  48.71 |   20,528,601.73 |  0.4% |   0.58 | `random_strings_100_len_1_8.std.unordered_map`
|  35.09 |   28,501,348.31 |  0.3% |   0.42 | `random_strings_100_len_1_8.boost.unordered_map`
| 110.99 |    9,009,895.76 |  0.1% |   1.32 | `random_strings_100_len_1_8.boost.flat_map`
|  16.14 |   61,945,137.67 |  0.2% |   0.19 | `random_strings_100_len_1_8.gperf`
|   5.00 |  200,018,769.41 |  0.4% |   0.06 | `random_strings_100_len_1_8.mph`

/**
 * Minimal perfect hash function
 *
 * @tparam keys constexpr pair of id values such as std::array{{std::pair{"FOO"}, 1}, std::pair{"BAR"}, 2}}
 * @tparam policies invocable which returns the hash
 * @param data continuous input data such as std::string_view, std::span, std::array or intergral value
 * @param args... optional args propagated to policies
 * @return optional result of executing policies (*result = { mapped key: found, max_value<keys>+1u : not found })
 */
template<const auto keys, const auto policies = mph::policies> requires (std::size(keys) > 1u)
constexpr auto hash = [] [[nodiscard]] (auto&& data, auto &&...args) noexcept(true);

inline constexpr auto unconditional = []([[maybe_unused]] const bool cond, const auto lhs, [[maybe_unused]] const auto rhs) {
  return lhs; // [unsafe] returns unconditionally
};

inline constexpr auto conditional = [](const bool cond, const auto lhs, const auto rhs) {
  return cond ? lhs : rhs; // generates jmp (x86-64)
};

template<auto Probablity>
inline constexpr auto conditional_probability = [](const bool cond, const auto lhs, const auto rhs) {
  if (__builtin_expect_with_probability(cond, 1, Probablity)) {
    return lhs;
  } else {
    return rhs;
  }
};

inline constexpr auto branchless = [](const bool cond, const auto lhs, [[maybe_unused]] const auto rhs) {
  return cond * lhs; // generates cmov (x86-64)
};

inline constexpr auto branchless_table = [](const bool cond, const auto lhs, const auto rhs) {
  return std::array{rhs, lhs}[cond];
};

/**
 * Minimal perfect hash function based on SWAR
 *  reads sizeof(T) bytes and switches on that
 */
template<class T>
struct swar {
  template <const auto unknown, const auto keys>
    requires concepts::all_keys_size_lt<keys, sizeof(T)>
  [[nodiscard]] constexpr auto operator()(auto&& data, [[maybe_unused]] auto &&...args) const noexcept(true);
};

/**
 * Minimal perfect hash function based on intel's pext with support up to 2^max_bits_size elements and with max 8 characters
 *  requires platform with bmi2 support (https://en.wikipedia.org/wiki/X86_Bit_manipulation_instruction_set)
 */
template <const std::size_t max_bits_size, const auto result_policy = conditional>
struct pext {
  template <const auto unknown, const auto keys, class T, const auto mask = utility::find_mask<T>(keys())>
    requires concepts::bits_size_le<mask, max_bits_size> and concepts::all_keys_size_lt<keys, sizeof(T)>
  [[nodiscard]] [[gnu::target("bmi2")]] auto operator()(T&& data, [[maybe_unused]] auto &&...args) const noexcept(true);
};

/**
 * Minimal perfect hash function based on intel's pext with support up to 2^max_bits_size per split on N'th character and with max 8 characters
 *  requires platform with bmi2 support (https://en.wikipedia.org/wiki/X86_Bit_manipulation_instruction_set)
 */
template <const std::size_t max_bits_size, const std::size_t split_index, const auto result_policy = conditional>
struct pext_split {
  template <const auto unknown, const auto keys, class T, const auto masks = make_masks<T, keys>()>
    requires concepts::keys_bits_size_lt<masks, max_bits_size> and concepts::all_keys_size_lt<keys, sizeof(T)>
  [[nodiscard]] [[gnu::target("bmi2")]] auto operator()(T&& data, [[maybe_unused]] auto &&...args) const noexcept(true);
};

/**
 * Default policies
 *
 * @tparam unknown returned if there is no match
 * @tparam keys constexpr pair of id values such as std::array{{std::pair{"FOO"}, 1}, std::pair{"BAR"}, 2}}
 * @param data continuous input data such as std::string_view, std::span, std::array or integral value
 * @param args... args propagated to policies
 * @return second from matched key or unknown if not matched
 */
constexpr auto policies = []<const auto unknown, const auto keys>(auto&& data, auto&&... args) {
  if constexpr (requires { std::size(data); }) {
    if constexpr (auto min_max = utility::min_max_length<keys>; min_max.first == min_max.second and min_max.first == sizeof(std::uint32_t) and std::size(keys()) < 4u) {
      return mph::swar<std::uint32_t>{}<unknown, keys>(data, args...);
    } else if constexpr (min_max.first == min_max.second and min_max.first == sizeof(std::uint64_t) and std::size(keys()) < 4u) {
      return mph::swar<std::uint64_t>{}<unknown, keys>(data, args...);
    } else if constexpr (auto pext = mph::pext<7u>{}; requires { pext<unknown, keys>(data, args...); }) {
      return pext<unknown, keys>(data, args...);
    } else if constexpr (auto pext_split = mph::pext_split<7u, utility::find_unique_char_max_dist<keys>>{}; requires { pext_split<unknown, keys>(data, args...); }) {
      return pext_split<unknown, keys>(data, args...);
    } else {
      static_assert(false, "string hash can't be created with given policies!");
    }
  } else if constexpr (using T = std::remove_cvref_t<decltype(data)>; std::integral<T>) {
    if constexpr (sizeof(T) <= sizeof(std::uint32_t) and std::size(keys()) < 4u) {
      return mph::swar<std::uint32_t>{}<unknown, keys>(data, args...);
    } else if constexpr (sizeof(T) <= sizeof(std::uint64_t) and std::size(keys()) < 4u) {
      return mph::swar<std::uint64_t>{}<unknown, keys>(data, args...);
    } else if constexpr (auto pext = mph::pext<7u>{}; requires { pext<unknown, keys, T>(data, args...); }) {
      return pext<unknown, keys, T>(data, args...);
    } else {
      static_assert(false, "integral hash can't be created with given policies!");
    }
  } else {
    static_assert(false, "hash can't be created with given policies!");
  }
};

#define MPH 1'0'7 // Current library version (SemVer)
#define MPH_FIXED_STRING_MAX_SIZE 32u // [default]
#define MPH_CACHE_LINE_SIZE ::std::hardware_constructive_interference_size // [default] 64u
#define MPH_ALLOW_UNSAFE_MEMCPY 1 // [enabled by default] Faster but potentially unsafe memcpy, only required for string based keys
#define MPH_PAGE_SIZE 4096u // Only used if MPH_ALLOW_UNSAFE_MEMCPY is enabled