MOV al,0a5h
SHL ax,3

AND ax,01a5h

AND ax,0a5a5h

MOV al,0a5h
pva>SHL ax,3

AND ax,01a5h

AND ax,0a5a5h

#include <any>
#include <concepts>
#include <iostream>
#include <map>
#include <set>
#include <typeindex>

template <std::integral T>
struct Interval   // Вместо этого можно заюзать boost::interval
{
   T lower{};
   T upper{};
};

template <std::integral T>
class Set
{
public:
   using Interval = Interval<T>;

   void insert(T t) {insert({t, t});}  // Простые числа тоже хранятся как интервалы
   void insert(const Interval&);    // Вот тут нужно будет реализовать слияние интервалов
   bool contains(T t) const {
      const auto it = m_set.lower_bound(t);
      return it != m_set.end() and it->lower <= t;
   }

private:
   struct Comparer { // Хитрый компаратор
      using is_transparent = void;
      bool operator()(const Interval& a, const Interval& b) const {return a.upper < b.upper;}
      bool operator()(const Interval& a, T t) const { return a.upper < t; }
      bool operator()(T t, const Interval& a) const { return t < a.upper; }
   };
   std::set<Interval, Comparer> m_set;
};

class SuperSet
{
public:

   void insert(std::integral auto t) {get<decltype(t)>().insert(t);}
   template<std::integral T> bool contains(T t) const {return get<T>() and get<T>()->contains(t);}

private:
   template <std::integral T> Set<T>& get () {
      std::any& any = m_pool[typeid(T)];
      return any.has_value() ? std::any_cast<Set<T>&>(any) : any.emplace<Set<T>>();
   }
   template <std::integral T> const Set<T>* get() const;

   std::map<std::type_index, std::any> m_pool;
};

int main() {
   SuperSet s;
   s.contains(42);
}

template<typename T>
struct points_set
{
   std::function< bool(T) > impl;
 //...
   points_set operator & ( const points_set& rhs) const // добавить && по вкусу
   {
      return points_set { [l=this->impl, r=rhs.impl] (T i)->bool { return l(i) && r(i); } };
   }
     
   bool contains(T i) const { return impl(i); }
};

template<typename T>
struct points_set
{
   struct range{ T begin, end, step; };

   std::flat_set<T> points; // или unordered
   std::vector<range> ranges; // Можно сгруппировать по делителям / остаткам от деления если делители часто повторяются
};

template<typename T>
struct points_set
{
   bool out_of_range_value=flase; // это поле нужно только для поддержки "не"
   T begin, end;
   std::vector<bool> subrange_points;

   bool contains(T i) const { return ((i>=begin) && (i<end)) ? subrange_points.at(i-begin) : out_of_range_value; }
};

template<typename T>
struct points_set
{
   std::flat_map< T, std::flat_map< T, std::flat_set<T> > data; // data[begin][divider] -> remainders set 

   bool contains(T key) const 
   { 
      auto i = data.upper_bound(key);
      if(i==data.begin()) return false;
      --i;
      assert( i->first <= key ); 
      assert( i+1 == data.end() || (i+1)->first > key ); 

      for( auto & [divider, remainders] : i->second )
         if( remainders.contains( key % divider ))
            return true;
      return false;
   }
};