/export/starexec/sandbox/solver/bin/starexec_run_complexity /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


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


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

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) SlicingProof [LOWER BOUND(ID), 0 ms]
(4) CpxTRS
(5) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) typed CpxTrs
(7) OrderProof [LOWER BOUND(ID), 0 ms]
(8) typed CpxTrs
(9) RewriteLemmaProof [LOWER BOUND(ID), 560 ms]
(10) BEST
    (11) proven lower bound
        (12) LowerBoundPropagationProof [FINISHED, 0 ms]
        (13) BOUNDS(n^1, INF)
    (14) typed CpxTrs


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

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


The TRS R consists of the following rules:

   a__terms(N) -> cons(recip(a__sqr(mark(N))), terms(s(N)))
   a__sqr(0) -> 0
   a__sqr(s(X)) -> s(add(sqr(X), dbl(X)))
   a__dbl(0) -> 0
   a__dbl(s(X)) -> s(s(dbl(X)))
   a__add(0, X) -> mark(X)
   a__add(s(X), Y) -> s(add(X, Y))
   a__first(0, X) -> nil
   a__first(s(X), cons(Y, Z)) -> cons(mark(Y), first(X, Z))
   mark(terms(X)) -> a__terms(mark(X))
   mark(sqr(X)) -> a__sqr(mark(X))
   mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
   mark(dbl(X)) -> a__dbl(mark(X))
   mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
   mark(cons(X1, X2)) -> cons(mark(X1), X2)
   mark(recip(X)) -> recip(mark(X))
   mark(s(X)) -> s(X)
   mark(0) -> 0
   mark(nil) -> nil
   a__terms(X) -> terms(X)
   a__sqr(X) -> sqr(X)
   a__add(X1, X2) -> add(X1, X2)
   a__dbl(X) -> dbl(X)
   a__first(X1, X2) -> first(X1, X2)

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

(1) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

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


The TRS R consists of the following rules:

   a__terms(N) -> cons(recip(a__sqr(mark(N))), terms(s(N)))
   a__sqr(0') -> 0'
   a__sqr(s(X)) -> s(add(sqr(X), dbl(X)))
   a__dbl(0') -> 0'
   a__dbl(s(X)) -> s(s(dbl(X)))
   a__add(0', X) -> mark(X)
   a__add(s(X), Y) -> s(add(X, Y))
   a__first(0', X) -> nil
   a__first(s(X), cons(Y, Z)) -> cons(mark(Y), first(X, Z))
   mark(terms(X)) -> a__terms(mark(X))
   mark(sqr(X)) -> a__sqr(mark(X))
   mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
   mark(dbl(X)) -> a__dbl(mark(X))
   mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
   mark(cons(X1, X2)) -> cons(mark(X1), X2)
   mark(recip(X)) -> recip(mark(X))
   mark(s(X)) -> s(X)
   mark(0') -> 0'
   mark(nil) -> nil
   a__terms(X) -> terms(X)
   a__sqr(X) -> sqr(X)
   a__add(X1, X2) -> add(X1, X2)
   a__dbl(X) -> dbl(X)
   a__first(X1, X2) -> first(X1, X2)

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

(3) SlicingProof (LOWER BOUND(ID))
Sliced the following arguments:
cons/1
s/0

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

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


The TRS R consists of the following rules:

   a__terms(N) -> cons(recip(a__sqr(mark(N))))
   a__sqr(0') -> 0'
   a__sqr(s) -> s
   a__dbl(0') -> 0'
   a__dbl(s) -> s
   a__add(0', X) -> mark(X)
   a__add(s, Y) -> s
   a__first(0', X) -> nil
   a__first(s, cons(Y)) -> cons(mark(Y))
   mark(terms(X)) -> a__terms(mark(X))
   mark(sqr(X)) -> a__sqr(mark(X))
   mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
   mark(dbl(X)) -> a__dbl(mark(X))
   mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
   mark(cons(X1)) -> cons(mark(X1))
   mark(recip(X)) -> recip(mark(X))
   mark(s) -> s
   mark(0') -> 0'
   mark(nil) -> nil
   a__terms(X) -> terms(X)
   a__sqr(X) -> sqr(X)
   a__add(X1, X2) -> add(X1, X2)
   a__dbl(X) -> dbl(X)
   a__first(X1, X2) -> first(X1, X2)

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

(5) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(6)
Obligation:
Innermost TRS:
Rules:
a__terms(N) -> cons(recip(a__sqr(mark(N))))
a__sqr(0') -> 0'
a__sqr(s) -> s
a__dbl(0') -> 0'
a__dbl(s) -> s
a__add(0', X) -> mark(X)
a__add(s, Y) -> s
a__first(0', X) -> nil
a__first(s, cons(Y)) -> cons(mark(Y))
mark(terms(X)) -> a__terms(mark(X))
mark(sqr(X)) -> a__sqr(mark(X))
mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
mark(dbl(X)) -> a__dbl(mark(X))
mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
mark(cons(X1)) -> cons(mark(X1))
mark(recip(X)) -> recip(mark(X))
mark(s) -> s
mark(0') -> 0'
mark(nil) -> nil
a__terms(X) -> terms(X)
a__sqr(X) -> sqr(X)
a__add(X1, X2) -> add(X1, X2)
a__dbl(X) -> dbl(X)
a__first(X1, X2) -> first(X1, X2)

Types:
a__terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
cons :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
recip :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
mark :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
0' :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
s :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
nil :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
hole_recip:cons:0':s:nil:terms:sqr:add:dbl:first1_0 :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0 :: Nat -> recip:cons:0':s:nil:terms:sqr:add:dbl:first

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

(7) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
a__terms, mark

They will be analysed ascendingly in the following order:
a__terms = mark

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

(8)
Obligation:
Innermost TRS:
Rules:
a__terms(N) -> cons(recip(a__sqr(mark(N))))
a__sqr(0') -> 0'
a__sqr(s) -> s
a__dbl(0') -> 0'
a__dbl(s) -> s
a__add(0', X) -> mark(X)
a__add(s, Y) -> s
a__first(0', X) -> nil
a__first(s, cons(Y)) -> cons(mark(Y))
mark(terms(X)) -> a__terms(mark(X))
mark(sqr(X)) -> a__sqr(mark(X))
mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
mark(dbl(X)) -> a__dbl(mark(X))
mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
mark(cons(X1)) -> cons(mark(X1))
mark(recip(X)) -> recip(mark(X))
mark(s) -> s
mark(0') -> 0'
mark(nil) -> nil
a__terms(X) -> terms(X)
a__sqr(X) -> sqr(X)
a__add(X1, X2) -> add(X1, X2)
a__dbl(X) -> dbl(X)
a__first(X1, X2) -> first(X1, X2)

Types:
a__terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
cons :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
recip :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
mark :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
0' :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
s :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
nil :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
hole_recip:cons:0':s:nil:terms:sqr:add:dbl:first1_0 :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0 :: Nat -> recip:cons:0':s:nil:terms:sqr:add:dbl:first


Generator Equations:
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(0) <=> 0'
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(+(x, 1)) <=> cons(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(x))


The following defined symbols remain to be analysed:
mark, a__terms

They will be analysed ascendingly in the following order:
a__terms = mark

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

(9) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
mark(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(n4_0)) -> gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(n4_0), rt in Omega(1 + n4_0)

Induction Base:
mark(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(0)) ->_R^Omega(1)
0'

Induction Step:
mark(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(+(n4_0, 1))) ->_R^Omega(1)
cons(mark(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(n4_0))) ->_IH
cons(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(c5_0))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(10)
Complex Obligation (BEST)

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

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

Innermost TRS:
Rules:
a__terms(N) -> cons(recip(a__sqr(mark(N))))
a__sqr(0') -> 0'
a__sqr(s) -> s
a__dbl(0') -> 0'
a__dbl(s) -> s
a__add(0', X) -> mark(X)
a__add(s, Y) -> s
a__first(0', X) -> nil
a__first(s, cons(Y)) -> cons(mark(Y))
mark(terms(X)) -> a__terms(mark(X))
mark(sqr(X)) -> a__sqr(mark(X))
mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
mark(dbl(X)) -> a__dbl(mark(X))
mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
mark(cons(X1)) -> cons(mark(X1))
mark(recip(X)) -> recip(mark(X))
mark(s) -> s
mark(0') -> 0'
mark(nil) -> nil
a__terms(X) -> terms(X)
a__sqr(X) -> sqr(X)
a__add(X1, X2) -> add(X1, X2)
a__dbl(X) -> dbl(X)
a__first(X1, X2) -> first(X1, X2)

Types:
a__terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
cons :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
recip :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
mark :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
0' :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
s :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
nil :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
hole_recip:cons:0':s:nil:terms:sqr:add:dbl:first1_0 :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0 :: Nat -> recip:cons:0':s:nil:terms:sqr:add:dbl:first


Generator Equations:
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(0) <=> 0'
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(+(x, 1)) <=> cons(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(x))


The following defined symbols remain to be analysed:
mark, a__terms

They will be analysed ascendingly in the following order:
a__terms = mark

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

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

(13)
BOUNDS(n^1, INF)

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

(14)
Obligation:
Innermost TRS:
Rules:
a__terms(N) -> cons(recip(a__sqr(mark(N))))
a__sqr(0') -> 0'
a__sqr(s) -> s
a__dbl(0') -> 0'
a__dbl(s) -> s
a__add(0', X) -> mark(X)
a__add(s, Y) -> s
a__first(0', X) -> nil
a__first(s, cons(Y)) -> cons(mark(Y))
mark(terms(X)) -> a__terms(mark(X))
mark(sqr(X)) -> a__sqr(mark(X))
mark(add(X1, X2)) -> a__add(mark(X1), mark(X2))
mark(dbl(X)) -> a__dbl(mark(X))
mark(first(X1, X2)) -> a__first(mark(X1), mark(X2))
mark(cons(X1)) -> cons(mark(X1))
mark(recip(X)) -> recip(mark(X))
mark(s) -> s
mark(0') -> 0'
mark(nil) -> nil
a__terms(X) -> terms(X)
a__sqr(X) -> sqr(X)
a__add(X1, X2) -> add(X1, X2)
a__dbl(X) -> dbl(X)
a__first(X1, X2) -> first(X1, X2)

Types:
a__terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
cons :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
recip :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
mark :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
0' :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
s :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
a__first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
nil :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
terms :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
sqr :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
add :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
dbl :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
first :: recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first -> recip:cons:0':s:nil:terms:sqr:add:dbl:first
hole_recip:cons:0':s:nil:terms:sqr:add:dbl:first1_0 :: recip:cons:0':s:nil:terms:sqr:add:dbl:first
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0 :: Nat -> recip:cons:0':s:nil:terms:sqr:add:dbl:first


Lemmas:
mark(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(n4_0)) -> gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(n4_0), rt in Omega(1 + n4_0)


Generator Equations:
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(0) <=> 0'
gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(+(x, 1)) <=> cons(gen_recip:cons:0':s:nil:terms:sqr:add:dbl:first2_0(x))


The following defined symbols remain to be analysed:
a__terms

They will be analysed ascendingly in the following order:
a__terms = mark