/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:
 ap(ap(map(),f),xs) -> ap(ap(ap(if(),ap(isEmpty(),xs)),f),xs)
 ap(ap(ap(if(),true()),f),xs) -> nil()
 ap(ap(ap(if(),false()),f),xs) ->
 ap(ap(cons(),ap(f,ap(last(),xs))),ap(ap(map(),f),ap(dropLast(),xs)))
 ap(isEmpty(),nil()) -> true()
 ap(isEmpty(),ap(ap(cons(),x),xs)) -> false()
 ap(last(),ap(ap(cons(),x),nil())) -> x
 ap(last(),ap(ap(cons(),x),ap(ap(cons(),y),ys))) -> ap(last(),ap(ap(cons(),y),ys))
 ap(dropLast(),nil()) -> nil()
 ap(dropLast(),ap(ap(cons(),x),nil())) -> nil()
 ap(dropLast(),ap(ap(cons(),x),ap(ap(cons(),y),ys))) ->
 ap(ap(cons(),x),ap(dropLast(),ap(ap(cons(),y),ys)))

Proof:
 Extended Uncurrying Processor:
  application symbol: ap
  symbol table:
   dropLast ==> dropLast0/0 dropLast1/1
   last ==> last0/0 last1/1
   cons ==> cons0/0 cons1/1 cons2/2
   false ==> false0/0
   nil ==> nil0/0
   true ==> true0/0
   isEmpty ==> isEmpty0/0 isEmpty1/1
   if ==> if0/0 if1/1 if2/2 if3/3
   map ==> map0/0 map1/1 map2/2
   
  uncurry-rules:
   ap(map1(x5),x6) -> map2(x5,x6)
   ap(map0(),x5) -> map1(x5)
   ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
   ap(if1(x8),x9) -> if2(x8,x9)
   ap(if0(),x8) -> if1(x8)
   ap(isEmpty0(),x12) -> isEmpty1(x12)
   ap(cons1(x17),x18) -> cons2(x17,x18)
   ap(cons0(),x17) -> cons1(x17)
   ap(last0(),x20) -> last1(x20)
   ap(dropLast0(),x22) -> dropLast1(x22)
  eta-rules:
   
  problem:
   map2(f,xs) -> if3(isEmpty1(xs),f,xs)
   if3(true0(),f,xs) -> nil0()
   if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
   isEmpty1(nil0()) -> true0()
   isEmpty1(cons2(x,xs)) -> false0()
   last1(cons2(x,nil0())) -> x
   last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
   dropLast1(nil0()) -> nil0()
   dropLast1(cons2(x,nil0())) -> nil0()
   dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
   ap(map1(x5),x6) -> map2(x5,x6)
   ap(map0(),x5) -> map1(x5)
   ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
   ap(if1(x8),x9) -> if2(x8,x9)
   ap(if0(),x8) -> if1(x8)
   ap(isEmpty0(),x12) -> isEmpty1(x12)
   ap(cons1(x17),x18) -> cons2(x17,x18)
   ap(cons0(),x17) -> cons1(x17)
   ap(last0(),x20) -> last1(x20)
   ap(dropLast0(),x22) -> dropLast1(x22)
  DP Processor:
   DPs:
    map{2,#}(f,xs) -> isEmpty{1,#}(xs)
    map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
    if{3,#}(false0(),f,xs) -> dropLast{1,#}(xs)
    if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
    if{3,#}(false0(),f,xs) -> last{1,#}(xs)
    if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
    last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
    dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
    ap#(map1(x5),x6) -> map{2,#}(x5,x6)
    ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
    ap#(isEmpty0(),x12) -> isEmpty{1,#}(x12)
    ap#(last0(),x20) -> last{1,#}(x20)
    ap#(dropLast0(),x22) -> dropLast{1,#}(x22)
   TRS:
    map2(f,xs) -> if3(isEmpty1(xs),f,xs)
    if3(true0(),f,xs) -> nil0()
    if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
    isEmpty1(nil0()) -> true0()
    isEmpty1(cons2(x,xs)) -> false0()
    last1(cons2(x,nil0())) -> x
    last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
    dropLast1(nil0()) -> nil0()
    dropLast1(cons2(x,nil0())) -> nil0()
    dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
    ap(map1(x5),x6) -> map2(x5,x6)
    ap(map0(),x5) -> map1(x5)
    ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
    ap(if1(x8),x9) -> if2(x8,x9)
    ap(if0(),x8) -> if1(x8)
    ap(isEmpty0(),x12) -> isEmpty1(x12)
    ap(cons1(x17),x18) -> cons2(x17,x18)
    ap(cons0(),x17) -> cons1(x17)
    ap(last0(),x20) -> last1(x20)
    ap(dropLast0(),x22) -> dropLast1(x22)
   TDG Processor:
    DPs:
     map{2,#}(f,xs) -> isEmpty{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
     if{3,#}(false0(),f,xs) -> dropLast{1,#}(xs)
     if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
     if{3,#}(false0(),f,xs) -> last{1,#}(xs)
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     ap#(map1(x5),x6) -> map{2,#}(x5,x6)
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
     ap#(isEmpty0(),x12) -> isEmpty{1,#}(x12)
     ap#(last0(),x20) -> last{1,#}(x20)
     ap#(dropLast0(),x22) -> dropLast{1,#}(x22)
    TRS:
     map2(f,xs) -> if3(isEmpty1(xs),f,xs)
     if3(true0(),f,xs) -> nil0()
     if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
     isEmpty1(nil0()) -> true0()
     isEmpty1(cons2(x,xs)) -> false0()
     last1(cons2(x,nil0())) -> x
     last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
     dropLast1(nil0()) -> nil0()
     dropLast1(cons2(x,nil0())) -> nil0()
     dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
     ap(map1(x5),x6) -> map2(x5,x6)
     ap(map0(),x5) -> map1(x5)
     ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
     ap(if1(x8),x9) -> if2(x8,x9)
     ap(if0(),x8) -> if1(x8)
     ap(isEmpty0(),x12) -> isEmpty1(x12)
     ap(cons1(x17),x18) -> cons2(x17,x18)
     ap(cons0(),x17) -> cons1(x17)
     ap(last0(),x20) -> last1(x20)
     ap(dropLast0(),x22) -> dropLast1(x22)
    graph:
     ap#(dropLast0(),x22) -> dropLast{1,#}(x22) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     ap#(last0(),x20) -> last{1,#}(x20) ->
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(false0(),f,xs) -> last{1,#}(xs)
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(false0(),f,xs) -> dropLast{1,#}(xs)
     ap#(map1(x5),x6) -> map{2,#}(x5,x6) ->
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
     ap#(map1(x5),x6) -> map{2,#}(x5,x6) ->
     map{2,#}(f,xs) -> isEmpty{1,#}(xs)
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys)) ->
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys)) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(dropLast0(),x22) -> dropLast{1,#}(x22)
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(last0(),x20) -> last{1,#}(x20)
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(isEmpty0(),x12) -> isEmpty{1,#}(x12)
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(map1(x5),x6) -> map{2,#}(x5,x6)
     if{3,#}(false0(),f,xs) -> last{1,#}(xs) ->
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     if{3,#}(false0(),f,xs) -> dropLast{1,#}(xs) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs)) ->
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
     if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs)) ->
     map{2,#}(f,xs) -> isEmpty{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) ->
     if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) ->
     if{3,#}(false0(),f,xs) -> last{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) ->
     if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) -> if{3,#}(false0(),f,xs) -> dropLast{1,#}(xs)
    SCC Processor:
     #sccs: 3
     #rules: 7
     #arcs: 23/169
     DPs:
      ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
      if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
      map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
      if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
      ap#(map1(x5),x6) -> map{2,#}(x5,x6)
     TRS:
      map2(f,xs) -> if3(isEmpty1(xs),f,xs)
      if3(true0(),f,xs) -> nil0()
      if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
      isEmpty1(nil0()) -> true0()
      isEmpty1(cons2(x,xs)) -> false0()
      last1(cons2(x,nil0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(nil0()) -> nil0()
      dropLast1(cons2(x,nil0())) -> nil0()
      dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
      ap(map1(x5),x6) -> map2(x5,x6)
      ap(map0(),x5) -> map1(x5)
      ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
      ap(if1(x8),x9) -> if2(x8,x9)
      ap(if0(),x8) -> if1(x8)
      ap(isEmpty0(),x12) -> isEmpty1(x12)
      ap(cons1(x17),x18) -> cons2(x17,x18)
      ap(cons0(),x17) -> cons1(x17)
      ap(last0(),x20) -> last1(x20)
      ap(dropLast0(),x22) -> dropLast1(x22)
     Subterm Criterion Processor:
      simple projection:
       pi(map{2,#}) = 0
       pi(if{3,#}) = 1
       pi(ap#) = 0
      problem:
       DPs:
        if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
        map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
        if{3,#}(false0(),f,xs) -> ap#(f,last1(xs))
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> nil0()
        if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
        isEmpty1(nil0()) -> true0()
        isEmpty1(cons2(x,xs)) -> false0()
        last1(cons2(x,nil0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(nil0()) -> nil0()
        dropLast1(cons2(x,nil0())) -> nil0()
        dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
        ap(map1(x5),x6) -> map2(x5,x6)
        ap(map0(),x5) -> map1(x5)
        ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
        ap(if1(x8),x9) -> if2(x8,x9)
        ap(if0(),x8) -> if1(x8)
        ap(isEmpty0(),x12) -> isEmpty1(x12)
        ap(cons1(x17),x18) -> cons2(x17,x18)
        ap(cons0(),x17) -> cons1(x17)
        ap(last0(),x20) -> last1(x20)
        ap(dropLast0(),x22) -> dropLast1(x22)
      SCC Processor:
       #sccs: 1
       #rules: 2
       #arcs: 8/9
       DPs:
        if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
        map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> nil0()
        if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
        isEmpty1(nil0()) -> true0()
        isEmpty1(cons2(x,xs)) -> false0()
        last1(cons2(x,nil0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(nil0()) -> nil0()
        dropLast1(cons2(x,nil0())) -> nil0()
        dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
        ap(map1(x5),x6) -> map2(x5,x6)
        ap(map0(),x5) -> map1(x5)
        ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
        ap(if1(x8),x9) -> if2(x8,x9)
        ap(if0(),x8) -> if1(x8)
        ap(isEmpty0(),x12) -> isEmpty1(x12)
        ap(cons1(x17),x18) -> cons2(x17,x18)
        ap(cons0(),x17) -> cons1(x17)
        ap(last0(),x20) -> last1(x20)
        ap(dropLast0(),x22) -> dropLast1(x22)
       Usable Rule Processor:
        DPs:
         if{3,#}(false0(),f,xs) -> map{2,#}(f,dropLast1(xs))
         map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
        TRS:
         dropLast1(nil0()) -> nil0()
         dropLast1(cons2(x,nil0())) -> nil0()
         dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
         isEmpty1(nil0()) -> true0()
         isEmpty1(cons2(x,xs)) -> false0()
        Arctic Interpretation Processor:
         dimension: 1
         usable rules:
          dropLast1(nil0()) -> nil0()
          dropLast1(cons2(x,nil0())) -> nil0()
          dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
          isEmpty1(nil0()) -> true0()
          isEmpty1(cons2(x,xs)) -> false0()
         interpretation:
          [if{3,#}](x0, x1, x2) = -1x0 + -1x2 + 0,
          
          [map{2,#}](x0, x1) = x1 + 0,
          
          [dropLast1](x0) = -3x0 + 0,
          
          [cons2](x0, x1) = 3x1 + 3,
          
          [false0] = 2,
          
          [nil0] = 0,
          
          [true0] = 1,
          
          [isEmpty1](x0) = x0 + 1
         orientation:
          if{3,#}(false0(),f,xs) = -1xs + 1 >= -3xs + 0 = map{2,#}(f,dropLast1(xs))
          
          map{2,#}(f,xs) = xs + 0 >= -1xs + 0 = if{3,#}(isEmpty1(xs),f,xs)
          
          dropLast1(nil0()) = 0 >= 0 = nil0()
          
          dropLast1(cons2(x,nil0())) = 0 >= 0 = nil0()
          
          dropLast1(cons2(x,cons2(y,ys))) = 3ys + 3 >= 3ys + 3 = cons2(x,dropLast1(cons2(y,ys)))
          
          isEmpty1(nil0()) = 1 >= 1 = true0()
          
          isEmpty1(cons2(x,xs)) = 3xs + 3 >= 2 = false0()
         problem:
          DPs:
           map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
          TRS:
           dropLast1(nil0()) -> nil0()
           dropLast1(cons2(x,nil0())) -> nil0()
           dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
           isEmpty1(nil0()) -> true0()
           isEmpty1(cons2(x,xs)) -> false0()
         Restore Modifier:
          DPs:
           map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
          TRS:
           map2(f,xs) -> if3(isEmpty1(xs),f,xs)
           if3(true0(),f,xs) -> nil0()
           if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
           isEmpty1(nil0()) -> true0()
           isEmpty1(cons2(x,xs)) -> false0()
           last1(cons2(x,nil0())) -> x
           last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
           dropLast1(nil0()) -> nil0()
           dropLast1(cons2(x,nil0())) -> nil0()
           dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
           ap(map1(x5),x6) -> map2(x5,x6)
           ap(map0(),x5) -> map1(x5)
           ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
           ap(if1(x8),x9) -> if2(x8,x9)
           ap(if0(),x8) -> if1(x8)
           ap(isEmpty0(),x12) -> isEmpty1(x12)
           ap(cons1(x17),x18) -> cons2(x17,x18)
           ap(cons0(),x17) -> cons1(x17)
           ap(last0(),x20) -> last1(x20)
           ap(dropLast0(),x22) -> dropLast1(x22)
          SCC Processor:
           #sccs: 0
           #rules: 0
           #arcs: 2/1
           
     
     DPs:
      last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     TRS:
      map2(f,xs) -> if3(isEmpty1(xs),f,xs)
      if3(true0(),f,xs) -> nil0()
      if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
      isEmpty1(nil0()) -> true0()
      isEmpty1(cons2(x,xs)) -> false0()
      last1(cons2(x,nil0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(nil0()) -> nil0()
      dropLast1(cons2(x,nil0())) -> nil0()
      dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
      ap(map1(x5),x6) -> map2(x5,x6)
      ap(map0(),x5) -> map1(x5)
      ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
      ap(if1(x8),x9) -> if2(x8,x9)
      ap(if0(),x8) -> if1(x8)
      ap(isEmpty0(),x12) -> isEmpty1(x12)
      ap(cons1(x17),x18) -> cons2(x17,x18)
      ap(cons0(),x17) -> cons1(x17)
      ap(last0(),x20) -> last1(x20)
      ap(dropLast0(),x22) -> dropLast1(x22)
     Subterm Criterion Processor:
      simple projection:
       pi(last{1,#}) = 0
      problem:
       DPs:
        
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> nil0()
        if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
        isEmpty1(nil0()) -> true0()
        isEmpty1(cons2(x,xs)) -> false0()
        last1(cons2(x,nil0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(nil0()) -> nil0()
        dropLast1(cons2(x,nil0())) -> nil0()
        dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
        ap(map1(x5),x6) -> map2(x5,x6)
        ap(map0(),x5) -> map1(x5)
        ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
        ap(if1(x8),x9) -> if2(x8,x9)
        ap(if0(),x8) -> if1(x8)
        ap(isEmpty0(),x12) -> isEmpty1(x12)
        ap(cons1(x17),x18) -> cons2(x17,x18)
        ap(cons0(),x17) -> cons1(x17)
        ap(last0(),x20) -> last1(x20)
        ap(dropLast0(),x22) -> dropLast1(x22)
      Qed
     
     DPs:
      dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     TRS:
      map2(f,xs) -> if3(isEmpty1(xs),f,xs)
      if3(true0(),f,xs) -> nil0()
      if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
      isEmpty1(nil0()) -> true0()
      isEmpty1(cons2(x,xs)) -> false0()
      last1(cons2(x,nil0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(nil0()) -> nil0()
      dropLast1(cons2(x,nil0())) -> nil0()
      dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
      ap(map1(x5),x6) -> map2(x5,x6)
      ap(map0(),x5) -> map1(x5)
      ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
      ap(if1(x8),x9) -> if2(x8,x9)
      ap(if0(),x8) -> if1(x8)
      ap(isEmpty0(),x12) -> isEmpty1(x12)
      ap(cons1(x17),x18) -> cons2(x17,x18)
      ap(cons0(),x17) -> cons1(x17)
      ap(last0(),x20) -> last1(x20)
      ap(dropLast0(),x22) -> dropLast1(x22)
     Subterm Criterion Processor:
      simple projection:
       pi(dropLast{1,#}) = 0
      problem:
       DPs:
        
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> nil0()
        if3(false0(),f,xs) -> cons2(ap(f,last1(xs)),map2(f,dropLast1(xs)))
        isEmpty1(nil0()) -> true0()
        isEmpty1(cons2(x,xs)) -> false0()
        last1(cons2(x,nil0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(nil0()) -> nil0()
        dropLast1(cons2(x,nil0())) -> nil0()
        dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
        ap(map1(x5),x6) -> map2(x5,x6)
        ap(map0(),x5) -> map1(x5)
        ap(if2(x8,x9),x10) -> if3(x8,x9,x10)
        ap(if1(x8),x9) -> if2(x8,x9)
        ap(if0(),x8) -> if1(x8)
        ap(isEmpty0(),x12) -> isEmpty1(x12)
        ap(cons1(x17),x18) -> cons2(x17,x18)
        ap(cons0(),x17) -> cons1(x17)
        ap(last0(),x20) -> last1(x20)
        ap(dropLast0(),x22) -> dropLast1(x22)
      Qed