/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(D(),t()) -> 1()
 app(D(),constant()) -> 0()
 app(D(),app(app(+(),x),y)) -> app(app(+(),app(D(),x)),app(D(),y))
 app(D(),app(app(*(),x),y)) -> app(app(+(),app(app(*(),y),app(D(),x))),app(app(*(),x),app(D(),y)))
 app(D(),app(app(-(),x),y)) -> app(app(-(),app(D(),x)),app(D(),y))
 app(app(map(),f),nil()) -> nil()
 app(app(map(),f),app(app(cons(),x),xs)) -> app(app(cons(),app(f,x)),app(app(map(),f),xs))
 app(app(filter(),f),nil()) -> nil()
 app(app(filter(),f),app(app(cons(),x),xs)) -> app(app(app(app(filter2(),app(f,x)),f),x),xs)
 app(app(app(app(filter2(),true()),f),x),xs) -> app(app(cons(),x),app(app(filter(),f),xs))
 app(app(app(app(filter2(),false()),f),x),xs) -> app(app(filter(),f),xs)

Proof:
 Extended Uncurrying Processor:
  application symbol: app
  symbol table:
   false ==> false0/0
   true ==> true0/0
   filter2 ==> filter20/0 filter21/1 filter22/2 filter23/3 filter24/4
   filter ==> filter0/0 filter1/1 filter2/2
   cons ==> cons0/0 cons1/1 cons2/2
   nil ==> nil0/0
   map ==> map0/0 map1/1 map2/2
   - ==> -0/0 -1/1 -2/2
   * ==> *0/0 *1/1 *2/2
   + ==> +0/0 +1/1 +2/2
   0 ==> 00/0
   constant ==> constant0/0
   1 ==> 10/0
   t ==> t0/0
   D ==> D0/0 D1/1
   
  uncurry-rules:
   app(D0(),x4) -> D1(x4)
   app(+1(x10),x11) -> +2(x10,x11)
   app(+0(),x10) -> +1(x10)
   app(*1(x13),x14) -> *2(x13,x14)
   app(*0(),x13) -> *1(x13)
   app(-1(x16),x17) -> -2(x16,x17)
   app(-0(),x16) -> -1(x16)
   app(map1(x19),x20) -> map2(x19,x20)
   app(map0(),x19) -> map1(x19)
   app(cons1(x23),x24) -> cons2(x23,x24)
   app(cons0(),x23) -> cons1(x23)
   app(filter1(x26),x27) -> filter2(x26,x27)
   app(filter0(),x26) -> filter1(x26)
   app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
   app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
   app(filter21(x29),x30) -> filter22(x29,x30)
   app(filter20(),x29) -> filter21(x29)
  eta-rules:
   
  problem:
   D1(t0()) -> 10()
   D1(constant0()) -> 00()
   D1(+2(x,y)) -> +2(D1(x),D1(y))
   D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
   D1(-2(x,y)) -> -2(D1(x),D1(y))
   map2(f,nil0()) -> nil0()
   map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
   filter2(f,nil0()) -> nil0()
   filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
   filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
   filter24(false0(),f,x,xs) -> filter2(f,xs)
   app(D0(),x4) -> D1(x4)
   app(+1(x10),x11) -> +2(x10,x11)
   app(+0(),x10) -> +1(x10)
   app(*1(x13),x14) -> *2(x13,x14)
   app(*0(),x13) -> *1(x13)
   app(-1(x16),x17) -> -2(x16,x17)
   app(-0(),x16) -> -1(x16)
   app(map1(x19),x20) -> map2(x19,x20)
   app(map0(),x19) -> map1(x19)
   app(cons1(x23),x24) -> cons2(x23,x24)
   app(cons0(),x23) -> cons1(x23)
   app(filter1(x26),x27) -> filter2(x26,x27)
   app(filter0(),x26) -> filter1(x26)
   app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
   app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
   app(filter21(x29),x30) -> filter22(x29,x30)
   app(filter20(),x29) -> filter21(x29)
  DP Processor:
   DPs:
    D{1,#}(+2(x,y)) -> D{1,#}(y)
    D{1,#}(+2(x,y)) -> D{1,#}(x)
    D{1,#}(*2(x,y)) -> D{1,#}(y)
    D{1,#}(*2(x,y)) -> D{1,#}(x)
    D{1,#}(-2(x,y)) -> D{1,#}(y)
    D{1,#}(-2(x,y)) -> D{1,#}(x)
    map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
    map{2,#}(f,cons2(x,xs)) -> app#(f,x)
    filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
    filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
    filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
    filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
    app#(D0(),x4) -> D{1,#}(x4)
    app#(map1(x19),x20) -> map{2,#}(x19,x20)
    app#(filter1(x26),x27) -> filter{2,#}(x26,x27)
    app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32)
   TRS:
    D1(t0()) -> 10()
    D1(constant0()) -> 00()
    D1(+2(x,y)) -> +2(D1(x),D1(y))
    D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
    D1(-2(x,y)) -> -2(D1(x),D1(y))
    map2(f,nil0()) -> nil0()
    map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
    filter2(f,nil0()) -> nil0()
    filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
    filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
    filter24(false0(),f,x,xs) -> filter2(f,xs)
    app(D0(),x4) -> D1(x4)
    app(+1(x10),x11) -> +2(x10,x11)
    app(+0(),x10) -> +1(x10)
    app(*1(x13),x14) -> *2(x13,x14)
    app(*0(),x13) -> *1(x13)
    app(-1(x16),x17) -> -2(x16,x17)
    app(-0(),x16) -> -1(x16)
    app(map1(x19),x20) -> map2(x19,x20)
    app(map0(),x19) -> map1(x19)
    app(cons1(x23),x24) -> cons2(x23,x24)
    app(cons0(),x23) -> cons1(x23)
    app(filter1(x26),x27) -> filter2(x26,x27)
    app(filter0(),x26) -> filter1(x26)
    app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
    app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
    app(filter21(x29),x30) -> filter22(x29,x30)
    app(filter20(),x29) -> filter21(x29)
   TDG Processor:
    DPs:
     D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(x)
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     map{2,#}(f,cons2(x,xs)) -> app#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     app#(D0(),x4) -> D{1,#}(x4)
     app#(map1(x19),x20) -> map{2,#}(x19,x20)
     app#(filter1(x26),x27) -> filter{2,#}(x26,x27)
     app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32)
    TRS:
     D1(t0()) -> 10()
     D1(constant0()) -> 00()
     D1(+2(x,y)) -> +2(D1(x),D1(y))
     D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
     D1(-2(x,y)) -> -2(D1(x),D1(y))
     map2(f,nil0()) -> nil0()
     map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
     filter2(f,nil0()) -> nil0()
     filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
     filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
     filter24(false0(),f,x,xs) -> filter2(f,xs)
     app(D0(),x4) -> D1(x4)
     app(+1(x10),x11) -> +2(x10,x11)
     app(+0(),x10) -> +1(x10)
     app(*1(x13),x14) -> *2(x13,x14)
     app(*0(),x13) -> *1(x13)
     app(-1(x16),x17) -> -2(x16,x17)
     app(-0(),x16) -> -1(x16)
     app(map1(x19),x20) -> map2(x19,x20)
     app(map0(),x19) -> map1(x19)
     app(cons1(x23),x24) -> cons2(x23,x24)
     app(cons0(),x23) -> cons1(x23)
     app(filter1(x26),x27) -> filter2(x26,x27)
     app(filter0(),x26) -> filter1(x26)
     app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
     app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
     app(filter21(x29),x30) -> filter22(x29,x30)
     app(filter20(),x29) -> filter21(x29)
    graph:
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs) ->
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32)
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(filter1(x26),x27) -> filter{2,#}(x26,x27)
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(map1(x19),x20) -> map{2,#}(x19,x20)
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(D0(),x4) -> D{1,#}(x4)
     app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32) ->
     filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
     app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32) ->
     filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
     app#(filter1(x26),x27) -> filter{2,#}(x26,x27) ->
     filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
     app#(filter1(x26),x27) -> filter{2,#}(x26,x27) ->
     filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
     app#(map1(x19),x20) -> map{2,#}(x19,x20) ->
     map{2,#}(f,cons2(x,xs)) -> app#(f,x)
     app#(map1(x19),x20) -> map{2,#}(x19,x20) ->
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     app#(D0(),x4) -> D{1,#}(x4) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     app#(D0(),x4) -> D{1,#}(x4) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     app#(D0(),x4) -> D{1,#}(x4) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     app#(D0(),x4) -> D{1,#}(x4) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     app#(D0(),x4) -> D{1,#}(x4) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     app#(D0(),x4) -> D{1,#}(x4) ->
     D{1,#}(+2(x,y)) -> D{1,#}(y)
     map{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32)
     map{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(filter1(x26),x27) -> filter{2,#}(x26,x27)
     map{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(map1(x19),x20) -> map{2,#}(x19,x20)
     map{2,#}(f,cons2(x,xs)) -> app#(f,x) ->
     app#(D0(),x4) -> D{1,#}(x4)
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,cons2(x,xs)) -> app#(f,x)
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs) ->
     map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(-2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(*2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(y) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(-2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(*2(x,y)) -> D{1,#}(y)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(x)
     D{1,#}(+2(x,y)) -> D{1,#}(x) -> D{1,#}(+2(x,y)) -> D{1,#}(y)
    SCC Processor:
     #sccs: 2
     #rules: 15
     #arcs: 64/256
     DPs:
      filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
      filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
      app#(map1(x19),x20) -> map{2,#}(x19,x20)
      map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
      map{2,#}(f,cons2(x,xs)) -> app#(f,x)
      app#(filter1(x26),x27) -> filter{2,#}(x26,x27)
      filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
      filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
      app#(filter23(x29,x30,x31),x32) -> filter2{4,#}(x29,x30,x31,x32)
     TRS:
      D1(t0()) -> 10()
      D1(constant0()) -> 00()
      D1(+2(x,y)) -> +2(D1(x),D1(y))
      D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
      D1(-2(x,y)) -> -2(D1(x),D1(y))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app(D0(),x4) -> D1(x4)
      app(+1(x10),x11) -> +2(x10,x11)
      app(+0(),x10) -> +1(x10)
      app(*1(x13),x14) -> *2(x13,x14)
      app(*0(),x13) -> *1(x13)
      app(-1(x16),x17) -> -2(x16,x17)
      app(-0(),x16) -> -1(x16)
      app(map1(x19),x20) -> map2(x19,x20)
      app(map0(),x19) -> map1(x19)
      app(cons1(x23),x24) -> cons2(x23,x24)
      app(cons0(),x23) -> cons1(x23)
      app(filter1(x26),x27) -> filter2(x26,x27)
      app(filter0(),x26) -> filter1(x26)
      app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
      app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
      app(filter21(x29),x30) -> filter22(x29,x30)
      app(filter20(),x29) -> filter21(x29)
     Subterm Criterion Processor:
      simple projection:
       pi(map{2,#}) = 0
       pi(app#) = 0
       pi(filter{2,#}) = 0
       pi(filter2{4,#}) = 1
      problem:
       DPs:
        filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
        filter{2,#}(f,cons2(x,xs)) -> app#(f,x)
        map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
        map{2,#}(f,cons2(x,xs)) -> app#(f,x)
        filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
        filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
       TRS:
        D1(t0()) -> 10()
        D1(constant0()) -> 00()
        D1(+2(x,y)) -> +2(D1(x),D1(y))
        D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
        D1(-2(x,y)) -> -2(D1(x),D1(y))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app(D0(),x4) -> D1(x4)
        app(+1(x10),x11) -> +2(x10,x11)
        app(+0(),x10) -> +1(x10)
        app(*1(x13),x14) -> *2(x13,x14)
        app(*0(),x13) -> *1(x13)
        app(-1(x16),x17) -> -2(x16,x17)
        app(-0(),x16) -> -1(x16)
        app(map1(x19),x20) -> map2(x19,x20)
        app(map0(),x19) -> map1(x19)
        app(cons1(x23),x24) -> cons2(x23,x24)
        app(cons0(),x23) -> cons1(x23)
        app(filter1(x26),x27) -> filter2(x26,x27)
        app(filter0(),x26) -> filter1(x26)
        app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
        app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
        app(filter21(x29),x30) -> filter22(x29,x30)
        app(filter20(),x29) -> filter21(x29)
      SCC Processor:
       #sccs: 2
       #rules: 4
       #arcs: 20/36
       DPs:
        map{2,#}(f,cons2(x,xs)) -> map{2,#}(f,xs)
       TRS:
        D1(t0()) -> 10()
        D1(constant0()) -> 00()
        D1(+2(x,y)) -> +2(D1(x),D1(y))
        D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
        D1(-2(x,y)) -> -2(D1(x),D1(y))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app(D0(),x4) -> D1(x4)
        app(+1(x10),x11) -> +2(x10,x11)
        app(+0(),x10) -> +1(x10)
        app(*1(x13),x14) -> *2(x13,x14)
        app(*0(),x13) -> *1(x13)
        app(-1(x16),x17) -> -2(x16,x17)
        app(-0(),x16) -> -1(x16)
        app(map1(x19),x20) -> map2(x19,x20)
        app(map0(),x19) -> map1(x19)
        app(cons1(x23),x24) -> cons2(x23,x24)
        app(cons0(),x23) -> cons1(x23)
        app(filter1(x26),x27) -> filter2(x26,x27)
        app(filter0(),x26) -> filter1(x26)
        app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
        app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
        app(filter21(x29),x30) -> filter22(x29,x30)
        app(filter20(),x29) -> filter21(x29)
       Subterm Criterion Processor:
        simple projection:
         pi(map{2,#}) = 1
        problem:
         DPs:
          
         TRS:
          D1(t0()) -> 10()
          D1(constant0()) -> 00()
          D1(+2(x,y)) -> +2(D1(x),D1(y))
          D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
          D1(-2(x,y)) -> -2(D1(x),D1(y))
          map2(f,nil0()) -> nil0()
          map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app(D0(),x4) -> D1(x4)
          app(+1(x10),x11) -> +2(x10,x11)
          app(+0(),x10) -> +1(x10)
          app(*1(x13),x14) -> *2(x13,x14)
          app(*0(),x13) -> *1(x13)
          app(-1(x16),x17) -> -2(x16,x17)
          app(-0(),x16) -> -1(x16)
          app(map1(x19),x20) -> map2(x19,x20)
          app(map0(),x19) -> map1(x19)
          app(cons1(x23),x24) -> cons2(x23,x24)
          app(cons0(),x23) -> cons1(x23)
          app(filter1(x26),x27) -> filter2(x26,x27)
          app(filter0(),x26) -> filter1(x26)
          app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
          app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
          app(filter21(x29),x30) -> filter22(x29,x30)
          app(filter20(),x29) -> filter21(x29)
        Qed
       
       DPs:
        filter2{4,#}(false0(),f,x,xs) -> filter{2,#}(f,xs)
        filter{2,#}(f,cons2(x,xs)) -> filter2{4,#}(app(f,x),f,x,xs)
        filter2{4,#}(true0(),f,x,xs) -> filter{2,#}(f,xs)
       TRS:
        D1(t0()) -> 10()
        D1(constant0()) -> 00()
        D1(+2(x,y)) -> +2(D1(x),D1(y))
        D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
        D1(-2(x,y)) -> -2(D1(x),D1(y))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app(D0(),x4) -> D1(x4)
        app(+1(x10),x11) -> +2(x10,x11)
        app(+0(),x10) -> +1(x10)
        app(*1(x13),x14) -> *2(x13,x14)
        app(*0(),x13) -> *1(x13)
        app(-1(x16),x17) -> -2(x16,x17)
        app(-0(),x16) -> -1(x16)
        app(map1(x19),x20) -> map2(x19,x20)
        app(map0(),x19) -> map1(x19)
        app(cons1(x23),x24) -> cons2(x23,x24)
        app(cons0(),x23) -> cons1(x23)
        app(filter1(x26),x27) -> filter2(x26,x27)
        app(filter0(),x26) -> filter1(x26)
        app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
        app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
        app(filter21(x29),x30) -> filter22(x29,x30)
        app(filter20(),x29) -> filter21(x29)
       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:
          D1(t0()) -> 10()
          D1(constant0()) -> 00()
          D1(+2(x,y)) -> +2(D1(x),D1(y))
          D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
          D1(-2(x,y)) -> -2(D1(x),D1(y))
          map2(f,nil0()) -> nil0()
          map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
          filter2(f,nil0()) -> nil0()
          filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
          filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
          filter24(false0(),f,x,xs) -> filter2(f,xs)
          app(D0(),x4) -> D1(x4)
          app(+1(x10),x11) -> +2(x10,x11)
          app(+0(),x10) -> +1(x10)
          app(*1(x13),x14) -> *2(x13,x14)
          app(*0(),x13) -> *1(x13)
          app(-1(x16),x17) -> -2(x16,x17)
          app(-0(),x16) -> -1(x16)
          app(map1(x19),x20) -> map2(x19,x20)
          app(map0(),x19) -> map1(x19)
          app(cons1(x23),x24) -> cons2(x23,x24)
          app(cons0(),x23) -> cons1(x23)
          app(filter1(x26),x27) -> filter2(x26,x27)
          app(filter0(),x26) -> filter1(x26)
          app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
          app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
          app(filter21(x29),x30) -> filter22(x29,x30)
          app(filter20(),x29) -> filter21(x29)
        SCC Processor:
         #sccs: 0
         #rules: 0
         #arcs: 4/4
         
     
     DPs:
      D{1,#}(+2(x,y)) -> D{1,#}(y)
      D{1,#}(+2(x,y)) -> D{1,#}(x)
      D{1,#}(*2(x,y)) -> D{1,#}(y)
      D{1,#}(*2(x,y)) -> D{1,#}(x)
      D{1,#}(-2(x,y)) -> D{1,#}(y)
      D{1,#}(-2(x,y)) -> D{1,#}(x)
     TRS:
      D1(t0()) -> 10()
      D1(constant0()) -> 00()
      D1(+2(x,y)) -> +2(D1(x),D1(y))
      D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
      D1(-2(x,y)) -> -2(D1(x),D1(y))
      map2(f,nil0()) -> nil0()
      map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
      filter2(f,nil0()) -> nil0()
      filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
      filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
      filter24(false0(),f,x,xs) -> filter2(f,xs)
      app(D0(),x4) -> D1(x4)
      app(+1(x10),x11) -> +2(x10,x11)
      app(+0(),x10) -> +1(x10)
      app(*1(x13),x14) -> *2(x13,x14)
      app(*0(),x13) -> *1(x13)
      app(-1(x16),x17) -> -2(x16,x17)
      app(-0(),x16) -> -1(x16)
      app(map1(x19),x20) -> map2(x19,x20)
      app(map0(),x19) -> map1(x19)
      app(cons1(x23),x24) -> cons2(x23,x24)
      app(cons0(),x23) -> cons1(x23)
      app(filter1(x26),x27) -> filter2(x26,x27)
      app(filter0(),x26) -> filter1(x26)
      app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
      app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
      app(filter21(x29),x30) -> filter22(x29,x30)
      app(filter20(),x29) -> filter21(x29)
     Subterm Criterion Processor:
      simple projection:
       pi(D{1,#}) = 0
      problem:
       DPs:
        
       TRS:
        D1(t0()) -> 10()
        D1(constant0()) -> 00()
        D1(+2(x,y)) -> +2(D1(x),D1(y))
        D1(*2(x,y)) -> +2(*2(y,D1(x)),*2(x,D1(y)))
        D1(-2(x,y)) -> -2(D1(x),D1(y))
        map2(f,nil0()) -> nil0()
        map2(f,cons2(x,xs)) -> cons2(app(f,x),map2(f,xs))
        filter2(f,nil0()) -> nil0()
        filter2(f,cons2(x,xs)) -> filter24(app(f,x),f,x,xs)
        filter24(true0(),f,x,xs) -> cons2(x,filter2(f,xs))
        filter24(false0(),f,x,xs) -> filter2(f,xs)
        app(D0(),x4) -> D1(x4)
        app(+1(x10),x11) -> +2(x10,x11)
        app(+0(),x10) -> +1(x10)
        app(*1(x13),x14) -> *2(x13,x14)
        app(*0(),x13) -> *1(x13)
        app(-1(x16),x17) -> -2(x16,x17)
        app(-0(),x16) -> -1(x16)
        app(map1(x19),x20) -> map2(x19,x20)
        app(map0(),x19) -> map1(x19)
        app(cons1(x23),x24) -> cons2(x23,x24)
        app(cons0(),x23) -> cons1(x23)
        app(filter1(x26),x27) -> filter2(x26,x27)
        app(filter0(),x26) -> filter1(x26)
        app(filter23(x29,x30,x31),x32) -> filter24(x29,x30,x31,x32)
        app(filter22(x29,x30),x31) -> filter23(x29,x30,x31)
        app(filter21(x29),x30) -> filter22(x29,x30)
        app(filter20(),x29) -> filter21(x29)
      Qed