Termination Proof using AProVE

Term Rewriting System R:
[YS, X, XS, X1, X2, Y, L]
a_{_app}(nil, YS) -> mark(YS)
a_{_app}(cons(X, XS), YS) -> cons(mark(X), app(XS, YS))
a_{_app}(X1, X2) -> app(X1, X2)
a_{_from}(X) -> cons(mark(X), from(s(X)))
a_{_from}(X) -> from(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_{_zWadr}(X1, X2) -> zWadr(X1, X2)
a_{_prefix}(L) -> cons(nil, zWadr(L, prefix(L)))
a_{_prefix}(X) -> prefix(X)
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))

Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

A_{_APP}(nil, YS) -> MARK(YS)
A_{_APP}(cons(X, XS), YS) -> MARK(X)
A_{_FROM}(X) -> MARK(X)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(Y)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(X)
MARK(app(X1, X2)) -> A_{_APP}(mark(X1), mark(X2))
MARK(app(X1, X2)) -> MARK(X1)
MARK(app(X1, X2)) -> MARK(X2)
MARK(from(X)) -> A_{_FROM}(mark(X))
MARK(from(X)) -> MARK(X)
MARK(zWadr(X1, X2)) -> A_{_ZWADR}(mark(X1), mark(X2))
MARK(zWadr(X1, X2)) -> MARK(X1)
MARK(zWadr(X1, X2)) -> MARK(X2)
MARK(prefix(X)) -> A_{_PREFIX}(mark(X))
MARK(prefix(X)) -> MARK(X)
MARK(cons(X1, X2)) -> MARK(X1)
MARK(s(X)) -> MARK(X)

Furthermore, R contains one SCC.

     ↳DPs

       →DP Problem 1

         ↳Narrowing Transformation

Dependency Pairs:

A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(X)
MARK(s(X)) -> MARK(X)
MARK(cons(X1, X2)) -> MARK(X1)
MARK(prefix(X)) -> MARK(X)
MARK(zWadr(X1, X2)) -> MARK(X2)
MARK(zWadr(X1, X2)) -> MARK(X1)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(Y)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(mark(X), nil))
MARK(zWadr(X1, X2)) -> A_{_ZWADR}(mark(X1), mark(X2))
MARK(from(X)) -> MARK(X)
A_{_FROM}(X) -> MARK(X)
MARK(from(X)) -> A_{_FROM}(mark(X))
MARK(app(X1, X2)) -> MARK(X2)
MARK(app(X1, X2)) -> MARK(X1)
A_{_APP}(cons(X, XS), YS) -> MARK(X)
MARK(app(X1, X2)) -> A_{_APP}(mark(X1), mark(X2))
A_{_APP}(nil, YS) -> MARK(YS)

Rules:

a_{_app}(nil, YS) -> mark(YS)
a_{_app}(cons(X, XS), YS) -> cons(mark(X), app(XS, YS))
a_{_app}(X1, X2) -> app(X1, X2)
a_{_from}(X) -> cons(mark(X), from(s(X)))
a_{_from}(X) -> from(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_{_zWadr}(X1, X2) -> zWadr(X1, X2)
a_{_prefix}(L) -> cons(nil, zWadr(L, prefix(L)))
a_{_prefix}(X) -> prefix(X)
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))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(mark(X), nil))

14 new Dependency Pairs are created:

A_{_ZWADR}(cons(X, XS), cons(app(X1', X2'), YS)) -> A_{_APP}(a_{_app}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(from(X''), YS)) -> A_{_APP}(a_{_from}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(zWadr(X1', X2'), YS)) -> A_{_APP}(a_{_zWadr}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(prefix(X''), YS)) -> A_{_APP}(a_{_prefix}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(nil, YS)) -> A_{_APP}(nil, cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(cons(X1', X2'), YS)) -> A_{_APP}(cons(mark(X1'), X2'), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(s(X''), YS)) -> A_{_APP}(s(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(app(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_app}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(from(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_from}(mark(X'')), nil))
A_{_ZWADR}(cons(zWadr(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_zWadr}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(prefix(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_prefix}(mark(X'')), nil))
A_{_ZWADR}(cons(nil, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(nil, nil))
A_{_ZWADR}(cons(cons(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(cons(mark(X1'), X2'), nil))
A_{_ZWADR}(cons(s(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(s(mark(X'')), nil))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 2

             ↳Narrowing Transformation

Dependency Pairs:

A_{_ZWADR}(cons(s(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(s(mark(X'')), nil))
A_{_ZWADR}(cons(cons(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(cons(mark(X1'), X2'), nil))
A_{_ZWADR}(cons(nil, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(nil, nil))
A_{_ZWADR}(cons(prefix(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_prefix}(mark(X'')), nil))
A_{_ZWADR}(cons(zWadr(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_zWadr}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(from(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_from}(mark(X'')), nil))
A_{_ZWADR}(cons(app(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_app}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(X, XS), cons(cons(X1', X2'), YS)) -> A_{_APP}(cons(mark(X1'), X2'), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(nil, YS)) -> A_{_APP}(nil, cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(prefix(X''), YS)) -> A_{_APP}(a_{_prefix}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(zWadr(X1', X2'), YS)) -> A_{_APP}(a_{_zWadr}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(from(X''), YS)) -> A_{_APP}(a_{_from}(mark(X'')), cons(mark(X), nil))
A_{_APP}(cons(X, XS), YS) -> MARK(X)
A_{_ZWADR}(cons(X, XS), cons(app(X1', X2'), YS)) -> A_{_APP}(a_{_app}(mark(X1'), mark(X2')), cons(mark(X), nil))
MARK(s(X)) -> MARK(X)
MARK(cons(X1, X2)) -> MARK(X1)
MARK(prefix(X)) -> MARK(X)
MARK(zWadr(X1, X2)) -> MARK(X2)
MARK(zWadr(X1, X2)) -> MARK(X1)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(Y)
MARK(zWadr(X1, X2)) -> A_{_ZWADR}(mark(X1), mark(X2))
MARK(from(X)) -> MARK(X)
A_{_FROM}(X) -> MARK(X)
MARK(from(X)) -> A_{_FROM}(mark(X))
MARK(app(X1, X2)) -> MARK(X2)
MARK(app(X1, X2)) -> MARK(X1)
A_{_APP}(nil, YS) -> MARK(YS)
MARK(app(X1, X2)) -> A_{_APP}(mark(X1), mark(X2))
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(X)

Rules:

a_{_app}(nil, YS) -> mark(YS)
a_{_app}(cons(X, XS), YS) -> cons(mark(X), app(XS, YS))
a_{_app}(X1, X2) -> app(X1, X2)
a_{_from}(X) -> cons(mark(X), from(s(X)))
a_{_from}(X) -> from(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_{_zWadr}(X1, X2) -> zWadr(X1, X2)
a_{_prefix}(L) -> cons(nil, zWadr(L, prefix(L)))
a_{_prefix}(X) -> prefix(X)
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))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

MARK(app(X1, X2)) -> A_{_APP}(mark(X1), mark(X2))

14 new Dependency Pairs are created:

MARK(app(app(X1'', X2''), X2)) -> A_{_APP}(a_{_app}(mark(X1''), mark(X2'')), mark(X2))
MARK(app(from(X'), X2)) -> A_{_APP}(a_{_from}(mark(X')), mark(X2))
MARK(app(zWadr(X1'', X2''), X2)) -> A_{_APP}(a_{_zWadr}(mark(X1''), mark(X2'')), mark(X2))
MARK(app(prefix(X'), X2)) -> A_{_APP}(a_{_prefix}(mark(X')), mark(X2))
MARK(app(nil, X2)) -> A_{_APP}(nil, mark(X2))
MARK(app(cons(X1'', X2''), X2)) -> A_{_APP}(cons(mark(X1''), X2''), mark(X2))
MARK(app(s(X'), X2)) -> A_{_APP}(s(mark(X')), mark(X2))
MARK(app(X1, app(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_app}(mark(X1''), mark(X2'')))
MARK(app(X1, from(X'))) -> A_{_APP}(mark(X1), a_{_from}(mark(X')))
MARK(app(X1, zWadr(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_zWadr}(mark(X1''), mark(X2'')))
MARK(app(X1, prefix(X'))) -> A_{_APP}(mark(X1), a_{_prefix}(mark(X')))
MARK(app(X1, nil)) -> A_{_APP}(mark(X1), nil)
MARK(app(X1, cons(X1'', X2''))) -> A_{_APP}(mark(X1), cons(mark(X1''), X2''))
MARK(app(X1, s(X'))) -> A_{_APP}(mark(X1), s(mark(X')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 2

             ↳Nar

...

               →DP Problem 3

                 ↳Narrowing Transformation

Dependency Pairs:

A_{_ZWADR}(cons(cons(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(cons(mark(X1'), X2'), nil))
A_{_ZWADR}(cons(nil, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(nil, nil))
A_{_ZWADR}(cons(prefix(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_prefix}(mark(X'')), nil))
A_{_ZWADR}(cons(zWadr(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_zWadr}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(from(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_from}(mark(X'')), nil))
A_{_ZWADR}(cons(app(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_app}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(X, XS), cons(cons(X1', X2'), YS)) -> A_{_APP}(cons(mark(X1'), X2'), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(nil, YS)) -> A_{_APP}(nil, cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(prefix(X''), YS)) -> A_{_APP}(a_{_prefix}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(zWadr(X1', X2'), YS)) -> A_{_APP}(a_{_zWadr}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(from(X''), YS)) -> A_{_APP}(a_{_from}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(app(X1', X2'), YS)) -> A_{_APP}(a_{_app}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(X)
MARK(app(X1, s(X'))) -> A_{_APP}(mark(X1), s(mark(X')))
MARK(app(X1, cons(X1'', X2''))) -> A_{_APP}(mark(X1), cons(mark(X1''), X2''))
MARK(app(X1, nil)) -> A_{_APP}(mark(X1), nil)
MARK(app(X1, prefix(X'))) -> A_{_APP}(mark(X1), a_{_prefix}(mark(X')))
MARK(app(X1, zWadr(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_zWadr}(mark(X1''), mark(X2'')))
MARK(app(X1, from(X'))) -> A_{_APP}(mark(X1), a_{_from}(mark(X')))
MARK(app(X1, app(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_app}(mark(X1''), mark(X2'')))
MARK(app(cons(X1'', X2''), X2)) -> A_{_APP}(cons(mark(X1''), X2''), mark(X2))
MARK(app(nil, X2)) -> A_{_APP}(nil, mark(X2))
MARK(app(prefix(X'), X2)) -> A_{_APP}(a_{_prefix}(mark(X')), mark(X2))
MARK(app(zWadr(X1'', X2''), X2)) -> A_{_APP}(a_{_zWadr}(mark(X1''), mark(X2'')), mark(X2))
MARK(app(from(X'), X2)) -> A_{_APP}(a_{_from}(mark(X')), mark(X2))
A_{_APP}(cons(X, XS), YS) -> MARK(X)
MARK(app(app(X1'', X2''), X2)) -> A_{_APP}(a_{_app}(mark(X1''), mark(X2'')), mark(X2))
MARK(s(X)) -> MARK(X)
MARK(cons(X1, X2)) -> MARK(X1)
MARK(prefix(X)) -> MARK(X)
MARK(zWadr(X1, X2)) -> MARK(X2)
MARK(zWadr(X1, X2)) -> MARK(X1)
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(Y)
MARK(zWadr(X1, X2)) -> A_{_ZWADR}(mark(X1), mark(X2))
MARK(from(X)) -> MARK(X)
A_{_FROM}(X) -> MARK(X)
MARK(from(X)) -> A_{_FROM}(mark(X))
MARK(app(X1, X2)) -> MARK(X2)
MARK(app(X1, X2)) -> MARK(X1)
A_{_APP}(nil, YS) -> MARK(YS)
A_{_ZWADR}(cons(s(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(s(mark(X'')), nil))

Rules:

a_{_app}(nil, YS) -> mark(YS)
a_{_app}(cons(X, XS), YS) -> cons(mark(X), app(XS, YS))
a_{_app}(X1, X2) -> app(X1, X2)
a_{_from}(X) -> cons(mark(X), from(s(X)))
a_{_from}(X) -> from(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_{_zWadr}(X1, X2) -> zWadr(X1, X2)
a_{_prefix}(L) -> cons(nil, zWadr(L, prefix(L)))
a_{_prefix}(X) -> prefix(X)
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))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

MARK(zWadr(X1, X2)) -> A_{_ZWADR}(mark(X1), mark(X2))

14 new Dependency Pairs are created:

MARK(zWadr(app(X1'', X2''), X2)) -> A_{_ZWADR}(a_{_app}(mark(X1''), mark(X2'')), mark(X2))
MARK(zWadr(from(X'), X2)) -> A_{_ZWADR}(a_{_from}(mark(X')), mark(X2))
MARK(zWadr(zWadr(X1'', X2''), X2)) -> A_{_ZWADR}(a_{_zWadr}(mark(X1''), mark(X2'')), mark(X2))
MARK(zWadr(prefix(X'), X2)) -> A_{_ZWADR}(a_{_prefix}(mark(X')), mark(X2))
MARK(zWadr(nil, X2)) -> A_{_ZWADR}(nil, mark(X2))
MARK(zWadr(cons(X1'', X2''), X2)) -> A_{_ZWADR}(cons(mark(X1''), X2''), mark(X2))
MARK(zWadr(s(X'), X2)) -> A_{_ZWADR}(s(mark(X')), mark(X2))
MARK(zWadr(X1, app(X1'', X2''))) -> A_{_ZWADR}(mark(X1), a_{_app}(mark(X1''), mark(X2'')))
MARK(zWadr(X1, from(X'))) -> A_{_ZWADR}(mark(X1), a_{_from}(mark(X')))
MARK(zWadr(X1, zWadr(X1'', X2''))) -> A_{_ZWADR}(mark(X1), a_{_zWadr}(mark(X1''), mark(X2'')))
MARK(zWadr(X1, prefix(X'))) -> A_{_ZWADR}(mark(X1), a_{_prefix}(mark(X')))
MARK(zWadr(X1, nil)) -> A_{_ZWADR}(mark(X1), nil)
MARK(zWadr(X1, cons(X1'', X2''))) -> A_{_ZWADR}(mark(X1), cons(mark(X1''), X2''))
MARK(zWadr(X1, s(X'))) -> A_{_ZWADR}(mark(X1), s(mark(X')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 2

             ↳Nar

...

               →DP Problem 4

                 ↳Remaining Obligation(s)

The following remains to be proven:
Dependency Pairs:

MARK(zWadr(X1, cons(X1'', X2''))) -> A_{_ZWADR}(mark(X1), cons(mark(X1''), X2''))
MARK(zWadr(X1, prefix(X'))) -> A_{_ZWADR}(mark(X1), a_{_prefix}(mark(X')))
MARK(zWadr(X1, zWadr(X1'', X2''))) -> A_{_ZWADR}(mark(X1), a_{_zWadr}(mark(X1''), mark(X2'')))
MARK(zWadr(X1, from(X'))) -> A_{_ZWADR}(mark(X1), a_{_from}(mark(X')))
MARK(zWadr(X1, app(X1'', X2''))) -> A_{_ZWADR}(mark(X1), a_{_app}(mark(X1''), mark(X2'')))
MARK(zWadr(cons(X1'', X2''), X2)) -> A_{_ZWADR}(cons(mark(X1''), X2''), mark(X2))
MARK(zWadr(prefix(X'), X2)) -> A_{_ZWADR}(a_{_prefix}(mark(X')), mark(X2))
A_{_ZWADR}(cons(s(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(s(mark(X'')), nil))
A_{_ZWADR}(cons(nil, XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(nil, nil))
A_{_ZWADR}(cons(prefix(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_prefix}(mark(X'')), nil))
A_{_ZWADR}(cons(zWadr(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_zWadr}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(from(X''), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_from}(mark(X'')), nil))
A_{_ZWADR}(cons(app(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(a_{_app}(mark(X1'), mark(X2')), nil))
A_{_ZWADR}(cons(X, XS), cons(cons(X1', X2'), YS)) -> A_{_APP}(cons(mark(X1'), X2'), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(nil, YS)) -> A_{_APP}(nil, cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(prefix(X''), YS)) -> A_{_APP}(a_{_prefix}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(zWadr(X1', X2'), YS)) -> A_{_APP}(a_{_zWadr}(mark(X1'), mark(X2')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(from(X''), YS)) -> A_{_APP}(a_{_from}(mark(X'')), cons(mark(X), nil))
A_{_ZWADR}(cons(X, XS), cons(app(X1', X2'), YS)) -> A_{_APP}(a_{_app}(mark(X1'), mark(X2')), cons(mark(X), nil))
MARK(zWadr(zWadr(X1'', X2''), X2)) -> A_{_ZWADR}(a_{_zWadr}(mark(X1''), mark(X2'')), mark(X2))
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(X)
MARK(zWadr(from(X'), X2)) -> A_{_ZWADR}(a_{_from}(mark(X')), mark(X2))
A_{_ZWADR}(cons(X, XS), cons(Y, YS)) -> MARK(Y)
MARK(zWadr(app(X1'', X2''), X2)) -> A_{_ZWADR}(a_{_app}(mark(X1''), mark(X2'')), mark(X2))
MARK(app(X1, s(X'))) -> A_{_APP}(mark(X1), s(mark(X')))
MARK(app(X1, cons(X1'', X2''))) -> A_{_APP}(mark(X1), cons(mark(X1''), X2''))
MARK(app(X1, nil)) -> A_{_APP}(mark(X1), nil)
MARK(app(X1, prefix(X'))) -> A_{_APP}(mark(X1), a_{_prefix}(mark(X')))
MARK(app(X1, zWadr(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_zWadr}(mark(X1''), mark(X2'')))
MARK(app(X1, from(X'))) -> A_{_APP}(mark(X1), a_{_from}(mark(X')))
MARK(app(X1, app(X1'', X2''))) -> A_{_APP}(mark(X1), a_{_app}(mark(X1''), mark(X2'')))
MARK(app(cons(X1'', X2''), X2)) -> A_{_APP}(cons(mark(X1''), X2''), mark(X2))
MARK(app(nil, X2)) -> A_{_APP}(nil, mark(X2))
MARK(app(prefix(X'), X2)) -> A_{_APP}(a_{_prefix}(mark(X')), mark(X2))
MARK(app(zWadr(X1'', X2''), X2)) -> A_{_APP}(a_{_zWadr}(mark(X1''), mark(X2'')), mark(X2))
MARK(app(from(X'), X2)) -> A_{_APP}(a_{_from}(mark(X')), mark(X2))
A_{_APP}(cons(X, XS), YS) -> MARK(X)
MARK(app(app(X1'', X2''), X2)) -> A_{_APP}(a_{_app}(mark(X1''), mark(X2'')), mark(X2))
MARK(s(X)) -> MARK(X)
MARK(cons(X1, X2)) -> MARK(X1)
MARK(prefix(X)) -> MARK(X)
MARK(zWadr(X1, X2)) -> MARK(X2)
MARK(zWadr(X1, X2)) -> MARK(X1)
MARK(from(X)) -> MARK(X)
A_{_FROM}(X) -> MARK(X)
MARK(from(X)) -> A_{_FROM}(mark(X))
MARK(app(X1, X2)) -> MARK(X2)
MARK(app(X1, X2)) -> MARK(X1)
A_{_APP}(nil, YS) -> MARK(YS)
A_{_ZWADR}(cons(cons(X1', X2'), XS), cons(Y, YS)) -> A_{_APP}(mark(Y), cons(cons(mark(X1'), X2'), nil))

Rules:

a_{_app}(nil, YS) -> mark(YS)
a_{_app}(cons(X, XS), YS) -> cons(mark(X), app(XS, YS))
a_{_app}(X1, X2) -> app(X1, X2)
a_{_from}(X) -> cons(mark(X), from(s(X)))
a_{_from}(X) -> from(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_{_zWadr}(X1, X2) -> zWadr(X1, X2)
a_{_prefix}(L) -> cons(nil, zWadr(L, prefix(L)))
a_{_prefix}(X) -> prefix(X)
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))

Termination of R could not be shown.
Duration:
0:19 minutes