/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


YES

Problem:
 active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
 active(sqr(0())) -> mark(0())
 active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
 active(dbl(0())) -> mark(0())
 active(dbl(s(X))) -> mark(s(s(dbl(X))))
 active(add(0(),X)) -> mark(X)
 active(add(s(X),Y)) -> mark(s(add(X,Y)))
 active(first(0(),X)) -> mark(nil())
 active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
 mark(terms(X)) -> active(terms(mark(X)))
 mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
 mark(recip(X)) -> active(recip(mark(X)))
 mark(sqr(X)) -> active(sqr(mark(X)))
 mark(s(X)) -> active(s(mark(X)))
 mark(0()) -> active(0())
 mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
 mark(dbl(X)) -> active(dbl(mark(X)))
 mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
 mark(nil()) -> active(nil())
 terms(mark(X)) -> terms(X)
 terms(active(X)) -> terms(X)
 cons(mark(X1),X2) -> cons(X1,X2)
 cons(X1,mark(X2)) -> cons(X1,X2)
 cons(active(X1),X2) -> cons(X1,X2)
 cons(X1,active(X2)) -> cons(X1,X2)
 recip(mark(X)) -> recip(X)
 recip(active(X)) -> recip(X)
 sqr(mark(X)) -> sqr(X)
 sqr(active(X)) -> sqr(X)
 s(mark(X)) -> s(X)
 s(active(X)) -> s(X)
 add(mark(X1),X2) -> add(X1,X2)
 add(X1,mark(X2)) -> add(X1,X2)
 add(active(X1),X2) -> add(X1,X2)
 add(X1,active(X2)) -> add(X1,X2)
 dbl(mark(X)) -> dbl(X)
 dbl(active(X)) -> dbl(X)
 first(mark(X1),X2) -> first(X1,X2)
 first(X1,mark(X2)) -> first(X1,X2)
 first(active(X1),X2) -> first(X1,X2)
 first(X1,active(X2)) -> first(X1,X2)

Proof:
 DP Processor:
  DPs:
   active#(terms(N)) -> s#(N)
   active#(terms(N)) -> terms#(s(N))
   active#(terms(N)) -> sqr#(N)
   active#(terms(N)) -> recip#(sqr(N))
   active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
   active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
   active#(sqr(0())) -> mark#(0())
   active#(sqr(s(X))) -> dbl#(X)
   active#(sqr(s(X))) -> sqr#(X)
   active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
   active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
   active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
   active#(dbl(0())) -> mark#(0())
   active#(dbl(s(X))) -> dbl#(X)
   active#(dbl(s(X))) -> s#(dbl(X))
   active#(dbl(s(X))) -> s#(s(dbl(X)))
   active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
   active#(add(0(),X)) -> mark#(X)
   active#(add(s(X),Y)) -> add#(X,Y)
   active#(add(s(X),Y)) -> s#(add(X,Y))
   active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
   active#(first(0(),X)) -> mark#(nil())
   active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
   active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
   active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
   mark#(terms(X)) -> mark#(X)
   mark#(terms(X)) -> terms#(mark(X))
   mark#(terms(X)) -> active#(terms(mark(X)))
   mark#(cons(X1,X2)) -> mark#(X1)
   mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
   mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
   mark#(recip(X)) -> mark#(X)
   mark#(recip(X)) -> recip#(mark(X))
   mark#(recip(X)) -> active#(recip(mark(X)))
   mark#(sqr(X)) -> mark#(X)
   mark#(sqr(X)) -> sqr#(mark(X))
   mark#(sqr(X)) -> active#(sqr(mark(X)))
   mark#(s(X)) -> mark#(X)
   mark#(s(X)) -> s#(mark(X))
   mark#(s(X)) -> active#(s(mark(X)))
   mark#(0()) -> active#(0())
   mark#(add(X1,X2)) -> mark#(X2)
   mark#(add(X1,X2)) -> mark#(X1)
   mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
   mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
   mark#(dbl(X)) -> mark#(X)
   mark#(dbl(X)) -> dbl#(mark(X))
   mark#(dbl(X)) -> active#(dbl(mark(X)))
   mark#(first(X1,X2)) -> mark#(X2)
   mark#(first(X1,X2)) -> mark#(X1)
   mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
   mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
   mark#(nil()) -> active#(nil())
   terms#(mark(X)) -> terms#(X)
   terms#(active(X)) -> terms#(X)
   cons#(mark(X1),X2) -> cons#(X1,X2)
   cons#(X1,mark(X2)) -> cons#(X1,X2)
   cons#(active(X1),X2) -> cons#(X1,X2)
   cons#(X1,active(X2)) -> cons#(X1,X2)
   recip#(mark(X)) -> recip#(X)
   recip#(active(X)) -> recip#(X)
   sqr#(mark(X)) -> sqr#(X)
   sqr#(active(X)) -> sqr#(X)
   s#(mark(X)) -> s#(X)
   s#(active(X)) -> s#(X)
   add#(mark(X1),X2) -> add#(X1,X2)
   add#(X1,mark(X2)) -> add#(X1,X2)
   add#(active(X1),X2) -> add#(X1,X2)
   add#(X1,active(X2)) -> add#(X1,X2)
   dbl#(mark(X)) -> dbl#(X)
   dbl#(active(X)) -> dbl#(X)
   first#(mark(X1),X2) -> first#(X1,X2)
   first#(X1,mark(X2)) -> first#(X1,X2)
   first#(active(X1),X2) -> first#(X1,X2)
   first#(X1,active(X2)) -> first#(X1,X2)
  TRS:
   active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
   active(sqr(0())) -> mark(0())
   active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
   active(dbl(0())) -> mark(0())
   active(dbl(s(X))) -> mark(s(s(dbl(X))))
   active(add(0(),X)) -> mark(X)
   active(add(s(X),Y)) -> mark(s(add(X,Y)))
   active(first(0(),X)) -> mark(nil())
   active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
   mark(terms(X)) -> active(terms(mark(X)))
   mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
   mark(recip(X)) -> active(recip(mark(X)))
   mark(sqr(X)) -> active(sqr(mark(X)))
   mark(s(X)) -> active(s(mark(X)))
   mark(0()) -> active(0())
   mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
   mark(dbl(X)) -> active(dbl(mark(X)))
   mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
   mark(nil()) -> active(nil())
   terms(mark(X)) -> terms(X)
   terms(active(X)) -> terms(X)
   cons(mark(X1),X2) -> cons(X1,X2)
   cons(X1,mark(X2)) -> cons(X1,X2)
   cons(active(X1),X2) -> cons(X1,X2)
   cons(X1,active(X2)) -> cons(X1,X2)
   recip(mark(X)) -> recip(X)
   recip(active(X)) -> recip(X)
   sqr(mark(X)) -> sqr(X)
   sqr(active(X)) -> sqr(X)
   s(mark(X)) -> s(X)
   s(active(X)) -> s(X)
   add(mark(X1),X2) -> add(X1,X2)
   add(X1,mark(X2)) -> add(X1,X2)
   add(active(X1),X2) -> add(X1,X2)
   add(X1,active(X2)) -> add(X1,X2)
   dbl(mark(X)) -> dbl(X)
   dbl(active(X)) -> dbl(X)
   first(mark(X1),X2) -> first(X1,X2)
   first(X1,mark(X2)) -> first(X1,X2)
   first(active(X1),X2) -> first(X1,X2)
   first(X1,active(X2)) -> first(X1,X2)
  TDG Processor:
   DPs:
    active#(terms(N)) -> s#(N)
    active#(terms(N)) -> terms#(s(N))
    active#(terms(N)) -> sqr#(N)
    active#(terms(N)) -> recip#(sqr(N))
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    active#(sqr(0())) -> mark#(0())
    active#(sqr(s(X))) -> dbl#(X)
    active#(sqr(s(X))) -> sqr#(X)
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    active#(dbl(0())) -> mark#(0())
    active#(dbl(s(X))) -> dbl#(X)
    active#(dbl(s(X))) -> s#(dbl(X))
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    active#(add(0(),X)) -> mark#(X)
    active#(add(s(X),Y)) -> add#(X,Y)
    active#(add(s(X),Y)) -> s#(add(X,Y))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    active#(first(0(),X)) -> mark#(nil())
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(terms(X)) -> mark#(X)
    mark#(terms(X)) -> terms#(mark(X))
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(recip(X)) -> mark#(X)
    mark#(recip(X)) -> recip#(mark(X))
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(sqr(X)) -> mark#(X)
    mark#(sqr(X)) -> sqr#(mark(X))
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(0()) -> active#(0())
    mark#(add(X1,X2)) -> mark#(X2)
    mark#(add(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(dbl(X)) -> mark#(X)
    mark#(dbl(X)) -> dbl#(mark(X))
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(nil()) -> active#(nil())
    terms#(mark(X)) -> terms#(X)
    terms#(active(X)) -> terms#(X)
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2)
    recip#(mark(X)) -> recip#(X)
    recip#(active(X)) -> recip#(X)
    sqr#(mark(X)) -> sqr#(X)
    sqr#(active(X)) -> sqr#(X)
    s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X)
    add#(mark(X1),X2) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2)
    dbl#(mark(X)) -> dbl#(X)
    dbl#(active(X)) -> dbl#(X)
    first#(mark(X1),X2) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2)
   TRS:
    active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
    active(sqr(0())) -> mark(0())
    active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
    active(dbl(0())) -> mark(0())
    active(dbl(s(X))) -> mark(s(s(dbl(X))))
    active(add(0(),X)) -> mark(X)
    active(add(s(X),Y)) -> mark(s(add(X,Y)))
    active(first(0(),X)) -> mark(nil())
    active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
    mark(terms(X)) -> active(terms(mark(X)))
    mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
    mark(recip(X)) -> active(recip(mark(X)))
    mark(sqr(X)) -> active(sqr(mark(X)))
    mark(s(X)) -> active(s(mark(X)))
    mark(0()) -> active(0())
    mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
    mark(dbl(X)) -> active(dbl(mark(X)))
    mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
    mark(nil()) -> active(nil())
    terms(mark(X)) -> terms(X)
    terms(active(X)) -> terms(X)
    cons(mark(X1),X2) -> cons(X1,X2)
    cons(X1,mark(X2)) -> cons(X1,X2)
    cons(active(X1),X2) -> cons(X1,X2)
    cons(X1,active(X2)) -> cons(X1,X2)
    recip(mark(X)) -> recip(X)
    recip(active(X)) -> recip(X)
    sqr(mark(X)) -> sqr(X)
    sqr(active(X)) -> sqr(X)
    s(mark(X)) -> s(X)
    s(active(X)) -> s(X)
    add(mark(X1),X2) -> add(X1,X2)
    add(X1,mark(X2)) -> add(X1,X2)
    add(active(X1),X2) -> add(X1,X2)
    add(X1,active(X2)) -> add(X1,X2)
    dbl(mark(X)) -> dbl(X)
    dbl(active(X)) -> dbl(X)
    first(mark(X1),X2) -> first(X1,X2)
    first(X1,mark(X2)) -> first(X1,X2)
    first(active(X1),X2) -> first(X1,X2)
    first(X1,active(X2)) -> first(X1,X2)
   graph:
    first#(mark(X1),X2) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(mark(X1),X2) -> first#(X1,X2) ->
    first#(active(X1),X2) -> first#(X1,X2)
    first#(mark(X1),X2) -> first#(X1,X2) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    first#(mark(X1),X2) -> first#(X1,X2) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2) ->
    first#(active(X1),X2) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2) ->
    first#(active(X1),X2) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(active(X1),X2) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(active(X1),X2) -> add#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2) ->
    add#(active(X1),X2) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2) ->
    add#(active(X1),X2) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) ->
    add#(active(X1),X2) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) -> add#(mark(X1),X2) -> add#(X1,X2)
    dbl#(mark(X)) -> dbl#(X) -> dbl#(active(X)) -> dbl#(X)
    dbl#(mark(X)) -> dbl#(X) -> dbl#(mark(X)) -> dbl#(X)
    dbl#(active(X)) -> dbl#(X) -> dbl#(active(X)) -> dbl#(X)
    dbl#(active(X)) -> dbl#(X) -> dbl#(mark(X)) -> dbl#(X)
    mark#(nil()) -> active#(nil()) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(nil()) -> active#(nil()) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(nil()) -> active#(nil()) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(nil()) -> active#(nil()) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(nil()) -> active#(nil()) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(nil()) -> active#(nil()) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(nil()) -> active#(nil()) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(nil()) -> active#(nil()) -> active#(add(0(),X)) -> mark#(X)
    mark#(nil()) -> active#(nil()) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(nil()) -> active#(nil()) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(nil()) -> active#(nil()) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(nil()) -> active#(nil()) -> active#(dbl(s(X))) -> dbl#(X)
    mark#(nil()) -> active#(nil()) -> active#(dbl(0())) -> mark#(0())
    mark#(nil()) -> active#(nil()) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(nil()) -> active#(nil()) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(nil()) -> active#(nil()) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(nil()) -> active#(nil()) -> active#(sqr(s(X))) -> sqr#(X)
    mark#(nil()) -> active#(nil()) -> active#(sqr(s(X))) -> dbl#(X)
    mark#(nil()) -> active#(nil()) -> active#(sqr(0())) -> mark#(0())
    mark#(nil()) -> active#(nil()) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(nil()) -> active#(nil()) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(nil()) -> active#(nil()) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(nil()) -> active#(nil()) -> active#(terms(N)) -> sqr#(N)
    mark#(nil()) -> active#(nil()) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(nil()) -> active#(nil()) ->
    active#(terms(N)) -> s#(N)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(active(X1),X2) -> first#(X1,X2)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(nil()) -> active#(nil())
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(dbl(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> mark#(X2)
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(sqr(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(recip(X)) -> recip#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(recip(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> terms#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(terms(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(nil()) -> active#(nil())
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> mark#(X2)
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> recip#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) -> mark#(recip(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> terms#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> mark#(X)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
    active#(terms(N)) -> s#(N)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(active(X1),X2) -> add#(X1,X2)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil())
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(dbl(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(sqr(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(recip(X)) -> recip#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(recip(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> terms#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(terms(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil())
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> recip#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(recip(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> terms#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> mark#(X)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
    active#(terms(N)) -> s#(N)
    mark#(dbl(X)) -> dbl#(mark(X)) -> dbl#(active(X)) -> dbl#(X)
    mark#(dbl(X)) -> dbl#(mark(X)) -> dbl#(mark(X)) -> dbl#(X)
    mark#(dbl(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
    mark#(dbl(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(dbl(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(dbl(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
    mark#(dbl(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
    mark#(dbl(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    mark#(dbl(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(dbl(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(dbl(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(dbl(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(dbl(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    mark#(dbl(X)) -> mark#(X) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(recip(X)) -> recip#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    mark#(dbl(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(dbl(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(dbl(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(dbl(X)) -> mark#(X) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(dbl(X)) -> active#(dbl(mark(X))) -> active#(terms(N)) -> s#(N)
    mark#(0()) -> active#(0()) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(0()) -> active#(0()) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(0()) -> active#(0()) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(0()) -> active#(0()) -> active#(first(0(),X)) -> mark#(nil())
    mark#(0()) -> active#(0()) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(0()) -> active#(0()) -> active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(0()) -> active#(0()) -> active#(add(s(X),Y)) -> add#(X,Y)
    mark#(0()) -> active#(0()) -> active#(add(0(),X)) -> mark#(X)
    mark#(0()) -> active#(0()) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(0()) -> active#(0()) -> active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(0()) -> active#(0()) -> active#(dbl(s(X))) -> s#(dbl(X))
    mark#(0()) -> active#(0()) -> active#(dbl(s(X))) -> dbl#(X)
    mark#(0()) -> active#(0()) -> active#(dbl(0())) -> mark#(0())
    mark#(0()) -> active#(0()) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(0()) -> active#(0()) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(0()) -> active#(0()) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(0()) -> active#(0()) -> active#(sqr(s(X))) -> sqr#(X)
    mark#(0()) -> active#(0()) -> active#(sqr(s(X))) -> dbl#(X)
    mark#(0()) -> active#(0()) -> active#(sqr(0())) -> mark#(0())
    mark#(0()) -> active#(0()) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(0()) -> active#(0()) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(0()) -> active#(0()) -> active#(terms(N)) -> recip#(sqr(N))
    mark#(0()) -> active#(0()) -> active#(terms(N)) -> sqr#(N)
    mark#(0()) -> active#(0()) -> active#(terms(N)) -> terms#(s(N))
    mark#(0()) -> active#(0()) -> active#(terms(N)) -> s#(N)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(nil()) -> active#(nil())
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(first(X1,X2)) -> mark#(X2)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(add(X1,X2)) -> mark#(X2)
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(recip(X)) -> recip#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(recip(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> terms#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(terms(X)) -> mark#(X)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(0())) -> mark#(0())
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(0())) -> mark#(0())
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> sqr#(N)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> s#(N)
    mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
    mark#(s(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(s(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(s(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
    mark#(s(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(s(X)) -> mark#(X) -> mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(s(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) -> mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(recip(X)) -> recip#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
    mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(s(X)) -> active#(s(mark(X))) -> active#(terms(N)) -> s#(N)
    mark#(recip(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
    mark#(recip(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(recip(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(recip(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
    mark#(recip(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
    mark#(recip(X)) -> mark#(X) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(recip(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    mark#(recip(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(recip(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(recip(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(recip(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(recip(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(recip(X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(recip(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    mark#(recip(X)) -> mark#(X) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(recip(X)) -> recip#(mark(X))
    mark#(recip(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    mark#(recip(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(recip(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(recip(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(recip(X)) -> mark#(X) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(mark(X))
    mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(recip(X)) -> recip#(mark(X)) ->
    recip#(active(X)) -> recip#(X)
    mark#(recip(X)) -> recip#(mark(X)) ->
    recip#(mark(X)) -> recip#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> s#(N)
    mark#(sqr(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
    mark#(sqr(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(sqr(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(sqr(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
    mark#(sqr(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
    mark#(sqr(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    mark#(sqr(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(sqr(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(sqr(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(sqr(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(sqr(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    mark#(sqr(X)) -> mark#(X) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(recip(X)) -> recip#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    mark#(sqr(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(sqr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(sqr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(sqr(X)) -> mark#(X) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(sqr(X)) -> sqr#(mark(X)) -> sqr#(active(X)) -> sqr#(X)
    mark#(sqr(X)) -> sqr#(mark(X)) ->
    sqr#(mark(X)) -> sqr#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(sqr(X)) -> active#(sqr(mark(X))) -> active#(terms(N)) -> s#(N)
    mark#(terms(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
    mark#(terms(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    mark#(terms(X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    mark#(terms(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
    mark#(terms(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
    mark#(terms(X)) -> mark#(X) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(dbl(X)) -> dbl#(mark(X))
    mark#(terms(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    mark#(terms(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    mark#(terms(X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    mark#(terms(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
    mark#(terms(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
    mark#(terms(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(terms(X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(sqr(X)) -> sqr#(mark(X))
    mark#(terms(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    mark#(terms(X)) -> mark#(X) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(recip(X)) -> recip#(mark(X))
    mark#(terms(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    mark#(terms(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(terms(X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(terms(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
    mark#(terms(X)) -> mark#(X) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(mark(X))
    mark#(terms(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(terms(X)) -> terms#(mark(X)) ->
    terms#(active(X)) -> terms#(X)
    mark#(terms(X)) -> terms#(mark(X)) ->
    terms#(mark(X)) -> terms#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(first(0(),X)) -> mark#(nil())
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(add(s(X),Y)) -> s#(add(X,Y))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(add(s(X),Y)) -> add#(X,Y)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(add(0(),X)) -> mark#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(dbl(s(X))) -> s#(s(dbl(X)))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(dbl(s(X))) -> s#(dbl(X))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(dbl(s(X))) -> dbl#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(dbl(0())) -> mark#(0())
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X)))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(s(X))) -> sqr#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(s(X))) -> dbl#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(sqr(0())) -> mark#(0())
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N)))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(N))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> s#(N)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    recip#(mark(X)) -> recip#(X) -> recip#(active(X)) -> recip#(X)
    recip#(mark(X)) -> recip#(X) -> recip#(mark(X)) -> recip#(X)
    recip#(active(X)) -> recip#(X) -> recip#(active(X)) -> recip#(X)
    recip#(active(X)) -> recip#(X) -> recip#(mark(X)) -> recip#(X)
    sqr#(mark(X)) -> sqr#(X) -> sqr#(active(X)) -> sqr#(X)
    sqr#(mark(X)) -> sqr#(X) -> sqr#(mark(X)) -> sqr#(X)
    sqr#(active(X)) -> sqr#(X) -> sqr#(active(X)) -> sqr#(X)
    sqr#(active(X)) -> sqr#(X) -> sqr#(mark(X)) -> sqr#(X)
    terms#(mark(X)) -> terms#(X) -> terms#(active(X)) -> terms#(X)
    terms#(mark(X)) -> terms#(X) -> terms#(mark(X)) -> terms#(X)
    terms#(active(X)) -> terms#(X) -> terms#(active(X)) -> terms#(X)
    terms#(active(X)) -> terms#(X) -> terms#(mark(X)) -> terms#(X)
    s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(nil()) -> active#(nil())
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(dbl(X)) -> mark#(X)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(0()) -> active#(0())
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(s(X)) -> s#(mark(X))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(s(X)) -> mark#(X)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(sqr(X)) -> mark#(X)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(recip(X)) -> mark#(X)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(first(0(),X)) -> mark#(nil()) ->
    mark#(terms(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z) ->
    first#(active(X1),X2) -> first#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z) ->
    first#(X1,mark(X2)) -> first#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> first#(X,Z) ->
    first#(mark(X1),X2) -> first#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(nil()) -> active#(nil())
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(dbl(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(0()) -> active#(0())
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(s(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(sqr(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(recip(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(terms(X)) -> mark#(X)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z)) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z)) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z)) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z)) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(nil()) -> active#(nil())
    active#(add(0(),X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(add(0(),X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(add(0(),X)) -> mark#(X) -> mark#(0()) -> active#(0())
    active#(add(0(),X)) -> mark#(X) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(add(0(),X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    active#(add(0(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(add(0(),X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(add(0(),X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(add(0(),X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    active#(add(s(X),Y)) -> add#(X,Y) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    active#(add(s(X),Y)) -> add#(X,Y) ->
    add#(active(X1),X2) -> add#(X1,X2)
    active#(add(s(X),Y)) -> add#(X,Y) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    active#(add(s(X),Y)) -> add#(X,Y) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(nil()) -> active#(nil())
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(dbl(X)) -> mark#(X)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(0()) -> active#(0())
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(s(X)) -> mark#(X)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(sqr(X)) -> mark#(X)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(recip(X)) -> mark#(X)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
    mark#(terms(X)) -> mark#(X)
    active#(add(s(X),Y)) -> s#(add(X,Y)) ->
    s#(active(X)) -> s#(X)
    active#(add(s(X),Y)) -> s#(add(X,Y)) -> s#(mark(X)) -> s#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(nil()) -> active#(nil())
    active#(dbl(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(dbl(0())) -> mark#(0()) -> mark#(dbl(X)) -> mark#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(dbl(0())) -> mark#(0()) -> mark#(0()) -> active#(0())
    active#(dbl(0())) -> mark#(0()) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(dbl(0())) -> mark#(0()) -> mark#(s(X)) -> s#(mark(X))
    active#(dbl(0())) -> mark#(0()) -> mark#(s(X)) -> mark#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(dbl(0())) -> mark#(0()) -> mark#(sqr(X)) -> mark#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(dbl(0())) -> mark#(0()) -> mark#(recip(X)) -> mark#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(dbl(0())) -> mark#(0()) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(dbl(0())) -> mark#(0()) -> mark#(terms(X)) -> mark#(X)
    active#(dbl(s(X))) -> dbl#(X) -> dbl#(active(X)) -> dbl#(X)
    active#(dbl(s(X))) -> dbl#(X) ->
    dbl#(mark(X)) -> dbl#(X)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(nil()) -> active#(nil())
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(dbl(X)) -> mark#(X)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(0()) -> active#(0())
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(s(X)) -> mark#(X)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(sqr(X)) -> mark#(X)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(recip(X)) -> mark#(X)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(terms(X)) -> mark#(X)
    active#(dbl(s(X))) -> s#(dbl(X)) -> s#(active(X)) -> s#(X)
    active#(dbl(s(X))) -> s#(dbl(X)) -> s#(mark(X)) -> s#(X)
    active#(dbl(s(X))) -> s#(s(dbl(X))) ->
    s#(active(X)) -> s#(X)
    active#(dbl(s(X))) -> s#(s(dbl(X))) -> s#(mark(X)) -> s#(X)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(nil()) -> active#(nil())
    active#(sqr(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(sqr(0())) -> mark#(0()) -> mark#(dbl(X)) -> mark#(X)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(sqr(0())) -> mark#(0()) -> mark#(0()) -> active#(0())
    active#(sqr(0())) -> mark#(0()) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(sqr(0())) -> mark#(0()) -> mark#(s(X)) -> s#(mark(X))
    active#(sqr(0())) -> mark#(0()) -> mark#(s(X)) -> mark#(X)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(sqr(0())) -> mark#(0()) -> mark#(sqr(X)) -> mark#(X)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(sqr(0())) -> mark#(0()) -> mark#(recip(X)) -> mark#(X)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(sqr(0())) -> mark#(0()) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(sqr(0())) -> mark#(0()) ->
    mark#(terms(X)) -> mark#(X)
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X)) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X)) ->
    add#(active(X1),X2) -> add#(X1,X2)
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X)) ->
    add#(X1,mark(X2)) -> add#(X1,X2)
    active#(sqr(s(X))) -> add#(sqr(X),dbl(X)) ->
    add#(mark(X1),X2) -> add#(X1,X2)
    active#(sqr(s(X))) -> dbl#(X) -> dbl#(active(X)) -> dbl#(X)
    active#(sqr(s(X))) -> dbl#(X) ->
    dbl#(mark(X)) -> dbl#(X)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(nil()) -> active#(nil())
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(dbl(X)) -> mark#(X)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(0()) -> active#(0())
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(s(X)) -> mark#(X)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(sqr(X)) -> mark#(X)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(recip(X)) -> mark#(X)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
    mark#(terms(X)) -> mark#(X)
    active#(sqr(s(X))) -> sqr#(X) -> sqr#(active(X)) -> sqr#(X)
    active#(sqr(s(X))) -> sqr#(X) ->
    sqr#(mark(X)) -> sqr#(X)
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X))) ->
    s#(active(X)) -> s#(X)
    active#(sqr(s(X))) -> s#(add(sqr(X),dbl(X))) ->
    s#(mark(X)) -> s#(X)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(nil()) -> active#(nil())
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(first(X1,X2)) -> mark#(X1)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(first(X1,X2)) -> mark#(X2)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(dbl(X)) -> active#(dbl(mark(X)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(dbl(X)) -> dbl#(mark(X))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(dbl(X)) -> mark#(X)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(add(X1,X2)) -> mark#(X1)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(add(X1,X2)) -> mark#(X2)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(0()) -> active#(0())
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(s(X)) -> mark#(X)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(sqr(X)) -> sqr#(mark(X))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(sqr(X)) -> mark#(X)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(recip(X)) -> active#(recip(mark(X)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(recip(X)) -> recip#(mark(X))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(recip(X)) -> mark#(X)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(cons(X1,X2)) -> mark#(X1)
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(terms(X)) -> active#(terms(mark(X)))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(terms(X)) -> terms#(mark(X))
    active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
    mark#(terms(X)) -> mark#(X)
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N))) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N))) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N))) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N))) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(terms(N)) -> recip#(sqr(N)) ->
    recip#(active(X)) -> recip#(X)
    active#(terms(N)) -> recip#(sqr(N)) -> recip#(mark(X)) -> recip#(X)
    active#(terms(N)) -> sqr#(N) -> sqr#(active(X)) -> sqr#(X)
    active#(terms(N)) -> sqr#(N) -> sqr#(mark(X)) -> sqr#(X)
    active#(terms(N)) -> terms#(s(N)) ->
    terms#(active(X)) -> terms#(X)
    active#(terms(N)) -> terms#(s(N)) -> terms#(mark(X)) -> terms#(X)
    active#(terms(N)) -> s#(N) -> s#(active(X)) -> s#(X)
    active#(terms(N)) -> s#(N) -> s#(mark(X)) -> s#(X)
   SCC Processor:
    #sccs: 9
    #rules: 51
    #arcs: 914/5625
    DPs:
     mark#(nil()) -> active#(nil())
     active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
     mark#(terms(X)) -> mark#(X)
     mark#(terms(X)) -> active#(terms(mark(X)))
     active#(sqr(0())) -> mark#(0())
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
     mark#(recip(X)) -> mark#(X)
     mark#(recip(X)) -> active#(recip(mark(X)))
     active#(dbl(0())) -> mark#(0())
     mark#(sqr(X)) -> mark#(X)
     mark#(sqr(X)) -> active#(sqr(mark(X)))
     active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
     mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> active#(s(mark(X)))
     active#(add(0(),X)) -> mark#(X)
     mark#(0()) -> active#(0())
     active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
     mark#(add(X1,X2)) -> mark#(X2)
     mark#(add(X1,X2)) -> mark#(X1)
     mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
     active#(first(0(),X)) -> mark#(nil())
     mark#(dbl(X)) -> mark#(X)
     mark#(dbl(X)) -> active#(dbl(mark(X)))
     active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
     mark#(first(X1,X2)) -> mark#(X2)
     mark#(first(X1,X2)) -> mark#(X1)
     mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    EDG Processor:
     DPs:
      mark#(nil()) -> active#(nil())
      active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      mark#(terms(X)) -> mark#(X)
      mark#(terms(X)) -> active#(terms(mark(X)))
      active#(sqr(0())) -> mark#(0())
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
      mark#(recip(X)) -> mark#(X)
      mark#(recip(X)) -> active#(recip(mark(X)))
      active#(dbl(0())) -> mark#(0())
      mark#(sqr(X)) -> mark#(X)
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> active#(s(mark(X)))
      active#(add(0(),X)) -> mark#(X)
      mark#(0()) -> active#(0())
      active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      active#(first(0(),X)) -> mark#(nil())
      mark#(dbl(X)) -> mark#(X)
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
     TRS:
      active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
      active(sqr(0())) -> mark(0())
      active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
      active(dbl(0())) -> mark(0())
      active(dbl(s(X))) -> mark(s(s(dbl(X))))
      active(add(0(),X)) -> mark(X)
      active(add(s(X),Y)) -> mark(s(add(X,Y)))
      active(first(0(),X)) -> mark(nil())
      active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
      mark(terms(X)) -> active(terms(mark(X)))
      mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
      mark(recip(X)) -> active(recip(mark(X)))
      mark(sqr(X)) -> active(sqr(mark(X)))
      mark(s(X)) -> active(s(mark(X)))
      mark(0()) -> active(0())
      mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
      mark(dbl(X)) -> active(dbl(mark(X)))
      mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
      mark(nil()) -> active(nil())
      terms(mark(X)) -> terms(X)
      terms(active(X)) -> terms(X)
      cons(mark(X1),X2) -> cons(X1,X2)
      cons(X1,mark(X2)) -> cons(X1,X2)
      cons(active(X1),X2) -> cons(X1,X2)
      cons(X1,active(X2)) -> cons(X1,X2)
      recip(mark(X)) -> recip(X)
      recip(active(X)) -> recip(X)
      sqr(mark(X)) -> sqr(X)
      sqr(active(X)) -> sqr(X)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      add(mark(X1),X2) -> add(X1,X2)
      add(X1,mark(X2)) -> add(X1,X2)
      add(active(X1),X2) -> add(X1,X2)
      add(X1,active(X2)) -> add(X1,X2)
      dbl(mark(X)) -> dbl(X)
      dbl(active(X)) -> dbl(X)
      first(mark(X1),X2) -> first(X1,X2)
      first(X1,mark(X2)) -> first(X1,X2)
      first(active(X1),X2) -> first(X1,X2)
      first(X1,active(X2)) -> first(X1,X2)
     graph:
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(terms(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(recip(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(first(X1,X2)) -> mark#(X2) -> mark#(sqr(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(first(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(0()) -> active#(0())
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(first(X1,X2)) -> mark#(X2) -> mark#(dbl(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(first(X1,X2)) -> mark#(X2) ->
      mark#(nil()) -> active#(nil())
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(terms(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(recip(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(first(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(first(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(first(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(first(X1,X2)) -> mark#(X1) ->
      mark#(nil()) -> active#(nil())
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
      active#(first(0(),X)) -> mark#(nil())
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(terms(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(recip(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(sqr(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(add(X1,X2)) -> mark#(X2) -> mark#(dbl(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(add(X1,X2)) -> mark#(X2) ->
      mark#(nil()) -> active#(nil())
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(terms(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(recip(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(add(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(add(X1,X2)) -> mark#(X1) ->
      mark#(nil()) -> active#(nil())
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
      active#(add(0(),X)) -> mark#(X)
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
      active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
      mark#(dbl(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      mark#(dbl(X)) -> mark#(X) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(dbl(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(dbl(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(dbl(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      mark#(dbl(X)) -> mark#(X) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(dbl(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(dbl(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
      mark#(dbl(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
      mark#(dbl(X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(dbl(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      mark#(dbl(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(dbl(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
      mark#(dbl(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
      mark#(dbl(X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(dbl(X)) -> mark#(X) ->
      mark#(nil()) -> active#(nil())
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(dbl(0())) -> mark#(0())
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(terms(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(recip(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(sqr(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X2)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(dbl(X)) -> mark#(X)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X2)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> mark#(X1) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil())
      mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(s(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(s(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
      mark#(s(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(s(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
      mark#(s(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
      mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      mark#(recip(X)) -> mark#(X) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(recip(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(recip(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(recip(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      mark#(recip(X)) -> mark#(X) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(recip(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      mark#(recip(X)) -> mark#(X) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(recip(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(recip(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
      mark#(recip(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
      mark#(recip(X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(recip(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      mark#(recip(X)) -> mark#(X) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(recip(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
      mark#(recip(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
      mark#(recip(X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(recip(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
      mark#(sqr(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      mark#(sqr(X)) -> mark#(X) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(sqr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(sqr(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(sqr(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      mark#(sqr(X)) -> mark#(X) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(sqr(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(sqr(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
      mark#(sqr(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
      mark#(sqr(X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(sqr(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      mark#(sqr(X)) -> mark#(X) -> mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(sqr(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
      mark#(sqr(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
      mark#(sqr(X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(sqr(X)) -> mark#(X) ->
      mark#(nil()) -> active#(nil())
      mark#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(sqr(0())) -> mark#(0())
      mark#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
      mark#(terms(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      mark#(terms(X)) -> mark#(X) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      mark#(terms(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
      mark#(terms(X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(terms(X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      mark#(terms(X)) -> mark#(X) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      mark#(terms(X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      mark#(terms(X)) -> mark#(X) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(terms(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(terms(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X2)
      mark#(terms(X)) -> mark#(X) -> mark#(add(X1,X2)) -> mark#(X1)
      mark#(terms(X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      mark#(terms(X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      mark#(terms(X)) -> mark#(X) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      mark#(terms(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X2)
      mark#(terms(X)) -> mark#(X) -> mark#(first(X1,X2)) -> mark#(X1)
      mark#(terms(X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      mark#(terms(X)) -> mark#(X) ->
      mark#(nil()) -> active#(nil())
      mark#(terms(X)) -> active#(terms(mark(X))) ->
      active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      active#(first(0(),X)) -> mark#(nil()) ->
      mark#(nil()) -> active#(nil())
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(add(0(),X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(terms(X)) -> active#(terms(mark(X)))
      active#(add(0(),X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      active#(add(0(),X)) -> mark#(X) -> mark#(recip(X)) -> mark#(X)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(recip(X)) -> active#(recip(mark(X)))
      active#(add(0(),X)) -> mark#(X) -> mark#(sqr(X)) -> mark#(X)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(sqr(X)) -> active#(sqr(mark(X)))
      active#(add(0(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(add(0(),X)) -> mark#(X) -> mark#(0()) -> active#(0())
      active#(add(0(),X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> mark#(X2)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> mark#(X1)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
      active#(add(0(),X)) -> mark#(X) -> mark#(dbl(X)) -> mark#(X)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(dbl(X)) -> active#(dbl(mark(X)))
      active#(add(0(),X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> mark#(X2)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> mark#(X1)
      active#(add(0(),X)) -> mark#(X) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      active#(add(0(),X)) -> mark#(X) ->
      mark#(nil()) -> active#(nil())
      active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
      mark#(s(X)) -> mark#(X)
      active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(dbl(0())) -> mark#(0()) ->
      mark#(0()) -> active#(0())
      active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
      mark#(s(X)) -> mark#(X)
      active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(sqr(0())) -> mark#(0()) ->
      mark#(0()) -> active#(0())
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
      mark#(s(X)) -> mark#(X)
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
      mark#(cons(X1,X2)) -> mark#(X1)
      active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     SCC Processor:
      #sccs: 1
      #rules: 21
      #arcs: 242/841
      DPs:
       mark#(first(X1,X2)) -> mark#(X2)
       mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
       active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
       mark#(cons(X1,X2)) -> mark#(X1)
       mark#(first(X1,X2)) -> mark#(X1)
       mark#(dbl(X)) -> active#(dbl(mark(X)))
       active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
       mark#(s(X)) -> mark#(X)
       mark#(dbl(X)) -> mark#(X)
       mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
       active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
       active#(add(0(),X)) -> mark#(X)
       mark#(add(X1,X2)) -> mark#(X1)
       mark#(add(X1,X2)) -> mark#(X2)
       mark#(sqr(X)) -> active#(sqr(mark(X)))
       active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
       mark#(sqr(X)) -> mark#(X)
       mark#(recip(X)) -> mark#(X)
       mark#(terms(X)) -> active#(terms(mark(X)))
       active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
       mark#(terms(X)) -> mark#(X)
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
      LPO Processor:
       argument filtering:
        pi(terms) = [0]
        pi(active) = 0
        pi(sqr) = [0]
        pi(recip) = 0
        pi(s) = [0]
        pi(cons) = [0]
        pi(mark) = 0
        pi(0) = []
        pi(dbl) = [0]
        pi(add) = [0,1]
        pi(first) = [0,1]
        pi(nil) = []
        pi(active#) = 0
        pi(mark#) = 0
       usable rules:
        active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
        active(sqr(0())) -> mark(0())
        active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
        active(dbl(0())) -> mark(0())
        active(dbl(s(X))) -> mark(s(s(dbl(X))))
        active(add(0(),X)) -> mark(X)
        active(add(s(X),Y)) -> mark(s(add(X,Y)))
        active(first(0(),X)) -> mark(nil())
        active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
        mark(terms(X)) -> active(terms(mark(X)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(recip(X)) -> active(recip(mark(X)))
        mark(sqr(X)) -> active(sqr(mark(X)))
        mark(s(X)) -> active(s(mark(X)))
        mark(0()) -> active(0())
        mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
        mark(dbl(X)) -> active(dbl(mark(X)))
        mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
        mark(nil()) -> active(nil())
        terms(mark(X)) -> terms(X)
        terms(active(X)) -> terms(X)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        recip(mark(X)) -> recip(X)
        recip(active(X)) -> recip(X)
        sqr(mark(X)) -> sqr(X)
        sqr(active(X)) -> sqr(X)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        add(mark(X1),X2) -> add(X1,X2)
        add(X1,mark(X2)) -> add(X1,X2)
        add(active(X1),X2) -> add(X1,X2)
        add(X1,active(X2)) -> add(X1,X2)
        dbl(mark(X)) -> dbl(X)
        dbl(active(X)) -> dbl(X)
        first(mark(X1),X2) -> first(X1,X2)
        first(X1,mark(X2)) -> first(X1,X2)
        first(active(X1),X2) -> first(X1,X2)
        first(X1,active(X2)) -> first(X1,X2)
       precedence:
        first > terms > sqr > add ~ dbl > mark# ~ active# ~ nil ~ 0 ~ 
        mark ~ cons ~ s ~ recip ~ active
       problem:
        DPs:
         mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
         mark#(dbl(X)) -> active#(dbl(mark(X)))
         mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
         mark#(sqr(X)) -> active#(sqr(mark(X)))
         mark#(recip(X)) -> mark#(X)
         mark#(terms(X)) -> active#(terms(mark(X)))
        TRS:
         active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
         active(sqr(0())) -> mark(0())
         active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
         active(dbl(0())) -> mark(0())
         active(dbl(s(X))) -> mark(s(s(dbl(X))))
         active(add(0(),X)) -> mark(X)
         active(add(s(X),Y)) -> mark(s(add(X,Y)))
         active(first(0(),X)) -> mark(nil())
         active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
         mark(terms(X)) -> active(terms(mark(X)))
         mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
         mark(recip(X)) -> active(recip(mark(X)))
         mark(sqr(X)) -> active(sqr(mark(X)))
         mark(s(X)) -> active(s(mark(X)))
         mark(0()) -> active(0())
         mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
         mark(dbl(X)) -> active(dbl(mark(X)))
         mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
         mark(nil()) -> active(nil())
         terms(mark(X)) -> terms(X)
         terms(active(X)) -> terms(X)
         cons(mark(X1),X2) -> cons(X1,X2)
         cons(X1,mark(X2)) -> cons(X1,X2)
         cons(active(X1),X2) -> cons(X1,X2)
         cons(X1,active(X2)) -> cons(X1,X2)
         recip(mark(X)) -> recip(X)
         recip(active(X)) -> recip(X)
         sqr(mark(X)) -> sqr(X)
         sqr(active(X)) -> sqr(X)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         add(mark(X1),X2) -> add(X1,X2)
         add(X1,mark(X2)) -> add(X1,X2)
         add(active(X1),X2) -> add(X1,X2)
         add(X1,active(X2)) -> add(X1,X2)
         dbl(mark(X)) -> dbl(X)
         dbl(active(X)) -> dbl(X)
         first(mark(X1),X2) -> first(X1,X2)
         first(X1,mark(X2)) -> first(X1,X2)
         first(active(X1),X2) -> first(X1,X2)
         first(X1,active(X2)) -> first(X1,X2)
       Restore Modifier:
        DPs:
         mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
         mark#(dbl(X)) -> active#(dbl(mark(X)))
         mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
         mark#(sqr(X)) -> active#(sqr(mark(X)))
         mark#(recip(X)) -> mark#(X)
         mark#(terms(X)) -> active#(terms(mark(X)))
        TRS:
         active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
         active(sqr(0())) -> mark(0())
         active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
         active(dbl(0())) -> mark(0())
         active(dbl(s(X))) -> mark(s(s(dbl(X))))
         active(add(0(),X)) -> mark(X)
         active(add(s(X),Y)) -> mark(s(add(X,Y)))
         active(first(0(),X)) -> mark(nil())
         active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
         mark(terms(X)) -> active(terms(mark(X)))
         mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
         mark(recip(X)) -> active(recip(mark(X)))
         mark(sqr(X)) -> active(sqr(mark(X)))
         mark(s(X)) -> active(s(mark(X)))
         mark(0()) -> active(0())
         mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
         mark(dbl(X)) -> active(dbl(mark(X)))
         mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
         mark(nil()) -> active(nil())
         terms(mark(X)) -> terms(X)
         terms(active(X)) -> terms(X)
         cons(mark(X1),X2) -> cons(X1,X2)
         cons(X1,mark(X2)) -> cons(X1,X2)
         cons(active(X1),X2) -> cons(X1,X2)
         cons(X1,active(X2)) -> cons(X1,X2)
         recip(mark(X)) -> recip(X)
         recip(active(X)) -> recip(X)
         sqr(mark(X)) -> sqr(X)
         sqr(active(X)) -> sqr(X)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         add(mark(X1),X2) -> add(X1,X2)
         add(X1,mark(X2)) -> add(X1,X2)
         add(active(X1),X2) -> add(X1,X2)
         add(X1,active(X2)) -> add(X1,X2)
         dbl(mark(X)) -> dbl(X)
         dbl(active(X)) -> dbl(X)
         first(mark(X1),X2) -> first(X1,X2)
         first(X1,mark(X2)) -> first(X1,X2)
         first(active(X1),X2) -> first(X1,X2)
         first(X1,active(X2)) -> first(X1,X2)
        SCC Processor:
         #sccs: 1
         #rules: 1
         #arcs: 176/36
         DPs:
          mark#(recip(X)) -> mark#(X)
         TRS:
          active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
          active(sqr(0())) -> mark(0())
          active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
          active(dbl(0())) -> mark(0())
          active(dbl(s(X))) -> mark(s(s(dbl(X))))
          active(add(0(),X)) -> mark(X)
          active(add(s(X),Y)) -> mark(s(add(X,Y)))
          active(first(0(),X)) -> mark(nil())
          active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
          mark(terms(X)) -> active(terms(mark(X)))
          mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
          mark(recip(X)) -> active(recip(mark(X)))
          mark(sqr(X)) -> active(sqr(mark(X)))
          mark(s(X)) -> active(s(mark(X)))
          mark(0()) -> active(0())
          mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
          mark(dbl(X)) -> active(dbl(mark(X)))
          mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
          mark(nil()) -> active(nil())
          terms(mark(X)) -> terms(X)
          terms(active(X)) -> terms(X)
          cons(mark(X1),X2) -> cons(X1,X2)
          cons(X1,mark(X2)) -> cons(X1,X2)
          cons(active(X1),X2) -> cons(X1,X2)
          cons(X1,active(X2)) -> cons(X1,X2)
          recip(mark(X)) -> recip(X)
          recip(active(X)) -> recip(X)
          sqr(mark(X)) -> sqr(X)
          sqr(active(X)) -> sqr(X)
          s(mark(X)) -> s(X)
          s(active(X)) -> s(X)
          add(mark(X1),X2) -> add(X1,X2)
          add(X1,mark(X2)) -> add(X1,X2)
          add(active(X1),X2) -> add(X1,X2)
          add(X1,active(X2)) -> add(X1,X2)
          dbl(mark(X)) -> dbl(X)
          dbl(active(X)) -> dbl(X)
          first(mark(X1),X2) -> first(X1,X2)
          first(X1,mark(X2)) -> first(X1,X2)
          first(active(X1),X2) -> first(X1,X2)
          first(X1,active(X2)) -> first(X1,X2)
         Size-Change Termination Processor:
          DPs:
           
          TRS:
           active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
           active(sqr(0())) -> mark(0())
           active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
           active(dbl(0())) -> mark(0())
           active(dbl(s(X))) -> mark(s(s(dbl(X))))
           active(add(0(),X)) -> mark(X)
           active(add(s(X),Y)) -> mark(s(add(X,Y)))
           active(first(0(),X)) -> mark(nil())
           active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
           mark(terms(X)) -> active(terms(mark(X)))
           mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
           mark(recip(X)) -> active(recip(mark(X)))
           mark(sqr(X)) -> active(sqr(mark(X)))
           mark(s(X)) -> active(s(mark(X)))
           mark(0()) -> active(0())
           mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
           mark(dbl(X)) -> active(dbl(mark(X)))
           mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
           mark(nil()) -> active(nil())
           terms(mark(X)) -> terms(X)
           terms(active(X)) -> terms(X)
           cons(mark(X1),X2) -> cons(X1,X2)
           cons(X1,mark(X2)) -> cons(X1,X2)
           cons(active(X1),X2) -> cons(X1,X2)
           cons(X1,active(X2)) -> cons(X1,X2)
           recip(mark(X)) -> recip(X)
           recip(active(X)) -> recip(X)
           sqr(mark(X)) -> sqr(X)
           sqr(active(X)) -> sqr(X)
           s(mark(X)) -> s(X)
           s(active(X)) -> s(X)
           add(mark(X1),X2) -> add(X1,X2)
           add(X1,mark(X2)) -> add(X1,X2)
           add(active(X1),X2) -> add(X1,X2)
           add(X1,active(X2)) -> add(X1,X2)
           dbl(mark(X)) -> dbl(X)
           dbl(active(X)) -> dbl(X)
           first(mark(X1),X2) -> first(X1,X2)
           first(X1,mark(X2)) -> first(X1,X2)
           first(active(X1),X2) -> first(X1,X2)
           first(X1,active(X2)) -> first(X1,X2)
          The DP: mark#(recip(X)) -> mark#(X) has the edges:
            0 >   0
          Qed
    
    DPs:
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(cons#) = 0
     problem:
      DPs:
       cons#(X1,mark(X2)) -> cons#(X1,X2)
       cons#(X1,active(X2)) -> cons#(X1,X2)
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Subterm Criterion Processor:
      simple projection:
       pi(cons#) = 1
      problem:
       DPs:
        
       TRS:
        active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
        active(sqr(0())) -> mark(0())
        active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
        active(dbl(0())) -> mark(0())
        active(dbl(s(X))) -> mark(s(s(dbl(X))))
        active(add(0(),X)) -> mark(X)
        active(add(s(X),Y)) -> mark(s(add(X,Y)))
        active(first(0(),X)) -> mark(nil())
        active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
        mark(terms(X)) -> active(terms(mark(X)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(recip(X)) -> active(recip(mark(X)))
        mark(sqr(X)) -> active(sqr(mark(X)))
        mark(s(X)) -> active(s(mark(X)))
        mark(0()) -> active(0())
        mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
        mark(dbl(X)) -> active(dbl(mark(X)))
        mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
        mark(nil()) -> active(nil())
        terms(mark(X)) -> terms(X)
        terms(active(X)) -> terms(X)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        recip(mark(X)) -> recip(X)
        recip(active(X)) -> recip(X)
        sqr(mark(X)) -> sqr(X)
        sqr(active(X)) -> sqr(X)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        add(mark(X1),X2) -> add(X1,X2)
        add(X1,mark(X2)) -> add(X1,X2)
        add(active(X1),X2) -> add(X1,X2)
        add(X1,active(X2)) -> add(X1,X2)
        dbl(mark(X)) -> dbl(X)
        dbl(active(X)) -> dbl(X)
        first(mark(X1),X2) -> first(X1,X2)
        first(X1,mark(X2)) -> first(X1,X2)
        first(active(X1),X2) -> first(X1,X2)
        first(X1,active(X2)) -> first(X1,X2)
      Qed
    
    DPs:
     recip#(mark(X)) -> recip#(X)
     recip#(active(X)) -> recip#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(recip#) = 0
     problem:
      DPs:
       
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Qed
    
    DPs:
     sqr#(mark(X)) -> sqr#(X)
     sqr#(active(X)) -> sqr#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(sqr#) = 0
     problem:
      DPs:
       
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Qed
    
    DPs:
     terms#(mark(X)) -> terms#(X)
     terms#(active(X)) -> terms#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(terms#) = 0
     problem:
      DPs:
       
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Qed
    
    DPs:
     s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(s#) = 0
     problem:
      DPs:
       
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Qed
    
    DPs:
     dbl#(mark(X)) -> dbl#(X)
     dbl#(active(X)) -> dbl#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(dbl#) = 0
     problem:
      DPs:
       
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Qed
    
    DPs:
     add#(mark(X1),X2) -> add#(X1,X2)
     add#(X1,mark(X2)) -> add#(X1,X2)
     add#(active(X1),X2) -> add#(X1,X2)
     add#(X1,active(X2)) -> add#(X1,X2)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(add#) = 0
     problem:
      DPs:
       add#(X1,mark(X2)) -> add#(X1,X2)
       add#(X1,active(X2)) -> add#(X1,X2)
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Subterm Criterion Processor:
      simple projection:
       pi(add#) = 1
      problem:
       DPs:
        
       TRS:
        active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
        active(sqr(0())) -> mark(0())
        active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
        active(dbl(0())) -> mark(0())
        active(dbl(s(X))) -> mark(s(s(dbl(X))))
        active(add(0(),X)) -> mark(X)
        active(add(s(X),Y)) -> mark(s(add(X,Y)))
        active(first(0(),X)) -> mark(nil())
        active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
        mark(terms(X)) -> active(terms(mark(X)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(recip(X)) -> active(recip(mark(X)))
        mark(sqr(X)) -> active(sqr(mark(X)))
        mark(s(X)) -> active(s(mark(X)))
        mark(0()) -> active(0())
        mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
        mark(dbl(X)) -> active(dbl(mark(X)))
        mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
        mark(nil()) -> active(nil())
        terms(mark(X)) -> terms(X)
        terms(active(X)) -> terms(X)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        recip(mark(X)) -> recip(X)
        recip(active(X)) -> recip(X)
        sqr(mark(X)) -> sqr(X)
        sqr(active(X)) -> sqr(X)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        add(mark(X1),X2) -> add(X1,X2)
        add(X1,mark(X2)) -> add(X1,X2)
        add(active(X1),X2) -> add(X1,X2)
        add(X1,active(X2)) -> add(X1,X2)
        dbl(mark(X)) -> dbl(X)
        dbl(active(X)) -> dbl(X)
        first(mark(X1),X2) -> first(X1,X2)
        first(X1,mark(X2)) -> first(X1,X2)
        first(active(X1),X2) -> first(X1,X2)
        first(X1,active(X2)) -> first(X1,X2)
      Qed
    
    DPs:
     first#(mark(X1),X2) -> first#(X1,X2)
     first#(X1,mark(X2)) -> first#(X1,X2)
     first#(active(X1),X2) -> first#(X1,X2)
     first#(X1,active(X2)) -> first#(X1,X2)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(mark(X)))
     mark(0()) -> active(0())
     mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
     mark(dbl(X)) -> active(dbl(mark(X)))
     mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     terms(mark(X)) -> terms(X)
     terms(active(X)) -> terms(X)
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     recip(mark(X)) -> recip(X)
     recip(active(X)) -> recip(X)
     sqr(mark(X)) -> sqr(X)
     sqr(active(X)) -> sqr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     add(mark(X1),X2) -> add(X1,X2)
     add(X1,mark(X2)) -> add(X1,X2)
     add(active(X1),X2) -> add(X1,X2)
     add(X1,active(X2)) -> add(X1,X2)
     dbl(mark(X)) -> dbl(X)
     dbl(active(X)) -> dbl(X)
     first(mark(X1),X2) -> first(X1,X2)
     first(X1,mark(X2)) -> first(X1,X2)
     first(active(X1),X2) -> first(X1,X2)
     first(X1,active(X2)) -> first(X1,X2)
    Subterm Criterion Processor:
     simple projection:
      pi(first#) = 0
     problem:
      DPs:
       first#(X1,mark(X2)) -> first#(X1,X2)
       first#(X1,active(X2)) -> first#(X1,X2)
      TRS:
       active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
       active(sqr(0())) -> mark(0())
       active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
       active(dbl(0())) -> mark(0())
       active(dbl(s(X))) -> mark(s(s(dbl(X))))
       active(add(0(),X)) -> mark(X)
       active(add(s(X),Y)) -> mark(s(add(X,Y)))
       active(first(0(),X)) -> mark(nil())
       active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
       mark(terms(X)) -> active(terms(mark(X)))
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(recip(X)) -> active(recip(mark(X)))
       mark(sqr(X)) -> active(sqr(mark(X)))
       mark(s(X)) -> active(s(mark(X)))
       mark(0()) -> active(0())
       mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
       mark(dbl(X)) -> active(dbl(mark(X)))
       mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       terms(mark(X)) -> terms(X)
       terms(active(X)) -> terms(X)
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       recip(mark(X)) -> recip(X)
       recip(active(X)) -> recip(X)
       sqr(mark(X)) -> sqr(X)
       sqr(active(X)) -> sqr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       add(mark(X1),X2) -> add(X1,X2)
       add(X1,mark(X2)) -> add(X1,X2)
       add(active(X1),X2) -> add(X1,X2)
       add(X1,active(X2)) -> add(X1,X2)
       dbl(mark(X)) -> dbl(X)
       dbl(active(X)) -> dbl(X)
       first(mark(X1),X2) -> first(X1,X2)
       first(X1,mark(X2)) -> first(X1,X2)
       first(active(X1),X2) -> first(X1,X2)
       first(X1,active(X2)) -> first(X1,X2)
     Subterm Criterion Processor:
      simple projection:
       pi(first#) = 1
      problem:
       DPs:
        
       TRS:
        active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
        active(sqr(0())) -> mark(0())
        active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
        active(dbl(0())) -> mark(0())
        active(dbl(s(X))) -> mark(s(s(dbl(X))))
        active(add(0(),X)) -> mark(X)
        active(add(s(X),Y)) -> mark(s(add(X,Y)))
        active(first(0(),X)) -> mark(nil())
        active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
        mark(terms(X)) -> active(terms(mark(X)))
        mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
        mark(recip(X)) -> active(recip(mark(X)))
        mark(sqr(X)) -> active(sqr(mark(X)))
        mark(s(X)) -> active(s(mark(X)))
        mark(0()) -> active(0())
        mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
        mark(dbl(X)) -> active(dbl(mark(X)))
        mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
        mark(nil()) -> active(nil())
        terms(mark(X)) -> terms(X)
        terms(active(X)) -> terms(X)
        cons(mark(X1),X2) -> cons(X1,X2)
        cons(X1,mark(X2)) -> cons(X1,X2)
        cons(active(X1),X2) -> cons(X1,X2)
        cons(X1,active(X2)) -> cons(X1,X2)
        recip(mark(X)) -> recip(X)
        recip(active(X)) -> recip(X)
        sqr(mark(X)) -> sqr(X)
        sqr(active(X)) -> sqr(X)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        add(mark(X1),X2) -> add(X1,X2)
        add(X1,mark(X2)) -> add(X1,X2)
        add(active(X1),X2) -> add(X1,X2)
        add(X1,active(X2)) -> add(X1,X2)
        dbl(mark(X)) -> dbl(X)
        dbl(active(X)) -> dbl(X)
        first(mark(X1),X2) -> first(X1,X2)
        first(X1,mark(X2)) -> first(X1,X2)
        first(active(X1),X2) -> first(X1,X2)
        first(X1,active(X2)) -> first(X1,X2)
      Qed