/export/starexec/sandbox2/solver/bin/starexec_run_ttt2 /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


YES

Problem:
 app'(app'(minus(),x),0()) -> x
 app'(app'(minus(),app'(s(),x)),app'(s(),y)) -> app'(app'(minus(),x),y)
 app'(app'(minus(),app'(app'(minus(),x),y)),z) -> app'(app'(minus(),x),app'(app'(plus(),y),z))
 app'(app'(quot(),0()),app'(s(),y)) -> 0()
 app'(app'(quot(),app'(s(),x)),app'(s(),y)) ->
 app'(s(),app'(app'(quot(),app'(app'(minus(),x),y)),app'(s(),y)))
 app'(app'(plus(),0()),y) -> y
 app'(app'(plus(),app'(s(),x)),y) -> app'(s(),app'(app'(plus(),x),y))
 app'(app'(app(),nil()),k) -> k
 app'(app'(app(),l),nil()) -> l
 app'(app'(app(),app'(app'(cons(),x),l)),k) -> app'(app'(cons(),x),app'(app'(app(),l),k))
 app'(sum(),app'(app'(cons(),x),nil())) -> app'(app'(cons(),x),nil())
 app'(sum(),app'(app'(cons(),x),app'(app'(cons(),y),l))) ->
 app'(sum(),app'(app'(cons(),app'(app'(plus(),x),y)),l))
 app'(sum(),app'(app'(app(),l),app'(app'(cons(),x),app'(app'(cons(),y),k)))) ->
 app'(sum(),app'(app'(app(),l),app'(sum(),app'(app'(cons(),x),app'(app'(cons(),y),k)))))
 app'(app'(map(),f),nil()) -> nil()
 app'(app'(map(),f),app'(app'(cons(),x),xs)) -> app'(app'(cons(),app'(f,x)),app'(app'(map(),f),xs))
 app'(app'(filter(),f),nil()) -> nil()
 app'(app'(filter(),f),app'(app'(cons(),x),xs)) ->
 app'(app'(app'(app'(filter2(),app'(f,x)),f),x),xs)
 app'(app'(app'(app'(filter2(),true()),f),x),xs) -> app'(app'(cons(),x),app'(app'(filter(),f),xs))
 app'(app'(app'(app'(filter2(),false()),f),x),xs) -> app'(app'(filter(),f),xs)

Proof:
 Extended Uncurrying Processor:
  application symbol: app'
  symbol table:
   false ==> false0/0
   true ==> true0/0
   filter2 ==> filter20/0 filter21/1 filter22/2 filter23/3 filter24/4
   filter ==> filter0/0 filter1/1 filter2/2
   map ==> map0/0 map1/1 map2/2
   sum ==> sum0/0 sum1/1
   cons ==> cons0/0 cons1/1 cons2/2
   nil ==> nil0/0
   app ==> app0/0 app1/1 app2/2
   quot ==> quot0/0 quot1/1 quot2/2
   plus ==> plus0/0 plus1/1 plus2/2
   s ==> s0/0 s1/1
   0 ==> 00/0
   minus ==> minus0/0 minus1/1 minus2/2
   
  uncurry-rules:
   app'(minus1(x7),x8) -> minus2(x7,x8)
   app'(minus0(),x7) -> minus1(x7)
   app'(s0(),x11) -> s1(x11)
   app'(plus1(x13),x14) -> plus2(x13,x14)
   app'(plus0(),x13) -> plus1(x13)
   app'(quot1(x16),x17) -> quot2(x16,x17)
   app'(quot0(),x16) -> quot1(x16)
   app'(app1(x19),x20) -> app2(x19,x20)
   app'(app0(),x19) -> app1(x19)
   app'(cons1(x23),x24) -> cons2(x23,x24)
   app'(cons0(),x23) -> cons1(x23)
   app'(sum0(),x26) -> sum1(x26)
   app'(map1(x28),x29) -> map2(x28,x29)
   app'(map0(),x28) -> map1(x28)
   app'(filter1(x31),x32) -> filter2(x31,x32)
   app'(filter0(),x31) -> filter1(x31)
   app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
   app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
   app'(filter21(x34),x35) -> filter22(x34,x35)
   app'(filter20(),x34) -> filter21(x34)
  eta-rules:
   
  problem:
   minus2(x,00()) -> x
   minus2(s1(x),s1(y)) -> minus2(x,y)
   minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
   quot2(00(),s1(y)) -> 00()
   quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
   plus2(00(),y) -> y
   plus2(s1(x),y) -> s1(plus2(x,y))
   app2(nil0(),k) -> k
   app2(l,nil0()) -> l
   app2(cons2(x,l),k) -> cons2(x,app2(l,k))
   sum1(cons2(x,nil0())) -> cons2(x,nil0())
   sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
   sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
   map2(f,nil0()) -> nil0()
   map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
   filter2(f,nil0()) -> nil0()
   filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
   filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
   filter24(false0(),f,x,xs) -> filter2(f,xs)
   app'(minus1(x7),x8) -> minus2(x7,x8)
   app'(minus0(),x7) -> minus1(x7)
   app'(s0(),x11) -> s1(x11)
   app'(plus1(x13),x14) -> plus2(x13,x14)
   app'(plus0(),x13) -> plus1(x13)
   app'(quot1(x16),x17) -> quot2(x16,x17)
   app'(quot0(),x16) -> quot1(x16)
   app'(app1(x19),x20) -> app2(x19,x20)
   app'(app0(),x19) -> app1(x19)
   app'(cons1(x23),x24) -> cons2(x23,x24)
   app'(cons0(),x23) -> cons1(x23)
   app'(sum0(),x26) -> sum1(x26)
   app'(map1(x28),x29) -> map2(x28,x29)
   app'(map0(),x28) -> map1(x28)
   app'(filter1(x31),x32) -> filter2(x31,x32)
   app'(filter0(),x31) -> filter1(x31)
   app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
   app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
   app'(filter21(x34),x35) -> filter22(x34,x35)
   app'(filter20(),x34) -> filter21(x34)
  DP Processor:
   DPs:
    minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
    minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
    quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
    plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
    app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
    sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
    sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
    sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
    sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
    sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
    map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
    map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
    filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
    filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
    filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
    filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
    app'#(minus1(x7),x8) -> minus{2,#}(x7,x8)
    app'#(plus1(x13),x14) -> plus{2,#}(x13,x14)
    app'#(quot1(x16),x17) -> quot{2,#}(x16,x17)
    app'#(app1(x19),x20) -> app{2,#}(x19,x20)
    app'#(sum0(),x26) -> sum{1,#}(x26)
    app'#(map1(x28),x29) -> map{2,#}(x28,x29)
    app'#(filter1(x31),x32) -> filter{2,#}(x31,x32)
    app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37)
   TRS:
    minus2(x,00()) -> x
    minus2(s1(x),s1(y)) -> minus2(x,y)
    minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
    quot2(00(),s1(y)) -> 00()
    quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
    plus2(00(),y) -> y
    plus2(s1(x),y) -> s1(plus2(x,y))
    app2(nil0(),k) -> k
    app2(l,nil0()) -> l
    app2(cons2(x,l),k) -> cons2(x,app2(l,k))
    sum1(cons2(x,nil0())) -> cons2(x,nil0())
    sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
    sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
    map2(f,nil0()) -> nil0()
    map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
    filter2(f,nil0()) -> nil0()
    filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
    filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
    filter24(false0(),f,x,xs) -> filter2(f,xs)
    app'(minus1(x7),x8) -> minus2(x7,x8)
    app'(minus0(),x7) -> minus1(x7)
    app'(s0(),x11) -> s1(x11)
    app'(plus1(x13),x14) -> plus2(x13,x14)
    app'(plus0(),x13) -> plus1(x13)
    app'(quot1(x16),x17) -> quot2(x16,x17)
    app'(quot0(),x16) -> quot1(x16)
    app'(app1(x19),x20) -> app2(x19,x20)
    app'(app0(),x19) -> app1(x19)
    app'(cons1(x23),x24) -> cons2(x23,x24)
    app'(cons0(),x23) -> cons1(x23)
    app'(sum0(),x26) -> sum1(x26)
    app'(map1(x28),x29) -> map2(x28,x29)
    app'(map0(),x28) -> map1(x28)
    app'(filter1(x31),x32) -> filter2(x31,x32)
    app'(filter0(),x31) -> filter1(x31)
    app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
    app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
    app'(filter21(x34),x35) -> filter22(x34,x35)
    app'(filter20(),x34) -> filter21(x34)
   TDG Processor:
    DPs:
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8)
     app'#(plus1(x13),x14) -> plus{2,#}(x13,x14)
     app'#(quot1(x16),x17) -> quot{2,#}(x16,x17)
     app'#(app1(x19),x20) -> app{2,#}(x19,x20)
     app'#(sum0(),x26) -> sum{1,#}(x26)
     app'#(map1(x28),x29) -> map{2,#}(x28,x29)
     app'#(filter1(x31),x32) -> filter{2,#}(x31,x32)
     app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37)
    TRS:
     minus2(x,00()) -> x
     minus2(s1(x),s1(y)) -> minus2(x,y)
     minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
     quot2(00(),s1(y)) -> 00()
     quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
     plus2(00(),y) -> y
     plus2(s1(x),y) -> s1(plus2(x,y))
     app2(nil0(),k) -> k
     app2(l,nil0()) -> l
     app2(cons2(x,l),k) -> cons2(x,app2(l,k))
     sum1(cons2(x,nil0())) -> cons2(x,nil0())
     sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
     sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
     map2(f,nil0()) -> nil0()
     map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
     filter2(f,nil0()) -> nil0()
     filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
     filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
     filter24(false0(),f,x,xs) -> filter2(f,xs)
     app'(minus1(x7),x8) -> minus2(x7,x8)
     app'(minus0(),x7) -> minus1(x7)
     app'(s0(),x11) -> s1(x11)
     app'(plus1(x13),x14) -> plus2(x13,x14)
     app'(plus0(),x13) -> plus1(x13)
     app'(quot1(x16),x17) -> quot2(x16,x17)
     app'(quot0(),x16) -> quot1(x16)
     app'(app1(x19),x20) -> app2(x19,x20)
     app'(app0(),x19) -> app1(x19)
     app'(cons1(x23),x24) -> cons2(x23,x24)
     app'(cons0(),x23) -> cons1(x23)
     app'(sum0(),x26) -> sum1(x26)
     app'(map1(x28),x29) -> map2(x28,x29)
     app'(map0(),x28) -> map1(x28)
     app'(filter1(x31),x32) -> filter2(x31,x32)
     app'(filter0(),x31) -> filter1(x31)
     app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
     app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
     app'(filter21(x34),x35) -> filter22(x34,x35)
     app'(filter20(),x34) -> filter21(x34)
    graph:
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(filter1(x31),x32) -> filter{2,#}(x31,x32)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(map1(x28),x29) -> map{2,#}(x28,x29)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(sum0(),x26) -> sum{1,#}(x26)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x19),x20) -> app{2,#}(x19,x20)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(quot1(x16),x17) -> quot{2,#}(x16,x17)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(plus1(x13),x14) -> plus{2,#}(x13,x14)
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8)
     app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     app'#(filter1(x31),x32) -> filter{2,#}(x31,x32) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     app'#(filter1(x31),x32) -> filter{2,#}(x31,x32) ->
     filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     app'#(map1(x28),x29) -> map{2,#}(x28,x29) ->
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     app'#(map1(x28),x29) -> map{2,#}(x28,x29) ->
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     app'#(sum0(),x26) -> sum{1,#}(x26) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     app'#(sum0(),x26) -> sum{1,#}(x26) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
     app'#(sum0(),x26) -> sum{1,#}(x26) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
     app'#(sum0(),x26) -> sum{1,#}(x26) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
     app'#(sum0(),x26) -> sum{1,#}(x26) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
     app'#(app1(x19),x20) -> app{2,#}(x19,x20) ->
     app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
     app'#(quot1(x16),x17) -> quot{2,#}(x16,x17) ->
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     app'#(quot1(x16),x17) -> quot{2,#}(x16,x17) ->
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     app'#(plus1(x13),x14) -> plus{2,#}(x13,x14) ->
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8) ->
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8) ->
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8) ->
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(filter1(x31),x32) -> filter{2,#}(x31,x32)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(map1(x28),x29) -> map{2,#}(x28,x29)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(sum0(),x26) -> sum{1,#}(x26)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x19),x20) -> app{2,#}(x19,x20)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(quot1(x16),x17) -> quot{2,#}(x16,x17)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(plus1(x13),x14) -> plus{2,#}(x13,x14)
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x) ->
     app'#(minus1(x7),x8) -> minus{2,#}(x7,x8)
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y) ->
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k))))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
     sum{1,#}(cons2(x,cons2(y,l))) -> plus{2,#}(x,y)
     sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> app{2,#}(l,sum1(cons2(x,cons2(y,k)))) ->
     app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
     app{2,#}(cons2(x,l),k) -> app{2,#}(l,k) ->
     app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y)) ->
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y)) ->
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y) ->
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) ->
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z) ->
     plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z)) ->
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z)) ->
     minus{2,#}(minus2(x,y),z) -> plus{2,#}(y,z)
     minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z)) ->
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    SCC Processor:
     #sccs: 6
     #rules: 17
     #arcs: 73/676
     DPs:
      filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
      filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
      app'#(map1(x28),x29) -> map{2,#}(x28,x29)
      map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
      map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
      app'#(filter1(x31),x32) -> filter{2,#}(x31,x32)
      filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
      filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
      app'#(filter23(x34,x35,x36),x37) -> filter2{4,#}(x34,x35,x36,x37)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     Subterm Criterion Processor:
      simple projection:
       pi(map{2,#}) = 0
       pi(app'#) = 0
       pi(filter{2,#}) = 0
       pi(filter2{4,#}) = 1
      problem:
       DPs:
        filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
        filter{2,#}(f,cons2(x,xs)) -> app'#(f,x)
        map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
        map{2,#}(f,cons2(x,xs)) -> app'#(f,x)
        filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
        filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
      SCC Processor:
       #sccs: 2
       #rules: 4
       #arcs: 20/36
       DPs:
        map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
       Subterm Criterion Processor:
        simple projection:
         pi(map{2,#}) = 1
        problem:
         DPs:
          
         TRS:
          minus2(x,00()) -> x
          minus2(s1(x),s1(y)) -> minus2(x,y)
          minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
          quot2(00(),s1(y)) -> 00()
          quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
          plus2(00(),y) -> y
          plus2(s1(x),y) -> s1(plus2(x,y))
          app2(nil0(),k) -> k
          app2(l,nil0()) -> l
          app2(cons2(x,l),k) -> cons2(x,app2(l,k))
          sum1(cons2(x,nil0())) -> cons2(x,nil0())
          sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
          sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
          map2(f,nil0()) -> nil0()
          map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app'(minus1(x7),x8) -> minus2(x7,x8)
          app'(minus0(),x7) -> minus1(x7)
          app'(s0(),x11) -> s1(x11)
          app'(plus1(x13),x14) -> plus2(x13,x14)
          app'(plus0(),x13) -> plus1(x13)
          app'(quot1(x16),x17) -> quot2(x16,x17)
          app'(quot0(),x16) -> quot1(x16)
          app'(app1(x19),x20) -> app2(x19,x20)
          app'(app0(),x19) -> app1(x19)
          app'(cons1(x23),x24) -> cons2(x23,x24)
          app'(cons0(),x23) -> cons1(x23)
          app'(sum0(),x26) -> sum1(x26)
          app'(map1(x28),x29) -> map2(x28,x29)
          app'(map0(),x28) -> map1(x28)
          app'(filter1(x31),x32) -> filter2(x31,x32)
          app'(filter0(),x31) -> filter1(x31)
          app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
          app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
          app'(filter21(x34),x35) -> filter22(x34,x35)
          app'(filter20(),x34) -> filter21(x34)
        Qed
       
       DPs:
        filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
        filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
        filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
       Subterm Criterion Processor:
        simple projection:
         pi(filter{2,#}) = 1
         pi(filter2{4,#}) = 3
        problem:
         DPs:
          filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
          filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
         TRS:
          minus2(x,00()) -> x
          minus2(s1(x),s1(y)) -> minus2(x,y)
          minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
          quot2(00(),s1(y)) -> 00()
          quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
          plus2(00(),y) -> y
          plus2(s1(x),y) -> s1(plus2(x,y))
          app2(nil0(),k) -> k
          app2(l,nil0()) -> l
          app2(cons2(x,l),k) -> cons2(x,app2(l,k))
          sum1(cons2(x,nil0())) -> cons2(x,nil0())
          sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
          sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
          map2(f,nil0()) -> nil0()
          map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app'(minus1(x7),x8) -> minus2(x7,x8)
          app'(minus0(),x7) -> minus1(x7)
          app'(s0(),x11) -> s1(x11)
          app'(plus1(x13),x14) -> plus2(x13,x14)
          app'(plus0(),x13) -> plus1(x13)
          app'(quot1(x16),x17) -> quot2(x16,x17)
          app'(quot0(),x16) -> quot1(x16)
          app'(app1(x19),x20) -> app2(x19,x20)
          app'(app0(),x19) -> app1(x19)
          app'(cons1(x23),x24) -> cons2(x23,x24)
          app'(cons0(),x23) -> cons1(x23)
          app'(sum0(),x26) -> sum1(x26)
          app'(map1(x28),x29) -> map2(x28,x29)
          app'(map0(),x28) -> map1(x28)
          app'(filter1(x31),x32) -> filter2(x31,x32)
          app'(filter0(),x31) -> filter1(x31)
          app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
          app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
          app'(filter21(x34),x35) -> filter22(x34,x35)
          app'(filter20(),x34) -> filter21(x34)
        SCC Processor:
         #sccs: 0
         #rules: 0
         #arcs: 4/4
         
     
     DPs:
      sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
      sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
      sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     EDG Processor:
      DPs:
       sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
      TRS:
       minus2(x,00()) -> x
       minus2(s1(x),s1(y)) -> minus2(x,y)
       minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
       quot2(00(),s1(y)) -> 00()
       quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
       plus2(00(),y) -> y
       plus2(s1(x),y) -> s1(plus2(x,y))
       app2(nil0(),k) -> k
       app2(l,nil0()) -> l
       app2(cons2(x,l),k) -> cons2(x,app2(l,k))
       sum1(cons2(x,nil0())) -> cons2(x,nil0())
       sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
       sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
       map2(f,nil0()) -> nil0()
       map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
       filter2(f,nil0()) -> nil0()
       filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
       filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
       filter24(false0(),f,x,xs) -> filter2(f,xs)
       app'(minus1(x7),x8) -> minus2(x7,x8)
       app'(minus0(),x7) -> minus1(x7)
       app'(s0(),x11) -> s1(x11)
       app'(plus1(x13),x14) -> plus2(x13,x14)
       app'(plus0(),x13) -> plus1(x13)
       app'(quot1(x16),x17) -> quot2(x16,x17)
       app'(quot0(),x16) -> quot1(x16)
       app'(app1(x19),x20) -> app2(x19,x20)
       app'(app0(),x19) -> app1(x19)
       app'(cons1(x23),x24) -> cons2(x23,x24)
       app'(cons0(),x23) -> cons1(x23)
       app'(sum0(),x26) -> sum1(x26)
       app'(map1(x28),x29) -> map2(x28,x29)
       app'(map0(),x28) -> map1(x28)
       app'(filter1(x31),x32) -> filter2(x31,x32)
       app'(filter0(),x31) -> filter1(x31)
       app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
       app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
       app'(filter21(x34),x35) -> filter22(x34,x35)
       app'(filter20(),x34) -> filter21(x34)
      graph:
       sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l)) ->
       sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k))) ->
       sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
       sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(cons2(x,cons2(y,k)))
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k))))) ->
       sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
      SCC Processor:
       #sccs: 2
       #rules: 2
       #arcs: 5/9
       DPs:
        sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
       Usable Rule Processor:
        DPs:
         sum{1,#}(app2(l,cons2(x,cons2(y,k)))) -> sum{1,#}(app2(l,sum1(cons2(x,cons2(y,k)))))
        TRS:
         sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
         sum1(cons2(x,nil0())) -> cons2(x,nil0())
         plus2(00(),y) -> y
         plus2(s1(x),y) -> s1(plus2(x,y))
         app2(nil0(),k) -> k
         app2(l,nil0()) -> l
         app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        Semantic Labeling Processor:
         dimension: 1
         usable rules:
          
         interpretation:
          [00] = 0,
          
          [cons2](x0, x1) = x1 + 1,
          
          [s1](x0) = 1,
          
          [nil0] = 0,
          
          [plus2](x0, x1) = x1 + 1,
          
          [sum1](x0) = 1,
          
          [app2](x0, x1) = x0 + x1 + 1
          labeled:
           sum{1,#}
          usable (for model):
           sum{1,#}
           app2
           cons2
           sum1
           plus2
           nil0
           s1
          argument filtering:
           pi(00) = []
           pi(s1) = []
           pi(plus2) = 0
           pi(app2) = 0
           pi(nil0) = []
           pi(cons2) = 0
           pi(sum1) = 0
           pi(sum{1,#}) = []
         precedence:
          sum{1,#} ~ sum1 ~ cons2 ~ nil0 ~ app2 ~ plus2 ~ s1 ~ 00
         problem:
          DPs:
           
          TRS:
           sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
           sum1(cons2(x,nil0())) -> cons2(x,nil0())
           plus2(00(),y) -> y
           plus2(s1(x),y) -> s1(plus2(x,y))
           app2(nil0(),k) -> k
           app2(l,nil0()) -> l
           app2(cons2(x,l),k) -> cons2(x,app2(l,k))
         Qed
       
       DPs:
        sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
       Usable Rule Processor:
        DPs:
         sum{1,#}(cons2(x,cons2(y,l))) -> sum{1,#}(cons2(plus2(x,y),l))
        TRS:
         plus2(00(),y) -> y
         plus2(s1(x),y) -> s1(plus2(x,y))
        Semantic Labeling Processor:
         dimension: 1
         usable rules:
          
         interpretation:
          [00] = 0,
          
          [cons2](x0, x1) = x1 + 1,
          
          [s1](x0) = x0,
          
          [plus2](x0, x1) = x1
          labeled:
           sum{1,#}
           cons2
           s1
          usable (for model):
           sum{1,#}
           cons2
           plus2
           s1
          argument filtering:
           pi(00) = []
           pi(s1) = []
           pi(plus2) = 0
           pi(cons2) = 0
           pi(sum{1,#}) = []
         precedence:
          sum{1,#} ~ cons2 ~ plus2 ~ s1 ~ 00
         problem:
          DPs:
           
          TRS:
           plus2(00(),y) -> y
           plus2(s1(x),y) -> s1(plus2(x,y))
         Qed
     
     DPs:
      app{2,#}(cons2(x,l),k) -> app{2,#}(l,k)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     Subterm Criterion Processor:
      simple projection:
       pi(app{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
      Qed
     
     DPs:
      quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     Subterm Criterion Processor:
      simple projection:
       pi(minus2) = 0
       pi(quot{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
      Qed
     
     DPs:
      minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
      minus{2,#}(minus2(x,y),z) -> minus{2,#}(x,plus2(y,z))
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     Subterm Criterion Processor:
      simple projection:
       pi(minus{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
      Qed
     
     DPs:
      plus{2,#}(s1(x),y) -> plus{2,#}(x,y)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      plus2(00(),y) -> y
      plus2(s1(x),y) -> s1(plus2(x,y))
      app2(nil0(),k) -> k
      app2(l,nil0()) -> l
      app2(cons2(x,l),k) -> cons2(x,app2(l,k))
      sum1(cons2(x,nil0())) -> cons2(x,nil0())
      sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
      sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x7),x8) -> minus2(x7,x8)
      app'(minus0(),x7) -> minus1(x7)
      app'(s0(),x11) -> s1(x11)
      app'(plus1(x13),x14) -> plus2(x13,x14)
      app'(plus0(),x13) -> plus1(x13)
      app'(quot1(x16),x17) -> quot2(x16,x17)
      app'(quot0(),x16) -> quot1(x16)
      app'(app1(x19),x20) -> app2(x19,x20)
      app'(app0(),x19) -> app1(x19)
      app'(cons1(x23),x24) -> cons2(x23,x24)
      app'(cons0(),x23) -> cons1(x23)
      app'(sum0(),x26) -> sum1(x26)
      app'(map1(x28),x29) -> map2(x28,x29)
      app'(map0(),x28) -> map1(x28)
      app'(filter1(x31),x32) -> filter2(x31,x32)
      app'(filter0(),x31) -> filter1(x31)
      app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
      app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
      app'(filter21(x34),x35) -> filter22(x34,x35)
      app'(filter20(),x34) -> filter21(x34)
     Subterm Criterion Processor:
      simple projection:
       pi(plus{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        minus2(minus2(x,y),z) -> minus2(x,plus2(y,z))
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        plus2(00(),y) -> y
        plus2(s1(x),y) -> s1(plus2(x,y))
        app2(nil0(),k) -> k
        app2(l,nil0()) -> l
        app2(cons2(x,l),k) -> cons2(x,app2(l,k))
        sum1(cons2(x,nil0())) -> cons2(x,nil0())
        sum1(cons2(x,cons2(y,l))) -> sum1(cons2(plus2(x,y),l))
        sum1(app2(l,cons2(x,cons2(y,k)))) -> sum1(app2(l,sum1(cons2(x,cons2(y,k)))))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x7),x8) -> minus2(x7,x8)
        app'(minus0(),x7) -> minus1(x7)
        app'(s0(),x11) -> s1(x11)
        app'(plus1(x13),x14) -> plus2(x13,x14)
        app'(plus0(),x13) -> plus1(x13)
        app'(quot1(x16),x17) -> quot2(x16,x17)
        app'(quot0(),x16) -> quot1(x16)
        app'(app1(x19),x20) -> app2(x19,x20)
        app'(app0(),x19) -> app1(x19)
        app'(cons1(x23),x24) -> cons2(x23,x24)
        app'(cons0(),x23) -> cons1(x23)
        app'(sum0(),x26) -> sum1(x26)
        app'(map1(x28),x29) -> map2(x28,x29)
        app'(map0(),x28) -> map1(x28)
        app'(filter1(x31),x32) -> filter2(x31,x32)
        app'(filter0(),x31) -> filter1(x31)
        app'(filter23(x34,x35,x36),x37) -> filter24(x34,x35,x36,x37)
        app'(filter22(x34,x35),x36) -> filter23(x34,x35,x36)
        app'(filter21(x34),x35) -> filter22(x34,x35)
        app'(filter20(),x34) -> filter21(x34)
      Qed