anchor.diff:                                      Some "Fuel irrelevance",
                                       ("@fuel_irrelevance_" ^g)) in
               let aux_decls, g_typing =
  -              let vars, v_guards, env, binder_decls, _ = encode_binders None formals env0 in
  -              let vars_tm = List.map mkFreeV vars in
                 let gapp = mkApp(g, fuel_tm::vars_tm) in
                 let tok_corr =
                   let tok_app = mk_Apply (mkFreeV (gtok, Term_sort)) (fuel::vars) in
                   Util.mkAssume(mkForall (U.range_of_lbname lbn) ([[tok_app]], fuel::vars, mkEq(tok_app, gapp)),
  -                            Some "Fuel token correspondence",
  -                            ("fuel_token_correspondence_"^gtok))
  +                              Some "Fuel token correspondence",
  +                              ("fuel_token_correspondence_"^gtok))
                 in
                 let aux_decls, typing_corr =
  -                let g_typing, d3 = encode_term_pred None tres env gapp in
  -                d3, [Util.mkAssume(mkForall (U.range_of_lbname lbn) ([[gapp]], fuel::vars, mkImp(mk_and_l v_guards, g_typing)),
  +                let g_typing, d3 = encode_term_pred None tres env' gapp in
  +                d3, [Util.mkAssume(mkForall (U.range_of_lbname lbn)
  +                                            ([[gapp]], fuel::vars, mkImp(guard, g_typing)),
                                       Some "Typing correspondence of token to term",
                                       ("token_correspondence_"^g))]
                 in
  
positive.code:         let valid = mkApp("Valid", [l_not_a]) in
          let not_valid_a = mkNot <| mkApp("Valid", [a]) in
          [Util.mkAssume(mkForall (Env.get_range env) ([[l_not_a]], [aa], mkIff(not_valid_a, valid)), Some "not interpretation", "l_not-interp")] in
      // let mk_forall_interp : env -> string -> term -> decls_t = fun env for_all tt ->
      //     let aa = ("a", Term_sort) in
      //     let bb = ("b", Term_sort) in
      //     let xx = ("x", Term_sort) in
      //     let a = mkFreeV aa in
      //     let b = mkFreeV bb in
      //     let x = mkFreeV xx in
      //     let l_forall_a_b = mkApp(for_all, [a;b]) in
      //     let valid = mkApp("Valid", [l_forall_a_b]) in
      //     let valid_b_x = mkApp("Valid", [mk_ApplyTT b x]) in
      //     [Util.mkAssume(mkForall (Env.get_range env) ([[l_forall_a_b]], [aa;bb], mkIff(mkForall([[mk_HasTypeZ x a]], [xx], mkImp(mk_HasTypeZ x a, valid_b_x)), valid)),
      //                  Some "forall interpretation",
      //                  "forall-interp")] in
      // let mk_exists_interp : env -> string -> term -> decls_t = fun env for_some tt ->
      //     let aa = ("a", Term_sort) in
      //     let bb = ("b", Term_sort) in
      //     let xx = ("x", Term_sort) in
      //     let a = mkFreeV aa in
      //     let b = mkFreeV bb in
      //     let x = mkFreeV xx in
      //     let l_exists_a_b = mkApp(for_some, [a;b]) in
      //     let valid = mkApp("Valid", [l_exists_a_b]) in
      //     let valid_b_x = mkApp("Valid", [mk_ApplyTT b x]) in
      //     [Util.mkAssume(mkForall (Env.get_range env) ([[l_exists_a_b]], [aa;bb], mkIff(mkExists([[mk_HasTypeZ x a]], [xx], mkImp(mk_HasTypeZ x a, valid_b_x)), valid)),
      //                  Some "exists interpretation",
      //                  "exists-interp")] in
     let mk_range_interp : env -> string -> term -> decls_t = fun env range tt ->
          let range_ty = mkApp(range, []) in
          [Util.mkAssume(mk_HasTypeZ (mk_Range_const ()) range_ty, Some "Range_const typing", (varops.mk_unique "typing_range_const"))] in
  
negative.code: 
              let vars, guards, env', binder_decls, _ = encode_binders None binders env' in
              let guard, guard_decls =
                  match pre_opt with
                  | None -> mk_and_l guards, []
                  | Some pre ->
  