diff --git a/include/objidl.h b/include/objidl.h
index 062bea0..657250a 100644
--- a/include/objidl.h
+++ b/include/objidl.h
@@ -1,52 +1,8966 @@
-/*
- * Copyright (C) the Wine project
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef __WINE__
+/*** Autogenerated by WIDL 0.1 from objidl.idl - Do not edit ***/
 #include "rpc.h"
 #include "rpcndr.h"
-#ifndef COM_NO_WINDOWS_H
-#include "windows.h"
-#include "ole2.h"
-#endif
-#endif
 
-#ifndef __WINE_OBJIDL_H
-#define __WINE_OBJIDL_H
-
-#if defined(__WINE__) && !defined(INITGUID) && !defined(__WINE_INCLUDE_OBJIDL)
-#error DO NOT INCLUDE DIRECTLY
+#ifndef __WIDL_OBJIDL_H
+#define __WIDL_OBJIDL_H
+#ifdef __cplusplus
+extern "C" {
 #endif
-
 #include "unknwn.h"
+typedef struct IStream IStream;
+typedef struct IStream16 IStream16;
+typedef struct IEnumString IEnumString;
+typedef struct IRunningObjectTable IRunningObjectTable;
+typedef struct IMoniker IMoniker;
+typedef struct IAdviseSink IAdviseSink;
+typedef struct IAsyncManager IAsyncManager;
+typedef struct IMarshal IMarshal;
+typedef IMarshal *LPMARSHAL;
 
-/* the following depend only on obj_base.h */
-#include "wine/obj_misc.h"
-#include "wine/obj_channel.h"
-#include "wine/obj_clientserver.h"
-#include "wine/obj_storage.h"
+/*****************************************************************************
+ * IMarshal interface
+ */
+DEFINE_GUID(IID_IMarshal, 0x00000003, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMarshal: IUnknown {
 
-/* the following depend on obj_storage.h */
-#include "wine/obj_marshal.h"
-#include "wine/obj_moniker.h"
-#include "wine/obj_propertystorage.h"
+    virtual HRESULT CALLBACK GetUnmarshalClass(
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags,
+        CLSID* pCid) = 0;
 
-/* the following depend on obj_moniker.h */
-#include "wine/obj_dataobject.h"
+    virtual HRESULT CALLBACK GetMarshalSizeMax(
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags,
+        DWORD* pSize) = 0;
 
+    virtual HRESULT CALLBACK MarshalInterface(
+        IStream* pStm,
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags) = 0;
 
-#endif /* __WINE_OBJIDL_H */
+    virtual HRESULT CALLBACK UnmarshalInterface(
+        IStream* pStm,
+        REFIID riid,
+        void** ppv) = 0;
+
+    virtual HRESULT CALLBACK ReleaseMarshalData(
+        IStream* pStm) = 0;
+
+    virtual HRESULT CALLBACK DisconnectObject(
+        DWORD dwReserved) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMarshalVtbl IMarshalVtbl;
+struct IMarshal {
+    const IMarshalVtbl* lpVtbl;
+};
+struct IMarshalVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMarshal* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMarshal* This);
+
+    ULONG (CALLBACK *Release)(
+        IMarshal* This);
+
+    /*** IMarshal methods ***/
+    HRESULT (CALLBACK *GetUnmarshalClass)(
+        IMarshal* This,
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags,
+        CLSID* pCid);
+
+    HRESULT (CALLBACK *GetMarshalSizeMax)(
+        IMarshal* This,
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags,
+        DWORD* pSize);
+
+    HRESULT (CALLBACK *MarshalInterface)(
+        IMarshal* This,
+        IStream* pStm,
+        REFIID riid,
+        void* pv,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        DWORD mshlflags);
+
+    HRESULT (CALLBACK *UnmarshalInterface)(
+        IMarshal* This,
+        IStream* pStm,
+        REFIID riid,
+        void** ppv);
+
+    HRESULT (CALLBACK *ReleaseMarshalData)(
+        IMarshal* This,
+        IStream* pStm);
+
+    HRESULT (CALLBACK *DisconnectObject)(
+        IMarshal* This,
+        DWORD dwReserved);
+
+};
+
+#define IMarshal_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD6 (HRESULT,GetUnmarshalClass,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,CLSID*,pCid) \
+    ICOM_METHOD6 (HRESULT,GetMarshalSizeMax,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,DWORD*,pSize) \
+    ICOM_METHOD6 (HRESULT,MarshalInterface,IStream*,pStm,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags) \
+    ICOM_METHOD3 (HRESULT,UnmarshalInterface,IStream*,pStm,REFIID,riid,void**,ppv) \
+    ICOM_METHOD1 (HRESULT,ReleaseMarshalData,IStream*,pStm) \
+    ICOM_METHOD1 (HRESULT,DisconnectObject,DWORD,dwReserved)
+
+/*** IUnknown methods ***/
+#define IMarshal_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMarshal_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMarshal_Release(p) (p)->lpVtbl->Release(p)
+/*** IMarshal methods ***/
+#define IMarshal_GetUnmarshalClass(p,a,b,c,d,e,f) (p)->lpVtbl->GetUnmarshalClass(p,a,b,c,d,e,f)
+#define IMarshal_GetMarshalSizeMax(p,a,b,c,d,e,f) (p)->lpVtbl->GetMarshalSizeMax(p,a,b,c,d,e,f)
+#define IMarshal_MarshalInterface(p,a,b,c,d,e,f) (p)->lpVtbl->MarshalInterface(p,a,b,c,d,e,f)
+#define IMarshal_UnmarshalInterface(p,a,b,c) (p)->lpVtbl->UnmarshalInterface(p,a,b,c)
+#define IMarshal_ReleaseMarshalData(p,a) (p)->lpVtbl->ReleaseMarshalData(p,a)
+#define IMarshal_DisconnectObject(p,a) (p)->lpVtbl->DisconnectObject(p,a)
+
+#endif
+
+HRESULT CALLBACK IMarshal_GetUnmarshalClass_Proxy(
+    IMarshal* This,
+    REFIID riid,
+    void* pv,
+    DWORD dwDestContext,
+    void* pvDestContext,
+    DWORD mshlflags,
+    CLSID* pCid);
+void __RPC_STUB IMarshal_GetUnmarshalClass_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMarshal_GetMarshalSizeMax_Proxy(
+    IMarshal* This,
+    REFIID riid,
+    void* pv,
+    DWORD dwDestContext,
+    void* pvDestContext,
+    DWORD mshlflags,
+    DWORD* pSize);
+void __RPC_STUB IMarshal_GetMarshalSizeMax_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMarshal_MarshalInterface_Proxy(
+    IMarshal* This,
+    IStream* pStm,
+    REFIID riid,
+    void* pv,
+    DWORD dwDestContext,
+    void* pvDestContext,
+    DWORD mshlflags);
+void __RPC_STUB IMarshal_MarshalInterface_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMarshal_UnmarshalInterface_Proxy(
+    IMarshal* This,
+    IStream* pStm,
+    REFIID riid,
+    void** ppv);
+void __RPC_STUB IMarshal_UnmarshalInterface_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMarshal_ReleaseMarshalData_Proxy(
+    IMarshal* This,
+    IStream* pStm);
+void __RPC_STUB IMarshal_ReleaseMarshalData_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMarshal_DisconnectObject_Proxy(
+    IMarshal* This,
+    DWORD dwReserved);
+void __RPC_STUB IMarshal_DisconnectObject_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IStdMarshalInfo IStdMarshalInfo;
+typedef IStdMarshalInfo *LPSTDMARSHALINFO;
+
+/*****************************************************************************
+ * IStdMarshalInfo interface
+ */
+DEFINE_GUID(IID_IStdMarshalInfo, 0x00000018, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStdMarshalInfo: IUnknown {
+
+    virtual HRESULT CALLBACK GetClassForHandler(
+        DWORD dwDestContext,
+        void* pvDestContext,
+        CLSID* pClsid) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IStdMarshalInfoVtbl IStdMarshalInfoVtbl;
+struct IStdMarshalInfo {
+    const IStdMarshalInfoVtbl* lpVtbl;
+};
+struct IStdMarshalInfoVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IStdMarshalInfo* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IStdMarshalInfo* This);
+
+    ULONG (CALLBACK *Release)(
+        IStdMarshalInfo* This);
+
+    /*** IStdMarshalInfo methods ***/
+    HRESULT (CALLBACK *GetClassForHandler)(
+        IStdMarshalInfo* This,
+        DWORD dwDestContext,
+        void* pvDestContext,
+        CLSID* pClsid);
+
+};
+
+#define IStdMarshalInfo_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,GetClassForHandler,DWORD,dwDestContext,void*,pvDestContext,CLSID*,pClsid)
+
+/*** IUnknown methods ***/
+#define IStdMarshalInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStdMarshalInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStdMarshalInfo_Release(p) (p)->lpVtbl->Release(p)
+/*** IStdMarshalInfo methods ***/
+#define IStdMarshalInfo_GetClassForHandler(p,a,b,c) (p)->lpVtbl->GetClassForHandler(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK IStdMarshalInfo_GetClassForHandler_Proxy(
+    IStdMarshalInfo* This,
+    DWORD dwDestContext,
+    void* pvDestContext,
+    CLSID* pClsid);
+void __RPC_STUB IStdMarshalInfo_GetClassForHandler_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IExternalConnection IExternalConnection;
+typedef IExternalConnection *LPEXTERNALCONNECTION;
+
+typedef enum tagEXTCONN {
+    EXTCONN_STRONG = 0x1,
+    EXTCONN_WEAK = 0x2,
+    EXTCONN_CALLABLE = 0x4
+} EXTCONN;
+
+/*****************************************************************************
+ * IExternalConnection interface
+ */
+DEFINE_GUID(IID_IExternalConnection, 0x00000019, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IExternalConnection: IUnknown {
+
+    virtual DWORD CALLBACK AddConnection(
+        DWORD extconn,
+        DWORD reserved) = 0;
+
+    virtual DWORD CALLBACK ReleaseConnection(
+        DWORD extconn,
+        DWORD reserved,
+        BOOL fLastReleaseCloses) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IExternalConnectionVtbl IExternalConnectionVtbl;
+struct IExternalConnection {
+    const IExternalConnectionVtbl* lpVtbl;
+};
+struct IExternalConnectionVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IExternalConnection* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IExternalConnection* This);
+
+    ULONG (CALLBACK *Release)(
+        IExternalConnection* This);
+
+    /*** IExternalConnection methods ***/
+    DWORD (CALLBACK *AddConnection)(
+        IExternalConnection* This,
+        DWORD extconn,
+        DWORD reserved);
+
+    DWORD (CALLBACK *ReleaseConnection)(
+        IExternalConnection* This,
+        DWORD extconn,
+        DWORD reserved,
+        BOOL fLastReleaseCloses);
+
+};
+
+#define IExternalConnection_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD2 (DWORD,AddConnection,DWORD,extconn,DWORD,reserved) \
+    ICOM_METHOD3 (DWORD,ReleaseConnection,DWORD,extconn,DWORD,reserved,BOOL,fLastReleaseCloses)
+
+/*** IUnknown methods ***/
+#define IExternalConnection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IExternalConnection_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IExternalConnection_Release(p) (p)->lpVtbl->Release(p)
+/*** IExternalConnection methods ***/
+#define IExternalConnection_AddConnection(p,a,b) (p)->lpVtbl->AddConnection(p,a,b)
+#define IExternalConnection_ReleaseConnection(p,a,b,c) (p)->lpVtbl->ReleaseConnection(p,a,b,c)
+
+#endif
+
+DWORD CALLBACK IExternalConnection_AddConnection_Proxy(
+    IExternalConnection* This,
+    DWORD extconn,
+    DWORD reserved);
+void __RPC_STUB IExternalConnection_AddConnection_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+DWORD CALLBACK IExternalConnection_ReleaseConnection_Proxy(
+    IExternalConnection* This,
+    DWORD extconn,
+    DWORD reserved,
+    BOOL fLastReleaseCloses);
+void __RPC_STUB IExternalConnection_ReleaseConnection_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IMultiQI IMultiQI;
+typedef IMultiQI *LPMULTIQI;
+
+typedef struct tagMULTI_QI {
+    const IID *pIID;
+    IUnknown *pItf;
+    HRESULT hr;
+} MULTI_QI;
+
+/*****************************************************************************
+ * IMultiQI interface
+ */
+DEFINE_GUID(IID_IMultiQI, 0x00000020, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMultiQI: IUnknown {
+
+    virtual HRESULT CALLBACK QueryMultipleInterfaces(
+        ULONG cMQIs,
+        MULTI_QI* pMQIs) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMultiQIVtbl IMultiQIVtbl;
+struct IMultiQI {
+    const IMultiQIVtbl* lpVtbl;
+};
+struct IMultiQIVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMultiQI* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMultiQI* This);
+
+    ULONG (CALLBACK *Release)(
+        IMultiQI* This);
+
+    /*** IMultiQI methods ***/
+    HRESULT (CALLBACK *QueryMultipleInterfaces)(
+        IMultiQI* This,
+        ULONG cMQIs,
+        MULTI_QI* pMQIs);
+
+};
+
+#define IMultiQI_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD2 (HRESULT,QueryMultipleInterfaces,ULONG,cMQIs,MULTI_QI*,pMQIs)
+
+/*** IUnknown methods ***/
+#define IMultiQI_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMultiQI_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMultiQI_Release(p) (p)->lpVtbl->Release(p)
+/*** IMultiQI methods ***/
+#define IMultiQI_QueryMultipleInterfaces(p,a,b) (p)->lpVtbl->QueryMultipleInterfaces(p,a,b)
+
+#endif
+
+HRESULT CALLBACK IMultiQI_QueryMultipleInterfaces_Proxy(
+    IMultiQI* This,
+    ULONG cMQIs,
+    MULTI_QI* pMQIs);
+void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IMalloc IMalloc;
+typedef IMalloc *LPMALLOC;
+
+/*****************************************************************************
+ * IMalloc interface
+ */
+DEFINE_GUID(IID_IMalloc, 0x00000002, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMalloc: IUnknown {
+
+    virtual LPVOID CALLBACK Alloc(
+        ULONG cb) = 0;
+
+    virtual LPVOID CALLBACK Realloc(
+        LPVOID pv,
+        ULONG cb) = 0;
+
+    virtual void CALLBACK Free(
+        LPVOID pv) = 0;
+
+    virtual ULONG CALLBACK GetSize(
+        LPVOID pv) = 0;
+
+    virtual int CALLBACK DidAlloc(
+        LPVOID pv) = 0;
+
+    virtual void CALLBACK HeapMinimize(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMallocVtbl IMallocVtbl;
+struct IMalloc {
+    const IMallocVtbl* lpVtbl;
+};
+struct IMallocVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMalloc* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMalloc* This);
+
+    ULONG (CALLBACK *Release)(
+        IMalloc* This);
+
+    /*** IMalloc methods ***/
+    LPVOID (CALLBACK *Alloc)(
+        IMalloc* This,
+        ULONG cb);
+
+    LPVOID (CALLBACK *Realloc)(
+        IMalloc* This,
+        LPVOID pv,
+        ULONG cb);
+
+    void (CALLBACK *Free)(
+        IMalloc* This,
+        LPVOID pv);
+
+    ULONG (CALLBACK *GetSize)(
+        IMalloc* This,
+        LPVOID pv);
+
+    int (CALLBACK *DidAlloc)(
+        IMalloc* This,
+        LPVOID pv);
+
+    void (CALLBACK *HeapMinimize)(
+        IMalloc* This);
+
+};
+
+#define IMalloc_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (LPVOID,Alloc,ULONG,cb) \
+    ICOM_METHOD2 (LPVOID,Realloc,LPVOID,pv,ULONG,cb) \
+    ICOM_VMETHOD1(Free,LPVOID,pv) \
+    ICOM_METHOD1 (ULONG,GetSize,LPVOID,pv) \
+    ICOM_METHOD1 (int,DidAlloc,LPVOID,pv) \
+    ICOM_VMETHOD (HeapMinimize)
+
+/*** IUnknown methods ***/
+#define IMalloc_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMalloc_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMalloc_Release(p) (p)->lpVtbl->Release(p)
+/*** IMalloc methods ***/
+#define IMalloc_Alloc(p,a) (p)->lpVtbl->Alloc(p,a)
+#define IMalloc_Realloc(p,a,b) (p)->lpVtbl->Realloc(p,a,b)
+#define IMalloc_Free(p,a) (p)->lpVtbl->Free(p,a)
+#define IMalloc_GetSize(p,a) (p)->lpVtbl->GetSize(p,a)
+#define IMalloc_DidAlloc(p,a) (p)->lpVtbl->DidAlloc(p,a)
+#define IMalloc_HeapMinimize(p) (p)->lpVtbl->HeapMinimize(p)
+
+#endif
+
+LPVOID CALLBACK IMalloc_Alloc_Proxy(
+    IMalloc* This,
+    ULONG cb);
+void __RPC_STUB IMalloc_Alloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMalloc_Realloc_Proxy(
+    IMalloc* This,
+    LPVOID pv,
+    ULONG cb);
+void __RPC_STUB IMalloc_Realloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IMalloc_Free_Proxy(
+    IMalloc* This,
+    LPVOID pv);
+void __RPC_STUB IMalloc_Free_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+ULONG CALLBACK IMalloc_GetSize_Proxy(
+    IMalloc* This,
+    LPVOID pv);
+void __RPC_STUB IMalloc_GetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+int CALLBACK IMalloc_DidAlloc_Proxy(
+    IMalloc* This,
+    LPVOID pv);
+void __RPC_STUB IMalloc_DidAlloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IMalloc_HeapMinimize_Proxy(
+    IMalloc* This);
+void __RPC_STUB IMalloc_HeapMinimize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IMallocSpy IMallocSpy;
+typedef IMallocSpy *LPMALLOCSPY;
+
+/*****************************************************************************
+ * IMallocSpy interface
+ */
+DEFINE_GUID(IID_IMallocSpy, 0x0000001d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMallocSpy: IUnknown {
+
+    virtual ULONG CALLBACK PreAlloc(
+        ULONG cbRequest) = 0;
+
+    virtual LPVOID CALLBACK PostAlloc(
+        LPVOID pActual) = 0;
+
+    virtual LPVOID CALLBACK PreFree(
+        LPVOID pRequest,
+        BOOL fSpyed) = 0;
+
+    virtual void CALLBACK PostFree(
+        BOOL fSpyed) = 0;
+
+    virtual ULONG CALLBACK PreRealloc(
+        LPVOID pRequest,
+        ULONG cbRequest,
+        LPVOID* ppNewRequest,
+        BOOL fSpyed) = 0;
+
+    virtual LPVOID CALLBACK PostRealloc(
+        LPVOID pActual,
+        BOOL fSpyed) = 0;
+
+    virtual LPVOID CALLBACK PreGetSize(
+        LPVOID pRequest,
+        BOOL fSpyed) = 0;
+
+    virtual ULONG CALLBACK PostGetSize(
+        ULONG cbActual,
+        BOOL fSpyed) = 0;
+
+    virtual LPVOID CALLBACK PreDidAlloc(
+        LPVOID pRequest,
+        BOOL fSpyed) = 0;
+
+    virtual int CALLBACK PostDidAlloc(
+        LPVOID pRequest,
+        BOOL fSpyed,
+        int fActual) = 0;
+
+    virtual void CALLBACK PreHeapMinimize(
+        ) = 0;
+
+    virtual void CALLBACK PostHeapMinimize(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMallocSpyVtbl IMallocSpyVtbl;
+struct IMallocSpy {
+    const IMallocSpyVtbl* lpVtbl;
+};
+struct IMallocSpyVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMallocSpy* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMallocSpy* This);
+
+    ULONG (CALLBACK *Release)(
+        IMallocSpy* This);
+
+    /*** IMallocSpy methods ***/
+    ULONG (CALLBACK *PreAlloc)(
+        IMallocSpy* This,
+        ULONG cbRequest);
+
+    LPVOID (CALLBACK *PostAlloc)(
+        IMallocSpy* This,
+        LPVOID pActual);
+
+    LPVOID (CALLBACK *PreFree)(
+        IMallocSpy* This,
+        LPVOID pRequest,
+        BOOL fSpyed);
+
+    void (CALLBACK *PostFree)(
+        IMallocSpy* This,
+        BOOL fSpyed);
+
+    ULONG (CALLBACK *PreRealloc)(
+        IMallocSpy* This,
+        LPVOID pRequest,
+        ULONG cbRequest,
+        LPVOID* ppNewRequest,
+        BOOL fSpyed);
+
+    LPVOID (CALLBACK *PostRealloc)(
+        IMallocSpy* This,
+        LPVOID pActual,
+        BOOL fSpyed);
+
+    LPVOID (CALLBACK *PreGetSize)(
+        IMallocSpy* This,
+        LPVOID pRequest,
+        BOOL fSpyed);
+
+    ULONG (CALLBACK *PostGetSize)(
+        IMallocSpy* This,
+        ULONG cbActual,
+        BOOL fSpyed);
+
+    LPVOID (CALLBACK *PreDidAlloc)(
+        IMallocSpy* This,
+        LPVOID pRequest,
+        BOOL fSpyed);
+
+    int (CALLBACK *PostDidAlloc)(
+        IMallocSpy* This,
+        LPVOID pRequest,
+        BOOL fSpyed,
+        int fActual);
+
+    void (CALLBACK *PreHeapMinimize)(
+        IMallocSpy* This);
+
+    void (CALLBACK *PostHeapMinimize)(
+        IMallocSpy* This);
+
+};
+
+#define IMallocSpy_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (ULONG,PreAlloc,ULONG,cbRequest) \
+    ICOM_METHOD1 (LPVOID,PostAlloc,LPVOID,pActual) \
+    ICOM_METHOD2 (LPVOID,PreFree,LPVOID,pRequest,BOOL,fSpyed) \
+    ICOM_VMETHOD1(PostFree,BOOL,fSpyed) \
+    ICOM_METHOD4 (ULONG,PreRealloc,LPVOID,pRequest,ULONG,cbRequest,LPVOID*,ppNewRequest,BOOL,fSpyed) \
+    ICOM_METHOD2 (LPVOID,PostRealloc,LPVOID,pActual,BOOL,fSpyed) \
+    ICOM_METHOD2 (LPVOID,PreGetSize,LPVOID,pRequest,BOOL,fSpyed) \
+    ICOM_METHOD2 (ULONG,PostGetSize,ULONG,cbActual,BOOL,fSpyed) \
+    ICOM_METHOD2 (LPVOID,PreDidAlloc,LPVOID,pRequest,BOOL,fSpyed) \
+    ICOM_METHOD3 (int,PostDidAlloc,LPVOID,pRequest,BOOL,fSpyed,int,fActual) \
+    ICOM_VMETHOD (PreHeapMinimize) \
+    ICOM_VMETHOD (PostHeapMinimize)
+
+/*** IUnknown methods ***/
+#define IMallocSpy_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMallocSpy_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMallocSpy_Release(p) (p)->lpVtbl->Release(p)
+/*** IMallocSpy methods ***/
+#define IMallocSpy_PreAlloc(p,a) (p)->lpVtbl->PreAlloc(p,a)
+#define IMallocSpy_PostAlloc(p,a) (p)->lpVtbl->PostAlloc(p,a)
+#define IMallocSpy_PreFree(p,a,b) (p)->lpVtbl->PreFree(p,a,b)
+#define IMallocSpy_PostFree(p,a) (p)->lpVtbl->PostFree(p,a)
+#define IMallocSpy_PreRealloc(p,a,b,c,d) (p)->lpVtbl->PreRealloc(p,a,b,c,d)
+#define IMallocSpy_PostRealloc(p,a,b) (p)->lpVtbl->PostRealloc(p,a,b)
+#define IMallocSpy_PreGetSize(p,a,b) (p)->lpVtbl->PreGetSize(p,a,b)
+#define IMallocSpy_PostGetSize(p,a,b) (p)->lpVtbl->PostGetSize(p,a,b)
+#define IMallocSpy_PreDidAlloc(p,a,b) (p)->lpVtbl->PreDidAlloc(p,a,b)
+#define IMallocSpy_PostDidAlloc(p,a,b,c) (p)->lpVtbl->PostDidAlloc(p,a,b,c)
+#define IMallocSpy_PreHeapMinimize(p) (p)->lpVtbl->PreHeapMinimize(p)
+#define IMallocSpy_PostHeapMinimize(p) (p)->lpVtbl->PostHeapMinimize(p)
+
+#endif
+
+ULONG CALLBACK IMallocSpy_PreAlloc_Proxy(
+    IMallocSpy* This,
+    ULONG cbRequest);
+void __RPC_STUB IMallocSpy_PreAlloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMallocSpy_PostAlloc_Proxy(
+    IMallocSpy* This,
+    LPVOID pActual);
+void __RPC_STUB IMallocSpy_PostAlloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMallocSpy_PreFree_Proxy(
+    IMallocSpy* This,
+    LPVOID pRequest,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PreFree_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IMallocSpy_PostFree_Proxy(
+    IMallocSpy* This,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PostFree_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+ULONG CALLBACK IMallocSpy_PreRealloc_Proxy(
+    IMallocSpy* This,
+    LPVOID pRequest,
+    ULONG cbRequest,
+    LPVOID* ppNewRequest,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PreRealloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMallocSpy_PostRealloc_Proxy(
+    IMallocSpy* This,
+    LPVOID pActual,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PostRealloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMallocSpy_PreGetSize_Proxy(
+    IMallocSpy* This,
+    LPVOID pRequest,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PreGetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+ULONG CALLBACK IMallocSpy_PostGetSize_Proxy(
+    IMallocSpy* This,
+    ULONG cbActual,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PostGetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+LPVOID CALLBACK IMallocSpy_PreDidAlloc_Proxy(
+    IMallocSpy* This,
+    LPVOID pRequest,
+    BOOL fSpyed);
+void __RPC_STUB IMallocSpy_PreDidAlloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+int CALLBACK IMallocSpy_PostDidAlloc_Proxy(
+    IMallocSpy* This,
+    LPVOID pRequest,
+    BOOL fSpyed,
+    int fActual);
+void __RPC_STUB IMallocSpy_PostDidAlloc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IMallocSpy_PreHeapMinimize_Proxy(
+    IMallocSpy* This);
+void __RPC_STUB IMallocSpy_PreHeapMinimize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IMallocSpy_PostHeapMinimize_Proxy(
+    IMallocSpy* This);
+void __RPC_STUB IMallocSpy_PostHeapMinimize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumUnknown IEnumUnknown;
+typedef IEnumUnknown *LPENUMUNKNOWN;
+
+/*****************************************************************************
+ * IEnumUnknown interface
+ */
+DEFINE_GUID(IID_IEnumUnknown, 0x00000100, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumUnknown: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        IUnknown** rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumUnknown** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumUnknownVtbl IEnumUnknownVtbl;
+struct IEnumUnknown {
+    const IEnumUnknownVtbl* lpVtbl;
+};
+struct IEnumUnknownVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumUnknown* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumUnknown* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumUnknown* This);
+
+    /*** IEnumUnknown methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumUnknown* This,
+        ULONG celt,
+        IUnknown** rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumUnknown* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumUnknown* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumUnknown* This,
+        IEnumUnknown** ppenum);
+
+};
+
+#define IEnumUnknown_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IUnknown**,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumUnknown**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumUnknown_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumUnknown_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumUnknown_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumUnknown methods ***/
+#define IEnumUnknown_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumUnknown_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumUnknown_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumUnknown_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumUnknown_RemoteNext_Proxy(
+    IEnumUnknown* This,
+    ULONG celt,
+    IUnknown** rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumUnknown_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumUnknown_Next_Proxy(
+    IEnumUnknown* This,
+    ULONG celt,
+    IUnknown** rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumUnknown_Next_Stub(
+    IEnumUnknown* This,
+    ULONG celt,
+    IUnknown** rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumUnknown_Skip_Proxy(
+    IEnumUnknown* This,
+    ULONG celt);
+void __RPC_STUB IEnumUnknown_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumUnknown_Reset_Proxy(
+    IEnumUnknown* This);
+void __RPC_STUB IEnumUnknown_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumUnknown_Clone_Proxy(
+    IEnumUnknown* This,
+    IEnumUnknown** ppenum);
+void __RPC_STUB IEnumUnknown_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct ISurrogate ISurrogate;
+typedef ISurrogate *LPSURROGATE;
+
+/*****************************************************************************
+ * ISurrogate interface
+ */
+DEFINE_GUID(IID_ISurrogate, 0x00000022, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ISurrogate: IUnknown {
+
+    virtual HRESULT CALLBACK LoadDllServer(
+        REFCLSID Clsid) = 0;
+
+    virtual HRESULT CALLBACK FreeSurrogate(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct ISurrogateVtbl ISurrogateVtbl;
+struct ISurrogate {
+    const ISurrogateVtbl* lpVtbl;
+};
+struct ISurrogateVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        ISurrogate* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        ISurrogate* This);
+
+    ULONG (CALLBACK *Release)(
+        ISurrogate* This);
+
+    /*** ISurrogate methods ***/
+    HRESULT (CALLBACK *LoadDllServer)(
+        ISurrogate* This,
+        REFCLSID Clsid);
+
+    HRESULT (CALLBACK *FreeSurrogate)(
+        ISurrogate* This);
+
+};
+
+#define ISurrogate_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,LoadDllServer,REFCLSID,Clsid) \
+    ICOM_METHOD  (HRESULT,FreeSurrogate)
+
+/*** IUnknown methods ***/
+#define ISurrogate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ISurrogate_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ISurrogate_Release(p) (p)->lpVtbl->Release(p)
+/*** ISurrogate methods ***/
+#define ISurrogate_LoadDllServer(p,a) (p)->lpVtbl->LoadDllServer(p,a)
+#define ISurrogate_FreeSurrogate(p) (p)->lpVtbl->FreeSurrogate(p)
+
+#endif
+
+HRESULT CALLBACK ISurrogate_LoadDllServer_Proxy(
+    ISurrogate* This,
+    REFCLSID Clsid);
+void __RPC_STUB ISurrogate_LoadDllServer_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ISurrogate_FreeSurrogate_Proxy(
+    ISurrogate* This);
+void __RPC_STUB ISurrogate_FreeSurrogate_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IGlobalInterfaceTable IGlobalInterfaceTable;
+typedef IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;
+
+/*****************************************************************************
+ * IGlobalInterfaceTable interface
+ */
+DEFINE_GUID(IID_IGlobalInterfaceTable, 0x00000146, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IGlobalInterfaceTable: IUnknown {
+
+    virtual HRESULT CALLBACK RegisterInterfaceInGlobal(
+        IUnknown* pUnk,
+        REFIID riid,
+        DWORD* pdwCookie) = 0;
+
+    virtual HRESULT CALLBACK RevokeInterfaceFromGlobal(
+        DWORD dwCookie) = 0;
+
+    virtual HRESULT CALLBACK GetInterfaceFromGlobal(
+        DWORD dwCookie,
+        REFIID riid,
+        void** ppv) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IGlobalInterfaceTableVtbl IGlobalInterfaceTableVtbl;
+struct IGlobalInterfaceTable {
+    const IGlobalInterfaceTableVtbl* lpVtbl;
+};
+struct IGlobalInterfaceTableVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IGlobalInterfaceTable* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IGlobalInterfaceTable* This);
+
+    ULONG (CALLBACK *Release)(
+        IGlobalInterfaceTable* This);
+
+    /*** IGlobalInterfaceTable methods ***/
+    HRESULT (CALLBACK *RegisterInterfaceInGlobal)(
+        IGlobalInterfaceTable* This,
+        IUnknown* pUnk,
+        REFIID riid,
+        DWORD* pdwCookie);
+
+    HRESULT (CALLBACK *RevokeInterfaceFromGlobal)(
+        IGlobalInterfaceTable* This,
+        DWORD dwCookie);
+
+    HRESULT (CALLBACK *GetInterfaceFromGlobal)(
+        IGlobalInterfaceTable* This,
+        DWORD dwCookie,
+        REFIID riid,
+        void** ppv);
+
+};
+
+#define IGlobalInterfaceTable_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,RegisterInterfaceInGlobal,IUnknown*,pUnk,REFIID,riid,DWORD*,pdwCookie) \
+    ICOM_METHOD1 (HRESULT,RevokeInterfaceFromGlobal,DWORD,dwCookie) \
+    ICOM_METHOD3 (HRESULT,GetInterfaceFromGlobal,DWORD,dwCookie,REFIID,riid,void**,ppv)
+
+/*** IUnknown methods ***/
+#define IGlobalInterfaceTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IGlobalInterfaceTable_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IGlobalInterfaceTable_Release(p) (p)->lpVtbl->Release(p)
+/*** IGlobalInterfaceTable methods ***/
+#define IGlobalInterfaceTable_RegisterInterfaceInGlobal(p,a,b,c) (p)->lpVtbl->RegisterInterfaceInGlobal(p,a,b,c)
+#define IGlobalInterfaceTable_RevokeInterfaceFromGlobal(p,a) (p)->lpVtbl->RevokeInterfaceFromGlobal(p,a)
+#define IGlobalInterfaceTable_GetInterfaceFromGlobal(p,a,b,c) (p)->lpVtbl->GetInterfaceFromGlobal(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK IGlobalInterfaceTable_RegisterInterfaceInGlobal_Proxy(
+    IGlobalInterfaceTable* This,
+    IUnknown* pUnk,
+    REFIID riid,
+    DWORD* pdwCookie);
+void __RPC_STUB IGlobalInterfaceTable_RegisterInterfaceInGlobal_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Proxy(
+    IGlobalInterfaceTable* This,
+    DWORD dwCookie);
+void __RPC_STUB IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IGlobalInterfaceTable_GetInterfaceFromGlobal_Proxy(
+    IGlobalInterfaceTable* This,
+    DWORD dwCookie,
+    REFIID riid,
+    void** ppv);
+void __RPC_STUB IGlobalInterfaceTable_GetInterfaceFromGlobal_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IBindCtx IBindCtx;
+typedef IBindCtx *LPBINDCTX;
+
+typedef IBindCtx *LPBC;
+
+typedef struct tagBIND_OPTS {
+    DWORD cbStruct;
+    DWORD grfFlags;
+    DWORD grfMode;
+    DWORD dwTickCountDeadline;
+} BIND_OPTS, *LPBIND_OPTS;
+
+typedef struct tagBIND_OPTS2 {
+    DWORD cbStruct;
+    DWORD grfFlags;
+    DWORD grfMode;
+    DWORD dwTickCountDeadline;
+    DWORD dwTrackFlags;
+    DWORD dwClassContext;
+    LCID locale;
+    COSERVERINFO *pServerInfo;
+} BIND_OPTS2, *LPBIND_OPTS2;
+
+typedef enum tagBIND_FLAGS {
+    BIND_MAYBOTHERUSER = 1,
+    BIND_JUSTTESTEXISTENCE = 2
+} BIND_FLAGS;
+
+/*****************************************************************************
+ * IBindCtx interface
+ */
+DEFINE_GUID(IID_IBindCtx, 0x0000000e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IBindCtx: IUnknown {
+
+    virtual HRESULT CALLBACK RegisterObjectBound(
+        IUnknown* punk) = 0;
+
+    virtual HRESULT CALLBACK RevokeObjectBound(
+        IUnknown* punk) = 0;
+
+    virtual HRESULT CALLBACK ReleaseBoundObjects(
+        ) = 0;
+
+    virtual HRESULT CALLBACK SetBindOptions(
+        BIND_OPTS* pbindopts) = 0;
+
+    virtual HRESULT CALLBACK GetBindOptions(
+        BIND_OPTS* pbindopts) = 0;
+
+    virtual HRESULT CALLBACK GetRunningObjectTable(
+        IRunningObjectTable** pprot) = 0;
+
+    virtual HRESULT CALLBACK RegisterObjectParam(
+        LPOLESTR pszKey,
+        IUnknown* punk) = 0;
+
+    virtual HRESULT CALLBACK GetObjectParam(
+        LPOLESTR pszKey,
+        IUnknown** ppunk) = 0;
+
+    virtual HRESULT CALLBACK EnumObjectParam(
+        IEnumString** ppenum) = 0;
+
+    virtual HRESULT CALLBACK RevokeObjectParam(
+        LPOLESTR pszKey) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IBindCtxVtbl IBindCtxVtbl;
+struct IBindCtx {
+    const IBindCtxVtbl* lpVtbl;
+};
+struct IBindCtxVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IBindCtx* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IBindCtx* This);
+
+    ULONG (CALLBACK *Release)(
+        IBindCtx* This);
+
+    /*** IBindCtx methods ***/
+    HRESULT (CALLBACK *RegisterObjectBound)(
+        IBindCtx* This,
+        IUnknown* punk);
+
+    HRESULT (CALLBACK *RevokeObjectBound)(
+        IBindCtx* This,
+        IUnknown* punk);
+
+    HRESULT (CALLBACK *ReleaseBoundObjects)(
+        IBindCtx* This);
+
+    HRESULT (CALLBACK *SetBindOptions)(
+        IBindCtx* This,
+        BIND_OPTS* pbindopts);
+
+    HRESULT (CALLBACK *GetBindOptions)(
+        IBindCtx* This,
+        BIND_OPTS* pbindopts);
+
+    HRESULT (CALLBACK *GetRunningObjectTable)(
+        IBindCtx* This,
+        IRunningObjectTable** pprot);
+
+    HRESULT (CALLBACK *RegisterObjectParam)(
+        IBindCtx* This,
+        LPOLESTR pszKey,
+        IUnknown* punk);
+
+    HRESULT (CALLBACK *GetObjectParam)(
+        IBindCtx* This,
+        LPOLESTR pszKey,
+        IUnknown** ppunk);
+
+    HRESULT (CALLBACK *EnumObjectParam)(
+        IBindCtx* This,
+        IEnumString** ppenum);
+
+    HRESULT (CALLBACK *RevokeObjectParam)(
+        IBindCtx* This,
+        LPOLESTR pszKey);
+
+};
+
+#define IBindCtx_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,RegisterObjectBound,IUnknown*,punk) \
+    ICOM_METHOD1 (HRESULT,RevokeObjectBound,IUnknown*,punk) \
+    ICOM_METHOD  (HRESULT,ReleaseBoundObjects) \
+    ICOM_METHOD1 (HRESULT,SetBindOptions,BIND_OPTS*,pbindopts) \
+    ICOM_METHOD1 (HRESULT,GetBindOptions,BIND_OPTS*,pbindopts) \
+    ICOM_METHOD1 (HRESULT,GetRunningObjectTable,IRunningObjectTable**,pprot) \
+    ICOM_METHOD2 (HRESULT,RegisterObjectParam,LPOLESTR,pszKey,IUnknown*,punk) \
+    ICOM_METHOD2 (HRESULT,GetObjectParam,LPOLESTR,pszKey,IUnknown**,ppunk) \
+    ICOM_METHOD1 (HRESULT,EnumObjectParam,IEnumString**,ppenum) \
+    ICOM_METHOD1 (HRESULT,RevokeObjectParam,LPOLESTR,pszKey)
+
+/*** IUnknown methods ***/
+#define IBindCtx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IBindCtx_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IBindCtx_Release(p) (p)->lpVtbl->Release(p)
+/*** IBindCtx methods ***/
+#define IBindCtx_RegisterObjectBound(p,a) (p)->lpVtbl->RegisterObjectBound(p,a)
+#define IBindCtx_RevokeObjectBound(p,a) (p)->lpVtbl->RevokeObjectBound(p,a)
+#define IBindCtx_ReleaseBoundObjects(p) (p)->lpVtbl->ReleaseBoundObjects(p)
+#define IBindCtx_SetBindOptions(p,a) (p)->lpVtbl->SetBindOptions(p,a)
+#define IBindCtx_GetBindOptions(p,a) (p)->lpVtbl->GetBindOptions(p,a)
+#define IBindCtx_GetRunningObjectTable(p,a) (p)->lpVtbl->GetRunningObjectTable(p,a)
+#define IBindCtx_RegisterObjectParam(p,a,b) (p)->lpVtbl->RegisterObjectParam(p,a,b)
+#define IBindCtx_GetObjectParam(p,a,b) (p)->lpVtbl->GetObjectParam(p,a,b)
+#define IBindCtx_EnumObjectParam(p,a) (p)->lpVtbl->EnumObjectParam(p,a)
+#define IBindCtx_RevokeObjectParam(p,a) (p)->lpVtbl->RevokeObjectParam(p,a)
+
+#endif
+
+HRESULT CALLBACK IBindCtx_RegisterObjectBound_Proxy(
+    IBindCtx* This,
+    IUnknown* punk);
+void __RPC_STUB IBindCtx_RegisterObjectBound_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_RevokeObjectBound_Proxy(
+    IBindCtx* This,
+    IUnknown* punk);
+void __RPC_STUB IBindCtx_RevokeObjectBound_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_ReleaseBoundObjects_Proxy(
+    IBindCtx* This);
+void __RPC_STUB IBindCtx_ReleaseBoundObjects_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_RemoteSetBindOptions_Proxy(
+    IBindCtx* This,
+    BIND_OPTS2* pbindopts);
+void __RPC_STUB IBindCtx_RemoteSetBindOptions_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy(
+    IBindCtx* This,
+    BIND_OPTS* pbindopts);
+HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub(
+    IBindCtx* This,
+    BIND_OPTS2* pbindopts);
+HRESULT CALLBACK IBindCtx_RemoteGetBindOptions_Proxy(
+    IBindCtx* This,
+    BIND_OPTS2* pbindopts);
+void __RPC_STUB IBindCtx_RemoteGetBindOptions_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy(
+    IBindCtx* This,
+    BIND_OPTS* pbindopts);
+HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub(
+    IBindCtx* This,
+    BIND_OPTS2* pbindopts);
+HRESULT CALLBACK IBindCtx_GetRunningObjectTable_Proxy(
+    IBindCtx* This,
+    IRunningObjectTable** pprot);
+void __RPC_STUB IBindCtx_GetRunningObjectTable_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_RegisterObjectParam_Proxy(
+    IBindCtx* This,
+    LPOLESTR pszKey,
+    IUnknown* punk);
+void __RPC_STUB IBindCtx_RegisterObjectParam_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_GetObjectParam_Proxy(
+    IBindCtx* This,
+    LPOLESTR pszKey,
+    IUnknown** ppunk);
+void __RPC_STUB IBindCtx_GetObjectParam_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_EnumObjectParam_Proxy(
+    IBindCtx* This,
+    IEnumString** ppenum);
+void __RPC_STUB IBindCtx_EnumObjectParam_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IBindCtx_RevokeObjectParam_Proxy(
+    IBindCtx* This,
+    LPOLESTR pszKey);
+void __RPC_STUB IBindCtx_RevokeObjectParam_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumMoniker IEnumMoniker;
+typedef IEnumMoniker *LPENUMMONIKER;
+
+/*****************************************************************************
+ * IEnumMoniker interface
+ */
+DEFINE_GUID(IID_IEnumMoniker, 0x00000102, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumMoniker: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        IMoniker** rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumMoniker** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumMonikerVtbl IEnumMonikerVtbl;
+struct IEnumMoniker {
+    const IEnumMonikerVtbl* lpVtbl;
+};
+struct IEnumMonikerVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumMoniker* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumMoniker* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumMoniker* This);
+
+    /*** IEnumMoniker methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumMoniker* This,
+        ULONG celt,
+        IMoniker** rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumMoniker* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumMoniker* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumMoniker* This,
+        IEnumMoniker** ppenum);
+
+};
+
+#define IEnumMoniker_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IMoniker**,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumMoniker**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumMoniker_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumMoniker_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumMoniker methods ***/
+#define IEnumMoniker_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumMoniker_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumMoniker_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumMoniker_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumMoniker_RemoteNext_Proxy(
+    IEnumMoniker* This,
+    ULONG celt,
+    IMoniker** rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumMoniker_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMoniker_Next_Proxy(
+    IEnumMoniker* This,
+    ULONG celt,
+    IMoniker** rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumMoniker_Next_Stub(
+    IEnumMoniker* This,
+    ULONG celt,
+    IMoniker** rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumMoniker_Skip_Proxy(
+    IEnumMoniker* This,
+    ULONG celt);
+void __RPC_STUB IEnumMoniker_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMoniker_Reset_Proxy(
+    IEnumMoniker* This);
+void __RPC_STUB IEnumMoniker_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMoniker_Clone_Proxy(
+    IEnumMoniker* This,
+    IEnumMoniker** ppenum);
+void __RPC_STUB IEnumMoniker_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRunnableObject IRunnableObject;
+typedef IRunnableObject *LPRUNNABLEOBJECT;
+
+/*****************************************************************************
+ * IRunnableObject interface
+ */
+DEFINE_GUID(IID_IRunnableObject, 0x00000126, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRunnableObject: IUnknown {
+
+    virtual HRESULT CALLBACK GetRunningClass(
+        LPCLSID lpClsid) = 0;
+
+    virtual HRESULT CALLBACK Run(
+        LPBINDCTX pbc) = 0;
+
+    virtual BOOL CALLBACK IsRunning(
+        ) = 0;
+
+    virtual HRESULT CALLBACK LockRunning(
+        BOOL fLock,
+        BOOL fLastUnlockCloses) = 0;
+
+    virtual HRESULT CALLBACK SetContainedObject(
+        BOOL fContained) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRunnableObjectVtbl IRunnableObjectVtbl;
+struct IRunnableObject {
+    const IRunnableObjectVtbl* lpVtbl;
+};
+struct IRunnableObjectVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRunnableObject* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRunnableObject* This);
+
+    ULONG (CALLBACK *Release)(
+        IRunnableObject* This);
+
+    /*** IRunnableObject methods ***/
+    HRESULT (CALLBACK *GetRunningClass)(
+        IRunnableObject* This,
+        LPCLSID lpClsid);
+
+    HRESULT (CALLBACK *Run)(
+        IRunnableObject* This,
+        LPBINDCTX pbc);
+
+    BOOL (CALLBACK *IsRunning)(
+        IRunnableObject* This);
+
+    HRESULT (CALLBACK *LockRunning)(
+        IRunnableObject* This,
+        BOOL fLock,
+        BOOL fLastUnlockCloses);
+
+    HRESULT (CALLBACK *SetContainedObject)(
+        IRunnableObject* This,
+        BOOL fContained);
+
+};
+
+#define IRunnableObject_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,GetRunningClass,LPCLSID,lpClsid) \
+    ICOM_METHOD1 (HRESULT,Run,LPBINDCTX,pbc) \
+    ICOM_METHOD  (BOOL,IsRunning) \
+    ICOM_METHOD2 (HRESULT,LockRunning,BOOL,fLock,BOOL,fLastUnlockCloses) \
+    ICOM_METHOD1 (HRESULT,SetContainedObject,BOOL,fContained)
+
+/*** IUnknown methods ***/
+#define IRunnableObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRunnableObject_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRunnableObject_Release(p) (p)->lpVtbl->Release(p)
+/*** IRunnableObject methods ***/
+#define IRunnableObject_GetRunningClass(p,a) (p)->lpVtbl->GetRunningClass(p,a)
+#define IRunnableObject_Run(p,a) (p)->lpVtbl->Run(p,a)
+#define IRunnableObject_IsRunning(p) (p)->lpVtbl->IsRunning(p)
+#define IRunnableObject_LockRunning(p,a,b) (p)->lpVtbl->LockRunning(p,a,b)
+#define IRunnableObject_SetContainedObject(p,a) (p)->lpVtbl->SetContainedObject(p,a)
+
+#endif
+
+HRESULT CALLBACK IRunnableObject_GetRunningClass_Proxy(
+    IRunnableObject* This,
+    LPCLSID lpClsid);
+void __RPC_STUB IRunnableObject_GetRunningClass_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunnableObject_Run_Proxy(
+    IRunnableObject* This,
+    LPBINDCTX pbc);
+void __RPC_STUB IRunnableObject_Run_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunnableObject_RemoteIsRunning_Proxy(
+    IRunnableObject* This);
+void __RPC_STUB IRunnableObject_RemoteIsRunning_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+BOOL CALLBACK IRunnableObject_IsRunning_Proxy(
+    IRunnableObject* This);
+HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub(
+    IRunnableObject* This);
+HRESULT CALLBACK IRunnableObject_LockRunning_Proxy(
+    IRunnableObject* This,
+    BOOL fLock,
+    BOOL fLastUnlockCloses);
+void __RPC_STUB IRunnableObject_LockRunning_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunnableObject_SetContainedObject_Proxy(
+    IRunnableObject* This,
+    BOOL fContained);
+void __RPC_STUB IRunnableObject_SetContainedObject_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#ifdef __WINE__
+#undef GetObject
+#endif
+typedef IRunningObjectTable *LPRUNNINGOBJECTTABLE;
+
+/*****************************************************************************
+ * IRunningObjectTable interface
+ */
+DEFINE_GUID(IID_IRunningObjectTable, 0x00000010, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRunningObjectTable: IUnknown {
+
+    virtual HRESULT CALLBACK Register(
+        DWORD grfFlags,
+        IUnknown* punkObject,
+        IMoniker* pmkObjectName,
+        DWORD* pdwRegister) = 0;
+
+    virtual HRESULT CALLBACK Revoke(
+        DWORD dwRegister) = 0;
+
+    virtual HRESULT CALLBACK IsRunning(
+        IMoniker* pmkObjectName) = 0;
+
+    virtual HRESULT CALLBACK GetObject(
+        IMoniker* pmkObjectName,
+        IUnknown** ppunkObject) = 0;
+
+    virtual HRESULT CALLBACK NoteChangeTime(
+        DWORD dwRegister,
+        FILETIME* pfiletime) = 0;
+
+    virtual HRESULT CALLBACK GetTimeOfLastChange(
+        IMoniker* pmkObjectName,
+        FILETIME* pfiletime) = 0;
+
+    virtual HRESULT CALLBACK EnumRunning(
+        IEnumMoniker** ppenumMoniker) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRunningObjectTableVtbl IRunningObjectTableVtbl;
+struct IRunningObjectTable {
+    const IRunningObjectTableVtbl* lpVtbl;
+};
+struct IRunningObjectTableVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRunningObjectTable* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRunningObjectTable* This);
+
+    ULONG (CALLBACK *Release)(
+        IRunningObjectTable* This);
+
+    /*** IRunningObjectTable methods ***/
+    HRESULT (CALLBACK *Register)(
+        IRunningObjectTable* This,
+        DWORD grfFlags,
+        IUnknown* punkObject,
+        IMoniker* pmkObjectName,
+        DWORD* pdwRegister);
+
+    HRESULT (CALLBACK *Revoke)(
+        IRunningObjectTable* This,
+        DWORD dwRegister);
+
+    HRESULT (CALLBACK *IsRunning)(
+        IRunningObjectTable* This,
+        IMoniker* pmkObjectName);
+
+    HRESULT (CALLBACK *GetObject)(
+        IRunningObjectTable* This,
+        IMoniker* pmkObjectName,
+        IUnknown** ppunkObject);
+
+    HRESULT (CALLBACK *NoteChangeTime)(
+        IRunningObjectTable* This,
+        DWORD dwRegister,
+        FILETIME* pfiletime);
+
+    HRESULT (CALLBACK *GetTimeOfLastChange)(
+        IRunningObjectTable* This,
+        IMoniker* pmkObjectName,
+        FILETIME* pfiletime);
+
+    HRESULT (CALLBACK *EnumRunning)(
+        IRunningObjectTable* This,
+        IEnumMoniker** ppenumMoniker);
+
+};
+
+#define IRunningObjectTable_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD4 (HRESULT,Register,DWORD,grfFlags,IUnknown*,punkObject,IMoniker*,pmkObjectName,DWORD*,pdwRegister) \
+    ICOM_METHOD1 (HRESULT,Revoke,DWORD,dwRegister) \
+    ICOM_METHOD1 (HRESULT,IsRunning,IMoniker*,pmkObjectName) \
+    ICOM_METHOD2 (HRESULT,GetObject,IMoniker*,pmkObjectName,IUnknown**,ppunkObject) \
+    ICOM_METHOD2 (HRESULT,NoteChangeTime,DWORD,dwRegister,FILETIME*,pfiletime) \
+    ICOM_METHOD2 (HRESULT,GetTimeOfLastChange,IMoniker*,pmkObjectName,FILETIME*,pfiletime) \
+    ICOM_METHOD1 (HRESULT,EnumRunning,IEnumMoniker**,ppenumMoniker)
+
+/*** IUnknown methods ***/
+#define IRunningObjectTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRunningObjectTable_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRunningObjectTable_Release(p) (p)->lpVtbl->Release(p)
+/*** IRunningObjectTable methods ***/
+#define IRunningObjectTable_Register(p,a,b,c,d) (p)->lpVtbl->Register(p,a,b,c,d)
+#define IRunningObjectTable_Revoke(p,a) (p)->lpVtbl->Revoke(p,a)
+#define IRunningObjectTable_IsRunning(p,a) (p)->lpVtbl->IsRunning(p,a)
+#define IRunningObjectTable_GetObject(p,a,b) (p)->lpVtbl->GetObject(p,a,b)
+#define IRunningObjectTable_NoteChangeTime(p,a,b) (p)->lpVtbl->NoteChangeTime(p,a,b)
+#define IRunningObjectTable_GetTimeOfLastChange(p,a,b) (p)->lpVtbl->GetTimeOfLastChange(p,a,b)
+#define IRunningObjectTable_EnumRunning(p,a) (p)->lpVtbl->EnumRunning(p,a)
+
+#endif
+
+HRESULT CALLBACK IRunningObjectTable_Register_Proxy(
+    IRunningObjectTable* This,
+    DWORD grfFlags,
+    IUnknown* punkObject,
+    IMoniker* pmkObjectName,
+    DWORD* pdwRegister);
+void __RPC_STUB IRunningObjectTable_Register_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_Revoke_Proxy(
+    IRunningObjectTable* This,
+    DWORD dwRegister);
+void __RPC_STUB IRunningObjectTable_Revoke_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_IsRunning_Proxy(
+    IRunningObjectTable* This,
+    IMoniker* pmkObjectName);
+void __RPC_STUB IRunningObjectTable_IsRunning_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_GetObject_Proxy(
+    IRunningObjectTable* This,
+    IMoniker* pmkObjectName,
+    IUnknown** ppunkObject);
+void __RPC_STUB IRunningObjectTable_GetObject_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_NoteChangeTime_Proxy(
+    IRunningObjectTable* This,
+    DWORD dwRegister,
+    FILETIME* pfiletime);
+void __RPC_STUB IRunningObjectTable_NoteChangeTime_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_GetTimeOfLastChange_Proxy(
+    IRunningObjectTable* This,
+    IMoniker* pmkObjectName,
+    FILETIME* pfiletime);
+void __RPC_STUB IRunningObjectTable_GetTimeOfLastChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRunningObjectTable_EnumRunning_Proxy(
+    IRunningObjectTable* This,
+    IEnumMoniker** ppenumMoniker);
+void __RPC_STUB IRunningObjectTable_EnumRunning_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPersist IPersist;
+typedef IPersist *LPPERSIST;
+
+/*****************************************************************************
+ * IPersist interface
+ */
+DEFINE_GUID(IID_IPersist, 0x0000010c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPersist: IUnknown {
+
+    virtual HRESULT CALLBACK GetClassID(
+        CLSID* pClassID) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPersistVtbl IPersistVtbl;
+struct IPersist {
+    const IPersistVtbl* lpVtbl;
+};
+struct IPersistVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPersist* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPersist* This);
+
+    ULONG (CALLBACK *Release)(
+        IPersist* This);
+
+    /*** IPersist methods ***/
+    HRESULT (CALLBACK *GetClassID)(
+        IPersist* This,
+        CLSID* pClassID);
+
+};
+
+#define IPersist_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,GetClassID,CLSID*,pClassID)
+
+/*** IUnknown methods ***/
+#define IPersist_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPersist_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPersist_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IPersist_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+
+#endif
+
+HRESULT CALLBACK IPersist_GetClassID_Proxy(
+    IPersist* This,
+    CLSID* pClassID);
+void __RPC_STUB IPersist_GetClassID_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPersistStream IPersistStream;
+typedef IPersistStream *LPPERSISTSTREAM;
+
+/*****************************************************************************
+ * IPersistStream interface
+ */
+DEFINE_GUID(IID_IPersistStream, 0x00000109, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPersistStream: IPersist {
+
+    virtual HRESULT CALLBACK IsDirty(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Load(
+        IStream* pStm) = 0;
+
+    virtual HRESULT CALLBACK Save(
+        IStream* pStm,
+        BOOL fClearDirty) = 0;
+
+    virtual HRESULT CALLBACK GetSizeMax(
+        ULARGE_INTEGER* pcbSize) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPersistStreamVtbl IPersistStreamVtbl;
+struct IPersistStream {
+    const IPersistStreamVtbl* lpVtbl;
+};
+struct IPersistStreamVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPersistStream* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPersistStream* This);
+
+    ULONG (CALLBACK *Release)(
+        IPersistStream* This);
+
+    /*** IPersist methods ***/
+    HRESULT (CALLBACK *GetClassID)(
+        IPersistStream* This,
+        CLSID* pClassID);
+
+    /*** IPersistStream methods ***/
+    HRESULT (CALLBACK *IsDirty)(
+        IPersistStream* This);
+
+    HRESULT (CALLBACK *Load)(
+        IPersistStream* This,
+        IStream* pStm);
+
+    HRESULT (CALLBACK *Save)(
+        IPersistStream* This,
+        IStream* pStm,
+        BOOL fClearDirty);
+
+    HRESULT (CALLBACK *GetSizeMax)(
+        IPersistStream* This,
+        ULARGE_INTEGER* pcbSize);
+
+};
+
+#define IPersistStream_IMETHODS \
+    IPersist_IMETHODS \
+    ICOM_METHOD  (HRESULT,IsDirty) \
+    ICOM_METHOD1 (HRESULT,Load,IStream*,pStm) \
+    ICOM_METHOD2 (HRESULT,Save,IStream*,pStm,BOOL,fClearDirty) \
+    ICOM_METHOD1 (HRESULT,GetSizeMax,ULARGE_INTEGER*,pcbSize)
+
+/*** IUnknown methods ***/
+#define IPersistStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPersistStream_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPersistStream_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IPersistStream_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IPersistStream methods ***/
+#define IPersistStream_IsDirty(p) (p)->lpVtbl->IsDirty(p)
+#define IPersistStream_Load(p,a) (p)->lpVtbl->Load(p,a)
+#define IPersistStream_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
+#define IPersistStream_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a)
+
+#endif
+
+HRESULT CALLBACK IPersistStream_IsDirty_Proxy(
+    IPersistStream* This);
+void __RPC_STUB IPersistStream_IsDirty_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStream_Load_Proxy(
+    IPersistStream* This,
+    IStream* pStm);
+void __RPC_STUB IPersistStream_Load_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStream_Save_Proxy(
+    IPersistStream* This,
+    IStream* pStm,
+    BOOL fClearDirty);
+void __RPC_STUB IPersistStream_Save_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStream_GetSizeMax_Proxy(
+    IPersistStream* This,
+    ULARGE_INTEGER* pcbSize);
+void __RPC_STUB IPersistStream_GetSizeMax_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IMoniker *LPMONIKER;
+
+typedef enum tagMKSYS {
+    MKSYS_NONE = 0,
+    MKSYS_GENERICCOMPOSITE = 1,
+    MKSYS_FILEMONIKER = 2,
+    MKSYS_ANTIMONIKER = 3,
+    MKSYS_ITEMMONIKER = 4,
+    MKSYS_POINTERMONIKER = 5,
+    MKSYS_CLASSMONIKER = 7
+} MKSYS;
+
+typedef enum tagMKREDUCE {
+    MKRREDUCE_ONE = 3 << 16,
+    MKRREDUCE_TOUSER = 2 << 16,
+    MKRREDUCE_THROUGHUSER = 1 << 16,
+    MKRREDUCE_ALL = 0
+} MKRREDUCE;
+
+/*****************************************************************************
+ * IMoniker interface
+ */
+DEFINE_GUID(IID_IMoniker, 0x0000000f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMoniker: IPersistStream {
+
+    virtual HRESULT CALLBACK BindToObject(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        REFIID riidResult,
+        void** ppvResult) = 0;
+
+    virtual HRESULT CALLBACK BindToStorage(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        REFIID riid,
+        void** ppvObj) = 0;
+
+    virtual HRESULT CALLBACK Reduce(
+        IBindCtx* pbc,
+        DWORD dwReduceHowFar,
+        IMoniker** ppmkToLeft,
+        IMoniker** ppmkReduced) = 0;
+
+    virtual HRESULT CALLBACK ComposeWith(
+        IMoniker* pmkRight,
+        BOOL fOnlyIfNotGeneric,
+        IMoniker** ppmkComposite) = 0;
+
+    virtual HRESULT CALLBACK Enum(
+        BOOL fForward,
+        IEnumMoniker** ppenumMoniker) = 0;
+
+    virtual HRESULT CALLBACK IsEqual(
+        IMoniker* pmkOtherMoniker) = 0;
+
+    virtual HRESULT CALLBACK Hash(
+        DWORD* pdwHash) = 0;
+
+    virtual HRESULT CALLBACK IsRunning(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        IMoniker* pmkNewlyRunning) = 0;
+
+    virtual HRESULT CALLBACK GetTimeOfLastChange(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        FILETIME* pFileTime) = 0;
+
+    virtual HRESULT CALLBACK Inverse(
+        IMoniker** ppmk) = 0;
+
+    virtual HRESULT CALLBACK CommonPrefixWith(
+        IMoniker* pmkOther,
+        IMoniker** ppmkPrefix) = 0;
+
+    virtual HRESULT CALLBACK RelativePathTo(
+        IMoniker* pmkOther,
+        IMoniker** ppmkRelPath) = 0;
+
+    virtual HRESULT CALLBACK GetDisplayName(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        LPOLESTR* ppszDisplayName) = 0;
+
+    virtual HRESULT CALLBACK ParseDisplayName(
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        LPOLESTR pszDisplayName,
+        ULONG* pchEaten,
+        IMoniker** ppmkOut) = 0;
+
+    virtual HRESULT CALLBACK IsSystemMoniker(
+        DWORD* pdwMksys) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMonikerVtbl IMonikerVtbl;
+struct IMoniker {
+    const IMonikerVtbl* lpVtbl;
+};
+struct IMonikerVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMoniker* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMoniker* This);
+
+    ULONG (CALLBACK *Release)(
+        IMoniker* This);
+
+    /*** IPersist methods ***/
+    HRESULT (CALLBACK *GetClassID)(
+        IMoniker* This,
+        CLSID* pClassID);
+
+    /*** IPersistStream methods ***/
+    HRESULT (CALLBACK *IsDirty)(
+        IMoniker* This);
+
+    HRESULT (CALLBACK *Load)(
+        IMoniker* This,
+        IStream* pStm);
+
+    HRESULT (CALLBACK *Save)(
+        IMoniker* This,
+        IStream* pStm,
+        BOOL fClearDirty);
+
+    HRESULT (CALLBACK *GetSizeMax)(
+        IMoniker* This,
+        ULARGE_INTEGER* pcbSize);
+
+    /*** IMoniker methods ***/
+    HRESULT (CALLBACK *BindToObject)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        REFIID riidResult,
+        void** ppvResult);
+
+    HRESULT (CALLBACK *BindToStorage)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        REFIID riid,
+        void** ppvObj);
+
+    HRESULT (CALLBACK *Reduce)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        DWORD dwReduceHowFar,
+        IMoniker** ppmkToLeft,
+        IMoniker** ppmkReduced);
+
+    HRESULT (CALLBACK *ComposeWith)(
+        IMoniker* This,
+        IMoniker* pmkRight,
+        BOOL fOnlyIfNotGeneric,
+        IMoniker** ppmkComposite);
+
+    HRESULT (CALLBACK *Enum)(
+        IMoniker* This,
+        BOOL fForward,
+        IEnumMoniker** ppenumMoniker);
+
+    HRESULT (CALLBACK *IsEqual)(
+        IMoniker* This,
+        IMoniker* pmkOtherMoniker);
+
+    HRESULT (CALLBACK *Hash)(
+        IMoniker* This,
+        DWORD* pdwHash);
+
+    HRESULT (CALLBACK *IsRunning)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        IMoniker* pmkNewlyRunning);
+
+    HRESULT (CALLBACK *GetTimeOfLastChange)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        FILETIME* pFileTime);
+
+    HRESULT (CALLBACK *Inverse)(
+        IMoniker* This,
+        IMoniker** ppmk);
+
+    HRESULT (CALLBACK *CommonPrefixWith)(
+        IMoniker* This,
+        IMoniker* pmkOther,
+        IMoniker** ppmkPrefix);
+
+    HRESULT (CALLBACK *RelativePathTo)(
+        IMoniker* This,
+        IMoniker* pmkOther,
+        IMoniker** ppmkRelPath);
+
+    HRESULT (CALLBACK *GetDisplayName)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        LPOLESTR* ppszDisplayName);
+
+    HRESULT (CALLBACK *ParseDisplayName)(
+        IMoniker* This,
+        IBindCtx* pbc,
+        IMoniker* pmkToLeft,
+        LPOLESTR pszDisplayName,
+        ULONG* pchEaten,
+        IMoniker** ppmkOut);
+
+    HRESULT (CALLBACK *IsSystemMoniker)(
+        IMoniker* This,
+        DWORD* pdwMksys);
+
+};
+
+#define IMoniker_IMETHODS \
+    IPersistStream_IMETHODS \
+    ICOM_METHOD4 (HRESULT,BindToObject,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riidResult,void**,ppvResult) \
+    ICOM_METHOD4 (HRESULT,BindToStorage,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riid,void**,ppvObj) \
+    ICOM_METHOD4 (HRESULT,Reduce,IBindCtx*,pbc,DWORD,dwReduceHowFar,IMoniker**,ppmkToLeft,IMoniker**,ppmkReduced) \
+    ICOM_METHOD3 (HRESULT,ComposeWith,IMoniker*,pmkRight,BOOL,fOnlyIfNotGeneric,IMoniker**,ppmkComposite) \
+    ICOM_METHOD2 (HRESULT,Enum,BOOL,fForward,IEnumMoniker**,ppenumMoniker) \
+    ICOM_METHOD1 (HRESULT,IsEqual,IMoniker*,pmkOtherMoniker) \
+    ICOM_METHOD1 (HRESULT,Hash,DWORD*,pdwHash) \
+    ICOM_METHOD3 (HRESULT,IsRunning,IBindCtx*,pbc,IMoniker*,pmkToLeft,IMoniker*,pmkNewlyRunning) \
+    ICOM_METHOD3 (HRESULT,GetTimeOfLastChange,IBindCtx*,pbc,IMoniker*,pmkToLeft,FILETIME*,pFileTime) \
+    ICOM_METHOD1 (HRESULT,Inverse,IMoniker**,ppmk) \
+    ICOM_METHOD2 (HRESULT,CommonPrefixWith,IMoniker*,pmkOther,IMoniker**,ppmkPrefix) \
+    ICOM_METHOD2 (HRESULT,RelativePathTo,IMoniker*,pmkOther,IMoniker**,ppmkRelPath) \
+    ICOM_METHOD3 (HRESULT,GetDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR*,ppszDisplayName) \
+    ICOM_METHOD5 (HRESULT,ParseDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR,pszDisplayName,ULONG*,pchEaten,IMoniker**,ppmkOut) \
+    ICOM_METHOD1 (HRESULT,IsSystemMoniker,DWORD*,pdwMksys)
+
+/*** IUnknown methods ***/
+#define IMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMoniker_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMoniker_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IMoniker_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IPersistStream methods ***/
+#define IMoniker_IsDirty(p) (p)->lpVtbl->IsDirty(p)
+#define IMoniker_Load(p,a) (p)->lpVtbl->Load(p,a)
+#define IMoniker_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
+#define IMoniker_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a)
+/*** IMoniker methods ***/
+#define IMoniker_BindToObject(p,a,b,c,d) (p)->lpVtbl->BindToObject(p,a,b,c,d)
+#define IMoniker_BindToStorage(p,a,b,c,d) (p)->lpVtbl->BindToStorage(p,a,b,c,d)
+#define IMoniker_Reduce(p,a,b,c,d) (p)->lpVtbl->Reduce(p,a,b,c,d)
+#define IMoniker_ComposeWith(p,a,b,c) (p)->lpVtbl->ComposeWith(p,a,b,c)
+#define IMoniker_Enum(p,a,b) (p)->lpVtbl->Enum(p,a,b)
+#define IMoniker_IsEqual(p,a) (p)->lpVtbl->IsEqual(p,a)
+#define IMoniker_Hash(p,a) (p)->lpVtbl->Hash(p,a)
+#define IMoniker_IsRunning(p,a,b,c) (p)->lpVtbl->IsRunning(p,a,b,c)
+#define IMoniker_GetTimeOfLastChange(p,a,b,c) (p)->lpVtbl->GetTimeOfLastChange(p,a,b,c)
+#define IMoniker_Inverse(p,a) (p)->lpVtbl->Inverse(p,a)
+#define IMoniker_CommonPrefixWith(p,a,b) (p)->lpVtbl->CommonPrefixWith(p,a,b)
+#define IMoniker_RelativePathTo(p,a,b) (p)->lpVtbl->RelativePathTo(p,a,b)
+#define IMoniker_GetDisplayName(p,a,b,c) (p)->lpVtbl->GetDisplayName(p,a,b,c)
+#define IMoniker_ParseDisplayName(p,a,b,c,d,e) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d,e)
+#define IMoniker_IsSystemMoniker(p,a) (p)->lpVtbl->IsSystemMoniker(p,a)
+
+#endif
+
+HRESULT CALLBACK IMoniker_RemoteBindToObject_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riidResult,
+    IUnknown** ppvResult);
+void __RPC_STUB IMoniker_RemoteBindToObject_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_BindToObject_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riidResult,
+    void** ppvResult);
+HRESULT __RPC_STUB IMoniker_BindToObject_Stub(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riidResult,
+    IUnknown** ppvResult);
+HRESULT CALLBACK IMoniker_RemoteBindToStorage_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riid,
+    IUnknown** ppvObj);
+void __RPC_STUB IMoniker_RemoteBindToStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_BindToStorage_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riid,
+    void** ppvObj);
+HRESULT __RPC_STUB IMoniker_BindToStorage_Stub(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    REFIID riid,
+    IUnknown** ppvObj);
+HRESULT CALLBACK IMoniker_Reduce_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    DWORD dwReduceHowFar,
+    IMoniker** ppmkToLeft,
+    IMoniker** ppmkReduced);
+void __RPC_STUB IMoniker_Reduce_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_ComposeWith_Proxy(
+    IMoniker* This,
+    IMoniker* pmkRight,
+    BOOL fOnlyIfNotGeneric,
+    IMoniker** ppmkComposite);
+void __RPC_STUB IMoniker_ComposeWith_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_Enum_Proxy(
+    IMoniker* This,
+    BOOL fForward,
+    IEnumMoniker** ppenumMoniker);
+void __RPC_STUB IMoniker_Enum_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_IsEqual_Proxy(
+    IMoniker* This,
+    IMoniker* pmkOtherMoniker);
+void __RPC_STUB IMoniker_IsEqual_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_Hash_Proxy(
+    IMoniker* This,
+    DWORD* pdwHash);
+void __RPC_STUB IMoniker_Hash_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_IsRunning_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    IMoniker* pmkNewlyRunning);
+void __RPC_STUB IMoniker_IsRunning_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_GetTimeOfLastChange_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    FILETIME* pFileTime);
+void __RPC_STUB IMoniker_GetTimeOfLastChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_Inverse_Proxy(
+    IMoniker* This,
+    IMoniker** ppmk);
+void __RPC_STUB IMoniker_Inverse_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_CommonPrefixWith_Proxy(
+    IMoniker* This,
+    IMoniker* pmkOther,
+    IMoniker** ppmkPrefix);
+void __RPC_STUB IMoniker_CommonPrefixWith_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_RelativePathTo_Proxy(
+    IMoniker* This,
+    IMoniker* pmkOther,
+    IMoniker** ppmkRelPath);
+void __RPC_STUB IMoniker_RelativePathTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_GetDisplayName_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    LPOLESTR* ppszDisplayName);
+void __RPC_STUB IMoniker_GetDisplayName_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_ParseDisplayName_Proxy(
+    IMoniker* This,
+    IBindCtx* pbc,
+    IMoniker* pmkToLeft,
+    LPOLESTR pszDisplayName,
+    ULONG* pchEaten,
+    IMoniker** ppmkOut);
+void __RPC_STUB IMoniker_ParseDisplayName_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IMoniker_IsSystemMoniker_Proxy(
+    IMoniker* This,
+    DWORD* pdwMksys);
+void __RPC_STUB IMoniker_IsSystemMoniker_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IROTData IROTData;
+/*****************************************************************************
+ * IROTData interface
+ */
+DEFINE_GUID(IID_IROTData, 0xf29f6bc0, 0x5021, 0x11ce, 0xaa,0x15, 0x00,0x00,0x69,0x01,0x29,0x3f);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IROTData: IUnknown {
+
+    virtual HRESULT CALLBACK GetComparisonData(
+        byte* pbData,
+        ULONG cbMax,
+        ULONG* pcbData) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IROTDataVtbl IROTDataVtbl;
+struct IROTData {
+    const IROTDataVtbl* lpVtbl;
+};
+struct IROTDataVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IROTData* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IROTData* This);
+
+    ULONG (CALLBACK *Release)(
+        IROTData* This);
+
+    /*** IROTData methods ***/
+    HRESULT (CALLBACK *GetComparisonData)(
+        IROTData* This,
+        byte* pbData,
+        ULONG cbMax,
+        ULONG* pcbData);
+
+};
+
+#define IROTData_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,GetComparisonData,byte*,pbData,ULONG,cbMax,ULONG*,pcbData)
+
+/*** IUnknown methods ***/
+#define IROTData_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IROTData_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IROTData_Release(p) (p)->lpVtbl->Release(p)
+/*** IROTData methods ***/
+#define IROTData_GetComparisonData(p,a,b,c) (p)->lpVtbl->GetComparisonData(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK IROTData_GetComparisonData_Proxy(
+    IROTData* This,
+    byte* pbData,
+    ULONG cbMax,
+    ULONG* pcbData);
+void __RPC_STUB IROTData_GetComparisonData_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IEnumString *LPENUMSTRING;
+
+/*****************************************************************************
+ * IEnumString interface
+ */
+DEFINE_GUID(IID_IEnumString, 0x00000101, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumString: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        LPOLESTR* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumString** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumStringVtbl IEnumStringVtbl;
+struct IEnumString {
+    const IEnumStringVtbl* lpVtbl;
+};
+struct IEnumStringVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumString* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumString* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumString* This);
+
+    /*** IEnumString methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumString* This,
+        ULONG celt,
+        LPOLESTR* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumString* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumString* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumString* This,
+        IEnumString** ppenum);
+
+};
+
+#define IEnumString_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,LPOLESTR*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumString**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumString_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumString_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumString_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumString methods ***/
+#define IEnumString_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumString_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumString_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumString_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumString_RemoteNext_Proxy(
+    IEnumString* This,
+    ULONG celt,
+    LPOLESTR* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumString_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumString_Next_Proxy(
+    IEnumString* This,
+    ULONG celt,
+    LPOLESTR* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumString_Next_Stub(
+    IEnumString* This,
+    ULONG celt,
+    LPOLESTR* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumString_Skip_Proxy(
+    IEnumString* This,
+    ULONG celt);
+void __RPC_STUB IEnumString_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumString_Reset_Proxy(
+    IEnumString* This);
+void __RPC_STUB IEnumString_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumString_Clone_Proxy(
+    IEnumString* This,
+    IEnumString** ppenum);
+void __RPC_STUB IEnumString_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IClassActivator IClassActivator;
+/*****************************************************************************
+ * IClassActivator interface
+ */
+DEFINE_GUID(IID_IClassActivator, 0x00000140, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IClassActivator: IUnknown {
+
+    virtual HRESULT CALLBACK GetClassObject(
+        REFCLSID rclsid,
+        DWORD dwClassContext,
+        LCID locale,
+        REFIID riid,
+        void** ppv) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IClassActivatorVtbl IClassActivatorVtbl;
+struct IClassActivator {
+    const IClassActivatorVtbl* lpVtbl;
+};
+struct IClassActivatorVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IClassActivator* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IClassActivator* This);
+
+    ULONG (CALLBACK *Release)(
+        IClassActivator* This);
+
+    /*** IClassActivator methods ***/
+    HRESULT (CALLBACK *GetClassObject)(
+        IClassActivator* This,
+        REFCLSID rclsid,
+        DWORD dwClassContext,
+        LCID locale,
+        REFIID riid,
+        void** ppv);
+
+};
+
+#define IClassActivator_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,GetClassObject,REFCLSID,rclsid,DWORD,dwClassContext,LCID,locale,REFIID,riid,void**,ppv)
+
+/*** IUnknown methods ***/
+#define IClassActivator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IClassActivator_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IClassActivator_Release(p) (p)->lpVtbl->Release(p)
+/*** IClassActivator methods ***/
+#define IClassActivator_GetClassObject(p,a,b,c,d,e) (p)->lpVtbl->GetClassObject(p,a,b,c,d,e)
+
+#endif
+
+HRESULT CALLBACK IClassActivator_GetClassObject_Proxy(
+    IClassActivator* This,
+    REFCLSID rclsid,
+    DWORD dwClassContext,
+    LCID locale,
+    REFIID riid,
+    void** ppv);
+void __RPC_STUB IClassActivator_GetClassObject_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct ISequentialStream ISequentialStream;
+/*****************************************************************************
+ * ISequentialStream interface
+ */
+DEFINE_GUID(IID_ISequentialStream, 0x0c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ISequentialStream: IUnknown {
+
+    virtual HRESULT CALLBACK Read(
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead) = 0;
+
+    virtual HRESULT CALLBACK Write(
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct ISequentialStreamVtbl ISequentialStreamVtbl;
+struct ISequentialStream {
+    const ISequentialStreamVtbl* lpVtbl;
+};
+struct ISequentialStreamVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        ISequentialStream* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        ISequentialStream* This);
+
+    ULONG (CALLBACK *Release)(
+        ISequentialStream* This);
+
+    /*** ISequentialStream methods ***/
+    HRESULT (CALLBACK *Read)(
+        ISequentialStream* This,
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead);
+
+    HRESULT (CALLBACK *Write)(
+        ISequentialStream* This,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+};
+
+#define ISequentialStream_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Read,void*,pv,ULONG,cb,ULONG*,pcbRead) \
+    ICOM_METHOD3 (HRESULT,Write,const void*,pv,ULONG,cb,ULONG*,pcbWritten)
+
+/*** IUnknown methods ***/
+#define ISequentialStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ISequentialStream_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ISequentialStream_Release(p) (p)->lpVtbl->Release(p)
+/*** ISequentialStream methods ***/
+#define ISequentialStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
+#define ISequentialStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK ISequentialStream_RemoteRead_Proxy(
+    ISequentialStream* This,
+    byte* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+void __RPC_STUB ISequentialStream_RemoteRead_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ISequentialStream_Read_Proxy(
+    ISequentialStream* This,
+    void* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+HRESULT __RPC_STUB ISequentialStream_Read_Stub(
+    ISequentialStream* This,
+    byte* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+HRESULT CALLBACK ISequentialStream_RemoteWrite_Proxy(
+    ISequentialStream* This,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+void __RPC_STUB ISequentialStream_RemoteWrite_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ISequentialStream_Write_Proxy(
+    ISequentialStream* This,
+    const void* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT __RPC_STUB ISequentialStream_Write_Stub(
+    ISequentialStream* This,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+
+typedef IStream *LPSTREAM;
+
+typedef struct tagSTATSTG {
+    LPOLESTR pwcsName;
+    DWORD type;
+    ULARGE_INTEGER cbSize;
+    FILETIME mtime;
+    FILETIME ctime;
+    FILETIME atime;
+    DWORD grfMode;
+    DWORD grfLocksSupported;
+    CLSID clsid;
+    DWORD grfStateBits;
+    DWORD reserved;
+} STATSTG;
+
+typedef enum tagSTGTY {
+    STGTY_STORAGE = 1,
+    STGTY_STREAM = 2,
+    STGTY_LOCKBYTES = 3,
+    STGTY_PROPERTY = 4
+} STGTY;
+
+typedef enum tagSTREAM_SEEK {
+    STREAM_SEEK_SET = 0,
+    STREAM_SEEK_CUR = 1,
+    STREAM_SEEK_END = 2
+} STREAM_SEEK;
+
+#undef LOCK_MAND
+#undef LOCK_READ
+#undef LOCK_WRITE
+#undef LOCK_RW
+typedef enum tagLOCKTYPE {
+    LOCK_WRITE = 1,
+    LOCK_EXCLUSIVE = 2,
+    LOCK_ONLYONCE = 4
+} LOCKTYPE;
+
+/*****************************************************************************
+ * IStream interface
+ */
+DEFINE_GUID(IID_IStream, 0x0000000c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStream: ISequentialStream {
+
+    virtual HRESULT CALLBACK Seek(
+        LARGE_INTEGER dlibMove,
+        DWORD dwOrigin,
+        ULARGE_INTEGER* plibNewPosition) = 0;
+
+    virtual HRESULT CALLBACK SetSize(
+        ULARGE_INTEGER libNewSize) = 0;
+
+    virtual HRESULT CALLBACK CopyTo(
+        IStream* pstm,
+        ULARGE_INTEGER cb,
+        ULARGE_INTEGER* pcbRead,
+        ULARGE_INTEGER* pcbWritten) = 0;
+
+    virtual HRESULT CALLBACK Commit(
+        DWORD grfCommitFlags) = 0;
+
+    virtual HRESULT CALLBACK Revert(
+        ) = 0;
+
+    virtual HRESULT CALLBACK LockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK UnlockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATSTG* pstatstg,
+        DWORD grfStatFlag) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IStream** ppstm) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IStreamVtbl IStreamVtbl;
+struct IStream {
+    const IStreamVtbl* lpVtbl;
+};
+struct IStreamVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IStream* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IStream* This);
+
+    ULONG (CALLBACK *Release)(
+        IStream* This);
+
+    /*** ISequentialStream methods ***/
+    HRESULT (CALLBACK *Read)(
+        IStream* This,
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead);
+
+    HRESULT (CALLBACK *Write)(
+        IStream* This,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+    /*** IStream methods ***/
+    HRESULT (CALLBACK *Seek)(
+        IStream* This,
+        LARGE_INTEGER dlibMove,
+        DWORD dwOrigin,
+        ULARGE_INTEGER* plibNewPosition);
+
+    HRESULT (CALLBACK *SetSize)(
+        IStream* This,
+        ULARGE_INTEGER libNewSize);
+
+    HRESULT (CALLBACK *CopyTo)(
+        IStream* This,
+        IStream* pstm,
+        ULARGE_INTEGER cb,
+        ULARGE_INTEGER* pcbRead,
+        ULARGE_INTEGER* pcbWritten);
+
+    HRESULT (CALLBACK *Commit)(
+        IStream* This,
+        DWORD grfCommitFlags);
+
+    HRESULT (CALLBACK *Revert)(
+        IStream* This);
+
+    HRESULT (CALLBACK *LockRegion)(
+        IStream* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *UnlockRegion)(
+        IStream* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *Stat)(
+        IStream* This,
+        STATSTG* pstatstg,
+        DWORD grfStatFlag);
+
+    HRESULT (CALLBACK *Clone)(
+        IStream* This,
+        IStream** ppstm);
+
+};
+
+#define IStream_IMETHODS \
+    ISequentialStream_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \
+    ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \
+    ICOM_METHOD4 (HRESULT,CopyTo,IStream*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \
+    ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
+    ICOM_METHOD  (HRESULT,Revert) \
+    ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \
+    ICOM_METHOD1 (HRESULT,Clone,IStream**,ppstm)
+
+/*** IUnknown methods ***/
+#define IStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStream_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStream_Release(p) (p)->lpVtbl->Release(p)
+/*** ISequentialStream methods ***/
+#define IStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
+#define IStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
+/*** IStream methods ***/
+#define IStream_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
+#define IStream_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
+#define IStream_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
+#define IStream_Commit(p,a) (p)->lpVtbl->Commit(p,a)
+#define IStream_Revert(p) (p)->lpVtbl->Revert(p)
+#define IStream_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
+#define IStream_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
+#define IStream_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
+#define IStream_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IStream_RemoteSeek_Proxy(
+    IStream* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+void __RPC_STUB IStream_RemoteSeek_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_Seek_Proxy(
+    IStream* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+HRESULT __RPC_STUB IStream_Seek_Stub(
+    IStream* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+HRESULT CALLBACK IStream_SetSize_Proxy(
+    IStream* This,
+    ULARGE_INTEGER libNewSize);
+void __RPC_STUB IStream_SetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_RemoteCopyTo_Proxy(
+    IStream* This,
+    IStream* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+void __RPC_STUB IStream_RemoteCopyTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_CopyTo_Proxy(
+    IStream* This,
+    IStream* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+HRESULT __RPC_STUB IStream_CopyTo_Stub(
+    IStream* This,
+    IStream* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+HRESULT CALLBACK IStream_Commit_Proxy(
+    IStream* This,
+    DWORD grfCommitFlags);
+void __RPC_STUB IStream_Commit_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_Revert_Proxy(
+    IStream* This);
+void __RPC_STUB IStream_Revert_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_LockRegion_Proxy(
+    IStream* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB IStream_LockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_UnlockRegion_Proxy(
+    IStream* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB IStream_UnlockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_Stat_Proxy(
+    IStream* This,
+    STATSTG* pstatstg,
+    DWORD grfStatFlag);
+void __RPC_STUB IStream_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream_Clone_Proxy(
+    IStream* This,
+    IStream** ppstm);
+void __RPC_STUB IStream_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IStream16 *LPSTREAM16;
+
+typedef struct tagSTATSTG16 {
+    LPOLESTR16 pwcsName;
+    DWORD type;
+    ULARGE_INTEGER cbSize;
+    FILETIME mtime;
+    FILETIME ctime;
+    FILETIME atime;
+    DWORD grfMode;
+    DWORD grfLocksSupported;
+    CLSID clsid;
+    DWORD grfStateBits;
+    DWORD reserved;
+} STATSTG16;
+
+/*****************************************************************************
+ * IStream16 interface
+ */
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStream16: ISequentialStream {
+
+    virtual HRESULT CALLBACK Seek(
+        LARGE_INTEGER dlibMove,
+        DWORD dwOrigin,
+        ULARGE_INTEGER* plibNewPosition) = 0;
+
+    virtual HRESULT CALLBACK SetSize(
+        ULARGE_INTEGER libNewSize) = 0;
+
+    virtual HRESULT CALLBACK CopyTo(
+        IStream16* pstm,
+        ULARGE_INTEGER cb,
+        ULARGE_INTEGER* pcbRead,
+        ULARGE_INTEGER* pcbWritten) = 0;
+
+    virtual HRESULT CALLBACK Commit(
+        DWORD grfCommitFlags) = 0;
+
+    virtual HRESULT CALLBACK Revert(
+        ) = 0;
+
+    virtual HRESULT CALLBACK LockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK UnlockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATSTG* pstatstg,
+        DWORD grfStatFlag) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IStream16** ppstm) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IStream16Vtbl IStream16Vtbl;
+struct IStream16 {
+    const IStream16Vtbl* lpVtbl;
+};
+struct IStream16Vtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IStream16* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IStream16* This);
+
+    ULONG (CALLBACK *Release)(
+        IStream16* This);
+
+    /*** ISequentialStream methods ***/
+    HRESULT (CALLBACK *Read)(
+        IStream16* This,
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead);
+
+    HRESULT (CALLBACK *Write)(
+        IStream16* This,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+    /*** IStream16 methods ***/
+    HRESULT (CALLBACK *Seek)(
+        IStream16* This,
+        LARGE_INTEGER dlibMove,
+        DWORD dwOrigin,
+        ULARGE_INTEGER* plibNewPosition);
+
+    HRESULT (CALLBACK *SetSize)(
+        IStream16* This,
+        ULARGE_INTEGER libNewSize);
+
+    HRESULT (CALLBACK *CopyTo)(
+        IStream16* This,
+        IStream16* pstm,
+        ULARGE_INTEGER cb,
+        ULARGE_INTEGER* pcbRead,
+        ULARGE_INTEGER* pcbWritten);
+
+    HRESULT (CALLBACK *Commit)(
+        IStream16* This,
+        DWORD grfCommitFlags);
+
+    HRESULT (CALLBACK *Revert)(
+        IStream16* This);
+
+    HRESULT (CALLBACK *LockRegion)(
+        IStream16* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *UnlockRegion)(
+        IStream16* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *Stat)(
+        IStream16* This,
+        STATSTG* pstatstg,
+        DWORD grfStatFlag);
+
+    HRESULT (CALLBACK *Clone)(
+        IStream16* This,
+        IStream16** ppstm);
+
+};
+
+#define IStream16_IMETHODS \
+    ISequentialStream_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \
+    ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \
+    ICOM_METHOD4 (HRESULT,CopyTo,IStream16*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \
+    ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
+    ICOM_METHOD  (HRESULT,Revert) \
+    ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \
+    ICOM_METHOD1 (HRESULT,Clone,IStream16**,ppstm)
+
+/*** IUnknown methods ***/
+#define IStream16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStream16_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStream16_Release(p) (p)->lpVtbl->Release(p)
+/*** ISequentialStream methods ***/
+#define IStream16_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
+#define IStream16_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
+/*** IStream16 methods ***/
+#define IStream16_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
+#define IStream16_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
+#define IStream16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
+#define IStream16_Commit(p,a) (p)->lpVtbl->Commit(p,a)
+#define IStream16_Revert(p) (p)->lpVtbl->Revert(p)
+#define IStream16_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
+#define IStream16_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
+#define IStream16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
+#define IStream16_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IStream16_RemoteSeek_Proxy(
+    IStream16* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+void __RPC_STUB IStream16_RemoteSeek_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_Seek_Proxy(
+    IStream16* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+HRESULT __RPC_STUB IStream16_Seek_Stub(
+    IStream16* This,
+    LARGE_INTEGER dlibMove,
+    DWORD dwOrigin,
+    ULARGE_INTEGER* plibNewPosition);
+HRESULT CALLBACK IStream16_SetSize_Proxy(
+    IStream16* This,
+    ULARGE_INTEGER libNewSize);
+void __RPC_STUB IStream16_SetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_RemoteCopyTo_Proxy(
+    IStream16* This,
+    IStream16* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+void __RPC_STUB IStream16_RemoteCopyTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_CopyTo_Proxy(
+    IStream16* This,
+    IStream16* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+HRESULT __RPC_STUB IStream16_CopyTo_Stub(
+    IStream16* This,
+    IStream16* pstm,
+    ULARGE_INTEGER cb,
+    ULARGE_INTEGER* pcbRead,
+    ULARGE_INTEGER* pcbWritten);
+HRESULT CALLBACK IStream16_Commit_Proxy(
+    IStream16* This,
+    DWORD grfCommitFlags);
+void __RPC_STUB IStream16_Commit_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_Revert_Proxy(
+    IStream16* This);
+void __RPC_STUB IStream16_Revert_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_LockRegion_Proxy(
+    IStream16* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB IStream16_LockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_UnlockRegion_Proxy(
+    IStream16* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB IStream16_UnlockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_Stat_Proxy(
+    IStream16* This,
+    STATSTG* pstatstg,
+    DWORD grfStatFlag);
+void __RPC_STUB IStream16_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStream16_Clone_Proxy(
+    IStream16* This,
+    IStream16** ppstm);
+void __RPC_STUB IStream16_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumSTATSTG IEnumSTATSTG;
+typedef IEnumSTATSTG *LPENUMSTATSTG;
+
+/*****************************************************************************
+ * IEnumSTATSTG interface
+ */
+DEFINE_GUID(IID_IEnumSTATSTG, 0x0000000d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumSTATSTG: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        STATSTG* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumSTATSTG** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumSTATSTGVtbl IEnumSTATSTGVtbl;
+struct IEnumSTATSTG {
+    const IEnumSTATSTGVtbl* lpVtbl;
+};
+struct IEnumSTATSTGVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumSTATSTG* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumSTATSTG* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumSTATSTG* This);
+
+    /*** IEnumSTATSTG methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumSTATSTG* This,
+        ULONG celt,
+        STATSTG* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumSTATSTG* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumSTATSTG* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumSTATSTG* This,
+        IEnumSTATSTG** ppenum);
+
+};
+
+#define IEnumSTATSTG_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATSTG*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumSTATSTG**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumSTATSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumSTATSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumSTATSTG_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumSTATSTG methods ***/
+#define IEnumSTATSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumSTATSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumSTATSTG_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumSTATSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumSTATSTG_RemoteNext_Proxy(
+    IEnumSTATSTG* This,
+    ULONG celt,
+    STATSTG* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumSTATSTG_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATSTG_Next_Proxy(
+    IEnumSTATSTG* This,
+    ULONG celt,
+    STATSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub(
+    IEnumSTATSTG* This,
+    ULONG celt,
+    STATSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumSTATSTG_Skip_Proxy(
+    IEnumSTATSTG* This,
+    ULONG celt);
+void __RPC_STUB IEnumSTATSTG_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATSTG_Reset_Proxy(
+    IEnumSTATSTG* This);
+void __RPC_STUB IEnumSTATSTG_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATSTG_Clone_Proxy(
+    IEnumSTATSTG* This,
+    IEnumSTATSTG** ppenum);
+void __RPC_STUB IEnumSTATSTG_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IStorage IStorage;
+typedef IStorage *LPSTORAGE;
+
+typedef struct tagRemSNB {
+    unsigned long ulCntStr;
+    unsigned long ulCntChar;
+    OLECHAR rgString[1];
+} RemSNB;
+
+typedef RemSNB *wireSNB;
+
+typedef OLECHAR **SNB;
+
+/*****************************************************************************
+ * IStorage interface
+ */
+DEFINE_GUID(IID_IStorage, 0x0000000b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStorage: IUnknown {
+
+    virtual HRESULT CALLBACK CreateStream(
+        LPCOLESTR pwcsName,
+        DWORD grfMode,
+        DWORD reserved1,
+        DWORD reserved2,
+        IStream** ppstm) = 0;
+
+    virtual HRESULT CALLBACK OpenStream(
+        LPCOLESTR pwcsName,
+        void* reserved1,
+        DWORD grfMode,
+        DWORD reserved2,
+        IStream** ppstm) = 0;
+
+    virtual HRESULT CALLBACK CreateStorage(
+        LPCOLESTR pwcsName,
+        DWORD grfMode,
+        DWORD dwStgFmt,
+        DWORD reserved2,
+        IStorage** ppstg) = 0;
+
+    virtual HRESULT CALLBACK OpenStorage(
+        LPCOLESTR pwcsName,
+        IStorage* pstgPriority,
+        DWORD grfMode,
+        SNB snbExclude,
+        DWORD reserved,
+        IStorage** ppstg) = 0;
+
+    virtual HRESULT CALLBACK CopyTo(
+        DWORD ciidExclude,
+        const IID* rgiidExclude,
+        SNB snbExclude,
+        IStorage* pstgDest) = 0;
+
+    virtual HRESULT CALLBACK MoveElementTo(
+        LPCOLESTR pwcsName,
+        IStorage* pstgDest,
+        LPCOLESTR pwcsNewName,
+        DWORD grfFlags) = 0;
+
+    virtual HRESULT CALLBACK Commit(
+        DWORD grfCommitFlags) = 0;
+
+    virtual HRESULT CALLBACK Revert(
+        ) = 0;
+
+    virtual HRESULT CALLBACK EnumElements(
+        DWORD reserved1,
+        void* reserved2,
+        DWORD reserved3,
+        IEnumSTATSTG** ppenum) = 0;
+
+    virtual HRESULT CALLBACK DestroyElement(
+        LPCOLESTR pwcsName) = 0;
+
+    virtual HRESULT CALLBACK RenameElement(
+        LPCOLESTR pwcsOldName,
+        LPCOLESTR pwcsNewName) = 0;
+
+    virtual HRESULT CALLBACK SetElementTimes(
+        LPCOLESTR pwcsName,
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime) = 0;
+
+    virtual HRESULT CALLBACK SetClass(
+        REFCLSID clsid) = 0;
+
+    virtual HRESULT CALLBACK SetStateBits(
+        DWORD grfStateBits,
+        DWORD grfMask) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATSTG* pstatstg,
+        DWORD grfStatFlag) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IStorageVtbl IStorageVtbl;
+struct IStorage {
+    const IStorageVtbl* lpVtbl;
+};
+struct IStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        IStorage* This);
+
+    /*** IStorage methods ***/
+    HRESULT (CALLBACK *CreateStream)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        DWORD grfMode,
+        DWORD reserved1,
+        DWORD reserved2,
+        IStream** ppstm);
+
+    HRESULT (CALLBACK *OpenStream)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        void* reserved1,
+        DWORD grfMode,
+        DWORD reserved2,
+        IStream** ppstm);
+
+    HRESULT (CALLBACK *CreateStorage)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        DWORD grfMode,
+        DWORD dwStgFmt,
+        DWORD reserved2,
+        IStorage** ppstg);
+
+    HRESULT (CALLBACK *OpenStorage)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        IStorage* pstgPriority,
+        DWORD grfMode,
+        SNB snbExclude,
+        DWORD reserved,
+        IStorage** ppstg);
+
+    HRESULT (CALLBACK *CopyTo)(
+        IStorage* This,
+        DWORD ciidExclude,
+        const IID* rgiidExclude,
+        SNB snbExclude,
+        IStorage* pstgDest);
+
+    HRESULT (CALLBACK *MoveElementTo)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        IStorage* pstgDest,
+        LPCOLESTR pwcsNewName,
+        DWORD grfFlags);
+
+    HRESULT (CALLBACK *Commit)(
+        IStorage* This,
+        DWORD grfCommitFlags);
+
+    HRESULT (CALLBACK *Revert)(
+        IStorage* This);
+
+    HRESULT (CALLBACK *EnumElements)(
+        IStorage* This,
+        DWORD reserved1,
+        void* reserved2,
+        DWORD reserved3,
+        IEnumSTATSTG** ppenum);
+
+    HRESULT (CALLBACK *DestroyElement)(
+        IStorage* This,
+        LPCOLESTR pwcsName);
+
+    HRESULT (CALLBACK *RenameElement)(
+        IStorage* This,
+        LPCOLESTR pwcsOldName,
+        LPCOLESTR pwcsNewName);
+
+    HRESULT (CALLBACK *SetElementTimes)(
+        IStorage* This,
+        LPCOLESTR pwcsName,
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime);
+
+    HRESULT (CALLBACK *SetClass)(
+        IStorage* This,
+        REFCLSID clsid);
+
+    HRESULT (CALLBACK *SetStateBits)(
+        IStorage* This,
+        DWORD grfStateBits,
+        DWORD grfMask);
+
+    HRESULT (CALLBACK *Stat)(
+        IStorage* This,
+        STATSTG* pstatstg,
+        DWORD grfStatFlag);
+
+};
+
+#define IStorage_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream**,ppstm) \
+    ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream**,ppstm) \
+    ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage**,ppstg) \
+    ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR,pwcsName,IStorage*,pstgPriority,DWORD,grfMode,SNB,snbExclude,DWORD,reserved,IStorage**,ppstg) \
+    ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB,snbExclude,IStorage*,pstgDest) \
+    ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR,pwcsName,IStorage*,pstgDest,LPCOLESTR,pwcsNewName,DWORD,grfFlags) \
+    ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
+    ICOM_METHOD  (HRESULT,Revert) \
+    ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \
+    ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR,pwcsName) \
+    ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR,pwcsOldName,LPCOLESTR,pwcsNewName) \
+    ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
+    ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
+    ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \
+    ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
+
+/*** IUnknown methods ***/
+#define IStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** IStorage methods ***/
+#define IStorage_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e)
+#define IStorage_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e)
+#define IStorage_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e)
+#define IStorage_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f)
+#define IStorage_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
+#define IStorage_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d)
+#define IStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a)
+#define IStorage_Revert(p) (p)->lpVtbl->Revert(p)
+#define IStorage_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d)
+#define IStorage_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a)
+#define IStorage_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b)
+#define IStorage_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d)
+#define IStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
+#define IStorage_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b)
+#define IStorage_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
+
+#endif
+
+HRESULT CALLBACK IStorage_CreateStream_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    DWORD grfMode,
+    DWORD reserved1,
+    DWORD reserved2,
+    IStream** ppstm);
+void __RPC_STUB IStorage_CreateStream_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_RemoteOpenStream_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    unsigned long cbReserved1,
+    byte* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream** ppstm);
+void __RPC_STUB IStorage_RemoteOpenStream_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_OpenStream_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    void* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream** ppstm);
+HRESULT __RPC_STUB IStorage_OpenStream_Stub(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    unsigned long cbReserved1,
+    byte* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream** ppstm);
+HRESULT CALLBACK IStorage_CreateStorage_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    DWORD grfMode,
+    DWORD dwStgFmt,
+    DWORD reserved2,
+    IStorage** ppstg);
+void __RPC_STUB IStorage_CreateStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_OpenStorage_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    IStorage* pstgPriority,
+    DWORD grfMode,
+    SNB snbExclude,
+    DWORD reserved,
+    IStorage** ppstg);
+void __RPC_STUB IStorage_OpenStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_CopyTo_Proxy(
+    IStorage* This,
+    DWORD ciidExclude,
+    const IID* rgiidExclude,
+    SNB snbExclude,
+    IStorage* pstgDest);
+void __RPC_STUB IStorage_CopyTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_MoveElementTo_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    IStorage* pstgDest,
+    LPCOLESTR pwcsNewName,
+    DWORD grfFlags);
+void __RPC_STUB IStorage_MoveElementTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_Commit_Proxy(
+    IStorage* This,
+    DWORD grfCommitFlags);
+void __RPC_STUB IStorage_Commit_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_Revert_Proxy(
+    IStorage* This);
+void __RPC_STUB IStorage_Revert_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_RemoteEnumElements_Proxy(
+    IStorage* This,
+    DWORD reserved1,
+    unsigned long cbReserved2,
+    byte* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+void __RPC_STUB IStorage_RemoteEnumElements_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_EnumElements_Proxy(
+    IStorage* This,
+    DWORD reserved1,
+    void* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+HRESULT __RPC_STUB IStorage_EnumElements_Stub(
+    IStorage* This,
+    DWORD reserved1,
+    unsigned long cbReserved2,
+    byte* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+HRESULT CALLBACK IStorage_DestroyElement_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName);
+void __RPC_STUB IStorage_DestroyElement_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_RenameElement_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsOldName,
+    LPCOLESTR pwcsNewName);
+void __RPC_STUB IStorage_RenameElement_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_SetElementTimes_Proxy(
+    IStorage* This,
+    LPCOLESTR pwcsName,
+    const FILETIME* pctime,
+    const FILETIME* patime,
+    const FILETIME* pmtime);
+void __RPC_STUB IStorage_SetElementTimes_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_SetClass_Proxy(
+    IStorage* This,
+    REFCLSID clsid);
+void __RPC_STUB IStorage_SetClass_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_SetStateBits_Proxy(
+    IStorage* This,
+    DWORD grfStateBits,
+    DWORD grfMask);
+void __RPC_STUB IStorage_SetStateBits_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage_Stat_Proxy(
+    IStorage* This,
+    STATSTG* pstatstg,
+    DWORD grfStatFlag);
+void __RPC_STUB IStorage_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IStorage16 IStorage16;
+typedef IStorage16 *LPSTORAGE16;
+
+typedef struct tagRemSNB16 {
+    unsigned long ulCntStr;
+    unsigned long ulCntChar;
+    OLECHAR16 rgString[1];
+} RemSNB16;
+
+typedef RemSNB16 *wireSNB16;
+
+typedef OLECHAR16 **SNB16;
+
+/*****************************************************************************
+ * IStorage16 interface
+ */
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStorage16: IUnknown {
+
+    virtual HRESULT CALLBACK CreateStream(
+        LPCOLESTR16 pwcsName,
+        DWORD grfMode,
+        DWORD reserved1,
+        DWORD reserved2,
+        IStream16** ppstm) = 0;
+
+    virtual HRESULT CALLBACK OpenStream(
+        LPCOLESTR16 pwcsName,
+        void* reserved1,
+        DWORD grfMode,
+        DWORD reserved2,
+        IStream16** ppstm) = 0;
+
+    virtual HRESULT CALLBACK CreateStorage(
+        LPCOLESTR16 pwcsName,
+        DWORD grfMode,
+        DWORD dwStgFmt,
+        DWORD reserved2,
+        IStorage16** ppstg) = 0;
+
+    virtual HRESULT CALLBACK OpenStorage(
+        LPCOLESTR16 pwcsName,
+        IStorage16* pstgPriority,
+        DWORD grfMode,
+        SNB16 snbExclude,
+        DWORD reserved,
+        IStorage16** ppstg) = 0;
+
+    virtual HRESULT CALLBACK CopyTo(
+        DWORD ciidExclude,
+        const IID* rgiidExclude,
+        SNB16 snbExclude,
+        IStorage16* pstgDest) = 0;
+
+    virtual HRESULT CALLBACK MoveElementTo(
+        LPCOLESTR16 pwcsName,
+        IStorage16* pstgDest,
+        LPCOLESTR16 pwcsNewName,
+        DWORD grfFlags) = 0;
+
+    virtual HRESULT CALLBACK Commit(
+        DWORD grfCommitFlags) = 0;
+
+    virtual HRESULT CALLBACK Revert(
+        ) = 0;
+
+    virtual HRESULT CALLBACK EnumElements(
+        DWORD reserved1,
+        void* reserved2,
+        DWORD reserved3,
+        IEnumSTATSTG** ppenum) = 0;
+
+    virtual HRESULT CALLBACK DestroyElement(
+        LPCOLESTR16 pwcsName) = 0;
+
+    virtual HRESULT CALLBACK RenameElement(
+        LPCOLESTR16 pwcsOldName,
+        LPCOLESTR16 pwcsNewName) = 0;
+
+    virtual HRESULT CALLBACK SetElementTimes(
+        LPCOLESTR16 pwcsName,
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime) = 0;
+
+    virtual HRESULT CALLBACK SetClass(
+        REFCLSID clsid) = 0;
+
+    virtual HRESULT CALLBACK SetStateBits(
+        DWORD grfStateBits,
+        DWORD grfMask) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATSTG* pstatstg,
+        DWORD grfStatFlag) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IStorage16Vtbl IStorage16Vtbl;
+struct IStorage16 {
+    const IStorage16Vtbl* lpVtbl;
+};
+struct IStorage16Vtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IStorage16* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IStorage16* This);
+
+    ULONG (CALLBACK *Release)(
+        IStorage16* This);
+
+    /*** IStorage16 methods ***/
+    HRESULT (CALLBACK *CreateStream)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        DWORD grfMode,
+        DWORD reserved1,
+        DWORD reserved2,
+        IStream16** ppstm);
+
+    HRESULT (CALLBACK *OpenStream)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        void* reserved1,
+        DWORD grfMode,
+        DWORD reserved2,
+        IStream16** ppstm);
+
+    HRESULT (CALLBACK *CreateStorage)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        DWORD grfMode,
+        DWORD dwStgFmt,
+        DWORD reserved2,
+        IStorage16** ppstg);
+
+    HRESULT (CALLBACK *OpenStorage)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        IStorage16* pstgPriority,
+        DWORD grfMode,
+        SNB16 snbExclude,
+        DWORD reserved,
+        IStorage16** ppstg);
+
+    HRESULT (CALLBACK *CopyTo)(
+        IStorage16* This,
+        DWORD ciidExclude,
+        const IID* rgiidExclude,
+        SNB16 snbExclude,
+        IStorage16* pstgDest);
+
+    HRESULT (CALLBACK *MoveElementTo)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        IStorage16* pstgDest,
+        LPCOLESTR16 pwcsNewName,
+        DWORD grfFlags);
+
+    HRESULT (CALLBACK *Commit)(
+        IStorage16* This,
+        DWORD grfCommitFlags);
+
+    HRESULT (CALLBACK *Revert)(
+        IStorage16* This);
+
+    HRESULT (CALLBACK *EnumElements)(
+        IStorage16* This,
+        DWORD reserved1,
+        void* reserved2,
+        DWORD reserved3,
+        IEnumSTATSTG** ppenum);
+
+    HRESULT (CALLBACK *DestroyElement)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName);
+
+    HRESULT (CALLBACK *RenameElement)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsOldName,
+        LPCOLESTR16 pwcsNewName);
+
+    HRESULT (CALLBACK *SetElementTimes)(
+        IStorage16* This,
+        LPCOLESTR16 pwcsName,
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime);
+
+    HRESULT (CALLBACK *SetClass)(
+        IStorage16* This,
+        REFCLSID clsid);
+
+    HRESULT (CALLBACK *SetStateBits)(
+        IStorage16* This,
+        DWORD grfStateBits,
+        DWORD grfMask);
+
+    HRESULT (CALLBACK *Stat)(
+        IStorage16* This,
+        STATSTG* pstatstg,
+        DWORD grfStatFlag);
+
+};
+
+#define IStorage16_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream16**,ppstm) \
+    ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR16,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream16**,ppstm) \
+    ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage16**,ppstg) \
+    ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR16,pwcsName,IStorage16*,pstgPriority,DWORD,grfMode,SNB16,snbExclude,DWORD,reserved,IStorage16**,ppstg) \
+    ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB16,snbExclude,IStorage16*,pstgDest) \
+    ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR16,pwcsName,IStorage16*,pstgDest,LPCOLESTR16,pwcsNewName,DWORD,grfFlags) \
+    ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
+    ICOM_METHOD  (HRESULT,Revert) \
+    ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \
+    ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR16,pwcsName) \
+    ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR16,pwcsOldName,LPCOLESTR16,pwcsNewName) \
+    ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR16,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
+    ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
+    ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \
+    ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
+
+/*** IUnknown methods ***/
+#define IStorage16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStorage16_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStorage16_Release(p) (p)->lpVtbl->Release(p)
+/*** IStorage16 methods ***/
+#define IStorage16_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e)
+#define IStorage16_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e)
+#define IStorage16_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e)
+#define IStorage16_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f)
+#define IStorage16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
+#define IStorage16_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d)
+#define IStorage16_Commit(p,a) (p)->lpVtbl->Commit(p,a)
+#define IStorage16_Revert(p) (p)->lpVtbl->Revert(p)
+#define IStorage16_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d)
+#define IStorage16_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a)
+#define IStorage16_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b)
+#define IStorage16_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d)
+#define IStorage16_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
+#define IStorage16_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b)
+#define IStorage16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
+
+#endif
+
+HRESULT CALLBACK IStorage16_CreateStream_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    DWORD grfMode,
+    DWORD reserved1,
+    DWORD reserved2,
+    IStream16** ppstm);
+void __RPC_STUB IStorage16_CreateStream_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_RemoteOpenStream_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    unsigned long cbReserved1,
+    byte* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream16** ppstm);
+void __RPC_STUB IStorage16_RemoteOpenStream_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_OpenStream_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    void* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream16** ppstm);
+HRESULT __RPC_STUB IStorage16_OpenStream_Stub(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    unsigned long cbReserved1,
+    byte* reserved1,
+    DWORD grfMode,
+    DWORD reserved2,
+    IStream16** ppstm);
+HRESULT CALLBACK IStorage16_CreateStorage_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    DWORD grfMode,
+    DWORD dwStgFmt,
+    DWORD reserved2,
+    IStorage16** ppstg);
+void __RPC_STUB IStorage16_CreateStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_OpenStorage_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    IStorage16* pstgPriority,
+    DWORD grfMode,
+    SNB16 snbExclude,
+    DWORD reserved,
+    IStorage16** ppstg);
+void __RPC_STUB IStorage16_OpenStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_CopyTo_Proxy(
+    IStorage16* This,
+    DWORD ciidExclude,
+    const IID* rgiidExclude,
+    SNB16 snbExclude,
+    IStorage16* pstgDest);
+void __RPC_STUB IStorage16_CopyTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_MoveElementTo_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    IStorage16* pstgDest,
+    LPCOLESTR16 pwcsNewName,
+    DWORD grfFlags);
+void __RPC_STUB IStorage16_MoveElementTo_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_Commit_Proxy(
+    IStorage16* This,
+    DWORD grfCommitFlags);
+void __RPC_STUB IStorage16_Commit_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_Revert_Proxy(
+    IStorage16* This);
+void __RPC_STUB IStorage16_Revert_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_RemoteEnumElements_Proxy(
+    IStorage16* This,
+    DWORD reserved1,
+    unsigned long cbReserved2,
+    byte* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+void __RPC_STUB IStorage16_RemoteEnumElements_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_EnumElements_Proxy(
+    IStorage16* This,
+    DWORD reserved1,
+    void* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+HRESULT __RPC_STUB IStorage16_EnumElements_Stub(
+    IStorage16* This,
+    DWORD reserved1,
+    unsigned long cbReserved2,
+    byte* reserved2,
+    DWORD reserved3,
+    IEnumSTATSTG** ppenum);
+HRESULT CALLBACK IStorage16_DestroyElement_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName);
+void __RPC_STUB IStorage16_DestroyElement_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_RenameElement_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsOldName,
+    LPCOLESTR16 pwcsNewName);
+void __RPC_STUB IStorage16_RenameElement_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_SetElementTimes_Proxy(
+    IStorage16* This,
+    LPCOLESTR16 pwcsName,
+    const FILETIME* pctime,
+    const FILETIME* patime,
+    const FILETIME* pmtime);
+void __RPC_STUB IStorage16_SetElementTimes_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_SetClass_Proxy(
+    IStorage16* This,
+    REFCLSID clsid);
+void __RPC_STUB IStorage16_SetClass_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_SetStateBits_Proxy(
+    IStorage16* This,
+    DWORD grfStateBits,
+    DWORD grfMask);
+void __RPC_STUB IStorage16_SetStateBits_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IStorage16_Stat_Proxy(
+    IStorage16* This,
+    STATSTG* pstatstg,
+    DWORD grfStatFlag);
+void __RPC_STUB IStorage16_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPersistFile IPersistFile;
+typedef IPersistFile *LPPERSISTFILE;
+
+/*****************************************************************************
+ * IPersistFile interface
+ */
+DEFINE_GUID(IID_IPersistFile, 0x0000010b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPersistFile: IPersist {
+
+    virtual HRESULT CALLBACK IsDirty(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Load(
+        LPCOLESTR pszFileName,
+        DWORD dwMode) = 0;
+
+    virtual HRESULT CALLBACK Save(
+        LPCOLESTR pszFileName,
+        BOOL fRemember) = 0;
+
+    virtual HRESULT CALLBACK SaveCompleted(
+        LPCOLESTR pszFileName) = 0;
+
+    virtual HRESULT CALLBACK GetCurFile(
+        LPOLESTR* ppszFileName) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPersistFileVtbl IPersistFileVtbl;
+struct IPersistFile {
+    const IPersistFileVtbl* lpVtbl;
+};
+struct IPersistFileVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPersistFile* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPersistFile* This);
+
+    ULONG (CALLBACK *Release)(
+        IPersistFile* This);
+
+    /*** IPersist methods ***/
+    HRESULT (CALLBACK *GetClassID)(
+        IPersistFile* This,
+        CLSID* pClassID);
+
+    /*** IPersistFile methods ***/
+    HRESULT (CALLBACK *IsDirty)(
+        IPersistFile* This);
+
+    HRESULT (CALLBACK *Load)(
+        IPersistFile* This,
+        LPCOLESTR pszFileName,
+        DWORD dwMode);
+
+    HRESULT (CALLBACK *Save)(
+        IPersistFile* This,
+        LPCOLESTR pszFileName,
+        BOOL fRemember);
+
+    HRESULT (CALLBACK *SaveCompleted)(
+        IPersistFile* This,
+        LPCOLESTR pszFileName);
+
+    HRESULT (CALLBACK *GetCurFile)(
+        IPersistFile* This,
+        LPOLESTR* ppszFileName);
+
+};
+
+#define IPersistFile_IMETHODS \
+    IPersist_IMETHODS \
+    ICOM_METHOD  (HRESULT,IsDirty) \
+    ICOM_METHOD2 (HRESULT,Load,LPCOLESTR,pszFileName,DWORD,dwMode) \
+    ICOM_METHOD2 (HRESULT,Save,LPCOLESTR,pszFileName,BOOL,fRemember) \
+    ICOM_METHOD1 (HRESULT,SaveCompleted,LPCOLESTR,pszFileName) \
+    ICOM_METHOD1 (HRESULT,GetCurFile,LPOLESTR*,ppszFileName)
+
+/*** IUnknown methods ***/
+#define IPersistFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPersistFile_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPersistFile_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IPersistFile_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IPersistFile methods ***/
+#define IPersistFile_IsDirty(p) (p)->lpVtbl->IsDirty(p)
+#define IPersistFile_Load(p,a,b) (p)->lpVtbl->Load(p,a,b)
+#define IPersistFile_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
+#define IPersistFile_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a)
+#define IPersistFile_GetCurFile(p,a) (p)->lpVtbl->GetCurFile(p,a)
+
+#endif
+
+HRESULT CALLBACK IPersistFile_IsDirty_Proxy(
+    IPersistFile* This);
+void __RPC_STUB IPersistFile_IsDirty_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistFile_Load_Proxy(
+    IPersistFile* This,
+    LPCOLESTR pszFileName,
+    DWORD dwMode);
+void __RPC_STUB IPersistFile_Load_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistFile_Save_Proxy(
+    IPersistFile* This,
+    LPCOLESTR pszFileName,
+    BOOL fRemember);
+void __RPC_STUB IPersistFile_Save_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistFile_SaveCompleted_Proxy(
+    IPersistFile* This,
+    LPCOLESTR pszFileName);
+void __RPC_STUB IPersistFile_SaveCompleted_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistFile_GetCurFile_Proxy(
+    IPersistFile* This,
+    LPOLESTR* ppszFileName);
+void __RPC_STUB IPersistFile_GetCurFile_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPersistStorage IPersistStorage;
+typedef IPersistStorage *LPPERSISTSTORAGE;
+
+/*****************************************************************************
+ * IPersistStorage interface
+ */
+DEFINE_GUID(IID_IPersistStorage, 0x0000010a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPersistStorage: IPersist {
+
+    virtual HRESULT CALLBACK IsDirty(
+        ) = 0;
+
+    virtual HRESULT CALLBACK InitNew(
+        IStorage* pStg) = 0;
+
+    virtual HRESULT CALLBACK Load(
+        IStorage* pStg) = 0;
+
+    virtual HRESULT CALLBACK Save(
+        IStorage* pStgSave,
+        BOOL fSameAsLoad) = 0;
+
+    virtual HRESULT CALLBACK SaveCompleted(
+        IStorage* pStgNew) = 0;
+
+    virtual HRESULT CALLBACK HandsOffStorage(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPersistStorageVtbl IPersistStorageVtbl;
+struct IPersistStorage {
+    const IPersistStorageVtbl* lpVtbl;
+};
+struct IPersistStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPersistStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPersistStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        IPersistStorage* This);
+
+    /*** IPersist methods ***/
+    HRESULT (CALLBACK *GetClassID)(
+        IPersistStorage* This,
+        CLSID* pClassID);
+
+    /*** IPersistStorage methods ***/
+    HRESULT (CALLBACK *IsDirty)(
+        IPersistStorage* This);
+
+    HRESULT (CALLBACK *InitNew)(
+        IPersistStorage* This,
+        IStorage* pStg);
+
+    HRESULT (CALLBACK *Load)(
+        IPersistStorage* This,
+        IStorage* pStg);
+
+    HRESULT (CALLBACK *Save)(
+        IPersistStorage* This,
+        IStorage* pStgSave,
+        BOOL fSameAsLoad);
+
+    HRESULT (CALLBACK *SaveCompleted)(
+        IPersistStorage* This,
+        IStorage* pStgNew);
+
+    HRESULT (CALLBACK *HandsOffStorage)(
+        IPersistStorage* This);
+
+};
+
+#define IPersistStorage_IMETHODS \
+    IPersist_IMETHODS \
+    ICOM_METHOD  (HRESULT,IsDirty) \
+    ICOM_METHOD1 (HRESULT,InitNew,IStorage*,pStg) \
+    ICOM_METHOD1 (HRESULT,Load,IStorage*,pStg) \
+    ICOM_METHOD2 (HRESULT,Save,IStorage*,pStgSave,BOOL,fSameAsLoad) \
+    ICOM_METHOD1 (HRESULT,SaveCompleted,IStorage*,pStgNew) \
+    ICOM_METHOD  (HRESULT,HandsOffStorage)
+
+/*** IUnknown methods ***/
+#define IPersistStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPersistStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPersistStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IPersistStorage_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IPersistStorage methods ***/
+#define IPersistStorage_IsDirty(p) (p)->lpVtbl->IsDirty(p)
+#define IPersistStorage_InitNew(p,a) (p)->lpVtbl->InitNew(p,a)
+#define IPersistStorage_Load(p,a) (p)->lpVtbl->Load(p,a)
+#define IPersistStorage_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
+#define IPersistStorage_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a)
+#define IPersistStorage_HandsOffStorage(p) (p)->lpVtbl->HandsOffStorage(p)
+
+#endif
+
+HRESULT CALLBACK IPersistStorage_IsDirty_Proxy(
+    IPersistStorage* This);
+void __RPC_STUB IPersistStorage_IsDirty_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStorage_InitNew_Proxy(
+    IPersistStorage* This,
+    IStorage* pStg);
+void __RPC_STUB IPersistStorage_InitNew_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStorage_Load_Proxy(
+    IPersistStorage* This,
+    IStorage* pStg);
+void __RPC_STUB IPersistStorage_Load_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStorage_Save_Proxy(
+    IPersistStorage* This,
+    IStorage* pStgSave,
+    BOOL fSameAsLoad);
+void __RPC_STUB IPersistStorage_Save_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStorage_SaveCompleted_Proxy(
+    IPersistStorage* This,
+    IStorage* pStgNew);
+void __RPC_STUB IPersistStorage_SaveCompleted_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPersistStorage_HandsOffStorage_Proxy(
+    IPersistStorage* This);
+void __RPC_STUB IPersistStorage_HandsOffStorage_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRootStorage IRootStorage;
+typedef IRootStorage *LPROOTSTORAGE;
+
+/*****************************************************************************
+ * IRootStorage interface
+ */
+DEFINE_GUID(IID_IRootStorage, 0x00000012, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRootStorage: IUnknown {
+
+    virtual HRESULT CALLBACK SwitchToFile(
+        LPOLESTR pszFile) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRootStorageVtbl IRootStorageVtbl;
+struct IRootStorage {
+    const IRootStorageVtbl* lpVtbl;
+};
+struct IRootStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRootStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRootStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        IRootStorage* This);
+
+    /*** IRootStorage methods ***/
+    HRESULT (CALLBACK *SwitchToFile)(
+        IRootStorage* This,
+        LPOLESTR pszFile);
+
+};
+
+#define IRootStorage_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,SwitchToFile,LPOLESTR,pszFile)
+
+/*** IUnknown methods ***/
+#define IRootStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRootStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRootStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** IRootStorage methods ***/
+#define IRootStorage_SwitchToFile(p,a) (p)->lpVtbl->SwitchToFile(p,a)
+
+#endif
+
+HRESULT CALLBACK IRootStorage_SwitchToFile_Proxy(
+    IRootStorage* This,
+    LPOLESTR pszFile);
+void __RPC_STUB IRootStorage_SwitchToFile_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct ILockBytes ILockBytes;
+typedef ILockBytes *LPLOCKBYTES;
+
+/*****************************************************************************
+ * ILockBytes interface
+ */
+DEFINE_GUID(IID_ILockBytes, 0x0000000a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ILockBytes: IUnknown {
+
+    virtual HRESULT CALLBACK ReadAt(
+        ULARGE_INTEGER ulOffset,
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead) = 0;
+
+    virtual HRESULT CALLBACK WriteAt(
+        ULARGE_INTEGER ulOffset,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten) = 0;
+
+    virtual HRESULT CALLBACK Flush(
+        ) = 0;
+
+    virtual HRESULT CALLBACK SetSize(
+        ULARGE_INTEGER cb) = 0;
+
+    virtual HRESULT CALLBACK LockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK UnlockRegion(
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATSTG* pstatstg,
+        DWORD grfStatFlag) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct ILockBytesVtbl ILockBytesVtbl;
+struct ILockBytes {
+    const ILockBytesVtbl* lpVtbl;
+};
+struct ILockBytesVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        ILockBytes* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        ILockBytes* This);
+
+    ULONG (CALLBACK *Release)(
+        ILockBytes* This);
+
+    /*** ILockBytes methods ***/
+    HRESULT (CALLBACK *ReadAt)(
+        ILockBytes* This,
+        ULARGE_INTEGER ulOffset,
+        void* pv,
+        ULONG cb,
+        ULONG* pcbRead);
+
+    HRESULT (CALLBACK *WriteAt)(
+        ILockBytes* This,
+        ULARGE_INTEGER ulOffset,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+    HRESULT (CALLBACK *Flush)(
+        ILockBytes* This);
+
+    HRESULT (CALLBACK *SetSize)(
+        ILockBytes* This,
+        ULARGE_INTEGER cb);
+
+    HRESULT (CALLBACK *LockRegion)(
+        ILockBytes* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *UnlockRegion)(
+        ILockBytes* This,
+        ULARGE_INTEGER libOffset,
+        ULARGE_INTEGER cb,
+        DWORD dwLockType);
+
+    HRESULT (CALLBACK *Stat)(
+        ILockBytes* This,
+        STATSTG* pstatstg,
+        DWORD grfStatFlag);
+
+};
+
+#define ILockBytes_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD4 (HRESULT,ReadAt,ULARGE_INTEGER,ulOffset,void*,pv,ULONG,cb,ULONG*,pcbRead) \
+    ICOM_METHOD4 (HRESULT,WriteAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
+    ICOM_METHOD  (HRESULT,Flush) \
+    ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,cb) \
+    ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
+    ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
+
+/*** IUnknown methods ***/
+#define ILockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ILockBytes_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ILockBytes_Release(p) (p)->lpVtbl->Release(p)
+/*** ILockBytes methods ***/
+#define ILockBytes_ReadAt(p,a,b,c,d) (p)->lpVtbl->ReadAt(p,a,b,c,d)
+#define ILockBytes_WriteAt(p,a,b,c,d) (p)->lpVtbl->WriteAt(p,a,b,c,d)
+#define ILockBytes_Flush(p) (p)->lpVtbl->Flush(p)
+#define ILockBytes_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
+#define ILockBytes_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
+#define ILockBytes_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
+#define ILockBytes_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
+
+#endif
+
+HRESULT CALLBACK ILockBytes_RemoteReadAt_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    byte* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+void __RPC_STUB ILockBytes_RemoteReadAt_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_ReadAt_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    void* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+HRESULT __RPC_STUB ILockBytes_ReadAt_Stub(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    byte* pv,
+    ULONG cb,
+    ULONG* pcbRead);
+HRESULT CALLBACK ILockBytes_RemoteWriteAt_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+void __RPC_STUB ILockBytes_RemoteWriteAt_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_WriteAt_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const void* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT __RPC_STUB ILockBytes_WriteAt_Stub(
+    ILockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT CALLBACK ILockBytes_Flush_Proxy(
+    ILockBytes* This);
+void __RPC_STUB ILockBytes_Flush_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_SetSize_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER cb);
+void __RPC_STUB ILockBytes_SetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_LockRegion_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB ILockBytes_LockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_UnlockRegion_Proxy(
+    ILockBytes* This,
+    ULARGE_INTEGER libOffset,
+    ULARGE_INTEGER cb,
+    DWORD dwLockType);
+void __RPC_STUB ILockBytes_UnlockRegion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILockBytes_Stat_Proxy(
+    ILockBytes* This,
+    STATSTG* pstatstg,
+    DWORD grfStatFlag);
+void __RPC_STUB ILockBytes_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IFillLockBytes IFillLockBytes;
+/*****************************************************************************
+ * IFillLockBytes interface
+ */
+DEFINE_GUID(IID_IFillLockBytes, 0x99caf010, 0x415e, 0x11cf, 0x88,0x14, 0x00,0xaa,0x00,0xb5,0x69,0xf5);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFillLockBytes: IUnknown {
+
+    virtual HRESULT CALLBACK FillAppend(
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten) = 0;
+
+    virtual HRESULT CALLBACK FillAt(
+        ULARGE_INTEGER ulOffset,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten) = 0;
+
+    virtual HRESULT CALLBACK SetFillSize(
+        ULARGE_INTEGER ulSize) = 0;
+
+    virtual HRESULT CALLBACK Terminate(
+        BOOL bCanceled) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IFillLockBytesVtbl IFillLockBytesVtbl;
+struct IFillLockBytes {
+    const IFillLockBytesVtbl* lpVtbl;
+};
+struct IFillLockBytesVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IFillLockBytes* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IFillLockBytes* This);
+
+    ULONG (CALLBACK *Release)(
+        IFillLockBytes* This);
+
+    /*** IFillLockBytes methods ***/
+    HRESULT (CALLBACK *FillAppend)(
+        IFillLockBytes* This,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+    HRESULT (CALLBACK *FillAt)(
+        IFillLockBytes* This,
+        ULARGE_INTEGER ulOffset,
+        const void* pv,
+        ULONG cb,
+        ULONG* pcbWritten);
+
+    HRESULT (CALLBACK *SetFillSize)(
+        IFillLockBytes* This,
+        ULARGE_INTEGER ulSize);
+
+    HRESULT (CALLBACK *Terminate)(
+        IFillLockBytes* This,
+        BOOL bCanceled);
+
+};
+
+#define IFillLockBytes_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,FillAppend,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
+    ICOM_METHOD4 (HRESULT,FillAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
+    ICOM_METHOD1 (HRESULT,SetFillSize,ULARGE_INTEGER,ulSize) \
+    ICOM_METHOD1 (HRESULT,Terminate,BOOL,bCanceled)
+
+/*** IUnknown methods ***/
+#define IFillLockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFillLockBytes_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFillLockBytes_Release(p) (p)->lpVtbl->Release(p)
+/*** IFillLockBytes methods ***/
+#define IFillLockBytes_FillAppend(p,a,b,c) (p)->lpVtbl->FillAppend(p,a,b,c)
+#define IFillLockBytes_FillAt(p,a,b,c,d) (p)->lpVtbl->FillAt(p,a,b,c,d)
+#define IFillLockBytes_SetFillSize(p,a) (p)->lpVtbl->SetFillSize(p,a)
+#define IFillLockBytes_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
+
+#endif
+
+HRESULT CALLBACK IFillLockBytes_RemoteFillAppend_Proxy(
+    IFillLockBytes* This,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+void __RPC_STUB IFillLockBytes_RemoteFillAppend_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy(
+    IFillLockBytes* This,
+    const void* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub(
+    IFillLockBytes* This,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT CALLBACK IFillLockBytes_RemoteFillAt_Proxy(
+    IFillLockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+void __RPC_STUB IFillLockBytes_RemoteFillAt_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IFillLockBytes_FillAt_Proxy(
+    IFillLockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const void* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub(
+    IFillLockBytes* This,
+    ULARGE_INTEGER ulOffset,
+    const byte* pv,
+    ULONG cb,
+    ULONG* pcbWritten);
+HRESULT CALLBACK IFillLockBytes_SetFillSize_Proxy(
+    IFillLockBytes* This,
+    ULARGE_INTEGER ulSize);
+void __RPC_STUB IFillLockBytes_SetFillSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IFillLockBytes_Terminate_Proxy(
+    IFillLockBytes* This,
+    BOOL bCanceled);
+void __RPC_STUB IFillLockBytes_Terminate_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IProgressNotify IProgressNotify;
+/*****************************************************************************
+ * IProgressNotify interface
+ */
+DEFINE_GUID(IID_IProgressNotify, 0xa9d758a0, 0x4617, 0x11cf, 0x95,0xfc, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IProgressNotify: IUnknown {
+
+    virtual HRESULT CALLBACK OnProgress(
+        DWORD dwProgressCurrent,
+        DWORD dwProgressMaximum,
+        BOOL fAccurate,
+        BOOL fOwner) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IProgressNotifyVtbl IProgressNotifyVtbl;
+struct IProgressNotify {
+    const IProgressNotifyVtbl* lpVtbl;
+};
+struct IProgressNotifyVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IProgressNotify* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IProgressNotify* This);
+
+    ULONG (CALLBACK *Release)(
+        IProgressNotify* This);
+
+    /*** IProgressNotify methods ***/
+    HRESULT (CALLBACK *OnProgress)(
+        IProgressNotify* This,
+        DWORD dwProgressCurrent,
+        DWORD dwProgressMaximum,
+        BOOL fAccurate,
+        BOOL fOwner);
+
+};
+
+#define IProgressNotify_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD4 (HRESULT,OnProgress,DWORD,dwProgressCurrent,DWORD,dwProgressMaximum,BOOL,fAccurate,BOOL,fOwner)
+
+/*** IUnknown methods ***/
+#define IProgressNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IProgressNotify_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IProgressNotify_Release(p) (p)->lpVtbl->Release(p)
+/*** IProgressNotify methods ***/
+#define IProgressNotify_OnProgress(p,a,b,c,d) (p)->lpVtbl->OnProgress(p,a,b,c,d)
+
+#endif
+
+HRESULT CALLBACK IProgressNotify_OnProgress_Proxy(
+    IProgressNotify* This,
+    DWORD dwProgressCurrent,
+    DWORD dwProgressMaximum,
+    BOOL fAccurate,
+    BOOL fOwner);
+void __RPC_STUB IProgressNotify_OnProgress_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct ILayoutStorage ILayoutStorage;
+typedef struct tagStorageLayout {
+    DWORD LayoutType;
+    OLECHAR *pwcsElementName;
+    LARGE_INTEGER cOffset;
+    LARGE_INTEGER cBytes;
+} StorageLayout;
+
+/*****************************************************************************
+ * ILayoutStorage interface
+ */
+DEFINE_GUID(IID_ILayoutStorage, 0x0e6d4d90, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ILayoutStorage: IUnknown {
+
+    virtual HRESULT CALLBACK LayoutScript(
+        StorageLayout* pStorageLayout,
+        DWORD nEntries,
+        DWORD glfInterleavedFlag) = 0;
+
+    virtual HRESULT CALLBACK BeginMonitor(
+        ) = 0;
+
+    virtual HRESULT CALLBACK EndMonitor(
+        ) = 0;
+
+    virtual HRESULT CALLBACK ReLayoutDocfile(
+        OLECHAR* pwcsNewDfName) = 0;
+
+    virtual HRESULT CALLBACK ReLayoutDocfileOnILockBytes(
+        ILockBytes* pILockBytes) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct ILayoutStorageVtbl ILayoutStorageVtbl;
+struct ILayoutStorage {
+    const ILayoutStorageVtbl* lpVtbl;
+};
+struct ILayoutStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        ILayoutStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        ILayoutStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        ILayoutStorage* This);
+
+    /*** ILayoutStorage methods ***/
+    HRESULT (CALLBACK *LayoutScript)(
+        ILayoutStorage* This,
+        StorageLayout* pStorageLayout,
+        DWORD nEntries,
+        DWORD glfInterleavedFlag);
+
+    HRESULT (CALLBACK *BeginMonitor)(
+        ILayoutStorage* This);
+
+    HRESULT (CALLBACK *EndMonitor)(
+        ILayoutStorage* This);
+
+    HRESULT (CALLBACK *ReLayoutDocfile)(
+        ILayoutStorage* This,
+        OLECHAR* pwcsNewDfName);
+
+    HRESULT (CALLBACK *ReLayoutDocfileOnILockBytes)(
+        ILayoutStorage* This,
+        ILockBytes* pILockBytes);
+
+};
+
+#define ILayoutStorage_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,LayoutScript,StorageLayout*,pStorageLayout,DWORD,nEntries,DWORD,glfInterleavedFlag) \
+    ICOM_METHOD  (HRESULT,BeginMonitor) \
+    ICOM_METHOD  (HRESULT,EndMonitor) \
+    ICOM_METHOD1 (HRESULT,ReLayoutDocfile,OLECHAR*,pwcsNewDfName) \
+    ICOM_METHOD1 (HRESULT,ReLayoutDocfileOnILockBytes,ILockBytes*,pILockBytes)
+
+/*** IUnknown methods ***/
+#define ILayoutStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ILayoutStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ILayoutStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** ILayoutStorage methods ***/
+#define ILayoutStorage_LayoutScript(p,a,b,c) (p)->lpVtbl->LayoutScript(p,a,b,c)
+#define ILayoutStorage_BeginMonitor(p) (p)->lpVtbl->BeginMonitor(p)
+#define ILayoutStorage_EndMonitor(p) (p)->lpVtbl->EndMonitor(p)
+#define ILayoutStorage_ReLayoutDocfile(p,a) (p)->lpVtbl->ReLayoutDocfile(p,a)
+#define ILayoutStorage_ReLayoutDocfileOnILockBytes(p,a) (p)->lpVtbl->ReLayoutDocfileOnILockBytes(p,a)
+
+#endif
+
+HRESULT CALLBACK ILayoutStorage_LayoutScript_Proxy(
+    ILayoutStorage* This,
+    StorageLayout* pStorageLayout,
+    DWORD nEntries,
+    DWORD glfInterleavedFlag);
+void __RPC_STUB ILayoutStorage_LayoutScript_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILayoutStorage_BeginMonitor_Proxy(
+    ILayoutStorage* This);
+void __RPC_STUB ILayoutStorage_BeginMonitor_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILayoutStorage_EndMonitor_Proxy(
+    ILayoutStorage* This);
+void __RPC_STUB ILayoutStorage_EndMonitor_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILayoutStorage_ReLayoutDocfile_Proxy(
+    ILayoutStorage* This,
+    OLECHAR* pwcsNewDfName);
+void __RPC_STUB ILayoutStorage_ReLayoutDocfile_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK ILayoutStorage_ReLayoutDocfileOnILockBytes_Proxy(
+    ILayoutStorage* This,
+    ILockBytes* pILockBytes);
+void __RPC_STUB ILayoutStorage_ReLayoutDocfileOnILockBytes_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumFORMATETC IEnumFORMATETC;
+typedef IEnumFORMATETC *LPENUMFORMATETC;
+
+typedef struct tagDVTARGETDEVICE {
+    DWORD tdSize;
+    WORD tdDriverNameOffset;
+    WORD tdDeviceNameOffset;
+    WORD tdPortNameOffset;
+    WORD tdExtDevmodeOffset;
+    BYTE tdData[1];
+} DVTARGETDEVICE;
+
+typedef CLIPFORMAT *LPCLIPFORMAT;
+
+typedef struct tagFORMATETC {
+    CLIPFORMAT cfFormat;
+    DVTARGETDEVICE *ptd;
+    DWORD dwAspect;
+    LONG lindex;
+    DWORD tymed;
+} FORMATETC, *LPFORMATETC;
+
+/*****************************************************************************
+ * IEnumFORMATETC interface
+ */
+DEFINE_GUID(IID_IEnumFORMATETC, 0x00000103, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumFORMATETC: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        FORMATETC* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumFORMATETC** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumFORMATETCVtbl IEnumFORMATETCVtbl;
+struct IEnumFORMATETC {
+    const IEnumFORMATETCVtbl* lpVtbl;
+};
+struct IEnumFORMATETCVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumFORMATETC* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumFORMATETC* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumFORMATETC* This);
+
+    /*** IEnumFORMATETC methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumFORMATETC* This,
+        ULONG celt,
+        FORMATETC* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumFORMATETC* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumFORMATETC* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumFORMATETC* This,
+        IEnumFORMATETC** ppenum);
+
+};
+
+#define IEnumFORMATETC_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,FORMATETC*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumFORMATETC**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumFORMATETC_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumFORMATETC_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumFORMATETC_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumFORMATETC methods ***/
+#define IEnumFORMATETC_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumFORMATETC_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumFORMATETC_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumFORMATETC_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumFORMATETC_RemoteNext_Proxy(
+    IEnumFORMATETC* This,
+    ULONG celt,
+    FORMATETC* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumFORMATETC_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFORMATETC_Next_Proxy(
+    IEnumFORMATETC* This,
+    ULONG celt,
+    FORMATETC* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub(
+    IEnumFORMATETC* This,
+    ULONG celt,
+    FORMATETC* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumFORMATETC_Skip_Proxy(
+    IEnumFORMATETC* This,
+    ULONG celt);
+void __RPC_STUB IEnumFORMATETC_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFORMATETC_Reset_Proxy(
+    IEnumFORMATETC* This);
+void __RPC_STUB IEnumFORMATETC_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFORMATETC_Clone_Proxy(
+    IEnumFORMATETC* This,
+    IEnumFORMATETC** ppenum);
+void __RPC_STUB IEnumFORMATETC_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumSTATDATA IEnumSTATDATA;
+typedef IEnumSTATDATA *LPENUMSTATDATA;
+
+typedef enum tagADVF {
+    ADVF_NODATA = 1,
+    ADVF_PRIMEFIRST = 2,
+    ADVF_ONLYONCE = 4,
+    ADVF_DATAONSTOP = 64,
+    ADVFCACHE_NOHANDLER = 8,
+    ADVFCACHE_FORCEBUILTIN = 16,
+    ADVFCACHE_ONSAVE = 32
+} ADVF;
+
+typedef struct tagSTATDATA {
+    FORMATETC formatetc;
+    DWORD advf;
+    IAdviseSink *pAdvSink;
+    DWORD dwConnection;
+} STATDATA, *LPSTATDATA;
+
+/*****************************************************************************
+ * IEnumSTATDATA interface
+ */
+DEFINE_GUID(IID_IEnumSTATDATA, 0x00000105, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumSTATDATA: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        STATDATA* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumSTATDATA** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumSTATDATAVtbl IEnumSTATDATAVtbl;
+struct IEnumSTATDATA {
+    const IEnumSTATDATAVtbl* lpVtbl;
+};
+struct IEnumSTATDATAVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumSTATDATA* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumSTATDATA* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumSTATDATA* This);
+
+    /*** IEnumSTATDATA methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumSTATDATA* This,
+        ULONG celt,
+        STATDATA* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumSTATDATA* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumSTATDATA* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumSTATDATA* This,
+        IEnumSTATDATA** ppenum);
+
+};
+
+#define IEnumSTATDATA_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATDATA*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumSTATDATA**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumSTATDATA_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumSTATDATA_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumSTATDATA_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumSTATDATA methods ***/
+#define IEnumSTATDATA_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumSTATDATA_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumSTATDATA_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumSTATDATA_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumSTATDATA_RemoteNext_Proxy(
+    IEnumSTATDATA* This,
+    ULONG celt,
+    STATDATA* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumSTATDATA_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATDATA_Next_Proxy(
+    IEnumSTATDATA* This,
+    ULONG celt,
+    STATDATA* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub(
+    IEnumSTATDATA* This,
+    ULONG celt,
+    STATDATA* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumSTATDATA_Skip_Proxy(
+    IEnumSTATDATA* This,
+    ULONG celt);
+void __RPC_STUB IEnumSTATDATA_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATDATA_Reset_Proxy(
+    IEnumSTATDATA* This);
+void __RPC_STUB IEnumSTATDATA_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATDATA_Clone_Proxy(
+    IEnumSTATDATA* This,
+    IEnumSTATDATA** ppenum);
+void __RPC_STUB IEnumSTATDATA_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IAdviseSink *LPADVISESINK;
+
+typedef enum tagTYMED {
+    TYMED_HGLOBAL = 1,
+    TYMED_FILE = 2,
+    TYMED_ISTREAM = 4,
+    TYMED_ISTORAGE = 8,
+    TYMED_GDI = 16,
+    TYMED_MFPICT = 32,
+    TYMED_ENHMF = 64,
+    TYMED_NULL = 0
+} TYMED;
+
+typedef struct tagRemSTGMEDIUM {
+    DWORD tymed;
+    DWORD dwHandleType;
+    unsigned long pData;
+    unsigned long pUnkForRelease;
+    unsigned long cbData;
+    byte data[1];
+} RemSTGMEDIUM;
+
+typedef struct tagSTGMEDIUM {
+    DWORD tymed;
+    union {
+        HBITMAP hBitmap;
+        HMETAFILEPICT hMetaFilePict;
+        HENHMETAFILE hEnhMetaFile;
+        HGLOBAL hGlobal;
+        LPOLESTR lpszFileName;
+        IStream *pstm;
+        IStorage *pstg;
+    } DUMMYUNIONNAME;
+    IUnknown *pUnkForRelease;
+} uSTGMEDIUM;
+
+typedef struct _GDI_OBJECT {
+    DWORD ObjectType;
+    union {
+        wireHBITMAP hBitmap;
+        wireHPALETTE hPalette;
+        wireHGLOBAL hGeneric;
+    } u;
+} GDI_OBJECT;
+
+typedef struct _userSTGMEDIUM {
+    struct _STGMEDIUM_UNION {
+        DWORD tymed;
+        union {
+            wireHMETAFILEPICT hMetaFilePict;
+            wireHENHMETAFILE hHEnhMetaFile;
+            GDI_OBJECT *hGdiHandle;
+            wireHGLOBAL hGlobal;
+            LPOLESTR lpszFileName;
+            BYTE_BLOB *pstm;
+            BYTE_BLOB *pstg;
+        } u;
+    } DUMMYSTRUCTNAME;
+    IUnknown *pUnkForRelease;
+} userSTGMEDIUM;
+
+typedef userSTGMEDIUM *wireSTGMEDIUM;
+
+typedef uSTGMEDIUM STGMEDIUM;
+
+typedef userSTGMEDIUM *wireASYNC_STGMEDIUM;
+
+typedef STGMEDIUM ASYNC_STGMEDIUM;
+
+typedef STGMEDIUM *LPSTGMEDIUM;
+
+typedef struct _userFLAG_STGMEDIUM {
+    long ContextFlags;
+    long fPassOwnership;
+    userSTGMEDIUM Stgmed;
+} userFLAG_STGMEDIUM;
+
+typedef userFLAG_STGMEDIUM *wireFLAG_STGMEDIUM;
+
+typedef struct _FLAG_STGMEDIUM {
+    long ContextFlags;
+    long fPassOwnership;
+    STGMEDIUM Stgmed;
+} FLAG_STGMEDIUM;
+
+/*****************************************************************************
+ * IAdviseSink interface
+ */
+DEFINE_GUID(IID_IAdviseSink, 0x0000010f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAdviseSink: IUnknown {
+
+    virtual void CALLBACK OnDataChange(
+        FORMATETC* pFormatetc,
+        STGMEDIUM* pStgmed) = 0;
+
+    virtual void CALLBACK OnViewChange(
+        DWORD dwAspect,
+        LONG lindex) = 0;
+
+    virtual void CALLBACK OnRename(
+        IMoniker* pmk) = 0;
+
+    virtual void CALLBACK OnSave(
+        ) = 0;
+
+    virtual void CALLBACK OnClose(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IAdviseSinkVtbl IAdviseSinkVtbl;
+struct IAdviseSink {
+    const IAdviseSinkVtbl* lpVtbl;
+};
+struct IAdviseSinkVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IAdviseSink* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IAdviseSink* This);
+
+    ULONG (CALLBACK *Release)(
+        IAdviseSink* This);
+
+    /*** IAdviseSink methods ***/
+    void (CALLBACK *OnDataChange)(
+        IAdviseSink* This,
+        FORMATETC* pFormatetc,
+        STGMEDIUM* pStgmed);
+
+    void (CALLBACK *OnViewChange)(
+        IAdviseSink* This,
+        DWORD dwAspect,
+        LONG lindex);
+
+    void (CALLBACK *OnRename)(
+        IAdviseSink* This,
+        IMoniker* pmk);
+
+    void (CALLBACK *OnSave)(
+        IAdviseSink* This);
+
+    void (CALLBACK *OnClose)(
+        IAdviseSink* This);
+
+};
+
+#define IAdviseSink_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_VMETHOD2(OnDataChange,FORMATETC*,pFormatetc,STGMEDIUM*,pStgmed) \
+    ICOM_VMETHOD2(OnViewChange,DWORD,dwAspect,LONG,lindex) \
+    ICOM_VMETHOD1(OnRename,IMoniker*,pmk) \
+    ICOM_VMETHOD (OnSave) \
+    ICOM_VMETHOD (OnClose)
+
+/*** IUnknown methods ***/
+#define IAdviseSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAdviseSink_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAdviseSink_Release(p) (p)->lpVtbl->Release(p)
+/*** IAdviseSink methods ***/
+#define IAdviseSink_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b)
+#define IAdviseSink_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b)
+#define IAdviseSink_OnRename(p,a) (p)->lpVtbl->OnRename(p,a)
+#define IAdviseSink_OnSave(p) (p)->lpVtbl->OnSave(p)
+#define IAdviseSink_OnClose(p) (p)->lpVtbl->OnClose(p)
+
+#endif
+
+HRESULT CALLBACK IAdviseSink_RemoteOnDataChange_Proxy(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    FORMATETC* pFormatetc,
+    ASYNC_STGMEDIUM* pStgmed);
+void __RPC_STUB IAdviseSink_RemoteOnDataChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink_OnDataChange_Proxy(
+    IAdviseSink* This,
+    FORMATETC* pFormatetc,
+    STGMEDIUM* pStgmed);
+HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    FORMATETC* pFormatetc,
+    ASYNC_STGMEDIUM* pStgmed);
+HRESULT CALLBACK IAdviseSink_RemoteOnViewChange_Proxy(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    DWORD dwAspect,
+    LONG lindex);
+void __RPC_STUB IAdviseSink_RemoteOnViewChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink_OnViewChange_Proxy(
+    IAdviseSink* This,
+    DWORD dwAspect,
+    LONG lindex);
+HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    DWORD dwAspect,
+    LONG lindex);
+HRESULT CALLBACK IAdviseSink_RemoteOnRename_Proxy(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    IMoniker* pmk);
+void __RPC_STUB IAdviseSink_RemoteOnRename_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink_OnRename_Proxy(
+    IAdviseSink* This,
+    IMoniker* pmk);
+HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM,
+    IMoniker* pmk);
+HRESULT CALLBACK IAdviseSink_RemoteOnSave_Proxy(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM);
+void __RPC_STUB IAdviseSink_RemoteOnSave_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink_OnSave_Proxy(
+    IAdviseSink* This);
+HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
+    IAdviseSink* This,
+    IAsyncManager** ppIAM);
+HRESULT CALLBACK IAdviseSink_RemoteOnClose_Proxy(
+    IAdviseSink* This);
+void __RPC_STUB IAdviseSink_RemoteOnClose_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink_OnClose_Proxy(
+    IAdviseSink* This);
+HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
+    IAdviseSink* This);
+
+typedef struct IAdviseSink2 IAdviseSink2;
+typedef IAdviseSink2 *LPADVISESINK2;
+
+/*****************************************************************************
+ * IAdviseSink2 interface
+ */
+DEFINE_GUID(IID_IAdviseSink2, 0x00000125, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAdviseSink2: IAdviseSink {
+
+    virtual void CALLBACK OnLinkSrcChange(
+        IMoniker* pmk) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IAdviseSink2Vtbl IAdviseSink2Vtbl;
+struct IAdviseSink2 {
+    const IAdviseSink2Vtbl* lpVtbl;
+};
+struct IAdviseSink2Vtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IAdviseSink2* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IAdviseSink2* This);
+
+    ULONG (CALLBACK *Release)(
+        IAdviseSink2* This);
+
+    /*** IAdviseSink methods ***/
+    void (CALLBACK *OnDataChange)(
+        IAdviseSink2* This,
+        FORMATETC* pFormatetc,
+        STGMEDIUM* pStgmed);
+
+    void (CALLBACK *OnViewChange)(
+        IAdviseSink2* This,
+        DWORD dwAspect,
+        LONG lindex);
+
+    void (CALLBACK *OnRename)(
+        IAdviseSink2* This,
+        IMoniker* pmk);
+
+    void (CALLBACK *OnSave)(
+        IAdviseSink2* This);
+
+    void (CALLBACK *OnClose)(
+        IAdviseSink2* This);
+
+    /*** IAdviseSink2 methods ***/
+    void (CALLBACK *OnLinkSrcChange)(
+        IAdviseSink2* This,
+        IMoniker* pmk);
+
+};
+
+#define IAdviseSink2_IMETHODS \
+    IAdviseSink_IMETHODS \
+    ICOM_VMETHOD1(OnLinkSrcChange,IMoniker*,pmk)
+
+/*** IUnknown methods ***/
+#define IAdviseSink2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAdviseSink2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAdviseSink2_Release(p) (p)->lpVtbl->Release(p)
+/*** IAdviseSink methods ***/
+#define IAdviseSink2_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b)
+#define IAdviseSink2_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b)
+#define IAdviseSink2_OnRename(p,a) (p)->lpVtbl->OnRename(p,a)
+#define IAdviseSink2_OnSave(p) (p)->lpVtbl->OnSave(p)
+#define IAdviseSink2_OnClose(p) (p)->lpVtbl->OnClose(p)
+/*** IAdviseSink2 methods ***/
+#define IAdviseSink2_OnLinkSrcChange(p,a) (p)->lpVtbl->OnLinkSrcChange(p,a)
+
+#endif
+
+HRESULT CALLBACK IAdviseSink2_RemoteOnLinkSrcChange_Proxy(
+    IAdviseSink2* This,
+    IAsyncManager** ppIAM,
+    IMoniker* pmk);
+void __RPC_STUB IAdviseSink2_RemoteOnLinkSrcChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
+    IAdviseSink2* This,
+    IMoniker* pmk);
+HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
+    IAdviseSink2* This,
+    IAsyncManager** ppIAM,
+    IMoniker* pmk);
+
+typedef struct IDataObject IDataObject;
+typedef IDataObject *LPDATAOBJECT;
+
+typedef enum tagDATADIR {
+    DATADIR_GET = 1,
+    DATADIR_SET = 2
+} DATADIR;
+
+/*****************************************************************************
+ * IDataObject interface
+ */
+DEFINE_GUID(IID_IDataObject, 0x0000010e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IDataObject: IUnknown {
+
+    virtual HRESULT CALLBACK GetData(
+        FORMATETC* pformatetcIn,
+        STGMEDIUM* pmedium) = 0;
+
+    virtual HRESULT CALLBACK GetDataHere(
+        FORMATETC* pformatetc,
+        STGMEDIUM* pmedium) = 0;
+
+    virtual HRESULT CALLBACK QueryGetData(
+        FORMATETC* pformatetc) = 0;
+
+    virtual HRESULT CALLBACK GetCanonicalFormatEtc(
+        FORMATETC* pformatectIn,
+        FORMATETC* pformatetcOut) = 0;
+
+    virtual HRESULT CALLBACK SetData(
+        FORMATETC* pformatetc,
+        STGMEDIUM* pmedium,
+        BOOL fRelease) = 0;
+
+    virtual HRESULT CALLBACK EnumFormatEtc(
+        DWORD dwDirection,
+        IEnumFORMATETC** ppenumFormatEtc) = 0;
+
+    virtual HRESULT CALLBACK DAdvise(
+        FORMATETC* pformatetc,
+        DWORD advf,
+        IAdviseSink* pAdvSink,
+        DWORD* pdwConnection) = 0;
+
+    virtual HRESULT CALLBACK DUnadvise(
+        DWORD dwConnection) = 0;
+
+    virtual HRESULT CALLBACK EnumDAdvise(
+        IEnumSTATDATA** ppenumAdvise) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IDataObjectVtbl IDataObjectVtbl;
+struct IDataObject {
+    const IDataObjectVtbl* lpVtbl;
+};
+struct IDataObjectVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IDataObject* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IDataObject* This);
+
+    ULONG (CALLBACK *Release)(
+        IDataObject* This);
+
+    /*** IDataObject methods ***/
+    HRESULT (CALLBACK *GetData)(
+        IDataObject* This,
+        FORMATETC* pformatetcIn,
+        STGMEDIUM* pmedium);
+
+    HRESULT (CALLBACK *GetDataHere)(
+        IDataObject* This,
+        FORMATETC* pformatetc,
+        STGMEDIUM* pmedium);
+
+    HRESULT (CALLBACK *QueryGetData)(
+        IDataObject* This,
+        FORMATETC* pformatetc);
+
+    HRESULT (CALLBACK *GetCanonicalFormatEtc)(
+        IDataObject* This,
+        FORMATETC* pformatectIn,
+        FORMATETC* pformatetcOut);
+
+    HRESULT (CALLBACK *SetData)(
+        IDataObject* This,
+        FORMATETC* pformatetc,
+        STGMEDIUM* pmedium,
+        BOOL fRelease);
+
+    HRESULT (CALLBACK *EnumFormatEtc)(
+        IDataObject* This,
+        DWORD dwDirection,
+        IEnumFORMATETC** ppenumFormatEtc);
+
+    HRESULT (CALLBACK *DAdvise)(
+        IDataObject* This,
+        FORMATETC* pformatetc,
+        DWORD advf,
+        IAdviseSink* pAdvSink,
+        DWORD* pdwConnection);
+
+    HRESULT (CALLBACK *DUnadvise)(
+        IDataObject* This,
+        DWORD dwConnection);
+
+    HRESULT (CALLBACK *EnumDAdvise)(
+        IDataObject* This,
+        IEnumSTATDATA** ppenumAdvise);
+
+};
+
+#define IDataObject_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD2 (HRESULT,GetData,FORMATETC*,pformatetcIn,STGMEDIUM*,pmedium) \
+    ICOM_METHOD2 (HRESULT,GetDataHere,FORMATETC*,pformatetc,STGMEDIUM*,pmedium) \
+    ICOM_METHOD1 (HRESULT,QueryGetData,FORMATETC*,pformatetc) \
+    ICOM_METHOD2 (HRESULT,GetCanonicalFormatEtc,FORMATETC*,pformatectIn,FORMATETC*,pformatetcOut) \
+    ICOM_METHOD3 (HRESULT,SetData,FORMATETC*,pformatetc,STGMEDIUM*,pmedium,BOOL,fRelease) \
+    ICOM_METHOD2 (HRESULT,EnumFormatEtc,DWORD,dwDirection,IEnumFORMATETC**,ppenumFormatEtc) \
+    ICOM_METHOD4 (HRESULT,DAdvise,FORMATETC*,pformatetc,DWORD,advf,IAdviseSink*,pAdvSink,DWORD*,pdwConnection) \
+    ICOM_METHOD1 (HRESULT,DUnadvise,DWORD,dwConnection) \
+    ICOM_METHOD1 (HRESULT,EnumDAdvise,IEnumSTATDATA**,ppenumAdvise)
+
+/*** IUnknown methods ***/
+#define IDataObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDataObject_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDataObject_Release(p) (p)->lpVtbl->Release(p)
+/*** IDataObject methods ***/
+#define IDataObject_GetData(p,a,b) (p)->lpVtbl->GetData(p,a,b)
+#define IDataObject_GetDataHere(p,a,b) (p)->lpVtbl->GetDataHere(p,a,b)
+#define IDataObject_QueryGetData(p,a) (p)->lpVtbl->QueryGetData(p,a)
+#define IDataObject_GetCanonicalFormatEtc(p,a,b) (p)->lpVtbl->GetCanonicalFormatEtc(p,a,b)
+#define IDataObject_SetData(p,a,b,c) (p)->lpVtbl->SetData(p,a,b,c)
+#define IDataObject_EnumFormatEtc(p,a,b) (p)->lpVtbl->EnumFormatEtc(p,a,b)
+#define IDataObject_DAdvise(p,a,b,c,d) (p)->lpVtbl->DAdvise(p,a,b,c,d)
+#define IDataObject_DUnadvise(p,a) (p)->lpVtbl->DUnadvise(p,a)
+#define IDataObject_EnumDAdvise(p,a) (p)->lpVtbl->EnumDAdvise(p,a)
+
+#endif
+
+HRESULT CALLBACK IDataObject_RemoteGetData_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetcIn,
+    STGMEDIUM* pRemoteMedium);
+void __RPC_STUB IDataObject_RemoteGetData_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_GetData_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetcIn,
+    STGMEDIUM* pmedium);
+HRESULT __RPC_STUB IDataObject_GetData_Stub(
+    IDataObject* This,
+    FORMATETC* pformatetcIn,
+    STGMEDIUM* pRemoteMedium);
+HRESULT CALLBACK IDataObject_RemoteGetDataHere_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    STGMEDIUM* pRemoteMedium);
+void __RPC_STUB IDataObject_RemoteGetDataHere_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_GetDataHere_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    STGMEDIUM* pmedium);
+HRESULT __RPC_STUB IDataObject_GetDataHere_Stub(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    STGMEDIUM* pRemoteMedium);
+HRESULT CALLBACK IDataObject_QueryGetData_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc);
+void __RPC_STUB IDataObject_QueryGetData_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_GetCanonicalFormatEtc_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatectIn,
+    FORMATETC* pformatetcOut);
+void __RPC_STUB IDataObject_GetCanonicalFormatEtc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_RemoteSetData_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    FLAG_STGMEDIUM* pmedium,
+    BOOL fRelease);
+void __RPC_STUB IDataObject_RemoteSetData_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_SetData_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    STGMEDIUM* pmedium,
+    BOOL fRelease);
+HRESULT __RPC_STUB IDataObject_SetData_Stub(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    FLAG_STGMEDIUM* pmedium,
+    BOOL fRelease);
+HRESULT CALLBACK IDataObject_EnumFormatEtc_Proxy(
+    IDataObject* This,
+    DWORD dwDirection,
+    IEnumFORMATETC** ppenumFormatEtc);
+void __RPC_STUB IDataObject_EnumFormatEtc_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_DAdvise_Proxy(
+    IDataObject* This,
+    FORMATETC* pformatetc,
+    DWORD advf,
+    IAdviseSink* pAdvSink,
+    DWORD* pdwConnection);
+void __RPC_STUB IDataObject_DAdvise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_DUnadvise_Proxy(
+    IDataObject* This,
+    DWORD dwConnection);
+void __RPC_STUB IDataObject_DUnadvise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataObject_EnumDAdvise_Proxy(
+    IDataObject* This,
+    IEnumSTATDATA** ppenumAdvise);
+void __RPC_STUB IDataObject_EnumDAdvise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IDataAdviseHolder IDataAdviseHolder;
+typedef IDataAdviseHolder *LPDATAADVISEHOLDER;
+
+/*****************************************************************************
+ * IDataAdviseHolder interface
+ */
+DEFINE_GUID(IID_IDataAdviseHolder, 0x00000110, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IDataAdviseHolder: IUnknown {
+
+    virtual HRESULT CALLBACK Advise(
+        IDataObject* pDataObject,
+        FORMATETC* pFetc,
+        DWORD advf,
+        IAdviseSink* pAdvise,
+        DWORD* pdwConnection) = 0;
+
+    virtual HRESULT CALLBACK Unadvise(
+        DWORD dwConnection) = 0;
+
+    virtual HRESULT CALLBACK EnumAdvise(
+        IEnumSTATDATA** ppenumAdvise) = 0;
+
+    virtual HRESULT CALLBACK SendOnDataChange(
+        IDataObject* pDataObject,
+        DWORD dwReserved,
+        DWORD advf) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IDataAdviseHolderVtbl IDataAdviseHolderVtbl;
+struct IDataAdviseHolder {
+    const IDataAdviseHolderVtbl* lpVtbl;
+};
+struct IDataAdviseHolderVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IDataAdviseHolder* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IDataAdviseHolder* This);
+
+    ULONG (CALLBACK *Release)(
+        IDataAdviseHolder* This);
+
+    /*** IDataAdviseHolder methods ***/
+    HRESULT (CALLBACK *Advise)(
+        IDataAdviseHolder* This,
+        IDataObject* pDataObject,
+        FORMATETC* pFetc,
+        DWORD advf,
+        IAdviseSink* pAdvise,
+        DWORD* pdwConnection);
+
+    HRESULT (CALLBACK *Unadvise)(
+        IDataAdviseHolder* This,
+        DWORD dwConnection);
+
+    HRESULT (CALLBACK *EnumAdvise)(
+        IDataAdviseHolder* This,
+        IEnumSTATDATA** ppenumAdvise);
+
+    HRESULT (CALLBACK *SendOnDataChange)(
+        IDataAdviseHolder* This,
+        IDataObject* pDataObject,
+        DWORD dwReserved,
+        DWORD advf);
+
+};
+
+#define IDataAdviseHolder_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,Advise,IDataObject*,pDataObject,FORMATETC*,pFetc,DWORD,advf,IAdviseSink*,pAdvise,DWORD*,pdwConnection) \
+    ICOM_METHOD1 (HRESULT,Unadvise,DWORD,dwConnection) \
+    ICOM_METHOD1 (HRESULT,EnumAdvise,IEnumSTATDATA**,ppenumAdvise) \
+    ICOM_METHOD3 (HRESULT,SendOnDataChange,IDataObject*,pDataObject,DWORD,dwReserved,DWORD,advf)
+
+/*** IUnknown methods ***/
+#define IDataAdviseHolder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDataAdviseHolder_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDataAdviseHolder_Release(p) (p)->lpVtbl->Release(p)
+/*** IDataAdviseHolder methods ***/
+#define IDataAdviseHolder_Advise(p,a,b,c,d,e) (p)->lpVtbl->Advise(p,a,b,c,d,e)
+#define IDataAdviseHolder_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
+#define IDataAdviseHolder_EnumAdvise(p,a) (p)->lpVtbl->EnumAdvise(p,a)
+#define IDataAdviseHolder_SendOnDataChange(p,a,b,c) (p)->lpVtbl->SendOnDataChange(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK IDataAdviseHolder_Advise_Proxy(
+    IDataAdviseHolder* This,
+    IDataObject* pDataObject,
+    FORMATETC* pFetc,
+    DWORD advf,
+    IAdviseSink* pAdvise,
+    DWORD* pdwConnection);
+void __RPC_STUB IDataAdviseHolder_Advise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataAdviseHolder_Unadvise_Proxy(
+    IDataAdviseHolder* This,
+    DWORD dwConnection);
+void __RPC_STUB IDataAdviseHolder_Unadvise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataAdviseHolder_EnumAdvise_Proxy(
+    IDataAdviseHolder* This,
+    IEnumSTATDATA** ppenumAdvise);
+void __RPC_STUB IDataAdviseHolder_EnumAdvise_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IDataAdviseHolder_SendOnDataChange_Proxy(
+    IDataAdviseHolder* This,
+    IDataObject* pDataObject,
+    DWORD dwReserved,
+    DWORD advf);
+void __RPC_STUB IDataAdviseHolder_SendOnDataChange_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IMessageFilter IMessageFilter;
+typedef IMessageFilter *LPMESSAGEFILTER;
+
+typedef enum tagCALLTYPE {
+    CALLTYPE_TOPLEVEL = 1,
+    CALLTYPE_NESTED = 2,
+    CALLTYPE_ASYNC = 3,
+    CALLTYPE_TOPLEVEL_CALLPENDING = 4,
+    CALLTYPE_ASYNC_CALLPENDING = 5
+} CALLTYPE;
+
+typedef enum tagSERVERCALL {
+    SERVERCALL_ISHANDLED = 0,
+    SERVERCALL_REJECTED = 1,
+    SERVERCALL_RETRYLATER = 2
+} SERVERCALL;
+
+typedef enum tagPENDINGTYPE {
+    PENDINGTYPE_TOPLEVEL = 1,
+    PENDINGTYPE_NESTED = 2
+} PENDINGTYPE;
+
+typedef enum tagPENDINGMSG {
+    PENDINGMSG_CANCELCALL = 0,
+    PENDINGMSG_WAITNOPROCESS = 1,
+    PENDINGMSG_WAITDEFPROCESS = 2
+} PENDINGMSG;
+
+typedef struct tagINTERFACEINFO {
+    IUnknown *pUnk;
+    IID iid;
+    WORD wMethod;
+} INTERFACEINFO, *LPINTERFACEINFO;
+
+/*****************************************************************************
+ * IMessageFilter interface
+ */
+DEFINE_GUID(IID_IMessageFilter, 0x00000016, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMessageFilter: IUnknown {
+
+    virtual DWORD CALLBACK HandleInComingCall(
+        DWORD dwCallType,
+        HTASK htaskCaller,
+        DWORD dwTickCount,
+        LPINTERFACEINFO lpInterfaceInfo) = 0;
+
+    virtual DWORD CALLBACK RetryRejectedCall(
+        HTASK htaskCallee,
+        DWORD dwTickCount,
+        DWORD dwRejectType) = 0;
+
+    virtual DWORD CALLBACK MessagePending(
+        HTASK htaskCallee,
+        DWORD dwTickCount,
+        DWORD dwPendingType) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IMessageFilterVtbl IMessageFilterVtbl;
+struct IMessageFilter {
+    const IMessageFilterVtbl* lpVtbl;
+};
+struct IMessageFilterVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IMessageFilter* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IMessageFilter* This);
+
+    ULONG (CALLBACK *Release)(
+        IMessageFilter* This);
+
+    /*** IMessageFilter methods ***/
+    DWORD (CALLBACK *HandleInComingCall)(
+        IMessageFilter* This,
+        DWORD dwCallType,
+        HTASK htaskCaller,
+        DWORD dwTickCount,
+        LPINTERFACEINFO lpInterfaceInfo);
+
+    DWORD (CALLBACK *RetryRejectedCall)(
+        IMessageFilter* This,
+        HTASK htaskCallee,
+        DWORD dwTickCount,
+        DWORD dwRejectType);
+
+    DWORD (CALLBACK *MessagePending)(
+        IMessageFilter* This,
+        HTASK htaskCallee,
+        DWORD dwTickCount,
+        DWORD dwPendingType);
+
+};
+
+#define IMessageFilter_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD4 (DWORD,HandleInComingCall,DWORD,dwCallType,HTASK,htaskCaller,DWORD,dwTickCount,LPINTERFACEINFO,lpInterfaceInfo) \
+    ICOM_METHOD3 (DWORD,RetryRejectedCall,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwRejectType) \
+    ICOM_METHOD3 (DWORD,MessagePending,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwPendingType)
+
+/*** IUnknown methods ***/
+#define IMessageFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMessageFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMessageFilter_Release(p) (p)->lpVtbl->Release(p)
+/*** IMessageFilter methods ***/
+#define IMessageFilter_HandleInComingCall(p,a,b,c,d) (p)->lpVtbl->HandleInComingCall(p,a,b,c,d)
+#define IMessageFilter_RetryRejectedCall(p,a,b,c) (p)->lpVtbl->RetryRejectedCall(p,a,b,c)
+#define IMessageFilter_MessagePending(p,a,b,c) (p)->lpVtbl->MessagePending(p,a,b,c)
+
+#endif
+
+DWORD CALLBACK IMessageFilter_HandleInComingCall_Proxy(
+    IMessageFilter* This,
+    DWORD dwCallType,
+    HTASK htaskCaller,
+    DWORD dwTickCount,
+    LPINTERFACEINFO lpInterfaceInfo);
+void __RPC_STUB IMessageFilter_HandleInComingCall_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+DWORD CALLBACK IMessageFilter_RetryRejectedCall_Proxy(
+    IMessageFilter* This,
+    HTASK htaskCallee,
+    DWORD dwTickCount,
+    DWORD dwRejectType);
+void __RPC_STUB IMessageFilter_RetryRejectedCall_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+DWORD CALLBACK IMessageFilter_MessagePending_Proxy(
+    IMessageFilter* This,
+    HTASK htaskCallee,
+    DWORD dwTickCount,
+    DWORD dwPendingType);
+void __RPC_STUB IMessageFilter_MessagePending_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRpcChannelBuffer IRpcChannelBuffer;
+typedef IRpcChannelBuffer *LPRPCCHANNELBUFFER;
+
+typedef unsigned long RPCOLEDATAREP;
+
+typedef struct tagRPCOLEMESSAGE {
+    void *reserved1;
+    RPCOLEDATAREP dataRepresentation;
+    void *Buffer;
+    ULONG cbBuffer;
+    ULONG iMethod;
+    void *reserved2[5];
+    ULONG rpcFlags;
+} RPCOLEMESSAGE;
+
+typedef RPCOLEMESSAGE *PRPCOLEMESSAGE;
+
+/*****************************************************************************
+ * IRpcChannelBuffer interface
+ */
+DEFINE_GUID(IID_IRpcChannelBuffer, 0xd5f56b60, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRpcChannelBuffer: IUnknown {
+
+    virtual HRESULT CALLBACK GetBuffer(
+        RPCOLEMESSAGE* pMessage,
+        REFIID riid) = 0;
+
+    virtual HRESULT CALLBACK SendReceive(
+        RPCOLEMESSAGE* pMessage,
+        ULONG* pStatus) = 0;
+
+    virtual HRESULT CALLBACK FreeBuffer(
+        RPCOLEMESSAGE* pMessage) = 0;
+
+    virtual HRESULT CALLBACK GetDestCtx(
+        DWORD* pdwDestContext,
+        void** ppvDestContext) = 0;
+
+    virtual HRESULT CALLBACK IsConnected(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRpcChannelBufferVtbl IRpcChannelBufferVtbl;
+struct IRpcChannelBuffer {
+    const IRpcChannelBufferVtbl* lpVtbl;
+};
+struct IRpcChannelBufferVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRpcChannelBuffer* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRpcChannelBuffer* This);
+
+    ULONG (CALLBACK *Release)(
+        IRpcChannelBuffer* This);
+
+    /*** IRpcChannelBuffer methods ***/
+    HRESULT (CALLBACK *GetBuffer)(
+        IRpcChannelBuffer* This,
+        RPCOLEMESSAGE* pMessage,
+        REFIID riid);
+
+    HRESULT (CALLBACK *SendReceive)(
+        IRpcChannelBuffer* This,
+        RPCOLEMESSAGE* pMessage,
+        ULONG* pStatus);
+
+    HRESULT (CALLBACK *FreeBuffer)(
+        IRpcChannelBuffer* This,
+        RPCOLEMESSAGE* pMessage);
+
+    HRESULT (CALLBACK *GetDestCtx)(
+        IRpcChannelBuffer* This,
+        DWORD* pdwDestContext,
+        void** ppvDestContext);
+
+    HRESULT (CALLBACK *IsConnected)(
+        IRpcChannelBuffer* This);
+
+};
+
+#define IRpcChannelBuffer_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD2 (HRESULT,GetBuffer,RPCOLEMESSAGE*,pMessage,REFIID,riid) \
+    ICOM_METHOD2 (HRESULT,SendReceive,RPCOLEMESSAGE*,pMessage,ULONG*,pStatus) \
+    ICOM_METHOD1 (HRESULT,FreeBuffer,RPCOLEMESSAGE*,pMessage) \
+    ICOM_METHOD2 (HRESULT,GetDestCtx,DWORD*,pdwDestContext,void**,ppvDestContext) \
+    ICOM_METHOD  (HRESULT,IsConnected)
+
+/*** IUnknown methods ***/
+#define IRpcChannelBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRpcChannelBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRpcChannelBuffer_Release(p) (p)->lpVtbl->Release(p)
+/*** IRpcChannelBuffer methods ***/
+#define IRpcChannelBuffer_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
+#define IRpcChannelBuffer_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
+#define IRpcChannelBuffer_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
+#define IRpcChannelBuffer_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
+#define IRpcChannelBuffer_IsConnected(p) (p)->lpVtbl->IsConnected(p)
+
+#endif
+
+HRESULT CALLBACK IRpcChannelBuffer_GetBuffer_Proxy(
+    IRpcChannelBuffer* This,
+    RPCOLEMESSAGE* pMessage,
+    REFIID riid);
+void __RPC_STUB IRpcChannelBuffer_GetBuffer_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer_SendReceive_Proxy(
+    IRpcChannelBuffer* This,
+    RPCOLEMESSAGE* pMessage,
+    ULONG* pStatus);
+void __RPC_STUB IRpcChannelBuffer_SendReceive_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer_FreeBuffer_Proxy(
+    IRpcChannelBuffer* This,
+    RPCOLEMESSAGE* pMessage);
+void __RPC_STUB IRpcChannelBuffer_FreeBuffer_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer_GetDestCtx_Proxy(
+    IRpcChannelBuffer* This,
+    DWORD* pdwDestContext,
+    void** ppvDestContext);
+void __RPC_STUB IRpcChannelBuffer_GetDestCtx_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer_IsConnected_Proxy(
+    IRpcChannelBuffer* This);
+void __RPC_STUB IRpcChannelBuffer_IsConnected_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRpcChannelBuffer2 IRpcChannelBuffer2;
+typedef IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;
+
+/*****************************************************************************
+ * IRpcChannelBuffer2 interface
+ */
+DEFINE_GUID(IID_IRpcChannelBuffer2, 0x594f31d0, 0x7f19, 0x11d0, 0xb1,0x94, 0x00,0xa0,0xc9,0x0d,0xc8,0xbf);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRpcChannelBuffer2: IRpcChannelBuffer {
+
+    virtual HRESULT CALLBACK GetProtocolVersion(
+        DWORD* pdwVersion) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRpcChannelBuffer2Vtbl IRpcChannelBuffer2Vtbl;
+struct IRpcChannelBuffer2 {
+    const IRpcChannelBuffer2Vtbl* lpVtbl;
+};
+struct IRpcChannelBuffer2Vtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRpcChannelBuffer2* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRpcChannelBuffer2* This);
+
+    ULONG (CALLBACK *Release)(
+        IRpcChannelBuffer2* This);
+
+    /*** IRpcChannelBuffer methods ***/
+    HRESULT (CALLBACK *GetBuffer)(
+        IRpcChannelBuffer2* This,
+        RPCOLEMESSAGE* pMessage,
+        REFIID riid);
+
+    HRESULT (CALLBACK *SendReceive)(
+        IRpcChannelBuffer2* This,
+        RPCOLEMESSAGE* pMessage,
+        ULONG* pStatus);
+
+    HRESULT (CALLBACK *FreeBuffer)(
+        IRpcChannelBuffer2* This,
+        RPCOLEMESSAGE* pMessage);
+
+    HRESULT (CALLBACK *GetDestCtx)(
+        IRpcChannelBuffer2* This,
+        DWORD* pdwDestContext,
+        void** ppvDestContext);
+
+    HRESULT (CALLBACK *IsConnected)(
+        IRpcChannelBuffer2* This);
+
+    /*** IRpcChannelBuffer2 methods ***/
+    HRESULT (CALLBACK *GetProtocolVersion)(
+        IRpcChannelBuffer2* This,
+        DWORD* pdwVersion);
+
+};
+
+#define IRpcChannelBuffer2_IMETHODS \
+    IRpcChannelBuffer_IMETHODS \
+    ICOM_METHOD1 (HRESULT,GetProtocolVersion,DWORD*,pdwVersion)
+
+/*** IUnknown methods ***/
+#define IRpcChannelBuffer2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRpcChannelBuffer2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRpcChannelBuffer2_Release(p) (p)->lpVtbl->Release(p)
+/*** IRpcChannelBuffer methods ***/
+#define IRpcChannelBuffer2_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
+#define IRpcChannelBuffer2_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
+#define IRpcChannelBuffer2_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
+#define IRpcChannelBuffer2_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
+#define IRpcChannelBuffer2_IsConnected(p) (p)->lpVtbl->IsConnected(p)
+/*** IRpcChannelBuffer2 methods ***/
+#define IRpcChannelBuffer2_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a)
+
+#endif
+
+HRESULT CALLBACK IRpcChannelBuffer2_GetProtocolVersion_Proxy(
+    IRpcChannelBuffer2* This,
+    DWORD* pdwVersion);
+void __RPC_STUB IRpcChannelBuffer2_GetProtocolVersion_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRpcChannelBuffer3 IRpcChannelBuffer3;
+typedef IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;
+
+/*****************************************************************************
+ * IRpcChannelBuffer3 interface
+ */
+DEFINE_GUID(IID_IRpcChannelBuffer3, 0x25b15600, 0x0115, 0x11d0, 0xbf,0x0d, 0x00,0xaa,0x00,0xb8,0xdf,0xd2);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRpcChannelBuffer3: IRpcChannelBuffer2 {
+
+    virtual HRESULT CALLBACK Send(
+        RPCOLEMESSAGE* pMsg,
+        ULONG* pulStatus) = 0;
+
+    virtual HRESULT CALLBACK Receive(
+        RPCOLEMESSAGE* pMsg,
+        ULONG ulSize,
+        ULONG* pulStatus) = 0;
+
+    virtual HRESULT CALLBACK Cancel(
+        RPCOLEMESSAGE* pMsg) = 0;
+
+    virtual HRESULT CALLBACK GetCallContext(
+        RPCOLEMESSAGE* pMsg,
+        REFIID riid,
+        void** pInterface) = 0;
+
+    virtual HRESULT CALLBACK GetDestCtxEx(
+        RPCOLEMESSAGE* pMsg,
+        DWORD* pdwDestContext,
+        void** ppvDestContext) = 0;
+
+    virtual HRESULT CALLBACK GetState(
+        RPCOLEMESSAGE* pMsg,
+        DWORD* pState) = 0;
+
+    virtual HRESULT CALLBACK RegisterAsync(
+        RPCOLEMESSAGE* pMsg,
+        IAsyncManager* pAsyncMgr) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRpcChannelBuffer3Vtbl IRpcChannelBuffer3Vtbl;
+struct IRpcChannelBuffer3 {
+    const IRpcChannelBuffer3Vtbl* lpVtbl;
+};
+struct IRpcChannelBuffer3Vtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRpcChannelBuffer3* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRpcChannelBuffer3* This);
+
+    ULONG (CALLBACK *Release)(
+        IRpcChannelBuffer3* This);
+
+    /*** IRpcChannelBuffer methods ***/
+    HRESULT (CALLBACK *GetBuffer)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMessage,
+        REFIID riid);
+
+    HRESULT (CALLBACK *SendReceive)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMessage,
+        ULONG* pStatus);
+
+    HRESULT (CALLBACK *FreeBuffer)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMessage);
+
+    HRESULT (CALLBACK *GetDestCtx)(
+        IRpcChannelBuffer3* This,
+        DWORD* pdwDestContext,
+        void** ppvDestContext);
+
+    HRESULT (CALLBACK *IsConnected)(
+        IRpcChannelBuffer3* This);
+
+    /*** IRpcChannelBuffer2 methods ***/
+    HRESULT (CALLBACK *GetProtocolVersion)(
+        IRpcChannelBuffer3* This,
+        DWORD* pdwVersion);
+
+    /*** IRpcChannelBuffer3 methods ***/
+    HRESULT (CALLBACK *Send)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        ULONG* pulStatus);
+
+    HRESULT (CALLBACK *Receive)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        ULONG ulSize,
+        ULONG* pulStatus);
+
+    HRESULT (CALLBACK *Cancel)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg);
+
+    HRESULT (CALLBACK *GetCallContext)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        REFIID riid,
+        void** pInterface);
+
+    HRESULT (CALLBACK *GetDestCtxEx)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        DWORD* pdwDestContext,
+        void** ppvDestContext);
+
+    HRESULT (CALLBACK *GetState)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        DWORD* pState);
+
+    HRESULT (CALLBACK *RegisterAsync)(
+        IRpcChannelBuffer3* This,
+        RPCOLEMESSAGE* pMsg,
+        IAsyncManager* pAsyncMgr);
+
+};
+
+#define IRpcChannelBuffer3_IMETHODS \
+    IRpcChannelBuffer2_IMETHODS \
+    ICOM_METHOD2 (HRESULT,Send,RPCOLEMESSAGE*,pMsg,ULONG*,pulStatus) \
+    ICOM_METHOD3 (HRESULT,Receive,RPCOLEMESSAGE*,pMsg,ULONG,ulSize,ULONG*,pulStatus) \
+    ICOM_METHOD1 (HRESULT,Cancel,RPCOLEMESSAGE*,pMsg) \
+    ICOM_METHOD3 (HRESULT,GetCallContext,RPCOLEMESSAGE*,pMsg,REFIID,riid,void**,pInterface) \
+    ICOM_METHOD3 (HRESULT,GetDestCtxEx,RPCOLEMESSAGE*,pMsg,DWORD*,pdwDestContext,void**,ppvDestContext) \
+    ICOM_METHOD2 (HRESULT,GetState,RPCOLEMESSAGE*,pMsg,DWORD*,pState) \
+    ICOM_METHOD2 (HRESULT,RegisterAsync,RPCOLEMESSAGE*,pMsg,IAsyncManager*,pAsyncMgr)
+
+/*** IUnknown methods ***/
+#define IRpcChannelBuffer3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRpcChannelBuffer3_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRpcChannelBuffer3_Release(p) (p)->lpVtbl->Release(p)
+/*** IRpcChannelBuffer methods ***/
+#define IRpcChannelBuffer3_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
+#define IRpcChannelBuffer3_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
+#define IRpcChannelBuffer3_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
+#define IRpcChannelBuffer3_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
+#define IRpcChannelBuffer3_IsConnected(p) (p)->lpVtbl->IsConnected(p)
+/*** IRpcChannelBuffer2 methods ***/
+#define IRpcChannelBuffer3_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a)
+/*** IRpcChannelBuffer3 methods ***/
+#define IRpcChannelBuffer3_Send(p,a,b) (p)->lpVtbl->Send(p,a,b)
+#define IRpcChannelBuffer3_Receive(p,a,b,c) (p)->lpVtbl->Receive(p,a,b,c)
+#define IRpcChannelBuffer3_Cancel(p,a) (p)->lpVtbl->Cancel(p,a)
+#define IRpcChannelBuffer3_GetCallContext(p,a,b,c) (p)->lpVtbl->GetCallContext(p,a,b,c)
+#define IRpcChannelBuffer3_GetDestCtxEx(p,a,b,c) (p)->lpVtbl->GetDestCtxEx(p,a,b,c)
+#define IRpcChannelBuffer3_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
+#define IRpcChannelBuffer3_RegisterAsync(p,a,b) (p)->lpVtbl->RegisterAsync(p,a,b)
+
+#endif
+
+HRESULT CALLBACK IRpcChannelBuffer3_Send_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    ULONG* pulStatus);
+void __RPC_STUB IRpcChannelBuffer3_Send_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_Receive_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    ULONG ulSize,
+    ULONG* pulStatus);
+void __RPC_STUB IRpcChannelBuffer3_Receive_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_Cancel_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg);
+void __RPC_STUB IRpcChannelBuffer3_Cancel_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_GetCallContext_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    REFIID riid,
+    void** pInterface);
+void __RPC_STUB IRpcChannelBuffer3_GetCallContext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_GetDestCtxEx_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    DWORD* pdwDestContext,
+    void** ppvDestContext);
+void __RPC_STUB IRpcChannelBuffer3_GetDestCtxEx_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_GetState_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    DWORD* pState);
+void __RPC_STUB IRpcChannelBuffer3_GetState_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcChannelBuffer3_RegisterAsync_Proxy(
+    IRpcChannelBuffer3* This,
+    RPCOLEMESSAGE* pMsg,
+    IAsyncManager* pAsyncMgr);
+void __RPC_STUB IRpcChannelBuffer3_RegisterAsync_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRpcProxyBuffer IRpcProxyBuffer;
+typedef IRpcProxyBuffer *LPRPCPROXYBUFFER;
+
+/*****************************************************************************
+ * IRpcProxyBuffer interface
+ */
+DEFINE_GUID(IID_IRpcProxyBuffer, 0xd5f56a34, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRpcProxyBuffer: IUnknown {
+
+    virtual HRESULT CALLBACK Connect(
+        IRpcChannelBuffer* pRpcChannelBuffer) = 0;
+
+    virtual void CALLBACK Disconnect(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRpcProxyBufferVtbl IRpcProxyBufferVtbl;
+struct IRpcProxyBuffer {
+    const IRpcProxyBufferVtbl* lpVtbl;
+};
+struct IRpcProxyBufferVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRpcProxyBuffer* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRpcProxyBuffer* This);
+
+    ULONG (CALLBACK *Release)(
+        IRpcProxyBuffer* This);
+
+    /*** IRpcProxyBuffer methods ***/
+    HRESULT (CALLBACK *Connect)(
+        IRpcProxyBuffer* This,
+        IRpcChannelBuffer* pRpcChannelBuffer);
+
+    void (CALLBACK *Disconnect)(
+        IRpcProxyBuffer* This);
+
+};
+
+#define IRpcProxyBuffer_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,Connect,IRpcChannelBuffer*,pRpcChannelBuffer) \
+    ICOM_VMETHOD (Disconnect)
+
+/*** IUnknown methods ***/
+#define IRpcProxyBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRpcProxyBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRpcProxyBuffer_Release(p) (p)->lpVtbl->Release(p)
+/*** IRpcProxyBuffer methods ***/
+#define IRpcProxyBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a)
+#define IRpcProxyBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p)
+
+#endif
+
+HRESULT CALLBACK IRpcProxyBuffer_Connect_Proxy(
+    IRpcProxyBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer);
+void __RPC_STUB IRpcProxyBuffer_Connect_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IRpcProxyBuffer_Disconnect_Proxy(
+    IRpcProxyBuffer* This);
+void __RPC_STUB IRpcProxyBuffer_Disconnect_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IRpcStubBuffer IRpcStubBuffer;
+typedef IRpcStubBuffer *LPRPCSTUBBUFFER;
+
+/*****************************************************************************
+ * IRpcStubBuffer interface
+ */
+DEFINE_GUID(IID_IRpcStubBuffer, 0xd5f56afc, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRpcStubBuffer: IUnknown {
+
+    virtual HRESULT CALLBACK Connect(
+        IUnknown* pUnkServer) = 0;
+
+    virtual void CALLBACK Disconnect(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Invoke(
+        RPCOLEMESSAGE* _prpcmsg,
+        IRpcChannelBuffer* _pRpcChannelBuffer) = 0;
+
+    virtual IRpcStubBuffer* CALLBACK IsIIDSupported(
+        REFIID riid) = 0;
+
+    virtual ULONG CALLBACK CountRefs(
+        ) = 0;
+
+    virtual HRESULT CALLBACK DebugServerQueryInterface(
+        void** ppv) = 0;
+
+    virtual void CALLBACK DebugServerRelease(
+        void* pv) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IRpcStubBufferVtbl IRpcStubBufferVtbl;
+struct IRpcStubBuffer {
+    const IRpcStubBufferVtbl* lpVtbl;
+};
+struct IRpcStubBufferVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IRpcStubBuffer* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IRpcStubBuffer* This);
+
+    ULONG (CALLBACK *Release)(
+        IRpcStubBuffer* This);
+
+    /*** IRpcStubBuffer methods ***/
+    HRESULT (CALLBACK *Connect)(
+        IRpcStubBuffer* This,
+        IUnknown* pUnkServer);
+
+    void (CALLBACK *Disconnect)(
+        IRpcStubBuffer* This);
+
+    HRESULT (CALLBACK *Invoke)(
+        IRpcStubBuffer* This,
+        RPCOLEMESSAGE* _prpcmsg,
+        IRpcChannelBuffer* _pRpcChannelBuffer);
+
+    IRpcStubBuffer* (CALLBACK *IsIIDSupported)(
+        IRpcStubBuffer* This,
+        REFIID riid);
+
+    ULONG (CALLBACK *CountRefs)(
+        IRpcStubBuffer* This);
+
+    HRESULT (CALLBACK *DebugServerQueryInterface)(
+        IRpcStubBuffer* This,
+        void** ppv);
+
+    void (CALLBACK *DebugServerRelease)(
+        IRpcStubBuffer* This,
+        void* pv);
+
+};
+
+#define IRpcStubBuffer_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,Connect,IUnknown*,pUnkServer) \
+    ICOM_VMETHOD (Disconnect) \
+    ICOM_METHOD2 (HRESULT,Invoke,RPCOLEMESSAGE*,_prpcmsg,IRpcChannelBuffer*,_pRpcChannelBuffer) \
+    ICOM_METHOD1 (IRpcStubBuffer*,IsIIDSupported,REFIID,riid) \
+    ICOM_METHOD  (ULONG,CountRefs) \
+    ICOM_METHOD1 (HRESULT,DebugServerQueryInterface,void**,ppv) \
+    ICOM_VMETHOD1(DebugServerRelease,void*,pv)
+
+/*** IUnknown methods ***/
+#define IRpcStubBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IRpcStubBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IRpcStubBuffer_Release(p) (p)->lpVtbl->Release(p)
+/*** IRpcStubBuffer methods ***/
+#define IRpcStubBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a)
+#define IRpcStubBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p)
+#define IRpcStubBuffer_Invoke(p,a,b) (p)->lpVtbl->Invoke(p,a,b)
+#define IRpcStubBuffer_IsIIDSupported(p,a) (p)->lpVtbl->IsIIDSupported(p,a)
+#define IRpcStubBuffer_CountRefs(p) (p)->lpVtbl->CountRefs(p)
+#define IRpcStubBuffer_DebugServerQueryInterface(p,a) (p)->lpVtbl->DebugServerQueryInterface(p,a)
+#define IRpcStubBuffer_DebugServerRelease(p,a) (p)->lpVtbl->DebugServerRelease(p,a)
+
+#endif
+
+HRESULT CALLBACK IRpcStubBuffer_Connect_Proxy(
+    IRpcStubBuffer* This,
+    IUnknown* pUnkServer);
+void __RPC_STUB IRpcStubBuffer_Connect_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IRpcStubBuffer_Disconnect_Proxy(
+    IRpcStubBuffer* This);
+void __RPC_STUB IRpcStubBuffer_Disconnect_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcStubBuffer_Invoke_Proxy(
+    IRpcStubBuffer* This,
+    RPCOLEMESSAGE* _prpcmsg,
+    IRpcChannelBuffer* _pRpcChannelBuffer);
+void __RPC_STUB IRpcStubBuffer_Invoke_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+IRpcStubBuffer* CALLBACK IRpcStubBuffer_IsIIDSupported_Proxy(
+    IRpcStubBuffer* This,
+    REFIID riid);
+void __RPC_STUB IRpcStubBuffer_IsIIDSupported_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+ULONG CALLBACK IRpcStubBuffer_CountRefs_Proxy(
+    IRpcStubBuffer* This);
+void __RPC_STUB IRpcStubBuffer_CountRefs_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IRpcStubBuffer_DebugServerQueryInterface_Proxy(
+    IRpcStubBuffer* This,
+    void** ppv);
+void __RPC_STUB IRpcStubBuffer_DebugServerQueryInterface_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IRpcStubBuffer_DebugServerRelease_Proxy(
+    IRpcStubBuffer* This,
+    void* pv);
+void __RPC_STUB IRpcStubBuffer_DebugServerRelease_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPSFactoryBuffer IPSFactoryBuffer;
+typedef IPSFactoryBuffer *LPPSFACTORYBUFFER;
+
+/*****************************************************************************
+ * IPSFactoryBuffer interface
+ */
+DEFINE_GUID(IID_IPSFactoryBuffer, 0xd5f569d0, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPSFactoryBuffer: IUnknown {
+
+    virtual HRESULT CALLBACK CreateProxy(
+        IUnknown* pUnkOuter,
+        REFIID riid,
+        IRpcProxyBuffer** ppProxy,
+        void** ppv) = 0;
+
+    virtual HRESULT CALLBACK CreateStub(
+        REFIID riid,
+        IUnknown* pUnkServer,
+        IRpcStubBuffer** ppStub) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPSFactoryBufferVtbl IPSFactoryBufferVtbl;
+struct IPSFactoryBuffer {
+    const IPSFactoryBufferVtbl* lpVtbl;
+};
+struct IPSFactoryBufferVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPSFactoryBuffer* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPSFactoryBuffer* This);
+
+    ULONG (CALLBACK *Release)(
+        IPSFactoryBuffer* This);
+
+    /*** IPSFactoryBuffer methods ***/
+    HRESULT (CALLBACK *CreateProxy)(
+        IPSFactoryBuffer* This,
+        IUnknown* pUnkOuter,
+        REFIID riid,
+        IRpcProxyBuffer** ppProxy,
+        void** ppv);
+
+    HRESULT (CALLBACK *CreateStub)(
+        IPSFactoryBuffer* This,
+        REFIID riid,
+        IUnknown* pUnkServer,
+        IRpcStubBuffer** ppStub);
+
+};
+
+#define IPSFactoryBuffer_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD4 (HRESULT,CreateProxy,IUnknown*,pUnkOuter,REFIID,riid,IRpcProxyBuffer**,ppProxy,void**,ppv) \
+    ICOM_METHOD3 (HRESULT,CreateStub,REFIID,riid,IUnknown*,pUnkServer,IRpcStubBuffer**,ppStub)
+
+/*** IUnknown methods ***/
+#define IPSFactoryBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPSFactoryBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPSFactoryBuffer_Release(p) (p)->lpVtbl->Release(p)
+/*** IPSFactoryBuffer methods ***/
+#define IPSFactoryBuffer_CreateProxy(p,a,b,c,d) (p)->lpVtbl->CreateProxy(p,a,b,c,d)
+#define IPSFactoryBuffer_CreateStub(p,a,b,c) (p)->lpVtbl->CreateStub(p,a,b,c)
+
+#endif
+
+HRESULT CALLBACK IPSFactoryBuffer_CreateProxy_Proxy(
+    IPSFactoryBuffer* This,
+    IUnknown* pUnkOuter,
+    REFIID riid,
+    IRpcProxyBuffer** ppProxy,
+    void** ppv);
+void __RPC_STUB IPSFactoryBuffer_CreateProxy_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPSFactoryBuffer_CreateStub_Proxy(
+    IPSFactoryBuffer* This,
+    REFIID riid,
+    IUnknown* pUnkServer,
+    IRpcStubBuffer** ppStub);
+void __RPC_STUB IPSFactoryBuffer_CreateStub_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IChannelHook IChannelHook;
+typedef IChannelHook *LPCHANNELHOOK;
+
+typedef struct SChannelHookCallInfo {
+    IID iid;
+    DWORD cbSize;
+    GUID uCausality;
+    DWORD dwServerPid;
+    DWORD iMethod;
+    void *pObject;
+} SChannelHookCallInfo;
+
+/*****************************************************************************
+ * IChannelHook interface
+ */
+DEFINE_GUID(IID_IChannelHook, 0x1008c4a0, 0x7613, 0x11cf, 0x9a,0xf1, 0x00,0x20,0xaf,0x6e,0x72,0xf4);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IChannelHook: IUnknown {
+
+    virtual void CALLBACK ClientGetSize(
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize) = 0;
+
+    virtual void CALLBACK ClientFillBuffer(
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize,
+        void* pDataBuffer) = 0;
+
+    virtual void CALLBACK ClientNotify(
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG cbDataSize,
+        void* pDataBuffer,
+        DWORD lDataRep,
+        HRESULT hrFault) = 0;
+
+    virtual void CALLBACK ServerNotify(
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG cbDataSize,
+        void* pDataBuffer,
+        DWORD lDataRep) = 0;
+
+    virtual void CALLBACK ServerGetSize(
+        REFGUID uExtent,
+        REFIID riid,
+        HRESULT hrFault,
+        ULONG* pDataSize) = 0;
+
+    virtual void CALLBACK ServerFillBuffer(
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize,
+        void* pDataBuffer,
+        HRESULT hrFault) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IChannelHookVtbl IChannelHookVtbl;
+struct IChannelHook {
+    const IChannelHookVtbl* lpVtbl;
+};
+struct IChannelHookVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IChannelHook* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IChannelHook* This);
+
+    ULONG (CALLBACK *Release)(
+        IChannelHook* This);
+
+    /*** IChannelHook methods ***/
+    void (CALLBACK *ClientGetSize)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize);
+
+    void (CALLBACK *ClientFillBuffer)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize,
+        void* pDataBuffer);
+
+    void (CALLBACK *ClientNotify)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG cbDataSize,
+        void* pDataBuffer,
+        DWORD lDataRep,
+        HRESULT hrFault);
+
+    void (CALLBACK *ServerNotify)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG cbDataSize,
+        void* pDataBuffer,
+        DWORD lDataRep);
+
+    void (CALLBACK *ServerGetSize)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        HRESULT hrFault,
+        ULONG* pDataSize);
+
+    void (CALLBACK *ServerFillBuffer)(
+        IChannelHook* This,
+        REFGUID uExtent,
+        REFIID riid,
+        ULONG* pDataSize,
+        void* pDataBuffer,
+        HRESULT hrFault);
+
+};
+
+#define IChannelHook_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_VMETHOD3(ClientGetSize,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize) \
+    ICOM_VMETHOD4(ClientFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer) \
+    ICOM_VMETHOD6(ClientNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep,HRESULT,hrFault) \
+    ICOM_VMETHOD5(ServerNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep) \
+    ICOM_VMETHOD4(ServerGetSize,REFGUID,uExtent,REFIID,riid,HRESULT,hrFault,ULONG*,pDataSize) \
+    ICOM_VMETHOD5(ServerFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer,HRESULT,hrFault)
+
+/*** IUnknown methods ***/
+#define IChannelHook_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IChannelHook_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IChannelHook_Release(p) (p)->lpVtbl->Release(p)
+/*** IChannelHook methods ***/
+#define IChannelHook_ClientGetSize(p,a,b,c) (p)->lpVtbl->ClientGetSize(p,a,b,c)
+#define IChannelHook_ClientFillBuffer(p,a,b,c,d) (p)->lpVtbl->ClientFillBuffer(p,a,b,c,d)
+#define IChannelHook_ClientNotify(p,a,b,c,d,e,f) (p)->lpVtbl->ClientNotify(p,a,b,c,d,e,f)
+#define IChannelHook_ServerNotify(p,a,b,c,d,e) (p)->lpVtbl->ServerNotify(p,a,b,c,d,e)
+#define IChannelHook_ServerGetSize(p,a,b,c,d) (p)->lpVtbl->ServerGetSize(p,a,b,c,d)
+#define IChannelHook_ServerFillBuffer(p,a,b,c,d,e) (p)->lpVtbl->ServerFillBuffer(p,a,b,c,d,e)
+
+#endif
+
+void CALLBACK IChannelHook_ClientGetSize_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    ULONG* pDataSize);
+void __RPC_STUB IChannelHook_ClientGetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IChannelHook_ClientFillBuffer_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    ULONG* pDataSize,
+    void* pDataBuffer);
+void __RPC_STUB IChannelHook_ClientFillBuffer_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IChannelHook_ClientNotify_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    ULONG cbDataSize,
+    void* pDataBuffer,
+    DWORD lDataRep,
+    HRESULT hrFault);
+void __RPC_STUB IChannelHook_ClientNotify_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IChannelHook_ServerNotify_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    ULONG cbDataSize,
+    void* pDataBuffer,
+    DWORD lDataRep);
+void __RPC_STUB IChannelHook_ServerNotify_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IChannelHook_ServerGetSize_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    HRESULT hrFault,
+    ULONG* pDataSize);
+void __RPC_STUB IChannelHook_ServerGetSize_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void CALLBACK IChannelHook_ServerFillBuffer_Proxy(
+    IChannelHook* This,
+    REFGUID uExtent,
+    REFIID riid,
+    ULONG* pDataSize,
+    void* pDataBuffer,
+    HRESULT hrFault);
+void __RPC_STUB IChannelHook_ServerFillBuffer_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IEnumSTATPROPSTG IEnumSTATPROPSTG;
+typedef struct IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG;
+typedef struct IPropertyStorage IPropertyStorage;
+typedef IPropertyStorage *LPPROPERTYSTORAGE;
+
+extern const FMTID FMTID_SummaryInformation;
+
+extern const FMTID FMTID_DocSummaryInformation;
+
+extern const FMTID FMTID_UserDefinedProperties;
+
+#define PROPSETFLAG_DEFAULT (0)
+
+#define PROPSETFLAG_NONSIMPLE (1)
+
+#define PROPSETFLAG_ANSI (2)
+
+#define PROPSETFLAG_UNBUFFERED (4)
+
+typedef struct tagPROPVARIANT PROPVARIANT;
+
+typedef struct tagCAUB {
+    ULONG cElems;
+    unsigned char *pElems;
+} CAUB;
+
+typedef struct tagCAI {
+    ULONG cElems;
+    short *pElems;
+} CAI;
+
+typedef struct tagCAUI {
+    ULONG cElems;
+    USHORT *pElems;
+} CAUI;
+
+typedef struct tagCAL {
+    ULONG cElems;
+    long *pElems;
+} CAL;
+
+typedef struct tagCAUL {
+    ULONG cElems;
+    ULONG *pElems;
+} CAUL;
+
+typedef struct tagCAFLT {
+    ULONG cElems;
+    float *pElems;
+} CAFLT;
+
+typedef struct tagCADBL {
+    ULONG cElems;
+    double *pElems;
+} CADBL;
+
+typedef struct tagCACY {
+    ULONG cElems;
+    CY *pElems;
+} CACY;
+
+typedef struct tagCADATE {
+    ULONG cElems;
+    DATE *pElems;
+} CADATE;
+
+typedef struct tagCABSTR {
+    ULONG cElems;
+    BSTR *pElems;
+} CABSTR;
+
+typedef struct tagCABSTRBLOB {
+    ULONG cElems;
+    BSTRBLOB *pElems;
+} CABSTRBLOB;
+
+typedef struct tagCABOOL {
+    ULONG cElems;
+    VARIANT_BOOL *pElems;
+} CABOOL;
+
+typedef struct tagCASCODE {
+    ULONG cElems;
+    SCODE *pElems;
+} CASCODE;
+
+typedef struct tagCAPROPVARIANT {
+    ULONG cElems;
+    PROPVARIANT *pElems;
+} CAPROPVARIANT;
+
+typedef struct tagCAH {
+    ULONG cElems;
+    LARGE_INTEGER *pElems;
+} CAH;
+
+typedef struct tagCAUH {
+    ULONG cElems;
+    ULARGE_INTEGER *pElems;
+} CAUH;
+
+typedef struct tagCALPSTR {
+    ULONG cElems;
+    LPSTR *pElems;
+} CALPSTR;
+
+typedef struct tagCALPWSTR {
+    ULONG cElems;
+    LPWSTR *pElems;
+} CALPWSTR;
+
+typedef struct tagCAFILETIME {
+    ULONG cElems;
+    FILETIME *pElems;
+} CAFILETIME;
+
+typedef struct tagCACLIPDATA {
+    ULONG cElems;
+    CLIPDATA *pElems;
+} CACLIPDATA;
+
+typedef struct tagCACLSID {
+    ULONG cElems;
+    CLSID *pElems;
+} CACLSID;
+
+struct tagPROPVARIANT {
+    VARTYPE vt;
+    WORD wReserved1;
+    WORD wReserved2;
+    WORD wReserved3;
+    union {
+        UCHAR bVal;
+        short iVal;
+        USHORT uiVal;
+        VARIANT_BOOL boolVal;
+        long lVal;
+        ULONG ulVal;
+        float fltVal;
+        SCODE scode;
+        LARGE_INTEGER hVal;
+        ULARGE_INTEGER uhVal;
+        double dblVal;
+        CY cyVal;
+        DATE date;
+        FILETIME filetime;
+        CLSID *puuid;
+        BLOB blob;
+        CLIPDATA *pclipdata;
+        IStream *pStream;
+        IStorage *pStorage;
+        BSTR bstrVal;
+        BSTRBLOB bstrblobVal;
+        LPSTR pszVal;
+        LPWSTR pwszVal;
+        CAUB caub;
+        CAI cai;
+        CAUI caui;
+        CABOOL cabool;
+        CAL cal;
+        CAUL caul;
+        CAFLT caflt;
+        CASCODE cascode;
+        CAH cah;
+        CAUH cauh;
+        CADBL cadbl;
+        CACY cacy;
+        CADATE cadate;
+        CAFILETIME cafiletime;
+        CACLSID cauuid;
+        CACLIPDATA caclipdata;
+        CABSTR cabstr;
+        CABSTRBLOB cabstrblob;
+        CALPSTR calpstr;
+        CALPWSTR calpwstr;
+        CAPROPVARIANT capropvar;
+    } DUMMYUNIONNAME;
+};
+
+typedef struct tagPROPVARIANT *LPPROPVARIANT;
+
+#define PRSPEC_INVALID (0x7fffffff)
+
+#define PRSPEC_LPWSTR (0)
+
+#define PRSPEC_PROPID (1)
+
+typedef struct tagPROPSPEC {
+    ULONG ulKind;
+    union {
+        PROPID propid;
+        LPOLESTR lpwstr;
+    } DUMMYUNIONNAME;
+} PROPSPEC;
+
+typedef struct tagSTATPROPSTG {
+    LPOLESTR lpwstrName;
+    PROPID propid;
+    VARTYPE vt;
+} STATPROPSTG;
+
+typedef struct tagSTATPROPSETSTG {
+    FMTID fmtid;
+    CLSID clsid;
+    DWORD grfFlags;
+    FILETIME mtime;
+    FILETIME ctime;
+    FILETIME atime;
+    DWORD dwOSVersion;
+} STATPROPSETSTG;
+
+/*****************************************************************************
+ * IPropertyStorage interface
+ */
+DEFINE_GUID(IID_IPropertyStorage, 0x00000138, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPropertyStorage: IUnknown {
+
+    virtual HRESULT CALLBACK ReadMultiple(
+        ULONG cpspec,
+        const PROPSPEC rgpspec[],
+        PROPVARIANT rgpropvar[]) = 0;
+
+    virtual HRESULT CALLBACK WriteMultiple(
+        ULONG cpspec,
+        const PROPSPEC rgpspec[],
+        const PROPVARIANT rgpropvar[],
+        PROPID propidNameFirst) = 0;
+
+    virtual HRESULT CALLBACK DeleteMultiple(
+        ULONG cpspec,
+        const PROPSPEC rgpspec[]) = 0;
+
+    virtual HRESULT CALLBACK ReadPropertyNames(
+        ULONG cpropid,
+        const PROPID rgpropid[],
+        LPOLESTR rglpwstrName[]) = 0;
+
+    virtual HRESULT CALLBACK WritePropertyNames(
+        ULONG cpropid,
+        const PROPID rgpropid[],
+        const LPOLESTR rglpwstrName[]) = 0;
+
+    virtual HRESULT CALLBACK DeletePropertyNames(
+        ULONG cpropid,
+        const PROPID rgpropid[]) = 0;
+
+    virtual HRESULT CALLBACK Commit(
+        DWORD grfCommitFlags) = 0;
+
+    virtual HRESULT CALLBACK Revert(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Enum(
+        IEnumSTATPROPSTG** ppenum) = 0;
+
+    virtual HRESULT CALLBACK SetTimes(
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime) = 0;
+
+    virtual HRESULT CALLBACK SetClass(
+        REFCLSID clsid) = 0;
+
+    virtual HRESULT CALLBACK Stat(
+        STATPROPSETSTG* statpsstg) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPropertyStorageVtbl IPropertyStorageVtbl;
+struct IPropertyStorage {
+    const IPropertyStorageVtbl* lpVtbl;
+};
+struct IPropertyStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPropertyStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPropertyStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        IPropertyStorage* This);
+
+    /*** IPropertyStorage methods ***/
+    HRESULT (CALLBACK *ReadMultiple)(
+        IPropertyStorage* This,
+        ULONG cpspec,
+        const PROPSPEC rgpspec[],
+        PROPVARIANT rgpropvar[]);
+
+    HRESULT (CALLBACK *WriteMultiple)(
+        IPropertyStorage* This,
+        ULONG cpspec,
+        const PROPSPEC rgpspec[],
+        const PROPVARIANT rgpropvar[],
+        PROPID propidNameFirst);
+
+    HRESULT (CALLBACK *DeleteMultiple)(
+        IPropertyStorage* This,
+        ULONG cpspec,
+        const PROPSPEC rgpspec[]);
+
+    HRESULT (CALLBACK *ReadPropertyNames)(
+        IPropertyStorage* This,
+        ULONG cpropid,
+        const PROPID rgpropid[],
+        LPOLESTR rglpwstrName[]);
+
+    HRESULT (CALLBACK *WritePropertyNames)(
+        IPropertyStorage* This,
+        ULONG cpropid,
+        const PROPID rgpropid[],
+        const LPOLESTR rglpwstrName[]);
+
+    HRESULT (CALLBACK *DeletePropertyNames)(
+        IPropertyStorage* This,
+        ULONG cpropid,
+        const PROPID rgpropid[]);
+
+    HRESULT (CALLBACK *Commit)(
+        IPropertyStorage* This,
+        DWORD grfCommitFlags);
+
+    HRESULT (CALLBACK *Revert)(
+        IPropertyStorage* This);
+
+    HRESULT (CALLBACK *Enum)(
+        IPropertyStorage* This,
+        IEnumSTATPROPSTG** ppenum);
+
+    HRESULT (CALLBACK *SetTimes)(
+        IPropertyStorage* This,
+        const FILETIME* pctime,
+        const FILETIME* patime,
+        const FILETIME* pmtime);
+
+    HRESULT (CALLBACK *SetClass)(
+        IPropertyStorage* This,
+        REFCLSID clsid);
+
+    HRESULT (CALLBACK *Stat)(
+        IPropertyStorage* This,
+        STATPROPSETSTG* statpsstg);
+
+};
+
+#define IPropertyStorage_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,ReadMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,PROPVARIANT*,rgpropvar) \
+    ICOM_METHOD4 (HRESULT,WriteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,const PROPVARIANT*,rgpropvar,PROPID,propidNameFirst) \
+    ICOM_METHOD2 (HRESULT,DeleteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec) \
+    ICOM_METHOD3 (HRESULT,ReadPropertyNames,ULONG,cpropid,const PROPID*,rgpropid,LPOLESTR*,rglpwstrName) \
+    ICOM_METHOD3 (HRESULT,WritePropertyNames,ULONG,cpropid,const PROPID*,rgpropid,const LPOLESTR*,rglpwstrName) \
+    ICOM_METHOD2 (HRESULT,DeletePropertyNames,ULONG,cpropid,const PROPID*,rgpropid) \
+    ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
+    ICOM_METHOD  (HRESULT,Revert) \
+    ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSTG**,ppenum) \
+    ICOM_METHOD3 (HRESULT,SetTimes,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
+    ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
+    ICOM_METHOD1 (HRESULT,Stat,STATPROPSETSTG*,statpsstg)
+
+/*** IUnknown methods ***/
+#define IPropertyStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPropertyStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPropertyStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** IPropertyStorage methods ***/
+#define IPropertyStorage_ReadMultiple(p,a,b,c) (p)->lpVtbl->ReadMultiple(p,a,b,c)
+#define IPropertyStorage_WriteMultiple(p,a,b,c,d) (p)->lpVtbl->WriteMultiple(p,a,b,c,d)
+#define IPropertyStorage_DeleteMultiple(p,a,b) (p)->lpVtbl->DeleteMultiple(p,a,b)
+#define IPropertyStorage_ReadPropertyNames(p,a,b,c) (p)->lpVtbl->ReadPropertyNames(p,a,b,c)
+#define IPropertyStorage_WritePropertyNames(p,a,b,c) (p)->lpVtbl->WritePropertyNames(p,a,b,c)
+#define IPropertyStorage_DeletePropertyNames(p,a,b) (p)->lpVtbl->DeletePropertyNames(p,a,b)
+#define IPropertyStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a)
+#define IPropertyStorage_Revert(p) (p)->lpVtbl->Revert(p)
+#define IPropertyStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a)
+#define IPropertyStorage_SetTimes(p,a,b,c) (p)->lpVtbl->SetTimes(p,a,b,c)
+#define IPropertyStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
+#define IPropertyStorage_Stat(p,a) (p)->lpVtbl->Stat(p,a)
+
+#endif
+
+HRESULT CALLBACK IPropertyStorage_ReadMultiple_Proxy(
+    IPropertyStorage* This,
+    ULONG cpspec,
+    const PROPSPEC rgpspec[],
+    PROPVARIANT rgpropvar[]);
+void __RPC_STUB IPropertyStorage_ReadMultiple_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_WriteMultiple_Proxy(
+    IPropertyStorage* This,
+    ULONG cpspec,
+    const PROPSPEC rgpspec[],
+    const PROPVARIANT rgpropvar[],
+    PROPID propidNameFirst);
+void __RPC_STUB IPropertyStorage_WriteMultiple_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_DeleteMultiple_Proxy(
+    IPropertyStorage* This,
+    ULONG cpspec,
+    const PROPSPEC rgpspec[]);
+void __RPC_STUB IPropertyStorage_DeleteMultiple_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_ReadPropertyNames_Proxy(
+    IPropertyStorage* This,
+    ULONG cpropid,
+    const PROPID rgpropid[],
+    LPOLESTR rglpwstrName[]);
+void __RPC_STUB IPropertyStorage_ReadPropertyNames_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_WritePropertyNames_Proxy(
+    IPropertyStorage* This,
+    ULONG cpropid,
+    const PROPID rgpropid[],
+    const LPOLESTR rglpwstrName[]);
+void __RPC_STUB IPropertyStorage_WritePropertyNames_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_DeletePropertyNames_Proxy(
+    IPropertyStorage* This,
+    ULONG cpropid,
+    const PROPID rgpropid[]);
+void __RPC_STUB IPropertyStorage_DeletePropertyNames_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_Commit_Proxy(
+    IPropertyStorage* This,
+    DWORD grfCommitFlags);
+void __RPC_STUB IPropertyStorage_Commit_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_Revert_Proxy(
+    IPropertyStorage* This);
+void __RPC_STUB IPropertyStorage_Revert_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_Enum_Proxy(
+    IPropertyStorage* This,
+    IEnumSTATPROPSTG** ppenum);
+void __RPC_STUB IPropertyStorage_Enum_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_SetTimes_Proxy(
+    IPropertyStorage* This,
+    const FILETIME* pctime,
+    const FILETIME* patime,
+    const FILETIME* pmtime);
+void __RPC_STUB IPropertyStorage_SetTimes_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_SetClass_Proxy(
+    IPropertyStorage* This,
+    REFCLSID clsid);
+void __RPC_STUB IPropertyStorage_SetClass_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertyStorage_Stat_Proxy(
+    IPropertyStorage* This,
+    STATPROPSETSTG* statpsstg);
+void __RPC_STUB IPropertyStorage_Stat_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IPropertySetStorage IPropertySetStorage;
+typedef IPropertySetStorage *LPPROPERTYSETSTORAGE;
+
+/*****************************************************************************
+ * IPropertySetStorage interface
+ */
+DEFINE_GUID(IID_IPropertySetStorage, 0x0000013a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPropertySetStorage: IUnknown {
+
+    virtual HRESULT CALLBACK Create(
+        REFFMTID rfmtid,
+        const CLSID* pclsid,
+        DWORD grfFlags,
+        DWORD grfMode,
+        IPropertyStorage** ppprstg) = 0;
+
+    virtual HRESULT CALLBACK Open(
+        REFFMTID rfmtid,
+        DWORD grfMode,
+        IPropertyStorage** ppprstg) = 0;
+
+    virtual HRESULT CALLBACK Delete(
+        REFFMTID rfmtid) = 0;
+
+    virtual HRESULT CALLBACK Enum(
+        IEnumSTATPROPSETSTG** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IPropertySetStorageVtbl IPropertySetStorageVtbl;
+struct IPropertySetStorage {
+    const IPropertySetStorageVtbl* lpVtbl;
+};
+struct IPropertySetStorageVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IPropertySetStorage* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IPropertySetStorage* This);
+
+    ULONG (CALLBACK *Release)(
+        IPropertySetStorage* This);
+
+    /*** IPropertySetStorage methods ***/
+    HRESULT (CALLBACK *Create)(
+        IPropertySetStorage* This,
+        REFFMTID rfmtid,
+        const CLSID* pclsid,
+        DWORD grfFlags,
+        DWORD grfMode,
+        IPropertyStorage** ppprstg);
+
+    HRESULT (CALLBACK *Open)(
+        IPropertySetStorage* This,
+        REFFMTID rfmtid,
+        DWORD grfMode,
+        IPropertyStorage** ppprstg);
+
+    HRESULT (CALLBACK *Delete)(
+        IPropertySetStorage* This,
+        REFFMTID rfmtid);
+
+    HRESULT (CALLBACK *Enum)(
+        IPropertySetStorage* This,
+        IEnumSTATPROPSETSTG** ppenum);
+
+};
+
+#define IPropertySetStorage_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,Create,REFFMTID,rfmtid,const CLSID*,pclsid,DWORD,grfFlags,DWORD,grfMode,IPropertyStorage**,ppprstg) \
+    ICOM_METHOD3 (HRESULT,Open,REFFMTID,rfmtid,DWORD,grfMode,IPropertyStorage**,ppprstg) \
+    ICOM_METHOD1 (HRESULT,Delete,REFFMTID,rfmtid) \
+    ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSETSTG**,ppenum)
+
+/*** IUnknown methods ***/
+#define IPropertySetStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPropertySetStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPropertySetStorage_Release(p) (p)->lpVtbl->Release(p)
+/*** IPropertySetStorage methods ***/
+#define IPropertySetStorage_Create(p,a,b,c,d,e) (p)->lpVtbl->Create(p,a,b,c,d,e)
+#define IPropertySetStorage_Open(p,a,b,c) (p)->lpVtbl->Open(p,a,b,c)
+#define IPropertySetStorage_Delete(p,a) (p)->lpVtbl->Delete(p,a)
+#define IPropertySetStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a)
+
+#endif
+
+HRESULT CALLBACK IPropertySetStorage_Create_Proxy(
+    IPropertySetStorage* This,
+    REFFMTID rfmtid,
+    const CLSID* pclsid,
+    DWORD grfFlags,
+    DWORD grfMode,
+    IPropertyStorage** ppprstg);
+void __RPC_STUB IPropertySetStorage_Create_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertySetStorage_Open_Proxy(
+    IPropertySetStorage* This,
+    REFFMTID rfmtid,
+    DWORD grfMode,
+    IPropertyStorage** ppprstg);
+void __RPC_STUB IPropertySetStorage_Open_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertySetStorage_Delete_Proxy(
+    IPropertySetStorage* This,
+    REFFMTID rfmtid);
+void __RPC_STUB IPropertySetStorage_Delete_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IPropertySetStorage_Enum_Proxy(
+    IPropertySetStorage* This,
+    IEnumSTATPROPSETSTG** ppenum);
+void __RPC_STUB IPropertySetStorage_Enum_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IEnumSTATPROPSTG *LPENUMSTATPROPSTG;
+
+/*****************************************************************************
+ * IEnumSTATPROPSTG interface
+ */
+DEFINE_GUID(IID_IEnumSTATPROPSTG, 0x00000139, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumSTATPROPSTG: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        STATPROPSTG* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumSTATPROPSTG** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumSTATPROPSTGVtbl IEnumSTATPROPSTGVtbl;
+struct IEnumSTATPROPSTG {
+    const IEnumSTATPROPSTGVtbl* lpVtbl;
+};
+struct IEnumSTATPROPSTGVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumSTATPROPSTG* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumSTATPROPSTG* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumSTATPROPSTG* This);
+
+    /*** IEnumSTATPROPSTG methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumSTATPROPSTG* This,
+        ULONG celt,
+        STATPROPSTG* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumSTATPROPSTG* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumSTATPROPSTG* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumSTATPROPSTG* This,
+        IEnumSTATPROPSTG** ppenum);
+
+};
+
+#define IEnumSTATPROPSTG_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSTG*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSTG**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumSTATPROPSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumSTATPROPSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumSTATPROPSTG_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumSTATPROPSTG methods ***/
+#define IEnumSTATPROPSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumSTATPROPSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumSTATPROPSTG_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumSTATPROPSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumSTATPROPSTG_RemoteNext_Proxy(
+    IEnumSTATPROPSTG* This,
+    ULONG celt,
+    STATPROPSTG* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumSTATPROPSTG_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSTG_Next_Proxy(
+    IEnumSTATPROPSTG* This,
+    ULONG celt,
+    STATPROPSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumSTATPROPSTG_Next_Stub(
+    IEnumSTATPROPSTG* This,
+    ULONG celt,
+    STATPROPSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumSTATPROPSTG_Skip_Proxy(
+    IEnumSTATPROPSTG* This,
+    ULONG celt);
+void __RPC_STUB IEnumSTATPROPSTG_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSTG_Reset_Proxy(
+    IEnumSTATPROPSTG* This);
+void __RPC_STUB IEnumSTATPROPSTG_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSTG_Clone_Proxy(
+    IEnumSTATPROPSTG* This,
+    IEnumSTATPROPSTG** ppenum);
+void __RPC_STUB IEnumSTATPROPSTG_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG;
+
+/*****************************************************************************
+ * IEnumSTATPROPSETSTG interface
+ */
+DEFINE_GUID(IID_IEnumSTATPROPSETSTG, 0x0000013b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumSTATPROPSETSTG: IUnknown {
+
+    virtual HRESULT CALLBACK Next(
+        ULONG celt,
+        STATPROPSETSTG* rgelt,
+        ULONG* pceltFetched) = 0;
+
+    virtual HRESULT CALLBACK Skip(
+        ULONG celt) = 0;
+
+    virtual HRESULT CALLBACK Reset(
+        ) = 0;
+
+    virtual HRESULT CALLBACK Clone(
+        IEnumSTATPROPSETSTG** ppenum) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTGVtbl;
+struct IEnumSTATPROPSETSTG {
+    const IEnumSTATPROPSETSTGVtbl* lpVtbl;
+};
+struct IEnumSTATPROPSETSTGVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IEnumSTATPROPSETSTG* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IEnumSTATPROPSETSTG* This);
+
+    ULONG (CALLBACK *Release)(
+        IEnumSTATPROPSETSTG* This);
+
+    /*** IEnumSTATPROPSETSTG methods ***/
+    HRESULT (CALLBACK *Next)(
+        IEnumSTATPROPSETSTG* This,
+        ULONG celt,
+        STATPROPSETSTG* rgelt,
+        ULONG* pceltFetched);
+
+    HRESULT (CALLBACK *Skip)(
+        IEnumSTATPROPSETSTG* This,
+        ULONG celt);
+
+    HRESULT (CALLBACK *Reset)(
+        IEnumSTATPROPSETSTG* This);
+
+    HRESULT (CALLBACK *Clone)(
+        IEnumSTATPROPSETSTG* This,
+        IEnumSTATPROPSETSTG** ppenum);
+
+};
+
+#define IEnumSTATPROPSETSTG_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSETSTG*,rgelt,ULONG*,pceltFetched) \
+    ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
+    ICOM_METHOD  (HRESULT,Reset) \
+    ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSETSTG**,ppenum)
+
+/*** IUnknown methods ***/
+#define IEnumSTATPROPSETSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumSTATPROPSETSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumSTATPROPSETSTG_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumSTATPROPSETSTG methods ***/
+#define IEnumSTATPROPSETSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumSTATPROPSETSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumSTATPROPSETSTG_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumSTATPROPSETSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+HRESULT CALLBACK IEnumSTATPROPSETSTG_RemoteNext_Proxy(
+    IEnumSTATPROPSETSTG* This,
+    ULONG celt,
+    STATPROPSETSTG* rgelt,
+    ULONG* pceltFetched);
+void __RPC_STUB IEnumSTATPROPSETSTG_RemoteNext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSETSTG_Next_Proxy(
+    IEnumSTATPROPSETSTG* This,
+    ULONG celt,
+    STATPROPSETSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT __RPC_STUB IEnumSTATPROPSETSTG_Next_Stub(
+    IEnumSTATPROPSETSTG* This,
+    ULONG celt,
+    STATPROPSETSTG* rgelt,
+    ULONG* pceltFetched);
+HRESULT CALLBACK IEnumSTATPROPSETSTG_Skip_Proxy(
+    IEnumSTATPROPSETSTG* This,
+    ULONG celt);
+void __RPC_STUB IEnumSTATPROPSETSTG_Skip_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSETSTG_Reset_Proxy(
+    IEnumSTATPROPSETSTG* This);
+void __RPC_STUB IEnumSTATPROPSETSTG_Reset_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumSTATPROPSETSTG_Clone_Proxy(
+    IEnumSTATPROPSETSTG* This,
+    IEnumSTATPROPSETSTG** ppenum);
+void __RPC_STUB IEnumSTATPROPSETSTG_Clone_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IClientSecurity IClientSecurity;
+typedef struct tagSOLE_AUTHENTICATION_SERVICE {
+    DWORD dwAuthnSvc;
+    DWORD dwAuthzSvc;
+    OLECHAR *pPrincipalName;
+    HRESULT hr;
+} SOLE_AUTHENTICATION_SERVICE;
+
+typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE;
+
+typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES {
+    EOAC_NONE = 0x0,
+    EOAC_MUTUAL_AUTH = 0x1,
+    EOAC_CLOAKING = 0x10,
+    EOAC_SECURE_REFS = 0x2,
+    EOAC_ACCESS_CONTROL = 0x4,
+    EOAC_APPID = 0x8
+} EOLE_AUTHENTICATION_CAPABILITIES;
+
+/*****************************************************************************
+ * IClientSecurity interface
+ */
+DEFINE_GUID(IID_IClientSecurity, 0x0000013d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IClientSecurity: IUnknown {
+
+    virtual HRESULT CALLBACK QueryBlanket(
+        IUnknown* pProxy,
+        DWORD* pAuthnSvc,
+        DWORD* pAuthzSvc,
+        OLECHAR** pServerPrincName,
+        DWORD* pAuthnLevel,
+        DWORD* pImpLevel,
+        void** pAuthInfo,
+        DWORD* pCapabilites) = 0;
+
+    virtual HRESULT CALLBACK SetBlanket(
+        IUnknown* pProxy,
+        DWORD AuthnSvc,
+        DWORD AuthzSvc,
+        OLECHAR* pServerPrincName,
+        DWORD AuthnLevel,
+        DWORD ImpLevel,
+        void* pAuthInfo,
+        DWORD Capabilities) = 0;
+
+    virtual HRESULT CALLBACK CopyProxy(
+        IUnknown* pProxy,
+        IUnknown** ppCopy) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IClientSecurityVtbl IClientSecurityVtbl;
+struct IClientSecurity {
+    const IClientSecurityVtbl* lpVtbl;
+};
+struct IClientSecurityVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IClientSecurity* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IClientSecurity* This);
+
+    ULONG (CALLBACK *Release)(
+        IClientSecurity* This);
+
+    /*** IClientSecurity methods ***/
+    HRESULT (CALLBACK *QueryBlanket)(
+        IClientSecurity* This,
+        IUnknown* pProxy,
+        DWORD* pAuthnSvc,
+        DWORD* pAuthzSvc,
+        OLECHAR** pServerPrincName,
+        DWORD* pAuthnLevel,
+        DWORD* pImpLevel,
+        void** pAuthInfo,
+        DWORD* pCapabilites);
+
+    HRESULT (CALLBACK *SetBlanket)(
+        IClientSecurity* This,
+        IUnknown* pProxy,
+        DWORD AuthnSvc,
+        DWORD AuthzSvc,
+        OLECHAR* pServerPrincName,
+        DWORD AuthnLevel,
+        DWORD ImpLevel,
+        void* pAuthInfo,
+        DWORD Capabilities);
+
+    HRESULT (CALLBACK *CopyProxy)(
+        IClientSecurity* This,
+        IUnknown* pProxy,
+        IUnknown** ppCopy);
+
+};
+
+#define IClientSecurity_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD8 (HRESULT,QueryBlanket,IUnknown*,pProxy,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pAuthInfo,DWORD*,pCapabilites) \
+    ICOM_METHOD8 (HRESULT,SetBlanket,IUnknown*,pProxy,DWORD,AuthnSvc,DWORD,AuthzSvc,OLECHAR*,pServerPrincName,DWORD,AuthnLevel,DWORD,ImpLevel,void*,pAuthInfo,DWORD,Capabilities) \
+    ICOM_METHOD2 (HRESULT,CopyProxy,IUnknown*,pProxy,IUnknown**,ppCopy)
+
+/*** IUnknown methods ***/
+#define IClientSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IClientSecurity_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IClientSecurity_Release(p) (p)->lpVtbl->Release(p)
+/*** IClientSecurity methods ***/
+#define IClientSecurity_QueryBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g,h)
+#define IClientSecurity_SetBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->SetBlanket(p,a,b,c,d,e,f,g,h)
+#define IClientSecurity_CopyProxy(p,a,b) (p)->lpVtbl->CopyProxy(p,a,b)
+
+#endif
+
+HRESULT CALLBACK IClientSecurity_QueryBlanket_Proxy(
+    IClientSecurity* This,
+    IUnknown* pProxy,
+    DWORD* pAuthnSvc,
+    DWORD* pAuthzSvc,
+    OLECHAR** pServerPrincName,
+    DWORD* pAuthnLevel,
+    DWORD* pImpLevel,
+    void** pAuthInfo,
+    DWORD* pCapabilites);
+void __RPC_STUB IClientSecurity_QueryBlanket_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IClientSecurity_SetBlanket_Proxy(
+    IClientSecurity* This,
+    IUnknown* pProxy,
+    DWORD AuthnSvc,
+    DWORD AuthzSvc,
+    OLECHAR* pServerPrincName,
+    DWORD AuthnLevel,
+    DWORD ImpLevel,
+    void* pAuthInfo,
+    DWORD Capabilities);
+void __RPC_STUB IClientSecurity_SetBlanket_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IClientSecurity_CopyProxy_Proxy(
+    IClientSecurity* This,
+    IUnknown* pProxy,
+    IUnknown** ppCopy);
+void __RPC_STUB IClientSecurity_CopyProxy_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IServerSecurity IServerSecurity;
+/*****************************************************************************
+ * IServerSecurity interface
+ */
+DEFINE_GUID(IID_IServerSecurity, 0x0000013e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IServerSecurity: IUnknown {
+
+    virtual HRESULT CALLBACK QueryBlanket(
+        DWORD* pAuthnSvc,
+        DWORD* pAuthzSvc,
+        OLECHAR** pServerPrincName,
+        DWORD* pAuthnLevel,
+        DWORD* pImpLevel,
+        void** pPrivs,
+        DWORD* pCapabilities) = 0;
+
+    virtual HRESULT CALLBACK ImpersonateClient(
+        ) = 0;
+
+    virtual HRESULT CALLBACK RevertToSelf(
+        ) = 0;
+
+    virtual BOOL CALLBACK IsImpersonating(
+        ) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IServerSecurityVtbl IServerSecurityVtbl;
+struct IServerSecurity {
+    const IServerSecurityVtbl* lpVtbl;
+};
+struct IServerSecurityVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IServerSecurity* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IServerSecurity* This);
+
+    ULONG (CALLBACK *Release)(
+        IServerSecurity* This);
+
+    /*** IServerSecurity methods ***/
+    HRESULT (CALLBACK *QueryBlanket)(
+        IServerSecurity* This,
+        DWORD* pAuthnSvc,
+        DWORD* pAuthzSvc,
+        OLECHAR** pServerPrincName,
+        DWORD* pAuthnLevel,
+        DWORD* pImpLevel,
+        void** pPrivs,
+        DWORD* pCapabilities);
+
+    HRESULT (CALLBACK *ImpersonateClient)(
+        IServerSecurity* This);
+
+    HRESULT (CALLBACK *RevertToSelf)(
+        IServerSecurity* This);
+
+    BOOL (CALLBACK *IsImpersonating)(
+        IServerSecurity* This);
+
+};
+
+#define IServerSecurity_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD7 (HRESULT,QueryBlanket,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pPrivs,DWORD*,pCapabilities) \
+    ICOM_METHOD  (HRESULT,ImpersonateClient) \
+    ICOM_METHOD  (HRESULT,RevertToSelf) \
+    ICOM_METHOD  (BOOL,IsImpersonating)
+
+/*** IUnknown methods ***/
+#define IServerSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IServerSecurity_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IServerSecurity_Release(p) (p)->lpVtbl->Release(p)
+/*** IServerSecurity methods ***/
+#define IServerSecurity_QueryBlanket(p,a,b,c,d,e,f,g) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g)
+#define IServerSecurity_ImpersonateClient(p) (p)->lpVtbl->ImpersonateClient(p)
+#define IServerSecurity_RevertToSelf(p) (p)->lpVtbl->RevertToSelf(p)
+#define IServerSecurity_IsImpersonating(p) (p)->lpVtbl->IsImpersonating(p)
+
+#endif
+
+HRESULT CALLBACK IServerSecurity_QueryBlanket_Proxy(
+    IServerSecurity* This,
+    DWORD* pAuthnSvc,
+    DWORD* pAuthzSvc,
+    OLECHAR** pServerPrincName,
+    DWORD* pAuthnLevel,
+    DWORD* pImpLevel,
+    void** pPrivs,
+    DWORD* pCapabilities);
+void __RPC_STUB IServerSecurity_QueryBlanket_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IServerSecurity_ImpersonateClient_Proxy(
+    IServerSecurity* This);
+void __RPC_STUB IServerSecurity_ImpersonateClient_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IServerSecurity_RevertToSelf_Proxy(
+    IServerSecurity* This);
+void __RPC_STUB IServerSecurity_RevertToSelf_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+BOOL CALLBACK IServerSecurity_IsImpersonating_Proxy(
+    IServerSecurity* This);
+void __RPC_STUB IServerSecurity_IsImpersonating_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef struct IAsyncSetup IAsyncSetup;
+/*****************************************************************************
+ * IAsyncSetup interface
+ */
+DEFINE_GUID(IID_IAsyncSetup, 0x00000024, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAsyncSetup: IUnknown {
+
+    virtual HRESULT CALLBACK GetAsyncManager(
+        REFIID riid,
+        IUnknown* pOuter,
+        DWORD dwFlags,
+        IUnknown** ppInner,
+        IAsyncManager** ppAsyncMgr) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IAsyncSetupVtbl IAsyncSetupVtbl;
+struct IAsyncSetup {
+    const IAsyncSetupVtbl* lpVtbl;
+};
+struct IAsyncSetupVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IAsyncSetup* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IAsyncSetup* This);
+
+    ULONG (CALLBACK *Release)(
+        IAsyncSetup* This);
+
+    /*** IAsyncSetup methods ***/
+    HRESULT (CALLBACK *GetAsyncManager)(
+        IAsyncSetup* This,
+        REFIID riid,
+        IUnknown* pOuter,
+        DWORD dwFlags,
+        IUnknown** ppInner,
+        IAsyncManager** ppAsyncMgr);
+
+};
+
+#define IAsyncSetup_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD5 (HRESULT,GetAsyncManager,REFIID,riid,IUnknown*,pOuter,DWORD,dwFlags,IUnknown**,ppInner,IAsyncManager**,ppAsyncMgr)
+
+/*** IUnknown methods ***/
+#define IAsyncSetup_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAsyncSetup_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAsyncSetup_Release(p) (p)->lpVtbl->Release(p)
+/*** IAsyncSetup methods ***/
+#define IAsyncSetup_GetAsyncManager(p,a,b,c,d,e) (p)->lpVtbl->GetAsyncManager(p,a,b,c,d,e)
+
+#endif
+
+HRESULT CALLBACK IAsyncSetup_GetAsyncManager_Proxy(
+    IAsyncSetup* This,
+    REFIID riid,
+    IUnknown* pOuter,
+    DWORD dwFlags,
+    IUnknown** ppInner,
+    IAsyncManager** ppAsyncMgr);
+void __RPC_STUB IAsyncSetup_GetAsyncManager_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+typedef enum tagDCOM_CALL_STATE {
+    DCOM_NONE = 0,
+    DCOM_CALL_COMPLETE = 1,
+    DCOM_CALL_CANCELED = 2
+} DCOM_CALL_STATE;
+
+/*****************************************************************************
+ * IAsyncManager interface
+ */
+DEFINE_GUID(IID_IAsyncManager, 0x0000002a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAsyncManager: IUnknown {
+
+    virtual HRESULT CALLBACK CompleteCall(
+        HRESULT Result) = 0;
+
+    virtual HRESULT CALLBACK GetCallContext(
+        REFIID riid,
+        void** pInterface) = 0;
+
+    virtual HRESULT CALLBACK GetState(
+        ULONG* pulStateFlags) = 0;
+
+} ICOM_COM_INTERFACE_ATTRIBUTE;
+#else
+typedef struct IAsyncManagerVtbl IAsyncManagerVtbl;
+struct IAsyncManager {
+    const IAsyncManagerVtbl* lpVtbl;
+};
+struct IAsyncManagerVtbl {
+    ICOM_MSVTABLE_COMPAT_FIELDS
+
+    /*** IUnknown methods ***/
+    HRESULT (CALLBACK *QueryInterface)(
+        IAsyncManager* This,
+        REFIID riid,
+        void** ppvObject);
+
+    ULONG (CALLBACK *AddRef)(
+        IAsyncManager* This);
+
+    ULONG (CALLBACK *Release)(
+        IAsyncManager* This);
+
+    /*** IAsyncManager methods ***/
+    HRESULT (CALLBACK *CompleteCall)(
+        IAsyncManager* This,
+        HRESULT Result);
+
+    HRESULT (CALLBACK *GetCallContext)(
+        IAsyncManager* This,
+        REFIID riid,
+        void** pInterface);
+
+    HRESULT (CALLBACK *GetState)(
+        IAsyncManager* This,
+        ULONG* pulStateFlags);
+
+};
+
+#define IAsyncManager_IMETHODS \
+    IUnknown_IMETHODS \
+    ICOM_METHOD1 (HRESULT,CompleteCall,HRESULT,Result) \
+    ICOM_METHOD2 (HRESULT,GetCallContext,REFIID,riid,void**,pInterface) \
+    ICOM_METHOD1 (HRESULT,GetState,ULONG*,pulStateFlags)
+
+/*** IUnknown methods ***/
+#define IAsyncManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAsyncManager_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAsyncManager_Release(p) (p)->lpVtbl->Release(p)
+/*** IAsyncManager methods ***/
+#define IAsyncManager_CompleteCall(p,a) (p)->lpVtbl->CompleteCall(p,a)
+#define IAsyncManager_GetCallContext(p,a,b) (p)->lpVtbl->GetCallContext(p,a,b)
+#define IAsyncManager_GetState(p,a) (p)->lpVtbl->GetState(p,a)
+
+#endif
+
+HRESULT CALLBACK IAsyncManager_CompleteCall_Proxy(
+    IAsyncManager* This,
+    HRESULT Result);
+void __RPC_STUB IAsyncManager_CompleteCall_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncManager_GetCallContext_Proxy(
+    IAsyncManager* This,
+    REFIID riid,
+    void** pInterface);
+void __RPC_STUB IAsyncManager_GetCallContext_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncManager_GetState_Proxy(
+    IAsyncManager* This,
+    ULONG* pulStateFlags);
+void __RPC_STUB IAsyncManager_GetState_Stub(
+    struct IRpcStubBuffer* This,
+    struct IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __WIDL_OBJIDL_H */