/export/starexec/sandbox2/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


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)
   SCC Processor:
    #sccs: 6
    #rules: 36
    #arcs: 535/3249
    DPs:
     mark#(zprimes()) -> active#(zprimes())
     active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
     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),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
     mark#(0()) -> active#(0())
     active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
     mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> active#(s(mark(X)))
     active#(nats(N)) -> mark#(cons(N,nats(s(N))))
     mark#(sieve(X)) -> mark#(X)
     mark#(sieve(X)) -> active#(sieve(mark(X)))
     active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
     mark#(nats(X)) -> mark#(X)
     mark#(nats(X)) -> active#(nats(mark(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)
    EDG Processor:
     DPs:
      mark#(zprimes()) -> active#(zprimes())
      active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
      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),s(N),M)) -> mark#(cons(X,filter(Y,N,M)))
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(sieve(cons(0(),Y))) -> mark#(cons(0(),sieve(Y)))
      mark#(0()) -> active#(0())
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
      mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> active#(s(mark(X)))
      active#(nats(N)) -> mark#(cons(N,nats(s(N))))
      mark#(sieve(X)) -> mark#(X)
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      active#(zprimes()) -> mark#(sieve(nats(s(s(0())))))
      mark#(nats(X)) -> mark#(X)
      mark#(nats(X)) -> active#(nats(mark(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:
      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)) -> 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)) -> 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)) -> active#(s(mark(X)))
      mark#(nats(X)) -> mark#(X) -> mark#(sieve(X)) -> 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)) -> active#(nats(mark(X)))
      mark#(nats(X)) -> mark#(X) ->
      mark#(zprimes()) -> active#(zprimes())
      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)) -> 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)) -> 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)) -> active#(s(mark(X)))
      mark#(sieve(X)) -> mark#(X) -> mark#(sieve(X)) -> 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)) -> active#(nats(mark(X)))
      mark#(sieve(X)) -> mark#(X) ->
      mark#(zprimes()) -> active#(zprimes())
      mark#(sieve(X)) -> active#(sieve(mark(X))) ->
      active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
      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)) -> 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)) -> 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)) -> active#(s(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(sieve(X)) -> 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)) -> active#(nats(mark(X)))
      mark#(s(X)) -> mark#(X) ->
      mark#(zprimes()) -> active#(zprimes())
      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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(nats(mark(X)))
      mark#(filter(X1,X2,X3)) -> mark#(X1) ->
      mark#(zprimes()) -> active#(zprimes())
      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)) -> mark#(cons(X,filter(Y,N,M)))
      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)) -> 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)) -> 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)) -> active#(s(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sieve(X)) -> 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)) -> active#(nats(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(zprimes()) -> active#(zprimes())
      active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
      mark#(sieve(X)) -> mark#(X)
      active#(zprimes()) -> mark#(sieve(nats(s(s(0()))))) ->
      mark#(sieve(X)) -> active#(sieve(mark(X)))
      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)) -> active#(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#(cons(X1,X2)) -> active#(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#(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)) -> 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),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)) -> active#(cons(mark(X1),X2))
     SCC Processor:
      #sccs: 1
      #rules: 12
      #arcs: 113/400
      DPs:
       mark#(nats(X)) -> mark#(X)
       mark#(sieve(X)) -> active#(sieve(mark(X)))
       active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
       mark#(cons(X1,X2)) -> mark#(X1)
       mark#(sieve(X)) -> mark#(X)
       mark#(s(X)) -> mark#(X)
       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)))
       active#(filter(cons(X,Y),0(),M)) -> mark#(cons(0(),filter(Y,M,M)))
       mark#(filter(X1,X2,X3)) -> mark#(X1)
       mark#(filter(X1,X2,X3)) -> mark#(X2)
       mark#(filter(X1,X2,X3)) -> mark#(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)
      KBO Processor:
       argument filtering:
        pi(cons) = 0
        pi(0) = []
        pi(filter) = [0,1,2]
        pi(active) = 0
        pi(mark) = 0
        pi(s) = 0
        pi(sieve) = 0
        pi(nats) = 0
        pi(zprimes) = []
        pi(active#) = 0
        pi(mark#) = 0
       usable rules:
        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)
       weight function:
        w0 = 1
        w(mark#) = w(active#) = w(zprimes) = w(sieve) = w(filter) = w(
        0) = w(cons) = 1
        w(nats) = w(s) = w(mark) = w(active) = 0
       precedence:
        zprimes > mark# ~ active# ~ nats ~ sieve ~ s ~ mark ~ active ~ filter ~ 0 ~ cons
       problem:
        DPs:
         mark#(nats(X)) -> mark#(X)
         mark#(sieve(X)) -> active#(sieve(mark(X)))
         active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
         mark#(cons(X1,X2)) -> mark#(X1)
         mark#(sieve(X)) -> mark#(X)
         mark#(s(X)) -> mark#(X)
         mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(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)
       Restore Modifier:
        DPs:
         mark#(nats(X)) -> mark#(X)
         mark#(sieve(X)) -> active#(sieve(mark(X)))
         active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
         mark#(cons(X1,X2)) -> mark#(X1)
         mark#(sieve(X)) -> mark#(X)
         mark#(s(X)) -> mark#(X)
         mark#(filter(X1,X2,X3)) -> active#(filter(mark(X1),mark(X2),mark(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)
        SCC Processor:
         #sccs: 1
         #rules: 6
         #arcs: 69/49
         DPs:
          mark#(nats(X)) -> mark#(X)
          mark#(sieve(X)) -> active#(sieve(mark(X)))
          active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
          mark#(cons(X1,X2)) -> mark#(X1)
          mark#(sieve(X)) -> mark#(X)
          mark#(s(X)) -> mark#(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)
         LPO Processor:
          argument filtering:
           pi(cons) = 0
           pi(0) = []
           pi(filter) = [0]
           pi(active) = 0
           pi(mark) = 0
           pi(s) = 0
           pi(sieve) = 0
           pi(nats) = [0]
           pi(zprimes) = []
           pi(active#) = 0
           pi(mark#) = 0
          usable rules:
           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)
          precedence:
           zprimes ~ filter > mark# ~ active# ~ nats ~ sieve ~ s ~ mark ~ active ~ 0 ~ cons
          problem:
           DPs:
            mark#(sieve(X)) -> active#(sieve(mark(X)))
            active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
            mark#(cons(X1,X2)) -> mark#(X1)
            mark#(sieve(X)) -> mark#(X)
            mark#(s(X)) -> mark#(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)
          Restore Modifier:
           DPs:
            mark#(sieve(X)) -> active#(sieve(mark(X)))
            active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
            mark#(cons(X1,X2)) -> mark#(X1)
            mark#(sieve(X)) -> mark#(X)
            mark#(s(X)) -> mark#(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)
           LPO Processor:
            argument filtering:
             pi(cons) = 0
             pi(0) = []
             pi(filter) = [0]
             pi(active) = 0
             pi(mark) = 0
             pi(s) = [0]
             pi(sieve) = 0
             pi(nats) = [0]
             pi(zprimes) = []
             pi(active#) = 0
             pi(mark#) = 0
            usable rules:
             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)
            precedence:
             zprimes ~ filter > mark# ~ active# ~ nats ~ sieve ~ s ~ mark ~ active ~ 0 ~ cons
            problem:
             DPs:
              mark#(sieve(X)) -> active#(sieve(mark(X)))
              active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
              mark#(cons(X1,X2)) -> mark#(X1)
              mark#(sieve(X)) -> mark#(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)
            Restore Modifier:
             DPs:
              mark#(sieve(X)) -> active#(sieve(mark(X)))
              active#(sieve(cons(s(N),Y))) -> mark#(cons(s(N),sieve(filter(Y,N,N))))
              mark#(cons(X1,X2)) -> mark#(X1)
              mark#(sieve(X)) -> mark#(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)
             KBO Processor:
              argument filtering:
               pi(cons) = 0
               pi(0) = []
               pi(filter) = []
               pi(active) = 0
               pi(mark) = 0
               pi(s) = []
               pi(sieve) = [0]
               pi(nats) = 0
               pi(zprimes) = []
               pi(active#) = []
               pi(mark#) = 0
              usable rules:
               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)
              weight function:
               w0 = 1
               w(active#) = w(zprimes) = w(sieve) = w(s) = w(filter) = w(
               0) = 1
               w(mark#) = w(nats) = w(mark) = w(active) = w(cons) = 0
              precedence:
               active# > mark# ~ zprimes ~ nats ~ sieve ~ s ~ mark ~ active ~ filter ~ 0 ~ cons
              problem:
               DPs:
                mark#(cons(X1,X2)) -> mark#(X1)
               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)
              Restore Modifier:
               DPs:
                mark#(cons(X1,X2)) -> mark#(X1)
               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)
               Size-Change Termination Processor:
                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)
                The DP: mark#(cons(X1,X2)) -> mark#(X1) has the edges:
                  0 >   0
                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)
    Subterm Criterion Processor:
     simple projection:
      pi(cons#) = 0
     problem:
      DPs:
       cons#(X1,mark(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)
     Subterm Criterion Processor:
      simple projection:
       pi(cons#) = 1
      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)
    Subterm Criterion Processor:
     simple projection:
      pi(filter#) = 1
     problem:
      DPs:
       filter#(mark(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,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)
     Subterm Criterion Processor:
      simple projection:
       pi(filter#) = 2
      problem:
       DPs:
        filter#(mark(X1),X2,X3) -> filter#(X1,X2,X3)
        filter#(active(X1),X2,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)
      Subterm Criterion Processor:
       simple projection:
        pi(filter#) = 0
       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)
    Subterm Criterion Processor:
     simple projection:
      pi(sieve#) = 0
     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)
    Subterm Criterion Processor:
     simple projection:
      pi(s#) = 0
     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)
    Subterm Criterion Processor:
     simple projection:
      pi(nats#) = 0
     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