anchor.diff:              //But, the pattern ensures that this only applies to well-typed terms
               //NS 08/10: Setting the weight of this quantifier to 0, since its instantiations are controlled by F* fuel
               //NS 11/28/2018: Restoring the mkImp (mk_and_l guards, mkEq(gsapp, body_tm))
  -            let eqn_g = Util.mkAssume(mkForall' (U.range_of_lbname lbn) ([[gsapp]], Some 0, fuel::vars, mkImp(mk_and_l guards, mkEq(gsapp, body_tm))),
  -                                    Some (BU.format1 "Equation for fuel-instrumented recursive function: %s" fvb.fvar_lid.str),
  -                                    ("equation_with_fuel_" ^g)) in
  +            //   11/29/2018: Also guarding by the precondition of a Pure/Ghost function in addition to typing guards
  +            let eqn_g =
  +                Util.mkAssume
  +                    (mkForall' (U.range_of_lbname lbn)
  +                               ([[gsapp]], Some 0, fuel::vars, mkImp(guard, mkEq(gsapp, body_tm))),
  +                     Some (BU.format1 "Equation for fuel-instrumented recursive function: %s" fvb.fvar_lid.str),
  +                     "equation_with_fuel_" ^g) in
               let eqn_f = Util.mkAssume(mkForall (U.range_of_lbname lbn) ([[app]], vars, mkEq(app, gmax)),
                                       Some "Correspondence of recursive function to instrumented version",
                                       ("@fuel_correspondence_"^g)) in
  
positive.code:               match (SS.compress t_norm).n with
                | Tm_arrow(formals, c) ->
                  let formals, c = SS.open_comp formals c in
                  let tres = get_result_type c in
                  let binders, body = eta_expand [] formals e tres in
                  (binders, body, formals, tres), false
                | Tm_refine (bv, _) -> aux' bv.sort
                | _ -> ([], e, [], t_norm), false
              in
              aux' t_norm
            end
  
negative.code:                         (Print.term_to_string e);
  
              (* Open binders *)
              let (binders, body, formals, tres_comp), curry = destruct_bound_function fvb.fvar_lid t_norm e in
              let tres = U.comp_result tres_comp in
              if Env.debug env0.tcenv <| Options.Other "SMTEncoding"
              then BU.print4 "Encoding let rec: binders=[%s], body=%s, formals=[%s], tres=%s\n"
                                (Print.binders_to_string ", " binders)
                                (Print.term_to_string body)
                                (Print.binders_to_string ", " formals)
                                (Print.term_to_string tres);
              let _ =
                  if curry
                  then failwith "Unexpected type of let rec in SMT Encoding; \
                                 expected it to be annotated with an arrow type"
              in
  
  
              let vars, guards, env', binder_decls, _ = encode_binders None binders env' in
              let guard, guard_decls =
                  let pre_opt, _ = TcUtil.pure_or_ghost_pre_and_post env.tcenv tres_comp in
                  match pre_opt with
                  | None -> mk_and_l guards, []
                  | Some pre ->
                    let guard, decls0 = encode_formula pre env' in
                    mk_and_l (guards@[guard]), decls0
              in
              let binder_decls = binder_decls @ guard_decls in
              let decl_g = Term.DeclFun(g, Fuel_sort::List.map snd vars, Term_sort, Some "Fuel-instrumented function name") in
              let env0 = push_zfuel_name env0 fvb.fvar_lid g in
              let decl_g_tok = Term.DeclFun(gtok, [], Term_sort, Some "Token for fuel-instrumented partial applications") in
  