/*** Autogenerated by WIDL 0.9.22 from objidl.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_OBJIDL_H
#define __WIDL_OBJIDL_H
#ifdef __cplusplus
extern "C" {
#endif
#include <unknwn.h>
#ifndef __IStream_FWD_DEFINED__
#define __IStream_FWD_DEFINED__
typedef interface IStream IStream;
#endif

#ifndef __IEnumString_FWD_DEFINED__
#define __IEnumString_FWD_DEFINED__
typedef interface IEnumString IEnumString;
#endif

#ifndef __IRunningObjectTable_FWD_DEFINED__
#define __IRunningObjectTable_FWD_DEFINED__
typedef interface IRunningObjectTable IRunningObjectTable;
#endif

#ifndef __IMoniker_FWD_DEFINED__
#define __IMoniker_FWD_DEFINED__
typedef interface IMoniker IMoniker;
#endif

#ifndef __IAdviseSink_FWD_DEFINED__
#define __IAdviseSink_FWD_DEFINED__
typedef interface IAdviseSink IAdviseSink;
#endif

#ifndef __IAsyncManager_FWD_DEFINED__
#define __IAsyncManager_FWD_DEFINED__
typedef interface IAsyncManager IAsyncManager;
#endif

#ifndef __ISynchronize_FWD_DEFINED__
#define __ISynchronize_FWD_DEFINED__
typedef interface ISynchronize ISynchronize;
#endif

typedef struct _COSERVERINFO {
    DWORD dwReserved1;
    LPWSTR pwszName;
    COAUTHINFO *pAuthInfo;
    DWORD dwReserved2;
} COSERVERINFO;
#ifndef __IMarshal_FWD_DEFINED__
#define __IMarshal_FWD_DEFINED__
typedef interface IMarshal IMarshal;
#endif

typedef IMarshal *LPMARSHAL;
/*****************************************************************************
 * IMarshal interface
 */
#ifndef __IMarshal_INTERFACE_DEFINED__
#define __IMarshal_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMarshal, 0x00000003, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMarshal : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetUnmarshalClass(
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        CLSID* pCid) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax(
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        DWORD* pSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE MarshalInterface(
        IStream* pStm,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnmarshalInterface(
        IStream* pStm,
        REFIID riid,
        void** ppv) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalData(
        IStream* pStm) = 0;

    virtual HRESULT STDMETHODCALLTYPE DisconnectObject(
        DWORD dwReserved) = 0;

};
#else
typedef struct IMarshalVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMarshal* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMarshal* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMarshal* This);

    /*** IMarshal methods ***/
    HRESULT (STDMETHODCALLTYPE *GetUnmarshalClass)(
        IMarshal* This,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        CLSID* pCid);

    HRESULT (STDMETHODCALLTYPE *GetMarshalSizeMax)(
        IMarshal* This,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        DWORD* pSize);

    HRESULT (STDMETHODCALLTYPE *MarshalInterface)(
        IMarshal* This,
        IStream* pStm,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags);

    HRESULT (STDMETHODCALLTYPE *UnmarshalInterface)(
        IMarshal* This,
        IStream* pStm,
        REFIID riid,
        void** ppv);

    HRESULT (STDMETHODCALLTYPE *ReleaseMarshalData)(
        IMarshal* This,
        IStream* pStm);

    HRESULT (STDMETHODCALLTYPE *DisconnectObject)(
        IMarshal* This,
        DWORD dwReserved);

    END_INTERFACE
} IMarshalVtbl;
interface IMarshal {
    const IMarshalVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_ReleaseMarshalData_Proxy(
    IMarshal* This,
    IStream* pStm);
void __RPC_STUB IMarshal_ReleaseMarshalData_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_DisconnectObject_Proxy(
    IMarshal* This,
    DWORD dwReserved);
void __RPC_STUB IMarshal_DisconnectObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMarshal_INTERFACE_DEFINED__ */

#ifndef __IMarshal2_FWD_DEFINED__
#define __IMarshal2_FWD_DEFINED__
typedef interface IMarshal2 IMarshal2;
#endif

typedef IMarshal2 *LPMARSHAL2;
/*****************************************************************************
 * IMarshal2 interface
 */
#ifndef __IMarshal2_INTERFACE_DEFINED__
#define __IMarshal2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMarshal2, 0x000001cf, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMarshal2 : public IMarshal
{
};
#else
typedef struct IMarshal2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMarshal2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMarshal2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMarshal2* This);

    /*** IMarshal methods ***/
    HRESULT (STDMETHODCALLTYPE *GetUnmarshalClass)(
        IMarshal2* This,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        CLSID* pCid);

    HRESULT (STDMETHODCALLTYPE *GetMarshalSizeMax)(
        IMarshal2* This,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags,
        DWORD* pSize);

    HRESULT (STDMETHODCALLTYPE *MarshalInterface)(
        IMarshal2* This,
        IStream* pStm,
        REFIID riid,
        void* pv,
        DWORD dwDestContext,
        void* pvDestContext,
        DWORD mshlflags);

    HRESULT (STDMETHODCALLTYPE *UnmarshalInterface)(
        IMarshal2* This,
        IStream* pStm,
        REFIID riid,
        void** ppv);

    HRESULT (STDMETHODCALLTYPE *ReleaseMarshalData)(
        IMarshal2* This,
        IStream* pStm);

    HRESULT (STDMETHODCALLTYPE *DisconnectObject)(
        IMarshal2* This,
        DWORD dwReserved);

    END_INTERFACE
} IMarshal2Vtbl;
interface IMarshal2 {
    const IMarshal2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMarshal2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMarshal2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMarshal2_Release(p) (p)->lpVtbl->Release(p)
/*** IMarshal methods ***/
#define IMarshal2_GetUnmarshalClass(p,a,b,c,d,e,f) (p)->lpVtbl->GetUnmarshalClass(p,a,b,c,d,e,f)
#define IMarshal2_GetMarshalSizeMax(p,a,b,c,d,e,f) (p)->lpVtbl->GetMarshalSizeMax(p,a,b,c,d,e,f)
#define IMarshal2_MarshalInterface(p,a,b,c,d,e,f) (p)->lpVtbl->MarshalInterface(p,a,b,c,d,e,f)
#define IMarshal2_UnmarshalInterface(p,a,b,c) (p)->lpVtbl->UnmarshalInterface(p,a,b,c)
#define IMarshal2_ReleaseMarshalData(p,a) (p)->lpVtbl->ReleaseMarshalData(p,a)
#define IMarshal2_DisconnectObject(p,a) (p)->lpVtbl->DisconnectObject(p,a)
#endif

#endif


#endif  /* __IMarshal2_INTERFACE_DEFINED__ */

#ifndef __IStdMarshalInfo_FWD_DEFINED__
#define __IStdMarshalInfo_FWD_DEFINED__
typedef interface IStdMarshalInfo IStdMarshalInfo;
#endif

typedef IStdMarshalInfo *LPSTDMARSHALINFO;
/*****************************************************************************
 * IStdMarshalInfo interface
 */
#ifndef __IStdMarshalInfo_INTERFACE_DEFINED__
#define __IStdMarshalInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IStdMarshalInfo, 0x00000018, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IStdMarshalInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetClassForHandler(
        DWORD dwDestContext,
        void* pvDestContext,
        CLSID* pClsid) = 0;

};
#else
typedef struct IStdMarshalInfoVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IStdMarshalInfo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IStdMarshalInfo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IStdMarshalInfo* This);

    /*** IStdMarshalInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassForHandler)(
        IStdMarshalInfo* This,
        DWORD dwDestContext,
        void* pvDestContext,
        CLSID* pClsid);

    END_INTERFACE
} IStdMarshalInfoVtbl;
interface IStdMarshalInfo {
    const IStdMarshalInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IStdMarshalInfo_GetClassForHandler_Proxy(
    IStdMarshalInfo* This,
    DWORD dwDestContext,
    void* pvDestContext,
    CLSID* pClsid);
void __RPC_STUB IStdMarshalInfo_GetClassForHandler_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IStdMarshalInfo_INTERFACE_DEFINED__ */

#ifndef __IExternalConnection_FWD_DEFINED__
#define __IExternalConnection_FWD_DEFINED__
typedef interface IExternalConnection IExternalConnection;
#endif

typedef IExternalConnection *LPEXTERNALCONNECTION;
typedef enum tagEXTCONN {
    EXTCONN_STRONG = 0x1,
    EXTCONN_WEAK = 0x2,
    EXTCONN_CALLABLE = 0x4
} EXTCONN;
/*****************************************************************************
 * IExternalConnection interface
 */
#ifndef __IExternalConnection_INTERFACE_DEFINED__
#define __IExternalConnection_INTERFACE_DEFINED__

DEFINE_GUID(IID_IExternalConnection, 0x00000019, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IExternalConnection : public IUnknown
{
    virtual DWORD STDMETHODCALLTYPE AddConnection(
        DWORD extconn,
        DWORD reserved) = 0;

    virtual DWORD STDMETHODCALLTYPE ReleaseConnection(
        DWORD extconn,
        DWORD reserved,
        BOOL fLastReleaseCloses) = 0;

};
#else
typedef struct IExternalConnectionVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IExternalConnection* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IExternalConnection* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IExternalConnection* This);

    /*** IExternalConnection methods ***/
    DWORD (STDMETHODCALLTYPE *AddConnection)(
        IExternalConnection* This,
        DWORD extconn,
        DWORD reserved);

    DWORD (STDMETHODCALLTYPE *ReleaseConnection)(
        IExternalConnection* This,
        DWORD extconn,
        DWORD reserved,
        BOOL fLastReleaseCloses);

    END_INTERFACE
} IExternalConnectionVtbl;
interface IExternalConnection {
    const IExternalConnectionVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

DWORD CALLBACK IExternalConnection_AddConnection_Proxy(
    IExternalConnection* This,
    DWORD extconn,
    DWORD reserved);
void __RPC_STUB IExternalConnection_AddConnection_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IExternalConnection_INTERFACE_DEFINED__ */

#ifndef __IMultiQI_FWD_DEFINED__
#define __IMultiQI_FWD_DEFINED__
typedef interface IMultiQI IMultiQI;
#endif

typedef IMultiQI *LPMULTIQI;
typedef struct tagMULTI_QI {
    const IID *pIID;
    IUnknown *pItf;
    HRESULT hr;
} MULTI_QI;
/*****************************************************************************
 * IMultiQI interface
 */
#ifndef __IMultiQI_INTERFACE_DEFINED__
#define __IMultiQI_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMultiQI, 0x00000020, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMultiQI : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryMultipleInterfaces(
        ULONG cMQIs,
        MULTI_QI* pMQIs) = 0;

};
#else
typedef struct IMultiQIVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMultiQI* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMultiQI* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMultiQI* This);

    /*** IMultiQI methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryMultipleInterfaces)(
        IMultiQI* This,
        ULONG cMQIs,
        MULTI_QI* pMQIs);

    END_INTERFACE
} IMultiQIVtbl;
interface IMultiQI {
    const IMultiQIVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IMultiQI_QueryMultipleInterfaces_Proxy(
    IMultiQI* This,
    ULONG cMQIs,
    MULTI_QI* pMQIs);
void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMultiQI_INTERFACE_DEFINED__ */

#ifndef __IMalloc_FWD_DEFINED__
#define __IMalloc_FWD_DEFINED__
typedef interface IMalloc IMalloc;
#endif

typedef IMalloc *LPMALLOC;
/*****************************************************************************
 * IMalloc interface
 */
#ifndef __IMalloc_INTERFACE_DEFINED__
#define __IMalloc_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMalloc, 0x00000002, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMalloc : public IUnknown
{
    virtual LPVOID STDMETHODCALLTYPE Alloc(
        ULONG cb) = 0;

    virtual LPVOID STDMETHODCALLTYPE Realloc(
        LPVOID pv,
        ULONG cb) = 0;

    virtual void STDMETHODCALLTYPE Free(
        LPVOID pv) = 0;

    virtual ULONG STDMETHODCALLTYPE GetSize(
        LPVOID pv) = 0;

    virtual int STDMETHODCALLTYPE DidAlloc(
        LPVOID pv) = 0;

    virtual void STDMETHODCALLTYPE HeapMinimize(
        ) = 0;

};
#else
typedef struct IMallocVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMalloc* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMalloc* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMalloc* This);

    /*** IMalloc methods ***/
    LPVOID (STDMETHODCALLTYPE *Alloc)(
        IMalloc* This,
        ULONG cb);

    LPVOID (STDMETHODCALLTYPE *Realloc)(
        IMalloc* This,
        LPVOID pv,
        ULONG cb);

    void (STDMETHODCALLTYPE *Free)(
        IMalloc* This,
        LPVOID pv);

    ULONG (STDMETHODCALLTYPE *GetSize)(
        IMalloc* This,
        LPVOID pv);

    int (STDMETHODCALLTYPE *DidAlloc)(
        IMalloc* This,
        LPVOID pv);

    void (STDMETHODCALLTYPE *HeapMinimize)(
        IMalloc* This);

    END_INTERFACE
} IMallocVtbl;
interface IMalloc {
    const IMallocVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

LPVOID CALLBACK IMalloc_Alloc_Proxy(
    IMalloc* This,
    ULONG cb);
void __RPC_STUB IMalloc_Alloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMalloc_Realloc_Proxy(
    IMalloc* This,
    LPVOID pv,
    ULONG cb);
void __RPC_STUB IMalloc_Realloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IMalloc_Free_Proxy(
    IMalloc* This,
    LPVOID pv);
void __RPC_STUB IMalloc_Free_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
ULONG CALLBACK IMalloc_GetSize_Proxy(
    IMalloc* This,
    LPVOID pv);
void __RPC_STUB IMalloc_GetSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
int CALLBACK IMalloc_DidAlloc_Proxy(
    IMalloc* This,
    LPVOID pv);
void __RPC_STUB IMalloc_DidAlloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IMalloc_HeapMinimize_Proxy(
    IMalloc* This);
void __RPC_STUB IMalloc_HeapMinimize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMalloc_INTERFACE_DEFINED__ */

#ifndef __IMallocSpy_FWD_DEFINED__
#define __IMallocSpy_FWD_DEFINED__
typedef interface IMallocSpy IMallocSpy;
#endif

typedef IMallocSpy *LPMALLOCSPY;
/*****************************************************************************
 * IMallocSpy interface
 */
#ifndef __IMallocSpy_INTERFACE_DEFINED__
#define __IMallocSpy_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMallocSpy, 0x0000001d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMallocSpy : public IUnknown
{
    virtual ULONG STDMETHODCALLTYPE PreAlloc(
        ULONG cbRequest) = 0;

    virtual LPVOID STDMETHODCALLTYPE PostAlloc(
        LPVOID pActual) = 0;

    virtual LPVOID STDMETHODCALLTYPE PreFree(
        LPVOID pRequest,
        BOOL fSpyed) = 0;

    virtual void STDMETHODCALLTYPE PostFree(
        BOOL fSpyed) = 0;

    virtual ULONG STDMETHODCALLTYPE PreRealloc(
        LPVOID pRequest,
        ULONG cbRequest,
        LPVOID* ppNewRequest,
        BOOL fSpyed) = 0;

    virtual LPVOID STDMETHODCALLTYPE PostRealloc(
        LPVOID pActual,
        BOOL fSpyed) = 0;

    virtual LPVOID STDMETHODCALLTYPE PreGetSize(
        LPVOID pRequest,
        BOOL fSpyed) = 0;

    virtual ULONG STDMETHODCALLTYPE PostGetSize(
        ULONG cbActual,
        BOOL fSpyed) = 0;

    virtual LPVOID STDMETHODCALLTYPE PreDidAlloc(
        LPVOID pRequest,
        BOOL fSpyed) = 0;

    virtual int STDMETHODCALLTYPE PostDidAlloc(
        LPVOID pRequest,
        BOOL fSpyed,
        int fActual) = 0;

    virtual void STDMETHODCALLTYPE PreHeapMinimize(
        ) = 0;

    virtual void STDMETHODCALLTYPE PostHeapMinimize(
        ) = 0;

};
#else
typedef struct IMallocSpyVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMallocSpy* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMallocSpy* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMallocSpy* This);

    /*** IMallocSpy methods ***/
    ULONG (STDMETHODCALLTYPE *PreAlloc)(
        IMallocSpy* This,
        ULONG cbRequest);

    LPVOID (STDMETHODCALLTYPE *PostAlloc)(
        IMallocSpy* This,
        LPVOID pActual);

    LPVOID (STDMETHODCALLTYPE *PreFree)(
        IMallocSpy* This,
        LPVOID pRequest,
        BOOL fSpyed);

    void (STDMETHODCALLTYPE *PostFree)(
        IMallocSpy* This,
        BOOL fSpyed);

    ULONG (STDMETHODCALLTYPE *PreRealloc)(
        IMallocSpy* This,
        LPVOID pRequest,
        ULONG cbRequest,
        LPVOID* ppNewRequest,
        BOOL fSpyed);

    LPVOID (STDMETHODCALLTYPE *PostRealloc)(
        IMallocSpy* This,
        LPVOID pActual,
        BOOL fSpyed);

    LPVOID (STDMETHODCALLTYPE *PreGetSize)(
        IMallocSpy* This,
        LPVOID pRequest,
        BOOL fSpyed);

    ULONG (STDMETHODCALLTYPE *PostGetSize)(
        IMallocSpy* This,
        ULONG cbActual,
        BOOL fSpyed);

    LPVOID (STDMETHODCALLTYPE *PreDidAlloc)(
        IMallocSpy* This,
        LPVOID pRequest,
        BOOL fSpyed);

    int (STDMETHODCALLTYPE *PostDidAlloc)(
        IMallocSpy* This,
        LPVOID pRequest,
        BOOL fSpyed,
        int fActual);

    void (STDMETHODCALLTYPE *PreHeapMinimize)(
        IMallocSpy* This);

    void (STDMETHODCALLTYPE *PostHeapMinimize)(
        IMallocSpy* This);

    END_INTERFACE
} IMallocSpyVtbl;
interface IMallocSpy {
    const IMallocSpyVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

ULONG CALLBACK IMallocSpy_PreAlloc_Proxy(
    IMallocSpy* This,
    ULONG cbRequest);
void __RPC_STUB IMallocSpy_PreAlloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PostAlloc_Proxy(
    IMallocSpy* This,
    LPVOID pActual);
void __RPC_STUB IMallocSpy_PostAlloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreFree_Proxy(
    IMallocSpy* This,
    LPVOID pRequest,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreFree_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PostFree_Proxy(
    IMallocSpy* This,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostFree_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PostRealloc_Proxy(
    IMallocSpy* This,
    LPVOID pActual,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostRealloc_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreGetSize_Proxy(
    IMallocSpy* This,
    LPVOID pRequest,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreGetSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
ULONG CALLBACK IMallocSpy_PostGetSize_Proxy(
    IMallocSpy* This,
    ULONG cbActual,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostGetSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreDidAlloc_Proxy(
    IMallocSpy* This,
    LPVOID pRequest,
    BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreDidAlloc_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PreHeapMinimize_Proxy(
    IMallocSpy* This);
void __RPC_STUB IMallocSpy_PreHeapMinimize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PostHeapMinimize_Proxy(
    IMallocSpy* This);
void __RPC_STUB IMallocSpy_PostHeapMinimize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMallocSpy_INTERFACE_DEFINED__ */

#ifndef __IInternalUnknown_FWD_DEFINED__
#define __IInternalUnknown_FWD_DEFINED__
typedef interface IInternalUnknown IInternalUnknown;
#endif

/*****************************************************************************
 * IInternalUnknown interface
 */
#ifndef __IInternalUnknown_INTERFACE_DEFINED__
#define __IInternalUnknown_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInternalUnknown, 0x00000021, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInternalUnknown : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryInternalInterface(
        REFIID riid,
        void** ppv) = 0;

};
#else
typedef struct IInternalUnknownVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IInternalUnknown* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IInternalUnknown* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IInternalUnknown* This);

    /*** IInternalUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInternalInterface)(
        IInternalUnknown* This,
        REFIID riid,
        void** ppv);

    END_INTERFACE
} IInternalUnknownVtbl;
interface IInternalUnknown {
    const IInternalUnknownVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInternalUnknown_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInternalUnknown_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInternalUnknown_Release(p) (p)->lpVtbl->Release(p)
/*** IInternalUnknown methods ***/
#define IInternalUnknown_QueryInternalInterface(p,a,b) (p)->lpVtbl->QueryInternalInterface(p,a,b)
#endif

#endif

HRESULT CALLBACK IInternalUnknown_QueryInternalInterface_Proxy(
    IInternalUnknown* This,
    REFIID riid,
    void** ppv);
void __RPC_STUB IInternalUnknown_QueryInternalInterface_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInternalUnknown_INTERFACE_DEFINED__ */

#ifndef __IEnumUnknown_FWD_DEFINED__
#define __IEnumUnknown_FWD_DEFINED__
typedef interface IEnumUnknown IEnumUnknown;
#endif

typedef IEnumUnknown *LPENUMUNKNOWN;
/*****************************************************************************
 * IEnumUnknown interface
 */
#ifndef __IEnumUnknown_INTERFACE_DEFINED__
#define __IEnumUnknown_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumUnknown, 0x00000100, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumUnknown : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        IUnknown** rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumUnknown** ppenum) = 0;

};
#else
typedef struct IEnumUnknownVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumUnknown* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumUnknown* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumUnknown* This);

    /*** IEnumUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumUnknown* This,
        ULONG celt,
        IUnknown** rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumUnknown* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumUnknown* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumUnknown* This,
        IEnumUnknown** ppenum);

    END_INTERFACE
} IEnumUnknownVtbl;
interface IEnumUnknown {
    const IEnumUnknownVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumUnknown_RemoteNext_Proxy(
    IEnumUnknown* This,
    ULONG celt,
    IUnknown** rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumUnknown_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumUnknown_Reset_Proxy(
    IEnumUnknown* This);
void __RPC_STUB IEnumUnknown_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumUnknown_Clone_Proxy(
    IEnumUnknown* This,
    IEnumUnknown** ppenum);
void __RPC_STUB IEnumUnknown_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumUnknown_INTERFACE_DEFINED__ */

#ifndef __ISurrogate_FWD_DEFINED__
#define __ISurrogate_FWD_DEFINED__
typedef interface ISurrogate ISurrogate;
#endif

typedef ISurrogate *LPSURROGATE;
/*****************************************************************************
 * ISurrogate interface
 */
#ifndef __ISurrogate_INTERFACE_DEFINED__
#define __ISurrogate_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISurrogate, 0x00000022, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISurrogate : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE LoadDllServer(
        REFCLSID Clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE FreeSurrogate(
        ) = 0;

};
#else
typedef struct ISurrogateVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISurrogate* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISurrogate* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISurrogate* This);

    /*** ISurrogate methods ***/
    HRESULT (STDMETHODCALLTYPE *LoadDllServer)(
        ISurrogate* This,
        REFCLSID Clsid);

    HRESULT (STDMETHODCALLTYPE *FreeSurrogate)(
        ISurrogate* This);

    END_INTERFACE
} ISurrogateVtbl;
interface ISurrogate {
    const ISurrogateVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK ISurrogate_LoadDllServer_Proxy(
    ISurrogate* This,
    REFCLSID Clsid);
void __RPC_STUB ISurrogate_LoadDllServer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISurrogate_FreeSurrogate_Proxy(
    ISurrogate* This);
void __RPC_STUB ISurrogate_FreeSurrogate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISurrogate_INTERFACE_DEFINED__ */

#ifndef __IGlobalInterfaceTable_FWD_DEFINED__
#define __IGlobalInterfaceTable_FWD_DEFINED__
typedef interface IGlobalInterfaceTable IGlobalInterfaceTable;
#endif

typedef IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;
/*****************************************************************************
 * IGlobalInterfaceTable interface
 */
#ifndef __IGlobalInterfaceTable_INTERFACE_DEFINED__
#define __IGlobalInterfaceTable_INTERFACE_DEFINED__

DEFINE_GUID(IID_IGlobalInterfaceTable, 0x00000146, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IGlobalInterfaceTable : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE RegisterInterfaceInGlobal(
        IUnknown* pUnk,
        REFIID riid,
        DWORD* pdwCookie) = 0;

    virtual HRESULT STDMETHODCALLTYPE RevokeInterfaceFromGlobal(
        DWORD dwCookie) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInterfaceFromGlobal(
        DWORD dwCookie,
        REFIID riid,
        void** ppv) = 0;

};
#else
typedef struct IGlobalInterfaceTableVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IGlobalInterfaceTable* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IGlobalInterfaceTable* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IGlobalInterfaceTable* This);

    /*** IGlobalInterfaceTable methods ***/
    HRESULT (STDMETHODCALLTYPE *RegisterInterfaceInGlobal)(
        IGlobalInterfaceTable* This,
        IUnknown* pUnk,
        REFIID riid,
        DWORD* pdwCookie);

    HRESULT (STDMETHODCALLTYPE *RevokeInterfaceFromGlobal)(
        IGlobalInterfaceTable* This,
        DWORD dwCookie);

    HRESULT (STDMETHODCALLTYPE *GetInterfaceFromGlobal)(
        IGlobalInterfaceTable* This,
        DWORD dwCookie,
        REFIID riid,
        void** ppv);

    END_INTERFACE
} IGlobalInterfaceTableVtbl;
interface IGlobalInterfaceTable {
    const IGlobalInterfaceTableVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IGlobalInterfaceTable_RegisterInterfaceInGlobal_Proxy(
    IGlobalInterfaceTable* This,
    IUnknown* pUnk,
    REFIID riid,
    DWORD* pdwCookie);
void __RPC_STUB IGlobalInterfaceTable_RegisterInterfaceInGlobal_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Proxy(
    IGlobalInterfaceTable* This,
    DWORD dwCookie);
void __RPC_STUB IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IGlobalInterfaceTable_INTERFACE_DEFINED__ */

#ifndef __IBindCtx_FWD_DEFINED__
#define __IBindCtx_FWD_DEFINED__
typedef interface IBindCtx IBindCtx;
#endif

typedef IBindCtx *LPBINDCTX;
typedef IBindCtx *LPBC;
typedef struct tagBIND_OPTS {
    DWORD cbStruct;
    DWORD grfFlags;
    DWORD grfMode;
    DWORD dwTickCountDeadline;
} BIND_OPTS;
typedef struct tagBIND_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;
typedef struct tagBIND_OPTS2 *LPBIND_OPTS2;
typedef enum tagBIND_FLAGS {
    BIND_MAYBOTHERUSER = 1,
    BIND_JUSTTESTEXISTENCE = 2
} BIND_FLAGS;
/*****************************************************************************
 * IBindCtx interface
 */
#ifndef __IBindCtx_INTERFACE_DEFINED__
#define __IBindCtx_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBindCtx, 0x0000000e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IBindCtx : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE RegisterObjectBound(
        IUnknown* punk) = 0;

    virtual HRESULT STDMETHODCALLTYPE RevokeObjectBound(
        IUnknown* punk) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReleaseBoundObjects(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBindOptions(
        BIND_OPTS* pbindopts) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBindOptions(
        BIND_OPTS* pbindopts) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRunningObjectTable(
        IRunningObjectTable** pprot) = 0;

    virtual HRESULT STDMETHODCALLTYPE RegisterObjectParam(
        LPOLESTR pszKey,
        IUnknown* punk) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetObjectParam(
        LPOLESTR pszKey,
        IUnknown** ppunk) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumObjectParam(
        IEnumString** ppenum) = 0;

    virtual HRESULT STDMETHODCALLTYPE RevokeObjectParam(
        LPOLESTR pszKey) = 0;

};
#else
typedef struct IBindCtxVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBindCtx* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBindCtx* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBindCtx* This);

    /*** IBindCtx methods ***/
    HRESULT (STDMETHODCALLTYPE *RegisterObjectBound)(
        IBindCtx* This,
        IUnknown* punk);

    HRESULT (STDMETHODCALLTYPE *RevokeObjectBound)(
        IBindCtx* This,
        IUnknown* punk);

    HRESULT (STDMETHODCALLTYPE *ReleaseBoundObjects)(
        IBindCtx* This);

    HRESULT (STDMETHODCALLTYPE *SetBindOptions)(
        IBindCtx* This,
        BIND_OPTS* pbindopts);

    HRESULT (STDMETHODCALLTYPE *GetBindOptions)(
        IBindCtx* This,
        BIND_OPTS* pbindopts);

    HRESULT (STDMETHODCALLTYPE *GetRunningObjectTable)(
        IBindCtx* This,
        IRunningObjectTable** pprot);

    HRESULT (STDMETHODCALLTYPE *RegisterObjectParam)(
        IBindCtx* This,
        LPOLESTR pszKey,
        IUnknown* punk);

    HRESULT (STDMETHODCALLTYPE *GetObjectParam)(
        IBindCtx* This,
        LPOLESTR pszKey,
        IUnknown** ppunk);

    HRESULT (STDMETHODCALLTYPE *EnumObjectParam)(
        IBindCtx* This,
        IEnumString** ppenum);

    HRESULT (STDMETHODCALLTYPE *RevokeObjectParam)(
        IBindCtx* This,
        LPOLESTR pszKey);

    END_INTERFACE
} IBindCtxVtbl;
interface IBindCtx {
    const IBindCtxVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IBindCtx_RegisterObjectBound_Proxy(
    IBindCtx* This,
    IUnknown* punk);
void __RPC_STUB IBindCtx_RegisterObjectBound_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RevokeObjectBound_Proxy(
    IBindCtx* This,
    IUnknown* punk);
void __RPC_STUB IBindCtx_RevokeObjectBound_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_ReleaseBoundObjects_Proxy(
    IBindCtx* This);
void __RPC_STUB IBindCtx_ReleaseBoundObjects_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RemoteSetBindOptions_Proxy(
    IBindCtx* This,
    BIND_OPTS2* pbindopts);
void __RPC_STUB IBindCtx_RemoteSetBindOptions_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RegisterObjectParam_Proxy(
    IBindCtx* This,
    LPOLESTR pszKey,
    IUnknown* punk);
void __RPC_STUB IBindCtx_RegisterObjectParam_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_GetObjectParam_Proxy(
    IBindCtx* This,
    LPOLESTR pszKey,
    IUnknown** ppunk);
void __RPC_STUB IBindCtx_GetObjectParam_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_EnumObjectParam_Proxy(
    IBindCtx* This,
    IEnumString** ppenum);
void __RPC_STUB IBindCtx_EnumObjectParam_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RevokeObjectParam_Proxy(
    IBindCtx* This,
    LPOLESTR pszKey);
void __RPC_STUB IBindCtx_RevokeObjectParam_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBindCtx_INTERFACE_DEFINED__ */

#ifndef __IEnumMoniker_FWD_DEFINED__
#define __IEnumMoniker_FWD_DEFINED__
typedef interface IEnumMoniker IEnumMoniker;
#endif

typedef IEnumMoniker *LPENUMMONIKER;
/*****************************************************************************
 * IEnumMoniker interface
 */
#ifndef __IEnumMoniker_INTERFACE_DEFINED__
#define __IEnumMoniker_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumMoniker, 0x00000102, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumMoniker : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        IMoniker** rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumMoniker** ppenum) = 0;

};
#else
typedef struct IEnumMonikerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumMoniker* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumMoniker* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumMoniker* This);

    /*** IEnumMoniker methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumMoniker* This,
        ULONG celt,
        IMoniker** rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumMoniker* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumMoniker* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumMoniker* This,
        IEnumMoniker** ppenum);

    END_INTERFACE
} IEnumMonikerVtbl;
interface IEnumMoniker {
    const IEnumMonikerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumMoniker_RemoteNext_Proxy(
    IEnumMoniker* This,
    ULONG celt,
    IMoniker** rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumMoniker_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumMoniker_Reset_Proxy(
    IEnumMoniker* This);
void __RPC_STUB IEnumMoniker_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumMoniker_Clone_Proxy(
    IEnumMoniker* This,
    IEnumMoniker** ppenum);
void __RPC_STUB IEnumMoniker_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumMoniker_INTERFACE_DEFINED__ */

#ifndef __IRunnableObject_FWD_DEFINED__
#define __IRunnableObject_FWD_DEFINED__
typedef interface IRunnableObject IRunnableObject;
#endif

typedef IRunnableObject *LPRUNNABLEOBJECT;
/*****************************************************************************
 * IRunnableObject interface
 */
#ifndef __IRunnableObject_INTERFACE_DEFINED__
#define __IRunnableObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRunnableObject, 0x00000126, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRunnableObject : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetRunningClass(
        LPCLSID lpClsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE Run(
        LPBINDCTX pbc) = 0;

    virtual BOOL STDMETHODCALLTYPE IsRunning(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockRunning(
        BOOL fLock,
        BOOL fLastUnlockCloses) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetContainedObject(
        BOOL fContained) = 0;

};
#else
typedef struct IRunnableObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRunnableObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRunnableObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRunnableObject* This);

    /*** IRunnableObject methods ***/
    HRESULT (STDMETHODCALLTYPE *GetRunningClass)(
        IRunnableObject* This,
        LPCLSID lpClsid);

    HRESULT (STDMETHODCALLTYPE *Run)(
        IRunnableObject* This,
        LPBINDCTX pbc);

    BOOL (STDMETHODCALLTYPE *IsRunning)(
        IRunnableObject* This);

    HRESULT (STDMETHODCALLTYPE *LockRunning)(
        IRunnableObject* This,
        BOOL fLock,
        BOOL fLastUnlockCloses);

    HRESULT (STDMETHODCALLTYPE *SetContainedObject)(
        IRunnableObject* This,
        BOOL fContained);

    END_INTERFACE
} IRunnableObjectVtbl;
interface IRunnableObject {
    const IRunnableObjectVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRunnableObject_GetRunningClass_Proxy(
    IRunnableObject* This,
    LPCLSID lpClsid);
void __RPC_STUB IRunnableObject_GetRunningClass_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_Run_Proxy(
    IRunnableObject* This,
    LPBINDCTX pbc);
void __RPC_STUB IRunnableObject_Run_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_RemoteIsRunning_Proxy(
    IRunnableObject* This);
void __RPC_STUB IRunnableObject_RemoteIsRunning_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_SetContainedObject_Proxy(
    IRunnableObject* This,
    BOOL fContained);
void __RPC_STUB IRunnableObject_SetContainedObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRunnableObject_INTERFACE_DEFINED__ */

#ifdef WINE_NO_UNICODE_MACROS
#undef GetObject
#endif
typedef IRunningObjectTable *LPRUNNINGOBJECTTABLE;
/*****************************************************************************
 * IRunningObjectTable interface
 */
#ifndef __IRunningObjectTable_INTERFACE_DEFINED__
#define __IRunningObjectTable_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRunningObjectTable, 0x00000010, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRunningObjectTable : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Register(
        DWORD grfFlags,
        IUnknown* punkObject,
        IMoniker* pmkObjectName,
        DWORD* pdwRegister) = 0;

    virtual HRESULT STDMETHODCALLTYPE Revoke(
        DWORD dwRegister) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsRunning(
        IMoniker* pmkObjectName) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetObject(
        IMoniker* pmkObjectName,
        IUnknown** ppunkObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE NoteChangeTime(
        DWORD dwRegister,
        FILETIME* pfiletime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTimeOfLastChange(
        IMoniker* pmkObjectName,
        FILETIME* pfiletime) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumRunning(
        IEnumMoniker** ppenumMoniker) = 0;

};
#else
typedef struct IRunningObjectTableVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRunningObjectTable* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRunningObjectTable* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRunningObjectTable* This);

    /*** IRunningObjectTable methods ***/
    HRESULT (STDMETHODCALLTYPE *Register)(
        IRunningObjectTable* This,
        DWORD grfFlags,
        IUnknown* punkObject,
        IMoniker* pmkObjectName,
        DWORD* pdwRegister);

    HRESULT (STDMETHODCALLTYPE *Revoke)(
        IRunningObjectTable* This,
        DWORD dwRegister);

    HRESULT (STDMETHODCALLTYPE *IsRunning)(
        IRunningObjectTable* This,
        IMoniker* pmkObjectName);

    HRESULT (STDMETHODCALLTYPE *GetObject)(
        IRunningObjectTable* This,
        IMoniker* pmkObjectName,
        IUnknown** ppunkObject);

    HRESULT (STDMETHODCALLTYPE *NoteChangeTime)(
        IRunningObjectTable* This,
        DWORD dwRegister,
        FILETIME* pfiletime);

    HRESULT (STDMETHODCALLTYPE *GetTimeOfLastChange)(
        IRunningObjectTable* This,
        IMoniker* pmkObjectName,
        FILETIME* pfiletime);

    HRESULT (STDMETHODCALLTYPE *EnumRunning)(
        IRunningObjectTable* This,
        IEnumMoniker** ppenumMoniker);

    END_INTERFACE
} IRunningObjectTableVtbl;
interface IRunningObjectTable {
    const IRunningObjectTableVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRunningObjectTable_Register_Proxy(
    IRunningObjectTable* This,
    DWORD grfFlags,
    IUnknown* punkObject,
    IMoniker* pmkObjectName,
    DWORD* pdwRegister);
void __RPC_STUB IRunningObjectTable_Register_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_Revoke_Proxy(
    IRunningObjectTable* This,
    DWORD dwRegister);
void __RPC_STUB IRunningObjectTable_Revoke_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_IsRunning_Proxy(
    IRunningObjectTable* This,
    IMoniker* pmkObjectName);
void __RPC_STUB IRunningObjectTable_IsRunning_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_GetObject_Proxy(
    IRunningObjectTable* This,
    IMoniker* pmkObjectName,
    IUnknown** ppunkObject);
void __RPC_STUB IRunningObjectTable_GetObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_NoteChangeTime_Proxy(
    IRunningObjectTable* This,
    DWORD dwRegister,
    FILETIME* pfiletime);
void __RPC_STUB IRunningObjectTable_NoteChangeTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_GetTimeOfLastChange_Proxy(
    IRunningObjectTable* This,
    IMoniker* pmkObjectName,
    FILETIME* pfiletime);
void __RPC_STUB IRunningObjectTable_GetTimeOfLastChange_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_EnumRunning_Proxy(
    IRunningObjectTable* This,
    IEnumMoniker** ppenumMoniker);
void __RPC_STUB IRunningObjectTable_EnumRunning_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRunningObjectTable_INTERFACE_DEFINED__ */

#ifndef __IPersist_FWD_DEFINED__
#define __IPersist_FWD_DEFINED__
typedef interface IPersist IPersist;
#endif

typedef IPersist *LPPERSIST;
/*****************************************************************************
 * IPersist interface
 */
#ifndef __IPersist_INTERFACE_DEFINED__
#define __IPersist_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPersist, 0x0000010c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPersist : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetClassID(
        CLSID* pClassID) = 0;

};
#else
typedef struct IPersistVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPersist* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPersist* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPersist* This);

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IPersist* This,
        CLSID* pClassID);

    END_INTERFACE
} IPersistVtbl;
interface IPersist {
    const IPersistVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPersist_GetClassID_Proxy(
    IPersist* This,
    CLSID* pClassID);
void __RPC_STUB IPersist_GetClassID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersist_INTERFACE_DEFINED__ */

#ifndef __IPersistStream_FWD_DEFINED__
#define __IPersistStream_FWD_DEFINED__
typedef interface IPersistStream IPersistStream;
#endif

typedef IPersistStream *LPPERSISTSTREAM;
/*****************************************************************************
 * IPersistStream interface
 */
#ifndef __IPersistStream_INTERFACE_DEFINED__
#define __IPersistStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPersistStream, 0x00000109, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPersistStream : public IPersist
{
    virtual HRESULT STDMETHODCALLTYPE IsDirty(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Load(
        IStream* pStm) = 0;

    virtual HRESULT STDMETHODCALLTYPE Save(
        IStream* pStm,
        BOOL fClearDirty) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSizeMax(
        ULARGE_INTEGER* pcbSize) = 0;

};
#else
typedef struct IPersistStreamVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPersistStream* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPersistStream* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPersistStream* This);

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IPersistStream* This,
        CLSID* pClassID);

    /*** IPersistStream methods ***/
    HRESULT (STDMETHODCALLTYPE *IsDirty)(
        IPersistStream* This);

    HRESULT (STDMETHODCALLTYPE *Load)(
        IPersistStream* This,
        IStream* pStm);

    HRESULT (STDMETHODCALLTYPE *Save)(
        IPersistStream* This,
        IStream* pStm,
        BOOL fClearDirty);

    HRESULT (STDMETHODCALLTYPE *GetSizeMax)(
        IPersistStream* This,
        ULARGE_INTEGER* pcbSize);

    END_INTERFACE
} IPersistStreamVtbl;
interface IPersistStream {
    const IPersistStreamVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPersistStream_IsDirty_Proxy(
    IPersistStream* This);
void __RPC_STUB IPersistStream_IsDirty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_Load_Proxy(
    IPersistStream* This,
    IStream* pStm);
void __RPC_STUB IPersistStream_Load_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_Save_Proxy(
    IPersistStream* This,
    IStream* pStm,
    BOOL fClearDirty);
void __RPC_STUB IPersistStream_Save_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_GetSizeMax_Proxy(
    IPersistStream* This,
    ULARGE_INTEGER* pcbSize);
void __RPC_STUB IPersistStream_GetSizeMax_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersistStream_INTERFACE_DEFINED__ */

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
 */
#ifndef __IMoniker_INTERFACE_DEFINED__
#define __IMoniker_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMoniker, 0x0000000f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMoniker : public IPersistStream
{
    virtual HRESULT STDMETHODCALLTYPE BindToObject(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        REFIID riidResult,
        void** ppvResult) = 0;

    virtual HRESULT STDMETHODCALLTYPE BindToStorage(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        REFIID riid,
        void** ppvObj) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reduce(
        IBindCtx* pbc,
        DWORD dwReduceHowFar,
        IMoniker** ppmkToLeft,
        IMoniker** ppmkReduced) = 0;

    virtual HRESULT STDMETHODCALLTYPE ComposeWith(
        IMoniker* pmkRight,
        BOOL fOnlyIfNotGeneric,
        IMoniker** ppmkComposite) = 0;

    virtual HRESULT STDMETHODCALLTYPE Enum(
        BOOL fForward,
        IEnumMoniker** ppenumMoniker) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsEqual(
        IMoniker* pmkOtherMoniker) = 0;

    virtual HRESULT STDMETHODCALLTYPE Hash(
        DWORD* pdwHash) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsRunning(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        IMoniker* pmkNewlyRunning) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTimeOfLastChange(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        FILETIME* pFileTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE Inverse(
        IMoniker** ppmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE CommonPrefixWith(
        IMoniker* pmkOther,
        IMoniker** ppmkPrefix) = 0;

    virtual HRESULT STDMETHODCALLTYPE RelativePathTo(
        IMoniker* pmkOther,
        IMoniker** ppmkRelPath) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDisplayName(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        LPOLESTR* ppszDisplayName) = 0;

    virtual HRESULT STDMETHODCALLTYPE ParseDisplayName(
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsSystemMoniker(
        DWORD* pdwMksys) = 0;

};
#else
typedef struct IMonikerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMoniker* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMoniker* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMoniker* This);

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IMoniker* This,
        CLSID* pClassID);

    /*** IPersistStream methods ***/
    HRESULT (STDMETHODCALLTYPE *IsDirty)(
        IMoniker* This);

    HRESULT (STDMETHODCALLTYPE *Load)(
        IMoniker* This,
        IStream* pStm);

    HRESULT (STDMETHODCALLTYPE *Save)(
        IMoniker* This,
        IStream* pStm,
        BOOL fClearDirty);

    HRESULT (STDMETHODCALLTYPE *GetSizeMax)(
        IMoniker* This,
        ULARGE_INTEGER* pcbSize);

    /*** IMoniker methods ***/
    HRESULT (STDMETHODCALLTYPE *BindToObject)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        REFIID riidResult,
        void** ppvResult);

    HRESULT (STDMETHODCALLTYPE *BindToStorage)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        REFIID riid,
        void** ppvObj);

    HRESULT (STDMETHODCALLTYPE *Reduce)(
        IMoniker* This,
        IBindCtx* pbc,
        DWORD dwReduceHowFar,
        IMoniker** ppmkToLeft,
        IMoniker** ppmkReduced);

    HRESULT (STDMETHODCALLTYPE *ComposeWith)(
        IMoniker* This,
        IMoniker* pmkRight,
        BOOL fOnlyIfNotGeneric,
        IMoniker** ppmkComposite);

    HRESULT (STDMETHODCALLTYPE *Enum)(
        IMoniker* This,
        BOOL fForward,
        IEnumMoniker** ppenumMoniker);

    HRESULT (STDMETHODCALLTYPE *IsEqual)(
        IMoniker* This,
        IMoniker* pmkOtherMoniker);

    HRESULT (STDMETHODCALLTYPE *Hash)(
        IMoniker* This,
        DWORD* pdwHash);

    HRESULT (STDMETHODCALLTYPE *IsRunning)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        IMoniker* pmkNewlyRunning);

    HRESULT (STDMETHODCALLTYPE *GetTimeOfLastChange)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        FILETIME* pFileTime);

    HRESULT (STDMETHODCALLTYPE *Inverse)(
        IMoniker* This,
        IMoniker** ppmk);

    HRESULT (STDMETHODCALLTYPE *CommonPrefixWith)(
        IMoniker* This,
        IMoniker* pmkOther,
        IMoniker** ppmkPrefix);

    HRESULT (STDMETHODCALLTYPE *RelativePathTo)(
        IMoniker* This,
        IMoniker* pmkOther,
        IMoniker** ppmkRelPath);

    HRESULT (STDMETHODCALLTYPE *GetDisplayName)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        LPOLESTR* ppszDisplayName);

    HRESULT (STDMETHODCALLTYPE *ParseDisplayName)(
        IMoniker* This,
        IBindCtx* pbc,
        IMoniker* pmkToLeft,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut);

    HRESULT (STDMETHODCALLTYPE *IsSystemMoniker)(
        IMoniker* This,
        DWORD* pdwMksys);

    END_INTERFACE
} IMonikerVtbl;
interface IMoniker {
    const IMonikerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IMoniker_RemoteBindToObject_Proxy(
    IMoniker* This,
    IBindCtx* pbc,
    IMoniker* pmkToLeft,
    REFIID riidResult,
    IUnknown** ppvResult);
void __RPC_STUB IMoniker_RemoteBindToObject_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Enum_Proxy(
    IMoniker* This,
    BOOL fForward,
    IEnumMoniker** ppenumMoniker);
void __RPC_STUB IMoniker_Enum_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_IsEqual_Proxy(
    IMoniker* This,
    IMoniker* pmkOtherMoniker);
void __RPC_STUB IMoniker_IsEqual_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Hash_Proxy(
    IMoniker* This,
    DWORD* pdwHash);
void __RPC_STUB IMoniker_Hash_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Inverse_Proxy(
    IMoniker* This,
    IMoniker** ppmk);
void __RPC_STUB IMoniker_Inverse_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_CommonPrefixWith_Proxy(
    IMoniker* This,
    IMoniker* pmkOther,
    IMoniker** ppmkPrefix);
void __RPC_STUB IMoniker_CommonPrefixWith_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_RelativePathTo_Proxy(
    IMoniker* This,
    IMoniker* pmkOther,
    IMoniker** ppmkRelPath);
void __RPC_STUB IMoniker_RelativePathTo_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_IsSystemMoniker_Proxy(
    IMoniker* This,
    DWORD* pdwMksys);
void __RPC_STUB IMoniker_IsSystemMoniker_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMoniker_INTERFACE_DEFINED__ */

#ifndef __IROTData_FWD_DEFINED__
#define __IROTData_FWD_DEFINED__
typedef interface IROTData IROTData;
#endif

/*****************************************************************************
 * IROTData interface
 */
#ifndef __IROTData_INTERFACE_DEFINED__
#define __IROTData_INTERFACE_DEFINED__

DEFINE_GUID(IID_IROTData, 0xf29f6bc0, 0x5021, 0x11ce, 0xaa,0x15, 0x00,0x00,0x69,0x01,0x29,0x3f);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IROTData : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetComparisonData(
        byte* pbData,
        ULONG cbMax,
        ULONG* pcbData) = 0;

};
#else
typedef struct IROTDataVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IROTData* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IROTData* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IROTData* This);

    /*** IROTData methods ***/
    HRESULT (STDMETHODCALLTYPE *GetComparisonData)(
        IROTData* This,
        byte* pbData,
        ULONG cbMax,
        ULONG* pcbData);

    END_INTERFACE
} IROTDataVtbl;
interface IROTData {
    const IROTDataVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IROTData_GetComparisonData_Proxy(
    IROTData* This,
    byte* pbData,
    ULONG cbMax,
    ULONG* pcbData);
void __RPC_STUB IROTData_GetComparisonData_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IROTData_INTERFACE_DEFINED__ */

typedef IEnumString *LPENUMSTRING;
/*****************************************************************************
 * IEnumString interface
 */
#ifndef __IEnumString_INTERFACE_DEFINED__
#define __IEnumString_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumString, 0x00000101, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumString : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        LPOLESTR* rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumString** ppenum) = 0;

};
#else
typedef struct IEnumStringVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumString* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumString* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumString* This);

    /*** IEnumString methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumString* This,
        ULONG celt,
        LPOLESTR* rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumString* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumString* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumString* This,
        IEnumString** ppenum);

    END_INTERFACE
} IEnumStringVtbl;
interface IEnumString {
    const IEnumStringVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumString_RemoteNext_Proxy(
    IEnumString* This,
    ULONG celt,
    LPOLESTR* rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumString_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumString_Reset_Proxy(
    IEnumString* This);
void __RPC_STUB IEnumString_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumString_Clone_Proxy(
    IEnumString* This,
    IEnumString** ppenum);
void __RPC_STUB IEnumString_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumString_INTERFACE_DEFINED__ */

#ifndef __IClassActivator_FWD_DEFINED__
#define __IClassActivator_FWD_DEFINED__
typedef interface IClassActivator IClassActivator;
#endif

/*****************************************************************************
 * IClassActivator interface
 */
#ifndef __IClassActivator_INTERFACE_DEFINED__
#define __IClassActivator_INTERFACE_DEFINED__

DEFINE_GUID(IID_IClassActivator, 0x00000140, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IClassActivator : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetClassObject(
        REFCLSID rclsid,
        DWORD dwClassContext,
        LCID locale,
        REFIID riid,
        void** ppv) = 0;

};
#else
typedef struct IClassActivatorVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IClassActivator* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IClassActivator* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IClassActivator* This);

    /*** IClassActivator methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassObject)(
        IClassActivator* This,
        REFCLSID rclsid,
        DWORD dwClassContext,
        LCID locale,
        REFIID riid,
        void** ppv);

    END_INTERFACE
} IClassActivatorVtbl;
interface IClassActivator {
    const IClassActivatorVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IClassActivator_GetClassObject_Proxy(
    IClassActivator* This,
    REFCLSID rclsid,
    DWORD dwClassContext,
    LCID locale,
    REFIID riid,
    void** ppv);
void __RPC_STUB IClassActivator_GetClassObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IClassActivator_INTERFACE_DEFINED__ */

#ifndef __ISequentialStream_FWD_DEFINED__
#define __ISequentialStream_FWD_DEFINED__
typedef interface ISequentialStream ISequentialStream;
#endif

/*****************************************************************************
 * ISequentialStream interface
 */
#ifndef __ISequentialStream_INTERFACE_DEFINED__
#define __ISequentialStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISequentialStream, 0x0c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISequentialStream : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Read(
        void* pv,
        ULONG cb,
        ULONG* pcbRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE Write(
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten) = 0;

};
#else
typedef struct ISequentialStreamVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISequentialStream* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISequentialStream* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISequentialStream* This);

    /*** ISequentialStream methods ***/
    HRESULT (STDMETHODCALLTYPE *Read)(
        ISequentialStream* This,
        void* pv,
        ULONG cb,
        ULONG* pcbRead);

    HRESULT (STDMETHODCALLTYPE *Write)(
        ISequentialStream* This,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten);

    END_INTERFACE
} ISequentialStreamVtbl;
interface ISequentialStream {
    const ISequentialStreamVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK ISequentialStream_RemoteRead_Proxy(
    ISequentialStream* This,
    byte* pv,
    ULONG cb,
    ULONG* pcbRead);
void __RPC_STUB ISequentialStream_RemoteRead_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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);

#endif  /* __ISequentialStream_INTERFACE_DEFINED__ */

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
 */
#ifndef __IStream_INTERFACE_DEFINED__
#define __IStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IStream, 0x0000000c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IStream : public ISequentialStream
{
    virtual HRESULT STDMETHODCALLTYPE Seek(
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER* plibNewPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSize(
        ULARGE_INTEGER libNewSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyTo(
        IStream* pstm,
        ULARGE_INTEGER cb,
        ULARGE_INTEGER* pcbRead,
        ULARGE_INTEGER* pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE Commit(
        DWORD grfCommitFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE Revert(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnlockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stat(
        STATSTG* pstatstg,
        DWORD grfStatFlag) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IStream** ppstm) = 0;

};
#else
typedef struct IStreamVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IStream* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IStream* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IStream* This);

    /*** ISequentialStream methods ***/
    HRESULT (STDMETHODCALLTYPE *Read)(
        IStream* This,
        void* pv,
        ULONG cb,
        ULONG* pcbRead);

    HRESULT (STDMETHODCALLTYPE *Write)(
        IStream* This,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten);

    /*** IStream methods ***/
    HRESULT (STDMETHODCALLTYPE *Seek)(
        IStream* This,
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER* plibNewPosition);

    HRESULT (STDMETHODCALLTYPE *SetSize)(
        IStream* This,
        ULARGE_INTEGER libNewSize);

    HRESULT (STDMETHODCALLTYPE *CopyTo)(
        IStream* This,
        IStream* pstm,
        ULARGE_INTEGER cb,
        ULARGE_INTEGER* pcbRead,
        ULARGE_INTEGER* pcbWritten);

    HRESULT (STDMETHODCALLTYPE *Commit)(
        IStream* This,
        DWORD grfCommitFlags);

    HRESULT (STDMETHODCALLTYPE *Revert)(
        IStream* This);

    HRESULT (STDMETHODCALLTYPE *LockRegion)(
        IStream* This,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType);

    HRESULT (STDMETHODCALLTYPE *UnlockRegion)(
        IStream* This,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType);

    HRESULT (STDMETHODCALLTYPE *Stat)(
        IStream* This,
        STATSTG* pstatstg,
        DWORD grfStatFlag);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IStream* This,
        IStream** ppstm);

    END_INTERFACE
} IStreamVtbl;
interface IStream {
    const IStreamVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IStream_RemoteSeek_Proxy(
    IStream* This,
    LARGE_INTEGER dlibMove,
    DWORD dwOrigin,
    ULARGE_INTEGER* plibNewPosition);
void __RPC_STUB IStream_RemoteSeek_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Revert_Proxy(
    IStream* This);
void __RPC_STUB IStream_Revert_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Stat_Proxy(
    IStream* This,
    STATSTG* pstatstg,
    DWORD grfStatFlag);
void __RPC_STUB IStream_Stat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Clone_Proxy(
    IStream* This,
    IStream** ppstm);
void __RPC_STUB IStream_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IStream_INTERFACE_DEFINED__ */

#ifndef __IEnumSTATSTG_FWD_DEFINED__
#define __IEnumSTATSTG_FWD_DEFINED__
typedef interface IEnumSTATSTG IEnumSTATSTG;
#endif

typedef IEnumSTATSTG *LPENUMSTATSTG;
/*****************************************************************************
 * IEnumSTATSTG interface
 */
#ifndef __IEnumSTATSTG_INTERFACE_DEFINED__
#define __IEnumSTATSTG_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumSTATSTG, 0x0000000d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumSTATSTG : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        STATSTG* rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumSTATSTG** ppenum) = 0;

};
#else
typedef struct IEnumSTATSTGVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumSTATSTG* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumSTATSTG* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumSTATSTG* This);

    /*** IEnumSTATSTG methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumSTATSTG* This,
        ULONG celt,
        STATSTG* rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumSTATSTG* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumSTATSTG* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumSTATSTG* This,
        IEnumSTATSTG** ppenum);

    END_INTERFACE
} IEnumSTATSTGVtbl;
interface IEnumSTATSTG {
    const IEnumSTATSTGVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumSTATSTG_RemoteNext_Proxy(
    IEnumSTATSTG* This,
    ULONG celt,
    STATSTG* rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumSTATSTG_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATSTG_Reset_Proxy(
    IEnumSTATSTG* This);
void __RPC_STUB IEnumSTATSTG_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATSTG_Clone_Proxy(
    IEnumSTATSTG* This,
    IEnumSTATSTG** ppenum);
void __RPC_STUB IEnumSTATSTG_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumSTATSTG_INTERFACE_DEFINED__ */

#ifndef __IStorage_FWD_DEFINED__
#define __IStorage_FWD_DEFINED__
typedef interface IStorage IStorage;
#endif

typedef IStorage *LPSTORAGE;
typedef struct tagRemSNB {
    unsigned long ulCntStr;
    unsigned long ulCntChar;
    OLECHAR rgString[1];
} RemSNB;
typedef RemSNB *wireSNB;
typedef OLECHAR **SNB;
/*****************************************************************************
 * IStorage interface
 */
#ifndef __IStorage_INTERFACE_DEFINED__
#define __IStorage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IStorage, 0x0000000b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IStorage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateStream(
        LPCOLESTR pwcsName,
        DWORD grfMode,
        DWORD reserved1,
        DWORD reserved2,
        IStream** ppstm) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenStream(
        LPCOLESTR pwcsName,
        void* reserved1,
        DWORD grfMode,
        DWORD reserved2,
        IStream** ppstm) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateStorage(
        LPCOLESTR pwcsName,
        DWORD grfMode,
        DWORD dwStgFmt,
        DWORD reserved2,
        IStorage** ppstg) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenStorage(
        LPCOLESTR pwcsName,
        IStorage* pstgPriority,
        DWORD grfMode,
        SNB snbExclude,
        DWORD reserved,
        IStorage** ppstg) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyTo(
        DWORD ciidExclude,
        const IID* rgiidExclude,
        SNB snbExclude,
        IStorage* pstgDest) = 0;

    virtual HRESULT STDMETHODCALLTYPE MoveElementTo(
        LPCOLESTR pwcsName,
        IStorage* pstgDest,
        LPCOLESTR pwcsNewName,
        DWORD grfFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE Commit(
        DWORD grfCommitFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE Revert(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumElements(
        DWORD reserved1,
        void* reserved2,
        DWORD reserved3,
        IEnumSTATSTG** ppenum) = 0;

    virtual HRESULT STDMETHODCALLTYPE DestroyElement(
        LPCOLESTR pwcsName) = 0;

    virtual HRESULT STDMETHODCALLTYPE RenameElement(
        LPCOLESTR pwcsOldName,
        LPCOLESTR pwcsNewName) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetElementTimes(
        LPCOLESTR pwcsName,
        const FILETIME* pctime,
        const FILETIME* patime,
        const FILETIME* pmtime) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetClass(
        REFCLSID clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStateBits(
        DWORD grfStateBits,
        DWORD grfMask) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stat(
        STATSTG* pstatstg,
        DWORD grfStatFlag) = 0;

};
#else
typedef struct IStorageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IStorage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IStorage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IStorage* This);

    /*** IStorage methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateStream)(
        IStorage* This,
        LPCOLESTR pwcsName,
        DWORD grfMode,
        DWORD reserved1,
        DWORD reserved2,
        IStream** ppstm);

    HRESULT (STDMETHODCALLTYPE *OpenStream)(
        IStorage* This,
        LPCOLESTR pwcsName,
        void* reserved1,
        DWORD grfMode,
        DWORD reserved2,
        IStream** ppstm);

    HRESULT (STDMETHODCALLTYPE *CreateStorage)(
        IStorage* This,
        LPCOLESTR pwcsName,
        DWORD grfMode,
        DWORD dwStgFmt,
        DWORD reserved2,
        IStorage** ppstg);

    HRESULT (STDMETHODCALLTYPE *OpenStorage)(
        IStorage* This,
        LPCOLESTR pwcsName,
        IStorage* pstgPriority,
        DWORD grfMode,
        SNB snbExclude,
        DWORD reserved,
        IStorage** ppstg);

    HRESULT (STDMETHODCALLTYPE *CopyTo)(
        IStorage* This,
        DWORD ciidExclude,
        const IID* rgiidExclude,
        SNB snbExclude,
        IStorage* pstgDest);

    HRESULT (STDMETHODCALLTYPE *MoveElementTo)(
        IStorage* This,
        LPCOLESTR pwcsName,
        IStorage* pstgDest,
        LPCOLESTR pwcsNewName,
        DWORD grfFlags);

    HRESULT (STDMETHODCALLTYPE *Commit)(
        IStorage* This,
        DWORD grfCommitFlags);

    HRESULT (STDMETHODCALLTYPE *Revert)(
        IStorage* This);

    HRESULT (STDMETHODCALLTYPE *EnumElements)(
        IStorage* This,
        DWORD reserved1,
        void* reserved2,
        DWORD reserved3,
        IEnumSTATSTG** ppenum);

    HRESULT (STDMETHODCALLTYPE *DestroyElement)(
        IStorage* This,
        LPCOLESTR pwcsName);

    HRESULT (STDMETHODCALLTYPE *RenameElement)(
        IStorage* This,
        LPCOLESTR pwcsOldName,
        LPCOLESTR pwcsNewName);

    HRESULT (STDMETHODCALLTYPE *SetElementTimes)(
        IStorage* This,
        LPCOLESTR pwcsName,
        const FILETIME* pctime,
        const FILETIME* patime,
        const FILETIME* pmtime);

    HRESULT (STDMETHODCALLTYPE *SetClass)(
        IStorage* This,
        REFCLSID clsid);

    HRESULT (STDMETHODCALLTYPE *SetStateBits)(
        IStorage* This,
        DWORD grfStateBits,
        DWORD grfMask);

    HRESULT (STDMETHODCALLTYPE *Stat)(
        IStorage* This,
        STATSTG* pstatstg,
        DWORD grfStatFlag);

    END_INTERFACE
} IStorageVtbl;
interface IStorage {
    const IStorageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IStorage_CreateStream_Proxy(
    IStorage* This,
    LPCOLESTR pwcsName,
    DWORD grfMode,
    DWORD reserved1,
    DWORD reserved2,
    IStream** ppstm);
void __RPC_STUB IStorage_CreateStream_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Commit_Proxy(
    IStorage* This,
    DWORD grfCommitFlags);
void __RPC_STUB IStorage_Commit_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Revert_Proxy(
    IStorage* This);
void __RPC_STUB IStorage_Revert_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_RenameElement_Proxy(
    IStorage* This,
    LPCOLESTR pwcsOldName,
    LPCOLESTR pwcsNewName);
void __RPC_STUB IStorage_RenameElement_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_SetClass_Proxy(
    IStorage* This,
    REFCLSID clsid);
void __RPC_STUB IStorage_SetClass_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_SetStateBits_Proxy(
    IStorage* This,
    DWORD grfStateBits,
    DWORD grfMask);
void __RPC_STUB IStorage_SetStateBits_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Stat_Proxy(
    IStorage* This,
    STATSTG* pstatstg,
    DWORD grfStatFlag);
void __RPC_STUB IStorage_Stat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IStorage_INTERFACE_DEFINED__ */

#ifndef __IPersistFile_FWD_DEFINED__
#define __IPersistFile_FWD_DEFINED__
typedef interface IPersistFile IPersistFile;
#endif

typedef IPersistFile *LPPERSISTFILE;
/*****************************************************************************
 * IPersistFile interface
 */
#ifndef __IPersistFile_INTERFACE_DEFINED__
#define __IPersistFile_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPersistFile, 0x0000010b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPersistFile : public IPersist
{
    virtual HRESULT STDMETHODCALLTYPE IsDirty(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Load(
        LPCOLESTR pszFileName,
        DWORD dwMode) = 0;

    virtual HRESULT STDMETHODCALLTYPE Save(
        LPCOLESTR pszFileName,
        BOOL fRemember) = 0;

    virtual HRESULT STDMETHODCALLTYPE SaveCompleted(
        LPCOLESTR pszFileName) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurFile(
        LPOLESTR* ppszFileName) = 0;

};
#else
typedef struct IPersistFileVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPersistFile* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPersistFile* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPersistFile* This);

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IPersistFile* This,
        CLSID* pClassID);

    /*** IPersistFile methods ***/
    HRESULT (STDMETHODCALLTYPE *IsDirty)(
        IPersistFile* This);

    HRESULT (STDMETHODCALLTYPE *Load)(
        IPersistFile* This,
        LPCOLESTR pszFileName,
        DWORD dwMode);

    HRESULT (STDMETHODCALLTYPE *Save)(
        IPersistFile* This,
        LPCOLESTR pszFileName,
        BOOL fRemember);

    HRESULT (STDMETHODCALLTYPE *SaveCompleted)(
        IPersistFile* This,
        LPCOLESTR pszFileName);

    HRESULT (STDMETHODCALLTYPE *GetCurFile)(
        IPersistFile* This,
        LPOLESTR* ppszFileName);

    END_INTERFACE
} IPersistFileVtbl;
interface IPersistFile {
    const IPersistFileVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPersistFile_IsDirty_Proxy(
    IPersistFile* This);
void __RPC_STUB IPersistFile_IsDirty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_Load_Proxy(
    IPersistFile* This,
    LPCOLESTR pszFileName,
    DWORD dwMode);
void __RPC_STUB IPersistFile_Load_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_Save_Proxy(
    IPersistFile* This,
    LPCOLESTR pszFileName,
    BOOL fRemember);
void __RPC_STUB IPersistFile_Save_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_SaveCompleted_Proxy(
    IPersistFile* This,
    LPCOLESTR pszFileName);
void __RPC_STUB IPersistFile_SaveCompleted_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_GetCurFile_Proxy(
    IPersistFile* This,
    LPOLESTR* ppszFileName);
void __RPC_STUB IPersistFile_GetCurFile_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersistFile_INTERFACE_DEFINED__ */

#ifndef __IPersistStorage_FWD_DEFINED__
#define __IPersistStorage_FWD_DEFINED__
typedef interface IPersistStorage IPersistStorage;
#endif

typedef IPersistStorage *LPPERSISTSTORAGE;
/*****************************************************************************
 * IPersistStorage interface
 */
#ifndef __IPersistStorage_INTERFACE_DEFINED__
#define __IPersistStorage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPersistStorage, 0x0000010a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPersistStorage : public IPersist
{
    virtual HRESULT STDMETHODCALLTYPE IsDirty(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE InitNew(
        IStorage* pStg) = 0;

    virtual HRESULT STDMETHODCALLTYPE Load(
        IStorage* pStg) = 0;

    virtual HRESULT STDMETHODCALLTYPE Save(
        IStorage* pStgSave,
        BOOL fSameAsLoad) = 0;

    virtual HRESULT STDMETHODCALLTYPE SaveCompleted(
        IStorage* pStgNew) = 0;

    virtual HRESULT STDMETHODCALLTYPE HandsOffStorage(
        ) = 0;

};
#else
typedef struct IPersistStorageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPersistStorage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPersistStorage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPersistStorage* This);

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IPersistStorage* This,
        CLSID* pClassID);

    /*** IPersistStorage methods ***/
    HRESULT (STDMETHODCALLTYPE *IsDirty)(
        IPersistStorage* This);

    HRESULT (STDMETHODCALLTYPE *InitNew)(
        IPersistStorage* This,
        IStorage* pStg);

    HRESULT (STDMETHODCALLTYPE *Load)(
        IPersistStorage* This,
        IStorage* pStg);

    HRESULT (STDMETHODCALLTYPE *Save)(
        IPersistStorage* This,
        IStorage* pStgSave,
        BOOL fSameAsLoad);

    HRESULT (STDMETHODCALLTYPE *SaveCompleted)(
        IPersistStorage* This,
        IStorage* pStgNew);

    HRESULT (STDMETHODCALLTYPE *HandsOffStorage)(
        IPersistStorage* This);

    END_INTERFACE
} IPersistStorageVtbl;
interface IPersistStorage {
    const IPersistStorageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPersistStorage_IsDirty_Proxy(
    IPersistStorage* This);
void __RPC_STUB IPersistStorage_IsDirty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_InitNew_Proxy(
    IPersistStorage* This,
    IStorage* pStg);
void __RPC_STUB IPersistStorage_InitNew_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_Load_Proxy(
    IPersistStorage* This,
    IStorage* pStg);
void __RPC_STUB IPersistStorage_Load_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_Save_Proxy(
    IPersistStorage* This,
    IStorage* pStgSave,
    BOOL fSameAsLoad);
void __RPC_STUB IPersistStorage_Save_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_SaveCompleted_Proxy(
    IPersistStorage* This,
    IStorage* pStgNew);
void __RPC_STUB IPersistStorage_SaveCompleted_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_HandsOffStorage_Proxy(
    IPersistStorage* This);
void __RPC_STUB IPersistStorage_HandsOffStorage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPersistStorage_INTERFACE_DEFINED__ */

#ifndef __IRootStorage_FWD_DEFINED__
#define __IRootStorage_FWD_DEFINED__
typedef interface IRootStorage IRootStorage;
#endif

typedef IRootStorage *LPROOTSTORAGE;
/*****************************************************************************
 * IRootStorage interface
 */
#ifndef __IRootStorage_INTERFACE_DEFINED__
#define __IRootStorage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRootStorage, 0x00000012, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRootStorage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SwitchToFile(
        LPOLESTR pszFile) = 0;

};
#else
typedef struct IRootStorageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRootStorage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRootStorage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRootStorage* This);

    /*** IRootStorage methods ***/
    HRESULT (STDMETHODCALLTYPE *SwitchToFile)(
        IRootStorage* This,
        LPOLESTR pszFile);

    END_INTERFACE
} IRootStorageVtbl;
interface IRootStorage {
    const IRootStorageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRootStorage_SwitchToFile_Proxy(
    IRootStorage* This,
    LPOLESTR pszFile);
void __RPC_STUB IRootStorage_SwitchToFile_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRootStorage_INTERFACE_DEFINED__ */

#ifndef __ILockBytes_FWD_DEFINED__
#define __ILockBytes_FWD_DEFINED__
typedef interface ILockBytes ILockBytes;
#endif

typedef ILockBytes *LPLOCKBYTES;
/*****************************************************************************
 * ILockBytes interface
 */
#ifndef __ILockBytes_INTERFACE_DEFINED__
#define __ILockBytes_INTERFACE_DEFINED__

DEFINE_GUID(IID_ILockBytes, 0x0000000a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ILockBytes : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ReadAt(
        ULARGE_INTEGER ulOffset,
        void* pv,
        ULONG cb,
        ULONG* pcbRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE WriteAt(
        ULARGE_INTEGER ulOffset,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE Flush(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSize(
        ULARGE_INTEGER cb) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnlockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stat(
        STATSTG* pstatstg,
        DWORD grfStatFlag) = 0;

};
#else
typedef struct ILockBytesVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ILockBytes* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ILockBytes* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ILockBytes* This);

    /*** ILockBytes methods ***/
    HRESULT (STDMETHODCALLTYPE *ReadAt)(
        ILockBytes* This,
        ULARGE_INTEGER ulOffset,
        void* pv,
        ULONG cb,
        ULONG* pcbRead);

    HRESULT (STDMETHODCALLTYPE *WriteAt)(
        ILockBytes* This,
        ULARGE_INTEGER ulOffset,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten);

    HRESULT (STDMETHODCALLTYPE *Flush)(
        ILockBytes* This);

    HRESULT (STDMETHODCALLTYPE *SetSize)(
        ILockBytes* This,
        ULARGE_INTEGER cb);

    HRESULT (STDMETHODCALLTYPE *LockRegion)(
        ILockBytes* This,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType);

    HRESULT (STDMETHODCALLTYPE *UnlockRegion)(
        ILockBytes* This,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType);

    HRESULT (STDMETHODCALLTYPE *Stat)(
        ILockBytes* This,
        STATSTG* pstatstg,
        DWORD grfStatFlag);

    END_INTERFACE
} ILockBytesVtbl;
interface ILockBytes {
    const ILockBytesVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK ILockBytes_RemoteReadAt_Proxy(
    ILockBytes* This,
    ULARGE_INTEGER ulOffset,
    byte* pv,
    ULONG cb,
    ULONG* pcbRead);
void __RPC_STUB ILockBytes_RemoteReadAt_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_SetSize_Proxy(
    ILockBytes* This,
    ULARGE_INTEGER cb);
void __RPC_STUB ILockBytes_SetSize_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_Stat_Proxy(
    ILockBytes* This,
    STATSTG* pstatstg,
    DWORD grfStatFlag);
void __RPC_STUB ILockBytes_Stat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ILockBytes_INTERFACE_DEFINED__ */

#ifndef __IFillLockBytes_FWD_DEFINED__
#define __IFillLockBytes_FWD_DEFINED__
typedef interface IFillLockBytes IFillLockBytes;
#endif

/*****************************************************************************
 * IFillLockBytes interface
 */
#ifndef __IFillLockBytes_INTERFACE_DEFINED__
#define __IFillLockBytes_INTERFACE_DEFINED__

DEFINE_GUID(IID_IFillLockBytes, 0x99caf010, 0x415e, 0x11cf, 0x88,0x14, 0x00,0xaa,0x00,0xb5,0x69,0xf5);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IFillLockBytes : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE FillAppend(
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE FillAt(
        ULARGE_INTEGER ulOffset,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetFillSize(
        ULARGE_INTEGER ulSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE Terminate(
        BOOL bCanceled) = 0;

};
#else
typedef struct IFillLockBytesVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IFillLockBytes* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IFillLockBytes* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IFillLockBytes* This);

    /*** IFillLockBytes methods ***/
    HRESULT (STDMETHODCALLTYPE *FillAppend)(
        IFillLockBytes* This,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten);

    HRESULT (STDMETHODCALLTYPE *FillAt)(
        IFillLockBytes* This,
        ULARGE_INTEGER ulOffset,
        const void* pv,
        ULONG cb,
        ULONG* pcbWritten);

    HRESULT (STDMETHODCALLTYPE *SetFillSize)(
        IFillLockBytes* This,
        ULARGE_INTEGER ulSize);

    HRESULT (STDMETHODCALLTYPE *Terminate)(
        IFillLockBytes* This,
        BOOL bCanceled);

    END_INTERFACE
} IFillLockBytesVtbl;
interface IFillLockBytes {
    const IFillLockBytesVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IFillLockBytes_RemoteFillAppend_Proxy(
    IFillLockBytes* This,
    const byte* pv,
    ULONG cb,
    ULONG* pcbWritten);
void __RPC_STUB IFillLockBytes_RemoteFillAppend_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFillLockBytes_Terminate_Proxy(
    IFillLockBytes* This,
    BOOL bCanceled);
void __RPC_STUB IFillLockBytes_Terminate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IFillLockBytes_INTERFACE_DEFINED__ */

#ifndef __IProgressNotify_FWD_DEFINED__
#define __IProgressNotify_FWD_DEFINED__
typedef interface IProgressNotify IProgressNotify;
#endif

/*****************************************************************************
 * IProgressNotify interface
 */
#ifndef __IProgressNotify_INTERFACE_DEFINED__
#define __IProgressNotify_INTERFACE_DEFINED__

DEFINE_GUID(IID_IProgressNotify, 0xa9d758a0, 0x4617, 0x11cf, 0x95,0xfc, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IProgressNotify : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE OnProgress(
        DWORD dwProgressCurrent,
        DWORD dwProgressMaximum,
        BOOL fAccurate,
        BOOL fOwner) = 0;

};
#else
typedef struct IProgressNotifyVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IProgressNotify* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IProgressNotify* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IProgressNotify* This);

    /*** IProgressNotify methods ***/
    HRESULT (STDMETHODCALLTYPE *OnProgress)(
        IProgressNotify* This,
        DWORD dwProgressCurrent,
        DWORD dwProgressMaximum,
        BOOL fAccurate,
        BOOL fOwner);

    END_INTERFACE
} IProgressNotifyVtbl;
interface IProgressNotify {
    const IProgressNotifyVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IProgressNotify_OnProgress_Proxy(
    IProgressNotify* This,
    DWORD dwProgressCurrent,
    DWORD dwProgressMaximum,
    BOOL fAccurate,
    BOOL fOwner);
void __RPC_STUB IProgressNotify_OnProgress_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IProgressNotify_INTERFACE_DEFINED__ */

#ifndef __ILayoutStorage_FWD_DEFINED__
#define __ILayoutStorage_FWD_DEFINED__
typedef interface ILayoutStorage ILayoutStorage;
#endif

typedef struct tagStorageLayout {
    DWORD LayoutType;
    OLECHAR *pwcsElementName;
    LARGE_INTEGER cOffset;
    LARGE_INTEGER cBytes;
} StorageLayout;
/*****************************************************************************
 * ILayoutStorage interface
 */
#ifndef __ILayoutStorage_INTERFACE_DEFINED__
#define __ILayoutStorage_INTERFACE_DEFINED__

DEFINE_GUID(IID_ILayoutStorage, 0x0e6d4d90, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ILayoutStorage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE LayoutScript(
        StorageLayout* pStorageLayout,
        DWORD nEntries,
        DWORD glfInterleavedFlag) = 0;

    virtual HRESULT STDMETHODCALLTYPE BeginMonitor(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndMonitor(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReLayoutDocfile(
        OLECHAR* pwcsNewDfName) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReLayoutDocfileOnILockBytes(
        ILockBytes* pILockBytes) = 0;

};
#else
typedef struct ILayoutStorageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ILayoutStorage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ILayoutStorage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ILayoutStorage* This);

    /*** ILayoutStorage methods ***/
    HRESULT (STDMETHODCALLTYPE *LayoutScript)(
        ILayoutStorage* This,
        StorageLayout* pStorageLayout,
        DWORD nEntries,
        DWORD glfInterleavedFlag);

    HRESULT (STDMETHODCALLTYPE *BeginMonitor)(
        ILayoutStorage* This);

    HRESULT (STDMETHODCALLTYPE *EndMonitor)(
        ILayoutStorage* This);

    HRESULT (STDMETHODCALLTYPE *ReLayoutDocfile)(
        ILayoutStorage* This,
        OLECHAR* pwcsNewDfName);

    HRESULT (STDMETHODCALLTYPE *ReLayoutDocfileOnILockBytes)(
        ILayoutStorage* This,
        ILockBytes* pILockBytes);

    END_INTERFACE
} ILayoutStorageVtbl;
interface ILayoutStorage {
    const ILayoutStorageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK ILayoutStorage_LayoutScript_Proxy(
    ILayoutStorage* This,
    StorageLayout* pStorageLayout,
    DWORD nEntries,
    DWORD glfInterleavedFlag);
void __RPC_STUB ILayoutStorage_LayoutScript_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_BeginMonitor_Proxy(
    ILayoutStorage* This);
void __RPC_STUB ILayoutStorage_BeginMonitor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_EndMonitor_Proxy(
    ILayoutStorage* This);
void __RPC_STUB ILayoutStorage_EndMonitor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_ReLayoutDocfile_Proxy(
    ILayoutStorage* This,
    OLECHAR* pwcsNewDfName);
void __RPC_STUB ILayoutStorage_ReLayoutDocfile_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_ReLayoutDocfileOnILockBytes_Proxy(
    ILayoutStorage* This,
    ILockBytes* pILockBytes);
void __RPC_STUB ILayoutStorage_ReLayoutDocfileOnILockBytes_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ILayoutStorage_INTERFACE_DEFINED__ */

#ifndef __IBlockingLock_FWD_DEFINED__
#define __IBlockingLock_FWD_DEFINED__
typedef interface IBlockingLock IBlockingLock;
#endif

/*****************************************************************************
 * IBlockingLock interface
 */
#ifndef __IBlockingLock_INTERFACE_DEFINED__
#define __IBlockingLock_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBlockingLock, 0x30f3d47a, 0x6447, 0x11d1, 0x8e,0x3c, 0x00,0xc0,0x4f,0xb9,0x38,0x6d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IBlockingLock : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Lock(
        DWORD dwTimeout) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unlock(
        ) = 0;

};
#else
typedef struct IBlockingLockVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBlockingLock* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBlockingLock* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBlockingLock* This);

    /*** IBlockingLock methods ***/
    HRESULT (STDMETHODCALLTYPE *Lock)(
        IBlockingLock* This,
        DWORD dwTimeout);

    HRESULT (STDMETHODCALLTYPE *Unlock)(
        IBlockingLock* This);

    END_INTERFACE
} IBlockingLockVtbl;
interface IBlockingLock {
    const IBlockingLockVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IBlockingLock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBlockingLock_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBlockingLock_Release(p) (p)->lpVtbl->Release(p)
/*** IBlockingLock methods ***/
#define IBlockingLock_Lock(p,a) (p)->lpVtbl->Lock(p,a)
#define IBlockingLock_Unlock(p) (p)->lpVtbl->Unlock(p)
#endif

#endif

HRESULT CALLBACK IBlockingLock_Lock_Proxy(
    IBlockingLock* This,
    DWORD dwTimeout);
void __RPC_STUB IBlockingLock_Lock_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBlockingLock_Unlock_Proxy(
    IBlockingLock* This);
void __RPC_STUB IBlockingLock_Unlock_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBlockingLock_INTERFACE_DEFINED__ */

#ifndef __ITimeAndNoticeControl_FWD_DEFINED__
#define __ITimeAndNoticeControl_FWD_DEFINED__
typedef interface ITimeAndNoticeControl ITimeAndNoticeControl;
#endif

/*****************************************************************************
 * ITimeAndNoticeControl interface
 */
#ifndef __ITimeAndNoticeControl_INTERFACE_DEFINED__
#define __ITimeAndNoticeControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_ITimeAndNoticeControl, 0xbc0bf6ae, 0x8878, 0x11d1, 0x83,0xe9, 0x00,0xc0,0x4f,0xc2,0xc6,0xd4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ITimeAndNoticeControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SuppressChanges(
        DWORD res1,
        DWORD res2) = 0;

};
#else
typedef struct ITimeAndNoticeControlVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ITimeAndNoticeControl* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ITimeAndNoticeControl* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ITimeAndNoticeControl* This);

    /*** ITimeAndNoticeControl methods ***/
    HRESULT (STDMETHODCALLTYPE *SuppressChanges)(
        ITimeAndNoticeControl* This,
        DWORD res1,
        DWORD res2);

    END_INTERFACE
} ITimeAndNoticeControlVtbl;
interface ITimeAndNoticeControl {
    const ITimeAndNoticeControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ITimeAndNoticeControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ITimeAndNoticeControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ITimeAndNoticeControl_Release(p) (p)->lpVtbl->Release(p)
/*** ITimeAndNoticeControl methods ***/
#define ITimeAndNoticeControl_SuppressChanges(p,a,b) (p)->lpVtbl->SuppressChanges(p,a,b)
#endif

#endif

HRESULT CALLBACK ITimeAndNoticeControl_SuppressChanges_Proxy(
    ITimeAndNoticeControl* This,
    DWORD res1,
    DWORD res2);
void __RPC_STUB ITimeAndNoticeControl_SuppressChanges_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ITimeAndNoticeControl_INTERFACE_DEFINED__ */

#ifndef __IOplockStorage_FWD_DEFINED__
#define __IOplockStorage_FWD_DEFINED__
typedef interface IOplockStorage IOplockStorage;
#endif

/*****************************************************************************
 * IOplockStorage interface
 */
#ifndef __IOplockStorage_INTERFACE_DEFINED__
#define __IOplockStorage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOplockStorage, 0x8d19c834, 0x8879, 0x11d1, 0x83,0xe9, 0x00,0xc0,0x4f,0xc2,0xc6,0xd4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IOplockStorage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateStorageEx(
        LPCWSTR pwcsName,
        DWORD grfMode,
        DWORD stgfmt,
        DWORD grfAttrs,
        REFIID riid,
        void** ppstgOpen) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenStorageEx(
        LPCWSTR pwcsName,
        DWORD grfMode,
        DWORD stgfmt,
        DWORD grfAttrs,
        REFIID riid,
        void** ppstgOpen) = 0;

};
#else
typedef struct IOplockStorageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOplockStorage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOplockStorage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOplockStorage* This);

    /*** IOplockStorage methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateStorageEx)(
        IOplockStorage* This,
        LPCWSTR pwcsName,
        DWORD grfMode,
        DWORD stgfmt,
        DWORD grfAttrs,
        REFIID riid,
        void** ppstgOpen);

    HRESULT (STDMETHODCALLTYPE *OpenStorageEx)(
        IOplockStorage* This,
        LPCWSTR pwcsName,
        DWORD grfMode,
        DWORD stgfmt,
        DWORD grfAttrs,
        REFIID riid,
        void** ppstgOpen);

    END_INTERFACE
} IOplockStorageVtbl;
interface IOplockStorage {
    const IOplockStorageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOplockStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOplockStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOplockStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IOplockStorage methods ***/
#define IOplockStorage_CreateStorageEx(p,a,b,c,d,e,f) (p)->lpVtbl->CreateStorageEx(p,a,b,c,d,e,f)
#define IOplockStorage_OpenStorageEx(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorageEx(p,a,b,c,d,e,f)
#endif

#endif

HRESULT CALLBACK IOplockStorage_CreateStorageEx_Proxy(
    IOplockStorage* This,
    LPCWSTR pwcsName,
    DWORD grfMode,
    DWORD stgfmt,
    DWORD grfAttrs,
    REFIID riid,
    void** ppstgOpen);
void __RPC_STUB IOplockStorage_CreateStorageEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOplockStorage_OpenStorageEx_Proxy(
    IOplockStorage* This,
    LPCWSTR pwcsName,
    DWORD grfMode,
    DWORD stgfmt,
    DWORD grfAttrs,
    REFIID riid,
    void** ppstgOpen);
void __RPC_STUB IOplockStorage_OpenStorageEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOplockStorage_INTERFACE_DEFINED__ */

#ifndef __IEnumFORMATETC_FWD_DEFINED__
#define __IEnumFORMATETC_FWD_DEFINED__
typedef interface IEnumFORMATETC IEnumFORMATETC;
#endif

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;
typedef struct tagFORMATETC *LPFORMATETC;
/*****************************************************************************
 * IEnumFORMATETC interface
 */
#ifndef __IEnumFORMATETC_INTERFACE_DEFINED__
#define __IEnumFORMATETC_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumFORMATETC, 0x00000103, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumFORMATETC : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        FORMATETC* rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumFORMATETC** ppenum) = 0;

};
#else
typedef struct IEnumFORMATETCVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumFORMATETC* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumFORMATETC* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumFORMATETC* This);

    /*** IEnumFORMATETC methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumFORMATETC* This,
        ULONG celt,
        FORMATETC* rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumFORMATETC* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumFORMATETC* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumFORMATETC* This,
        IEnumFORMATETC** ppenum);

    END_INTERFACE
} IEnumFORMATETCVtbl;
interface IEnumFORMATETC {
    const IEnumFORMATETCVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumFORMATETC_RemoteNext_Proxy(
    IEnumFORMATETC* This,
    ULONG celt,
    FORMATETC* rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumFORMATETC_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumFORMATETC_Reset_Proxy(
    IEnumFORMATETC* This);
void __RPC_STUB IEnumFORMATETC_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumFORMATETC_Clone_Proxy(
    IEnumFORMATETC* This,
    IEnumFORMATETC** ppenum);
void __RPC_STUB IEnumFORMATETC_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumFORMATETC_INTERFACE_DEFINED__ */

#ifndef __IEnumSTATDATA_FWD_DEFINED__
#define __IEnumSTATDATA_FWD_DEFINED__
typedef interface IEnumSTATDATA IEnumSTATDATA;
#endif

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;
typedef struct tagSTATDATA *LPSTATDATA;
/*****************************************************************************
 * IEnumSTATDATA interface
 */
#ifndef __IEnumSTATDATA_INTERFACE_DEFINED__
#define __IEnumSTATDATA_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumSTATDATA, 0x00000105, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumSTATDATA : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        STATDATA* rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumSTATDATA** ppenum) = 0;

};
#else
typedef struct IEnumSTATDATAVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumSTATDATA* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumSTATDATA* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumSTATDATA* This);

    /*** IEnumSTATDATA methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumSTATDATA* This,
        ULONG celt,
        STATDATA* rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumSTATDATA* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumSTATDATA* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumSTATDATA* This,
        IEnumSTATDATA** ppenum);

    END_INTERFACE
} IEnumSTATDATAVtbl;
interface IEnumSTATDATA {
    const IEnumSTATDATAVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IEnumSTATDATA_RemoteNext_Proxy(
    IEnumSTATDATA* This,
    ULONG celt,
    STATDATA* rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumSTATDATA_RemoteNext_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATDATA_Reset_Proxy(
    IEnumSTATDATA* This);
void __RPC_STUB IEnumSTATDATA_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATDATA_Clone_Proxy(
    IEnumSTATDATA* This,
    IEnumSTATDATA** ppenum);
void __RPC_STUB IEnumSTATDATA_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumSTATDATA_INTERFACE_DEFINED__ */

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 {
        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
 */
#ifndef __IAdviseSink_INTERFACE_DEFINED__
#define __IAdviseSink_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAdviseSink, 0x0000010f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAdviseSink : public IUnknown
{
    virtual void STDMETHODCALLTYPE OnDataChange(
        FORMATETC* pFormatetc,
        STGMEDIUM* pStgmed) = 0;

    virtual void STDMETHODCALLTYPE OnViewChange(
        DWORD dwAspect,
        LONG lindex) = 0;

    virtual void STDMETHODCALLTYPE OnRename(
        IMoniker* pmk) = 0;

    virtual void STDMETHODCALLTYPE OnSave(
        ) = 0;

    virtual void STDMETHODCALLTYPE OnClose(
        ) = 0;

};
#else
typedef struct IAdviseSinkVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAdviseSink* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAdviseSink* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAdviseSink* This);

    /*** IAdviseSink methods ***/
    void (STDMETHODCALLTYPE *OnDataChange)(
        IAdviseSink* This,
        FORMATETC* pFormatetc,
        STGMEDIUM* pStgmed);

    void (STDMETHODCALLTYPE *OnViewChange)(
        IAdviseSink* This,
        DWORD dwAspect,
        LONG lindex);

    void (STDMETHODCALLTYPE *OnRename)(
        IAdviseSink* This,
        IMoniker* pmk);

    void (STDMETHODCALLTYPE *OnSave)(
        IAdviseSink* This);

    void (STDMETHODCALLTYPE *OnClose)(
        IAdviseSink* This);

    END_INTERFACE
} IAdviseSinkVtbl;
interface IAdviseSink {
    const IAdviseSinkVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IAdviseSink_RemoteOnDataChange_Proxy(
    IAdviseSink* This,
    FORMATETC* pFormatetc,
    ASYNC_STGMEDIUM* pStgmed);
void __RPC_STUB IAdviseSink_RemoteOnDataChange_Stub(
    IRpcStubBuffer* This,
    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,
    FORMATETC* pFormatetc,
    ASYNC_STGMEDIUM* pStgmed);
HRESULT CALLBACK IAdviseSink_RemoteOnViewChange_Proxy(
    IAdviseSink* This,
    DWORD dwAspect,
    LONG lindex);
void __RPC_STUB IAdviseSink_RemoteOnViewChange_Stub(
    IRpcStubBuffer* This,
    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,
    DWORD dwAspect,
    LONG lindex);
HRESULT CALLBACK IAdviseSink_RemoteOnRename_Proxy(
    IAdviseSink* This,
    IMoniker* pmk);
void __RPC_STUB IAdviseSink_RemoteOnRename_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnRename_Proxy(
    IAdviseSink* This,
    IMoniker* pmk);
HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
    IAdviseSink* This,
    IMoniker* pmk);
HRESULT CALLBACK IAdviseSink_RemoteOnSave_Proxy(
    IAdviseSink* This);
void __RPC_STUB IAdviseSink_RemoteOnSave_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnSave_Proxy(
    IAdviseSink* This);
HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
    IAdviseSink* This);
HRESULT CALLBACK IAdviseSink_RemoteOnClose_Proxy(
    IAdviseSink* This);
void __RPC_STUB IAdviseSink_RemoteOnClose_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnClose_Proxy(
    IAdviseSink* This);
HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
    IAdviseSink* This);

#endif  /* __IAdviseSink_INTERFACE_DEFINED__ */

#ifndef __IAdviseSink2_FWD_DEFINED__
#define __IAdviseSink2_FWD_DEFINED__
typedef interface IAdviseSink2 IAdviseSink2;
#endif

typedef IAdviseSink2 *LPADVISESINK2;
/*****************************************************************************
 * IAdviseSink2 interface
 */
#ifndef __IAdviseSink2_INTERFACE_DEFINED__
#define __IAdviseSink2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAdviseSink2, 0x00000125, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAdviseSink2 : public IAdviseSink
{
    virtual void STDMETHODCALLTYPE OnLinkSrcChange(
        IMoniker* pmk) = 0;

};
#else
typedef struct IAdviseSink2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAdviseSink2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAdviseSink2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAdviseSink2* This);

    /*** IAdviseSink methods ***/
    void (STDMETHODCALLTYPE *OnDataChange)(
        IAdviseSink2* This,
        FORMATETC* pFormatetc,
        STGMEDIUM* pStgmed);

    void (STDMETHODCALLTYPE *OnViewChange)(
        IAdviseSink2* This,
        DWORD dwAspect,
        LONG lindex);

    void (STDMETHODCALLTYPE *OnRename)(
        IAdviseSink2* This,
        IMoniker* pmk);

    void (STDMETHODCALLTYPE *OnSave)(
        IAdviseSink2* This);

    void (STDMETHODCALLTYPE *OnClose)(
        IAdviseSink2* This);

    /*** IAdviseSink2 methods ***/
    void (STDMETHODCALLTYPE *OnLinkSrcChange)(
        IAdviseSink2* This,
        IMoniker* pmk);

    END_INTERFACE
} IAdviseSink2Vtbl;
interface IAdviseSink2 {
    const IAdviseSink2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IAdviseSink2_RemoteOnLinkSrcChange_Proxy(
    IAdviseSink2* This,
    IMoniker* pmk);
void __RPC_STUB IAdviseSink2_RemoteOnLinkSrcChange_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
    IAdviseSink2* This,
    IMoniker* pmk);
HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
    IAdviseSink2* This,
    IMoniker* pmk);

#endif  /* __IAdviseSink2_INTERFACE_DEFINED__ */

#ifndef __IDataObject_FWD_DEFINED__
#define __IDataObject_FWD_DEFINED__
typedef interface IDataObject IDataObject;
#endif

typedef IDataObject *LPDATAOBJECT;
typedef enum tagDATADIR {
    DATADIR_GET = 1,
    DATADIR_SET = 2
} DATADIR;
/*****************************************************************************
 * IDataObject interface
 */
#ifndef __IDataObject_INTERFACE_DEFINED__
#define __IDataObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDataObject, 0x0000010e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IDataObject : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetData(
        FORMATETC* pformatetcIn,
        STGMEDIUM* pmedium) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDataHere(
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueryGetData(
        FORMATETC* pformatetc) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc(
        FORMATETC* pformatectIn,
        FORMATETC* pformatetcOut) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetData(
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium,
        BOOL fRelease) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumFormatEtc(
        DWORD dwDirection,
        IEnumFORMATETC** ppenumFormatEtc) = 0;

    virtual HRESULT STDMETHODCALLTYPE DAdvise(
        FORMATETC* pformatetc,
        DWORD advf,
        IAdviseSink* pAdvSink,
        DWORD* pdwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE DUnadvise(
        DWORD dwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumDAdvise(
        IEnumSTATDATA** ppenumAdvise) = 0;

};
#else
typedef struct IDataObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDataObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDataObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDataObject* This);

    /*** IDataObject methods ***/
    HRESULT (STDMETHODCALLTYPE *GetData)(
        IDataObject* This,
        FORMATETC* pformatetcIn,
        STGMEDIUM* pmedium);

    HRESULT (STDMETHODCALLTYPE *GetDataHere)(
        IDataObject* This,
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium);

    HRESULT (STDMETHODCALLTYPE *QueryGetData)(
        IDataObject* This,
        FORMATETC* pformatetc);

    HRESULT (STDMETHODCALLTYPE *GetCanonicalFormatEtc)(
        IDataObject* This,
        FORMATETC* pformatectIn,
        FORMATETC* pformatetcOut);

    HRESULT (STDMETHODCALLTYPE *SetData)(
        IDataObject* This,
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium,
        BOOL fRelease);

    HRESULT (STDMETHODCALLTYPE *EnumFormatEtc)(
        IDataObject* This,
        DWORD dwDirection,
        IEnumFORMATETC** ppenumFormatEtc);

    HRESULT (STDMETHODCALLTYPE *DAdvise)(
        IDataObject* This,
        FORMATETC* pformatetc,
        DWORD advf,
        IAdviseSink* pAdvSink,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *DUnadvise)(
        IDataObject* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumDAdvise)(
        IDataObject* This,
        IEnumSTATDATA** ppenumAdvise);

    END_INTERFACE
} IDataObjectVtbl;
interface IDataObject {
    const IDataObjectVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IDataObject_RemoteGetData_Proxy(
    IDataObject* This,
    FORMATETC* pformatetcIn,
    STGMEDIUM* pRemoteMedium);
void __RPC_STUB IDataObject_RemoteGetData_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_GetCanonicalFormatEtc_Proxy(
    IDataObject* This,
    FORMATETC* pformatectIn,
    FORMATETC* pformatetcOut);
void __RPC_STUB IDataObject_GetCanonicalFormatEtc_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_DUnadvise_Proxy(
    IDataObject* This,
    DWORD dwConnection);
void __RPC_STUB IDataObject_DUnadvise_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_EnumDAdvise_Proxy(
    IDataObject* This,
    IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IDataObject_EnumDAdvise_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDataObject_INTERFACE_DEFINED__ */

#ifndef __IDataAdviseHolder_FWD_DEFINED__
#define __IDataAdviseHolder_FWD_DEFINED__
typedef interface IDataAdviseHolder IDataAdviseHolder;
#endif

typedef IDataAdviseHolder *LPDATAADVISEHOLDER;
/*****************************************************************************
 * IDataAdviseHolder interface
 */
#ifndef __IDataAdviseHolder_INTERFACE_DEFINED__
#define __IDataAdviseHolder_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDataAdviseHolder, 0x00000110, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IDataAdviseHolder : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Advise(
        IDataObject* pDataObject,
        FORMATETC* pFetc,
        DWORD advf,
        IAdviseSink* pAdvise,
        DWORD* pdwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unadvise(
        DWORD dwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumAdvise(
        IEnumSTATDATA** ppenumAdvise) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendOnDataChange(
        IDataObject* pDataObject,
        DWORD dwReserved,
        DWORD advf) = 0;

};
#else
typedef struct IDataAdviseHolderVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDataAdviseHolder* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDataAdviseHolder* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDataAdviseHolder* This);

    /*** IDataAdviseHolder methods ***/
    HRESULT (STDMETHODCALLTYPE *Advise)(
        IDataAdviseHolder* This,
        IDataObject* pDataObject,
        FORMATETC* pFetc,
        DWORD advf,
        IAdviseSink* pAdvise,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *Unadvise)(
        IDataAdviseHolder* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumAdvise)(
        IDataAdviseHolder* This,
        IEnumSTATDATA** ppenumAdvise);

    HRESULT (STDMETHODCALLTYPE *SendOnDataChange)(
        IDataAdviseHolder* This,
        IDataObject* pDataObject,
        DWORD dwReserved,
        DWORD advf);

    END_INTERFACE
} IDataAdviseHolderVtbl;
interface IDataAdviseHolder {
    const IDataAdviseHolderVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IDataAdviseHolder_Advise_Proxy(
    IDataAdviseHolder* This,
    IDataObject* pDataObject,
    FORMATETC* pFetc,
    DWORD advf,
    IAdviseSink* pAdvise,
    DWORD* pdwConnection);
void __RPC_STUB IDataAdviseHolder_Advise_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDataAdviseHolder_Unadvise_Proxy(
    IDataAdviseHolder* This,
    DWORD dwConnection);
void __RPC_STUB IDataAdviseHolder_Unadvise_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDataAdviseHolder_EnumAdvise_Proxy(
    IDataAdviseHolder* This,
    IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IDataAdviseHolder_EnumAdvise_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDataAdviseHolder_INTERFACE_DEFINED__ */

#ifndef __IMessageFilter_FWD_DEFINED__
#define __IMessageFilter_FWD_DEFINED__
typedef interface IMessageFilter IMessageFilter;
#endif

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;
typedef struct tagINTERFACEINFO *LPINTERFACEINFO;
/*****************************************************************************
 * IMessageFilter interface
 */
#ifndef __IMessageFilter_INTERFACE_DEFINED__
#define __IMessageFilter_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMessageFilter, 0x00000016, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMessageFilter : public IUnknown
{
    virtual DWORD STDMETHODCALLTYPE HandleInComingCall(
        DWORD dwCallType,
        HTASK htaskCaller,
        DWORD dwTickCount,
        LPINTERFACEINFO lpInterfaceInfo) = 0;

    virtual DWORD STDMETHODCALLTYPE RetryRejectedCall(
        HTASK htaskCallee,
        DWORD dwTickCount,
        DWORD dwRejectType) = 0;

    virtual DWORD STDMETHODCALLTYPE MessagePending(
        HTASK htaskCallee,
        DWORD dwTickCount,
        DWORD dwPendingType) = 0;

};
#else
typedef struct IMessageFilterVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMessageFilter* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMessageFilter* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMessageFilter* This);

    /*** IMessageFilter methods ***/
    DWORD (STDMETHODCALLTYPE *HandleInComingCall)(
        IMessageFilter* This,
        DWORD dwCallType,
        HTASK htaskCaller,
        DWORD dwTickCount,
        LPINTERFACEINFO lpInterfaceInfo);

    DWORD (STDMETHODCALLTYPE *RetryRejectedCall)(
        IMessageFilter* This,
        HTASK htaskCallee,
        DWORD dwTickCount,
        DWORD dwRejectType);

    DWORD (STDMETHODCALLTYPE *MessagePending)(
        IMessageFilter* This,
        HTASK htaskCallee,
        DWORD dwTickCount,
        DWORD dwPendingType);

    END_INTERFACE
} IMessageFilterVtbl;
interface IMessageFilter {
    const IMessageFilterVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

DWORD CALLBACK IMessageFilter_HandleInComingCall_Proxy(
    IMessageFilter* This,
    DWORD dwCallType,
    HTASK htaskCaller,
    DWORD dwTickCount,
    LPINTERFACEINFO lpInterfaceInfo);
void __RPC_STUB IMessageFilter_HandleInComingCall_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMessageFilter_INTERFACE_DEFINED__ */

#ifndef __IRpcChannelBuffer_FWD_DEFINED__
#define __IRpcChannelBuffer_FWD_DEFINED__
typedef interface IRpcChannelBuffer IRpcChannelBuffer;
#endif

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
 */
#ifndef __IRpcChannelBuffer_INTERFACE_DEFINED__
#define __IRpcChannelBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcChannelBuffer, 0xd5f56b60, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcChannelBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetBuffer(
        RPCOLEMESSAGE* pMessage,
        REFIID riid) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendReceive(
        RPCOLEMESSAGE* pMessage,
        ULONG* pStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE FreeBuffer(
        RPCOLEMESSAGE* pMessage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDestCtx(
        DWORD* pdwDestContext,
        void** ppvDestContext) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsConnected(
        ) = 0;

};
#else
typedef struct IRpcChannelBufferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcChannelBuffer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcChannelBuffer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcChannelBuffer* This);

    /*** IRpcChannelBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBuffer)(
        IRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage,
        REFIID riid);

    HRESULT (STDMETHODCALLTYPE *SendReceive)(
        IRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage,
        ULONG* pStatus);

    HRESULT (STDMETHODCALLTYPE *FreeBuffer)(
        IRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage);

    HRESULT (STDMETHODCALLTYPE *GetDestCtx)(
        IRpcChannelBuffer* This,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    HRESULT (STDMETHODCALLTYPE *IsConnected)(
        IRpcChannelBuffer* This);

    END_INTERFACE
} IRpcChannelBufferVtbl;
interface IRpcChannelBuffer {
    const IRpcChannelBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRpcChannelBuffer_GetBuffer_Proxy(
    IRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMessage,
    REFIID riid);
void __RPC_STUB IRpcChannelBuffer_GetBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_SendReceive_Proxy(
    IRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMessage,
    ULONG* pStatus);
void __RPC_STUB IRpcChannelBuffer_SendReceive_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_FreeBuffer_Proxy(
    IRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMessage);
void __RPC_STUB IRpcChannelBuffer_FreeBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_GetDestCtx_Proxy(
    IRpcChannelBuffer* This,
    DWORD* pdwDestContext,
    void** ppvDestContext);
void __RPC_STUB IRpcChannelBuffer_GetDestCtx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_IsConnected_Proxy(
    IRpcChannelBuffer* This);
void __RPC_STUB IRpcChannelBuffer_IsConnected_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcChannelBuffer_INTERFACE_DEFINED__ */

#ifndef __IRpcChannelBuffer2_FWD_DEFINED__
#define __IRpcChannelBuffer2_FWD_DEFINED__
typedef interface IRpcChannelBuffer2 IRpcChannelBuffer2;
#endif

typedef IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;
/*****************************************************************************
 * IRpcChannelBuffer2 interface
 */
#ifndef __IRpcChannelBuffer2_INTERFACE_DEFINED__
#define __IRpcChannelBuffer2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcChannelBuffer2, 0x594f31d0, 0x7f19, 0x11d0, 0xb1,0x94, 0x00,0xa0,0xc9,0x0d,0xc8,0xbf);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcChannelBuffer2 : public IRpcChannelBuffer
{
    virtual HRESULT STDMETHODCALLTYPE GetProtocolVersion(
        DWORD* pdwVersion) = 0;

};
#else
typedef struct IRpcChannelBuffer2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcChannelBuffer2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcChannelBuffer2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcChannelBuffer2* This);

    /*** IRpcChannelBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBuffer)(
        IRpcChannelBuffer2* This,
        RPCOLEMESSAGE* pMessage,
        REFIID riid);

    HRESULT (STDMETHODCALLTYPE *SendReceive)(
        IRpcChannelBuffer2* This,
        RPCOLEMESSAGE* pMessage,
        ULONG* pStatus);

    HRESULT (STDMETHODCALLTYPE *FreeBuffer)(
        IRpcChannelBuffer2* This,
        RPCOLEMESSAGE* pMessage);

    HRESULT (STDMETHODCALLTYPE *GetDestCtx)(
        IRpcChannelBuffer2* This,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    HRESULT (STDMETHODCALLTYPE *IsConnected)(
        IRpcChannelBuffer2* This);

    /*** IRpcChannelBuffer2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)(
        IRpcChannelBuffer2* This,
        DWORD* pdwVersion);

    END_INTERFACE
} IRpcChannelBuffer2Vtbl;
interface IRpcChannelBuffer2 {
    const IRpcChannelBuffer2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRpcChannelBuffer2_GetProtocolVersion_Proxy(
    IRpcChannelBuffer2* This,
    DWORD* pdwVersion);
void __RPC_STUB IRpcChannelBuffer2_GetProtocolVersion_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcChannelBuffer2_INTERFACE_DEFINED__ */

#ifndef __IRpcChannelBuffer3_FWD_DEFINED__
#define __IRpcChannelBuffer3_FWD_DEFINED__
typedef interface IRpcChannelBuffer3 IRpcChannelBuffer3;
#endif

typedef IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;
/*****************************************************************************
 * IRpcChannelBuffer3 interface
 */
#ifndef __IRpcChannelBuffer3_INTERFACE_DEFINED__
#define __IRpcChannelBuffer3_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcChannelBuffer3, 0x25b15600, 0x0115, 0x11d0, 0xbf,0x0d, 0x00,0xaa,0x00,0xb8,0xdf,0xd2);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcChannelBuffer3 : public IRpcChannelBuffer2
{
    virtual HRESULT STDMETHODCALLTYPE Send(
        RPCOLEMESSAGE* pMsg,
        ULONG* pulStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE Receive(
        RPCOLEMESSAGE* pMsg,
        ULONG ulSize,
        ULONG* pulStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE Cancel(
        RPCOLEMESSAGE* pMsg) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCallContext(
        RPCOLEMESSAGE* pMsg,
        REFIID riid,
        void** pInterface) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDestCtxEx(
        RPCOLEMESSAGE* pMsg,
        DWORD* pdwDestContext,
        void** ppvDestContext) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        RPCOLEMESSAGE* pMsg,
        DWORD* pState) = 0;

    virtual HRESULT STDMETHODCALLTYPE RegisterAsync(
        RPCOLEMESSAGE* pMsg,
        IAsyncManager* pAsyncMgr) = 0;

};
#else
typedef struct IRpcChannelBuffer3Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcChannelBuffer3* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcChannelBuffer3* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcChannelBuffer3* This);

    /*** IRpcChannelBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBuffer)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMessage,
        REFIID riid);

    HRESULT (STDMETHODCALLTYPE *SendReceive)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMessage,
        ULONG* pStatus);

    HRESULT (STDMETHODCALLTYPE *FreeBuffer)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMessage);

    HRESULT (STDMETHODCALLTYPE *GetDestCtx)(
        IRpcChannelBuffer3* This,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    HRESULT (STDMETHODCALLTYPE *IsConnected)(
        IRpcChannelBuffer3* This);

    /*** IRpcChannelBuffer2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)(
        IRpcChannelBuffer3* This,
        DWORD* pdwVersion);

    /*** IRpcChannelBuffer3 methods ***/
    HRESULT (STDMETHODCALLTYPE *Send)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        ULONG* pulStatus);

    HRESULT (STDMETHODCALLTYPE *Receive)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        ULONG ulSize,
        ULONG* pulStatus);

    HRESULT (STDMETHODCALLTYPE *Cancel)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg);

    HRESULT (STDMETHODCALLTYPE *GetCallContext)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        REFIID riid,
        void** pInterface);

    HRESULT (STDMETHODCALLTYPE *GetDestCtxEx)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        DWORD* pState);

    HRESULT (STDMETHODCALLTYPE *RegisterAsync)(
        IRpcChannelBuffer3* This,
        RPCOLEMESSAGE* pMsg,
        IAsyncManager* pAsyncMgr);

    END_INTERFACE
} IRpcChannelBuffer3Vtbl;
interface IRpcChannelBuffer3 {
    const IRpcChannelBuffer3Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRpcChannelBuffer3_Send_Proxy(
    IRpcChannelBuffer3* This,
    RPCOLEMESSAGE* pMsg,
    ULONG* pulStatus);
void __RPC_STUB IRpcChannelBuffer3_Send_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_Cancel_Proxy(
    IRpcChannelBuffer3* This,
    RPCOLEMESSAGE* pMsg);
void __RPC_STUB IRpcChannelBuffer3_Cancel_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_GetState_Proxy(
    IRpcChannelBuffer3* This,
    RPCOLEMESSAGE* pMsg,
    DWORD* pState);
void __RPC_STUB IRpcChannelBuffer3_GetState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_RegisterAsync_Proxy(
    IRpcChannelBuffer3* This,
    RPCOLEMESSAGE* pMsg,
    IAsyncManager* pAsyncMgr);
void __RPC_STUB IRpcChannelBuffer3_RegisterAsync_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcChannelBuffer3_INTERFACE_DEFINED__ */

#ifndef __IAsyncRpcChannelBuffer_FWD_DEFINED__
#define __IAsyncRpcChannelBuffer_FWD_DEFINED__
typedef interface IAsyncRpcChannelBuffer IAsyncRpcChannelBuffer;
#endif

/*****************************************************************************
 * IAsyncRpcChannelBuffer interface
 */
#ifndef __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__
#define __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAsyncRpcChannelBuffer, 0xa5029fb6, 0x3c34, 0x11d1, 0x9c,0x99, 0x00,0xc0,0x4f,0xb9,0x98,0xaa);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAsyncRpcChannelBuffer : public IRpcChannelBuffer2
{
    virtual HRESULT STDMETHODCALLTYPE Send(
        RPCOLEMESSAGE* pMsg,
        ISynchronize* pSync,
        ULONG* pulStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE Receive(
        RPCOLEMESSAGE* pMsg,
        ULONG* pulStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDestCtxEx(
        RPCOLEMESSAGE* pMsg,
        DWORD* pdwDestContext,
        void** ppvDestContext) = 0;

};
#else
typedef struct IAsyncRpcChannelBufferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAsyncRpcChannelBuffer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAsyncRpcChannelBuffer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAsyncRpcChannelBuffer* This);

    /*** IRpcChannelBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBuffer)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage,
        REFIID riid);

    HRESULT (STDMETHODCALLTYPE *SendReceive)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage,
        ULONG* pStatus);

    HRESULT (STDMETHODCALLTYPE *FreeBuffer)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMessage);

    HRESULT (STDMETHODCALLTYPE *GetDestCtx)(
        IAsyncRpcChannelBuffer* This,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    HRESULT (STDMETHODCALLTYPE *IsConnected)(
        IAsyncRpcChannelBuffer* This);

    /*** IRpcChannelBuffer2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)(
        IAsyncRpcChannelBuffer* This,
        DWORD* pdwVersion);

    /*** IAsyncRpcChannelBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Send)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMsg,
        ISynchronize* pSync,
        ULONG* pulStatus);

    HRESULT (STDMETHODCALLTYPE *Receive)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMsg,
        ULONG* pulStatus);

    HRESULT (STDMETHODCALLTYPE *GetDestCtxEx)(
        IAsyncRpcChannelBuffer* This,
        RPCOLEMESSAGE* pMsg,
        DWORD* pdwDestContext,
        void** ppvDestContext);

    END_INTERFACE
} IAsyncRpcChannelBufferVtbl;
interface IAsyncRpcChannelBuffer {
    const IAsyncRpcChannelBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAsyncRpcChannelBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAsyncRpcChannelBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAsyncRpcChannelBuffer_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcChannelBuffer methods ***/
#define IAsyncRpcChannelBuffer_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
#define IAsyncRpcChannelBuffer_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
#define IAsyncRpcChannelBuffer_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
#define IAsyncRpcChannelBuffer_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
#define IAsyncRpcChannelBuffer_IsConnected(p) (p)->lpVtbl->IsConnected(p)
/*** IRpcChannelBuffer2 methods ***/
#define IAsyncRpcChannelBuffer_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a)
/*** IAsyncRpcChannelBuffer methods ***/
#define IAsyncRpcChannelBuffer_Send(p,a,b,c) (p)->lpVtbl->Send(p,a,b,c)
#define IAsyncRpcChannelBuffer_Receive(p,a,b) (p)->lpVtbl->Receive(p,a,b)
#define IAsyncRpcChannelBuffer_GetDestCtxEx(p,a,b,c) (p)->lpVtbl->GetDestCtxEx(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IAsyncRpcChannelBuffer_Send_Proxy(
    IAsyncRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMsg,
    ISynchronize* pSync,
    ULONG* pulStatus);
void __RPC_STUB IAsyncRpcChannelBuffer_Send_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncRpcChannelBuffer_Receive_Proxy(
    IAsyncRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMsg,
    ULONG* pulStatus);
void __RPC_STUB IAsyncRpcChannelBuffer_Receive_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncRpcChannelBuffer_GetDestCtxEx_Proxy(
    IAsyncRpcChannelBuffer* This,
    RPCOLEMESSAGE* pMsg,
    DWORD* pdwDestContext,
    void** ppvDestContext);
void __RPC_STUB IAsyncRpcChannelBuffer_GetDestCtxEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__ */

#ifndef __IRpcSyntaxNegotiate_FWD_DEFINED__
#define __IRpcSyntaxNegotiate_FWD_DEFINED__
typedef interface IRpcSyntaxNegotiate IRpcSyntaxNegotiate;
#endif

/*****************************************************************************
 * IRpcSyntaxNegotiate interface
 */
#ifndef __IRpcSyntaxNegotiate_INTERFACE_DEFINED__
#define __IRpcSyntaxNegotiate_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcSyntaxNegotiate, 0x58a08519, 0x24c8, 0x4935, 0xb4,0x82, 0x3f,0xd8,0x23,0x33,0x3a,0x4f);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcSyntaxNegotiate : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE NegotiateSyntax(
        RPCOLEMESSAGE* pMsg) = 0;

};
#else
typedef struct IRpcSyntaxNegotiateVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcSyntaxNegotiate* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcSyntaxNegotiate* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcSyntaxNegotiate* This);

    /*** IRpcSyntaxNegotiate methods ***/
    HRESULT (STDMETHODCALLTYPE *NegotiateSyntax)(
        IRpcSyntaxNegotiate* This,
        RPCOLEMESSAGE* pMsg);

    END_INTERFACE
} IRpcSyntaxNegotiateVtbl;
interface IRpcSyntaxNegotiate {
    const IRpcSyntaxNegotiateVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IRpcSyntaxNegotiate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcSyntaxNegotiate_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcSyntaxNegotiate_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcSyntaxNegotiate methods ***/
#define IRpcSyntaxNegotiate_NegotiateSyntax(p,a) (p)->lpVtbl->NegotiateSyntax(p,a)
#endif

#endif

HRESULT CALLBACK IRpcSyntaxNegotiate_NegotiateSyntax_Proxy(
    IRpcSyntaxNegotiate* This,
    RPCOLEMESSAGE* pMsg);
void __RPC_STUB IRpcSyntaxNegotiate_NegotiateSyntax_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcSyntaxNegotiate_INTERFACE_DEFINED__ */

#ifndef __IRpcProxyBuffer_FWD_DEFINED__
#define __IRpcProxyBuffer_FWD_DEFINED__
typedef interface IRpcProxyBuffer IRpcProxyBuffer;
#endif

typedef IRpcProxyBuffer *LPRPCPROXYBUFFER;
/*****************************************************************************
 * IRpcProxyBuffer interface
 */
#ifndef __IRpcProxyBuffer_INTERFACE_DEFINED__
#define __IRpcProxyBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcProxyBuffer, 0xd5f56a34, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcProxyBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Connect(
        IRpcChannelBuffer* pRpcChannelBuffer) = 0;

    virtual void STDMETHODCALLTYPE Disconnect(
        ) = 0;

};
#else
typedef struct IRpcProxyBufferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcProxyBuffer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcProxyBuffer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcProxyBuffer* This);

    /*** IRpcProxyBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Connect)(
        IRpcProxyBuffer* This,
        IRpcChannelBuffer* pRpcChannelBuffer);

    void (STDMETHODCALLTYPE *Disconnect)(
        IRpcProxyBuffer* This);

    END_INTERFACE
} IRpcProxyBufferVtbl;
interface IRpcProxyBuffer {
    const IRpcProxyBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRpcProxyBuffer_Connect_Proxy(
    IRpcProxyBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer);
void __RPC_STUB IRpcProxyBuffer_Connect_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IRpcProxyBuffer_Disconnect_Proxy(
    IRpcProxyBuffer* This);
void __RPC_STUB IRpcProxyBuffer_Disconnect_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcProxyBuffer_INTERFACE_DEFINED__ */

#ifndef __IRpcStubBuffer_FWD_DEFINED__
#define __IRpcStubBuffer_FWD_DEFINED__
typedef interface IRpcStubBuffer IRpcStubBuffer;
#endif

typedef IRpcStubBuffer *LPRPCSTUBBUFFER;
/*****************************************************************************
 * IRpcStubBuffer interface
 */
#ifndef __IRpcStubBuffer_INTERFACE_DEFINED__
#define __IRpcStubBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcStubBuffer, 0xd5f56afc, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcStubBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Connect(
        IUnknown* pUnkServer) = 0;

    virtual void STDMETHODCALLTYPE Disconnect(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Invoke(
        RPCOLEMESSAGE* _prpcmsg,
        IRpcChannelBuffer* _pRpcChannelBuffer) = 0;

    virtual IRpcStubBuffer* STDMETHODCALLTYPE IsIIDSupported(
        REFIID riid) = 0;

    virtual ULONG STDMETHODCALLTYPE CountRefs(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE DebugServerQueryInterface(
        void** ppv) = 0;

    virtual void STDMETHODCALLTYPE DebugServerRelease(
        void* pv) = 0;

};
#else
typedef struct IRpcStubBufferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcStubBuffer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcStubBuffer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcStubBuffer* This);

    /*** IRpcStubBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Connect)(
        IRpcStubBuffer* This,
        IUnknown* pUnkServer);

    void (STDMETHODCALLTYPE *Disconnect)(
        IRpcStubBuffer* This);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IRpcStubBuffer* This,
        RPCOLEMESSAGE* _prpcmsg,
        IRpcChannelBuffer* _pRpcChannelBuffer);

    IRpcStubBuffer* (STDMETHODCALLTYPE *IsIIDSupported)(
        IRpcStubBuffer* This,
        REFIID riid);

    ULONG (STDMETHODCALLTYPE *CountRefs)(
        IRpcStubBuffer* This);

    HRESULT (STDMETHODCALLTYPE *DebugServerQueryInterface)(
        IRpcStubBuffer* This,
        void** ppv);

    void (STDMETHODCALLTYPE *DebugServerRelease)(
        IRpcStubBuffer* This,
        void* pv);

    END_INTERFACE
} IRpcStubBufferVtbl;
interface IRpcStubBuffer {
    const IRpcStubBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IRpcStubBuffer_Connect_Proxy(
    IRpcStubBuffer* This,
    IUnknown* pUnkServer);
void __RPC_STUB IRpcStubBuffer_Connect_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IRpcStubBuffer_Disconnect_Proxy(
    IRpcStubBuffer* This);
void __RPC_STUB IRpcStubBuffer_Disconnect_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcStubBuffer_Invoke_Proxy(
    IRpcStubBuffer* This,
    RPCOLEMESSAGE* _prpcmsg,
    IRpcChannelBuffer* _pRpcChannelBuffer);
void __RPC_STUB IRpcStubBuffer_Invoke_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
IRpcStubBuffer* CALLBACK IRpcStubBuffer_IsIIDSupported_Proxy(
    IRpcStubBuffer* This,
    REFIID riid);
void __RPC_STUB IRpcStubBuffer_IsIIDSupported_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
ULONG CALLBACK IRpcStubBuffer_CountRefs_Proxy(
    IRpcStubBuffer* This);
void __RPC_STUB IRpcStubBuffer_CountRefs_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcStubBuffer_DebugServerQueryInterface_Proxy(
    IRpcStubBuffer* This,
    void** ppv);
void __RPC_STUB IRpcStubBuffer_DebugServerQueryInterface_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
void CALLBACK IRpcStubBuffer_DebugServerRelease_Proxy(
    IRpcStubBuffer* This,
    void* pv);
void __RPC_STUB IRpcStubBuffer_DebugServerRelease_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcStubBuffer_INTERFACE_DEFINED__ */

#ifndef __IPSFactoryBuffer_FWD_DEFINED__
#define __IPSFactoryBuffer_FWD_DEFINED__
typedef interface IPSFactoryBuffer IPSFactoryBuffer;
#endif

typedef IPSFactoryBuffer *LPPSFACTORYBUFFER;
/*****************************************************************************
 * IPSFactoryBuffer interface
 */
#ifndef __IPSFactoryBuffer_INTERFACE_DEFINED__
#define __IPSFactoryBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IPSFactoryBuffer, 0xd5f569d0, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPSFactoryBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateProxy(
        IUnknown* pUnkOuter,
        REFIID riid,
        IRpcProxyBuffer** ppProxy,
        void** ppv) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateStub(
        REFIID riid,
        IUnknown* pUnkServer,
        IRpcStubBuffer** ppStub) = 0;

};
#else
typedef struct IPSFactoryBufferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IPSFactoryBuffer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IPSFactoryBuffer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IPSFactoryBuffer* This);

    /*** IPSFactoryBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateProxy)(
        IPSFactoryBuffer* This,
        IUnknown* pUnkOuter,
        REFIID riid,
        IRpcProxyBuffer** ppProxy,
        void** ppv);

    HRESULT (STDMETHODCALLTYPE *CreateStub)(
        IPSFactoryBuffer* This,
        REFIID riid,
        IUnknown* pUnkServer,
        IRpcStubBuffer** ppStub);

    END_INTERFACE
} IPSFactoryBufferVtbl;
interface IPSFactoryBuffer {
    const IPSFactoryBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IPSFactoryBuffer_CreateProxy_Proxy(
    IPSFactoryBuffer* This,
    IUnknown* pUnkOuter,
    REFIID riid,
    IRpcProxyBuffer** ppProxy,
    void** ppv);
void __RPC_STUB IPSFactoryBuffer_CreateProxy_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IPSFactoryBuffer_INTERFACE_DEFINED__ */

#ifndef __IChannelHook_FWD_DEFINED__
#define __IChannelHook_FWD_DEFINED__
typedef interface IChannelHook IChannelHook;
#endif

typedef IChannelHook *LPCHANNELHOOK;
typedef struct SChannelHookCallInfo {
    IID iid;
    DWORD cbSize;
    GUID uCausality;
    DWORD dwServerPid;
    DWORD iMethod;
    void *pObject;
} SChannelHookCallInfo;
/*****************************************************************************
 * IChannelHook interface
 */
#ifndef __IChannelHook_INTERFACE_DEFINED__
#define __IChannelHook_INTERFACE_DEFINED__

DEFINE_GUID(IID_IChannelHook, 0x1008c4a0, 0x7613, 0x11cf, 0x9a,0xf1, 0x00,0x20,0xaf,0x6e,0x72,0xf4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IChannelHook : public IUnknown
{
    virtual void STDMETHODCALLTYPE ClientGetSize(
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize) = 0;

    virtual void STDMETHODCALLTYPE ClientFillBuffer(
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize,
        void* pDataBuffer) = 0;

    virtual void STDMETHODCALLTYPE ClientNotify(
        REFGUID uExtent,
        REFIID riid,
        ULONG cbDataSize,
        void* pDataBuffer,
        DWORD lDataRep,
        HRESULT hrFault) = 0;

    virtual void STDMETHODCALLTYPE ServerNotify(
        REFGUID uExtent,
        REFIID riid,
        ULONG cbDataSize,
        void* pDataBuffer,
        DWORD lDataRep) = 0;

    virtual void STDMETHODCALLTYPE ServerGetSize(
        REFGUID uExtent,
        REFIID riid,
        HRESULT hrFault,
        ULONG* pDataSize) = 0;

    virtual void STDMETHODCALLTYPE ServerFillBuffer(
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize,
        void* pDataBuffer,
        HRESULT hrFault) = 0;

};
#else
typedef struct IChannelHookVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IChannelHook* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IChannelHook* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IChannelHook* This);

    /*** IChannelHook methods ***/
    void (STDMETHODCALLTYPE *ClientGetSize)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize);

    void (STDMETHODCALLTYPE *ClientFillBuffer)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize,
        void* pDataBuffer);

    void (STDMETHODCALLTYPE *ClientNotify)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        ULONG cbDataSize,
        void* pDataBuffer,
        DWORD lDataRep,
        HRESULT hrFault);

    void (STDMETHODCALLTYPE *ServerNotify)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        ULONG cbDataSize,
        void* pDataBuffer,
        DWORD lDataRep);

    void (STDMETHODCALLTYPE *ServerGetSize)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        HRESULT hrFault,
        ULONG* pDataSize);

    void (STDMETHODCALLTYPE *ServerFillBuffer)(
        IChannelHook* This,
        REFGUID uExtent,
        REFIID riid,
        ULONG* pDataSize,
        void* pDataBuffer,
        HRESULT hrFault);

    END_INTERFACE
} IChannelHookVtbl;
interface IChannelHook {
    const IChannelHookVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

void CALLBACK IChannelHook_ClientGetSize_Proxy(
    IChannelHook* This,
    REFGUID uExtent,
    REFIID riid,
    ULONG* pDataSize);
void __RPC_STUB IChannelHook_ClientGetSize_Stub(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IChannelHook_INTERFACE_DEFINED__ */

extern const FMTID FMTID_SummaryInformation;

extern const FMTID FMTID_DocSummaryInformation;

extern const FMTID FMTID_UserDefinedProperties;

#ifndef __IClientSecurity_FWD_DEFINED__
#define __IClientSecurity_FWD_DEFINED__
typedef interface IClientSecurity IClientSecurity;
#endif

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
 */
#ifndef __IClientSecurity_INTERFACE_DEFINED__
#define __IClientSecurity_INTERFACE_DEFINED__

DEFINE_GUID(IID_IClientSecurity, 0x0000013d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IClientSecurity : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryBlanket(
        IUnknown* pProxy,
        DWORD* pAuthnSvc,
        DWORD* pAuthzSvc,
        OLECHAR** pServerPrincName,
        DWORD* pAuthnLevel,
        DWORD* pImpLevel,
        void** pAuthInfo,
        DWORD* pCapabilites) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBlanket(
        IUnknown* pProxy,
        DWORD AuthnSvc,
        DWORD AuthzSvc,
        OLECHAR* pServerPrincName,
        DWORD AuthnLevel,
        DWORD ImpLevel,
        void* pAuthInfo,
        DWORD Capabilities) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyProxy(
        IUnknown* pProxy,
        IUnknown** ppCopy) = 0;

};
#else
typedef struct IClientSecurityVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IClientSecurity* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IClientSecurity* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IClientSecurity* This);

    /*** IClientSecurity methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryBlanket)(
        IClientSecurity* This,
        IUnknown* pProxy,
        DWORD* pAuthnSvc,
        DWORD* pAuthzSvc,
        OLECHAR** pServerPrincName,
        DWORD* pAuthnLevel,
        DWORD* pImpLevel,
        void** pAuthInfo,
        DWORD* pCapabilites);

    HRESULT (STDMETHODCALLTYPE *SetBlanket)(
        IClientSecurity* This,
        IUnknown* pProxy,
        DWORD AuthnSvc,
        DWORD AuthzSvc,
        OLECHAR* pServerPrincName,
        DWORD AuthnLevel,
        DWORD ImpLevel,
        void* pAuthInfo,
        DWORD Capabilities);

    HRESULT (STDMETHODCALLTYPE *CopyProxy)(
        IClientSecurity* This,
        IUnknown* pProxy,
        IUnknown** ppCopy);

    END_INTERFACE
} IClientSecurityVtbl;
interface IClientSecurity {
    const IClientSecurityVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#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(
    IRpcStubBuffer* This,
    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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IClientSecurity_CopyProxy_Proxy(
    IClientSecurity* This,
    IUnknown* pProxy,
    IUnknown** ppCopy);
void __RPC_STUB IClientSecurity_CopyProxy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IClientSecurity_INTERFACE_DEFINED__ */

#ifndef __IServerSecurity_FWD_DEFINED__
#define __IServerSecurity_FWD_DEFINED__
typedef interface IServerSecurity IServerSecurity;
#endif

/*****************************************************************************
 * IServerSecurity interface
 */
#ifndef __IServerSecurity_INTERFACE_DEFINED__
#define __IServerSecurity_INTERFACE_DEFINED__

DEFINE_GUID(IID_IServerSecurity, 0x0000013e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IServerSecurity : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryBlanket(
        DWORD* pAuthnSvc,
        DWORD* pAuthzSvc,
        OLECHAR** pServerPrincName,
        DWORD* pAuthnLevel,
        DWORD* pImpLevel,
        void** pPrivs,
        DWORD* pCapabilities) = 0;

    virtual HRESULT STDMETHODCALLTYPE ImpersonateClient(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE RevertToSelf(
        ) = 0;

    virtual BOOL STDMETHODCALLTYPE IsImpersonating(
        ) = 0;

};
#else
typedef struct IServerSecurityVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IServerSecurity* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IServerSecurity* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IServerSecurity* This);

    /*** IServerSecurity methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryBlanket)(
        IServerSecurity* This,
        DWORD* pAuthnSvc,
        DWORD* pAuthzSvc,
        OLECHAR** pServerPrincName,
        DWORD* pAuthnLevel,
        DWORD* pImpLevel,
        void** pPrivs,
        DWORD* pCapabilities);

    HRESULT (STDMETHODCALLTYPE *ImpersonateClient)(
        IServerSecurity* This);

    HRESULT (STDMETHODCALLTYPE *RevertToSelf)(
        IServerSecurity* This);

    BOOL (STDMETHODCALLTYPE *IsImpersonating)(
        IServerSecurity* This);

    END_INTERFACE
} IServerSecurityVtbl;
interface IServerSecurity {
    const IServerSecurityVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#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(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IServerSecurity_ImpersonateClient_Proxy(
    IServerSecurity* This);
void __RPC_STUB IServerSecurity_ImpersonateClient_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IServerSecurity_RevertToSelf_Proxy(
    IServerSecurity* This);
void __RPC_STUB IServerSecurity_RevertToSelf_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
BOOL CALLBACK IServerSecurity_IsImpersonating_Proxy(
    IServerSecurity* This);
void __RPC_STUB IServerSecurity_IsImpersonating_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IServerSecurity_INTERFACE_DEFINED__ */

#ifndef __IAsyncSetup_FWD_DEFINED__
#define __IAsyncSetup_FWD_DEFINED__
typedef interface IAsyncSetup IAsyncSetup;
#endif

/*****************************************************************************
 * IAsyncSetup interface
 */
#ifndef __IAsyncSetup_INTERFACE_DEFINED__
#define __IAsyncSetup_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAsyncSetup, 0x00000024, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAsyncSetup : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetAsyncManager(
        REFIID riid,
        IUnknown* pOuter,
        DWORD dwFlags,
        IUnknown** ppInner,
        IAsyncManager** ppAsyncMgr) = 0;

};
#else
typedef struct IAsyncSetupVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAsyncSetup* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAsyncSetup* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAsyncSetup* This);

    /*** IAsyncSetup methods ***/
    HRESULT (STDMETHODCALLTYPE *GetAsyncManager)(
        IAsyncSetup* This,
        REFIID riid,
        IUnknown* pOuter,
        DWORD dwFlags,
        IUnknown** ppInner,
        IAsyncManager** ppAsyncMgr);

    END_INTERFACE
} IAsyncSetupVtbl;
interface IAsyncSetup {
    const IAsyncSetupVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IAsyncSetup_GetAsyncManager_Proxy(
    IAsyncSetup* This,
    REFIID riid,
    IUnknown* pOuter,
    DWORD dwFlags,
    IUnknown** ppInner,
    IAsyncManager** ppAsyncMgr);
void __RPC_STUB IAsyncSetup_GetAsyncManager_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAsyncSetup_INTERFACE_DEFINED__ */

#ifndef __IDirectWriterLock_FWD_DEFINED__
#define __IDirectWriterLock_FWD_DEFINED__
typedef interface IDirectWriterLock IDirectWriterLock;
#endif

/*****************************************************************************
 * IDirectWriterLock interface
 */
#ifndef __IDirectWriterLock_INTERFACE_DEFINED__
#define __IDirectWriterLock_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDirectWriterLock, 0x0e6d4d92, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IDirectWriterLock : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE WaitForWriteAccess(
        DWORD dwTimeout) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReleaseWriteAccess(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE HaveWriteAccess(
        ) = 0;

};
#else
typedef struct IDirectWriterLockVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDirectWriterLock* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDirectWriterLock* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDirectWriterLock* This);

    /*** IDirectWriterLock methods ***/
    HRESULT (STDMETHODCALLTYPE *WaitForWriteAccess)(
        IDirectWriterLock* This,
        DWORD dwTimeout);

    HRESULT (STDMETHODCALLTYPE *ReleaseWriteAccess)(
        IDirectWriterLock* This);

    HRESULT (STDMETHODCALLTYPE *HaveWriteAccess)(
        IDirectWriterLock* This);

    END_INTERFACE
} IDirectWriterLockVtbl;
interface IDirectWriterLock {
    const IDirectWriterLockVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDirectWriterLock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDirectWriterLock_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDirectWriterLock_Release(p) (p)->lpVtbl->Release(p)
/*** IDirectWriterLock methods ***/
#define IDirectWriterLock_WaitForWriteAccess(p,a) (p)->lpVtbl->WaitForWriteAccess(p,a)
#define IDirectWriterLock_ReleaseWriteAccess(p) (p)->lpVtbl->ReleaseWriteAccess(p)
#define IDirectWriterLock_HaveWriteAccess(p) (p)->lpVtbl->HaveWriteAccess(p)
#endif

#endif

HRESULT CALLBACK IDirectWriterLock_WaitForWriteAccess_Proxy(
    IDirectWriterLock* This,
    DWORD dwTimeout);
void __RPC_STUB IDirectWriterLock_WaitForWriteAccess_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectWriterLock_ReleaseWriteAccess_Proxy(
    IDirectWriterLock* This);
void __RPC_STUB IDirectWriterLock_ReleaseWriteAccess_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectWriterLock_HaveWriteAccess_Proxy(
    IDirectWriterLock* This);
void __RPC_STUB IDirectWriterLock_HaveWriteAccess_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDirectWriterLock_INTERFACE_DEFINED__ */

/*****************************************************************************
 * ISynchronize interface
 */
#ifndef __ISynchronize_INTERFACE_DEFINED__
#define __ISynchronize_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISynchronize, 0x00000030, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISynchronize : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Wait(
        DWORD dwFlags,
        DWORD dwMilliseconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE Signal(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

};
#else
typedef struct ISynchronizeVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISynchronize* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISynchronize* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISynchronize* This);

    /*** ISynchronize methods ***/
    HRESULT (STDMETHODCALLTYPE *Wait)(
        ISynchronize* This,
        DWORD dwFlags,
        DWORD dwMilliseconds);

    HRESULT (STDMETHODCALLTYPE *Signal)(
        ISynchronize* This);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        ISynchronize* This);

    END_INTERFACE
} ISynchronizeVtbl;
interface ISynchronize {
    const ISynchronizeVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISynchronize_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISynchronize_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISynchronize_Release(p) (p)->lpVtbl->Release(p)
/*** ISynchronize methods ***/
#define ISynchronize_Wait(p,a,b) (p)->lpVtbl->Wait(p,a,b)
#define ISynchronize_Signal(p) (p)->lpVtbl->Signal(p)
#define ISynchronize_Reset(p) (p)->lpVtbl->Reset(p)
#endif

#endif

HRESULT CALLBACK ISynchronize_Wait_Proxy(
    ISynchronize* This,
    DWORD dwFlags,
    DWORD dwMilliseconds);
void __RPC_STUB ISynchronize_Wait_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISynchronize_Signal_Proxy(
    ISynchronize* This);
void __RPC_STUB ISynchronize_Signal_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISynchronize_Reset_Proxy(
    ISynchronize* This);
void __RPC_STUB ISynchronize_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISynchronize_INTERFACE_DEFINED__ */

#ifndef __ISynchronizeHandle_FWD_DEFINED__
#define __ISynchronizeHandle_FWD_DEFINED__
typedef interface ISynchronizeHandle ISynchronizeHandle;
#endif

/*****************************************************************************
 * ISynchronizeHandle interface
 */
#ifndef __ISynchronizeHandle_INTERFACE_DEFINED__
#define __ISynchronizeHandle_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISynchronizeHandle, 0x00000031, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISynchronizeHandle : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetHandle(
        HANDLE* ph) = 0;

};
#else
typedef struct ISynchronizeHandleVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISynchronizeHandle* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISynchronizeHandle* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISynchronizeHandle* This);

    /*** ISynchronizeHandle methods ***/
    HRESULT (STDMETHODCALLTYPE *GetHandle)(
        ISynchronizeHandle* This,
        HANDLE* ph);

    END_INTERFACE
} ISynchronizeHandleVtbl;
interface ISynchronizeHandle {
    const ISynchronizeHandleVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISynchronizeHandle_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISynchronizeHandle_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISynchronizeHandle_Release(p) (p)->lpVtbl->Release(p)
/*** ISynchronizeHandle methods ***/
#define ISynchronizeHandle_GetHandle(p,a) (p)->lpVtbl->GetHandle(p,a)
#endif

#endif

HRESULT CALLBACK ISynchronizeHandle_GetHandle_Proxy(
    ISynchronizeHandle* This,
    HANDLE* ph);
void __RPC_STUB ISynchronizeHandle_GetHandle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISynchronizeHandle_INTERFACE_DEFINED__ */

#ifndef __ISynchronizeEvent_FWD_DEFINED__
#define __ISynchronizeEvent_FWD_DEFINED__
typedef interface ISynchronizeEvent ISynchronizeEvent;
#endif

/*****************************************************************************
 * ISynchronizeEvent interface
 */
#ifndef __ISynchronizeEvent_INTERFACE_DEFINED__
#define __ISynchronizeEvent_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISynchronizeEvent, 0x00000032, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISynchronizeEvent : public ISynchronizeHandle
{
    virtual HRESULT STDMETHODCALLTYPE SetEventHandle(
        HANDLE* ph) = 0;

};
#else
typedef struct ISynchronizeEventVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISynchronizeEvent* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISynchronizeEvent* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISynchronizeEvent* This);

    /*** ISynchronizeHandle methods ***/
    HRESULT (STDMETHODCALLTYPE *GetHandle)(
        ISynchronizeEvent* This,
        HANDLE* ph);

    /*** ISynchronizeEvent methods ***/
    HRESULT (STDMETHODCALLTYPE *SetEventHandle)(
        ISynchronizeEvent* This,
        HANDLE* ph);

    END_INTERFACE
} ISynchronizeEventVtbl;
interface ISynchronizeEvent {
    const ISynchronizeEventVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISynchronizeEvent_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISynchronizeEvent_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISynchronizeEvent_Release(p) (p)->lpVtbl->Release(p)
/*** ISynchronizeHandle methods ***/
#define ISynchronizeEvent_GetHandle(p,a) (p)->lpVtbl->GetHandle(p,a)
/*** ISynchronizeEvent methods ***/
#define ISynchronizeEvent_SetEventHandle(p,a) (p)->lpVtbl->SetEventHandle(p,a)
#endif

#endif

HRESULT CALLBACK ISynchronizeEvent_SetEventHandle_Proxy(
    ISynchronizeEvent* This,
    HANDLE* ph);
void __RPC_STUB ISynchronizeEvent_SetEventHandle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISynchronizeEvent_INTERFACE_DEFINED__ */

#ifndef __ISynchronizeContainer_FWD_DEFINED__
#define __ISynchronizeContainer_FWD_DEFINED__
typedef interface ISynchronizeContainer ISynchronizeContainer;
#endif

/*****************************************************************************
 * ISynchronizeContainer interface
 */
#ifndef __ISynchronizeContainer_INTERFACE_DEFINED__
#define __ISynchronizeContainer_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISynchronizeContainer, 0x00000033, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISynchronizeContainer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE AddSynchronize(
        ISynchronize* pSync) = 0;

    virtual HRESULT STDMETHODCALLTYPE WaitMultiple(
        DWORD dwFlags,
        DWORD dwTimeOut,
        ISynchronize** ppSync) = 0;

};
#else
typedef struct ISynchronizeContainerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISynchronizeContainer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISynchronizeContainer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISynchronizeContainer* This);

    /*** ISynchronizeContainer methods ***/
    HRESULT (STDMETHODCALLTYPE *AddSynchronize)(
        ISynchronizeContainer* This,
        ISynchronize* pSync);

    HRESULT (STDMETHODCALLTYPE *WaitMultiple)(
        ISynchronizeContainer* This,
        DWORD dwFlags,
        DWORD dwTimeOut,
        ISynchronize** ppSync);

    END_INTERFACE
} ISynchronizeContainerVtbl;
interface ISynchronizeContainer {
    const ISynchronizeContainerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISynchronizeContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISynchronizeContainer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISynchronizeContainer_Release(p) (p)->lpVtbl->Release(p)
/*** ISynchronizeContainer methods ***/
#define ISynchronizeContainer_AddSynchronize(p,a) (p)->lpVtbl->AddSynchronize(p,a)
#define ISynchronizeContainer_WaitMultiple(p,a,b,c) (p)->lpVtbl->WaitMultiple(p,a,b,c)
#endif

#endif

HRESULT CALLBACK ISynchronizeContainer_AddSynchronize_Proxy(
    ISynchronizeContainer* This,
    ISynchronize* pSync);
void __RPC_STUB ISynchronizeContainer_AddSynchronize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ISynchronizeContainer_WaitMultiple_Proxy(
    ISynchronizeContainer* This,
    DWORD dwFlags,
    DWORD dwTimeOut,
    ISynchronize** ppSync);
void __RPC_STUB ISynchronizeContainer_WaitMultiple_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISynchronizeContainer_INTERFACE_DEFINED__ */

#ifndef __ISynchronizeMutex_FWD_DEFINED__
#define __ISynchronizeMutex_FWD_DEFINED__
typedef interface ISynchronizeMutex ISynchronizeMutex;
#endif

/*****************************************************************************
 * ISynchronizeMutex interface
 */
#ifndef __ISynchronizeMutex_INTERFACE_DEFINED__
#define __ISynchronizeMutex_INTERFACE_DEFINED__

DEFINE_GUID(IID_ISynchronizeMutex, 0x00000025, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ISynchronizeMutex : public ISynchronize
{
    virtual HRESULT STDMETHODCALLTYPE ReleaseMutex(
        ) = 0;

};
#else
typedef struct ISynchronizeMutexVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ISynchronizeMutex* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ISynchronizeMutex* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ISynchronizeMutex* This);

    /*** ISynchronize methods ***/
    HRESULT (STDMETHODCALLTYPE *Wait)(
        ISynchronizeMutex* This,
        DWORD dwFlags,
        DWORD dwMilliseconds);

    HRESULT (STDMETHODCALLTYPE *Signal)(
        ISynchronizeMutex* This);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        ISynchronizeMutex* This);

    /*** ISynchronizeMutex methods ***/
    HRESULT (STDMETHODCALLTYPE *ReleaseMutex)(
        ISynchronizeMutex* This);

    END_INTERFACE
} ISynchronizeMutexVtbl;
interface ISynchronizeMutex {
    const ISynchronizeMutexVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ISynchronizeMutex_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISynchronizeMutex_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISynchronizeMutex_Release(p) (p)->lpVtbl->Release(p)
/*** ISynchronize methods ***/
#define ISynchronizeMutex_Wait(p,a,b) (p)->lpVtbl->Wait(p,a,b)
#define ISynchronizeMutex_Signal(p) (p)->lpVtbl->Signal(p)
#define ISynchronizeMutex_Reset(p) (p)->lpVtbl->Reset(p)
/*** ISynchronizeMutex methods ***/
#define ISynchronizeMutex_ReleaseMutex(p) (p)->lpVtbl->ReleaseMutex(p)
#endif

#endif

HRESULT CALLBACK ISynchronizeMutex_ReleaseMutex_Proxy(
    ISynchronizeMutex* This);
void __RPC_STUB ISynchronizeMutex_ReleaseMutex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ISynchronizeMutex_INTERFACE_DEFINED__ */

#ifndef __ICancelMethodCalls_FWD_DEFINED__
#define __ICancelMethodCalls_FWD_DEFINED__
typedef interface ICancelMethodCalls ICancelMethodCalls;
#endif

typedef ICancelMethodCalls *LPCANCELMETHODCALLS;
/*****************************************************************************
 * ICancelMethodCalls interface
 */
#ifndef __ICancelMethodCalls_INTERFACE_DEFINED__
#define __ICancelMethodCalls_INTERFACE_DEFINED__

DEFINE_GUID(IID_ICancelMethodCalls, 0x00000029, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ICancelMethodCalls : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Cancel(
        ULONG ulSeconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE TestCancel(
        ) = 0;

};
#else
typedef struct ICancelMethodCallsVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ICancelMethodCalls* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ICancelMethodCalls* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ICancelMethodCalls* This);

    /*** ICancelMethodCalls methods ***/
    HRESULT (STDMETHODCALLTYPE *Cancel)(
        ICancelMethodCalls* This,
        ULONG ulSeconds);

    HRESULT (STDMETHODCALLTYPE *TestCancel)(
        ICancelMethodCalls* This);

    END_INTERFACE
} ICancelMethodCallsVtbl;
interface ICancelMethodCalls {
    const ICancelMethodCallsVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ICancelMethodCalls_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ICancelMethodCalls_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ICancelMethodCalls_Release(p) (p)->lpVtbl->Release(p)
/*** ICancelMethodCalls methods ***/
#define ICancelMethodCalls_Cancel(p,a) (p)->lpVtbl->Cancel(p,a)
#define ICancelMethodCalls_TestCancel(p) (p)->lpVtbl->TestCancel(p)
#endif

#endif

HRESULT CALLBACK ICancelMethodCalls_Cancel_Proxy(
    ICancelMethodCalls* This,
    ULONG ulSeconds);
void __RPC_STUB ICancelMethodCalls_Cancel_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK ICancelMethodCalls_TestCancel_Proxy(
    ICancelMethodCalls* This);
void __RPC_STUB ICancelMethodCalls_TestCancel_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ICancelMethodCalls_INTERFACE_DEFINED__ */

typedef enum tagDCOM_CALL_STATE {
    DCOM_NONE = 0,
    DCOM_CALL_COMPLETE = 1,
    DCOM_CALL_CANCELED = 2
} DCOM_CALL_STATE;
/*****************************************************************************
 * IAsyncManager interface
 */
#ifndef __IAsyncManager_INTERFACE_DEFINED__
#define __IAsyncManager_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAsyncManager, 0x0000002a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAsyncManager : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CompleteCall(
        HRESULT Result) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCallContext(
        REFIID riid,
        void** pInterface) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        ULONG* pulStateFlags) = 0;

};
#else
typedef struct IAsyncManagerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAsyncManager* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAsyncManager* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAsyncManager* This);

    /*** IAsyncManager methods ***/
    HRESULT (STDMETHODCALLTYPE *CompleteCall)(
        IAsyncManager* This,
        HRESULT Result);

    HRESULT (STDMETHODCALLTYPE *GetCallContext)(
        IAsyncManager* This,
        REFIID riid,
        void** pInterface);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IAsyncManager* This,
        ULONG* pulStateFlags);

    END_INTERFACE
} IAsyncManagerVtbl;
interface IAsyncManager {
    const IAsyncManagerVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** 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

#endif

HRESULT CALLBACK IAsyncManager_CompleteCall_Proxy(
    IAsyncManager* This,
    HRESULT Result);
void __RPC_STUB IAsyncManager_CompleteCall_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncManager_GetCallContext_Proxy(
    IAsyncManager* This,
    REFIID riid,
    void** pInterface);
void __RPC_STUB IAsyncManager_GetCallContext_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncManager_GetState_Proxy(
    IAsyncManager* This,
    ULONG* pulStateFlags);
void __RPC_STUB IAsyncManager_GetState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAsyncManager_INTERFACE_DEFINED__ */

#ifndef __ICallFactory_FWD_DEFINED__
#define __ICallFactory_FWD_DEFINED__
typedef interface ICallFactory ICallFactory;
#endif

/*****************************************************************************
 * ICallFactory interface
 */
#ifndef __ICallFactory_INTERFACE_DEFINED__
#define __ICallFactory_INTERFACE_DEFINED__

DEFINE_GUID(IID_ICallFactory, 0x1c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface ICallFactory : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateCall(
        REFIID riid,
        IUnknown* pCtrlUnk,
        REFIID riid2,
        IUnknown** ppv) = 0;

};
#else
typedef struct ICallFactoryVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ICallFactory* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        ICallFactory* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        ICallFactory* This);

    /*** ICallFactory methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateCall)(
        ICallFactory* This,
        REFIID riid,
        IUnknown* pCtrlUnk,
        REFIID riid2,
        IUnknown** ppv);

    END_INTERFACE
} ICallFactoryVtbl;
interface ICallFactory {
    const ICallFactoryVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define ICallFactory_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ICallFactory_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ICallFactory_Release(p) (p)->lpVtbl->Release(p)
/*** ICallFactory methods ***/
#define ICallFactory_CreateCall(p,a,b,c,d) (p)->lpVtbl->CreateCall(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK ICallFactory_CreateCall_Proxy(
    ICallFactory* This,
    REFIID riid,
    IUnknown* pCtrlUnk,
    REFIID riid2,
    IUnknown** ppv);
void __RPC_STUB ICallFactory_CreateCall_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __ICallFactory_INTERFACE_DEFINED__ */

#ifndef __IRpcOptions_FWD_DEFINED__
#define __IRpcOptions_FWD_DEFINED__
typedef interface IRpcOptions IRpcOptions;
#endif

/*****************************************************************************
 * IRpcOptions interface
 */
#ifndef __IRpcOptions_INTERFACE_DEFINED__
#define __IRpcOptions_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcOptions, 0x00000144, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcOptions : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Set(
        IUnknown* pPrx,
        DWORD dwProperty,
        ULONG_PTR dwValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE Query(
        IUnknown* pPrx,
        DWORD dwProperty,
        ULONG_PTR* pdwValue) = 0;

};
#else
typedef struct IRpcOptionsVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcOptions* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcOptions* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcOptions* This);

    /*** IRpcOptions methods ***/
    HRESULT (STDMETHODCALLTYPE *Set)(
        IRpcOptions* This,
        IUnknown* pPrx,
        DWORD dwProperty,
        ULONG_PTR dwValue);

    HRESULT (STDMETHODCALLTYPE *Query)(
        IRpcOptions* This,
        IUnknown* pPrx,
        DWORD dwProperty,
        ULONG_PTR* pdwValue);

    END_INTERFACE
} IRpcOptionsVtbl;
interface IRpcOptions {
    const IRpcOptionsVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IRpcOptions_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcOptions_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcOptions_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcOptions methods ***/
#define IRpcOptions_Set(p,a,b,c) (p)->lpVtbl->Set(p,a,b,c)
#define IRpcOptions_Query(p,a,b,c) (p)->lpVtbl->Query(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IRpcOptions_Set_Proxy(
    IRpcOptions* This,
    IUnknown* pPrx,
    DWORD dwProperty,
    ULONG_PTR dwValue);
void __RPC_STUB IRpcOptions_Set_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcOptions_Query_Proxy(
    IRpcOptions* This,
    IUnknown* pPrx,
    DWORD dwProperty,
    ULONG_PTR* pdwValue);
void __RPC_STUB IRpcOptions_Query_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcOptions_INTERFACE_DEFINED__ */

enum {
    COMBND_RPCTIMEOUT = 1,
    COMBND_SERVER_LOCALITY = 2
};

enum {
    SERVER_LOCALITY_PROCESS_LOCAL = 0,
    SERVER_LOCALITY_MACHINE_LOCAL = 1,
    SERVER_LOCALITY_REMOTE = 2
};

#ifndef __IRpcHelper_FWD_DEFINED__
#define __IRpcHelper_FWD_DEFINED__
typedef interface IRpcHelper IRpcHelper;
#endif

/*****************************************************************************
 * IRpcHelper interface
 */
#ifndef __IRpcHelper_INTERFACE_DEFINED__
#define __IRpcHelper_INTERFACE_DEFINED__

DEFINE_GUID(IID_IRpcHelper, 0x00000149, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IRpcHelper : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetDCOMProtocolVersion(
        DWORD* pComVersion) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetIIDFromOBJREF(
        void* pObjRef,
        IID** piid) = 0;

};
#else
typedef struct IRpcHelperVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IRpcHelper* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IRpcHelper* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IRpcHelper* This);

    /*** IRpcHelper methods ***/
    HRESULT (STDMETHODCALLTYPE *GetDCOMProtocolVersion)(
        IRpcHelper* This,
        DWORD* pComVersion);

    HRESULT (STDMETHODCALLTYPE *GetIIDFromOBJREF)(
        IRpcHelper* This,
        void* pObjRef,
        IID** piid);

    END_INTERFACE
} IRpcHelperVtbl;
interface IRpcHelper {
    const IRpcHelperVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IRpcHelper_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcHelper_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcHelper_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcHelper methods ***/
#define IRpcHelper_GetDCOMProtocolVersion(p,a) (p)->lpVtbl->GetDCOMProtocolVersion(p,a)
#define IRpcHelper_GetIIDFromOBJREF(p,a,b) (p)->lpVtbl->GetIIDFromOBJREF(p,a,b)
#endif

#endif

HRESULT CALLBACK IRpcHelper_GetDCOMProtocolVersion_Proxy(
    IRpcHelper* This,
    DWORD* pComVersion);
void __RPC_STUB IRpcHelper_GetDCOMProtocolVersion_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcHelper_GetIIDFromOBJREF_Proxy(
    IRpcHelper* This,
    void* pObjRef,
    IID** piid);
void __RPC_STUB IRpcHelper_GetIIDFromOBJREF_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IRpcHelper_INTERFACE_DEFINED__ */

#ifndef __IReleaseMarshalBuffers_FWD_DEFINED__
#define __IReleaseMarshalBuffers_FWD_DEFINED__
typedef interface IReleaseMarshalBuffers IReleaseMarshalBuffers;
#endif

/*****************************************************************************
 * IReleaseMarshalBuffers interface
 */
#ifndef __IReleaseMarshalBuffers_INTERFACE_DEFINED__
#define __IReleaseMarshalBuffers_INTERFACE_DEFINED__

DEFINE_GUID(IID_IReleaseMarshalBuffers, 0xeb0cb9e8, 0x7996, 0x11d2, 0x87,0x2e, 0x00,0x00,0xf8,0x08,0x08,0x59);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IReleaseMarshalBuffers : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalBuffer(
        RPCOLEMESSAGE* pMsg,
        DWORD dwFlags,
        IUnknown* pChnl) = 0;

};
#else
typedef struct IReleaseMarshalBuffersVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IReleaseMarshalBuffers* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IReleaseMarshalBuffers* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IReleaseMarshalBuffers* This);

    /*** IReleaseMarshalBuffers methods ***/
    HRESULT (STDMETHODCALLTYPE *ReleaseMarshalBuffer)(
        IReleaseMarshalBuffers* This,
        RPCOLEMESSAGE* pMsg,
        DWORD dwFlags,
        IUnknown* pChnl);

    END_INTERFACE
} IReleaseMarshalBuffersVtbl;
interface IReleaseMarshalBuffers {
    const IReleaseMarshalBuffersVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IReleaseMarshalBuffers_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IReleaseMarshalBuffers_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IReleaseMarshalBuffers_Release(p) (p)->lpVtbl->Release(p)
/*** IReleaseMarshalBuffers methods ***/
#define IReleaseMarshalBuffers_ReleaseMarshalBuffer(p,a,b,c) (p)->lpVtbl->ReleaseMarshalBuffer(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IReleaseMarshalBuffers_ReleaseMarshalBuffer_Proxy(
    IReleaseMarshalBuffers* This,
    RPCOLEMESSAGE* pMsg,
    DWORD dwFlags,
    IUnknown* pChnl);
void __RPC_STUB IReleaseMarshalBuffers_ReleaseMarshalBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IReleaseMarshalBuffers_INTERFACE_DEFINED__ */

#ifndef __IWaitMultiple_FWD_DEFINED__
#define __IWaitMultiple_FWD_DEFINED__
typedef interface IWaitMultiple IWaitMultiple;
#endif

/*****************************************************************************
 * IWaitMultiple interface
 */
#ifndef __IWaitMultiple_INTERFACE_DEFINED__
#define __IWaitMultiple_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWaitMultiple, 0x0000002b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IWaitMultiple : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE WaitMultiple(
        DWORD timeout,
        ISynchronize** pSync) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddSynchronize(
        ISynchronize* pSync) = 0;

};
#else
typedef struct IWaitMultipleVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWaitMultiple* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWaitMultiple* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWaitMultiple* This);

    /*** IWaitMultiple methods ***/
    HRESULT (STDMETHODCALLTYPE *WaitMultiple)(
        IWaitMultiple* This,
        DWORD timeout,
        ISynchronize** pSync);

    HRESULT (STDMETHODCALLTYPE *AddSynchronize)(
        IWaitMultiple* This,
        ISynchronize* pSync);

    END_INTERFACE
} IWaitMultipleVtbl;
interface IWaitMultiple {
    const IWaitMultipleVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IWaitMultiple_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IWaitMultiple_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IWaitMultiple_Release(p) (p)->lpVtbl->Release(p)
/*** IWaitMultiple methods ***/
#define IWaitMultiple_WaitMultiple(p,a,b) (p)->lpVtbl->WaitMultiple(p,a,b)
#define IWaitMultiple_AddSynchronize(p,a) (p)->lpVtbl->AddSynchronize(p,a)
#endif

#endif

HRESULT CALLBACK IWaitMultiple_WaitMultiple_Proxy(
    IWaitMultiple* This,
    DWORD timeout,
    ISynchronize** pSync);
void __RPC_STUB IWaitMultiple_WaitMultiple_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IWaitMultiple_AddSynchronize_Proxy(
    IWaitMultiple* This,
    ISynchronize* pSync);
void __RPC_STUB IWaitMultiple_AddSynchronize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWaitMultiple_INTERFACE_DEFINED__ */

#ifndef __IUrlMon_FWD_DEFINED__
#define __IUrlMon_FWD_DEFINED__
typedef interface IUrlMon IUrlMon;
#endif

/*****************************************************************************
 * IUrlMon interface
 */
#ifndef __IUrlMon_INTERFACE_DEFINED__
#define __IUrlMon_INTERFACE_DEFINED__

DEFINE_GUID(IID_IUrlMon, 0x00000026, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IUrlMon : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE AsyncGetClassBits(
        REFCLSID rclsid,
        LPCWSTR pszTYPE,
        LPCWSTR pszExt,
        DWORD dwFileVersionMS,
        DWORD dwFileVersionLS,
        LPCWSTR pszCodeBase,
        IBindCtx* pbc,
        DWORD dwClassContext,
        REFIID riid,
        DWORD flags) = 0;

};
#else
typedef struct IUrlMonVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IUrlMon* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IUrlMon* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IUrlMon* This);

    /*** IUrlMon methods ***/
    HRESULT (STDMETHODCALLTYPE *AsyncGetClassBits)(
        IUrlMon* This,
        REFCLSID rclsid,
        LPCWSTR pszTYPE,
        LPCWSTR pszExt,
        DWORD dwFileVersionMS,
        DWORD dwFileVersionLS,
        LPCWSTR pszCodeBase,
        IBindCtx* pbc,
        DWORD dwClassContext,
        REFIID riid,
        DWORD flags);

    END_INTERFACE
} IUrlMonVtbl;
interface IUrlMon {
    const IUrlMonVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IUrlMon_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IUrlMon_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IUrlMon_Release(p) (p)->lpVtbl->Release(p)
/*** IUrlMon methods ***/
#define IUrlMon_AsyncGetClassBits(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->AsyncGetClassBits(p,a,b,c,d,e,f,g,h,i,j)
#endif

#endif

HRESULT CALLBACK IUrlMon_AsyncGetClassBits_Proxy(
    IUrlMon* This,
    REFCLSID rclsid,
    LPCWSTR pszTYPE,
    LPCWSTR pszExt,
    DWORD dwFileVersionMS,
    DWORD dwFileVersionLS,
    LPCWSTR pszCodeBase,
    IBindCtx* pbc,
    DWORD dwClassContext,
    REFIID riid,
    DWORD flags);
void __RPC_STUB IUrlMon_AsyncGetClassBits_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IUrlMon_INTERFACE_DEFINED__ */

#ifndef __IForegroundTransfer_FWD_DEFINED__
#define __IForegroundTransfer_FWD_DEFINED__
typedef interface IForegroundTransfer IForegroundTransfer;
#endif

/*****************************************************************************
 * IForegroundTransfer interface
 */
#ifndef __IForegroundTransfer_INTERFACE_DEFINED__
#define __IForegroundTransfer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IForegroundTransfer, 0x00000145, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IForegroundTransfer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE AllowForegroundTransfer(
        void* lpvReserved) = 0;

};
#else
typedef struct IForegroundTransferVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IForegroundTransfer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IForegroundTransfer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IForegroundTransfer* This);

    /*** IForegroundTransfer methods ***/
    HRESULT (STDMETHODCALLTYPE *AllowForegroundTransfer)(
        IForegroundTransfer* This,
        void* lpvReserved);

    END_INTERFACE
} IForegroundTransferVtbl;
interface IForegroundTransfer {
    const IForegroundTransferVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IForegroundTransfer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IForegroundTransfer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IForegroundTransfer_Release(p) (p)->lpVtbl->Release(p)
/*** IForegroundTransfer methods ***/
#define IForegroundTransfer_AllowForegroundTransfer(p,a) (p)->lpVtbl->AllowForegroundTransfer(p,a)
#endif

#endif

HRESULT CALLBACK IForegroundTransfer_AllowForegroundTransfer_Proxy(
    IForegroundTransfer* This,
    void* lpvReserved);
void __RPC_STUB IForegroundTransfer_AllowForegroundTransfer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IForegroundTransfer_INTERFACE_DEFINED__ */

#ifndef __IAddrTrackingControl_FWD_DEFINED__
#define __IAddrTrackingControl_FWD_DEFINED__
typedef interface IAddrTrackingControl IAddrTrackingControl;
#endif

typedef IAddrTrackingControl *LPADDRTRACKINGCONTROL;
/*****************************************************************************
 * IAddrTrackingControl interface
 */
#ifndef __IAddrTrackingControl_INTERFACE_DEFINED__
#define __IAddrTrackingControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAddrTrackingControl, 0x00000147, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAddrTrackingControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE EnableCOMDynamicAddrTracking(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE DisableCOMDynamicAddrTracking(
        ) = 0;

};
#else
typedef struct IAddrTrackingControlVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAddrTrackingControl* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAddrTrackingControl* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAddrTrackingControl* This);

    /*** IAddrTrackingControl methods ***/
    HRESULT (STDMETHODCALLTYPE *EnableCOMDynamicAddrTracking)(
        IAddrTrackingControl* This);

    HRESULT (STDMETHODCALLTYPE *DisableCOMDynamicAddrTracking)(
        IAddrTrackingControl* This);

    END_INTERFACE
} IAddrTrackingControlVtbl;
interface IAddrTrackingControl {
    const IAddrTrackingControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAddrTrackingControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAddrTrackingControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAddrTrackingControl_Release(p) (p)->lpVtbl->Release(p)
/*** IAddrTrackingControl methods ***/
#define IAddrTrackingControl_EnableCOMDynamicAddrTracking(p) (p)->lpVtbl->EnableCOMDynamicAddrTracking(p)
#define IAddrTrackingControl_DisableCOMDynamicAddrTracking(p) (p)->lpVtbl->DisableCOMDynamicAddrTracking(p)
#endif

#endif

HRESULT CALLBACK IAddrTrackingControl_EnableCOMDynamicAddrTracking_Proxy(
    IAddrTrackingControl* This);
void __RPC_STUB IAddrTrackingControl_EnableCOMDynamicAddrTracking_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAddrTrackingControl_DisableCOMDynamicAddrTracking_Proxy(
    IAddrTrackingControl* This);
void __RPC_STUB IAddrTrackingControl_DisableCOMDynamicAddrTracking_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAddrTrackingControl_INTERFACE_DEFINED__ */

#ifndef __IAddrExclusionControl_FWD_DEFINED__
#define __IAddrExclusionControl_FWD_DEFINED__
typedef interface IAddrExclusionControl IAddrExclusionControl;
#endif

typedef IAddrExclusionControl *LPADDREXCLUSIONCONTROL;
/*****************************************************************************
 * IAddrExclusionControl interface
 */
#ifndef __IAddrExclusionControl_INTERFACE_DEFINED__
#define __IAddrExclusionControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAddrExclusionControl, 0x00000148, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IAddrExclusionControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetCurrentAddrExclusionList(
        REFIID riid,
        void** ppEnumerator) = 0;

    virtual HRESULT STDMETHODCALLTYPE UpdateAddrExclusionList(
        IUnknown* pEnumerator) = 0;

};
#else
typedef struct IAddrExclusionControlVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IAddrExclusionControl* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IAddrExclusionControl* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IAddrExclusionControl* This);

    /*** IAddrExclusionControl methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCurrentAddrExclusionList)(
        IAddrExclusionControl* This,
        REFIID riid,
        void** ppEnumerator);

    HRESULT (STDMETHODCALLTYPE *UpdateAddrExclusionList)(
        IAddrExclusionControl* This,
        IUnknown* pEnumerator);

    END_INTERFACE
} IAddrExclusionControlVtbl;
interface IAddrExclusionControl {
    const IAddrExclusionControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAddrExclusionControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAddrExclusionControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAddrExclusionControl_Release(p) (p)->lpVtbl->Release(p)
/*** IAddrExclusionControl methods ***/
#define IAddrExclusionControl_GetCurrentAddrExclusionList(p,a,b) (p)->lpVtbl->GetCurrentAddrExclusionList(p,a,b)
#define IAddrExclusionControl_UpdateAddrExclusionList(p,a) (p)->lpVtbl->UpdateAddrExclusionList(p,a)
#endif

#endif

HRESULT CALLBACK IAddrExclusionControl_GetCurrentAddrExclusionList_Proxy(
    IAddrExclusionControl* This,
    REFIID riid,
    void** ppEnumerator);
void __RPC_STUB IAddrExclusionControl_GetCurrentAddrExclusionList_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAddrExclusionControl_UpdateAddrExclusionList_Proxy(
    IAddrExclusionControl* This,
    IUnknown* pEnumerator);
void __RPC_STUB IAddrExclusionControl_UpdateAddrExclusionList_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAddrExclusionControl_INTERFACE_DEFINED__ */

typedef enum _APTTYPE {
    APTTYPE_CURRENT = -1,
    APTTYPE_STA = 0,
    APTTYPE_MTA = 1,
    APTTYPE_NA = 2,
    APTTYPE_MAINSTA = 3
} APTTYPE;
typedef enum _THDTYPE {
    THDTYPE_BLOCKMESSAGES = 0,
    THDTYPE_PROCESSMESSAGES = 1
} THDTYPE;
#ifndef __IComThreadingInfo_FWD_DEFINED__
#define __IComThreadingInfo_FWD_DEFINED__
typedef interface IComThreadingInfo IComThreadingInfo;
#endif

/*****************************************************************************
 * IComThreadingInfo interface
 */
#ifndef __IComThreadingInfo_INTERFACE_DEFINED__
#define __IComThreadingInfo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IComThreadingInfo, 0x000001ce, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IComThreadingInfo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetCurrentApartmentType(
        APTTYPE* pAptType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentThreadType(
        THDTYPE* pThreadType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentLogicalThreadId(
        GUID* pguidLogicalThreadId) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCurrentLogicalThreadId(
        REFGUID rguid) = 0;

};
#else
typedef struct IComThreadingInfoVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IComThreadingInfo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IComThreadingInfo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IComThreadingInfo* This);

    /*** IComThreadingInfo methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCurrentApartmentType)(
        IComThreadingInfo* This,
        APTTYPE* pAptType);

    HRESULT (STDMETHODCALLTYPE *GetCurrentThreadType)(
        IComThreadingInfo* This,
        THDTYPE* pThreadType);

    HRESULT (STDMETHODCALLTYPE *GetCurrentLogicalThreadId)(
        IComThreadingInfo* This,
        GUID* pguidLogicalThreadId);

    HRESULT (STDMETHODCALLTYPE *SetCurrentLogicalThreadId)(
        IComThreadingInfo* This,
        REFGUID rguid);

    END_INTERFACE
} IComThreadingInfoVtbl;
interface IComThreadingInfo {
    const IComThreadingInfoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IComThreadingInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IComThreadingInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IComThreadingInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IComThreadingInfo methods ***/
#define IComThreadingInfo_GetCurrentApartmentType(p,a) (p)->lpVtbl->GetCurrentApartmentType(p,a)
#define IComThreadingInfo_GetCurrentThreadType(p,a) (p)->lpVtbl->GetCurrentThreadType(p,a)
#define IComThreadingInfo_GetCurrentLogicalThreadId(p,a) (p)->lpVtbl->GetCurrentLogicalThreadId(p,a)
#define IComThreadingInfo_SetCurrentLogicalThreadId(p,a) (p)->lpVtbl->SetCurrentLogicalThreadId(p,a)
#endif

#endif

HRESULT CALLBACK IComThreadingInfo_GetCurrentApartmentType_Proxy(
    IComThreadingInfo* This,
    APTTYPE* pAptType);
void __RPC_STUB IComThreadingInfo_GetCurrentApartmentType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IComThreadingInfo_GetCurrentThreadType_Proxy(
    IComThreadingInfo* This,
    THDTYPE* pThreadType);
void __RPC_STUB IComThreadingInfo_GetCurrentThreadType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IComThreadingInfo_GetCurrentLogicalThreadId_Proxy(
    IComThreadingInfo* This,
    GUID* pguidLogicalThreadId);
void __RPC_STUB IComThreadingInfo_GetCurrentLogicalThreadId_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IComThreadingInfo_SetCurrentLogicalThreadId_Proxy(
    IComThreadingInfo* This,
    REFGUID rguid);
void __RPC_STUB IComThreadingInfo_SetCurrentLogicalThreadId_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IComThreadingInfo_INTERFACE_DEFINED__ */

#ifndef __IProcessInitControl_FWD_DEFINED__
#define __IProcessInitControl_FWD_DEFINED__
typedef interface IProcessInitControl IProcessInitControl;
#endif

/*****************************************************************************
 * IProcessInitControl interface
 */
#ifndef __IProcessInitControl_INTERFACE_DEFINED__
#define __IProcessInitControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IProcessInitControl, 0x72380d55, 0x8d2b, 0x43a3, 0x85,0x13, 0x2b,0x6e,0xf3,0x14,0x34,0xe9);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IProcessInitControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ResetInitializerTimeout(
        DWORD dwSecondsRemaining) = 0;

};
#else
typedef struct IProcessInitControlVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IProcessInitControl* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IProcessInitControl* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IProcessInitControl* This);

    /*** IProcessInitControl methods ***/
    HRESULT (STDMETHODCALLTYPE *ResetInitializerTimeout)(
        IProcessInitControl* This,
        DWORD dwSecondsRemaining);

    END_INTERFACE
} IProcessInitControlVtbl;
interface IProcessInitControl {
    const IProcessInitControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IProcessInitControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IProcessInitControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IProcessInitControl_Release(p) (p)->lpVtbl->Release(p)
/*** IProcessInitControl methods ***/
#define IProcessInitControl_ResetInitializerTimeout(p,a) (p)->lpVtbl->ResetInitializerTimeout(p,a)
#endif

#endif

HRESULT CALLBACK IProcessInitControl_ResetInitializerTimeout_Proxy(
    IProcessInitControl* This,
    DWORD dwSecondsRemaining);
void __RPC_STUB IProcessInitControl_ResetInitializerTimeout_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IProcessInitControl_INTERFACE_DEFINED__ */

#ifndef __IInitializeSpy_FWD_DEFINED__
#define __IInitializeSpy_FWD_DEFINED__
typedef interface IInitializeSpy IInitializeSpy;
#endif

typedef IInitializeSpy *LPINITIALIZESPY;
/*****************************************************************************
 * IInitializeSpy interface
 */
#ifndef __IInitializeSpy_INTERFACE_DEFINED__
#define __IInitializeSpy_INTERFACE_DEFINED__

DEFINE_GUID(IID_IInitializeSpy, 0x00000034, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IInitializeSpy : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE PreInitialize(
        DWORD dwCoInit,
        DWORD dwCurThreadAptRefs) = 0;

    virtual HRESULT STDMETHODCALLTYPE PostInitialize(
        HRESULT hrCoInit,
        DWORD dwCoInit,
        DWORD dwNewThreadAptRefs) = 0;

    virtual HRESULT STDMETHODCALLTYPE PreUninitialize(
        DWORD dwCurThreadAptRefs) = 0;

    virtual HRESULT STDMETHODCALLTYPE PostUninitialize(
        DWORD dwNewThreadAptRefs) = 0;

};
#else
typedef struct IInitializeSpyVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IInitializeSpy* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IInitializeSpy* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IInitializeSpy* This);

    /*** IInitializeSpy methods ***/
    HRESULT (STDMETHODCALLTYPE *PreInitialize)(
        IInitializeSpy* This,
        DWORD dwCoInit,
        DWORD dwCurThreadAptRefs);

    HRESULT (STDMETHODCALLTYPE *PostInitialize)(
        IInitializeSpy* This,
        HRESULT hrCoInit,
        DWORD dwCoInit,
        DWORD dwNewThreadAptRefs);

    HRESULT (STDMETHODCALLTYPE *PreUninitialize)(
        IInitializeSpy* This,
        DWORD dwCurThreadAptRefs);

    HRESULT (STDMETHODCALLTYPE *PostUninitialize)(
        IInitializeSpy* This,
        DWORD dwNewThreadAptRefs);

    END_INTERFACE
} IInitializeSpyVtbl;
interface IInitializeSpy {
    const IInitializeSpyVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IInitializeSpy_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IInitializeSpy_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IInitializeSpy_Release(p) (p)->lpVtbl->Release(p)
/*** IInitializeSpy methods ***/
#define IInitializeSpy_PreInitialize(p,a,b) (p)->lpVtbl->PreInitialize(p,a,b)
#define IInitializeSpy_PostInitialize(p,a,b,c) (p)->lpVtbl->PostInitialize(p,a,b,c)
#define IInitializeSpy_PreUninitialize(p,a) (p)->lpVtbl->PreUninitialize(p,a)
#define IInitializeSpy_PostUninitialize(p,a) (p)->lpVtbl->PostUninitialize(p,a)
#endif

#endif

HRESULT CALLBACK IInitializeSpy_PreInitialize_Proxy(
    IInitializeSpy* This,
    DWORD dwCoInit,
    DWORD dwCurThreadAptRefs);
void __RPC_STUB IInitializeSpy_PreInitialize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInitializeSpy_PostInitialize_Proxy(
    IInitializeSpy* This,
    HRESULT hrCoInit,
    DWORD dwCoInit,
    DWORD dwNewThreadAptRefs);
void __RPC_STUB IInitializeSpy_PostInitialize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInitializeSpy_PreUninitialize_Proxy(
    IInitializeSpy* This,
    DWORD dwCurThreadAptRefs);
void __RPC_STUB IInitializeSpy_PreUninitialize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IInitializeSpy_PostUninitialize_Proxy(
    IInitializeSpy* This,
    DWORD dwNewThreadAptRefs);
void __RPC_STUB IInitializeSpy_PostUninitialize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IInitializeSpy_INTERFACE_DEFINED__ */

#ifndef __IThumbnailExtractor_FWD_DEFINED__
#define __IThumbnailExtractor_FWD_DEFINED__
typedef interface IThumbnailExtractor IThumbnailExtractor;
#endif

/*****************************************************************************
 * IThumbnailExtractor interface
 */
#ifndef __IThumbnailExtractor_INTERFACE_DEFINED__
#define __IThumbnailExtractor_INTERFACE_DEFINED__

DEFINE_GUID(IID_IThumbnailExtractor, 0x969dc708, 0x5c76, 0x11d1, 0x8d,0x86, 0x00,0x00,0xf8,0x04,0xb0,0x57);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IThumbnailExtractor : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ExtractThumbnail(
        IStorage* pStg,
        ULONG ulLength,
        ULONG ulHeight,
        ULONG* pulOutputLength,
        ULONG* pulOutputHeight,
        HBITMAP* phOutputBitmap) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnFileUpdated(
        IStorage* pStg) = 0;

};
#else
typedef struct IThumbnailExtractorVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IThumbnailExtractor* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IThumbnailExtractor* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IThumbnailExtractor* This);

    /*** IThumbnailExtractor methods ***/
    HRESULT (STDMETHODCALLTYPE *ExtractThumbnail)(
        IThumbnailExtractor* This,
        IStorage* pStg,
        ULONG ulLength,
        ULONG ulHeight,
        ULONG* pulOutputLength,
        ULONG* pulOutputHeight,
        HBITMAP* phOutputBitmap);

    HRESULT (STDMETHODCALLTYPE *OnFileUpdated)(
        IThumbnailExtractor* This,
        IStorage* pStg);

    END_INTERFACE
} IThumbnailExtractorVtbl;
interface IThumbnailExtractor {
    const IThumbnailExtractorVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IThumbnailExtractor_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IThumbnailExtractor_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IThumbnailExtractor_Release(p) (p)->lpVtbl->Release(p)
/*** IThumbnailExtractor methods ***/
#define IThumbnailExtractor_ExtractThumbnail(p,a,b,c,d,e,f) (p)->lpVtbl->ExtractThumbnail(p,a,b,c,d,e,f)
#define IThumbnailExtractor_OnFileUpdated(p,a) (p)->lpVtbl->OnFileUpdated(p,a)
#endif

#endif

HRESULT CALLBACK IThumbnailExtractor_ExtractThumbnail_Proxy(
    IThumbnailExtractor* This,
    IStorage* pStg,
    ULONG ulLength,
    ULONG ulHeight,
    ULONG* pulOutputLength,
    ULONG* pulOutputHeight,
    HBITMAP* phOutputBitmap);
void __RPC_STUB IThumbnailExtractor_ExtractThumbnail_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IThumbnailExtractor_OnFileUpdated_Proxy(
    IThumbnailExtractor* This,
    IStorage* pStg);
void __RPC_STUB IThumbnailExtractor_OnFileUpdated_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IThumbnailExtractor_INTERFACE_DEFINED__ */

#ifdef USE_COM_CONTEXT_DEF
typedef DWORD CPFLAGS;
typedef struct tagContextProperty {
    GUID policyId;
    CPFLAGS flags;
    IUnknown *pUnk;
} ContextProperty;
#ifndef __IEnumContextProps_FWD_DEFINED__
#define __IEnumContextProps_FWD_DEFINED__
typedef interface IEnumContextProps IEnumContextProps;
#endif

typedef IEnumContextProps *LPENUMCONTEXTPROPS;
/*****************************************************************************
 * IEnumContextProps interface
 */
#ifndef __IEnumContextProps_INTERFACE_DEFINED__
#define __IEnumContextProps_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumContextProps, 0x000001c1, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumContextProps : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        ContextProperty* pContextProperties,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumContextProps** ppEnumContextProps) = 0;

    virtual HRESULT STDMETHODCALLTYPE Count(
        ULONG* pcelt) = 0;

};
#else
typedef struct IEnumContextPropsVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumContextProps* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumContextProps* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumContextProps* This);

    /*** IEnumContextProps methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumContextProps* This,
        ULONG celt,
        ContextProperty* pContextProperties,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumContextProps* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumContextProps* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumContextProps* This,
        IEnumContextProps** ppEnumContextProps);

    HRESULT (STDMETHODCALLTYPE *Count)(
        IEnumContextProps* This,
        ULONG* pcelt);

    END_INTERFACE
} IEnumContextPropsVtbl;
interface IEnumContextProps {
    const IEnumContextPropsVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IEnumContextProps_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumContextProps_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumContextProps_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumContextProps methods ***/
#define IEnumContextProps_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumContextProps_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumContextProps_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumContextProps_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#define IEnumContextProps_Count(p,a) (p)->lpVtbl->Count(p,a)
#endif

#endif

HRESULT CALLBACK IEnumContextProps_Next_Proxy(
    IEnumContextProps* This,
    ULONG celt,
    ContextProperty* pContextProperties,
    ULONG* pceltFetched);
void __RPC_STUB IEnumContextProps_Next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumContextProps_Skip_Proxy(
    IEnumContextProps* This,
    ULONG celt);
void __RPC_STUB IEnumContextProps_Skip_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumContextProps_Reset_Proxy(
    IEnumContextProps* This);
void __RPC_STUB IEnumContextProps_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumContextProps_Clone_Proxy(
    IEnumContextProps* This,
    IEnumContextProps** ppEnumContextProps);
void __RPC_STUB IEnumContextProps_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumContextProps_Count_Proxy(
    IEnumContextProps* This,
    ULONG* pcelt);
void __RPC_STUB IEnumContextProps_Count_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumContextProps_INTERFACE_DEFINED__ */

#ifndef __IContext_FWD_DEFINED__
#define __IContext_FWD_DEFINED__
typedef interface IContext IContext;
#endif

/*****************************************************************************
 * IContext interface
 */
#ifndef __IContext_INTERFACE_DEFINED__
#define __IContext_INTERFACE_DEFINED__

DEFINE_GUID(IID_IContext, 0x000001c0, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IContext : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetProperty(
        REFGUID policyId,
        CPFLAGS flags,
        IUnknown* pUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemovePropert(
        REFGUID policyId) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetProperty(
        REFGUID guid,
        CPFLAGS* pFlags,
        IUnknown** ppUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumContextProps(
        IEnumContextProps** ppEnumContextProps) = 0;

};
#else
typedef struct IContextVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IContext* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IContext* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IContext* This);

    /*** IContext methods ***/
    HRESULT (STDMETHODCALLTYPE *SetProperty)(
        IContext* This,
        REFGUID policyId,
        CPFLAGS flags,
        IUnknown* pUnk);

    HRESULT (STDMETHODCALLTYPE *RemovePropert)(
        IContext* This,
        REFGUID policyId);

    HRESULT (STDMETHODCALLTYPE *GetProperty)(
        IContext* This,
        REFGUID guid,
        CPFLAGS* pFlags,
        IUnknown** ppUnk);

    HRESULT (STDMETHODCALLTYPE *EnumContextProps)(
        IContext* This,
        IEnumContextProps** ppEnumContextProps);

    END_INTERFACE
} IContextVtbl;
interface IContext {
    const IContextVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IContext_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IContext_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IContext_Release(p) (p)->lpVtbl->Release(p)
/*** IContext methods ***/
#define IContext_SetProperty(p,a,b,c) (p)->lpVtbl->SetProperty(p,a,b,c)
#define IContext_RemovePropert(p,a) (p)->lpVtbl->RemovePropert(p,a)
#define IContext_GetProperty(p,a,b,c) (p)->lpVtbl->GetProperty(p,a,b,c)
#define IContext_EnumContextProps(p,a) (p)->lpVtbl->EnumContextProps(p,a)
#endif

#endif

HRESULT CALLBACK IContext_SetProperty_Proxy(
    IContext* This,
    REFGUID policyId,
    CPFLAGS flags,
    IUnknown* pUnk);
void __RPC_STUB IContext_SetProperty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IContext_RemovePropert_Proxy(
    IContext* This,
    REFGUID policyId);
void __RPC_STUB IContext_RemovePropert_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IContext_GetProperty_Proxy(
    IContext* This,
    REFGUID guid,
    CPFLAGS* pFlags,
    IUnknown** ppUnk);
void __RPC_STUB IContext_GetProperty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IContext_EnumContextProps_Proxy(
    IContext* This,
    IEnumContextProps** ppEnumContextProps);
void __RPC_STUB IContext_EnumContextProps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IContext_INTERFACE_DEFINED__ */

#endif /* defined USE_COM_CONTEXT_DEF */
/* Begin additional prototypes for all interfaces */

unsigned long   __RPC_USER FLAG_STGMEDIUM_UserSize     (unsigned long *, unsigned long,   FLAG_STGMEDIUM *);
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal  (unsigned long *, unsigned char *, FLAG_STGMEDIUM *);
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, FLAG_STGMEDIUM *);
void            __RPC_USER FLAG_STGMEDIUM_UserFree     (unsigned long *, FLAG_STGMEDIUM *);
unsigned long   __RPC_USER HGLOBAL_UserSize     (unsigned long *, unsigned long,   HGLOBAL *);
unsigned char * __RPC_USER HGLOBAL_UserMarshal  (unsigned long *, unsigned char *, HGLOBAL *);
unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(unsigned long *, unsigned char *, HGLOBAL *);
void            __RPC_USER HGLOBAL_UserFree     (unsigned long *, HGLOBAL *);
unsigned long   __RPC_USER HENHMETAFILE_UserSize     (unsigned long *, unsigned long,   HENHMETAFILE *);
unsigned char * __RPC_USER HENHMETAFILE_UserMarshal  (unsigned long *, unsigned char *, HENHMETAFILE *);
unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(unsigned long *, unsigned char *, HENHMETAFILE *);
void            __RPC_USER HENHMETAFILE_UserFree     (unsigned long *, HENHMETAFILE *);
unsigned long   __RPC_USER HMETAFILEPICT_UserSize     (unsigned long *, unsigned long,   HMETAFILEPICT *);
unsigned char * __RPC_USER HMETAFILEPICT_UserMarshal  (unsigned long *, unsigned char *, HMETAFILEPICT *);
unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(unsigned long *, unsigned char *, HMETAFILEPICT *);
void            __RPC_USER HMETAFILEPICT_UserFree     (unsigned long *, HMETAFILEPICT *);
unsigned long   __RPC_USER HBITMAP_UserSize     (unsigned long *, unsigned long,   HBITMAP *);
unsigned char * __RPC_USER HBITMAP_UserMarshal  (unsigned long *, unsigned char *, HBITMAP *);
unsigned char * __RPC_USER HBITMAP_UserUnmarshal(unsigned long *, unsigned char *, HBITMAP *);
void            __RPC_USER HBITMAP_UserFree     (unsigned long *, HBITMAP *);
unsigned long   __RPC_USER STGMEDIUM_UserSize     (unsigned long *, unsigned long,   STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserMarshal  (unsigned long *, unsigned char *, STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, STGMEDIUM *);
void            __RPC_USER STGMEDIUM_UserFree     (unsigned long *, STGMEDIUM *);
unsigned long   __RPC_USER ASYNC_STGMEDIUM_UserSize     (unsigned long *, unsigned long,   ASYNC_STGMEDIUM *);
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal  (unsigned long *, unsigned char *, ASYNC_STGMEDIUM *);
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, ASYNC_STGMEDIUM *);
void            __RPC_USER ASYNC_STGMEDIUM_UserFree     (unsigned long *, ASYNC_STGMEDIUM *);
unsigned long   __RPC_USER CLIPFORMAT_UserSize     (unsigned long *, unsigned long,   CLIPFORMAT *);
unsigned char * __RPC_USER CLIPFORMAT_UserMarshal  (unsigned long *, unsigned char *, CLIPFORMAT *);
unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(unsigned long *, unsigned char *, CLIPFORMAT *);
void            __RPC_USER CLIPFORMAT_UserFree     (unsigned long *, CLIPFORMAT *);
unsigned long   __RPC_USER SNB_UserSize     (unsigned long *, unsigned long,   SNB *);
unsigned char * __RPC_USER SNB_UserMarshal  (unsigned long *, unsigned char *, SNB *);
unsigned char * __RPC_USER SNB_UserUnmarshal(unsigned long *, unsigned char *, SNB *);
void            __RPC_USER SNB_UserFree     (unsigned long *, SNB *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_OBJIDL_H */
