MAYBE
Time: 0.007696
TRS:
 {                    activate X -> X,
  activate n__filter(X1, X2, X3) -> filter(X1, X2, X3),
             activate n__sieve X -> sieve X,
              activate n__nats X -> nats X,
              filter(X1, X2, X3) -> n__filter(X1, X2, X3),
      filter(cons(X, Y), 0(), M) -> cons(0(), n__filter(activate Y, M, M)),
      filter(cons(X, Y), s N, M) -> cons(X, n__filter(activate Y, N, M)),
                         sieve X -> n__sieve X,
              sieve cons(0(), Y) -> cons(0(), n__sieve activate Y),
              sieve cons(s N, Y) -> cons(s N, n__sieve filter(activate Y, N, N)),
                          nats X -> n__nats X,
                          nats N -> cons(N, n__nats s N),
                       zprimes() -> sieve nats s s 0()}
 DP:
  DP:
   {activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3),
               activate# n__sieve X -> sieve# X,
                activate# n__nats X -> nats# X,
        filter#(cons(X, Y), 0(), M) -> activate# Y,
        filter#(cons(X, Y), s N, M) -> activate# Y,
                sieve# cons(0(), Y) -> activate# Y,
                sieve# cons(s N, Y) -> activate# Y,
                sieve# cons(s N, Y) -> filter#(activate Y, N, N),
                         zprimes#() -> sieve# nats s s 0(),
                         zprimes#() -> nats# s s 0()}
  TRS:
  {                    activate X -> X,
   activate n__filter(X1, X2, X3) -> filter(X1, X2, X3),
              activate n__sieve X -> sieve X,
               activate n__nats X -> nats X,
               filter(X1, X2, X3) -> n__filter(X1, X2, X3),
       filter(cons(X, Y), 0(), M) -> cons(0(), n__filter(activate Y, M, M)),
       filter(cons(X, Y), s N, M) -> cons(X, n__filter(activate Y, N, M)),
                          sieve X -> n__sieve X,
               sieve cons(0(), Y) -> cons(0(), n__sieve activate Y),
               sieve cons(s N, Y) -> cons(s N, n__sieve filter(activate Y, N, N)),
                           nats X -> n__nats X,
                           nats N -> cons(N, n__nats s N),
                        zprimes() -> sieve nats s s 0()}
  UR:
   {                    activate X -> X,
    activate n__filter(X1, X2, X3) -> filter(X1, X2, X3),
               activate n__sieve X -> sieve X,
                activate n__nats X -> nats X,
                filter(X1, X2, X3) -> n__filter(X1, X2, X3),
        filter(cons(X, Y), 0(), M) -> cons(0(), n__filter(activate Y, M, M)),
        filter(cons(X, Y), s N, M) -> cons(X, n__filter(activate Y, N, M)),
                           sieve X -> n__sieve X,
                sieve cons(0(), Y) -> cons(0(), n__sieve activate Y),
                sieve cons(s N, Y) -> cons(s N, n__sieve filter(activate Y, N, N)),
                            nats X -> n__nats X,
                            nats N -> cons(N, n__nats s N),
                           a(x, y) -> x,
                           a(x, y) -> y}
   EDG:
    {(activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3), filter#(cons(X, Y), s N, M) -> activate# Y)
     (activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3), filter#(cons(X, Y), 0(), M) -> activate# Y)
     (filter#(cons(X, Y), s N, M) -> activate# Y, activate# n__nats X -> nats# X)
     (filter#(cons(X, Y), s N, M) -> activate# Y, activate# n__sieve X -> sieve# X)
     (filter#(cons(X, Y), s N, M) -> activate# Y, activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3))
     (sieve# cons(s N, Y) -> activate# Y, activate# n__nats X -> nats# X)
     (sieve# cons(s N, Y) -> activate# Y, activate# n__sieve X -> sieve# X)
     (sieve# cons(s N, Y) -> activate# Y, activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3))
     (sieve# cons(0(), Y) -> activate# Y, activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3))
     (sieve# cons(0(), Y) -> activate# Y, activate# n__sieve X -> sieve# X)
     (sieve# cons(0(), Y) -> activate# Y, activate# n__nats X -> nats# X)
     (filter#(cons(X, Y), 0(), M) -> activate# Y, activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3))
     (filter#(cons(X, Y), 0(), M) -> activate# Y, activate# n__sieve X -> sieve# X)
     (filter#(cons(X, Y), 0(), M) -> activate# Y, activate# n__nats X -> nats# X)
     (sieve# cons(s N, Y) -> filter#(activate Y, N, N), filter#(cons(X, Y), 0(), M) -> activate# Y)
     (sieve# cons(s N, Y) -> filter#(activate Y, N, N), filter#(cons(X, Y), s N, M) -> activate# Y)
     (zprimes#() -> sieve# nats s s 0(), sieve# cons(0(), Y) -> activate# Y)
     (zprimes#() -> sieve# nats s s 0(), sieve# cons(s N, Y) -> activate# Y)
     (zprimes#() -> sieve# nats s s 0(), sieve# cons(s N, Y) -> filter#(activate Y, N, N))
     (activate# n__sieve X -> sieve# X, sieve# cons(0(), Y) -> activate# Y)
     (activate# n__sieve X -> sieve# X, sieve# cons(s N, Y) -> activate# Y)
     (activate# n__sieve X -> sieve# X, sieve# cons(s N, Y) -> filter#(activate Y, N, N))}
    STATUS:
     arrows: 0.780000
     SCCS (1):
      Scc:
       {activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3),
                   activate# n__sieve X -> sieve# X,
            filter#(cons(X, Y), 0(), M) -> activate# Y,
            filter#(cons(X, Y), s N, M) -> activate# Y,
                    sieve# cons(0(), Y) -> activate# Y,
                    sieve# cons(s N, Y) -> activate# Y,
                    sieve# cons(s N, Y) -> filter#(activate Y, N, N)}
      
      
      
      SCC (7):
       Strict:
        {activate# n__filter(X1, X2, X3) -> filter#(X1, X2, X3),
                    activate# n__sieve X -> sieve# X,
             filter#(cons(X, Y), 0(), M) -> activate# Y,
             filter#(cons(X, Y), s N, M) -> activate# Y,
                     sieve# cons(0(), Y) -> activate# Y,
                     sieve# cons(s N, Y) -> activate# Y,
                     sieve# cons(s N, Y) -> filter#(activate Y, N, N)}
       Weak:
       {                    activate X -> X,
        activate n__filter(X1, X2, X3) -> filter(X1, X2, X3),
                   activate n__sieve X -> sieve X,
                    activate n__nats X -> nats X,
                    filter(X1, X2, X3) -> n__filter(X1, X2, X3),
            filter(cons(X, Y), 0(), M) -> cons(0(), n__filter(activate Y, M, M)),
            filter(cons(X, Y), s N, M) -> cons(X, n__filter(activate Y, N, M)),
                               sieve X -> n__sieve X,
                    sieve cons(0(), Y) -> cons(0(), n__sieve activate Y),
                    sieve cons(s N, Y) -> cons(s N, n__sieve filter(activate Y, N, N)),
                                nats X -> n__nats X,
                                nats N -> cons(N, n__nats s N),
                             zprimes() -> sieve nats s s 0()}
       Open