/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) -> null()
 ap(ap(ap(if(),null()),f),xs) -> ap(ap(cons(),ap(f,ap(last(),xs))),ap(ap(if2(),f),xs))
 ap(ap(if2(),f),xs) -> ap(ap(map(),f),ap(dropLast(),xs))
 ap(isEmpty(),null()) -> true()
 ap(isEmpty(),ap(ap(cons(),x),xs)) -> null()
 ap(last(),ap(ap(cons(),x),null())) -> x
 ap(last(),ap(ap(cons(),x),ap(ap(cons(),y),ys))) -> ap(last(),ap(ap(cons(),y),ys))
 ap(dropLast(),ap(ap(cons(),x),null())) -> null()
 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
   if2 ==> if20/0 if21/1 if22/2
   last ==> last0/0 last1/1
   cons ==> cons0/0 cons1/1 cons2/2
   null ==> null0/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(x16),x17) -> cons2(x16,x17)
   ap(cons0(),x16) -> cons1(x16)
   ap(last0(),x19) -> last1(x19)
   ap(if21(x21),x22) -> if22(x21,x22)
   ap(if20(),x21) -> if21(x21)
   ap(dropLast0(),x24) -> dropLast1(x24)
  eta-rules:
   
  problem:
   map2(f,xs) -> if3(isEmpty1(xs),f,xs)
   if3(true0(),f,xs) -> null0()
   if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
   if22(f,xs) -> map2(f,dropLast1(xs))
   isEmpty1(null0()) -> true0()
   isEmpty1(cons2(x,xs)) -> null0()
   last1(cons2(x,null0())) -> x
   last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
   dropLast1(cons2(x,null0())) -> null0()
   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(x16),x17) -> cons2(x16,x17)
   ap(cons0(),x16) -> cons1(x16)
   ap(last0(),x19) -> last1(x19)
   ap(if21(x21),x22) -> if22(x21,x22)
   ap(if20(),x21) -> if21(x21)
   ap(dropLast0(),x24) -> dropLast1(x24)
  DP Processor:
   DPs:
    map{2,#}(f,xs) -> isEmpty{1,#}(xs)
    map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
    if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
    if{3,#}(null0(),f,xs) -> last{1,#}(xs)
    if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
    if2{2,#}(f,xs) -> dropLast{1,#}(xs)
    if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(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(),x19) -> last{1,#}(x19)
    ap#(if21(x21),x22) -> if2{2,#}(x21,x22)
    ap#(dropLast0(),x24) -> dropLast{1,#}(x24)
   TRS:
    map2(f,xs) -> if3(isEmpty1(xs),f,xs)
    if3(true0(),f,xs) -> null0()
    if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
    if22(f,xs) -> map2(f,dropLast1(xs))
    isEmpty1(null0()) -> true0()
    isEmpty1(cons2(x,xs)) -> null0()
    last1(cons2(x,null0())) -> x
    last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
    dropLast1(cons2(x,null0())) -> null0()
    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(x16),x17) -> cons2(x16,x17)
    ap(cons0(),x16) -> cons1(x16)
    ap(last0(),x19) -> last1(x19)
    ap(if21(x21),x22) -> if22(x21,x22)
    ap(if20(),x21) -> if21(x21)
    ap(dropLast0(),x24) -> dropLast1(x24)
   TDG Processor:
    DPs:
     map{2,#}(f,xs) -> isEmpty{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
     if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
     if{3,#}(null0(),f,xs) -> last{1,#}(xs)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
     if2{2,#}(f,xs) -> dropLast{1,#}(xs)
     if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(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(),x19) -> last{1,#}(x19)
     ap#(if21(x21),x22) -> if2{2,#}(x21,x22)
     ap#(dropLast0(),x24) -> dropLast{1,#}(x24)
    TRS:
     map2(f,xs) -> if3(isEmpty1(xs),f,xs)
     if3(true0(),f,xs) -> null0()
     if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
     if22(f,xs) -> map2(f,dropLast1(xs))
     isEmpty1(null0()) -> true0()
     isEmpty1(cons2(x,xs)) -> null0()
     last1(cons2(x,null0())) -> x
     last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
     dropLast1(cons2(x,null0())) -> null0()
     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(x16),x17) -> cons2(x16,x17)
     ap(cons0(),x16) -> cons1(x16)
     ap(last0(),x19) -> last1(x19)
     ap(if21(x21),x22) -> if22(x21,x22)
     ap(if20(),x21) -> if21(x21)
     ap(dropLast0(),x24) -> dropLast1(x24)
    graph:
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys)) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     ap#(dropLast0(),x24) -> dropLast{1,#}(x24) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     ap#(if21(x21),x22) -> if2{2,#}(x21,x22) ->
     if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
     ap#(if21(x21),x22) -> if2{2,#}(x21,x22) ->
     if2{2,#}(f,xs) -> dropLast{1,#}(xs)
     ap#(last0(),x19) -> last{1,#}(x19) ->
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(null0(),f,xs) -> last{1,#}(xs)
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10) ->
     if{3,#}(null0(),f,xs) -> if2{2,#}(f,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))
     if2{2,#}(f,xs) -> dropLast{1,#}(xs) ->
     dropLast{1,#}(cons2(x,cons2(y,ys))) -> dropLast{1,#}(cons2(y,ys))
     if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs)) ->
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
     if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs)) ->
     map{2,#}(f,xs) -> isEmpty{1,#}(xs)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(dropLast0(),x24) -> dropLast{1,#}(x24)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(if21(x21),x22) -> if2{2,#}(x21,x22)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(last0(),x19) -> last{1,#}(x19)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(isEmpty0(),x12) -> isEmpty{1,#}(x12)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs)) ->
     ap#(map1(x5),x6) -> map{2,#}(x5,x6)
     if{3,#}(null0(),f,xs) -> last{1,#}(xs) ->
     last{1,#}(cons2(x,cons2(y,ys))) -> last{1,#}(cons2(y,ys))
     if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs) ->
     if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
     if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs) ->
     if2{2,#}(f,xs) -> dropLast{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) ->
     if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) ->
     if{3,#}(null0(),f,xs) -> last{1,#}(xs)
     map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs) -> if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
    SCC Processor:
     #sccs: 3
     #rules: 9
     #arcs: 26/225
     DPs:
      ap#(if21(x21),x22) -> if2{2,#}(x21,x22)
      if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
      map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
      if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
      if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
      ap#(map1(x5),x6) -> map{2,#}(x5,x6)
      ap#(if2(x8,x9),x10) -> if{3,#}(x8,x9,x10)
     TRS:
      map2(f,xs) -> if3(isEmpty1(xs),f,xs)
      if3(true0(),f,xs) -> null0()
      if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
      if22(f,xs) -> map2(f,dropLast1(xs))
      isEmpty1(null0()) -> true0()
      isEmpty1(cons2(x,xs)) -> null0()
      last1(cons2(x,null0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(cons2(x,null0())) -> null0()
      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(x16),x17) -> cons2(x16,x17)
      ap(cons0(),x16) -> cons1(x16)
      ap(last0(),x19) -> last1(x19)
      ap(if21(x21),x22) -> if22(x21,x22)
      ap(if20(),x21) -> if21(x21)
      ap(dropLast0(),x24) -> dropLast1(x24)
     Subterm Criterion Processor:
      simple projection:
       pi(map{2,#}) = 0
       pi(if{3,#}) = 1
       pi(if2{2,#}) = 0
       pi(ap#) = 0
      problem:
       DPs:
        if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
        map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
        if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
        if{3,#}(null0(),f,xs) -> ap#(f,last1(xs))
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> null0()
        if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
        if22(f,xs) -> map2(f,dropLast1(xs))
        isEmpty1(null0()) -> true0()
        isEmpty1(cons2(x,xs)) -> null0()
        last1(cons2(x,null0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(cons2(x,null0())) -> null0()
        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(x16),x17) -> cons2(x16,x17)
        ap(cons0(),x16) -> cons1(x16)
        ap(last0(),x19) -> last1(x19)
        ap(if21(x21),x22) -> if22(x21,x22)
        ap(if20(),x21) -> if21(x21)
        ap(dropLast0(),x24) -> dropLast1(x24)
      SCC Processor:
       #sccs: 1
       #rules: 3
       #arcs: 11/16
       DPs:
        if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
        map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
        if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> null0()
        if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
        if22(f,xs) -> map2(f,dropLast1(xs))
        isEmpty1(null0()) -> true0()
        isEmpty1(cons2(x,xs)) -> null0()
        last1(cons2(x,null0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(cons2(x,null0())) -> null0()
        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(x16),x17) -> cons2(x16,x17)
        ap(cons0(),x16) -> cons1(x16)
        ap(last0(),x19) -> last1(x19)
        ap(if21(x21),x22) -> if22(x21,x22)
        ap(if20(),x21) -> if21(x21)
        ap(dropLast0(),x24) -> dropLast1(x24)
       Usable Rule Processor:
        DPs:
         if2{2,#}(f,xs) -> map{2,#}(f,dropLast1(xs))
         map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
         if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
        TRS:
         dropLast1(cons2(x,null0())) -> null0()
         dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
         isEmpty1(null0()) -> true0()
         isEmpty1(cons2(x,xs)) -> null0()
        Arctic Interpretation Processor:
         dimension: 1
         usable rules:
          dropLast1(cons2(x,null0())) -> null0()
          dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
          isEmpty1(null0()) -> true0()
          isEmpty1(cons2(x,xs)) -> null0()
         interpretation:
          [if2{2,#}](x0, x1) = x1 + 1,
          
          [if{3,#}](x0, x1, x2) = -3x0 + x2 + 0,
          
          [map{2,#}](x0, x1) = x1 + 0,
          
          [dropLast1](x0) = -2x0 + 0,
          
          [cons2](x0, x1) = 2x1 + 4,
          
          [null0] = 4,
          
          [true0] = 7,
          
          [isEmpty1](x0) = 3x0
         orientation:
          if2{2,#}(f,xs) = xs + 1 >= -2xs + 0 = map{2,#}(f,dropLast1(xs))
          
          map{2,#}(f,xs) = xs + 0 >= xs + 0 = if{3,#}(isEmpty1(xs),f,xs)
          
          if{3,#}(null0(),f,xs) = xs + 1 >= xs + 1 = if2{2,#}(f,xs)
          
          dropLast1(cons2(x,null0())) = 4 >= 4 = null0()
          
          dropLast1(cons2(x,cons2(y,ys))) = 2ys + 4 >= 2ys + 4 = cons2(x,dropLast1(cons2(y,ys)))
          
          isEmpty1(null0()) = 7 >= 7 = true0()
          
          isEmpty1(cons2(x,xs)) = 5xs + 7 >= 4 = null0()
         problem:
          DPs:
           map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
           if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
          TRS:
           dropLast1(cons2(x,null0())) -> null0()
           dropLast1(cons2(x,cons2(y,ys))) -> cons2(x,dropLast1(cons2(y,ys)))
           isEmpty1(null0()) -> true0()
           isEmpty1(cons2(x,xs)) -> null0()
         Restore Modifier:
          DPs:
           map{2,#}(f,xs) -> if{3,#}(isEmpty1(xs),f,xs)
           if{3,#}(null0(),f,xs) -> if2{2,#}(f,xs)
          TRS:
           map2(f,xs) -> if3(isEmpty1(xs),f,xs)
           if3(true0(),f,xs) -> null0()
           if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
           if22(f,xs) -> map2(f,dropLast1(xs))
           isEmpty1(null0()) -> true0()
           isEmpty1(cons2(x,xs)) -> null0()
           last1(cons2(x,null0())) -> x
           last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
           dropLast1(cons2(x,null0())) -> null0()
           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(x16),x17) -> cons2(x16,x17)
           ap(cons0(),x16) -> cons1(x16)
           ap(last0(),x19) -> last1(x19)
           ap(if21(x21),x22) -> if22(x21,x22)
           ap(if20(),x21) -> if21(x21)
           ap(dropLast0(),x24) -> dropLast1(x24)
          SCC Processor:
           #sccs: 0
           #rules: 0
           #arcs: 3/4
           
     
     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) -> null0()
      if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
      if22(f,xs) -> map2(f,dropLast1(xs))
      isEmpty1(null0()) -> true0()
      isEmpty1(cons2(x,xs)) -> null0()
      last1(cons2(x,null0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(cons2(x,null0())) -> null0()
      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(x16),x17) -> cons2(x16,x17)
      ap(cons0(),x16) -> cons1(x16)
      ap(last0(),x19) -> last1(x19)
      ap(if21(x21),x22) -> if22(x21,x22)
      ap(if20(),x21) -> if21(x21)
      ap(dropLast0(),x24) -> dropLast1(x24)
     Subterm Criterion Processor:
      simple projection:
       pi(last{1,#}) = 0
      problem:
       DPs:
        
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> null0()
        if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
        if22(f,xs) -> map2(f,dropLast1(xs))
        isEmpty1(null0()) -> true0()
        isEmpty1(cons2(x,xs)) -> null0()
        last1(cons2(x,null0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(cons2(x,null0())) -> null0()
        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(x16),x17) -> cons2(x16,x17)
        ap(cons0(),x16) -> cons1(x16)
        ap(last0(),x19) -> last1(x19)
        ap(if21(x21),x22) -> if22(x21,x22)
        ap(if20(),x21) -> if21(x21)
        ap(dropLast0(),x24) -> dropLast1(x24)
      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) -> null0()
      if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
      if22(f,xs) -> map2(f,dropLast1(xs))
      isEmpty1(null0()) -> true0()
      isEmpty1(cons2(x,xs)) -> null0()
      last1(cons2(x,null0())) -> x
      last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
      dropLast1(cons2(x,null0())) -> null0()
      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(x16),x17) -> cons2(x16,x17)
      ap(cons0(),x16) -> cons1(x16)
      ap(last0(),x19) -> last1(x19)
      ap(if21(x21),x22) -> if22(x21,x22)
      ap(if20(),x21) -> if21(x21)
      ap(dropLast0(),x24) -> dropLast1(x24)
     Subterm Criterion Processor:
      simple projection:
       pi(dropLast{1,#}) = 0
      problem:
       DPs:
        
       TRS:
        map2(f,xs) -> if3(isEmpty1(xs),f,xs)
        if3(true0(),f,xs) -> null0()
        if3(null0(),f,xs) -> cons2(ap(f,last1(xs)),if22(f,xs))
        if22(f,xs) -> map2(f,dropLast1(xs))
        isEmpty1(null0()) -> true0()
        isEmpty1(cons2(x,xs)) -> null0()
        last1(cons2(x,null0())) -> x
        last1(cons2(x,cons2(y,ys))) -> last1(cons2(y,ys))
        dropLast1(cons2(x,null0())) -> null0()
        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(x16),x17) -> cons2(x16,x17)
        ap(cons0(),x16) -> cons1(x16)
        ap(last0(),x19) -> last1(x19)
        ap(if21(x21),x22) -> if22(x21,x22)
        ap(if20(),x21) -> if21(x21)
        ap(dropLast0(),x24) -> dropLast1(x24)
      Qed