/export/starexec/sandbox2/solver/bin/starexec_run_rcdcRelativeAlsoLower /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


WORST_CASE(Omega(n^1), ?)
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(n^1, INF).

(0) DCpxTrs
(1) DerivationalComplexityToRuntimeComplexityProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxRelTRS
(3) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 883 ms]
(4) CpxRelTRS
(5) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(6) TRS for Loop Detection
(7) DecreasingLoopProof [LOWER BOUND(ID), 0 ms]
(8) BEST
    (9) proven lower bound
        (10) LowerBoundPropagationProof [FINISHED, 0 ms]
        (11) BOUNDS(n^1, INF)
    (12) TRS for Loop Detection


----------------------------------------

(0)
Obligation:
The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(1) DerivationalComplexityToRuntimeComplexityProof (BOTH BOUNDS(ID, ID))
The following rules have been added to S to convert the given derivational complexity problem to a runtime complexity problem:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c


----------------------------------------

(2)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

The (relative) TRS S consists of the following rules:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c

Rewrite Strategy: INNERMOST
----------------------------------------

(3) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved innermost termination of relative rules
----------------------------------------

(4)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

The (relative) TRS S consists of the following rules:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c

Rewrite Strategy: INNERMOST
----------------------------------------

(5) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(6)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

The (relative) TRS S consists of the following rules:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c

Rewrite Strategy: INNERMOST
----------------------------------------

(7) DecreasingLoopProof (LOWER BOUND(ID))
The following loop(s) give(s) rise to the lower bound Omega(n^1):

The rewrite sequence

droplast(cons(x, cons(y, xs))) ->^+ cons(x, droplast(cons(y, xs)))

gives rise to a decreasing loop by considering the right hand sides subterm at position [1].

The pumping substitution is [xs / cons(y, xs)].

The result substitution is [x / y].




----------------------------------------

(8)
Complex Obligation (BEST)

----------------------------------------

(9)
Obligation:
Proved the lower bound n^1 for the following obligation:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

The (relative) TRS S consists of the following rules:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c

Rewrite Strategy: INNERMOST
----------------------------------------

(10) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(11)
BOUNDS(n^1, INF)

----------------------------------------

(12)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

The (relative) TRS S consists of the following rules:

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(false) -> false
   encArg(true) -> true
   encArg(logError) -> logError
   encArg(nil) -> nil
   encArg(cons(x_1, x_2)) -> cons(encArg(x_1), encArg(x_2))
   encArg(error) -> error
   encArg(b) -> b
   encArg(c) -> c
   encArg(cons_le(x_1, x_2)) -> le(encArg(x_1), encArg(x_2))
   encArg(cons_double(x_1)) -> double(encArg(x_1))
   encArg(cons_log(x_1)) -> log(encArg(x_1))
   encArg(cons_loop(x_1, x_2, x_3)) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_if(x_1, x_2, x_3, x_4)) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encArg(cons_maplog(x_1)) -> maplog(encArg(x_1))
   encArg(cons_mapIter(x_1, x_2)) -> mapIter(encArg(x_1), encArg(x_2))
   encArg(cons_ifmap(x_1, x_2, x_3)) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encArg(cons_isempty(x_1)) -> isempty(encArg(x_1))
   encArg(cons_last(x_1)) -> last(encArg(x_1))
   encArg(cons_droplast(x_1)) -> droplast(encArg(x_1))
   encArg(cons_a) -> a
   encode_le(x_1, x_2) -> le(encArg(x_1), encArg(x_2))
   encode_s(x_1) -> s(encArg(x_1))
   encode_0 -> 0
   encode_false -> false
   encode_true -> true
   encode_double(x_1) -> double(encArg(x_1))
   encode_log(x_1) -> log(encArg(x_1))
   encode_logError -> logError
   encode_loop(x_1, x_2, x_3) -> loop(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_if(x_1, x_2, x_3, x_4) -> if(encArg(x_1), encArg(x_2), encArg(x_3), encArg(x_4))
   encode_maplog(x_1) -> maplog(encArg(x_1))
   encode_mapIter(x_1, x_2) -> mapIter(encArg(x_1), encArg(x_2))
   encode_nil -> nil
   encode_ifmap(x_1, x_2, x_3) -> ifmap(encArg(x_1), encArg(x_2), encArg(x_3))
   encode_isempty(x_1) -> isempty(encArg(x_1))
   encode_droplast(x_1) -> droplast(encArg(x_1))
   encode_cons(x_1, x_2) -> cons(encArg(x_1), encArg(x_2))
   encode_last(x_1) -> last(encArg(x_1))
   encode_error -> error
   encode_a -> a
   encode_b -> b
   encode_c -> c

Rewrite Strategy: INNERMOST