anchor.diff:        let env = add_binders env args in
         let name = env.module_name, name in
         let flags = (match t0 with
  -      | MLTY_Fun (_, E_GHOST, _) -> NoExtract :: (translate_flags flags)
  -      | _ -> translate_flags flags) in
  +        | MLTY_Fun (_, E_GHOST, _) -> MustDisappear :: (translate_flags flags)
  +        | _ -> translate_flags flags) in
         if assumed then
           if List.length tvars = 0 then
  -          Some (DExternal (None, name, translate_type env t0))
  +          Some (DExternal (None, flags, name, translate_type env t0))
           else
             // JP: TODO assume polymorphic function and have KreMLin generate
             // monomorphized assumes 
  
positive.code: (** Versioned binary writing/reading of ASTs *)
  
  type version = int
  let current_version: version = 25
  
  type file = string * program
  type binary_format = version * list<file>
  
negative.code: 
  and translate_type_decl env ty: option<decl> =
    match ty with
    | (assumed, name, _mangled_name, args, flags, Some (MLTD_Abbrev t)) ->
        let name = env.module_name, name in
        let env = List.fold_left (fun env name -> extend_t env name) env args in
        if assumed then
          // JP: TODO: shall we be smarter here?
          None
        else
          Some (DTypeAlias (name, translate_flags flags, List.length args, translate_type env t))
  
    | (_, name, _mangled_name, args, flags, Some (MLTD_Record fields)) ->
        let name = env.module_name, name in
        let env = List.fold_left (fun env name -> extend_t env name) env args in
        Some (DTypeFlat (name, translate_flags flags, List.length args, List.map (fun (f, t) ->
          f, (translate_type env t, false)) fields))
  
    | (_, name, _mangled_name, args, flags, Some (MLTD_DType branches)) ->
        let name = env.module_name, name in
        let flags = translate_flags flags in
        let env = List.fold_left extend_t env args in
        Some (DTypeVariant (name, flags, List.length args, List.map (fun (cons, ts) ->
          cons, List.map (fun (name, t) ->
  