MAYBE
Time: 0.091668
TRS:
 {                mark cons(X1, X2) -> active cons(mark X1, X2),
                           mark 0() -> active 0(),
            mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                           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(),
                  cons(X1, mark 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),
            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, 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),
  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(),
                           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}
 DP:
  DP:
   {                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# filter(X1, X2, X3) -> mark# X1,
              mark# filter(X1, X2, X3) -> mark# X2,
              mark# filter(X1, X2, X3) -> mark# X3,
              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# s X -> mark# X,
                             mark# s X -> active# s mark X,
                             mark# s X -> s# mark X,
                         mark# sieve X -> mark# X,
                         mark# sieve X -> active# sieve mark X,
                         mark# sieve X -> sieve# mark X,
                          mark# nats X -> mark# X,
                          mark# nats X -> active# nats mark X,
                          mark# nats X -> nats# mark X,
                       mark# zprimes() -> active# zprimes(),
                    cons#(X1, mark 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),
              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, 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),
    active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)),
    active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)),
    active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M),
    active# filter(cons(X, Y), s N, M) -> mark# cons(X, 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) -> filter#(Y, N, M),
            active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y),
            active# sieve cons(0(), Y) -> cons#(0(), sieve Y),
            active# sieve cons(0(), Y) -> sieve# Y,
            active# sieve cons(s N, Y) -> mark# cons(s N, 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) -> filter#(Y, N, N),
            active# sieve cons(s N, Y) -> sieve# filter(Y, N, N),
                        active# nats N -> mark# cons(N, nats s N),
                        active# nats N -> cons#(N, nats s N),
                        active# nats N -> s# N,
                        active# nats N -> nats# s N,
                     active# zprimes() -> mark# sieve nats s s 0(),
                     active# zprimes() -> s# 0(),
                     active# zprimes() -> s# s 0(),
                     active# zprimes() -> sieve# nats s s 0(),
                     active# zprimes() -> nats# s s 0(),
                             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:
  {                mark cons(X1, X2) -> active cons(mark X1, X2),
                            mark 0() -> active 0(),
             mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                            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(),
                   cons(X1, mark 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),
             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, 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),
   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(),
                            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:
   {
    (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#(mark X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, mark X3) -> filter#(X1, X2, X3), filter#(X1, active X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, mark X3) -> filter#(X1, X2, X3), filter#(X1, mark 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, X2, mark X3) -> filter#(X1, X2, X3))
    (filter#(X1, mark X2, X3) -> filter#(X1, X2, X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, mark X2, X3) -> filter#(X1, X2, X3), filter#(mark X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, mark X2, X3) -> filter#(X1, X2, X3), filter#(X1, active X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, mark X2, X3) -> filter#(X1, X2, X3), filter#(X1, mark 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, X2, mark X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(mark X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, active X2, X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, X2, active X3) -> filter#(X1, X2, X3))
    (filter#(mark X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, X2, mark X3) -> filter#(X1, X2, X3))
    (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#(mark X1, X2) -> cons#(X1, X2))
    (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#(X1, mark X2) -> cons#(X1, X2))
    (active# sieve cons(0(), Y) -> sieve# Y, sieve# active X -> sieve# X)
    (active# sieve cons(0(), Y) -> sieve# Y, sieve# mark X -> sieve# X)
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, active 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#(active X1, X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (active# zprimes() -> sieve# nats s s 0(), sieve# active X -> sieve# X)
    (active# zprimes() -> sieve# nats s s 0(), sieve# mark X -> sieve# X)
    (mark# s X -> active# s mark X, active# zprimes() -> 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() -> s# s 0())
    (mark# s X -> active# s mark X, active# zprimes() -> s# 0())
    (mark# s X -> active# s mark X, active# zprimes() -> mark# sieve nats s s 0())
    (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# nats N -> cons#(N, nats s N))
    (mark# s X -> active# s mark X, active# nats N -> mark# cons(N, nats s 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(s N, Y) -> cons#(s N, sieve filter(Y, N, N)))
    (mark# s X -> active# s mark X, active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)))
    (mark# s X -> active# s mark X, active# sieve cons(0(), Y) -> sieve# Y)
    (mark# s X -> active# s mark X, active# sieve cons(0(), Y) -> cons#(0(), sieve Y))
    (mark# s X -> active# s mark X, active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), s N, M) -> cons#(X, filter(Y, N, M)))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)))
    (mark# s X -> active# s mark X, active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)))
    (mark# nats X -> active# nats mark X, active# zprimes() -> 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() -> s# s 0())
    (mark# nats X -> active# nats mark X, active# zprimes() -> s# 0())
    (mark# nats X -> active# nats mark X, active# zprimes() -> mark# sieve nats s s 0())
    (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# nats N -> cons#(N, nats s N))
    (mark# nats X -> active# nats mark X, active# nats N -> mark# cons(N, nats s 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(s N, Y) -> cons#(s N, sieve filter(Y, N, N)))
    (mark# nats X -> active# nats mark X, active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)))
    (mark# nats X -> active# nats mark X, active# sieve cons(0(), Y) -> sieve# Y)
    (mark# nats X -> active# nats mark X, active# sieve cons(0(), Y) -> cons#(0(), sieve Y))
    (mark# nats X -> active# nats mark X, active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), s N, M) -> cons#(X, filter(Y, N, M)))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)))
    (mark# nats X -> active# nats mark X, active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)))
    (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 -> 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) -> 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 -> sieve# mark X)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# sieve X -> active# sieve mark X)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# sieve X -> mark# X)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# s X -> s# mark X)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# s X -> active# s mark X)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# s X -> mark# X)
    (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# X3)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# filter(X1, X2, X3) -> mark# X2)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# filter(X1, X2, X3) -> mark# X1)
    (active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)), mark# 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# zprimes() -> s# s 0(), s# active X -> s# X)
    (active# zprimes() -> s# s 0(), s# mark X -> s# X)
    (mark# 0() -> active# 0(), active# zprimes() -> nats# s s 0())
    (mark# 0() -> active# 0(), active# zprimes() -> sieve# 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# zprimes() -> mark# sieve nats s s 0())
    (mark# 0() -> active# 0(), active# nats N -> nats# s N)
    (mark# 0() -> active# 0(), active# nats N -> s# N)
    (mark# 0() -> active# 0(), active# nats N -> cons#(N, nats s N))
    (mark# 0() -> active# 0(), active# nats N -> mark# cons(N, nats s 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(s N, Y) -> 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# 0() -> active# 0(), active# sieve cons(0(), Y) -> sieve# Y)
    (mark# 0() -> active# 0(), active# sieve cons(0(), Y) -> cons#(0(), sieve Y))
    (mark# 0() -> active# 0(), active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y))
    (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), s N, M) -> 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# 0() -> active# 0(), active# filter(cons(X, Y), 0(), M) -> 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) -> mark# cons(0(), filter(Y, M, M)))
    (active# zprimes() -> s# 0(), s# active X -> s# X)
    (active# zprimes() -> s# 0(), s# mark X -> s# X)
    (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() -> sieve# 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# zprimes() -> mark# sieve nats s s 0())
    (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# nats N -> cons#(N, nats s N))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# nats N -> mark# cons(N, nats s N))
    (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(s N, Y) -> cons#(s N, sieve filter(Y, N, N)))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sieve cons(s N, Y) -> mark# cons(s N, sieve filter(Y, N, N)))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sieve cons(0(), Y) -> sieve# Y)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sieve cons(0(), Y) -> cons#(0(), sieve Y))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), s N, M) -> cons#(X, filter(Y, N, M)))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)))
    (mark# filter(X1, X2, X3) -> mark# X1, mark# zprimes() -> active# zprimes())
    (mark# filter(X1, X2, X3) -> mark# X1, mark# nats X -> nats# mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# nats X -> active# nats mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# nats X -> mark# X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# sieve X -> sieve# mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# sieve X -> active# sieve mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# sieve X -> mark# X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# s X -> s# mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# s X -> active# s mark X)
    (mark# filter(X1, X2, X3) -> mark# X1, mark# s X -> mark# X)
    (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# 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# 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)
    (active# nats N -> s# N, s# active X -> s# X)
    (active# nats N -> s# N, s# mark X -> s# X)
    (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 -> 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) -> 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 -> sieve# mark X)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# sieve X -> active# sieve mark X)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# sieve X -> mark# X)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# s X -> s# mark X)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# s X -> active# s mark X)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# s X -> mark# X)
    (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# X3)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# filter(X1, X2, X3) -> mark# X2)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# filter(X1, X2, X3) -> mark# X1)
    (active# filter(cons(X, Y), 0(), M) -> mark# cons(0(), filter(Y, M, M)), mark# 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# 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#(mark X1, X2) -> cons#(X1, X2))
    (active# sieve cons(s N, Y) -> cons#(s N, sieve filter(Y, N, N)), cons#(X1, active X2) -> cons#(X1, X2))
    (active# sieve cons(s N, Y) -> cons#(s N, sieve filter(Y, N, N)), cons#(X1, mark X2) -> cons#(X1, X2))
    (mark# sieve X -> mark# X, mark# zprimes() -> active# zprimes())
    (mark# sieve X -> mark# X, mark# nats X -> nats# mark X)
    (mark# sieve X -> mark# X, mark# nats X -> active# nats mark X)
    (mark# sieve X -> mark# X, mark# nats X -> mark# X)
    (mark# sieve X -> mark# X, mark# sieve X -> sieve# mark X)
    (mark# sieve X -> mark# X, mark# sieve X -> active# sieve mark X)
    (mark# sieve X -> mark# X, mark# sieve X -> mark# X)
    (mark# sieve X -> mark# X, mark# s X -> s# mark X)
    (mark# sieve X -> mark# X, mark# s X -> active# s mark X)
    (mark# sieve X -> mark# X, mark# s X -> mark# X)
    (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# 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# 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)
    (s# mark X -> s# X, s# active X -> s# X)
    (s# mark 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)
    (nats# mark X -> nats# X, nats# active X -> nats# X)
    (nats# mark X -> nats# X, nats# mark X -> nats# X)
    (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)
    (mark# s X -> s# mark X, s# active X -> s# X)
    (mark# s X -> s# mark X, s# mark X -> s# X)
    (mark# nats X -> nats# mark X, nats# active X -> nats# X)
    (mark# nats X -> nats# mark X, nats# mark X -> nats# X)
    (active# filter(cons(X, Y), s N, M) -> cons#(X, filter(Y, N, M)), cons#(active X1, X2) -> cons#(X1, X2))
    (active# filter(cons(X, Y), s N, M) -> cons#(X, filter(Y, N, M)), cons#(mark X1, X2) -> cons#(X1, X2))
    (active# filter(cons(X, Y), s N, M) -> 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#(X1, mark X2) -> cons#(X1, X2))
    (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#(mark X1, X2, X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M), filter#(X1, active X2, X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M), filter#(X1, X2, active X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), s N, M) -> filter#(Y, N, M), filter#(X1, X2, mark X3) -> filter#(X1, X2, X3))
    (active# nats N -> cons#(N, nats s N), cons#(X1, mark X2) -> cons#(X1, X2))
    (active# nats N -> cons#(N, nats s N), cons#(X1, active X2) -> cons#(X1, X2))
    (active# nats N -> cons#(N, nats s N), cons#(mark X1, X2) -> cons#(X1, X2))
    (active# nats N -> cons#(N, nats s N), cons#(active X1, X2) -> cons#(X1, X2))
    (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, X2, active X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (active# filter(cons(X, Y), 0(), M) -> filter#(Y, M, M), filter#(X1, active 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))
    (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) -> cons#(0(), filter(Y, M, M)), cons#(X1, mark X2) -> cons#(X1, X2))
    (active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)), cons#(X1, active X2) -> cons#(X1, X2))
    (active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)), cons#(mark X1, X2) -> cons#(X1, X2))
    (active# filter(cons(X, Y), 0(), M) -> cons#(0(), filter(Y, M, M)), cons#(active X1, X2) -> cons#(X1, X2))
    (mark# sieve X -> sieve# mark X, sieve# mark X -> sieve# X)
    (mark# sieve X -> sieve# mark X, sieve# active X -> sieve# X)
    (active# nats N -> nats# s N, nats# mark X -> nats# X)
    (active# nats N -> nats# s N, nats# active X -> nats# X)
    (nats# active X -> nats# X, nats# mark X -> nats# X)
    (nats# active X -> nats# X, nats# active X -> nats# X)
    (sieve# active X -> sieve# X, sieve# mark X -> sieve# X)
    (sieve# active X -> sieve# X, sieve# active X -> sieve# X)
    (s# active X -> s# X, s# mark X -> s# X)
    (s# active X -> s# X, s# active X -> s# X)
    (mark# nats X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# nats X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# nats X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# nats X -> mark# X, mark# 0() -> active# 0())
    (mark# nats X -> mark# X, mark# 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 -> mark# X, mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (mark# nats X -> mark# X, mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (mark# nats X -> mark# X, mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (mark# s X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# s X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# s X -> mark# X, mark# 0() -> active# 0())
    (mark# s X -> mark# X, mark# 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 -> mark# X, mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (mark# s X -> mark# X, mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (mark# s X -> mark# X, mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# cons(X1, X2) -> mark# X1)
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# 0() -> active# 0())
    (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) -> mark# cons(X, filter(Y, N, M)), mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (active# filter(cons(X, Y), s N, M) -> mark# cons(X, filter(Y, N, M)), mark# s 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# sieve 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# nats X -> 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) -> 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# 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), 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# 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# 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# 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) -> 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# 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 -> 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# zprimes() -> mark# sieve nats 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# zprimes() -> 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())
    (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, X2, active X3) -> filter#(X1, X2, X3))
    (active# sieve cons(s N, Y) -> filter#(Y, N, N), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (active# sieve cons(s N, Y) -> filter#(Y, N, N), filter#(X1, active 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(s N, Y) -> filter#(Y, N, N), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# cons(X1, X2) -> mark# X1, mark# 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) -> mark# X1, mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (mark# cons(X1, X2) -> mark# X1, mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (mark# cons(X1, X2) -> mark# X1, mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (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, X2, active X3) -> filter#(X1, X2, X3))
    (mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3), filter#(X1, active 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) -> filter#(mark X1, mark X2, mark X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (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# 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# 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# 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) -> filter#(Y, N, N))
    (mark# zprimes() -> active# zprimes(), active# sieve cons(s N, Y) -> sieve# filter(Y, N, N))
    (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 -> s# N)
    (mark# zprimes() -> active# zprimes(), active# nats N -> nats# s N)
    (mark# zprimes() -> active# zprimes(), active# zprimes() -> mark# sieve nats s s 0())
    (mark# zprimes() -> active# zprimes(), active# zprimes() -> s# 0())
    (mark# zprimes() -> active# zprimes(), active# zprimes() -> 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# filter(X1, X2, X3) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# filter(X1, X2, X3) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# filter(X1, X2, X3) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# filter(X1, X2, X3) -> mark# X2, mark# 0() -> active# 0())
    (mark# filter(X1, X2, X3) -> mark# X2, mark# 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# X2, mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (mark# filter(X1, X2, X3) -> mark# X2, mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (mark# filter(X1, X2, X3) -> mark# X2, mark# 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# s X -> 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# sieve X -> 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# nats X -> nats# mark X)
    (mark# filter(X1, X2, X3) -> mark# X2, mark# zprimes() -> active# zprimes())
    (active# nats N -> mark# cons(N, nats s N), mark# cons(X1, X2) -> mark# X1)
    (active# nats N -> mark# cons(N, nats s N), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# nats N -> mark# cons(N, nats s N), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# nats N -> mark# cons(N, nats s N), mark# 0() -> active# 0())
    (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 -> mark# cons(N, nats s N), mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (active# nats N -> mark# cons(N, nats s N), mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (active# nats N -> mark# cons(N, nats s N), mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# cons(X1, X2) -> mark# X1)
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# 0() -> active# 0())
    (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) -> mark# cons(0(), sieve Y), mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (active# sieve cons(0(), Y) -> mark# cons(0(), sieve Y), mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (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# 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# 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# 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) -> 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# 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 -> s# N)
    (mark# sieve X -> active# sieve mark X, active# nats N -> nats# s N)
    (mark# sieve X -> active# sieve mark X, active# zprimes() -> mark# sieve nats s s 0())
    (mark# sieve X -> active# sieve mark X, active# zprimes() -> s# 0())
    (mark# sieve X -> active# sieve mark X, active# zprimes() -> 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())
    (active# zprimes() -> nats# s s 0(), nats# mark X -> nats# X)
    (active# zprimes() -> nats# s s 0(), nats# active X -> nats# X)
    (active# zprimes() -> mark# sieve nats s s 0(), mark# cons(X1, X2) -> mark# X1)
    (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) -> active# cons(mark X1, X2))
    (active# zprimes() -> mark# sieve nats s s 0(), mark# 0() -> active# 0())
    (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# 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) -> active# filter(mark X1, mark X2, mark X3))
    (active# zprimes() -> mark# sieve nats s s 0(), mark# s 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# sieve 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# nats X -> mark# X)
    (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# zprimes() -> active# zprimes())
    (cons#(mark X1, 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#(mark X1, 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, mark X2) -> cons#(X1, X2), cons#(X1, mark 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#(mark X1, X2) -> cons#(X1, X2))
    (cons#(X1, mark X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (mark# filter(X1, X2, X3) -> mark# X3, mark# cons(X1, X2) -> mark# X1)
    (mark# filter(X1, X2, X3) -> mark# X3, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# filter(X1, X2, X3) -> mark# X3, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# filter(X1, X2, X3) -> mark# X3, mark# 0() -> active# 0())
    (mark# filter(X1, X2, X3) -> mark# X3, mark# 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# X3, mark# filter(X1, X2, X3) -> filter#(mark X1, mark X2, mark X3))
    (mark# filter(X1, X2, X3) -> mark# X3, mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3))
    (mark# filter(X1, X2, X3) -> mark# X3, mark# 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# s X -> 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# sieve X -> 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# nats X -> nats# mark X)
    (mark# filter(X1, X2, X3) -> mark# X3, mark# zprimes() -> active# zprimes())
    (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, X2, active X3) -> filter#(X1, X2, X3))
    (filter#(active X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (filter#(active X1, X2, X3) -> filter#(X1, X2, X3), filter#(X1, active 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#(active X1, X2, X3) -> filter#(X1, X2, X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, active X2, X3) -> filter#(X1, X2, X3), filter#(X1, X2, mark 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, mark X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, active X2, X3) -> filter#(X1, X2, X3), filter#(X1, active X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, active X2, X3) -> filter#(X1, X2, X3), filter#(mark X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, active X2, X3) -> filter#(X1, X2, X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, active X3) -> filter#(X1, X2, X3), filter#(X1, X2, mark X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, active X3) -> filter#(X1, X2, X3), filter#(X1, X2, active X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, active X3) -> filter#(X1, X2, X3), filter#(X1, mark X2, X3) -> filter#(X1, X2, X3))
    (filter#(X1, X2, active X3) -> filter#(X1, X2, X3), filter#(X1, active 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, X2, active X3) -> filter#(X1, X2, X3), filter#(active X1, X2, X3) -> filter#(X1, X2, X3))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
   }
   STATUS:
    arrows: 0.835334
    SCCS (6):
     Scc:
      {                mark# cons(X1, X2) -> mark# X1,
                       mark# cons(X1, X2) -> active# cons(mark X1, X2),
                                mark# 0() -> active# 0(),
                 mark# filter(X1, X2, X3) -> mark# X1,
                 mark# filter(X1, X2, X3) -> mark# X2,
                 mark# filter(X1, X2, X3) -> mark# X3,
                 mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3),
                                mark# s X -> mark# X,
                                mark# s X -> active# s mark X,
                            mark# sieve X -> mark# X,
                            mark# sieve X -> active# sieve mark X,
                             mark# nats X -> mark# X,
                             mark# nats X -> active# nats mark X,
                          mark# zprimes() -> active# zprimes(),
       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()}
     Scc:
      {  nats# mark X -> nats# X,
       nats# active X -> nats# X}
     Scc:
      {  s# mark X -> s# X,
       s# active X -> s# X}
     Scc:
      {  sieve# mark X -> sieve# X,
       sieve# active X -> sieve# X}
     Scc:
      {  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, 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)}
     Scc:
      {  cons#(X1, mark 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)}
     
     SCC (20):
      Strict:
       {                mark# cons(X1, X2) -> mark# X1,
                        mark# cons(X1, X2) -> active# cons(mark X1, X2),
                                 mark# 0() -> active# 0(),
                  mark# filter(X1, X2, X3) -> mark# X1,
                  mark# filter(X1, X2, X3) -> mark# X2,
                  mark# filter(X1, X2, X3) -> mark# X3,
                  mark# filter(X1, X2, X3) -> active# filter(mark X1, mark X2, mark X3),
                                 mark# s X -> mark# X,
                                 mark# s X -> active# s mark X,
                             mark# sieve X -> mark# X,
                             mark# sieve X -> active# sieve mark X,
                              mark# nats X -> mark# X,
                              mark# nats X -> active# nats mark X,
                           mark# zprimes() -> active# zprimes(),
        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()}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open
     
     
     
     
     
     
     SCC (2):
      Strict:
       {  nats# mark X -> nats# X,
        nats# active X -> nats# X}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open
     
     
     
     
     
     
     
     SCC (2):
      Strict:
       {  s# mark X -> s# X,
        s# active X -> s# X}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open
     
     SCC (2):
      Strict:
       {  sieve# mark X -> sieve# X,
        sieve# active X -> sieve# X}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open
     
     
     
     
     
     
     SCC (6):
      Strict:
       {  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, 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)}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open
     
     SCC (4):
      Strict:
       {  cons#(X1, mark 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)}
      Weak:
      {                mark cons(X1, X2) -> active cons(mark X1, X2),
                                mark 0() -> active 0(),
                 mark filter(X1, X2, X3) -> active filter(mark X1, mark X2, mark X3),
                                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(),
                       cons(X1, mark 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),
                 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, 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),
       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(),
                                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}
      Open