anchor.diff:                  * AR: any decls computed here are ignored
                   *     we encode terms in this let-scope just to compute a hash
                   *)
  -               let vars, _, guards_l, env_bs, _, _ = encode_binders None binders env in
  +               let vars, guards_l, env_bs, _, _ = encode_binders None binders env in
                  let c = Env.unfold_effect_abbrev env.tcenv res |> S.mk_Comp in
                  let ct, _ = encode_term (c |> U.comp_result) env_bs in
                  let effect_args, _ = encode_args (c |> U.comp_effect_args) env_bs in
  
positive.code:         if  (env.encode_non_total_function_typ
               && U.is_pure_or_ghost_comp res)
               || U.is_tot_or_gtot_comp res
          then let vars, _, guards_l, env', decls, _ = encode_binders None binders env in
               let fsym = mk_fv (varops.fresh module_name "f", Term_sort) in
               let f = mkFreeV  fsym in
               let app = mk_Apply f vars in
               let pre_opt, res_t = TcUtil.pure_or_ghost_pre_and_post ({env.tcenv with lax=true}) res in
               let _, res_pred, decls' = encode_term_pred None res_t env' app in
               let guards, guard_decls = match pre_opt with
                  | None -> mk_and_l guards_l, []
                  | Some pre ->
  
negative.code:         Util.mkAssume(mkForall t0.pos ([[t_haseq_ref]], cvars, (mkIff (t_haseq_ref, t_haseq_base))),
                          Some ("haseq for " ^ tsym),
                          "haseq" ^ tsym) in
          // let t_valid =
          //   let xx = (x, Term_sort) in
          //   let valid_t = mkApp ("Valid", [t]) in
  