MAYBE
Time: 0.009159
TRS:
 {          sieve cons(X, Y) -> cons(X, n__filter(X, sieve activate Y)),
                      from X -> cons(X, n__from s X),
                      from X -> n__from X,
                    primes() -> sieve from s s 0(),
                cons(X1, X2) -> n__cons(X1, X2),
             head cons(X, Y) -> X,
                  activate X -> X,
          activate n__from X -> from X,
  activate n__filter(X1, X2) -> filter(X1, X2),
    activate n__cons(X1, X2) -> cons(X1, X2),
             tail cons(X, Y) -> activate Y,
            if(true(), X, Y) -> activate X,
           if(false(), X, Y) -> activate Y,
              filter(X1, X2) -> n__filter(X1, X2),
   filter(s s X, cons(Y, Z)) -> if(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y)))}
 DP:
  DP:
   {          sieve# cons(X, Y) -> sieve# activate Y,
              sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)),
              sieve# cons(X, Y) -> activate# Y,
                        from# X -> cons#(X, n__from s X),
                      primes#() -> sieve# from s s 0(),
                      primes#() -> from# s s 0(),
            activate# n__from X -> from# X,
    activate# n__filter(X1, X2) -> filter#(X1, X2),
      activate# n__cons(X1, X2) -> cons#(X1, X2),
               tail# cons(X, Y) -> activate# Y,
              if#(true(), X, Y) -> activate# X,
             if#(false(), X, Y) -> activate# Y,
     filter#(s s X, cons(Y, Z)) -> sieve# Y,
     filter#(s s X, cons(Y, Z)) -> activate# Z,
     filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y)))}
  TRS:
  {          sieve cons(X, Y) -> cons(X, n__filter(X, sieve activate Y)),
                       from X -> cons(X, n__from s X),
                       from X -> n__from X,
                     primes() -> sieve from s s 0(),
                 cons(X1, X2) -> n__cons(X1, X2),
              head cons(X, Y) -> X,
                   activate X -> X,
           activate n__from X -> from X,
   activate n__filter(X1, X2) -> filter(X1, X2),
     activate n__cons(X1, X2) -> cons(X1, X2),
              tail cons(X, Y) -> activate Y,
             if(true(), X, Y) -> activate X,
            if(false(), X, Y) -> activate Y,
               filter(X1, X2) -> n__filter(X1, X2),
    filter(s s X, cons(Y, Z)) -> if(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y)))}
  UR:
   {          sieve cons(X, Y) -> cons(X, n__filter(X, sieve activate Y)),
                        from X -> cons(X, n__from s X),
                        from X -> n__from X,
                  cons(X1, X2) -> n__cons(X1, X2),
                    activate X -> X,
            activate n__from X -> from X,
    activate n__filter(X1, X2) -> filter(X1, X2),
      activate n__cons(X1, X2) -> cons(X1, X2),
                filter(X1, X2) -> n__filter(X1, X2),
     filter(s s X, cons(Y, Z)) -> if(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))),
                       a(x, y) -> x,
                       a(x, y) -> y}
   EDG:
    {(tail# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (tail# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
     (tail# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
     (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> activate# Y)
     (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
     (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> sieve# activate Y)
     (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> activate# Y)
     (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
     (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> sieve# activate Y)
     (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__filter(X1, X2) -> filter#(X1, X2))
     (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__from X -> from# X)
     (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> activate# Y)
     (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
     (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> sieve# activate Y)
     (if#(true(), X, Y) -> activate# X, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (if#(true(), X, Y) -> activate# X, activate# n__filter(X1, X2) -> filter#(X1, X2))
     (if#(true(), X, Y) -> activate# X, activate# n__from X -> from# X)
     (filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))), if#(true(), X, Y) -> activate# X)
     (filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))), if#(false(), X, Y) -> activate# Y)
     (activate# n__from X -> from# X, from# X -> cons#(X, n__from s X))
     (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> sieve# Y)
     (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> activate# Z)
     (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))))
     (primes#() -> from# s s 0(), from# X -> cons#(X, n__from s X))
     (if#(false(), X, Y) -> activate# Y, activate# n__from X -> from# X)
     (if#(false(), X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
     (if#(false(), X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (sieve# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
     (sieve# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
     (sieve# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))}
    EDG:
     {(tail# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
      (tail# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
      (tail# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
      (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> activate# Y)
      (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
      (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> sieve# activate Y)
      (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> activate# Y)
      (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
      (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> sieve# activate Y)
      (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__cons(X1, X2) -> cons#(X1, X2))
      (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__filter(X1, X2) -> filter#(X1, X2))
      (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__from X -> from# X)
      (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> activate# Y)
      (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
      (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> sieve# activate Y)
      (if#(true(), X, Y) -> activate# X, activate# n__cons(X1, X2) -> cons#(X1, X2))
      (if#(true(), X, Y) -> activate# X, activate# n__filter(X1, X2) -> filter#(X1, X2))
      (if#(true(), X, Y) -> activate# X, activate# n__from X -> from# X)
      (activate# n__from X -> from# X, from# X -> cons#(X, n__from s X))
      (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> sieve# Y)
      (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> activate# Z)
      (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))))
      (primes#() -> from# s s 0(), from# X -> cons#(X, n__from s X))
      (if#(false(), X, Y) -> activate# Y, activate# n__from X -> from# X)
      (if#(false(), X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
      (if#(false(), X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
      (sieve# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
      (sieve# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
      (sieve# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))}
     EDG:
      {(tail# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
       (tail# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
       (tail# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
       (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> activate# Y)
       (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
       (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> sieve# activate Y)
       (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> activate# Y)
       (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
       (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> sieve# activate Y)
       (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__cons(X1, X2) -> cons#(X1, X2))
       (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__filter(X1, X2) -> filter#(X1, X2))
       (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__from X -> from# X)
       (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> activate# Y)
       (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
       (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> sieve# activate Y)
       (if#(true(), X, Y) -> activate# X, activate# n__cons(X1, X2) -> cons#(X1, X2))
       (if#(true(), X, Y) -> activate# X, activate# n__filter(X1, X2) -> filter#(X1, X2))
       (if#(true(), X, Y) -> activate# X, activate# n__from X -> from# X)
       (activate# n__from X -> from# X, from# X -> cons#(X, n__from s X))
       (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> sieve# Y)
       (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> activate# Z)
       (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))))
       (primes#() -> from# s s 0(), from# X -> cons#(X, n__from s X))
       (if#(false(), X, Y) -> activate# Y, activate# n__from X -> from# X)
       (if#(false(), X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
       (if#(false(), X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
       (sieve# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
       (sieve# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
       (sieve# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))}
      EDG:
       {(tail# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
        (tail# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
        (tail# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
        (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> activate# Y)
        (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
        (filter#(s s X, cons(Y, Z)) -> sieve# Y, sieve# cons(X, Y) -> sieve# activate Y)
        (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> activate# Y)
        (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
        (primes#() -> sieve# from s s 0(), sieve# cons(X, Y) -> sieve# activate Y)
        (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__cons(X1, X2) -> cons#(X1, X2))
        (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__filter(X1, X2) -> filter#(X1, X2))
        (filter#(s s X, cons(Y, Z)) -> activate# Z, activate# n__from X -> from# X)
        (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> activate# Y)
        (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> cons#(X, n__filter(X, sieve activate Y)))
        (sieve# cons(X, Y) -> sieve# activate Y, sieve# cons(X, Y) -> sieve# activate Y)
        (if#(true(), X, Y) -> activate# X, activate# n__cons(X1, X2) -> cons#(X1, X2))
        (if#(true(), X, Y) -> activate# X, activate# n__filter(X1, X2) -> filter#(X1, X2))
        (if#(true(), X, Y) -> activate# X, activate# n__from X -> from# X)
        (activate# n__from X -> from# X, from# X -> cons#(X, n__from s X))
        (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> sieve# Y)
        (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> activate# Z)
        (activate# n__filter(X1, X2) -> filter#(X1, X2), filter#(s s X, cons(Y, Z)) -> if#(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y))))
        (primes#() -> from# s s 0(), from# X -> cons#(X, n__from s X))
        (if#(false(), X, Y) -> activate# Y, activate# n__from X -> from# X)
        (if#(false(), X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
        (if#(false(), X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))
        (sieve# cons(X, Y) -> activate# Y, activate# n__from X -> from# X)
        (sieve# cons(X, Y) -> activate# Y, activate# n__filter(X1, X2) -> filter#(X1, X2))
        (sieve# cons(X, Y) -> activate# Y, activate# n__cons(X1, X2) -> cons#(X1, X2))}
       STATUS:
        arrows: 0.871111
        SCCS (1):
         Scc:
          {          sieve# cons(X, Y) -> sieve# activate Y,
                     sieve# cons(X, Y) -> activate# Y,
           activate# n__filter(X1, X2) -> filter#(X1, X2),
            filter#(s s X, cons(Y, Z)) -> sieve# Y,
            filter#(s s X, cons(Y, Z)) -> activate# Z}
         
         
         
         
         
         
         SCC (5):
          Strict:
           {          sieve# cons(X, Y) -> sieve# activate Y,
                      sieve# cons(X, Y) -> activate# Y,
            activate# n__filter(X1, X2) -> filter#(X1, X2),
             filter#(s s X, cons(Y, Z)) -> sieve# Y,
             filter#(s s X, cons(Y, Z)) -> activate# Z}
          Weak:
          {          sieve cons(X, Y) -> cons(X, n__filter(X, sieve activate Y)),
                               from X -> cons(X, n__from s X),
                               from X -> n__from X,
                             primes() -> sieve from s s 0(),
                         cons(X1, X2) -> n__cons(X1, X2),
                      head cons(X, Y) -> X,
                           activate X -> X,
                   activate n__from X -> from X,
           activate n__filter(X1, X2) -> filter(X1, X2),
             activate n__cons(X1, X2) -> cons(X1, X2),
                      tail cons(X, Y) -> activate Y,
                     if(true(), X, Y) -> activate X,
                    if(false(), X, Y) -> activate Y,
                       filter(X1, X2) -> n__filter(X1, X2),
            filter(s s X, cons(Y, Z)) -> if(divides(s s X, Y), n__filter(s s X, activate Z), n__cons(Y, n__filter(X, sieve Y)))}
          Open