#include <iostream>
#include <type_traits>
using namespace std;
 
template <typename T>
class RangeType{
    private:
        T start, stop, step;
    public:
        RangeType(T start, T stop, T step):start(start), stop(stop), step(step){ return; }
 
        class iterator{
            private:
                T current, stop, step;
                iterator():step(0){ return; }
                iterator(T current, T stop, T step):current(current), stop(stop), step(step){ return; }
                friend class RangeType;
                bool is_alive() const noexcept { return step > 0 ? current < stop : step < 0 ? current > stop : false; }
            public:
                T operator*() const noexcept{ return current; }
                iterator &operator++() noexcept{ current += step; return *this; }
 
                template <typename X>
                bool operator!=(X &&e) const noexcept { return is_alive(); }
        };
 
        iterator begin() const noexcept { return iterator(start, stop, step); }
        iterator end() const noexcept { return iterator(); }
};
 
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
inline RangeType<T> range(T stop){ return RangeType<T>(0, stop, 1); }
 
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
inline RangeType<T> range(T start, T stop, T step = 1){ return RangeType<T>(start, stop, step); }
 
int main(){
    for(auto i : range(128)){
        cout << i << ' ';
    }
    cout << endl;
}

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