anchor.diff:              let h = str_to_top_name ("FStar_Tactics_Interpreter.mk_tactic_interpretation_" ^ string_of_int arity) in
               let tac_fun = w <| MLE_App (str_to_top_name ("FStar_Tactics_Native.from_tactic_" ^ string_of_int arity), [lid_to_top_name fv]) in
               let tac_lid_app = w <| MLE_App (str_to_top_name "FStar_Ident.lid_of_str", [w ml_fv]) in
  -            let psc = w <| str_to_name "psc" in
  -            let args = w <| str_to_name "args" in
  +            let psc = str_to_name "psc" in
  +            let args = str_to_name "args" in
               let args =
                   [w <| MLE_Const (MLC_Bool true); //trigger a TAC?.reflect
                    tac_fun] @
                   arg_unembeddings @
  -                [res_embedding.to_term;
  -                 w <| mk_tac_param_type tcenv result_typ;
  +                [res_embedding.embed;
  +                 res_embedding.type_repr;
                    tac_lid_app;
                    psc;
                    args] in
  
positive.code:     in
      let tvar_context = List.mapi (fun i tv -> Some <| id_embedding ("tv_" ^ string_of_int i)) type_vars in
      aux [] tvar_context bs
  //
  //(*
  //  Given:
  
negative.code:     | Embed
      | Unembed
  
  type embedding = {
      embed  :mlexpr;
      unembed:mlexpr;
      type_repr:mlexpr;
  }
  
  type variance =
    | Covariant
    | Contravariant
    | Invariant
  
  let interpret_plugin_as_term_fun tcenv (fv:lident) (t:typ) (ml_fv:mlexpr') =
      let w = with_ty MLTY_Top in
      let lid_to_name l     = with_ty MLTY_Top <| MLE_Name (mlpath_of_lident l) in
      let lid_to_top_name l = with_ty MLTY_Top <| MLE_Name (mlpath_of_lident l) in
      let str_to_name s     = lid_to_name (lid_of_str s) in
      let str_to_top_name s = lid_to_top_name (lid_of_str s) in
      let fstar_syn_syn_prefix s = str_to_name ("FStar_Syntax_Syntax." ^ s) in
      let fstar_tc_common_prefix s = str_to_name ("FStar_TypeChecker_Common." ^ s) in
      let fstar_refl_basic_prefix s = str_to_name ("FStar_Reflection_Basic." ^ s) in
      let fstar_refl_data_prefix s = str_to_name ("FStar_Reflection_Data." ^ s) in
      let fstar_emb_basic_prefix s = str_to_name ("FStar_Syntax_Embeddings." ^ s) in
      let mk_basic_embedding (m: emb_decl) (s: string) =
          match m with
          | Embed -> fstar_emb_basic_prefix ("embed_" ^ s)
          | Unembed -> fstar_emb_basic_prefix ("unembed_" ^ s) in
      let mk_lam nm e =
          w <| MLE_Fun ([(nm, MLTY_Top)], e)
      in
      let id_embedding nm =
          let id = mk_lam "x" (str_to_name "x") in
          { embed = id; unembed = id; type_repr = str_to_name nm}
      in
      let known_type_constructors =
          [ (PC.int_lid,  [], fstar_syn_syn_prefix "t_int");
            (PC.bool_lid, [], fstar_syn_syn_prefix "t_bool");
            (PC.unit_lid, [], fstar_syn_syn_prefix "t_unit");
            (PC.string_lid, [], fstar_syn_syn_prefix "t_string");
            (RD.fstar_refl_types_lid "term", [], fstar_refl_data_prefix "t_term");
            (RD.fstar_refl_types_lid "fv", [], fstar_refl_data_prefix "t_fv");
            (RD.fstar_refl_types_lid "binder", [], fstar_refl_data_prefix "t_binder");
            (RD.fstar_refl_syntax_lid "binders", [], fstar_refl_data_prefix "t_binders");
            (RD.fstar_refl_syntax_lid "norm_step", [], fstar_refl_data_prefix "t_norm_step");
            (PC.list_lid,   [Covariant], fstar_tc_common_prefix "t_list_of"); //one covariant argument
            (PC.option_lid, [Covariant], fstar_tc_common_prefix "t_option_of");
            (PC.mk_tuple_lid 2 Range.dummyRange, [Covariant; Covariant], fstar_tc_common_prefix "t_tuple2_of") //two covariant arguments
          ]
      in
      let is_known_type_constructor fv n =
          BU.for_some
              (fun (x, args, _) -> fv_eq_lid fv x && n = List.length args)
              known_type_constructors
      in
      let embed_type_app (fv:Syntax.fv) (arg_embeddings:list<embedding>) =
          let nm = fv.fv_name.v.ident.idText in
          let _, variances, trepr_head =
              BU.find_opt
                  (fun (x, _, _) -> fv_eq_lid fv x)
                  known_type_constructors
              |> BU.must
          in
          let choose e_or_u variance embedding =
              let term_embedding =
                   match variance with
                   | Covariant ->
                      (match e_or_u with
                       | Embed   -> [embedding.embed]
                       | Unembed -> [embedding.unembed])
                   | Contravariant ->
                      (match e_or_u with
                       | Embed   -> [embedding.unembed]
                       | Unembed -> [embedding.embed])
                   | Invariant ->
                      [embedding.embed;
                       embedding.unembed]
              in
              term_embedding@[embedding.type_repr]
          in
          let mk embed_or_unembed =
              let head = mk_basic_embedding embed_or_unembed nm in
              match variances with
              | [] -> head
              | _ ->
                let args =
                  List.map2 (choose embed_or_unembed) variances arg_embeddings
                in
                w <| MLE_App(head, List.flatten args)
          in
          let type_repr =
              match variances with
              | [] ->
                trepr_head
              | _ ->
                w <| MLE_App (trepr_head,
                              List.map (fun x -> x.type_repr) arg_embeddings)
          in
          { embed   = mk Embed;
            unembed = mk Unembed;
            type_repr = type_repr}
      in
      let rec mk_embedding (env:list<(option<embedding>)>) t =
          match (FStar.Syntax.Subst.compress t).n with
  