text: #ifndef CORE_META_HPP
  #define CORE_META_HPP
  
  #include <type_traits>
  #include <limits>
  #include <tuple>
  
  #include <cstdint>
  #include <cstddef>
  
  namespace core {
  inline namespace v2 {
  namespace meta {
  namespace impl {
  
  using false_t = ::std::false_type;
  using true_t = ::std::true_type;
  
  template <class T, T V> using integral = ::std::integral_constant<T, V>;
  template <bool B> using boolean = integral<bool, B>;
  
  template <class T> struct identity { using type = T; };
  
  template <class...> struct deducer : identity<void> { };
  template <class... Ts> using deduce = typename deducer<Ts...>::type;
  
  template <class T, class V, template <class...> class Detector, class... Args>
  struct detect : identity<T> { using value = false_t; };
  
  template <class T, template <class...> class Detector, class... Args>
  struct detect<T, deduce<Detector<Args...>>, Detector, Args...> :
    identity<Detector<Args...>>
  { using value = true_t; };
  
  template <class... Ts>
  struct list {
    static constexpr ::std::size_t size () noexcept { return sizeof...(Ts); }
    static constexpr bool empty () noexcept { return size() == 0u; }
  };
  
  template <class, template <class...> class> struct convert;
  template <class, class> struct rebind;
  template <class> struct into;
  
  template <class, template <class...> class, class...> struct filter;
  template <class, template <class...> class, class...> struct map;
  template <class...> struct join;
  
  template <template <class...> class, class...> struct apply;
  
  template <class, ::std::size_t> struct get;
  template <class, class> struct index_of;
  template <class> struct head;
  template <class> struct tail;
  
  template <class, template <class...> class, class...> struct count_if;
  template <class, template <class...> class, class...> struct find_if;
  template <class, class> struct count;
  template <class, class> struct find;
  
  template <class, ::std::size_t> struct rotate;
  template <class> struct reverse;
  
  template <class, class> struct equal;
  
  template <class, template <class...> class, class...> struct none_of;
  template <class, template <class...> class, class...> struct all_of;
  template <class, template <class...> class, class...> struct any_of;
  
  template <bool...> struct none;
  template <bool...> struct all;
  template <bool...> struct any;
  
  template <class... Ts, template <class...> class To>
  struct convert<list<Ts...>, To> : identity<To<Ts...>> { };
  
  template <template <class...> class To, class... Ts, class... Us>
  struct rebind<list<Ts...>, To<Us...>> : identity<To<Ts...>> { };
  
  template <template <class...> class T, class... Ts>
  struct into<T<Ts...>> : identity<list<Ts...>> { };
  
  template <template <class...> class F, class... Ts, class... Args>
  struct filter<list<Ts...>, F, Args...> :
    join<
      typename ::std::conditional<
        F<Ts, Args...>::value,
        list<Ts>,
        list<>
      >::type...
    >
  { };
  
  template <template <class...> class F, class... Ts, class... Args>
  struct map<list<Ts...>, F, Args...> : identity<list<F<Ts, Args...>...>> { };
  
  template <class... Ts> struct join<list<Ts...>> : identity<list<Ts...>> { };
  template <class... Ts, class... Us, class... Vs>
  struct join<list<Ts...>, list<Us...>, Vs...> :
    join<list<Ts..., Us...>, Vs...>
  { };
  
  template <class T, class... Ts>
  struct index_of<list<Ts...>, T> : integral<
    ::std::size_t,
    list<Ts...>::size() - find<list<Ts...>, T>::type::size()
  > { };
  
  template <class T, class... Ts>
  struct get<list<T, Ts...>, 0> : identity<T> { };
  template <class T, class... Ts, size_t N>
  struct get<list<T, Ts...>, N> :
    get<list<Ts...>, N - 1>
  { static_assert(N < (sizeof...(Ts) + 1),""); };
  
  
  template <class T, class... Ts>
  struct head<list<T, Ts...>> : identity<T> { };
  template <class T, class... Ts>
  struct tail<list<T, Ts...>> : identity<list<Ts...>> { };
  
  template <class... Ts, template <class...> class F, class... Args>
  struct count_if<list<Ts...>, F, Args...> : integral<
    ::std::size_t,
    filter<list<Ts...>, F, Args...>::type::size()
  > { };
  
  template <template <class...> class F, class... Args>
  struct find_if<list<>, F, Args...> : identity<list<>> { };
  
  template <template <class...> class F, class T, class... Ts, class... Args>
  struct find_if<list<T, Ts...>, F, Args...> : ::std::conditional<
    F<Args..., T>::value,
    list<T, Ts...>,
    typename find_if<list<Ts...>, F, Args...>::type
  > { };
  
  template <class T, class U> struct count : count_if<T, ::std::is_same, U> { };
  template <class T, class U> struct find : find_if<T, ::std::is_same, U> { };
  
  template <template <class...> class F, class... Ts, class... Args>
  struct none_of<list<Ts...>, F, Args...> : none<F<Ts, Args...>::value...> { };
  
  template <template <class...> class F, class... Ts, class... Args>
  struct all_of<list<Ts...>, F, Args...> : all<F<Ts, Args...>::value...> { };
  
  template <template <class...> class F, class... Ts, class... Args>
  struct any_of<list<Ts...>, F, Args...> : any<F<Ts, Args...>::value...> { };
  
  template <bool B, bool... Bs> struct none<B, Bs...> :
    boolean<not B and none<Bs...>::value>
  { };
  template <> struct none<> : true_t { };
  
  template <bool B, bool... Bs> struct all<B, Bs...> :
    boolean<B and all<Bs...>::value>
  { };
  template <> struct all<> : true_t { };
  
  template <bool B, bool... Bs> struct any<B, Bs...> :
    boolean<B or any<Bs...>::value>
  { };
  template <> struct any<> : false_t { };
  
  template <class T, template <class...> class U>
  struct is_specialization_of : false_t { };
  template <template <class...> class T, class... Ts>
  struct is_specialization_of<T<Ts...>, T> : true_t { };
  
  }}}} /* namespace core::v2::meta::impl */
  
  namespace core {
  inline namespace v2 {
  namespace meta {
  
  template <bool B, class T = void>
  using unless = typename ::std::enable_if<not B, T>::type;
  
  template <bool B, class T = void>
  using when = typename ::std::enable_if<B, T>::type;
  
  template <bool B> using inhibit = unless<B, ::std::size_t>;
  template <bool B> using require = when<B, ::std::size_t>;
  
  template <bool B, class T, class F>
  using either = typename ::std::conditional<B, T, F>::type;
  
  using impl::integral;
  using impl::boolean;
  
  using impl::false_t;
  using impl::true_t;
  
  using impl::identity;
  using impl::list;
  
  using impl::is_specialization_of;
  
  template <class... Ts> using deduce = typename impl::deduce<Ts...>;
  
  template <class T, template <class...> class U>
  using convert = typename impl::convert<T, U>::type;
  
  template <class T, class U> using rebind = typename impl::rebind<T, U>::type;
  template <class T> using into = typename impl::into<T>::type;
  
  template <class... Ts> using join = typename impl::join<Ts...>::type;
  
  template <class T, size_t N> using get = typename impl::get<T, N>::type;
  template <class T> using head = typename impl::head<T>::type;
  template <class T> using tail = typename impl::tail<T>::type;
  
  template <class T, class U>
  using index_of_t = impl::index_of<T, U>;
  
  template <class T, template <class...> class F, class... Args>
  using count_if_t = impl::count_if<T, F, Args...>;
  
  template <class T, template <class...> class F, class... Args>
  using find_if = typename impl::find_if<T, F>::type;
  
  template <class T, class U> using count_t = impl::count<T, U>;
  
  template <class T, class U>
  using find = typename impl::find<T, U>::type;
  
  template <class T, template <class...> class F, class... Args>
  using none_of_t = impl::none_of<T, F, Args...>;
  
  template <class T, template <class...> class F, class... Args>
  using all_of_t = impl::all_of<T, F, Args...>;
  
  template <class T, template <class...> class F, class... Args>
  using any_of_t = impl::any_of<T, F, Args...>;
  
  template <bool... Bs> using none_t = impl::none<Bs...>;
  template <bool... Bs> using all_t = impl::all<Bs...>;
  template <bool... Bs> using any_t = impl::any<Bs...>;
  
  template <class T, class U>
  constexpr ::std::size_t index_of () noexcept {
    return index_of_t<T, U>::value;
  }
  
  template <class T, template <class...> class F, class... Args>
  constexpr ::std::size_t count_if () noexcept {
    return count_if_t<T, F, Args...>::value;
  }
  
  template <class T, class U>
  constexpr ::std::size_t count () noexcept { return count_t<T, U>::value; }
  
  template <class T, template <class...> class F, class... Args>
  constexpr bool none_of () noexcept { return none_of_t<T, F, Args...>::value; }
  
  template <class T, template <class...> class F, class... Args>
  constexpr bool all_of () noexcept { return all_of_t<T, F, Args...>::value; }
  
  template <class T, template <class...> class F, class... Args>
  constexpr bool any_of () noexcept { return any_of_t<T, F, Args...>::value; }
  
  template <bool... Bs>
  constexpr bool none () noexcept { return none_t<Bs...>::value; }
  
  template <bool... Bs>
  constexpr bool all () noexcept { return all_t<Bs...>::value; }
  
  template <bool... Bs>
  constexpr bool any () noexcept { return any_t<Bs...>::value; }
  
  }}} /* namespace core::v2::meta */
  
  namespace core {
  inline namespace v2 {
  namespace meta {
  
  template <class T, T... I> struct integer_sequence : identity<T> {
    static_assert(
      ::std::is_integral<T>::value,
      "integer_sequence must use an integral type"
    );
  
    template <T N> using append = integer_sequence<T, I..., N>;
    static constexpr ::std::size_t size() noexcept { return sizeof...(I); }
    using next = append<sizeof...(I)>;
  };
  
  template <class T, T Index, ::std::size_t N>
  struct iota : identity<
    typename iota<T, Index - 1, N - 1u>::type::next
  > { static_assert(Index >= 0, "Index cannot be negative"); };
  
  template <class T, T Index>
  struct iota<T, Index, 0u> : identity<integer_sequence<T>> { };
  
  template <::std::size_t... I>
  using index_sequence = integer_sequence<::std::size_t, I...>;
  
  template <class T, T N>
  using make_integer_sequence = typename iota<T, N, N>::type;
  
  template <::std::size_t N>
  using make_index_sequence = make_integer_sequence<::std::size_t, N>;
  
  template <class... Ts>
  using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
  
  template <class> struct index_sequence_from;
  
  }}} /* namespace core::meta::v2 */
  
  #endif /* CORE_META_HPP */
  