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


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


YES

Problem:
 a(a(divides(),0()),a(s(),y)) -> true()
 a(a(divides(),a(s(),x)),a(s(),y)) -> a(a(a(div2(),x),a(s(),y)),y)
 a(a(a(div2(),x),y),0()) -> a(a(divides(),x),y)
 a(a(a(div2(),0()),y),a(s(),z)) -> false()
 a(a(a(div2(),a(s(),x)),y),a(s(),z)) -> a(a(a(div2(),x),y),z)
 a(a(filter(),f),nil()) -> nil()
 a(a(filter(),f),a(a(cons(),x),xs)) -> a(a(a(if(),a(f,x)),x),a(a(filter(),f),xs))
 a(a(a(if(),true()),x),xs) -> a(a(cons(),x),xs)
 a(a(a(if(),false()),x),xs) -> xs
 a(a(not(),f),x) -> a(not2(),a(f,x))
 a(not2(),true()) -> false()
 a(not2(),false()) -> true()
 a(sieve(),nil()) -> nil()
 a(sieve(),a(a(cons(),x),xs)) ->
 a(a(cons(),x),a(sieve(),a(a(filter(),a(not(),a(divides(),x))),xs)))

Proof:
 Extended Uncurrying Processor:
  application symbol: a
  symbol table:
   sieve ==> sieve0/0 sieve1/1
   not2 ==> not20/0 not21/1
   not ==> not0/0 not1/1 not2/2
   if ==> if0/0 if1/1 if2/2 if3/3
   cons ==> cons0/0 cons1/1 cons2/2
   nil ==> nil0/0
   filter ==> filter0/0 filter1/1 filter2/2
   false ==> false0/0
   div2 ==> div20/0 div21/1 div22/2 div23/3
   true ==> true0/0
   s ==> s0/0 s1/1
   0 ==> 00/0
   divides ==> divides0/0 divides1/1 divides2/2
   
  uncurry-rules:
   a(divides1(x5),x6) -> divides2(x5,x6)
   a(divides0(),x5) -> divides1(x5)
   a(s0(),x9) -> s1(x9)
   a(div22(x12,x13),x14) -> div23(x12,x13,x14)
   a(div21(x12),x13) -> div22(x12,x13)
   a(div20(),x12) -> div21(x12)
   a(filter1(x17),x18) -> filter2(x17,x18)
   a(filter0(),x17) -> filter1(x17)
   a(cons1(x21),x22) -> cons2(x21,x22)
   a(cons0(),x21) -> cons1(x21)
   a(if2(x24,x25),x26) -> if3(x24,x25,x26)
   a(if1(x24),x25) -> if2(x24,x25)
   a(if0(),x24) -> if1(x24)
   a(not1(x28),x29) -> not2(x28,x29)
   a(not0(),x28) -> not1(x28)
   a(not20(),x31) -> not21(x31)
   a(sieve0(),x33) -> sieve1(x33)
  eta-rules:
   
  problem:
   divides2(00(),s1(y)) -> true0()
   divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
   div23(x,y,00()) -> divides2(x,y)
   div23(00(),y,s1(z)) -> false0()
   div23(s1(x),y,s1(z)) -> div23(x,y,z)
   filter2(f,nil0()) -> nil0()
   filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
   if3(true0(),x,xs) -> cons2(x,xs)
   if3(false0(),x,xs) -> xs
   not2(f,x) -> not21(a(f,x))
   not21(true0()) -> false0()
   not21(false0()) -> true0()
   sieve1(nil0()) -> nil0()
   sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
   a(divides1(x5),x6) -> divides2(x5,x6)
   a(divides0(),x5) -> divides1(x5)
   a(s0(),x9) -> s1(x9)
   a(div22(x12,x13),x14) -> div23(x12,x13,x14)
   a(div21(x12),x13) -> div22(x12,x13)
   a(div20(),x12) -> div21(x12)
   a(filter1(x17),x18) -> filter2(x17,x18)
   a(filter0(),x17) -> filter1(x17)
   a(cons1(x21),x22) -> cons2(x21,x22)
   a(cons0(),x21) -> cons1(x21)
   a(if2(x24,x25),x26) -> if3(x24,x25,x26)
   a(if1(x24),x25) -> if2(x24,x25)
   a(if0(),x24) -> if1(x24)
   a(not1(x28),x29) -> not2(x28,x29)
   a(not0(),x28) -> not1(x28)
   a(not20(),x31) -> not21(x31)
   a(sieve0(),x33) -> sieve1(x33)
  DP Processor:
   DPs:
    divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y)
    div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
    div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
    filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
    filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
    filter{2,#}(f,cons2(x,xs)) -> if{3,#}(a(f,x),x,filter2(f,xs))
    not{2,#}(f,x) -> a#(f,x)
    not{2,#}(f,x) -> not2{1,#}(a(f,x))
    sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs)
    sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs))
    a#(divides1(x5),x6) -> divides{2,#}(x5,x6)
    a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14)
    a#(filter1(x17),x18) -> filter{2,#}(x17,x18)
    a#(if2(x24,x25),x26) -> if{3,#}(x24,x25,x26)
    a#(not1(x28),x29) -> not{2,#}(x28,x29)
    a#(not20(),x31) -> not2{1,#}(x31)
    a#(sieve0(),x33) -> sieve{1,#}(x33)
   TRS:
    divides2(00(),s1(y)) -> true0()
    divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
    div23(x,y,00()) -> divides2(x,y)
    div23(00(),y,s1(z)) -> false0()
    div23(s1(x),y,s1(z)) -> div23(x,y,z)
    filter2(f,nil0()) -> nil0()
    filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
    if3(true0(),x,xs) -> cons2(x,xs)
    if3(false0(),x,xs) -> xs
    not2(f,x) -> not21(a(f,x))
    not21(true0()) -> false0()
    not21(false0()) -> true0()
    sieve1(nil0()) -> nil0()
    sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
    a(divides1(x5),x6) -> divides2(x5,x6)
    a(divides0(),x5) -> divides1(x5)
    a(s0(),x9) -> s1(x9)
    a(div22(x12,x13),x14) -> div23(x12,x13,x14)
    a(div21(x12),x13) -> div22(x12,x13)
    a(div20(),x12) -> div21(x12)
    a(filter1(x17),x18) -> filter2(x17,x18)
    a(filter0(),x17) -> filter1(x17)
    a(cons1(x21),x22) -> cons2(x21,x22)
    a(cons0(),x21) -> cons1(x21)
    a(if2(x24,x25),x26) -> if3(x24,x25,x26)
    a(if1(x24),x25) -> if2(x24,x25)
    a(if0(),x24) -> if1(x24)
    a(not1(x28),x29) -> not2(x28,x29)
    a(not0(),x28) -> not1(x28)
    a(not20(),x31) -> not21(x31)
    a(sieve0(),x33) -> sieve1(x33)
   TDG Processor:
    DPs:
     divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y)
     div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> if{3,#}(a(f,x),x,filter2(f,xs))
     not{2,#}(f,x) -> a#(f,x)
     not{2,#}(f,x) -> not2{1,#}(a(f,x))
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs)
     sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs))
     a#(divides1(x5),x6) -> divides{2,#}(x5,x6)
     a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14)
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18)
     a#(if2(x24,x25),x26) -> if{3,#}(x24,x25,x26)
     a#(not1(x28),x29) -> not{2,#}(x28,x29)
     a#(not20(),x31) -> not2{1,#}(x31)
     a#(sieve0(),x33) -> sieve{1,#}(x33)
    TRS:
     divides2(00(),s1(y)) -> true0()
     divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
     div23(x,y,00()) -> divides2(x,y)
     div23(00(),y,s1(z)) -> false0()
     div23(s1(x),y,s1(z)) -> div23(x,y,z)
     filter2(f,nil0()) -> nil0()
     filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
     if3(true0(),x,xs) -> cons2(x,xs)
     if3(false0(),x,xs) -> xs
     not2(f,x) -> not21(a(f,x))
     not21(true0()) -> false0()
     not21(false0()) -> true0()
     sieve1(nil0()) -> nil0()
     sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
     a(divides1(x5),x6) -> divides2(x5,x6)
     a(divides0(),x5) -> divides1(x5)
     a(s0(),x9) -> s1(x9)
     a(div22(x12,x13),x14) -> div23(x12,x13,x14)
     a(div21(x12),x13) -> div22(x12,x13)
     a(div20(),x12) -> div21(x12)
     a(filter1(x17),x18) -> filter2(x17,x18)
     a(filter0(),x17) -> filter1(x17)
     a(cons1(x21),x22) -> cons2(x21,x22)
     a(cons0(),x21) -> cons1(x21)
     a(if2(x24,x25),x26) -> if3(x24,x25,x26)
     a(if1(x24),x25) -> if2(x24,x25)
     a(if0(),x24) -> if1(x24)
     a(not1(x28),x29) -> not2(x28,x29)
     a(not0(),x28) -> not1(x28)
     a(not20(),x31) -> not21(x31)
     a(sieve0(),x33) -> sieve1(x33)
    graph:
     sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs)) ->
     sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs))
     sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs)) ->
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs)
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs) ->
     filter{2,#}(f,cons2(x,xs)) -> if{3,#}(a(f,x),x,filter2(f,xs))
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs) ->
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
     not{2,#}(f,x) -> a#(f,x) -> a#(sieve0(),x33) -> sieve{1,#}(x33)
     not{2,#}(f,x) -> a#(f,x) -> a#(not20(),x31) -> not2{1,#}(x31)
     not{2,#}(f,x) -> a#(f,x) -> a#(not1(x28),x29) -> not{2,#}(x28,x29)
     not{2,#}(f,x) -> a#(f,x) ->
     a#(if2(x24,x25),x26) -> if{3,#}(x24,x25,x26)
     not{2,#}(f,x) -> a#(f,x) ->
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18)
     not{2,#}(f,x) -> a#(f,x) ->
     a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14)
     not{2,#}(f,x) -> a#(f,x) ->
     a#(divides1(x5),x6) -> divides{2,#}(x5,x6)
     a#(sieve0(),x33) -> sieve{1,#}(x33) ->
     sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs))
     a#(sieve0(),x33) -> sieve{1,#}(x33) ->
     sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs)
     a#(not1(x28),x29) -> not{2,#}(x28,x29) ->
     not{2,#}(f,x) -> not2{1,#}(a(f,x))
     a#(not1(x28),x29) -> not{2,#}(x28,x29) ->
     not{2,#}(f,x) -> a#(f,x)
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18) ->
     filter{2,#}(f,cons2(x,xs)) -> if{3,#}(a(f,x),x,filter2(f,xs))
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18) ->
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18) ->
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
     a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14) ->
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
     a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14) ->
     div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
     a#(divides1(x5),x6) -> divides{2,#}(x5,x6) ->
     divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(sieve0(),x33) -> sieve{1,#}(x33)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(not20(),x31) -> not2{1,#}(x31)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(not1(x28),x29) -> not{2,#}(x28,x29)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(if2(x24,x25),x26) -> if{3,#}(x24,x25,x26)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(filter1(x17),x18) -> filter{2,#}(x17,x18)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(div22(x12,x13),x14) -> div2{3,#}(x12,x13,x14)
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x) ->
     a#(divides1(x5),x6) -> divides{2,#}(x5,x6)
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> if{3,#}(a(f,x),x,filter2(f,xs))
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z) ->
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z) ->
     div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
     div2{3,#}(x,y,00()) -> divides{2,#}(x,y) ->
     divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y)
     divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y) ->
     div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
     divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y) -> div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
    SCC Processor:
     #sccs: 2
     #rules: 11
     #arcs: 37/289
     DPs:
      sieve{1,#}(cons2(x,xs)) -> sieve{1,#}(filter2(not1(divides1(x)),xs))
      sieve{1,#}(cons2(x,xs)) -> filter{2,#}(not1(divides1(x)),xs)
      filter{2,#}(f,cons2(x,xs)) -> filter{2,#}(f,xs)
      filter{2,#}(f,cons2(x,xs)) -> a#(f,x)
      a#(filter1(x17),x18) -> filter{2,#}(x17,x18)
      a#(not1(x28),x29) -> not{2,#}(x28,x29)
      not{2,#}(f,x) -> a#(f,x)
      a#(sieve0(),x33) -> sieve{1,#}(x33)
     TRS:
      divides2(00(),s1(y)) -> true0()
      divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
      div23(x,y,00()) -> divides2(x,y)
      div23(00(),y,s1(z)) -> false0()
      div23(s1(x),y,s1(z)) -> div23(x,y,z)
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
      if3(true0(),x,xs) -> cons2(x,xs)
      if3(false0(),x,xs) -> xs
      not2(f,x) -> not21(a(f,x))
      not21(true0()) -> false0()
      not21(false0()) -> true0()
      sieve1(nil0()) -> nil0()
      sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
      a(divides1(x5),x6) -> divides2(x5,x6)
      a(divides0(),x5) -> divides1(x5)
      a(s0(),x9) -> s1(x9)
      a(div22(x12,x13),x14) -> div23(x12,x13,x14)
      a(div21(x12),x13) -> div22(x12,x13)
      a(div20(),x12) -> div21(x12)
      a(filter1(x17),x18) -> filter2(x17,x18)
      a(filter0(),x17) -> filter1(x17)
      a(cons1(x21),x22) -> cons2(x21,x22)
      a(cons0(),x21) -> cons1(x21)
      a(if2(x24,x25),x26) -> if3(x24,x25,x26)
      a(if1(x24),x25) -> if2(x24,x25)
      a(if0(),x24) -> if1(x24)
      a(not1(x28),x29) -> not2(x28,x29)
      a(not0(),x28) -> not1(x28)
      a(not20(),x31) -> not21(x31)
      a(sieve0(),x33) -> sieve1(x33)
     Subterm Criterion Processor:
      simple projection:
       pi(filter2) = [1,1]
       pi(cons2) = [0,0,1,1]
       pi(if2) = [1,1]
       pi(if3) = [1,1,1,2,2]
       pi(filter{2,#}) = [1,1]
       pi(a#) = [1,1,1]
       pi(not{2,#}) = [1,1,1]
       pi(sieve{1,#}) = [0,0]
      problem:
       DPs:
        a#(not1(x28),x29) -> not{2,#}(x28,x29)
        not{2,#}(f,x) -> a#(f,x)
       TRS:
        divides2(00(),s1(y)) -> true0()
        divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
        div23(x,y,00()) -> divides2(x,y)
        div23(00(),y,s1(z)) -> false0()
        div23(s1(x),y,s1(z)) -> div23(x,y,z)
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
        if3(true0(),x,xs) -> cons2(x,xs)
        if3(false0(),x,xs) -> xs
        not2(f,x) -> not21(a(f,x))
        not21(true0()) -> false0()
        not21(false0()) -> true0()
        sieve1(nil0()) -> nil0()
        sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
        a(divides1(x5),x6) -> divides2(x5,x6)
        a(divides0(),x5) -> divides1(x5)
        a(s0(),x9) -> s1(x9)
        a(div22(x12,x13),x14) -> div23(x12,x13,x14)
        a(div21(x12),x13) -> div22(x12,x13)
        a(div20(),x12) -> div21(x12)
        a(filter1(x17),x18) -> filter2(x17,x18)
        a(filter0(),x17) -> filter1(x17)
        a(cons1(x21),x22) -> cons2(x21,x22)
        a(cons0(),x21) -> cons1(x21)
        a(if2(x24,x25),x26) -> if3(x24,x25,x26)
        a(if1(x24),x25) -> if2(x24,x25)
        a(if0(),x24) -> if1(x24)
        a(not1(x28),x29) -> not2(x28,x29)
        a(not0(),x28) -> not1(x28)
        a(not20(),x31) -> not21(x31)
        a(sieve0(),x33) -> sieve1(x33)
      Size-Change Termination Processor:
       DPs:
        
       TRS:
        divides2(00(),s1(y)) -> true0()
        divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
        div23(x,y,00()) -> divides2(x,y)
        div23(00(),y,s1(z)) -> false0()
        div23(s1(x),y,s1(z)) -> div23(x,y,z)
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
        if3(true0(),x,xs) -> cons2(x,xs)
        if3(false0(),x,xs) -> xs
        not2(f,x) -> not21(a(f,x))
        not21(true0()) -> false0()
        not21(false0()) -> true0()
        sieve1(nil0()) -> nil0()
        sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
        a(divides1(x5),x6) -> divides2(x5,x6)
        a(divides0(),x5) -> divides1(x5)
        a(s0(),x9) -> s1(x9)
        a(div22(x12,x13),x14) -> div23(x12,x13,x14)
        a(div21(x12),x13) -> div22(x12,x13)
        a(div20(),x12) -> div21(x12)
        a(filter1(x17),x18) -> filter2(x17,x18)
        a(filter0(),x17) -> filter1(x17)
        a(cons1(x21),x22) -> cons2(x21,x22)
        a(cons0(),x21) -> cons1(x21)
        a(if2(x24,x25),x26) -> if3(x24,x25,x26)
        a(if1(x24),x25) -> if2(x24,x25)
        a(if0(),x24) -> if1(x24)
        a(not1(x28),x29) -> not2(x28,x29)
        a(not0(),x28) -> not1(x28)
        a(not20(),x31) -> not21(x31)
        a(sieve0(),x33) -> sieve1(x33)
       The DP: a#(not1(x28),x29) -> not{2,#}(x28,x29) has the edges:
         0 >   0
         1 >=  1
       The DP: not{2,#}(f,x) -> a#(f,x) has the edges:
         0 >=  0
         1 >=  1
       Qed
     
     DPs:
      divides{2,#}(s1(x),s1(y)) -> div2{3,#}(x,s1(y),y)
      div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
      div2{3,#}(s1(x),y,s1(z)) -> div2{3,#}(x,y,z)
     TRS:
      divides2(00(),s1(y)) -> true0()
      divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
      div23(x,y,00()) -> divides2(x,y)
      div23(00(),y,s1(z)) -> false0()
      div23(s1(x),y,s1(z)) -> div23(x,y,z)
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
      if3(true0(),x,xs) -> cons2(x,xs)
      if3(false0(),x,xs) -> xs
      not2(f,x) -> not21(a(f,x))
      not21(true0()) -> false0()
      not21(false0()) -> true0()
      sieve1(nil0()) -> nil0()
      sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
      a(divides1(x5),x6) -> divides2(x5,x6)
      a(divides0(),x5) -> divides1(x5)
      a(s0(),x9) -> s1(x9)
      a(div22(x12,x13),x14) -> div23(x12,x13,x14)
      a(div21(x12),x13) -> div22(x12,x13)
      a(div20(),x12) -> div21(x12)
      a(filter1(x17),x18) -> filter2(x17,x18)
      a(filter0(),x17) -> filter1(x17)
      a(cons1(x21),x22) -> cons2(x21,x22)
      a(cons0(),x21) -> cons1(x21)
      a(if2(x24,x25),x26) -> if3(x24,x25,x26)
      a(if1(x24),x25) -> if2(x24,x25)
      a(if0(),x24) -> if1(x24)
      a(not1(x28),x29) -> not2(x28,x29)
      a(not0(),x28) -> not1(x28)
      a(not20(),x31) -> not21(x31)
      a(sieve0(),x33) -> sieve1(x33)
     Subterm Criterion Processor:
      simple projection:
       pi(divides{2,#}) = 0
       pi(div2{3,#}) = 0
      problem:
       DPs:
        div2{3,#}(x,y,00()) -> divides{2,#}(x,y)
       TRS:
        divides2(00(),s1(y)) -> true0()
        divides2(s1(x),s1(y)) -> div23(x,s1(y),y)
        div23(x,y,00()) -> divides2(x,y)
        div23(00(),y,s1(z)) -> false0()
        div23(s1(x),y,s1(z)) -> div23(x,y,z)
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> if3(a(f,x),x,filter2(f,xs))
        if3(true0(),x,xs) -> cons2(x,xs)
        if3(false0(),x,xs) -> xs
        not2(f,x) -> not21(a(f,x))
        not21(true0()) -> false0()
        not21(false0()) -> true0()
        sieve1(nil0()) -> nil0()
        sieve1(cons2(x,xs)) -> cons2(x,sieve1(filter2(not1(divides1(x)),xs)))
        a(divides1(x5),x6) -> divides2(x5,x6)
        a(divides0(),x5) -> divides1(x5)
        a(s0(),x9) -> s1(x9)
        a(div22(x12,x13),x14) -> div23(x12,x13,x14)
        a(div21(x12),x13) -> div22(x12,x13)
        a(div20(),x12) -> div21(x12)
        a(filter1(x17),x18) -> filter2(x17,x18)
        a(filter0(),x17) -> filter1(x17)
        a(cons1(x21),x22) -> cons2(x21,x22)
        a(cons0(),x21) -> cons1(x21)
        a(if2(x24,x25),x26) -> if3(x24,x25,x26)
        a(if1(x24),x25) -> if2(x24,x25)
        a(if0(),x24) -> if1(x24)
        a(not1(x28),x29) -> not2(x28,x29)
        a(not0(),x28) -> not1(x28)
        a(not20(),x31) -> not21(x31)
        a(sieve0(),x33) -> sieve1(x33)
      SCC Processor:
       #sccs: 0
       #rules: 0
       #arcs: 5/1