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(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)) -> active#(s(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(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:
    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)) -> active#(s(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(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#(mark(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#(active(X1),X2) -> first#(X1,X2)
    first#(mark(X1),X2) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(active(X1),X2) -> first#(X1,X2) ->
    first#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> first#(X1,X2)
    first#(X1,mark(X2)) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(mark(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#(active(X1),X2) -> first#(X1,X2)
    first#(X1,active(X2)) -> first#(X1,X2) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(mark(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#(active(X1),X2) -> add#(X1,X2)
    add#(mark(X1),X2) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(active(X1),X2) -> add#(X1,X2) ->
    add#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> add#(X1,X2)
    add#(X1,mark(X2)) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) ->
    add#(mark(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#(active(X1),X2) -> add#(X1,X2)
    add#(X1,active(X2)) -> add#(X1,X2) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    dbl#(mark(X)) -> dbl#(X) -> dbl#(mark(X)) -> dbl#(X)
    dbl#(mark(X)) -> dbl#(X) -> dbl#(active(X)) -> dbl#(X)
    dbl#(active(X)) -> dbl#(X) -> dbl#(mark(X)) -> dbl#(X)
    dbl#(active(X)) -> dbl#(X) ->
    dbl#(active(X)) -> dbl#(X)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(mark(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#(active(X1),X2) -> first#(X1,X2)
    mark#(first(X1,X2)) -> first#(mark(X1),mark(X2)) ->
    first#(X1,active(X2)) -> first#(X1,X2)
    mark#(first(X1,X2)) -> mark#(X2) -> mark#(terms(X)) -> mark#(X)
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(first(X1,X2)) -> mark#(X2) ->
    mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(first(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> s#(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)) -> sqr#(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)) -> 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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> 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)) -> 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)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(mark(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#(active(X1),X2) -> add#(X1,X2)
    mark#(add(X1,X2)) -> add#(mark(X1),mark(X2)) ->
    add#(X1,active(X2)) -> add#(X1,X2)
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(terms(X)) -> mark#(X)
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(add(X1,X2)) -> mark#(X2) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(add(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(add(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(add(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> s#(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)) -> sqr#(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)) -> 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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> 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)) -> 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)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    mark#(dbl(X)) -> dbl#(mark(X)) -> dbl#(mark(X)) -> dbl#(X)
    mark#(dbl(X)) -> dbl#(mark(X)) -> dbl#(active(X)) -> dbl#(X)
    mark#(dbl(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(dbl(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(dbl(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(dbl(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> s#(N)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> s#(s(dbl(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#(add(0(),X)) -> mark#(X)
    mark#(dbl(X)) -> active#(dbl(mark(X))) ->
    active#(add(s(X),Y)) -> 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)) -> 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))) -> 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))) -> 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)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(cons(X1,X2)) -> mark#(X1) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> cons#(mark(X1),X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
    cons#(active(X1),X2) -> cons#(X1,X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
    active#(terms(N)) -> s#(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)) -> sqr#(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)) -> 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)) -> active#(cons(mark(X1),X2)) ->
    active#(sqr(0())) -> mark#(0())
    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(s(X))) -> sqr#(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))) -> 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)) -> active#(cons(mark(X1),X2)) ->
    active#(dbl(0())) -> mark#(0())
    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(s(X))) -> 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))) -> 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)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(recip(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(recip(X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(recip(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> recip#(mark(X)) ->
    recip#(mark(X)) -> recip#(X)
    mark#(recip(X)) -> recip#(mark(X)) ->
    recip#(active(X)) -> recip#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> s#(N)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> s#(s(dbl(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#(add(0(),X)) -> mark#(X)
    mark#(recip(X)) -> active#(recip(mark(X))) ->
    active#(add(s(X),Y)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    mark#(sqr(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(sqr(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(sqr(X)) -> mark#(X) -> mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(sqr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> sqr#(mark(X)) -> sqr#(mark(X)) -> sqr#(X)
    mark#(sqr(X)) -> sqr#(mark(X)) ->
    sqr#(active(X)) -> sqr#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> s#(N)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> s#(s(dbl(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#(add(0(),X)) -> mark#(X)
    mark#(sqr(X)) -> active#(sqr(mark(X))) ->
    active#(add(s(X),Y)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    mark#(terms(X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    mark#(terms(X)) -> mark#(X) -> mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    mark#(terms(X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    mark#(terms(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> terms#(mark(X)) ->
    terms#(mark(X)) -> terms#(X)
    mark#(terms(X)) -> terms#(mark(X)) ->
    terms#(active(X)) -> terms#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> s#(N)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> terms#(s(N))
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> sqr#(N)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(terms(N)) -> recip#(sqr(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)) -> 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))) -> 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))) -> 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))) -> 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))) -> 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))) -> s#(s(dbl(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#(add(0(),X)) -> mark#(X)
    mark#(terms(X)) -> active#(terms(mark(X))) ->
    active#(add(s(X),Y)) -> 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)) -> 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))) -> 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))) -> mark#(cons(Y,first(X,Z)))
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(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#(active(X1),X2) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2) ->
    cons#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(mark(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#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    recip#(mark(X)) -> recip#(X) -> recip#(mark(X)) -> recip#(X)
    recip#(mark(X)) -> recip#(X) -> recip#(active(X)) -> recip#(X)
    recip#(active(X)) -> recip#(X) -> recip#(mark(X)) -> recip#(X)
    recip#(active(X)) -> recip#(X) -> recip#(active(X)) -> recip#(X)
    sqr#(mark(X)) -> sqr#(X) -> sqr#(mark(X)) -> sqr#(X)
    sqr#(mark(X)) -> sqr#(X) -> sqr#(active(X)) -> sqr#(X)
    sqr#(active(X)) -> sqr#(X) -> sqr#(mark(X)) -> sqr#(X)
    sqr#(active(X)) -> sqr#(X) -> sqr#(active(X)) -> sqr#(X)
    terms#(mark(X)) -> terms#(X) -> terms#(mark(X)) -> terms#(X)
    terms#(mark(X)) -> terms#(X) -> terms#(active(X)) -> terms#(X)
    terms#(active(X)) -> terms#(X) -> terms#(mark(X)) -> terms#(X)
    terms#(active(X)) -> terms#(X) -> terms#(active(X)) -> terms#(X)
    s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> mark#(cons(Y,first(X,Z))) ->
    mark#(s(X)) -> active#(s(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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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)) ->
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    active#(first(s(X),cons(Y,Z))) -> cons#(Y,first(X,Z)) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(add(0(),X)) -> mark#(X) -> mark#(terms(X)) -> mark#(X)
    active#(add(0(),X)) -> mark#(X) ->
    mark#(terms(X)) -> terms#(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)) -> cons#(mark(X1),X2)
    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)) -> recip#(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)) -> sqr#(mark(X))
    active#(add(0(),X)) -> mark#(X) ->
    mark#(sqr(X)) -> active#(sqr(mark(X)))
    active#(add(0(),X)) -> mark#(X) -> mark#(s(X)) -> active#(s(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)) -> add#(mark(X1),mark(X2))
    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)) -> dbl#(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)) -> first#(mark(X1),mark(X2))
    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)) -> 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)) -> 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)) -> 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)) -> mark#(s(add(X,Y))) ->
    mark#(recip(X)) -> 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)) -> 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)) -> 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)) -> mark#(s(add(X,Y))) ->
    mark#(s(X)) -> active#(s(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)) -> 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)) -> mark#(s(add(X,Y))) ->
    mark#(dbl(X)) -> 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)) -> 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)) -> 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)) ->
    s#(mark(X)) -> s#(X)
    active#(add(s(X),Y)) -> s#(add(X,Y)) -> s#(active(X)) -> s#(X)
    active#(dbl(0())) -> mark#(0()) ->
    mark#(0()) -> active#(0())
    active#(dbl(s(X))) -> mark#(s(s(dbl(X)))) ->
    mark#(s(X)) -> active#(s(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(X))
    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)) -> terms#(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)) -> 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)) -> 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)) -> recip#(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)) -> sqr#(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)) -> active#(s(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)) -> 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)) -> 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)) -> dbl#(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)) -> 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))) ->
    cons#(mark(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#(active(X1),X2) -> cons#(X1,X2)
    active#(terms(N)) -> cons#(recip(sqr(N)),terms(s(N))) ->
    cons#(X1,active(X2)) -> cons#(X1,X2)
    active#(terms(N)) -> recip#(sqr(N)) ->
    recip#(mark(X)) -> recip#(X)
    active#(terms(N)) -> recip#(sqr(N)) ->
    recip#(active(X)) -> recip#(X)
    active#(terms(N)) -> terms#(s(N)) ->
    terms#(mark(X)) -> terms#(X)
    active#(terms(N)) -> terms#(s(N)) -> terms#(active(X)) -> terms#(X)
   SCC Processor:
    #sccs: 9
    #rules: 42
    #arcs: 610/5329
    DPs:
     mark#(first(X1,X2)) -> mark#(X2)
     mark#(first(X1,X2)) -> active#(first(mark(X1),mark(X2)))
     active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
     mark#(first(X1,X2)) -> mark#(X1)
     mark#(dbl(X)) -> active#(dbl(mark(X)))
     active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
     mark#(dbl(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)
     mark#(add(X1,X2)) -> mark#(X2)
     mark#(sqr(X)) -> active#(sqr(mark(X)))
     active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
     mark#(sqr(X)) -> mark#(X)
     mark#(recip(X)) -> active#(recip(mark(X)))
     mark#(recip(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(terms(X)) -> active#(terms(mark(X)))
     mark#(terms(X)) -> mark#(X)
    TRS:
     active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
     active(sqr(0())) -> mark(0())
     active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
     active(dbl(0())) -> mark(0())
     active(dbl(s(X))) -> mark(s(s(dbl(X))))
     active(add(0(),X)) -> mark(X)
     active(add(s(X),Y)) -> mark(s(add(X,Y)))
     active(first(0(),X)) -> mark(nil())
     active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
     mark(terms(X)) -> active(terms(mark(X)))
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(recip(X)) -> active(recip(mark(X)))
     mark(sqr(X)) -> active(sqr(mark(X)))
     mark(s(X)) -> active(s(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [mark#](x0) = x0 + 1,
      
      [active#](x0) = x0,
      
      [nil] = 1,
      
      [first](x0, x1) = x0 + x1 + 1,
      
      [add](x0, x1) = x0 + x1 + 1,
      
      [dbl](x0) = x0,
      
      [0] = 0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x0,
      
      [s](x0) = 0,
      
      [recip](x0) = x0,
      
      [sqr](x0) = x0,
      
      [active](x0) = x0,
      
      [terms](x0) = x0 + 1
     orientation:
      mark#(first(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = mark#(X2)
      
      mark#(first(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = active#(first(mark(X1),mark(X2)))
      
      active#(first(s(X),cons(Y,Z))) = Y + 1 >= Y + 1 = mark#(cons(Y,first(X,Z)))
      
      mark#(first(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = mark#(X1)
      
      mark#(dbl(X)) = X + 1 >= X = active#(dbl(mark(X)))
      
      active#(add(s(X),Y)) = Y + 1 >= 1 = mark#(s(add(X,Y)))
      
      mark#(dbl(X)) = X + 1 >= X + 1 = mark#(X)
      
      mark#(add(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = active#(add(mark(X1),mark(X2)))
      
      active#(add(0(),X)) = X + 1 >= X + 1 = mark#(X)
      
      mark#(add(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = mark#(X1)
      
      mark#(add(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = mark#(X2)
      
      mark#(sqr(X)) = X + 1 >= X = active#(sqr(mark(X)))
      
      active#(terms(N)) = N + 1 >= N + 1 = mark#(cons(recip(sqr(N)),terms(s(N))))
      
      mark#(sqr(X)) = X + 1 >= X + 1 = mark#(X)
      
      mark#(recip(X)) = X + 1 >= X = active#(recip(mark(X)))
      
      mark#(recip(X)) = X + 1 >= X + 1 = mark#(X)
      
      mark#(cons(X1,X2)) = X1 + 1 >= X1 = active#(cons(mark(X1),X2))
      
      mark#(cons(X1,X2)) = X1 + 1 >= X1 + 1 = mark#(X1)
      
      mark#(terms(X)) = X + 2 >= X + 1 = active#(terms(mark(X)))
      
      mark#(terms(X)) = X + 2 >= X + 1 = mark#(X)
      
      active(terms(N)) = N + 1 >= N = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 0 >= 0 = mark(0())
      
      active(sqr(s(X))) = 0 >= 0 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 0 >= 0 = mark(0())
      
      active(dbl(s(X))) = 0 >= 0 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 0 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = X + 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = Y + 1 >= Y = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = X + 1 >= X + 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = X1 >= X1 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = X >= X = active(recip(mark(X)))
      
      mark(sqr(X)) = X >= X = active(sqr(mark(X)))
      
      mark(s(X)) = 0 >= 0 = active(s(X))
      
      mark(0()) = 0 >= 0 = active(0())
      
      mark(add(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = X >= X = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 1 = active(nil())
      
      terms(mark(X)) = X + 1 >= X + 1 = terms(X)
      
      terms(active(X)) = X + 1 >= X + 1 = terms(X)
      
      cons(mark(X1),X2) = X1 >= X1 = cons(X1,X2)
      
      cons(X1,mark(X2)) = X1 >= X1 = cons(X1,X2)
      
      cons(active(X1),X2) = X1 >= X1 = cons(X1,X2)
      
      cons(X1,active(X2)) = X1 >= X1 = cons(X1,X2)
      
      recip(mark(X)) = X >= X = recip(X)
      
      recip(active(X)) = X >= X = recip(X)
      
      sqr(mark(X)) = X >= X = sqr(X)
      
      sqr(active(X)) = X >= X = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = X >= X = dbl(X)
      
      dbl(active(X)) = X >= X = dbl(X)
      
      first(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = first(X1,X2)
      
      first(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = first(X1,X2)
      
      first(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = first(X1,X2)
      
      first(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = first(X1,X2)
     problem:
      DPs:
       active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
       active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
       mark#(dbl(X)) -> mark#(X)
       active#(add(0(),X)) -> mark#(X)
       active#(terms(N)) -> mark#(cons(recip(sqr(N)),terms(s(N))))
       mark#(sqr(X)) -> mark#(X)
       mark#(recip(X)) -> mark#(X)
       mark#(cons(X1,X2)) -> mark#(X1)
      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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [mark#](x0) = 0,
       
       [active#](x0) = x0,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 0,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = 0,
       
       [terms](x0) = 1
      orientation:
       active#(first(s(X),cons(Y,Z))) = 0 >= 0 = mark#(cons(Y,first(X,Z)))
       
       active#(add(s(X),Y)) = 0 >= 0 = mark#(s(add(X,Y)))
       
       mark#(dbl(X)) = 0 >= 0 = mark#(X)
       
       active#(add(0(),X)) = 0 >= 0 = mark#(X)
       
       active#(terms(N)) = 1 >= 0 = mark#(cons(recip(sqr(N)),terms(s(N))))
       
       mark#(sqr(X)) = 0 >= 0 = mark#(X)
       
       mark#(recip(X)) = 0 >= 0 = mark#(X)
       
       mark#(cons(X1,X2)) = 0 >= 0 = mark#(X1)
       
       active(terms(N)) = 0 >= 0 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 0 >= 0 = mark(0())
       
       active(sqr(s(X))) = 0 >= 0 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 0 >= 0 = mark(0())
       
       active(dbl(s(X))) = 0 >= 0 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 0 >= 0 = mark(X)
       
       active(add(s(X),Y)) = 0 >= 0 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 0 >= 0 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 0 >= 0 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 0 >= 0 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 0 >= 0 = active(recip(mark(X)))
       
       mark(sqr(X)) = 0 >= 0 = active(sqr(mark(X)))
       
       mark(s(X)) = 0 >= 0 = active(s(X))
       
       mark(0()) = 0 >= 0 = active(0())
       
       mark(add(X1,X2)) = 0 >= 0 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 0 >= 0 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 0 >= 0 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 0 >= 0 = active(nil())
       
       terms(mark(X)) = 1 >= 1 = terms(X)
       
       terms(active(X)) = 1 >= 1 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      problem:
       DPs:
        active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
        active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
        mark#(dbl(X)) -> mark#(X)
        active#(add(0(),X)) -> mark#(X)
        mark#(sqr(X)) -> mark#(X)
        mark#(recip(X)) -> mark#(X)
        mark#(cons(X1,X2)) -> mark#(X1)
       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(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)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [mark#](x0) = 1,
        
        [active#](x0) = x0,
        
        [nil] = 0,
        
        [first](x0, x1) = 1,
        
        [add](x0, x1) = x0 + x1 + 1,
        
        [dbl](x0) = 1,
        
        [0] = 1,
        
        [mark](x0) = x0,
        
        [cons](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [recip](x0) = 0,
        
        [sqr](x0) = 1,
        
        [active](x0) = x0,
        
        [terms](x0) = 1
       orientation:
        active#(first(s(X),cons(Y,Z))) = 1 >= 1 = mark#(cons(Y,first(X,Z)))
        
        active#(add(s(X),Y)) = Y + 1 >= 1 = mark#(s(add(X,Y)))
        
        mark#(dbl(X)) = 1 >= 1 = mark#(X)
        
        active#(add(0(),X)) = X + 2 >= 1 = mark#(X)
        
        mark#(sqr(X)) = 1 >= 1 = mark#(X)
        
        mark#(recip(X)) = 1 >= 1 = mark#(X)
        
        mark#(cons(X1,X2)) = 1 >= 1 = mark#(X1)
        
        active(terms(N)) = 1 >= 0 = mark(cons(recip(sqr(N)),terms(s(N))))
        
        active(sqr(0())) = 1 >= 1 = mark(0())
        
        active(sqr(s(X))) = 1 >= 0 = mark(s(add(sqr(X),dbl(X))))
        
        active(dbl(0())) = 1 >= 1 = mark(0())
        
        active(dbl(s(X))) = 1 >= 0 = mark(s(s(dbl(X))))
        
        active(add(0(),X)) = X + 2 >= X = mark(X)
        
        active(add(s(X),Y)) = Y + 1 >= 0 = mark(s(add(X,Y)))
        
        active(first(0(),X)) = 1 >= 0 = mark(nil())
        
        active(first(s(X),cons(Y,Z))) = 1 >= 0 = mark(cons(Y,first(X,Z)))
        
        mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
        
        mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2))
        
        mark(recip(X)) = 0 >= 0 = active(recip(mark(X)))
        
        mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
        
        mark(s(X)) = 0 >= 0 = active(s(X))
        
        mark(0()) = 1 >= 1 = active(0())
        
        mark(add(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(add(mark(X1),mark(X2)))
        
        mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
        
        mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
        
        mark(nil()) = 0 >= 0 = active(nil())
        
        terms(mark(X)) = 1 >= 1 = terms(X)
        
        terms(active(X)) = 1 >= 1 = terms(X)
        
        cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
        
        cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
        
        recip(mark(X)) = 0 >= 0 = recip(X)
        
        recip(active(X)) = 0 >= 0 = recip(X)
        
        sqr(mark(X)) = 1 >= 1 = sqr(X)
        
        sqr(active(X)) = 1 >= 1 = sqr(X)
        
        s(mark(X)) = 0 >= 0 = s(X)
        
        s(active(X)) = 0 >= 0 = s(X)
        
        add(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
        
        add(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
        
        add(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
        
        add(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = add(X1,X2)
        
        dbl(mark(X)) = 1 >= 1 = dbl(X)
        
        dbl(active(X)) = 1 >= 1 = dbl(X)
        
        first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
        
        first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
        
        first(active(X1),X2) = 1 >= 1 = first(X1,X2)
        
        first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
       problem:
        DPs:
         active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
         active#(add(s(X),Y)) -> mark#(s(add(X,Y)))
         mark#(dbl(X)) -> mark#(X)
         mark#(sqr(X)) -> mark#(X)
         mark#(recip(X)) -> mark#(X)
         mark#(cons(X1,X2)) -> mark#(X1)
        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(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)
       Matrix Interpretation Processor:
        dimension: 1
        interpretation:
         [mark#](x0) = 0,
         
         [active#](x0) = x0,
         
         [nil] = 0,
         
         [first](x0, x1) = 0,
         
         [add](x0, x1) = 1,
         
         [dbl](x0) = 1,
         
         [0] = 0,
         
         [mark](x0) = 0,
         
         [cons](x0, x1) = 0,
         
         [s](x0) = 0,
         
         [recip](x0) = 0,
         
         [sqr](x0) = 1,
         
         [active](x0) = 0,
         
         [terms](x0) = 0
        orientation:
         active#(first(s(X),cons(Y,Z))) = 0 >= 0 = mark#(cons(Y,first(X,Z)))
         
         active#(add(s(X),Y)) = 1 >= 0 = mark#(s(add(X,Y)))
         
         mark#(dbl(X)) = 0 >= 0 = mark#(X)
         
         mark#(sqr(X)) = 0 >= 0 = mark#(X)
         
         mark#(recip(X)) = 0 >= 0 = mark#(X)
         
         mark#(cons(X1,X2)) = 0 >= 0 = mark#(X1)
         
         active(terms(N)) = 0 >= 0 = mark(cons(recip(sqr(N)),terms(s(N))))
         
         active(sqr(0())) = 0 >= 0 = mark(0())
         
         active(sqr(s(X))) = 0 >= 0 = mark(s(add(sqr(X),dbl(X))))
         
         active(dbl(0())) = 0 >= 0 = mark(0())
         
         active(dbl(s(X))) = 0 >= 0 = mark(s(s(dbl(X))))
         
         active(add(0(),X)) = 0 >= 0 = mark(X)
         
         active(add(s(X),Y)) = 0 >= 0 = mark(s(add(X,Y)))
         
         active(first(0(),X)) = 0 >= 0 = mark(nil())
         
         active(first(s(X),cons(Y,Z))) = 0 >= 0 = mark(cons(Y,first(X,Z)))
         
         mark(terms(X)) = 0 >= 0 = active(terms(mark(X)))
         
         mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2))
         
         mark(recip(X)) = 0 >= 0 = active(recip(mark(X)))
         
         mark(sqr(X)) = 0 >= 0 = active(sqr(mark(X)))
         
         mark(s(X)) = 0 >= 0 = active(s(X))
         
         mark(0()) = 0 >= 0 = active(0())
         
         mark(add(X1,X2)) = 0 >= 0 = active(add(mark(X1),mark(X2)))
         
         mark(dbl(X)) = 0 >= 0 = active(dbl(mark(X)))
         
         mark(first(X1,X2)) = 0 >= 0 = active(first(mark(X1),mark(X2)))
         
         mark(nil()) = 0 >= 0 = active(nil())
         
         terms(mark(X)) = 0 >= 0 = terms(X)
         
         terms(active(X)) = 0 >= 0 = terms(X)
         
         cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
         
         cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
         
         cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
         
         cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
         
         recip(mark(X)) = 0 >= 0 = recip(X)
         
         recip(active(X)) = 0 >= 0 = recip(X)
         
         sqr(mark(X)) = 1 >= 1 = sqr(X)
         
         sqr(active(X)) = 1 >= 1 = sqr(X)
         
         s(mark(X)) = 0 >= 0 = s(X)
         
         s(active(X)) = 0 >= 0 = s(X)
         
         add(mark(X1),X2) = 1 >= 1 = add(X1,X2)
         
         add(X1,mark(X2)) = 1 >= 1 = add(X1,X2)
         
         add(active(X1),X2) = 1 >= 1 = add(X1,X2)
         
         add(X1,active(X2)) = 1 >= 1 = add(X1,X2)
         
         dbl(mark(X)) = 1 >= 1 = dbl(X)
         
         dbl(active(X)) = 1 >= 1 = dbl(X)
         
         first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
         
         first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
         
         first(active(X1),X2) = 0 >= 0 = first(X1,X2)
         
         first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
        problem:
         DPs:
          active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
          mark#(dbl(X)) -> mark#(X)
          mark#(sqr(X)) -> mark#(X)
          mark#(recip(X)) -> mark#(X)
          mark#(cons(X1,X2)) -> mark#(X1)
         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(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)
        Matrix Interpretation Processor:
         dimension: 1
         interpretation:
          [mark#](x0) = x0,
          
          [active#](x0) = x0,
          
          [nil] = 0,
          
          [first](x0, x1) = x1,
          
          [add](x0, x1) = x1,
          
          [dbl](x0) = x0,
          
          [0] = 0,
          
          [mark](x0) = x0,
          
          [cons](x0, x1) = x0 + 1,
          
          [s](x0) = 0,
          
          [recip](x0) = x0,
          
          [sqr](x0) = x0,
          
          [active](x0) = x0,
          
          [terms](x0) = x0 + 1
         orientation:
          active#(first(s(X),cons(Y,Z))) = Y + 1 >= Y + 1 = mark#(cons(Y,first(X,Z)))
          
          mark#(dbl(X)) = X >= X = mark#(X)
          
          mark#(sqr(X)) = X >= X = mark#(X)
          
          mark#(recip(X)) = X >= X = mark#(X)
          
          mark#(cons(X1,X2)) = X1 + 1 >= X1 = mark#(X1)
          
          active(terms(N)) = N + 1 >= N + 1 = mark(cons(recip(sqr(N)),terms(s(N))))
          
          active(sqr(0())) = 0 >= 0 = mark(0())
          
          active(sqr(s(X))) = 0 >= 0 = mark(s(add(sqr(X),dbl(X))))
          
          active(dbl(0())) = 0 >= 0 = mark(0())
          
          active(dbl(s(X))) = 0 >= 0 = mark(s(s(dbl(X))))
          
          active(add(0(),X)) = X >= X = mark(X)
          
          active(add(s(X),Y)) = Y >= 0 = mark(s(add(X,Y)))
          
          active(first(0(),X)) = X >= 0 = mark(nil())
          
          active(first(s(X),cons(Y,Z))) = Y + 1 >= Y + 1 = mark(cons(Y,first(X,Z)))
          
          mark(terms(X)) = X + 1 >= X + 1 = active(terms(mark(X)))
          
          mark(cons(X1,X2)) = X1 + 1 >= X1 + 1 = active(cons(mark(X1),X2))
          
          mark(recip(X)) = X >= X = active(recip(mark(X)))
          
          mark(sqr(X)) = X >= X = active(sqr(mark(X)))
          
          mark(s(X)) = 0 >= 0 = active(s(X))
          
          mark(0()) = 0 >= 0 = active(0())
          
          mark(add(X1,X2)) = X2 >= X2 = active(add(mark(X1),mark(X2)))
          
          mark(dbl(X)) = X >= X = active(dbl(mark(X)))
          
          mark(first(X1,X2)) = X2 >= X2 = active(first(mark(X1),mark(X2)))
          
          mark(nil()) = 0 >= 0 = active(nil())
          
          terms(mark(X)) = X + 1 >= X + 1 = terms(X)
          
          terms(active(X)) = X + 1 >= X + 1 = terms(X)
          
          cons(mark(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2)
          
          cons(X1,mark(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2)
          
          cons(active(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2)
          
          cons(X1,active(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2)
          
          recip(mark(X)) = X >= X = recip(X)
          
          recip(active(X)) = X >= X = recip(X)
          
          sqr(mark(X)) = X >= X = sqr(X)
          
          sqr(active(X)) = X >= X = sqr(X)
          
          s(mark(X)) = 0 >= 0 = s(X)
          
          s(active(X)) = 0 >= 0 = s(X)
          
          add(mark(X1),X2) = X2 >= X2 = add(X1,X2)
          
          add(X1,mark(X2)) = X2 >= X2 = add(X1,X2)
          
          add(active(X1),X2) = X2 >= X2 = add(X1,X2)
          
          add(X1,active(X2)) = X2 >= X2 = add(X1,X2)
          
          dbl(mark(X)) = X >= X = dbl(X)
          
          dbl(active(X)) = X >= X = dbl(X)
          
          first(mark(X1),X2) = X2 >= X2 = first(X1,X2)
          
          first(X1,mark(X2)) = X2 >= X2 = first(X1,X2)
          
          first(active(X1),X2) = X2 >= X2 = first(X1,X2)
          
          first(X1,active(X2)) = X2 >= X2 = first(X1,X2)
         problem:
          DPs:
           active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
           mark#(dbl(X)) -> mark#(X)
           mark#(sqr(X)) -> mark#(X)
           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(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)
         Matrix Interpretation Processor:
          dimension: 1
          interpretation:
           [mark#](x0) = x0 + 1,
           
           [active#](x0) = x0,
           
           [nil] = 0,
           
           [first](x0, x1) = 1,
           
           [add](x0, x1) = x1 + 1,
           
           [dbl](x0) = x0 + 1,
           
           [0] = 0,
           
           [mark](x0) = x0 + 1,
           
           [cons](x0, x1) = 0,
           
           [s](x0) = 0,
           
           [recip](x0) = x0 + 1,
           
           [sqr](x0) = x0 + 1,
           
           [active](x0) = x0,
           
           [terms](x0) = 1
          orientation:
           active#(first(s(X),cons(Y,Z))) = 1 >= 1 = mark#(cons(Y,first(X,Z)))
           
           mark#(dbl(X)) = X + 2 >= X + 1 = mark#(X)
           
           mark#(sqr(X)) = X + 2 >= X + 1 = mark#(X)
           
           mark#(recip(X)) = X + 2 >= X + 1 = mark#(X)
           
           active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
           
           active(sqr(0())) = 1 >= 1 = mark(0())
           
           active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
           
           active(dbl(0())) = 1 >= 1 = mark(0())
           
           active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
           
           active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
           
           active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
           
           active(first(0(),X)) = 1 >= 1 = mark(nil())
           
           active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
           
           mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
           
           mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
           
           mark(recip(X)) = X + 2 >= X + 2 = active(recip(mark(X)))
           
           mark(sqr(X)) = X + 2 >= X + 2 = active(sqr(mark(X)))
           
           mark(s(X)) = 1 >= 0 = active(s(X))
           
           mark(0()) = 1 >= 0 = active(0())
           
           mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
           
           mark(dbl(X)) = X + 2 >= X + 2 = active(dbl(mark(X)))
           
           mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
           
           mark(nil()) = 1 >= 0 = active(nil())
           
           terms(mark(X)) = 1 >= 1 = terms(X)
           
           terms(active(X)) = 1 >= 1 = terms(X)
           
           cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
           
           cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
           
           cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
           
           cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
           
           recip(mark(X)) = X + 2 >= X + 1 = recip(X)
           
           recip(active(X)) = X + 1 >= X + 1 = recip(X)
           
           sqr(mark(X)) = X + 2 >= X + 1 = sqr(X)
           
           sqr(active(X)) = X + 1 >= X + 1 = sqr(X)
           
           s(mark(X)) = 0 >= 0 = s(X)
           
           s(active(X)) = 0 >= 0 = s(X)
           
           add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
           
           add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
           
           add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
           
           add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
           
           dbl(mark(X)) = X + 2 >= X + 1 = dbl(X)
           
           dbl(active(X)) = X + 1 >= X + 1 = dbl(X)
           
           first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
           
           first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
           
           first(active(X1),X2) = 1 >= 1 = first(X1,X2)
           
           first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
          problem:
           DPs:
            active#(first(s(X),cons(Y,Z))) -> mark#(cons(Y,first(X,Z)))
           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(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)
          Matrix Interpretation Processor:
           dimension: 1
           interpretation:
            [mark#](x0) = 0,
            
            [active#](x0) = 1,
            
            [nil] = 0,
            
            [first](x0, x1) = 0,
            
            [add](x0, x1) = 0,
            
            [dbl](x0) = 0,
            
            [0] = 0,
            
            [mark](x0) = 0,
            
            [cons](x0, x1) = 0,
            
            [s](x0) = 0,
            
            [recip](x0) = 1,
            
            [sqr](x0) = 0,
            
            [active](x0) = 0,
            
            [terms](x0) = 0
           orientation:
            active#(first(s(X),cons(Y,Z))) = 1 >= 0 = mark#(cons(Y,first(X,Z)))
            
            active(terms(N)) = 0 >= 0 = mark(cons(recip(sqr(N)),terms(s(N))))
            
            active(sqr(0())) = 0 >= 0 = mark(0())
            
            active(sqr(s(X))) = 0 >= 0 = mark(s(add(sqr(X),dbl(X))))
            
            active(dbl(0())) = 0 >= 0 = mark(0())
            
            active(dbl(s(X))) = 0 >= 0 = mark(s(s(dbl(X))))
            
            active(add(0(),X)) = 0 >= 0 = mark(X)
            
            active(add(s(X),Y)) = 0 >= 0 = mark(s(add(X,Y)))
            
            active(first(0(),X)) = 0 >= 0 = mark(nil())
            
            active(first(s(X),cons(Y,Z))) = 0 >= 0 = mark(cons(Y,first(X,Z)))
            
            mark(terms(X)) = 0 >= 0 = active(terms(mark(X)))
            
            mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2))
            
            mark(recip(X)) = 0 >= 0 = active(recip(mark(X)))
            
            mark(sqr(X)) = 0 >= 0 = active(sqr(mark(X)))
            
            mark(s(X)) = 0 >= 0 = active(s(X))
            
            mark(0()) = 0 >= 0 = active(0())
            
            mark(add(X1,X2)) = 0 >= 0 = active(add(mark(X1),mark(X2)))
            
            mark(dbl(X)) = 0 >= 0 = active(dbl(mark(X)))
            
            mark(first(X1,X2)) = 0 >= 0 = active(first(mark(X1),mark(X2)))
            
            mark(nil()) = 0 >= 0 = active(nil())
            
            terms(mark(X)) = 0 >= 0 = terms(X)
            
            terms(active(X)) = 0 >= 0 = terms(X)
            
            cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
            
            cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
            
            cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
            
            cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
            
            recip(mark(X)) = 1 >= 1 = recip(X)
            
            recip(active(X)) = 1 >= 1 = recip(X)
            
            sqr(mark(X)) = 0 >= 0 = sqr(X)
            
            sqr(active(X)) = 0 >= 0 = sqr(X)
            
            s(mark(X)) = 0 >= 0 = s(X)
            
            s(active(X)) = 0 >= 0 = s(X)
            
            add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
            
            add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
            
            add(active(X1),X2) = 0 >= 0 = add(X1,X2)
            
            add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
            
            dbl(mark(X)) = 0 >= 0 = dbl(X)
            
            dbl(active(X)) = 0 >= 0 = dbl(X)
            
            first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
            
            first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
            
            first(active(X1),X2) = 0 >= 0 = first(X1,X2)
            
            first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
           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(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#(active(X)) -> terms#(X)
     terms#(mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [terms#](x0) = x0 + 1,
      
      [nil] = 0,
      
      [first](x0, x1) = 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = 1,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      terms#(active(X)) = X + 1 >= X + 1 = terms#(X)
      
      terms#(mark(X)) = X + 2 >= X + 1 = terms#(X)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 2 >= 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = 1 >= 1 = recip(X)
      
      recip(active(X)) = 1 >= 1 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
      
      first(active(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
     problem:
      DPs:
       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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [terms#](x0) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = x0 + 1,
       
       [terms](x0) = 0
      orientation:
       terms#(active(X)) = X + 2 >= X + 1 = terms#(X)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 1 >= 1 = mark(X)
       
       active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
       
       mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 1 = active(s(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 1 = active(nil())
       
       terms(mark(X)) = 0 >= 0 = terms(X)
       
       terms(active(X)) = 0 >= 0 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      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(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#(active(X)) -> recip#(X)
     recip#(mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [recip#](x0) = x0 + 1,
      
      [nil] = 0,
      
      [first](x0, x1) = 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = 1,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      recip#(active(X)) = X + 1 >= X + 1 = recip#(X)
      
      recip#(mark(X)) = X + 2 >= X + 1 = recip#(X)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 2 >= 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = 1 >= 1 = recip(X)
      
      recip(active(X)) = 1 >= 1 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
      
      first(active(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
     problem:
      DPs:
       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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [recip#](x0) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = x0 + 1,
       
       [terms](x0) = 0
      orientation:
       recip#(active(X)) = X + 2 >= X + 1 = recip#(X)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 1 >= 1 = mark(X)
       
       active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
       
       mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 1 = active(s(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 1 = active(nil())
       
       terms(mark(X)) = 0 >= 0 = terms(X)
       
       terms(active(X)) = 0 >= 0 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      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(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#(active(X)) -> sqr#(X)
     sqr#(mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [sqr#](x0) = x0 + 1,
      
      [nil] = 0,
      
      [first](x0, x1) = 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = 1,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      sqr#(active(X)) = X + 1 >= X + 1 = sqr#(X)
      
      sqr#(mark(X)) = X + 2 >= X + 1 = sqr#(X)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 2 >= 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = 1 >= 1 = recip(X)
      
      recip(active(X)) = 1 >= 1 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
      
      first(active(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
     problem:
      DPs:
       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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [sqr#](x0) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = x0 + 1,
       
       [terms](x0) = 0
      orientation:
       sqr#(active(X)) = X + 2 >= X + 1 = sqr#(X)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 1 >= 1 = mark(X)
       
       active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
       
       mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 1 = active(s(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 1 = active(nil())
       
       terms(mark(X)) = 0 >= 0 = terms(X)
       
       terms(active(X)) = 0 >= 0 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      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(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#(active(X)) -> s#(X)
     s#(mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [s#](x0) = x0 + 1,
      
      [nil] = 0,
      
      [first](x0, x1) = 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = 1,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      s#(active(X)) = X + 1 >= X + 1 = s#(X)
      
      s#(mark(X)) = X + 2 >= X + 1 = s#(X)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 2 >= 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = 1 >= 1 = recip(X)
      
      recip(active(X)) = 1 >= 1 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
      
      first(active(X1),X2) = 1 >= 1 = first(X1,X2)
      
      first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
     problem:
      DPs:
       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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [s#](x0) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = x0 + 1,
       
       [terms](x0) = 0
      orientation:
       s#(active(X)) = X + 2 >= X + 1 = s#(X)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 1 >= 1 = mark(X)
       
       active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
       
       mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 1 = active(s(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 1 = active(nil())
       
       terms(mark(X)) = 0 >= 0 = terms(X)
       
       terms(active(X)) = 0 >= 0 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      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(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#(X1,active(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [cons#](x0, x1) = x0,
      
      [nil] = 0,
      
      [first](x0, x1) = x1 + 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = 1,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      cons#(X1,active(X2)) = X1 >= X1 = cons#(X1,X2)
      
      cons#(active(X1),X2) = X1 >= X1 = cons#(X1,X2)
      
      cons#(X1,mark(X2)) = X1 >= X1 = cons#(X1,X2)
      
      cons#(mark(X1),X2) = X1 + 1 >= X1 = cons#(X1,X2)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = X + 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 2 >= 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = X2 + 2 >= X2 + 2 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = 1 >= 1 = recip(X)
      
      recip(active(X)) = 1 >= 1 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
      
      first(X1,mark(X2)) = X2 + 2 >= X2 + 1 = first(X1,X2)
      
      first(active(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
      
      first(X1,active(X2)) = X2 + 1 >= X2 + 1 = first(X1,X2)
     problem:
      DPs:
       cons#(X1,active(X2)) -> cons#(X1,X2)
       cons#(active(X1),X2) -> cons#(X1,X2)
       cons#(X1,mark(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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [cons#](x0, x1) = x1,
       
       [nil] = 0,
       
       [first](x0, x1) = x1 + 1,
       
       [add](x0, x1) = x1 + 1,
       
       [dbl](x0) = 1,
       
       [0] = 0,
       
       [mark](x0) = x0 + 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 1,
       
       [active](x0) = x0,
       
       [terms](x0) = 1
      orientation:
       cons#(X1,active(X2)) = X2 >= X2 = cons#(X1,X2)
       
       cons#(active(X1),X2) = X2 >= X2 = cons#(X1,X2)
       
       cons#(X1,mark(X2)) = X2 + 1 >= X2 = cons#(X1,X2)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
       
       active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = X + 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 0 = active(recip(mark(X)))
       
       mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 0 = active(s(X))
       
       mark(0()) = 1 >= 0 = active(0())
       
       mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = X2 + 2 >= X2 + 2 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 0 = active(nil())
       
       terms(mark(X)) = 1 >= 1 = terms(X)
       
       terms(active(X)) = 1 >= 1 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 1 >= 1 = sqr(X)
       
       sqr(active(X)) = 1 >= 1 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
       
       add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       dbl(mark(X)) = 1 >= 1 = dbl(X)
       
       dbl(active(X)) = 1 >= 1 = dbl(X)
       
       first(mark(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
       
       first(X1,mark(X2)) = X2 + 2 >= X2 + 1 = first(X1,X2)
       
       first(active(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
       
       first(X1,active(X2)) = X2 + 1 >= X2 + 1 = first(X1,X2)
      problem:
       DPs:
        cons#(X1,active(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(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)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [cons#](x0, x1) = x0 + x1 + 1,
        
        [nil] = 0,
        
        [first](x0, x1) = 0,
        
        [add](x0, x1) = 0,
        
        [dbl](x0) = 0,
        
        [0] = 0,
        
        [mark](x0) = 1,
        
        [cons](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [recip](x0) = 0,
        
        [sqr](x0) = 0,
        
        [active](x0) = x0 + 1,
        
        [terms](x0) = 0
       orientation:
        cons#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = cons#(X1,X2)
        
        cons#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = cons#(X1,X2)
        
        active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
        
        active(sqr(0())) = 1 >= 1 = mark(0())
        
        active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
        
        active(dbl(0())) = 1 >= 1 = mark(0())
        
        active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
        
        active(add(0(),X)) = 1 >= 1 = mark(X)
        
        active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
        
        active(first(0(),X)) = 1 >= 1 = mark(nil())
        
        active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
        
        mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
        
        mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
        
        mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
        
        mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
        
        mark(s(X)) = 1 >= 1 = active(s(X))
        
        mark(0()) = 1 >= 1 = active(0())
        
        mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
        
        mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
        
        mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
        
        mark(nil()) = 1 >= 1 = active(nil())
        
        terms(mark(X)) = 0 >= 0 = terms(X)
        
        terms(active(X)) = 0 >= 0 = terms(X)
        
        cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
        
        cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
        
        recip(mark(X)) = 0 >= 0 = recip(X)
        
        recip(active(X)) = 0 >= 0 = recip(X)
        
        sqr(mark(X)) = 0 >= 0 = sqr(X)
        
        sqr(active(X)) = 0 >= 0 = sqr(X)
        
        s(mark(X)) = 0 >= 0 = s(X)
        
        s(active(X)) = 0 >= 0 = s(X)
        
        add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
        
        add(active(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
        
        dbl(mark(X)) = 0 >= 0 = dbl(X)
        
        dbl(active(X)) = 0 >= 0 = dbl(X)
        
        first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
        
        first(active(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
       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(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [dbl#](x0) = x0 + 1,
      
      [nil] = 0,
      
      [first](x0, x1) = x1 + 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = x0,
      
      [s](x0) = 0,
      
      [recip](x0) = 0,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = 1
     orientation:
      dbl#(mark(X)) = X + 2 >= X + 1 = dbl#(X)
      
      dbl#(active(X)) = X + 1 >= X + 1 = dbl#(X)
      
      active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = X + 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = Y + 1 >= Y + 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = X1 + 1 >= X1 + 1 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = 1 >= 0 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = X2 + 2 >= X2 + 2 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = 1 >= 1 = terms(X)
      
      terms(active(X)) = 1 >= 1 = terms(X)
      
      cons(mark(X1),X2) = X1 + 1 >= X1 = cons(X1,X2)
      
      cons(X1,mark(X2)) = X1 >= X1 = cons(X1,X2)
      
      cons(active(X1),X2) = X1 >= X1 = cons(X1,X2)
      
      cons(X1,active(X2)) = X1 >= X1 = cons(X1,X2)
      
      recip(mark(X)) = 0 >= 0 = recip(X)
      
      recip(active(X)) = 0 >= 0 = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = 1 >= 1 = dbl(X)
      
      dbl(active(X)) = 1 >= 1 = dbl(X)
      
      first(mark(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
      
      first(X1,mark(X2)) = X2 + 2 >= X2 + 1 = first(X1,X2)
      
      first(active(X1),X2) = X2 + 1 >= X2 + 1 = first(X1,X2)
      
      first(X1,active(X2)) = X2 + 1 >= X2 + 1 = first(X1,X2)
     problem:
      DPs:
       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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [dbl#](x0) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 0,
       
       [add](x0, x1) = 0,
       
       [dbl](x0) = 0,
       
       [0] = 0,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 0,
       
       [active](x0) = x0 + 1,
       
       [terms](x0) = 0
      orientation:
       dbl#(active(X)) = X + 2 >= X + 1 = dbl#(X)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = 1 >= 1 = mark(X)
       
       active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
       
       mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 1 = active(s(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 1 = active(nil())
       
       terms(mark(X)) = 0 >= 0 = terms(X)
       
       terms(active(X)) = 0 >= 0 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 0 >= 0 = sqr(X)
       
       sqr(active(X)) = 0 >= 0 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
       
       add(active(X1),X2) = 0 >= 0 = add(X1,X2)
       
       add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
       
       dbl(mark(X)) = 0 >= 0 = dbl(X)
       
       dbl(active(X)) = 0 >= 0 = dbl(X)
       
       first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
       
       first(active(X1),X2) = 0 >= 0 = first(X1,X2)
       
       first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
      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(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,active(X2)) -> add#(X1,X2)
     add#(active(X1),X2) -> add#(X1,X2)
     add#(X1,mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [add#](x0, x1) = x1,
      
      [nil] = 0,
      
      [first](x0, x1) = x0 + 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = x0 + 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = x0,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = x0 + 1
     orientation:
      add#(mark(X1),X2) = X2 >= X2 = add#(X1,X2)
      
      add#(X1,active(X2)) = X2 >= X2 = add#(X1,X2)
      
      add#(active(X1),X2) = X2 >= X2 = add#(X1,X2)
      
      add#(X1,mark(X2)) = X2 + 1 >= X2 = add#(X1,X2)
      
      active(terms(N)) = N + 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = X + 2 >= X + 2 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = X + 1 >= X + 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = X + 2 >= X + 2 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = X1 + 2 >= X1 + 2 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = X + 2 >= X + 1 = terms(X)
      
      terms(active(X)) = X + 1 >= X + 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = X + 1 >= X = recip(X)
      
      recip(active(X)) = X >= X = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = X + 2 >= X + 1 = dbl(X)
      
      dbl(active(X)) = X + 1 >= X + 1 = dbl(X)
      
      first(mark(X1),X2) = X1 + 2 >= X1 + 1 = first(X1,X2)
      
      first(X1,mark(X2)) = X1 + 1 >= X1 + 1 = first(X1,X2)
      
      first(active(X1),X2) = X1 + 1 >= X1 + 1 = first(X1,X2)
      
      first(X1,active(X2)) = X1 + 1 >= X1 + 1 = first(X1,X2)
     problem:
      DPs:
       add#(mark(X1),X2) -> add#(X1,X2)
       add#(X1,active(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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [add#](x0, x1) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 1,
       
       [add](x0, x1) = x1 + 1,
       
       [dbl](x0) = 1,
       
       [0] = 0,
       
       [mark](x0) = x0 + 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 1,
       
       [active](x0) = x0,
       
       [terms](x0) = 1
      orientation:
       add#(mark(X1),X2) = X1 + 2 >= X1 + 1 = add#(X1,X2)
       
       add#(X1,active(X2)) = X1 + 1 >= X1 + 1 = add#(X1,X2)
       
       add#(active(X1),X2) = X1 + 1 >= X1 + 1 = add#(X1,X2)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
       
       active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 0 = active(recip(mark(X)))
       
       mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 0 = active(s(X))
       
       mark(0()) = 1 >= 0 = active(0())
       
       mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 0 = active(nil())
       
       terms(mark(X)) = 1 >= 1 = terms(X)
       
       terms(active(X)) = 1 >= 1 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 1 >= 1 = sqr(X)
       
       sqr(active(X)) = 1 >= 1 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
       
       add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       dbl(mark(X)) = 1 >= 1 = dbl(X)
       
       dbl(active(X)) = 1 >= 1 = dbl(X)
       
       first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
       
       first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
       
       first(active(X1),X2) = 1 >= 1 = first(X1,X2)
       
       first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
      problem:
       DPs:
        add#(X1,active(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(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)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [add#](x0, x1) = x0 + x1 + 1,
        
        [nil] = 0,
        
        [first](x0, x1) = 0,
        
        [add](x0, x1) = 0,
        
        [dbl](x0) = 0,
        
        [0] = 0,
        
        [mark](x0) = 1,
        
        [cons](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [recip](x0) = 0,
        
        [sqr](x0) = 0,
        
        [active](x0) = x0 + 1,
        
        [terms](x0) = 0
       orientation:
        add#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = add#(X1,X2)
        
        add#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = add#(X1,X2)
        
        active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
        
        active(sqr(0())) = 1 >= 1 = mark(0())
        
        active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
        
        active(dbl(0())) = 1 >= 1 = mark(0())
        
        active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
        
        active(add(0(),X)) = 1 >= 1 = mark(X)
        
        active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
        
        active(first(0(),X)) = 1 >= 1 = mark(nil())
        
        active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
        
        mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
        
        mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
        
        mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
        
        mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
        
        mark(s(X)) = 1 >= 1 = active(s(X))
        
        mark(0()) = 1 >= 1 = active(0())
        
        mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
        
        mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
        
        mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
        
        mark(nil()) = 1 >= 1 = active(nil())
        
        terms(mark(X)) = 0 >= 0 = terms(X)
        
        terms(active(X)) = 0 >= 0 = terms(X)
        
        cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
        
        cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
        
        recip(mark(X)) = 0 >= 0 = recip(X)
        
        recip(active(X)) = 0 >= 0 = recip(X)
        
        sqr(mark(X)) = 0 >= 0 = sqr(X)
        
        sqr(active(X)) = 0 >= 0 = sqr(X)
        
        s(mark(X)) = 0 >= 0 = s(X)
        
        s(active(X)) = 0 >= 0 = s(X)
        
        add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
        
        add(active(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
        
        dbl(mark(X)) = 0 >= 0 = dbl(X)
        
        dbl(active(X)) = 0 >= 0 = dbl(X)
        
        first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
        
        first(active(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
       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(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,active(X2)) -> first#(X1,X2)
     first#(active(X1),X2) -> first#(X1,X2)
     first#(X1,mark(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(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)
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [first#](x0, x1) = x1,
      
      [nil] = 0,
      
      [first](x0, x1) = x0 + 1,
      
      [add](x0, x1) = x1 + 1,
      
      [dbl](x0) = x0 + 1,
      
      [0] = 0,
      
      [mark](x0) = x0 + 1,
      
      [cons](x0, x1) = 0,
      
      [s](x0) = 0,
      
      [recip](x0) = x0,
      
      [sqr](x0) = 1,
      
      [active](x0) = x0,
      
      [terms](x0) = x0 + 1
     orientation:
      first#(mark(X1),X2) = X2 >= X2 = first#(X1,X2)
      
      first#(X1,active(X2)) = X2 >= X2 = first#(X1,X2)
      
      first#(active(X1),X2) = X2 >= X2 = first#(X1,X2)
      
      first#(X1,mark(X2)) = X2 + 1 >= X2 = first#(X1,X2)
      
      active(terms(N)) = N + 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
      
      active(sqr(0())) = 1 >= 1 = mark(0())
      
      active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
      
      active(dbl(0())) = 1 >= 1 = mark(0())
      
      active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
      
      active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
      
      active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
      
      active(first(0(),X)) = 1 >= 1 = mark(nil())
      
      active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
      
      mark(terms(X)) = X + 2 >= X + 2 = active(terms(mark(X)))
      
      mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
      
      mark(recip(X)) = X + 1 >= X + 1 = active(recip(mark(X)))
      
      mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
      
      mark(s(X)) = 1 >= 0 = active(s(X))
      
      mark(0()) = 1 >= 0 = active(0())
      
      mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
      
      mark(dbl(X)) = X + 2 >= X + 2 = active(dbl(mark(X)))
      
      mark(first(X1,X2)) = X1 + 2 >= X1 + 2 = active(first(mark(X1),mark(X2)))
      
      mark(nil()) = 1 >= 0 = active(nil())
      
      terms(mark(X)) = X + 2 >= X + 1 = terms(X)
      
      terms(active(X)) = X + 1 >= X + 1 = terms(X)
      
      cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
      
      cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
      
      cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
      
      recip(mark(X)) = X + 1 >= X = recip(X)
      
      recip(active(X)) = X >= X = recip(X)
      
      sqr(mark(X)) = 1 >= 1 = sqr(X)
      
      sqr(active(X)) = 1 >= 1 = sqr(X)
      
      s(mark(X)) = 0 >= 0 = s(X)
      
      s(active(X)) = 0 >= 0 = s(X)
      
      add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
      
      add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
      
      dbl(mark(X)) = X + 2 >= X + 1 = dbl(X)
      
      dbl(active(X)) = X + 1 >= X + 1 = dbl(X)
      
      first(mark(X1),X2) = X1 + 2 >= X1 + 1 = first(X1,X2)
      
      first(X1,mark(X2)) = X1 + 1 >= X1 + 1 = first(X1,X2)
      
      first(active(X1),X2) = X1 + 1 >= X1 + 1 = first(X1,X2)
      
      first(X1,active(X2)) = X1 + 1 >= X1 + 1 = first(X1,X2)
     problem:
      DPs:
       first#(mark(X1),X2) -> first#(X1,X2)
       first#(X1,active(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(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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [first#](x0, x1) = x0 + 1,
       
       [nil] = 0,
       
       [first](x0, x1) = 1,
       
       [add](x0, x1) = x1 + 1,
       
       [dbl](x0) = 1,
       
       [0] = 0,
       
       [mark](x0) = x0 + 1,
       
       [cons](x0, x1) = 0,
       
       [s](x0) = 0,
       
       [recip](x0) = 0,
       
       [sqr](x0) = 1,
       
       [active](x0) = x0,
       
       [terms](x0) = 1
      orientation:
       first#(mark(X1),X2) = X1 + 2 >= X1 + 1 = first#(X1,X2)
       
       first#(X1,active(X2)) = X1 + 1 >= X1 + 1 = first#(X1,X2)
       
       first#(active(X1),X2) = X1 + 1 >= X1 + 1 = first#(X1,X2)
       
       active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
       
       active(sqr(0())) = 1 >= 1 = mark(0())
       
       active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
       
       active(dbl(0())) = 1 >= 1 = mark(0())
       
       active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
       
       active(add(0(),X)) = X + 1 >= X + 1 = mark(X)
       
       active(add(s(X),Y)) = Y + 1 >= 1 = mark(s(add(X,Y)))
       
       active(first(0(),X)) = 1 >= 1 = mark(nil())
       
       active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
       
       mark(terms(X)) = 2 >= 1 = active(terms(mark(X)))
       
       mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2))
       
       mark(recip(X)) = 1 >= 0 = active(recip(mark(X)))
       
       mark(sqr(X)) = 2 >= 1 = active(sqr(mark(X)))
       
       mark(s(X)) = 1 >= 0 = active(s(X))
       
       mark(0()) = 1 >= 0 = active(0())
       
       mark(add(X1,X2)) = X2 + 2 >= X2 + 2 = active(add(mark(X1),mark(X2)))
       
       mark(dbl(X)) = 2 >= 1 = active(dbl(mark(X)))
       
       mark(first(X1,X2)) = 2 >= 1 = active(first(mark(X1),mark(X2)))
       
       mark(nil()) = 1 >= 0 = active(nil())
       
       terms(mark(X)) = 1 >= 1 = terms(X)
       
       terms(active(X)) = 1 >= 1 = terms(X)
       
       cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
       
       cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
       
       cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
       
       recip(mark(X)) = 0 >= 0 = recip(X)
       
       recip(active(X)) = 0 >= 0 = recip(X)
       
       sqr(mark(X)) = 1 >= 1 = sqr(X)
       
       sqr(active(X)) = 1 >= 1 = sqr(X)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       add(mark(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,mark(X2)) = X2 + 2 >= X2 + 1 = add(X1,X2)
       
       add(active(X1),X2) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       add(X1,active(X2)) = X2 + 1 >= X2 + 1 = add(X1,X2)
       
       dbl(mark(X)) = 1 >= 1 = dbl(X)
       
       dbl(active(X)) = 1 >= 1 = dbl(X)
       
       first(mark(X1),X2) = 1 >= 1 = first(X1,X2)
       
       first(X1,mark(X2)) = 1 >= 1 = first(X1,X2)
       
       first(active(X1),X2) = 1 >= 1 = first(X1,X2)
       
       first(X1,active(X2)) = 1 >= 1 = first(X1,X2)
      problem:
       DPs:
        first#(X1,active(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(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)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [first#](x0, x1) = x0 + x1 + 1,
        
        [nil] = 0,
        
        [first](x0, x1) = 0,
        
        [add](x0, x1) = 0,
        
        [dbl](x0) = 0,
        
        [0] = 0,
        
        [mark](x0) = 1,
        
        [cons](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [recip](x0) = 0,
        
        [sqr](x0) = 0,
        
        [active](x0) = x0 + 1,
        
        [terms](x0) = 0
       orientation:
        first#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = first#(X1,X2)
        
        first#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = first#(X1,X2)
        
        active(terms(N)) = 1 >= 1 = mark(cons(recip(sqr(N)),terms(s(N))))
        
        active(sqr(0())) = 1 >= 1 = mark(0())
        
        active(sqr(s(X))) = 1 >= 1 = mark(s(add(sqr(X),dbl(X))))
        
        active(dbl(0())) = 1 >= 1 = mark(0())
        
        active(dbl(s(X))) = 1 >= 1 = mark(s(s(dbl(X))))
        
        active(add(0(),X)) = 1 >= 1 = mark(X)
        
        active(add(s(X),Y)) = 1 >= 1 = mark(s(add(X,Y)))
        
        active(first(0(),X)) = 1 >= 1 = mark(nil())
        
        active(first(s(X),cons(Y,Z))) = 1 >= 1 = mark(cons(Y,first(X,Z)))
        
        mark(terms(X)) = 1 >= 1 = active(terms(mark(X)))
        
        mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2))
        
        mark(recip(X)) = 1 >= 1 = active(recip(mark(X)))
        
        mark(sqr(X)) = 1 >= 1 = active(sqr(mark(X)))
        
        mark(s(X)) = 1 >= 1 = active(s(X))
        
        mark(0()) = 1 >= 1 = active(0())
        
        mark(add(X1,X2)) = 1 >= 1 = active(add(mark(X1),mark(X2)))
        
        mark(dbl(X)) = 1 >= 1 = active(dbl(mark(X)))
        
        mark(first(X1,X2)) = 1 >= 1 = active(first(mark(X1),mark(X2)))
        
        mark(nil()) = 1 >= 1 = active(nil())
        
        terms(mark(X)) = 0 >= 0 = terms(X)
        
        terms(active(X)) = 0 >= 0 = terms(X)
        
        cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2)
        
        cons(active(X1),X2) = 0 >= 0 = cons(X1,X2)
        
        cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2)
        
        recip(mark(X)) = 0 >= 0 = recip(X)
        
        recip(active(X)) = 0 >= 0 = recip(X)
        
        sqr(mark(X)) = 0 >= 0 = sqr(X)
        
        sqr(active(X)) = 0 >= 0 = sqr(X)
        
        s(mark(X)) = 0 >= 0 = s(X)
        
        s(active(X)) = 0 >= 0 = s(X)
        
        add(mark(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,mark(X2)) = 0 >= 0 = add(X1,X2)
        
        add(active(X1),X2) = 0 >= 0 = add(X1,X2)
        
        add(X1,active(X2)) = 0 >= 0 = add(X1,X2)
        
        dbl(mark(X)) = 0 >= 0 = dbl(X)
        
        dbl(active(X)) = 0 >= 0 = dbl(X)
        
        first(mark(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,mark(X2)) = 0 >= 0 = first(X1,X2)
        
        first(active(X1),X2) = 0 >= 0 = first(X1,X2)
        
        first(X1,active(X2)) = 0 >= 0 = first(X1,X2)
       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(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