YES

Problem:
 active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
 active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
 active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
 active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
 active(nats(N)) -> mark(cons(N,nats(s(N))))
 active(zprimes()) -> mark(sieve(nats(s(s(0())))))
 mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
 mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
 mark(0()) -> active(0())
 mark(s(X)) -> active(s(mark(X)))
 mark(sieve(X)) -> active(sieve(mark(X)))
 mark(nats(X)) -> active(nats(mark(X)))
 mark(zprimes()) -> active(zprimes())
 filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
 filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
 filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
 filter(active(X1),X2,X3) -> filter(X1,X2,X3)
 filter(X1,active(X2),X3) -> filter(X1,X2,X3)
 filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
 cons(mark(X1),X2) -> cons(X1,X2)
 cons(X1,mark(X2)) -> cons(X1,X2)
 cons(active(X1),X2) -> cons(X1,X2)
 cons(X1,active(X2)) -> cons(X1,X2)
 s(mark(X)) -> s(X)
 s(active(X)) -> s(X)
 sieve(mark(X)) -> sieve(X)
 sieve(active(X)) -> sieve(X)
 nats(mark(X)) -> nats(X)
 nats(active(X)) -> nats(X)

Proof:
 DP Processor:
  DPs:
   active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
   active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
   active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
   active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
   active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
   active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
   active#(sieve(cons(0(),Y))) -> sieve#(Y)
   active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
   active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
   active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
   active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
   active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
   active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
   active#(nats(N)) -> s#(N)
   active#(nats(N)) -> nats#(s(N))
   active#(nats(N)) -> cons#(N,nats(s(N)))
   active#(nats(N)) -> mark#(cons(N,nats(s(N))))
   active#(zprimes()) -> s#(0())
   active#(zprimes()) -> s#(s(0()))
   active#(zprimes()) -> nats#(s(s(0())))
   active#(zprimes()) -> sieve#(nats(s(s(0()))))
   active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
   mark#(filter(X1,X2,X3)) -> mark#(X3)
   mark#(filter(X1,X2,X3)) -> mark#(X2)
   mark#(filter(X1,X2,X3)) -> mark#(X1)
   mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
   mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
   mark#(cons(X1,X2)) -> mark#(X1)
   mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
   mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
   mark#(0()) -> active#(0())
   mark#(s(X)) -> mark#(X)
   mark#(s(X)) -> s#(mark(X))
   mark#(s(X)) -> active#(s(mark(X)))
   mark#(sieve(X)) -> mark#(X)
   mark#(sieve(X)) -> sieve#(mark(X))
   mark#(sieve(X)) -> active#(sieve(mark(X)))
   mark#(nats(X)) -> mark#(X)
   mark#(nats(X)) -> nats#(mark(X))
   mark#(nats(X)) -> active#(nats(mark(X)))
   mark#(zprimes()) -> active#(zprimes())
   filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
   filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
   filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
   filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
   filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
   filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
   cons#(mark(X1),X2) -> cons#(X1,X2)
   cons#(X1,mark(X2)) -> cons#(X1,X2)
   cons#(active(X1),X2) -> cons#(X1,X2)
   cons#(X1,active(X2)) -> cons#(X1,X2)
   s#(mark(X)) -> s#(X)
   s#(active(X)) -> s#(X)
   sieve#(mark(X)) -> sieve#(X)
   sieve#(active(X)) -> sieve#(X)
   nats#(mark(X)) -> nats#(X)
   nats#(active(X)) -> nats#(X)
  TRS:
   active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
   active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
   active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
   active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
   active(nats(N)) -> mark(cons(N,nats(s(N))))
   active(zprimes()) -> mark(sieve(nats(s(s(0())))))
   mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
   mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
   mark(0()) -> active(0())
   mark(s(X)) -> active(s(mark(X)))
   mark(sieve(X)) -> active(sieve(mark(X)))
   mark(nats(X)) -> active(nats(mark(X)))
   mark(zprimes()) -> active(zprimes())
   filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
   filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
   filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
   filter(active(X1),X2,X3) -> filter(X1,X2,X3)
   filter(X1,active(X2),X3) -> filter(X1,X2,X3)
   filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
   cons(mark(X1),X2) -> cons(X1,X2)
   cons(X1,mark(X2)) -> cons(X1,X2)
   cons(active(X1),X2) -> cons(X1,X2)
   cons(X1,active(X2)) -> cons(X1,X2)
   s(mark(X)) -> s(X)
   s(active(X)) -> s(X)
   sieve(mark(X)) -> sieve(X)
   sieve(active(X)) -> sieve(X)
   nats(mark(X)) -> nats(X)
   nats(active(X)) -> nats(X)
  TDG Processor:
   DPs:
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    active#(nats(N)) -> s#(N)
    active#(nats(N)) -> nats#(s(N))
    active#(nats(N)) -> cons#(N,nats(s(N)))
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    active#(zprimes()) -> s#(0())
    active#(zprimes()) -> s#(s(0()))
    active#(zprimes()) -> nats#(s(s(0())))
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(0()) -> active#(0())
    mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(sieve(X)) -> mark#(X)
    mark#(sieve(X)) -> sieve#(mark(X))
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(nats(X)) -> mark#(X)
    mark#(nats(X)) -> nats#(mark(X))
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(zprimes()) -> active#(zprimes())
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2)
    s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X)
    sieve#(mark(X)) -> sieve#(X)
    sieve#(active(X)) -> sieve#(X)
    nats#(mark(X)) -> nats#(X)
    nats#(active(X)) -> nats#(X)
   TRS:
    active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
    active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
    active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
    active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
    active(nats(N)) -> mark(cons(N,nats(s(N))))
    active(zprimes()) -> mark(sieve(nats(s(s(0())))))
    mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
    mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
    mark(0()) -> active(0())
    mark(s(X)) -> active(s(mark(X)))
    mark(sieve(X)) -> active(sieve(mark(X)))
    mark(nats(X)) -> active(nats(mark(X)))
    mark(zprimes()) -> active(zprimes())
    filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
    filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
    filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
    filter(active(X1),X2,X3) -> filter(X1,X2,X3)
    filter(X1,active(X2),X3) -> filter(X1,X2,X3)
    filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
    cons(mark(X1),X2) -> cons(X1,X2)
    cons(X1,mark(X2)) -> cons(X1,X2)
    cons(active(X1),X2) -> cons(X1,X2)
    cons(X1,active(X2)) -> cons(X1,X2)
    s(mark(X)) -> s(X)
    s(active(X)) -> s(X)
    sieve(mark(X)) -> sieve(X)
    sieve(active(X)) -> sieve(X)
    nats(mark(X)) -> nats(X)
    nats(active(X)) -> nats(X)
   graph:
    nats#(mark(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
    nats#(mark(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
    nats#(active(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
    nats#(active(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
    s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    sieve#(mark(X)) -> sieve#(X) -> sieve#(active(X)) -> sieve#(X)
    sieve#(mark(X)) -> sieve#(X) -> sieve#(mark(X)) -> sieve#(X)
    sieve#(active(X)) -> sieve#(X) -> sieve#(active(X)) -> sieve#(X)
    sieve#(active(X)) -> sieve#(X) ->
    sieve#(mark(X)) -> sieve#(X)
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(zprimes()) -> s#(0())
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(nats(N)) -> s#(N)
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(zprimes()) -> active#(zprimes()) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(nats(X)) -> nats#(mark(X)) ->
    nats#(active(X)) -> nats#(X)
    mark#(nats(X)) -> nats#(mark(X)) -> nats#(mark(X)) -> nats#(X)
    mark#(nats(X)) -> mark#(X) -> mark#(zprimes()) -> active#(zprimes())
    mark#(nats(X)) -> mark#(X) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
    mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
    mark#(nats(X)) -> mark#(X) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
    mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
    mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(nats(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(nats(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(nats(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(nats(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(nats(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(nats(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(nats(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(zprimes()) -> s#(0())
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(nats(N)) -> s#(N)
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(nats(X)) -> active#(nats(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(sieve(X)) -> sieve#(mark(X)) ->
    sieve#(active(X)) -> sieve#(X)
    mark#(sieve(X)) -> sieve#(mark(X)) -> sieve#(mark(X)) -> sieve#(X)
    mark#(sieve(X)) -> mark#(X) ->
    mark#(zprimes()) -> active#(zprimes())
    mark#(sieve(X)) -> mark#(X) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
    mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
    mark#(sieve(X)) -> mark#(X) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
    mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
    mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(sieve(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(sieve(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(sieve(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(sieve(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(sieve(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(sieve(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(sieve(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(sieve(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(sieve(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(zprimes()) -> s#(0())
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(nats(N)) -> s#(N)
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(sieve(X)) -> active#(sieve(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
    mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
    mark#(s(X)) -> mark#(X) -> mark#(zprimes()) -> active#(zprimes())
    mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(s(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(s(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(s(X)) -> mark#(X) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(zprimes()) -> s#(0())
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(nats(N)) -> s#(N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(zprimes()) -> active#(zprimes())
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(nats(X)) -> nats#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(nats(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(sieve(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(s(X)) -> s#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(s(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(0()) -> active#(0())
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(filter(X1,X2,X3)) -> mark#(X3) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(zprimes()) -> active#(zprimes())
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(nats(X)) -> nats#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(nats(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(sieve(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(s(X)) -> s#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(s(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(0()) -> active#(0())
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(filter(X1,X2,X3)) -> mark#(X2) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(zprimes()) -> active#(zprimes())
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(nats(X)) -> nats#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(nats(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(sieve(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(s(X)) -> s#(mark(X))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(s(X)) -> mark#(X)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(0()) -> active#(0())
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(filter(X1,X2,X3)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(zprimes()) -> s#(0())
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(nats(N)) -> s#(N)
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(0()) -> active#(0()) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(0()) -> active#(0()) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(0()) -> active#(0()) -> active#(zprimes()) -> nats#(s(s(0())))
    mark#(0()) -> active#(0()) -> active#(zprimes()) -> s#(s(0()))
    mark#(0()) -> active#(0()) -> active#(zprimes()) -> s#(0())
    mark#(0()) -> active#(0()) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(0()) -> active#(0()) -> active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(0()) -> active#(0()) -> active#(nats(N)) -> nats#(s(N))
    mark#(0()) -> active#(0()) -> active#(nats(N)) -> s#(N)
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(0()) -> active#(0()) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(0()) -> active#(0()) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(zprimes()) -> active#(zprimes())
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(nats(X)) -> nats#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nats(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sieve(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(zprimes()) -> sieve#(nats(s(s(0()))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(zprimes()) -> nats#(s(s(0())))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(zprimes()) -> s#(s(0()))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(zprimes()) -> s#(0())
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(nats(N)) -> mark#(cons(N,nats(s(N))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(nats(N)) -> cons#(N,nats(s(N)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(nats(N)) -> nats#(s(N))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(nats(N)) -> s#(N)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sieve(cons(0(),Y))) -> sieve#(Y)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(zprimes()) -> nats#(s(s(0()))) ->
    nats#(active(X)) -> nats#(X)
    active#(zprimes()) -> nats#(s(s(0()))) ->
    nats#(mark(X)) -> nats#(X)
    active#(zprimes()) -> s#(s(0())) -> s#(active(X)) -> s#(X)
    active#(zprimes()) -> s#(s(0())) -> s#(mark(X)) -> s#(X)
    active#(zprimes()) -> s#(0()) -> s#(active(X)) -> s#(X)
    active#(zprimes()) -> s#(0()) ->
    s#(mark(X)) -> s#(X)
    active#(zprimes()) -> sieve#(nats(s(s(0())))) ->
    sieve#(active(X)) -> sieve#(X)
    active#(zprimes()) -> sieve#(nats(s(s(0())))) ->
    sieve#(mark(X)) -> sieve#(X)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(nats(X)) -> mark#(X)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(s(X)) -> mark#(X)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(0()) -> active#(0())
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(nats(N)) -> nats#(s(N)) -> nats#(active(X)) -> nats#(X)
    active#(nats(N)) -> nats#(s(N)) -> nats#(mark(X)) -> nats#(X)
    active#(nats(N)) -> s#(N) -> s#(active(X)) -> s#(X)
    active#(nats(N)) -> s#(N) -> s#(mark(X)) -> s#(X)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(nats(X)) -> mark#(X)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(s(X)) -> mark#(X)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(0()) -> active#(0())
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(nats(N)) -> cons#(N,nats(s(N))) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(nats(N)) -> cons#(N,nats(s(N))) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(nats(N)) -> cons#(N,nats(s(N))) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(nats(N)) -> cons#(N,nats(s(N))) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N)) ->
    sieve#(active(X)) -> sieve#(X)
    active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N)) ->
    sieve#(mark(X)) -> sieve#(X)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(nats(X)) -> mark#(X)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(s(X)) -> mark#(X)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(0()) -> active#(0())
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
    sieve#(active(X)) -> sieve#(X)
    active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
    sieve#(mark(X)) -> sieve#(X)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(nats(X)) -> mark#(X)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(s(X)) -> mark#(X)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(0()) -> active#(0())
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(nats(X)) -> mark#(X)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(s(X)) -> mark#(X)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(0()) -> active#(0())
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(zprimes()) -> active#(zprimes())
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(nats(X)) -> active#(nats(mark(X)))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(nats(X)) -> nats#(mark(X))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(nats(X)) -> mark#(X)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(sieve(X)) -> active#(sieve(mark(X)))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(sieve(X)) -> sieve#(mark(X))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(sieve(X)) -> mark#(X)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(s(X)) -> mark#(X)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(0()) -> active#(0())
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X1)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X2)
    active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
    mark#(filter(X1,X2,X3)) -> mark#(X3)
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
    active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
    filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
   EDG Processor:
    DPs:
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     active#(nats(N)) -> s#(N)
     active#(nats(N)) -> nats#(s(N))
     active#(nats(N)) -> cons#(N,nats(s(N)))
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     active#(zprimes()) -> s#(0())
     active#(zprimes()) -> s#(s(0()))
     active#(zprimes()) -> nats#(s(s(0())))
     active#(zprimes()) -> sieve#(nats(s(s(0()))))
     active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(0()) -> active#(0())
     mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> s#(mark(X))
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(sieve(X)) -> mark#(X)
     mark#(sieve(X)) -> sieve#(mark(X))
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(nats(X)) -> mark#(X)
     mark#(nats(X)) -> nats#(mark(X))
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(zprimes()) -> active#(zprimes())
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2)
     s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X)
     sieve#(mark(X)) -> sieve#(X)
     sieve#(active(X)) -> sieve#(X)
     nats#(mark(X)) -> nats#(X)
     nats#(active(X)) -> nats#(X)
    TRS:
     active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
     active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
     active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
     active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
     active(nats(N)) -> mark(cons(N,nats(s(N))))
     active(zprimes()) -> mark(sieve(nats(s(s(0())))))
     mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(0()) -> active(0())
     mark(s(X)) -> active(s(mark(X)))
     mark(sieve(X)) -> active(sieve(mark(X)))
     mark(nats(X)) -> active(nats(mark(X)))
     mark(zprimes()) -> active(zprimes())
     filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
     filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
     filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
     filter(active(X1),X2,X3) -> filter(X1,X2,X3)
     filter(X1,active(X2),X3) -> filter(X1,X2,X3)
     filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     sieve(mark(X)) -> sieve(X)
     sieve(active(X)) -> sieve(X)
     nats(mark(X)) -> nats(X)
     nats(active(X)) -> nats(X)
    graph:
     nats#(mark(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
     nats#(mark(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
     nats#(active(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
     nats#(active(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
     s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     sieve#(mark(X)) -> sieve#(X) -> sieve#(mark(X)) -> sieve#(X)
     sieve#(mark(X)) -> sieve#(X) -> sieve#(active(X)) -> sieve#(X)
     sieve#(active(X)) -> sieve#(X) -> sieve#(mark(X)) -> sieve#(X)
     sieve#(active(X)) -> sieve#(X) ->
     sieve#(active(X)) -> sieve#(X)
     mark#(zprimes()) -> active#(zprimes()) ->
     active#(zprimes()) -> s#(0())
     mark#(zprimes()) -> active#(zprimes()) ->
     active#(zprimes()) -> s#(s(0()))
     mark#(zprimes()) -> active#(zprimes()) ->
     active#(zprimes()) -> nats#(s(s(0())))
     mark#(zprimes()) -> active#(zprimes()) ->
     active#(zprimes()) -> sieve#(nats(s(s(0()))))
     mark#(zprimes()) -> active#(zprimes()) ->
     active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
     mark#(nats(X)) -> nats#(mark(X)) -> nats#(mark(X)) -> nats#(X)
     mark#(nats(X)) -> nats#(mark(X)) -> nats#(active(X)) -> nats#(X)
     mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(nats(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(nats(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(nats(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(nats(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(nats(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(nats(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
     mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
     mark#(nats(X)) -> mark#(X) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
     mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
     mark#(nats(X)) -> mark#(X) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(nats(X)) -> mark#(X) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(nats(N)) -> s#(N)
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(nats(N)) -> nats#(s(N))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(nats(N)) -> cons#(N,nats(s(N)))
     mark#(nats(X)) -> active#(nats(mark(X))) ->
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     mark#(sieve(X)) -> sieve#(mark(X)) ->
     sieve#(mark(X)) -> sieve#(X)
     mark#(sieve(X)) -> sieve#(mark(X)) ->
     sieve#(active(X)) -> sieve#(X)
     mark#(sieve(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(sieve(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(sieve(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(sieve(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(sieve(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(sieve(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(sieve(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(sieve(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(sieve(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
     mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
     mark#(sieve(X)) -> mark#(X) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
     mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
     mark#(sieve(X)) -> mark#(X) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(sieve(X)) -> mark#(X) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(nats(N)) -> s#(N)
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(nats(N)) -> nats#(s(N))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(nats(N)) -> cons#(N,nats(s(N)))
     mark#(sieve(X)) -> active#(sieve(mark(X))) ->
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
     mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
     mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(s(X)) -> mark#(X) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(s(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(s(X)) -> mark#(X) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(nats(N)) -> s#(N)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(nats(N)) -> nats#(s(N))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(nats(N)) -> cons#(N,nats(s(N)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(0()) -> active#(0())
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(s(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(s(X)) -> s#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(sieve(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(nats(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(nats(X)) -> nats#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X3) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(0()) -> active#(0())
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(s(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(s(X)) -> s#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(sieve(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(nats(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(nats(X)) -> nats#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X2) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(0()) -> active#(0())
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(s(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(s(X)) -> s#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(sieve(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(nats(X)) -> mark#(X)
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(nats(X)) -> nats#(mark(X))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(filter(X1,X2,X3)) -> mark#(X1) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(nats(N)) -> s#(N)
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(nats(N)) -> nats#(s(N))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(nats(N)) -> cons#(N,nats(s(N)))
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sieve(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nats(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(nats(X)) -> nats#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(zprimes()) -> active#(zprimes())
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(0(),Y))) -> sieve#(Y)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(nats(N)) -> s#(N)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(nats(N)) -> nats#(s(N))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(nats(N)) -> cons#(N,nats(s(N)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(nats(N)) -> nats#(s(N)) -> nats#(mark(X)) -> nats#(X)
     active#(nats(N)) -> nats#(s(N)) -> nats#(active(X)) -> nats#(X)
     active#(nats(N)) -> s#(N) -> s#(mark(X)) -> s#(X)
     active#(nats(N)) -> s#(N) ->
     s#(active(X)) -> s#(X)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(s(X)) -> mark#(X)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(nats(X)) -> mark#(X)
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(nats(X)) -> nats#(mark(X))
     active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     active#(nats(N)) -> cons#(N,nats(s(N))) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(nats(N)) -> cons#(N,nats(s(N))) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(nats(N)) -> cons#(N,nats(s(N))) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(nats(N)) -> cons#(N,nats(s(N))) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N)) ->
     sieve#(mark(X)) -> sieve#(X)
     active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N)) ->
     sieve#(active(X)) -> sieve#(X)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(s(X)) -> mark#(X)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(nats(X)) -> mark#(X)
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(nats(X)) -> nats#(mark(X))
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N))) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
     sieve#(mark(X)) -> sieve#(X)
     active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
     sieve#(active(X)) -> sieve#(X)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(s(X)) -> mark#(X)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(nats(X)) -> mark#(X)
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(nats(X)) -> nats#(mark(X))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(s(X)) -> mark#(X)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(nats(X)) -> mark#(X)
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(nats(X)) -> nats#(mark(X))
     active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X3)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X2)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(filter(X1,X2,X3)) -> mark#(X1)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(s(X)) -> mark#(X)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(sieve(X)) -> mark#(X)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(sieve(X)) -> sieve#(mark(X))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(nats(X)) -> mark#(X)
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(nats(X)) -> nats#(mark(X))
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
     mark#(nats(X)) -> active#(nats(mark(X)))
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
     active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
     filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
    CDG Processor:
     DPs:
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
      active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
      active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
      active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
      active#(sieve(cons(0(),Y))) -> sieve#(Y)
      active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
      active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
      active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
      active#(nats(N)) -> s#(N)
      active#(nats(N)) -> nats#(s(N))
      active#(nats(N)) -> cons#(N,nats(s(N)))
      active#(nats(N)) -> mark#(cons(N,nats(s(N))))
      active#(zprimes()) -> s#(0())
      active#(zprimes()) -> s#(s(0()))
      active#(zprimes()) -> nats#(s(s(0())))
      active#(zprimes()) -> sieve#(nats(s(s(0()))))
      active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(0()) -> active#(0())
      mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> s#(mark(X))
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(sieve(X)) -> mark#(X)
      mark#(sieve(X)) -> sieve#(mark(X))
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(nats(X)) -> mark#(X)
      mark#(nats(X)) -> nats#(mark(X))
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(zprimes()) -> active#(zprimes())
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2)
      s#(mark(X)) -> s#(X)
      s#(active(X)) -> s#(X)
      sieve#(mark(X)) -> sieve#(X)
      sieve#(active(X)) -> sieve#(X)
      nats#(mark(X)) -> nats#(X)
      nats#(active(X)) -> nats#(X)
     TRS:
      active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
      active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
      active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
      active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
      active(nats(N)) -> mark(cons(N,nats(s(N))))
      active(zprimes()) -> mark(sieve(nats(s(s(0())))))
      mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
      mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
      mark(0()) -> active(0())
      mark(s(X)) -> active(s(mark(X)))
      mark(sieve(X)) -> active(sieve(mark(X)))
      mark(nats(X)) -> active(nats(mark(X)))
      mark(zprimes()) -> active(zprimes())
      filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
      filter(active(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,active(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
      cons(mark(X1),X2) -> cons(X1,X2)
      cons(X1,mark(X2)) -> cons(X1,X2)
      cons(active(X1),X2) -> cons(X1,X2)
      cons(X1,active(X2)) -> cons(X1,X2)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      sieve(mark(X)) -> sieve(X)
      sieve(active(X)) -> sieve(X)
      nats(mark(X)) -> nats(X)
      nats(active(X)) -> nats(X)
     graph:
      nats#(mark(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
      nats#(mark(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
      nats#(active(X)) -> nats#(X) -> nats#(active(X)) -> nats#(X)
      nats#(active(X)) -> nats#(X) -> nats#(mark(X)) -> nats#(X)
      s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
      s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
      s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
      s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
      sieve#(mark(X)) -> sieve#(X) -> sieve#(active(X)) -> sieve#(X)
      sieve#(mark(X)) -> sieve#(X) -> sieve#(mark(X)) -> sieve#(X)
      sieve#(active(X)) -> sieve#(X) ->
      sieve#(active(X)) -> sieve#(X)
      sieve#(active(X)) -> sieve#(X) ->
      sieve#(mark(X)) -> sieve#(X)
      mark#(zprimes()) -> active#(zprimes()) ->
      active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
      mark#(zprimes()) -> active#(zprimes()) ->
      active#(zprimes()) -> sieve#(nats(s(s(0()))))
      mark#(zprimes()) -> active#(zprimes()) ->
      active#(zprimes()) -> nats#(s(s(0())))
      mark#(zprimes()) -> active#(zprimes()) ->
      active#(zprimes()) -> s#(s(0()))
      mark#(zprimes()) -> active#(zprimes()) ->
      active#(zprimes()) -> s#(0())
      mark#(nats(X)) -> nats#(mark(X)) ->
      nats#(active(X)) -> nats#(X)
      mark#(nats(X)) -> nats#(mark(X)) -> nats#(mark(X)) -> nats#(X)
      mark#(nats(X)) -> mark#(X) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(nats(X)) -> mark#(X) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
      mark#(nats(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
      mark#(nats(X)) -> mark#(X) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
      mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
      mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
      mark#(nats(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(nats(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(nats(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(nats(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(nats(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(nats(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(nats(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(nats(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(nats(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(nats(X)) -> active#(nats(mark(X))) ->
      active#(nats(N)) -> mark#(cons(N,nats(s(N))))
      mark#(nats(X)) -> active#(nats(mark(X))) ->
      active#(nats(N)) -> cons#(N,nats(s(N)))
      mark#(nats(X)) -> active#(nats(mark(X))) ->
      active#(nats(N)) -> nats#(s(N))
      mark#(nats(X)) -> active#(nats(mark(X))) ->
      active#(nats(N)) -> s#(N)
      mark#(sieve(X)) -> sieve#(mark(X)) ->
      sieve#(active(X)) -> sieve#(X)
      mark#(sieve(X)) -> sieve#(mark(X)) -> sieve#(mark(X)) -> sieve#(X)
      mark#(sieve(X)) -> mark#(X) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(sieve(X)) -> mark#(X) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
      mark#(sieve(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
      mark#(sieve(X)) -> mark#(X) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
      mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
      mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
      mark#(sieve(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(sieve(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(sieve(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(sieve(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(sieve(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(sieve(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(sieve(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(sieve(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(sieve(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(sieve(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(s(N),Y))) -> cons#(s(N),sieve(filter(Y,N,N)))
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(s(N),Y))) -> sieve#(filter(Y,N,N))
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N)
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(0(),Y))) -> cons#(0(),sieve(Y))
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(0(),Y))) -> sieve#(Y)
      mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
      mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
      mark#(s(X)) -> mark#(X) -> mark#(zprimes()) -> active#(zprimes())
      mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> nats#(mark(X))
      mark#(s(X)) -> mark#(X) -> mark#(nats(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> sieve#(mark(X))
      mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(s(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(s(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) -> mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(s(X)) -> mark#(X) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(nats(X)) -> nats#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(nats(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(sieve(X)) -> sieve#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(sieve(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(s(X)) -> s#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(s(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(0()) -> active#(0())
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(filter(X1,X2,X3)) -> mark#(X3) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(nats(X)) -> nats#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(nats(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(sieve(X)) -> sieve#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(sieve(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(s(X)) -> s#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(s(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(0()) -> active#(0())
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(filter(X1,X2,X3)) -> mark#(X2) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(nats(X)) -> nats#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(nats(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(sieve(X)) -> sieve#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(sieve(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(s(X)) -> s#(mark(X))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(s(X)) -> mark#(X)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3)) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M))
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M)
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),0(),M)) -> cons#(0(),filter(Y,M,M))
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3))) ->
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(nats(X)) -> active#(nats(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(nats(X)) -> nats#(mark(X))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nats(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(sieve(X)) -> sieve#(mark(X))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sieve(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> filter#(mark(X1),mark(X2),mark(X3))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X1)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X2)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(filter(X1,X2,X3)) -> mark#(X3)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
      cons#(X1,active(X2)) -> cons#(X1,X2)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(mark(X1),X2) -> cons#(X1,X2) ->
      cons#(X1,active(X2)) -> cons#(X1,X2)
      cons#(mark(X1),X2) -> cons#(X1,X2) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(mark(X1),X2) -> cons#(X1,X2) ->
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(mark(X1),X2) -> cons#(X1,X2) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2) ->
      cons#(X1,active(X2)) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2) ->
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2) ->
      cons#(X1,active(X2)) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2) ->
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2) ->
      cons#(X1,active(X2)) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2) ->
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
      mark#(sieve(X)) -> sieve#(mark(X))
      active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
      mark#(sieve(X)) -> mark#(X)
      active#(nats(N)) -> s#(N) -> s#(active(X)) -> s#(X)
      active#(nats(N)) -> s#(N) ->
      s#(mark(X)) -> s#(X)
      active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      active#(nats(N)) -> mark#(cons(N,nats(s(N)))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(nats(N)) -> cons#(N,nats(s(N))) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      active#(nats(N)) -> cons#(N,nats(s(N))) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N)))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      active#(sieve(cons(s(N),Y))) -> filter#(Y,N,N) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
      sieve#(active(X)) -> sieve#(X)
      active#(sieve(cons(0(),Y))) -> sieve#(Y) ->
      sieve#(mark(X)) -> sieve#(X)
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
      cons#(active(X1),X2) -> cons#(X1,X2)
      active#(filter(cons(X,Y),s(N),M)) -> cons#(X,filter(Y,N,M)) ->
      cons#(mark(X1),X2) -> cons#(X1,X2)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),s(N),M)) -> filter#(Y,N,M) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
      active#(filter(cons(X,Y),0(),M)) -> filter#(Y,M,M) ->
      filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
     SCC Processor:
      #sccs: 6
      #rules: 33
      #arcs: 279/3249
      DPs:
       mark#(zprimes()) -> active#(zprimes())
       active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
       mark#(sieve(X)) -> mark#(X)
       mark#(filter(X1,X2,X3)) -> mark#(X3)
       mark#(filter(X1,X2,X3)) -> mark#(X2)
       mark#(filter(X1,X2,X3)) -> mark#(X1)
       mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(X3)))
       active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
       mark#(cons(X1,X2)) -> mark#(X1)
       mark#(s(X)) -> mark#(X)
       mark#(sieve(X)) -> active#(sieve(mark(X)))
       active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
       active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
       mark#(nats(X)) -> mark#(X)
       mark#(nats(X)) -> active#(nats(mark(X)))
       active#(nats(N)) -> mark#(cons(N,nats(s(N))))
       active#(filter(cons(X,Y),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
      TRS:
       active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
       active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
       active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
       active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
       active(nats(N)) -> mark(cons(N,nats(s(N))))
       active(zprimes()) -> mark(sieve(nats(s(s(0())))))
       mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(s(X)) -> active(s(mark(X)))
       mark(sieve(X)) -> active(sieve(mark(X)))
       mark(nats(X)) -> active(nats(mark(X)))
       mark(zprimes()) -> active(zprimes())
       filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
       filter(active(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,active(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       sieve(mark(X)) -> sieve(X)
       sieve(active(X)) -> sieve(X)
       nats(mark(X)) -> nats(X)
       nats(active(X)) -> nats(X)
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [mark#](x0) = 4x0 + 1,
        
        [active#](x0) = 4x0,
        
        [zprimes] = 6,
        
        [nats](x0) = x0 + 2,
        
        [sieve](x0) = x0 + 1,
        
        [s](x0) = x0 + 1,
        
        [mark](x0) = x0,
        
        [active](x0) = x0,
        
        [filter](x0, x1, x2) = 2x0 + x1 + 4x2 + 2,
        
        [0] = 0,
        
        [cons](x0, x1) = x0 + 1
       orientation:
        mark#(zprimes()) = 25 >= 24 = active#(zprimes())
        
        active#(zprimes()) = 24 >= 21 = mark#(sieve(nats(s(s(0())))))
        
        mark#(sieve(X)) = 4X + 5 >= 4X + 1 = mark#(X)
        
        mark#(filter(X1,X2,X3)) = 8X1 + 4X2 + 16X3 + 9 >= 4X3 + 1 = mark#(X3)
        
        mark#(filter(X1,X2,X3)) = 8X1 + 4X2 + 16X3 + 9 >= 4X2 + 1 = mark#(X2)
        
        mark#(filter(X1,X2,X3)) = 8X1 + 4X2 + 16X3 + 9 >= 4X1 + 1 = mark#(X1)
        
        mark#(filter(X1,X2,X3)) = 8X1 + 4X2 + 16X3 + 9 >= 8X1 + 4X2 + 16X3 + 8 = active#(filter(mark(X1),mark(X2),mark(X3)))
        
        active#(filter(cons(X,Y),0(),M)) = 16M + 8X + 16 >= 5 = mark#(cons(0(),filter(Y,M,M)))
        
        mark#(cons(X1,X2)) = 4X1 + 5 >= 4X1 + 1 = mark#(X1)
        
        mark#(s(X)) = 4X + 5 >= 4X + 1 = mark#(X)
        
        mark#(sieve(X)) = 4X + 5 >= 4X + 4 = active#(sieve(mark(X)))
        
        active#(sieve(cons(0(),Y))) = 8 >= 5 = mark#(cons(0(),sieve(Y)))
        
        active#(sieve(cons(s(N),Y))) = 4N + 12 >= 4N + 9 = mark#(cons(s(N),sieve(filter(Y,N,N))))
        
        mark#(nats(X)) = 4X + 9 >= 4X + 1 = mark#(X)
        
        mark#(nats(X)) = 4X + 9 >= 4X + 8 = active#(nats(mark(X)))
        
        active#(nats(N)) = 4N + 8 >= 4N + 5 = mark#(cons(N,nats(s(N))))
        
        active#(filter(cons(X,Y),s(N),M)) = 16M + 4N + 8X + 20 >= 4X + 5 = mark#(cons(X,filter(Y,N,M)))
        
        active(filter(cons(X,Y),0(),M)) = 4M + 2X + 4 >= 1 = mark(cons(0(),filter(Y,M,M)))
        
        active(filter(cons(X,Y),s(N),M)) = 4M + N + 2X + 5 >= X + 1 = mark(cons(X,filter(Y,N,M)))
        
        active(sieve(cons(0(),Y))) = 2 >= 1 = mark(cons(0(),sieve(Y)))
        
        active(sieve(cons(s(N),Y))) = N + 3 >= N + 2 = mark(cons(s(N),sieve(filter(Y,N,N))))
        
        active(nats(N)) = N + 2 >= N + 1 = mark(cons(N,nats(s(N))))
        
        active(zprimes()) = 6 >= 5 = mark(sieve(nats(s(s(0())))))
        
        mark(filter(X1,X2,X3)) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = active(filter(mark(X1),mark(X2),mark(X3)))
        
        mark(cons(X1,X2)) = X1 + 1 >= X1 + 1 = active(cons(mark(X1),X2))
        
        mark(0()) = 0 >= 0 = active(0())
        
        mark(s(X)) = X + 1 >= X + 1 = active(s(mark(X)))
        
        mark(sieve(X)) = X + 1 >= X + 1 = active(sieve(mark(X)))
        
        mark(nats(X)) = X + 2 >= X + 2 = active(nats(mark(X)))
        
        mark(zprimes()) = 6 >= 6 = active(zprimes())
        
        filter(mark(X1),X2,X3) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        filter(X1,mark(X2),X3) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        filter(X1,X2,mark(X3)) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        filter(active(X1),X2,X3) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        filter(X1,active(X2),X3) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        filter(X1,X2,active(X3)) = 2X1 + X2 + 4X3 + 2 >= 2X1 + X2 + 4X3 + 2 = filter(X1,X2,X3)
        
        cons(mark(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2)
        
        cons(X1,mark(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2)
        
        cons(active(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2)
        
        cons(X1,active(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2)
        
        s(mark(X)) = X + 1 >= X + 1 = s(X)
        
        s(active(X)) = X + 1 >= X + 1 = s(X)
        
        sieve(mark(X)) = X + 1 >= X + 1 = sieve(X)
        
        sieve(active(X)) = X + 1 >= X + 1 = sieve(X)
        
        nats(mark(X)) = X + 2 >= X + 2 = nats(X)
        
        nats(active(X)) = X + 2 >= X + 2 = nats(X)
       problem:
        DPs:
         
        TRS:
         active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
         active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
         active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
         active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
         active(nats(N)) -> mark(cons(N,nats(s(N))))
         active(zprimes()) -> mark(sieve(nats(s(s(0())))))
         mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
         mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
         mark(0()) -> active(0())
         mark(s(X)) -> active(s(mark(X)))
         mark(sieve(X)) -> active(sieve(mark(X)))
         mark(nats(X)) -> active(nats(mark(X)))
         mark(zprimes()) -> active(zprimes())
         filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
         filter(active(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,active(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
         cons(mark(X1),X2) -> cons(X1,X2)
         cons(X1,mark(X2)) -> cons(X1,X2)
         cons(active(X1),X2) -> cons(X1,X2)
         cons(X1,active(X2)) -> cons(X1,X2)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         sieve(mark(X)) -> sieve(X)
         sieve(active(X)) -> sieve(X)
         nats(mark(X)) -> nats(X)
         nats(active(X)) -> nats(X)
       Qed
      
      DPs:
       cons#(mark(X1),X2) -> cons#(X1,X2)
       cons#(X1,mark(X2)) -> cons#(X1,X2)
       cons#(active(X1),X2) -> cons#(X1,X2)
       cons#(X1,active(X2)) -> cons#(X1,X2)
      TRS:
       active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
       active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
       active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
       active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
       active(nats(N)) -> mark(cons(N,nats(s(N))))
       active(zprimes()) -> mark(sieve(nats(s(s(0())))))
       mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(s(X)) -> active(s(mark(X)))
       mark(sieve(X)) -> active(sieve(mark(X)))
       mark(nats(X)) -> active(nats(mark(X)))
       mark(zprimes()) -> active(zprimes())
       filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
       filter(active(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,active(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       sieve(mark(X)) -> sieve(X)
       sieve(active(X)) -> sieve(X)
       nats(mark(X)) -> nats(X)
       nats(active(X)) -> nats(X)
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [cons#](x0, x1) = 4x0 + x1 + 4,
        
        [zprimes] = 2,
        
        [nats](x0) = 0,
        
        [sieve](x0) = 1,
        
        [s](x0) = 1,
        
        [mark](x0) = 2x0 + 1,
        
        [active](x0) = x0 + 1,
        
        [filter](x0, x1, x2) = 0,
        
        [0] = 0,
        
        [cons](x0, x1) = 0
       orientation:
        cons#(mark(X1),X2) = 8X1 + X2 + 8 >= 4X1 + X2 + 4 = cons#(X1,X2)
        
        cons#(X1,mark(X2)) = 4X1 + 2X2 + 5 >= 4X1 + X2 + 4 = cons#(X1,X2)
        
        cons#(active(X1),X2) = 4X1 + X2 + 8 >= 4X1 + X2 + 4 = cons#(X1,X2)
        
        cons#(X1,active(X2)) = 4X1 + X2 + 5 >= 4X1 + X2 + 4 = cons#(X1,X2)
        
        active(filter(cons(X,Y),0(),M)) = 1 >= 1 = mark(cons(0(),filter(Y,M,M)))
        
        active(filter(cons(X,Y),s(N),M)) = 1 >= 1 = mark(cons(X,filter(Y,N,M)))
        
        active(sieve(cons(0(),Y))) = 2 >= 1 = mark(cons(0(),sieve(Y)))
        
        active(sieve(cons(s(N),Y))) = 2 >= 1 = mark(cons(s(N),sieve(filter(Y,N,N))))
        
        active(nats(N)) = 1 >= 1 = mark(cons(N,nats(s(N))))
        
        active(zprimes()) = 3 >= 3 = mark(sieve(nats(s(s(0())))))
        
        mark(filter(X1,X2,X3)) = 1 >= 1 = active(filter(mark(X1),mark(X2),mark(X3)))
        
        mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
        
        mark(0()) = 1 >= 1 = active(0())
        
        mark(s(X)) = 3 >= 2 = active(s(mark(X)))
        
        mark(sieve(X)) = 3 >= 2 = active(sieve(mark(X)))
        
        mark(nats(X)) = 1 >= 1 = active(nats(mark(X)))
        
        mark(zprimes()) = 5 >= 3 = active(zprimes())
        
        filter(mark(X1),X2,X3) = 0 >= 0 = filter(X1,X2,X3)
        
        filter(X1,mark(X2),X3) = 0 >= 0 = filter(X1,X2,X3)
        
        filter(X1,X2,mark(X3)) = 0 >= 0 = filter(X1,X2,X3)
        
        filter(active(X1),X2,X3) = 0 >= 0 = filter(X1,X2,X3)
        
        filter(X1,active(X2),X3) = 0 >= 0 = filter(X1,X2,X3)
        
        filter(X1,X2,active(X3)) = 0 >= 0 = filter(X1,X2,X3)
        
        cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
        
        cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
        
        s(mark(X)) = 1 >= 1 = s(X)
        
        s(active(X)) = 1 >= 1 = s(X)
        
        sieve(mark(X)) = 1 >= 1 = sieve(X)
        
        sieve(active(X)) = 1 >= 1 = sieve(X)
        
        nats(mark(X)) = 0 >= 0 = nats(X)
        
        nats(active(X)) = 0 >= 0 = nats(X)
       problem:
        DPs:
         
        TRS:
         active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
         active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
         active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
         active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
         active(nats(N)) -> mark(cons(N,nats(s(N))))
         active(zprimes()) -> mark(sieve(nats(s(s(0())))))
         mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
         mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
         mark(0()) -> active(0())
         mark(s(X)) -> active(s(mark(X)))
         mark(sieve(X)) -> active(sieve(mark(X)))
         mark(nats(X)) -> active(nats(mark(X)))
         mark(zprimes()) -> active(zprimes())
         filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
         filter(active(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,active(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
         cons(mark(X1),X2) -> cons(X1,X2)
         cons(X1,mark(X2)) -> cons(X1,X2)
         cons(active(X1),X2) -> cons(X1,X2)
         cons(X1,active(X2)) -> cons(X1,X2)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         sieve(mark(X)) -> sieve(X)
         sieve(active(X)) -> sieve(X)
         nats(mark(X)) -> nats(X)
         nats(active(X)) -> nats(X)
       Qed
      
      DPs:
       filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
       filter#(X1,mark(X2),X3) -> filter#(X1,X2,X3)
       filter#(X1,X2,mark(X3)) -> filter#(X1,X2,X3)
       filter#(active(X1),X2,X3) -> filter#(X1,X2,X3)
       filter#(X1,active(X2),X3) -> filter#(X1,X2,X3)
       filter#(X1,X2,active(X3)) -> filter#(X1,X2,X3)
      TRS:
       active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
       active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
       active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
       active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
       active(nats(N)) -> mark(cons(N,nats(s(N))))
       active(zprimes()) -> mark(sieve(nats(s(s(0())))))
       mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(s(X)) -> active(s(mark(X)))
       mark(sieve(X)) -> active(sieve(mark(X)))
       mark(nats(X)) -> active(nats(mark(X)))
       mark(zprimes()) -> active(zprimes())
       filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
       filter(active(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,active(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       sieve(mark(X)) -> sieve(X)
       sieve(active(X)) -> sieve(X)
       nats(mark(X)) -> nats(X)
       nats(active(X)) -> nats(X)
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [filter#](x0, x1, x2) = 4x0 + 2x1 + 2x2 + 2,
        
        [zprimes] = 4,
        
        [nats](x0) = 4x0 + 7,
        
        [sieve](x0) = 1,
        
        [s](x0) = 1,
        
        [mark](x0) = 4x0 + 2,
        
        [active](x0) = x0 + 5,
        
        [filter](x0, x1, x2) = x0 + x1 + 4x2 + 6,
        
        [0] = 1,
        
        [cons](x0, x1) = 1
       orientation:
        filter#(mark(X1),X2,X3) = 16X1 + 2X2 + 2X3 + 10 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        filter#(X1,mark(X2),X3) = 4X1 + 8X2 + 2X3 + 6 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        filter#(X1,X2,mark(X3)) = 4X1 + 2X2 + 8X3 + 6 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        filter#(active(X1),X2,X3) = 4X1 + 2X2 + 2X3 + 22 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        filter#(X1,active(X2),X3) = 4X1 + 2X2 + 2X3 + 12 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        filter#(X1,X2,active(X3)) = 4X1 + 2X2 + 2X3 + 12 >= 4X1 + 2X2 + 2X3 + 2 = filter#(X1,X2,X3)
        
        active(filter(cons(X,Y),0(),M)) = 4M + 13 >= 6 = mark(cons(0(),filter(Y,M,M)))
        
        active(filter(cons(X,Y),s(N),M)) = 4M + 13 >= 6 = mark(cons(X,filter(Y,N,M)))
        
        active(sieve(cons(0(),Y))) = 6 >= 6 = mark(cons(0(),sieve(Y)))
        
        active(sieve(cons(s(N),Y))) = 6 >= 6 = mark(cons(s(N),sieve(filter(Y,N,N))))
        
        active(nats(N)) = 4N + 12 >= 6 = mark(cons(N,nats(s(N))))
        
        active(zprimes()) = 9 >= 6 = mark(sieve(nats(s(s(0())))))
        
        mark(filter(X1,X2,X3)) = 4X1 + 4X2 + 16X3 + 26 >= 4X1 + 4X2 + 16X3 + 23 = active(filter(mark(X1),mark(X2),mark(X3)))
        
        mark(cons(X1,X2)) = 6 >= 6 = active(cons(mark(X1),X2))
        
        mark(0()) = 6 >= 6 = active(0())
        
        mark(s(X)) = 6 >= 6 = active(s(mark(X)))
        
        mark(sieve(X)) = 6 >= 6 = active(sieve(mark(X)))
        
        mark(nats(X)) = 16X + 30 >= 16X + 20 = active(nats(mark(X)))
        
        mark(zprimes()) = 18 >= 9 = active(zprimes())
        
        filter(mark(X1),X2,X3) = 4X1 + X2 + 4X3 + 8 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        filter(X1,mark(X2),X3) = X1 + 4X2 + 4X3 + 8 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        filter(X1,X2,mark(X3)) = X1 + X2 + 16X3 + 14 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        filter(active(X1),X2,X3) = X1 + X2 + 4X3 + 11 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        filter(X1,active(X2),X3) = X1 + X2 + 4X3 + 11 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        filter(X1,X2,active(X3)) = X1 + X2 + 4X3 + 26 >= X1 + X2 + 4X3 + 6 = filter(X1,X2,X3)
        
        cons(mark(X1),X2) = 1 >= 1 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 1 >= 1 = cons(X1,X2)
        
        cons(active(X1),X2) = 1 >= 1 = cons(X1,X2)
        
        cons(X1,active(X2)) = 1 >= 1 = cons(X1,X2)
        
        s(mark(X)) = 1 >= 1 = s(X)
        
        s(active(X)) = 1 >= 1 = s(X)
        
        sieve(mark(X)) = 1 >= 1 = sieve(X)
        
        sieve(active(X)) = 1 >= 1 = sieve(X)
        
        nats(mark(X)) = 16X + 15 >= 4X + 7 = nats(X)
        
        nats(active(X)) = 4X + 27 >= 4X + 7 = nats(X)
       problem:
        DPs:
         
        TRS:
         active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
         active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
         active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
         active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
         active(nats(N)) -> mark(cons(N,nats(s(N))))
         active(zprimes()) -> mark(sieve(nats(s(s(0())))))
         mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
         mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
         mark(0()) -> active(0())
         mark(s(X)) -> active(s(mark(X)))
         mark(sieve(X)) -> active(sieve(mark(X)))
         mark(nats(X)) -> active(nats(mark(X)))
         mark(zprimes()) -> active(zprimes())
         filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
         filter(active(X1),X2,X3) -> filter(X1,X2,X3)
         filter(X1,active(X2),X3) -> filter(X1,X2,X3)
         filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
         cons(mark(X1),X2) -> cons(X1,X2)
         cons(X1,mark(X2)) -> cons(X1,X2)
         cons(active(X1),X2) -> cons(X1,X2)
         cons(X1,active(X2)) -> cons(X1,X2)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         sieve(mark(X)) -> sieve(X)
         sieve(active(X)) -> sieve(X)
         nats(mark(X)) -> nats(X)
         nats(active(X)) -> nats(X)
       Qed
     
     DPs:
      sieve#(mark(X)) -> sieve#(X)
      sieve#(active(X)) -> sieve#(X)
     TRS:
      active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
      active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
      active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
      active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
      active(nats(N)) -> mark(cons(N,nats(s(N))))
      active(zprimes()) -> mark(sieve(nats(s(s(0())))))
      mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
      mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
      mark(0()) -> active(0())
      mark(s(X)) -> active(s(mark(X)))
      mark(sieve(X)) -> active(sieve(mark(X)))
      mark(nats(X)) -> active(nats(mark(X)))
      mark(zprimes()) -> active(zprimes())
      filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
      filter(active(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,active(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
      cons(mark(X1),X2) -> cons(X1,X2)
      cons(X1,mark(X2)) -> cons(X1,X2)
      cons(active(X1),X2) -> cons(X1,X2)
      cons(X1,active(X2)) -> cons(X1,X2)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      sieve(mark(X)) -> sieve(X)
      sieve(active(X)) -> sieve(X)
      nats(mark(X)) -> nats(X)
      nats(active(X)) -> nats(X)
     Matrix Interpretation Processor: dim=1
      
      interpretation:
       [sieve#](x0) = x0 + 2,
       
       [zprimes] = 6,
       
       [nats](x0) = 5,
       
       [sieve](x0) = 2,
       
       [s](x0) = 0,
       
       [mark](x0) = 4x0 + 1,
       
       [active](x0) = 2x0 + 1,
       
       [filter](x0, x1, x2) = 1,
       
       [0] = 3,
       
       [cons](x0, x1) = 0
      orientation:
       sieve#(mark(X)) = 4X + 3 >= X + 2 = sieve#(X)
       
       sieve#(active(X)) = 2X + 3 >= X + 2 = sieve#(X)
       
       active(filter(cons(X,Y),0(),M)) = 3 >= 1 = mark(cons(0(),filter(Y,M,M)))
       
       active(filter(cons(X,Y),s(N),M)) = 3 >= 1 = mark(cons(X,filter(Y,N,M)))
       
       active(sieve(cons(0(),Y))) = 5 >= 1 = mark(cons(0(),sieve(Y)))
       
       active(sieve(cons(s(N),Y))) = 5 >= 1 = mark(cons(s(N),sieve(filter(Y,N,N))))
       
       active(nats(N)) = 11 >= 1 = mark(cons(N,nats(s(N))))
       
       active(zprimes()) = 13 >= 9 = mark(sieve(nats(s(s(0())))))
       
       mark(filter(X1,X2,X3)) = 5 >= 3 = active(filter(mark(X1),mark(X2),mark(X3)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(0()) = 13 >= 7 = active(0())
       
       mark(s(X)) = 1 >= 1 = active(s(mark(X)))
       
       mark(sieve(X)) = 9 >= 5 = active(sieve(mark(X)))
       
       mark(nats(X)) = 21 >= 11 = active(nats(mark(X)))
       
       mark(zprimes()) = 25 >= 13 = active(zprimes())
       
       filter(mark(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,mark(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,X2,mark(X3)) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(active(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,active(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,X2,active(X3)) = 1 >= 1 = filter(X1,X2,X3)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       sieve(mark(X)) = 2 >= 2 = sieve(X)
       
       sieve(active(X)) = 2 >= 2 = sieve(X)
       
       nats(mark(X)) = 5 >= 5 = nats(X)
       
       nats(active(X)) = 5 >= 5 = nats(X)
      problem:
       DPs:
        
       TRS:
        active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
        active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
        active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
        active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
        active(nats(N)) -> mark(cons(N,nats(s(N))))
        active(zprimes()) -> mark(sieve(nats(s(s(0())))))
        mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(0()) -> active(0())
        mark(s(X)) -> active(s(mark(X)))
        mark(sieve(X)) -> active(sieve(mark(X)))
        mark(nats(X)) -> active(nats(mark(X)))
        mark(zprimes()) -> active(zprimes())
        filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
        filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
        filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
        filter(active(X1),X2,X3) -> filter(X1,X2,X3)
        filter(X1,active(X2),X3) -> filter(X1,X2,X3)
        filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        sieve(mark(X)) -> sieve(X)
        sieve(active(X)) -> sieve(X)
        nats(mark(X)) -> nats(X)
        nats(active(X)) -> nats(X)
      Qed
     
     DPs:
      s#(mark(X)) -> s#(X)
      s#(active(X)) -> s#(X)
     TRS:
      active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
      active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
      active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
      active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
      active(nats(N)) -> mark(cons(N,nats(s(N))))
      active(zprimes()) -> mark(sieve(nats(s(s(0())))))
      mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
      mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
      mark(0()) -> active(0())
      mark(s(X)) -> active(s(mark(X)))
      mark(sieve(X)) -> active(sieve(mark(X)))
      mark(nats(X)) -> active(nats(mark(X)))
      mark(zprimes()) -> active(zprimes())
      filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
      filter(active(X1),X2,X3) -> filter(X1,X2,X3)
      filter(X1,active(X2),X3) -> filter(X1,X2,X3)
      filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
      cons(mark(X1),X2) -> cons(X1,X2)
      cons(X1,mark(X2)) -> cons(X1,X2)
      cons(active(X1),X2) -> cons(X1,X2)
      cons(X1,active(X2)) -> cons(X1,X2)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      sieve(mark(X)) -> sieve(X)
      sieve(active(X)) -> sieve(X)
      nats(mark(X)) -> nats(X)
      nats(active(X)) -> nats(X)
     Matrix Interpretation Processor: dim=1
      
      interpretation:
       [s#](x0) = x0 + 2,
       
       [zprimes] = 6,
       
       [nats](x0) = 5,
       
       [sieve](x0) = 2,
       
       [s](x0) = 0,
       
       [mark](x0) = 4x0 + 1,
       
       [active](x0) = 2x0 + 1,
       
       [filter](x0, x1, x2) = 1,
       
       [0] = 3,
       
       [cons](x0, x1) = 0
      orientation:
       s#(mark(X)) = 4X + 3 >= X + 2 = s#(X)
       
       s#(active(X)) = 2X + 3 >= X + 2 = s#(X)
       
       active(filter(cons(X,Y),0(),M)) = 3 >= 1 = mark(cons(0(),filter(Y,M,M)))
       
       active(filter(cons(X,Y),s(N),M)) = 3 >= 1 = mark(cons(X,filter(Y,N,M)))
       
       active(sieve(cons(0(),Y))) = 5 >= 1 = mark(cons(0(),sieve(Y)))
       
       active(sieve(cons(s(N),Y))) = 5 >= 1 = mark(cons(s(N),sieve(filter(Y,N,N))))
       
       active(nats(N)) = 11 >= 1 = mark(cons(N,nats(s(N))))
       
       active(zprimes()) = 13 >= 9 = mark(sieve(nats(s(s(0())))))
       
       mark(filter(X1,X2,X3)) = 5 >= 3 = active(filter(mark(X1),mark(X2),mark(X3)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(0()) = 13 >= 7 = active(0())
       
       mark(s(X)) = 1 >= 1 = active(s(mark(X)))
       
       mark(sieve(X)) = 9 >= 5 = active(sieve(mark(X)))
       
       mark(nats(X)) = 21 >= 11 = active(nats(mark(X)))
       
       mark(zprimes()) = 25 >= 13 = active(zprimes())
       
       filter(mark(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,mark(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,X2,mark(X3)) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(active(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,active(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
       
       filter(X1,X2,active(X3)) = 1 >= 1 = filter(X1,X2,X3)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       sieve(mark(X)) = 2 >= 2 = sieve(X)
       
       sieve(active(X)) = 2 >= 2 = sieve(X)
       
       nats(mark(X)) = 5 >= 5 = nats(X)
       
       nats(active(X)) = 5 >= 5 = nats(X)
      problem:
       DPs:
        
       TRS:
        active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
        active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
        active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
        active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
        active(nats(N)) -> mark(cons(N,nats(s(N))))
        active(zprimes()) -> mark(sieve(nats(s(s(0())))))
        mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(0()) -> active(0())
        mark(s(X)) -> active(s(mark(X)))
        mark(sieve(X)) -> active(sieve(mark(X)))
        mark(nats(X)) -> active(nats(mark(X)))
        mark(zprimes()) -> active(zprimes())
        filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
        filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
        filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
        filter(active(X1),X2,X3) -> filter(X1,X2,X3)
        filter(X1,active(X2),X3) -> filter(X1,X2,X3)
        filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        sieve(mark(X)) -> sieve(X)
        sieve(active(X)) -> sieve(X)
        nats(mark(X)) -> nats(X)
        nats(active(X)) -> nats(X)
      Qed
    
    DPs:
     nats#(mark(X)) -> nats#(X)
     nats#(active(X)) -> nats#(X)
    TRS:
     active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
     active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
     active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
     active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
     active(nats(N)) -> mark(cons(N,nats(s(N))))
     active(zprimes()) -> mark(sieve(nats(s(s(0())))))
     mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(0()) -> active(0())
     mark(s(X)) -> active(s(mark(X)))
     mark(sieve(X)) -> active(sieve(mark(X)))
     mark(nats(X)) -> active(nats(mark(X)))
     mark(zprimes()) -> active(zprimes())
     filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
     filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
     filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
     filter(active(X1),X2,X3) -> filter(X1,X2,X3)
     filter(X1,active(X2),X3) -> filter(X1,X2,X3)
     filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     sieve(mark(X)) -> sieve(X)
     sieve(active(X)) -> sieve(X)
     nats(mark(X)) -> nats(X)
     nats(active(X)) -> nats(X)
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [nats#](x0) = x0 + 2,
      
      [zprimes] = 6,
      
      [nats](x0) = 5,
      
      [sieve](x0) = 2,
      
      [s](x0) = 0,
      
      [mark](x0) = 4x0 + 1,
      
      [active](x0) = 2x0 + 1,
      
      [filter](x0, x1, x2) = 1,
      
      [0] = 3,
      
      [cons](x0, x1) = 0
     orientation:
      nats#(mark(X)) = 4X + 3 >= X + 2 = nats#(X)
      
      nats#(active(X)) = 2X + 3 >= X + 2 = nats#(X)
      
      active(filter(cons(X,Y),0(),M)) = 3 >= 1 = mark(cons(0(),filter(Y,M,M)))
      
      active(filter(cons(X,Y),s(N),M)) = 3 >= 1 = mark(cons(X,filter(Y,N,M)))
      
      active(sieve(cons(0(),Y))) = 5 >= 1 = mark(cons(0(),sieve(Y)))
      
      active(sieve(cons(s(N),Y))) = 5 >= 1 = mark(cons(s(N),sieve(filter(Y,N,N))))
      
      active(nats(N)) = 11 >= 1 = mark(cons(N,nats(s(N))))
      
      active(zprimes()) = 13 >= 9 = mark(sieve(nats(s(s(0())))))
      
      mark(filter(X1,X2,X3)) = 5 >= 3 = active(filter(mark(X1),mark(X2),mark(X3)))
      
      mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
      
      mark(0()) = 13 >= 7 = active(0())
      
      mark(s(X)) = 1 >= 1 = active(s(mark(X)))
      
      mark(sieve(X)) = 9 >= 5 = active(sieve(mark(X)))
      
      mark(nats(X)) = 21 >= 11 = active(nats(mark(X)))
      
      mark(zprimes()) = 25 >= 13 = active(zprimes())
      
      filter(mark(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
      
      filter(X1,mark(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
      
      filter(X1,X2,mark(X3)) = 1 >= 1 = filter(X1,X2,X3)
      
      filter(active(X1),X2,X3) = 1 >= 1 = filter(X1,X2,X3)
      
      filter(X1,active(X2),X3) = 1 >= 1 = filter(X1,X2,X3)
      
      filter(X1,X2,active(X3)) = 1 >= 1 = filter(X1,X2,X3)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      sieve(mark(X)) = 2 >= 2 = sieve(X)
      
      sieve(active(X)) = 2 >= 2 = sieve(X)
      
      nats(mark(X)) = 5 >= 5 = nats(X)
      
      nats(active(X)) = 5 >= 5 = nats(X)
     problem:
      DPs:
       
      TRS:
       active(filter(cons(X,Y),0(),M)) -> mark(cons(0(),filter(Y,M,M)))
       active(filter(cons(X,Y),s(N),M)) -> mark(cons(X,filter(Y,N,M)))
       active(sieve(cons(0(),Y))) -> mark(cons(0(),sieve(Y)))
       active(sieve(cons(s(N),Y))) -> mark(cons(s(N),sieve(filter(Y,N,N))))
       active(nats(N)) -> mark(cons(N,nats(s(N))))
       active(zprimes()) -> mark(sieve(nats(s(s(0())))))
       mark(filter(X1,X2,X3)) -> active(filter(mark(X1),mark(X2),mark(X3)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(s(X)) -> active(s(mark(X)))
       mark(sieve(X)) -> active(sieve(mark(X)))
       mark(nats(X)) -> active(nats(mark(X)))
       mark(zprimes()) -> active(zprimes())
       filter(mark(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,mark(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,mark(X3)) -> filter(X1,X2,X3)
       filter(active(X1),X2,X3) -> filter(X1,X2,X3)
       filter(X1,active(X2),X3) -> filter(X1,X2,X3)
       filter(X1,X2,active(X3)) -> filter(X1,X2,X3)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       sieve(mark(X)) -> sieve(X)
       sieve(active(X)) -> sieve(X)
       nats(mark(X)) -> nats(X)
       nats(active(X)) -> nats(X)
     Qed