MAYBE
Time: 0.194971
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))}
    STATUS:
     arrows: 0.862222
     SCCS (1):
      Scc:
       {          sieve# cons(X, Y) -> sieve# activate Y,
                  sieve# cons(X, Y) -> activate# Y,
        activate# n__filter(X1, X2) -> filter#(X1, X2),
                  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)))}
      
      
      
      
      SCC (8):
       Strict:
        {          sieve# cons(X, Y) -> sieve# activate Y,
                   sieve# cons(X, Y) -> activate# Y,
         activate# n__filter(X1, X2) -> filter#(X1, X2),
                   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)))}
       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)))}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [if](x0, x1, x2) = x0 + x1 + 1,
         
         [cons](x0, x1) = 0,
         
         [divides](x0, x1) = 0,
         
         [n__filter](x0, x1) = x0 + x1 + 1,
         
         [n__cons](x0, x1) = 0,
         
         [filter](x0, x1) = 0,
         
         [sieve](x0) = x0 + 1,
         
         [from](x0) = 1,
         
         [s](x0) = x0 + 1,
         
         [n__from](x0) = x0 + 1,
         
         [head](x0) = 0,
         
         [activate](x0) = 1,
         
         [tail](x0) = 0,
         
         [0] = 0,
         
         [primes] = 0,
         
         [true] = 1,
         
         [false] = 1,
         
         [if#](x0, x1, x2) = x0,
         
         [filter#](x0, x1) = 1,
         
         [sieve#](x0) = 1,
         
         [activate#](x0) = 1
        Strict:
         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)))
         1 + 0X + 0Y + 0Z >= 0 + 0X + 0Y + 0Z
         filter#(s s X, cons(Y, Z)) -> activate# Z
         1 + 0X + 0Y + 0Z >= 1 + 0Z
         filter#(s s X, cons(Y, Z)) -> sieve# Y
         1 + 0X + 0Y + 0Z >= 1 + 0Y
         if#(false(), X, Y) -> activate# Y
         1 + 0X + 0Y >= 1 + 0Y
         if#(true(), X, Y) -> activate# X
         1 + 0X + 0Y >= 1 + 0X
         activate# n__filter(X1, X2) -> filter#(X1, X2)
         1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         sieve# cons(X, Y) -> activate# Y
         1 + 0X + 0Y >= 1 + 0Y
         sieve# cons(X, Y) -> sieve# activate Y
         1 + 0X + 0Y >= 1 + 0Y
        Weak:
         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)))
         0 + 0X + 0Y + 0Z >= 5 + 1X + 0Y + 0Z
         filter(X1, X2) -> n__filter(X1, X2)
         0 + 0X1 + 0X2 >= 1 + 1X1 + 1X2
         if(false(), X, Y) -> activate Y
         2 + 1X + 0Y >= 1 + 0Y
         if(true(), X, Y) -> activate X
         2 + 1X + 0Y >= 1 + 0X
         tail cons(X, Y) -> activate Y
         0 + 0X + 0Y >= 1 + 0Y
         activate n__cons(X1, X2) -> cons(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         activate n__filter(X1, X2) -> filter(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         activate n__from X -> from X
         1 + 0X >= 1 + 0X
         activate X -> X
         1 + 0X >= 1X
         head cons(X, Y) -> X
         0 + 0X + 0Y >= 1X
         cons(X1, X2) -> n__cons(X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         primes() -> sieve from s s 0()
         0 >= 2
         from X -> n__from X
         1 + 0X >= 1 + 1X
         from X -> cons(X, n__from s X)
         1 + 0X >= 0 + 0X
         sieve cons(X, Y) -> cons(X, n__filter(X, sieve activate Y))
         1 + 0X + 0Y >= 0 + 0X + 0Y
       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)))}
         Fail