) else r 
     | res -> res
   ;;
-            
+
+  let rec lpo s t =
+    match s,t with
+      | Terms.Var i, Terms.Var j when i = j ->
+         XEQ
+      | Terms.Var _, Terms.Var _ ->
+         XINCOMPARABLE
+      | Terms.Var _, _ ->
+         (match lpo t s with
+           | XGT -> XLT
+           | XLT -> XGT
+           | o -> o)
+      | _, Terms.Var i ->
+         if (List.mem i (Terms.vars_of_term s)) then XGT
+         else XINCOMPARABLE
+      | Terms.Leaf a1, Terms.Leaf a2 -> 
+          let cmp = B.compare a1 a2 in
+            if cmp = 0 then XEQ else if cmp < 0 then XLT else XGT
+      | Terms.Node (hd1::tl1), Terms.Node (hd2::tl2) ->
+         (match lpo hd1 hd2 with
+           | XGT -> if List.for_all (fun x -> lpo s x = XGT) tl2 then XGT
+             else XINCOMPARABLE
+           | XLT -> if List.for_all (fun x -> lpo s x = XLT) tl2 then XLT
+             else XINCOMPARABLE
+           | XEQ -> List.fold_left2
+               (fun acc si ti -> if acc = XEQ then lpo si ti else acc)
+                 XEQ tl1 tl2
+           | XINCOMPARABLE -> XINCOMPARABLE
+           | _ -> assert false)
+      | _ -> assert false
+           
+  ;;
+
   let compare_terms x y = 
-    match nonrec_kbo x y with
+    match kbo x y with
     | XINCOMPARABLE -> Terms.Incomparable
     | XGT -> Terms.Gt
     | XLT -> Terms.Lt
 
           end
         else raise (Stop (Timeout (maxvar,bag)));
 
-    let use_age = weight_picks = (iterno / 10 + 1) in
+    let use_age = weight_picks = (iterno / 6 + 1) in
     let weight_picks = if use_age then 0 else weight_picks+1
     in
 
 
       in
         aux bag pos ctx id t
     ;;
-
-    let vars_of_term t =
-      let rec aux acc = function
-       | Terms.Leaf _ -> acc
-       | Terms.Var i -> if (List.mem i acc) then acc else i::acc
-       | Terms.Node l -> List.fold_left aux acc l
-      in aux [] t
-    ;;
     
     let build_clause bag filter rule t subst vl id id2 pos dir =
       let proof = Terms.Step(rule,id,id2,dir,pos,subst) in
           | t -> Terms.Predicate t
         in
         let bag, uc = 
-          Terms.add_to_bag (0, literal, vars_of_term t, proof) bag
+          Terms.add_to_bag (0, literal, Terms.vars_of_term t, proof) bag
         in
         Some (bag, uc)
       else
 
 type 'a passive_clause = int * 'a unit_clause (* weight * equation *)
 
 
+let vars_of_term t =
+  let rec aux acc = function
+    | Leaf _ -> acc
+    | Var i -> if (List.mem i acc) then acc else i::acc
+    | Node l -> List.fold_left aux acc l
+  in aux [] t
+;;
+
 module OT =
  struct
    type t = int 
 
 
 type 'a passive_clause = int * 'a unit_clause (* weight * equation *)
 
+val vars_of_term : 'a foterm -> int list
+
 module M : Map.S with type key = int 
 
 type 'a bag = int (* max ID  *)