class Iterator<T> {
    pub. Bool hasNext;
    testNext() {}
    getNext(T next) {}
}

class Iterable<T> {
    newIterator(&Iterator<T:-T> iterator) {}
}

class Nothing<T> {
    newIterator(&Iterator<T:-T> iterator) {
        NothingItr<T:-T>.new(iterator);
    }
}

class NothingItr<T> {
    pub. Bool hasNext;
    testNext() {
        self.hasNext := false;
    }
    getNext(T next) {}
}

class Range {
    priv. Int a;
    priv. Int b;
    init(Int a, Int b) {
        self.a := a;
        self.b := b;
    }
    newIterator(&Iterator<T:-Int> iterator) {
        RangeItr.new(iterator);
        ((RangeItr)iterator).init(self.a, self.b : a, b : _, _);
    }
}

class RangeItr {
    pub. Bool hasNext;
    init(Int a, Int b) {
        self.i := a;
        self.b := b;
    }
    testNext() {
        self.hasNext := ltInt(self.i, self.b);
    }
    getNext(Int next) {
        next := self.i;
        self.i := add(self.i, 1);
    }
    
    priv. Int i;
    priv. Int b;
}

class InfItr {
    pub. Bool hasNext;
    testNext() {
        self.hasNext := true;
    }
}

class From {
    priv. Int s;
    init(Int s) {
        self.s := s;
    }
    newIterator(&Iterator<T:-Int> iterator) {
        FromItr.new(iterator);
        ((FromItr)iterator).init(self.s : s : _);
    }
}

class FromItr ext. InfItr {
    priv. Int s;
    init(Int s) {
        self.s := s;
    }
    clone(&(Iterator<T:-Int>, ClonableIterator<T:-Int>) iterator) {
        FromItr.new(iterator);
        ((FromItr)iterator).s := self.s;
    }
    getNext(Int next) {
        next := self.s;
        self.s := add(self.s, 1);
    }
}

class Take<T> {
    priv. &Iterable<T:-T> s;
    priv. Int n;
    init(&Iterable<T:-T> s, Int n) {
        self.s := s;
        self.n := n;
    }
    newIterator(&Iterator<T:-T> iterator) {
        TakeItr<T:-T>.new(iterator);
        ((TakeItr<T:-T>)iterator).init(self.s, self.n : s, n : _, _);
    }
}

class TakeItr<T> {
    priv. &Iterator<T:-T> i;
    priv. Int n;
    pub. Bool hasNext;
    init(&Iterable<T:-T> s, Int n) {
        s.newIterator(_ : iterator : self.i);
        self.n := n;
    }
    testNext() {
        self.hasNext := gtInt(self.n, 0);
        if ( self.hasNext ) {
            self.i.testNext();
            self.hasNext := self.i.hasNext;
        } else {}
    }
    getNext(T next) {
        self.i.getNext(_ : next : next);
        self.n := sub(self.n, 1);
    }
}

class Drop<T> {
    priv. &Iterable<T:-T> s;
    priv. Int n;
    init(&Iterable<T:-T> s, Int n) {
        self.s := s;
        self.n := n;
    }
    newIterator(&Iterator<T:-T> iterator) {
        DropItr<T:-T>.new(iterator);
        ((DropItr<T:-T>)iterator).init(self.s, self.n : s, n : _, _);
    }
}

class DropItr<T> {
    priv. &Iterator<T:-T> i;
    priv. Int n;
    pub. Bool hasNext;
    init(&Iterable<T:-T> s, Int n) {
        s.newIterator(_ : iterator : self.i);
        self.n := n;
    }
    testNext() {
        self.i.testNext();
        var T next;
        while ( and(gtInt(self.n, 0), self.i.hasNext) ) {
            self.i.getNext(_ : next : _);
            self.n := sub(self.n, 1);
            self.i.testNext();
        }
        end next;
        self.hasNext := self.i.hasNext;
    }
    getNext(T next) {
        self.i.getNext(_ : next : next);
    }
}

class Pred<T> {
    pub. Bool ok;
    eval(T x) {}
}

class Filter<T> {
    priv. &Iterable<T:-T> s;
    priv. &Pred<T:-T> p;
    init(&Iterable<T:-T> s, &Pred<T:-T> p) {
        self.s := s;
        self.p := p;
    }
    newIterator(&Iterator<T:-T> iterator) {
        FilterItr<T:-T>.new(iterator);
        ((FilterItr<T:-T>)iterator).init(self.s, self.p : s, p : _, _);
    }
}

class FilterItr<T> {
    priv. &Iterator<T:-T> i;
    priv. &Pred<T:-T> p;
    priv. T next;
    priv. Bool nextTaken;
    pub. Bool hasNext;
    init(&Iterable<T:-T> s, &Pred<T:-T> p) {
        s.newIterator(_ : iterator : self.i);
        self.p := p;
        self.nextTaken := false;
    }
    clone(&(Iterator<T:-T>, ClonableIterator<T:-T>) iterator) {
        FilterItr<T:-T>.new(iterator);
        ((FilterItr<T:-T>)iterator).i := self.i;
        ((FilterItr<T:-T>)iterator).p := self.p;
        ((FilterItr<T:-T>)iterator).next := self.next;
        ((FilterItr<T:-T>)iterator).nextTaken := self.nextTaken;
        ((FilterItr<T:-T>)iterator).hasNext := self.hasNext;
    }
    testNext() {
        if ( not(self.nextTaken) ) {
            self.hasNext := false;
            var Bool more;
            more := true;
            while ( and(not(self.hasNext), more) ) {
                self.i.testNext();
                if ( self.i.hasNext ) {
                    self.i.getNext(_ : next : self.next);
                    self.p.eval(self.next : x : _);
                    self.hasNext := self.p.ok;
                } else more := false;
            }
            end more;
            self.nextTaken := true;
        } else {}
    }
    getNext(T next) {
        self.testNext();
        next := self.next;
        self.nextTaken := false;
    }
}

class Div {
    pub. Bool ok;
    priv. Int divisor;
    init(Int divisor) {
        self.divisor := divisor;
    }
    eval(Int x) {
        self.ok := eqInt(0, mod(x, self.divisor));
    }
}

class NotDiv {
    pub. Bool ok;
    priv. Int divisor;
    init(Int divisor) {
        self.divisor := divisor;
    }
    eval(Int x) {
        self.ok := not(eqInt(0, mod(x, self.divisor)));
    }
}

class Concat<T> {
    priv. &Iterable<T:-T> a;
    priv. &Iterable<T:-T> b;
    init(&Iterable<T:-T> a, &Iterable<T:-T> b) {
        self.a := a;
        self.b := b;
    }
    newIterator(&Iterator<T:-T> iterator) {
        ConcatItr<T:-T>.new(iterator);
        ((ConcatItr<T:-T>)iterator).init(self.a, self.b : a, b : _, _);
    }
}

class ConcatItr<T> {
    priv. &Iterator<T:-T> i;
    priv. &Iterable<T:-T> b;
    priv. Bool first;
    pub. Bool hasNext;
    init(&Iterable<T:-T> a, &Iterable<T:-T> b) {
        a.newIterator(self.i : iterator : self.i);
        self.b := b;
        self.first := true;
    }
    testNext() {
        self.i.testNext();
        self.hasNext := self.i.hasNext;
        if ( and(self.first, not(self.hasNext)) ) {
            self.b.newIterator(_ : iterator : self.i);
            self.i.testNext();
            self.hasNext := self.i.hasNext;
            self.first := false;
        } else {}
    }
    getNext(T next) {
        self.i.getNext(_ : next : next);
    }
}

class ClonableIterator<T> {
    clone(&(Iterator<T:-T>, ClonableIterator<T:-T>) iterator) {}
}

class Snapshot<T> {
    priv. &(Iterator<T:-T>, ClonableIterator<T:-T>) i;
    init(&ClonableIterator<T:-T> i) {
        i.clone(_ : iterator : self.i);
    }
    newIterator(&Iterator<T:-T> iterator) {
        self.i.clone(_ : iterator : iterator);
    }
}

class Sieve {
    priv. &Iterable<T:-Int> s;

    init(&Iterable<T:-Int> s) {
        self.s := s;
    }
    newIterator(&Iterator<T:-Int> iterator) {
        SieveItr.new(iterator);
        ((SieveItr)iterator).init(self.s : s : _);
    }
}

class SieveItr {    
    priv. &Iterator<T:-Int> i;
    priv. Int stage;
    priv. NotDiv nd;
    pub. Bool hasNext;
    
    init(&Iterable<T:-Int> s) {
        s.newIterator(_ : iterator : self.i);
        self.stage := 0;
    }
    testNext() {    
        if ( eqInt(1, self.stage) ) {
            var Snapshot<T:-Int> snapshot, Filter<T:-Int> filter, Sieve sieve;
        
            Snapshot<T:-Int>.new(snapshot);
            snapshot.init((&(Iterator<T:-Int>, ClonableIterator<T:-Int>))self.i : i : _);
        
            Filter<T:-Int>.new(filter);
            filter.init(snapshot, self.nd : s, p : _, _);
        
            Sieve.new(sieve);
            sieve.init(filter : s : _);
            
            sieve.newIterator(_ : iterator (SieveItr) : self.i);
            self.stage := 2;
            
            end snapshot, filter, sieve;
        } else {}

        self.i.testNext();
        self.hasNext := self.i.hasNext;
    }
    getNext(Int next) {    
        self.i.getNext(_ : next : next);
        
        if ( eqInt(0, self.stage) ) {
            NotDiv.new(self.nd);
            self.nd.init(next : divisor : _);
            
            self.stage := _;        // wildcard test
            
            self.stage := 1;
            
            _ := 2;                 // wildcard test
            _ := _;                 // wildcard test
        } else {}
    }
}

class Static<T> {
    iterate(&Iterable<T:-T> s) {
        var &Iterator<T:-T> i;
        s.newIterator(_ : iterator : i);
        i.testNext();
        while ( i.hasNext ) {
            var T x;
            i.getNext(_ : next : x);
            print x;
            i.testNext();
            end x;
        }
        print;
        end i;
    }
}

main {
    Range range, From from, Concat<T:-Int> concat, Sieve sieve;
    
    var Static<T:-Int> sta;
    Static<T:-Int>.new(sta);
    
    Range.new(range);
    range.init(100, 120 : a, b : _, _);

    Concat<T:-Int>.new(concat);
    concat.init(range, range : a, b : _, _);
    
    sta.iterate(concat : s : _);
    
    From.new(from);
    from.init(2000 : s : _);
    
    var Take<T:-Int> take, Drop<T:-Int> drop, Filter<T:-Int> filter, Div d;
    
    Take<T:-Int>.new(take);
    take.init(from, 80 : s, n : _, _);
    
    Drop<T:-Int>.new(drop);
    drop.init(take, 20 : s, n : _, _);
    
    sta.iterate(drop : s : _);

    Div.new(d);
    d.init(3 : divisor : _);
    
    Filter<T:-Int>.new(filter);
    filter.init(drop, d : s, p : _, _);

    sta.iterate(filter : s : _);
    
    end take, drop, filter, d;

    var Take<T:-Int> take;

    from.init(2 : s : _);

    Sieve.new(sieve);
    sieve.init(from : s : _);

    Take<T:-Int>.new(take);
    take.init(sieve, 25 : s, n : _, _);

    sta.iterate(take : s : _);
    
    end take;
    
    end sta;
}