- : unit = ()
h : heuristic = <heuristic>
- : unit = ()
APPLY CRITERIA (Marked dependency pairs)

TRS termination of:
[1] active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
[2] active(sqr(0)) -> mark(0)
[3] active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
[4] active(dbl(0)) -> mark(0)
[5] active(dbl(s(X))) -> mark(s(s(dbl(X))))
[6] active(add(0,X)) -> mark(X)
[7] active(add(s(X),Y)) -> mark(s(add(X,Y)))
[8] active(first(0,X)) -> mark(nil)
[9] active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
[10] mark(terms(X)) -> active(terms(mark(X)))
[11] mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
[12] mark(recip(X)) -> active(recip(mark(X)))
[13] mark(sqr(X)) -> active(sqr(mark(X)))
[14] mark(s(X)) -> active(s(X))
[15] mark(0) -> active(0)
[16] mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
[17] mark(dbl(X)) -> active(dbl(mark(X)))
[18] mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
[19] mark(nil) -> active(nil)
[20] terms(mark(X)) -> terms(X)
[21] terms(active(X)) -> terms(X)
[22] cons(mark(X1),X2) -> cons(X1,X2)
[23] cons(X1,mark(X2)) -> cons(X1,X2)
[24] cons(active(X1),X2) -> cons(X1,X2)
[25] cons(X1,active(X2)) -> cons(X1,X2)
[26] recip(mark(X)) -> recip(X)
[27] recip(active(X)) -> recip(X)
[28] sqr(mark(X)) -> sqr(X)
[29] sqr(active(X)) -> sqr(X)
[30] s(mark(X)) -> s(X)
[31] s(active(X)) -> s(X)
[32] add(mark(X1),X2) -> add(X1,X2)
[33] add(X1,mark(X2)) -> add(X1,X2)
[34] add(active(X1),X2) -> add(X1,X2)
[35] add(X1,active(X2)) -> add(X1,X2)
[36] dbl(mark(X)) -> dbl(X)
[37] dbl(active(X)) -> dbl(X)
[38] first(mark(X1),X2) -> first(X1,X2)
[39] first(X1,mark(X2)) -> first(X1,X2)
[40] first(active(X1),X2) -> first(X1,X2)
[41] first(X1,active(X2)) -> first(X1,X2)


Sub problem: 
guided: 

DP termination of:
<Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(terms(N)) , Marked_cons(recip(sqr(N)),terms(s(N)))>
<Marked_active(terms(N)) , Marked_recip(sqr(N))>
<Marked_active(terms(N)) , Marked_sqr(N)>
<Marked_active(terms(N)) , Marked_terms(s(N))>
<Marked_active(terms(N)) , Marked_s(N)>
<Marked_active(sqr(0)) , Marked_mark(0)>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(sqr(s(X))) , Marked_s(add(sqr(X),dbl(X)))>
<Marked_active(sqr(s(X))) , Marked_add(sqr(X),dbl(X))>
<Marked_active(sqr(s(X))) , Marked_sqr(X)>
<Marked_active(sqr(s(X))) , Marked_dbl(X)>
<Marked_active(dbl(0)) , Marked_mark(0)>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_s(s(dbl(X)))>
<Marked_active(dbl(s(X))) , Marked_s(dbl(X))>
<Marked_active(dbl(s(X))) , Marked_dbl(X)>
<Marked_active(add(0,X)) , Marked_mark(X)>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_active(add(s(X),Y)) , Marked_s(add(X,Y))>
<Marked_active(add(s(X),Y)) , Marked_add(X,Y)>
<Marked_active(first(0,X)) , Marked_mark(nil)>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_cons(Y,first(X,Z))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_first(X,Z)>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_terms(mark(X))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_cons(mark(X1),X2)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_recip(mark(X))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_sqr(mark(X))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(0) , Marked_active(0)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_add(mark(X1),mark(X2))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_dbl(mark(X))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
<Marked_mark(first(X1,X2)) , Marked_first(mark(X1),mark(X2))>
<Marked_mark(first(X1,X2)) , Marked_mark(X1)>
<Marked_mark(first(X1,X2)) , Marked_mark(X2)>
<Marked_mark(nil) , Marked_active(nil)>
<Marked_terms(mark(X)) , Marked_terms(X)>
<Marked_terms(active(X)) , Marked_terms(X)>
<Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
<Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
<Marked_recip(mark(X)) , Marked_recip(X)>
<Marked_recip(active(X)) , Marked_recip(X)>
<Marked_sqr(mark(X)) , Marked_sqr(X)>
<Marked_sqr(active(X)) , Marked_sqr(X)>
<Marked_s(mark(X)) , Marked_s(X)>
<Marked_s(active(X)) , Marked_s(X)>
<Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
<Marked_add(active(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
<Marked_dbl(mark(X)) , Marked_dbl(X)>
<Marked_dbl(active(X)) , Marked_dbl(X)>
<Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
<Marked_first(active(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
 
END GUIDED
APPLY CRITERIA (Graph splitting)
Found 9 components:

{  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
      --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(add(0,X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(add(0,X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}

{  <Marked_terms(active(X)) , Marked_terms(X)> 
      --> <Marked_terms(active(X)) , Marked_terms(X)>
  <Marked_terms(active(X)) , Marked_terms(X)> 
     --> <Marked_terms(mark(X)) , Marked_terms(X)>
  <Marked_terms(mark(X)) , Marked_terms(X)> 
     --> <Marked_terms(active(X)) , Marked_terms(X)>
  <Marked_terms(mark(X)) , Marked_terms(X)> 
     --> <Marked_terms(mark(X)) , Marked_terms(X)>
}

{  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
      --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
}

{  <Marked_recip(active(X)) , Marked_recip(X)> 
      --> <Marked_recip(active(X)) , Marked_recip(X)>
  <Marked_recip(active(X)) , Marked_recip(X)> 
     --> <Marked_recip(mark(X)) , Marked_recip(X)>
  <Marked_recip(mark(X)) , Marked_recip(X)> 
     --> <Marked_recip(active(X)) , Marked_recip(X)>
  <Marked_recip(mark(X)) , Marked_recip(X)> 
     --> <Marked_recip(mark(X)) , Marked_recip(X)>
}

{  <Marked_sqr(active(X)) , Marked_sqr(X)> 
      --> <Marked_sqr(active(X)) , Marked_sqr(X)>
  <Marked_sqr(active(X)) , Marked_sqr(X)> 
     --> <Marked_sqr(mark(X)) , Marked_sqr(X)>
  <Marked_sqr(mark(X)) , Marked_sqr(X)> 
     --> <Marked_sqr(active(X)) , Marked_sqr(X)>
  <Marked_sqr(mark(X)) , Marked_sqr(X)> 
     --> <Marked_sqr(mark(X)) , Marked_sqr(X)>
}

{  <Marked_s(active(X)) , Marked_s(X)> --> <Marked_s(active(X)) , Marked_s(X)>
  <Marked_s(active(X)) , Marked_s(X)> --> <Marked_s(mark(X)) , Marked_s(X)>
  <Marked_s(mark(X)) , Marked_s(X)> --> <Marked_s(active(X)) , Marked_s(X)>
  <Marked_s(mark(X)) , Marked_s(X)> --> <Marked_s(mark(X)) , Marked_s(X)>
}

{  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
      --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
  <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(mark(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(mark(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(mark(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
  <Marked_add(mark(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
}

{  <Marked_dbl(active(X)) , Marked_dbl(X)> 
      --> <Marked_dbl(active(X)) , Marked_dbl(X)>
  <Marked_dbl(active(X)) , Marked_dbl(X)> 
     --> <Marked_dbl(mark(X)) , Marked_dbl(X)>
  <Marked_dbl(mark(X)) , Marked_dbl(X)> 
     --> <Marked_dbl(active(X)) , Marked_dbl(X)>
  <Marked_dbl(mark(X)) , Marked_dbl(X)> 
     --> <Marked_dbl(mark(X)) , Marked_dbl(X)>
}

{  <Marked_first(X1,active(X2)) , Marked_first(X1,X2)> 
      --> <Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
  <Marked_first(X1,active(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(active(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(X1,active(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
  <Marked_first(X1,active(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(active(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
  <Marked_first(active(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(active(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(active(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
  <Marked_first(active(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
  <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(active(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
  <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)> 
     --> <Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(mark(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
  <Marked_first(mark(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(active(X1),X2) , Marked_first(X1,X2)>
  <Marked_first(mark(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
  <Marked_first(mark(X1),X2) , Marked_first(X1,X2)> 
     --> <Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2)) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(recip(X)) >= Marked_active(recip(mark(X))) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_mark(X) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(s(X)) >= Marked_active(s(X)) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_mark(first(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(first(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
  Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
  Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y))) ;
  Marked_active(add(0,X)) >= Marked_mark(X) ;
  Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X)))) ;
  Marked_active(first(s(X),cons(Y,Z))) >= Marked_mark(cons(Y,first(X,Z))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(cons(X1,X2)) > Marked_active(cons(mark(X1),X2)) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(recip(X)) > Marked_active(recip(mark(X))) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(s(X)) > Marked_active(s(X)) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_active(first(mark(X1),mark(X2))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
{
  Marked_active(terms(N)) > Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
{
  Marked_active(add(s(X),Y)) > Marked_mark(s(add(X,Y))) ;
 }
{
  Marked_active(add(0,X)) > Marked_mark(X) ;
 }
{
  Marked_active(dbl(s(X))) > Marked_mark(s(s(dbl(X)))) ;
 }
{
  Marked_active(first(s(X),cons(Y,Z))) > Marked_mark(cons(Y,first(X,Z))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2))
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(recip(X)) >= Marked_active(recip(mark(X)))
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_mark(X)
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(s(X)) >= Marked_active(s(X))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_mark(first(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(first(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
constraint: Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),
                                                    terms(s(N))))
constraint: Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y)))
constraint: Marked_active(add(0,X)) >= Marked_mark(X)
constraint: Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X))))
constraint: Marked_active(first(s(X),cons(Y,Z))) >= Marked_mark(cons(
                                                                 Y,first(X,Z)))
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_terms(mark(X)) >= Marked_terms(X) ;
  Marked_terms(active(X)) >= Marked_terms(X) ;
 }
 + Disjunctions:{ 
{
  Marked_terms(mark(X)) > Marked_terms(X) ;
 }
{
  Marked_terms(active(X)) > Marked_terms(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_terms(mark(X)) >= Marked_terms(X)
constraint: Marked_terms(active(X)) >= Marked_terms(X)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_cons(mark(X1),X2) >= Marked_cons(X1,X2) ;
  Marked_cons(active(X1),X2) >= Marked_cons(X1,X2) ;
  Marked_cons(X1,mark(X2)) >= Marked_cons(X1,X2) ;
  Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_cons(mark(X1),X2) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(active(X1),X2) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(X1,mark(X2)) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(X1,active(X2)) > Marked_cons(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_cons(mark(X1),X2) >= Marked_cons(X1,X2)
constraint: Marked_cons(active(X1),X2) >= Marked_cons(X1,X2)
constraint: Marked_cons(X1,mark(X2)) >= Marked_cons(X1,X2)
constraint: Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_recip(mark(X)) >= Marked_recip(X) ;
  Marked_recip(active(X)) >= Marked_recip(X) ;
 }
 + Disjunctions:{ 
{
  Marked_recip(mark(X)) > Marked_recip(X) ;
 }
{
  Marked_recip(active(X)) > Marked_recip(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_recip(mark(X)) >= Marked_recip(X)
constraint: Marked_recip(active(X)) >= Marked_recip(X)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_sqr(mark(X)) >= Marked_sqr(X) ;
  Marked_sqr(active(X)) >= Marked_sqr(X) ;
 }
 + Disjunctions:{ 
{
  Marked_sqr(mark(X)) > Marked_sqr(X) ;
 }
{
  Marked_sqr(active(X)) > Marked_sqr(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_sqr(mark(X)) >= Marked_sqr(X)
constraint: Marked_sqr(active(X)) >= Marked_sqr(X)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_s(mark(X)) >= Marked_s(X) ;
  Marked_s(active(X)) >= Marked_s(X) ;
 }
 + Disjunctions:{ 
{
  Marked_s(mark(X)) > Marked_s(X) ;
 }
{
  Marked_s(active(X)) > Marked_s(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_s(mark(X)) >= Marked_s(X)
constraint: Marked_s(active(X)) >= Marked_s(X)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_add(mark(X1),X2) >= Marked_add(X1,X2) ;
  Marked_add(active(X1),X2) >= Marked_add(X1,X2) ;
  Marked_add(X1,mark(X2)) >= Marked_add(X1,X2) ;
  Marked_add(X1,active(X2)) >= Marked_add(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_add(mark(X1),X2) > Marked_add(X1,X2) ;
 }
{
  Marked_add(active(X1),X2) > Marked_add(X1,X2) ;
 }
{
  Marked_add(X1,mark(X2)) > Marked_add(X1,X2) ;
 }
{
  Marked_add(X1,active(X2)) > Marked_add(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_add(mark(X1),X2) >= Marked_add(X1,X2)
constraint: Marked_add(active(X1),X2) >= Marked_add(X1,X2)
constraint: Marked_add(X1,mark(X2)) >= Marked_add(X1,X2)
constraint: Marked_add(X1,active(X2)) >= Marked_add(X1,X2)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_dbl(mark(X)) >= Marked_dbl(X) ;
  Marked_dbl(active(X)) >= Marked_dbl(X) ;
 }
 + Disjunctions:{ 
{
  Marked_dbl(mark(X)) > Marked_dbl(X) ;
 }
{
  Marked_dbl(active(X)) > Marked_dbl(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_dbl(mark(X)) >= Marked_dbl(X)
constraint: Marked_dbl(active(X)) >= Marked_dbl(X)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_first(mark(X1),X2) >= Marked_first(X1,X2) ;
  Marked_first(active(X1),X2) >= Marked_first(X1,X2) ;
  Marked_first(X1,mark(X2)) >= Marked_first(X1,X2) ;
  Marked_first(X1,active(X2)) >= Marked_first(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_first(mark(X1),X2) > Marked_first(X1,X2) ;
 }
{
  Marked_first(active(X1),X2) > Marked_first(X1,X2) ;
 }
{
  Marked_first(X1,mark(X2)) > Marked_first(X1,X2) ;
 }
{
  Marked_first(X1,active(X2)) > Marked_first(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_first(mark(X1),X2) >= Marked_first(X1,X2)
constraint: Marked_first(active(X1),X2) >= Marked_first(X1,X2)
constraint: Marked_first(X1,mark(X2)) >= Marked_first(X1,X2)
constraint: Marked_first(X1,active(X2)) >= Marked_first(X1,X2)
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
      --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(first(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2)) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(recip(X)) >= Marked_active(recip(mark(X))) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_mark(X) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(s(X)) >= Marked_active(s(X)) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_mark(first(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(first(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
  Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
  Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y))) ;
  Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X)))) ;
  Marked_active(first(s(X),cons(Y,Z))) >= Marked_mark(cons(Y,first(X,Z))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(cons(X1,X2)) > Marked_active(cons(mark(X1),X2)) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(recip(X)) > Marked_active(recip(mark(X))) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(s(X)) > Marked_active(s(X)) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_active(first(mark(X1),mark(X2))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
{
  Marked_active(terms(N)) > Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
{
  Marked_active(add(s(X),Y)) > Marked_mark(s(add(X,Y))) ;
 }
{
  Marked_active(dbl(s(X))) > Marked_mark(s(s(dbl(X)))) ;
 }
{
  Marked_active(first(s(X),cons(Y,Z))) > Marked_mark(cons(Y,first(X,Z))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2))
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(recip(X)) >= Marked_active(recip(mark(X)))
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_mark(X)
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(s(X)) >= Marked_active(s(X))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_mark(first(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(first(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
constraint: Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),
                                                    terms(s(N))))
constraint: Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y)))
constraint: Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X))))
constraint: Marked_active(first(s(X),cons(Y,Z))) >= Marked_mark(cons(
                                                                 Y,first(X,Z)))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
      --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(s(X)) , Marked_active(s(X))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(s(X)) , Marked_active(s(X))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2)) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(recip(X)) >= Marked_active(recip(mark(X))) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_mark(X) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(s(X)) >= Marked_active(s(X)) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
  Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
  Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y))) ;
  Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(cons(X1,X2)) > Marked_active(cons(mark(X1),X2)) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(recip(X)) > Marked_active(recip(mark(X))) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(s(X)) > Marked_active(s(X)) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_mark(first(X1,X2)) > Marked_active(first(mark(X1),mark(X2))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
{
  Marked_active(terms(N)) > Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
{
  Marked_active(add(s(X),Y)) > Marked_mark(s(add(X,Y))) ;
 }
{
  Marked_active(dbl(s(X))) > Marked_mark(s(s(dbl(X)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(cons(X1,X2)) >= Marked_active(cons(mark(X1),X2))
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(recip(X)) >= Marked_active(recip(mark(X)))
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_mark(X)
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(s(X)) >= Marked_active(s(X))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_mark(first(X1,X2)) >= Marked_active(first(mark(X1),mark(X2)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
constraint: Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),
                                                    terms(s(N))))
constraint: Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y)))
constraint: Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(dbl(X)) , Marked_mark(X)> 
      --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_mark(X) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
  Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
  Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y))) ;
  Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
{
  Marked_active(terms(N)) > Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
{
  Marked_active(add(s(X),Y)) > Marked_mark(s(add(X,Y))) ;
 }
{
  Marked_active(dbl(s(X))) > Marked_mark(s(s(dbl(X)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_mark(X)
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
constraint: Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),
                                                    terms(s(N))))
constraint: Marked_active(add(s(X),Y)) >= Marked_mark(s(add(X,Y)))
constraint: Marked_active(dbl(s(X))) >= Marked_mark(s(s(dbl(X))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(dbl(X)) , Marked_mark(X)> 
      --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_mark(terms(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_mark(X)>
  <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_mark(X) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
  Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
{
  Marked_active(terms(N)) > Marked_mark(cons(recip(sqr(N)),terms(s(N)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_mark(X)
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
constraint: Marked_active(terms(N)) >= Marked_mark(cons(recip(sqr(N)),
                                                    terms(s(N))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(dbl(X)) , Marked_mark(X)> 
      --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
  <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(terms(X)) >= Marked_active(terms(mark(X))) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2))) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X))) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(terms(X)) > Marked_active(terms(mark(X))) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_active(add(mark(X1),mark(X2))) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(dbl(X)) > Marked_active(dbl(mark(X))) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(terms(X)) >= Marked_active(terms(mark(X)))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(add(X1,X2)) >= Marked_active(add(mark(X1),mark(X2)))
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_mark(dbl(X)) >= Marked_active(dbl(mark(X)))
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(dbl(X)) , Marked_mark(X)> 
      --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(cons(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(cons(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(cons(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(cons(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(dbl(X)) , Marked_mark(X)> 
      --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(dbl(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(sqr(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))> 
     --> <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(dbl(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_mark(X)>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
  <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_mark(X) ;
  Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X))) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
  Marked_mark(dbl(X)) >= Marked_mark(X) ;
  Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(sqr(X)) > Marked_active(sqr(mark(X))) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
{
  Marked_mark(dbl(X)) > Marked_mark(X) ;
 }
{
  Marked_active(sqr(s(X))) > Marked_mark(s(add(sqr(X),dbl(X)))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_mark(X)
constraint: Marked_mark(sqr(X)) >= Marked_active(sqr(mark(X)))
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
constraint: Marked_mark(dbl(X)) >= Marked_mark(X)
constraint: Marked_active(sqr(s(X))) >= Marked_mark(s(add(sqr(X),dbl(X))))
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
      --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X2)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(add(X1,X2)) , Marked_mark(X1)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X2)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(add(X1,X2)) , Marked_mark(X1)>
  <Marked_mark(recip(X)) , Marked_mark(X)> 
     --> <Marked_mark(recip(X)) , Marked_mark(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X1) ;
  Marked_mark(add(X1,X2)) >= Marked_mark(X2) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X1) ;
 }
{
  Marked_mark(add(X1,X2)) > Marked_mark(X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X1)
constraint: Marked_mark(add(X1,X2)) >= Marked_mark(X2)
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_mark(recip(X)) , Marked_mark(X)> 
      --> <Marked_mark(recip(X)) , Marked_mark(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_mark(recip(X)) >= Marked_mark(X) ;
 }
 + Disjunctions:{ 
{
  Marked_mark(recip(X)) > Marked_mark(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_mark(recip(X)) >= Marked_mark(X)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_terms(active(X)) , Marked_terms(X)> 
      --> <Marked_terms(active(X)) , Marked_terms(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_terms(active(X)) >= Marked_terms(X) ;
 }
 + Disjunctions:{ 
{
  Marked_terms(active(X)) > Marked_terms(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_terms(active(X)) >= Marked_terms(X)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
      --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_cons(mark(X1),X2) >= Marked_cons(X1,X2) ;
  Marked_cons(active(X1),X2) >= Marked_cons(X1,X2) ;
  Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_cons(mark(X1),X2) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(active(X1),X2) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(X1,active(X2)) > Marked_cons(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_cons(mark(X1),X2) >= Marked_cons(X1,X2)
constraint: Marked_cons(active(X1),X2) >= Marked_cons(X1,X2)
constraint: Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2)
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
      --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
  <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)> 
     --> <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_cons(active(X1),X2) >= Marked_cons(X1,X2) ;
  Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_cons(active(X1),X2) > Marked_cons(X1,X2) ;
 }
{
  Marked_cons(X1,active(X2)) > Marked_cons(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_cons(active(X1),X2) >= Marked_cons(X1,X2)
constraint: Marked_cons(X1,active(X2)) >= Marked_cons(X1,X2)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_recip(active(X)) , Marked_recip(X)> 
      --> <Marked_recip(active(X)) , Marked_recip(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_recip(active(X)) >= Marked_recip(X) ;
 }
 + Disjunctions:{ 
{
  Marked_recip(active(X)) > Marked_recip(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_recip(active(X)) >= Marked_recip(X)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_s(active(X)) , Marked_s(X)> --> <Marked_s(active(X)) , Marked_s(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_s(active(X)) >= Marked_s(X) ;
 }
 + Disjunctions:{ 
{
  Marked_s(active(X)) > Marked_s(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_s(active(X)) >= Marked_s(X)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
      --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(X1,active(X2)) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
  <Marked_add(active(X1),X2) , Marked_add(X1,X2)> 
     --> <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_add(active(X1),X2) >= Marked_add(X1,X2) ;
  Marked_add(X1,active(X2)) >= Marked_add(X1,X2) ;
 }
 + Disjunctions:{ 
{
  Marked_add(active(X1),X2) > Marked_add(X1,X2) ;
 }
{
  Marked_add(X1,active(X2)) > Marked_add(X1,X2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_add(active(X1),X2) >= Marked_add(X1,X2)
constraint: Marked_add(X1,active(X2)) >= Marked_add(X1,X2)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_dbl(active(X)) , Marked_dbl(X)> 
      --> <Marked_dbl(active(X)) , Marked_dbl(X)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  mark(cons(X1,X2)) >= active(cons(mark(X1),X2)) ;
  mark(recip(X)) >= active(recip(mark(X))) ;
  mark(sqr(X)) >= active(sqr(mark(X))) ;
  mark(terms(X)) >= active(terms(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(nil) >= active(nil) ;
  mark(first(X1,X2)) >= active(first(mark(X1),mark(X2))) ;
  cons(mark(X1),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) ;
  recip(mark(X)) >= recip(X) ;
  recip(active(X)) >= recip(X) ;
  sqr(mark(X)) >= sqr(X) ;
  sqr(active(X)) >= sqr(X) ;
  terms(mark(X)) >= terms(X) ;
  terms(active(X)) >= terms(X) ;
  s(mark(X)) >= s(X) ;
  s(active(X)) >= s(X) ;
  active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X)))) ;
  active(sqr(0)) >= mark(0) ;
  active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N)))) ;
  active(add(s(X),Y)) >= mark(s(add(X,Y))) ;
  active(add(0,X)) >= mark(X) ;
  active(dbl(s(X))) >= mark(s(s(dbl(X)))) ;
  active(dbl(0)) >= mark(0) ;
  active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z))) ;
  active(first(0,X)) >= mark(nil) ;
  add(mark(X1),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) ;
  dbl(mark(X)) >= dbl(X) ;
  dbl(active(X)) >= dbl(X) ;
  first(mark(X1),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) ;
  Marked_dbl(active(X)) >= Marked_dbl(X) ;
 }
 + Disjunctions:{ 
{
  Marked_dbl(active(X)) > Marked_dbl(X) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: mark(cons(X1,X2)) >= active(cons(mark(X1),X2))
constraint: mark(recip(X)) >= active(recip(mark(X)))
constraint: mark(sqr(X)) >= active(sqr(mark(X)))
constraint: mark(terms(X)) >= active(terms(mark(X)))
constraint: mark(s(X)) >= active(s(X))
constraint: mark(0) >= active(0)
constraint: mark(add(X1,X2)) >= active(add(mark(X1),mark(X2)))
constraint: mark(dbl(X)) >= active(dbl(mark(X)))
constraint: mark(nil) >= active(nil)
constraint: mark(first(X1,X2)) >= active(first(mark(X1),mark(X2)))
constraint: cons(mark(X1),X2) >= cons(X1,X2)
constraint: cons(active(X1),X2) >= cons(X1,X2)
constraint: cons(X1,mark(X2)) >= cons(X1,X2)
constraint: cons(X1,active(X2)) >= cons(X1,X2)
constraint: recip(mark(X)) >= recip(X)
constraint: recip(active(X)) >= recip(X)
constraint: sqr(mark(X)) >= sqr(X)
constraint: sqr(active(X)) >= sqr(X)
constraint: terms(mark(X)) >= terms(X)
constraint: terms(active(X)) >= terms(X)
constraint: s(mark(X)) >= s(X)
constraint: s(active(X)) >= s(X)
constraint: active(sqr(s(X))) >= mark(s(add(sqr(X),dbl(X))))
constraint: active(sqr(0)) >= mark(0)
constraint: active(terms(N)) >= mark(cons(recip(sqr(N)),terms(s(N))))
constraint: active(add(s(X),Y)) >= mark(s(add(X,Y)))
constraint: active(add(0,X)) >= mark(X)
constraint: active(dbl(s(X))) >= mark(s(s(dbl(X))))
constraint: active(dbl(0)) >= mark(0)
constraint: active(first(s(X),cons(Y,Z))) >= mark(cons(Y,first(X,Z)))
constraint: active(first(0,X)) >= mark(nil)
constraint: add(mark(X1),X2) >= add(X1,X2)
constraint: add(active(X1),X2) >= add(X1,X2)
constraint: add(X1,mark(X2)) >= add(X1,X2)
constraint: add(X1,active(X2)) >= add(X1,X2)
constraint: dbl(mark(X)) >= dbl(X)
constraint: dbl(active(X)) >= dbl(X)
constraint: first(mark(X1),X2) >= first(X1,X2)
constraint: first(active(X1),X2) >= first(X1,X2)
constraint: first(X1,mark(X2)) >= first(X1,X2)
constraint: first(X1,active(X2)) >= first(X1,X2)
constraint: Marked_dbl(active(X)) >= Marked_dbl(X)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
SOLVED
{
 
TRS termination of:
[1] active(terms(N)) -> mark(cons(recip(sqr(N)),terms(s(N))))
[2] active(sqr(0)) -> mark(0)
[3] active(sqr(s(X))) -> mark(s(add(sqr(X),dbl(X))))
[4] active(dbl(0)) -> mark(0)
[5] active(dbl(s(X))) -> mark(s(s(dbl(X))))
[6] active(add(0,X)) -> mark(X)
[7] active(add(s(X),Y)) -> mark(s(add(X,Y)))
[8] active(first(0,X)) -> mark(nil)
[9] active(first(s(X),cons(Y,Z))) -> mark(cons(Y,first(X,Z)))
[10] mark(terms(X)) -> active(terms(mark(X)))
[11] mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
[12] mark(recip(X)) -> active(recip(mark(X)))
[13] mark(sqr(X)) -> active(sqr(mark(X)))
[14] mark(s(X)) -> active(s(X))
[15] mark(0) -> active(0)
[16] mark(add(X1,X2)) -> active(add(mark(X1),mark(X2)))
[17] mark(dbl(X)) -> active(dbl(mark(X)))
[18] mark(first(X1,X2)) -> active(first(mark(X1),mark(X2)))
[19] mark(nil) -> active(nil)
[20] terms(mark(X)) -> terms(X)
[21] terms(active(X)) -> terms(X)
[22] cons(mark(X1),X2) -> cons(X1,X2)
[23] cons(X1,mark(X2)) -> cons(X1,X2)
[24] cons(active(X1),X2) -> cons(X1,X2)
[25] cons(X1,active(X2)) -> cons(X1,X2)
[26] recip(mark(X)) -> recip(X)
[27] recip(active(X)) -> recip(X)
[28] sqr(mark(X)) -> sqr(X)
[29] sqr(active(X)) -> sqr(X)
[30] s(mark(X)) -> s(X)
[31] s(active(X)) -> s(X)
[32] add(mark(X1),X2) -> add(X1,X2)
[33] add(X1,mark(X2)) -> add(X1,X2)
[34] add(active(X1),X2) -> add(X1,X2)
[35] add(X1,active(X2)) -> add(X1,X2)
[36] dbl(mark(X)) -> dbl(X)
[37] dbl(active(X)) -> dbl(X)
[38] first(mark(X1),X2) -> first(X1,X2)
[39] first(X1,mark(X2)) -> first(X1,X2)
[40] first(active(X1),X2) -> first(X1,X2)
[41] first(X1,active(X2)) -> first(X1,X2)
 ,
 CRITERION: MDP
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(terms(N)) , Marked_cons(recip(sqr(N)),terms(s(N)))>
<Marked_active(terms(N)) , Marked_recip(sqr(N))>
<Marked_active(terms(N)) , Marked_sqr(N)>
<Marked_active(terms(N)) , Marked_terms(s(N))>
<Marked_active(terms(N)) , Marked_s(N)>
<Marked_active(sqr(0)) , Marked_mark(0)>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(sqr(s(X))) , Marked_s(add(sqr(X),dbl(X)))>
<Marked_active(sqr(s(X))) , Marked_add(sqr(X),dbl(X))>
<Marked_active(sqr(s(X))) , Marked_sqr(X)>
<Marked_active(sqr(s(X))) , Marked_dbl(X)>
<Marked_active(dbl(0)) , Marked_mark(0)>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_s(s(dbl(X)))>
<Marked_active(dbl(s(X))) , Marked_s(dbl(X))>
<Marked_active(dbl(s(X))) , Marked_dbl(X)>
<Marked_active(add(0,X)) , Marked_mark(X)>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_active(add(s(X),Y)) , Marked_s(add(X,Y))>
<Marked_active(add(s(X),Y)) , Marked_add(X,Y)>
<Marked_active(first(0,X)) , Marked_mark(nil)>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_cons(Y,first(X,Z))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_first(X,Z)>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_terms(mark(X))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_cons(mark(X1),X2)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_recip(mark(X))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_sqr(mark(X))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(0) , Marked_active(0)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_add(mark(X1),mark(X2))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_dbl(mark(X))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
<Marked_mark(first(X1,X2)) , Marked_first(mark(X1),mark(X2))>
<Marked_mark(first(X1,X2)) , Marked_mark(X1)>
<Marked_mark(first(X1,X2)) , Marked_mark(X2)>
<Marked_mark(nil) , Marked_active(nil)>
<Marked_terms(mark(X)) , Marked_terms(X)>
<Marked_terms(active(X)) , Marked_terms(X)>
<Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
<Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
<Marked_recip(mark(X)) , Marked_recip(X)>
<Marked_recip(active(X)) , Marked_recip(X)>
<Marked_sqr(mark(X)) , Marked_sqr(X)>
<Marked_sqr(active(X)) , Marked_sqr(X)>
<Marked_s(mark(X)) , Marked_s(X)>
<Marked_s(active(X)) , Marked_s(X)>
<Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
<Marked_add(active(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
<Marked_dbl(mark(X)) , Marked_dbl(X)>
<Marked_dbl(active(X)) , Marked_dbl(X)>
<Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
<Marked_first(active(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(0,X)) , Marked_mark(X)>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
<Marked_mark(first(X1,X2)) , Marked_mark(X1)>
<Marked_mark(first(X1,X2)) , Marked_mark(X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 1*X1 + 1*X0; 
 [ terms ] (X0) = 2*X0; 
 [ Marked_mark ] (X0) = 2*X0; 
 [ recip ] (X0) = 2*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 1*X0; 
 [ dbl ] (X0) = 1*X0; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 2*X0; 
 [ sqr ] (X0) = 1*X0; 
 [ first ] (X0,X1) = 2*X1 + 2*X0; 
 [ 0 ] () = 1; 
 removing <Marked_active(add(0,X)),Marked_mark(X)>
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
<Marked_mark(first(X1,X2)) , Marked_mark(X1)>
<Marked_mark(first(X1,X2)) , Marked_mark(X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_active(first(s(X),cons(Y,Z))) , Marked_mark(cons(Y,first(X,Z)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
<Marked_mark(first(X1,X2)) , Marked_mark(X1)>
<Marked_mark(first(X1,X2)) , Marked_mark(X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 1*X1 + 2*X0; 
 [ terms ] (X0) = 2*X0; 
 [ Marked_mark ] (X0) = 2*X0; 
 [ recip ] (X0) = 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 2*X0; 
 [ dbl ] (X0) = 1*X0; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 2*X0; 
 [ sqr ] (X0) = 1*X0; 
 [ first ] (X0,X1) = 1*X1 + 2*X0 + 1; 
 [ 0 ] () = 0; 
 removing <Marked_active(first(s(X),cons(Y,Z))),Marked_mark(cons(Y,first(X,Z)))><
Marked_mark(first(X1,X2)),Marked_mark(X1)><Marked_mark(first(X1,X2)),
Marked_mark(X2)>
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_active(cons(mark(X1),X2))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_active(recip(mark(X)))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(s(X)) , Marked_active(s(X))>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
<Marked_mark(first(X1,X2)) , Marked_active(first(mark(X1),mark(X2)))>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 0; 
 [ add ] (X0,X1) = 1; 
 [ terms ] (X0) = 1; 
 [ Marked_mark ] (X0) = 2; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 1; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 2*X0; 
 [ sqr ] (X0) = 1; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 removing <Marked_mark(cons(X1,X2)),Marked_active(cons(mark(X1),X2))><
Marked_mark(recip(X)),Marked_active(recip(mark(X)))><Marked_mark(s(X)),
Marked_active(s(X))><Marked_mark(first(X1,X2)),Marked_active(first(mark(X1),
                                                              mark(X2)))>
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_active(dbl(s(X))) , Marked_mark(s(s(dbl(X))))>
<Marked_active(add(s(X),Y)) , Marked_mark(s(add(X,Y)))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 2*X1 + 2*X0; 
 [ terms ] (X0) = 2*X0; 
 [ Marked_mark ] (X0) = 2*X0 + 3; 
 [ recip ] (X0) = 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 1*X0; 
 [ dbl ] (X0) = 2*X0; 
 [ s ] (X0) = 2; 
 [ Marked_active ] (X0) = 2*X0 + 3; 
 [ sqr ] (X0) = 1*X0; 
 [ first ] (X0,X1) = 1*X1; 
 [ 0 ] () = 0; 
 removing <Marked_active(dbl(s(X))),Marked_mark(s(s(dbl(X))))><Marked_active(
                                                                add(s(X),
                                                                 Y)),
Marked_mark(s(add(X,Y)))>
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(terms(N)) , Marked_mark(cons(recip(sqr(N)),terms(s(N))))>
<Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(terms(X)) , Marked_mark(X)>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 2*X1 + 1*X0; 
 [ terms ] (X0) = 2*X0 + 3; 
 [ Marked_mark ] (X0) = 2*X0 + 3; 
 [ recip ] (X0) = 2*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 1*X0; 
 [ dbl ] (X0) = 1*X0; 
 [ s ] (X0) = 2; 
 [ Marked_active ] (X0) = 2*X0 + 3; 
 [ sqr ] (X0) = 1*X0; 
 [ first ] (X0,X1) = 2*X1 + 3*X0; 
 [ 0 ] () = 0; 
 removing <Marked_active(terms(N)),Marked_mark(cons(recip(sqr(N)),terms(s(N))))><
Marked_mark(terms(X)),Marked_mark(X)>
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(terms(X)) , Marked_active(terms(mark(X)))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_active(add(mark(X1),mark(X2)))>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_active(dbl(mark(X)))>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 0; 
 [ add ] (X0,X1) = 0; 
 [ terms ] (X0) = 0; 
 [ Marked_mark ] (X0) = 2; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 0; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 1*X0; 
 [ sqr ] (X0) = 2; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 removing <Marked_mark(terms(X)),Marked_active(terms(mark(X)))><Marked_mark(
                                                                 add(
                                                                  X1,
                                                                  X2)),
Marked_active(add(mark(X1),mark(X2)))><Marked_mark(dbl(X)),Marked_active(
                                                            dbl(mark(X)))>
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(cons(X1,X2)) , Marked_mark(X1)>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 1*X1 + 2*X0; 
 [ terms ] (X0) = 2*X0 + 2; 
 [ Marked_mark ] (X0) = 1*X0; 
 [ recip ] (X0) = 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 1*X0 + 1; 
 [ dbl ] (X0) = 1*X0; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 0; 
 [ sqr ] (X0) = 2*X0; 
 [ first ] (X0,X1) = 2*X1; 
 [ 0 ] () = 0; 
 removing <Marked_mark(cons(X1,X2)),Marked_mark(X1)>
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(sqr(X)) , Marked_active(sqr(mark(X)))>
<Marked_mark(sqr(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
<Marked_mark(dbl(X)) , Marked_mark(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 2*X1 + 2*X0; 
 [ terms ] (X0) = 0; 
 [ Marked_mark ] (X0) = 2*X0 + 3; 
 [ recip ] (X0) = 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 1*X0 + 2; 
 [ s ] (X0) = 0; 
 [ Marked_active ] (X0) = 3; 
 [ sqr ] (X0) = 1*X0 + 3; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 removing <Marked_mark(sqr(X)),Marked_active(sqr(mark(X)))><Marked_mark(sqr(X)),
Marked_mark(X)><Marked_mark(dbl(X)),Marked_mark(X)>
 [ {
      
     DP termination of:
     <Marked_active(sqr(s(X))) , Marked_mark(s(add(sqr(X),dbl(X))))>
<Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_mark(recip(X)) , Marked_mark(X)>
<Marked_mark(add(X1,X2)) , Marked_mark(X1)>
<Marked_mark(add(X1,X2)) , Marked_mark(X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 1*X0; 
 [ add ] (X0,X1) = 2*X1 + 2*X0 + 2; 
 [ terms ] (X0) = 0; 
 [ Marked_mark ] (X0) = 3*X0; 
 [ recip ] (X0) = 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 removing <Marked_mark(add(X1,X2)),Marked_mark(X1)><Marked_mark(add(X1,X2)),
Marked_mark(X2)>
 [ {
      
     DP termination of:
     <Marked_mark(recip(X)) , Marked_mark(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_mark(recip(X)) , Marked_mark(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ Marked_mark ] (X0) = 3*X0 + 0; 
 [ recip ] (X0) = 1 + 2*X0 + 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0 + 0; 
 [ cons ] (X0,X1) = 2*X1 + 0; 
 [ dbl ] (X0) = 3 + 0; 
 [ s ] (X0) = 1 + 0; 
 [ sqr ] (X0) = 3 + 1*X0 + 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_terms(mark(X)) , Marked_terms(X)>
<Marked_terms(active(X)) , Marked_terms(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 2*X0 + 1; 
 [ add ] (X0,X1) = 2*X1 + 1; 
 [ terms ] (X0) = 1; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 1; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 1; 
 [ Marked_terms ] (X0) = 3*X0; 
 [ first ] (X0,X1) = 2; 
 [ 0 ] () = 0; 
 removing <Marked_terms(mark(X)),Marked_terms(X)>
 [ {
      
     DP termination of:
     <Marked_terms(active(X)) , Marked_terms(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_terms(active(X)) , Marked_terms(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 2*X1 + 0; 
 [ dbl ] (X0) = 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 0; 
 [ Marked_terms ] (X0) = 3*X0 + 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,mark(X2)) , Marked_cons(X1,X2)>
<Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 2*X0 + 1; 
 [ add ] (X0,X1) = 2*X1 + 2; 
 [ terms ] (X0) = 1; 
 [ recip ] (X0) = 2; 
 [ Marked_cons ] (X0,X1) = 1*X1; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 2*X0 + 2; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 3*X0 + 2; 
 [ first ] (X0,X1) = 2; 
 [ 0 ] () = 0; 
 removing <Marked_cons(X1,mark(X2)),Marked_cons(X1,X2)>
 [ {
      
     DP termination of:
     <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_cons(mark(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 2*X0 + 2; 
 [ add ] (X0,X1) = 2*X1 + 2; 
 [ terms ] (X0) = 2*X0 + 2; 
 [ recip ] (X0) = 0; 
 [ Marked_cons ] (X0,X1) = 3*X1 + 1*X0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 2; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 2; 
 [ first ] (X0,X1) = 2; 
 [ 0 ] () = 0; 
 removing <Marked_cons(mark(X1),X2),Marked_cons(X1,X2)>
 [ {
      
     DP termination of:
     <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_cons(active(X1),X2) , Marked_cons(X1,X2)>
<Marked_cons(X1,active(X2)) , Marked_cons(X1,X2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 3*X0 + 2*X1 + 0; 
 [ terms ] (X0) = 3 + 0; 
 [ recip ] (X0) = 2 + 0; 
 [ Marked_cons ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ nil ] () = 2 + 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 2 + 0; 
 [ dbl ] (X0) = 1 + 1*X0 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ sqr ] (X0) = 2 + 1*X0 + 0; 
 [ first ] (X0,X1) = 3 + 2*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_recip(mark(X)) , Marked_recip(X)>
<Marked_recip(active(X)) , Marked_recip(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 3*X0 + 1; 
 [ add ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ terms ] (X0) = 1; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ Marked_recip ] (X0) = 3*X0; 
 [ dbl ] (X0) = 3*X0 + 1; 
 [ s ] (X0) = 3; 
 [ sqr ] (X0) = 3*X0 + 2; 
 [ first ] (X0,X1) = 3*X0 + 1; 
 [ 0 ] () = 0; 
 removing <Marked_recip(mark(X)),Marked_recip(X)>
 [ {
      
     DP termination of:
     <Marked_recip(active(X)) , Marked_recip(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_recip(active(X)) , Marked_recip(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 2*X1 + 0; 
 [ Marked_recip ] (X0) = 3*X0 + 0; 
 [ dbl ] (X0) = 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_sqr(mark(X)) , Marked_sqr(X)>
<Marked_sqr(active(X)) , Marked_sqr(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ Marked_sqr ] (X0) = 3*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 3 + 2*X0 + 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 3 + 2*X0 + 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 2 + 0; 
 ]} 
{
 
DP termination of:
<Marked_s(mark(X)) , Marked_s(X)>
<Marked_s(active(X)) , Marked_s(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 3*X0 + 1; 
 [ add ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ terms ] (X0) = 1; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 3*X0 + 1; 
 [ s ] (X0) = 3; 
 [ sqr ] (X0) = 3*X0 + 3; 
 [ first ] (X0,X1) = 3*X0 + 1; 
 [ 0 ] () = 0; 
 [ Marked_s ] (X0) = 3*X0; 
 removing <Marked_s(mark(X)),Marked_s(X)>
 [ {
      
     DP termination of:
     <Marked_s(active(X)) , Marked_s(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_s(active(X)) , Marked_s(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ add ] (X0,X1) = 3 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 2*X1 + 0; 
 [ dbl ] (X0) = 3 + 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 1 + 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 [ Marked_s ] (X0) = 3*X0 + 0; 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_add(mark(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,mark(X2)) , Marked_add(X1,X2)>
<Marked_add(active(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 2*X0 + 1; 
 [ add ] (X0,X1) = 2*X1 + 1; 
 [ terms ] (X0) = 1; 
 [ recip ] (X0) = 2; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ Marked_add ] (X0,X1) = 3*X1 + 3*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 1; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 2*X0 + 1; 
 [ first ] (X0,X1) = 3*X0 + 2; 
 [ 0 ] () = 0; 
 removing <Marked_add(mark(X1),X2),Marked_add(X1,X2)><Marked_add(X1,mark(X2)),
Marked_add(X1,X2)>
 [ {
      
     DP termination of:
     <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_add(active(X1),X2) , Marked_add(X1,X2)>
<Marked_add(X1,active(X2)) , Marked_add(X1,X2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 2*X0 + 0; 
 [ add ] (X0,X1) = 3 + 2*X1 + 0; 
 [ terms ] (X0) = 1 + 0; 
 [ recip ] (X0) = 2 + 0; 
 [ nil ] () = 1 + 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ Marked_add ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ cons ] (X0,X1) = 1 + 0; 
 [ dbl ] (X0) = 2 + 3*X0 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ sqr ] (X0) = 2 + 1*X0 + 0; 
 [ first ] (X0,X1) = 1 + 0; 
 [ 0 ] () = 2 + 0; 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_dbl(mark(X)) , Marked_dbl(X)>
<Marked_dbl(active(X)) , Marked_dbl(X)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ mark ] (X0) = 2*X0 + 1; 
 [ add ] (X0,X1) = 2*X1 + 1; 
 [ terms ] (X0) = 2*X0 + 1; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1*X0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 2; 
 [ s ] (X0) = 0; 
 [ Marked_dbl ] (X0) = 3*X0; 
 [ sqr ] (X0) = 2; 
 [ first ] (X0,X1) = 1; 
 [ 0 ] () = 0; 
 removing <Marked_dbl(mark(X)),Marked_dbl(X)>
 [ {
      
     DP termination of:
     <Marked_dbl(active(X)) , Marked_dbl(X)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_dbl(active(X)) , Marked_dbl(X)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 2*X1 + 0; 
 [ dbl ] (X0) = 2 + 0; 
 [ s ] (X0) = 0; 
 [ Marked_dbl ] (X0) = 3*X0 + 0; 
 [ sqr ] (X0) = 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_first(mark(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,mark(X2)) , Marked_first(X1,X2)>
<Marked_first(active(X1),X2) , Marked_first(X1,X2)>
<Marked_first(X1,active(X2)) , Marked_first(X1,X2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ mark ] (X0) = 1 + 2*X0 + 0; 
 [ add ] (X0,X1) = 2 + 2*X1 + 0; 
 [ terms ] (X0) = 0; 
 [ Marked_first ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ recip ] (X0) = 0; 
 [ nil ] () = 0; 
 [ active ] (X0) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 0; 
 [ dbl ] (X0) = 3 + 0; 
 [ s ] (X0) = 0; 
 [ sqr ] (X0) = 1 + 0; 
 [ first ] (X0,X1) = 0; 
 [ 0 ] () = 0; 
 ]} 
 ]} 
 ]} 

Cime worked for 5.684866 seconds (real time)
Cime Exit Status: 0