print_endline (Pp.pp_unit_clause ~margin:max_int
      (fst(Terms.M.find x bag)))) l; 
 *)
-  let stamp = Unix.gettimeofday () in
-  let proofterm = NCicProof.mk_proof bag i fo_subst l in
-    print (lazy (Printf.sprintf "Got proof term in %fs"
-                    (Unix.gettimeofday() -. stamp)));
+  (* let stamp = Unix.gettimeofday () in *)
+  let proofterm,prooftype = NCicProof.mk_proof bag i fo_subst l in
+  (* debug (lazy (Printf.sprintf "Got proof term in %fs"
+                    (Unix.gettimeofday() -. stamp))); *)
   let metasenv, proofterm = 
     let rec aux k metasenv = function
       | NCic.Meta _ as t -> metasenv, t
           (fun _ k -> k+1) k aux metasenv t
     in
       aux 0 metasenv proofterm
-  in
-  print (lazy (NCicPp.ppterm ~metasenv ~subst ~context proofterm));
+  in 
+  debug (lazy (NCicPp.ppterm ~metasenv ~subst ~context proofterm));
+(*
   let stamp = Unix.gettimeofday () in
   let metasenv, subst, proofterm, _prooftype = 
     NCicRefiner.typeof 
   in
     print (lazy (Printf.sprintf "Refined in %fs"
                     (Unix.gettimeofday() -. stamp)));
-    proofterm, metasenv, subst
+*)
+    proofterm, prooftype, metasenv, subst
 
 let nparamod rdb metasenv subst context t table =
   let module C =
 ;;
 
 let fast_eq_check rdb metasenv subst context s goal =
-  let stamp = Unix.gettimeofday () in
+  (* let stamp = Unix.gettimeofday () in *)
   match P.fast_eq_check s goal with
   | P.Error _ | P.GaveUp | P.Timeout _ -> []
   | P.Unsatisfiable solutions -> 
-      print (lazy (Printf.sprintf "Got solutions in %fs"
-                    (Unix.gettimeofday() -. stamp)));
+      (* print (lazy (Printf.sprintf "Got solutions in %fs"
+                    (Unix.gettimeofday() -. stamp))); *)
       List.map (readback rdb metasenv subst context) solutions
 ;;
 
 
   #NRstatus.status ->
   NCic.metasenv -> NCic.substitution -> NCic.context -> 
     (NCic.term * NCic.term) -> (NCic.term * NCic.term) list ->
-     (NCic.term * NCic.metasenv * NCic.substitution) list
+     (NCic.term * NCic.term * NCic.metasenv * NCic.substitution) list
 
 type state 
 val empty_state: state
   NCic.metasenv -> NCic.substitution -> NCic.context ->
   state -> 
   (NCic.term * NCic.term) -> 
-  (NCic.term * NCic.metasenv * NCic.substitution) list
+  (NCic.term * NCic.term * NCic.metasenv * NCic.substitution) list
 
          -> NCic.Appl [eq_refl();ty;l]
       | _ -> assert false
     in  
+    let proof_type =
+      let lit,_,_ = get_literal mp in
+      let lit = Subst.apply_subst subst lit in
+       extract 0 [] lit in
     let rec aux ongoal seen = function
       | [] -> NCic.Rel 1
       | id :: tl ->
                  aux ongoal 
                    ((id,(List.map (fun x -> Terms.Var x) vl,lit))::seen) tl)
     in 
-      aux false [] steps
+      aux false [] steps, proof_type
   ;;