/export/starexec/sandbox/solver/bin/starexec_run_ttt2 /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/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'(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'(le(),0()),y) -> true()
 app'(app'(le(),app'(s(),x)),0()) -> false()
 app'(app'(le(),app'(s(),x)),app'(s(),y)) -> app'(app'(le(),x),y)
 app'(app'(app(),nil()),y) -> y
 app'(app'(app(),app'(app'(add(),n),x)),y) -> app'(app'(add(),n),app'(app'(app(),x),y))
 app'(app'(low(),n),nil()) -> nil()
 app'(app'(low(),n),app'(app'(add(),m),x)) ->
 app'(app'(app'(if_low(),app'(app'(le(),m),n)),n),app'(app'(add(),m),x))
 app'(app'(app'(if_low(),true()),n),app'(app'(add(),m),x)) ->
 app'(app'(add(),m),app'(app'(low(),n),x))
 app'(app'(app'(if_low(),false()),n),app'(app'(add(),m),x)) -> app'(app'(low(),n),x)
 app'(app'(high(),n),nil()) -> nil()
 app'(app'(high(),n),app'(app'(add(),m),x)) ->
 app'(app'(app'(if_high(),app'(app'(le(),m),n)),n),app'(app'(add(),m),x))
 app'(app'(app'(if_high(),true()),n),app'(app'(add(),m),x)) -> app'(app'(high(),n),x)
 app'(app'(app'(if_high(),false()),n),app'(app'(add(),m),x)) ->
 app'(app'(add(),m),app'(app'(high(),n),x))
 app'(quicksort(),nil()) -> nil()
 app'(quicksort(),app'(app'(add(),n),x)) ->
 app'(app'(app(),app'(quicksort(),app'(app'(low(),n),x))),app'(app'(add(),n),
                                                               app'(quicksort(),
                                                                    app'
                                                                    (app'(high(),n),x))))
 app'(app'(map(),f),nil()) -> nil()
 app'(app'(map(),f),app'(app'(add(),x),xs)) -> app'(app'(add(),app'(f,x)),app'(app'(map(),f),xs))
 app'(app'(filter(),f),nil()) -> nil()
 app'(app'(filter(),f),app'(app'(add(),x),xs)) ->
 app'(app'(app'(app'(filter2(),app'(f,x)),f),x),xs)
 app'(app'(app'(app'(filter2(),true()),f),x),xs) -> app'(app'(add(),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:
   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
   quicksort ==> quicksort0/0 quicksort1/1
   if_high ==> if_high0/0 if_high1/1 if_high2/2 if_high3/3
   high ==> high0/0 high1/1 high2/2
   if_low ==> if_low0/0 if_low1/1 if_low2/2 if_low3/3
   low ==> low0/0 low1/1 low2/2
   add ==> add0/0 add1/1 add2/2
   nil ==> nil0/0
   app ==> app0/0 app1/1 app2/2
   false ==> false0/0
   true ==> true0/0
   le ==> le0/0 le1/1 le2/2
   quot ==> quot0/0 quot1/1 quot2/2
   s ==> s0/0 s1/1
   0 ==> 00/0
   minus ==> minus0/0 minus1/1 minus2/2
   
  uncurry-rules:
   app'(minus1(x6),x7) -> minus2(x6,x7)
   app'(minus0(),x6) -> minus1(x6)
   app'(s0(),x10) -> s1(x10)
   app'(quot1(x12),x13) -> quot2(x12,x13)
   app'(quot0(),x12) -> quot1(x12)
   app'(le1(x15),x16) -> le2(x15,x16)
   app'(le0(),x15) -> le1(x15)
   app'(app1(x20),x21) -> app2(x20,x21)
   app'(app0(),x20) -> app1(x20)
   app'(add1(x24),x25) -> add2(x24,x25)
   app'(add0(),x24) -> add1(x24)
   app'(low1(x27),x28) -> low2(x27,x28)
   app'(low0(),x27) -> low1(x27)
   app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
   app'(if_low1(x30),x31) -> if_low2(x30,x31)
   app'(if_low0(),x30) -> if_low1(x30)
   app'(high1(x34),x35) -> high2(x34,x35)
   app'(high0(),x34) -> high1(x34)
   app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
   app'(if_high1(x37),x38) -> if_high2(x37,x38)
   app'(if_high0(),x37) -> if_high1(x37)
   app'(quicksort0(),x41) -> quicksort1(x41)
   app'(map1(x43),x44) -> map2(x43,x44)
   app'(map0(),x43) -> map1(x43)
   app'(filter1(x46),x47) -> filter2(x46,x47)
   app'(filter0(),x46) -> filter1(x46)
   app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
   app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
   app'(filter21(x49),x50) -> filter22(x49,x50)
   app'(filter20(),x49) -> filter21(x49)
  eta-rules:
   
  problem:
   minus2(x,00()) -> x
   minus2(s1(x),s1(y)) -> minus2(x,y)
   quot2(00(),s1(y)) -> 00()
   quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
   le2(00(),y) -> true0()
   le2(s1(x),00()) -> false0()
   le2(s1(x),s1(y)) -> le2(x,y)
   app2(nil0(),y) -> y
   app2(add2(n,x),y) -> add2(n,app2(x,y))
   low2(n,nil0()) -> nil0()
   low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
   if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
   if_low3(false0(),n,add2(m,x)) -> low2(n,x)
   high2(n,nil0()) -> nil0()
   high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
   if_high3(true0(),n,add2(m,x)) -> high2(n,x)
   if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
   quicksort1(nil0()) -> nil0()
   quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
   map2(f,nil0()) -> nil0()
   map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
   filter2(f,nil0()) -> nil0()
   filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
   filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
   filter24(false0(),f,x,xs) -> filter2(f,xs)
   app'(minus1(x6),x7) -> minus2(x6,x7)
   app'(minus0(),x6) -> minus1(x6)
   app'(s0(),x10) -> s1(x10)
   app'(quot1(x12),x13) -> quot2(x12,x13)
   app'(quot0(),x12) -> quot1(x12)
   app'(le1(x15),x16) -> le2(x15,x16)
   app'(le0(),x15) -> le1(x15)
   app'(app1(x20),x21) -> app2(x20,x21)
   app'(app0(),x20) -> app1(x20)
   app'(add1(x24),x25) -> add2(x24,x25)
   app'(add0(),x24) -> add1(x24)
   app'(low1(x27),x28) -> low2(x27,x28)
   app'(low0(),x27) -> low1(x27)
   app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
   app'(if_low1(x30),x31) -> if_low2(x30,x31)
   app'(if_low0(),x30) -> if_low1(x30)
   app'(high1(x34),x35) -> high2(x34,x35)
   app'(high0(),x34) -> high1(x34)
   app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
   app'(if_high1(x37),x38) -> if_high2(x37,x38)
   app'(if_high0(),x37) -> if_high1(x37)
   app'(quicksort0(),x41) -> quicksort1(x41)
   app'(map1(x43),x44) -> map2(x43,x44)
   app'(map0(),x43) -> map1(x43)
   app'(filter1(x46),x47) -> filter2(x46,x47)
   app'(filter0(),x46) -> filter1(x46)
   app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
   app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
   app'(filter21(x49),x50) -> filter22(x49,x50)
   app'(filter20(),x49) -> filter21(x49)
  DP Processor:
   DPs:
    minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
    le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
    app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
    low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
    low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
    if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x)
    if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x)
    high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
    high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
    if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x)
    if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x)
    quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x)
    quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
    quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x)
    quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
    quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
    map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
    map{2,#}(f,add2(x,xs)) -> app'#(f,x)
    filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
    filter{2,#}(f,add2(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(x6),x7) -> minus{2,#}(x6,x7)
    app'#(quot1(x12),x13) -> quot{2,#}(x12,x13)
    app'#(le1(x15),x16) -> le{2,#}(x15,x16)
    app'#(app1(x20),x21) -> app{2,#}(x20,x21)
    app'#(low1(x27),x28) -> low{2,#}(x27,x28)
    app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32)
    app'#(high1(x34),x35) -> high{2,#}(x34,x35)
    app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39)
    app'#(quicksort0(),x41) -> quicksort{1,#}(x41)
    app'#(map1(x43),x44) -> map{2,#}(x43,x44)
    app'#(filter1(x46),x47) -> filter{2,#}(x46,x47)
    app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52)
   TRS:
    minus2(x,00()) -> x
    minus2(s1(x),s1(y)) -> minus2(x,y)
    quot2(00(),s1(y)) -> 00()
    quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
    le2(00(),y) -> true0()
    le2(s1(x),00()) -> false0()
    le2(s1(x),s1(y)) -> le2(x,y)
    app2(nil0(),y) -> y
    app2(add2(n,x),y) -> add2(n,app2(x,y))
    low2(n,nil0()) -> nil0()
    low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
    if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
    if_low3(false0(),n,add2(m,x)) -> low2(n,x)
    high2(n,nil0()) -> nil0()
    high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
    if_high3(true0(),n,add2(m,x)) -> high2(n,x)
    if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
    quicksort1(nil0()) -> nil0()
    quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
    map2(f,nil0()) -> nil0()
    map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
    filter2(f,nil0()) -> nil0()
    filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
    filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
    filter24(false0(),f,x,xs) -> filter2(f,xs)
    app'(minus1(x6),x7) -> minus2(x6,x7)
    app'(minus0(),x6) -> minus1(x6)
    app'(s0(),x10) -> s1(x10)
    app'(quot1(x12),x13) -> quot2(x12,x13)
    app'(quot0(),x12) -> quot1(x12)
    app'(le1(x15),x16) -> le2(x15,x16)
    app'(le0(),x15) -> le1(x15)
    app'(app1(x20),x21) -> app2(x20,x21)
    app'(app0(),x20) -> app1(x20)
    app'(add1(x24),x25) -> add2(x24,x25)
    app'(add0(),x24) -> add1(x24)
    app'(low1(x27),x28) -> low2(x27,x28)
    app'(low0(),x27) -> low1(x27)
    app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
    app'(if_low1(x30),x31) -> if_low2(x30,x31)
    app'(if_low0(),x30) -> if_low1(x30)
    app'(high1(x34),x35) -> high2(x34,x35)
    app'(high0(),x34) -> high1(x34)
    app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
    app'(if_high1(x37),x38) -> if_high2(x37,x38)
    app'(if_high0(),x37) -> if_high1(x37)
    app'(quicksort0(),x41) -> quicksort1(x41)
    app'(map1(x43),x44) -> map2(x43,x44)
    app'(map0(),x43) -> map1(x43)
    app'(filter1(x46),x47) -> filter2(x46,x47)
    app'(filter0(),x46) -> filter1(x46)
    app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
    app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
    app'(filter21(x49),x50) -> filter22(x49,x50)
    app'(filter20(),x49) -> filter21(x49)
   TDG Processor:
    DPs:
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
     if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x)
     if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x)
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
     if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x)
     if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
     quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
     map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,add2(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(x6),x7) -> minus{2,#}(x6,x7)
     app'#(quot1(x12),x13) -> quot{2,#}(x12,x13)
     app'#(le1(x15),x16) -> le{2,#}(x15,x16)
     app'#(app1(x20),x21) -> app{2,#}(x20,x21)
     app'#(low1(x27),x28) -> low{2,#}(x27,x28)
     app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32)
     app'#(high1(x34),x35) -> high{2,#}(x34,x35)
     app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39)
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41)
     app'#(map1(x43),x44) -> map{2,#}(x43,x44)
     app'#(filter1(x46),x47) -> filter{2,#}(x46,x47)
     app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52)
    TRS:
     minus2(x,00()) -> x
     minus2(s1(x),s1(y)) -> minus2(x,y)
     quot2(00(),s1(y)) -> 00()
     quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
     le2(00(),y) -> true0()
     le2(s1(x),00()) -> false0()
     le2(s1(x),s1(y)) -> le2(x,y)
     app2(nil0(),y) -> y
     app2(add2(n,x),y) -> add2(n,app2(x,y))
     low2(n,nil0()) -> nil0()
     low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
     if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
     if_low3(false0(),n,add2(m,x)) -> low2(n,x)
     high2(n,nil0()) -> nil0()
     high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
     if_high3(true0(),n,add2(m,x)) -> high2(n,x)
     if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
     quicksort1(nil0()) -> nil0()
     quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
     map2(f,nil0()) -> nil0()
     map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
     filter2(f,nil0()) -> nil0()
     filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
     filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
     filter24(false0(),f,x,xs) -> filter2(f,xs)
     app'(minus1(x6),x7) -> minus2(x6,x7)
     app'(minus0(),x6) -> minus1(x6)
     app'(s0(),x10) -> s1(x10)
     app'(quot1(x12),x13) -> quot2(x12,x13)
     app'(quot0(),x12) -> quot1(x12)
     app'(le1(x15),x16) -> le2(x15,x16)
     app'(le0(),x15) -> le1(x15)
     app'(app1(x20),x21) -> app2(x20,x21)
     app'(app0(),x20) -> app1(x20)
     app'(add1(x24),x25) -> add2(x24,x25)
     app'(add0(),x24) -> add1(x24)
     app'(low1(x27),x28) -> low2(x27,x28)
     app'(low0(),x27) -> low1(x27)
     app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
     app'(if_low1(x30),x31) -> if_low2(x30,x31)
     app'(if_low0(),x30) -> if_low1(x30)
     app'(high1(x34),x35) -> high2(x34,x35)
     app'(high0(),x34) -> high1(x34)
     app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
     app'(if_high1(x37),x38) -> if_high2(x37,x38)
     app'(if_high0(),x37) -> if_high1(x37)
     app'(quicksort0(),x41) -> quicksort1(x41)
     app'(map1(x43),x44) -> map2(x43,x44)
     app'(map0(),x43) -> map1(x43)
     app'(filter1(x46),x47) -> filter2(x46,x47)
     app'(filter0(),x46) -> filter1(x46)
     app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
     app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
     app'(filter21(x49),x50) -> filter22(x49,x50)
     app'(filter20(),x49) -> filter21(x49)
    graph:
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
     filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(filter1(x46),x47) -> filter{2,#}(x46,x47)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(map1(x43),x44) -> map{2,#}(x43,x44)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(high1(x34),x35) -> high{2,#}(x34,x35)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(low1(x27),x28) -> low{2,#}(x27,x28)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x20),x21) -> app{2,#}(x20,x21)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(le1(x15),x16) -> le{2,#}(x15,x16)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(quot1(x12),x13) -> quot{2,#}(x12,x13)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(minus1(x6),x7) -> minus{2,#}(x6,x7)
     app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     app'#(filter1(x46),x47) -> filter{2,#}(x46,x47) ->
     filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
     app'#(filter1(x46),x47) -> filter{2,#}(x46,x47) ->
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
     app'#(map1(x43),x44) -> map{2,#}(x43,x44) ->
     map{2,#}(f,add2(x,xs)) -> app'#(f,x)
     app'#(map1(x43),x44) -> map{2,#}(x43,x44) ->
     map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41) ->
     quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41) ->
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x)
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41) ->
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x)
     app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39) ->
     if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x)
     app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39) ->
     if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x)
     app'#(high1(x34),x35) -> high{2,#}(x34,x35) ->
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
     app'#(high1(x34),x35) -> high{2,#}(x34,x35) ->
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32) ->
     if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x)
     app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32) ->
     if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x)
     app'#(low1(x27),x28) -> low{2,#}(x27,x28) ->
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
     app'#(low1(x27),x28) -> low{2,#}(x27,x28) ->
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     app'#(app1(x20),x21) -> app{2,#}(x20,x21) ->
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     app'#(le1(x15),x16) -> le{2,#}(x15,x16) ->
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     app'#(quot1(x12),x13) -> quot{2,#}(x12,x13) ->
     quot{2,#}(s1(x),s1(y)) -> quot{2,#}(minus2(x,y),s1(y))
     app'#(quot1(x12),x13) -> quot{2,#}(x12,x13) ->
     quot{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     app'#(minus1(x6),x7) -> minus{2,#}(x6,x7) ->
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(filter1(x46),x47) -> filter{2,#}(x46,x47)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(map1(x43),x44) -> map{2,#}(x43,x44)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(quicksort0(),x41) -> quicksort{1,#}(x41)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_high2(x37,x38),x39) -> if_high{3,#}(x37,x38,x39)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(high1(x34),x35) -> high{2,#}(x34,x35)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_low2(x30,x31),x32) -> if_low{3,#}(x30,x31,x32)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(low1(x27),x28) -> low{2,#}(x27,x28)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x20),x21) -> app{2,#}(x20,x21)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(le1(x15),x16) -> le{2,#}(x15,x16)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(quot1(x12),x13) -> quot{2,#}(x12,x13)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(minus1(x6),x7) -> minus{2,#}(x6,x7)
     map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,add2(x,xs)) -> app'#(f,x)
     map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
     quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x)) ->
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x)
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
     quicksort{1,#}(add2(n,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
     quicksort{1,#}(add2(n,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     quicksort{1,#}(add2(n,x)) -> app{2,#}(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x)))) ->
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
     if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
     if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x) ->
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x)) ->
     if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x)
     high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x)) ->
     if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x)
     high{2,#}(n,add2(m,x)) -> le{2,#}(m,n) ->
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
     if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
     if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x) ->
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n)
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x)) ->
     if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x)
     low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x)) ->
     if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x)
     low{2,#}(n,add2(m,x)) -> le{2,#}(m,n) ->
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y) ->
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y) ->
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,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)) -> 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,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y) -> minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
    SCC Processor:
     #sccs: 8
     #rules: 21
     #arcs: 91/1296
     DPs:
      filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
      filter{2,#}(f,add2(x,xs)) -> app'#(f,x)
      app'#(map1(x43),x44) -> map{2,#}(x43,x44)
      map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
      map{2,#}(f,add2(x,xs)) -> app'#(f,x)
      app'#(filter1(x46),x47) -> filter{2,#}(x46,x47)
      filter{2,#}(f,add2(x,xs)) -> filter2{4,#}(app'(f,x),f,x,xs)
      filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
      app'#(filter23(x49,x50,x51),x52) -> filter2{4,#}(x49,x50,x51,x52)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     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,add2(x,xs)) -> app'#(f,x)
        map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
        map{2,#}(f,add2(x,xs)) -> app'#(f,x)
        filter{2,#}(f,add2(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)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      SCC Processor:
       #sccs: 2
       #rules: 4
       #arcs: 20/36
       DPs:
        map{2,#}(f,add2(x,xs)) -> map{2,#}(f,xs)
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
       Subterm Criterion Processor:
        simple projection:
         pi(map{2,#}) = 1
        problem:
         DPs:
          
         TRS:
          minus2(x,00()) -> x
          minus2(s1(x),s1(y)) -> minus2(x,y)
          quot2(00(),s1(y)) -> 00()
          quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
          le2(00(),y) -> true0()
          le2(s1(x),00()) -> false0()
          le2(s1(x),s1(y)) -> le2(x,y)
          app2(nil0(),y) -> y
          app2(add2(n,x),y) -> add2(n,app2(x,y))
          low2(n,nil0()) -> nil0()
          low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
          if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
          if_low3(false0(),n,add2(m,x)) -> low2(n,x)
          high2(n,nil0()) -> nil0()
          high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
          if_high3(true0(),n,add2(m,x)) -> high2(n,x)
          if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
          quicksort1(nil0()) -> nil0()
          quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
          map2(f,nil0()) -> nil0()
          map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app'(minus1(x6),x7) -> minus2(x6,x7)
          app'(minus0(),x6) -> minus1(x6)
          app'(s0(),x10) -> s1(x10)
          app'(quot1(x12),x13) -> quot2(x12,x13)
          app'(quot0(),x12) -> quot1(x12)
          app'(le1(x15),x16) -> le2(x15,x16)
          app'(le0(),x15) -> le1(x15)
          app'(app1(x20),x21) -> app2(x20,x21)
          app'(app0(),x20) -> app1(x20)
          app'(add1(x24),x25) -> add2(x24,x25)
          app'(add0(),x24) -> add1(x24)
          app'(low1(x27),x28) -> low2(x27,x28)
          app'(low0(),x27) -> low1(x27)
          app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
          app'(if_low1(x30),x31) -> if_low2(x30,x31)
          app'(if_low0(),x30) -> if_low1(x30)
          app'(high1(x34),x35) -> high2(x34,x35)
          app'(high0(),x34) -> high1(x34)
          app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
          app'(if_high1(x37),x38) -> if_high2(x37,x38)
          app'(if_high0(),x37) -> if_high1(x37)
          app'(quicksort0(),x41) -> quicksort1(x41)
          app'(map1(x43),x44) -> map2(x43,x44)
          app'(map0(),x43) -> map1(x43)
          app'(filter1(x46),x47) -> filter2(x46,x47)
          app'(filter0(),x46) -> filter1(x46)
          app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
          app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
          app'(filter21(x49),x50) -> filter22(x49,x50)
          app'(filter20(),x49) -> filter21(x49)
        Qed
       
       DPs:
        filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
        filter{2,#}(f,add2(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)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
       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)
          quot2(00(),s1(y)) -> 00()
          quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
          le2(00(),y) -> true0()
          le2(s1(x),00()) -> false0()
          le2(s1(x),s1(y)) -> le2(x,y)
          app2(nil0(),y) -> y
          app2(add2(n,x),y) -> add2(n,app2(x,y))
          low2(n,nil0()) -> nil0()
          low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
          if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
          if_low3(false0(),n,add2(m,x)) -> low2(n,x)
          high2(n,nil0()) -> nil0()
          high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
          if_high3(true0(),n,add2(m,x)) -> high2(n,x)
          if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
          quicksort1(nil0()) -> nil0()
          quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
          map2(f,nil0()) -> nil0()
          map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app'(minus1(x6),x7) -> minus2(x6,x7)
          app'(minus0(),x6) -> minus1(x6)
          app'(s0(),x10) -> s1(x10)
          app'(quot1(x12),x13) -> quot2(x12,x13)
          app'(quot0(),x12) -> quot1(x12)
          app'(le1(x15),x16) -> le2(x15,x16)
          app'(le0(),x15) -> le1(x15)
          app'(app1(x20),x21) -> app2(x20,x21)
          app'(app0(),x20) -> app1(x20)
          app'(add1(x24),x25) -> add2(x24,x25)
          app'(add0(),x24) -> add1(x24)
          app'(low1(x27),x28) -> low2(x27,x28)
          app'(low0(),x27) -> low1(x27)
          app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
          app'(if_low1(x30),x31) -> if_low2(x30,x31)
          app'(if_low0(),x30) -> if_low1(x30)
          app'(high1(x34),x35) -> high2(x34,x35)
          app'(high0(),x34) -> high1(x34)
          app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
          app'(if_high1(x37),x38) -> if_high2(x37,x38)
          app'(if_high0(),x37) -> if_high1(x37)
          app'(quicksort0(),x41) -> quicksort1(x41)
          app'(map1(x43),x44) -> map2(x43,x44)
          app'(map0(),x43) -> map1(x43)
          app'(filter1(x46),x47) -> filter2(x46,x47)
          app'(filter0(),x46) -> filter1(x46)
          app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
          app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
          app'(filter21(x49),x50) -> filter22(x49,x50)
          app'(filter20(),x49) -> filter21(x49)
        SCC Processor:
         #sccs: 0
         #rules: 0
         #arcs: 4/4
         
     
     DPs:
      quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
      quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Usable Rule Processor:
      DPs:
       quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(high2(n,x))
       quicksort{1,#}(add2(n,x)) -> quicksort{1,#}(low2(n,x))
      TRS:
       high2(n,nil0()) -> nil0()
       high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
       if_high3(true0(),n,add2(m,x)) -> high2(n,x)
       if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
       le2(00(),y) -> true0()
       le2(s1(x),00()) -> false0()
       le2(s1(x),s1(y)) -> le2(x,y)
       low2(n,nil0()) -> nil0()
       low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
       if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
       if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      KBO Processor:
       argument filtering:
        pi(00) = []
        pi(s1) = 0
        pi(le2) = []
        pi(true0) = []
        pi(false0) = []
        pi(nil0) = []
        pi(add2) = [0,1]
        pi(low2) = 1
        pi(if_low3) = 2
        pi(high2) = 1
        pi(if_high3) = 2
        pi(quicksort{1,#}) = 0
       usable rules:
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
       weight function:
        w0 = 1
        w(quicksort{1,#}) = w(nil0) = w(false0) = w(true0) = w(le2) = w(
        s1) = w(00) = 1
        w(if_high3) = w(high2) = w(if_low3) = w(low2) = w(add2) = 0
       precedence:
        quicksort{1,#} > 00 > high2 > if_low3 > nil0 > true0 > if_high3 > 
        s1 > add2 > false0 > le2 > low2
       problem:
        DPs:
         
        TRS:
         high2(n,nil0()) -> nil0()
         high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
         if_high3(true0(),n,add2(m,x)) -> high2(n,x)
         if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
         le2(00(),y) -> true0()
         le2(s1(x),00()) -> false0()
         le2(s1(x),s1(y)) -> le2(x,y)
         low2(n,nil0()) -> nil0()
         low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
         if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
         if_low3(false0(),n,add2(m,x)) -> low2(n,x)
       Qed
     
     DPs:
      high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
      if_high{3,#}(true0(),n,add2(m,x)) -> high{2,#}(n,x)
      if_high{3,#}(false0(),n,add2(m,x)) -> high{2,#}(n,x)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Subterm Criterion Processor:
      simple projection:
       pi(high{2,#}) = 1
       pi(if_high{3,#}) = 2
      problem:
       DPs:
        high{2,#}(n,add2(m,x)) -> if_high{3,#}(le2(m,n),n,add2(m,x))
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      SCC Processor:
       #sccs: 0
       #rules: 0
       #arcs: 4/1
       
     
     DPs:
      low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
      if_low{3,#}(true0(),n,add2(m,x)) -> low{2,#}(n,x)
      if_low{3,#}(false0(),n,add2(m,x)) -> low{2,#}(n,x)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Subterm Criterion Processor:
      simple projection:
       pi(low{2,#}) = 1
       pi(if_low{3,#}) = 2
      problem:
       DPs:
        low{2,#}(n,add2(m,x)) -> if_low{3,#}(le2(m,n),n,add2(m,x))
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      SCC Processor:
       #sccs: 0
       #rules: 0
       #arcs: 4/1
       
     
     DPs:
      app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Subterm Criterion Processor:
      simple projection:
       pi(app{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      Qed
     
     DPs:
      le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Subterm Criterion Processor:
      simple projection:
       pi(le{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      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)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     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)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      Qed
     
     DPs:
      minus{2,#}(s1(x),s1(y)) -> minus{2,#}(x,y)
     TRS:
      minus2(x,00()) -> x
      minus2(s1(x),s1(y)) -> minus2(x,y)
      quot2(00(),s1(y)) -> 00()
      quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
      le2(00(),y) -> true0()
      le2(s1(x),00()) -> false0()
      le2(s1(x),s1(y)) -> le2(x,y)
      app2(nil0(),y) -> y
      app2(add2(n,x),y) -> add2(n,app2(x,y))
      low2(n,nil0()) -> nil0()
      low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
      if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
      if_low3(false0(),n,add2(m,x)) -> low2(n,x)
      high2(n,nil0()) -> nil0()
      high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
      if_high3(true0(),n,add2(m,x)) -> high2(n,x)
      if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
      quicksort1(nil0()) -> nil0()
      quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
      map2(f,nil0()) -> nil0()
      map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app'(minus1(x6),x7) -> minus2(x6,x7)
      app'(minus0(),x6) -> minus1(x6)
      app'(s0(),x10) -> s1(x10)
      app'(quot1(x12),x13) -> quot2(x12,x13)
      app'(quot0(),x12) -> quot1(x12)
      app'(le1(x15),x16) -> le2(x15,x16)
      app'(le0(),x15) -> le1(x15)
      app'(app1(x20),x21) -> app2(x20,x21)
      app'(app0(),x20) -> app1(x20)
      app'(add1(x24),x25) -> add2(x24,x25)
      app'(add0(),x24) -> add1(x24)
      app'(low1(x27),x28) -> low2(x27,x28)
      app'(low0(),x27) -> low1(x27)
      app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
      app'(if_low1(x30),x31) -> if_low2(x30,x31)
      app'(if_low0(),x30) -> if_low1(x30)
      app'(high1(x34),x35) -> high2(x34,x35)
      app'(high0(),x34) -> high1(x34)
      app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
      app'(if_high1(x37),x38) -> if_high2(x37,x38)
      app'(if_high0(),x37) -> if_high1(x37)
      app'(quicksort0(),x41) -> quicksort1(x41)
      app'(map1(x43),x44) -> map2(x43,x44)
      app'(map0(),x43) -> map1(x43)
      app'(filter1(x46),x47) -> filter2(x46,x47)
      app'(filter0(),x46) -> filter1(x46)
      app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
      app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
      app'(filter21(x49),x50) -> filter22(x49,x50)
      app'(filter20(),x49) -> filter21(x49)
     Subterm Criterion Processor:
      simple projection:
       pi(minus{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        minus2(x,00()) -> x
        minus2(s1(x),s1(y)) -> minus2(x,y)
        quot2(00(),s1(y)) -> 00()
        quot2(s1(x),s1(y)) -> s1(quot2(minus2(x,y),s1(y)))
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
        low2(n,nil0()) -> nil0()
        low2(n,add2(m,x)) -> if_low3(le2(m,n),n,add2(m,x))
        if_low3(true0(),n,add2(m,x)) -> add2(m,low2(n,x))
        if_low3(false0(),n,add2(m,x)) -> low2(n,x)
        high2(n,nil0()) -> nil0()
        high2(n,add2(m,x)) -> if_high3(le2(m,n),n,add2(m,x))
        if_high3(true0(),n,add2(m,x)) -> high2(n,x)
        if_high3(false0(),n,add2(m,x)) -> add2(m,high2(n,x))
        quicksort1(nil0()) -> nil0()
        quicksort1(add2(n,x)) -> app2(quicksort1(low2(n,x)),add2(n,quicksort1(high2(n,x))))
        map2(f,nil0()) -> nil0()
        map2(f,add2(x,xs)) -> add2(app'(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,add2(x,xs)) -> filter24(app'(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> add2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app'(minus1(x6),x7) -> minus2(x6,x7)
        app'(minus0(),x6) -> minus1(x6)
        app'(s0(),x10) -> s1(x10)
        app'(quot1(x12),x13) -> quot2(x12,x13)
        app'(quot0(),x12) -> quot1(x12)
        app'(le1(x15),x16) -> le2(x15,x16)
        app'(le0(),x15) -> le1(x15)
        app'(app1(x20),x21) -> app2(x20,x21)
        app'(app0(),x20) -> app1(x20)
        app'(add1(x24),x25) -> add2(x24,x25)
        app'(add0(),x24) -> add1(x24)
        app'(low1(x27),x28) -> low2(x27,x28)
        app'(low0(),x27) -> low1(x27)
        app'(if_low2(x30,x31),x32) -> if_low3(x30,x31,x32)
        app'(if_low1(x30),x31) -> if_low2(x30,x31)
        app'(if_low0(),x30) -> if_low1(x30)
        app'(high1(x34),x35) -> high2(x34,x35)
        app'(high0(),x34) -> high1(x34)
        app'(if_high2(x37,x38),x39) -> if_high3(x37,x38,x39)
        app'(if_high1(x37),x38) -> if_high2(x37,x38)
        app'(if_high0(),x37) -> if_high1(x37)
        app'(quicksort0(),x41) -> quicksort1(x41)
        app'(map1(x43),x44) -> map2(x43,x44)
        app'(map0(),x43) -> map1(x43)
        app'(filter1(x46),x47) -> filter2(x46,x47)
        app'(filter0(),x46) -> filter1(x46)
        app'(filter23(x49,x50,x51),x52) -> filter24(x49,x50,x51,x52)
        app'(filter22(x49,x50),x51) -> filter23(x49,x50,x51)
        app'(filter21(x49),x50) -> filter22(x49,x50)
        app'(filter20(),x49) -> filter21(x49)
      Qed