anchor.diff:        let n = List.length univs in
         let n_binders = List.length binders in
         let elim_tscheme (us, t) =
  -//        printfn "0. elim_tscheme %s" (Print.tscheme_to_string (us, t));
           let n_us = List.length us in
           let us, t = SS.open_univ_vars us t in
  -//        printfn "1. elim_tscheme %s" (Print.tscheme_to_string (us, t));
           let b_opening, b_closing =
               b_opening |> SS.shift_subst n_us,
               b_closing |> SS.shift_subst n_us in
           let univs_opening, univs_closing =
               univs_opening |> SS.shift_subst n_us,
               univs_closing |> SS.shift_subst n_us in
  -//        let opening = univs_opening @ b_opening in
  -//        printfn "univs_opening = %A" univs_opening;
           let t = SS.subst univs_opening (SS.subst b_opening t) in
  -//        printfn "2. elim_tscheme opened to %s" (Print.term_to_string t);
           let _, _, t = elim_uvars_aux_t env [] [] t in
           let t = SS.subst univs_closing (SS.subst b_closing (SS.close_univ_vars us t)) in
           us, t
  
positive.code:                     let t = mk (Tm_meta(head, m)) t.pos in
                      rebuild cfg env stack t
                  end
          end
  
  and do_unfold_fv cfg env stack (t0:term) (f:fv) : term =
      //preserve the range info on the returned def
  
negative.code: 
  let rec norm : cfg -> env -> stack -> term -> term =
      fun cfg env stack t ->
          log cfg  (fun () ->
              let t = compress t in
              BU.print4 ">>> %s\nNorm %s with with %s env elements top of the stack %s \n"
                                          (Print.tag_of_term t)
                                          (Print.term_to_string t)
                                          (BU.string_of_int (List.length env))
                                          (stack_to_string (fst <| firstn 4 stack)));
          match t.n with
            | Tm_unknown
            | Tm_constant _
            | Tm_name _
  
  