anchor.diff:  
         | Tm_uvar (uv, _) ->
           let ttm = mk_Term_uvar (Unionfind.uvar_id uv.ctx_uvar_head) in
  -        let _, t_has_k, decls = encode_term_pred None uv.ctx_uvar_typ env ttm in //TODO: skip encoding this if it has already been encoded before
  +        let t_has_k, decls = encode_term_pred None uv.ctx_uvar_typ env ttm in //TODO: skip encoding this if it has already been encoded before
           let d =
               Util.mkAssume(t_has_k,
                             Some "Uvar typing",
  
positive.code: 
      if Env.debug env.tcenv Options.Medium then BU.print1 "Encoding binders %s\n" (Print.binders_to_string ", " bs);
  
      let vars, sorts, guards, env, decls, names =
        bs |> List.fold_left
        (fun (vars, sorts, guards, env, decls, names) b ->
          let v, t, g, env, decls', n =
              let x = fst b in
              let xxsym, xx, env' = gen_term_var env x in
              let t_term, guard_x_t, decls' =
                encode_term_pred fuel_opt (norm env x.sort) env xx
              in //if we had polarities, we could generate a mkHasTypeZ here in the negative case
              mk_fv (xxsym, Term_sort),
              t_term,
              guard_x_t,
              env',
              decls',
              x
          in
          v::vars, t::sorts, g::guards, env, decls@decls', n::names)
         ([], [], [], env, [], [])
      in
      List.rev vars,
      List.rev sorts,
      List.rev guards,
      env,
      decls,
      List.rev names
  
  and encode_term_pred (fuel_opt:option<term>) (t:typ) (env:env_t) (e:term) : term * term * decls_t =
      let t, decls = encode_term t env in
      t, mk_HasTypeWithFuel fuel_opt e t, decls
  
  and encode_term_pred' (fuel_opt:option<term>) (t:typ) (env:env_t) (e:term) : term * decls_t =
      let t, decls = encode_term t env in
  
negative.code:                       let t_head_hyp, decls' =
                          match smt_head.tm with
                          | FreeV _ ->
                            encode_term_pred None head_type env smt_head
                          | _ ->
                            mkTrue, []
                        in
                        let hyp = Term.mk_and_l (t_head_hyp::t_hyps) Range.dummyRange in
                        let has_type_conclusion, decls'' =
                            encode_term_pred None ty env app_tm
                        in
                        let has_type = mkImp (hyp, has_type_conclusion) in
  