YES

Problem:
 a__app(nil(),YS) -> mark(YS)
 a__app(cons(X,XS),YS) -> cons(mark(X),app(XS,YS))
 a__from(X) -> cons(mark(X),from(s(X)))
 a__zWadr(nil(),YS) -> nil()
 a__zWadr(XS,nil()) -> nil()
 a__zWadr(cons(X,XS),cons(Y,YS)) -> cons(a__app(mark(Y),cons(mark(X),nil())),zWadr(XS,YS))
 a__prefix(L) -> cons(nil(),zWadr(L,prefix(L)))
 mark(app(X1,X2)) -> a__app(mark(X1),mark(X2))
 mark(from(X)) -> a__from(mark(X))
 mark(zWadr(X1,X2)) -> a__zWadr(mark(X1),mark(X2))
 mark(prefix(X)) -> a__prefix(mark(X))
 mark(nil()) -> nil()
 mark(cons(X1,X2)) -> cons(mark(X1),X2)
 mark(s(X)) -> s(mark(X))
 a__app(X1,X2) -> app(X1,X2)
 a__from(X) -> from(X)
 a__zWadr(X1,X2) -> zWadr(X1,X2)
 a__prefix(X) -> prefix(X)

Proof:
 WPO Processor:
  algebra: Max
  weight function:
   w0 = 0
   w(from) = w(a__from) = 5
   w(a__zWadr) = 3
   w(a__prefix) = 2
   w(cons) = 1
   w(prefix) = w(zWadr) = w(s) = w(app) = w(mark) = w(a__app) = w(nil) = 0
  status function:
   st(a__zWadr) = st(app) = st(cons) = [1, 0]
   st(prefix) = st(a__prefix) = [0]
   st(zWadr) = [0, 1]
   st(from) = st(s) = st(a__from) = st(mark) = [0]
   st(a__app) = [0, 1]
   st(nil) = []
  subterm penalty function:
   sp(prefix, 0) = sp(a__prefix, 0) = sp(zWadr, 0) = sp(a__zWadr, 0) = 3
   sp(from, 0) = sp(a__from, 0) = sp(cons, 0) = 2
   sp(app, 1) = sp(a__app, 1) = 1
   sp(zWadr, 1) = sp(a__zWadr, 1) = sp(s, 0) = sp(app, 0) = sp(cons, 1) = sp(
   mark, 0) = sp(a__app, 0) = 0
  precedence:
   mark > a__zWadr ~ a__from ~ a__app > a__prefix > prefix ~ zWadr ~ from ~ s ~ app ~ cons ~ nil
  problem:
   
  Qed