anchor.diff:  
   let e_proofstate =
       let embed_proofstate (rng:Range.range) (ps:proofstate) : term =
  -        U.mk_lazy ps t_proofstate Lazy_proofstate (Some rng)
  +        U.mk_lazy ps fstar_tactics_proofstate.t Lazy_proofstate (Some rng)
       in
       let unembed_proofstate w (t:term) : option<proofstate> =
           match (SS.compress t).n with
  
positive.code:         unembed_result
          (t_result_of (type_of ea))
          (fun _ -> "")
          (ET_app (t_result_lid |> Ident.string_of_lid, [emb_typ_of ea]))
  
  let e_result_nbe (ea : NBET.embedding<'a>)  =
      let embed_result cb (res:__result<'a>) : NBET.t =
          match res with
          | Failed (e, ps) ->
              mkConstruct fstar_tactics_Failed_fv
                [U_zero]
                [ NBETerm.as_iarg (NBETerm.type_of ea)
                ; NBETerm.as_arg (NBETerm.embed e_exn_nbe cb e)
                ; NBETerm.as_arg (NBETerm.embed e_proofstate_nbe cb ps) ]
          | Success (a, ps) ->
              mkConstruct fstar_tactics_Success_fv
                [U_zero]
                [ NBETerm.as_iarg (NBETerm.type_of ea)
                ; NBETerm.as_arg (NBETerm.embed ea cb a)
  
negative.code:     in
      { NBETerm.em = embed_proofstate
      ; NBETerm.un = unembed_proofstate
      ; NBETerm.typ = mkFV fstar_tactics_proofstate.fv [] []
      ; NBETerm.emb_typ = fv_as_emb_typ fstar_tactics_proofstate.fv }
  
  let e_goal =
      let embed_goal (rng:Range.range) (g:goal) : term =
          U.mk_lazy g fstar_tactics_goal.t Lazy_goal (Some rng)
      in
      let unembed_goal w (t:term) : option<goal> =
          match (SS.compress t).n with
  