anchor.diff:          l, t', u_names
         in
         letrecs |> List.map guard_one_letrec
  -
  +      
   let wrap_guard_with_tactic_opt topt g =
      match topt with
      | None -> g
  
positive.code:                 | _ -> bs |> filter_types_and_functions in
  
        let precedes_t = TcUtil.fvar_const env Const.precedes_lid in
        let rec mk_precedes_lex l l_prev =
          (*
           * AR: aux assumes that l and l_prev have the same lengths
           *     Given l = [a; b; c], l_prev = [d; e; f], it builds:
           *       a << d \/ (eq3 a d /\ b << e) \/ (eq3 a d /\ eq3 b e /\ c << f
           *     We build an "untyped" term here, the caller will typecheck it properly
           *)
          let rec aux l l_prev =
            match l, l_prev with
            | [], [] ->
              mk_Tm_app precedes_t [as_arg S.unit_const; as_arg S.unit_const] r
            | [x], [x_prev] -> mk_Tm_app precedes_t [as_arg x; as_arg x_prev] r
            | x::tl, x_prev::tl_prev ->
              mk_disj (mk_Tm_app precedes_t [as_arg x; as_arg x_prev] r)
                      (mk_conj (mk_untyped_eq3 x x_prev) (aux tl tl_prev)) in
  
          (* Call aux with equal sized prefixes of l and l_prev *)
          let l, l_prev =
  
negative.code:           then ({b with binder_bv=S.new_bv (Some (S.range_of_bv b.binder_bv)) b.binder_bv.sort})
            else b) in
          let dec = decreases_clause formals c in
          let precedes =
            let env = Env.push_binders env formals in
            mk_precedes_lex env dec previous_dec in
          let precedes = TcUtil.label "Could not prove termination of this recursive call" r precedes in
          let bs, ({binder_bv=last; binder_qual=imp}) = BU.prefix formals in
          let last = {last with sort=U.refine last precedes} in
  