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


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


YES

Problem:
 app'(app'(eq(),0()),0()) -> true()
 app'(app'(eq(),0()),app'(s(),x)) -> false()
 app'(app'(eq(),app'(s(),x)),0()) -> false()
 app'(app'(eq(),app'(s(),x)),app'(s(),y)) -> app'(app'(eq(),x),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'(min(),app'(app'(add(),n),nil())) -> n
 app'(min(),app'(app'(add(),n),app'(app'(add(),m),x))) ->
 app'(app'(if_min(),app'(app'(le(),n),m)),app'(app'(add(),n),app'(app'(add(),m),x)))
 app'(app'(if_min(),true()),app'(app'(add(),n),app'(app'(add(),m),x))) ->
 app'(min(),app'(app'(add(),n),x))
 app'(app'(if_min(),false()),app'(app'(add(),n),app'(app'(add(),m),x))) ->
 app'(min(),app'(app'(add(),m),x))
 app'(app'(rm(),n),nil()) -> nil()
 app'(app'(rm(),n),app'(app'(add(),m),x)) ->
 app'(app'(app'(if_rm(),app'(app'(eq(),n),m)),n),app'(app'(add(),m),x))
 app'(app'(app'(if_rm(),true()),n),app'(app'(add(),m),x)) -> app'(app'(rm(),n),x)
 app'(app'(app'(if_rm(),false()),n),app'(app'(add(),m),x)) ->
 app'(app'(add(),m),app'(app'(rm(),n),x))
 app'(app'(minsort(),nil()),nil()) -> nil()
 app'(app'(minsort(),app'(app'(add(),n),x)),y) ->
 app'(app'(app'(if_minsort(),app'(app'(eq(),n),app'(min(),app'(app'(add(),n),x)))),
           app'(app'(add(),n),x)),y)
 app'(app'(app'(if_minsort(),true()),app'(app'(add(),n),x)),y) ->
 app'(app'(add(),n),app'(app'(minsort(),app'(app'(app(),app'(app'(rm(),n),x)),y)),nil()))
 app'(app'(app'(if_minsort(),false()),app'(app'(add(),n),x)),y) ->
 app'(app'(minsort(),x),app'(app'(add(),n),y))
 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
   if_minsort ==> if_minsort0/0 if_minsort1/1 if_minsort2/2 if_minsort3/3
   minsort ==> minsort0/0 minsort1/1 minsort2/2
   if_rm ==> if_rm0/0 if_rm1/1 if_rm2/2 if_rm3/3
   rm ==> rm0/0 rm1/1 rm2/2
   if_min ==> if_min0/0 if_min1/1 if_min2/2
   min ==> min0/0 min1/1
   add ==> add0/0 add1/1 add2/2
   nil ==> nil0/0
   app ==> app0/0 app1/1 app2/2
   le ==> le0/0 le1/1 le2/2
   false ==> false0/0
   s ==> s0/0 s1/1
   true ==> true0/0
   0 ==> 00/0
   eq ==> eq0/0 eq1/1 eq2/2
   
  uncurry-rules:
   app'(eq1(x6),x7) -> eq2(x6,x7)
   app'(eq0(),x6) -> eq1(x6)
   app'(s0(),x11) -> s1(x11)
   app'(le1(x14),x15) -> le2(x14,x15)
   app'(le0(),x14) -> le1(x14)
   app'(app1(x17),x18) -> app2(x17,x18)
   app'(app0(),x17) -> app1(x17)
   app'(add1(x21),x22) -> add2(x21,x22)
   app'(add0(),x21) -> add1(x21)
   app'(min0(),x24) -> min1(x24)
   app'(if_min1(x26),x27) -> if_min2(x26,x27)
   app'(if_min0(),x26) -> if_min1(x26)
   app'(rm1(x29),x30) -> rm2(x29,x30)
   app'(rm0(),x29) -> rm1(x29)
   app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
   app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
   app'(if_rm0(),x32) -> if_rm1(x32)
   app'(minsort1(x36),x37) -> minsort2(x36,x37)
   app'(minsort0(),x36) -> minsort1(x36)
   app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
   app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
   app'(if_minsort0(),x39) -> if_minsort1(x39)
   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:
   eq2(00(),00()) -> true0()
   eq2(00(),s1(x)) -> false0()
   eq2(s1(x),00()) -> false0()
   eq2(s1(x),s1(y)) -> eq2(x,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))
   min1(add2(n,nil0())) -> n
   min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
   if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
   if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
   rm2(n,nil0()) -> nil0()
   rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
   if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
   if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
   minsort2(nil0(),nil0()) -> nil0()
   minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
   if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
   if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
   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'(eq1(x6),x7) -> eq2(x6,x7)
   app'(eq0(),x6) -> eq1(x6)
   app'(s0(),x11) -> s1(x11)
   app'(le1(x14),x15) -> le2(x14,x15)
   app'(le0(),x14) -> le1(x14)
   app'(app1(x17),x18) -> app2(x17,x18)
   app'(app0(),x17) -> app1(x17)
   app'(add1(x21),x22) -> add2(x21,x22)
   app'(add0(),x21) -> add1(x21)
   app'(min0(),x24) -> min1(x24)
   app'(if_min1(x26),x27) -> if_min2(x26,x27)
   app'(if_min0(),x26) -> if_min1(x26)
   app'(rm1(x29),x30) -> rm2(x29,x30)
   app'(rm0(),x29) -> rm1(x29)
   app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
   app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
   app'(if_rm0(),x32) -> if_rm1(x32)
   app'(minsort1(x36),x37) -> minsort2(x36,x37)
   app'(minsort0(),x36) -> minsort1(x36)
   app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
   app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
   app'(if_minsort0(),x39) -> if_minsort1(x39)
   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:
    eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
    le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
    app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
    min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
    min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
    if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
    if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
    rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
    rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
    if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x)
    if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x)
    minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x))
    minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x)))
    minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
    if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x)
    if_minsort{3,#}(true0(),add2(n,x),y) -> app{2,#}(rm2(n,x),y)
    if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
    if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
    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'#(eq1(x6),x7) -> eq{2,#}(x6,x7)
    app'#(le1(x14),x15) -> le{2,#}(x14,x15)
    app'#(app1(x17),x18) -> app{2,#}(x17,x18)
    app'#(min0(),x24) -> min{1,#}(x24)
    app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27)
    app'#(rm1(x29),x30) -> rm{2,#}(x29,x30)
    app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34)
    app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37)
    app'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,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:
    eq2(00(),00()) -> true0()
    eq2(00(),s1(x)) -> false0()
    eq2(s1(x),00()) -> false0()
    eq2(s1(x),s1(y)) -> eq2(x,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))
    min1(add2(n,nil0())) -> n
    min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
    if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
    if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
    rm2(n,nil0()) -> nil0()
    rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
    if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
    if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
    minsort2(nil0(),nil0()) -> nil0()
    minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
    if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
    if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
    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'(eq1(x6),x7) -> eq2(x6,x7)
    app'(eq0(),x6) -> eq1(x6)
    app'(s0(),x11) -> s1(x11)
    app'(le1(x14),x15) -> le2(x14,x15)
    app'(le0(),x14) -> le1(x14)
    app'(app1(x17),x18) -> app2(x17,x18)
    app'(app0(),x17) -> app1(x17)
    app'(add1(x21),x22) -> add2(x21,x22)
    app'(add0(),x21) -> add1(x21)
    app'(min0(),x24) -> min1(x24)
    app'(if_min1(x26),x27) -> if_min2(x26,x27)
    app'(if_min0(),x26) -> if_min1(x26)
    app'(rm1(x29),x30) -> rm2(x29,x30)
    app'(rm0(),x29) -> rm1(x29)
    app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
    app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
    app'(if_rm0(),x32) -> if_rm1(x32)
    app'(minsort1(x36),x37) -> minsort2(x36,x37)
    app'(minsort0(),x36) -> minsort1(x36)
    app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
    app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
    app'(if_minsort0(),x39) -> if_minsort1(x39)
    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:
     eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
     if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
     if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
     if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x)
     if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x)
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x))
     minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x)))
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
     if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x)
     if_minsort{3,#}(true0(),add2(n,x),y) -> app{2,#}(rm2(n,x),y)
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
     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'#(eq1(x6),x7) -> eq{2,#}(x6,x7)
     app'#(le1(x14),x15) -> le{2,#}(x14,x15)
     app'#(app1(x17),x18) -> app{2,#}(x17,x18)
     app'#(min0(),x24) -> min{1,#}(x24)
     app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27)
     app'#(rm1(x29),x30) -> rm{2,#}(x29,x30)
     app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34)
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37)
     app'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,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:
     eq2(00(),00()) -> true0()
     eq2(00(),s1(x)) -> false0()
     eq2(s1(x),00()) -> false0()
     eq2(s1(x),s1(y)) -> eq2(x,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))
     min1(add2(n,nil0())) -> n
     min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
     if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
     if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
     rm2(n,nil0()) -> nil0()
     rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
     if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
     if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
     minsort2(nil0(),nil0()) -> nil0()
     minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
     if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
     if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
     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'(eq1(x6),x7) -> eq2(x6,x7)
     app'(eq0(),x6) -> eq1(x6)
     app'(s0(),x11) -> s1(x11)
     app'(le1(x14),x15) -> le2(x14,x15)
     app'(le0(),x14) -> le1(x14)
     app'(app1(x17),x18) -> app2(x17,x18)
     app'(app0(),x17) -> app1(x17)
     app'(add1(x21),x22) -> add2(x21,x22)
     app'(add0(),x21) -> add1(x21)
     app'(min0(),x24) -> min1(x24)
     app'(if_min1(x26),x27) -> if_min2(x26,x27)
     app'(if_min0(),x26) -> if_min1(x26)
     app'(rm1(x29),x30) -> rm2(x29,x30)
     app'(rm0(),x29) -> rm1(x29)
     app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
     app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
     app'(if_rm0(),x32) -> if_rm1(x32)
     app'(minsort1(x36),x37) -> minsort2(x36,x37)
     app'(minsort0(),x36) -> minsort1(x36)
     app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
     app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
     app'(if_minsort0(),x39) -> if_minsort1(x39)
     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'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(rm1(x29),x30) -> rm{2,#}(x29,x30)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(min0(),x24) -> min{1,#}(x24)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x17),x18) -> app{2,#}(x17,x18)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(le1(x14),x15) -> le{2,#}(x14,x15)
     filter{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(eq1(x6),x7) -> eq{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'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41) ->
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
     app'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
     app'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> app{2,#}(rm2(n,x),y)
     app'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x)
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37) ->
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37) ->
     minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x)))
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37) ->
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x))
     app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34) ->
     if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x)
     app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34) ->
     if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x)
     app'#(rm1(x29),x30) -> rm{2,#}(x29,x30) ->
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
     app'#(rm1(x29),x30) -> rm{2,#}(x29,x30) ->
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
     app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27) ->
     if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
     app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27) ->
     if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
     app'#(min0(),x24) -> min{1,#}(x24) ->
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
     app'#(min0(),x24) -> min{1,#}(x24) ->
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
     app'#(app1(x17),x18) -> app{2,#}(x17,x18) ->
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     app'#(le1(x14),x15) -> le{2,#}(x14,x15) ->
     le{2,#}(s1(x),s1(y)) -> le{2,#}(x,y)
     app'#(eq1(x6),x7) -> eq{2,#}(x6,x7) ->
     eq{2,#}(s1(x),s1(y)) -> eq{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'#(if_minsort2(x39,x40),x41) -> if_minsort{3,#}(x39,x40,x41)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(minsort1(x36),x37) -> minsort{2,#}(x36,x37)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_rm2(x32,x33),x34) -> if_rm{3,#}(x32,x33,x34)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(rm1(x29),x30) -> rm{2,#}(x29,x30)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(if_min1(x26),x27) -> if_min{2,#}(x26,x27)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(min0(),x24) -> min{1,#}(x24)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(app1(x17),x18) -> app{2,#}(x17,x18)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(le1(x14),x15) -> le{2,#}(x14,x15)
     map{2,#}(f,add2(x,xs)) -> app'#(f,x) ->
     app'#(eq1(x6),x7) -> eq{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)
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y)) ->
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y)) ->
     minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x)))
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y)) ->
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x))
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0()) ->
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0()) ->
     minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x)))
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0()) ->
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x))
     if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
     if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
     if_minsort{3,#}(true0(),add2(n,x),y) -> app{2,#}(rm2(n,x),y) ->
     app{2,#}(add2(n,x),y) -> app{2,#}(x,y)
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y) ->
     if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> app{2,#}(rm2(n,x),y)
     minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y) ->
     if_minsort{3,#}(true0(),add2(n,x),y) -> rm{2,#}(n,x)
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
     minsort{2,#}(add2(n,x),y) -> min{1,#}(add2(n,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
     minsort{2,#}(add2(n,x),y) -> eq{2,#}(n,min1(add2(n,x))) ->
     eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
     if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
     if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
     if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
     if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x) ->
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m)
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x)) ->
     if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x)
     rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x)) ->
     if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x)
     rm{2,#}(n,add2(m,x)) -> eq{2,#}(n,m) ->
     eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
     if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
     if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
     if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
     if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x)) ->
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m)
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x))) ->
     if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
     min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x))) ->
     if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
     min{1,#}(add2(n,add2(m,x))) -> le{2,#}(n,m) ->
     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)
     eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y) -> eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
    SCC Processor:
     #sccs: 7
     #rules: 21
     #arcs: 89/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:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
          eq2(00(),00()) -> true0()
          eq2(00(),s1(x)) -> false0()
          eq2(s1(x),00()) -> false0()
          eq2(s1(x),s1(y)) -> eq2(x,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))
          min1(add2(n,nil0())) -> n
          min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
          if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
          if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
          rm2(n,nil0()) -> nil0()
          rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
          if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
          if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
          minsort2(nil0(),nil0()) -> nil0()
          minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
          if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
          if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
          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'(eq1(x6),x7) -> eq2(x6,x7)
          app'(eq0(),x6) -> eq1(x6)
          app'(s0(),x11) -> s1(x11)
          app'(le1(x14),x15) -> le2(x14,x15)
          app'(le0(),x14) -> le1(x14)
          app'(app1(x17),x18) -> app2(x17,x18)
          app'(app0(),x17) -> app1(x17)
          app'(add1(x21),x22) -> add2(x21,x22)
          app'(add0(),x21) -> add1(x21)
          app'(min0(),x24) -> min1(x24)
          app'(if_min1(x26),x27) -> if_min2(x26,x27)
          app'(if_min0(),x26) -> if_min1(x26)
          app'(rm1(x29),x30) -> rm2(x29,x30)
          app'(rm0(),x29) -> rm1(x29)
          app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
          app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
          app'(if_rm0(),x32) -> if_rm1(x32)
          app'(minsort1(x36),x37) -> minsort2(x36,x37)
          app'(minsort0(),x36) -> minsort1(x36)
          app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
          app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
          app'(if_minsort0(),x39) -> if_minsort1(x39)
          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:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
          eq2(00(),00()) -> true0()
          eq2(00(),s1(x)) -> false0()
          eq2(s1(x),00()) -> false0()
          eq2(s1(x),s1(y)) -> eq2(x,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))
          min1(add2(n,nil0())) -> n
          min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
          if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
          if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
          rm2(n,nil0()) -> nil0()
          rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
          if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
          if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
          minsort2(nil0(),nil0()) -> nil0()
          minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
          if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
          if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
          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'(eq1(x6),x7) -> eq2(x6,x7)
          app'(eq0(),x6) -> eq1(x6)
          app'(s0(),x11) -> s1(x11)
          app'(le1(x14),x15) -> le2(x14,x15)
          app'(le0(),x14) -> le1(x14)
          app'(app1(x17),x18) -> app2(x17,x18)
          app'(app0(),x17) -> app1(x17)
          app'(add1(x21),x22) -> add2(x21,x22)
          app'(add0(),x21) -> add1(x21)
          app'(min0(),x24) -> min1(x24)
          app'(if_min1(x26),x27) -> if_min2(x26,x27)
          app'(if_min0(),x26) -> if_min1(x26)
          app'(rm1(x29),x30) -> rm2(x29,x30)
          app'(rm0(),x29) -> rm1(x29)
          app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
          app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
          app'(if_rm0(),x32) -> if_rm1(x32)
          app'(minsort1(x36),x37) -> minsort2(x36,x37)
          app'(minsort0(),x36) -> minsort1(x36)
          app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
          app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
          app'(if_minsort0(),x39) -> if_minsort1(x39)
          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:
      minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
      if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
     TRS:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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:
       minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
       if_minsort{3,#}(true0(),add2(n,x),y) -> minsort{2,#}(app2(rm2(n,x),y),nil0())
       if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
      TRS:
       min1(add2(n,nil0())) -> n
       min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
       if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
       if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
       le2(00(),y) -> true0()
       le2(s1(x),00()) -> false0()
       le2(s1(x),s1(y)) -> le2(x,y)
       eq2(00(),00()) -> true0()
       eq2(00(),s1(x)) -> false0()
       eq2(s1(x),00()) -> false0()
       eq2(s1(x),s1(y)) -> eq2(x,y)
       rm2(n,nil0()) -> nil0()
       rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
       if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
       if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
       app2(nil0(),y) -> y
       app2(add2(n,x),y) -> add2(n,app2(x,y))
      Matrix Interpretation Processor: dim=1
       
       usable rules:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,y)
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        app2(nil0(),y) -> y
        app2(add2(n,x),y) -> add2(n,app2(x,y))
       interpretation:
        [if_minsort{3,#}](x0, x1, x2) = 1/2x0 + 2x1 + 2x2,
        
        [minsort{2,#}](x0, x1) = 2x0 + 2x1 + 1,
        
        [if_rm3](x0, x1, x2) = 1/2x0 + x2,
        
        [rm2](x0, x1) = x1 + 1,
        
        [if_min2](x0, x1) = 2x1,
        
        [min1](x0) = 0,
        
        [add2](x0, x1) = x1 + 2,
        
        [nil0] = 1/2,
        
        [app2](x0, x1) = x0 + x1,
        
        [le2](x0, x1) = x1,
        
        [false0] = 2,
        
        [s1](x0) = 1/2x0,
        
        [true0] = 2,
        
        [00] = 0,
        
        [eq2](x0, x1) = 2
       orientation:
        minsort{2,#}(add2(n,x),y) = 2x + 2y + 5 >= 2x + 2y + 5 = if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
        
        if_minsort{3,#}(true0(),add2(n,x),y) = 2x + 2y + 5 >= 2x + 2y + 4 = minsort{2,#}(app2(rm2(n,x),y),nil0())
        
        if_minsort{3,#}(false0(),add2(n,x),y) = 2x + 2y + 5 >= 2x + 2y + 5 = minsort{2,#}(x,add2(n,y))
        
        min1(add2(n,nil0())) = 0 >= n = n
        
        min1(add2(n,add2(m,x))) = 0 >= 2x + 8 = if_min2(le2(n,m),add2(n,add2(m,x)))
        
        if_min2(true0(),add2(n,add2(m,x))) = 2x + 8 >= 0 = min1(add2(n,x))
        
        if_min2(false0(),add2(n,add2(m,x))) = 2x + 8 >= 0 = min1(add2(m,x))
        
        le2(00(),y) = y >= 2 = true0()
        
        le2(s1(x),00()) = 0 >= 2 = false0()
        
        le2(s1(x),s1(y)) = 1/2y >= y = le2(x,y)
        
        eq2(00(),00()) = 2 >= 2 = true0()
        
        eq2(00(),s1(x)) = 2 >= 2 = false0()
        
        eq2(s1(x),00()) = 2 >= 2 = false0()
        
        eq2(s1(x),s1(y)) = 2 >= 2 = eq2(x,y)
        
        rm2(n,nil0()) = 3/2 >= 1/2 = nil0()
        
        rm2(n,add2(m,x)) = x + 3 >= x + 3 = if_rm3(eq2(n,m),n,add2(m,x))
        
        if_rm3(true0(),n,add2(m,x)) = x + 3 >= x + 1 = rm2(n,x)
        
        if_rm3(false0(),n,add2(m,x)) = x + 3 >= x + 3 = add2(m,rm2(n,x))
        
        app2(nil0(),y) = y + 1/2 >= y = y
        
        app2(add2(n,x),y) = x + y + 2 >= x + y + 2 = add2(n,app2(x,y))
       problem:
        DPs:
         minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
         if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
        TRS:
         min1(add2(n,nil0())) -> n
         min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
         if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
         if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
         le2(00(),y) -> true0()
         le2(s1(x),00()) -> false0()
         le2(s1(x),s1(y)) -> le2(x,y)
         eq2(00(),00()) -> true0()
         eq2(00(),s1(x)) -> false0()
         eq2(s1(x),00()) -> false0()
         eq2(s1(x),s1(y)) -> eq2(x,y)
         rm2(n,nil0()) -> nil0()
         rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
         if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
         if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
         app2(nil0(),y) -> y
         app2(add2(n,x),y) -> add2(n,app2(x,y))
       Restore Modifier:
        DPs:
         minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y)
         if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y))
        TRS:
         eq2(00(),00()) -> true0()
         eq2(00(),s1(x)) -> false0()
         eq2(s1(x),00()) -> false0()
         eq2(s1(x),s1(y)) -> eq2(x,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))
         min1(add2(n,nil0())) -> n
         min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
         if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
         if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
         rm2(n,nil0()) -> nil0()
         rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
         if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
         if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
         minsort2(nil0(),nil0()) -> nil0()
         minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
         if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
         if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
         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'(eq1(x6),x7) -> eq2(x6,x7)
         app'(eq0(),x6) -> eq1(x6)
         app'(s0(),x11) -> s1(x11)
         app'(le1(x14),x15) -> le2(x14,x15)
         app'(le0(),x14) -> le1(x14)
         app'(app1(x17),x18) -> app2(x17,x18)
         app'(app0(),x17) -> app1(x17)
         app'(add1(x21),x22) -> add2(x21,x22)
         app'(add0(),x21) -> add1(x21)
         app'(min0(),x24) -> min1(x24)
         app'(if_min1(x26),x27) -> if_min2(x26,x27)
         app'(if_min0(),x26) -> if_min1(x26)
         app'(rm1(x29),x30) -> rm2(x29,x30)
         app'(rm0(),x29) -> rm1(x29)
         app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
         app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
         app'(if_rm0(),x32) -> if_rm1(x32)
         app'(minsort1(x36),x37) -> minsort2(x36,x37)
         app'(minsort0(),x36) -> minsort1(x36)
         app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
         app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
         app'(if_minsort0(),x39) -> if_minsort1(x39)
         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)
        Size-Change Termination Processor:
         DPs:
          
         TRS:
          eq2(00(),00()) -> true0()
          eq2(00(),s1(x)) -> false0()
          eq2(s1(x),00()) -> false0()
          eq2(s1(x),s1(y)) -> eq2(x,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))
          min1(add2(n,nil0())) -> n
          min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
          if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
          if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
          rm2(n,nil0()) -> nil0()
          rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
          if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
          if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
          minsort2(nil0(),nil0()) -> nil0()
          minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
          if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
          if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
          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'(eq1(x6),x7) -> eq2(x6,x7)
          app'(eq0(),x6) -> eq1(x6)
          app'(s0(),x11) -> s1(x11)
          app'(le1(x14),x15) -> le2(x14,x15)
          app'(le0(),x14) -> le1(x14)
          app'(app1(x17),x18) -> app2(x17,x18)
          app'(app0(),x17) -> app1(x17)
          app'(add1(x21),x22) -> add2(x21,x22)
          app'(add0(),x21) -> add1(x21)
          app'(min0(),x24) -> min1(x24)
          app'(if_min1(x26),x27) -> if_min2(x26,x27)
          app'(if_min0(),x26) -> if_min1(x26)
          app'(rm1(x29),x30) -> rm2(x29,x30)
          app'(rm0(),x29) -> rm1(x29)
          app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
          app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
          app'(if_rm0(),x32) -> if_rm1(x32)
          app'(minsort1(x36),x37) -> minsort2(x36,x37)
          app'(minsort0(),x36) -> minsort1(x36)
          app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
          app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
          app'(if_minsort0(),x39) -> if_minsort1(x39)
          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)
         The DP: minsort{2,#}(add2(n,x),y) -> if_minsort{3,#}(eq2(n,min1(add2(n,x))),add2(n,x),y) has the edges:
           0 >=  1
           1 >=  2
         The DP: if_minsort{3,#}(false0(),add2(n,x),y) -> minsort{2,#}(x,add2(n,y)) has the edges:
           1 >   0
         Qed
     
     DPs:
      rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
      if_rm{3,#}(true0(),n,add2(m,x)) -> rm{2,#}(n,x)
      if_rm{3,#}(false0(),n,add2(m,x)) -> rm{2,#}(n,x)
     TRS:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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(rm{2,#}) = 1
       pi(if_rm{3,#}) = 2
      problem:
       DPs:
        rm{2,#}(n,add2(m,x)) -> if_rm{3,#}(eq2(n,m),n,add2(m,x))
       TRS:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
      min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
      if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
      if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
     TRS:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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:
       min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
       if_min{2,#}(true0(),add2(n,add2(m,x))) -> min{1,#}(add2(n,x))
       if_min{2,#}(false0(),add2(n,add2(m,x))) -> min{1,#}(add2(m,x))
      TRS:
       le2(00(),y) -> true0()
       le2(s1(x),00()) -> false0()
       le2(s1(x),s1(y)) -> le2(x,y)
      Arctic Interpretation Processor:
       dimension: 1
       usable rules:
        le2(00(),y) -> true0()
        le2(s1(x),00()) -> false0()
        le2(s1(x),s1(y)) -> le2(x,y)
       interpretation:
        [if_min{2,#}](x0, x1) = x0 + x1 + 0,
        
        [min{1,#}](x0) = x0 + 0,
        
        [add2](x0, x1) = 1x1 + 4,
        
        [le2](x0, x1) = 0,
        
        [false0] = 0,
        
        [s1](x0) = 2x0 + 0,
        
        [true0] = 0,
        
        [00] = 3
       orientation:
        min{1,#}(add2(n,add2(m,x))) = 2x + 5 >= 2x + 5 = if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
        
        if_min{2,#}(true0(),add2(n,add2(m,x))) = 2x + 5 >= 1x + 4 = min{1,#}(add2(n,x))
        
        if_min{2,#}(false0(),add2(n,add2(m,x))) = 2x + 5 >= 1x + 4 = min{1,#}(add2(m,x))
        
        le2(00(),y) = 0 >= 0 = true0()
        
        le2(s1(x),00()) = 0 >= 0 = false0()
        
        le2(s1(x),s1(y)) = 0 >= 0 = le2(x,y)
       problem:
        DPs:
         min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
        TRS:
         le2(00(),y) -> true0()
         le2(s1(x),00()) -> false0()
         le2(s1(x),s1(y)) -> le2(x,y)
       Restore Modifier:
        DPs:
         min{1,#}(add2(n,add2(m,x))) -> if_min{2,#}(le2(n,m),add2(n,add2(m,x)))
        TRS:
         eq2(00(),00()) -> true0()
         eq2(00(),s1(x)) -> false0()
         eq2(s1(x),00()) -> false0()
         eq2(s1(x),s1(y)) -> eq2(x,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))
         min1(add2(n,nil0())) -> n
         min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
         if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
         if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
         rm2(n,nil0()) -> nil0()
         rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
         if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
         if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
         minsort2(nil0(),nil0()) -> nil0()
         minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
         if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
         if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
         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'(eq1(x6),x7) -> eq2(x6,x7)
         app'(eq0(),x6) -> eq1(x6)
         app'(s0(),x11) -> s1(x11)
         app'(le1(x14),x15) -> le2(x14,x15)
         app'(le0(),x14) -> le1(x14)
         app'(app1(x17),x18) -> app2(x17,x18)
         app'(app0(),x17) -> app1(x17)
         app'(add1(x21),x22) -> add2(x21,x22)
         app'(add0(),x21) -> add1(x21)
         app'(min0(),x24) -> min1(x24)
         app'(if_min1(x26),x27) -> if_min2(x26,x27)
         app'(if_min0(),x26) -> if_min1(x26)
         app'(rm1(x29),x30) -> rm2(x29,x30)
         app'(rm0(),x29) -> rm1(x29)
         app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
         app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
         app'(if_rm0(),x32) -> if_rm1(x32)
         app'(minsort1(x36),x37) -> minsort2(x36,x37)
         app'(minsort0(),x36) -> minsort1(x36)
         app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
         app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
         app'(if_minsort0(),x39) -> if_minsort1(x39)
         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:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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:
      eq{2,#}(s1(x),s1(y)) -> eq{2,#}(x,y)
     TRS:
      eq2(00(),00()) -> true0()
      eq2(00(),s1(x)) -> false0()
      eq2(s1(x),00()) -> false0()
      eq2(s1(x),s1(y)) -> eq2(x,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))
      min1(add2(n,nil0())) -> n
      min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
      if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
      if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
      rm2(n,nil0()) -> nil0()
      rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
      if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
      if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
      minsort2(nil0(),nil0()) -> nil0()
      minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
      if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
      if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
      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'(eq1(x6),x7) -> eq2(x6,x7)
      app'(eq0(),x6) -> eq1(x6)
      app'(s0(),x11) -> s1(x11)
      app'(le1(x14),x15) -> le2(x14,x15)
      app'(le0(),x14) -> le1(x14)
      app'(app1(x17),x18) -> app2(x17,x18)
      app'(app0(),x17) -> app1(x17)
      app'(add1(x21),x22) -> add2(x21,x22)
      app'(add0(),x21) -> add1(x21)
      app'(min0(),x24) -> min1(x24)
      app'(if_min1(x26),x27) -> if_min2(x26,x27)
      app'(if_min0(),x26) -> if_min1(x26)
      app'(rm1(x29),x30) -> rm2(x29,x30)
      app'(rm0(),x29) -> rm1(x29)
      app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
      app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
      app'(if_rm0(),x32) -> if_rm1(x32)
      app'(minsort1(x36),x37) -> minsort2(x36,x37)
      app'(minsort0(),x36) -> minsort1(x36)
      app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
      app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
      app'(if_minsort0(),x39) -> if_minsort1(x39)
      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(eq{2,#}) = 0
      problem:
       DPs:
        
       TRS:
        eq2(00(),00()) -> true0()
        eq2(00(),s1(x)) -> false0()
        eq2(s1(x),00()) -> false0()
        eq2(s1(x),s1(y)) -> eq2(x,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))
        min1(add2(n,nil0())) -> n
        min1(add2(n,add2(m,x))) -> if_min2(le2(n,m),add2(n,add2(m,x)))
        if_min2(true0(),add2(n,add2(m,x))) -> min1(add2(n,x))
        if_min2(false0(),add2(n,add2(m,x))) -> min1(add2(m,x))
        rm2(n,nil0()) -> nil0()
        rm2(n,add2(m,x)) -> if_rm3(eq2(n,m),n,add2(m,x))
        if_rm3(true0(),n,add2(m,x)) -> rm2(n,x)
        if_rm3(false0(),n,add2(m,x)) -> add2(m,rm2(n,x))
        minsort2(nil0(),nil0()) -> nil0()
        minsort2(add2(n,x),y) -> if_minsort3(eq2(n,min1(add2(n,x))),add2(n,x),y)
        if_minsort3(true0(),add2(n,x),y) -> add2(n,minsort2(app2(rm2(n,x),y),nil0()))
        if_minsort3(false0(),add2(n,x),y) -> minsort2(x,add2(n,y))
        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'(eq1(x6),x7) -> eq2(x6,x7)
        app'(eq0(),x6) -> eq1(x6)
        app'(s0(),x11) -> s1(x11)
        app'(le1(x14),x15) -> le2(x14,x15)
        app'(le0(),x14) -> le1(x14)
        app'(app1(x17),x18) -> app2(x17,x18)
        app'(app0(),x17) -> app1(x17)
        app'(add1(x21),x22) -> add2(x21,x22)
        app'(add0(),x21) -> add1(x21)
        app'(min0(),x24) -> min1(x24)
        app'(if_min1(x26),x27) -> if_min2(x26,x27)
        app'(if_min0(),x26) -> if_min1(x26)
        app'(rm1(x29),x30) -> rm2(x29,x30)
        app'(rm0(),x29) -> rm1(x29)
        app'(if_rm2(x32,x33),x34) -> if_rm3(x32,x33,x34)
        app'(if_rm1(x32),x33) -> if_rm2(x32,x33)
        app'(if_rm0(),x32) -> if_rm1(x32)
        app'(minsort1(x36),x37) -> minsort2(x36,x37)
        app'(minsort0(),x36) -> minsort1(x36)
        app'(if_minsort2(x39,x40),x41) -> if_minsort3(x39,x40,x41)
        app'(if_minsort1(x39),x40) -> if_minsort2(x39,x40)
        app'(if_minsort0(),x39) -> if_minsort1(x39)
        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