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#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      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#(sqr(s(X))) -> mark#(s(add(sqr(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#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      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#(add(s(X),Y)) -> mark#(s(add(X,Y)))
      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#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      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#(sqr(s(X))) -> mark#(s(add(sqr(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#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      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#(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#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(sqr(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#(dbl(0())) -> mark#(0())
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(dbl(X)) -> active#(dbl(mark(X))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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#(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#(sqr(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#(dbl(0())) -> mark#(0())
      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#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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#(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#(sqr(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#(dbl(0())) -> mark#(0())
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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#(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#(sqr(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#(dbl(0())) -> mark#(0())
      mark#(recip(X)) -> active#(recip(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(recip(X)) -> active#(recip(mark(X))) ->
      active#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(recip(X)) -> active#(recip(mark(X))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
      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#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(dbl(0())) -> mark#(0())
      mark#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(sqr(X)) -> active#(sqr(mark(X))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      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))))
      mark#(terms(X)) -> active#(terms(mark(X))) ->
      active#(sqr(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#(dbl(0())) -> mark#(0())
      mark#(terms(X)) -> active#(terms(mark(X))) ->
      active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
      mark#(terms(X)) -> active#(terms(mark(X))) ->
      active#(add(0(),X)) -> mark#(X)
      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#(first(0(),X)) -> mark#(nil())
      mark#(terms(X)) -> active#(terms(mark(X))) ->
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
      active#(first(0(),X)) -> mark#(nil()) ->
      mark#(nil()) -> active#(nil())
      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))) -> 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#(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#(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#(recip(X)) -> active#(recip(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#(sqr(X)) -> active#(sqr(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#(s(X)) -> active#(s(mark(X)))
      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#(add(X1,X2)) -> mark#(X1)
      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#(dbl(X)) -> 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))) -> 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#(first(X1,X2)) -> mark#(X1)
      active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(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#(terms(X)) -> mark#(X)
      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#(cons(X1,X2)) -> mark#(X1)
      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#(recip(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#(sqr(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#(s(X)) -> mark#(X)
      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#(add(X1,X2)) -> 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)) -> active#(add(mark(X1),mark(X2)))
      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#(dbl(X)) -> active#(dbl(mark(X)))
      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#(first(X1,X2)) -> mark#(X1)
      active#(add(s(X),Y)) -> mark#(s(add(X,Y))) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      active#(dbl(0())) -> mark#(0()) ->
      mark#(0()) -> active#(0())
      active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
      mark#(terms(X)) -> mark#(X)
      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#(cons(X1,X2)) -> mark#(X1)
      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#(recip(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#(sqr(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#(s(X)) -> mark#(X)
      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#(add(X1,X2)) -> 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)) -> active#(add(mark(X1),mark(X2)))
      active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
      mark#(dbl(X)) -> mark#(X)
      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#(first(X1,X2)) -> 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)) -> active#(first(mark(X1),mark(X2)))
      active#(sqr(0())) -> mark#(0()) ->
      mark#(0()) -> active#(0())
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
      mark#(terms(X)) -> mark#(X)
      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#(cons(X1,X2)) -> mark#(X1)
      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#(recip(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#(sqr(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#(s(X)) -> mark#(X)
      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#(add(X1,X2)) -> 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)) -> active#(add(mark(X1),mark(X2)))
      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#(dbl(X)) -> active#(dbl(mark(X)))
      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#(first(X1,X2)) -> mark#(X1)
      active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
      mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
      active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N)))) ->
      mark#(terms(X)) -> mark#(X)
      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#(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))
      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#(recip(X)) -> active#(recip(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#(sqr(X)) -> active#(sqr(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#(s(X)) -> active#(s(mark(X)))
      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#(add(X1,X2)) -> mark#(X1)
      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#(dbl(X)) -> mark#(X)
      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#(first(X1,X2)) -> 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)) -> active#(first(mark(X1),mark(X2)))
     CDG 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#(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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(first(X1,X2)) -> mark#(X2) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(first(X1,X2)) -> mark#(X2) ->
       mark#(terms(X)) -> active#(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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(first(X1,X2)) -> mark#(X1) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(first(X1,X2)) -> mark#(X1) ->
       mark#(terms(X)) -> active#(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(0(),X)) -> mark#(nil())
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(add(X1,X2)) -> mark#(X2) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(add(X1,X2)) -> mark#(X2) ->
       mark#(terms(X)) -> active#(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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(add(X1,X2)) -> mark#(X1) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(add(X1,X2)) -> mark#(X1) ->
       mark#(terms(X)) -> active#(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#(add(s(X),Y)) -> mark#(s(add(X,Y)))
       mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2))) ->
       active#(add(0(),X)) -> mark#(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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(dbl(X)) -> mark#(X) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(dbl(X)) -> mark#(X) ->
       mark#(terms(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(0())) -> mark#(0())
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(cons(X1,X2)) -> mark#(X1) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(cons(X1,X2)) -> mark#(X1) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(cons(X1,X2)) -> mark#(X1) -> mark#(terms(X)) -> mark#(X)
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(s(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(s(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(recip(X)) -> mark#(X) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(recip(X)) -> mark#(X) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(sqr(X)) -> mark#(X) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(sqr(X)) -> mark#(X) ->
       mark#(terms(X)) -> mark#(X)
       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(0())) -> mark#(0())
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       mark#(terms(X)) -> mark#(X) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       mark#(terms(X)) -> mark#(X) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       mark#(terms(X)) -> mark#(X) ->
       mark#(terms(X)) -> mark#(X)
       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)) -> active#(cons(mark(X1),X2))
       active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z))) ->
       mark#(cons(X1,X2)) -> mark#(X1)
       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)) -> 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)) -> 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)) -> 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)) -> mark#(X)
       active#(add(0(),X)) -> mark#(X) ->
       mark#(sqr(X)) -> active#(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)) -> 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)) -> mark#(X1)
       active#(add(0(),X)) -> mark#(X) ->
       mark#(terms(X)) -> active#(terms(mark(X)))
       active#(add(0(),X)) -> mark#(X) ->
       mark#(terms(X)) -> mark#(X)
       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)) -> mark#(X)
       active#(dbl(0())) -> mark#(0()) ->
       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)) -> 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)) -> active#(s(mark(X)))
       active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X)))) ->
       mark#(s(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)) -> mark#(X1)
      SCC Processor:
       #sccs: 1
       #rules: 21
       #arcs: 242/841
       DPs:
        mark#(first(X1,X2)) -> mark#(X2)
        mark#(terms(X)) -> mark#(X)
        mark#(terms(X)) -> active#(terms(mark(X)))
        active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
        mark#(cons(X1,X2)) -> mark#(X1)
        mark#(recip(X)) -> mark#(X)
        mark#(sqr(X)) -> mark#(X)
        mark#(sqr(X)) -> active#(sqr(mark(X)))
        active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
        mark#(s(X)) -> mark#(X)
        mark#(add(X1,X2)) -> mark#(X2)
        mark#(add(X1,X2)) -> mark#(X1)
        mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
        active#(add(0(),X)) -> mark#(X)
        mark#(dbl(X)) -> mark#(X)
        mark#(dbl(X)) -> active#(dbl(mark(X)))
        active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
        mark#(first(X1,X2)) -> mark#(X1)
        mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
        active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
        active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
       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)
       Arctic Interpretation Processor:
        dimension: 1
        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)
        interpretation:
         [mark#](x0) = x0,
         
         [active#](x0) = x0 + 0,
         
         [nil] = 0,
         
         [first](x0, x1) = 5x0 + x1 + 5,
         
         [add](x0, x1) = x0 + x1 + 0,
         
         [dbl](x0) = x0 + 0,
         
         [0] = 0,
         
         [mark](x0) = x0 + 0,
         
         [cons](x0, x1) = x0 + x1 + 6,
         
         [s](x0) = x0 + 0,
         
         [recip](x0) = x0,
         
         [sqr](x0) = x0 + 0,
         
         [active](x0) = x0 + 0,
         
         [terms](x0) = 6x0 + 7
        orientation:
         mark#(first(X1,X2)) = 5X1 + X2 + 5 >= X2 = mark#(X2)
         
         mark#(terms(X)) = 6X + 7 >= X = mark#(X)
         
         mark#(terms(X)) = 6X + 7 >= 6X + 7 = active#(terms(mark(X)))
         
         active#(terms(N)) = 6N + 7 >= 6N + 7 = mark#(cons(recip(sqr(N)),terms(s(N))))
         
         mark#(cons(X1,X2)) = X1 + X2 + 6 >= X1 = mark#(X1)
         
         mark#(recip(X)) = X >= X = mark#(X)
         
         mark#(sqr(X)) = X + 0 >= X = mark#(X)
         
         mark#(sqr(X)) = X + 0 >= X + 0 = active#(sqr(mark(X)))
         
         active#(sqr(s(X))) = X + 0 >= X + 0 = mark#(s(add(sqr(X),dbl(X))))
         
         mark#(s(X)) = X + 0 >= X = mark#(X)
         
         mark#(add(X1,X2)) = X1 + X2 + 0 >= X2 = mark#(X2)
         
         mark#(add(X1,X2)) = X1 + X2 + 0 >= X1 = mark#(X1)
         
         mark#(add(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(add(mark(X1),mark(X2)))
         
         active#(add(0(),X)) = X + 0 >= X = mark#(X)
         
         mark#(dbl(X)) = X + 0 >= X = mark#(X)
         
         mark#(dbl(X)) = X + 0 >= X + 0 = active#(dbl(mark(X)))
         
         active#(dbl(s(X))) = X + 0 >= X + 0 = mark#(s(s(dbl(X))))
         
         mark#(first(X1,X2)) = 5X1 + X2 + 5 >= X1 = mark#(X1)
         
         mark#(first(X1,X2)) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = active#(first(mark(X1),mark(X2)))
         
         active#(first(s(X),cons(Y,Z))) = 5X + Y + Z + 6 >= 5X + Y + Z + 6 = mark#(cons(Y,first(X,Z)))
         
         active#(add(s(X),Y)) = X + Y + 0 >= X + Y + 0 = mark#(s(add(X,Y)))
         
         active(terms(N)) = 6N + 7 >= 6N + 7 = mark(cons(recip(sqr(N)),terms(s(N))))
         
         active(sqr(0())) = 0 >= 0 = mark(0())
         
         active(sqr(s(X))) = X + 0 >= X + 0 = mark(s(add(sqr(X),dbl(X))))
         
         active(dbl(0())) = 0 >= 0 = mark(0())
         
         active(dbl(s(X))) = X + 0 >= X + 0 = mark(s(s(dbl(X))))
         
         active(add(0(),X)) = X + 0 >= X + 0 = mark(X)
         
         active(add(s(X),Y)) = X + Y + 0 >= X + Y + 0 = mark(s(add(X,Y)))
         
         active(first(0(),X)) = X + 5 >= 0 = mark(nil())
         
         active(first(s(X),cons(Y,Z))) = 5X + Y + Z + 6 >= 5X + Y + Z + 6 = mark(cons(Y,first(X,Z)))
         
         mark(terms(X)) = 6X + 7 >= 6X + 7 = active(terms(mark(X)))
         
         mark(cons(X1,X2)) = X1 + X2 + 6 >= X1 + X2 + 6 = active(cons(mark(X1),X2))
         
         mark(recip(X)) = X + 0 >= X + 0 = active(recip(mark(X)))
         
         mark(sqr(X)) = X + 0 >= X + 0 = active(sqr(mark(X)))
         
         mark(s(X)) = X + 0 >= X + 0 = active(s(mark(X)))
         
         mark(0()) = 0 >= 0 = active(0())
         
         mark(add(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(add(mark(X1),mark(X2)))
         
         mark(dbl(X)) = X + 0 >= X + 0 = active(dbl(mark(X)))
         
         mark(first(X1,X2)) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = active(first(mark(X1),mark(X2)))
         
         mark(nil()) = 0 >= 0 = active(nil())
         
         terms(mark(X)) = 6X + 7 >= 6X + 7 = terms(X)
         
         terms(active(X)) = 6X + 7 >= 6X + 7 = terms(X)
         
         cons(mark(X1),X2) = X1 + X2 + 6 >= X1 + X2 + 6 = cons(X1,X2)
         
         cons(X1,mark(X2)) = X1 + X2 + 6 >= X1 + X2 + 6 = cons(X1,X2)
         
         cons(active(X1),X2) = X1 + X2 + 6 >= X1 + X2 + 6 = cons(X1,X2)
         
         cons(X1,active(X2)) = X1 + X2 + 6 >= X1 + X2 + 6 = cons(X1,X2)
         
         recip(mark(X)) = X + 0 >= X = recip(X)
         
         recip(active(X)) = X + 0 >= X = recip(X)
         
         sqr(mark(X)) = X + 0 >= X + 0 = sqr(X)
         
         sqr(active(X)) = X + 0 >= X + 0 = sqr(X)
         
         s(mark(X)) = X + 0 >= X + 0 = s(X)
         
         s(active(X)) = X + 0 >= X + 0 = s(X)
         
         add(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = add(X1,X2)
         
         add(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = add(X1,X2)
         
         add(active(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = add(X1,X2)
         
         add(X1,active(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = add(X1,X2)
         
         dbl(mark(X)) = X + 0 >= X + 0 = dbl(X)
         
         dbl(active(X)) = X + 0 >= X + 0 = dbl(X)
         
         first(mark(X1),X2) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = first(X1,X2)
         
         first(X1,mark(X2)) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = first(X1,X2)
         
         first(active(X1),X2) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = first(X1,X2)
         
         first(X1,active(X2)) = 5X1 + X2 + 5 >= 5X1 + X2 + 5 = first(X1,X2)
        problem:
         DPs:
          mark#(first(X1,X2)) -> mark#(X2)
          mark#(terms(X)) -> active#(terms(mark(X)))
          active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
          mark#(cons(X1,X2)) -> mark#(X1)
          mark#(recip(X)) -> mark#(X)
          mark#(sqr(X)) -> mark#(X)
          mark#(sqr(X)) -> active#(sqr(mark(X)))
          active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
          mark#(s(X)) -> mark#(X)
          mark#(add(X1,X2)) -> mark#(X2)
          mark#(add(X1,X2)) -> mark#(X1)
          mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
          active#(add(0(),X)) -> mark#(X)
          mark#(dbl(X)) -> mark#(X)
          mark#(dbl(X)) -> active#(dbl(mark(X)))
          active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
          mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
          active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
          active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
         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)) -> mark#(X2)
          mark#(terms(X)) -> active#(terms(mark(X)))
          active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
          mark#(cons(X1,X2)) -> mark#(X1)
          mark#(recip(X)) -> mark#(X)
          mark#(sqr(X)) -> mark#(X)
          mark#(sqr(X)) -> active#(sqr(mark(X)))
          active#(sqr(s(X))) -> mark#(s(add(sqr(X),dbl(X))))
          mark#(s(X)) -> mark#(X)
          mark#(add(X1,X2)) -> mark#(X2)
          mark#(add(X1,X2)) -> mark#(X1)
          mark#(add(X1,X2)) -> active#(add(mark(X1),mark(X2)))
          active#(add(0(),X)) -> mark#(X)
          mark#(dbl(X)) -> mark#(X)
          mark#(dbl(X)) -> active#(dbl(mark(X)))
          active#(dbl(s(X))) -> mark#(s(s(dbl(X))))
          mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
          active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
          active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
         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) = [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:
           terms > sqr > first ~ dbl > add > mark# ~ active# ~ nil ~ 
           0 ~ mark ~ cons ~ s ~ recip ~ active
          problem:
           DPs:
            mark#(terms(X)) -> active#(terms(mark(X)))
            mark#(cons(X1,X2)) -> mark#(X1)
            mark#(recip(X)) -> mark#(X)
            mark#(sqr(X)) -> active#(sqr(mark(X)))
            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)))
           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#(terms(X)) -> active#(terms(mark(X)))
            mark#(cons(X1,X2)) -> mark#(X1)
            mark#(recip(X)) -> mark#(X)
            mark#(sqr(X)) -> active#(sqr(mark(X)))
            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)))
           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: 2
            #arcs: 176/49
            DPs:
             mark#(cons(X1,X2)) -> mark#(X1)
             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)
            Subterm Criterion Processor:
             simple projection:
              pi(mark#) = 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:
     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#) = 1
     problem:
      DPs:
       cons#(mark(X1),X2) -> cons#(X1,X2)
       cons#(active(X1),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:
        
       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#) = 1
     problem:
      DPs:
       add#(mark(X1),X2) -> add#(X1,X2)
       add#(active(X1),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:
        
       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#) = 1
     problem:
      DPs:
       first#(mark(X1),X2) -> first#(X1,X2)
       first#(active(X1),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:
        
       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