YES

Problem:
 ap(ap(ff(),x),x) -> ap(ap(x,ap(ff(),x)),ap(ap(cons(),x),nil()))

Proof:
 Extended Uncurrying Processor:
  application symbol: ap
  symbol table:
   nil ==> nil0/0
   cons ==> cons0/0 cons1/1 cons2/2
   ff ==> ff0/0 ff1/1 ff2/2
   
  uncurry-rules:
   ap(ff1(x1),x2) -> ff2(x1,x2)
   ap(ff0(),x1) -> ff1(x1)
   ap(cons1(x4),x5) -> cons2(x4,x5)
   ap(cons0(),x4) -> cons1(x4)
  eta-rules:
   
  problem:
   ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
   ap(ff1(x1),x2) -> ff2(x1,x2)
   ap(ff0(),x1) -> ff1(x1)
   ap(cons1(x4),x5) -> cons2(x4,x5)
   ap(cons0(),x4) -> cons1(x4)
  DP Processor:
   DPs:
    ff{2,#}(x,x) -> ap#(x,ff1(x))
    ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
    ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
   TRS:
    ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
    ap(ff1(x1),x2) -> ff2(x1,x2)
    ap(ff0(),x1) -> ff1(x1)
    ap(cons1(x4),x5) -> cons2(x4,x5)
    ap(cons0(),x4) -> cons1(x4)
   TDG Processor:
    DPs:
     ff{2,#}(x,x) -> ap#(x,ff1(x))
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
    TRS:
     ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
     ap(ff1(x1),x2) -> ff2(x1,x2)
     ap(ff0(),x1) -> ff1(x1)
     ap(cons1(x4),x5) -> cons2(x4,x5)
     ap(cons0(),x4) -> cons1(x4)
    graph:
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) ->
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) ->
     ff{2,#}(x,x) -> ap#(x,ff1(x))
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0())) ->
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
     ff{2,#}(x,x) -> ap#(x,ff1(x)) -> ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
    Arctic Interpretation Processor:
     dimension: 1
     usable rules:
      ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
      ap(ff1(x1),x2) -> ff2(x1,x2)
      ap(ff0(),x1) -> ff1(x1)
      ap(cons1(x4),x5) -> cons2(x4,x5)
      ap(cons0(),x4) -> cons1(x4)
     interpretation:
      [ff0] = 5,
      
      [cons1](x0) = 6,
      
      [ap](x0, x1) = -4x0 + -8x1 + 0,
      
      [ff1](x0) = 1,
      
      [nil0] = 14,
      
      [cons0] = 10,
      
      [ap#](x0, x1) = 1x0 + 1x1 + 0,
      
      [ff{2,#}](x0, x1) = 1x1 + 2,
      
      [cons2](x0, x1) = -14x1 + 0,
      
      [ff2](x0, x1) = -8x1 + 0
     orientation:
      ff{2,#}(x,x) = 1x + 2 >= 1x + 2 = ap#(x,ff1(x))
      
      ff{2,#}(x,x) = 1x + 2 >= -3x + 1 = ap#(ap(x,ff1(x)),cons2(x,nil0()))
      
      ap#(ff1(x1),x2) = 1x2 + 2 >= 1x2 + 2 = ff{2,#}(x1,x2)
      
      ff2(x,x) = -8x + 0 >= -8x + 0 = ap(ap(x,ff1(x)),cons2(x,nil0()))
      
      ap(ff1(x1),x2) = -8x2 + 0 >= -8x2 + 0 = ff2(x1,x2)
      
      ap(ff0(),x1) = -8x1 + 1 >= 1 = ff1(x1)
      
      ap(cons1(x4),x5) = -8x5 + 2 >= -14x5 + 0 = cons2(x4,x5)
      
      ap(cons0(),x4) = -8x4 + 6 >= 6 = cons1(x4)
     problem:
      DPs:
       ff{2,#}(x,x) -> ap#(x,ff1(x))
       ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
      TRS:
       ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
       ap(ff1(x1),x2) -> ff2(x1,x2)
       ap(ff0(),x1) -> ff1(x1)
       ap(cons1(x4),x5) -> cons2(x4,x5)
       ap(cons0(),x4) -> cons1(x4)
     Restore Modifier:
      DPs:
       ff{2,#}(x,x) -> ap#(x,ff1(x))
       ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
      TRS:
       ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
       ap(ff1(x1),x2) -> ff2(x1,x2)
       ap(ff0(),x1) -> ff1(x1)
       ap(cons1(x4),x5) -> cons2(x4,x5)
       ap(cons0(),x4) -> cons1(x4)
      Size-Change Termination Processor:
       DPs:
        
       TRS:
        ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
        ap(ff1(x1),x2) -> ff2(x1,x2)
        ap(ff0(),x1) -> ff1(x1)
        ap(cons1(x4),x5) -> cons2(x4,x5)
        ap(cons0(),x4) -> cons1(x4)
       The DP: ff{2,#}(x,x) -> ap#(x,ff1(x)) has the edges:
         0 >=  0
         1 >=  0
       The DP: ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) has the edges:
         0 >   0
         1 >=  1
       Qed