//////////////////////////////////////////////////////////////////////////////
//
//  Detours Test Program (_win32.cpp of traceapi.dll)
//
//  Microsoft Research Detours Package
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//

///////////////////////////////////////////////////////////////// Trampolines.
//
int (__stdcall * Real_AbortDoc)(HDC a0)
    = AbortDoc;

BOOL (__stdcall * Real_AbortPath)(HDC a0)
    = AbortPath;

HKL (__stdcall * Real_ActivateKeyboardLayout)(HKL a0,
                                              UINT a1)
    = ActivateKeyboardLayout;

ATOM (__stdcall * Real_AddAtomA)(LPCSTR a0)
    = AddAtomA;

ATOM (__stdcall * Real_AddAtomW)(LPCWSTR a0)
    = AddAtomW;

int (__stdcall * Real_AddFontResourceA)(LPCSTR a0)
    = AddFontResourceA;

int (__stdcall * Real_AddFontResourceW)(LPCWSTR a0)
    = AddFontResourceW;

BOOL (__stdcall * Real_AdjustWindowRect)(LPRECT a0,
                                         DWORD a1,
                                         BOOL a2)
    = AdjustWindowRect;

BOOL (__stdcall * Real_AdjustWindowRectEx)(LPRECT a0,
                                           DWORD a1,
                                           BOOL a2,
                                           DWORD a3)
    = AdjustWindowRectEx;

BOOL (__stdcall * Real_AllocConsole)(void)
    = AllocConsole;

BOOL (__stdcall * Real_AngleArc)(HDC a0,
                                 int a1,
                                 int a2,
                                 DWORD a3,
                                 FLOAT a4,
                                 FLOAT a5)
    = AngleArc;

BOOL (__stdcall * Real_AnimatePalette)(HPALETTE a0,
                                       UINT a1,
                                       UINT a2,
                                       CONST PALETTEENTRY* a3)
    = AnimatePalette;

BOOL (__stdcall * Real_AnyPopup)(void)
    = AnyPopup;

BOOL (__stdcall * Real_AppendMenuA)(HMENU a0,
                                    UINT a1,
                                    UINT_PTR a2,
                                    LPCSTR a3)
    = AppendMenuA;

BOOL (__stdcall * Real_AppendMenuW)(HMENU a0,
                                    UINT a1,
                                    UINT_PTR a2,
                                    LPCWSTR a3)
    = AppendMenuW;

BOOL (__stdcall * Real_Arc)(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4,
                            int a5,
                            int a6,
                            int a7,
                            int a8)
    = Arc;

BOOL (__stdcall * Real_ArcTo)(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4,
                              int a5,
                              int a6,
                              int a7,
                              int a8)
    = ArcTo;

BOOL (__stdcall * Real_AreFileApisANSI)(void)
    = AreFileApisANSI;

UINT (__stdcall * Real_ArrangeIconicWindows)(HWND a0)
    = ArrangeIconicWindows;

BOOL (__stdcall * Real_AttachThreadInput)(DWORD a0,
                                          DWORD a1,
                                          BOOL a2)
    = AttachThreadInput;

BOOL (__stdcall * Real_BackupRead)(HANDLE a0,
                                   LPBYTE a1,
                                   DWORD a2,
                                   LPDWORD a3,
                                   BOOL a4,
                                   BOOL a5,
                                   LPVOID* a6)
    = BackupRead;

BOOL (__stdcall * Real_BackupSeek)(HANDLE a0,
                                   DWORD a1,
                                   DWORD a2,
                                   LPDWORD a3,
                                   LPDWORD a4,
                                   LPVOID* a5)
    = BackupSeek;

BOOL (__stdcall * Real_BackupWrite)(HANDLE a0,
                                    LPBYTE a1,
                                    DWORD a2,
                                    LPDWORD a3,
                                    BOOL a4,
                                    BOOL a5,
                                    LPVOID* a6)
    = BackupWrite;

BOOL (__stdcall * Real_Beep)(DWORD a0,
                             DWORD a1)
    = Beep;

HDWP (__stdcall * Real_BeginDeferWindowPos)(int a0)
    = BeginDeferWindowPos;

HDC (__stdcall * Real_BeginPaint)(HWND a0,
                                  LPPAINTSTRUCT a1)
    = BeginPaint;

BOOL (__stdcall * Real_BeginPath)(HDC a0)
    = BeginPath;

HANDLE (__stdcall * Real_BeginUpdateResourceA)(LPCSTR a0,
                                               BOOL a1)
    = BeginUpdateResourceA;

HANDLE (__stdcall * Real_BeginUpdateResourceW)(LPCWSTR a0,
                                               BOOL a1)
    = BeginUpdateResourceW;

HRESULT (__stdcall * Real_BindMoniker)(IMoniker* a0,
                                       DWORD a1,
                                       CONST IID& a2,
                                       LPVOID* a3)
    = BindMoniker;

BOOL (__stdcall * Real_BitBlt)(HDC a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               HDC a5,
                               int a6,
                               int a7,
                               DWORD a8)
    = BitBlt;

BOOL (__stdcall * Real_BringWindowToTop)(HWND a0)
    = BringWindowToTop;

long (__stdcall * Real_BroadcastSystemMessageA)(DWORD a0,
                                                LPDWORD a1,
                                                UINT a2,
                                                WPARAM a3,
                                                LPARAM a4)
    = BroadcastSystemMessageA;

long (__stdcall * Real_BroadcastSystemMessageW)(DWORD a0,
                                                LPDWORD a1,
                                                UINT a2,
                                                WPARAM a3,
                                                LPARAM a4)
    = BroadcastSystemMessageW;

BOOL (__stdcall * Real_BuildCommDCBA)(LPCSTR a0,
                                      LPDCB a1)
    = BuildCommDCBA;

BOOL (__stdcall * Real_BuildCommDCBAndTimeoutsA)(LPCSTR a0,
                                                 LPDCB a1,
                                                 LPCOMMTIMEOUTS a2)
    = BuildCommDCBAndTimeoutsA;

BOOL (__stdcall * Real_BuildCommDCBAndTimeoutsW)(LPCWSTR a0,
                                                 LPDCB a1,
                                                 LPCOMMTIMEOUTS a2)
    = BuildCommDCBAndTimeoutsW;

BOOL (__stdcall * Real_BuildCommDCBW)(LPCWSTR a0,
                                      LPDCB a1)
    = BuildCommDCBW;

HRESULT (__stdcall * Real_CLSIDFromProgID)(LPCOLESTR a0,
                                           LPGUID a1)
    = CLSIDFromProgID;

#ifdef _WIN32_WINNT_WIN7
HRESULT (__stdcall * Real_CLSIDFromString)(LPCOLESTR a0,
                                           LPGUID a1)
    = CLSIDFromString;
#else
HRESULT (__stdcall * Real_CLSIDFromString)(LPOLESTR a0,
                                           LPGUID a1)
    = CLSIDFromString;
#endif

BOOL (__stdcall * Real_CallMsgFilterA)(LPMSG a0,
                                       int a1)
    = CallMsgFilterA;

BOOL (__stdcall * Real_CallMsgFilterW)(LPMSG a0,
                                       int a1)
    = CallMsgFilterW;

BOOL (__stdcall * Real_CallNamedPipeA)(LPCSTR a0,
                                       LPVOID a1,
                                       DWORD a2,
                                       LPVOID a3,
                                       DWORD a4,
                                       LPDWORD a5,
                                       DWORD a6)
    = CallNamedPipeA;

BOOL (__stdcall * Real_CallNamedPipeW)(LPCWSTR a0,
                                       LPVOID a1,
                                       DWORD a2,
                                       LPVOID a3,
                                       DWORD a4,
                                       LPDWORD a5,
                                       DWORD a6)
    = CallNamedPipeW;

LRESULT (__stdcall * Real_CallNextHookEx)(HHOOK a0,
                                          int a1,
                                          WPARAM a2,
                                          LPARAM a3)
    = CallNextHookEx;

LRESULT (__stdcall * Real_CallWindowProcA)(WNDPROC a0,
                                           HWND a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
    = CallWindowProcA;

LRESULT (__stdcall * Real_CallWindowProcW)(WNDPROC a0,
                                           HWND a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
    = CallWindowProcW;

BOOL (__stdcall * Real_CancelDC)(HDC a0)
    = CancelDC;

BOOL (__stdcall * Real_CancelIo)(HANDLE a0)
    = CancelIo;

BOOL (__stdcall * Real_CancelWaitableTimer)(HANDLE a0)
    = CancelWaitableTimer;

WORD (__stdcall * Real_CascadeWindows)(HWND a0,
                                       UINT a1,
                                       CONST RECT* a2,
                                       UINT a3,
                                       CONST HWND * a4)
    = CascadeWindows;

BOOL (__stdcall * Real_ChangeClipboardChain)(HWND a0,
                                             HWND a1)
    = ChangeClipboardChain;

LONG (__stdcall * Real_ChangeDisplaySettingsA)(LPDEVMODEA a0,
                                               DWORD a1)
    = ChangeDisplaySettingsA;

LONG (__stdcall * Real_ChangeDisplaySettingsExA)(LPCSTR a0,
                                                 LPDEVMODEA a1,
                                                 HWND a2,
                                                 DWORD a3,
                                                 LPVOID a4)
    = ChangeDisplaySettingsExA;

LONG (__stdcall * Real_ChangeDisplaySettingsExW)(LPCWSTR a0,
                                                 LPDEVMODEW a1,
                                                 HWND a2,
                                                 DWORD a3,
                                                 LPVOID a4)
    = ChangeDisplaySettingsExW;

LONG (__stdcall * Real_ChangeDisplaySettingsW)(LPDEVMODEW a0,
                                               DWORD a1)
    = ChangeDisplaySettingsW;

BOOL (__stdcall * Real_ChangeMenuA)(HMENU a0,
                                    UINT a1,
                                    LPCSTR a2,
                                    UINT a3,
                                    UINT a4)
    = ChangeMenuA;

BOOL (__stdcall * Real_ChangeMenuW)(HMENU a0,
                                    UINT a1,
                                    LPCWSTR a2,
                                    UINT a3,
                                    UINT a4)
    = ChangeMenuW;

LPSTR (__stdcall * Real_CharLowerA)(LPSTR a0)
    = CharLowerA;

DWORD (__stdcall * Real_CharLowerBuffA)(LPSTR a0,
                                        DWORD a1)
    = CharLowerBuffA;

DWORD (__stdcall * Real_CharLowerBuffW)(LPWSTR a0,
                                        DWORD a1)
    = CharLowerBuffW;

LPWSTR (__stdcall * Real_CharLowerW)(LPWSTR a0)
    = CharLowerW;

LPSTR (__stdcall * Real_CharNextA)(LPCSTR a0)
    = CharNextA;

LPSTR (__stdcall * Real_CharNextExA)(WORD a0,
                                     LPCSTR a1,
                                     DWORD a2)
    = CharNextExA;

LPWSTR (__stdcall * Real_CharNextW)(LPCWSTR a0)
    = CharNextW;

LPSTR (__stdcall * Real_CharPrevA)(LPCSTR a0,
                                   LPCSTR a1)
    = CharPrevA;

LPSTR (__stdcall * Real_CharPrevExA)(WORD a0,
                                     LPCSTR a1,
                                     LPCSTR a2,
                                     DWORD a3)
    = CharPrevExA;

LPWSTR (__stdcall * Real_CharPrevW)(LPCWSTR a0,
                                    LPCWSTR a1)
    = CharPrevW;

BOOL (__stdcall * Real_CharToOemA)(LPCSTR a0,
                                   LPSTR a1)
    = CharToOemA;

BOOL (__stdcall * Real_CharToOemBuffA)(LPCSTR a0,
                                       LPSTR a1,
                                       DWORD a2)
    = CharToOemBuffA;

BOOL (__stdcall * Real_CharToOemBuffW)(LPCWSTR a0,
                                       LPSTR a1,
                                       DWORD a2)
    = CharToOemBuffW;

BOOL (__stdcall * Real_CharToOemW)(LPCWSTR a0,
                                   LPSTR a1)
    = CharToOemW;

LPSTR (__stdcall * Real_CharUpperA)(LPSTR a0)
    = CharUpperA;

DWORD (__stdcall * Real_CharUpperBuffA)(LPSTR a0,
                                        DWORD a1)
    = CharUpperBuffA;

DWORD (__stdcall * Real_CharUpperBuffW)(LPWSTR a0,
                                        DWORD a1)
    = CharUpperBuffW;

LPWSTR (__stdcall * Real_CharUpperW)(LPWSTR a0)
    = CharUpperW;

BOOL (__stdcall * Real_CheckColorsInGamut)(
                                           HDC a0,
#ifdef GDIPLUS_TS_QUERYVER
                                           LPRGBTRIPLE a1,
#else
                                           LPVOID a1,
#endif
                                           LPVOID a2,
                                           DWORD a3
                                          )
    = CheckColorsInGamut;

BOOL (__stdcall * Real_CheckDlgButton)(HWND a0,
                                       int a1,
                                       UINT a2)
    = CheckDlgButton;

DWORD (__stdcall * Real_CheckMenuItem)(HMENU a0,
                                       UINT a1,
                                       UINT a2)
    = CheckMenuItem;

BOOL (__stdcall * Real_CheckMenuRadioItem)(HMENU a0,
                                           UINT a1,
                                           UINT a2,
                                           UINT a3,
                                           UINT a4)
    = CheckMenuRadioItem;

BOOL (__stdcall * Real_CheckRadioButton)(HWND a0,
                                         int a1,
                                         int a2,
                                         int a3)
    = CheckRadioButton;

HWND (__stdcall * Real_ChildWindowFromPoint)(HWND a0,
                                             POINT a1)
    = ChildWindowFromPoint;

HWND (__stdcall * Real_ChildWindowFromPointEx)(HWND a0,
                                               POINT a1,
                                               UINT a2)
    = ChildWindowFromPointEx;

int (__stdcall * Real_ChoosePixelFormat)(HDC a0,
                                         CONST PIXELFORMATDESCRIPTOR* a1)
    = ChoosePixelFormat;

BOOL (__stdcall * Real_Chord)(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4,
                              int a5,
                              int a6,
                              int a7,
                              int a8)
    = Chord;

BOOL (__stdcall * Real_ClearCommBreak)(HANDLE a0)
    = ClearCommBreak;

BOOL (__stdcall * Real_ClearCommError)(HANDLE a0,
                                       LPDWORD a1,
                                       LPCOMSTAT a2)
    = ClearCommError;

BOOL (__stdcall * Real_ClientToScreen)(HWND a0,
                                       LPPOINT a1)
    = ClientToScreen;

BOOL (__stdcall * Real_ClipCursor)(CONST RECT* a0)
    = ClipCursor;

BOOL (__stdcall * Real_CloseClipboard)(void)
    = CloseClipboard;

BOOL (__stdcall * Real_CloseDesktop)(HDESK a0)
    = CloseDesktop;

HENHMETAFILE (__stdcall * Real_CloseEnhMetaFile)(HDC a0)
    = CloseEnhMetaFile;

BOOL (__stdcall * Real_CloseFigure)(HDC a0)
    = CloseFigure;

BOOL (__stdcall * Real_CloseHandle)(HANDLE a0)
    = CloseHandle;

HMETAFILE (__stdcall * Real_CloseMetaFile)(HDC a0)
    = CloseMetaFile;

BOOL (__stdcall * Real_CloseWindow)(HWND a0)
    = CloseWindow;

BOOL (__stdcall * Real_CloseWindowStation)(HWINSTA a0)
    = CloseWindowStation;

ULONG (__stdcall * Real_CoAddRefServerProcess)(void)
    = CoAddRefServerProcess;

DWORD (__stdcall * Real_CoBuildVersion)(void)
    = CoBuildVersion;

HRESULT (__stdcall * Real_CoCopyProxy)(IUnknown* a0,
                                       IUnknown** a1)
    = CoCopyProxy;

HRESULT (__stdcall * Real_CoCreateFreeThreadedMarshaler)(LPUNKNOWN a0,
                                                         LPUNKNOWN* a1)
    = CoCreateFreeThreadedMarshaler;

HRESULT (__stdcall * Real_CoCreateGuid)(GUID* a0)
    = CoCreateGuid;

HRESULT (__stdcall * Real_CoCreateInstance)(CONST IID& a0,
                                            LPUNKNOWN a1,
                                            DWORD a2,
                                            CONST IID& a3,
                                            LPVOID* a4)
    = CoCreateInstance;

HRESULT (__stdcall * Real_CoCreateInstanceEx)(CONST IID& a0,
                                              IUnknown* a1,
                                              DWORD a2,
                                              COSERVERINFO* a3,
                                              DWORD a4,
                                              MULTI_QI* a5)
    = CoCreateInstanceEx;

HRESULT (__stdcall * Real_CoDisconnectObject)(LPUNKNOWN a0,
                                              DWORD a1)
    = CoDisconnectObject;

BOOL (__stdcall * Real_CoDosDateTimeToFileTime)(WORD a0,
                                                WORD a1,
                                                FILETIME* a2)
    = CoDosDateTimeToFileTime;

HRESULT (__stdcall * Real_CoFileTimeNow)(FILETIME* a0)
    = CoFileTimeNow;

BOOL (__stdcall * Real_CoFileTimeToDosDateTime)(FILETIME* a0,
                                                LPWORD a1,
                                                LPWORD a2)
    = CoFileTimeToDosDateTime;

void (__stdcall * Real_CoFreeAllLibraries)(void)
    = CoFreeAllLibraries;

void (__stdcall * Real_CoFreeLibrary)(HINSTANCE a0)
    = CoFreeLibrary;

void (__stdcall * Real_CoFreeUnusedLibraries)(void)
    = CoFreeUnusedLibraries;

HRESULT (__stdcall * Real_CoGetCallContext)(CONST IID& a0,
                                            void** a1)
    = CoGetCallContext;

HRESULT (__stdcall * Real_CoGetClassObject)(CONST IID& a0,
                                            DWORD a1,
                                            LPVOID a2,
                                            CONST IID& a3,
                                            LPVOID* a4)
    = CoGetClassObject;

DWORD (__stdcall * Real_CoGetCurrentProcess)(void)
    = CoGetCurrentProcess;

HRESULT (__stdcall * Real_CoGetInstanceFromFile)(COSERVERINFO* a0,
                                                 CLSID* a1,
                                                 IUnknown* a2,
                                                 DWORD a3,
                                                 DWORD a4,
                                                 OLECHAR* a5,
                                                 DWORD a6,
                                                 MULTI_QI* a7)
    = CoGetInstanceFromFile;

HRESULT (__stdcall * Real_CoGetInstanceFromIStorage)(COSERVERINFO* a0,
                                                     CLSID* a1,
                                                     IUnknown* a2,
                                                     DWORD a3,
                                                     IStorage* a4,
                                                     DWORD a5,
                                                     MULTI_QI* a6)
    = CoGetInstanceFromIStorage;

HRESULT (__stdcall * Real_CoGetInterfaceAndReleaseStream)(LPSTREAM a0,
                                                          CONST IID& a1,
                                                          LPVOID* a2)
    = CoGetInterfaceAndReleaseStream;

HRESULT (__stdcall * Real_CoGetMalloc)(DWORD a0,
                                       IMalloc** a1)
    = CoGetMalloc;

HRESULT (__stdcall * Real_CoGetMarshalSizeMax)(ULONG* a0,
                                               CONST IID& a1,
                                               LPUNKNOWN a2,
                                               DWORD a3,
                                               LPVOID a4,
                                               DWORD a5)
    = CoGetMarshalSizeMax;

HRESULT (__stdcall * Real_CoGetObject)(LPCWSTR a0,
                                       BIND_OPTS* a1,
                                       CONST IID& a2,
                                       void** a3)
    = CoGetObject;

HRESULT (__stdcall * Real_CoGetPSClsid)(CONST IID& a0,
                                        CLSID* a1)
    = CoGetPSClsid;

HRESULT (__stdcall * Real_CoGetStandardMarshal)(CONST IID& a0,
                                                LPUNKNOWN a1,
                                                DWORD a2,
                                                LPVOID a3,
                                                DWORD a4,
                                                IMarshal** a5)
    = CoGetStandardMarshal;

HRESULT (__stdcall * Real_CoGetStdMarshalEx)(LPUNKNOWN a0,
                                             DWORD a1,
                                             LPUNKNOWN* a2)
    = CoGetStdMarshalEx;

HRESULT (__stdcall * Real_CoGetTreatAsClass)(CONST IID& a0,
                                             LPGUID a1)
    = CoGetTreatAsClass;

HRESULT (__stdcall * Real_CoImpersonateClient)(void)
    = CoImpersonateClient;

HRESULT (__stdcall * Real_CoInitialize)(LPVOID a0)
    = CoInitialize;

HRESULT (__stdcall * Real_CoInitializeEx)(LPVOID a0,
                                          DWORD a1)
    = CoInitializeEx;

HRESULT (__stdcall * Real_CoInitializeSecurity)(PSECURITY_DESCRIPTOR a0,
                                                LONG a1,
                                                SOLE_AUTHENTICATION_SERVICE* a2,
                                                void* a3,
                                                DWORD a4,
                                                DWORD a5,
                                                void* a6,
                                                DWORD a7,
                                                void* a8)
    = CoInitializeSecurity;

BOOL (__stdcall * Real_CoIsHandlerConnected)(LPUNKNOWN a0)
    = CoIsHandlerConnected;

BOOL (__stdcall * Real_CoIsOle1Class)(CONST IID& a0)
    = CoIsOle1Class;

HINSTANCE (__stdcall * Real_CoLoadLibrary)(LPOLESTR a0,
                                           BOOL a1)
    = CoLoadLibrary;

HRESULT (__stdcall * Real_CoLockObjectExternal)(LPUNKNOWN a0,
                                                BOOL a1,
                                                BOOL a2)
    = CoLockObjectExternal;

HRESULT (__stdcall * Real_CoMarshalHresult)(LPSTREAM a0,
                                            HRESULT a1)
    = CoMarshalHresult;

HRESULT (__stdcall * Real_CoMarshalInterThreadInterfaceInStream)(CONST IID& a0,
                                                                 LPUNKNOWN a1,
                                                                 LPSTREAM* a2)
    = CoMarshalInterThreadInterfaceInStream;

HRESULT (__stdcall * Real_CoMarshalInterface)(LPSTREAM a0,
                                              CONST IID& a1,
                                              LPUNKNOWN a2,
                                              DWORD a3,
                                              LPVOID a4,
                                              DWORD a5)
    = CoMarshalInterface;

HRESULT (__stdcall * Real_CoQueryAuthenticationServices)(DWORD* a0,
                                                         SOLE_AUTHENTICATION_SERVICE** a1)
    = CoQueryAuthenticationServices;

HRESULT (__stdcall * Real_CoQueryClientBlanket)(DWORD* a0,
                                                DWORD* a1,
                                                OLECHAR** a2,
                                                DWORD* a3,
                                                DWORD* a4,
                                                RPC_AUTHZ_HANDLE* a5,
                                                DWORD* a6)
    = CoQueryClientBlanket;

HRESULT (__stdcall * Real_CoQueryProxyBlanket)(IUnknown* a0,
                                               DWORD* a1,
                                               DWORD* a2,
                                               OLECHAR** a3,
                                               DWORD* a4,
                                               DWORD* a5,
                                               RPC_AUTH_IDENTITY_HANDLE* a6,
                                               DWORD* a7)
    = CoQueryProxyBlanket;

HRESULT (__stdcall * Real_CoRegisterChannelHook)(CONST GUID& a0,
                                                 IChannelHook* a1)
    = CoRegisterChannelHook;

HRESULT (__stdcall * Real_CoRegisterClassObject)(CONST IID& a0,
                                                 LPUNKNOWN a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 LPDWORD a4)
    = CoRegisterClassObject;

HRESULT (__stdcall * Real_CoRegisterMallocSpy)(IMallocSpy* a0)
    = CoRegisterMallocSpy;

HRESULT (__stdcall * Real_CoRegisterMessageFilter)(LPMESSAGEFILTER a0,
                                                   LPMESSAGEFILTER* a1)
    = CoRegisterMessageFilter;

HRESULT (__stdcall * Real_CoRegisterPSClsid)(CONST IID& a0,
                                             CONST IID& a1)
    = CoRegisterPSClsid;

HRESULT (__stdcall * Real_CoRegisterSurrogate)(LPSURROGATE a0)
    = CoRegisterSurrogate;

HRESULT (__stdcall * Real_CoReleaseMarshalData)(LPSTREAM a0)
    = CoReleaseMarshalData;

ULONG (__stdcall * Real_CoReleaseServerProcess)(void)
    = CoReleaseServerProcess;

HRESULT (__stdcall * Real_CoResumeClassObjects)(void)
    = CoResumeClassObjects;

HRESULT (__stdcall * Real_CoRevertToSelf)(void)
    = CoRevertToSelf;

HRESULT (__stdcall * Real_CoRevokeClassObject)(DWORD a0)
    = CoRevokeClassObject;

HRESULT (__stdcall * Real_CoRevokeMallocSpy)(void)
    = CoRevokeMallocSpy;

HRESULT (__stdcall * Real_CoSetProxyBlanket)(IUnknown* a0,
                                             DWORD a1,
                                             DWORD a2,
                                             OLECHAR* a3,
                                             DWORD a4,
                                             DWORD a5,
                                             RPC_AUTH_IDENTITY_HANDLE a6,
                                             DWORD a7)
    = CoSetProxyBlanket;

HRESULT (__stdcall * Real_CoSuspendClassObjects)(void)
    = CoSuspendClassObjects;

HRESULT (__stdcall * Real_CoSwitchCallContext)(IUnknown* a0,
                                               IUnknown** a1)
    = CoSwitchCallContext;

LPVOID (__stdcall * Real_CoTaskMemAlloc)(SIZE_T a0)
    = CoTaskMemAlloc;

void (__stdcall * Real_CoTaskMemFree)(LPVOID a0)
    = CoTaskMemFree;

LPVOID (__stdcall * Real_CoTaskMemRealloc)(LPVOID a0,
                                           SIZE_T a1)
    = CoTaskMemRealloc;

HRESULT (__stdcall * Real_CoTreatAsClass)(CONST IID& a0,
                                          CONST IID& a1)
    = CoTreatAsClass;

void (__stdcall * Real_CoUninitialize)(void)
    = CoUninitialize;

HRESULT (__stdcall * Real_CoUnmarshalHresult)(LPSTREAM a0,
                                              HRESULT* a1)
    = CoUnmarshalHresult;

HRESULT (__stdcall * Real_CoUnmarshalInterface)(LPSTREAM a0,
                                                CONST IID& a1,
                                                LPVOID* a2)
    = CoUnmarshalInterface;

BOOL (__stdcall * Real_ColorMatchToTarget)(HDC a0,
                                           HDC a1,
                                           DWORD a2)
    = ColorMatchToTarget;

int (__stdcall * Real_CombineRgn)(HRGN a0,
                                  HRGN a1,
                                  HRGN a2,
                                  int a3)
    = CombineRgn;

BOOL (__stdcall * Real_CombineTransform)(LPXFORM a0,
                                         CONST XFORM* a1,
                                         CONST XFORM* a2)
    = CombineTransform;

BOOL (__stdcall * Real_CommConfigDialogA)(LPCSTR a0,
                                          HWND a1,
                                          LPCOMMCONFIG a2)
    = CommConfigDialogA;

BOOL (__stdcall * Real_CommConfigDialogW)(LPCWSTR a0,
                                          HWND a1,
                                          LPCOMMCONFIG a2)
    = CommConfigDialogW;

LONG (__stdcall * Real_CompareFileTime)(CONST FILETIME* a0,
                                        CONST FILETIME* a1)
    = CompareFileTime;

int (__stdcall * Real_CompareStringA)(LCID a0,
                                      DWORD a1,
                                      LPCSTR a2,
                                      int a3,
                                      LPCSTR a4,
                                      int a5)
    = CompareStringA;

int (__stdcall * Real_CompareStringW)(LCID a0,
                                      DWORD a1,
                                      LPCWSTR a2,
                                      int a3,
                                      LPCWSTR a4,
                                      int a5)
    = CompareStringW;

BOOL (__stdcall * Real_ConnectNamedPipe)(HANDLE a0,
                                         LPOVERLAPPED a1)
    = ConnectNamedPipe;

#if !defined(DETOURS_ARM)
BOOL (__stdcall * Real_ContinueDebugEvent)(DWORD a0,
                                           DWORD a1,
                                           DWORD a2)
    = ContinueDebugEvent;
#endif // !DETOURS_ARM

LCID (__stdcall * Real_ConvertDefaultLocale)(LCID a0)
    = ConvertDefaultLocale;

LPVOID (__stdcall * Real_ConvertThreadToFiber)(LPVOID a0)
    = ConvertThreadToFiber;

int (__stdcall * Real_CopyAcceleratorTableA)(HACCEL a0,
                                             LPACCEL a1,
                                             int a2)
    = CopyAcceleratorTableA;

int (__stdcall * Real_CopyAcceleratorTableW)(HACCEL a0,
                                             LPACCEL a1,
                                             int a2)
    = CopyAcceleratorTableW;

HENHMETAFILE (__stdcall * Real_CopyEnhMetaFileA)(HENHMETAFILE a0,
                                                 LPCSTR a1)
    = CopyEnhMetaFileA;

HENHMETAFILE (__stdcall * Real_CopyEnhMetaFileW)(HENHMETAFILE a0,
                                                 LPCWSTR a1)
    = CopyEnhMetaFileW;

BOOL (__stdcall * Real_CopyFileA)(LPCSTR a0,
                                  LPCSTR a1,
                                  BOOL a2)
    = CopyFileA;

BOOL (__stdcall * Real_CopyFileExA)(LPCSTR a0,
                                    LPCSTR a1,
                                    LPPROGRESS_ROUTINE a2,
                                    LPVOID a3,
                                    LPBOOL a4,
                                    DWORD a5)
    = CopyFileExA;

BOOL (__stdcall * Real_CopyFileExW)(LPCWSTR a0,
                                    LPCWSTR a1,
                                    LPPROGRESS_ROUTINE a2,
                                    LPVOID a3,
                                    LPBOOL a4,
                                    DWORD a5)
    = CopyFileExW;

BOOL (__stdcall * Real_CopyFileW)(LPCWSTR a0,
                                  LPCWSTR a1,
                                  BOOL a2)
    = CopyFileW;

HICON (__stdcall * Real_CopyIcon)(HICON a0)
    = CopyIcon;

HANDLE (__stdcall * Real_CopyImage)(HANDLE a0,
                                    UINT a1,
                                    int a2,
                                    int a3,
                                    UINT a4)
    = CopyImage;

HMETAFILE (__stdcall * Real_CopyMetaFileA)(HMETAFILE a0,
                                           LPCSTR a1)
    = CopyMetaFileA;

HMETAFILE (__stdcall * Real_CopyMetaFileW)(HMETAFILE a0,
                                           LPCWSTR a1)
    = CopyMetaFileW;

BOOL (__stdcall * Real_CopyRect)(LPRECT a0,
                                 CONST RECT* a1)
    = CopyRect;

int (__stdcall * Real_CountClipboardFormats)(void)
    = CountClipboardFormats;

HACCEL (__stdcall * Real_CreateAcceleratorTableA)(LPACCEL a0,
                                                  int a1)
    = CreateAcceleratorTableA;

HACCEL (__stdcall * Real_CreateAcceleratorTableW)(LPACCEL a0,
                                                  int a1)
    = CreateAcceleratorTableW;

HRESULT (__stdcall * Real_CreateAntiMoniker)(IMoniker** a0)
    = CreateAntiMoniker;

HRESULT (__stdcall * Real_CreateBindCtx)(DWORD a0,
                                         IBindCtx** a1)
    = CreateBindCtx;

HBITMAP (__stdcall * Real_CreateBitmap)(int a0,
                                        int a1,
                                        UINT a2,
                                        UINT a3,
                                        CONST void* a4)
    = CreateBitmap;

HBITMAP (__stdcall * Real_CreateBitmapIndirect)(CONST BITMAP* a0)
    = CreateBitmapIndirect;

HBRUSH (__stdcall * Real_CreateBrushIndirect)(CONST LOGBRUSH* a0)
    = CreateBrushIndirect;

BOOL (__stdcall * Real_CreateCaret)(HWND a0,
                                    HBITMAP a1,
                                    int a2,
                                    int a3)
    = CreateCaret;

HRESULT (__stdcall * Real_CreateClassMoniker)(CONST IID& a0,
                                              IMoniker** a1)
    = CreateClassMoniker;

HCOLORSPACE (__stdcall * Real_CreateColorSpaceA)(LPLOGCOLORSPACEA a0)
    = CreateColorSpaceA;

HCOLORSPACE (__stdcall * Real_CreateColorSpaceW)(LPLOGCOLORSPACEW a0)
    = CreateColorSpaceW;

HBITMAP (__stdcall * Real_CreateCompatibleBitmap)(HDC a0,
                                                  int a1,
                                                  int a2)
    = CreateCompatibleBitmap;

HDC (__stdcall * Real_CreateCompatibleDC)(HDC a0)
    = CreateCompatibleDC;

HANDLE (__stdcall * Real_CreateConsoleScreenBuffer)(DWORD a0,
                                                    DWORD a1,
                                                    CONST SECURITY_ATTRIBUTES* a2,
                                                    DWORD a3,
                                                    LPVOID a4)
    = CreateConsoleScreenBuffer;

HCURSOR (__stdcall * Real_CreateCursor)(HINSTANCE a0,
                                        int a1,
                                        int a2,
                                        int a3,
                                        int a4,
                                        CONST void* a5,
                                        CONST void* a6)
    = CreateCursor;

HDC (__stdcall * Real_CreateDCA)(LPCSTR a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 CONST DEVMODEA * a3)
    = CreateDCA;

HDC (__stdcall * Real_CreateDCW)(LPCWSTR a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 CONST DEVMODEW * a3)
    = CreateDCW;

HBRUSH (__stdcall * Real_CreateDIBPatternBrush)(HGLOBAL a0,
                                                UINT a1)
    = CreateDIBPatternBrush;

HBRUSH (__stdcall * Real_CreateDIBPatternBrushPt)(CONST void* a0,
                                                  UINT a1)
    = CreateDIBPatternBrushPt;

HBITMAP (__stdcall * Real_CreateDIBSection)(HDC a0,
                                            CONST BITMAPINFO* a1,
                                            UINT a2,
                                            void** a3,
                                            HANDLE a4,
                                            DWORD a5)
    = CreateDIBSection;

HBITMAP (__stdcall * Real_CreateDIBitmap)(HDC a0,
                                          CONST BITMAPINFOHEADER* a1,
                                          DWORD a2,
                                          CONST void* a3,
                                          CONST BITMAPINFO* a4,
                                          UINT a5)
    = CreateDIBitmap;

HRESULT (__stdcall * Real_CreateDataAdviseHolder)(LPDATAADVISEHOLDER* a0)
    = CreateDataAdviseHolder;

HRESULT (__stdcall * Real_CreateDataCache)(LPUNKNOWN a0,
                                           CONST IID& a1,
                                           CONST IID& a2,
                                           LPVOID* a3)
    = CreateDataCache;

#if _MSC_VER < 1300
HDESK (__stdcall * Real_CreateDesktopA)(LPSTR a0,
                                        LPSTR a1,
                                        LPDEVMODEA a2,
                                        DWORD a3,
                                        ACCESS_MASK a4,
                                        LPSECURITY_ATTRIBUTES a5)
    = CreateDesktopA;
#else
HDESK (__stdcall * Real_CreateDesktopA)(LPCSTR a0,
                                        LPCSTR a1,
                                        LPDEVMODEA a2,
                                        DWORD a3,
                                        ACCESS_MASK a4,
                                        LPSECURITY_ATTRIBUTES a5)
    = CreateDesktopA;

#endif

#if _MSC_VER < 1300
HDESK (__stdcall * Real_CreateDesktopW)(LPWSTR a0,
                                        LPWSTR a1,
                                        LPDEVMODEW a2,
                                        DWORD a3,
                                        ACCESS_MASK a4,
                                        LPSECURITY_ATTRIBUTES a5)
    = CreateDesktopW;
#else
HDESK (__stdcall * Real_CreateDesktopW)(LPCWSTR a0,
                                        LPCWSTR a1,
                                        LPDEVMODEW a2,
                                        DWORD a3,
                                        ACCESS_MASK a4,
                                        LPSECURITY_ATTRIBUTES a5)
    = CreateDesktopW;
#endif

HWND (__stdcall * Real_CreateDialogIndirectParamA)(HINSTANCE a0,
                                                   LPCDLGTEMPLATEA a1,
                                                   HWND a2,
                                                   DLGPROC a3,
                                                   LPARAM a4)
    = CreateDialogIndirectParamA;

HWND (__stdcall * Real_CreateDialogIndirectParamW)(HINSTANCE a0,
                                                   LPCDLGTEMPLATEW a1,
                                                   HWND a2,
                                                   DLGPROC a3,
                                                   LPARAM a4)
    = CreateDialogIndirectParamW;

HWND (__stdcall * Real_CreateDialogParamA)(HINSTANCE a0,
                                           LPCSTR a1,
                                           HWND a2,
                                           DLGPROC a3,
                                           LPARAM a4)
    = CreateDialogParamA;

HWND (__stdcall * Real_CreateDialogParamW)(HINSTANCE a0,
                                           LPCWSTR a1,
                                           HWND a2,
                                           DLGPROC a3,
                                           LPARAM a4)
    = CreateDialogParamW;

BOOL (__stdcall * Real_CreateDirectoryA)(LPCSTR a0,
                                         LPSECURITY_ATTRIBUTES a1)
    = CreateDirectoryA;

BOOL (__stdcall * Real_CreateDirectoryExA)(LPCSTR a0,
                                           LPCSTR a1,
                                           LPSECURITY_ATTRIBUTES a2)
    = CreateDirectoryExA;

BOOL (__stdcall * Real_CreateDirectoryExW)(LPCWSTR a0,
                                           LPCWSTR a1,
                                           LPSECURITY_ATTRIBUTES a2)
    = CreateDirectoryExW;

BOOL (__stdcall * Real_CreateDirectoryW)(LPCWSTR a0,
                                         LPSECURITY_ATTRIBUTES a1)
    = CreateDirectoryW;

HBITMAP (__stdcall * Real_CreateDiscardableBitmap)(HDC a0,
                                                   int a1,
                                                   int a2)
    = CreateDiscardableBitmap;

HRGN (__stdcall * Real_CreateEllipticRgn)(int a0,
                                          int a1,
                                          int a2,
                                          int a3)
    = CreateEllipticRgn;

HRGN (__stdcall * Real_CreateEllipticRgnIndirect)(CONST RECT* a0)
    = CreateEllipticRgnIndirect;

HDC (__stdcall * Real_CreateEnhMetaFileA)(HDC a0,
                                          LPCSTR a1,
                                          CONST RECT* a2,
                                          LPCSTR a3)
    = CreateEnhMetaFileA;

HDC (__stdcall * Real_CreateEnhMetaFileW)(HDC a0,
                                          LPCWSTR a1,
                                          CONST RECT* a2,
                                          LPCWSTR a3)
    = CreateEnhMetaFileW;

HANDLE (__stdcall * Real_CreateEventA)(LPSECURITY_ATTRIBUTES a0,
                                       BOOL a1,
                                       BOOL a2,
                                       LPCSTR a3)
    = CreateEventA;

HANDLE (__stdcall * Real_CreateEventW)(LPSECURITY_ATTRIBUTES a0,
                                       BOOL a1,
                                       BOOL a2,
                                       LPCWSTR a3)
    = CreateEventW;

LPVOID (__stdcall * Real_CreateFiber)(ULONG_PTR a0,
                                      LPFIBER_START_ROUTINE a1,
                                      LPVOID a2)
    = CreateFiber;

HANDLE (__stdcall * Real_CreateFileA)(LPCSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3,
                                      DWORD a4,
                                      DWORD a5,
                                      HANDLE a6)
    = CreateFileA;

HANDLE (__stdcall * Real_CreateFileMappingA)(HANDLE a0,
                                             LPSECURITY_ATTRIBUTES a1,
                                             DWORD a2,
                                             DWORD a3,
                                             DWORD a4,
                                             LPCSTR a5)
    = CreateFileMappingA;

HANDLE (__stdcall * Real_CreateFileMappingW)(HANDLE a0,
                                             LPSECURITY_ATTRIBUTES a1,
                                             DWORD a2,
                                             DWORD a3,
                                             DWORD a4,
                                             LPCWSTR a5)
    = CreateFileMappingW;

HRESULT (__stdcall * Real_CreateFileMoniker)(LPCOLESTR a0,
                                             IMoniker** a1)
    = CreateFileMoniker;

HANDLE (__stdcall * Real_CreateFileW)(LPCWSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3,
                                      DWORD a4,
                                      DWORD a5,
                                      HANDLE a6)
    = CreateFileW;

HFONT (__stdcall * Real_CreateFontA)(int a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     DWORD a5,
                                     DWORD a6,
                                     DWORD a7,
                                     DWORD a8,
                                     DWORD a9,
                                     DWORD a10,
                                     DWORD a11,
                                     DWORD a12,
                                     LPCSTR a13)
    = CreateFontA;

HFONT (__stdcall * Real_CreateFontIndirectA)(CONST LOGFONTA* a0)
    = CreateFontIndirectA;

HFONT (__stdcall * Real_CreateFontIndirectW)(CONST LOGFONTW* a0)
    = CreateFontIndirectW;

HFONT (__stdcall * Real_CreateFontW)(int a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     DWORD a5,
                                     DWORD a6,
                                     DWORD a7,
                                     DWORD a8,
                                     DWORD a9,
                                     DWORD a10,
                                     DWORD a11,
                                     DWORD a12,
                                     LPCWSTR a13)
    = CreateFontW;

HRESULT (__stdcall * Real_CreateGenericComposite)(IMoniker* a0,
                                                  IMoniker* a1,
                                                  IMoniker** a2)
    = CreateGenericComposite;

HPALETTE (__stdcall * Real_CreateHalftonePalette)(HDC a0)
    = CreateHalftonePalette;

HBRUSH (__stdcall * Real_CreateHatchBrush)(int a0,
                                           COLORREF a1)
    = CreateHatchBrush;

HDC (__stdcall * Real_CreateICA)(LPCSTR a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 CONST DEVMODEA* a3)
    = CreateICA;

HDC (__stdcall * Real_CreateICW)(LPCWSTR a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 CONST DEVMODEW* a3)
    = CreateICW;

HRESULT (__stdcall * Real_CreateILockBytesOnHGlobal)(HGLOBAL a0,
                                                     BOOL a1,
                                                     ILockBytes** a2)
    = CreateILockBytesOnHGlobal;

HICON (__stdcall * Real_CreateIcon)(HINSTANCE a0,
                                    int a1,
                                    int a2,
                                    BYTE a3,
                                    BYTE a4,
                                    CONST BYTE* a5,
                                    CONST BYTE* a6)
    = CreateIcon;

HICON (__stdcall * Real_CreateIconFromResource)(PBYTE a0,
                                                DWORD a1,
                                                BOOL a2,
                                                DWORD a3)
    = CreateIconFromResource;

HICON (__stdcall * Real_CreateIconFromResourceEx)(PBYTE a0,
                                                  DWORD a1,
                                                  BOOL a2,
                                                  DWORD a3,
                                                  int a4,
                                                  int a5,
                                                  UINT a6)
    = CreateIconFromResourceEx;

HICON (__stdcall * Real_CreateIconIndirect)(PICONINFO a0)
    = CreateIconIndirect;

HANDLE (__stdcall * Real_CreateIoCompletionPort)(HANDLE a0,
                                                 HANDLE a1,
                                                 ULONG_PTR a2,
                                                 DWORD a3)
    = CreateIoCompletionPort;

HRESULT (__stdcall * Real_CreateItemMoniker)(LPCOLESTR a0,
                                             LPCOLESTR a1,
                                             IMoniker** a2)
    = CreateItemMoniker;

#if _MSC_VER < 1300
HWND (__stdcall * Real_CreateMDIWindowA)(LPSTR a0,
                                         LPSTR a1,
                                         DWORD a2,
                                         int a3,
                                         int a4,
                                         int a5,
                                         int a6,
                                         HWND a7,
                                         HINSTANCE a8,
                                         LPARAM a9)
    = CreateMDIWindowA;
#else
HWND (__stdcall * Real_CreateMDIWindowA)(LPCSTR a0,
                                         LPCSTR a1,
                                         DWORD a2,
                                         int a3,
                                         int a4,
                                         int a5,
                                         int a6,
                                         HWND a7,
                                         HINSTANCE a8,
                                         LPARAM a9)
    = CreateMDIWindowA;
#endif

#if _MSC_VER < 1300
HWND (__stdcall * Real_CreateMDIWindowW)(LPWSTR a0,
                                         LPWSTR a1,
                                         DWORD a2,
                                         int a3,
                                         int a4,
                                         int a5,
                                         int a6,
                                         HWND a7,
                                         HINSTANCE a8,
                                         LPARAM a9)
    = CreateMDIWindowW;
#else
HWND (__stdcall * Real_CreateMDIWindowW)(LPCWSTR a0,
                                         LPCWSTR a1,
                                         DWORD a2,
                                         int a3,
                                         int a4,
                                         int a5,
                                         int a6,
                                         HWND a7,
                                         HINSTANCE a8,
                                         LPARAM a9)
    = CreateMDIWindowW;
#endif

HANDLE (__stdcall * Real_CreateMailslotA)(LPCSTR a0,
                                          DWORD a1,
                                          DWORD a2,
                                          LPSECURITY_ATTRIBUTES a3)
    = CreateMailslotA;

HANDLE (__stdcall * Real_CreateMailslotW)(LPCWSTR a0,
                                          DWORD a1,
                                          DWORD a2,
                                          LPSECURITY_ATTRIBUTES a3)
    = CreateMailslotW;

HMENU (__stdcall * Real_CreateMenu)(void)
    = CreateMenu;

HDC (__stdcall * Real_CreateMetaFileA)(LPCSTR a0)
    = CreateMetaFileA;

HDC (__stdcall * Real_CreateMetaFileW)(LPCWSTR a0)
    = CreateMetaFileW;

HANDLE (__stdcall * Real_CreateMutexA)(LPSECURITY_ATTRIBUTES a0,
                                       BOOL a1,
                                       LPCSTR a2)
    = CreateMutexA;

HANDLE (__stdcall * Real_CreateMutexW)(LPSECURITY_ATTRIBUTES a0,
                                       BOOL a1,
                                       LPCWSTR a2)
    = CreateMutexW;

HANDLE (__stdcall * Real_CreateNamedPipeA)(LPCSTR a0,
                                           DWORD a1,
                                           DWORD a2,
                                           DWORD a3,
                                           DWORD a4,
                                           DWORD a5,
                                           DWORD a6,
                                           LPSECURITY_ATTRIBUTES a7)
    = CreateNamedPipeA;

HANDLE (__stdcall * Real_CreateNamedPipeW)(LPCWSTR a0,
                                           DWORD a1,
                                           DWORD a2,
                                           DWORD a3,
                                           DWORD a4,
                                           DWORD a5,
                                           DWORD a6,
                                           LPSECURITY_ATTRIBUTES a7)
    = CreateNamedPipeW;

HRESULT (__stdcall * Real_CreateOleAdviseHolder)(LPOLEADVISEHOLDER* a0)
    = CreateOleAdviseHolder;

HPALETTE (__stdcall * Real_CreatePalette)(CONST LOGPALETTE* a0)
    = CreatePalette;

HBRUSH (__stdcall * Real_CreatePatternBrush)(HBITMAP a0)
    = CreatePatternBrush;

HPEN (__stdcall * Real_CreatePen)(int a0,
                                  int a1,
                                  COLORREF a2)
    = CreatePen;

HPEN (__stdcall * Real_CreatePenIndirect)(CONST LOGPEN* a0)
    = CreatePenIndirect;

BOOL (__stdcall * Real_CreatePipe)(PHANDLE a0,
                                   PHANDLE a1,
                                   LPSECURITY_ATTRIBUTES a2,
                                   DWORD a3)
    = CreatePipe;

HRESULT (__stdcall * Real_CreatePointerMoniker)(LPUNKNOWN a0,
                                                IMoniker** a1)
    = CreatePointerMoniker;

HRGN (__stdcall * Real_CreatePolyPolygonRgn)(CONST POINT* a0,
                                             CONST INT* a1,
                                             int a2,
                                             int a3)
    = CreatePolyPolygonRgn;

HRGN (__stdcall * Real_CreatePolygonRgn)(CONST POINT* a0,
                                         int a1,
                                         int a2)
    = CreatePolygonRgn;

HMENU (__stdcall * Real_CreatePopupMenu)(void)
    = CreatePopupMenu;

BOOL (__stdcall * Real_CreateProcessA)(LPCSTR a0,
                                       LPSTR a1,
                                       LPSECURITY_ATTRIBUTES a2,
                                       LPSECURITY_ATTRIBUTES a3,
                                       BOOL a4,
                                       DWORD a5,
                                       LPVOID a6,
                                       LPCSTR a7,
                                       LPSTARTUPINFOA a8,
                                       LPPROCESS_INFORMATION a9)
    = CreateProcessA;

BOOL (__stdcall * Real_CreateProcessW)(LPCWSTR a0,
                                       LPWSTR a1,
                                       LPSECURITY_ATTRIBUTES a2,
                                       LPSECURITY_ATTRIBUTES a3,
                                       BOOL a4,
                                       DWORD a5,
                                       LPVOID a6,
                                       LPCWSTR a7,
                                       LPSTARTUPINFOW a8,
                                       LPPROCESS_INFORMATION a9)
    = CreateProcessW;

BOOL (__stdcall * Real_CreateProcessAsUserA)(
  __in_opt     HANDLE hToken,
  __in_opt     LPCSTR lpApplicationName,
  __inout_opt  LPSTR lpCommandLine,
  __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
  __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
  __in         BOOL bInheritHandles,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOA lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInformation
                                       ) = CreateProcessAsUserA;

BOOL (__stdcall * Real_CreateProcessAsUserW)(
  __in_opt     HANDLE hToken,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
  __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
  __in         BOOL bInheritHandles,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInformation
) = CreateProcessAsUserW;

#if(_WIN32_WINNT >= 0x0500)

BOOL (WINAPI * Real_CreateProcessWithLogonW)(
  __in         LPCWSTR lpUsername,
  __in_opt     LPCWSTR lpDomain,
  __in         LPCWSTR lpPassword,
  __in         DWORD dwLogonFlags,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInfo
) = CreateProcessWithLogonW;

BOOL (WINAPI * Real_CreateProcessWithTokenW)(
  __in         HANDLE hToken,
  __in         DWORD dwLogonFlags,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInfo
) = CreateProcessWithTokenW;
#endif

HRGN (__stdcall * Real_CreateRectRgn)(int a0,
                                      int a1,
                                      int a2,
                                      int a3)
    = CreateRectRgn;

HRGN (__stdcall * Real_CreateRectRgnIndirect)(CONST RECT* a0)
    = CreateRectRgnIndirect;

HANDLE (__stdcall * Real_CreateRemoteThread)(HANDLE a0,
                                             LPSECURITY_ATTRIBUTES a1,
                                             ULONG_PTR a2,
                                             LPTHREAD_START_ROUTINE a3,
                                             LPVOID a4,
                                             DWORD a5,
                                             LPDWORD a6)
    = CreateRemoteThread;

HRGN (__stdcall * Real_CreateRoundRectRgn)(int a0,
                                           int a1,
                                           int a2,
                                           int a3,
                                           int a4,
                                           int a5)
    = CreateRoundRectRgn;

BOOL (__stdcall * Real_CreateScalableFontResourceA)(DWORD a0,
                                                    LPCSTR a1,
                                                    LPCSTR a2,
                                                    LPCSTR a3)
    = CreateScalableFontResourceA;

BOOL (__stdcall * Real_CreateScalableFontResourceW)(DWORD a0,
                                                    LPCWSTR a1,
                                                    LPCWSTR a2,
                                                    LPCWSTR a3)
    = CreateScalableFontResourceW;

HANDLE (__stdcall * Real_CreateSemaphoreA)(LPSECURITY_ATTRIBUTES a0,
                                           LONG a1,
                                           LONG a2,
                                           LPCSTR a3)
    = CreateSemaphoreA;

HANDLE (__stdcall * Real_CreateSemaphoreW)(LPSECURITY_ATTRIBUTES a0,
                                           LONG a1,
                                           LONG a2,
                                           LPCWSTR a3)
    = CreateSemaphoreW;

HBRUSH (__stdcall * Real_CreateSolidBrush)(COLORREF a0)
    = CreateSolidBrush;

HRESULT (__stdcall * Real_CreateStdProgressIndicator)(HWND a0,
                                                      LPCOLESTR a1,
                                                      IBindStatusCallback* a2,
                                                      IBindStatusCallback** a3)
    = CreateStdProgressIndicator;

HRESULT (__stdcall * Real_CreateStreamOnHGlobal)(HGLOBAL a0,
                                                 BOOL a1,
                                                 LPSTREAM* a2)
    = CreateStreamOnHGlobal;

DWORD (__stdcall * Real_CreateTapePartition)(HANDLE a0,
                                             DWORD a1,
                                             DWORD a2,
                                             DWORD a3)
    = CreateTapePartition;

HANDLE (__stdcall * Real_CreateThread)(LPSECURITY_ATTRIBUTES a0,
                                       ULONG_PTR a1,
                                       LPTHREAD_START_ROUTINE a2,
                                       LPVOID a3,
                                       DWORD a4,
                                       LPDWORD a5)
    = CreateThread;

HANDLE (__stdcall * Real_CreateWaitableTimerA)(LPSECURITY_ATTRIBUTES a0,
                                               BOOL a1,
                                               LPCSTR a2)
    = CreateWaitableTimerA;

HANDLE (__stdcall * Real_CreateWaitableTimerW)(LPSECURITY_ATTRIBUTES a0,
                                               BOOL a1,
                                               LPCWSTR a2)
    = CreateWaitableTimerW;

HWND (__stdcall * Real_CreateWindowExA)(DWORD a0,
                                        LPCSTR a1,
                                        LPCSTR a2,
                                        DWORD a3,
                                        int a4,
                                        int a5,
                                        int a6,
                                        int a7,
                                        HWND a8,
                                        HMENU a9,
                                        HINSTANCE a10,
                                        LPVOID a11)
    = CreateWindowExA;

HWND (__stdcall * Real_CreateWindowExW)(DWORD a0,
                                        LPCWSTR a1,
                                        LPCWSTR a2,
                                        DWORD a3,
                                        int a4,
                                        int a5,
                                        int a6,
                                        int a7,
                                        HWND a8,
                                        HMENU a9,
                                        HINSTANCE a10,
                                        LPVOID a11)
    = CreateWindowExW;

#if _MSC_VER < 1300
HWINSTA (__stdcall * Real_CreateWindowStationA)(LPSTR a0,
                                                DWORD a1,
                                                ACCESS_MASK a2,
                                                LPSECURITY_ATTRIBUTES a3)
    = CreateWindowStationA;
#else
HWINSTA (__stdcall * Real_CreateWindowStationA)(LPCSTR a0,
                                                DWORD a1,
                                                ACCESS_MASK a2,
                                                LPSECURITY_ATTRIBUTES a3)
    = CreateWindowStationA;
#endif

#if _MSC_VER < 1300
HWINSTA (__stdcall * Real_CreateWindowStationW)(LPWSTR a0,
                                                DWORD a1,
                                                ACCESS_MASK a2,
                                                LPSECURITY_ATTRIBUTES a3)
    = CreateWindowStationW;
#else
HWINSTA (__stdcall * Real_CreateWindowStationW)(LPCWSTR a0,
                                                DWORD a1,
                                                ACCESS_MASK a2,
                                                LPSECURITY_ATTRIBUTES a3)
    = CreateWindowStationW;
#endif

BOOL (__stdcall * Real_DPtoLP)(HDC a0,
                               POINT* a1,
                               int a2)
    = DPtoLP;

BOOL (__stdcall * Real_DdeAbandonTransaction)(DWORD a0,
                                              HCONV a1,
                                              DWORD a2)
    = DdeAbandonTransaction;

LPBYTE (__stdcall * Real_DdeAccessData)(HDDEDATA a0,
                                        LPDWORD a1)
    = DdeAccessData;

HDDEDATA (__stdcall * Real_DdeAddData)(HDDEDATA a0,
                                       LPBYTE a1,
                                       DWORD a2,
                                       DWORD a3)
    = DdeAddData;

HDDEDATA (__stdcall * Real_DdeClientTransaction)(LPBYTE a0,
                                                 DWORD a1,
                                                 HCONV a2,
                                                 HSZ a3,
                                                 UINT a4,
                                                 UINT a5,
                                                 DWORD a6,
                                                 LPDWORD a7)
    = DdeClientTransaction;

int (__stdcall * Real_DdeCmpStringHandles)(HSZ a0,
                                           HSZ a1)
    = DdeCmpStringHandles;

HCONV (__stdcall * Real_DdeConnect)(DWORD a0,
                                    HSZ a1,
                                    HSZ a2,
                                    PCONVCONTEXT a3)
    = DdeConnect;

HCONVLIST (__stdcall * Real_DdeConnectList)(DWORD a0,
                                            HSZ a1,
                                            HSZ a2,
                                            HCONVLIST a3,
                                            PCONVCONTEXT a4)
    = DdeConnectList;

HDDEDATA (__stdcall * Real_DdeCreateDataHandle)(DWORD a0,
                                                LPBYTE a1,
                                                DWORD a2,
                                                DWORD a3,
                                                HSZ a4,
                                                UINT a5,
                                                UINT a6)
    = DdeCreateDataHandle;

HSZ (__stdcall * Real_DdeCreateStringHandleA)(DWORD a0,
                                              LPCSTR a1,
                                              int a2)
    = DdeCreateStringHandleA;

HSZ (__stdcall * Real_DdeCreateStringHandleW)(DWORD a0,
                                              LPCWSTR a1,
                                              int a2)
    = DdeCreateStringHandleW;

BOOL (__stdcall * Real_DdeDisconnect)(HCONV a0)
    = DdeDisconnect;

BOOL (__stdcall * Real_DdeDisconnectList)(HCONVLIST a0)
    = DdeDisconnectList;

BOOL (__stdcall * Real_DdeEnableCallback)(DWORD a0,
                                          HCONV a1,
                                          UINT a2)
    = DdeEnableCallback;

BOOL (__stdcall * Real_DdeFreeDataHandle)(HDDEDATA a0)
    = DdeFreeDataHandle;

BOOL (__stdcall * Real_DdeFreeStringHandle)(DWORD a0,
                                            HSZ a1)
    = DdeFreeStringHandle;

DWORD (__stdcall * Real_DdeGetData)(HDDEDATA a0,
                                    LPBYTE a1,
                                    DWORD a2,
                                    DWORD a3)
    = DdeGetData;

UINT (__stdcall * Real_DdeGetLastError)(DWORD a0)
    = DdeGetLastError;

BOOL (__stdcall * Real_DdeImpersonateClient)(HCONV a0)
    = DdeImpersonateClient;

BOOL (__stdcall * Real_DdeKeepStringHandle)(DWORD a0,
                                            HSZ a1)
    = DdeKeepStringHandle;

HDDEDATA (__stdcall * Real_DdeNameService)(DWORD a0,
                                           HSZ a1,
                                           HSZ a2,
                                           UINT a3)
    = DdeNameService;

BOOL (__stdcall * Real_DdePostAdvise)(DWORD a0,
                                      HSZ a1,
                                      HSZ a2)
    = DdePostAdvise;

UINT (__stdcall * Real_DdeQueryConvInfo)(HCONV a0,
                                         DWORD a1,
                                         CONVINFO* a2)
    = DdeQueryConvInfo;

HCONV (__stdcall * Real_DdeQueryNextServer)(HCONVLIST a0,
                                            HCONV a1)
    = DdeQueryNextServer;

DWORD (__stdcall * Real_DdeQueryStringA)(DWORD a0,
                                         HSZ a1,
                                         LPSTR a2,
                                         DWORD a3,
                                         int a4)
    = DdeQueryStringA;

DWORD (__stdcall * Real_DdeQueryStringW)(DWORD a0,
                                         HSZ a1,
                                         LPWSTR a2,
                                         DWORD a3,
                                         int a4)
    = DdeQueryStringW;

HCONV (__stdcall * Real_DdeReconnect)(HCONV a0)
    = DdeReconnect;

BOOL (__stdcall * Real_DdeSetQualityOfService)(HWND a0,
                                               CONST SECURITY_QUALITY_OF_SERVICE* a1,
                                               PSECURITY_QUALITY_OF_SERVICE a2)
    = DdeSetQualityOfService;

BOOL (__stdcall * Real_DdeSetUserHandle)(HCONV a0,
                                         DWORD a1,
                                         ULONG_PTR a2)
    = DdeSetUserHandle;

BOOL (__stdcall * Real_DdeUnaccessData)(HDDEDATA a0)
    = DdeUnaccessData;

BOOL (__stdcall * Real_DdeUninitialize)(DWORD a0)
    = DdeUninitialize;

BOOL (__stdcall * Real_DebugActiveProcess)(DWORD a0)
    = DebugActiveProcess;

BOOL (__stdcall * Real_DebugActiveProcessStop)(DWORD a0)
    = DebugActiveProcessStop;

void (__stdcall * Real_DebugBreak)(void)
    = DebugBreak;

LRESULT (__stdcall * Real_DefDlgProcA)(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
    = DefDlgProcA;

LRESULT (__stdcall * Real_DefDlgProcW)(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
    = DefDlgProcW;

LRESULT (__stdcall * Real_DefFrameProcA)(HWND a0,
                                         HWND a1,
                                         UINT a2,
                                         WPARAM a3,
                                         LPARAM a4)
    = DefFrameProcA;

LRESULT (__stdcall * Real_DefFrameProcW)(HWND a0,
                                         HWND a1,
                                         UINT a2,
                                         WPARAM a3,
                                         LPARAM a4)
    = DefFrameProcW;

LRESULT (__stdcall * Real_DefMDIChildProcA)(HWND a0,
                                            UINT a1,
                                            WPARAM a2,
                                            LPARAM a3)
    = DefMDIChildProcA;

LRESULT (__stdcall * Real_DefMDIChildProcW)(HWND a0,
                                            UINT a1,
                                            WPARAM a2,
                                            LPARAM a3)
    = DefMDIChildProcW;

LRESULT (__stdcall * Real_DefWindowProcA)(HWND a0,
                                          UINT a1,
                                          WPARAM a2,
                                          LPARAM a3)
    = DefWindowProcA;

LRESULT (__stdcall * Real_DefWindowProcW)(HWND a0,
                                          UINT a1,
                                          WPARAM a2,
                                          LPARAM a3)
    = DefWindowProcW;

HDWP (__stdcall * Real_DeferWindowPos)(HDWP a0,
                                       HWND a1,
                                       HWND a2,
                                       int a3,
                                       int a4,
                                       int a5,
                                       int a6,
                                       UINT a7)
    = DeferWindowPos;

BOOL (__stdcall * Real_DefineDosDeviceA)(DWORD a0,
                                         LPCSTR a1,
                                         LPCSTR a2)
    = DefineDosDeviceA;

BOOL (__stdcall * Real_DefineDosDeviceW)(DWORD a0,
                                         LPCWSTR a1,
                                         LPCWSTR a2)
    = DefineDosDeviceW;

ATOM (__stdcall * Real_DeleteAtom)(ATOM a0)
    = DeleteAtom;

BOOL (__stdcall * Real_DeleteColorSpace)(HCOLORSPACE a0)
    = DeleteColorSpace;

BOOL (__stdcall * Real_DeleteDC)(HDC a0)
    = DeleteDC;

BOOL (__stdcall * Real_DeleteEnhMetaFile)(HENHMETAFILE a0)
    = DeleteEnhMetaFile;

void (__stdcall * Real_DeleteFiber)(LPVOID a0)
    = DeleteFiber;

BOOL (__stdcall * Real_DeleteFileA)(LPCSTR a0)
    = DeleteFileA;

BOOL (__stdcall * Real_DeleteFileW)(LPCWSTR a0)
    = DeleteFileW;

BOOL (__stdcall * Real_DeleteMenu)(HMENU a0,
                                   UINT a1,
                                   UINT a2)
    = DeleteMenu;

BOOL (__stdcall * Real_DeleteMetaFile)(HMETAFILE a0)
    = DeleteMetaFile;

BOOL (__stdcall * Real_DeleteObject)(HGDIOBJ a0)
    = DeleteObject;

int (__stdcall * Real_DescribePixelFormat)(HDC a0,
                                           int a1,
                                           UINT a2,
                                           PIXELFORMATDESCRIPTOR* a3)
    = DescribePixelFormat;

BOOL (__stdcall * Real_DestroyAcceleratorTable)(HACCEL a0)
    = DestroyAcceleratorTable;

BOOL (__stdcall * Real_DestroyCaret)(void)
    = DestroyCaret;

BOOL (__stdcall * Real_DestroyCursor)(HCURSOR a0)
    = DestroyCursor;

BOOL (__stdcall * Real_DestroyIcon)(HICON a0)
    = DestroyIcon;

BOOL (__stdcall * Real_DestroyMenu)(HMENU a0)
    = DestroyMenu;

BOOL (__stdcall * Real_DestroyWindow)(HWND a0)
    = DestroyWindow;

BOOL (__stdcall * Real_DeviceIoControl)(HANDLE a0,
                                        DWORD a1,
                                        LPVOID a2,
                                        DWORD a3,
                                        LPVOID a4,
                                        DWORD a5,
                                        LPDWORD a6,
                                        LPOVERLAPPED a7)
    = DeviceIoControl;

INT_PTR (__stdcall * Real_DialogBoxIndirectParamA)(HINSTANCE a0,
                                                   LPCDLGTEMPLATEA a1,
                                                   HWND a2,
                                                   DLGPROC a3,
                                                   LPARAM a4)
    = DialogBoxIndirectParamA;

INT_PTR (__stdcall * Real_DialogBoxIndirectParamW)(HINSTANCE a0,
                                                   LPCDLGTEMPLATEW a1,
                                                   HWND a2,
                                                   DLGPROC a3,
                                                   LPARAM a4)
    = DialogBoxIndirectParamW;

INT_PTR (__stdcall * Real_DialogBoxParamA)(HINSTANCE a0,
                                           LPCSTR a1,
                                           HWND a2,
                                           DLGPROC a3,
                                           LPARAM a4)
    = DialogBoxParamA;

INT_PTR (__stdcall * Real_DialogBoxParamW)(HINSTANCE a0,
                                           LPCWSTR a1,
                                           HWND a2,
                                           DLGPROC a3,
                                           LPARAM a4)
    = DialogBoxParamW;

BOOL (__stdcall * Real_DisableThreadLibraryCalls)(HMODULE a0)
    = DisableThreadLibraryCalls;

BOOL (__stdcall * Real_DisconnectNamedPipe)(HANDLE a0)
    = DisconnectNamedPipe;

LRESULT (__stdcall * Real_DispatchMessageA)(CONST MSG* a0)
    = DispatchMessageA;

LRESULT (__stdcall * Real_DispatchMessageW)(CONST MSG* a0)
    = DispatchMessageW;

int (__stdcall * Real_DlgDirListA)(HWND a0,
                                   LPSTR a1,
                                   int a2,
                                   int a3,
                                   UINT a4)
    = DlgDirListA;

int (__stdcall * Real_DlgDirListComboBoxA)(HWND a0,
                                           LPSTR a1,
                                           int a2,
                                           int a3,
                                           UINT a4)
    = DlgDirListComboBoxA;

int (__stdcall * Real_DlgDirListComboBoxW)(HWND a0,
                                           LPWSTR a1,
                                           int a2,
                                           int a3,
                                           UINT a4)
    = DlgDirListComboBoxW;

int (__stdcall * Real_DlgDirListW)(HWND a0,
                                   LPWSTR a1,
                                   int a2,
                                   int a3,
                                   UINT a4)
    = DlgDirListW;

BOOL (__stdcall * Real_DlgDirSelectComboBoxExA)(HWND a0,
                                                LPSTR a1,
                                                int a2,
                                                int a3)
    = DlgDirSelectComboBoxExA;

BOOL (__stdcall * Real_DlgDirSelectComboBoxExW)(HWND a0,
                                                LPWSTR a1,
                                                int a2,
                                                int a3)
    = DlgDirSelectComboBoxExW;

BOOL (__stdcall * Real_DlgDirSelectExA)(HWND a0,
                                        LPSTR a1,
                                        int a2,
                                        int a3)
    = DlgDirSelectExA;

BOOL (__stdcall * Real_DlgDirSelectExW)(HWND a0,
                                        LPWSTR a1,
                                        int a2,
                                        int a3)
    = DlgDirSelectExW;

HRESULT (__stdcall * Real_DoDragDrop)(IDataObject* a0,
                                      IDropSource* a1,
                                      DWORD a2,
                                      LPDWORD a3)
    = DoDragDrop;

BOOL (__stdcall * Real_DosDateTimeToFileTime)(WORD a0,
                                              WORD a1,
                                              LPFILETIME a2)
    = DosDateTimeToFileTime;

BOOL (__stdcall * Real_DragDetect)(HWND a0,
                                   POINT a1)
    = DragDetect;

DWORD (__stdcall * Real_DragObject)(HWND a0,
                                    HWND a1,
                                    UINT a2,
                                    ULONG_PTR a3,
                                    HCURSOR a4)
    = DragObject;

BOOL (__stdcall * Real_DrawAnimatedRects)(HWND a0,
                                          int a1,
                                          CONST RECT* a2,
                                          CONST RECT* a3)
    = DrawAnimatedRects;

BOOL (__stdcall * Real_DrawCaption)(HWND a0,
                                    HDC a1,
                                    CONST RECT* a2,
                                    UINT a3)
    = DrawCaption;

BOOL (__stdcall * Real_DrawEdge)(HDC a0,
                                 LPRECT a1,
                                 UINT a2,
                                 UINT a3)
    = DrawEdge;

int (__stdcall * Real_DrawEscape)(HDC a0,
                                  int a1,
                                  int a2,
                                  LPCSTR a3)
    = DrawEscape;

BOOL (__stdcall * Real_DrawFocusRect)(HDC a0,
                                      CONST RECT* a1)
    = DrawFocusRect;

BOOL (__stdcall * Real_DrawFrameControl)(HDC a0,
                                         LPRECT a1,
                                         UINT a2,
                                         UINT a3)
    = DrawFrameControl;

BOOL (__stdcall * Real_DrawIcon)(HDC a0,
                                 int a1,
                                 int a2,
                                 HICON a3)
    = DrawIcon;

BOOL (__stdcall * Real_DrawIconEx)(HDC a0,
                                   int a1,
                                   int a2,
                                   HICON a3,
                                   int a4,
                                   int a5,
                                   UINT a6,
                                   HBRUSH a7,
                                   UINT a8)
    = DrawIconEx;

BOOL (__stdcall * Real_DrawMenuBar)(HWND a0)
    = DrawMenuBar;

BOOL (__stdcall * Real_DrawStateA)(HDC a0,
                                   HBRUSH a1,
                                   DRAWSTATEPROC a2,
                                   LPARAM a3,
                                   WPARAM a4,
                                   int a5,
                                   int a6,
                                   int a7,
                                   int a8,
                                   UINT a9)
    = DrawStateA;

BOOL (__stdcall * Real_DrawStateW)(HDC a0,
                                   HBRUSH a1,
                                   DRAWSTATEPROC a2,
                                   LPARAM a3,
                                   WPARAM a4,
                                   int a5,
                                   int a6,
                                   int a7,
                                   int a8,
                                   UINT a9)
    = DrawStateW;

int (__stdcall * Real_DrawTextA)(HDC a0,
                                 LPCSTR a1,
                                 int a2,
                                 LPRECT a3,
                                 UINT a4)
    = DrawTextA;

int (__stdcall * Real_DrawTextExA)(HDC a0,
                                   LPSTR a1,
                                   int a2,
                                   LPRECT a3,
                                   UINT a4,
                                   LPDRAWTEXTPARAMS a5)
    = DrawTextExA;

int (__stdcall * Real_DrawTextExW)(HDC a0,
                                   LPWSTR a1,
                                   int a2,
                                   LPRECT a3,
                                   UINT a4,
                                   LPDRAWTEXTPARAMS a5)
    = DrawTextExW;

int (__stdcall * Real_DrawTextW)(HDC a0,
                                 LPCWSTR a1,
                                 int a2,
                                 LPRECT a3,
                                 UINT a4)
    = DrawTextW;

BOOL (__stdcall * Real_DuplicateHandle)(HANDLE a0,
                                        HANDLE a1,
                                        HANDLE a2,
                                        LPHANDLE a3,
                                        DWORD a4,
                                        BOOL a5,
                                        DWORD a6)
    = DuplicateHandle;

BOOL (__stdcall * Real_Ellipse)(HDC a0,
                                int a1,
                                int a2,
                                int a3,
                                int a4)
    = Ellipse;

BOOL (__stdcall * Real_EmptyClipboard)(void)
    = EmptyClipboard;

BOOL (__stdcall * Real_EnableMenuItem)(HMENU a0,
                                       UINT a1,
                                       UINT a2)
    = EnableMenuItem;

BOOL (__stdcall * Real_EnableScrollBar)(HWND a0,
                                        UINT a1,
                                        UINT a2)
    = EnableScrollBar;

BOOL (__stdcall * Real_EnableWindow)(HWND a0,
                                     BOOL a1)
    = EnableWindow;

BOOL (__stdcall * Real_EndDeferWindowPos)(HDWP a0)
    = EndDeferWindowPos;

BOOL (__stdcall * Real_EndDialog)(HWND a0,
                                  INT_PTR a1)
    = EndDialog;

int (__stdcall * Real_EndDoc)(HDC a0)
    = EndDoc;

int (__stdcall * Real_EndPage)(HDC a0)
    = EndPage;

BOOL (__stdcall * Real_EndPaint)(HWND a0,
                                 CONST PAINTSTRUCT* a1)
    = EndPaint;

BOOL (__stdcall * Real_EndPath)(HDC a0)
    = EndPath;

BOOL (__stdcall * Real_EndUpdateResourceA)(HANDLE a0,
                                           BOOL a1)
    = EndUpdateResourceA;

BOOL (__stdcall * Real_EndUpdateResourceW)(HANDLE a0,
                                           BOOL a1)
    = EndUpdateResourceW;

BOOL (__stdcall * Real_EnumCalendarInfoA)(CALINFO_ENUMPROCA a0,
                                          LCID a1,
                                          CALID a2,
                                          CALTYPE a3)
    = EnumCalendarInfoA;

BOOL (__stdcall * Real_EnumCalendarInfoW)(CALINFO_ENUMPROCW a0,
                                          LCID a1,
                                          CALID a2,
                                          CALTYPE a3)
    = EnumCalendarInfoW;

BOOL (__stdcall * Real_EnumChildWindows)(HWND a0,
                                         WNDENUMPROC a1,
                                         LPARAM a2)
    = EnumChildWindows;

UINT (__stdcall * Real_EnumClipboardFormats)(UINT a0)
    = EnumClipboardFormats;

BOOL (__stdcall * Real_EnumDateFormatsA)(DATEFMT_ENUMPROCA a0,
                                         LCID a1,
                                         DWORD a2)
    = EnumDateFormatsA;

BOOL (__stdcall * Real_EnumDateFormatsW)(DATEFMT_ENUMPROCW a0,
                                         LCID a1,
                                         DWORD a2)
    = EnumDateFormatsW;

BOOL (__stdcall * Real_EnumDesktopWindows)(HDESK a0,
                                           WNDENUMPROC a1,
                                           LPARAM a2)
    = EnumDesktopWindows;

BOOL (__stdcall * Real_EnumDesktopsA)(HWINSTA a0,
                                      DESKTOPENUMPROCA a1,
                                      LPARAM a2)
    = EnumDesktopsA;

BOOL (__stdcall * Real_EnumDesktopsW)(HWINSTA a0,
                                      DESKTOPENUMPROCW a1,
                                      LPARAM a2)
    = EnumDesktopsW;

BOOL (__stdcall * Real_EnumDisplaySettingsA)(LPCSTR a0,
                                             DWORD a1,
                                             LPDEVMODEA a2)
    = EnumDisplaySettingsA;

BOOL (__stdcall * Real_EnumDisplaySettingsW)(LPCWSTR a0,
                                             DWORD a1,
                                             LPDEVMODEW a2)
    = EnumDisplaySettingsW;

BOOL (__stdcall * Real_EnumEnhMetaFile)(HDC a0,
                                        HENHMETAFILE a1,
                                        ENHMFENUMPROC a2,
                                        LPVOID a3,
                                        CONST RECT* a4)
    = EnumEnhMetaFile;

int (__stdcall * Real_EnumFontFamiliesA)(HDC a0,
                                         LPCSTR a1,
                                         FONTENUMPROCA a2,
                                         LPARAM a3)
    = EnumFontFamiliesA;

int (__stdcall * Real_EnumFontFamiliesExA)(HDC a0,
                                           LPLOGFONTA a1,
                                           FONTENUMPROCA a2,
                                           LPARAM a3,
                                           DWORD a4)
    = EnumFontFamiliesExA;

int (__stdcall * Real_EnumFontFamiliesExW)(HDC a0,
                                           LPLOGFONTW a1,
                                           FONTENUMPROCW a2,
                                           LPARAM a3,
                                           DWORD a4)
    = EnumFontFamiliesExW;

int (__stdcall * Real_EnumFontFamiliesW)(HDC a0,
                                         LPCWSTR a1,
                                         FONTENUMPROCW a2,
                                         LPARAM a3)
    = EnumFontFamiliesW;

int (__stdcall * Real_EnumFontsA)(HDC a0,
                                  LPCSTR a1,
                                  FONTENUMPROCA a2,
                                  LPARAM a3)
    = EnumFontsA;

int (__stdcall * Real_EnumFontsW)(HDC a0,
                                  LPCWSTR a1,
                                  FONTENUMPROCW a2,
                                  LPARAM a3)
    = EnumFontsW;

int (__stdcall * Real_EnumICMProfilesA)(HDC a0,
                                        ICMENUMPROCA a1,
                                        LPARAM a2)
    = EnumICMProfilesA;

int (__stdcall * Real_EnumICMProfilesW)(HDC a0,
                                        ICMENUMPROCW a1,
                                        LPARAM a2)
    = EnumICMProfilesW;

BOOL (__stdcall * Real_EnumMetaFile)(HDC a0,
                                     HMETAFILE a1,
                                     MFENUMPROC a2,
                                     LPARAM a3)
    = EnumMetaFile;

int (__stdcall * Real_EnumObjects)(HDC a0,
                                   int a1,
                                   GOBJENUMPROC a2,
                                   LPARAM a3)
    = EnumObjects;

int (__stdcall * Real_EnumPropsA)(HWND a0,
                                  PROPENUMPROCA a1)
    = EnumPropsA;

int (__stdcall * Real_EnumPropsExA)(HWND a0,
                                    PROPENUMPROCEXA a1,
                                    LPARAM a2)
    = EnumPropsExA;

int (__stdcall * Real_EnumPropsExW)(HWND a0,
                                    PROPENUMPROCEXW a1,
                                    LPARAM a2)
    = EnumPropsExW;

int (__stdcall * Real_EnumPropsW)(HWND a0,
                                  PROPENUMPROCW a1)
    = EnumPropsW;

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceLanguagesA)(HMODULE a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               ENUMRESLANGPROC a3,
                                               LONG a4)
    = EnumResourceLanguagesA;
#else
BOOL (__stdcall * Real_EnumResourceLanguagesA)(HMODULE a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               ENUMRESLANGPROCA a3,
                                               LONG_PTR a4)
    = EnumResourceLanguagesA;
#endif

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceLanguagesW)(HMODULE a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               ENUMRESLANGPROC a3,
                                               LONG a4)
    = EnumResourceLanguagesW;
#else
BOOL (__stdcall * Real_EnumResourceLanguagesW)(HMODULE a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               ENUMRESLANGPROCW a3,
                                               LONG_PTR a4)
    = EnumResourceLanguagesW;
#endif

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceNamesA)(HMODULE a0,
                                           LPCSTR a1,
                                           ENUMRESNAMEPROC a2,
                                           LONG a3)
    = EnumResourceNamesA;
#else
BOOL (__stdcall * Real_EnumResourceNamesA)(HMODULE a0,
                                           LPCSTR a1,
                                           ENUMRESNAMEPROCA a2,
                                           LONG_PTR a3)
    = EnumResourceNamesA;
#endif

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceNamesW)(HMODULE a0,
                                           LPCWSTR a1,
                                           ENUMRESNAMEPROC a2,
                                           LONG a3)
    = EnumResourceNamesW;
#else
BOOL (__stdcall * Real_EnumResourceNamesW)(HMODULE a0,
                                           LPCWSTR a1,
                                           ENUMRESNAMEPROCW a2,
                                           LONG_PTR a3)
    = EnumResourceNamesW;
#endif

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceTypesA)(HMODULE a0,
                                           ENUMRESTYPEPROC a1,
                                           LONG a2)
    = EnumResourceTypesA;
#else
BOOL (__stdcall * Real_EnumResourceTypesA)(HMODULE a0,
                                           ENUMRESTYPEPROCA a1,
                                           LONG_PTR a2)
    = EnumResourceTypesA;
#endif

#if _MSC_VER < 1300
BOOL (__stdcall * Real_EnumResourceTypesW)(HMODULE a0,
                                           ENUMRESTYPEPROC a1,
                                           LONG a2)
    = EnumResourceTypesW;
#else
BOOL (__stdcall * Real_EnumResourceTypesW)(HMODULE a0,
                                           ENUMRESTYPEPROCW a1,
                                           LONG_PTR a2)
    = EnumResourceTypesW;
#endif

BOOL (__stdcall * Real_EnumSystemCodePagesA)(CODEPAGE_ENUMPROCA a0,
                                             DWORD a1)
    = EnumSystemCodePagesA;

BOOL (__stdcall * Real_EnumSystemCodePagesW)(CODEPAGE_ENUMPROCW a0,
                                             DWORD a1)
    = EnumSystemCodePagesW;

#if(WINVER >= 0x0500)
BOOL (__stdcall * Real_EnumSystemLocalesA)(LOCALE_ENUMPROCA a0,
                                           DWORD a1)
    = EnumSystemLocalesA;

BOOL (__stdcall * Real_EnumSystemLocalesW)(LOCALE_ENUMPROCW a0,
                                           DWORD a1)
    = EnumSystemLocalesW;
#endif // (WINVER >= 0x0500)

BOOL (__stdcall * Real_EnumThreadWindows)(DWORD a0,
                                          WNDENUMPROC a1,
                                          LPARAM a2)
    = EnumThreadWindows;

BOOL (__stdcall * Real_EnumTimeFormatsA)(TIMEFMT_ENUMPROCA a0,
                                         LCID a1,
                                         DWORD a2)
    = EnumTimeFormatsA;

BOOL (__stdcall * Real_EnumTimeFormatsW)(TIMEFMT_ENUMPROCW a0,
                                         LCID a1,
                                         DWORD a2)
    = EnumTimeFormatsW;

BOOL (__stdcall * Real_EnumWindowStationsA)(WINSTAENUMPROCA a0,
                                            LPARAM a1)
    = EnumWindowStationsA;

BOOL (__stdcall * Real_EnumWindowStationsW)(WINSTAENUMPROCW a0,
                                            LPARAM a1)
    = EnumWindowStationsW;

BOOL (__stdcall * Real_EnumWindows)(WNDENUMPROC a0,
                                    LPARAM a1)
    = EnumWindows;

BOOL (__stdcall * Real_EqualRect)(CONST RECT* a0,
                                  CONST RECT* a1)
    = EqualRect;

BOOL (__stdcall * Real_EqualRgn)(HRGN a0,
                                 HRGN a1)
    = EqualRgn;

DWORD (__stdcall * Real_EraseTape)(HANDLE a0,
                                   DWORD a1,
                                   BOOL a2)
    = EraseTape;

int (__stdcall * Real_Escape)(HDC a0,
                              int a1,
                              int a2,
                              LPCSTR a3,
                              LPVOID a4)
    = Escape;

BOOL (__stdcall * Real_EscapeCommFunction)(HANDLE a0,
                                           DWORD a1)
    = EscapeCommFunction;

int (__stdcall * Real_ExcludeClipRect)(HDC a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       int a4)
    = ExcludeClipRect;

int (__stdcall * Real_ExcludeUpdateRgn)(HDC a0,
                                        HWND a1)
    = ExcludeUpdateRgn;

void (__stdcall * Real_ExitProcess)(UINT a0)
    = ExitProcess;

void (__stdcall * Real_ExitThread)(DWORD a0)
    = ExitThread;

BOOL (__stdcall * Real_ExitWindowsEx)(UINT a0,
                                      DWORD a1)
    = ExitWindowsEx;

DWORD (__stdcall * Real_ExpandEnvironmentStringsA)(LPCSTR a0,
                                                   LPSTR a1,
                                                   DWORD a2)
    = ExpandEnvironmentStringsA;

DWORD (__stdcall * Real_ExpandEnvironmentStringsW)(LPCWSTR a0,
                                                   LPWSTR a1,
                                                   DWORD a2)
    = ExpandEnvironmentStringsW;

HPEN (__stdcall * Real_ExtCreatePen)(DWORD a0,
                                     DWORD a1,
                                     CONST LOGBRUSH* a2,
                                     DWORD a3,
                                     CONST DWORD* a4)
    = ExtCreatePen;

HRGN (__stdcall * Real_ExtCreateRegion)(CONST XFORM* a0,
                                        DWORD a1,
                                        CONST RGNDATA* a2)
    = ExtCreateRegion;

int (__stdcall * Real_ExtEscape)(HDC a0,
                                 int a1,
                                 int a2,
                                 LPCSTR a3,
                                 int a4,
                                 LPSTR a5)
    = ExtEscape;

BOOL (__stdcall * Real_ExtFloodFill)(HDC a0,
                                     int a1,
                                     int a2,
                                     COLORREF a3,
                                     UINT a4)
    = ExtFloodFill;

int (__stdcall * Real_ExtSelectClipRgn)(HDC a0,
                                        HRGN a1,
                                        int a2)
    = ExtSelectClipRgn;

BOOL (__stdcall * Real_ExtTextOutA)(HDC a0,
                                    int a1,
                                    int a2,
                                    UINT a3,
                                    CONST RECT* a4,
                                    LPCSTR a5,
                                    UINT a6,
                                    CONST INT* a7)
    = ExtTextOutA;

BOOL (__stdcall * Real_ExtTextOutW)(HDC a0,
                                    int a1,
                                    int a2,
                                    UINT a3,
                                    CONST RECT* a4,
                                    LPCWSTR a5,
                                    UINT a6,
                                    CONST INT* a7)
    = ExtTextOutW;

void (__stdcall * Real_FatalAppExitA)(UINT a0,
                                      LPCSTR a1)
    = FatalAppExitA;

void (__stdcall * Real_FatalAppExitW)(UINT a0,
                                      LPCWSTR a1)
    = FatalAppExitW;

void (__stdcall * Real_FatalExit)(int a0)
    = FatalExit;

BOOL (__stdcall * Real_FileTimeToDosDateTime)(CONST FILETIME* a0,
                                              LPWORD a1,
                                              LPWORD a2)
    = FileTimeToDosDateTime;

BOOL (__stdcall * Real_FileTimeToLocalFileTime)(CONST FILETIME* a0,
                                                LPFILETIME a1)
    = FileTimeToLocalFileTime;

BOOL (__stdcall * Real_FileTimeToSystemTime)(CONST FILETIME* a0,
                                             LPSYSTEMTIME a1)
    = FileTimeToSystemTime;

BOOL (__stdcall * Real_FillConsoleOutputAttribute)(HANDLE a0,
                                                   WORD a1,
                                                   DWORD a2,
                                                   COORD a3,
                                                   LPDWORD a4)
    = FillConsoleOutputAttribute;

BOOL (__stdcall * Real_FillConsoleOutputCharacterA)(HANDLE a0,
                                                    CHAR a1,
                                                    DWORD a2,
                                                    COORD a3,
                                                    LPDWORD a4)
    = FillConsoleOutputCharacterA;

BOOL (__stdcall * Real_FillConsoleOutputCharacterW)(HANDLE a0,
                                                    WCHAR a1,
                                                    DWORD a2,
                                                    COORD a3,
                                                    LPDWORD a4)
    = FillConsoleOutputCharacterW;

BOOL (__stdcall * Real_FillPath)(HDC a0)
    = FillPath;

int (__stdcall * Real_FillRect)(HDC a0,
                                CONST RECT* a1,
                                HBRUSH a2)
    = FillRect;

BOOL (__stdcall * Real_FillRgn)(HDC a0,
                                HRGN a1,
                                HBRUSH a2)
    = FillRgn;

ATOM (__stdcall * Real_FindAtomA)(LPCSTR a0)
    = FindAtomA;

ATOM (__stdcall * Real_FindAtomW)(LPCWSTR a0)
    = FindAtomW;

BOOL (__stdcall * Real_FindClose)(HANDLE a0)
    = FindClose;

BOOL (__stdcall * Real_FindCloseChangeNotification)(HANDLE a0)
    = FindCloseChangeNotification;

HANDLE (__stdcall * Real_FindFirstChangeNotificationA)(LPCSTR a0,
                                                       BOOL a1,
                                                       DWORD a2)
    = FindFirstChangeNotificationA;

HANDLE (__stdcall * Real_FindFirstChangeNotificationW)(LPCWSTR a0,
                                                       BOOL a1,
                                                       DWORD a2)
    = FindFirstChangeNotificationW;

HANDLE (__stdcall * Real_FindFirstFileA)(LPCSTR a0,
                                         LPWIN32_FIND_DATAA a1)
    = FindFirstFileA;

HANDLE (__stdcall * Real_FindFirstFileExA)(LPCSTR a0,
                                           FINDEX_INFO_LEVELS a1,
                                           LPVOID a2,
                                           FINDEX_SEARCH_OPS a3,
                                           LPVOID a4,
                                           DWORD a5)
    = FindFirstFileExA;

HANDLE (__stdcall * Real_FindFirstFileExW)(LPCWSTR a0,
                                           FINDEX_INFO_LEVELS a1,
                                           LPVOID a2,
                                           FINDEX_SEARCH_OPS a3,
                                           LPVOID a4,
                                           DWORD a5)
    = FindFirstFileExW;

HANDLE (__stdcall * Real_FindFirstFileW)(LPCWSTR a0,
                                         LPWIN32_FIND_DATAW a1)
    = FindFirstFileW;

BOOL (__stdcall * Real_FindNextChangeNotification)(HANDLE a0)
    = FindNextChangeNotification;

BOOL (__stdcall * Real_FindNextFileA)(HANDLE a0,
                                      LPWIN32_FIND_DATAA a1)
    = FindNextFileA;

BOOL (__stdcall * Real_FindNextFileW)(HANDLE a0,
                                      LPWIN32_FIND_DATAW a1)
    = FindNextFileW;

HRSRC (__stdcall * Real_FindResourceA)(HMODULE a0,
                                       LPCSTR a1,
                                       LPCSTR a2)
    = FindResourceA;

HRSRC (__stdcall * Real_FindResourceExA)(HMODULE a0,
                                         LPCSTR a1,
                                         LPCSTR a2,
                                         WORD a3)
    = FindResourceExA;

HRSRC (__stdcall * Real_FindResourceExW)(HMODULE a0,
                                         LPCWSTR a1,
                                         LPCWSTR a2,
                                         WORD a3)
    = FindResourceExW;

HRSRC (__stdcall * Real_FindResourceW)(HMODULE a0,
                                       LPCWSTR a1,
                                       LPCWSTR a2)
    = FindResourceW;

HWND (__stdcall * Real_FindWindowA)(LPCSTR a0,
                                    LPCSTR a1)
    = FindWindowA;

HWND (__stdcall * Real_FindWindowExA)(HWND a0,
                                      HWND a1,
                                      LPCSTR a2,
                                      LPCSTR a3)
    = FindWindowExA;

HWND (__stdcall * Real_FindWindowExW)(HWND a0,
                                      HWND a1,
                                      LPCWSTR a2,
                                      LPCWSTR a3)
    = FindWindowExW;

HWND (__stdcall * Real_FindWindowW)(LPCWSTR a0,
                                    LPCWSTR a1)
    = FindWindowW;

BOOL (__stdcall * Real_FixBrushOrgEx)(HDC a0,
                                      int a1,
                                      int a2,
                                      POINT* a3)
    = FixBrushOrgEx;

BOOL (__stdcall * Real_FlashWindow)(HWND a0,
                                    BOOL a1)
    = FlashWindow;

BOOL (__stdcall * Real_FlattenPath)(HDC a0)
    = FlattenPath;

BOOL (__stdcall * Real_FloodFill)(HDC a0,
                                  int a1,
                                  int a2,
                                  COLORREF a3)
    = FloodFill;

BOOL (__stdcall * Real_FlushConsoleInputBuffer)(HANDLE a0)
    = FlushConsoleInputBuffer;

BOOL (__stdcall * Real_FlushFileBuffers)(HANDLE a0)
    = FlushFileBuffers;

BOOL (__stdcall * Real_FlushViewOfFile)(LPCVOID a0,
                                        SIZE_T a1)
    = FlushViewOfFile;

HRESULT (__stdcall * Real_FmtIdToPropStgName)(CONST FMTID* a0,
                                              LPOLESTR a1)
    = FmtIdToPropStgName;

int (__stdcall * Real_FoldStringA)(DWORD a0,
                                   LPCSTR a1,
                                   int a2,
                                   LPSTR a3,
                                   int a4)
    = FoldStringA;

int (__stdcall * Real_FoldStringW)(DWORD a0,
                                   LPCWSTR a1,
                                   int a2,
                                   LPWSTR a3,
                                   int a4)
    = FoldStringW;

DWORD (__stdcall * Real_FormatMessageA)(DWORD a0,
                                        LPCVOID a1,
                                        DWORD a2,
                                        DWORD a3,
                                        LPSTR a4,
                                        DWORD a5,
                                        va_list* a6)
    = FormatMessageA;

DWORD (__stdcall * Real_FormatMessageW)(DWORD a0,
                                        LPCVOID a1,
                                        DWORD a2,
                                        DWORD a3,
                                        LPWSTR a4,
                                        DWORD a5,
                                        va_list* a6)
    = FormatMessageW;

int (__stdcall * Real_FrameRect)(HDC a0,
                                 CONST RECT* a1,
                                 HBRUSH a2)
    = FrameRect;

BOOL (__stdcall * Real_FrameRgn)(HDC a0,
                                 HRGN a1,
                                 HBRUSH a2,
                                 int a3,
                                 int a4)
    = FrameRgn;

BOOL (__stdcall * Real_FreeConsole)(void)
    = FreeConsole;

BOOL (__stdcall * Real_FreeDDElParam)(UINT a0,
                                      LPARAM a1)
    = FreeDDElParam;

BOOL (__stdcall * Real_FreeEnvironmentStringsA)(LPSTR a0)
    = FreeEnvironmentStringsA;

BOOL (__stdcall * Real_FreeEnvironmentStringsW)(LPWSTR a0)
    = FreeEnvironmentStringsW;

BOOL (__stdcall * Real_FreeLibrary)(HMODULE a0)
    = FreeLibrary;

void (__stdcall * Real_FreeLibraryAndExitThread)(HMODULE a0,
                                                 DWORD a1)
    = FreeLibraryAndExitThread;

HRESULT (__stdcall * Real_FreePropVariantArray)(ULONG a0,
                                                PROPVARIANT* a1)
    = FreePropVariantArray;

BOOL (__stdcall * Real_FreeResource)(HGLOBAL a0)
    = FreeResource;

BOOL (__stdcall * Real_GdiComment)(HDC a0,
                                   UINT a1,
                                   CONST BYTE* a2)
    = GdiComment;

BOOL (__stdcall * Real_GdiFlush)(void)
    = GdiFlush;

DWORD (__stdcall * Real_GdiGetBatchLimit)(void)
    = GdiGetBatchLimit;

DWORD (__stdcall * Real_GdiSetBatchLimit)(DWORD a0)
    = GdiSetBatchLimit;

BOOL (__stdcall * Real_GenerateConsoleCtrlEvent)(DWORD a0,
                                                 DWORD a1)
    = GenerateConsoleCtrlEvent;

UINT (__stdcall * Real_GetACP)(void)
    = GetACP;

HWND (__stdcall * Real_GetActiveWindow)(void)
    = GetActiveWindow;

int (__stdcall * Real_GetArcDirection)(HDC a0)
    = GetArcDirection;

BOOL (__stdcall * Real_GetAspectRatioFilterEx)(HDC a0,
                                               SIZE* a1)
    = GetAspectRatioFilterEx;

SHORT (__stdcall * Real_GetAsyncKeyState)(int a0)
    = GetAsyncKeyState;

UINT (__stdcall * Real_GetAtomNameA)(ATOM a0,
                                     LPSTR a1,
                                     int a2)
    = GetAtomNameA;

UINT (__stdcall * Real_GetAtomNameW)(ATOM a0,
                                     LPWSTR a1,
                                     int a2)
    = GetAtomNameW;

BOOL (__stdcall * Real_GetBinaryTypeA)(LPCSTR a0,
                                       LPDWORD a1)
    = GetBinaryTypeA;

BOOL (__stdcall * Real_GetBinaryTypeW)(LPCWSTR a0,
                                       LPDWORD a1)
    = GetBinaryTypeW;

LONG (__stdcall * Real_GetBitmapBits)(HBITMAP a0,
                                      LONG a1,
                                      LPVOID a2)
    = GetBitmapBits;

BOOL (__stdcall * Real_GetBitmapDimensionEx)(HBITMAP a0,
                                             SIZE* a1)
    = GetBitmapDimensionEx;

COLORREF (__stdcall * Real_GetBkColor)(HDC a0)
    = GetBkColor;

int (__stdcall * Real_GetBkMode)(HDC a0)
    = GetBkMode;

UINT (__stdcall * Real_GetBoundsRect)(HDC a0,
                                      LPRECT a1,
                                      UINT a2)
    = GetBoundsRect;

BOOL (__stdcall * Real_GetBrushOrgEx)(HDC a0,
                                      POINT* a1)
    = GetBrushOrgEx;

BOOL (__stdcall * Real_GetCPInfo)(UINT a0,
                                  LPCPINFO a1)
    = GetCPInfo;

HWND (__stdcall * Real_GetCapture)(void)
    = GetCapture;

UINT (__stdcall * Real_GetCaretBlinkTime)(void)
    = GetCaretBlinkTime;

BOOL (__stdcall * Real_GetCaretPos)(POINT* a0)
    = GetCaretPos;

BOOL (__stdcall * Real_GetCharABCWidthsA)(HDC a0,
                                          UINT a1,
                                          UINT a2,
                                          LPABC a3)
    = GetCharABCWidthsA;

BOOL (__stdcall * Real_GetCharABCWidthsFloatA)(HDC a0,
                                               UINT a1,
                                               UINT a2,
                                               LPABCFLOAT a3)
    = GetCharABCWidthsFloatA;

BOOL (__stdcall * Real_GetCharABCWidthsFloatW)(HDC a0,
                                               UINT a1,
                                               UINT a2,
                                               LPABCFLOAT a3)
    = GetCharABCWidthsFloatW;

BOOL (__stdcall * Real_GetCharABCWidthsW)(HDC a0,
                                          UINT a1,
                                          UINT a2,
                                          LPABC a3)
    = GetCharABCWidthsW;

BOOL (__stdcall * Real_GetCharWidth32A)(HDC a0,
                                        UINT a1,
                                        UINT a2,
                                        LPINT a3)
    = GetCharWidth32A;

BOOL (__stdcall * Real_GetCharWidth32W)(HDC a0,
                                        UINT a1,
                                        UINT a2,
                                        LPINT a3)
    = GetCharWidth32W;

BOOL (__stdcall * Real_GetCharWidthA)(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPINT a3)
    = GetCharWidthA;

BOOL (__stdcall * Real_GetCharWidthFloatA)(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           PFLOAT a3)
    = GetCharWidthFloatA;

BOOL (__stdcall * Real_GetCharWidthFloatW)(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           PFLOAT a3)
    = GetCharWidthFloatW;

BOOL (__stdcall * Real_GetCharWidthW)(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPINT a3)
    = GetCharWidthW;

DWORD (__stdcall * Real_GetCharacterPlacementA)(HDC a0,
                                                LPCSTR a1,
                                                int a2,
                                                int a3,
                                                LPGCP_RESULTSA a4,
                                                DWORD a5)
    = GetCharacterPlacementA;

DWORD (__stdcall * Real_GetCharacterPlacementW)(HDC a0,
                                                LPCWSTR a1,
                                                int a2,
                                                int a3,
                                                LPGCP_RESULTSW a4,
                                                DWORD a5)
    = GetCharacterPlacementW;

HRESULT (__stdcall * Real_GetClassFile)(LPCOLESTR a0,
                                        CLSID* a1)
    = GetClassFile;

BOOL (__stdcall * Real_GetClassInfoA)(HINSTANCE a0,
                                      LPCSTR a1,
                                      LPWNDCLASSA a2)
    = GetClassInfoA;

BOOL (__stdcall * Real_GetClassInfoExA)(HINSTANCE a0,
                                        LPCSTR a1,
                                        LPWNDCLASSEXA a2)
    = GetClassInfoExA;

BOOL (__stdcall * Real_GetClassInfoExW)(HINSTANCE a0,
                                        LPCWSTR a1,
                                        LPWNDCLASSEXW a2)
    = GetClassInfoExW;

BOOL (__stdcall * Real_GetClassInfoW)(HINSTANCE a0,
                                      LPCWSTR a1,
                                      LPWNDCLASSW a2)
    = GetClassInfoW;

DWORD (__stdcall * Real_GetClassLongA)(HWND a0,
                                       int a1)
    = GetClassLongA;

DWORD (__stdcall * Real_GetClassLongW)(HWND a0,
                                       int a1)
    = GetClassLongW;

int (__stdcall * Real_GetClassNameA)(HWND a0,
                                     LPSTR a1,
                                     int a2)
    = GetClassNameA;

int (__stdcall * Real_GetClassNameW)(HWND a0,
                                     LPWSTR a1,
                                     int a2)
    = GetClassNameW;

WORD (__stdcall * Real_GetClassWord)(HWND a0,
                                     int a1)
    = GetClassWord;

BOOL (__stdcall * Real_GetClientRect)(HWND a0,
                                      LPRECT a1)
    = GetClientRect;

int (__stdcall * Real_GetClipBox)(HDC a0,
                                  LPRECT a1)
    = GetClipBox;

BOOL (__stdcall * Real_GetClipCursor)(LPRECT a0)
    = GetClipCursor;

int (__stdcall * Real_GetClipRgn)(HDC a0,
                                  HRGN a1)
    = GetClipRgn;

HANDLE (__stdcall * Real_GetClipboardData)(UINT a0)
    = GetClipboardData;

int (__stdcall * Real_GetClipboardFormatNameA)(UINT a0,
                                               LPSTR a1,
                                               int a2)
    = GetClipboardFormatNameA;

int (__stdcall * Real_GetClipboardFormatNameW)(UINT a0,
                                               LPWSTR a1,
                                               int a2)
    = GetClipboardFormatNameW;

HWND (__stdcall * Real_GetClipboardOwner)(void)
    = GetClipboardOwner;

HWND (__stdcall * Real_GetClipboardViewer)(void)
    = GetClipboardViewer;

BOOL (__stdcall * Real_GetColorAdjustment)(HDC a0,
                                           LPCOLORADJUSTMENT a1)
    = GetColorAdjustment;

HCOLORSPACE (__stdcall * Real_GetColorSpace)(HDC a0)
    = GetColorSpace;

BOOL (__stdcall * Real_GetCommConfig)(HANDLE a0,
                                      LPCOMMCONFIG a1,
                                      LPDWORD a2)
    = GetCommConfig;

BOOL (__stdcall * Real_GetCommMask)(HANDLE a0,
                                    LPDWORD a1)
    = GetCommMask;

BOOL (__stdcall * Real_GetCommModemStatus)(HANDLE a0,
                                           LPDWORD a1)
    = GetCommModemStatus;

BOOL (__stdcall * Real_GetCommProperties)(HANDLE a0,
                                          LPCOMMPROP a1)
    = GetCommProperties;

BOOL (__stdcall * Real_GetCommState)(HANDLE a0,
                                     LPDCB a1)
    = GetCommState;

BOOL (__stdcall * Real_GetCommTimeouts)(HANDLE a0,
                                        LPCOMMTIMEOUTS a1)
    = GetCommTimeouts;

LPSTR (__stdcall * Real_GetCommandLineA)(void)
    = GetCommandLineA;

LPWSTR (__stdcall * Real_GetCommandLineW)(void)
    = GetCommandLineW;

BOOL (__stdcall * Real_GetComputerNameA)(LPSTR a0,
                                         LPDWORD a1)
    = GetComputerNameA;

BOOL (__stdcall * Real_GetComputerNameW)(LPWSTR a0,
                                         LPDWORD a1)
    = GetComputerNameW;

UINT (__stdcall * Real_GetConsoleCP)(void)
    = GetConsoleCP;

BOOL (__stdcall * Real_GetConsoleCursorInfo)(HANDLE a0,
                                             PCONSOLE_CURSOR_INFO a1)
    = GetConsoleCursorInfo;

BOOL (__stdcall * Real_GetConsoleMode)(HANDLE a0,
                                       LPDWORD a1)
    = GetConsoleMode;

UINT (__stdcall * Real_GetConsoleOutputCP)(void)
    = GetConsoleOutputCP;

BOOL (__stdcall * Real_GetConsoleScreenBufferInfo)(HANDLE a0,
                                                   PCONSOLE_SCREEN_BUFFER_INFO a1)
    = GetConsoleScreenBufferInfo;

DWORD (__stdcall * Real_GetConsoleTitleA)(LPSTR a0,
                                          DWORD a1)
    = GetConsoleTitleA;

DWORD (__stdcall * Real_GetConsoleTitleW)(LPWSTR a0,
                                          DWORD a1)
    = GetConsoleTitleW;

HRESULT (__stdcall * Real_GetConvertStg)(IStorage* a0)
    = GetConvertStg;

int (__stdcall * Real_GetCurrencyFormatA)(LCID a0,
                                          DWORD a1,
                                          LPCSTR a2,
                                          CONST CURRENCYFMTA* a3,
                                          LPSTR a4,
                                          int a5)
    = GetCurrencyFormatA;

int (__stdcall * Real_GetCurrencyFormatW)(LCID a0,
                                          DWORD a1,
                                          LPCWSTR a2,
                                          CONST CURRENCYFMTW* a3,
                                          LPWSTR a4,
                                          int a5)
    = GetCurrencyFormatW;

DWORD (__stdcall * Real_GetCurrentDirectoryA)(DWORD a0,
                                              LPSTR a1)
    = GetCurrentDirectoryA;

DWORD (__stdcall * Real_GetCurrentDirectoryW)(DWORD a0,
                                              LPWSTR a1)
    = GetCurrentDirectoryW;

HGDIOBJ (__stdcall * Real_GetCurrentObject)(HDC a0,
                                            UINT a1)
    = GetCurrentObject;

BOOL (__stdcall * Real_GetCurrentPositionEx)(HDC a0,
                                             POINT* a1)
    = GetCurrentPositionEx;

HANDLE (__stdcall * Real_GetCurrentProcess)(void)
    = GetCurrentProcess;

DWORD (__stdcall * Real_GetCurrentProcessId)(void)
    = GetCurrentProcessId;

DWORD (__stdcall * Real_GetCurrentThreadId)(void)
    = GetCurrentThreadId;

HCURSOR (__stdcall * Real_GetCursor)(void)
    = GetCursor;

BOOL (__stdcall * Real_GetCursorPos)(POINT* a0)
    = GetCursorPos;

HDC (__stdcall * Real_GetDC)(HWND a0)
    = GetDC;

HDC (__stdcall * Real_GetDCEx)(HWND a0,
                               HRGN a1,
                               DWORD a2)
    = GetDCEx;

BOOL (__stdcall * Real_GetDCOrgEx)(HDC a0,
                                   POINT* a1)
    = GetDCOrgEx;

UINT (__stdcall * Real_GetDIBColorTable)(HDC a0,
                                         UINT a1,
                                         UINT a2,
                                         RGBQUAD* a3)
    = GetDIBColorTable;

int (__stdcall * Real_GetDIBits)(HDC a0,
                                 HBITMAP a1,
                                 UINT a2,
                                 UINT a3,
                                 LPVOID a4,
                                 LPBITMAPINFO a5,
                                 UINT a6)
    = GetDIBits;

int (__stdcall * Real_GetDateFormatA)(LCID a0,
                                      DWORD a1,
                                      CONST SYSTEMTIME* a2,
                                      LPCSTR a3,
                                      LPSTR a4,
                                      int a5)
    = GetDateFormatA;

int (__stdcall * Real_GetDateFormatW)(LCID a0,
                                      DWORD a1,
                                      CONST SYSTEMTIME* a2,
                                      LPCWSTR a3,
                                      LPWSTR a4,
                                      int a5)
    = GetDateFormatW;

BOOL (__stdcall * Real_GetDefaultCommConfigA)(LPCSTR a0,
                                              LPCOMMCONFIG a1,
                                              LPDWORD a2)
    = GetDefaultCommConfigA;

BOOL (__stdcall * Real_GetDefaultCommConfigW)(LPCWSTR a0,
                                              LPCOMMCONFIG a1,
                                              LPDWORD a2)
    = GetDefaultCommConfigW;

HWND (__stdcall * Real_GetDesktopWindow)(void)
    = GetDesktopWindow;

int (__stdcall * Real_GetDeviceCaps)(HDC a0,
                                     int a1)
    = GetDeviceCaps;

BOOL (__stdcall * Real_GetDeviceGammaRamp)(HDC a0,
                                           LPVOID a1)
    = GetDeviceGammaRamp;

long (__stdcall * Real_GetDialogBaseUnits)(void)
    = GetDialogBaseUnits;

BOOL (__stdcall * Real_GetDiskFreeSpaceA)(LPCSTR a0,
                                          LPDWORD a1,
                                          LPDWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4)
    = GetDiskFreeSpaceA;

BOOL (__stdcall * Real_GetDiskFreeSpaceExA)(LPCSTR a0,
                                            union _ULARGE_INTEGER* a1,
                                            union _ULARGE_INTEGER* a2,
                                            union _ULARGE_INTEGER* a3)
    = GetDiskFreeSpaceExA;

BOOL (__stdcall * Real_GetDiskFreeSpaceExW)(LPCWSTR a0,
                                            union _ULARGE_INTEGER* a1,
                                            union _ULARGE_INTEGER* a2,
                                            union _ULARGE_INTEGER* a3)
    = GetDiskFreeSpaceExW;

BOOL (__stdcall * Real_GetDiskFreeSpaceW)(LPCWSTR a0,
                                          LPDWORD a1,
                                          LPDWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4)
    = GetDiskFreeSpaceW;

int (__stdcall * Real_GetDlgCtrlID)(HWND a0)
    = GetDlgCtrlID;

HWND (__stdcall * Real_GetDlgItem)(HWND a0,
                                   int a1)
    = GetDlgItem;

UINT (__stdcall * Real_GetDlgItemInt)(HWND a0,
                                      int a1,
                                      BOOL* a2,
                                      BOOL a3)
    = GetDlgItemInt;

UINT (__stdcall * Real_GetDlgItemTextA)(HWND a0,
                                        int a1,
                                        LPSTR a2,
                                        int a3)
    = GetDlgItemTextA;

UINT (__stdcall * Real_GetDlgItemTextW)(HWND a0,
                                        int a1,
                                        LPWSTR a2,
                                        int a3)
    = GetDlgItemTextW;

UINT (__stdcall * Real_GetDoubleClickTime)(void)
    = GetDoubleClickTime;

UINT (__stdcall * Real_GetDriveTypeA)(LPCSTR a0)
    = GetDriveTypeA;

UINT (__stdcall * Real_GetDriveTypeW)(LPCWSTR a0)
    = GetDriveTypeW;

HENHMETAFILE (__stdcall * Real_GetEnhMetaFileA)(LPCSTR a0)
    = GetEnhMetaFileA;

UINT (__stdcall * Real_GetEnhMetaFileBits)(HENHMETAFILE a0,
                                           UINT a1,
                                           LPBYTE a2)
    = GetEnhMetaFileBits;

UINT (__stdcall * Real_GetEnhMetaFileDescriptionA)(HENHMETAFILE a0,
                                                   UINT a1,
                                                   LPSTR a2)
    = GetEnhMetaFileDescriptionA;

UINT (__stdcall * Real_GetEnhMetaFileDescriptionW)(HENHMETAFILE a0,
                                                   UINT a1,
                                                   LPWSTR a2)
    = GetEnhMetaFileDescriptionW;

UINT (__stdcall * Real_GetEnhMetaFileHeader)(HENHMETAFILE a0,
                                             UINT a1,
                                             ENHMETAHEADER* a2)
    = GetEnhMetaFileHeader;

UINT (__stdcall * Real_GetEnhMetaFilePaletteEntries)(HENHMETAFILE a0,
                                                     UINT a1,
                                                     PALETTEENTRY* a2)
    = GetEnhMetaFilePaletteEntries;

UINT (__stdcall * Real_GetEnhMetaFilePixelFormat)(HENHMETAFILE a0,
                                                  UINT a1,
                                                  PIXELFORMATDESCRIPTOR* a2)
    = GetEnhMetaFilePixelFormat;

HENHMETAFILE (__stdcall * Real_GetEnhMetaFileW)(LPCWSTR a0)
    = GetEnhMetaFileW;

#undef GetEnvironmentStrings

LPSTR (__stdcall * Real_GetEnvironmentStrings)(void)
    = GetEnvironmentStrings;

LPWSTR (__stdcall * Real_GetEnvironmentStringsW)(void)
    = GetEnvironmentStringsW;

DWORD (__stdcall * Real_GetEnvironmentVariableA)(LPCSTR a0,
                                                 LPSTR a1,
                                                 DWORD a2)
    = GetEnvironmentVariableA;

DWORD (__stdcall * Real_GetEnvironmentVariableW)(LPCWSTR a0,
                                                 LPWSTR a1,
                                                 DWORD a2)
    = GetEnvironmentVariableW;

BOOL (__stdcall * Real_GetExitCodeProcess)(HANDLE a0,
                                           LPDWORD a1)
    = GetExitCodeProcess;

BOOL (__stdcall * Real_GetExitCodeThread)(HANDLE a0,
                                          LPDWORD a1)
    = GetExitCodeThread;

DWORD (__stdcall * Real_GetFileAttributesA)(LPCSTR a0)
    = GetFileAttributesA;

BOOL (__stdcall * Real_GetFileAttributesExA)(LPCSTR a0,
                                             enum _GET_FILEEX_INFO_LEVELS a1,
                                             LPVOID a2)
    = GetFileAttributesExA;

BOOL (__stdcall * Real_GetFileAttributesExW)(LPCWSTR a0,
                                             enum _GET_FILEEX_INFO_LEVELS a1,
                                             LPVOID a2)
    = GetFileAttributesExW;

DWORD (__stdcall * Real_GetFileAttributesW)(LPCWSTR a0)
    = GetFileAttributesW;

BOOL (__stdcall * Real_GetFileInformationByHandle)(HANDLE a0,
                                                   LPBY_HANDLE_FILE_INFORMATION a1)
    = GetFileInformationByHandle;

DWORD (__stdcall * Real_GetFileSize)(HANDLE a0,
                                     LPDWORD a1)
    = GetFileSize;

BOOL (__stdcall * Real_GetFileTime)(HANDLE a0,
                                    LPFILETIME a1,
                                    LPFILETIME a2,
                                    LPFILETIME a3)
    = GetFileTime;

DWORD (__stdcall * Real_GetFileType)(HANDLE a0)
    = GetFileType;

HWND (__stdcall * Real_GetFocus)(void)
    = GetFocus;

DWORD (__stdcall * Real_GetFontData)(HDC a0,
                                     DWORD a1,
                                     DWORD a2,
                                     LPVOID a3,
                                     DWORD a4)
    = GetFontData;

DWORD (__stdcall * Real_GetFontLanguageInfo)(HDC a0)
    = GetFontLanguageInfo;

HWND (__stdcall * Real_GetForegroundWindow)(void)
    = GetForegroundWindow;

DWORD (__stdcall * Real_GetFullPathNameA)(LPCSTR a0,
                                          DWORD a1,
                                          LPSTR a2,
                                          LPSTR* a3)
    = GetFullPathNameA;

DWORD (__stdcall * Real_GetFullPathNameW)(LPCWSTR a0,
                                          DWORD a1,
                                          LPWSTR a2,
                                          LPWSTR* a3)
    = GetFullPathNameW;

DWORD (__stdcall * Real_GetGlyphOutlineA)(HDC a0,
                                          UINT a1,
                                          UINT a2,
                                          LPGLYPHMETRICS a3,
                                          DWORD a4,
                                          LPVOID a5,
                                          CONST MAT2* a6)
    = GetGlyphOutlineA;

DWORD (__stdcall * Real_GetGlyphOutlineW)(HDC a0,
                                          UINT a1,
                                          UINT a2,
                                          LPGLYPHMETRICS a3,
                                          DWORD a4,
                                          LPVOID a5,
                                          CONST MAT2* a6)
    = GetGlyphOutlineW;

int (__stdcall * Real_GetGraphicsMode)(HDC a0)
    = GetGraphicsMode;

HRESULT (__stdcall * Real_GetHGlobalFromILockBytes)(ILockBytes* a0,
                                                    HGLOBAL* a1)
    = GetHGlobalFromILockBytes;

HRESULT (__stdcall * Real_GetHGlobalFromStream)(LPSTREAM a0,
                                                HGLOBAL* a1)
    = GetHGlobalFromStream;

BOOL (__stdcall * Real_GetHandleInformation)(HANDLE a0,
                                             LPDWORD a1)
    = GetHandleInformation;

BOOL (__stdcall * Real_GetICMProfileA)(HDC a0,
                                       LPDWORD a1,
                                       LPSTR a2)
    = GetICMProfileA;

BOOL (__stdcall * Real_GetICMProfileW)(HDC a0,
                                       LPDWORD a1,
                                       LPWSTR a2)
    = GetICMProfileW;

BOOL (__stdcall * Real_GetIconInfo)(HICON a0,
                                    PICONINFO a1)
    = GetIconInfo;

BOOL (__stdcall * Real_GetInputState)(void)
    = GetInputState;

UINT (__stdcall * Real_GetKBCodePage)(void)
    = GetKBCodePage;

DWORD (__stdcall * Real_GetKerningPairsA)(HDC a0,
                                          DWORD a1,
                                          KERNINGPAIR* a2)
    = GetKerningPairsA;

DWORD (__stdcall * Real_GetKerningPairsW)(HDC a0,
                                          DWORD a1,
                                          KERNINGPAIR* a2)
    = GetKerningPairsW;

int (__stdcall * Real_GetKeyNameTextA)(LONG a0,
                                       LPSTR a1,
                                       int a2)
    = GetKeyNameTextA;

int (__stdcall * Real_GetKeyNameTextW)(LONG a0,
                                       LPWSTR a1,
                                       int a2)
    = GetKeyNameTextW;

SHORT (__stdcall * Real_GetKeyState)(int a0)
    = GetKeyState;

HKL (__stdcall * Real_GetKeyboardLayout)(DWORD a0)
    = GetKeyboardLayout;

int (__stdcall * Real_GetKeyboardLayoutList)(int a0,
                                             HKL* a1)
    = GetKeyboardLayoutList;

BOOL (__stdcall * Real_GetKeyboardLayoutNameA)(LPSTR a0)
    = GetKeyboardLayoutNameA;

BOOL (__stdcall * Real_GetKeyboardLayoutNameW)(LPWSTR a0)
    = GetKeyboardLayoutNameW;

BOOL (__stdcall * Real_GetKeyboardState)(PBYTE a0)
    = GetKeyboardState;

int (__stdcall * Real_GetKeyboardType)(int a0)
    = GetKeyboardType;

HWND (__stdcall * Real_GetLastActivePopup)(HWND a0)
    = GetLastActivePopup;

void (__stdcall * Real_GetLocalTime)(LPSYSTEMTIME a0)
    = GetLocalTime;

int (__stdcall * Real_GetLocaleInfoA)(LCID a0,
                                      LCTYPE a1,
                                      LPSTR a2,
                                      int a3)
    = GetLocaleInfoA;

int (__stdcall * Real_GetLocaleInfoW)(LCID a0,
                                      LCTYPE a1,
                                      LPWSTR a2,
                                      int a3)
    = GetLocaleInfoW;

BOOL (__stdcall * Real_GetLogColorSpaceA)(HCOLORSPACE a0,
                                          LOGCOLORSPACEA* a1,
                                          DWORD a2)
    = GetLogColorSpaceA;

BOOL (__stdcall * Real_GetLogColorSpaceW)(HCOLORSPACE a0,
                                          LOGCOLORSPACEW* a1,
                                          DWORD a2)
    = GetLogColorSpaceW;

DWORD (__stdcall * Real_GetLogicalDriveStringsA)(DWORD a0,
                                                 LPSTR a1)
    = GetLogicalDriveStringsA;

DWORD (__stdcall * Real_GetLogicalDriveStringsW)(DWORD a0,
                                                 LPWSTR a1)
    = GetLogicalDriveStringsW;

DWORD (__stdcall * Real_GetLogicalDrives)(void)
    = GetLogicalDrives;

BOOL (__stdcall * Real_GetMailslotInfo)(HANDLE a0,
                                        LPDWORD a1,
                                        LPDWORD a2,
                                        LPDWORD a3,
                                        LPDWORD a4)
    = GetMailslotInfo;

int (__stdcall * Real_GetMapMode)(HDC a0)
    = GetMapMode;

HMENU (__stdcall * Real_GetMenu)(HWND a0)
    = GetMenu;

LONG (__stdcall * Real_GetMenuCheckMarkDimensions)(void)
    = GetMenuCheckMarkDimensions;

DWORD (__stdcall * Real_GetMenuContextHelpId)(HMENU a0)
    = GetMenuContextHelpId;

UINT (__stdcall * Real_GetMenuDefaultItem)(HMENU a0,
                                           UINT a1,
                                           UINT a2)
    = GetMenuDefaultItem;

int (__stdcall * Real_GetMenuItemCount)(HMENU a0)
    = GetMenuItemCount;

UINT (__stdcall * Real_GetMenuItemID)(HMENU a0,
                                      int a1)
    = GetMenuItemID;

BOOL (__stdcall * Real_GetMenuItemInfoA)(HMENU a0,
                                         UINT a1,
                                         BOOL a2,
                                         LPMENUITEMINFOA a3)
    = GetMenuItemInfoA;

BOOL (__stdcall * Real_GetMenuItemInfoW)(HMENU a0,
                                         UINT a1,
                                         BOOL a2,
                                         LPMENUITEMINFOW a3)
    = GetMenuItemInfoW;

BOOL (__stdcall * Real_GetMenuItemRect)(HWND a0,
                                        HMENU a1,
                                        UINT a2,
                                        LPRECT a3)
    = GetMenuItemRect;

UINT (__stdcall * Real_GetMenuState)(HMENU a0,
                                     UINT a1,
                                     UINT a2)
    = GetMenuState;

int (__stdcall * Real_GetMenuStringA)(HMENU a0,
                                      UINT a1,
                                      LPSTR a2,
                                      int a3,
                                      UINT a4)
    = GetMenuStringA;

int (__stdcall * Real_GetMenuStringW)(HMENU a0,
                                      UINT a1,
                                      LPWSTR a2,
                                      int a3,
                                      UINT a4)
    = GetMenuStringW;

BOOL (__stdcall * Real_GetMessageA)(LPMSG a0,
                                    HWND a1,
                                    UINT a2,
                                    UINT a3)
    = GetMessageA;

LPARAM (__stdcall * Real_GetMessageExtraInfo)(void)
    = GetMessageExtraInfo;

DWORD (__stdcall * Real_GetMessagePos)(void)
    = GetMessagePos;

LONG (__stdcall * Real_GetMessageTime)(void)
    = GetMessageTime;

BOOL (__stdcall * Real_GetMessageW)(LPMSG a0,
                                    HWND a1,
                                    UINT a2,
                                    UINT a3)
    = GetMessageW;

HMETAFILE (__stdcall * Real_GetMetaFileA)(LPCSTR a0)
    = GetMetaFileA;

UINT (__stdcall * Real_GetMetaFileBitsEx)(HMETAFILE a0,
                                          UINT a1,
                                          LPVOID a2)
    = GetMetaFileBitsEx;

HMETAFILE (__stdcall * Real_GetMetaFileW)(LPCWSTR a0)
    = GetMetaFileW;

int (__stdcall * Real_GetMetaRgn)(HDC a0,
                                  HRGN a1)
    = GetMetaRgn;

BOOL (__stdcall * Real_GetMiterLimit)(HDC a0,
                                      PFLOAT a1)
    = GetMiterLimit;

DWORD (__stdcall * Real_GetModuleFileNameA)(HMODULE a0,
                                            LPSTR a1,
                                            DWORD a2)
    = GetModuleFileNameA;

DWORD (__stdcall * Real_GetModuleFileNameW)(HMODULE a0,
                                            LPWSTR a1,
                                            DWORD a2)
    = GetModuleFileNameW;

HMODULE (__stdcall * Real_GetModuleHandleA)(LPCSTR a0)
    = GetModuleHandleA;

HMODULE (__stdcall * Real_GetModuleHandleW)(LPCWSTR a0)
    = GetModuleHandleW;

BOOL (__stdcall * Real_GetNamedPipeHandleStateA)(HANDLE a0,
                                                 LPDWORD a1,
                                                 LPDWORD a2,
                                                 LPDWORD a3,
                                                 LPDWORD a4,
                                                 LPSTR a5,
                                                 DWORD a6)
    = GetNamedPipeHandleStateA;

BOOL (__stdcall * Real_GetNamedPipeHandleStateW)(HANDLE a0,
                                                 LPDWORD a1,
                                                 LPDWORD a2,
                                                 LPDWORD a3,
                                                 LPDWORD a4,
                                                 LPWSTR a5,
                                                 DWORD a6)
    = GetNamedPipeHandleStateW;

BOOL (__stdcall * Real_GetNamedPipeInfo)(HANDLE a0,
                                         LPDWORD a1,
                                         LPDWORD a2,
                                         LPDWORD a3,
                                         LPDWORD a4)
    = GetNamedPipeInfo;

COLORREF (__stdcall * Real_GetNearestColor)(HDC a0,
                                            COLORREF a1)
    = GetNearestColor;

UINT (__stdcall * Real_GetNearestPaletteIndex)(HPALETTE a0,
                                               COLORREF a1)
    = GetNearestPaletteIndex;

HWND (__stdcall * Real_GetNextDlgGroupItem)(HWND a0,
                                            HWND a1,
                                            BOOL a2)
    = GetNextDlgGroupItem;

HWND (__stdcall * Real_GetNextDlgTabItem)(HWND a0,
                                          HWND a1,
                                          BOOL a2)
    = GetNextDlgTabItem;

int (__stdcall * Real_GetNumberFormatA)(LCID a0,
                                        DWORD a1,
                                        LPCSTR a2,
                                        CONST NUMBERFMTA* a3,
                                        LPSTR a4,
                                        int a5)
    = GetNumberFormatA;

int (__stdcall * Real_GetNumberFormatW)(LCID a0,
                                        DWORD a1,
                                        LPCWSTR a2,
                                        CONST NUMBERFMTW* a3,
                                        LPWSTR a4,
                                        int a5)
    = GetNumberFormatW;

BOOL (__stdcall * Real_GetNumberOfConsoleInputEvents)(HANDLE a0,
                                                      LPDWORD a1)
    = GetNumberOfConsoleInputEvents;

BOOL (__stdcall * Real_GetNumberOfConsoleMouseButtons)(LPDWORD a0)
    = GetNumberOfConsoleMouseButtons;

UINT (__stdcall * Real_GetOEMCP)(void)
    = GetOEMCP;

int (__stdcall * Real_GetObjectA)(HGDIOBJ a0,
                                  int a1,
                                  LPVOID a2)
    = GetObjectA;

DWORD (__stdcall * Real_GetObjectType)(HGDIOBJ a0)
    = GetObjectType;

int (__stdcall * Real_GetObjectW)(HGDIOBJ a0,
                                  int a1,
                                  LPVOID a2)
    = GetObjectW;

HWND (__stdcall * Real_GetOpenClipboardWindow)(void)
    = GetOpenClipboardWindow;

UINT (__stdcall * Real_GetOutlineTextMetricsA)(HDC a0,
                                               UINT a1,
                                               LPOUTLINETEXTMETRICA a2)
    = GetOutlineTextMetricsA;

UINT (__stdcall * Real_GetOutlineTextMetricsW)(HDC a0,
                                               UINT a1,
                                               LPOUTLINETEXTMETRICW a2)
    = GetOutlineTextMetricsW;

BOOL (__stdcall * Real_GetOverlappedResult)(HANDLE a0,
                                            LPOVERLAPPED a1,
                                            LPDWORD a2,
                                            BOOL a3)
    = GetOverlappedResult;

UINT (__stdcall * Real_GetPaletteEntries)(HPALETTE a0,
                                          UINT a1,
                                          UINT a2,
                                          PALETTEENTRY* a3)
    = GetPaletteEntries;

HWND (__stdcall * Real_GetParent)(HWND a0)
    = GetParent;

int (__stdcall * Real_GetPath)(HDC a0,
                               POINT* a1,
                               LPBYTE a2,
                               int a3)
    = GetPath;

COLORREF (__stdcall * Real_GetPixel)(HDC a0,
                                     int a1,
                                     int a2)
    = GetPixel;

int (__stdcall * Real_GetPixelFormat)(HDC a0)
    = GetPixelFormat;

int (__stdcall * Real_GetPolyFillMode)(HDC a0)
    = GetPolyFillMode;

DWORD (__stdcall * Real_GetPriorityClass)(HANDLE a0)
    = GetPriorityClass;

int (__stdcall * Real_GetPriorityClipboardFormat)(UINT* a0,
                                                  int a1)
    = GetPriorityClipboardFormat;

UINT (__stdcall * Real_GetPrivateProfileIntA)(LPCSTR a0,
                                              LPCSTR a1,
                                              INT a2,
                                              LPCSTR a3)
    = GetPrivateProfileIntA;

UINT (__stdcall * Real_GetPrivateProfileIntW)(LPCWSTR a0,
                                              LPCWSTR a1,
                                              INT a2,
                                              LPCWSTR a3)
    = GetPrivateProfileIntW;

DWORD (__stdcall * Real_GetPrivateProfileSectionA)(LPCSTR a0,
                                                   LPSTR a1,
                                                   DWORD a2,
                                                   LPCSTR a3)
    = GetPrivateProfileSectionA;

DWORD (__stdcall * Real_GetPrivateProfileSectionNamesA)(LPSTR a0,
                                                        DWORD a1,
                                                        LPCSTR a2)
    = GetPrivateProfileSectionNamesA;

DWORD (__stdcall * Real_GetPrivateProfileSectionNamesW)(LPWSTR a0,
                                                        DWORD a1,
                                                        LPCWSTR a2)
    = GetPrivateProfileSectionNamesW;

DWORD (__stdcall * Real_GetPrivateProfileSectionW)(LPCWSTR a0,
                                                   LPWSTR a1,
                                                   DWORD a2,
                                                   LPCWSTR a3)
    = GetPrivateProfileSectionW;

DWORD (__stdcall * Real_GetPrivateProfileStringA)(LPCSTR a0,
                                                  LPCSTR a1,
                                                  LPCSTR a2,
                                                  LPSTR a3,
                                                  DWORD a4,
                                                  LPCSTR a5)
    = GetPrivateProfileStringA;

DWORD (__stdcall * Real_GetPrivateProfileStringW)(LPCWSTR a0,
                                                  LPCWSTR a1,
                                                  LPCWSTR a2,
                                                  LPWSTR a3,
                                                  DWORD a4,
                                                  LPCWSTR a5)
    = GetPrivateProfileStringW;

BOOL (__stdcall * Real_GetPrivateProfileStructA)(LPCSTR a0,
                                                 LPCSTR a1,
                                                 LPVOID a2,
                                                 UINT a3,
                                                 LPCSTR a4)
    = GetPrivateProfileStructA;

BOOL (__stdcall * Real_GetPrivateProfileStructW)(LPCWSTR a0,
                                                 LPCWSTR a1,
                                                 LPVOID a2,
                                                 UINT a3,
                                                 LPCWSTR a4)
    = GetPrivateProfileStructW;

FARPROC (__stdcall * Real_GetProcAddress)(HMODULE a0,
                                          LPCSTR a1)
    = GetProcAddress;

BOOL (__stdcall * Real_GetProcessAffinityMask)(HANDLE a0,
                                               PDWORD_PTR a1,
                                               PDWORD_PTR a2)
    = GetProcessAffinityMask;

DWORD (__stdcall * Real_GetProcessHeaps)(DWORD a0,
                                         PHANDLE a1)
    = GetProcessHeaps;

BOOL (__stdcall * Real_GetProcessShutdownParameters)(LPDWORD a0,
                                                     LPDWORD a1)
    = GetProcessShutdownParameters;

BOOL (__stdcall * Real_GetProcessTimes)(HANDLE a0,
                                        LPFILETIME a1,
                                        LPFILETIME a2,
                                        LPFILETIME a3,
                                        LPFILETIME a4)
    = GetProcessTimes;

DWORD (__stdcall * Real_GetProcessVersion)(DWORD a0)
    = GetProcessVersion;

HWINSTA (__stdcall * Real_GetProcessWindowStation)(void)
    = GetProcessWindowStation;

BOOL (__stdcall * Real_GetProcessWorkingSetSize)(HANDLE a0,
                                                 PSIZE_T a1,
                                                 PSIZE_T a2)
    = GetProcessWorkingSetSize;

UINT (__stdcall * Real_GetProfileIntA)(LPCSTR a0,
                                       LPCSTR a1,
                                       INT a2)
    = GetProfileIntA;

UINT (__stdcall * Real_GetProfileIntW)(LPCWSTR a0,
                                       LPCWSTR a1,
                                       INT a2)
    = GetProfileIntW;

DWORD (__stdcall * Real_GetProfileSectionA)(LPCSTR a0,
                                            LPSTR a1,
                                            DWORD a2)
    = GetProfileSectionA;

DWORD (__stdcall * Real_GetProfileSectionW)(LPCWSTR a0,
                                            LPWSTR a1,
                                            DWORD a2)
    = GetProfileSectionW;

DWORD (__stdcall * Real_GetProfileStringA)(LPCSTR a0,
                                           LPCSTR a1,
                                           LPCSTR a2,
                                           LPSTR a3,
                                           DWORD a4)
    = GetProfileStringA;

DWORD (__stdcall * Real_GetProfileStringW)(LPCWSTR a0,
                                           LPCWSTR a1,
                                           LPCWSTR a2,
                                           LPWSTR a3,
                                           DWORD a4)
    = GetProfileStringW;

HANDLE (__stdcall * Real_GetPropA)(HWND a0,
                                   LPCSTR a1)
    = GetPropA;

HANDLE (__stdcall * Real_GetPropW)(HWND a0,
                                   LPCWSTR a1)
    = GetPropW;

DWORD (__stdcall * Real_GetQueueStatus)(UINT a0)
    = GetQueueStatus;

BOOL (__stdcall * Real_GetQueuedCompletionStatus)(HANDLE a0,
                                                  LPDWORD a1,
                                                  PULONG_PTR a2,
                                                  LPOVERLAPPED* a3,
                                                  DWORD a4)
    = GetQueuedCompletionStatus;

int (__stdcall * Real_GetROP2)(HDC a0)
    = GetROP2;

BOOL (__stdcall * Real_GetRasterizerCaps)(LPRASTERIZER_STATUS a0,
                                          UINT a1)
    = GetRasterizerCaps;

DWORD (__stdcall * Real_GetRegionData)(HRGN a0,
                                       DWORD a1,
                                       LPRGNDATA a2)
    = GetRegionData;

int (__stdcall * Real_GetRgnBox)(HRGN a0,
                                 LPRECT a1)
    = GetRgnBox;

HRESULT (__stdcall * Real_GetRunningObjectTable)(DWORD a0,
                                                 LPRUNNINGOBJECTTABLE* a1)
    = GetRunningObjectTable;

BOOL (__stdcall * Real_GetScrollInfo)(HWND a0,
                                      int a1,
                                      LPSCROLLINFO a2)
    = GetScrollInfo;

int (__stdcall * Real_GetScrollPos)(HWND a0,
                                    int a1)
    = GetScrollPos;

BOOL (__stdcall * Real_GetScrollRange)(HWND a0,
                                       int a1,
                                       LPINT a2,
                                       LPINT a3)
    = GetScrollRange;

DWORD (__stdcall * Real_GetShortPathNameA)(LPCSTR a0,
                                           LPSTR a1,
                                           DWORD a2)
    = GetShortPathNameA;

DWORD (__stdcall * Real_GetShortPathNameW)(LPCWSTR a0,
                                           LPWSTR a1,
                                           DWORD a2)
    = GetShortPathNameW;

void (__stdcall * Real_GetStartupInfoA)(LPSTARTUPINFOA a0)
    = GetStartupInfoA;

void (__stdcall * Real_GetStartupInfoW)(LPSTARTUPINFOW a0)
    = GetStartupInfoW;

HANDLE (__stdcall * Real_GetStdHandle)(DWORD a0)
    = GetStdHandle;

HGDIOBJ (__stdcall * Real_GetStockObject)(int a0)
    = GetStockObject;

int (__stdcall * Real_GetStretchBltMode)(HDC a0)
    = GetStretchBltMode;

HMENU (__stdcall * Real_GetSubMenu)(HMENU a0,
                                    int a1)
    = GetSubMenu;

DWORD (__stdcall * Real_GetSysColor)(int a0)
    = GetSysColor;

HBRUSH (__stdcall * Real_GetSysColorBrush)(int a0)
    = GetSysColorBrush;

LCID (__stdcall * Real_GetSystemDefaultLCID)(void)
    = GetSystemDefaultLCID;

LANGID (__stdcall * Real_GetSystemDefaultLangID)(void)
    = GetSystemDefaultLangID;

UINT (__stdcall * Real_GetSystemDirectoryA)(LPSTR a0,
                                            UINT a1)
    = GetSystemDirectoryA;

UINT (__stdcall * Real_GetSystemDirectoryW)(LPWSTR a0,
                                            UINT a1)
    = GetSystemDirectoryW;

void (__stdcall * Real_GetSystemInfo)(LPSYSTEM_INFO a0)
    = GetSystemInfo;

HMENU (__stdcall * Real_GetSystemMenu)(HWND a0,
                                       BOOL a1)
    = GetSystemMenu;

int (__stdcall * Real_GetSystemMetrics)(int a0)
    = GetSystemMetrics;

UINT (__stdcall * Real_GetSystemPaletteEntries)(HDC a0,
                                                UINT a1,
                                                UINT a2,
                                                PALETTEENTRY* a3)
    = GetSystemPaletteEntries;

UINT (__stdcall * Real_GetSystemPaletteUse)(HDC a0)
    = GetSystemPaletteUse;

BOOL (__stdcall * Real_GetSystemPowerStatus)(LPSYSTEM_POWER_STATUS a0)
    = GetSystemPowerStatus;

void (__stdcall * Real_GetSystemTime)(LPSYSTEMTIME a0)
    = GetSystemTime;

BOOL (__stdcall * Real_GetSystemTimeAdjustment)(PDWORD a0,
                                                PDWORD a1,
                                                PBOOL a2)
    = GetSystemTimeAdjustment;

void (__stdcall * Real_GetSystemTimeAsFileTime)(LPFILETIME a0)
    = GetSystemTimeAsFileTime;

#if _MSC_VER < 1300
DWORD (__stdcall * Real_GetTabbedTextExtentA)(HDC a0,
                                              LPCSTR a1,
                                              int a2,
                                              int a3,
                                              INT* a4)
    = GetTabbedTextExtentA;
#else
DWORD (__stdcall * Real_GetTabbedTextExtentA)(HDC a0,
                                              LPCSTR a1,
                                              int a2,
                                              int a3,
                                              CONST INT* a4)
    = GetTabbedTextExtentA;
#endif

#if _MSC_VER < 1300
DWORD (__stdcall * Real_GetTabbedTextExtentW)(HDC a0,
                                              LPCWSTR a1,
                                              int a2,
                                              int a3,
                                              INT* a4)
    = GetTabbedTextExtentW;
#else
DWORD (__stdcall * Real_GetTabbedTextExtentW)(HDC a0,
                                              LPCWSTR a1,
                                              int a2,
                                              int a3,
                                              CONST INT* a4)
    = GetTabbedTextExtentW;
#endif

DWORD (__stdcall * Real_GetTapeParameters)(HANDLE a0,
                                           DWORD a1,
                                           LPDWORD a2,
                                           LPVOID a3)
    = GetTapeParameters;

DWORD (__stdcall * Real_GetTapePosition)(HANDLE a0,
                                         DWORD a1,
                                         LPDWORD a2,
                                         LPDWORD a3,
                                         LPDWORD a4)
    = GetTapePosition;

DWORD (__stdcall * Real_GetTapeStatus)(HANDLE a0)
    = GetTapeStatus;

UINT (__stdcall * Real_GetTempFileNameA)(LPCSTR a0,
                                         LPCSTR a1,
                                         UINT a2,
                                         LPSTR a3)
    = GetTempFileNameA;

UINT (__stdcall * Real_GetTempFileNameW)(LPCWSTR a0,
                                         LPCWSTR a1,
                                         UINT a2,
                                         LPWSTR a3)
    = GetTempFileNameW;

DWORD (__stdcall * Real_GetTempPathA)(DWORD a0,
                                      LPSTR a1)
    = GetTempPathA;

DWORD (__stdcall * Real_GetTempPathW)(DWORD a0,
                                      LPWSTR a1)
    = GetTempPathW;

UINT (__stdcall * Real_GetTextAlign)(HDC a0)
    = GetTextAlign;

int (__stdcall * Real_GetTextCharacterExtra)(HDC a0)
    = GetTextCharacterExtra;

int (__stdcall * Real_GetTextCharset)(HDC a0)
    = GetTextCharset;

int (__stdcall * Real_GetTextCharsetInfo)(HDC a0,
                                          LPFONTSIGNATURE a1,
                                          DWORD a2)
    = GetTextCharsetInfo;

COLORREF (__stdcall * Real_GetTextColor)(HDC a0)
    = GetTextColor;

BOOL (__stdcall * Real_GetTextExtentExPointA)(HDC a0,
                                              LPCSTR a1,
                                              int a2,
                                              int a3,
                                              LPINT a4,
                                              LPINT a5,
                                              SIZE* a6)
    = GetTextExtentExPointA;

BOOL (__stdcall * Real_GetTextExtentExPointW)(HDC a0,
                                              LPCWSTR a1,
                                              int a2,
                                              int a3,
                                              LPINT a4,
                                              LPINT a5,
                                              SIZE* a6)
    = GetTextExtentExPointW;

BOOL (__stdcall * Real_GetTextExtentPoint32A)(HDC a0,
                                              LPCSTR a1,
                                              int a2,
                                              SIZE* a3)
    = GetTextExtentPoint32A;

BOOL (__stdcall * Real_GetTextExtentPoint32W)(HDC a0,
                                              LPCWSTR a1,
                                              int a2,
                                              SIZE* a3)
    = GetTextExtentPoint32W;

BOOL (__stdcall * Real_GetTextExtentPointA)(HDC a0,
                                            LPCSTR a1,
                                            int a2,
                                            SIZE* a3)
    = GetTextExtentPointA;

BOOL (__stdcall * Real_GetTextExtentPointW)(HDC a0,
                                            LPCWSTR a1,
                                            int a2,
                                            SIZE* a3)
    = GetTextExtentPointW;

int (__stdcall * Real_GetTextFaceA)(HDC a0,
                                    int a1,
                                    LPSTR a2)
    = GetTextFaceA;

int (__stdcall * Real_GetTextFaceW)(HDC a0,
                                    int a1,
                                    LPWSTR a2)
    = GetTextFaceW;

BOOL (__stdcall * Real_GetTextMetricsA)(HDC a0,
                                        LPTEXTMETRICA a1)
    = GetTextMetricsA;

BOOL (__stdcall * Real_GetTextMetricsW)(HDC a0,
                                        LPTEXTMETRICW a1)
    = GetTextMetricsW;

BOOL (__stdcall * Real_GetThreadContext)(HANDLE a0,
                                         LPCONTEXT a1)
    = GetThreadContext;

HDESK (__stdcall * Real_GetThreadDesktop)(DWORD a0)
    = GetThreadDesktop;

#if(WINVER >= 0x0500)
LCID (__stdcall * Real_GetThreadLocale)(void)
    = GetThreadLocale;
#endif // (WINVER >= 0x0500)

int (__stdcall * Real_GetThreadPriority)(HANDLE a0)
    = GetThreadPriority;

BOOL (__stdcall * Real_GetThreadPriorityBoost)(HANDLE a0,
                                               PBOOL a1)
    = GetThreadPriorityBoost;

BOOL (__stdcall * Real_GetThreadSelectorEntry)(HANDLE a0,
                                               DWORD a1,
                                               LPLDT_ENTRY a2)
    = GetThreadSelectorEntry;

BOOL (__stdcall * Real_GetThreadTimes)(HANDLE a0,
                                       LPFILETIME a1,
                                       LPFILETIME a2,
                                       LPFILETIME a3,
                                       LPFILETIME a4)
    = GetThreadTimes;

DWORD (__stdcall * Real_GetTickCount)(void)
    = GetTickCount;

int (__stdcall * Real_GetTimeFormatA)(LCID a0,
                                      DWORD a1,
                                      CONST SYSTEMTIME* a2,
                                      LPCSTR a3,
                                      LPSTR a4,
                                      int a5)
    = GetTimeFormatA;

int (__stdcall * Real_GetTimeFormatW)(LCID a0,
                                      DWORD a1,
                                      CONST SYSTEMTIME* a2,
                                      LPCWSTR a3,
                                      LPWSTR a4,
                                      int a5)
    = GetTimeFormatW;

DWORD (__stdcall * Real_GetTimeZoneInformation)(LPTIME_ZONE_INFORMATION a0)
    = GetTimeZoneInformation;

HWND (__stdcall * Real_GetTopWindow)(HWND a0)
    = GetTopWindow;

BOOL (__stdcall * Real_GetUpdateRect)(HWND a0,
                                      LPRECT a1,
                                      BOOL a2)
    = GetUpdateRect;

int (__stdcall * Real_GetUpdateRgn)(HWND a0,
                                    HRGN a1,
                                    BOOL a2)
    = GetUpdateRgn;

LCID (__stdcall * Real_GetUserDefaultLCID)(void)
    = GetUserDefaultLCID;

LANGID (__stdcall * Real_GetUserDefaultLangID)(void)
    = GetUserDefaultLangID;

BOOL (__stdcall * Real_GetUserObjectInformationA)(HANDLE a0,
                                                  int a1,
                                                  PVOID a2,
                                                  DWORD a3,
                                                  LPDWORD a4)
    = GetUserObjectInformationA;

BOOL (__stdcall * Real_GetUserObjectInformationW)(HANDLE a0,
                                                  int a1,
                                                  PVOID a2,
                                                  DWORD a3,
                                                  LPDWORD a4)
    = GetUserObjectInformationW;

BOOL (__stdcall * Real_GetUserObjectSecurity)(HANDLE a0,
                                              PSECURITY_INFORMATION a1,
                                              PSECURITY_DESCRIPTOR a2,
                                              DWORD a3,
                                              LPDWORD a4)
    = GetUserObjectSecurity;

DWORD (__stdcall * Real_GetVersion)(void)
    = GetVersion;

BOOL (__stdcall * Real_GetVersionExA)(LPOSVERSIONINFOA a0)
    = GetVersionExA;

BOOL (__stdcall * Real_GetVersionExW)(LPOSVERSIONINFOW a0)
    = GetVersionExW;

BOOL (__stdcall * Real_GetViewportExtEx)(HDC a0,
                                         SIZE* a1)
    = GetViewportExtEx;

BOOL (__stdcall * Real_GetViewportOrgEx)(HDC a0,
                                         POINT* a1)
    = GetViewportOrgEx;

BOOL (__stdcall * Real_GetVolumeInformationA)(LPCSTR a0,
                                              LPSTR a1,
                                              DWORD a2,
                                              LPDWORD a3,
                                              LPDWORD a4,
                                              LPDWORD a5,
                                              LPSTR a6,
                                              DWORD a7)
    = GetVolumeInformationA;

BOOL (__stdcall * Real_GetVolumeInformationW)(LPCWSTR a0,
                                              LPWSTR a1,
                                              DWORD a2,
                                              LPDWORD a3,
                                              LPDWORD a4,
                                              LPDWORD a5,
                                              LPWSTR a6,
                                              DWORD a7)
    = GetVolumeInformationW;

UINT (__stdcall * Real_GetWinMetaFileBits)(HENHMETAFILE a0,
                                           UINT a1,
                                           LPBYTE a2,
                                           INT a3,
                                           HDC a4)
    = GetWinMetaFileBits;

HWND (__stdcall * Real_GetWindow)(HWND a0,
                                  UINT a1)
    = GetWindow;

DWORD (__stdcall * Real_GetWindowContextHelpId)(HWND a0)
    = GetWindowContextHelpId;

HDC (__stdcall * Real_GetWindowDC)(HWND a0)
    = GetWindowDC;

BOOL (__stdcall * Real_GetWindowExtEx)(HDC a0,
                                       SIZE* a1)
    = GetWindowExtEx;

LONG (__stdcall * Real_GetWindowLongA)(HWND a0,
                                       int a1)
    = GetWindowLongA;

LONG (__stdcall * Real_GetWindowLongW)(HWND a0,
                                       int a1)
    = GetWindowLongW;

BOOL (__stdcall * Real_GetWindowOrgEx)(HDC a0,
                                       POINT* a1)
    = GetWindowOrgEx;

BOOL (__stdcall * Real_GetWindowPlacement)(HWND a0,
                                           WINDOWPLACEMENT* a1)
    = GetWindowPlacement;

BOOL (__stdcall * Real_GetWindowRect)(HWND a0,
                                      LPRECT a1)
    = GetWindowRect;

int (__stdcall * Real_GetWindowRgn)(HWND a0,
                                    HRGN a1)
    = GetWindowRgn;

int (__stdcall * Real_GetWindowTextA)(HWND a0,
                                      LPSTR a1,
                                      int a2)
    = GetWindowTextA;

int (__stdcall * Real_GetWindowTextLengthA)(HWND a0)
    = GetWindowTextLengthA;

int (__stdcall * Real_GetWindowTextLengthW)(HWND a0)
    = GetWindowTextLengthW;

int (__stdcall * Real_GetWindowTextW)(HWND a0,
                                      LPWSTR a1,
                                      int a2)
    = GetWindowTextW;

DWORD (__stdcall * Real_GetWindowThreadProcessId)(HWND a0,
                                                  LPDWORD a1)
    = GetWindowThreadProcessId;

WORD (__stdcall * Real_GetWindowWord)(HWND a0,
                                      int a1)
    = GetWindowWord;

UINT (__stdcall * Real_GetWindowsDirectoryA)(LPSTR a0,
                                             UINT a1)
    = GetWindowsDirectoryA;

UINT (__stdcall * Real_GetWindowsDirectoryW)(LPWSTR a0,
                                             UINT a1)
    = GetWindowsDirectoryW;

BOOL (__stdcall * Real_GetWorldTransform)(HDC a0,
                                          XFORM* a1)
    = GetWorldTransform;

ATOM (__stdcall * Real_GlobalAddAtomA)(LPCSTR a0)
    = GlobalAddAtomA;

ATOM (__stdcall * Real_GlobalAddAtomW)(LPCWSTR a0)
    = GlobalAddAtomW;

HGLOBAL (__stdcall * Real_GlobalAlloc)(UINT a0,
                                       SIZE_T a1)
    = GlobalAlloc;

#if _MSC_VER < 1300
UINT (__stdcall * Real_GlobalCompact)(DWORD a0)
    = GlobalCompact;
#else
SIZE_T (__stdcall * Real_GlobalCompact)(DWORD a0)
    = GlobalCompact;
#endif

ATOM (__stdcall * Real_GlobalDeleteAtom)(ATOM a0)
    = GlobalDeleteAtom;

ATOM (__stdcall * Real_GlobalFindAtomA)(LPCSTR a0)
    = GlobalFindAtomA;

ATOM (__stdcall * Real_GlobalFindAtomW)(LPCWSTR a0)
    = GlobalFindAtomW;

void (__stdcall * Real_GlobalFix)(HGLOBAL a0)
    = GlobalFix;

UINT (__stdcall * Real_GlobalFlags)(HGLOBAL a0)
    = GlobalFlags;

HGLOBAL (__stdcall * Real_GlobalFree)(HGLOBAL a0)
    = GlobalFree;

UINT (__stdcall * Real_GlobalGetAtomNameA)(ATOM a0,
                                           LPSTR a1,
                                           int a2)
    = GlobalGetAtomNameA;

UINT (__stdcall * Real_GlobalGetAtomNameW)(ATOM a0,
                                           LPWSTR a1,
                                           int a2)
    = GlobalGetAtomNameW;

HGLOBAL (__stdcall * Real_GlobalHandle)(LPCVOID a0)
    = GlobalHandle;

LPVOID (__stdcall * Real_GlobalLock)(HGLOBAL a0)
    = GlobalLock;

void (__stdcall * Real_GlobalMemoryStatus)(LPMEMORYSTATUS a0)
    = GlobalMemoryStatus;

HGLOBAL (__stdcall * Real_GlobalReAlloc)(HGLOBAL a0,
                                         SIZE_T a1,
                                         UINT a2)
    = GlobalReAlloc;

SIZE_T (__stdcall * Real_GlobalSize)(HGLOBAL a0)
    = GlobalSize;

BOOL (__stdcall * Real_GlobalUnWire)(HGLOBAL a0)
    = GlobalUnWire;

void (__stdcall * Real_GlobalUnfix)(HGLOBAL a0)
    = GlobalUnfix;

BOOL (__stdcall * Real_GlobalUnlock)(HGLOBAL a0)
    = GlobalUnlock;

LPVOID (__stdcall * Real_GlobalWire)(HGLOBAL a0)
    = GlobalWire;

BOOL (__stdcall * Real_GrayStringA)(HDC a0,
                                    HBRUSH a1,
                                    GRAYSTRINGPROC a2,
                                    LPARAM a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    int a8)
    = GrayStringA;

BOOL (__stdcall * Real_GrayStringW)(HDC a0,
                                    HBRUSH a1,
                                    GRAYSTRINGPROC a2,
                                    LPARAM a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    int a8)
    = GrayStringW;

BOOL (__stdcall * Real_HeapLock)(HANDLE a0)
    = HeapLock;

BOOL (__stdcall * Real_HeapUnlock)(HANDLE a0)
    = HeapUnlock;

BOOL (__stdcall * Real_HideCaret)(HWND a0)
    = HideCaret;

BOOL (__stdcall * Real_HiliteMenuItem)(HWND a0,
                                       HMENU a1,
                                       UINT a2,
                                       UINT a3)
    = HiliteMenuItem;

#ifdef _WIN32_WINNT_WIN7
HRESULT (__stdcall * Real_IIDFromString)(LPCOLESTR a0,
                                         LPGUID a1)
    = IIDFromString;
#else
HRESULT (__stdcall * Real_IIDFromString)(LPOLESTR a0,
                                         LPGUID a1)
    = IIDFromString;
#endif

BOOL (__stdcall * Real_ImpersonateDdeClientWindow)(HWND a0,
                                                   HWND a1)
    = ImpersonateDdeClientWindow;

BOOL (__stdcall * Real_InSendMessage)(void)
    = InSendMessage;

BOOL (__stdcall * Real_InflateRect)(LPRECT a0,
                                    int a1,
                                    int a2)
    = InflateRect;

BOOL (__stdcall * Real_InitAtomTable)(DWORD a0)
    = InitAtomTable;

BOOL (__stdcall * Real_InsertMenuA)(HMENU a0,
                                    UINT a1,
                                    UINT a2,
                                    UINT_PTR a3,
                                    LPCSTR a4)
    = InsertMenuA;

BOOL (__stdcall * Real_InsertMenuW)(HMENU a0,
                                    UINT a1,
                                    UINT a2,
                                    UINT_PTR a3,
                                    LPCWSTR a4)
    = InsertMenuW;

BOOL (__stdcall * Real_InsertMenuItemA)(HMENU a0,
                                        UINT a1,
                                        BOOL a2,
                                        LPCMENUITEMINFOA a3)
    = InsertMenuItemA;

BOOL (__stdcall * Real_InsertMenuItemW)(HMENU a0,
                                        UINT a1,
                                        BOOL a2,
                                        LPCMENUITEMINFOW a3)
    = InsertMenuItemW;

int (__stdcall * Real_IntersectClipRect)(HDC a0,
                                         int a1,
                                         int a2,
                                         int a3,
                                         int a4)
    = IntersectClipRect;

BOOL (__stdcall * Real_IntersectRect)(LPRECT a0,
                                      CONST RECT* a1,
                                      CONST RECT* a2)
    = IntersectRect;

BOOL (__stdcall * Real_InvalidateRect)(HWND a0,
                                       CONST RECT* a1,
                                       BOOL a2)
    = InvalidateRect;

BOOL (__stdcall * Real_InvalidateRgn)(HWND a0,
                                      HRGN a1,
                                      BOOL a2)
    = InvalidateRgn;

BOOL (__stdcall * Real_InvertRect)(HDC a0,
                                   CONST RECT* a1)
    = InvertRect;

BOOL (__stdcall * Real_InvertRgn)(HDC a0,
                                  HRGN a1)
    = InvertRgn;

BOOL (__stdcall * Real_IsAccelerator)(HACCEL a0,
                                      int a1,
                                      LPMSG a2,
                                      WORD* a3)
    = IsAccelerator;

BOOL (__stdcall * Real_IsBadCodePtr)(FARPROC a0)
    = IsBadCodePtr;

BOOL (__stdcall * Real_IsBadHugeReadPtr)(CONST void* a0,
                                         UINT_PTR a1)
    = IsBadHugeReadPtr;

BOOL (__stdcall * Real_IsBadHugeWritePtr)(LPVOID a0,
                                          UINT_PTR a1)
    = IsBadHugeWritePtr;

BOOL (__stdcall * Real_IsBadReadPtr)(CONST void* a0,
                                     UINT_PTR a1)
    = IsBadReadPtr;

BOOL (__stdcall * Real_IsBadStringPtrA)(LPCSTR a0,
                                        UINT_PTR a1)
    = IsBadStringPtrA;

BOOL (__stdcall * Real_IsBadStringPtrW)(LPCWSTR a0,
                                        UINT_PTR a1)
    = IsBadStringPtrW;

BOOL (__stdcall * Real_IsBadWritePtr)(LPVOID a0,
                                      UINT_PTR a1)
    = IsBadWritePtr;

BOOL (__stdcall * Real_IsCharAlphaA)(CHAR a0)
    = IsCharAlphaA;

BOOL (__stdcall * Real_IsCharAlphaNumericA)(CHAR a0)
    = IsCharAlphaNumericA;

BOOL (__stdcall * Real_IsCharAlphaNumericW)(WCHAR a0)
    = IsCharAlphaNumericW;

BOOL (__stdcall * Real_IsCharAlphaW)(WCHAR a0)
    = IsCharAlphaW;

BOOL (__stdcall * Real_IsCharLowerA)(CHAR a0)
    = IsCharLowerA;

BOOL (__stdcall * Real_IsCharLowerW)(WCHAR a0)
    = IsCharLowerW;

BOOL (__stdcall * Real_IsCharUpperA)(CHAR a0)
    = IsCharUpperA;

BOOL (__stdcall * Real_IsCharUpperW)(WCHAR a0)
    = IsCharUpperW;

BOOL (__stdcall * Real_IsChild)(HWND a0,
                                HWND a1)
    = IsChild;

BOOL (__stdcall * Real_IsClipboardFormatAvailable)(UINT a0)
    = IsClipboardFormatAvailable;

BOOL (__stdcall * Real_IsDBCSLeadByte)(BYTE a0)
    = IsDBCSLeadByte;

BOOL (__stdcall * Real_IsDBCSLeadByteEx)(UINT a0,
                                         BYTE a1)
    = IsDBCSLeadByteEx;

BOOL (__stdcall * Real_IsDebuggerPresent)(void)
    = IsDebuggerPresent;

BOOL (__stdcall * Real_IsDialogMessageA)(HWND a0,
                                         LPMSG a1)
    = IsDialogMessageA;

BOOL (__stdcall * Real_IsDialogMessageW)(HWND a0,
                                         LPMSG a1)
    = IsDialogMessageW;

UINT (__stdcall * Real_IsDlgButtonChecked)(HWND a0,
                                           int a1)
    = IsDlgButtonChecked;

BOOL (__stdcall * Real_IsIconic)(HWND a0)
    = IsIconic;

BOOL (__stdcall * Real_IsMenu)(HMENU a0)
    = IsMenu;

#if !defined(DETOURS_ARM)
BOOL (__stdcall * Real_IsProcessorFeaturePresent)(DWORD a0)
    = IsProcessorFeaturePresent;
#endif // !DETOURS_ARM

BOOL (__stdcall * Real_IsRectEmpty)(CONST RECT* a0)
    = IsRectEmpty;

BOOL (__stdcall * Real_IsValidCodePage)(UINT a0)
    = IsValidCodePage;

BOOL (__stdcall * Real_IsValidLocale)(LCID a0,
                                      DWORD a1)
    = IsValidLocale;

BOOL (__stdcall * Real_IsWindow)(HWND a0)
    = IsWindow;

BOOL (__stdcall * Real_IsWindowEnabled)(HWND a0)
    = IsWindowEnabled;

BOOL (__stdcall * Real_IsWindowUnicode)(HWND a0)
    = IsWindowUnicode;

BOOL (__stdcall * Real_IsWindowVisible)(HWND a0)
    = IsWindowVisible;

BOOL (__stdcall * Real_IsZoomed)(HWND a0)
    = IsZoomed;

BOOL (__stdcall * Real_KillTimer)(HWND a0,
                                  UINT_PTR a1)
    = KillTimer;

BOOL (__stdcall * Real_LPtoDP)(HDC a0,
                               POINT* a1,
                               int a2)
    = LPtoDP;

BOOL (__stdcall * Real_LineDDA)(int a0,
                                int a1,
                                int a2,
                                int a3,
                                LINEDDAPROC a4,
                                LPARAM a5)
    = LineDDA;

BOOL (__stdcall * Real_LineTo)(HDC a0,
                               int a1,
                               int a2)
    = LineTo;

HACCEL (__stdcall * Real_LoadAcceleratorsA)(HINSTANCE a0,
                                            LPCSTR a1)
    = LoadAcceleratorsA;

HACCEL (__stdcall * Real_LoadAcceleratorsW)(HINSTANCE a0,
                                            LPCWSTR a1)
    = LoadAcceleratorsW;

HBITMAP (__stdcall * Real_LoadBitmapA)(HINSTANCE a0,
                                       LPCSTR a1)
    = LoadBitmapA;

HBITMAP (__stdcall * Real_LoadBitmapW)(HINSTANCE a0,
                                       LPCWSTR a1)
    = LoadBitmapW;

HCURSOR (__stdcall * Real_LoadCursorA)(HINSTANCE a0,
                                       LPCSTR a1)
    = LoadCursorA;

HCURSOR (__stdcall * Real_LoadCursorFromFileA)(LPCSTR a0)
    = LoadCursorFromFileA;

HCURSOR (__stdcall * Real_LoadCursorFromFileW)(LPCWSTR a0)
    = LoadCursorFromFileW;

HCURSOR (__stdcall * Real_LoadCursorW)(HINSTANCE a0,
                                       LPCWSTR a1)
    = LoadCursorW;

HICON (__stdcall * Real_LoadIconA)(HINSTANCE a0,
                                   LPCSTR a1)
    = LoadIconA;

HICON (__stdcall * Real_LoadIconW)(HINSTANCE a0,
                                   LPCWSTR a1)
    = LoadIconW;

HANDLE (__stdcall * Real_LoadImageA)(HINSTANCE a0,
                                     LPCSTR a1,
                                     UINT a2,
                                     int a3,
                                     int a4,
                                     UINT a5)
    = LoadImageA;

HANDLE (__stdcall * Real_LoadImageW)(HINSTANCE a0,
                                     LPCWSTR a1,
                                     UINT a2,
                                     int a3,
                                     int a4,
                                     UINT a5)
    = LoadImageW;

HKL (__stdcall * Real_LoadKeyboardLayoutA)(LPCSTR a0,
                                           UINT a1)
    = LoadKeyboardLayoutA;

HKL (__stdcall * Real_LoadKeyboardLayoutW)(LPCWSTR a0,
                                           UINT a1)
    = LoadKeyboardLayoutW;

HMODULE (__stdcall * Real_LoadLibraryA)(LPCSTR a0)
    = LoadLibraryA;

HMODULE (__stdcall * Real_LoadLibraryExA)(LPCSTR a0,
                                          HANDLE a1,
                                          DWORD a2)
    = LoadLibraryExA;

HMODULE (__stdcall * Real_LoadLibraryExW)(LPCWSTR a0,
                                          HANDLE a1,
                                          DWORD a2)
    = LoadLibraryExW;

HMODULE (__stdcall * Real_LoadLibraryW)(LPCWSTR a0)
    = LoadLibraryW;

HMENU (__stdcall * Real_LoadMenuA)(HINSTANCE a0,
                                   LPCSTR a1)
    = LoadMenuA;

HMENU (__stdcall * Real_LoadMenuIndirectA)(CONST MENUTEMPLATEA* a0)
    = LoadMenuIndirectA;

HMENU (__stdcall * Real_LoadMenuIndirectW)(CONST MENUTEMPLATEW* a0)
    = LoadMenuIndirectW;

HMENU (__stdcall * Real_LoadMenuW)(HINSTANCE a0,
                                   LPCWSTR a1)
    = LoadMenuW;

DWORD (__stdcall * Real_LoadModule)(LPCSTR a0,
                                    LPVOID a1)
    = LoadModule;

HGLOBAL (__stdcall * Real_LoadResource)(HMODULE a0,
                                        HRSRC a1)
    = LoadResource;

int (__stdcall * Real_LoadStringA)(HINSTANCE a0,
                                   UINT a1,
                                   LPSTR a2,
                                   int a3)
    = LoadStringA;

int (__stdcall * Real_LoadStringW)(HINSTANCE a0,
                                   UINT a1,
                                   LPWSTR a2,
                                   int a3)
    = LoadStringW;

#if _MSC_VER < 1300
HLOCAL (__stdcall * Real_LocalAlloc)(UINT a0,
                                     UINT a1)
    = LocalAlloc;
#else
HLOCAL (__stdcall * Real_LocalAlloc)(UINT a0,
                                     SIZE_T a1)
    = LocalAlloc;
#endif

#if _MSC_VER < 1300
UINT (__stdcall * Real_LocalCompact)(UINT a0)
    = LocalCompact;
#else
SIZE_T (__stdcall * Real_LocalCompact)(UINT a0)
    = LocalCompact;
#endif

BOOL (__stdcall * Real_LocalFileTimeToFileTime)(CONST FILETIME* a0,
                                                LPFILETIME a1)
    = LocalFileTimeToFileTime;

UINT (__stdcall * Real_LocalFlags)(HLOCAL a0)
    = LocalFlags;

HLOCAL (__stdcall * Real_LocalFree)(HLOCAL a0)
    = LocalFree;

HLOCAL (__stdcall * Real_LocalHandle)(LPCVOID a0)
    = LocalHandle;

LPVOID (__stdcall * Real_LocalLock)(HLOCAL a0)
    = LocalLock;

#if _MSC_VER < 1300
HLOCAL (__stdcall * Real_LocalReAlloc)(HLOCAL a0,
                                       UINT a1,
                                       UINT a2)
    = LocalReAlloc;
#else
HLOCAL (__stdcall * Real_LocalReAlloc)(HLOCAL a0,
                                       SIZE_T a1,
                                       UINT a2)
    = LocalReAlloc;
#endif

#if _MSC_VER < 1300
UINT (__stdcall * Real_LocalShrink)(HLOCAL a0,
                                      UINT a1)
    = LocalShrink;
#else
SIZE_T (__stdcall * Real_LocalShrink)(HLOCAL a0,
                                      UINT a1)
    = LocalShrink;
#endif

#if _MSC_VER < 1300
UINT (__stdcall * Real_LocalSize)(HLOCAL a0)
    = LocalSize;
#else
SIZE_T (__stdcall * Real_LocalSize)(HLOCAL a0)
    = LocalSize;
#endif

BOOL (__stdcall * Real_LocalUnlock)(HLOCAL a0)
    = LocalUnlock;

BOOL (__stdcall * Real_LockFile)(HANDLE a0,
                                 DWORD a1,
                                 DWORD a2,
                                 DWORD a3,
                                 DWORD a4)
    = LockFile;

BOOL (__stdcall * Real_LockFileEx)(HANDLE a0,
                                   DWORD a1,
                                   DWORD a2,
                                   DWORD a3,
                                   DWORD a4,
                                   LPOVERLAPPED a5)
    = LockFileEx;

LPVOID (__stdcall * Real_LockResource)(HGLOBAL a0)
    = LockResource;

BOOL (__stdcall * Real_LockWindowUpdate)(HWND a0)
    = LockWindowUpdate;

int (__stdcall * Real_LookupIconIdFromDirectory)(PBYTE a0,
                                                 BOOL a1)
    = LookupIconIdFromDirectory;

int (__stdcall * Real_LookupIconIdFromDirectoryEx)(PBYTE a0,
                                                   BOOL a1,
                                                   int a2,
                                                   int a3,
                                                   UINT a4)
    = LookupIconIdFromDirectoryEx;

BOOL (__stdcall * Real_MapDialogRect)(HWND a0,
                                      LPRECT a1)
    = MapDialogRect;

LPVOID (__stdcall * Real_MapViewOfFile)(HANDLE a0,
                                        DWORD a1,
                                        DWORD a2,
                                        DWORD a3,
                                        SIZE_T a4)
    = MapViewOfFile;

LPVOID (__stdcall * Real_MapViewOfFileEx)(HANDLE a0,
                                          DWORD a1,
                                          DWORD a2,
                                          DWORD a3,
                                          SIZE_T a4,
                                          LPVOID a5)
    = MapViewOfFileEx;

UINT (__stdcall * Real_MapVirtualKeyA)(UINT a0,
                                       UINT a1)
    = MapVirtualKeyA;

UINT (__stdcall * Real_MapVirtualKeyExA)(UINT a0,
                                         UINT a1,
                                         HKL a2)
    = MapVirtualKeyExA;

UINT (__stdcall * Real_MapVirtualKeyExW)(UINT a0,
                                         UINT a1,
                                         HKL a2)
    = MapVirtualKeyExW;

UINT (__stdcall * Real_MapVirtualKeyW)(UINT a0,
                                       UINT a1)
    = MapVirtualKeyW;

int (__stdcall * Real_MapWindowPoints)(HWND a0,
                                       HWND a1,
                                       POINT* a2,
                                       UINT a3)
    = MapWindowPoints;

BOOL (__stdcall * Real_MaskBlt)(HDC a0,
                                int a1,
                                int a2,
                                int a3,
                                int a4,
                                HDC a5,
                                int a6,
                                int a7,
                                HBITMAP a8,
                                int a9,
                                int a10,
                                DWORD a11)
    = MaskBlt;

int (__stdcall * Real_MenuItemFromPoint)(HWND a0,
                                         HMENU a1,
                                         POINT a2)
    = MenuItemFromPoint;

BOOL (__stdcall * Real_MessageBeep)(UINT a0)
    = MessageBeep;

int (__stdcall * Real_MessageBoxA)(HWND a0,
                                   LPCSTR a1,
                                   LPCSTR a2,
                                   UINT a3)
    = MessageBoxA;

int (__stdcall * Real_MessageBoxExA)(HWND a0,
                                     LPCSTR a1,
                                     LPCSTR a2,
                                     UINT a3,
                                     WORD a4)
    = MessageBoxExA;

int (__stdcall * Real_MessageBoxExW)(HWND a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2,
                                     UINT a3,
                                     WORD a4)
    = MessageBoxExW;

#if _MSC_VER < 1300
int (__stdcall * Real_MessageBoxIndirectA)(MSGBOXPARAMSA* a0)
    = MessageBoxIndirectA;
#else
int (__stdcall * Real_MessageBoxIndirectA)(CONST MSGBOXPARAMSA* a0)
    = MessageBoxIndirectA;
#endif

#if _MSC_VER < 1300
int (__stdcall * Real_MessageBoxIndirectW)(MSGBOXPARAMSW* a0)
    = MessageBoxIndirectW;
#else
int (__stdcall * Real_MessageBoxIndirectW)(CONST MSGBOXPARAMSW* a0)
    = MessageBoxIndirectW;
#endif

int (__stdcall * Real_MessageBoxW)(HWND a0,
                                   LPCWSTR a1,
                                   LPCWSTR a2,
                                   UINT a3)
    = MessageBoxW;

HRESULT (__stdcall * Real_MkParseDisplayName)(IBindCtx* a0,
                                              LPCOLESTR a1,
                                              ULONG* a2,
                                              IMoniker** a3)
    = MkParseDisplayName;

BOOL (__stdcall * Real_ModifyMenuA)(HMENU a0,
                                    UINT a1,
                                    UINT a2,
                                    UINT_PTR a3,
                                    LPCSTR a4)
    = ModifyMenuA;

BOOL (__stdcall * Real_ModifyMenuW)(HMENU a0,
                                    UINT a1,
                                    UINT a2,
                                    UINT_PTR a3,
                                    LPCWSTR a4)
    = ModifyMenuW;

BOOL (__stdcall * Real_ModifyWorldTransform)(HDC a0,
                                             CONST XFORM* a1,
                                             DWORD a2)
    = ModifyWorldTransform;

HRESULT (__stdcall * Real_MonikerCommonPrefixWith)(IMoniker* a0,
                                                   IMoniker* a1,
                                                   IMoniker** a2)
    = MonikerCommonPrefixWith;

HRESULT (__stdcall * Real_MonikerRelativePathTo)(IMoniker* a0,
                                                 IMoniker* a1,
                                                 IMoniker** a2,
                                                 BOOL a3)
    = MonikerRelativePathTo;

BOOL (__stdcall * Real_MoveFileA)(LPCSTR a0,
                                  LPCSTR a1)
    = MoveFileA;

BOOL (__stdcall * Real_MoveFileExA)(LPCSTR a0,
                                    LPCSTR a1,
                                    DWORD a2)
    = MoveFileExA;

BOOL (__stdcall * Real_MoveFileExW)(LPCWSTR a0,
                                    LPCWSTR a1,
                                    DWORD a2)
    = MoveFileExW;

BOOL (__stdcall * Real_MoveFileW)(LPCWSTR a0,
                                  LPCWSTR a1)
    = MoveFileW;

BOOL (__stdcall * Real_MoveToEx)(HDC a0,
                                 int a1,
                                 int a2,
                                 POINT* a3)
    = MoveToEx;

BOOL (__stdcall * Real_MoveWindow)(HWND a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   int a4,
                                   BOOL a5)
    = MoveWindow;

#if _MSC_VER < 1300
DWORD (__stdcall * Real_MsgWaitForMultipleObjects)(DWORD a0,
                                                   HANDLE * a1,
                                                   BOOL a2,
                                                   DWORD a3,
                                                   DWORD a4)
    = MsgWaitForMultipleObjects;
#else
DWORD (__stdcall * Real_MsgWaitForMultipleObjects)(DWORD a0,
                                                   CONST HANDLE * a1,
                                                   BOOL a2,
                                                   DWORD a3,
                                                   DWORD a4)
    = MsgWaitForMultipleObjects;
#endif

#if _MSC_VER < 1300
DWORD (__stdcall * Real_MsgWaitForMultipleObjectsEx)(DWORD a0,
                                                     HANDLE * a1,
                                                     DWORD a2,
                                                     DWORD a3,
                                                     DWORD a4)
    = MsgWaitForMultipleObjectsEx;
#else
DWORD (__stdcall * Real_MsgWaitForMultipleObjectsEx)(DWORD a0,
                                                     CONST HANDLE * a1,
                                                     DWORD a2,
                                                     DWORD a3,
                                                     DWORD a4)
    = MsgWaitForMultipleObjectsEx;
#endif

int (__stdcall * Real_MulDiv)(int a0,
                              int a1,
                              int a2)
    = MulDiv;

DWORD (__stdcall * Real_OemKeyScan)(WORD a0)
    = OemKeyScan;

BOOL (__stdcall * Real_OemToCharA)(LPCSTR a0,
                                   LPSTR a1)
    = OemToCharA;

BOOL (__stdcall * Real_OemToCharBuffA)(LPCSTR a0,
                                       LPSTR a1,
                                       DWORD a2)
    = OemToCharBuffA;

BOOL (__stdcall * Real_OemToCharBuffW)(LPCSTR a0,
                                       LPWSTR a1,
                                       DWORD a2)
    = OemToCharBuffW;

BOOL (__stdcall * Real_OemToCharW)(LPCSTR a0,
                                   LPWSTR a1)
    = OemToCharW;

int (__stdcall * Real_OffsetClipRgn)(HDC a0,
                                     int a1,
                                     int a2)
    = OffsetClipRgn;

BOOL (__stdcall * Real_OffsetRect)(LPRECT a0,
                                   int a1,
                                   int a2)
    = OffsetRect;

int (__stdcall * Real_OffsetRgn)(HRGN a0,
                                 int a1,
                                 int a2)
    = OffsetRgn;

BOOL (__stdcall * Real_OffsetViewportOrgEx)(HDC a0,
                                            int a1,
                                            int a2,
                                            POINT* a3)
    = OffsetViewportOrgEx;

BOOL (__stdcall * Real_OffsetWindowOrgEx)(HDC a0,
                                          int a1,
                                          int a2,
                                          POINT* a3)
    = OffsetWindowOrgEx;

DWORD (__stdcall * Real_OleBuildVersion)(void)
    = OleBuildVersion;

HRESULT (__stdcall * Real_OleConvertIStorageToOLESTREAM)(IStorage* a0,
                                                         LPOLESTREAM a1)
    = OleConvertIStorageToOLESTREAM;

HRESULT (__stdcall * Real_OleConvertIStorageToOLESTREAMEx)(IStorage* a0,
                                                           CLIPFORMAT a1,
                                                           LONG a2,
                                                           LONG a3,
                                                           DWORD a4,
                                                           LPSTGMEDIUM a5,
                                                           LPOLESTREAM a6)
    = OleConvertIStorageToOLESTREAMEx;

HRESULT (__stdcall * Real_OleConvertOLESTREAMToIStorage)(LPOLESTREAM a0,
                                                         LPSTORAGE a1,
                                                         CONST DVTARGETDEVICE* a2)
    = OleConvertOLESTREAMToIStorage;

HRESULT (__stdcall * Real_OleConvertOLESTREAMToIStorageEx)(LPOLESTREAM a0,
                                                           LPSTORAGE a1,
                                                           CLIPFORMAT* a2,
                                                           LONG* a3,
                                                           LONG* a4,
                                                           DWORD* a5,
                                                           LPSTGMEDIUM a6)
    = OleConvertOLESTREAMToIStorageEx;

HRESULT (__stdcall * Real_OleCreate)(CONST IID& a0,
                                     CONST IID& a1,
                                     DWORD a2,
                                     LPFORMATETC a3,
                                     LPOLECLIENTSITE a4,
                                     LPSTORAGE a5,
                                     LPVOID* a6)
    = OleCreate;

HRESULT (__stdcall * Real_OleCreateDefaultHandler)(CONST IID& a0,
                                                   LPUNKNOWN a1,
                                                   CONST IID& a2,
                                                   LPVOID* a3)
    = OleCreateDefaultHandler;

HRESULT (__stdcall * Real_OleCreateEmbeddingHelper)(CONST IID& a0,
                                                    LPUNKNOWN a1,
                                                    DWORD a2,
                                                    LPCLASSFACTORY a3,
                                                    CONST IID& a4,
                                                    LPVOID* a5)
    = OleCreateEmbeddingHelper;

HRESULT (__stdcall * Real_OleCreateEx)(CONST IID& a0,
                                       CONST IID& a1,
                                       DWORD a2,
                                       DWORD a3,
                                       ULONG a4,
                                       DWORD* a5,
                                       LPFORMATETC a6,
                                       IAdviseSink* a7,
                                       DWORD* a8,
                                       LPOLECLIENTSITE a9,
                                       LPSTORAGE a10,
                                       LPVOID* a11)
    = OleCreateEx;

HRESULT (__stdcall * Real_OleCreateFromData)(IDataObject* a0,
                                             CONST IID& a1,
                                             DWORD a2,
                                             LPFORMATETC a3,
                                             LPOLECLIENTSITE a4,
                                             LPSTORAGE a5,
                                             LPVOID* a6)
    = OleCreateFromData;

HRESULT (__stdcall * Real_OleCreateFromDataEx)(IDataObject* a0,
                                               CONST IID& a1,
                                               DWORD a2,
                                               DWORD a3,
                                               ULONG a4,
                                               DWORD* a5,
                                               LPFORMATETC a6,
                                               IAdviseSink* a7,
                                               DWORD* a8,
                                               LPOLECLIENTSITE a9,
                                               LPSTORAGE a10,
                                               LPVOID* a11)
    = OleCreateFromDataEx;

HRESULT (__stdcall * Real_OleCreateFromFile)(CONST IID& a0,
                                             LPCOLESTR a1,
                                             CONST IID& a2,
                                             DWORD a3,
                                             LPFORMATETC a4,
                                             LPOLECLIENTSITE a5,
                                             LPSTORAGE a6,
                                             LPVOID* a7)
    = OleCreateFromFile;

HRESULT (__stdcall * Real_OleCreateFromFileEx)(CONST IID& a0,
                                               LPCOLESTR a1,
                                               CONST IID& a2,
                                               DWORD a3,
                                               DWORD a4,
                                               ULONG a5,
                                               DWORD* a6,
                                               LPFORMATETC a7,
                                               IAdviseSink* a8,
                                               DWORD* a9,
                                               LPOLECLIENTSITE a10,
                                               LPSTORAGE a11,
                                               LPVOID* a12)
    = OleCreateFromFileEx;

HRESULT (__stdcall * Real_OleCreateLink)(IMoniker* a0,
                                         CONST IID& a1,
                                         DWORD a2,
                                         LPFORMATETC a3,
                                         LPOLECLIENTSITE a4,
                                         LPSTORAGE a5,
                                         LPVOID* a6)
    = OleCreateLink;

HRESULT (__stdcall * Real_OleCreateLinkEx)(IMoniker* a0,
                                           CONST IID& a1,
                                           DWORD a2,
                                           DWORD a3,
                                           ULONG a4,
                                           DWORD* a5,
                                           LPFORMATETC a6,
                                           IAdviseSink* a7,
                                           DWORD* a8,
                                           LPOLECLIENTSITE a9,
                                           LPSTORAGE a10,
                                           LPVOID* a11)
    = OleCreateLinkEx;

HRESULT (__stdcall * Real_OleCreateLinkFromData)(IDataObject* a0,
                                                 CONST IID& a1,
                                                 DWORD a2,
                                                 LPFORMATETC a3,
                                                 LPOLECLIENTSITE a4,
                                                 LPSTORAGE a5,
                                                 LPVOID* a6)
    = OleCreateLinkFromData;

HRESULT (__stdcall * Real_OleCreateLinkFromDataEx)(IDataObject* a0,
                                                   CONST IID& a1,
                                                   DWORD a2,
                                                   DWORD a3,
                                                   ULONG a4,
                                                   DWORD* a5,
                                                   LPFORMATETC a6,
                                                   IAdviseSink* a7,
                                                   DWORD* a8,
                                                   LPOLECLIENTSITE a9,
                                                   LPSTORAGE a10,
                                                   LPVOID* a11)
    = OleCreateLinkFromDataEx;

HRESULT (__stdcall * Real_OleCreateLinkToFile)(LPCOLESTR a0,
                                               CONST IID& a1,
                                               DWORD a2,
                                               LPFORMATETC a3,
                                               LPOLECLIENTSITE a4,
                                               LPSTORAGE a5,
                                               LPVOID* a6)
    = OleCreateLinkToFile;

HRESULT (__stdcall * Real_OleCreateLinkToFileEx)(LPCOLESTR a0,
                                                 CONST IID& a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 ULONG a4,
                                                 DWORD* a5,
                                                 LPFORMATETC a6,
                                                 IAdviseSink* a7,
                                                 DWORD* a8,
                                                 LPOLECLIENTSITE a9,
                                                 LPSTORAGE a10,
                                                 LPVOID* a11)
    = OleCreateLinkToFileEx;

HOLEMENU (__stdcall * Real_OleCreateMenuDescriptor)(HMENU a0,
                                                    LPOLEMENUGROUPWIDTHS a1)
    = OleCreateMenuDescriptor;

HRESULT (__stdcall * Real_OleCreateStaticFromData)(IDataObject* a0,
                                                   CONST IID& a1,
                                                   DWORD a2,
                                                   LPFORMATETC a3,
                                                   LPOLECLIENTSITE a4,
                                                   LPSTORAGE a5,
                                                   LPVOID* a6)
    = OleCreateStaticFromData;

HRESULT (__stdcall * Real_OleDestroyMenuDescriptor)(HOLEMENU a0)
    = OleDestroyMenuDescriptor;

HRESULT (__stdcall * Real_OleDoAutoConvert)(LPSTORAGE a0,
                                            LPGUID a1)
    = OleDoAutoConvert;

HRESULT (__stdcall * Real_OleDraw)(LPUNKNOWN a0,
                                   DWORD a1,
                                   HDC a2,
                                   LPCRECT a3)
    = OleDraw;

HANDLE (__stdcall * Real_OleDuplicateData)(HANDLE a0,
                                           CLIPFORMAT a1,
                                           UINT a2)
    = OleDuplicateData;

HRESULT (__stdcall * Real_OleFlushClipboard)(void)
    = OleFlushClipboard;

HRESULT (__stdcall * Real_OleGetAutoConvert)(CONST IID& a0,
                                             LPGUID a1)
    = OleGetAutoConvert;

HRESULT (__stdcall * Real_OleGetClipboard)(IDataObject** a0)
    = OleGetClipboard;

HGLOBAL (__stdcall * Real_OleGetIconOfClass)(CONST IID& a0,
                                             LPOLESTR a1,
                                             BOOL a2)
    = OleGetIconOfClass;

HGLOBAL (__stdcall * Real_OleGetIconOfFile)(LPOLESTR a0,
                                            BOOL a1)
    = OleGetIconOfFile;

HRESULT (__stdcall * Real_OleInitialize)(LPVOID a0)
    = OleInitialize;

HRESULT (__stdcall * Real_OleIsCurrentClipboard)(IDataObject* a0)
    = OleIsCurrentClipboard;

BOOL (__stdcall * Real_OleIsRunning)(IOleObject* a0)
    = OleIsRunning;

HRESULT (__stdcall * Real_OleLoad)(LPSTORAGE a0,
                                   CONST IID& a1,
                                   LPOLECLIENTSITE a2,
                                   LPVOID* a3)
    = OleLoad;

HRESULT (__stdcall * Real_OleLoadFromStream)(LPSTREAM a0,
                                             CONST IID& a1,
                                             LPVOID* a2)
    = OleLoadFromStream;

HRESULT (__stdcall * Real_OleLockRunning)(LPUNKNOWN a0,
                                          BOOL a1,
                                          BOOL a2)
    = OleLockRunning;

HGLOBAL (__stdcall * Real_OleMetafilePictFromIconAndLabel)(HICON a0,
                                                           LPOLESTR a1,
                                                           LPOLESTR a2,
                                                           UINT a3)
    = OleMetafilePictFromIconAndLabel;

HRESULT (__stdcall * Real_OleNoteObjectVisible)(LPUNKNOWN a0,
                                                BOOL a1)
    = OleNoteObjectVisible;

HRESULT (__stdcall * Real_OleQueryCreateFromData)(IDataObject* a0)
    = OleQueryCreateFromData;

HRESULT (__stdcall * Real_OleQueryLinkFromData)(IDataObject* a0)
    = OleQueryLinkFromData;

HRESULT (__stdcall * Real_OleRegEnumFormatEtc)(CONST IID& a0,
                                               DWORD a1,
                                               IEnumFORMATETC** a2)
    = OleRegEnumFormatEtc;

HRESULT (__stdcall * Real_OleRegEnumVerbs)(CONST IID& a0,
                                           IEnumOLEVERB** a1)
    = OleRegEnumVerbs;

HRESULT (__stdcall * Real_OleRegGetMiscStatus)(CONST IID& a0,
                                               DWORD a1,
                                               DWORD* a2)
    = OleRegGetMiscStatus;

HRESULT (__stdcall * Real_OleRegGetUserType)(CONST IID& a0,
                                             DWORD a1,
                                             LPOLESTR* a2)
    = OleRegGetUserType;

HRESULT (__stdcall * Real_OleRun)(LPUNKNOWN a0)
    = OleRun;

HRESULT (__stdcall * Real_OleSave)(LPPERSISTSTORAGE a0,
                                   LPSTORAGE a1,
                                   BOOL a2)
    = OleSave;

HRESULT (__stdcall * Real_OleSaveToStream)(IPersistStream* a0,
                                           LPSTREAM a1)
    = OleSaveToStream;

HRESULT (__stdcall * Real_OleSetAutoConvert)(CONST IID& a0,
                                             CONST IID& a1)
    = OleSetAutoConvert;

HRESULT (__stdcall * Real_OleSetClipboard)(IDataObject* a0)
    = OleSetClipboard;

HRESULT (__stdcall * Real_OleSetContainedObject)(LPUNKNOWN a0,
                                                 BOOL a1)
    = OleSetContainedObject;

HRESULT (__stdcall * Real_OleSetMenuDescriptor)(HOLEMENU a0,
                                                HWND a1,
                                                HWND a2,
                                                LPOLEINPLACEFRAME a3,
                                                LPOLEINPLACEACTIVEOBJECT a4)
    = OleSetMenuDescriptor;

HRESULT (__stdcall * Real_OleTranslateAccelerator)(LPOLEINPLACEFRAME a0,
                                                   LPOLEINPLACEFRAMEINFO a1,
                                                   LPMSG a2)
    = OleTranslateAccelerator;

void (__stdcall * Real_OleUninitialize)(void)
    = OleUninitialize;

BOOL (__stdcall * Real_OpenClipboard)(HWND a0)
    = OpenClipboard;

#if _MSC_VER < 1300
HDESK (__stdcall * Real_OpenDesktopA)(LPSTR a0,
                                      DWORD a1,
                                      BOOL a2,
                                      ACCESS_MASK a3)
    = OpenDesktopA;
#else
HDESK (__stdcall * Real_OpenDesktopA)(LPCSTR a0,
                                      DWORD a1,
                                      BOOL a2,
                                      ACCESS_MASK a3)
    = OpenDesktopA;
#endif

#if _MSC_VER < 1300
HDESK (__stdcall * Real_OpenDesktopW)(LPWSTR a0,
                                      DWORD a1,
                                      BOOL a2,
                                      ACCESS_MASK a3)
    = OpenDesktopW;
#else
HDESK (__stdcall * Real_OpenDesktopW)(LPCWSTR a0,
                                      DWORD a1,
                                      BOOL a2,
                                      ACCESS_MASK a3)
    = OpenDesktopW;
#endif

HANDLE (__stdcall * Real_OpenEventA)(DWORD a0,
                                     BOOL a1,
                                     LPCSTR a2)
    = OpenEventA;

HANDLE (__stdcall * Real_OpenEventW)(DWORD a0,
                                     BOOL a1,
                                     LPCWSTR a2)
    = OpenEventW;

HFILE (__stdcall * Real_OpenFile)(LPCSTR a0,
                                  LPOFSTRUCT a1,
                                  UINT a2)
    = OpenFile;

HANDLE (__stdcall * Real_OpenFileMappingA)(DWORD a0,
                                           BOOL a1,
                                           LPCSTR a2)
    = OpenFileMappingA;

HANDLE (__stdcall * Real_OpenFileMappingW)(DWORD a0,
                                           BOOL a1,
                                           LPCWSTR a2)
    = OpenFileMappingW;

BOOL (__stdcall * Real_OpenIcon)(HWND a0)
    = OpenIcon;

HDESK (__stdcall * Real_OpenInputDesktop)(DWORD a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
    = OpenInputDesktop;

HANDLE (__stdcall * Real_OpenMutexA)(DWORD a0,
                                     BOOL a1,
                                     LPCSTR a2)
    = OpenMutexA;

HANDLE (__stdcall * Real_OpenMutexW)(DWORD a0,
                                     BOOL a1,
                                     LPCWSTR a2)
    = OpenMutexW;

HANDLE (__stdcall * Real_OpenProcess)(DWORD a0,
                                      BOOL a1,
                                      DWORD pid)
    = OpenProcess;

BOOL (__stdcall * Real_OpenProcessToken)(__in   HANDLE ProcessHandle,
                                         __in   DWORD DesiredAccess,
                                         __out  PHANDLE TokenHandle
                                        )
    = OpenProcessToken;

HANDLE (__stdcall * Real_OpenSemaphoreA)(DWORD a0,
                                         BOOL a1,
                                         LPCSTR a2)
    = OpenSemaphoreA;

HANDLE (__stdcall * Real_OpenSemaphoreW)(DWORD a0,
                                         BOOL a1,
                                         LPCWSTR a2)
    = OpenSemaphoreW;

HANDLE (__stdcall * Real_OpenWaitableTimerA)(DWORD a0,
                                             BOOL a1,
                                             LPCSTR a2)
    = OpenWaitableTimerA;

HANDLE (__stdcall * Real_OpenWaitableTimerW)(DWORD a0,
                                             BOOL a1,
                                             LPCWSTR a2)
    = OpenWaitableTimerW;

#if _MSC_VER < 1300
HWINSTA (__stdcall * Real_OpenWindowStationA)(LPSTR a0,
                                              BOOL a1,
                                              ACCESS_MASK a2)
    = OpenWindowStationA;
#else
HWINSTA (__stdcall * Real_OpenWindowStationA)(LPCSTR a0,
                                              BOOL a1,
                                              ACCESS_MASK a2)
    = OpenWindowStationA;
#endif

#if _MSC_VER < 1300
HWINSTA (__stdcall * Real_OpenWindowStationW)(LPWSTR a0,
                                              BOOL a1,
                                              ACCESS_MASK a2)
    = OpenWindowStationW;
#else
HWINSTA (__stdcall * Real_OpenWindowStationW)(LPCWSTR a0,
                                              BOOL a1,
                                              ACCESS_MASK a2)
    = OpenWindowStationW;
#endif

void (__stdcall * Real_OutputDebugStringA)(LPCSTR a0)
    = OutputDebugStringA;

void (__stdcall * Real_OutputDebugStringW)(LPCWSTR a0)
    = OutputDebugStringW;

LPARAM (__stdcall * Real_PackDDElParam)(UINT a0,
                                        UINT_PTR a1,
                                        UINT_PTR a2)
    = PackDDElParam;

BOOL (__stdcall * Real_PaintDesktop)(HDC a0)
    = PaintDesktop;

BOOL (__stdcall * Real_PaintRgn)(HDC a0,
                                 HRGN a1)
    = PaintRgn;

BOOL (__stdcall * Real_PatBlt)(HDC a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               DWORD a5)
    = PatBlt;

HRGN (__stdcall * Real_PathToRegion)(HDC a0)
    = PathToRegion;

BOOL (__stdcall * Real_PeekConsoleInputA)(HANDLE a0,
                                          PINPUT_RECORD a1,
                                          DWORD a2,
                                          LPDWORD a3)
    = PeekConsoleInputA;

BOOL (__stdcall * Real_PeekConsoleInputW)(HANDLE a0,
                                          PINPUT_RECORD a1,
                                          DWORD a2,
                                          LPDWORD a3)
    = PeekConsoleInputW;

BOOL (__stdcall * Real_PeekMessageA)(LPMSG a0,
                                     HWND a1,
                                     UINT a2,
                                     UINT a3,
                                     UINT a4)
    = PeekMessageA;

BOOL (__stdcall * Real_PeekMessageW)(LPMSG a0,
                                     HWND a1,
                                     UINT a2,
                                     UINT a3,
                                     UINT a4)
    = PeekMessageW;

BOOL (__stdcall * Real_PeekNamedPipe)(HANDLE a0,
                                      LPVOID a1,
                                      DWORD a2,
                                      LPDWORD a3,
                                      LPDWORD a4,
                                      LPDWORD a5)
    = PeekNamedPipe;

BOOL (__stdcall * Real_Pie)(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4,
                            int a5,
                            int a6,
                            int a7,
                            int a8)
    = Pie;

BOOL (__stdcall * Real_PlayEnhMetaFile)(HDC a0,
                                        HENHMETAFILE a1,
                                        CONST RECT* a2)
    = PlayEnhMetaFile;

BOOL (__stdcall * Real_PlayEnhMetaFileRecord)(HDC a0,
                                              LPHANDLETABLE a1,
                                              CONST ENHMETARECORD* a2,
                                              UINT a3)
    = PlayEnhMetaFileRecord;

BOOL (__stdcall * Real_PlayMetaFile)(HDC a0,
                                     HMETAFILE a1)
    = PlayMetaFile;

BOOL (__stdcall * Real_PlayMetaFileRecord)(HDC a0,
                                           LPHANDLETABLE a1,
                                           LPMETARECORD a2,
                                           UINT a3)
    = PlayMetaFileRecord;

BOOL (__stdcall * Real_PlgBlt)(HDC a0,
                               CONST POINT* a1,
                               HDC a2,
                               int a3,
                               int a4,
                               int a5,
                               int a6,
                               HBITMAP a7,
                               int a8,
                               int a9)
    = PlgBlt;

BOOL (__stdcall * Real_PolyBezier)(HDC a0,
                                   CONST POINT* a1,
                                   DWORD a2)
    = PolyBezier;

BOOL (__stdcall * Real_PolyBezierTo)(HDC a0,
                                     CONST POINT* a1,
                                     DWORD a2)
    = PolyBezierTo;

BOOL (__stdcall * Real_PolyDraw)(HDC a0,
                                 CONST POINT* a1,
                                 CONST BYTE* a2,
                                 int a3)
    = PolyDraw;

BOOL (__stdcall * Real_PolyPolygon)(HDC a0,
                                    CONST POINT* a1,
                                    CONST INT* a2,
                                    int a3)
    = PolyPolygon;

BOOL (__stdcall * Real_PolyPolyline)(HDC a0,
                                     CONST POINT* a1,
                                     CONST DWORD* a2,
                                     DWORD a3)
    = PolyPolyline;

BOOL (__stdcall * Real_PolyTextOutA)(HDC a0,
                                     CONST POLYTEXTA* a1,
                                     int a2)
    = PolyTextOutA;

BOOL (__stdcall * Real_PolyTextOutW)(HDC a0,
                                     CONST POLYTEXTW* a1,
                                     int a2)
    = PolyTextOutW;

BOOL (__stdcall * Real_Polygon)(HDC a0,
                                CONST POINT* a1,
                                int a2)
    = Polygon;

BOOL (__stdcall * Real_Polyline)(HDC a0,
                                 CONST POINT* a1,
                                 int a2)
    = Polyline;

BOOL (__stdcall * Real_PolylineTo)(HDC a0,
                                   CONST POINT* a1,
                                   DWORD a2)
    = PolylineTo;

BOOL (__stdcall * Real_PostMessageA)(HWND a0,
                                     UINT a1,
                                     WPARAM a2,
                                     LPARAM a3)
    = PostMessageA;

BOOL (__stdcall * Real_PostMessageW)(HWND a0,
                                     UINT a1,
                                     WPARAM a2,
                                     LPARAM a3)
    = PostMessageW;

BOOL (__stdcall * Real_PostQueuedCompletionStatus)(HANDLE a0,
                                                   DWORD a1,
                                                   ULONG_PTR a2,
                                                   LPOVERLAPPED a3)
    = PostQueuedCompletionStatus;

void (__stdcall * Real_PostQuitMessage)(int a0)
    = PostQuitMessage;

BOOL (__stdcall * Real_PostThreadMessageA)(DWORD a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3)
    = PostThreadMessageA;

BOOL (__stdcall * Real_PostThreadMessageW)(DWORD a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3)
    = PostThreadMessageW;

DWORD (__stdcall * Real_PrepareTape)(HANDLE a0,
                                     DWORD a1,
                                     BOOL a2)
    = PrepareTape;

HRESULT (__stdcall * Real_ProgIDFromCLSID)(CONST IID& a0,
                                           LPOLESTR* a1)
    = ProgIDFromCLSID;

HRESULT (__stdcall * Real_PropVariantClear)(PROPVARIANT* a0)
    = PropVariantClear;

HRESULT (__stdcall * Real_PropVariantCopy)(PROPVARIANT* a0,
                                           CONST PROPVARIANT* a1)
    = PropVariantCopy;

BOOL (__stdcall * Real_PtInRect)(CONST RECT* a0,
                                 POINT a1)
    = PtInRect;

BOOL (__stdcall * Real_PtInRegion)(HRGN a0,
                                   int a1,
                                   int a2)
    = PtInRegion;

BOOL (__stdcall * Real_PtVisible)(HDC a0,
                                  int a1,
                                  int a2)
    = PtVisible;

BOOL (__stdcall * Real_PulseEvent)(HANDLE a0)
    = PulseEvent;

BOOL (__stdcall * Real_PurgeComm)(HANDLE a0,
                                  DWORD a1)
    = PurgeComm;

DWORD (__stdcall * Real_QueryDosDeviceA)(LPCSTR a0,
                                         LPSTR a1,
                                         DWORD a2)
    = QueryDosDeviceA;

DWORD (__stdcall * Real_QueryDosDeviceW)(LPCWSTR a0,
                                         LPWSTR a1,
                                         DWORD a2)
    = QueryDosDeviceW;

BOOL (__stdcall * Real_QueryPerformanceCounter)(LARGE_INTEGER* a0)
    = QueryPerformanceCounter;

BOOL (__stdcall * Real_QueryPerformanceFrequency)(LARGE_INTEGER* a0)
    = QueryPerformanceFrequency;

DWORD (__stdcall * Real_QueueUserAPC)(PAPCFUNC a0,
                                      HANDLE a1,
                                      ULONG_PTR a2)
    = QueueUserAPC;

void (__stdcall * Real_RaiseException)(DWORD a0,
                                       DWORD a1,
                                       DWORD a2,
                                       CONST ULONG_PTR* a3)
    = RaiseException;

HRESULT (__stdcall * Real_ReadClassStg)(LPSTORAGE a0,
                                        CLSID* a1)
    = ReadClassStg;

HRESULT (__stdcall * Real_ReadClassStm)(LPSTREAM a0,
                                        CLSID* a1)
    = ReadClassStm;

BOOL (__stdcall * Real_ReadConsoleA)(
                                     HANDLE a0,
                                     LPVOID a1,
                                     DWORD a2,
                                     LPDWORD a3,
#ifdef ENABLE_INSERT_MODE
                                     PCONSOLE_READCONSOLE_CONTROL a4
#else
                                     LPVOID a4
#endif
                                    )
    = ReadConsoleA;

BOOL (__stdcall * Real_ReadConsoleInputA)(HANDLE a0,
                                          PINPUT_RECORD a1,
                                          DWORD a2,
                                          LPDWORD a3)
    = ReadConsoleInputA;

BOOL (__stdcall * Real_ReadConsoleInputW)(HANDLE a0,
                                          PINPUT_RECORD a1,
                                          DWORD a2,
                                          LPDWORD a3)
    = ReadConsoleInputW;

BOOL (__stdcall * Real_ReadConsoleOutputA)(HANDLE a0,
                                           PCHAR_INFO a1,
                                           COORD a2,
                                           COORD a3,
                                           PSMALL_RECT a4)
    = ReadConsoleOutputA;

BOOL (__stdcall * Real_ReadConsoleOutputAttribute)(HANDLE a0,
                                                   LPWORD a1,
                                                   DWORD a2,
                                                   COORD a3,
                                                   LPDWORD a4)
    = ReadConsoleOutputAttribute;

BOOL (__stdcall * Real_ReadConsoleOutputCharacterA)(HANDLE a0,
                                                    LPSTR a1,
                                                    DWORD a2,
                                                    COORD a3,
                                                    LPDWORD a4)
    = ReadConsoleOutputCharacterA;

BOOL (__stdcall * Real_ReadConsoleOutputCharacterW)(HANDLE a0,
                                                    LPWSTR a1,
                                                    DWORD a2,
                                                    COORD a3,
                                                    LPDWORD a4)
    = ReadConsoleOutputCharacterW;

BOOL (__stdcall * Real_ReadConsoleOutputW)(HANDLE a0,
                                           PCHAR_INFO a1,
                                           COORD a2,
                                           COORD a3,
                                           PSMALL_RECT a4)
    = ReadConsoleOutputW;

BOOL (__stdcall * Real_ReadConsoleW)(
                                     HANDLE a0,
                                     LPVOID a1,
                                     DWORD a2,
                                     LPDWORD a3,
#ifdef ENABLE_INSERT_MODE
                                     PCONSOLE_READCONSOLE_CONTROL a4
#else
                                     LPVOID a4
#endif
                                    )
    = ReadConsoleW;

BOOL (__stdcall * Real_ReadDirectoryChangesW)(HANDLE a0,
                                              LPVOID a1,
                                              DWORD a2,
                                              BOOL a3,
                                              DWORD a4,
                                              LPDWORD a5,
                                              LPOVERLAPPED a6,
                                              LPOVERLAPPED_COMPLETION_ROUTINE a7)
    = ReadDirectoryChangesW;

BOOL (__stdcall * Real_ReadFile)(HANDLE a0,
                                 LPVOID a1,
                                 DWORD a2,
                                 LPDWORD a3,
                                 LPOVERLAPPED a4)
    = ReadFile;

BOOL (__stdcall * Real_ReadFileEx)(HANDLE a0,
                                   LPVOID a1,
                                   DWORD a2,
                                   LPOVERLAPPED a3,
                                   LPOVERLAPPED_COMPLETION_ROUTINE a4)
    = ReadFileEx;

HRESULT (__stdcall * Real_ReadFmtUserTypeStg)(LPSTORAGE a0,
                                              CLIPFORMAT* a1,
                                              LPOLESTR* a2)
    = ReadFmtUserTypeStg;

BOOL (__stdcall * Real_ReadProcessMemory)(HANDLE a0,
                                          LPCVOID a1,
                                          LPVOID a2,
                                          DWORD_PTR a3,
                                          PDWORD_PTR a4)
    = ReadProcessMemory;

UINT (__stdcall * Real_RealizePalette)(HDC a0)
    = RealizePalette;

BOOL (__stdcall * Real_RectInRegion)(HRGN a0,
                                     CONST RECT* a1)
    = RectInRegion;

BOOL (__stdcall * Real_RectVisible)(HDC a0,
                                    CONST RECT* a1)
    = RectVisible;

BOOL (__stdcall * Real_Rectangle)(HDC a0,
                                  int a1,
                                  int a2,
                                  int a3,
                                  int a4)
    = Rectangle;

BOOL (__stdcall * Real_RedrawWindow)(HWND a0,
                                     CONST RECT* a1,
                                     HRGN a2,
                                     UINT a3)
    = RedrawWindow;

ATOM (__stdcall * Real_RegisterClassA)(CONST WNDCLASSA* a0)
    = RegisterClassA;

ATOM (__stdcall * Real_RegisterClassExA)(CONST WNDCLASSEXA* a0)
    = RegisterClassExA;

ATOM (__stdcall * Real_RegisterClassExW)(CONST WNDCLASSEXW* a0)
    = RegisterClassExW;

ATOM (__stdcall * Real_RegisterClassW)(CONST WNDCLASSW* a0)
    = RegisterClassW;

UINT (__stdcall * Real_RegisterClipboardFormatA)(LPCSTR a0)
    = RegisterClipboardFormatA;

UINT (__stdcall * Real_RegisterClipboardFormatW)(LPCWSTR a0)
    = RegisterClipboardFormatW;

HRESULT (__stdcall * Real_RegisterDragDrop)(HWND a0,
                                            IDropTarget* a1)
    = RegisterDragDrop;

BOOL (__stdcall * Real_RegisterHotKey)(HWND a0,
                                       int a1,
                                       UINT a2,
                                       UINT a3)
    = RegisterHotKey;

UINT (__stdcall * Real_RegisterWindowMessageA)(LPCSTR a0)
    = RegisterWindowMessageA;

UINT (__stdcall * Real_RegisterWindowMessageW)(LPCWSTR a0)
    = RegisterWindowMessageW;

BOOL (__stdcall * Real_ReleaseCapture)(void)
    = ReleaseCapture;

int (__stdcall * Real_ReleaseDC)(HWND a0,
                                 HDC a1)
    = ReleaseDC;

BOOL (__stdcall * Real_ReleaseMutex)(HANDLE a0)
    = ReleaseMutex;

BOOL (__stdcall * Real_ReleaseSemaphore)(HANDLE a0,
                                         LONG a1,
                                         LPLONG a2)
    = ReleaseSemaphore;

void (__stdcall * Real_ReleaseStgMedium)(LPSTGMEDIUM a0)
    = ReleaseStgMedium;

BOOL (__stdcall * Real_RemoveDirectoryA)(LPCSTR a0)
    = RemoveDirectoryA;

BOOL (__stdcall * Real_RemoveDirectoryW)(LPCWSTR a0)
    = RemoveDirectoryW;

BOOL (__stdcall * Real_RemoveFontResourceA)(LPCSTR a0)
    = RemoveFontResourceA;

BOOL (__stdcall * Real_RemoveFontResourceW)(LPCWSTR a0)
    = RemoveFontResourceW;

BOOL (__stdcall * Real_RemoveMenu)(HMENU a0,
                                   UINT a1,
                                   UINT a2)
    = RemoveMenu;

HANDLE (__stdcall * Real_RemovePropA)(HWND a0,
                                      LPCSTR a1)
    = RemovePropA;

HANDLE (__stdcall * Real_RemovePropW)(HWND a0,
                                      LPCWSTR a1)
    = RemovePropW;

BOOL (__stdcall * Real_ReplyMessage)(LRESULT a0)
    = ReplyMessage;

HDC (__stdcall * Real_ResetDCA)(HDC a0,
                                CONST DEVMODEA* a1)
    = ResetDCA;

HDC (__stdcall * Real_ResetDCW)(HDC a0,
                                CONST DEVMODEW* a1)
    = ResetDCW;

BOOL (__stdcall * Real_ResetEvent)(HANDLE a0)
    = ResetEvent;

BOOL (__stdcall * Real_ResizePalette)(HPALETTE a0,
                                      UINT a1)
    = ResizePalette;

BOOL (__stdcall * Real_RestoreDC)(HDC a0,
                                  int a1)
    = RestoreDC;

DWORD (__stdcall * Real_ResumeThread)(HANDLE a0)
    = ResumeThread;

LPARAM (__stdcall * Real_ReuseDDElParam)(LPARAM a0,
                                         UINT a1,
                                         UINT a2,
                                         UINT_PTR a3,
                                         UINT_PTR a4)
    = ReuseDDElParam;

HRESULT (__stdcall * Real_RevokeDragDrop)(HWND a0)
    = RevokeDragDrop;

BOOL (__stdcall * Real_RoundRect)(HDC a0,
                                  int a1,
                                  int a2,
                                  int a3,
                                  int a4,
                                  int a5,
                                  int a6)
    = RoundRect;

int (__stdcall * Real_SaveDC)(HDC a0)
    = SaveDC;

BOOL (__stdcall * Real_ScaleViewportExtEx)(HDC a0,
                                           int a1,
                                           int a2,
                                           int a3,
                                           int a4,
                                           SIZE* a5)
    = ScaleViewportExtEx;

BOOL (__stdcall * Real_ScaleWindowExtEx)(HDC a0,
                                         int a1,
                                         int a2,
                                         int a3,
                                         int a4,
                                         SIZE* a5)
    = ScaleWindowExtEx;

BOOL (__stdcall * Real_ScreenToClient)(HWND a0,
                                       POINT* a1)
    = ScreenToClient;

BOOL (__stdcall * Real_ScrollConsoleScreenBufferA)(HANDLE a0,
                                                   CONST SMALL_RECT* a1,
                                                   CONST SMALL_RECT* a2,
                                                   COORD a3,
                                                   CONST CHAR_INFO* a4)
    = ScrollConsoleScreenBufferA;

BOOL (__stdcall * Real_ScrollConsoleScreenBufferW)(HANDLE a0,
                                                   CONST SMALL_RECT* a1,
                                                   CONST SMALL_RECT* a2,
                                                   COORD a3,
                                                   CONST CHAR_INFO* a4)
    = ScrollConsoleScreenBufferW;

BOOL (__stdcall * Real_ScrollDC)(HDC a0,
                                 int a1,
                                 int a2,
                                 CONST RECT* a3,
                                 CONST RECT* a4,
                                 HRGN a5,
                                 LPRECT a6)
    = ScrollDC;

BOOL (__stdcall * Real_ScrollWindow)(HWND a0,
                                     int a1,
                                     int a2,
                                     CONST RECT* a3,
                                     CONST RECT* a4)
    = ScrollWindow;

int (__stdcall * Real_ScrollWindowEx)(HWND a0,
                                      int a1,
                                      int a2,
                                      CONST RECT* a3,
                                      CONST RECT* a4,
                                      HRGN a5,
                                      LPRECT a6,
                                      UINT a7)
    = ScrollWindowEx;

DWORD (__stdcall * Real_SearchPathA)(LPCSTR a0,
                                     LPCSTR a1,
                                     LPCSTR a2,
                                     DWORD a3,
                                     LPSTR a4,
                                     LPSTR* a5)
    = SearchPathA;

DWORD (__stdcall * Real_SearchPathW)(LPCWSTR a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2,
                                     DWORD a3,
                                     LPWSTR a4,
                                     LPWSTR* a5)
    = SearchPathW;

BOOL (__stdcall * Real_SelectClipPath)(HDC a0,
                                       int a1)
    = SelectClipPath;

int (__stdcall * Real_SelectClipRgn)(HDC a0,
                                     HRGN a1)
    = SelectClipRgn;

HGDIOBJ (__stdcall * Real_SelectObject)(HDC a0,
                                        HGDIOBJ a1)
    = SelectObject;

HPALETTE (__stdcall * Real_SelectPalette)(HDC a0,
                                          HPALETTE a1,
                                          BOOL a2)
    = SelectPalette;

LRESULT (__stdcall * Real_SendDlgItemMessageA)(HWND a0,
                                               int a1,
                                               UINT a2,
                                               WPARAM a3,
                                               LPARAM a4)
    = SendDlgItemMessageA;

LRESULT (__stdcall * Real_SendDlgItemMessageW)(HWND a0,
                                               int a1,
                                               UINT a2,
                                               WPARAM a3,
                                               LPARAM a4)
    = SendDlgItemMessageW;

LRESULT (__stdcall * Real_SendMessageA)(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
    = SendMessageA;

BOOL (__stdcall * Real_SendMessageCallbackA)(HWND a0,
                                             UINT a1,
                                             WPARAM a2,
                                             LPARAM a3,
                                             SENDASYNCPROC a4,
                                             ULONG_PTR a5)
    = SendMessageCallbackA;

BOOL (__stdcall * Real_SendMessageCallbackW)(HWND a0,
                                             UINT a1,
                                             WPARAM a2,
                                             LPARAM a3,
                                             SENDASYNCPROC a4,
                                             ULONG_PTR a5)
    = SendMessageCallbackW;

LRESULT (__stdcall * Real_SendMessageTimeoutA)(HWND a0,
                                               UINT a1,
                                               WPARAM a2,
                                               LPARAM a3,
                                               UINT a4,
                                               UINT a5,
                                               PULONG_PTR a6)
    = SendMessageTimeoutA;

LRESULT (__stdcall * Real_SendMessageTimeoutW)(HWND a0,
                                               UINT a1,
                                               WPARAM a2,
                                               LPARAM a3,
                                               UINT a4,
                                               UINT a5,
                                               PULONG_PTR a6)
    = SendMessageTimeoutW;

LRESULT (__stdcall * Real_SendMessageW)(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
    = SendMessageW;

BOOL (__stdcall * Real_SendNotifyMessageA)(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3)
    = SendNotifyMessageA;

BOOL (__stdcall * Real_SendNotifyMessageW)(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3)
    = SendNotifyMessageW;

int (__stdcall * Real_SetAbortProc)(HDC a0,
                                    ABORTPROC a1)
    = SetAbortProc;

HWND (__stdcall * Real_SetActiveWindow)(HWND a0)
    = SetActiveWindow;

int (__stdcall * Real_SetArcDirection)(HDC a0,
                                       int a1)
    = SetArcDirection;

LONG (__stdcall * Real_SetBitmapBits)(HBITMAP a0,
                                      DWORD a1,
                                      CONST void* a2)
    = SetBitmapBits;

BOOL (__stdcall * Real_SetBitmapDimensionEx)(HBITMAP a0,
                                             int a1,
                                             int a2,
                                             SIZE* a3)
    = SetBitmapDimensionEx;

COLORREF (__stdcall * Real_SetBkColor)(HDC a0,
                                       COLORREF a1)
    = SetBkColor;

int (__stdcall * Real_SetBkMode)(HDC a0,
                                 int a1)
    = SetBkMode;

UINT (__stdcall * Real_SetBoundsRect)(HDC a0,
                                      CONST RECT* a1,
                                      UINT a2)
    = SetBoundsRect;

BOOL (__stdcall * Real_SetBrushOrgEx)(HDC a0,
                                      int a1,
                                      int a2,
                                      POINT* a3)
    = SetBrushOrgEx;

HWND (__stdcall * Real_SetCapture)(HWND a0)
    = SetCapture;

BOOL (__stdcall * Real_SetCaretBlinkTime)(UINT a0)
    = SetCaretBlinkTime;

BOOL (__stdcall * Real_SetCaretPos)(int a0,
                                    int a1)
    = SetCaretPos;

DWORD (__stdcall * Real_SetClassLongA)(HWND a0,
                                       int a1,
                                       LONG a2)
    = SetClassLongA;

DWORD (__stdcall * Real_SetClassLongW)(HWND a0,
                                       int a1,
                                       LONG a2)
    = SetClassLongW;

WORD (__stdcall * Real_SetClassWord)(HWND a0,
                                     int a1,
                                     WORD a2)
    = SetClassWord;

HANDLE (__stdcall * Real_SetClipboardData)(UINT a0,
                                           HANDLE a1)
    = SetClipboardData;

HWND (__stdcall * Real_SetClipboardViewer)(HWND a0)
    = SetClipboardViewer;

BOOL (__stdcall * Real_SetColorAdjustment)(HDC a0,
                                           CONST COLORADJUSTMENT* a1)
    = SetColorAdjustment;

HCOLORSPACE (__stdcall * Real_SetColorSpace)(HDC a0,
                                             HCOLORSPACE a1)
    = SetColorSpace;

BOOL (__stdcall * Real_SetCommBreak)(HANDLE a0)
    = SetCommBreak;

BOOL (__stdcall * Real_SetCommConfig)(HANDLE a0,
                                      LPCOMMCONFIG a1,
                                      DWORD a2)
    = SetCommConfig;

BOOL (__stdcall * Real_SetCommMask)(HANDLE a0,
                                    DWORD a1)
    = SetCommMask;

BOOL (__stdcall * Real_SetCommState)(HANDLE a0,
                                     LPDCB a1)
    = SetCommState;

BOOL (__stdcall * Real_SetCommTimeouts)(HANDLE a0,
                                        LPCOMMTIMEOUTS a1)
    = SetCommTimeouts;

BOOL (__stdcall * Real_SetComputerNameA)(LPCSTR a0)
    = SetComputerNameA;

BOOL (__stdcall * Real_SetComputerNameW)(LPCWSTR a0)
    = SetComputerNameW;

BOOL (__stdcall * Real_SetConsoleActiveScreenBuffer)(HANDLE a0)
    = SetConsoleActiveScreenBuffer;

BOOL (__stdcall * Real_SetConsoleCP)(UINT a0)
    = SetConsoleCP;

BOOL (__stdcall * Real_SetConsoleCtrlHandler)(PHANDLER_ROUTINE a0,
                                              BOOL a1)
    = SetConsoleCtrlHandler;

BOOL (__stdcall * Real_SetConsoleCursorInfo)(HANDLE a0,
                                             CONST CONSOLE_CURSOR_INFO* a1)
    = SetConsoleCursorInfo;

BOOL (__stdcall * Real_SetConsoleCursorPosition)(HANDLE a0,
                                                 COORD a1)
    = SetConsoleCursorPosition;

BOOL (__stdcall * Real_SetConsoleMode)(HANDLE a0,
                                       DWORD a1)
    = SetConsoleMode;

BOOL (__stdcall * Real_SetConsoleOutputCP)(UINT a0)
    = SetConsoleOutputCP;

BOOL (__stdcall * Real_SetConsoleScreenBufferSize)(HANDLE a0,
                                                   COORD a1)
    = SetConsoleScreenBufferSize;

BOOL (__stdcall * Real_SetConsoleTextAttribute)(HANDLE a0,
                                                WORD a1)
    = SetConsoleTextAttribute;

BOOL (__stdcall * Real_SetConsoleTitleA)(LPCSTR a0)
    = SetConsoleTitleA;

BOOL (__stdcall * Real_SetConsoleTitleW)(LPCWSTR a0)
    = SetConsoleTitleW;

BOOL (__stdcall * Real_SetConsoleWindowInfo)(HANDLE a0,
                                             BOOL a1,
                                             CONST SMALL_RECT* a2)
    = SetConsoleWindowInfo;

HRESULT (__stdcall * Real_SetConvertStg)(LPSTORAGE a0,
                                         BOOL a1)
    = SetConvertStg;

BOOL (__stdcall * Real_SetCurrentDirectoryA)(LPCSTR a0)
    = SetCurrentDirectoryA;

BOOL (__stdcall * Real_SetCurrentDirectoryW)(LPCWSTR a0)
    = SetCurrentDirectoryW;

HCURSOR (__stdcall * Real_SetCursor)(HCURSOR a0)
    = SetCursor;

BOOL (__stdcall * Real_SetCursorPos)(int a0,
                                     int a1)
    = SetCursorPos;

UINT (__stdcall * Real_SetDIBColorTable)(HDC a0,
                                         UINT a1,
                                         UINT a2,
                                         CONST RGBQUAD* a3)
    = SetDIBColorTable;

int (__stdcall * Real_SetDIBits)(HDC a0,
                                 HBITMAP a1,
                                 UINT a2,
                                 UINT a3,
                                 CONST void* a4,
                                 CONST BITMAPINFO* a5,
                                 UINT a6)
    = SetDIBits;

int (__stdcall * Real_SetDIBitsToDevice)(HDC a0,
                                         int a1,
                                         int a2,
                                         DWORD a3,
                                         DWORD a4,
                                         int a5,
                                         int a6,
                                         UINT a7,
                                         UINT a8,
                                         CONST void* a9,
                                         CONST BITMAPINFO* a10,
                                         UINT a11)
    = SetDIBitsToDevice;

BOOL (__stdcall * Real_SetDefaultCommConfigA)(LPCSTR a0,
                                              LPCOMMCONFIG a1,
                                              DWORD a2)
    = SetDefaultCommConfigA;

BOOL (__stdcall * Real_SetDefaultCommConfigW)(LPCWSTR a0,
                                              LPCOMMCONFIG a1,
                                              DWORD a2)
    = SetDefaultCommConfigW;

BOOL (__stdcall * Real_SetDeviceGammaRamp)(HDC a0,
                                           LPVOID a1)
    = SetDeviceGammaRamp;

BOOL (__stdcall * Real_SetDlgItemInt)(HWND a0,
                                      int a1,
                                      UINT a2,
                                      BOOL a3)
    = SetDlgItemInt;

BOOL (__stdcall * Real_SetDlgItemTextA)(HWND a0,
                                        int a1,
                                        LPCSTR a2)
    = SetDlgItemTextA;

BOOL (__stdcall * Real_SetDlgItemTextW)(HWND a0,
                                        int a1,
                                        LPCWSTR a2)
    = SetDlgItemTextW;

BOOL (__stdcall * Real_SetDoubleClickTime)(UINT a0)
    = SetDoubleClickTime;

BOOL (__stdcall * Real_SetEndOfFile)(HANDLE a0)
    = SetEndOfFile;

HENHMETAFILE (__stdcall * Real_SetEnhMetaFileBits)(UINT a0,
                                                   CONST BYTE* a1)
    = SetEnhMetaFileBits;

BOOL (__stdcall * Real_SetEnvironmentVariableA)(LPCSTR a0,
                                                LPCSTR a1)
    = SetEnvironmentVariableA;

BOOL (__stdcall * Real_SetEnvironmentVariableW)(LPCWSTR a0,
                                                LPCWSTR a1)
    = SetEnvironmentVariableW;

UINT (__stdcall * Real_SetErrorMode)(UINT a0)
    = SetErrorMode;

BOOL (__stdcall * Real_SetEvent)(HANDLE a0)
    = SetEvent;

void (__stdcall * Real_SetFileApisToANSI)(void)
    = SetFileApisToANSI;

void (__stdcall * Real_SetFileApisToOEM)(void)
    = SetFileApisToOEM;

BOOL (__stdcall * Real_SetFileAttributesA)(LPCSTR a0,
                                           DWORD a1)
    = SetFileAttributesA;

BOOL (__stdcall * Real_SetFileAttributesW)(LPCWSTR a0,
                                           DWORD a1)
    = SetFileAttributesW;

DWORD (__stdcall * Real_SetFilePointer)(HANDLE a0,
                                        LONG a1,
                                        PLONG a2,
                                        DWORD a3)
    = SetFilePointer;

BOOL (__stdcall * Real_SetFileTime)(HANDLE a0,
                                    CONST FILETIME* a1,
                                    CONST FILETIME* a2,
                                    CONST FILETIME* a3)
    = SetFileTime;

HWND (__stdcall * Real_SetFocus)(HWND a0)
    = SetFocus;

BOOL (__stdcall * Real_SetForegroundWindow)(HWND a0)
    = SetForegroundWindow;

int (__stdcall * Real_SetGraphicsMode)(HDC a0,
                                       int a1)
    = SetGraphicsMode;

UINT (__stdcall * Real_SetHandleCount)(UINT a0)
    = SetHandleCount;

BOOL (__stdcall * Real_SetHandleInformation)(HANDLE a0,
                                             DWORD a1,
                                             DWORD a2)
    = SetHandleInformation;

int (__stdcall * Real_SetICMMode)(HDC a0,
                                  int a1)
    = SetICMMode;

BOOL (__stdcall * Real_SetICMProfileA)(HDC a0,
                                       LPSTR a1)
    = SetICMProfileA;

BOOL (__stdcall * Real_SetICMProfileW)(HDC a0,
                                       LPWSTR a1)
    = SetICMProfileW;

BOOL (__stdcall * Real_SetKeyboardState)(LPBYTE a0)
    = SetKeyboardState;

BOOL (__stdcall * Real_SetLocalTime)(CONST SYSTEMTIME* a0)
    = SetLocalTime;

BOOL (__stdcall * Real_SetLocaleInfoA)(LCID a0,
                                       LCTYPE a1,
                                       LPCSTR a2)
    = SetLocaleInfoA;

BOOL (__stdcall * Real_SetLocaleInfoW)(LCID a0,
                                       LCTYPE a1,
                                       LPCWSTR a2)
    = SetLocaleInfoW;

BOOL (__stdcall * Real_SetMailslotInfo)(HANDLE a0,
                                        DWORD a1)
    = SetMailslotInfo;

int (__stdcall * Real_SetMapMode)(HDC a0,
                                  int a1)
    = SetMapMode;

DWORD (__stdcall * Real_SetMapperFlags)(HDC a0,
                                        DWORD a1)
    = SetMapperFlags;

BOOL (__stdcall * Real_SetMenu)(HWND a0,
                                HMENU a1)
    = SetMenu;

BOOL (__stdcall * Real_SetMenuContextHelpId)(HMENU a0,
                                             DWORD a1)
    = SetMenuContextHelpId;

BOOL (__stdcall * Real_SetMenuDefaultItem)(HMENU a0,
                                           UINT a1,
                                           UINT a2)
    = SetMenuDefaultItem;

BOOL (__stdcall * Real_SetMenuItemBitmaps)(HMENU a0,
                                           UINT a1,
                                           UINT a2,
                                           HBITMAP a3,
                                           HBITMAP a4)
    = SetMenuItemBitmaps;

BOOL (__stdcall * Real_SetMenuItemInfoA)(HMENU a0,
                                         UINT a1,
                                         BOOL a2,
                                         CONST MENUITEMINFOA* a3)
    = SetMenuItemInfoA;

BOOL (__stdcall * Real_SetMenuItemInfoW)(HMENU a0,
                                         UINT a1,
                                         BOOL a2,
                                         CONST MENUITEMINFOW* a3)
    = SetMenuItemInfoW;

LPARAM (__stdcall * Real_SetMessageExtraInfo)(LPARAM a0)
    = SetMessageExtraInfo;

BOOL (__stdcall * Real_SetMessageQueue)(int a0)
    = SetMessageQueue;

HMETAFILE (__stdcall * Real_SetMetaFileBitsEx)(UINT a0,
                                               CONST BYTE* a1)
    = SetMetaFileBitsEx;

int (__stdcall * Real_SetMetaRgn)(HDC a0)
    = SetMetaRgn;

BOOL (__stdcall * Real_SetMiterLimit)(HDC a0,
                                      FLOAT a1,
                                      PFLOAT a2)
    = SetMiterLimit;

BOOL (__stdcall * Real_SetNamedPipeHandleState)(HANDLE a0,
                                                LPDWORD a1,
                                                LPDWORD a2,
                                                LPDWORD a3)
    = SetNamedPipeHandleState;

UINT (__stdcall * Real_SetPaletteEntries)(HPALETTE a0,
                                          UINT a1,
                                          UINT a2,
                                          CONST PALETTEENTRY* a3)
    = SetPaletteEntries;

HWND (__stdcall * Real_SetParent)(HWND a0,
                                  HWND a1)
    = SetParent;

COLORREF (__stdcall * Real_SetPixel)(HDC a0,
                                     int a1,
                                     int a2,
                                     COLORREF a3)
    = SetPixel;

BOOL (__stdcall * Real_SetPixelFormat)(HDC a0,
                                       int a1,
                                       CONST PIXELFORMATDESCRIPTOR* a2)
    = SetPixelFormat;

BOOL (__stdcall * Real_SetPixelV)(HDC a0,
                                  int a1,
                                  int a2,
                                  COLORREF a3)
    = SetPixelV;

int (__stdcall * Real_SetPolyFillMode)(HDC a0,
                                       int a1)
    = SetPolyFillMode;

BOOL (__stdcall * Real_SetPriorityClass)(HANDLE a0,
                                         DWORD a1)
    = SetPriorityClass;

BOOL (__stdcall * Real_SetProcessAffinityMask)(HANDLE a0,
                                               DWORD_PTR a1)
    = SetProcessAffinityMask;

BOOL (__stdcall * Real_SetProcessShutdownParameters)(DWORD a0,
                                                     DWORD a1)
    = SetProcessShutdownParameters;

BOOL (__stdcall * Real_SetProcessWindowStation)(HWINSTA a0)
    = SetProcessWindowStation;

BOOL (__stdcall * Real_SetProcessWorkingSetSize)(HANDLE a0,
                                                 SIZE_T a1,
                                                 SIZE_T a2)
    = SetProcessWorkingSetSize;

BOOL (__stdcall * Real_SetPropA)(HWND a0,
                                 LPCSTR a1,
                                 HANDLE a2)
    = SetPropA;

BOOL (__stdcall * Real_SetPropW)(HWND a0,
                                 LPCWSTR a1,
                                 HANDLE a2)
    = SetPropW;

int (__stdcall * Real_SetROP2)(HDC a0,
                               int a1)
    = SetROP2;

BOOL (__stdcall * Real_SetRect)(LPRECT a0,
                                int a1,
                                int a2,
                                int a3,
                                int a4)
    = SetRect;

BOOL (__stdcall * Real_SetRectEmpty)(LPRECT a0)
    = SetRectEmpty;

BOOL (__stdcall * Real_SetRectRgn)(HRGN a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   int a4)
    = SetRectRgn;

int (__stdcall * Real_SetScrollInfo)(HWND a0,
                                     int a1,
                                     LPCSCROLLINFO a2,
                                     BOOL a3)
    = SetScrollInfo;

int (__stdcall * Real_SetScrollPos)(HWND a0,
                                    int a1,
                                    int a2,
                                    BOOL a3)
    = SetScrollPos;

BOOL (__stdcall * Real_SetScrollRange)(HWND a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       BOOL a4)
    = SetScrollRange;

BOOL (__stdcall * Real_SetStdHandle)(DWORD a0,
                                     HANDLE a1)
    = SetStdHandle;

int (__stdcall * Real_SetStretchBltMode)(HDC a0,
                                         int a1)
    = SetStretchBltMode;

BOOL (__stdcall * Real_SetSysColors)(int a0,
                                     CONST INT* a1,
                                     CONST COLORREF* a2)
    = SetSysColors;

BOOL (__stdcall * Real_SetSystemCursor)(HCURSOR a0,
                                        DWORD a1)
    = SetSystemCursor;

UINT (__stdcall * Real_SetSystemPaletteUse)(HDC a0,
                                            UINT a1)
    = SetSystemPaletteUse;

BOOL (__stdcall * Real_SetSystemPowerState)(BOOL a0,
                                            BOOL a1)
    = SetSystemPowerState;

BOOL (__stdcall * Real_SetSystemTime)(CONST SYSTEMTIME* a0)
    = SetSystemTime;

BOOL (__stdcall * Real_SetSystemTimeAdjustment)(DWORD a0,
                                                BOOL a1)
    = SetSystemTimeAdjustment;

DWORD (__stdcall * Real_SetTapeParameters)(HANDLE a0,
                                           DWORD a1,
                                           LPVOID a2)
    = SetTapeParameters;

DWORD (__stdcall * Real_SetTapePosition)(HANDLE a0,
                                         DWORD a1,
                                         DWORD a2,
                                         DWORD a3,
                                         DWORD a4,
                                         BOOL a5)
    = SetTapePosition;

UINT (__stdcall * Real_SetTextAlign)(HDC a0,
                                     UINT a1)
    = SetTextAlign;

int (__stdcall * Real_SetTextCharacterExtra)(HDC a0,
                                             int a1)
    = SetTextCharacterExtra;

COLORREF (__stdcall * Real_SetTextColor)(HDC a0,
                                         COLORREF a1)
    = SetTextColor;

BOOL (__stdcall * Real_SetTextJustification)(HDC a0,
                                             int a1,
                                             int a2)
    = SetTextJustification;

DWORD_PTR (__stdcall * Real_SetThreadAffinityMask)(HANDLE a0,
                                               DWORD_PTR a1)
    = SetThreadAffinityMask;

BOOL (__stdcall * Real_SetThreadContext)(HANDLE a0,
                                         CONST CONTEXT* a1)
    = SetThreadContext;

BOOL (__stdcall * Real_SetThreadDesktop)(HDESK a0)
    = SetThreadDesktop;

DWORD (__stdcall * Real_SetThreadIdealProcessor)(HANDLE a0,
                                                 DWORD a1)
    = SetThreadIdealProcessor;

#if(WINVER >= 0x0500)
BOOL (__stdcall * Real_SetThreadLocale)(LCID a0)
    = SetThreadLocale;
#endif // (WINVER >= 0x0500)

BOOL (__stdcall * Real_SetThreadPriority)(HANDLE a0,
                                          int a1)
    = SetThreadPriority;

BOOL (__stdcall * Real_SetThreadPriorityBoost)(HANDLE a0,
                                               BOOL a1)
    = SetThreadPriorityBoost;

BOOL (__stdcall * Real_SetTimeZoneInformation)(CONST TIME_ZONE_INFORMATION* a0)
    = SetTimeZoneInformation;

UINT_PTR (__stdcall * Real_SetTimer)(HWND a0,
                                     UINT_PTR a1,
                                     UINT a2,
                                     TIMERPROC a3)
    = SetTimer;

LPTOP_LEVEL_EXCEPTION_FILTER (__stdcall * Real_SetUnhandledExceptionFilter)(LPTOP_LEVEL_EXCEPTION_FILTER a0)
    = SetUnhandledExceptionFilter;

BOOL (__stdcall * Real_SetUserObjectInformationA)(HANDLE a0,
                                                  int a1,
                                                  PVOID a2,
                                                  DWORD a3)
    = SetUserObjectInformationA;

BOOL (__stdcall * Real_SetUserObjectInformationW)(HANDLE a0,
                                                  int a1,
                                                  PVOID a2,
                                                  DWORD a3)
    = SetUserObjectInformationW;

BOOL (__stdcall * Real_SetUserObjectSecurity)(HANDLE a0,
                                              PSECURITY_INFORMATION a1,
                                              PSECURITY_DESCRIPTOR a2)
    = SetUserObjectSecurity;

BOOL (__stdcall * Real_SetViewportExtEx)(HDC a0,
                                         int a1,
                                         int a2,
                                         SIZE* a3)
    = SetViewportExtEx;

BOOL (__stdcall * Real_SetViewportOrgEx)(HDC a0,
                                         int a1,
                                         int a2,
                                         POINT* a3)
    = SetViewportOrgEx;

BOOL (__stdcall * Real_SetVolumeLabelA)(LPCSTR a0,
                                        LPCSTR a1)
    = SetVolumeLabelA;

BOOL (__stdcall * Real_SetVolumeLabelW)(LPCWSTR a0,
                                        LPCWSTR a1)
    = SetVolumeLabelW;

BOOL (__stdcall * Real_SetWaitableTimer)(HANDLE a0,
                                         CONST LARGE_INTEGER* a1,
                                         LONG a2,
                                         PTIMERAPCROUTINE a3,
                                         LPVOID a4,
                                         BOOL a5)
    = SetWaitableTimer;

HENHMETAFILE (__stdcall * Real_SetWinMetaFileBits)(UINT a0,
                                                   CONST BYTE* a1,
                                                   HDC a2,
                                                   CONST METAFILEPICT* a3)
    = SetWinMetaFileBits;

BOOL (__stdcall * Real_SetWindowContextHelpId)(HWND a0,
                                               DWORD a1)
    = SetWindowContextHelpId;

BOOL (__stdcall * Real_SetWindowExtEx)(HDC a0,
                                       int a1,
                                       int a2,
                                       SIZE* a3)
    = SetWindowExtEx;

LONG (__stdcall * Real_SetWindowLongA)(HWND a0,
                                       int a1,
                                       LONG a2)
    = SetWindowLongA;

LONG (__stdcall * Real_SetWindowLongW)(HWND a0,
                                       int a1,
                                       LONG a2)
    = SetWindowLongW;

BOOL (__stdcall * Real_SetWindowOrgEx)(HDC a0,
                                       int a1,
                                       int a2,
                                       POINT* a3)
    = SetWindowOrgEx;

BOOL (__stdcall * Real_SetWindowPlacement)(HWND a0,
                                           CONST WINDOWPLACEMENT* a1)
    = SetWindowPlacement;

BOOL (__stdcall * Real_SetWindowPos)(HWND a0,
                                     HWND a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     UINT a6)
    = SetWindowPos;

int (__stdcall * Real_SetWindowRgn)(HWND a0,
                                    HRGN a1,
                                    BOOL a2)
    = SetWindowRgn;

BOOL (__stdcall * Real_SetWindowTextA)(HWND a0,
                                       LPCSTR a1)
    = SetWindowTextA;

BOOL (__stdcall * Real_SetWindowTextW)(HWND a0,
                                       LPCWSTR a1)
    = SetWindowTextW;

WORD (__stdcall * Real_SetWindowWord)(HWND a0,
                                      int a1,
                                      WORD a2)
    = SetWindowWord;

HHOOK (__stdcall * Real_SetWindowsHookA)(int a0,
                                         HOOKPROC a1)
    = SetWindowsHookA;

HHOOK (__stdcall * Real_SetWindowsHookExA)(int a0,
                                           HOOKPROC a1,
                                           HINSTANCE a2,
                                           DWORD a3)
    = SetWindowsHookExA;

HHOOK (__stdcall * Real_SetWindowsHookExW)(int a0,
                                           HOOKPROC a1,
                                           HINSTANCE a2,
                                           DWORD a3)
    = SetWindowsHookExW;

HHOOK (__stdcall * Real_SetWindowsHookW)(int a0,
                                         HOOKPROC a1)
    = SetWindowsHookW;

BOOL (__stdcall * Real_SetWorldTransform)(HDC a0,
                                          CONST XFORM* a1)
    = SetWorldTransform;

BOOL (__stdcall * Real_SetupComm)(HANDLE a0,
                                  DWORD a1,
                                  DWORD a2)
    = SetupComm;

BOOL (__stdcall * Real_ShowCaret)(HWND a0)
    = ShowCaret;

int (__stdcall * Real_ShowCursor)(BOOL a0)
    = ShowCursor;

BOOL (__stdcall * Real_ShowOwnedPopups)(HWND a0,
                                        BOOL a1)
    = ShowOwnedPopups;

BOOL (__stdcall * Real_ShowScrollBar)(HWND a0,
                                      int a1,
                                      BOOL a2)
    = ShowScrollBar;

BOOL (__stdcall * Real_ShowWindow)(HWND a0,
                                   int a1)
    = ShowWindow;

BOOL (__stdcall * Real_ShowWindowAsync)(HWND a0,
                                        int a1)
    = ShowWindowAsync;

DWORD (__stdcall * Real_SignalObjectAndWait)(HANDLE a0,
                                             HANDLE a1,
                                             DWORD a2,
                                             BOOL a3)
    = SignalObjectAndWait;

DWORD (__stdcall * Real_SizeofResource)(HMODULE a0,
                                        HRSRC a1)
    = SizeofResource;

DWORD (__stdcall * Real_SleepEx)(DWORD a0,
                                 BOOL a1)
    = SleepEx;

int (__stdcall * Real_StartDocA)(HDC a0,
                                 CONST DOCINFOA* a1)
    = StartDocA;

int (__stdcall * Real_StartDocW)(HDC a0,
                                 CONST DOCINFOW* a1)
    = StartDocW;

int (__stdcall * Real_StartPage)(HDC a0)
    = StartPage;

HRESULT (__stdcall * Real_StgCreateDocfile)(CONST OLECHAR* a0,
                                            DWORD a1,
                                            DWORD a2,
                                            IStorage** a3)
    = StgCreateDocfile;

HRESULT (__stdcall * Real_StgCreateDocfileOnILockBytes)(ILockBytes* a0,
                                                        DWORD a1,
                                                        DWORD a2,
                                                        IStorage** a3)
    = StgCreateDocfileOnILockBytes;

HRESULT (__stdcall * Real_StgCreatePropSetStg)(IStorage* a0,
                                               DWORD a1,
                                               IPropertySetStorage** a2)
    = StgCreatePropSetStg;

HRESULT (__stdcall * Real_StgCreatePropStg)(IUnknown* a0,
                                            CONST IID& a1,
                                            CONST CLSID* a2,
                                            DWORD a3,
                                            DWORD a4,
                                            IPropertyStorage** a5)
    = StgCreatePropStg;

#if _MSC_VER < 1300
HRESULT (__stdcall * Real_StgCreateStorageEx)(CONST WCHAR* a0,
                                              DWORD a1,
                                              DWORD a2,
                                              DWORD a3,
                                              void* a4,
                                              void* a5,
                                              CONST IID& a6,
                                              void** a7)
    = StgCreateStorageEx;
#else
HRESULT (__stdcall * Real_StgCreateStorageEx)(CONST WCHAR* a0,
                                              DWORD a1,
                                              DWORD a2,
                                              DWORD a3,
                                              STGOPTIONS* a4,
                                              void* a5,
                                              CONST IID& a6,
                                              void** a7)
    = StgCreateStorageEx;
#endif

HRESULT (__stdcall * Real_StgGetIFillLockBytesOnFile)(CONST OLECHAR* a0,
                                                      IFillLockBytes** a1)
    = StgGetIFillLockBytesOnFile;

HRESULT (__stdcall * Real_StgGetIFillLockBytesOnILockBytes)(ILockBytes* a0,
                                                            IFillLockBytes** a1)
    = StgGetIFillLockBytesOnILockBytes;

HRESULT (__stdcall * Real_StgIsStorageFile)(CONST OLECHAR* a0)
    = StgIsStorageFile;

HRESULT (__stdcall * Real_StgIsStorageILockBytes)(ILockBytes* a0)
    = StgIsStorageILockBytes;

HRESULT (__stdcall * Real_StgOpenAsyncDocfileOnIFillLockBytes)(IFillLockBytes* a0,
                                                               DWORD a1,
                                                               DWORD a2,
                                                               IStorage** a3)
    = StgOpenAsyncDocfileOnIFillLockBytes;

HRESULT (__stdcall * Real_StgOpenPropStg)(IUnknown* a0,
                                          CONST IID& a1,
                                          DWORD a2,
                                          DWORD a3,
                                          IPropertyStorage** a4)
    = StgOpenPropStg;

HRESULT (__stdcall * Real_StgOpenStorage)(CONST OLECHAR* a0,
                                          IStorage* a1,
                                          DWORD a2,
                                          SNB a3,
                                          DWORD a4,
                                          IStorage** a5)
    = StgOpenStorage;

#if _MSC_VER < 1300
HRESULT (__stdcall * Real_StgOpenStorageEx)(CONST WCHAR* a0,
                                            DWORD a1,
                                            DWORD a2,
                                            DWORD a3,
                                            void* a4,
                                            void* a5,
                                            CONST IID& a6,
                                            void** a7)
    = StgOpenStorageEx;
#else
HRESULT (__stdcall * Real_StgOpenStorageEx)(CONST WCHAR* a0,
                                            DWORD a1,
                                            DWORD a2,
                                            DWORD a3,
                                            STGOPTIONS* a4,
                                            void* a5,
                                            CONST IID& a6,
                                            void** a7)
    = StgOpenStorageEx;
#endif

HRESULT (__stdcall * Real_StgOpenStorageOnILockBytes)(ILockBytes* a0,
                                                      IStorage* a1,
                                                      DWORD a2,
                                                      SNB a3,
                                                      DWORD a4,
                                                      IStorage** a5)
    = StgOpenStorageOnILockBytes;

HRESULT (__stdcall * Real_StgSetTimes)(CONST OLECHAR* a0,
                                       CONST FILETIME* a1,
                                       CONST FILETIME* a2,
                                       CONST FILETIME* a3)
    = StgSetTimes;

BOOL (__stdcall * Real_StretchBlt)(HDC a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   int a4,
                                   HDC a5,
                                   int a6,
                                   int a7,
                                   int a8,
                                   int a9,
                                   DWORD a10)
    = StretchBlt;

int (__stdcall * Real_StretchDIBits)(HDC a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     int a7,
                                     int a8,
                                     CONST void* a9,
                                     CONST BITMAPINFO* a10,
                                     UINT a11,
                                     DWORD a12)
    = StretchDIBits;

HRESULT (__stdcall * Real_StringFromCLSID)(CONST IID& a0,
                                           LPOLESTR* a1)
    = StringFromCLSID;

int (__stdcall * Real_StringFromGUID2)(CONST GUID& a0,
                                       LPOLESTR a1,
                                       int a2)
    = StringFromGUID2;

HRESULT (__stdcall * Real_StringFromIID)(CONST IID& a0,
                                         LPOLESTR* a1)
    = StringFromIID;

BOOL (__stdcall * Real_StrokeAndFillPath)(HDC a0)
    = StrokeAndFillPath;

BOOL (__stdcall * Real_StrokePath)(HDC a0)
    = StrokePath;

BOOL (__stdcall * Real_SubtractRect)(LPRECT a0,
                                     CONST RECT* a1,
                                     CONST RECT* a2)
    = SubtractRect;

DWORD (__stdcall * Real_SuspendThread)(HANDLE a0)
    = SuspendThread;

BOOL (__stdcall * Real_SwapBuffers)(HDC a0)
    = SwapBuffers;

BOOL (__stdcall * Real_SwapMouseButton)(BOOL a0)
    = SwapMouseButton;

BOOL (__stdcall * Real_SwitchDesktop)(HDESK a0)
    = SwitchDesktop;

void (__stdcall * Real_SwitchToFiber)(LPVOID a0)
    = SwitchToFiber;

BOOL (__stdcall * Real_SwitchToThread)(void)
    = SwitchToThread;

BOOL (__stdcall * Real_SystemParametersInfoA)(UINT a0,
                                              UINT a1,
                                              PVOID a2,
                                              UINT a3)
    = SystemParametersInfoA;

BOOL (__stdcall * Real_SystemParametersInfoW)(UINT a0,
                                              UINT a1,
                                              PVOID a2,
                                              UINT a3)
    = SystemParametersInfoW;

BOOL (__stdcall * Real_SystemTimeToFileTime)(CONST SYSTEMTIME* a0,
                                             LPFILETIME a1)
    = SystemTimeToFileTime;

BOOL (__stdcall * Real_SystemTimeToTzSpecificLocalTime)(
#ifdef PIPE_ACCEPT_REMOTE_CLIENTS
                                                        const TIME_ZONE_INFORMATION *a0,
                                                        const SYSTEMTIME *a1,
#else
                                                        LPTIME_ZONE_INFORMATION a0,
                                                        LPSYSTEMTIME a1,
#endif
                                                        LPSYSTEMTIME a2
                                                       )
    = SystemTimeToTzSpecificLocalTime;

#if _MSC_VER < 1300
LONG (__stdcall * Real_TabbedTextOutA)(HDC a0,
                                       int a1,
                                       int a2,
                                       LPCSTR a3,
                                       int a4,
                                       int a5,
                                       INT* a6,
                                       int a7)
    = TabbedTextOutA;
#else
LONG (__stdcall * Real_TabbedTextOutA)(HDC a0,
                                       int a1,
                                       int a2,
                                       LPCSTR a3,
                                       int a4,
                                       int a5,
                                       CONST INT* a6,
                                       int a7)
    = TabbedTextOutA;
#endif

#if _MSC_VER < 1300
LONG (__stdcall * Real_TabbedTextOutW)(HDC a0,
                                       int a1,
                                       int a2,
                                       LPCWSTR a3,
                                       int a4,
                                       int a5,
                                       INT* a6,
                                       int a7)
    = TabbedTextOutW;
#else
LONG (__stdcall * Real_TabbedTextOutW)(HDC a0,
                                       int a1,
                                       int a2,
                                       LPCWSTR a3,
                                       int a4,
                                       int a5,
                                       CONST INT* a6,
                                       int a7)
    = TabbedTextOutW;
#endif

BOOL (__stdcall * Real_TerminateProcess)(HANDLE a0,
                                         UINT a1)
    = TerminateProcess;

BOOL (__stdcall * Real_TerminateThread)(HANDLE a0,
                                        DWORD a1)
    = TerminateThread;

BOOL (__stdcall * Real_TextOutA)(HDC a0,
                                 int a1,
                                 int a2,
                                 LPCSTR a3,
                                 int a4)
    = TextOutA;

BOOL (__stdcall * Real_TextOutW)(HDC a0,
                                 int a1,
                                 int a2,
                                 LPCWSTR a3,
                                 int a4)
    = TextOutW;

WORD (__stdcall * Real_TileWindows)(HWND a0,
                                    UINT a1,
                                    CONST RECT* a2,
                                    UINT a3,
                                    CONST HWND * a4)
    = TileWindows;

#if _MSC_VER < 1300
int (__stdcall * Real_ToAscii)(UINT a0,
                               UINT a1,
                               BYTE* a2,
                               LPWORD a3,
                               UINT a4)
    = ToAscii;
#else
int (__stdcall * Real_ToAscii)(UINT a0,
                               UINT a1,
                               CONST BYTE* a2,
                               LPWORD a3,
                               UINT a4)
    = ToAscii;
#endif

#if _MSC_VER < 1300
int (__stdcall * Real_ToAsciiEx)(UINT a0,
                                 UINT a1,
                                 BYTE* a2,
                                 LPWORD a3,
                                 UINT a4,
                                 HKL a5)
    = ToAsciiEx;
#else
int (__stdcall * Real_ToAsciiEx)(UINT a0,
                                 UINT a1,
                                 CONST BYTE* a2,
                                 LPWORD a3,
                                 UINT a4,
                                 HKL a5)
    = ToAsciiEx;
#endif

#if _MSC_VER < 1300
int (__stdcall * Real_ToUnicode)(UINT a0,
                                 UINT a1,
                                 BYTE* a2,
                                 LPWSTR a3,
                                 int a4,
                                 UINT a5)
    = ToUnicode;
#else
int (__stdcall * Real_ToUnicode)(UINT a0,
                                 UINT a1,
                                 CONST BYTE* a2,
                                 LPWSTR a3,
                                 int a4,
                                 UINT a5)
    = ToUnicode;
#endif

#if _MSC_VER < 1300
int (__stdcall * Real_ToUnicodeEx)(UINT a0,
                                   UINT a1,
                                   BYTE* a2,
                                   LPWSTR a3,
                                   int a4,
                                   UINT a5,
                                   HKL a6)
    = ToUnicodeEx;
#else
int (__stdcall * Real_ToUnicodeEx)(UINT a0,
                                   UINT a1,
                                   CONST BYTE* a2,
                                   LPWSTR a3,
                                   int a4,
                                   UINT a5,
                                   HKL a6)
    = ToUnicodeEx;
#endif

BOOL (__stdcall * Real_TrackMouseEvent)(TRACKMOUSEEVENT* a0)
    = TrackMouseEvent;

BOOL (__stdcall * Real_TrackPopupMenu)(HMENU a0,
                                       UINT a1,
                                       int a2,
                                       int a3,
                                       int a4,
                                       HWND a5,
                                       CONST RECT* a6)
    = TrackPopupMenu;

BOOL (__stdcall * Real_TrackPopupMenuEx)(HMENU a0,
                                         UINT a1,
                                         int a2,
                                         int a3,
                                         HWND a4,
                                         LPTPMPARAMS a5)
    = TrackPopupMenuEx;

BOOL (__stdcall * Real_TransactNamedPipe)(HANDLE a0,
                                          LPVOID a1,
                                          DWORD a2,
                                          LPVOID a3,
                                          DWORD a4,
                                          LPDWORD a5,
                                          LPOVERLAPPED a6)
    = TransactNamedPipe;

int (__stdcall * Real_TranslateAcceleratorA)(HWND a0,
                                             HACCEL a1,
                                             LPMSG a2)
    = TranslateAcceleratorA;

int (__stdcall * Real_TranslateAcceleratorW)(HWND a0,
                                             HACCEL a1,
                                             LPMSG a2)
    = TranslateAcceleratorW;

BOOL (__stdcall * Real_TranslateCharsetInfo)(DWORD* a0,
                                             CHARSETINFO* a1,
                                             DWORD a2)
    = TranslateCharsetInfo;

BOOL (__stdcall * Real_TranslateMDISysAccel)(HWND a0,
                                             LPMSG a1)
    = TranslateMDISysAccel;

BOOL (__stdcall * Real_TranslateMessage)(CONST MSG* a0)
    = TranslateMessage;

BOOL (__stdcall * Real_TransmitCommChar)(HANDLE a0,
                                         char a1)
    = TransmitCommChar;

#if DETOUR_TryEnterCriticalSection_EVEN_IF_IT_EXERCISES_A_BUG_IN_RtlLookupFunctionTable
BOOL (__stdcall * Real_TryEnterCriticalSection)(LPCRITICAL_SECTION a0)
    = TryEnterCriticalSection;
#endif

BOOL (__stdcall * Real_UnhookWindowsHook)(int a0,
                                          HOOKPROC a1)
    = UnhookWindowsHook;

BOOL (__stdcall * Real_UnhookWindowsHookEx)(HHOOK a0)
    = UnhookWindowsHookEx;

BOOL (__stdcall * Real_UnionRect)(LPRECT a0,
                                  CONST RECT* a1,
                                  CONST RECT* a2)
    = UnionRect;

BOOL (__stdcall * Real_UnloadKeyboardLayout)(HKL a0)
    = UnloadKeyboardLayout;

BOOL (__stdcall * Real_UnlockFile)(HANDLE a0,
                                   DWORD a1,
                                   DWORD a2,
                                   DWORD a3,
                                   DWORD a4)
    = UnlockFile;

BOOL (__stdcall * Real_UnlockFileEx)(HANDLE a0,
                                     DWORD a1,
                                     DWORD a2,
                                     DWORD a3,
                                     LPOVERLAPPED a4)
    = UnlockFileEx;

BOOL (__stdcall * Real_UnmapViewOfFile)(LPCVOID a0)
    = UnmapViewOfFile;

BOOL (__stdcall * Real_UnpackDDElParam)(UINT a0,
                                        LPARAM a1,
                                        PUINT_PTR a2,
                                        PUINT_PTR a3)
    = UnpackDDElParam;

BOOL (__stdcall * Real_UnrealizeObject)(HGDIOBJ a0)
    = UnrealizeObject;

BOOL (__stdcall * Real_UnregisterClassA)(LPCSTR a0,
                                         HINSTANCE a1)
    = UnregisterClassA;

BOOL (__stdcall * Real_UnregisterClassW)(LPCWSTR a0,
                                         HINSTANCE a1)
    = UnregisterClassW;

BOOL (__stdcall * Real_UnregisterHotKey)(HWND a0,
                                         int a1)
    = UnregisterHotKey;

BOOL (__stdcall * Real_UpdateColors)(HDC a0)
    = UpdateColors;

BOOL (__stdcall * Real_UpdateResourceA)(HANDLE a0,
                                        LPCSTR a1,
                                        LPCSTR a2,
                                        WORD a3,
                                        LPVOID a4,
                                        DWORD a5)
    = UpdateResourceA;

BOOL (__stdcall * Real_UpdateResourceW)(HANDLE a0,
                                        LPCWSTR a1,
                                        LPCWSTR a2,
                                        WORD a3,
                                        LPVOID a4,
                                        DWORD a5)
    = UpdateResourceW;

BOOL (__stdcall * Real_UpdateWindow)(HWND a0)
    = UpdateWindow;

BOOL (__stdcall * Real_ValidateRect)(HWND a0,
                                     CONST RECT* a1)
    = ValidateRect;

BOOL (__stdcall * Real_ValidateRgn)(HWND a0,
                                    HRGN a1)
    = ValidateRgn;

DWORD (__stdcall * Real_VerLanguageNameA)(DWORD a0,
                                          LPSTR a1,
                                          DWORD a2)
    = VerLanguageNameA;

DWORD (__stdcall * Real_VerLanguageNameW)(DWORD a0,
                                          LPWSTR a1,
                                          DWORD a2)
    = VerLanguageNameW;

LPVOID (__stdcall * Real_VirtualAllocEx)(HANDLE a0,
                                         LPVOID a1,
                                         SIZE_T a2,
                                         DWORD a3,
                                         DWORD a4)
    = VirtualAllocEx;

BOOL (__stdcall * Real_VirtualFreeEx)(HANDLE a0,
                                      LPVOID a1,
                                      SIZE_T a2,
                                      DWORD a3)
    = VirtualFreeEx;

BOOL (__stdcall * Real_VirtualProtectEx)(HANDLE a0,
                                         LPVOID a1,
                                         SIZE_T a2,
                                         DWORD a3,
                                         PDWORD a4)
    = VirtualProtectEx;

DWORD_PTR (__stdcall * Real_VirtualQueryEx)(HANDLE a0,
                                        LPCVOID a1,
                                        PMEMORY_BASIC_INFORMATION a2,
                                        DWORD_PTR a3)
    = VirtualQueryEx;

SHORT (__stdcall * Real_VkKeyScanA)(CHAR a0)
    = VkKeyScanA;

SHORT (__stdcall * Real_VkKeyScanExA)(CHAR a0,
                                      HKL a1)
    = VkKeyScanExA;

SHORT (__stdcall * Real_VkKeyScanExW)(WCHAR a0,
                                      HKL a1)
    = VkKeyScanExW;

SHORT (__stdcall * Real_VkKeyScanW)(WCHAR a0)
    = VkKeyScanW;

SOCKET (__stdcall * Real_WSAAccept)(SOCKET a0,
                                    sockaddr* a1,
                                    LPINT a2,
                                    LPCONDITIONPROC a3,
                                    DWORD_PTR a4)
    = WSAAccept;

INT (__stdcall * Real_WSAAddressToStringA)(LPSOCKADDR a0,
                                           DWORD a1,
                                           LPWSAPROTOCOL_INFOA a2,
                                           LPSTR a3,
                                           LPDWORD a4)
    = WSAAddressToStringA;

INT (__stdcall * Real_WSAAddressToStringW)(LPSOCKADDR a0,
                                           DWORD a1,
                                           LPWSAPROTOCOL_INFOW a2,
                                           LPWSTR a3,
                                           LPDWORD a4)
    = WSAAddressToStringW;

HANDLE (__stdcall * Real_WSAAsyncGetHostByAddr)(HWND a0,
                                                u_int a1,
                                                CONST char* a2,
                                                int a3,
                                                int a4,
                                                char* a5,
                                                int a6)
    = WSAAsyncGetHostByAddr;

HANDLE (__stdcall * Real_WSAAsyncGetHostByName)(HWND a0,
                                                u_int a1,
                                                CONST char* a2,
                                                char* a3,
                                                int a4)
    = WSAAsyncGetHostByName;

HANDLE (__stdcall * Real_WSAAsyncGetProtoByName)(HWND a0,
                                                 u_int a1,
                                                 CONST char* a2,
                                                 char* a3,
                                                 int a4)
    = WSAAsyncGetProtoByName;

HANDLE (__stdcall * Real_WSAAsyncGetProtoByNumber)(HWND a0,
                                                   u_int a1,
                                                   int a2,
                                                   char* a3,
                                                   int a4)
    = WSAAsyncGetProtoByNumber;

HANDLE (__stdcall * Real_WSAAsyncGetServByName)(HWND a0,
                                                u_int a1,
                                                CONST char* a2,
                                                CONST char* a3,
                                                char* a4,
                                                int a5)
    = WSAAsyncGetServByName;

HANDLE (__stdcall * Real_WSAAsyncGetServByPort)(HWND a0,
                                                u_int a1,
                                                int a2,
                                                CONST char* a3,
                                                char* a4,
                                                int a5)
    = WSAAsyncGetServByPort;

int (__stdcall * Real_WSAAsyncSelect)(SOCKET a0,
                                      HWND a1,
                                      u_int a2,
                                      long a3)
    = WSAAsyncSelect;

int (__stdcall * Real_WSACancelAsyncRequest)(HANDLE a0)
    = WSACancelAsyncRequest;

int (__stdcall * Real_WSACancelBlockingCall)(void)
    = WSACancelBlockingCall;

int (__stdcall * Real_WSACleanup)(void)
    = WSACleanup;

BOOL (__stdcall * Real_WSACloseEvent)(HANDLE a0)
    = WSACloseEvent;

int (__stdcall * Real_WSAConnect)(SOCKET a0,
                                  CONST sockaddr* a1,
                                  int a2,
                                  LPWSABUF a3,
                                  LPWSABUF a4,
                                  LPQOS a5,
                                  LPQOS a6)
    = WSAConnect;

HANDLE (__stdcall * Real_WSACreateEvent)(void)
    = WSACreateEvent;

int (__stdcall * Real_WSADuplicateSocketA)(SOCKET a0,
                                           DWORD a1,
                                           LPWSAPROTOCOL_INFOA a2)
    = WSADuplicateSocketA;

int (__stdcall * Real_WSADuplicateSocketW)(SOCKET a0,
                                           DWORD a1,
                                           LPWSAPROTOCOL_INFOW a2)
    = WSADuplicateSocketW;

INT (__stdcall * Real_WSAEnumNameSpaceProvidersA)(LPDWORD a0,
                                                  LPWSANAMESPACE_INFOA a1)
    = WSAEnumNameSpaceProvidersA;

INT (__stdcall * Real_WSAEnumNameSpaceProvidersW)(LPDWORD a0,
                                                  LPWSANAMESPACE_INFOW a1)
    = WSAEnumNameSpaceProvidersW;

int (__stdcall * Real_WSAEnumNetworkEvents)(SOCKET a0,
                                            HANDLE a1,
                                            LPWSANETWORKEVENTS a2)
    = WSAEnumNetworkEvents;

int (__stdcall * Real_WSAEnumProtocolsA)(LPINT a0,
                                         LPWSAPROTOCOL_INFOA a1,
                                         LPDWORD a2)
    = WSAEnumProtocolsA;

int (__stdcall * Real_WSAEnumProtocolsW)(LPINT a0,
                                         LPWSAPROTOCOL_INFOW a1,
                                         LPDWORD a2)
    = WSAEnumProtocolsW;

int (__stdcall * Real_WSAEventSelect)(SOCKET a0,
                                      HANDLE a1,
                                      long a2)
    = WSAEventSelect;

BOOL (__stdcall * Real_WSAGetOverlappedResult)(SOCKET a0,
                                               LPWSAOVERLAPPED a1,
                                               LPDWORD a2,
                                               BOOL a3,
                                               LPDWORD a4)
    = WSAGetOverlappedResult;

BOOL (__stdcall * Real_WSAGetQOSByName)(SOCKET a0,
                                        LPWSABUF a1,
                                        LPQOS a2)
    = WSAGetQOSByName;

INT (__stdcall * Real_WSAGetServiceClassInfoA)(LPGUID a0,
                                               LPGUID a1,
                                               LPDWORD a2,
                                               LPWSASERVICECLASSINFOA a3)
    = WSAGetServiceClassInfoA;

INT (__stdcall * Real_WSAGetServiceClassInfoW)(LPGUID a0,
                                               LPGUID a1,
                                               LPDWORD a2,
                                               LPWSASERVICECLASSINFOW a3)
    = WSAGetServiceClassInfoW;

INT (__stdcall * Real_WSAGetServiceClassNameByClassIdA)(LPGUID a0,
                                                        LPSTR a1,
                                                        LPDWORD a2)
    = WSAGetServiceClassNameByClassIdA;

INT (__stdcall * Real_WSAGetServiceClassNameByClassIdW)(LPGUID a0,
                                                        LPWSTR a1,
                                                        LPDWORD a2)
    = WSAGetServiceClassNameByClassIdW;

int (__stdcall * Real_WSAHtonl)(SOCKET a0,
                                u_long a1,
                                u_long* a2)
    = WSAHtonl;

int (__stdcall * Real_WSAHtons)(SOCKET a0,
                                u_short a1,
                                u_short* a2)
    = WSAHtons;

INT (__stdcall * Real_WSAInstallServiceClassA)(LPWSASERVICECLASSINFOA a0)
    = WSAInstallServiceClassA;

INT (__stdcall * Real_WSAInstallServiceClassW)(LPWSASERVICECLASSINFOW a0)
    = WSAInstallServiceClassW;

int (__stdcall * Real_WSAIoctl)(SOCKET a0,
                                DWORD a1,
                                LPVOID a2,
                                DWORD a3,
                                LPVOID a4,
                                DWORD a5,
                                LPDWORD a6,
                                LPWSAOVERLAPPED a7,
                                LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
    = WSAIoctl;

BOOL (__stdcall * Real_WSAIsBlocking)(void)
    = WSAIsBlocking;

SOCKET (__stdcall * Real_WSAJoinLeaf)(SOCKET a0,
                                      CONST sockaddr* a1,
                                      int a2,
                                      LPWSABUF a3,
                                      LPWSABUF a4,
                                      LPQOS a5,
                                      LPQOS a6,
                                      DWORD a7)
    = WSAJoinLeaf;

INT (__stdcall * Real_WSALookupServiceBeginA)(LPWSAQUERYSETA a0,
                                              DWORD a1,
                                              LPHANDLE a2)
    = WSALookupServiceBeginA;

INT (__stdcall * Real_WSALookupServiceBeginW)(LPWSAQUERYSETW a0,
                                              DWORD a1,
                                              LPHANDLE a2)
    = WSALookupServiceBeginW;

INT (__stdcall * Real_WSALookupServiceEnd)(HANDLE a0)
    = WSALookupServiceEnd;

INT (__stdcall * Real_WSALookupServiceNextA)(HANDLE a0,
                                             DWORD a1,
                                             LPDWORD a2,
                                             LPWSAQUERYSETA a3)
    = WSALookupServiceNextA;

INT (__stdcall * Real_WSALookupServiceNextW)(HANDLE a0,
                                             DWORD a1,
                                             LPDWORD a2,
                                             LPWSAQUERYSETW a3)
    = WSALookupServiceNextW;

int (__stdcall * Real_WSANtohl)(SOCKET a0,
                                u_long a1,
                                u_long* a2)
    = WSANtohl;

int (__stdcall * Real_WSANtohs)(SOCKET a0,
                                u_short a1,
                                u_short* a2)
    = WSANtohs;

INT (__stdcall * Real_WSAProviderConfigChange)(LPHANDLE a0,
                                               LPWSAOVERLAPPED a1,
                                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a2)
    = WSAProviderConfigChange;

int (__stdcall * Real_WSARecv)(SOCKET a0,
                               LPWSABUF a1,
                               DWORD a2,
                               LPDWORD a3,
                               LPDWORD a4,
                               LPWSAOVERLAPPED a5,
                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
    = WSARecv;

int (__stdcall * Real_WSARecvDisconnect)(SOCKET a0,
                                         LPWSABUF a1)
    = WSARecvDisconnect;

int (__stdcall * Real_WSARecvFrom)(SOCKET a0,
                                   LPWSABUF a1,
                                   DWORD a2,
                                   LPDWORD a3,
                                   LPDWORD a4,
                                   sockaddr* a5,
                                   LPINT a6,
                                   LPWSAOVERLAPPED a7,
                                   LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
    = WSARecvFrom;

INT (__stdcall * Real_WSARemoveServiceClass)(LPGUID a0)
    = WSARemoveServiceClass;

BOOL (__stdcall * Real_WSAResetEvent)(HANDLE a0)
    = WSAResetEvent;

int (__stdcall * Real_WSASend)(SOCKET a0,
                               LPWSABUF a1,
                               DWORD a2,
                               LPDWORD a3,
                               DWORD a4,
                               LPWSAOVERLAPPED a5,
                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
    = WSASend;

int (__stdcall * Real_WSASendDisconnect)(SOCKET a0,
                                         LPWSABUF a1)
    = WSASendDisconnect;

int (__stdcall * Real_WSASendTo)(SOCKET a0,
                                 LPWSABUF a1,
                                 DWORD a2,
                                 LPDWORD a3,
                                 DWORD a4,
                                 CONST sockaddr* a5,
                                 int a6,
                                 LPWSAOVERLAPPED a7,
                                 LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
    = WSASendTo;

FARPROC (__stdcall * Real_WSASetBlockingHook)(FARPROC a0)
    = WSASetBlockingHook;

BOOL (__stdcall * Real_WSASetEvent)(HANDLE a0)
    = WSASetEvent;

INT (__stdcall * Real_WSASetServiceA)(LPWSAQUERYSETA a0,
                                      WSAESETSERVICEOP a1,
                                      DWORD a2)
    = WSASetServiceA;

INT (__stdcall * Real_WSASetServiceW)(LPWSAQUERYSETW a0,
                                      WSAESETSERVICEOP a1,
                                      DWORD a2)
    = WSASetServiceW;

SOCKET (__stdcall * Real_WSASocketA)(int a0,
                                     int a1,
                                     int a2,
                                     LPWSAPROTOCOL_INFOA a3,
                                     GROUP a4,
                                     DWORD a5)
    = WSASocketA;

SOCKET (__stdcall * Real_WSASocketW)(int a0,
                                     int a1,
                                     int a2,
                                     LPWSAPROTOCOL_INFOW a3,
                                     GROUP a4,
                                     DWORD a5)
    = WSASocketW;

int (__stdcall * Real_WSAStartup)(WORD a0,
                                  LPWSADATA a1)
    = WSAStartup;

INT (__stdcall * Real_WSAStringToAddressA)(LPSTR a0,
                                           INT a1,
                                           LPWSAPROTOCOL_INFOA a2,
                                           LPSOCKADDR a3,
                                           LPINT a4)
    = WSAStringToAddressA;

INT (__stdcall * Real_WSAStringToAddressW)(LPWSTR a0,
                                           INT a1,
                                           LPWSAPROTOCOL_INFOW a2,
                                           LPSOCKADDR a3,
                                           LPINT a4)
    = WSAStringToAddressW;

int (__stdcall * Real_WSAUnhookBlockingHook)(void)
    = WSAUnhookBlockingHook;

DWORD (__stdcall * Real_WSAWaitForMultipleEvents)(DWORD a0,
                                                  CONST HANDLE * a1,
                                                  BOOL a2,
                                                  DWORD a3,
                                                  BOOL a4)
    = WSAWaitForMultipleEvents;

BOOL (__stdcall * Real_WaitCommEvent)(HANDLE a0,
                                      LPDWORD a1,
                                      LPOVERLAPPED a2)
    = WaitCommEvent;

#if !defined(DETOURS_ARM)
BOOL (__stdcall * Real_WaitForDebugEvent)(LPDEBUG_EVENT a0,
                                          DWORD a1)
    = WaitForDebugEvent;
#endif // !DETOUR_ARM

DWORD (__stdcall * Real_WaitForInputIdle)(HANDLE a0,
                                          DWORD a1)
    = WaitForInputIdle;

DWORD (__stdcall * Real_WaitForMultipleObjects)(DWORD a0,
                                                CONST HANDLE * a1,
                                                BOOL a2,
                                                DWORD a3)
    = WaitForMultipleObjects;

DWORD (__stdcall * Real_WaitForMultipleObjectsEx)(DWORD a0,
                                                  CONST HANDLE * a1,
                                                  BOOL a2,
                                                  DWORD a3,
                                                  BOOL a4)
    = WaitForMultipleObjectsEx;

DWORD (__stdcall * Real_WaitForSingleObject)(HANDLE a0,
                                             DWORD a1)
    = WaitForSingleObject;

DWORD (__stdcall * Real_WaitForSingleObjectEx)(HANDLE a0,
                                               DWORD a1,
                                               BOOL a2)
    = WaitForSingleObjectEx;

BOOL (__stdcall * Real_WaitMessage)(void)
    = WaitMessage;

BOOL (__stdcall * Real_WaitNamedPipeA)(LPCSTR a0,
                                       DWORD a1)
    = WaitNamedPipeA;

BOOL (__stdcall * Real_WaitNamedPipeW)(LPCWSTR a0,
                                       DWORD a1)
    = WaitNamedPipeW;

BOOL (__stdcall * Real_WidenPath)(HDC a0)
    = WidenPath;

UINT (__stdcall * Real_WinExec)(LPCSTR a0,
                                UINT a1)
    = WinExec;

BOOL (__stdcall * Real_WinHelpA)(HWND a0,
                                 LPCSTR a1,
                                 UINT a2,
                                 ULONG_PTR a3)
    = WinHelpA;

BOOL (__stdcall * Real_WinHelpW)(HWND a0,
                                 LPCWSTR a1,
                                 UINT a2,
                                 ULONG_PTR a3)
    = WinHelpW;

HWND (__stdcall * Real_WindowFromDC)(HDC a0)
    = WindowFromDC;

HWND (__stdcall * Real_WindowFromPoint)(POINT a0)
    = WindowFromPoint;

HRESULT (__stdcall * Real_WriteClassStg)(LPSTORAGE a0,
                                         CONST IID& a1)
    = WriteClassStg;

HRESULT (__stdcall * Real_WriteClassStm)(LPSTREAM a0,
                                         CONST IID& a1)
    = WriteClassStm;

BOOL (__stdcall * Real_WriteConsoleA)(HANDLE a0,
                                      CONST void* a1,
                                      DWORD a2,
                                      LPDWORD a3,
                                      LPVOID a4)
    = WriteConsoleA;

BOOL (__stdcall * Real_WriteConsoleInputA)(HANDLE a0,
                                           CONST INPUT_RECORD* a1,
                                           DWORD a2,
                                           LPDWORD a3)
    = WriteConsoleInputA;

BOOL (__stdcall * Real_WriteConsoleInputW)(HANDLE a0,
                                           CONST INPUT_RECORD* a1,
                                           DWORD a2,
                                           LPDWORD a3)
    = WriteConsoleInputW;

BOOL (__stdcall * Real_WriteConsoleOutputA)(HANDLE a0,
                                            CONST CHAR_INFO* a1,
                                            COORD a2,
                                            COORD a3,
                                            PSMALL_RECT a4)
    = WriteConsoleOutputA;

BOOL (__stdcall * Real_WriteConsoleOutputAttribute)(HANDLE a0,
                                                    CONST WORD* a1,
                                                    DWORD a2,
                                                    COORD a3,
                                                    LPDWORD a4)
    = WriteConsoleOutputAttribute;

BOOL (__stdcall * Real_WriteConsoleOutputCharacterA)(HANDLE a0,
                                                     LPCSTR a1,
                                                     DWORD a2,
                                                     COORD a3,
                                                     LPDWORD a4)
    = WriteConsoleOutputCharacterA;

BOOL (__stdcall * Real_WriteConsoleOutputCharacterW)(HANDLE a0,
                                                     LPCWSTR a1,
                                                     DWORD a2,
                                                     COORD a3,
                                                     LPDWORD a4)
    = WriteConsoleOutputCharacterW;

BOOL (__stdcall * Real_WriteConsoleOutputW)(HANDLE a0,
                                            CONST CHAR_INFO* a1,
                                            COORD a2,
                                            COORD a3,
                                            PSMALL_RECT a4)
    = WriteConsoleOutputW;

BOOL (__stdcall * Real_WriteConsoleW)(HANDLE a0,
                                      CONST void* a1,
                                      DWORD a2,
                                      LPDWORD a3,
                                      LPVOID a4)
    = WriteConsoleW;

BOOL (__stdcall * Real_WriteFile)(HANDLE a0,
                                  LPCVOID a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPOVERLAPPED a4)
    = WriteFile;

BOOL (__stdcall * Real_WriteFileEx)(HANDLE a0,
                                    LPCVOID a1,
                                    DWORD a2,
                                    LPOVERLAPPED a3,
                                    LPOVERLAPPED_COMPLETION_ROUTINE a4)
    = WriteFileEx;

HRESULT (__stdcall * Real_WriteFmtUserTypeStg)(LPSTORAGE a0,
                                               CLIPFORMAT a1,
                                               LPOLESTR a2)
    = WriteFmtUserTypeStg;

BOOL (__stdcall * Real_WritePrivateProfileSectionA)(LPCSTR a0,
                                                    LPCSTR a1,
                                                    LPCSTR a2)
    = WritePrivateProfileSectionA;

BOOL (__stdcall * Real_WritePrivateProfileSectionW)(LPCWSTR a0,
                                                    LPCWSTR a1,
                                                    LPCWSTR a2)
    = WritePrivateProfileSectionW;

BOOL (__stdcall * Real_WritePrivateProfileStringA)(LPCSTR a0,
                                                   LPCSTR a1,
                                                   LPCSTR a2,
                                                   LPCSTR a3)
    = WritePrivateProfileStringA;

BOOL (__stdcall * Real_WritePrivateProfileStringW)(LPCWSTR a0,
                                                   LPCWSTR a1,
                                                   LPCWSTR a2,
                                                   LPCWSTR a3)
    = WritePrivateProfileStringW;

BOOL (__stdcall * Real_WritePrivateProfileStructA)(LPCSTR a0,
                                                   LPCSTR a1,
                                                   LPVOID a2,
                                                   UINT a3,
                                                   LPCSTR a4)
    = WritePrivateProfileStructA;

BOOL (__stdcall * Real_WritePrivateProfileStructW)(LPCWSTR a0,
                                                   LPCWSTR a1,
                                                   LPVOID a2,
                                                   UINT a3,
                                                   LPCWSTR a4)
    = WritePrivateProfileStructW;

#if _MSC_VER < 1300
BOOL (__stdcall * Real_WriteProcessMemory)(HANDLE a0,
                                           LPVOID a1,
                                           LPVOID a2,
                                           DWORD_PTR a3,
                                           PDWORD_PTR a4)
    = WriteProcessMemory;
#else
BOOL (__stdcall * Real_WriteProcessMemory)(HANDLE a0,
                                           LPVOID a1,
                                           LPCVOID a2,
                                           DWORD_PTR a3,
                                           PDWORD_PTR a4)
    = WriteProcessMemory;
#endif

BOOL (__stdcall * Real_WriteProfileSectionA)(LPCSTR a0,
                                             LPCSTR a1)
    = WriteProfileSectionA;

BOOL (__stdcall * Real_WriteProfileSectionW)(LPCWSTR a0,
                                             LPCWSTR a1)
    = WriteProfileSectionW;

BOOL (__stdcall * Real_WriteProfileStringA)(LPCSTR a0,
                                            LPCSTR a1,
                                            LPCSTR a2)
    = WriteProfileStringA;

BOOL (__stdcall * Real_WriteProfileStringW)(LPCWSTR a0,
                                            LPCWSTR a1,
                                            LPCWSTR a2)
    = WriteProfileStringW;

DWORD (__stdcall * Real_WriteTapemark)(HANDLE a0,
                                       DWORD a1,
                                       DWORD a2,
                                       BOOL a3)
    = WriteTapemark;

int (__stdcall * Real___WSAFDIsSet)(SOCKET a0,
                                    fd_set* a1)
    = __WSAFDIsSet;

long (__stdcall * Real__hread)(HFILE a0,
                               LPVOID a1,
                               long a2)
    = _hread;

long (__stdcall * Real__hwrite)(HFILE a0,
                                LPCSTR a1,
                                long a2)
    = _hwrite;

HFILE (__stdcall * Real__lclose)(HFILE a0)
    = _lclose;

HFILE (__stdcall * Real__lcreat)(LPCSTR a0,
                                 int a1)
    = _lcreat;

LONG (__stdcall * Real__llseek)(HFILE a0,
                                LONG a1,
                                int a2)
    = _llseek;

HFILE (__stdcall * Real__lopen)(LPCSTR a0,
                                int a1)
    = _lopen;

UINT (__stdcall * Real__lread)(HFILE a0,
                               LPVOID a1,
                               UINT a2)
    = _lread;

UINT (__stdcall * Real__lwrite)(HFILE a0,
                                LPCSTR a1,
                                UINT a2)
    = _lwrite;

SOCKET (__stdcall * Real_accept)(SOCKET a0,
                                 sockaddr* a1,
                                 int* a2)
    = accept;

int (__stdcall * Real_bind)(SOCKET a0,
                            CONST sockaddr* a1,
                            int a2)
    = bind;

int (__stdcall * Real_closesocket)(SOCKET a0)
    = closesocket;

int (__stdcall * Real_connect)(SOCKET a0,
                               CONST sockaddr* a1,
                               int a2)
    = connect;

hostent * (__stdcall * Real_gethostbyaddr)(CONST char* a0,
                                          int a1,
                                          int a2)
    = gethostbyaddr;

hostent * (__stdcall * Real_gethostbyname)(CONST char* a0)
    = gethostbyname;

int (__stdcall * Real_gethostname)(char* a0,
                                   int a1)
    = gethostname;

int (__stdcall * Real_getpeername)(SOCKET a0,
                                   sockaddr* a1,
                                   int* a2)
    = getpeername;

protoent * (__stdcall * Real_getprotobyname)(CONST char* a0)
    = getprotobyname;

protoent * (__stdcall * Real_getprotobynumber)(int a0)
    = getprotobynumber;

servent * (__stdcall * Real_getservbyname)(CONST char* a0,
                                           CONST char* a1)
    = getservbyname;

servent * (__stdcall * Real_getservbyport)(int a0,
                                           CONST char* a1)
    = getservbyport;

int (__stdcall * Real_getsockname)(SOCKET a0,
                                   sockaddr* a1,
                                   int* a2)
    = getsockname;

int (__stdcall * Real_getsockopt)(SOCKET a0,
                                  int a1,
                                  int a2,
                                  char* a3,
                                  int* a4)
    = getsockopt;

u_long (__stdcall * Real_htonl)(u_long a0)
    = htonl;

u_short (__stdcall * Real_htons)(u_short a0)
    = htons;

unsigned long (__stdcall * Real_inet_addr)(CONST char* a0)
    = inet_addr;

char * (__stdcall * Real_inet_ntoa)(in_addr a0)
    = inet_ntoa;

int (__stdcall * Real_ioctlsocket)(SOCKET a0,
                                   long a1,
                                   u_long* a2)
    = ioctlsocket;

void (__stdcall * Real_keybd_event)(BYTE a0,
                                    BYTE a1,
                                    DWORD a2,
                                    ULONG_PTR a3)
    = keybd_event;

int (__stdcall * Real_listen)(SOCKET a0,
                              int a1)
    = listen;

void (__stdcall * Real_mouse_event)(DWORD a0,
                                    DWORD a1,
                                    DWORD a2,
                                    DWORD a3,
                                    ULONG_PTR a4)
    = mouse_event;

u_long (__stdcall * Real_ntohl)(u_long a0)
    = ntohl;

u_short (__stdcall * Real_ntohs)(u_short a0)
    = ntohs;

int (__stdcall * Real_recv)(SOCKET a0,
                            char* a1,
                            int a2,
                            int a3)
    = recv;

int (__stdcall * Real_recvfrom)(SOCKET a0,
                                char* a1,
                                int a2,
                                int a3,
                                sockaddr* a4,
                                int* a5)
    = recvfrom;

int (__stdcall * Real_select)(int a0,
                              fd_set* a1,
                              fd_set* a2,
                              fd_set* a3,
                              CONST timeval* a4)
    = select;

int (__stdcall * Real_send)(SOCKET a0,
                            CONST char* a1,
                            int a2,
                            int a3)
    = send;

int (__stdcall * Real_sendto)(SOCKET a0,
                              CONST char* a1,
                              int a2,
                              int a3,
                              CONST sockaddr* a4,
                              int a5)
    = sendto;

int (__stdcall * Real_setsockopt)(SOCKET a0,
                                  int a1,
                                  int a2,
                                  CONST char* a3,
                                  int a4)
    = setsockopt;

int (__stdcall * Real_shutdown)(SOCKET a0,
                                int a1)
    = shutdown;

SOCKET (__stdcall * Real_socket)(int a0,
                                 int a1,
                                 int a2)
    = socket;

///////////////////////////////////////////////////////////////////// Detours.
//

int __stdcall Mine_AbortDoc(HDC a0)
{
    _PrintEnter("AbortDoc(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AbortDoc(a0);
    } __finally {
        _PrintExit("AbortDoc() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AbortPath(HDC a0)
{
    _PrintEnter("AbortPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_AbortPath(a0);
    } __finally {
        _PrintExit("AbortPath() -> %x\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_ActivateKeyboardLayout(HKL a0,
                                          UINT a1)
{
    _PrintEnter("ActivateKeyboardLayout(%p,%p)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_ActivateKeyboardLayout(a0, a1);
    } __finally {
        _PrintExit("ActivateKeyboardLayout(,) -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_AddAtomA(LPCSTR a0)
{
    _PrintEnter("AddAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_AddAtomA(a0);
    } __finally {
        _PrintExit("AddAtomA() -> %x\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_AddAtomW(LPCWSTR a0)
{
    _PrintEnter("AddAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_AddAtomW(a0);
    } __finally {
        _PrintExit("AddAtomW() -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_AddFontResourceA(LPCSTR a0)
{
    _PrintEnter("AddFontResourceA(%hs)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AddFontResourceA(a0);
    } __finally {
        _PrintExit("AddFontResourceA() -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_AddFontResourceW(LPCWSTR a0)
{
    _PrintEnter("AddFontResourceW(%ls)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AddFontResourceW(a0);
    } __finally {
        _PrintExit("AddFontResourceW() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AdjustWindowRect(LPRECT a0,
                                     DWORD a1,
                                     BOOL a2)
{
    _PrintEnter("AdjustWindowRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_AdjustWindowRect(a0, a1, a2);
    } __finally {
        _PrintExit("AdjustWindowRect(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AdjustWindowRectEx(LPRECT a0,
                                       DWORD a1,
                                       BOOL a2,
                                       DWORD a3)
{
    _PrintEnter("AdjustWindowRectEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AdjustWindowRectEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AdjustWindowRectEx(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AllocConsole(void)
{
    _PrintEnter("AllocConsole()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AllocConsole();
    } __finally {
        _PrintExit("AllocConsole() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AngleArc(HDC a0,
                             int a1,
                             int a2,
                             DWORD a3,
                             FLOAT a4,
                             FLOAT a5)
{
    _PrintEnter("AngleArc(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_AngleArc(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("AngleArc(,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AnimatePalette(HPALETTE a0,
                                   UINT a1,
                                   UINT a2,
                                   PALETTEENTRY* a3)
{
    _PrintEnter("AnimatePalette(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AnimatePalette(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AnimatePalette(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AnyPopup(void)
{
    _PrintEnter("AnyPopup()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AnyPopup();
    } __finally {
        _PrintExit("AnyPopup() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AppendMenuA(HMENU a0,
                                UINT a1,
                                UINT_PTR a2,
                                LPCSTR a3)
{
    _PrintEnter("AppendMenuA(%p,%p,%p,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AppendMenuA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AppendMenuA(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AppendMenuW(HMENU a0,
                                UINT a1,
                                UINT_PTR a2,
                                LPCWSTR a3)
{
    _PrintEnter("AppendMenuW(%p,%p,%p,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AppendMenuW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AppendMenuW(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Arc(HDC a0,
                        int a1,
                        int a2,
                        int a3,
                        int a4,
                        int a5,
                        int a6,
                        int a7,
                        int a8)
{
    _PrintEnter("Arc(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Arc(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Arc(,,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ArcTo(HDC a0,
                          int a1,
                          int a2,
                          int a3,
                          int a4,
                          int a5,
                          int a6,
                          int a7,
                          int a8)
{
    _PrintEnter("ArcTo(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_ArcTo(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("ArcTo(,,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AreFileApisANSI(void)
{
    _PrintEnter("AreFileApisANSI()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AreFileApisANSI();
    } __finally {
        _PrintExit("AreFileApisANSI() -> %x\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_ArrangeIconicWindows(HWND a0)
{
    _PrintEnter("ArrangeIconicWindows(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_ArrangeIconicWindows(a0);
    } __finally {
        _PrintExit("ArrangeIconicWindows() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AttachThreadInput(DWORD a0,
                                      DWORD a1,
                                      BOOL a2)
{
    _PrintEnter("AttachThreadInput(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_AttachThreadInput(a0, a1, a2);
    } __finally {
        _PrintExit("AttachThreadInput(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupRead(HANDLE a0,
                               LPBYTE a1,
                               DWORD a2,
                               LPDWORD a3,
                               BOOL a4,
                               BOOL a5,
                               LPVOID* a6)
{
    _PrintEnter("BackupRead(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_BackupRead(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("BackupRead(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupSeek(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               LPDWORD a3,
                               LPDWORD a4,
                               LPVOID* a5)
{
    _PrintEnter("BackupSeek(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_BackupSeek(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("BackupSeek(,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupWrite(HANDLE a0,
                                LPBYTE a1,
                                DWORD a2,
                                LPDWORD a3,
                                BOOL a4,
                                BOOL a5,
                                LPVOID* a6)
{
    _PrintEnter("BackupWrite(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_BackupWrite(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("BackupWrite(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Beep(DWORD a0,
                         DWORD a1)
{
    _PrintEnter("Beep(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_Beep(a0, a1);
    } __finally {
        _PrintExit("Beep(,) -> %x\n", rv);
    };
    return rv;
}

HDWP __stdcall Mine_BeginDeferWindowPos(int a0)
{
    _PrintEnter("BeginDeferWindowPos(%p)\n", a0);

    HDWP rv = 0;
    __try {
        rv = Real_BeginDeferWindowPos(a0);
    } __finally {
        _PrintExit("BeginDeferWindowPos() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_BeginPaint(HWND a0,
                              LPPAINTSTRUCT a1)
{
    _PrintEnter("BeginPaint(%p,%p)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_BeginPaint(a0, a1);
    } __finally {
        _PrintExit("BeginPaint(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BeginPath(HDC a0)
{
    _PrintEnter("BeginPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_BeginPath(a0);
    } __finally {
        _PrintExit("BeginPath() -> %x\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_BeginUpdateResourceA(LPCSTR a0,
                                           BOOL a1)
{
    _PrintEnter("BeginUpdateResourceA(%hs,%p)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_BeginUpdateResourceA(a0, a1);
    } __finally {
        _PrintExit("BeginUpdateResourceA(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_BeginUpdateResourceW(LPCWSTR a0,
                                           BOOL a1)
{
    _PrintEnter("BeginUpdateResourceW(%ls,%p)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_BeginUpdateResourceW(a0, a1);
    } __finally {
        _PrintExit("BeginUpdateResourceW(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_BindMoniker(IMoniker* a0,
                                   DWORD a1,
                                   CONST IID& a2,
                                   LPVOID* a3)
{
    _PrintEnter("BindMoniker(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_BindMoniker(a0, a1, a2, a3);
    } __finally {
        _PrintExit("BindMoniker(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BitBlt(HDC a0,
                           int a1,
                           int a2,
                           int a3,
                           int a4,
                           HDC a5,
                           int a6,
                           int a7,
                           DWORD a8)
{
    _PrintEnter("BitBlt(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_BitBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("BitBlt(,,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BringWindowToTop(HWND a0)
{
    _PrintEnter("BringWindowToTop(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_BringWindowToTop(a0);
    } __finally {
        _PrintExit("BringWindowToTop() -> %x\n", rv);
    };
    return rv;
}

long __stdcall Mine_BroadcastSystemMessageA(DWORD a0,
                                            LPDWORD a1,
                                            UINT a2,
                                            WPARAM a3,
                                            LPARAM a4)
{
    _PrintEnter("BroadcastSystemMessageA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    long rv = 0;
    __try {
        rv = Real_BroadcastSystemMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("BroadcastSystemMessageA(,,,,) -> %x\n", rv);
    };
    return rv;
}

long __stdcall Mine_BroadcastSystemMessageW(DWORD a0,
                                            LPDWORD a1,
                                            UINT a2,
                                            WPARAM a3,
                                            LPARAM a4)
{
    _PrintEnter("BroadcastSystemMessageW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    long rv = 0;
    __try {
        rv = Real_BroadcastSystemMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("BroadcastSystemMessageW(,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBA(LPCSTR a0,
                                  LPDCB a1)
{
    _PrintEnter("BuildCommDCBA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBA(a0, a1);
    } __finally {
        _PrintExit("BuildCommDCBA(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBAndTimeoutsA(LPCSTR a0,
                                             LPDCB a1,
                                             LPCOMMTIMEOUTS a2)
{
    _PrintEnter("BuildCommDCBAndTimeoutsA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBAndTimeoutsA(a0, a1, a2);
    } __finally {
        _PrintExit("BuildCommDCBAndTimeoutsA(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBAndTimeoutsW(LPCWSTR a0,
                                             LPDCB a1,
                                             LPCOMMTIMEOUTS a2)
{
    _PrintEnter("BuildCommDCBAndTimeoutsW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBAndTimeoutsW(a0, a1, a2);
    } __finally {
        _PrintExit("BuildCommDCBAndTimeoutsW(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBW(LPCWSTR a0,
                                  LPDCB a1)
{
    _PrintEnter("BuildCommDCBW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBW(a0, a1);
    } __finally {
        _PrintExit("BuildCommDCBW(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CLSIDFromProgID(LPCOLESTR a0,
                                       LPGUID a1)
{
    _PrintEnter("CLSIDFromProgID(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CLSIDFromProgID(a0, a1);
    } __finally {
        _PrintExit("CLSIDFromProgID(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CLSIDFromString(LPOLESTR a0,
                                       LPGUID a1)
{
    _PrintEnter("CLSIDFromString(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CLSIDFromString(a0, a1);
    } __finally {
        _PrintExit("CLSIDFromString(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallMsgFilterA(LPMSG a0,
                                   int a1)
{
    _PrintEnter("CallMsgFilterA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CallMsgFilterA(a0, a1);
    } __finally {
        _PrintExit("CallMsgFilterA(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallMsgFilterW(LPMSG a0,
                                   int a1)
{
    _PrintEnter("CallMsgFilterW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CallMsgFilterW(a0, a1);
    } __finally {
        _PrintExit("CallMsgFilterW(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallNamedPipeA(LPCSTR a0,
                                   LPVOID a1,
                                   DWORD a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5,
                                   DWORD a6)
{
    _PrintEnter("CallNamedPipeA(%hs,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_CallNamedPipeA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CallNamedPipeA(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallNamedPipeW(LPCWSTR a0,
                                   LPVOID a1,
                                   DWORD a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5,
                                   DWORD a6)
{
    _PrintEnter("CallNamedPipeW(%ls,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_CallNamedPipeW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CallNamedPipeW(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallNextHookEx(HHOOK a0,
                                      int a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("CallNextHookEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_CallNextHookEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CallNextHookEx(,,,) -> %x\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallWindowProcA(WNDPROC a0,
                                       HWND a1,
                                       UINT a2,
                                       WPARAM a3,
                                       LPARAM a4)
{
    _PrintEnter("CallWindowProcA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_CallWindowProcA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CallWindowProcA(,,,,) -> %x\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallWindowProcW(WNDPROC a0,
                                       HWND a1,
                                       UINT a2,
                                       WPARAM a3,
                                       LPARAM a4)
{
    _PrintEnter("CallWindowProcW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_CallWindowProcW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CallWindowProcW(,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelDC(HDC a0)
{
    _PrintEnter("CancelDC(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelDC(a0);
    } __finally {
        _PrintExit("CancelDC() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelIo(HANDLE a0)
{
    _PrintEnter("CancelIo(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelIo(a0);
    } __finally {
        _PrintExit("CancelIo() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelWaitableTimer(HANDLE a0)
{
    _PrintEnter("CancelWaitableTimer(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelWaitableTimer(a0);
    } __finally {
        _PrintExit("CancelWaitableTimer() -> %x\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_CascadeWindows(HWND a0,
                                   UINT a1,
                                   RECT* a2,
                                   UINT a3,
                                   struct HWND__** a4)
{
    _PrintEnter("CascadeWindows(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    WORD rv = 0;
    __try {
        rv = Real_CascadeWindows(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CascadeWindows(,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeClipboardChain(HWND a0,
                                         HWND a1)
{
    _PrintEnter("ChangeClipboardChain(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeClipboardChain(a0, a1);
    } __finally {
        _PrintExit("ChangeClipboardChain(,) -> %x\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsA(LPDEVMODEA a0,
                                           DWORD a1)
{
    _PrintEnter("ChangeDisplaySettingsA(%p,%p)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsA(a0, a1);
    } __finally {
        _PrintExit("ChangeDisplaySettingsA(,) -> %x\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsExA(LPCSTR a0,
                                             LPDEVMODEA a1,
                                             HWND a2,
                                             DWORD a3,
                                             LPVOID a4)
{
    _PrintEnter("ChangeDisplaySettingsExA(%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeDisplaySettingsExA(,,,,) -> %x\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsExW(LPCWSTR a0,
                                             LPDEVMODEW a1,
                                             HWND a2,
                                             DWORD a3,
                                             LPVOID a4)
{
    _PrintEnter("ChangeDisplaySettingsExW(%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeDisplaySettingsExW(,,,,) -> %x\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsW(LPDEVMODEW a0,
                                           DWORD a1)
{
    _PrintEnter("ChangeDisplaySettingsW(%p,%p)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsW(a0, a1);
    } __finally {
        _PrintExit("ChangeDisplaySettingsW(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeMenuA(HMENU a0,
                                UINT a1,
                                LPCSTR a2,
                                UINT a3,
                                UINT a4)
{
    _PrintEnter("ChangeMenuA(%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeMenuA(,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeMenuW(HMENU a0,
                                UINT a1,
                                LPCWSTR a2,
                                UINT a3,
                                UINT a4)
{
    _PrintEnter("ChangeMenuW(%p,%p,%ls,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeMenuW(,,,,) -> %x\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharLowerA(LPSTR a0)
{
    _PrintEnter("CharLowerA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharLowerA(a0);
    } __finally {
        _PrintExit("CharLowerA(%hs) -> %hs\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharLowerBuffA(LPSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharLowerBuffA(%hs,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharLowerBuffA(a0, a1);
    } __finally {
        _PrintExit("CharLowerBuffA(%hs,) -> %x\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharLowerBuffW(LPWSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharLowerBuffW(%ls,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharLowerBuffW(a0, a1);
    } __finally {
        _PrintExit("CharLowerBuffW(%ls,) -> %x\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharLowerW(LPWSTR a0)
{
    _PrintEnter("CharLowerW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharLowerW(a0);
    } __finally {
        _PrintExit("CharLowerW(%ls) -> %ls\n", a0, rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharNextA(LPCSTR a0)
{
    _PrintEnter("CharNextA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharNextA(a0);
    } __finally {
        _PrintExit("CharNextA() -> %hs\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharNextExA(WORD a0,
                                 LPCSTR a1,
                                 DWORD a2)
{
    _PrintEnter("CharNextExA(%p,%hs,%p)\n", a0, a1, a2);

    LPSTR rv = 0;
    __try {
        rv = Real_CharNextExA(a0, a1, a2);
    } __finally {
        _PrintExit("CharNextExA(,,) -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharNextW(LPCWSTR a0)
{
    _PrintEnter("CharNextW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharNextW(a0);
    } __finally {
        _PrintExit("CharNextW() -> %ls\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharPrevA(LPCSTR a0,
                               LPCSTR a1)
{
    _PrintEnter("CharPrevA(%hs,%hs)\n", a0, a1);

    LPSTR rv = 0;
    __try {
        rv = Real_CharPrevA(a0, a1);
    } __finally {
        _PrintExit("CharPrevA(,) -> %hs\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharPrevExA(WORD a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 DWORD a3)
{
    _PrintEnter("CharPrevExA(%p,%hs,%hs,%p)\n", a0, a1, a2, a3);

    LPSTR rv = 0;
    __try {
        rv = Real_CharPrevExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CharPrevExA(,,,) -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharPrevW(LPCWSTR a0,
                                LPCWSTR a1)
{
    _PrintEnter("CharPrevW(%ls,%ls)\n", a0, a1);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharPrevW(a0, a1);
    } __finally {
        _PrintExit("CharPrevW(,) -> %ls\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemA(LPCSTR a0,
                               LPSTR a1)
{
    _PrintEnter("CharToOemA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemA(a0, a1);
    } __finally {
        _PrintExit("CharToOemA(,%hs) -> %x\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemBuffA(LPCSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("CharToOemBuffA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemBuffA(a0, a1, a2);
    } __finally {
        _PrintExit("CharToOemBuffA(,%hs,) -> %x\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemBuffW(LPCWSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("CharToOemBuffW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemBuffW(a0, a1, a2);
    } __finally {
        _PrintExit("CharToOemBuffW(,%hs,) -> %x\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemW(LPCWSTR a0,
                               LPSTR a1)
{
    _PrintEnter("CharToOemW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemW(a0, a1);
    } __finally {
        _PrintExit("CharToOemW(,%hs) -> %x\n", a1, rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharUpperA(LPSTR a0)
{
    _PrintEnter("CharUpperA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharUpperA(a0);
    } __finally {
        _PrintExit("CharUpperA(%hs) -> %hs\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharUpperBuffA(LPSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharUpperBuffA(%hs,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharUpperBuffA(a0, a1);
    } __finally {
        _PrintExit("CharUpperBuffA(%hs,) -> %x\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharUpperBuffW(LPWSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharUpperBuffW(%ls,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharUpperBuffW(a0, a1);
    } __finally {
        _PrintExit("CharUpperBuffW(%ls,) -> %x\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharUpperW(LPWSTR a0)
{
    _PrintEnter("CharUpperW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharUpperW(a0);
    } __finally {
        _PrintExit("CharUpperW(%ls) -> %ls\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckColorsInGamut(
                                       HDC a0,
#ifdef GDIPLUS_TS_QUERYVER
                                       LPRGBTRIPLE a1,
#else
                                       LPVOID a1,
#endif
                                       LPVOID a2,
                                       DWORD a3
                                      )
{
    _PrintEnter("CheckColorsInGamut(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CheckColorsInGamut(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CheckColorsInGamut(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckDlgButton(HWND a0,
                                   int a1,
                                   UINT a2)
{
    _PrintEnter("CheckDlgButton(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CheckDlgButton(a0, a1, a2);
    } __finally {
        _PrintExit("CheckDlgButton(,,) -> %x\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CheckMenuItem(HMENU a0,
                                   UINT a1,
                                   UINT a2)
{
    _PrintEnter("CheckMenuItem(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_CheckMenuItem(a0, a1, a2);
    } __finally {
        _PrintExit("CheckMenuItem(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckMenuRadioItem(HMENU a0,
                                       UINT a1,
                                       UINT a2,
                                       UINT a3,
                                       UINT a4)
{
    _PrintEnter("CheckMenuRadioItem(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_CheckMenuRadioItem(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CheckMenuRadioItem(,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckRadioButton(HWND a0,
                                     int a1,
                                     int a2,
                                     int a3)
{
    _PrintEnter("CheckRadioButton(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CheckRadioButton(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CheckRadioButton(,,,) -> %x\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_ChildWindowFromPoint(HWND a0,
                                         POINT a1)
{
    _PrintEnter("ChildWindowFromPoint(%p,%p)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_ChildWindowFromPoint(a0, a1);
    } __finally {
        _PrintExit("ChildWindowFromPoint(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_ChildWindowFromPointEx(HWND a0,
                                           POINT a1,
                                           UINT a2)
{
    _PrintEnter("ChildWindowFromPointEx(%p,%p,%p)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_ChildWindowFromPointEx(a0, a1, a2);
    } __finally {
        _PrintExit("ChildWindowFromPointEx(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ChoosePixelFormat(HDC a0,
                                     PIXELFORMATDESCRIPTOR* a1)
{
    _PrintEnter("ChoosePixelFormat(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ChoosePixelFormat(a0, a1);
    } __finally {
        _PrintExit("ChoosePixelFormat(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Chord(HDC a0,
                          int a1,
                          int a2,
                          int a3,
                          int a4,
                          int a5,
                          int a6,
                          int a7,
                          int a8)
{
    _PrintEnter("Chord(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Chord(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Chord(,,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClearCommBreak(HANDLE a0)
{
    _PrintEnter("ClearCommBreak(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ClearCommBreak(a0);
    } __finally {
        _PrintExit("ClearCommBreak() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClearCommError(HANDLE a0,
                                   LPDWORD a1,
                                   LPCOMSTAT a2)
{
    _PrintEnter("ClearCommError(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ClearCommError(a0, a1, a2);
    } __finally {
        _PrintExit("ClearCommError(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClientToScreen(HWND a0,
                                   POINT* a1)
{
    _PrintEnter("ClientToScreen(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ClientToScreen(a0, a1);
    } __finally {
        _PrintExit("ClientToScreen(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClipCursor(RECT* a0)
{
    _PrintEnter("ClipCursor(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ClipCursor(a0);
    } __finally {
        _PrintExit("ClipCursor() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseClipboard(void)
{
    _PrintEnter("CloseClipboard()\n");

    BOOL rv = 0;
    __try {
        rv = Real_CloseClipboard();
    } __finally {
        _PrintExit("CloseClipboard() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseDesktop(HDESK a0)
{
    _PrintEnter("CloseDesktop(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseDesktop(a0);
    } __finally {
        _PrintExit("CloseDesktop() -> %x\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CloseEnhMetaFile(HDC a0)
{
    _PrintEnter("CloseEnhMetaFile(%p)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CloseEnhMetaFile(a0);
    } __finally {
        _PrintExit("CloseEnhMetaFile() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseFigure(HDC a0)
{
    _PrintEnter("CloseFigure(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseFigure(a0);
    } __finally {
        _PrintExit("CloseFigure() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseHandle(HANDLE a0)
{
    _PrintEnter("CloseHandle(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseHandle(a0);
    } __finally {
        _PrintExit("CloseHandle() -> %x\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CloseMetaFile(HDC a0)
{
    _PrintEnter("CloseMetaFile(%p)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CloseMetaFile(a0);
    } __finally {
        _PrintExit("CloseMetaFile() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseWindow(HWND a0)
{
    _PrintEnter("CloseWindow(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseWindow(a0);
    } __finally {
        _PrintExit("CloseWindow() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseWindowStation(HWINSTA a0)
{
    _PrintEnter("CloseWindowStation(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseWindowStation(a0);
    } __finally {
        _PrintExit("CloseWindowStation() -> %x\n", rv);
    };
    return rv;
}

ULONG __stdcall Mine_CoAddRefServerProcess(void)
{
    _PrintEnter("CoAddRefServerProcess()\n");

    ULONG rv = 0;
    __try {
        rv = Real_CoAddRefServerProcess();
    } __finally {
        _PrintExit("CoAddRefServerProcess() -> %x\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CoBuildVersion(void)
{
    _PrintEnter("CoBuildVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_CoBuildVersion();
    } __finally {
        _PrintExit("CoBuildVersion() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCopyProxy(IUnknown* a0,
                                   IUnknown** a1)
{
    _PrintEnter("CoCopyProxy(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCopyProxy(a0, a1);
    } __finally {
        _PrintExit("CoCopyProxy(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateFreeThreadedMarshaler(LPUNKNOWN a0,
                                                     LPUNKNOWN* a1)
{
    _PrintEnter("CoCreateFreeThreadedMarshaler(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateFreeThreadedMarshaler(a0, a1);
    } __finally {
        _PrintExit("CoCreateFreeThreadedMarshaler(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateGuid(GUID* a0)
{
    _PrintEnter("CoCreateGuid(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateGuid(a0);
    } __finally {
        _PrintExit("CoCreateGuid() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateInstance(CONST IID& a0,
                                        LPUNKNOWN a1,
                                        DWORD a2,
                                        CONST IID& a3,
                                        LPVOID* a4)
{
    _PrintEnter("CoCreateInstance(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateInstance(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoCreateInstance(,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateInstanceEx(CONST IID& a0,
                                          IUnknown* a1,
                                          DWORD a2,
                                          COSERVERINFO* a3,
                                          DWORD a4,
                                          MULTI_QI* a5)
{
    _PrintEnter("CoCreateInstanceEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateInstanceEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoCreateInstanceEx(,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoDisconnectObject(LPUNKNOWN a0,
                                          DWORD a1)
{
    _PrintEnter("CoDisconnectObject(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoDisconnectObject(a0, a1);
    } __finally {
        _PrintExit("CoDisconnectObject(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoDosDateTimeToFileTime(WORD a0,
                                            WORD a1,
                                            FILETIME* a2)
{
    _PrintEnter("CoDosDateTimeToFileTime(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CoDosDateTimeToFileTime(a0, a1, a2);
    } __finally {
        _PrintExit("CoDosDateTimeToFileTime(,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoFileTimeNow(FILETIME* a0)
{
    _PrintEnter("CoFileTimeNow(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoFileTimeNow(a0);
    } __finally {
        _PrintExit("CoFileTimeNow() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoFileTimeToDosDateTime(FILETIME* a0,
                                            LPWORD a1,
                                            LPWORD a2)
{
    _PrintEnter("CoFileTimeToDosDateTime(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CoFileTimeToDosDateTime(a0, a1, a2);
    } __finally {
        _PrintExit("CoFileTimeToDosDateTime(,,) -> %x\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoFreeAllLibraries(void)
{
    _PrintEnter("CoFreeAllLibraries()\n");

    __try {
        Real_CoFreeAllLibraries();
    } __finally {
        _PrintExit("CoFreeAllLibraries() ->\n");
    };
}

void __stdcall Mine_CoFreeLibrary(HINSTANCE a0)
{
    _PrintEnter("CoFreeLibrary(%p)\n", a0);

    __try {
        Real_CoFreeLibrary(a0);
    } __finally {
        _PrintExit("CoFreeLibrary() ->\n");
    };
}

void __stdcall Mine_CoFreeUnusedLibraries(void)
{
    _PrintEnter("CoFreeUnusedLibraries()\n");

    __try {
        Real_CoFreeUnusedLibraries();
    } __finally {
        _PrintExit("CoFreeUnusedLibraries() ->\n");
    };
}

HRESULT __stdcall Mine_CoGetCallContext(CONST IID& a0,
                                        void** a1)
{
    _PrintEnter("CoGetCallContext(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetCallContext(a0, a1);
    } __finally {
        _PrintExit("CoGetCallContext(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetClassObject(CONST IID& a0,
                                        DWORD a1,
                                        LPVOID a2,
                                        CONST IID& a3,
                                        LPVOID* a4)
{
    _PrintEnter("CoGetClassObject(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetClassObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoGetClassObject(,,,,) -> %x\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CoGetCurrentProcess(void)
{
    _PrintEnter("CoGetCurrentProcess()\n");

    DWORD rv = 0;
    __try {
        rv = Real_CoGetCurrentProcess();
    } __finally {
        _PrintExit("CoGetCurrentProcess() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInstanceFromFile(COSERVERINFO* a0,
                                             CLSID* a1,
                                             IUnknown* a2,
                                             DWORD a3,
                                             DWORD a4,
                                             OLECHAR* a5,
                                             DWORD a6,
                                             MULTI_QI* a7)
{
    _PrintEnter("CoGetInstanceFromFile(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInstanceFromFile(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoGetInstanceFromFile(,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInstanceFromIStorage(COSERVERINFO* a0,
                                                 CLSID* a1,
                                                 IUnknown* a2,
                                                 DWORD a3,
                                                 IStorage* a4,
                                                 DWORD a5,
                                                 MULTI_QI* a6)
{
    _PrintEnter("CoGetInstanceFromIStorage(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInstanceFromIStorage(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CoGetInstanceFromIStorage(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInterfaceAndReleaseStream(LPSTREAM a0,
                                                      CONST IID& a1,
                                                      LPVOID* a2)
{
    _PrintEnter("CoGetInterfaceAndReleaseStream(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInterfaceAndReleaseStream(a0, a1, a2);
    } __finally {
        _PrintExit("CoGetInterfaceAndReleaseStream(,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetMalloc(DWORD a0,
                                   IMalloc** a1)
{
    _PrintEnter("CoGetMalloc(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetMalloc(a0, a1);
    } __finally {
        _PrintExit("CoGetMalloc(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetMarshalSizeMax(ULONG* a0,
                                           CONST IID& a1,
                                           LPUNKNOWN a2,
                                           DWORD a3,
                                           LPVOID a4,
                                           DWORD a5)
{
    _PrintEnter("CoGetMarshalSizeMax(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetMarshalSizeMax(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoGetMarshalSizeMax(,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetObject(LPCWSTR a0,
                                   BIND_OPTS* a1,
                                   CONST IID& a2,
                                   void** a3)
{
    _PrintEnter("CoGetObject(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetObject(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CoGetObject(,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetPSClsid(CONST IID& a0,
                                    CLSID* a1)
{
    _PrintEnter("CoGetPSClsid(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetPSClsid(a0, a1);
    } __finally {
        _PrintExit("CoGetPSClsid(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetStandardMarshal(CONST IID& a0,
                                            LPUNKNOWN a1,
                                            DWORD a2,
                                            LPVOID a3,
                                            DWORD a4,
                                            IMarshal** a5)
{
    _PrintEnter("CoGetStandardMarshal(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetStandardMarshal(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoGetStandardMarshal(,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetStdMarshalEx(LPUNKNOWN a0,
                                         DWORD a1,
                                         LPUNKNOWN* a2)
{
    _PrintEnter("CoGetStdMarshalEx(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetStdMarshalEx(a0, a1, a2);
    } __finally {
        _PrintExit("CoGetStdMarshalEx(,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetTreatAsClass(CONST IID& a0,
                                         LPGUID a1)
{
    _PrintEnter("CoGetTreatAsClass(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetTreatAsClass(a0, a1);
    } __finally {
        _PrintExit("CoGetTreatAsClass(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoImpersonateClient(void)
{
    _PrintEnter("CoImpersonateClient()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoImpersonateClient();
    } __finally {
        _PrintExit("CoImpersonateClient() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitialize(LPVOID a0)
{
    _PrintEnter("CoInitialize(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitialize(a0);
    } __finally {
        _PrintExit("CoInitialize() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitializeEx(LPVOID a0,
                                      DWORD a1)
{
    _PrintEnter("CoInitializeEx(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitializeEx(a0, a1);
    } __finally {
        _PrintExit("CoInitializeEx(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitializeSecurity(PSECURITY_DESCRIPTOR a0,
                                            LONG a1,
                                            SOLE_AUTHENTICATION_SERVICE* a2,
                                            void* a3,
                                            DWORD a4,
                                            DWORD a5,
                                            void* a6,
                                            DWORD a7,
                                            void* a8)
{
    _PrintEnter("CoInitializeSecurity(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitializeSecurity(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("CoInitializeSecurity(,,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoIsHandlerConnected(LPUNKNOWN a0)
{
    _PrintEnter("CoIsHandlerConnected(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CoIsHandlerConnected(a0);
    } __finally {
        _PrintExit("CoIsHandlerConnected() -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoIsOle1Class(CONST IID& a0)
{
    _PrintEnter("CoIsOle1Class(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CoIsOle1Class(a0);
    } __finally {
        _PrintExit("CoIsOle1Class() -> %x\n", rv);
    };
    return rv;
}

HINSTANCE __stdcall Mine_CoLoadLibrary(LPOLESTR a0,
                                       BOOL a1)
{
    _PrintEnter("CoLoadLibrary(%p,%p)\n", a0, a1);

    HINSTANCE rv = 0;
    __try {
        rv = Real_CoLoadLibrary(a0, a1);
    } __finally {
        _PrintExit("CoLoadLibrary(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoLockObjectExternal(LPUNKNOWN a0,
                                            BOOL a1,
                                            BOOL a2)
{
    _PrintEnter("CoLockObjectExternal(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoLockObjectExternal(a0, a1, a2);
    } __finally {
        _PrintExit("CoLockObjectExternal(,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalHresult(LPSTREAM a0,
                                        HRESULT a1)
{
    _PrintEnter("CoMarshalHresult(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalHresult(a0, a1);
    } __finally {
        _PrintExit("CoMarshalHresult(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalInterThreadInterfaceInStream(CONST IID& a0,
                                                             LPUNKNOWN a1,
                                                             LPSTREAM* a2)
{
    _PrintEnter("CoMarshalInterThreadInterfaceInStream(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalInterThreadInterfaceInStream(a0, a1, a2);
    } __finally {
        _PrintExit("CoMarshalInterThreadInterfaceInStream(,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalInterface(LPSTREAM a0,
                                          CONST IID& a1,
                                          LPUNKNOWN a2,
                                          DWORD a3,
                                          LPVOID a4,
                                          DWORD a5)
{
    _PrintEnter("CoMarshalInterface(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalInterface(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoMarshalInterface(,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryAuthenticationServices(DWORD* a0,
                                                     SOLE_AUTHENTICATION_SERVICE** a1)
{
    _PrintEnter("CoQueryAuthenticationServices(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryAuthenticationServices(a0, a1);
    } __finally {
        _PrintExit("CoQueryAuthenticationServices(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryClientBlanket(DWORD* a0,
                                            DWORD* a1,
                                            OLECHAR** a2,
                                            DWORD* a3,
                                            DWORD* a4,
                                            RPC_AUTHZ_HANDLE* a5,
                                            DWORD* a6)
{
    _PrintEnter("CoQueryClientBlanket(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryClientBlanket(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CoQueryClientBlanket(,,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryProxyBlanket(IUnknown* a0,
                                           DWORD* a1,
                                           DWORD* a2,
                                           OLECHAR** a3,
                                           DWORD* a4,
                                           DWORD* a5,
                                           RPC_AUTH_IDENTITY_HANDLE* a6,
                                           DWORD* a7)
{
    _PrintEnter("CoQueryProxyBlanket(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryProxyBlanket(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoQueryProxyBlanket(,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterChannelHook(CONST GUID& a0,
                                             IChannelHook* a1)
{
    _PrintEnter("CoRegisterChannelHook(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterChannelHook(a0, a1);
    } __finally {
        _PrintExit("CoRegisterChannelHook(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterClassObject(CONST IID& a0,
                                             LPUNKNOWN a1,
                                             DWORD a2,
                                             DWORD a3,
                                             LPDWORD a4)
{
    _PrintEnter("CoRegisterClassObject(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterClassObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoRegisterClassObject(,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterMallocSpy(IMallocSpy* a0)
{
    _PrintEnter("CoRegisterMallocSpy(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterMallocSpy(a0);
    } __finally {
        _PrintExit("CoRegisterMallocSpy() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterMessageFilter(LPMESSAGEFILTER a0,
                                               LPMESSAGEFILTER* a1)
{
    _PrintEnter("CoRegisterMessageFilter(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterMessageFilter(a0, a1);
    } __finally {
        _PrintExit("CoRegisterMessageFilter(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterPSClsid(CONST IID& a0,
                                         CONST IID& a1)
{
    _PrintEnter("CoRegisterPSClsid(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterPSClsid(a0, a1);
    } __finally {
        _PrintExit("CoRegisterPSClsid(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterSurrogate(LPSURROGATE a0)
{
    _PrintEnter("CoRegisterSurrogate(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterSurrogate(a0);
    } __finally {
        _PrintExit("CoRegisterSurrogate() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoReleaseMarshalData(LPSTREAM a0)
{
    _PrintEnter("CoReleaseMarshalData(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoReleaseMarshalData(a0);
    } __finally {
        _PrintExit("CoReleaseMarshalData() -> %x\n", rv);
    };
    return rv;
}

ULONG __stdcall Mine_CoReleaseServerProcess(void)
{
    _PrintEnter("CoReleaseServerProcess()\n");

    ULONG rv = 0;
    __try {
        rv = Real_CoReleaseServerProcess();
    } __finally {
        _PrintExit("CoReleaseServerProcess() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoResumeClassObjects(void)
{
    _PrintEnter("CoResumeClassObjects()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoResumeClassObjects();
    } __finally {
        _PrintExit("CoResumeClassObjects() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevertToSelf(void)
{
    _PrintEnter("CoRevertToSelf()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevertToSelf();
    } __finally {
        _PrintExit("CoRevertToSelf() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevokeClassObject(DWORD a0)
{
    _PrintEnter("CoRevokeClassObject(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevokeClassObject(a0);
    } __finally {
        _PrintExit("CoRevokeClassObject() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevokeMallocSpy(void)
{
    _PrintEnter("CoRevokeMallocSpy()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevokeMallocSpy();
    } __finally {
        _PrintExit("CoRevokeMallocSpy() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSetProxyBlanket(IUnknown* a0,
                                         DWORD a1,
                                         DWORD a2,
                                         OLECHAR* a3,
                                         DWORD a4,
                                         DWORD a5,
                                         RPC_AUTH_IDENTITY_HANDLE a6,
                                         DWORD a7)
{
    _PrintEnter("CoSetProxyBlanket(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoSetProxyBlanket(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoSetProxyBlanket(,,,,,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSuspendClassObjects(void)
{
    _PrintEnter("CoSuspendClassObjects()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoSuspendClassObjects();
    } __finally {
        _PrintExit("CoSuspendClassObjects() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSwitchCallContext(IUnknown* a0,
                                           IUnknown** a1)
{
    _PrintEnter("CoSwitchCallContext(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoSwitchCallContext(a0, a1);
    } __finally {
        _PrintExit("CoSwitchCallContext(,) -> %x\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_CoTaskMemAlloc(SIZE_T a0)
{
    _PrintEnter("CoTaskMemAlloc(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_CoTaskMemAlloc(a0);
    } __finally {
        _PrintExit("CoTaskMemAlloc() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoTaskMemFree(LPVOID a0)
{
    _PrintEnter("CoTaskMemFree(%p)\n", a0);

    __try {
        Real_CoTaskMemFree(a0);
    } __finally {
        _PrintExit("CoTaskMemFree() ->\n");
    };
}

LPVOID __stdcall Mine_CoTaskMemRealloc(LPVOID a0,
                                       SIZE_T a1)
{
    _PrintEnter("CoTaskMemRealloc(%p,%p)\n", a0, a1);

    LPVOID rv = 0;
    __try {
        rv = Real_CoTaskMemRealloc(a0, a1);
    } __finally {
        _PrintExit("CoTaskMemRealloc(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoTreatAsClass(CONST IID& a0,
                                      CONST IID& a1)
{
    _PrintEnter("CoTreatAsClass(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoTreatAsClass(a0, a1);
    } __finally {
        _PrintExit("CoTreatAsClass(,) -> %x\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoUninitialize(void)
{
    _PrintEnter("CoUninitialize()\n");

    __try {
        Real_CoUninitialize();
    } __finally {
        _PrintExit("CoUninitialize() ->\n");
    };
}

HRESULT __stdcall Mine_CoUnmarshalHresult(LPSTREAM a0,
                                          HRESULT* a1)
{
    _PrintEnter("CoUnmarshalHresult(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoUnmarshalHresult(a0, a1);
    } __finally {
        _PrintExit("CoUnmarshalHresult(,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoUnmarshalInterface(LPSTREAM a0,
                                            CONST IID& a1,
                                            LPVOID* a2)
{
    _PrintEnter("CoUnmarshalInterface(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoUnmarshalInterface(a0, a1, a2);
    } __finally {
        _PrintExit("CoUnmarshalInterface(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ColorMatchToTarget(HDC a0,
                                       HDC a1,
                                       DWORD a2)
{
    _PrintEnter("ColorMatchToTarget(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ColorMatchToTarget(a0, a1, a2);
    } __finally {
        _PrintExit("ColorMatchToTarget(,,) -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_CombineRgn(HRGN a0,
                              HRGN a1,
                              HRGN a2,
                              int a3)
{
    _PrintEnter("CombineRgn(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_CombineRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CombineRgn(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CombineTransform(XFORM* a0,
                                     XFORM* a1,
                                     XFORM* a2)
{
    _PrintEnter("CombineTransform(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CombineTransform(a0, a1, a2);
    } __finally {
        _PrintExit("CombineTransform(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CommConfigDialogA(LPCSTR a0,
                                      HWND a1,
                                      LPCOMMCONFIG a2)
{
    _PrintEnter("CommConfigDialogA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CommConfigDialogA(a0, a1, a2);
    } __finally {
        _PrintExit("CommConfigDialogA(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CommConfigDialogW(LPCWSTR a0,
                                      HWND a1,
                                      LPCOMMCONFIG a2)
{
    _PrintEnter("CommConfigDialogW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CommConfigDialogW(a0, a1, a2);
    } __finally {
        _PrintExit("CommConfigDialogW(,,) -> %x\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_CompareFileTime(FILETIME* a0,
                                    FILETIME* a1)
{
    _PrintEnter("CompareFileTime(%p,%p)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_CompareFileTime(a0, a1);
    } __finally {
        _PrintExit("CompareFileTime(,) -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_CompareStringA(LCID a0,
                                  DWORD a1,
                                  LPCSTR a2,
                                  int a3,
                                  LPCSTR a4,
                                  int a5)
{
    _PrintEnter("CompareStringA(%p,%p,%hs,%p,%hs,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_CompareStringA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CompareStringA(,,,,,) -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_CompareStringW(LCID a0,
                                  DWORD a1,
                                  LPCWSTR a2,
                                  int a3,
                                  LPCWSTR a4,
                                  int a5)
{
    _PrintEnter("CompareStringW(%p,%p,%ls,%p,%ls,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_CompareStringW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CompareStringW(,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ConnectNamedPipe(HANDLE a0,
                                     LPOVERLAPPED a1)
{
    _PrintEnter("ConnectNamedPipe(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ConnectNamedPipe(a0, a1);
    } __finally {
        _PrintExit("ConnectNamedPipe(,) -> %x\n", rv);
    };
    return rv;
}

#if !defined(DETOURS_ARM)
BOOL __stdcall Mine_ContinueDebugEvent(DWORD a0,
                                       DWORD a1,
                                       DWORD a2)
{
    _PrintEnter("ContinueDebugEvent(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ContinueDebugEvent(a0, a1, a2);
    } __finally {
        _PrintExit("ContinueDebugEvent(,,) -> %x\n", rv);
    };
    return rv;
}
#endif // !DETOURS_ARM

LCID __stdcall Mine_ConvertDefaultLocale(LCID a0)
{
    _PrintEnter("ConvertDefaultLocale(%p)\n", a0);

    LCID rv = 0;
    __try {
        rv = Real_ConvertDefaultLocale(a0);
    } __finally {
        _PrintExit("ConvertDefaultLocale() -> %x\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_ConvertThreadToFiber(LPVOID a0)
{
    _PrintEnter("ConvertThreadToFiber(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_ConvertThreadToFiber(a0);
    } __finally {
        _PrintExit("ConvertThreadToFiber() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_CopyAcceleratorTableA(HACCEL a0,
                                         ACCEL* a1,
                                         int a2)
{
    _PrintEnter("CopyAcceleratorTableA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_CopyAcceleratorTableA(a0, a1, a2);
    } __finally {
        _PrintExit("CopyAcceleratorTableA(,,) -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_CopyAcceleratorTableW(HACCEL a0,
                                         ACCEL* a1,
                                         int a2)
{
    _PrintEnter("CopyAcceleratorTableW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_CopyAcceleratorTableW(a0, a1, a2);
    } __finally {
        _PrintExit("CopyAcceleratorTableW(,,) -> %x\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CopyEnhMetaFileA(HENHMETAFILE a0,
                                             LPCSTR a1)
{
    _PrintEnter("CopyEnhMetaFileA(%p,%hs)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CopyEnhMetaFileA(a0, a1);
    } __finally {
        _PrintExit("CopyEnhMetaFileA(,) -> %p\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CopyEnhMetaFileW(HENHMETAFILE a0,
                                             LPCWSTR a1)
{
    _PrintEnter("CopyEnhMetaFileW(%p,%ls)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CopyEnhMetaFileW(a0, a1);
    } __finally {
        _PrintExit("CopyEnhMetaFileW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileA(LPCSTR a0,
                              LPCSTR a1,
                              BOOL a2)
{
    _PrintEnter("CopyFileA(%hs,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileA(a0, a1, a2);
    } __finally {
        _PrintExit("CopyFileA(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileExA(LPCSTR a0,
                                LPCSTR a1,
                                LPPROGRESS_ROUTINE a2,
                                LPVOID a3,
                                LPBOOL a4,
                                DWORD a5)
{
    _PrintEnter("CopyFileExA(%hs,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CopyFileExA(,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileExW(LPCWSTR a0,
                                LPCWSTR a1,
                                LPPROGRESS_ROUTINE a2,
                                LPVOID a3,
                                LPBOOL a4,
                                DWORD a5)
{
    _PrintEnter("CopyFileExW(%ls,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CopyFileExW(,,,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileW(LPCWSTR a0,
                              LPCWSTR a1,
                              BOOL a2)
{
    _PrintEnter("CopyFileW(%ls,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileW(a0, a1, a2);
    } __finally {
        _PrintExit("CopyFileW(,,) -> %x\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CopyIcon(HICON a0)
{
    _PrintEnter("CopyIcon(%p)\n", a0);

    HICON rv = 0;
    __try {
        rv = Real_CopyIcon(a0);
    } __finally {
        _PrintExit("CopyIcon() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CopyImage(HANDLE a0,
                                UINT a1,
                                int a2,
                                int a3,
                                UINT a4)
{
    _PrintEnter("CopyImage(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_CopyImage(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CopyImage(,,,,) -> %p\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CopyMetaFileA(HMETAFILE a0,
                                       LPCSTR a1)
{
    _PrintEnter("CopyMetaFileA(%p,%hs)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CopyMetaFileA(a0, a1);
    } __finally {
        _PrintExit("CopyMetaFileA(,) -> %p\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CopyMetaFileW(HMETAFILE a0,
                                       LPCWSTR a1)
{
    _PrintEnter("CopyMetaFileW(%p,%ls)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CopyMetaFileW(a0, a1);
    } __finally {
        _PrintExit("CopyMetaFileW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyRect(LPRECT a0,
                             RECT* a1)
{
    _PrintEnter("CopyRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CopyRect(a0, a1);
    } __finally {
        _PrintExit("CopyRect(,) -> %x\n", rv);
    };
    return rv;
}

int __stdcall Mine_CountClipboardFormats(void)
{
    _PrintEnter("CountClipboardFormats()\n");

    int rv = 0;
    __try {
        rv = Real_CountClipboardFormats();
    } __finally {
        _PrintExit("CountClipboardFormats() -> %x\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_CreateAcceleratorTableA(ACCEL* a0,
                                              int a1)
{
    _PrintEnter("CreateAcceleratorTableA(%p,%p)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_CreateAcceleratorTableA(a0, a1);
    } __finally {
        _PrintExit("CreateAcceleratorTableA(,) -> %p\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_CreateAcceleratorTableW(ACCEL* a0,
                                              int a1)
{
    _PrintEnter("CreateAcceleratorTableW(%p,%p)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_CreateAcceleratorTableW(a0, a1);
    } __finally {
        _PrintExit("CreateAcceleratorTableW(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateAntiMoniker(IMoniker** a0)
{
    _PrintEnter("CreateAntiMoniker(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateAntiMoniker(a0);
    } __finally {
        _PrintExit("CreateAntiMoniker() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateBindCtx(DWORD a0,
                                     IBindCtx** a1)
{
    _PrintEnter("CreateBindCtx(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateBindCtx(a0, a1);
    } __finally {
        _PrintExit("CreateBindCtx(,) -> %x\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateBitmap(int a0,
                                    int a1,
                                    UINT a2,
                                    UINT a3,
                                    void* a4)
{
    _PrintEnter("CreateBitmap(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateBitmap(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateBitmap(,,,,) -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateBitmapIndirect(BITMAP* a0)
{
    _PrintEnter("CreateBitmapIndirect(%p)\n", a0);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateBitmapIndirect(a0);
    } __finally {
        _PrintExit("CreateBitmapIndirect() -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateBrushIndirect(LOGBRUSH* a0)
{
    _PrintEnter("CreateBrushIndirect(%p)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateBrushIndirect(a0);
    } __finally {
        _PrintExit("CreateBrushIndirect() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateCaret(HWND a0,
                                HBITMAP a1,
                                int a2,
                                int a3)
{
    _PrintEnter("CreateCaret(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateCaret(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateCaret(,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateClassMoniker(CONST IID& a0,
                                          IMoniker** a1)
{
    _PrintEnter("CreateClassMoniker(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateClassMoniker(a0, a1);
    } __finally {
        _PrintExit("CreateClassMoniker(,) -> %x\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_CreateColorSpaceA(LOGCOLORSPACEA* a0)
{
    _PrintEnter("CreateColorSpaceA(%p)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_CreateColorSpaceA(a0);
    } __finally {
        _PrintExit("CreateColorSpaceA() -> %p\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_CreateColorSpaceW(LOGCOLORSPACEW* a0)
{
    _PrintEnter("CreateColorSpaceW(%p)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_CreateColorSpaceW(a0);
    } __finally {
        _PrintExit("CreateColorSpaceW() -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateCompatibleBitmap(HDC a0,
                                              int a1,
                                              int a2)
{
    _PrintEnter("CreateCompatibleBitmap(%p,%p,%p)\n", a0, a1, a2);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateCompatibleBitmap(a0, a1, a2);
    } __finally {
        _PrintExit("CreateCompatibleBitmap(,,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateCompatibleDC(HDC a0)
{
    _PrintEnter("CreateCompatibleDC(%p)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateCompatibleDC(a0);
    } __finally {
        _PrintExit("CreateCompatibleDC() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateConsoleScreenBuffer(DWORD a0,
                                                DWORD a1,
                                                SECURITY_ATTRIBUTES* a2,
                                                DWORD a3,
                                                LPVOID a4)
{
    _PrintEnter("CreateConsoleScreenBuffer(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateConsoleScreenBuffer(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateConsoleScreenBuffer(,,,,) -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_CreateCursor(HINSTANCE a0,
                                    int a1,
                                    int a2,
                                    int a3,
                                    int a4,
                                    void* a5,
                                    void* a6)
{
    _PrintEnter("CreateCursor(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HCURSOR rv = 0;
    __try {
        rv = Real_CreateCursor(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateCursor(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateDCA(LPCSTR a0,
                             LPCSTR a1,
                             LPCSTR a2,
                             CONST DEVMODEA* a3)
{
    _PrintEnter("CreateDCA(%hs,%hs,%hs,%p)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateDCA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDCA(,,,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateDCW(LPCWSTR a0,
                             LPCWSTR a1,
                             LPCWSTR a2,
                             CONST DEVMODEW* a3)
{
    _PrintEnter("CreateDCW(%ls,%ls,%ls,%p)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateDCW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDCW(,,,) -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateDIBPatternBrush(HGLOBAL a0,
                                            UINT a1)
{
    _PrintEnter("CreateDIBPatternBrush(%p,%p)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateDIBPatternBrush(a0, a1);
    } __finally {
        _PrintExit("CreateDIBPatternBrush(,) -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateDIBPatternBrushPt(void* a0,
                                              UINT a1)
{
    _PrintEnter("CreateDIBPatternBrushPt(%p,%p)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateDIBPatternBrushPt(a0, a1);
    } __finally {
        _PrintExit("CreateDIBPatternBrushPt(,) -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDIBSection(HDC a0,
                                        BITMAPINFO* a1,
                                        UINT a2,
                                        void** a3,
                                        HANDLE a4,
                                        DWORD a5)
{
    _PrintEnter("CreateDIBSection(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDIBSection(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDIBSection(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDIBitmap(HDC a0,
                                      BITMAPINFOHEADER* a1,
                                      DWORD a2,
                                      void* a3,
                                      BITMAPINFO* a4,
                                      UINT a5)
{
    _PrintEnter("CreateDIBitmap(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDIBitmap(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDIBitmap(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateDataAdviseHolder(LPDATAADVISEHOLDER* a0)
{
    _PrintEnter("CreateDataAdviseHolder(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateDataAdviseHolder(a0);
    } __finally {
        _PrintExit("CreateDataAdviseHolder() -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateDataCache(LPUNKNOWN a0,
                                       CONST IID& a1,
                                       CONST IID& a2,
                                       LPVOID* a3)
{
    _PrintEnter("CreateDataCache(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateDataCache(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDataCache(,,,) -> %x\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HDESK __stdcall Mine_CreateDesktopA(LPSTR a0,
                                    LPSTR a1,
                                    LPDEVMODEA a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
#else
HDESK __stdcall Mine_CreateDesktopA(LPCSTR a0,
                                    LPCSTR a1,
                                    LPDEVMODEA a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
#endif
{
    _PrintEnter("CreateDesktopA(%hs,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HDESK rv = 0;
    __try {
        rv = Real_CreateDesktopA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDesktopA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HDESK __stdcall Mine_CreateDesktopW(LPWSTR a0, // NT 3.51 and older. NT4?
                                    LPWSTR a1, // NT 3.51 and older. NT4?
                                    LPDEVMODEW a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
#else
HDESK __stdcall Mine_CreateDesktopW(LPCWSTR a0, // Windows 2000 and newer; NT4?
                                    LPCWSTR a1, // Windows 2000 and newer; NT4?
                                    LPDEVMODEW a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
#endif
{
    _PrintEnter("CreateDesktopW(%ls,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HDESK rv = 0;
    __try {
        rv = Real_CreateDesktopW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDesktopW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogIndirectParamA(HINSTANCE a0,
                                               LPCDLGTEMPLATEA a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("CreateDialogIndirectParamA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogIndirectParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogIndirectParamA(,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogIndirectParamW(HINSTANCE a0,
                                               LPCDLGTEMPLATEW a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("CreateDialogIndirectParamW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogIndirectParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogIndirectParamW(,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogParamA(HINSTANCE a0,
                                       LPCSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("CreateDialogParamA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogParamA(,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogParamW(HINSTANCE a0,
                                       LPCWSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("CreateDialogParamW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogParamW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryA(LPCSTR a0,
                                     LPSECURITY_ATTRIBUTES a1)
{
    _PrintEnter("CreateDirectoryA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryA(a0, a1);
    } __finally {
        _PrintExit("CreateDirectoryA(,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryExA(LPCSTR a0,
                                       LPCSTR a1,
                                       LPSECURITY_ATTRIBUTES a2)
{
    _PrintEnter("CreateDirectoryExA(%hs,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryExA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDirectoryExA(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryExW(LPCWSTR a0,
                                       LPCWSTR a1,
                                       LPSECURITY_ATTRIBUTES a2)
{
    _PrintEnter("CreateDirectoryExW(%ls,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryExW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDirectoryExW(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryW(LPCWSTR a0,
                                     LPSECURITY_ATTRIBUTES a1)
{
    _PrintEnter("CreateDirectoryW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryW(a0, a1);
    } __finally {
        _PrintExit("CreateDirectoryW(,) -> %x\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDiscardableBitmap(HDC a0,
                                               int a1,
                                               int a2)
{
    _PrintEnter("CreateDiscardableBitmap(%p,%p,%p)\n", a0, a1, a2);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDiscardableBitmap(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDiscardableBitmap(,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateEllipticRgn(int a0,
                                      int a1,
                                      int a2,
                                      int a3)
{
    _PrintEnter("CreateEllipticRgn(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreateEllipticRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEllipticRgn(,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateEllipticRgnIndirect(RECT* a0)
{
    _PrintEnter("CreateEllipticRgnIndirect(%p)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_CreateEllipticRgnIndirect(a0);
    } __finally {
        _PrintExit("CreateEllipticRgnIndirect() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateEnhMetaFileA(HDC a0,
                                      LPCSTR a1,
                                      RECT* a2,
                                      LPCSTR a3)
{
    _PrintEnter("CreateEnhMetaFileA(%p,%hs,%p,%hs)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateEnhMetaFileA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEnhMetaFileA(,,,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateEnhMetaFileW(HDC a0,
                                      LPCWSTR a1,
                                      RECT* a2,
                                      LPCWSTR a3)
{
    _PrintEnter("CreateEnhMetaFileW(%p,%ls,%p,%ls)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateEnhMetaFileW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEnhMetaFileW(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateEventA(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   BOOL a2,
                                   LPCSTR a3)
{
    _PrintEnter("CreateEventA(%p,%p,%p,%hs)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateEventA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEventA(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateEventW(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   BOOL a2,
                                   LPCWSTR a3)
{
    _PrintEnter("CreateEventW(%p,%p,%p,%ls)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateEventW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEventW(,,,) -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_CreateFiber(ULONG_PTR a0,
                                  LPFIBER_START_ROUTINE a1,
                                  LPVOID a2)
{
    _PrintEnter("CreateFiber(%p,%p,%p)\n", a0, a1, a2);

    LPVOID rv = 0;
    __try {
        rv = Real_CreateFiber(a0, a1, a2);
    } __finally {
        _PrintExit("CreateFiber(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileA(LPCSTR a0,
                                  DWORD a1,
                                  DWORD a2,
                                  LPSECURITY_ATTRIBUTES a3,
                                  DWORD a4,
                                  DWORD a5,
                                  HANDLE a6)
{
    _PrintEnter("CreateFileA(%hs,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateFileA(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileMappingA(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         DWORD a2,
                                         DWORD a3,
                                         DWORD a4,
                                         LPCSTR a5)
{
    _PrintEnter("CreateFileMappingA(%p,%p,%p,%p,%p,%hs)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileMappingA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateFileMappingA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileMappingW(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         DWORD a2,
                                         DWORD a3,
                                         DWORD a4,
                                         LPCWSTR a5)
{
    _PrintEnter("CreateFileMappingW(%p,%p,%p,%p,%p,%ls)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileMappingW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateFileMappingW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateFileMoniker(LPCOLESTR a0,
                                         IMoniker** a1)
{
    _PrintEnter("CreateFileMoniker(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateFileMoniker(a0, a1);
    } __finally {
        _PrintExit("CreateFileMoniker(,) -> %x\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileW(LPCWSTR a0,
                                  DWORD a1,
                                  DWORD a2,
                                  LPSECURITY_ATTRIBUTES a3,
                                  DWORD a4,
                                  DWORD a5,
                                  HANDLE a6)
{
    _PrintEnter("CreateFileW(%ls,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateFileW(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontA(int a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 DWORD a5,
                                 DWORD a6,
                                 DWORD a7,
                                 DWORD a8,
                                 DWORD a9,
                                 DWORD a10,
                                 DWORD a11,
                                 DWORD a12,
                                 LPCSTR a13)
{
    _PrintEnter("CreateFontA(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%hs)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    } __finally {
        _PrintExit("CreateFontA(,,,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontIndirectA(LOGFONTA* a0)
{
    _PrintEnter("CreateFontIndirectA(%p)\n", a0);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontIndirectA(a0);
    } __finally {
        _PrintExit("CreateFontIndirectA() -> %p\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontIndirectW(LOGFONTW* a0)
{
    _PrintEnter("CreateFontIndirectW(%p)\n", a0);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontIndirectW(a0);
    } __finally {
        _PrintExit("CreateFontIndirectW() -> %p\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontW(int a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 DWORD a5,
                                 DWORD a6,
                                 DWORD a7,
                                 DWORD a8,
                                 DWORD a9,
                                 DWORD a10,
                                 DWORD a11,
                                 DWORD a12,
                                 LPCWSTR a13)
{
    _PrintEnter("CreateFontW(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%ls)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    } __finally {
        _PrintExit("CreateFontW(,,,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateGenericComposite(IMoniker* a0,
                                              IMoniker* a1,
                                              IMoniker** a2)
{
    _PrintEnter("CreateGenericComposite(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateGenericComposite(a0, a1, a2);
    } __finally {
        _PrintExit("CreateGenericComposite(,,) -> %x\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_CreateHalftonePalette(HDC a0)
{
    _PrintEnter("CreateHalftonePalette(%p)\n", a0);

    HPALETTE rv = 0;
    __try {
        rv = Real_CreateHalftonePalette(a0);
    } __finally {
        _PrintExit("CreateHalftonePalette() -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateHatchBrush(int a0,
                                       COLORREF a1)
{
    _PrintEnter("CreateHatchBrush(%p,%p)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateHatchBrush(a0, a1);
    } __finally {
        _PrintExit("CreateHatchBrush(,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateICA(LPCSTR a0,
                             LPCSTR a1,
                             LPCSTR a2,
                             CONST DEVMODEA* a3)
{
    _PrintEnter("CreateICA(%hs,%hs,%hs,%p)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateICA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateICA(,,,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateICW(LPCWSTR a0,
                             LPCWSTR a1,
                             LPCWSTR a2,
                             CONST DEVMODEW* a3)
{
    _PrintEnter("CreateICW(%ls,%ls,%ls,%p)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateICW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateICW(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateILockBytesOnHGlobal(HGLOBAL a0,
                                                 BOOL a1,
                                                 ILockBytes** a2)
{
    _PrintEnter("CreateILockBytesOnHGlobal(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateILockBytesOnHGlobal(a0, a1, a2);
    } __finally {
        _PrintExit("CreateILockBytesOnHGlobal(,,) -> %x\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIcon(HINSTANCE a0,
                                int a1,
                                int a2,
                                BYTE a3,
                                BYTE a4,
                                BYTE* a5,
                                BYTE* a6)
{
    _PrintEnter("CreateIcon(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HICON rv = 0;
    __try {
        rv = Real_CreateIcon(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateIcon(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconFromResource(PBYTE a0,
                                            DWORD a1,
                                            BOOL a2,
                                            DWORD a3)
{
    _PrintEnter("CreateIconFromResource(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconFromResource(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateIconFromResource(,,,) -> %p\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconFromResourceEx(PBYTE a0,
                                              DWORD a1,
                                              BOOL a2,
                                              DWORD a3,
                                              int a4,
                                              int a5,
                                              UINT a6)
{
    _PrintEnter("CreateIconFromResourceEx(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconFromResourceEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateIconFromResourceEx(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconIndirect(PICONINFO a0)
{
    _PrintEnter("CreateIconIndirect(%p)\n", a0);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconIndirect(a0);
    } __finally {
        _PrintExit("CreateIconIndirect() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateIoCompletionPort(HANDLE a0,
                                             HANDLE a1,
                                             ULONG_PTR a2,
                                             DWORD a3)
{
    _PrintEnter("CreateIoCompletionPort(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateIoCompletionPort(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateIoCompletionPort(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateItemMoniker(LPCOLESTR a0,
                                         LPCOLESTR a1,
                                         IMoniker** a2)
{
    _PrintEnter("CreateItemMoniker(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateItemMoniker(a0, a1, a2);
    } __finally {
        _PrintExit("CreateItemMoniker(,,) -> %x\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWND __stdcall Mine_CreateMDIWindowA(LPSTR a0, // NT 3.51 and older. NT4?
                                     LPSTR a1, // NT 3.51 and older. NT4?
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
#else
HWND __stdcall Mine_CreateMDIWindowA(LPCSTR a0, // Windows 2000 and newer; NT4?
                                     LPCSTR a1, // Windows 2000 and newer; NT4?
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
#endif
{
    _PrintEnter("CreateMDIWindowA(%hs,%hs,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    HWND rv = 0;
    __try {
        rv = Real_CreateMDIWindowA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateMDIWindowA(,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWND __stdcall Mine_CreateMDIWindowW(LPWSTR a0,
                                     LPWSTR a1,
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
#else
HWND __stdcall Mine_CreateMDIWindowW(LPCWSTR a0,
                                     LPCWSTR a1,
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
#endif
{
    _PrintEnter("CreateMDIWindowW(%ls,%ls,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    HWND rv = 0;
    __try {
        rv = Real_CreateMDIWindowW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateMDIWindowW(,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMailslotA(LPCSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateMailslotA(%hs,%p,%p,%p)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMailslotA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateMailslotA(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMailslotW(LPCWSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateMailslotW(%ls,%p,%p,%p)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMailslotW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateMailslotW(,,,) -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_CreateMenu(void)
{
    _PrintEnter("CreateMenu()\n");

    HMENU rv = 0;
    __try {
        rv = Real_CreateMenu();
    } __finally {
        _PrintExit("CreateMenu() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateMetaFileA(LPCSTR a0)
{
    _PrintEnter("CreateMetaFileA(%hs)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateMetaFileA(a0);
    } __finally {
        _PrintExit("CreateMetaFileA() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateMetaFileW(LPCWSTR a0)
{
    _PrintEnter("CreateMetaFileW(%ls)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateMetaFileW(a0);
    } __finally {
        _PrintExit("CreateMetaFileW() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMutexA(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   LPCSTR a2)
{
    _PrintEnter("CreateMutexA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMutexA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateMutexA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMutexW(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   LPCWSTR a2)
{
    _PrintEnter("CreateMutexW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMutexW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateMutexW(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateNamedPipeA(LPCSTR a0,
                                       DWORD a1,
                                       DWORD a2,
                                       DWORD a3,
                                       DWORD a4,
                                       DWORD a5,
                                       DWORD a6,
                                       LPSECURITY_ATTRIBUTES a7)
{
    _PrintEnter("CreateNamedPipeA(%hs,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateNamedPipeA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CreateNamedPipeA(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateNamedPipeW(LPCWSTR a0,
                                       DWORD a1,
                                       DWORD a2,
                                       DWORD a3,
                                       DWORD a4,
                                       DWORD a5,
                                       DWORD a6,
                                       LPSECURITY_ATTRIBUTES a7)
{
    _PrintEnter("CreateNamedPipeW(%ls,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateNamedPipeW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CreateNamedPipeW(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateOleAdviseHolder(LPOLEADVISEHOLDER* a0)
{
    _PrintEnter("CreateOleAdviseHolder(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateOleAdviseHolder(a0);
    } __finally {
        _PrintExit("CreateOleAdviseHolder() -> %x\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_CreatePalette(LOGPALETTE* a0)
{
    _PrintEnter("CreatePalette(%p)\n", a0);

    HPALETTE rv = 0;
    __try {
        rv = Real_CreatePalette(a0);
    } __finally {
        _PrintExit("CreatePalette() -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreatePatternBrush(HBITMAP a0)
{
    _PrintEnter("CreatePatternBrush(%p)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreatePatternBrush(a0);
    } __finally {
        _PrintExit("CreatePatternBrush() -> %p\n", rv);
    };
    return rv;
}

HPEN __stdcall Mine_CreatePen(int a0,
                              int a1,
                              COLORREF a2)
{
    _PrintEnter("CreatePen(%p,%p,%p)\n", a0, a1, a2);

    HPEN rv = 0;
    __try {
        rv = Real_CreatePen(a0, a1, a2);
    } __finally {
        _PrintExit("CreatePen(,,) -> %p\n", rv);
    };
    return rv;
}

HPEN __stdcall Mine_CreatePenIndirect(LOGPEN* a0)
{
    _PrintEnter("CreatePenIndirect(%p)\n", a0);

    HPEN rv = 0;
    __try {
        rv = Real_CreatePenIndirect(a0);
    } __finally {
        _PrintExit("CreatePenIndirect() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreatePipe(PHANDLE a0,
                               PHANDLE a1,
                               LPSECURITY_ATTRIBUTES a2,
                               DWORD a3)
{
    _PrintEnter("CreatePipe(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreatePipe(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreatePipe(,,,) -> %x\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreatePointerMoniker(LPUNKNOWN a0,
                                            IMoniker** a1)
{
    _PrintEnter("CreatePointerMoniker(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreatePointerMoniker(a0, a1);
    } __finally {
        _PrintExit("CreatePointerMoniker(,) -> %x\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreatePolyPolygonRgn(POINT* a0,
                                         INT* a1,
                                         int a2,
                                         int a3)
{
    _PrintEnter("CreatePolyPolygonRgn(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreatePolyPolygonRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreatePolyPolygonRgn(,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreatePolygonRgn(POINT* a0,
                                     int a1,
                                     int a2)
{
    _PrintEnter("CreatePolygonRgn(%p,%p,%p)\n", a0, a1, a2);

    HRGN rv = 0;
    __try {
        rv = Real_CreatePolygonRgn(a0, a1, a2);
    } __finally {
        _PrintExit("CreatePolygonRgn(,,) -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_CreatePopupMenu(void)
{
    _PrintEnter("CreatePopupMenu()\n");

    HMENU rv = 0;
    __try {
        rv = Real_CreatePopupMenu();
    } __finally {
        _PrintExit("CreatePopupMenu() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessA(LPCSTR lpApplicationName,
                                   LPSTR lpCommandLine,
                                   LPSECURITY_ATTRIBUTES lpProcessAttributes,
                                   LPSECURITY_ATTRIBUTES lpThreadAttributes,
                                   BOOL bInheritHandles,
                                   DWORD dwCreationFlags,
                                   LPVOID lpEnvironment,
                                   LPCSTR lpCurrentDirectory,
                                   LPSTARTUPINFOA lpStartupInfo,
                                   LPPROCESS_INFORMATION lpProcessInformation)
{
    _PrintEnter("CreateProcessA(%hs,%hs,%p,%p,%p,%p,%p,%hs,%p,%p)\n",
                lpApplicationName,
                lpCommandLine,
                lpProcessAttributes,
                lpThreadAttributes,
                bInheritHandles,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInformation);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInformation == NULL) {
        lpProcessInformation= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = DetourCreateProcessWithDllExA(lpApplicationName,
                                           lpCommandLine,
                                           lpProcessAttributes,
                                           lpThreadAttributes,
                                           bInheritHandles,
                                           dwCreationFlags,
                                           lpEnvironment,
                                           lpCurrentDirectory,
                                           lpStartupInfo,
                                           lpProcessInformation,
                                           s_szDllPath,
                                           Real_CreateProcessA);
    } __finally {
        _PrintExit("CreateProcessA(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInformation->dwProcessId,
                   lpProcessInformation->hProcess,
                   lpProcessInformation->dwThreadId,
                   lpProcessInformation->hThread);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessW(LPCWSTR lpApplicationName,
                                   LPWSTR lpCommandLine,
                                   LPSECURITY_ATTRIBUTES lpProcessAttributes,
                                   LPSECURITY_ATTRIBUTES lpThreadAttributes,
                                   BOOL bInheritHandles,
                                   DWORD dwCreationFlags,
                                   LPVOID lpEnvironment,
                                   LPCWSTR lpCurrentDirectory,
                                   LPSTARTUPINFOW lpStartupInfo,
                                   LPPROCESS_INFORMATION lpProcessInformation)
{
    _PrintEnter("CreateProcessW(%ls,%ls,%p,%p,%p,%p,%p,%ls,%p,%p)\n",
                lpApplicationName,
                lpCommandLine,
                lpProcessAttributes,
                lpThreadAttributes,
                bInheritHandles,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInformation);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInformation == NULL) {
        lpProcessInformation= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = DetourCreateProcessWithDllExW(lpApplicationName,
                                           lpCommandLine,
                                           lpProcessAttributes,
                                           lpThreadAttributes,
                                           bInheritHandles,
                                           dwCreationFlags,
                                           lpEnvironment,
                                           lpCurrentDirectory,
                                           lpStartupInfo,
                                           lpProcessInformation,
                                           s_szDllPath,
                                           Real_CreateProcessW);
    } __finally {
        _PrintExit("CreateProcessW(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInformation->dwProcessId,
                   lpProcessInformation->hProcess,
                   lpProcessInformation->dwThreadId,
                   lpProcessInformation->hThread);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessAsUserA(
  __in_opt     HANDLE hToken,
  __in_opt     LPCSTR lpApplicationName,
  __inout_opt  LPSTR lpCommandLine,
  __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
  __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
  __in         BOOL bInheritHandles,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOA lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInformation
                                        )
{
    _PrintEnter("CreateProcessAsUserA(%ls,%ls,%p,%p,%p,%p,%p,%ls,%p,%p)\n",
                lpApplicationName,
                lpCommandLine,
                lpProcessAttributes,
                lpThreadAttributes,
                bInheritHandles,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInformation);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInformation == NULL) {
        lpProcessInformation= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessAsUserA(hToken,
                                       lpApplicationName,
                                       lpCommandLine,
                                       lpProcessAttributes,
                                       lpThreadAttributes,
                                       bInheritHandles,
                                       dwCreationFlags,
                                       lpEnvironment,
                                       lpCurrentDirectory,
                                       lpStartupInfo,
                                       lpProcessInformation);
    } __finally {
        _PrintExit("CreateProcessAsUserAW(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInformation->dwProcessId,
                   lpProcessInformation->hProcess,
                   lpProcessInformation->dwThreadId,
                   lpProcessInformation->hThread);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessAsUserW(
  __in_opt     HANDLE hToken,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
  __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
  __in         BOOL bInheritHandles,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInformation
                                        )
{
    _PrintEnter("CreateProcessAsUserW(%ls,%ls,%p,%p,%p,%p,%p,%ls,%p,%p)\n",
                lpApplicationName,
                lpCommandLine,
                lpProcessAttributes,
                lpThreadAttributes,
                bInheritHandles,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInformation);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInformation == NULL) {
        lpProcessInformation= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessAsUserW(hToken,
                                       lpApplicationName,
                                       lpCommandLine,
                                       lpProcessAttributes,
                                       lpThreadAttributes,
                                       bInheritHandles,
                                       dwCreationFlags,
                                       lpEnvironment,
                                       lpCurrentDirectory,
                                       lpStartupInfo,
                                       lpProcessInformation);
    } __finally {
        _PrintExit("CreateProcessAsUserW(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInformation->dwProcessId,
                   lpProcessInformation->hProcess,
                   lpProcessInformation->dwThreadId,
                   lpProcessInformation->hThread);
    };
    return rv;
}

#if(_WIN32_WINNT >= 0x0500)
BOOL WINAPI Mine_CreateProcessWithLogonW(
  __in         LPCWSTR lpUsername,
  __in_opt     LPCWSTR lpDomain,
  __in         LPCWSTR lpPassword,
  __in         DWORD dwLogonFlags,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInfo
                                        )
{
    _PrintEnter("CreateProcessWithLogonW(%ls,%ls,%ls,%d,%ls,%ls,%p,%p,%ls,%p,%p)\n",
                lpUsername,
                lpDomain,
                lpPassword,
                dwLogonFlags,
                lpApplicationName,
                lpCommandLine,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInfo);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInfo == NULL) {
        lpProcessInfo= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessWithLogonW(
                lpUsername,
                lpDomain,
                lpPassword,
                dwLogonFlags,
                lpApplicationName,
                lpCommandLine,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInfo);
    } __finally {
        _PrintExit("CreateProcessWithLogonW(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInfo->dwProcessId,
                   lpProcessInfo->hProcess,
                   lpProcessInfo->dwThreadId,
                   lpProcessInfo->hThread);
    };
    return rv;
}

BOOL WINAPI Mine_CreateProcessWithTokenW(
  __in         HANDLE hToken,
  __in         DWORD dwLogonFlags,
  __in_opt     LPCWSTR lpApplicationName,
  __inout_opt  LPWSTR lpCommandLine,
  __in         DWORD dwCreationFlags,
  __in_opt     LPVOID lpEnvironment,
  __in_opt     LPCWSTR lpCurrentDirectory,
  __in         LPSTARTUPINFOW lpStartupInfo,
  __out        LPPROCESS_INFORMATION lpProcessInfo
)
{
    _PrintEnter("CreateProcessWithTokenW(%ls,%ls,%p,%p,%ls,%p,%p)\n",
                lpApplicationName,
                lpCommandLine,
                dwCreationFlags,
                lpEnvironment,
                lpCurrentDirectory,
                lpStartupInfo,
                lpProcessInfo);

    PROCESS_INFORMATION procInfo;
    if (lpProcessInfo == NULL) {
        lpProcessInfo= &procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));
    }

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessWithTokenW(hToken,
                                          dwLogonFlags,
                                          lpApplicationName,
                                          lpCommandLine,
                                          dwCreationFlags,
                                          lpEnvironment,
                                          lpCurrentDirectory,
                                          lpStartupInfo,
                                          lpProcessInfo);
    } __finally {
        _PrintExit("CreateProcessWithTokenW(,,,,,,,,,) -> %x (proc:%d/%p, thrd:%d/%p\n", rv,
                   lpProcessInfo->dwProcessId,
                   lpProcessInfo->hProcess,
                   lpProcessInfo->dwThreadId,
                   lpProcessInfo->hThread);
    };
    return rv;
}
#endif // (_WIN32_WINNT >= 0x0500)

HRGN __stdcall Mine_CreateRectRgn(int a0,
                                  int a1,
                                  int a2,
                                  int a3)
{
    _PrintEnter("CreateRectRgn(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRectRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateRectRgn(,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateRectRgnIndirect(RECT* a0)
{
    _PrintEnter("CreateRectRgnIndirect(%p)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRectRgnIndirect(a0);
    } __finally {
        _PrintExit("CreateRectRgnIndirect() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateRemoteThread(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         ULONG_PTR a2,
                                         LPTHREAD_START_ROUTINE a3,
                                         LPVOID a4,
                                         DWORD a5,
                                         LPDWORD a6)
{
    _PrintEnter("CreateRemoteThread(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateRemoteThread(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateRemoteThread(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateRoundRectRgn(int a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       int a4,
                                       int a5)
{
    _PrintEnter("CreateRoundRectRgn(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRoundRectRgn(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateRoundRectRgn(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateScalableFontResourceA(DWORD a0,
                                                LPCSTR a1,
                                                LPCSTR a2,
                                                LPCSTR a3)
{
    _PrintEnter("CreateScalableFontResourceA(%p,%hs,%hs,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateScalableFontResourceA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateScalableFontResourceA(,,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateScalableFontResourceW(DWORD a0,
                                                LPCWSTR a1,
                                                LPCWSTR a2,
                                                LPCWSTR a3)
{
    _PrintEnter("CreateScalableFontResourceW(%p,%ls,%ls,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateScalableFontResourceW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateScalableFontResourceW(,,,) -> %x\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateSemaphoreA(LPSECURITY_ATTRIBUTES a0,
                                       LONG a1,
                                       LONG a2,
                                       LPCSTR a3)
{
    _PrintEnter("CreateSemaphoreA(%p,%p,%p,%hs)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateSemaphoreA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateSemaphoreA(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateSemaphoreW(LPSECURITY_ATTRIBUTES a0,
                                       LONG a1,
                                       LONG a2,
                                       LPCWSTR a3)
{
    _PrintEnter("CreateSemaphoreW(%p,%p,%p,%ls)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateSemaphoreW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateSemaphoreW(,,,) -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateSolidBrush(COLORREF a0)
{
    _PrintEnter("CreateSolidBrush(%p)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateSolidBrush(a0);
    } __finally {
        _PrintExit("CreateSolidBrush() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateStdProgressIndicator(HWND a0,
                                                  LPCOLESTR a1,
                                                  IBindStatusCallback* a2,
                                                  IBindStatusCallback** a3)
{
    _PrintEnter("CreateStdProgressIndicator(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateStdProgressIndicator(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateStdProgressIndicator(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateStreamOnHGlobal(HGLOBAL a0,
                                             BOOL a1,
                                             LPSTREAM* a2)
{
    _PrintEnter("CreateStreamOnHGlobal(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateStreamOnHGlobal(a0, a1, a2);
    } __finally {
        _PrintExit("CreateStreamOnHGlobal(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CreateTapePartition(HANDLE a0,
                                         DWORD a1,
                                         DWORD a2,
                                         DWORD a3)
{
    _PrintEnter("CreateTapePartition(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_CreateTapePartition(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateTapePartition(,,,) -> %x\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateThread(LPSECURITY_ATTRIBUTES a0,
                                   ULONG_PTR a1,
                                   LPTHREAD_START_ROUTINE a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5)
{
    _PrintEnter("CreateThread(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateThread(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateThread(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateWaitableTimerA(LPSECURITY_ATTRIBUTES a0,
                                           BOOL a1,
                                           LPCSTR a2)
{
    _PrintEnter("CreateWaitableTimerA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateWaitableTimerA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateWaitableTimerA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateWaitableTimerW(LPSECURITY_ATTRIBUTES a0,
                                           BOOL a1,
                                           LPCWSTR a2)
{
    _PrintEnter("CreateWaitableTimerW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateWaitableTimerW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateWaitableTimerW(,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateWindowExA(DWORD a0,
                                    LPCSTR a1,
                                    LPCSTR a2,
                                    DWORD a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    HWND a8,
                                    HMENU a9,
                                    HINSTANCE a10,
                                    LPVOID a11)
{
    _PrintEnter("CreateWindowExA(%p,%hs,%hs,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HWND rv = 0;
    __try {
        rv = Real_CreateWindowExA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("CreateWindowExA(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateWindowExW(DWORD a0,
                                    LPCWSTR a1,
                                    LPCWSTR a2,
                                    DWORD a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    HWND a8,
                                    HMENU a9,
                                    HINSTANCE a10,
                                    LPVOID a11)
{
    _PrintEnter("CreateWindowExW(%p,%ls,%ls,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HWND rv = 0;
    __try {
        rv = Real_CreateWindowExW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("CreateWindowExW(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWINSTA __stdcall Mine_CreateWindowStationA(LPSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
#else
HWINSTA __stdcall Mine_CreateWindowStationA(LPCSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
#endif
{
    _PrintEnter("CreateWindowStationA(%hs,%p,%p,%p)\n", a0, a1, a2, a3);

    HWINSTA rv = 0;
    __try {
        rv = Real_CreateWindowStationA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateWindowStationA(,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWINSTA __stdcall Mine_CreateWindowStationW(LPWSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
#else
HWINSTA __stdcall Mine_CreateWindowStationW(LPCWSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
#endif
{
    _PrintEnter("CreateWindowStationW(%ls,%p,%p,%p)\n", a0, a1, a2, a3);

    HWINSTA rv = 0;
    __try {
        rv = Real_CreateWindowStationW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateWindowStationW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DPtoLP(HDC a0,
                           POINT* a1,
                           int a2)
{
    _PrintEnter("DPtoLP(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DPtoLP(a0, a1, a2);
    } __finally {
        _PrintExit("DPtoLP(,,) -> %x\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeAbandonTransaction(DWORD a0,
                                          HCONV a1,
                                          DWORD a2)
{
    _PrintEnter("DdeAbandonTransaction(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeAbandonTransaction(a0, a1, a2);
    } __finally {
        _PrintExit("DdeAbandonTransaction(,,) -> %p\n", rv);
    };
    return rv;
}

LPBYTE __stdcall Mine_DdeAccessData(HDDEDATA a0,
                                    LPDWORD a1)
{
    _PrintEnter("DdeAccessData(%p,%p)\n", a0, a1);

    LPBYTE rv = 0;
    __try {
        rv = Real_DdeAccessData(a0, a1);
    } __finally {
        _PrintExit("DdeAccessData(,) -> %p\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeAddData(HDDEDATA a0,
                                   LPBYTE a1,
                                   DWORD a2,
                                   DWORD a3)
{
    _PrintEnter("DdeAddData(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeAddData(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeAddData(,,,) -> %p\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeClientTransaction(LPBYTE a0,
                                             DWORD a1,
                                             HCONV a2,
                                             HSZ a3,
                                             UINT a4,
                                             UINT a5,
                                             DWORD a6,
                                             LPDWORD a7)
{
    _PrintEnter("DdeClientTransaction(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeClientTransaction(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DdeClientTransaction(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DdeCmpStringHandles(HSZ a0,
                                       HSZ a1)
{
    _PrintEnter("DdeCmpStringHandles(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_DdeCmpStringHandles(a0, a1);
    } __finally {
        _PrintExit("DdeCmpStringHandles(,) -> %x\n", rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeConnect(DWORD a0,
                                HSZ a1,
                                HSZ a2,
                                PCONVCONTEXT a3)
{
    _PrintEnter("DdeConnect(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HCONV rv = 0;
    __try {
        rv = Real_DdeConnect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeConnect(,,,) -> %p\n", rv);
    };
    return rv;
}

HCONVLIST __stdcall Mine_DdeConnectList(DWORD a0,
                                        HSZ a1,
                                        HSZ a2,
                                        HCONVLIST a3,
                                        PCONVCONTEXT a4)
{
    _PrintEnter("DdeConnectList(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HCONVLIST rv = 0;
    __try {
        rv = Real_DdeConnectList(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeConnectList(,,,,) -> %p\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeCreateDataHandle(DWORD a0,
                                            LPBYTE a1,
                                            DWORD a2,
                                            DWORD a3,
                                            HSZ a4,
                                            UINT a5,
                                            UINT a6)
{
    _PrintEnter("DdeCreateDataHandle(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeCreateDataHandle(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("DdeCreateDataHandle(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HSZ __stdcall Mine_DdeCreateStringHandleA(DWORD a0,
                                          LPCSTR a1,
                                          int a2)
{
    _PrintEnter("DdeCreateStringHandleA(%p,%hs,%p)\n", a0, a1, a2);

    HSZ rv = 0;
    __try {
        rv = Real_DdeCreateStringHandleA(a0, a1, a2);
    } __finally {
        _PrintExit("DdeCreateStringHandleA(,,) -> %p\n", rv);
    };
    return rv;
}

HSZ __stdcall Mine_DdeCreateStringHandleW(DWORD a0,
                                          LPCWSTR a1,
                                          int a2)
{
    _PrintEnter("DdeCreateStringHandleW(%p,%ls,%p)\n", a0, a1, a2);

    HSZ rv = 0;
    __try {
        rv = Real_DdeCreateStringHandleW(a0, a1, a2);
    } __finally {
        _PrintExit("DdeCreateStringHandleW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeDisconnect(HCONV a0)
{
    _PrintEnter("DdeDisconnect(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeDisconnect(a0);
    } __finally {
        _PrintExit("DdeDisconnect() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeDisconnectList(HCONVLIST a0)
{
    _PrintEnter("DdeDisconnectList(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeDisconnectList(a0);
    } __finally {
        _PrintExit("DdeDisconnectList() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeEnableCallback(DWORD a0,
                                      HCONV a1,
                                      UINT a2)
{
    _PrintEnter("DdeEnableCallback(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeEnableCallback(a0, a1, a2);
    } __finally {
        _PrintExit("DdeEnableCallback(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeFreeDataHandle(HDDEDATA a0)
{
    _PrintEnter("DdeFreeDataHandle(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeFreeDataHandle(a0);
    } __finally {
        _PrintExit("DdeFreeDataHandle() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeFreeStringHandle(DWORD a0,
                                        HSZ a1)
{
    _PrintEnter("DdeFreeStringHandle(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DdeFreeStringHandle(a0, a1);
    } __finally {
        _PrintExit("DdeFreeStringHandle(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeGetData(HDDEDATA a0,
                                LPBYTE a1,
                                DWORD a2,
                                DWORD a3)
{
    _PrintEnter("DdeGetData(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_DdeGetData(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeGetData(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_DdeGetLastError(DWORD a0)
{
    _PrintEnter("DdeGetLastError(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_DdeGetLastError(a0);
    } __finally {
        _PrintExit("DdeGetLastError() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeImpersonateClient(HCONV a0)
{
    _PrintEnter("DdeImpersonateClient(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeImpersonateClient(a0);
    } __finally {
        _PrintExit("DdeImpersonateClient() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeKeepStringHandle(DWORD a0,
                                        HSZ a1)
{
    _PrintEnter("DdeKeepStringHandle(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DdeKeepStringHandle(a0, a1);
    } __finally {
        _PrintExit("DdeKeepStringHandle(,) -> %p\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeNameService(DWORD a0,
                                       HSZ a1,
                                       HSZ a2,
                                       UINT a3)
{
    _PrintEnter("DdeNameService(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeNameService(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeNameService(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdePostAdvise(DWORD a0,
                                  HSZ a1,
                                  HSZ a2)
{
    _PrintEnter("DdePostAdvise(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdePostAdvise(a0, a1, a2);
    } __finally {
        _PrintExit("DdePostAdvise(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_DdeQueryConvInfo(HCONV a0,
                                     DWORD a1,
                                     CONVINFO* a2)
{
    _PrintEnter("DdeQueryConvInfo(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_DdeQueryConvInfo(a0, a1, a2);
    } __finally {
        _PrintExit("DdeQueryConvInfo(,,) -> %p\n", rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeQueryNextServer(HCONVLIST a0,
                                        HCONV a1)
{
    _PrintEnter("DdeQueryNextServer(%p,%p)\n", a0, a1);

    HCONV rv = 0;
    __try {
        rv = Real_DdeQueryNextServer(a0, a1);
    } __finally {
        _PrintExit("DdeQueryNextServer(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeQueryStringA(DWORD a0,
                                     HSZ a1,
                                     LPSTR a2,
                                     DWORD a3,
                                     int a4)
{
    _PrintEnter("DdeQueryStringA(%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DdeQueryStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeQueryStringA(,,%hs,,) -> %p\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeQueryStringW(DWORD a0,
                                     HSZ a1,
                                     LPWSTR a2,
                                     DWORD a3,
                                     int a4)
{
    _PrintEnter("DdeQueryStringW(%p,%p,%ls,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DdeQueryStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeQueryStringW(,,%ls,,) -> %p\n", a2, rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeReconnect(HCONV a0)
{
    _PrintEnter("DdeReconnect(%p)\n", a0);

    HCONV rv = 0;
    __try {
        rv = Real_DdeReconnect(a0);
    } __finally {
        _PrintExit("DdeReconnect() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeSetQualityOfService(HWND a0,
                                           PSECURITY_QUALITY_OF_SERVICE a1,
                                           PSECURITY_QUALITY_OF_SERVICE a2)
{
    _PrintEnter("DdeSetQualityOfService(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeSetQualityOfService(a0, a1, a2);
    } __finally {
        _PrintExit("DdeSetQualityOfService(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeSetUserHandle(HCONV a0,
                                     DWORD a1,
                                     ULONG_PTR a2)
{
    _PrintEnter("DdeSetUserHandle(%p,%x,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeSetUserHandle(a0, a1, a2);
    } __finally {
        _PrintExit("DdeSetUserHandle(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeUnaccessData(HDDEDATA a0)
{
    _PrintEnter("DdeUnaccessData(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeUnaccessData(a0);
    } __finally {
        _PrintExit("DdeUnaccessData() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeUninitialize(DWORD a0)
{
    _PrintEnter("DdeUninitialize(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeUninitialize(a0);
    } __finally {
        _PrintExit("DdeUninitialize() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DebugActiveProcess(DWORD a0)
{
    _PrintEnter("DebugActiveProcess(pid=%d)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DebugActiveProcess(a0);
    } __finally {
        _PrintExit("DebugActiveProcess() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DebugActiveProcessStop(DWORD a0)
{
    _PrintEnter("DebugActiveProcessStop(pid=%d)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DebugActiveProcess(a0);
    } __finally {
        _PrintExit("DebugActiveProcessStop() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_DebugBreak(void)
{
    _PrintEnter("DebugBreak()\n");

    __try {
        Real_DebugBreak();
    } __finally {
        _PrintExit("DebugBreak() ->\n");
    };
}

LRESULT __stdcall Mine_DefDlgProcA(HWND a0,
                                   UINT a1,
                                   WPARAM a2,
                                   LPARAM a3)
{
    _PrintEnter("DefDlgProcA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefDlgProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefDlgProcA(,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefDlgProcW(HWND a0,
                                   UINT a1,
                                   WPARAM a2,
                                   LPARAM a3)
{
    _PrintEnter("DefDlgProcW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefDlgProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefDlgProcW(,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefFrameProcA(HWND a0,
                                     HWND a1,
                                     UINT a2,
                                     WPARAM a3,
                                     LPARAM a4)
{
    _PrintEnter("DefFrameProcA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_DefFrameProcA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DefFrameProcA(,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefFrameProcW(HWND a0,
                                     HWND a1,
                                     UINT a2,
                                     WPARAM a3,
                                     LPARAM a4)
{
    _PrintEnter("DefFrameProcW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_DefFrameProcW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DefFrameProcW(,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefMDIChildProcA(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
{
    _PrintEnter("DefMDIChildProcA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefMDIChildProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefMDIChildProcA(,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefMDIChildProcW(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
{
    _PrintEnter("DefMDIChildProcW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefMDIChildProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefMDIChildProcW(,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefWindowProcA(HWND a0,
                                      UINT a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("DefWindowProcA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefWindowProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefWindowProcA(,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefWindowProcW(HWND a0,
                                      UINT a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("DefWindowProcW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefWindowProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefWindowProcW(,,,) -> %p\n", rv);
    };
    return rv;
}

HDWP __stdcall Mine_DeferWindowPos(HDWP a0,
                                   HWND a1,
                                   HWND a2,
                                   int a3,
                                   int a4,
                                   int a5,
                                   int a6,
                                   UINT a7)
{
    _PrintEnter("DeferWindowPos(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HDWP rv = 0;
    __try {
        rv = Real_DeferWindowPos(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DeferWindowPos(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DefineDosDeviceA(DWORD a0,
                                     LPCSTR a1,
                                     LPCSTR a2)
{
    _PrintEnter("DefineDosDeviceA(%p,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DefineDosDeviceA(a0, a1, a2);
    } __finally {
        _PrintExit("DefineDosDeviceA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DefineDosDeviceW(DWORD a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2)
{
    _PrintEnter("DefineDosDeviceW(%p,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DefineDosDeviceW(a0, a1, a2);
    } __finally {
        _PrintExit("DefineDosDeviceW(,,) -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_DeleteAtom(ATOM a0)
{
    _PrintEnter("DeleteAtom(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_DeleteAtom(a0);
    } __finally {
        _PrintExit("DeleteAtom() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteColorSpace(HCOLORSPACE a0)
{
    _PrintEnter("DeleteColorSpace(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteColorSpace(a0);
    } __finally {
        _PrintExit("DeleteColorSpace() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteDC(HDC a0)
{
    _PrintEnter("DeleteDC(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteDC(a0);
    } __finally {
        _PrintExit("DeleteDC() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteEnhMetaFile(HENHMETAFILE a0)
{
    _PrintEnter("DeleteEnhMetaFile(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteEnhMetaFile(a0);
    } __finally {
        _PrintExit("DeleteEnhMetaFile() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_DeleteFiber(LPVOID a0)
{
    _PrintEnter("DeleteFiber(%p)\n", a0);

    __try {
        Real_DeleteFiber(a0);
    } __finally {
        _PrintExit("DeleteFiber() ->\n");
    };
}

BOOL __stdcall Mine_DeleteFileA(LPCSTR a0)
{
    _PrintEnter("DeleteFileA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteFileA(a0);
    } __finally {
        _PrintExit("DeleteFileA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteFileW(LPCWSTR a0)
{
    _PrintEnter("DeleteFileW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteFileW(a0);
    } __finally {
        _PrintExit("DeleteFileW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteMenu(HMENU a0,
                               UINT a1,
                               UINT a2)
{
    _PrintEnter("DeleteMenu(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteMenu(a0, a1, a2);
    } __finally {
        _PrintExit("DeleteMenu(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteMetaFile(HMETAFILE a0)
{
    _PrintEnter("DeleteMetaFile(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteMetaFile(a0);
    } __finally {
        _PrintExit("DeleteMetaFile() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteObject(HGDIOBJ a0)
{
    _PrintEnter("DeleteObject(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteObject(a0);
    } __finally {
        _PrintExit("DeleteObject() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DescribePixelFormat(HDC a0,
                                       int a1,
                                       UINT a2,
                                       PIXELFORMATDESCRIPTOR* a3)
{
    _PrintEnter("DescribePixelFormat(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_DescribePixelFormat(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DescribePixelFormat(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyAcceleratorTable(HACCEL a0)
{
    _PrintEnter("DestroyAcceleratorTable(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyAcceleratorTable(a0);
    } __finally {
        _PrintExit("DestroyAcceleratorTable() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyCaret(void)
{
    _PrintEnter("DestroyCaret()\n");

    BOOL rv = 0;
    __try {
        rv = Real_DestroyCaret();
    } __finally {
        _PrintExit("DestroyCaret() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyCursor(HCURSOR a0)
{
    _PrintEnter("DestroyCursor(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyCursor(a0);
    } __finally {
        _PrintExit("DestroyCursor() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyIcon(HICON a0)
{
    _PrintEnter("DestroyIcon(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyIcon(a0);
    } __finally {
        _PrintExit("DestroyIcon() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyMenu(HMENU a0)
{
    _PrintEnter("DestroyMenu(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyMenu(a0);
    } __finally {
        _PrintExit("DestroyMenu() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyWindow(HWND a0)
{
    _PrintEnter("DestroyWindow(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyWindow(a0);
    } __finally {
        _PrintExit("DestroyWindow() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeviceIoControl(HANDLE a0,
                                    DWORD a1,
                                    LPVOID a2,
                                    DWORD a3,
                                    LPVOID a4,
                                    DWORD a5,
                                    LPDWORD a6,
                                    LPOVERLAPPED a7)
{
    _PrintEnter("DeviceIoControl(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_DeviceIoControl(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DeviceIoControl(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxIndirectParamA(HINSTANCE a0,
                                               LPCDLGTEMPLATEA a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("DialogBoxIndirectParamA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxIndirectParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxIndirectParamA(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxIndirectParamW(HINSTANCE a0,
                                               LPCDLGTEMPLATEW a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("DialogBoxIndirectParamW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxIndirectParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxIndirectParamW(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxParamA(HINSTANCE a0,
                                       LPCSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("DialogBoxParamA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxParamA(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxParamW(HINSTANCE a0,
                                       LPCWSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("DialogBoxParamW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxParamW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DisableThreadLibraryCalls(HMODULE a0)
{
    _PrintEnter("DisableThreadLibraryCalls(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DisableThreadLibraryCalls(a0);
    } __finally {
        _PrintExit("DisableThreadLibraryCalls() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DisconnectNamedPipe(HANDLE a0)
{
    _PrintEnter("DisconnectNamedPipe(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DisconnectNamedPipe(a0);
    } __finally {
        _PrintExit("DisconnectNamedPipe() -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DispatchMessageA(MSG* a0)
{
    _PrintEnter("DispatchMessageA(%p)\n", a0);

    LRESULT rv = 0;
    __try {
        rv = Real_DispatchMessageA(a0);
    } __finally {
        _PrintExit("DispatchMessageA() -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DispatchMessageW(MSG* a0)
{
    _PrintEnter("DispatchMessageW(%p)\n", a0);

    LRESULT rv = 0;
    __try {
        rv = Real_DispatchMessageW(a0);
    } __finally {
        _PrintExit("DispatchMessageW() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListA(HWND a0,
                               LPSTR a1,
                               int a2,
                               int a3,
                               UINT a4)
{
    _PrintEnter("DlgDirListA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListA(,%hs,,,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListComboBoxA(HWND a0,
                                       LPSTR a1,
                                       int a2,
                                       int a3,
                                       UINT a4)
{
    _PrintEnter("DlgDirListComboBoxA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListComboBoxA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListComboBoxA(,%hs,,,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListComboBoxW(HWND a0,
                                       LPWSTR a1,
                                       int a2,
                                       int a3,
                                       UINT a4)
{
    _PrintEnter("DlgDirListComboBoxW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListComboBoxW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListComboBoxW(,%ls,,,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListW(HWND a0,
                               LPWSTR a1,
                               int a2,
                               int a3,
                               UINT a4)
{
    _PrintEnter("DlgDirListW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListW(,%ls,,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectComboBoxExA(HWND a0,
                                            LPSTR a1,
                                            int a2,
                                            int a3)
{
    _PrintEnter("DlgDirSelectComboBoxExA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectComboBoxExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectComboBoxExA(,%hs,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectComboBoxExW(HWND a0,
                                            LPWSTR a1,
                                            int a2,
                                            int a3)
{
    _PrintEnter("DlgDirSelectComboBoxExW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectComboBoxExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectComboBoxExW(,%ls,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectExA(HWND a0,
                                    LPSTR a1,
                                    int a2,
                                    int a3)
{
    _PrintEnter("DlgDirSelectExA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectExA(,%hs,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectExW(HWND a0,
                                    LPWSTR a1,
                                    int a2,
                                    int a3)
{
    _PrintEnter("DlgDirSelectExW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectExW(,%ls,,) -> %p\n", a1, rv);
    };
    return rv;
}

HRESULT __stdcall Mine_DoDragDrop(IDataObject* a0,
                                  IDropSource* a1,
                                  DWORD a2,
                                  LPDWORD a3)
{
    _PrintEnter("DoDragDrop(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_DoDragDrop(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DoDragDrop(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DosDateTimeToFileTime(WORD a0,
                                          WORD a1,
                                          LPFILETIME a2)
{
    _PrintEnter("DosDateTimeToFileTime(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DosDateTimeToFileTime(a0, a1, a2);
    } __finally {
        _PrintExit("DosDateTimeToFileTime(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DragDetect(HWND a0,
                               POINT a1)
{
    _PrintEnter("DragDetect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DragDetect(a0, a1);
    } __finally {
        _PrintExit("DragDetect(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DragObject(HWND a0,
                                HWND a1,
                                UINT a2,
                                ULONG_PTR a3,
                                HCURSOR a4)
{
    _PrintEnter("DragObject(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DragObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DragObject(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawAnimatedRects(HWND a0,
                                      int a1,
                                      RECT* a2,
                                      RECT* a3)
{
    _PrintEnter("DrawAnimatedRects(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawAnimatedRects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawAnimatedRects(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawCaption(HWND a0,
                                HDC a1,
                                RECT* a2,
                                UINT a3)
{
    _PrintEnter("DrawCaption(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawCaption(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawCaption(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawEdge(HDC a0,
                             LPRECT a1,
                             UINT a2,
                             UINT a3)
{
    _PrintEnter("DrawEdge(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawEdge(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawEdge(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawEscape(HDC a0,
                              int a1,
                              int a2,
                              LPCSTR a3)
{
    _PrintEnter("DrawEscape(%p,%p,%p,%hs)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_DrawEscape(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawEscape(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawFocusRect(HDC a0,
                                  RECT* a1)
{
    _PrintEnter("DrawFocusRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DrawFocusRect(a0, a1);
    } __finally {
        _PrintExit("DrawFocusRect(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawFrameControl(HDC a0,
                                     LPRECT a1,
                                     UINT a2,
                                     UINT a3)
{
    _PrintEnter("DrawFrameControl(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawFrameControl(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawFrameControl(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawIcon(HDC a0,
                             int a1,
                             int a2,
                             HICON a3)
{
    _PrintEnter("DrawIcon(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawIcon(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawIcon(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawIconEx(HDC a0,
                               int a1,
                               int a2,
                               HICON a3,
                               int a4,
                               int a5,
                               UINT a6,
                               HBRUSH a7,
                               UINT a8)
{
    _PrintEnter("DrawIconEx(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_DrawIconEx(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("DrawIconEx(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawMenuBar(HWND a0)
{
    _PrintEnter("DrawMenuBar(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DrawMenuBar(a0);
    } __finally {
        _PrintExit("DrawMenuBar() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawStateA(HDC a0,
                               HBRUSH a1,
                               DRAWSTATEPROC a2,
                               LPARAM a3,
                               WPARAM a4,
                               int a5,
                               int a6,
                               int a7,
                               int a8,
                               UINT a9)
{
    _PrintEnter("DrawStateA(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_DrawStateA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("DrawStateA(,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawStateW(HDC a0,
                               HBRUSH a1,
                               DRAWSTATEPROC a2,
                               LPARAM a3,
                               WPARAM a4,
                               int a5,
                               int a6,
                               int a7,
                               int a8,
                               UINT a9)
{
    _PrintEnter("DrawStateW(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_DrawStateW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("DrawStateW(,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextA(HDC a0,
                             LPCSTR a1,
                             int a2,
                             LPRECT a3,
                             UINT a4)
{
    _PrintEnter("DrawTextA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DrawTextA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DrawTextA(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextExA(HDC a0,
                               LPSTR a1,
                               int a2,
                               LPRECT a3,
                               UINT a4,
                               LPDRAWTEXTPARAMS a5)
{
    _PrintEnter("DrawTextExA(%p,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_DrawTextExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("DrawTextExA(,%hs,,,,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextExW(HDC a0,
                               LPWSTR a1,
                               int a2,
                               LPRECT a3,
                               UINT a4,
                               LPDRAWTEXTPARAMS a5)
{
    _PrintEnter("DrawTextExW(%p,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_DrawTextExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("DrawTextExW(,%ls,,,,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextW(HDC a0,
                             LPCWSTR a1,
                             int a2,
                             LPRECT a3,
                             UINT a4)
{
    _PrintEnter("DrawTextW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DrawTextW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DrawTextW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DuplicateHandle(HANDLE a0,
                                    HANDLE a1,
                                    HANDLE a2,
                                    LPHANDLE a3,
                                    DWORD a4,
                                    BOOL a5,
                                    DWORD a6)
{
    _PrintEnter("DuplicateHandle(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_DuplicateHandle(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("DuplicateHandle(,,,%p,,,) -> %p\n", a3 != NULL ? *a3 : NULL, rv);
    };
    return rv;
}

BOOL __stdcall Mine_Ellipse(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4)
{
    _PrintEnter("Ellipse(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_Ellipse(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Ellipse(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EmptyClipboard(void)
{
    _PrintEnter("EmptyClipboard()\n");

    BOOL rv = 0;
    __try {
        rv = Real_EmptyClipboard();
    } __finally {
        _PrintExit("EmptyClipboard() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableMenuItem(HMENU a0,
                                   UINT a1,
                                   UINT a2)
{
    _PrintEnter("EnableMenuItem(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnableMenuItem(a0, a1, a2);
    } __finally {
        _PrintExit("EnableMenuItem(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableScrollBar(HWND a0,
                                    UINT a1,
                                    UINT a2)
{
    _PrintEnter("EnableScrollBar(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnableScrollBar(a0, a1, a2);
    } __finally {
        _PrintExit("EnableScrollBar(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableWindow(HWND a0,
                                 BOOL a1)
{
    _PrintEnter("EnableWindow(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnableWindow(a0, a1);
    } __finally {
        _PrintExit("EnableWindow(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndDeferWindowPos(HDWP a0)
{
    _PrintEnter("EndDeferWindowPos(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_EndDeferWindowPos(a0);
    } __finally {
        _PrintExit("EndDeferWindowPos() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndDialog(HWND a0,
                              INT_PTR a1)
{
    _PrintEnter("EndDialog(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndDialog(a0, a1);
    } __finally {
        _PrintExit("EndDialog(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EndDoc(HDC a0)
{
    _PrintEnter("EndDoc(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_EndDoc(a0);
    } __finally {
        _PrintExit("EndDoc() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EndPage(HDC a0)
{
    _PrintEnter("EndPage(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_EndPage(a0);
    } __finally {
        _PrintExit("EndPage() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndPaint(HWND a0,
                             PAINTSTRUCT* a1)
{
    _PrintEnter("EndPaint(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndPaint(a0, a1);
    } __finally {
        _PrintExit("EndPaint(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndPath(HDC a0)
{
    _PrintEnter("EndPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_EndPath(a0);
    } __finally {
        _PrintExit("EndPath() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndUpdateResourceA(HANDLE a0,
                                       BOOL a1)
{
    _PrintEnter("EndUpdateResourceA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndUpdateResourceA(a0, a1);
    } __finally {
        _PrintExit("EndUpdateResourceA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndUpdateResourceW(HANDLE a0,
                                       BOOL a1)
{
    _PrintEnter("EndUpdateResourceW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndUpdateResourceW(a0, a1);
    } __finally {
        _PrintExit("EndUpdateResourceW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumCalendarInfoA(CALINFO_ENUMPROCA a0,
                                      LCID a1,
                                      CALID a2,
                                      CALTYPE a3)
{
    _PrintEnter("EnumCalendarInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumCalendarInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumCalendarInfoA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumCalendarInfoW(CALINFO_ENUMPROCW a0,
                                      LCID a1,
                                      CALID a2,
                                      CALTYPE a3)
{
    _PrintEnter("EnumCalendarInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumCalendarInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumCalendarInfoW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumChildWindows(HWND a0,
                                     WNDENUMPROC a1,
                                     LPARAM a2)
{
    _PrintEnter("EnumChildWindows(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumChildWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumChildWindows(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_EnumClipboardFormats(UINT a0)
{
    _PrintEnter("EnumClipboardFormats(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_EnumClipboardFormats(a0);
    } __finally {
        _PrintExit("EnumClipboardFormats() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDateFormatsA(DATEFMT_ENUMPROCA a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumDateFormatsA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDateFormatsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDateFormatsA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDateFormatsW(DATEFMT_ENUMPROCW a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumDateFormatsW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDateFormatsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDateFormatsW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopWindows(HDESK a0,
                                       WNDENUMPROC a1,
                                       LPARAM a2)
{
    _PrintEnter("EnumDesktopWindows(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopWindows(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopsA(HWINSTA a0,
                                  DESKTOPENUMPROCA a1,
                                  LPARAM a2)
{
    _PrintEnter("EnumDesktopsA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopsA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopsW(HWINSTA a0,
                                  DESKTOPENUMPROCW a1,
                                  LPARAM a2)
{
    _PrintEnter("EnumDesktopsW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopsW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDisplaySettingsA(LPCSTR a0,
                                         DWORD a1,
                                         LPDEVMODEA a2)
{
    _PrintEnter("EnumDisplaySettingsA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDisplaySettingsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDisplaySettingsA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDisplaySettingsW(LPCWSTR a0,
                                         DWORD a1,
                                         LPDEVMODEW a2)
{
    _PrintEnter("EnumDisplaySettingsW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDisplaySettingsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDisplaySettingsW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumEnhMetaFile(HDC a0,
                                    HENHMETAFILE a1,
                                    ENHMFENUMPROC a2,
                                    LPVOID a3,
                                    RECT* a4)
{
    _PrintEnter("EnumEnhMetaFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumEnhMetaFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumEnhMetaFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesA(HDC a0,
                                     LPCSTR a1,
                                     FONTENUMPROCA a2,
                                     LPARAM a3)
{
    _PrintEnter("EnumFontFamiliesA(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontFamiliesA(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesExA(HDC a0,
                                       LPLOGFONTA a1,
                                       FONTENUMPROCA a2,
                                       LPARAM a3,
                                       DWORD a4)
{
    _PrintEnter("EnumFontFamiliesExA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumFontFamiliesExA(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesExW(HDC a0,
                                       LPLOGFONTW a1,
                                       FONTENUMPROCW a2,
                                       LPARAM a3,
                                       DWORD a4)
{
    _PrintEnter("EnumFontFamiliesExW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumFontFamiliesExW(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesW(HDC a0,
                                     LPCWSTR a1,
                                     FONTENUMPROCW a2,
                                     LPARAM a3)
{
    _PrintEnter("EnumFontFamiliesW(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontFamiliesW(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontsA(HDC a0,
                              LPCSTR a1,
                              FONTENUMPROCA a2,
                              LPARAM a3)
{
    _PrintEnter("EnumFontsA(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontsA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontsA(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontsW(HDC a0,
                              LPCWSTR a1,
                              FONTENUMPROCW a2,
                              LPARAM a3)
{
    _PrintEnter("EnumFontsW(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontsW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontsW(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumICMProfilesA(HDC a0,
                                    ICMENUMPROCA a1,
                                    LPARAM a2)
{
    _PrintEnter("EnumICMProfilesA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumICMProfilesA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumICMProfilesA(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumICMProfilesW(HDC a0,
                                    ICMENUMPROCW a1,
                                    LPARAM a2)
{
    _PrintEnter("EnumICMProfilesW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumICMProfilesW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumICMProfilesW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumMetaFile(HDC a0,
                                 HMETAFILE a1,
                                 MFENUMPROC a2,
                                 LPARAM a3)
{
    _PrintEnter("EnumMetaFile(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumMetaFile(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumMetaFile(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumObjects(HDC a0,
                               int a1,
                               GOBJENUMPROC a2,
                               LPARAM a3)
{
    _PrintEnter("EnumObjects(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumObjects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumObjects(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsA(HWND a0,
                              PROPENUMPROCA a1)
{
    _PrintEnter("EnumPropsA(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_EnumPropsA(a0, a1);
    } __finally {
        _PrintExit("EnumPropsA(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsExA(HWND a0,
                                PROPENUMPROCEXA a1,
                                LPARAM a2)
{
    _PrintEnter("EnumPropsExA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumPropsExA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumPropsExA(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsExW(HWND a0,
                                PROPENUMPROCEXW a1,
                                LPARAM a2)
{
    _PrintEnter("EnumPropsExW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumPropsExW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumPropsExW(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsW(HWND a0,
                              PROPENUMPROCW a1)
{
    _PrintEnter("EnumPropsW(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_EnumPropsW(a0, a1);
    } __finally {
        _PrintExit("EnumPropsW(,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceLanguagesA(HMODULE a0,
                                           LPCSTR a1,
                                           LPCSTR a2,
                                           ENUMRESLANGPROC a3,
                                           LONG_PTR a4)
#else
BOOL __stdcall Mine_EnumResourceLanguagesA(HMODULE a0,
                                           LPCSTR a1,
                                           LPCSTR a2,
                                           ENUMRESLANGPROCA a3,
                                           LONG_PTR a4)
#endif
{
    _PrintEnter("EnumResourceLanguagesA(%p,%hs,%hs,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceLanguagesA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumResourceLanguagesA(,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceLanguagesW(HMODULE a0,
                                           LPCWSTR a1,
                                           LPCWSTR a2,
                                           ENUMRESLANGPROC a3,
                                           LONG_PTR a4)
#else
BOOL __stdcall Mine_EnumResourceLanguagesW(HMODULE a0,
                                           LPCWSTR a1,
                                           LPCWSTR a2,
                                           ENUMRESLANGPROCW a3,
                                           LONG_PTR a4)
#endif
{
    _PrintEnter("EnumResourceLanguagesW(%p,%ls,%ls,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceLanguagesW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumResourceLanguagesW(,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceNamesA(HMODULE a0,
                                       LPCSTR a1,
                                       ENUMRESNAMEPROC a2,
                                       LONG_PTR a3)
#else
BOOL __stdcall Mine_EnumResourceNamesA(HMODULE a0,
                                       LPCSTR a1,
                                       ENUMRESNAMEPROCA a2,
                                       LONG_PTR a3)
#endif
{
    _PrintEnter("EnumResourceNamesA(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceNamesA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumResourceNamesA(,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceNamesW(HMODULE a0,
                                       LPCWSTR a1,
                                       ENUMRESNAMEPROC a2,
                                       LONG_PTR a3)
#else
BOOL __stdcall Mine_EnumResourceNamesW(HMODULE a0,
                                       LPCWSTR a1,
                                       ENUMRESNAMEPROCW a2,
                                       LONG_PTR a3)
#endif
{
    _PrintEnter("EnumResourceNamesW(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceNamesW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumResourceNamesW(,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceTypesA(HMODULE a0,
                                       ENUMRESTYPEPROC a1,
                                       LONG_PTR a2)
#else
BOOL __stdcall Mine_EnumResourceTypesA(HMODULE a0,
                                       ENUMRESTYPEPROCA a1,
                                       LONG_PTR a2)
#endif
{
    _PrintEnter("EnumResourceTypesA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceTypesA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumResourceTypesA(,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
BOOL __stdcall Mine_EnumResourceTypesW(HMODULE a0,
                                       ENUMRESTYPEPROC a1,
                                       LONG_PTR a2)
#else
BOOL __stdcall Mine_EnumResourceTypesW(HMODULE a0,
                                       ENUMRESTYPEPROCW a1,
                                       LONG_PTR a2)
#endif
{
    _PrintEnter("EnumResourceTypesW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceTypesW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumResourceTypesW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemCodePagesA(CODEPAGE_ENUMPROCA a0,
                                         DWORD a1)
{
    _PrintEnter("EnumSystemCodePagesA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemCodePagesA(a0, a1);
    } __finally {
        _PrintExit("EnumSystemCodePagesA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemCodePagesW(CODEPAGE_ENUMPROCW a0,
                                         DWORD a1)
{
    _PrintEnter("EnumSystemCodePagesW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemCodePagesW(a0, a1);
    } __finally {
        _PrintExit("EnumSystemCodePagesW(,) -> %p\n", rv);
    };
    return rv;
}

#if(WINVER >= 0x0500)
BOOL __stdcall Mine_EnumSystemLocalesA(LOCALE_ENUMPROCA a0,
                                       DWORD a1)
{
    _PrintEnter("EnumSystemLocalesA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemLocalesA(a0, a1);
    } __finally {
        _PrintExit("EnumSystemLocalesA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemLocalesW(LOCALE_ENUMPROCW a0,
                                       DWORD a1)
{
    _PrintEnter("EnumSystemLocalesW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemLocalesW(a0, a1);
    } __finally {
        _PrintExit("EnumSystemLocalesW(,) -> %p\n", rv);
    };
    return rv;
}
#endif // (WINVER >= 0x0500)

BOOL __stdcall Mine_EnumThreadWindows(DWORD a0,
                                      WNDENUMPROC a1,
                                      LPARAM a2)
{
    _PrintEnter("EnumThreadWindows(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumThreadWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumThreadWindows(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumTimeFormatsA(TIMEFMT_ENUMPROCA a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumTimeFormatsA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumTimeFormatsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumTimeFormatsA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumTimeFormatsW(TIMEFMT_ENUMPROCW a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumTimeFormatsW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumTimeFormatsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumTimeFormatsW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindowStationsA(WINSTAENUMPROCA a0,
                                        LPARAM a1)
{
    _PrintEnter("EnumWindowStationsA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindowStationsA(a0, a1);
    } __finally {
        _PrintExit("EnumWindowStationsA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindowStationsW(WINSTAENUMPROCW a0,
                                        LPARAM a1)
{
    _PrintEnter("EnumWindowStationsW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindowStationsW(a0, a1);
    } __finally {
        _PrintExit("EnumWindowStationsW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindows(WNDENUMPROC a0,
                                LPARAM a1)
{
    _PrintEnter("EnumWindows(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindows(a0, a1);
    } __finally {
        _PrintExit("EnumWindows(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EqualRect(RECT* a0,
                              RECT* a1)
{
    _PrintEnter("EqualRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EqualRect(a0, a1);
    } __finally {
        _PrintExit("EqualRect(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EqualRgn(HRGN a0,
                             HRGN a1)
{
    _PrintEnter("EqualRgn(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EqualRgn(a0, a1);
    } __finally {
        _PrintExit("EqualRgn(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_EraseTape(HANDLE a0,
                               DWORD a1,
                               BOOL a2)
{
    _PrintEnter("EraseTape(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_EraseTape(a0, a1, a2);
    } __finally {
        _PrintExit("EraseTape(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_Escape(HDC a0,
                          int a1,
                          int a2,
                          LPCSTR a3,
                          LPVOID a4)
{
    _PrintEnter("Escape(%p,%p,%p,%hs,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_Escape(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Escape(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EscapeCommFunction(HANDLE a0,
                                       DWORD a1)
{
    _PrintEnter("EscapeCommFunction(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EscapeCommFunction(a0, a1);
    } __finally {
        _PrintExit("EscapeCommFunction(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExcludeClipRect(HDC a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   int a4)
{
    _PrintEnter("ExcludeClipRect(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_ExcludeClipRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExcludeClipRect(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExcludeUpdateRgn(HDC a0,
                                    HWND a1)
{
    _PrintEnter("ExcludeUpdateRgn(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ExcludeUpdateRgn(a0, a1);
    } __finally {
        _PrintExit("ExcludeUpdateRgn(,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_ExitProcess(UINT a0)
{
    _PrintEnter("ExitProcess(%p)\n", a0);

    __try {
        Real_ExitProcess(a0);
    } __finally {
        _PrintExit("ExitProcess() ->\n");
    };
}

void __stdcall Mine_ExitThread(DWORD a0)
{
    _PrintEnter("ExitThread(%p)\n", a0);

    __try {
        Real_ExitThread(a0);
    } __finally {
        _PrintExit("ExitThread() ->\n");
    };
}

BOOL __stdcall Mine_ExitWindowsEx(UINT a0,
                                  DWORD a1)
{
    _PrintEnter("ExitWindowsEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ExitWindowsEx(a0, a1);
    } __finally {
        _PrintExit("ExitWindowsEx(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_ExpandEnvironmentStringsA(LPCSTR a0,
                                               LPSTR a1,
                                               DWORD a2)
{
    _PrintEnter("ExpandEnvironmentStringsA(%hs,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_ExpandEnvironmentStringsA(a0, a1, a2);
    } __finally {
        _PrintExit("ExpandEnvironmentStringsA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_ExpandEnvironmentStringsW(LPCWSTR a0,
                                               LPWSTR a1,
                                               DWORD a2)
{
    _PrintEnter("ExpandEnvironmentStringsW(%ls,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_ExpandEnvironmentStringsW(a0, a1, a2);
    } __finally {
        _PrintExit("ExpandEnvironmentStringsW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

HPEN __stdcall Mine_ExtCreatePen(DWORD a0,
                                 DWORD a1,
                                 LOGBRUSH* a2,
                                 DWORD a3,
                                 DWORD* a4)
{
    _PrintEnter("ExtCreatePen(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HPEN rv = 0;
    __try {
        rv = Real_ExtCreatePen(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExtCreatePen(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_ExtCreateRegion(XFORM* a0,
                                    DWORD a1,
                                    RGNDATA* a2)
{
    _PrintEnter("ExtCreateRegion(%p,%p,%p)\n", a0, a1, a2);

    HRGN rv = 0;
    __try {
        rv = Real_ExtCreateRegion(a0, a1, a2);
    } __finally {
        _PrintExit("ExtCreateRegion(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExtEscape(HDC a0,
                             int a1,
                             int a2,
                             LPCSTR a3,
                             int a4,
                             LPSTR a5)
{
    _PrintEnter("ExtEscape(%p,%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ExtEscape(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ExtEscape(,,,,,%hs) -> %p\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtFloodFill(HDC a0,
                                 int a1,
                                 int a2,
                                 COLORREF a3,
                                 UINT a4)
{
    _PrintEnter("ExtFloodFill(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ExtFloodFill(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExtFloodFill(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExtSelectClipRgn(HDC a0,
                                    HRGN a1,
                                    int a2)
{
    _PrintEnter("ExtSelectClipRgn(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_ExtSelectClipRgn(a0, a1, a2);
    } __finally {
        _PrintExit("ExtSelectClipRgn(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtTextOutA(HDC a0,
                                int a1,
                                int a2,
                                UINT a3,
                                RECT* a4,
                                LPCSTR a5,
                                UINT a6,
                                INT* a7)
{
    _PrintEnter("ExtTextOutA(%p,%p,%p,%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ExtTextOutA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ExtTextOutA(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtTextOutW(HDC a0,
                                int a1,
                                int a2,
                                UINT a3,
                                RECT* a4,
                                LPCWSTR a5,
                                UINT a6,
                                INT* a7)
{
    _PrintEnter("ExtTextOutW(%p,%p,%p,%p,%p,%ls,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ExtTextOutW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ExtTextOutW(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_FatalAppExitA(UINT a0,
                                  LPCSTR a1)
{
    _PrintEnter("FatalAppExitA(%p,%hs)\n", a0, a1);

    __try {
        Real_FatalAppExitA(a0, a1);
    } __finally {
        _PrintExit("FatalAppExitA(,) ->\n");
    };
}

void __stdcall Mine_FatalAppExitW(UINT a0,
                                  LPCWSTR a1)
{
    _PrintEnter("FatalAppExitW(%p,%ls)\n", a0, a1);

    __try {
        Real_FatalAppExitW(a0, a1);
    } __finally {
        _PrintExit("FatalAppExitW(,) ->\n");
    };
}

void __stdcall Mine_FatalExit(int a0)
{
    _PrintEnter("FatalExit(%p)\n", a0);

    __try {
        Real_FatalExit(a0);
    } __finally {
        _PrintExit("FatalExit() ->\n");
    };
}

BOOL __stdcall Mine_FileTimeToDosDateTime(FILETIME* a0,
                                          LPWORD a1,
                                          LPWORD a2)
{
    _PrintEnter("FileTimeToDosDateTime(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToDosDateTime(a0, a1, a2);
    } __finally {
        _PrintExit("FileTimeToDosDateTime(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FileTimeToLocalFileTime(FILETIME* a0,
                                            LPFILETIME a1)
{
    _PrintEnter("FileTimeToLocalFileTime(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToLocalFileTime(a0, a1);
    } __finally {
        _PrintExit("FileTimeToLocalFileTime(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FileTimeToSystemTime(FILETIME* a0,
                                         LPSYSTEMTIME a1)
{
    _PrintEnter("FileTimeToSystemTime(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToSystemTime(a0, a1);
    } __finally {
        _PrintExit("FileTimeToSystemTime(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputAttribute(HANDLE a0,
                                               WORD a1,
                                               DWORD a2,
                                               COORD a3,
                                               LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputAttribute(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputAttribute(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputCharacterA(HANDLE a0,
                                                CHAR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputCharacterA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputCharacterA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputCharacterW(HANDLE a0,
                                                WCHAR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputCharacterW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputCharacterW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillPath(HDC a0)
{
    _PrintEnter("FillPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FillPath(a0);
    } __finally {
        _PrintExit("FillPath() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_FillRect(HDC a0,
                            RECT* a1,
                            HBRUSH a2)
{
    _PrintEnter("FillRect(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_FillRect(a0, a1, a2);
    } __finally {
        _PrintExit("FillRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillRgn(HDC a0,
                            HRGN a1,
                            HBRUSH a2)
{
    _PrintEnter("FillRgn(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_FillRgn(a0, a1, a2);
    } __finally {
        _PrintExit("FillRgn(,,) -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_FindAtomA(LPCSTR a0)
{
    _PrintEnter("FindAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_FindAtomA(a0);
    } __finally {
        _PrintExit("FindAtomA() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_FindAtomW(LPCWSTR a0)
{
    _PrintEnter("FindAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_FindAtomW(a0);
    } __finally {
        _PrintExit("FindAtomW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindClose(HANDLE a0)
{
    _PrintEnter("FindClose(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindClose(a0);
    } __finally {
        _PrintExit("FindClose() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindCloseChangeNotification(HANDLE a0)
{
    _PrintEnter("FindCloseChangeNotification(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindCloseChangeNotification(a0);
    } __finally {
        _PrintExit("FindCloseChangeNotification() -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstChangeNotificationA(LPCSTR a0,
                                                   BOOL a1,
                                                   DWORD a2)
{
    _PrintEnter("FindFirstChangeNotificationA(%hs,%p,%p)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstChangeNotificationA(a0, a1, a2);
    } __finally {
        _PrintExit("FindFirstChangeNotificationA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstChangeNotificationW(LPCWSTR a0,
                                                   BOOL a1,
                                                   DWORD a2)
{
    _PrintEnter("FindFirstChangeNotificationW(%ls,%p,%p)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstChangeNotificationW(a0, a1, a2);
    } __finally {
        _PrintExit("FindFirstChangeNotificationW(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileA(LPCSTR a0,
                                     LPWIN32_FIND_DATAA a1)
{
    _PrintEnter("FindFirstFileA(%hs,%p)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileA(a0, a1);
    } __finally {
        _PrintExit("FindFirstFileA(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileExA(LPCSTR a0,
                                       FINDEX_INFO_LEVELS a1,
                                       LPVOID a2,
                                       FINDEX_SEARCH_OPS a3,
                                       LPVOID a4,
                                       DWORD a5)
{
    _PrintEnter("FindFirstFileExA(%hs,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("FindFirstFileExA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileExW(LPCWSTR a0,
                                       FINDEX_INFO_LEVELS a1,
                                       LPVOID a2,
                                       FINDEX_SEARCH_OPS a3,
                                       LPVOID a4,
                                       DWORD a5)
{
    _PrintEnter("FindFirstFileExW(%ls,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("FindFirstFileExW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileW(LPCWSTR a0,
                                     LPWIN32_FIND_DATAW a1)
{
    _PrintEnter("FindFirstFileW(%ls,%p)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileW(a0, a1);
    } __finally {
        _PrintExit("FindFirstFileW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextChangeNotification(HANDLE a0)
{
    _PrintEnter("FindNextChangeNotification(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextChangeNotification(a0);
    } __finally {
        _PrintExit("FindNextChangeNotification() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextFileA(HANDLE a0,
                                  LPWIN32_FIND_DATAA a1)
{
    _PrintEnter("FindNextFileA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextFileA(a0, a1);
    } __finally {
        _PrintExit("FindNextFileA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextFileW(HANDLE a0,
                                  LPWIN32_FIND_DATAW a1)
{
    _PrintEnter("FindNextFileW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextFileW(a0, a1);
    } __finally {
        _PrintExit("FindNextFileW(,) -> %p\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceA(HMODULE a0,
                                   LPCSTR a1,
                                   LPCSTR a2)
{
    _PrintEnter("FindResourceA(%p,%hs,%hs)\n", a0, a1, a2);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceA(a0, a1, a2);
    } __finally {
        _PrintExit("FindResourceA(,,) -> %p\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceExA(HMODULE a0,
                                     LPCSTR a1,
                                     LPCSTR a2,
                                     WORD a3)
{
    _PrintEnter("FindResourceExA(%p,%hs,%hs,%p)\n", a0, a1, a2, a3);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindResourceExA(,,,) -> %p\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceExW(HMODULE a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2,
                                     WORD a3)
{
    _PrintEnter("FindResourceExW(%p,%ls,%ls,%p)\n", a0, a1, a2, a3);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindResourceExW(,,,) -> %p\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceW(HMODULE a0,
                                   LPCWSTR a1,
                                   LPCWSTR a2)
{
    _PrintEnter("FindResourceW(%p,%ls,%ls)\n", a0, a1, a2);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceW(a0, a1, a2);
    } __finally {
        _PrintExit("FindResourceW(,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowA(LPCSTR a0,
                                LPCSTR a1)
{
    _PrintEnter("FindWindowA(%hs,%hs)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowA(a0, a1);
    } __finally {
        _PrintExit("FindWindowA(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowExA(HWND a0,
                                  HWND a1,
                                  LPCSTR a2,
                                  LPCSTR a3)
{
    _PrintEnter("FindWindowExA(%p,%p,%hs,%hs)\n", a0, a1, a2, a3);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindWindowExA(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowExW(HWND a0,
                                  HWND a1,
                                  LPCWSTR a2,
                                  LPCWSTR a3)
{
    _PrintEnter("FindWindowExW(%p,%p,%ls,%ls)\n", a0, a1, a2, a3);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindWindowExW(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowW(LPCWSTR a0,
                                LPCWSTR a1)
{
    _PrintEnter("FindWindowW(%ls,%ls)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowW(a0, a1);
    } __finally {
        _PrintExit("FindWindowW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FixBrushOrgEx(HDC a0,
                                  int a1,
                                  int a2,
                                  POINT* a3)
{
    _PrintEnter("FixBrushOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_FixBrushOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FixBrushOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlashWindow(HWND a0,
                                BOOL a1)
{
    _PrintEnter("FlashWindow(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FlashWindow(a0, a1);
    } __finally {
        _PrintExit("FlashWindow(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlattenPath(HDC a0)
{
    _PrintEnter("FlattenPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlattenPath(a0);
    } __finally {
        _PrintExit("FlattenPath() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FloodFill(HDC a0,
                              int a1,
                              int a2,
                              COLORREF a3)
{
    _PrintEnter("FloodFill(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_FloodFill(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FloodFill(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushConsoleInputBuffer(HANDLE a0)
{
    _PrintEnter("FlushConsoleInputBuffer(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlushConsoleInputBuffer(a0);
    } __finally {
        _PrintExit("FlushConsoleInputBuffer() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushFileBuffers(HANDLE a0)
{
    _PrintEnter("FlushFileBuffers(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlushFileBuffers(a0);
    } __finally {
        _PrintExit("FlushFileBuffers() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushViewOfFile(LPCVOID a0,
                                    SIZE_T a1)
{
    _PrintEnter("FlushViewOfFile(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FlushViewOfFile(a0, a1);
    } __finally {
        _PrintExit("FlushViewOfFile(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_FmtIdToPropStgName(FMTID* a0,
                                          LPOLESTR a1)
{
    _PrintEnter("FmtIdToPropStgName(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_FmtIdToPropStgName(a0, a1);
    } __finally {
        _PrintExit("FmtIdToPropStgName(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_FoldStringA(DWORD a0,
                               LPCSTR a1,
                               int a2,
                               LPSTR a3,
                               int a4)
{
    _PrintEnter("FoldStringA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_FoldStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FoldStringA(,,,%hs,) -> %p\n", a3, rv);
    };
    return rv;
}

int __stdcall Mine_FoldStringW(DWORD a0,
                               LPCWSTR a1,
                               int a2,
                               LPWSTR a3,
                               int a4)
{
    _PrintEnter("FoldStringW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_FoldStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FoldStringW(,,,%ls,) -> %p\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_FormatMessageA(DWORD a0,
                                    LPCVOID a1,
                                    DWORD a2,
                                    DWORD a3,
                                    LPSTR a4,
                                    DWORD a5,
                                    va_list* a6)
{
    _PrintEnter("FormatMessageA(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_FormatMessageA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("FormatMessageA(,,,,%hs,,) -> %p\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_FormatMessageW(DWORD a0,
                                    LPCVOID a1,
                                    DWORD a2,
                                    DWORD a3,
                                    LPWSTR a4,
                                    DWORD a5,
                                    va_list* a6)
{
    _PrintEnter("FormatMessageW(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_FormatMessageW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("FormatMessageW(,,,,%ls,,) -> %p\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_FrameRect(HDC a0,
                             RECT* a1,
                             HBRUSH a2)
{
    _PrintEnter("FrameRect(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_FrameRect(a0, a1, a2);
    } __finally {
        _PrintExit("FrameRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FrameRgn(HDC a0,
                             HRGN a1,
                             HBRUSH a2,
                             int a3,
                             int a4)
{
    _PrintEnter("FrameRgn(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FrameRgn(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FrameRgn(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeConsole(void)
{
    _PrintEnter("FreeConsole()\n");

    BOOL rv = 0;
    __try {
        rv = Real_FreeConsole();
    } __finally {
        _PrintExit("FreeConsole() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeDDElParam(UINT a0,
                                  LPARAM a1)
{
    _PrintEnter("FreeDDElParam(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FreeDDElParam(a0, a1);
    } __finally {
        _PrintExit("FreeDDElParam(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeEnvironmentStringsA(LPSTR a0)
{
    _PrintEnter("FreeEnvironmentStringsA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeEnvironmentStringsA(a0);
    } __finally {
        _PrintExit("FreeEnvironmentStringsA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeEnvironmentStringsW(LPWSTR a0)
{
    _PrintEnter("FreeEnvironmentStringsW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeEnvironmentStringsW(a0);
    } __finally {
        _PrintExit("FreeEnvironmentStringsW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeLibrary(HMODULE a0)
{
    _PrintEnter("FreeLibrary(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeLibrary(a0);
    } __finally {
        _PrintExit("FreeLibrary() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_FreeLibraryAndExitThread(HMODULE a0,
                                             DWORD a1)
{
    _PrintEnter("FreeLibraryAndExitThread(%p,%p)\n", a0, a1);

    __try {
        Real_FreeLibraryAndExitThread(a0, a1);
    } __finally {
        _PrintExit("FreeLibraryAndExitThread(,) ->\n");
    };
}

HRESULT __stdcall Mine_FreePropVariantArray(ULONG a0,
                                            PROPVARIANT* a1)
{
    _PrintEnter("FreePropVariantArray(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_FreePropVariantArray(a0, a1);
    } __finally {
        _PrintExit("FreePropVariantArray(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeResource(HGLOBAL a0)
{
    _PrintEnter("FreeResource(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeResource(a0);
    } __finally {
        _PrintExit("FreeResource() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GdiComment(HDC a0,
                               UINT a1,
                               BYTE* a2)
{
    _PrintEnter("GdiComment(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GdiComment(a0, a1, a2);
    } __finally {
        _PrintExit("GdiComment(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GdiFlush(void)
{
    _PrintEnter("GdiFlush()\n");

    BOOL rv = 0;
    __try {
        rv = Real_GdiFlush();
    } __finally {
        _PrintExit("GdiFlush() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GdiGetBatchLimit(void)
{
    _PrintEnter("GdiGetBatchLimit()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GdiGetBatchLimit();
    } __finally {
        _PrintExit("GdiGetBatchLimit() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GdiSetBatchLimit(DWORD a0)
{
    _PrintEnter("GdiSetBatchLimit(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GdiSetBatchLimit(a0);
    } __finally {
        _PrintExit("GdiSetBatchLimit() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GenerateConsoleCtrlEvent(DWORD a0,
                                             DWORD a1)
{
    _PrintEnter("GenerateConsoleCtrlEvent(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GenerateConsoleCtrlEvent(a0, a1);
    } __finally {
        _PrintExit("GenerateConsoleCtrlEvent(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetACP(void)
{
    _PrintEnter("GetACP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetACP();
    } __finally {
        _PrintExit("GetACP() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetActiveWindow(void)
{
    _PrintEnter("GetActiveWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetActiveWindow();
    } __finally {
        _PrintExit("GetActiveWindow() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetArcDirection(HDC a0)
{
    _PrintEnter("GetArcDirection(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetArcDirection(a0);
    } __finally {
        _PrintExit("GetArcDirection() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetAspectRatioFilterEx(HDC a0,
                                           SIZE* a1)
{
    _PrintEnter("GetAspectRatioFilterEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetAspectRatioFilterEx(a0, a1);
    } __finally {
        _PrintExit("GetAspectRatioFilterEx(,) -> %p\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_GetAsyncKeyState(int a0)
{
    _PrintEnter("GetAsyncKeyState(%p)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_GetAsyncKeyState(a0);
    } __finally {
        _PrintExit("GetAsyncKeyState() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetAtomNameA(ATOM a0,
                                 LPSTR a1,
                                 int a2)
{
    _PrintEnter("GetAtomNameA(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetAtomNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetAtomNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetAtomNameW(ATOM a0,
                                 LPWSTR a1,
                                 int a2)
{
    _PrintEnter("GetAtomNameW(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetAtomNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetAtomNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBinaryTypeA(LPCSTR a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetBinaryTypeA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBinaryTypeA(a0, a1);
    } __finally {
        _PrintExit("GetBinaryTypeA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBinaryTypeW(LPCWSTR a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetBinaryTypeW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBinaryTypeW(a0, a1);
    } __finally {
        _PrintExit("GetBinaryTypeW(,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetBitmapBits(HBITMAP a0,
                                  LONG a1,
                                  LPVOID a2)
{
    _PrintEnter("GetBitmapBits(%p,%p,%p)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_GetBitmapBits(a0, a1, a2);
    } __finally {
        _PrintExit("GetBitmapBits(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBitmapDimensionEx(HBITMAP a0,
                                         SIZE* a1)
{
    _PrintEnter("GetBitmapDimensionEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBitmapDimensionEx(a0, a1);
    } __finally {
        _PrintExit("GetBitmapDimensionEx(,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetBkColor(HDC a0)
{
    _PrintEnter("GetBkColor(%p)\n", a0);

    COLORREF rv = 0;
    __try {
        rv = Real_GetBkColor(a0);
    } __finally {
        _PrintExit("GetBkColor() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetBkMode(HDC a0)
{
    _PrintEnter("GetBkMode(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetBkMode(a0);
    } __finally {
        _PrintExit("GetBkMode() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetBoundsRect(HDC a0,
                                  LPRECT a1,
                                  UINT a2)
{
    _PrintEnter("GetBoundsRect(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetBoundsRect(a0, a1, a2);
    } __finally {
        _PrintExit("GetBoundsRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBrushOrgEx(HDC a0,
                                  POINT* a1)
{
    _PrintEnter("GetBrushOrgEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBrushOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetBrushOrgEx(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCPInfo(UINT a0,
                              LPCPINFO a1)
{
    _PrintEnter("GetCPInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCPInfo(a0, a1);
    } __finally {
        _PrintExit("GetCPInfo(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetCapture(void)
{
    _PrintEnter("GetCapture()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetCapture();
    } __finally {
        _PrintExit("GetCapture() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetCaretBlinkTime(void)
{
    _PrintEnter("GetCaretBlinkTime()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetCaretBlinkTime();
    } __finally {
        _PrintExit("GetCaretBlinkTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCaretPos(POINT* a0)
{
    _PrintEnter("GetCaretPos(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetCaretPos(a0);
    } __finally {
        _PrintExit("GetCaretPos() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsA(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPABC a3)
{
    _PrintEnter("GetCharABCWidthsA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsFloatA(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           LPABCFLOAT a3)
{
    _PrintEnter("GetCharABCWidthsFloatA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsFloatA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsFloatA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsFloatW(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           LPABCFLOAT a3)
{
    _PrintEnter("GetCharABCWidthsFloatW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsFloatW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsFloatW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsW(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPABC a3)
{
    _PrintEnter("GetCharABCWidthsW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidth32A(HDC a0,
                                    UINT a1,
                                    UINT a2,
                                    LPINT a3)
{
    _PrintEnter("GetCharWidth32A(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidth32A(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidth32A(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidth32W(HDC a0,
                                    UINT a1,
                                    UINT a2,
                                    LPINT a3)
{
    _PrintEnter("GetCharWidth32W(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidth32W(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidth32W(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthA(HDC a0,
                                  UINT a1,
                                  UINT a2,
                                  LPINT a3)
{
    _PrintEnter("GetCharWidthA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthFloatA(HDC a0,
                                       UINT a1,
                                       UINT a2,
                                       PFLOAT a3)
{
    _PrintEnter("GetCharWidthFloatA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthFloatA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthFloatA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthFloatW(HDC a0,
                                       UINT a1,
                                       UINT a2,
                                       PFLOAT a3)
{
    _PrintEnter("GetCharWidthFloatW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthFloatW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthFloatW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthW(HDC a0,
                                  UINT a1,
                                  UINT a2,
                                  LPINT a3)
{
    _PrintEnter("GetCharWidthW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthW(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCharacterPlacementA(HDC a0,
                                            LPCSTR a1,
                                            int a2,
                                            int a3,
                                            LPGCP_RESULTSA a4,
                                            DWORD a5)
{
    _PrintEnter("GetCharacterPlacementA(%p,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetCharacterPlacementA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCharacterPlacementA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCharacterPlacementW(HDC a0,
                                            LPCWSTR a1,
                                            int a2,
                                            int a3,
                                            LPGCP_RESULTSW a4,
                                            DWORD a5)
{
    _PrintEnter("GetCharacterPlacementW(%p,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetCharacterPlacementW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCharacterPlacementW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetClassFile(LPCOLESTR a0,
                                    CLSID* a1)
{
    _PrintEnter("GetClassFile(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetClassFile(a0, a1);
    } __finally {
        _PrintExit("GetClassFile(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoA(HINSTANCE a0,
                                  LPCSTR a1,
                                  LPWNDCLASSA a2)
{
    _PrintEnter("GetClassInfoA(%p,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoExA(HINSTANCE a0,
                                    LPCSTR a1,
                                    LPWNDCLASSEXA a2)
{
    _PrintEnter("GetClassInfoExA(%p,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoExA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoExA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoExW(HINSTANCE a0,
                                    LPCWSTR a1,
                                    LPWNDCLASSEXW a2)
{
    _PrintEnter("GetClassInfoExW(%p,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoExW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoExW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoW(HINSTANCE a0,
                                  LPCWSTR a1,
                                  LPWNDCLASSW a2)
{
    _PrintEnter("GetClassInfoW(%p,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoW(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetClassLongA(HWND a0,
                                   int a1)
{
    _PrintEnter("GetClassLongA(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetClassLongA(a0, a1);
    } __finally {
        _PrintExit("GetClassLongA(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetClassLongW(HWND a0,
                                   int a1)
{
    _PrintEnter("GetClassLongW(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetClassLongW(a0, a1);
    } __finally {
        _PrintExit("GetClassLongW(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClassNameA(HWND a0,
                                 LPSTR a1,
                                 int a2)
{
    _PrintEnter("GetClassNameA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClassNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetClassNameW(HWND a0,
                                 LPWSTR a1,
                                 int a2)
{
    _PrintEnter("GetClassNameW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClassNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

WORD __stdcall Mine_GetClassWord(HWND a0,
                                 int a1)
{
    _PrintEnter("GetClassWord(%p,%p)\n", a0, a1);

    WORD rv = 0;
    __try {
        rv = Real_GetClassWord(a0, a1);
    } __finally {
        _PrintExit("GetClassWord(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClientRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("GetClientRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetClientRect(a0, a1);
    } __finally {
        _PrintExit("GetClientRect(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipBox(HDC a0,
                              LPRECT a1)
{
    _PrintEnter("GetClipBox(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetClipBox(a0, a1);
    } __finally {
        _PrintExit("GetClipBox(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClipCursor(LPRECT a0)
{
    _PrintEnter("GetClipCursor(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetClipCursor(a0);
    } __finally {
        _PrintExit("GetClipCursor() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("GetClipRgn(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetClipRgn(a0, a1);
    } __finally {
        _PrintExit("GetClipRgn(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetClipboardData(UINT a0)
{
    _PrintEnter("GetClipboardData(%p)\n", a0);

    HANDLE rv = 0;
    __try {
        rv = Real_GetClipboardData(a0);
    } __finally {
        _PrintExit("GetClipboardData() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipboardFormatNameA(UINT a0,
                                           LPSTR a1,
                                           int a2)
{
    _PrintEnter("GetClipboardFormatNameA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClipboardFormatNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClipboardFormatNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetClipboardFormatNameW(UINT a0,
                                           LPWSTR a1,
                                           int a2)
{
    _PrintEnter("GetClipboardFormatNameW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClipboardFormatNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClipboardFormatNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

HWND __stdcall Mine_GetClipboardOwner(void)
{
    _PrintEnter("GetClipboardOwner()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetClipboardOwner();
    } __finally {
        _PrintExit("GetClipboardOwner() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetClipboardViewer(void)
{
    _PrintEnter("GetClipboardViewer()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetClipboardViewer();
    } __finally {
        _PrintExit("GetClipboardViewer() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetColorAdjustment(HDC a0,
                                       LPCOLORADJUSTMENT a1)
{
    _PrintEnter("GetColorAdjustment(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetColorAdjustment(a0, a1);
    } __finally {
        _PrintExit("GetColorAdjustment(,) -> %p\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_GetColorSpace(HDC a0)
{
    _PrintEnter("GetColorSpace(%p)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_GetColorSpace(a0);
    } __finally {
        _PrintExit("GetColorSpace() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommConfig(HANDLE a0,
                                  LPCOMMCONFIG a1,
                                  LPDWORD a2)
{
    _PrintEnter("GetCommConfig(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommConfig(a0, a1, a2);
    } __finally {
        _PrintExit("GetCommConfig(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommMask(HANDLE a0,
                                LPDWORD a1)
{
    _PrintEnter("GetCommMask(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommMask(a0, a1);
    } __finally {
        _PrintExit("GetCommMask(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommModemStatus(HANDLE a0,
                                       LPDWORD a1)
{
    _PrintEnter("GetCommModemStatus(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommModemStatus(a0, a1);
    } __finally {
        _PrintExit("GetCommModemStatus(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommProperties(HANDLE a0,
                                      LPCOMMPROP a1)
{
    _PrintEnter("GetCommProperties(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommProperties(a0, a1);
    } __finally {
        _PrintExit("GetCommProperties(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommState(HANDLE a0,
                                 LPDCB a1)
{
    _PrintEnter("GetCommState(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommState(a0, a1);
    } __finally {
        _PrintExit("GetCommState(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommTimeouts(HANDLE a0,
                                    LPCOMMTIMEOUTS a1)
{
    _PrintEnter("GetCommTimeouts(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommTimeouts(a0, a1);
    } __finally {
        _PrintExit("GetCommTimeouts(,) -> %p\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_GetCommandLineA(void)
{
    _PrintEnter("GetCommandLineA()\n");

    LPSTR rv = 0;
    __try {
        rv = Real_GetCommandLineA();
    } __finally {
        _PrintExit("GetCommandLineA() -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_GetCommandLineW(void)
{
    _PrintEnter("GetCommandLineW()\n");

    LPWSTR rv = 0;
    __try {
        rv = Real_GetCommandLineW();
    } __finally {
        _PrintExit("GetCommandLineW() -> %ls\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetComputerNameA(LPSTR a0,
                                     LPDWORD a1)
{
    _PrintEnter("GetComputerNameA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetComputerNameA(a0, a1);
    } __finally {
        _PrintExit("GetComputerNameA(%hs,) -> %p\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetComputerNameW(LPWSTR a0,
                                     LPDWORD a1)
{
    _PrintEnter("GetComputerNameW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetComputerNameW(a0, a1);
    } __finally {
        _PrintExit("GetComputerNameW(%ls,) -> %p\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetConsoleCP(void)
{
    _PrintEnter("GetConsoleCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetConsoleCP();
    } __finally {
        _PrintExit("GetConsoleCP() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleCursorInfo(HANDLE a0,
                                         PCONSOLE_CURSOR_INFO a1)
{
    _PrintEnter("GetConsoleCursorInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleCursorInfo(a0, a1);
    } __finally {
        _PrintExit("GetConsoleCursorInfo(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleMode(HANDLE a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetConsoleMode(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleMode(a0, a1);
    } __finally {
        _PrintExit("GetConsoleMode(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetConsoleOutputCP(void)
{
    _PrintEnter("GetConsoleOutputCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetConsoleOutputCP();
    } __finally {
        _PrintExit("GetConsoleOutputCP() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleScreenBufferInfo(HANDLE a0,
                                               PCONSOLE_SCREEN_BUFFER_INFO a1)
{
    _PrintEnter("GetConsoleScreenBufferInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleScreenBufferInfo(a0, a1);
    } __finally {
        _PrintExit("GetConsoleScreenBufferInfo(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetConsoleTitleA(LPSTR a0,
                                      DWORD a1)
{
    _PrintEnter("GetConsoleTitleA(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetConsoleTitleA(a0, a1);
    } __finally {
        _PrintExit("GetConsoleTitleA(%hs,) -> %p\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetConsoleTitleW(LPWSTR a0,
                                      DWORD a1)
{
    _PrintEnter("GetConsoleTitleW(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetConsoleTitleW(a0, a1);
    } __finally {
        _PrintExit("GetConsoleTitleW(%ls,) -> %p\n", a0, rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetConvertStg(LPSTORAGE a0)
{
    _PrintEnter("GetConvertStg(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_GetConvertStg(a0);
    } __finally {
        _PrintExit("GetConvertStg() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetCurrencyFormatA(LCID a0,
                                      DWORD a1,
                                      LPCSTR a2,
                                      CURRENCYFMTA* a3,
                                      LPSTR a4,
                                      int a5)
{
    _PrintEnter("GetCurrencyFormatA(%p,%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetCurrencyFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCurrencyFormatA(,,,,%hs,) -> %p\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetCurrencyFormatW(LCID a0,
                                      DWORD a1,
                                      LPCWSTR a2,
                                      CURRENCYFMTW* a3,
                                      LPWSTR a4,
                                      int a5)
{
    _PrintEnter("GetCurrencyFormatW(%p,%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetCurrencyFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCurrencyFormatW(,,,,%ls,) -> %p\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentDirectoryA(DWORD a0,
                                          LPSTR a1)
{
    _PrintEnter("GetCurrentDirectoryA(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetCurrentDirectoryA(,%hs) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentDirectoryW(DWORD a0,
                                          LPWSTR a1)
{
    _PrintEnter("GetCurrentDirectoryW(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetCurrentDirectoryW(,%ls) -> %p\n", a1, rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_GetCurrentObject(HDC a0,
                                        UINT a1)
{
    _PrintEnter("GetCurrentObject(%p,%p)\n", a0, a1);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_GetCurrentObject(a0, a1);
    } __finally {
        _PrintExit("GetCurrentObject(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCurrentPositionEx(HDC a0,
                                         POINT* a1)
{
    _PrintEnter("GetCurrentPositionEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCurrentPositionEx(a0, a1);
    } __finally {
        _PrintExit("GetCurrentPositionEx(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetCurrentProcess(void)
{
    _PrintEnter("GetCurrentProcess()\n");

    HANDLE rv = 0;
    __try {
        rv = Real_GetCurrentProcess();
    } __finally {
        _PrintExit("GetCurrentProcess() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentProcessId(void)
{
    _PrintEnter("GetCurrentProcessId()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentProcessId();
    } __finally {
        _PrintExit("GetCurrentProcessId() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentThreadId(void)
{
    _PrintEnter("GetCurrentThreadId()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentThreadId();
    } __finally {
        _PrintExit("GetCurrentThreadId() -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_GetCursor(void)
{
    _PrintEnter("GetCursor()\n");

    HCURSOR rv = 0;
    __try {
        rv = Real_GetCursor();
    } __finally {
        _PrintExit("GetCursor() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCursorPos(POINT* a0)
{
    _PrintEnter("GetCursorPos(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetCursorPos(a0);
    } __finally {
        _PrintExit("GetCursorPos() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetDC(HWND a0)
{
    _PrintEnter("GetDC(%p)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_GetDC(a0);
    } __finally {
        _PrintExit("GetDC() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetDCEx(HWND a0,
                           HRGN a1,
                           DWORD a2)
{
    _PrintEnter("GetDCEx(%p,%p,%p)\n", a0, a1, a2);

    HDC rv = 0;
    __try {
        rv = Real_GetDCEx(a0, a1, a2);
    } __finally {
        _PrintExit("GetDCEx(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDCOrgEx(HDC a0,
                               POINT* a1)
{
    _PrintEnter("GetDCOrgEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetDCOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetDCOrgEx(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDIBColorTable(HDC a0,
                                     UINT a1,
                                     UINT a2,
                                     RGBQUAD* a3)
{
    _PrintEnter("GetDIBColorTable(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDIBColorTable(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDIBColorTable(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDIBits(HDC a0,
                             HBITMAP a1,
                             UINT a2,
                             UINT a3,
                             LPVOID a4,
                             LPBITMAPINFO a5,
                             UINT a6)
{
    _PrintEnter("GetDIBits(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_GetDIBits(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetDIBits(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDateFormatA(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCSTR a3,
                                  LPSTR a4,
                                  int a5)
{
    _PrintEnter("GetDateFormatA(%p,%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetDateFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetDateFormatA(,,,,%hs,) -> %p\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetDateFormatW(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCWSTR a3,
                                  LPWSTR a4,
                                  int a5)
{
    _PrintEnter("GetDateFormatW(%p,%p,%p,%ls,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetDateFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetDateFormatW(,,,,%ls,) -> %p\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDefaultCommConfigA(LPCSTR a0,
                                          LPCOMMCONFIG a1,
                                          LPDWORD a2)
{
    _PrintEnter("GetDefaultCommConfigA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetDefaultCommConfigA(a0, a1, a2);
    } __finally {
        _PrintExit("GetDefaultCommConfigA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDefaultCommConfigW(LPCWSTR a0,
                                          LPCOMMCONFIG a1,
                                          LPDWORD a2)
{
    _PrintEnter("GetDefaultCommConfigW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetDefaultCommConfigW(a0, a1, a2);
    } __finally {
        _PrintExit("GetDefaultCommConfigW(,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetDesktopWindow(void)
{
    _PrintEnter("GetDesktopWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetDesktopWindow();
    } __finally {
        _PrintExit("GetDesktopWindow() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDeviceCaps(HDC a0,
                                 int a1)
{
    _PrintEnter("GetDeviceCaps(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetDeviceCaps(a0, a1);
    } __finally {
        _PrintExit("GetDeviceCaps(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDeviceGammaRamp(HDC a0,
                                       LPVOID a1)
{
    _PrintEnter("GetDeviceGammaRamp(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetDeviceGammaRamp(a0, a1);
    } __finally {
        _PrintExit("GetDeviceGammaRamp(,) -> %p\n", rv);
    };
    return rv;
}

long __stdcall Mine_GetDialogBaseUnits(void)
{
    _PrintEnter("GetDialogBaseUnits()\n");

    long rv = 0;
    __try {
        rv = Real_GetDialogBaseUnits();
    } __finally {
        _PrintExit("GetDialogBaseUnits() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceA(LPCSTR a0,
                                      LPDWORD a1,
                                      LPDWORD a2,
                                      LPDWORD a3,
                                      LPDWORD a4)
{
    _PrintEnter("GetDiskFreeSpaceA(%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetDiskFreeSpaceA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceExA(LPCSTR a0,
                                        union _ULARGE_INTEGER* a1,
                                        union _ULARGE_INTEGER* a2,
                                        union _ULARGE_INTEGER* a3)
{
    _PrintEnter("GetDiskFreeSpaceExA(%hs,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDiskFreeSpaceExA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceExW(LPCWSTR a0,
                                        union _ULARGE_INTEGER* a1,
                                        union _ULARGE_INTEGER* a2,
                                        union _ULARGE_INTEGER* a3)
{
    _PrintEnter("GetDiskFreeSpaceExW(%ls,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDiskFreeSpaceExW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceW(LPCWSTR a0,
                                      LPDWORD a1,
                                      LPDWORD a2,
                                      LPDWORD a3,
                                      LPDWORD a4)
{
    _PrintEnter("GetDiskFreeSpaceW(%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetDiskFreeSpaceW(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDlgCtrlID(HWND a0)
{
    _PrintEnter("GetDlgCtrlID(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetDlgCtrlID(a0);
    } __finally {
        _PrintExit("GetDlgCtrlID() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetDlgItem(HWND a0,
                               int a1)
{
    _PrintEnter("GetDlgItem(%p,%p)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_GetDlgItem(a0, a1);
    } __finally {
        _PrintExit("GetDlgItem(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemInt(HWND a0,
                                  int a1,
                                  BOOL* a2,
                                  BOOL a3)
{
    _PrintEnter("GetDlgItemInt(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemInt(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemInt(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemTextA(HWND a0,
                                    int a1,
                                    LPSTR a2,
                                    int a3)
{
    _PrintEnter("GetDlgItemTextA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemTextA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemTextA(,,%hs,) -> %p\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemTextW(HWND a0,
                                    int a1,
                                    LPWSTR a2,
                                    int a3)
{
    _PrintEnter("GetDlgItemTextW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemTextW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemTextW(,,%ls,) -> %p\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDoubleClickTime(void)
{
    _PrintEnter("GetDoubleClickTime()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetDoubleClickTime();
    } __finally {
        _PrintExit("GetDoubleClickTime() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDriveTypeA(LPCSTR a0)
{
    _PrintEnter("GetDriveTypeA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetDriveTypeA(a0);
    } __finally {
        _PrintExit("GetDriveTypeA() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDriveTypeW(LPCWSTR a0)
{
    _PrintEnter("GetDriveTypeW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetDriveTypeW(a0);
    } __finally {
        _PrintExit("GetDriveTypeW() -> %p\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_GetEnhMetaFileA(LPCSTR a0)
{
    _PrintEnter("GetEnhMetaFileA(%hs)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_GetEnhMetaFileA(a0);
    } __finally {
        _PrintExit("GetEnhMetaFileA() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileBits(HENHMETAFILE a0,
                                       UINT a1,
                                       LPBYTE a2)
{
    _PrintEnter("GetEnhMetaFileBits(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileBits(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileBits(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileDescriptionA(HENHMETAFILE a0,
                                               UINT a1,
                                               LPSTR a2)
{
    _PrintEnter("GetEnhMetaFileDescriptionA(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileDescriptionA(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileDescriptionA(,,%hs) -> %p\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileDescriptionW(HENHMETAFILE a0,
                                               UINT a1,
                                               LPWSTR a2)
{
    _PrintEnter("GetEnhMetaFileDescriptionW(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileDescriptionW(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileDescriptionW(,,%ls) -> %p\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileHeader(HENHMETAFILE a0,
                                         UINT a1,
                                         ENHMETAHEADER* a2)
{
    _PrintEnter("GetEnhMetaFileHeader(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileHeader(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileHeader(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFilePaletteEntries(HENHMETAFILE a0,
                                                 UINT a1,
                                                 PALETTEENTRY* a2)
{
    _PrintEnter("GetEnhMetaFilePaletteEntries(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFilePaletteEntries(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFilePaletteEntries(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFilePixelFormat(HENHMETAFILE a0,
                                              UINT a1,
                                              PIXELFORMATDESCRIPTOR* a2)
{
    _PrintEnter("GetEnhMetaFilePixelFormat(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFilePixelFormat(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFilePixelFormat(,,) -> %p\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_GetEnhMetaFileW(LPCWSTR a0)
{
    _PrintEnter("GetEnhMetaFileW(%ls)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_GetEnhMetaFileW(a0);
    } __finally {
        _PrintExit("GetEnhMetaFileW() -> %p\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_GetEnvironmentStrings(void)
{
    _PrintEnter("GetEnvironmentStrings()\n");

    LPSTR rv = 0;
    __try {
        rv = Real_GetEnvironmentStrings();
    } __finally {
        _PrintExit("GetEnvironmentStrings() -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_GetEnvironmentStringsW(void)
{
    _PrintEnter("GetEnvironmentStringsW()\n");

    LPWSTR rv = 0;
    __try {
        rv = Real_GetEnvironmentStringsW();
    } __finally {
        _PrintExit("GetEnvironmentStringsW() -> %ls\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetEnvironmentVariableA(LPCSTR a0,
                                             LPSTR a1,
                                             DWORD a2)
{
    _PrintEnter("GetEnvironmentVariableA(%hs,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetEnvironmentVariableA(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnvironmentVariableA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetEnvironmentVariableW(LPCWSTR a0,
                                             LPWSTR a1,
                                             DWORD a2)
{
    _PrintEnter("GetEnvironmentVariableW(%ls,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetEnvironmentVariableW(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnvironmentVariableW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetExitCodeProcess(HANDLE a0,
                                       LPDWORD a1)
{
    _PrintEnter("GetExitCodeProcess(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetExitCodeProcess(a0, a1);
    } __finally {
        _PrintExit("GetExitCodeProcess(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetExitCodeThread(HANDLE a0,
                                      LPDWORD a1)
{
    _PrintEnter("GetExitCodeThread(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetExitCodeThread(a0, a1);
    } __finally {
        _PrintExit("GetExitCodeThread(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileAttributesA(LPCSTR a0)
{
    _PrintEnter("GetFileAttributesA(%hs)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileAttributesA(a0);
    } __finally {
        _PrintExit("GetFileAttributesA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileAttributesExA(LPCSTR a0,
                                         enum _GET_FILEEX_INFO_LEVELS a1,
                                         LPVOID a2)
{
    _PrintEnter("GetFileAttributesExA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileAttributesExA(a0, a1, a2);
    } __finally {
        _PrintExit("GetFileAttributesExA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileAttributesExW(LPCWSTR a0,
                                         enum _GET_FILEEX_INFO_LEVELS a1,
                                         LPVOID a2)
{
    _PrintEnter("GetFileAttributesExW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileAttributesExW(a0, a1, a2);
    } __finally {
        _PrintExit("GetFileAttributesExW(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileAttributesW(LPCWSTR a0)
{
    _PrintEnter("GetFileAttributesW(%ls)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileAttributesW(a0);
    } __finally {
        _PrintExit("GetFileAttributesW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileInformationByHandle(HANDLE a0,
                                               LPBY_HANDLE_FILE_INFORMATION a1)
{
    _PrintEnter("GetFileInformationByHandle(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileInformationByHandle(a0, a1);
    } __finally {
        _PrintExit("GetFileInformationByHandle(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileSize(HANDLE a0,
                                 LPDWORD a1)
{
    _PrintEnter("GetFileSize(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileSize(a0, a1);
    } __finally {
        _PrintExit("GetFileSize(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileTime(HANDLE a0,
                                LPFILETIME a1,
                                LPFILETIME a2,
                                LPFILETIME a3)
{
    _PrintEnter("GetFileTime(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileTime(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFileTime(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileType(HANDLE a0)
{
    _PrintEnter("GetFileType(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileType(a0);
    } __finally {
        _PrintExit("GetFileType() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetFocus(void)
{
    _PrintEnter("GetFocus()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetFocus();
    } __finally {
        _PrintExit("GetFocus() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFontData(HDC a0,
                                 DWORD a1,
                                 DWORD a2,
                                 LPVOID a3,
                                 DWORD a4)
{
    _PrintEnter("GetFontData(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetFontData(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetFontData(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFontLanguageInfo(HDC a0)
{
    _PrintEnter("GetFontLanguageInfo(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFontLanguageInfo(a0);
    } __finally {
        _PrintExit("GetFontLanguageInfo() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetForegroundWindow(void)
{
    _PrintEnter("GetForegroundWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetForegroundWindow();
    } __finally {
        _PrintExit("GetForegroundWindow() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFullPathNameA(LPCSTR a0,
                                      DWORD a1,
                                      LPSTR a2,
                                      LPSTR* a3)
{
    _PrintEnter("GetFullPathNameA(%hs,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetFullPathNameA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFullPathNameA(,,%hs,) -> %p\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFullPathNameW(LPCWSTR a0,
                                      DWORD a1,
                                      LPWSTR a2,
                                      LPWSTR* a3)
{
    _PrintEnter("GetFullPathNameW(%ls,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetFullPathNameW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFullPathNameW(,,%ls,) -> %p\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetGlyphOutlineA(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPGLYPHMETRICS a3,
                                      DWORD a4,
                                      LPVOID a5,
                                      MAT2* a6)
{
    _PrintEnter("GetGlyphOutlineA(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_GetGlyphOutlineA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetGlyphOutlineA(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetGlyphOutlineW(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPGLYPHMETRICS a3,
                                      DWORD a4,
                                      LPVOID a5,
                                      MAT2* a6)
{
    _PrintEnter("GetGlyphOutlineW(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_GetGlyphOutlineW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetGlyphOutlineW(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetGraphicsMode(HDC a0)
{
    _PrintEnter("GetGraphicsMode(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetGraphicsMode(a0);
    } __finally {
        _PrintExit("GetGraphicsMode() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetHGlobalFromILockBytes(ILockBytes* a0,
                                                HGLOBAL* a1)
{
    _PrintEnter("GetHGlobalFromILockBytes(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetHGlobalFromILockBytes(a0, a1);
    } __finally {
        _PrintExit("GetHGlobalFromILockBytes(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetHGlobalFromStream(LPSTREAM a0,
                                            HGLOBAL* a1)
{
    _PrintEnter("GetHGlobalFromStream(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetHGlobalFromStream(a0, a1);
    } __finally {
        _PrintExit("GetHGlobalFromStream(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetHandleInformation(HANDLE a0,
                                         LPDWORD a1)
{
    _PrintEnter("GetHandleInformation(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetHandleInformation(a0, a1);
    } __finally {
        _PrintExit("GetHandleInformation(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetICMProfileA(HDC a0,
                                   LPDWORD a1,
                                   LPSTR a2)
{
    _PrintEnter("GetICMProfileA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetICMProfileA(a0, a1, a2);
    } __finally {
        _PrintExit("GetICMProfileA(,,%hs) -> %p\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetICMProfileW(HDC a0,
                                   LPDWORD a1,
                                   LPWSTR a2)
{
    _PrintEnter("GetICMProfileW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetICMProfileW(a0, a1, a2);
    } __finally {
        _PrintExit("GetICMProfileW(,,%ls) -> %p\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetIconInfo(HICON a0,
                                PICONINFO a1)
{
    _PrintEnter("GetIconInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetIconInfo(a0, a1);
    } __finally {
        _PrintExit("GetIconInfo(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetInputState(void)
{
    _PrintEnter("GetInputState()\n");

    BOOL rv = 0;
    __try {
        rv = Real_GetInputState();
    } __finally {
        _PrintExit("GetInputState() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetKBCodePage(void)
{
    _PrintEnter("GetKBCodePage()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetKBCodePage();
    } __finally {
        _PrintExit("GetKBCodePage() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetKerningPairsA(HDC a0,
                                      DWORD a1,
                                      KERNINGPAIR* a2)
{
    _PrintEnter("GetKerningPairsA(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetKerningPairsA(a0, a1, a2);
    } __finally {
        _PrintExit("GetKerningPairsA(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetKerningPairsW(HDC a0,
                                      DWORD a1,
                                      KERNINGPAIR* a2)
{
    _PrintEnter("GetKerningPairsW(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetKerningPairsW(a0, a1, a2);
    } __finally {
        _PrintExit("GetKerningPairsW(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyNameTextA(LONG a0,
                                   LPSTR a1,
                                   int a2)
{
    _PrintEnter("GetKeyNameTextA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetKeyNameTextA(a0, a1, a2);
    } __finally {
        _PrintExit("GetKeyNameTextA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyNameTextW(LONG a0,
                                   LPWSTR a1,
                                   int a2)
{
    _PrintEnter("GetKeyNameTextW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetKeyNameTextW(a0, a1, a2);
    } __finally {
        _PrintExit("GetKeyNameTextW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

SHORT __stdcall Mine_GetKeyState(int a0)
{
    _PrintEnter("GetKeyState(%p)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_GetKeyState(a0);
    } __finally {
        _PrintExit("GetKeyState() -> %p\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_GetKeyboardLayout(DWORD a0)
{
    _PrintEnter("GetKeyboardLayout(%p)\n", a0);

    HKL rv = 0;
    __try {
        rv = Real_GetKeyboardLayout(a0);
    } __finally {
        _PrintExit("GetKeyboardLayout() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyboardLayoutList(int a0,
                                         HKL* a1)
{
    _PrintEnter("GetKeyboardLayoutList(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutList(a0, a1);
    } __finally {
        _PrintExit("GetKeyboardLayoutList(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardLayoutNameA(LPSTR a0)
{
    _PrintEnter("GetKeyboardLayoutNameA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutNameA(a0);
    } __finally {
        _PrintExit("GetKeyboardLayoutNameA(%hs) -> %p\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardLayoutNameW(LPWSTR a0)
{
    _PrintEnter("GetKeyboardLayoutNameW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutNameW(a0);
    } __finally {
        _PrintExit("GetKeyboardLayoutNameW(%ls) -> %p\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardState(PBYTE a0)
{
    _PrintEnter("GetKeyboardState(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardState(a0);
    } __finally {
        _PrintExit("GetKeyboardState() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyboardType(int a0)
{
    _PrintEnter("GetKeyboardType(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetKeyboardType(a0);
    } __finally {
        _PrintExit("GetKeyboardType() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetLastActivePopup(HWND a0)
{
    _PrintEnter("GetLastActivePopup(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetLastActivePopup(a0);
    } __finally {
        _PrintExit("GetLastActivePopup() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetLocalTime(LPSYSTEMTIME a0)
{
    _PrintEnter("GetLocalTime(%p)\n", a0);

    __try {
        Real_GetLocalTime(a0);
    } __finally {
        _PrintExit("GetLocalTime() ->\n");
    };
}

int __stdcall Mine_GetLocaleInfoA(LCID a0,
                                  LCTYPE a1,
                                  LPSTR a2,
                                  int a3)
{
    _PrintEnter("GetLocaleInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetLocaleInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetLocaleInfoA(,,%hs,) -> %p\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetLocaleInfoW(LCID a0,
                                  LCTYPE a1,
                                  LPWSTR a2,
                                  int a3)
{
    _PrintEnter("GetLocaleInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetLocaleInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetLocaleInfoW(,,%ls,) -> %p\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetLogColorSpaceA(HCOLORSPACE a0,
                                      LOGCOLORSPACEA* a1,
                                      DWORD a2)
{
    _PrintEnter("GetLogColorSpaceA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetLogColorSpaceA(a0, a1, a2);
    } __finally {
        _PrintExit("GetLogColorSpaceA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetLogColorSpaceW(HCOLORSPACE a0,
                                      LOGCOLORSPACEW* a1,
                                      DWORD a2)
{
    _PrintEnter("GetLogColorSpaceW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetLogColorSpaceW(a0, a1, a2);
    } __finally {
        _PrintExit("GetLogColorSpaceW(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDriveStringsA(DWORD a0,
                                             LPSTR a1)
{
    _PrintEnter("GetLogicalDriveStringsA(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDriveStringsA(a0, a1);
    } __finally {
        _PrintExit("GetLogicalDriveStringsA(,%hs) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDriveStringsW(DWORD a0,
                                             LPWSTR a1)
{
    _PrintEnter("GetLogicalDriveStringsW(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDriveStringsW(a0, a1);
    } __finally {
        _PrintExit("GetLogicalDriveStringsW(,%ls) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDrives(void)
{
    _PrintEnter("GetLogicalDrives()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDrives();
    } __finally {
        _PrintExit("GetLogicalDrives() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMailslotInfo(HANDLE a0,
                                    LPDWORD a1,
                                    LPDWORD a2,
                                    LPDWORD a3,
                                    LPDWORD a4)
{
    _PrintEnter("GetMailslotInfo(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetMailslotInfo(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMailslotInfo(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMapMode(HDC a0)
{
    _PrintEnter("GetMapMode(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetMapMode(a0);
    } __finally {
        _PrintExit("GetMapMode() -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_GetMenu(HWND a0)
{
    _PrintEnter("GetMenu(%p)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_GetMenu(a0);
    } __finally {
        _PrintExit("GetMenu() -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetMenuCheckMarkDimensions(void)
{
    _PrintEnter("GetMenuCheckMarkDimensions()\n");

    LONG rv = 0;
    __try {
        rv = Real_GetMenuCheckMarkDimensions();
    } __finally {
        _PrintExit("GetMenuCheckMarkDimensions() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetMenuContextHelpId(HMENU a0)
{
    _PrintEnter("GetMenuContextHelpId(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetMenuContextHelpId(a0);
    } __finally {
        _PrintExit("GetMenuContextHelpId() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuDefaultItem(HMENU a0,
                                       UINT a1,
                                       UINT a2)
{
    _PrintEnter("GetMenuDefaultItem(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuDefaultItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetMenuDefaultItem(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuItemCount(HMENU a0)
{
    _PrintEnter("GetMenuItemCount(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetMenuItemCount(a0);
    } __finally {
        _PrintExit("GetMenuItemCount() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuItemID(HMENU a0,
                                  int a1)
{
    _PrintEnter("GetMenuItemID(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuItemID(a0, a1);
    } __finally {
        _PrintExit("GetMenuItemID(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemInfoA(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     LPMENUITEMINFOA a3)
{
    _PrintEnter("GetMenuItemInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemInfoA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemInfoW(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     LPMENUITEMINFOW a3)
{
    _PrintEnter("GetMenuItemInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemInfoW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemRect(HWND a0,
                                    HMENU a1,
                                    UINT a2,
                                    LPRECT a3)
{
    _PrintEnter("GetMenuItemRect(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemRect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemRect(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuState(HMENU a0,
                                 UINT a1,
                                 UINT a2)
{
    _PrintEnter("GetMenuState(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuState(a0, a1, a2);
    } __finally {
        _PrintExit("GetMenuState(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuStringA(HMENU a0,
                                  UINT a1,
                                  LPSTR a2,
                                  int a3,
                                  UINT a4)
{
    _PrintEnter("GetMenuStringA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_GetMenuStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMenuStringA(,,%hs,,) -> %p\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuStringW(HMENU a0,
                                  UINT a1,
                                  LPWSTR a2,
                                  int a3,
                                  UINT a4)
{
    _PrintEnter("GetMenuStringW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_GetMenuStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMenuStringW(,,%ls,,) -> %p\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMessageA(LPMSG a0,
                                HWND a1,
                                UINT a2,
                                UINT a3)
{
    _PrintEnter("GetMessageA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMessageA(,,,) -> %p\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_GetMessageExtraInfo(void)
{
    _PrintEnter("GetMessageExtraInfo()\n");

    LPARAM rv = 0;
    __try {
        rv = Real_GetMessageExtraInfo();
    } __finally {
        _PrintExit("GetMessageExtraInfo() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetMessagePos(void)
{
    _PrintEnter("GetMessagePos()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetMessagePos();
    } __finally {
        _PrintExit("GetMessagePos() -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetMessageTime(void)
{
    _PrintEnter("GetMessageTime()\n");

    LONG rv = 0;
    __try {
        rv = Real_GetMessageTime();
    } __finally {
        _PrintExit("GetMessageTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMessageW(LPMSG a0,
                                HWND a1,
                                UINT a2,
                                UINT a3)
{
    _PrintEnter("GetMessageW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMessageW(,,,) -> %p\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_GetMetaFileA(LPCSTR a0)
{
    _PrintEnter("GetMetaFileA(%hs)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_GetMetaFileA(a0);
    } __finally {
        _PrintExit("GetMetaFileA() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMetaFileBitsEx(HMETAFILE a0,
                                      UINT a1,
                                      LPVOID a2)
{
    _PrintEnter("GetMetaFileBitsEx(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMetaFileBitsEx(a0, a1, a2);
    } __finally {
        _PrintExit("GetMetaFileBitsEx(,,) -> %p\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_GetMetaFileW(LPCWSTR a0)
{
    _PrintEnter("GetMetaFileW(%ls)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_GetMetaFileW(a0);
    } __finally {
        _PrintExit("GetMetaFileW() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMetaRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("GetMetaRgn(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetMetaRgn(a0, a1);
    } __finally {
        _PrintExit("GetMetaRgn(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMiterLimit(HDC a0,
                                  PFLOAT a1)
{
    _PrintEnter("GetMiterLimit(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetMiterLimit(a0, a1);
    } __finally {
        _PrintExit("GetMiterLimit(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetModuleFileNameA(HMODULE a0,
                                        LPSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetModuleFileNameA(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetModuleFileNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetModuleFileNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetModuleFileNameW(HMODULE a0,
                                        LPWSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetModuleFileNameW(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetModuleFileNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetModuleFileNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

HMODULE __stdcall Mine_GetModuleHandleA(LPCSTR a0)
{
    _PrintEnter("GetModuleHandleA(%hs)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_GetModuleHandleA(a0);
    } __finally {
        _PrintExit("GetModuleHandleA() -> %p\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_GetModuleHandleW(LPCWSTR a0)
{
    _PrintEnter("GetModuleHandleW(%ls)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_GetModuleHandleW(a0);
    } __finally {
        _PrintExit("GetModuleHandleW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeHandleStateA(HANDLE a0,
                                             LPDWORD a1,
                                             LPDWORD a2,
                                             LPDWORD a3,
                                             LPDWORD a4,
                                             LPSTR a5,
                                             DWORD a6)
{
    _PrintEnter("GetNamedPipeHandleStateA(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeHandleStateA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetNamedPipeHandleStateA(,,,,,%hs,) -> %p\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeHandleStateW(HANDLE a0,
                                             LPDWORD a1,
                                             LPDWORD a2,
                                             LPDWORD a3,
                                             LPDWORD a4,
                                             LPWSTR a5,
                                             DWORD a6)
{
    _PrintEnter("GetNamedPipeHandleStateW(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeHandleStateW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetNamedPipeHandleStateW(,,,,,%ls,) -> %p\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeInfo(HANDLE a0,
                                     LPDWORD a1,
                                     LPDWORD a2,
                                     LPDWORD a3,
                                     LPDWORD a4)
{
    _PrintEnter("GetNamedPipeInfo(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeInfo(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetNamedPipeInfo(,,,,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetNearestColor(HDC a0,
                                        COLORREF a1)
{
    _PrintEnter("GetNearestColor(%p,%p)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_GetNearestColor(a0, a1);
    } __finally {
        _PrintExit("GetNearestColor(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetNearestPaletteIndex(HPALETTE a0,
                                           COLORREF a1)
{
    _PrintEnter("GetNearestPaletteIndex(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetNearestPaletteIndex(a0, a1);
    } __finally {
        _PrintExit("GetNearestPaletteIndex(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetNextDlgGroupItem(HWND a0,
                                        HWND a1,
                                        BOOL a2)
{
    _PrintEnter("GetNextDlgGroupItem(%p,%p,%p)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_GetNextDlgGroupItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetNextDlgGroupItem(,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetNextDlgTabItem(HWND a0,
                                      HWND a1,
                                      BOOL a2)
{
    _PrintEnter("GetNextDlgTabItem(%p,%p,%p)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_GetNextDlgTabItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetNextDlgTabItem(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetNumberFormatA(LCID a0,
                                    DWORD a1,
                                    LPCSTR a2,
                                    NUMBERFMTA* a3,
                                    LPSTR a4,
                                    int a5)
{
    _PrintEnter("GetNumberFormatA(%p,%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetNumberFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetNumberFormatA(,,,,%hs,) -> %p\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetNumberFormatW(LCID a0,
                                    DWORD a1,
                                    LPCWSTR a2,
                                    NUMBERFMTW* a3,
                                    LPWSTR a4,
                                    int a5)
{
    _PrintEnter("GetNumberFormatW(%p,%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetNumberFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetNumberFormatW(,,,,%ls,) -> %p\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNumberOfConsoleInputEvents(HANDLE a0,
                                                  LPDWORD a1)
{
    _PrintEnter("GetNumberOfConsoleInputEvents(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetNumberOfConsoleInputEvents(a0, a1);
    } __finally {
        _PrintExit("GetNumberOfConsoleInputEvents(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNumberOfConsoleMouseButtons(LPDWORD a0)
{
    _PrintEnter("GetNumberOfConsoleMouseButtons(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetNumberOfConsoleMouseButtons(a0);
    } __finally {
        _PrintExit("GetNumberOfConsoleMouseButtons() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOEMCP(void)
{
    _PrintEnter("GetOEMCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetOEMCP();
    } __finally {
        _PrintExit("GetOEMCP() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetObjectA(HGDIOBJ a0,
                              int a1,
                              LPVOID a2)
{
    _PrintEnter("GetObjectA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetObjectA(a0, a1, a2);
    } __finally {
        _PrintExit("GetObjectA(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetObjectType(HGDIOBJ a0)
{
    _PrintEnter("GetObjectType(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetObjectType(a0);
    } __finally {
        _PrintExit("GetObjectType() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetObjectW(HGDIOBJ a0,
                              int a1,
                              LPVOID a2)
{
    _PrintEnter("GetObjectW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetObjectW(a0, a1, a2);
    } __finally {
        _PrintExit("GetObjectW(,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetOpenClipboardWindow(void)
{
    _PrintEnter("GetOpenClipboardWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetOpenClipboardWindow();
    } __finally {
        _PrintExit("GetOpenClipboardWindow() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOutlineTextMetricsA(HDC a0,
                                           UINT a1,
                                           LPOUTLINETEXTMETRICA a2)
{
    _PrintEnter("GetOutlineTextMetricsA(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetOutlineTextMetricsA(a0, a1, a2);
    } __finally {
        _PrintExit("GetOutlineTextMetricsA(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOutlineTextMetricsW(HDC a0,
                                           UINT a1,
                                           LPOUTLINETEXTMETRICW a2)
{
    _PrintEnter("GetOutlineTextMetricsW(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetOutlineTextMetricsW(a0, a1, a2);
    } __finally {
        _PrintExit("GetOutlineTextMetricsW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetOverlappedResult(HANDLE a0,
                                        LPOVERLAPPED a1,
                                        LPDWORD a2,
                                        BOOL a3)
{
    _PrintEnter("GetOverlappedResult(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetOverlappedResult(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetOverlappedResult(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPaletteEntries(HPALETTE a0,
                                      UINT a1,
                                      UINT a2,
                                      PALETTEENTRY* a3)
{
    _PrintEnter("GetPaletteEntries(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPaletteEntries(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetParent(HWND a0)
{
    _PrintEnter("GetParent(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetParent(a0);
    } __finally {
        _PrintExit("GetParent() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPath(HDC a0,
                           POINT* a1,
                           LPBYTE a2,
                           int a3)
{
    _PrintEnter("GetPath(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetPath(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPath(,,,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetPixel(HDC a0,
                                 int a1,
                                 int a2)
{
    _PrintEnter("GetPixel(%p,%p,%p)\n", a0, a1, a2);

    COLORREF rv = 0;
    __try {
        rv = Real_GetPixel(a0, a1, a2);
    } __finally {
        _PrintExit("GetPixel(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPixelFormat(HDC a0)
{
    _PrintEnter("GetPixelFormat(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetPixelFormat(a0);
    } __finally {
        _PrintExit("GetPixelFormat() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPolyFillMode(HDC a0)
{
    _PrintEnter("GetPolyFillMode(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetPolyFillMode(a0);
    } __finally {
        _PrintExit("GetPolyFillMode() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPriorityClass(HANDLE a0)
{
    _PrintEnter("GetPriorityClass(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetPriorityClass(a0);
    } __finally {
        _PrintExit("GetPriorityClass() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPriorityClipboardFormat(UINT* a0,
                                              int a1)
{
    _PrintEnter("GetPriorityClipboardFormat(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetPriorityClipboardFormat(a0, a1);
    } __finally {
        _PrintExit("GetPriorityClipboardFormat(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPrivateProfileIntA(LPCSTR a0,
                                          LPCSTR a1,
                                          INT a2,
                                          LPCSTR a3)
{
    _PrintEnter("GetPrivateProfileIntA(%hs,%hs,%p,%hs)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPrivateProfileIntA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileIntA(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPrivateProfileIntW(LPCWSTR a0,
                                          LPCWSTR a1,
                                          INT a2,
                                          LPCWSTR a3)
{
    _PrintEnter("GetPrivateProfileIntW(%ls,%ls,%p,%ls)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPrivateProfileIntW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileIntW(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionA(LPCSTR a0,
                                               LPSTR a1,
                                               DWORD a2,
                                               LPCSTR a3)
{
    _PrintEnter("GetPrivateProfileSectionA(%hs,%p,%p,%hs)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileSectionA(,%hs,,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionNamesA(LPSTR a0,
                                                    DWORD a1,
                                                    LPCSTR a2)
{
    _PrintEnter("GetPrivateProfileSectionNamesA(%p,%p,%hs)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionNamesA(a0, a1, a2);
    } __finally {
        _PrintExit("GetPrivateProfileSectionNamesA(%hs,,) -> %p\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionNamesW(LPWSTR a0,
                                                    DWORD a1,
                                                    LPCWSTR a2)
{
    _PrintEnter("GetPrivateProfileSectionNamesW(%p,%p,%ls)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionNamesW(a0, a1, a2);
    } __finally {
        _PrintExit("GetPrivateProfileSectionNamesW(%ls,,) -> %p\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionW(LPCWSTR a0,
                                               LPWSTR a1,
                                               DWORD a2,
                                               LPCWSTR a3)
{
    _PrintEnter("GetPrivateProfileSectionW(%ls,%p,%p,%ls)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileSectionW(,%ls,,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileStringA(LPCSTR a0,
                                              LPCSTR a1,
                                              LPCSTR a2,
                                              LPSTR a3,
                                              DWORD a4,
                                              LPCSTR a5)
{
    _PrintEnter("GetPrivateProfileStringA(%hs,%hs,%hs,%p,%p,%hs)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileStringA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetPrivateProfileStringA(,,,%hs,,) -> %p\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileStringW(LPCWSTR a0,
                                              LPCWSTR a1,
                                              LPCWSTR a2,
                                              LPWSTR a3,
                                              DWORD a4,
                                              LPCWSTR a5)
{
    _PrintEnter("GetPrivateProfileStringW(%ls,%ls,%ls,%p,%p,%ls)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileStringW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetPrivateProfileStringW(,,,%ls,,) -> %p\n", a3, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetPrivateProfileStructA(LPCSTR a0,
                                             LPCSTR a1,
                                             LPVOID a2,
                                             UINT a3,
                                             LPCSTR a4)
{
    _PrintEnter("GetPrivateProfileStructA(%hs,%hs,%p,%p,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetPrivateProfileStructA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetPrivateProfileStructA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetPrivateProfileStructW(LPCWSTR a0,
                                             LPCWSTR a1,
                                             LPVOID a2,
                                             UINT a3,
                                             LPCWSTR a4)
{
    _PrintEnter("GetPrivateProfileStructW(%ls,%ls,%p,%p,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetPrivateProfileStructW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetPrivateProfileStructW(,,,,) -> %p\n", rv);
    };
    return rv;
}

FARPROC __stdcall Mine_GetProcAddress(HMODULE a0,
                                      LPCSTR a1)
{
    _PrintEnter("GetProcAddress(%p,%hs)\n", a0, a1);

    FARPROC rv = 0;
    __try {
        rv = Real_GetProcAddress(a0, a1);
    } __finally {
        _PrintExit("GetProcAddress(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessAffinityMask(HANDLE a0,
                                           PDWORD_PTR a1,
                                           PDWORD_PTR a2)
{
    _PrintEnter("GetProcessAffinityMask(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessAffinityMask(a0, a1, a2);
    } __finally {
        _PrintExit("GetProcessAffinityMask(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProcessHeaps(DWORD a0,
                                     PHANDLE a1)
{
    _PrintEnter("GetProcessHeaps(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetProcessHeaps(a0, a1);
    } __finally {
        _PrintExit("GetProcessHeaps(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessShutdownParameters(LPDWORD a0,
                                                 LPDWORD a1)
{
    _PrintEnter("GetProcessShutdownParameters(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessShutdownParameters(a0, a1);
    } __finally {
        _PrintExit("GetProcessShutdownParameters(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessTimes(HANDLE a0,
                                    LPFILETIME a1,
                                    LPFILETIME a2,
                                    LPFILETIME a3,
                                    LPFILETIME a4)
{
    _PrintEnter("GetProcessTimes(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessTimes(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProcessTimes(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProcessVersion(DWORD a0)
{
    _PrintEnter("GetProcessVersion(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetProcessVersion(a0);
    } __finally {
        _PrintExit("GetProcessVersion() -> %p\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_GetProcessWindowStation(void)
{
    _PrintEnter("GetProcessWindowStation()\n");

    HWINSTA rv = 0;
    __try {
        rv = Real_GetProcessWindowStation();
    } __finally {
        _PrintExit("GetProcessWindowStation() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessWorkingSetSize(HANDLE a0,
                                             PSIZE_T a1,
                                             PSIZE_T a2)
{
    _PrintEnter("GetProcessWorkingSetSize(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessWorkingSetSize(a0, a1, a2);
    } __finally {
        _PrintExit("GetProcessWorkingSetSize(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetProfileIntA(LPCSTR a0,
                                   LPCSTR a1,
                                   INT a2)
{
    _PrintEnter("GetProfileIntA(%hs,%hs,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetProfileIntA(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileIntA(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetProfileIntW(LPCWSTR a0,
                                   LPCWSTR a1,
                                   INT a2)
{
    _PrintEnter("GetProfileIntW(%ls,%ls,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetProfileIntW(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileIntW(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileSectionA(LPCSTR a0,
                                        LPSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetProfileSectionA(%hs,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileSectionA(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileSectionA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileSectionW(LPCWSTR a0,
                                        LPWSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetProfileSectionW(%ls,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileSectionW(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileSectionW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileStringA(LPCSTR a0,
                                       LPCSTR a1,
                                       LPCSTR a2,
                                       LPSTR a3,
                                       DWORD a4)
{
    _PrintEnter("GetProfileStringA(%hs,%hs,%hs,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProfileStringA(,,,%hs,) -> %p\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileStringW(LPCWSTR a0,
                                       LPCWSTR a1,
                                       LPCWSTR a2,
                                       LPWSTR a3,
                                       DWORD a4)
{
    _PrintEnter("GetProfileStringW(%ls,%ls,%ls,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProfileStringW(,,,%ls,) -> %p\n", a3, rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetPropA(HWND a0,
                               LPCSTR a1)
{
    _PrintEnter("GetPropA(%p,%hs)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_GetPropA(a0, a1);
    } __finally {
        _PrintExit("GetPropA(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetPropW(HWND a0,
                               LPCWSTR a1)
{
    _PrintEnter("GetPropW(%p,%ls)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_GetPropW(a0, a1);
    } __finally {
        _PrintExit("GetPropW(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetQueueStatus(UINT a0)
{
    _PrintEnter("GetQueueStatus(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetQueueStatus(a0);
    } __finally {
        _PrintExit("GetQueueStatus() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetQueuedCompletionStatus(HANDLE a0,
                                              LPDWORD a1,
                                              PULONG_PTR a2,
                                              LPOVERLAPPED* a3,
                                              DWORD a4)
{
    _PrintEnter("GetQueuedCompletionStatus(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetQueuedCompletionStatus(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetQueuedCompletionStatus(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetROP2(HDC a0)
{
    _PrintEnter("GetROP2(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetROP2(a0);
    } __finally {
        _PrintExit("GetROP2() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetRasterizerCaps(LPRASTERIZER_STATUS a0,
                                      UINT a1)
{
    _PrintEnter("GetRasterizerCaps(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetRasterizerCaps(a0, a1);
    } __finally {
        _PrintExit("GetRasterizerCaps(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetRegionData(HRGN a0,
                                   DWORD a1,
                                   LPRGNDATA a2)
{
    _PrintEnter("GetRegionData(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetRegionData(a0, a1, a2);
    } __finally {
        _PrintExit("GetRegionData(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetRgnBox(HRGN a0,
                             LPRECT a1)
{
    _PrintEnter("GetRgnBox(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetRgnBox(a0, a1);
    } __finally {
        _PrintExit("GetRgnBox(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetRunningObjectTable(DWORD a0,
                                             LPRUNNINGOBJECTTABLE* a1)
{
    _PrintEnter("GetRunningObjectTable(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetRunningObjectTable(a0, a1);
    } __finally {
        _PrintExit("GetRunningObjectTable(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetScrollInfo(HWND a0,
                                  int a1,
                                  LPSCROLLINFO a2)
{
    _PrintEnter("GetScrollInfo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetScrollInfo(a0, a1, a2);
    } __finally {
        _PrintExit("GetScrollInfo(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetScrollPos(HWND a0,
                                int a1)
{
    _PrintEnter("GetScrollPos(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetScrollPos(a0, a1);
    } __finally {
        _PrintExit("GetScrollPos(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetScrollRange(HWND a0,
                                   int a1,
                                   LPINT a2,
                                   LPINT a3)
{
    _PrintEnter("GetScrollRange(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetScrollRange(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetScrollRange(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetShortPathNameA(LPCSTR a0,
                                       LPSTR a1,
                                       DWORD a2)
{
    _PrintEnter("GetShortPathNameA(%hs,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetShortPathNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetShortPathNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetShortPathNameW(LPCWSTR a0,
                                       LPWSTR a1,
                                       DWORD a2)
{
    _PrintEnter("GetShortPathNameW(%ls,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetShortPathNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetShortPathNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

void __stdcall Mine_GetStartupInfoA(LPSTARTUPINFOA a0)
{
    _PrintEnter("GetStartupInfoA(%p)\n", a0);

    __try {
        Real_GetStartupInfoA(a0);
    } __finally {
        _PrintExit("GetStartupInfoA() ->\n");
    };
}

void __stdcall Mine_GetStartupInfoW(LPSTARTUPINFOW a0)
{
    _PrintEnter("GetStartupInfoW(%p)\n", a0);

    __try {
        Real_GetStartupInfoW(a0);
    } __finally {
        _PrintExit("GetStartupInfoW() ->\n");
    };
}

HANDLE __stdcall Mine_GetStdHandle(DWORD a0)
{
    _PrintEnter("GetStdHandle(%p)\n", a0);

    HANDLE rv = 0;
    __try {
        rv = Real_GetStdHandle(a0);
    } __finally {
        _PrintExit("GetStdHandle() -> %p\n", rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_GetStockObject(int a0)
{
    _PrintEnter("GetStockObject(%p)\n", a0);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_GetStockObject(a0);
    } __finally {
        _PrintExit("GetStockObject() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetStretchBltMode(HDC a0)
{
    _PrintEnter("GetStretchBltMode(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetStretchBltMode(a0);
    } __finally {
        _PrintExit("GetStretchBltMode() -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_GetSubMenu(HMENU a0,
                                int a1)
{
    _PrintEnter("GetSubMenu(%p,%p)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_GetSubMenu(a0, a1);
    } __finally {
        _PrintExit("GetSubMenu(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetSysColor(int a0)
{
    _PrintEnter("GetSysColor(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetSysColor(a0);
    } __finally {
        _PrintExit("GetSysColor() -> %p\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_GetSysColorBrush(int a0)
{
    _PrintEnter("GetSysColorBrush(%p)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_GetSysColorBrush(a0);
    } __finally {
        _PrintExit("GetSysColorBrush() -> %p\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_GetSystemDefaultLCID(void)
{
    _PrintEnter("GetSystemDefaultLCID()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetSystemDefaultLCID();
    } __finally {
        _PrintExit("GetSystemDefaultLCID() -> %p\n", rv);
    };
    return rv;
}

LANGID __stdcall Mine_GetSystemDefaultLangID(void)
{
    _PrintEnter("GetSystemDefaultLangID()\n");

    LANGID rv = 0;
    __try {
        rv = Real_GetSystemDefaultLangID();
    } __finally {
        _PrintExit("GetSystemDefaultLangID() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemDirectoryA(LPSTR a0,
                                        UINT a1)
{
    _PrintEnter("GetSystemDirectoryA(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetSystemDirectoryA(%hs,) -> %p\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemDirectoryW(LPWSTR a0,
                                        UINT a1)
{
    _PrintEnter("GetSystemDirectoryW(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetSystemDirectoryW(%ls,) -> %p\n", a0, rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemInfo(LPSYSTEM_INFO a0)
{
    _PrintEnter("GetSystemInfo(%p)\n", a0);

    __try {
        Real_GetSystemInfo(a0);
    } __finally {
        _PrintExit("GetSystemInfo() ->\n");
    };
}

HMENU __stdcall Mine_GetSystemMenu(HWND a0,
                                   BOOL a1)
{
    _PrintEnter("GetSystemMenu(%p,%p)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_GetSystemMenu(a0, a1);
    } __finally {
        _PrintExit("GetSystemMenu(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetSystemMetrics(int a0)
{
    _PrintEnter("GetSystemMetrics(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetSystemMetrics(a0);
    } __finally {
        _PrintExit("GetSystemMetrics() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemPaletteEntries(HDC a0,
                                            UINT a1,
                                            UINT a2,
                                            PALETTEENTRY* a3)
{
    _PrintEnter("GetSystemPaletteEntries(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetSystemPaletteEntries(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemPaletteUse(HDC a0)
{
    _PrintEnter("GetSystemPaletteUse(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemPaletteUse(a0);
    } __finally {
        _PrintExit("GetSystemPaletteUse() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetSystemPowerStatus(LPSYSTEM_POWER_STATUS a0)
{
    _PrintEnter("GetSystemPowerStatus(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetSystemPowerStatus(a0);
    } __finally {
        _PrintExit("GetSystemPowerStatus() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemTime(LPSYSTEMTIME a0)
{
    _PrintEnter("GetSystemTime(%p)\n", a0);

    __try {
        Real_GetSystemTime(a0);
    } __finally {
        _PrintExit("GetSystemTime() ->\n");
    };
}

BOOL __stdcall Mine_GetSystemTimeAdjustment(PDWORD a0,
                                            PDWORD a1,
                                            PBOOL a2)
{
    _PrintEnter("GetSystemTimeAdjustment(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetSystemTimeAdjustment(a0, a1, a2);
    } __finally {
        _PrintExit("GetSystemTimeAdjustment(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemTimeAsFileTime(LPFILETIME a0)
{
    _PrintEnter("GetSystemTimeAsFileTime(%p)\n", a0);

    __try {
        Real_GetSystemTimeAsFileTime(a0);
    } __finally {
        _PrintExit("GetSystemTimeAsFileTime() ->\n");
    };
}

DWORD __stdcall Mine_GetTabbedTextExtentA(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          int a3,
                                          INT* a4)
{
    _PrintEnter("GetTabbedTextExtentA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTabbedTextExtentA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTabbedTextExtentA(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTabbedTextExtentW(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          int a3,
                                          INT* a4)
{
    _PrintEnter("GetTabbedTextExtentW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTabbedTextExtentW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTabbedTextExtentW(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapeParameters(HANDLE a0,
                                       DWORD a1,
                                       LPDWORD a2,
                                       LPVOID a3)
{
    _PrintEnter("GetTapeParameters(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapeParameters(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTapeParameters(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapePosition(HANDLE a0,
                                     DWORD a1,
                                     LPDWORD a2,
                                     LPDWORD a3,
                                     LPDWORD a4)
{
    _PrintEnter("GetTapePosition(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapePosition(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTapePosition(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapeStatus(HANDLE a0)
{
    _PrintEnter("GetTapeStatus(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapeStatus(a0);
    } __finally {
        _PrintExit("GetTapeStatus() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTempFileNameA(LPCSTR a0,
                                     LPCSTR a1,
                                     UINT a2,
                                     LPSTR a3)
{
    _PrintEnter("GetTempFileNameA(%hs,%hs,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetTempFileNameA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTempFileNameA(,,,%hs) -> %p\n", a3, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTempFileNameW(LPCWSTR a0,
                                     LPCWSTR a1,
                                     UINT a2,
                                     LPWSTR a3)
{
    _PrintEnter("GetTempFileNameW(%ls,%ls,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetTempFileNameW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTempFileNameW(,,,%ls) -> %p\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTempPathA(DWORD a0,
                                  LPSTR a1)
{
    _PrintEnter("GetTempPathA(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetTempPathA(a0, a1);
    } __finally {
        _PrintExit("GetTempPathA(,%hs) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTempPathW(DWORD a0,
                                  LPWSTR a1)
{
    _PrintEnter("GetTempPathW(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetTempPathW(a0, a1);
    } __finally {
        _PrintExit("GetTempPathW(,%ls) -> %p\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTextAlign(HDC a0)
{
    _PrintEnter("GetTextAlign(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetTextAlign(a0);
    } __finally {
        _PrintExit("GetTextAlign() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharacterExtra(HDC a0)
{
    _PrintEnter("GetTextCharacterExtra(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetTextCharacterExtra(a0);
    } __finally {
        _PrintExit("GetTextCharacterExtra() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharset(HDC a0)
{
    _PrintEnter("GetTextCharset(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetTextCharset(a0);
    } __finally {
        _PrintExit("GetTextCharset() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharsetInfo(HDC a0,
                                      LPFONTSIGNATURE a1,
                                      DWORD a2)
{
    _PrintEnter("GetTextCharsetInfo(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextCharsetInfo(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextCharsetInfo(,,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetTextColor(HDC a0)
{
    _PrintEnter("GetTextColor(%p)\n", a0);

    COLORREF rv = 0;
    __try {
        rv = Real_GetTextColor(a0);
    } __finally {
        _PrintExit("GetTextColor() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentExPointA(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          int a3,
                                          LPINT a4,
                                          LPINT a5,
                                          SIZE* a6)
{
    _PrintEnter("GetTextExtentExPointA(%p,%hs,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentExPointA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetTextExtentExPointA(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentExPointW(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          int a3,
                                          LPINT a4,
                                          LPINT a5,
                                          SIZE* a6)
{
    _PrintEnter("GetTextExtentExPointW(%p,%ls,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentExPointW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetTextExtentExPointW(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPoint32A(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          SIZE* a3)
{
    _PrintEnter("GetTextExtentPoint32A(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPoint32A(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPoint32A(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPoint32W(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          SIZE* a3)
{
    _PrintEnter("GetTextExtentPoint32W(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPoint32W(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPoint32W(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPointA(HDC a0,
                                        LPCSTR a1,
                                        int a2,
                                        SIZE* a3)
{
    _PrintEnter("GetTextExtentPointA(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPointA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPointA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPointW(HDC a0,
                                        LPCWSTR a1,
                                        int a2,
                                        SIZE* a3)
{
    _PrintEnter("GetTextExtentPointW(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPointW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPointW(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextFaceA(HDC a0,
                                int a1,
                                LPSTR a2)
{
    _PrintEnter("GetTextFaceA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextFaceA(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextFaceA(,,%hs) -> %p\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetTextFaceW(HDC a0,
                                int a1,
                                LPWSTR a2)
{
    _PrintEnter("GetTextFaceW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextFaceW(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextFaceW(,,%ls) -> %p\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextMetricsA(HDC a0,
                                    LPTEXTMETRICA a1)
{
    _PrintEnter("GetTextMetricsA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextMetricsA(a0, a1);
    } __finally {
        _PrintExit("GetTextMetricsA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextMetricsW(HDC a0,
                                    LPTEXTMETRICW a1)
{
    _PrintEnter("GetTextMetricsW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextMetricsW(a0, a1);
    } __finally {
        _PrintExit("GetTextMetricsW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadContext(HANDLE a0,
                                     LPCONTEXT a1)
{
    _PrintEnter("GetThreadContext(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadContext(a0, a1);
    } __finally {
        _PrintExit("GetThreadContext(,) -> %p\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_GetThreadDesktop(DWORD a0)
{
    _PrintEnter("GetThreadDesktop(%p)\n", a0);

    HDESK rv = 0;
    __try {
        rv = Real_GetThreadDesktop(a0);
    } __finally {
        _PrintExit("GetThreadDesktop() -> %p\n", rv);
    };
    return rv;
}

#if(WINVER >= 0x0500)
LCID __stdcall Mine_GetThreadLocale(void)
{
    _PrintEnter("GetThreadLocale()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetThreadLocale();
    } __finally {
        _PrintExit("GetThreadLocale() -> %p\n", rv);
    };
    return rv;
}
#endif // (WINVER >= 0x0500)

int __stdcall Mine_GetThreadPriority(HANDLE a0)
{
    _PrintEnter("GetThreadPriority(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetThreadPriority(a0);
    } __finally {
        _PrintExit("GetThreadPriority() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadPriorityBoost(HANDLE a0,
                                           PBOOL a1)
{
    _PrintEnter("GetThreadPriorityBoost(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("GetThreadPriorityBoost(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadSelectorEntry(HANDLE a0,
                                           DWORD a1,
                                           LPLDT_ENTRY a2)
{
    _PrintEnter("GetThreadSelectorEntry(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadSelectorEntry(a0, a1, a2);
    } __finally {
        _PrintExit("GetThreadSelectorEntry(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadTimes(HANDLE a0,
                                   LPFILETIME a1,
                                   LPFILETIME a2,
                                   LPFILETIME a3,
                                   LPFILETIME a4)
{
    _PrintEnter("GetThreadTimes(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadTimes(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetThreadTimes(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTickCount(void)
{
    _PrintEnter("GetTickCount()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetTickCount();
    } __finally {
        _PrintExit("GetTickCount() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTimeFormatA(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCSTR a3,
                                  LPSTR a4,
                                  int a5)
{
    _PrintEnter("GetTimeFormatA(%p,%p,%p,%hs,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetTimeFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetTimeFormatA(,,,,%hs,) -> %p\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetTimeFormatW(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCWSTR a3,
                                  LPWSTR a4,
                                  int a5)
{
    _PrintEnter("GetTimeFormatW(%p,%p,%p,%ls,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetTimeFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetTimeFormatW(,,,,%ls,) -> %p\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTimeZoneInformation(LPTIME_ZONE_INFORMATION a0)
{
    _PrintEnter("GetTimeZoneInformation(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetTimeZoneInformation(a0);
    } __finally {
        _PrintExit("GetTimeZoneInformation() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetTopWindow(HWND a0)
{
    _PrintEnter("GetTopWindow(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetTopWindow(a0);
    } __finally {
        _PrintExit("GetTopWindow() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUpdateRect(HWND a0,
                                  LPRECT a1,
                                  BOOL a2)
{
    _PrintEnter("GetUpdateRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetUpdateRect(a0, a1, a2);
    } __finally {
        _PrintExit("GetUpdateRect(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetUpdateRgn(HWND a0,
                                HRGN a1,
                                BOOL a2)
{
    _PrintEnter("GetUpdateRgn(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetUpdateRgn(a0, a1, a2);
    } __finally {
        _PrintExit("GetUpdateRgn(,,) -> %p\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_GetUserDefaultLCID(void)
{
    _PrintEnter("GetUserDefaultLCID()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetUserDefaultLCID();
    } __finally {
        _PrintExit("GetUserDefaultLCID() -> %p\n", rv);
    };
    return rv;
}

LANGID __stdcall Mine_GetUserDefaultLangID(void)
{
    _PrintEnter("GetUserDefaultLangID()\n");

    LANGID rv = 0;
    __try {
        rv = Real_GetUserDefaultLangID();
    } __finally {
        _PrintExit("GetUserDefaultLangID() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectInformationA(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3,
                                              LPDWORD a4)
{
    _PrintEnter("GetUserObjectInformationA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectInformationA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectInformationA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectInformationW(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3,
                                              LPDWORD a4)
{
    _PrintEnter("GetUserObjectInformationW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectInformationW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectInformationW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectSecurity(HANDLE a0,
                                          PSECURITY_INFORMATION a1,
                                          PSECURITY_DESCRIPTOR a2,
                                          DWORD a3,
                                          LPDWORD a4)
{
    _PrintEnter("GetUserObjectSecurity(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectSecurity(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectSecurity(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetVersion(void)
{
    _PrintEnter("GetVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetVersion();
    } __finally {
        _PrintExit("GetVersion() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVersionExA(LPOSVERSIONINFOA a0)
{
    _PrintEnter("GetVersionExA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetVersionExA(a0);
    } __finally {
        _PrintExit("GetVersionExA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVersionExW(LPOSVERSIONINFOW a0)
{
    _PrintEnter("GetVersionExW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetVersionExW(a0);
    } __finally {
        _PrintExit("GetVersionExW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetViewportExtEx(HDC a0,
                                     SIZE* a1)
{
    _PrintEnter("GetViewportExtEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetViewportExtEx(a0, a1);
    } __finally {
        _PrintExit("GetViewportExtEx(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetViewportOrgEx(HDC a0,
                                     POINT* a1)
{
    _PrintEnter("GetViewportOrgEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetViewportOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetViewportOrgEx(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVolumeInformationA(LPCSTR a0,
                                          LPSTR a1,
                                          DWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4,
                                          LPDWORD a5,
                                          LPSTR a6,
                                          DWORD a7)
{
    _PrintEnter("GetVolumeInformationA(%hs,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_GetVolumeInformationA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("GetVolumeInformationA(,%hs,,,,,%hs,) -> %p\n", a1, a6, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVolumeInformationW(LPCWSTR a0,
                                          LPWSTR a1,
                                          DWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4,
                                          LPDWORD a5,
                                          LPWSTR a6,
                                          DWORD a7)
{
    _PrintEnter("GetVolumeInformationW(%ls,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_GetVolumeInformationW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("GetVolumeInformationW(,%ls,,,,,%ls,) -> %p\n", a1, a6, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWinMetaFileBits(HENHMETAFILE a0,
                                       UINT a1,
                                       LPBYTE a2,
                                       INT a3,
                                       HDC a4)
{
    _PrintEnter("GetWinMetaFileBits(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    UINT rv = 0;
    __try {
        rv = Real_GetWinMetaFileBits(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetWinMetaFileBits(,,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetWindow(HWND a0,
                              UINT a1)
{
    _PrintEnter("GetWindow(%p,%p)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_GetWindow(a0, a1);
    } __finally {
        _PrintExit("GetWindow(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetWindowContextHelpId(HWND a0)
{
    _PrintEnter("GetWindowContextHelpId(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetWindowContextHelpId(a0);
    } __finally {
        _PrintExit("GetWindowContextHelpId() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetWindowDC(HWND a0)
{
    _PrintEnter("GetWindowDC(%p)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_GetWindowDC(a0);
    } __finally {
        _PrintExit("GetWindowDC() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowExtEx(HDC a0,
                                   SIZE* a1)
{
    _PrintEnter("GetWindowExtEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowExtEx(a0, a1);
    } __finally {
        _PrintExit("GetWindowExtEx(,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetWindowLongA(HWND a0,
                                   int a1)
{
    _PrintEnter("GetWindowLongA(%p,%p)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_GetWindowLongA(a0, a1);
    } __finally {
        _PrintExit("GetWindowLongA(,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetWindowLongW(HWND a0,
                                   int a1)
{
    _PrintEnter("GetWindowLongW(%p,%p)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_GetWindowLongW(a0, a1);
    } __finally {
        _PrintExit("GetWindowLongW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowOrgEx(HDC a0,
                                   POINT* a1)
{
    _PrintEnter("GetWindowOrgEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetWindowOrgEx(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowPlacement(HWND a0,
                                       WINDOWPLACEMENT* a1)
{
    _PrintEnter("GetWindowPlacement(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowPlacement(a0, a1);
    } __finally {
        _PrintExit("GetWindowPlacement(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("GetWindowRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowRect(a0, a1);
    } __finally {
        _PrintExit("GetWindowRect(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowRgn(HWND a0,
                                HRGN a1)
{
    _PrintEnter("GetWindowRgn(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetWindowRgn(a0, a1);
    } __finally {
        _PrintExit("GetWindowRgn(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextA(HWND a0,
                                  LPSTR a1,
                                  int a2)
{
    _PrintEnter("GetWindowTextA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextA(a0, a1, a2);
    } __finally {
        _PrintExit("GetWindowTextA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextLengthA(HWND a0)
{
    _PrintEnter("GetWindowTextLengthA(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextLengthA(a0);
    } __finally {
        _PrintExit("GetWindowTextLengthA() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextLengthW(HWND a0)
{
    _PrintEnter("GetWindowTextLengthW(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextLengthW(a0);
    } __finally {
        _PrintExit("GetWindowTextLengthW() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextW(HWND a0,
                                  LPWSTR a1,
                                  int a2)
{
    _PrintEnter("GetWindowTextW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextW(a0, a1, a2);
    } __finally {
        _PrintExit("GetWindowTextW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetWindowThreadProcessId(HWND a0,
                                              LPDWORD a1)
{
    _PrintEnter("GetWindowThreadProcessId(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetWindowThreadProcessId(a0, a1);
    } __finally {
        _PrintExit("GetWindowThreadProcessId(,) -> %p\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_GetWindowWord(HWND a0,
                                  int a1)
{
    _PrintEnter("GetWindowWord(%p,%p)\n", a0, a1);

    WORD rv = 0;
    __try {
        rv = Real_GetWindowWord(a0, a1);
    } __finally {
        _PrintExit("GetWindowWord(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWindowsDirectoryA(LPSTR a0,
                                         UINT a1)
{
    _PrintEnter("GetWindowsDirectoryA(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetWindowsDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetWindowsDirectoryA(%hs,) -> %p\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWindowsDirectoryW(LPWSTR a0,
                                         UINT a1)
{
    _PrintEnter("GetWindowsDirectoryW(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetWindowsDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetWindowsDirectoryW(%ls,) -> %p\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWorldTransform(HDC a0,
                                      XFORM* a1)
{
    _PrintEnter("GetWorldTransform(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWorldTransform(a0, a1);
    } __finally {
        _PrintExit("GetWorldTransform(,) -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalAddAtomA(LPCSTR a0)
{
    _PrintEnter("GlobalAddAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalAddAtomA(a0);
    } __finally {
        _PrintExit("GlobalAddAtomA() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalAddAtomW(LPCWSTR a0)
{
    _PrintEnter("GlobalAddAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalAddAtomW(a0);
    } __finally {
        _PrintExit("GlobalAddAtomW() -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalAlloc(UINT a0,
                                   SIZE_T a1)
{
    _PrintEnter("GlobalAlloc(%p,%p)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalAlloc(a0, a1);
    } __finally {
        _PrintExit("GlobalAlloc(,) -> %p\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_GlobalCompact(DWORD a0)
{
    _PrintEnter("GlobalCompact(%p)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_GlobalCompact(a0);
    } __finally {
        _PrintExit("GlobalCompact() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalDeleteAtom(ATOM a0)
{
    _PrintEnter("GlobalDeleteAtom(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalDeleteAtom(a0);
    } __finally {
        _PrintExit("GlobalDeleteAtom() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalFindAtomA(LPCSTR a0)
{
    _PrintEnter("GlobalFindAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalFindAtomA(a0);
    } __finally {
        _PrintExit("GlobalFindAtomA() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalFindAtomW(LPCWSTR a0)
{
    _PrintEnter("GlobalFindAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalFindAtomW(a0);
    } __finally {
        _PrintExit("GlobalFindAtomW() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalFix(HGLOBAL a0)
{
    _PrintEnter("GlobalFix(%p)\n", a0);

    __try {
        Real_GlobalFix(a0);
    } __finally {
        _PrintExit("GlobalFix() ->\n");
    };
}

UINT __stdcall Mine_GlobalFlags(HGLOBAL a0)
{
    _PrintEnter("GlobalFlags(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GlobalFlags(a0);
    } __finally {
        _PrintExit("GlobalFlags() -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalFree(HGLOBAL a0)
{
    _PrintEnter("GlobalFree(%p)\n", a0);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalFree(a0);
    } __finally {
        _PrintExit("GlobalFree() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GlobalGetAtomNameA(ATOM a0,
                                       LPSTR a1,
                                       int a2)
{
    _PrintEnter("GlobalGetAtomNameA(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GlobalGetAtomNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalGetAtomNameA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GlobalGetAtomNameW(ATOM a0,
                                       LPWSTR a1,
                                       int a2)
{
    _PrintEnter("GlobalGetAtomNameW(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GlobalGetAtomNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalGetAtomNameW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalHandle(LPCVOID a0)
{
    _PrintEnter("GlobalHandle(%p)\n", a0);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalHandle(a0);
    } __finally {
        _PrintExit("GlobalHandle() -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_GlobalLock(HGLOBAL a0)
{
    _PrintEnter("GlobalLock(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_GlobalLock(a0);
    } __finally {
        _PrintExit("GlobalLock() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalMemoryStatus(LPMEMORYSTATUS a0)
{
    _PrintEnter("GlobalMemoryStatus(%p)\n", a0);

    __try {
        Real_GlobalMemoryStatus(a0);
    } __finally {
        _PrintExit("GlobalMemoryStatus() ->\n");
    };
}

HGLOBAL __stdcall Mine_GlobalReAlloc(HGLOBAL a0,
                                     SIZE_T a1,
                                     UINT a2)
{
    _PrintEnter("GlobalReAlloc(%p,%p,%p)\n", a0, a1, a2);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalReAlloc(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalReAlloc(,,) -> %p\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_GlobalSize(HGLOBAL a0)
{
    _PrintEnter("GlobalSize(%p)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_GlobalSize(a0);
    } __finally {
        _PrintExit("GlobalSize() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GlobalUnWire(HGLOBAL a0)
{
    _PrintEnter("GlobalUnWire(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GlobalUnWire(a0);
    } __finally {
        _PrintExit("GlobalUnWire() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalUnfix(HGLOBAL a0)
{
    _PrintEnter("GlobalUnfix(%p)\n", a0);

    __try {
        Real_GlobalUnfix(a0);
    } __finally {
        _PrintExit("GlobalUnfix() ->\n");
    };
}

BOOL __stdcall Mine_GlobalUnlock(HGLOBAL a0)
{
    _PrintEnter("GlobalUnlock(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GlobalUnlock(a0);
    } __finally {
        _PrintExit("GlobalUnlock() -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_GlobalWire(HGLOBAL a0)
{
    _PrintEnter("GlobalWire(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_GlobalWire(a0);
    } __finally {
        _PrintExit("GlobalWire() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GrayStringA(HDC a0,
                                HBRUSH a1,
                                GRAYSTRINGPROC a2,
                                LPARAM a3,
                                int a4,
                                int a5,
                                int a6,
                                int a7,
                                int a8)
{
    _PrintEnter("GrayStringA(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_GrayStringA(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("GrayStringA(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GrayStringW(HDC a0,
                                HBRUSH a1,
                                GRAYSTRINGPROC a2,
                                LPARAM a3,
                                int a4,
                                int a5,
                                int a6,
                                int a7,
                                int a8)
{
    _PrintEnter("GrayStringW(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_GrayStringW(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("GrayStringW(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HeapLock(HANDLE a0)
{
    _PrintEnter("HeapLock(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HeapLock(a0);
    } __finally {
        _PrintExit("HeapLock() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HeapUnlock(HANDLE a0)
{
    _PrintEnter("HeapUnlock(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HeapUnlock(a0);
    } __finally {
        _PrintExit("HeapUnlock() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HideCaret(HWND a0)
{
    _PrintEnter("HideCaret(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HideCaret(a0);
    } __finally {
        _PrintExit("HideCaret() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HiliteMenuItem(HWND a0,
                                   HMENU a1,
                                   UINT a2,
                                   UINT a3)
{
    _PrintEnter("HiliteMenuItem(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_HiliteMenuItem(a0, a1, a2, a3);
    } __finally {
        _PrintExit("HiliteMenuItem(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_IIDFromString(LPOLESTR a0,
                                     LPGUID a1)
{
    _PrintEnter("IIDFromString(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_IIDFromString(a0, a1);
    } __finally {
        _PrintExit("IIDFromString(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ImpersonateDdeClientWindow(HWND a0,
                                               HWND a1)
{
    _PrintEnter("ImpersonateDdeClientWindow(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ImpersonateDdeClientWindow(a0, a1);
    } __finally {
        _PrintExit("ImpersonateDdeClientWindow(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InSendMessage(void)
{
    _PrintEnter("InSendMessage()\n");

    BOOL rv = 0;
    __try {
        rv = Real_InSendMessage();
    } __finally {
        _PrintExit("InSendMessage() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InflateRect(LPRECT a0,
                                int a1,
                                int a2)
{
    _PrintEnter("InflateRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InflateRect(a0, a1, a2);
    } __finally {
        _PrintExit("InflateRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InitAtomTable(DWORD a0)
{
    _PrintEnter("InitAtomTable(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_InitAtomTable(a0);
    } __finally {
        _PrintExit("InitAtomTable() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuA(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCSTR a4)
{
    _PrintEnter("InsertMenuA(%p,%p,%p,%p,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("InsertMenuA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuItemA(HMENU a0,
                                    UINT a1,
                                    BOOL a2,
                                    MENUITEMINFOA* a3)
{
    _PrintEnter("InsertMenuItemA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuItemA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("InsertMenuItemA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuItemW(HMENU a0,
                                    UINT a1,
                                    BOOL a2,
                                    MENUITEMINFOW* a3)
{
    _PrintEnter("InsertMenuItemW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuItemW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("InsertMenuItemW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuW(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCWSTR a4)
{
    _PrintEnter("InsertMenuW(%p,%p,%p,%p,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("InsertMenuW(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_IntersectClipRect(HDC a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4)
{
    _PrintEnter("IntersectClipRect(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_IntersectClipRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("IntersectClipRect(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IntersectRect(LPRECT a0,
                                  RECT* a1,
                                  RECT* a2)
{
    _PrintEnter("IntersectRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_IntersectRect(a0, a1, a2);
    } __finally {
        _PrintExit("IntersectRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvalidateRect(HWND a0,
                                   RECT* a1,
                                   BOOL a2)
{
    _PrintEnter("InvalidateRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InvalidateRect(a0, a1, a2);
    } __finally {
        _PrintExit("InvalidateRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvalidateRgn(HWND a0,
                                  HRGN a1,
                                  BOOL a2)
{
    _PrintEnter("InvalidateRgn(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InvalidateRgn(a0, a1, a2);
    } __finally {
        _PrintExit("InvalidateRgn(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvertRect(HDC a0,
                               RECT* a1)
{
    _PrintEnter("InvertRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_InvertRect(a0, a1);
    } __finally {
        _PrintExit("InvertRect(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvertRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("InvertRgn(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_InvertRgn(a0, a1);
    } __finally {
        _PrintExit("InvertRgn(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsAccelerator(HACCEL a0,
                                  int a1,
                                  LPMSG a2,
                                  WORD* a3)
{
    _PrintEnter("IsAccelerator(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_IsAccelerator(a0, a1, a2, a3);
    } __finally {
        _PrintExit("IsAccelerator(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadCodePtr(FARPROC a0)
{
    _PrintEnter("IsBadCodePtr(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadCodePtr(a0);
    } __finally {
        _PrintExit("IsBadCodePtr() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadHugeReadPtr(void* a0,
                                     UINT_PTR a1)
{
    _PrintEnter("IsBadHugeReadPtr(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadHugeReadPtr(a0, a1);
    } __finally {
        _PrintExit("IsBadHugeReadPtr(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadHugeWritePtr(LPVOID a0,
                                      UINT_PTR a1)
{
    _PrintEnter("IsBadHugeWritePtr(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadHugeWritePtr(a0, a1);
    } __finally {
        _PrintExit("IsBadHugeWritePtr(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadReadPtr(void* a0,
                                 UINT_PTR a1)
{
    _PrintEnter("IsBadReadPtr(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadReadPtr(a0, a1);
    } __finally {
        _PrintExit("IsBadReadPtr(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadStringPtrA(LPCSTR a0,
                                    UINT_PTR a1)
{
    _PrintEnter("IsBadStringPtrA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadStringPtrA(a0, a1);
    } __finally {
        _PrintExit("IsBadStringPtrA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadStringPtrW(LPCWSTR a0,
                                    UINT_PTR a1)
{
    _PrintEnter("IsBadStringPtrW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadStringPtrW(a0, a1);
    } __finally {
        _PrintExit("IsBadStringPtrW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadWritePtr(LPVOID a0,
                                  UINT_PTR a1)
{
    _PrintEnter("IsBadWritePtr(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadWritePtr(a0, a1);
    } __finally {
        _PrintExit("IsBadWritePtr(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaA(CHAR a0)
{
    _PrintEnter("IsCharAlphaA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaA(a0);
    } __finally {
        _PrintExit("IsCharAlphaA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaNumericA(CHAR a0)
{
    _PrintEnter("IsCharAlphaNumericA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaNumericA(a0);
    } __finally {
        _PrintExit("IsCharAlphaNumericA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaNumericW(WCHAR a0)
{
    _PrintEnter("IsCharAlphaNumericW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaNumericW(a0);
    } __finally {
        _PrintExit("IsCharAlphaNumericW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaW(WCHAR a0)
{
    _PrintEnter("IsCharAlphaW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaW(a0);
    } __finally {
        _PrintExit("IsCharAlphaW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharLowerA(CHAR a0)
{
    _PrintEnter("IsCharLowerA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharLowerA(a0);
    } __finally {
        _PrintExit("IsCharLowerA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharLowerW(WCHAR a0)
{
    _PrintEnter("IsCharLowerW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharLowerW(a0);
    } __finally {
        _PrintExit("IsCharLowerW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharUpperA(CHAR a0)
{
    _PrintEnter("IsCharUpperA(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharUpperA(a0);
    } __finally {
        _PrintExit("IsCharUpperA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharUpperW(WCHAR a0)
{
    _PrintEnter("IsCharUpperW(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharUpperW(a0);
    } __finally {
        _PrintExit("IsCharUpperW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsChild(HWND a0,
                            HWND a1)
{
    _PrintEnter("IsChild(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsChild(a0, a1);
    } __finally {
        _PrintExit("IsChild(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsClipboardFormatAvailable(UINT a0)
{
    _PrintEnter("IsClipboardFormatAvailable(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsClipboardFormatAvailable(a0);
    } __finally {
        _PrintExit("IsClipboardFormatAvailable() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDBCSLeadByte(BYTE a0)
{
    _PrintEnter("IsDBCSLeadByte(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsDBCSLeadByte(a0);
    } __finally {
        _PrintExit("IsDBCSLeadByte() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDBCSLeadByteEx(UINT a0,
                                     BYTE a1)
{
    _PrintEnter("IsDBCSLeadByteEx(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDBCSLeadByteEx(a0, a1);
    } __finally {
        _PrintExit("IsDBCSLeadByteEx(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDebuggerPresent(void)
{
    _PrintEnter("IsDebuggerPresent()\n");

    BOOL rv = 0;
    __try {
        rv = Real_IsDebuggerPresent();
    } __finally {
        _PrintExit("IsDebuggerPresent() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDialogMessageA(HWND a0,
                                     LPMSG a1)
{
    _PrintEnter("IsDialogMessageA(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDialogMessageA(a0, a1);
    } __finally {
        _PrintExit("IsDialogMessageA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDialogMessageW(HWND a0,
                                     LPMSG a1)
{
    _PrintEnter("IsDialogMessageW(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDialogMessageW(a0, a1);
    } __finally {
        _PrintExit("IsDialogMessageW(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_IsDlgButtonChecked(HWND a0,
                                       int a1)
{
    _PrintEnter("IsDlgButtonChecked(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_IsDlgButtonChecked(a0, a1);
    } __finally {
        _PrintExit("IsDlgButtonChecked(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsIconic(HWND a0)
{
    _PrintEnter("IsIconic(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsIconic(a0);
    } __finally {
        _PrintExit("IsIconic() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsMenu(HMENU a0)
{
    _PrintEnter("IsMenu(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsMenu(a0);
    } __finally {
        _PrintExit("IsMenu() -> %p\n", rv);
    };
    return rv;
}

#if !defined(DETOURS_ARM)
BOOL __stdcall Mine_IsProcessorFeaturePresent(DWORD a0)
{
    _PrintEnter("IsProcessorFeaturePresent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsProcessorFeaturePresent(a0);
    } __finally {
        _PrintExit("IsProcessorFeaturePresent() -> %p\n", rv);
    };
    return rv;
}
#endif // !DETOURS_ARM

BOOL __stdcall Mine_IsRectEmpty(RECT* a0)
{
    _PrintEnter("IsRectEmpty(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsRectEmpty(a0);
    } __finally {
        _PrintExit("IsRectEmpty() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsValidCodePage(UINT a0)
{
    _PrintEnter("IsValidCodePage(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsValidCodePage(a0);
    } __finally {
        _PrintExit("IsValidCodePage() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsValidLocale(LCID a0,
                                  DWORD a1)
{
    _PrintEnter("IsValidLocale(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsValidLocale(a0, a1);
    } __finally {
        _PrintExit("IsValidLocale(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindow(HWND a0)
{
    _PrintEnter("IsWindow(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindow(a0);
    } __finally {
        _PrintExit("IsWindow() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowEnabled(HWND a0)
{
    _PrintEnter("IsWindowEnabled(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowEnabled(a0);
    } __finally {
        _PrintExit("IsWindowEnabled() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowUnicode(HWND a0)
{
    _PrintEnter("IsWindowUnicode(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowUnicode(a0);
    } __finally {
        _PrintExit("IsWindowUnicode() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowVisible(HWND a0)
{
    _PrintEnter("IsWindowVisible(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowVisible(a0);
    } __finally {
        _PrintExit("IsWindowVisible() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsZoomed(HWND a0)
{
    _PrintEnter("IsZoomed(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsZoomed(a0);
    } __finally {
        _PrintExit("IsZoomed() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_KillTimer(HWND a0,
                              UINT_PTR a1)
{
    _PrintEnter("KillTimer(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_KillTimer(a0, a1);
    } __finally {
        _PrintExit("KillTimer(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LPtoDP(HDC a0,
                           POINT* a1,
                           int a2)
{
    _PrintEnter("LPtoDP(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_LPtoDP(a0, a1, a2);
    } __finally {
        _PrintExit("LPtoDP(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LineDDA(int a0,
                            int a1,
                            int a2,
                            int a3,
                            LINEDDAPROC a4,
                            LPARAM a5)
{
    _PrintEnter("LineDDA(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_LineDDA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LineDDA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LineTo(HDC a0,
                           int a1,
                           int a2)
{
    _PrintEnter("LineTo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_LineTo(a0, a1, a2);
    } __finally {
        _PrintExit("LineTo(,,) -> %p\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_LoadAcceleratorsA(HINSTANCE a0,
                                        LPCSTR a1)
{
    _PrintEnter("LoadAcceleratorsA(%p,%hs)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_LoadAcceleratorsA(a0, a1);
    } __finally {
        _PrintExit("LoadAcceleratorsA(,) -> %p\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_LoadAcceleratorsW(HINSTANCE a0,
                                        LPCWSTR a1)
{
    _PrintEnter("LoadAcceleratorsW(%p,%ls)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_LoadAcceleratorsW(a0, a1);
    } __finally {
        _PrintExit("LoadAcceleratorsW(,) -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_LoadBitmapA(HINSTANCE a0,
                                   LPCSTR a1)
{
    _PrintEnter("LoadBitmapA(%p,%hs)\n", a0, a1);

    HBITMAP rv = 0;
    __try {
        rv = Real_LoadBitmapA(a0, a1);
    } __finally {
        _PrintExit("LoadBitmapA(,) -> %p\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_LoadBitmapW(HINSTANCE a0,
                                   LPCWSTR a1)
{
    _PrintEnter("LoadBitmapW(%p,%ls)\n", a0, a1);

    HBITMAP rv = 0;
    __try {
        rv = Real_LoadBitmapW(a0, a1);
    } __finally {
        _PrintExit("LoadBitmapW(,) -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorA(HINSTANCE a0,
                                   LPCSTR a1)
{
    _PrintEnter("LoadCursorA(%p,%hs)\n", a0, a1);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorA(a0, a1);
    } __finally {
        _PrintExit("LoadCursorA(,) -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorFromFileA(LPCSTR a0)
{
    _PrintEnter("LoadCursorFromFileA(%hs)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorFromFileA(a0);
    } __finally {
        _PrintExit("LoadCursorFromFileA() -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorFromFileW(LPCWSTR a0)
{
    _PrintEnter("LoadCursorFromFileW(%ls)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorFromFileW(a0);
    } __finally {
        _PrintExit("LoadCursorFromFileW() -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorW(HINSTANCE a0,
                                   LPCWSTR a1)
{
    _PrintEnter("LoadCursorW(%p,%ls)\n", a0, a1);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorW(a0, a1);
    } __finally {
        _PrintExit("LoadCursorW(,) -> %p\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_LoadIconA(HINSTANCE a0,
                               LPCSTR a1)
{
    _PrintEnter("LoadIconA(%p,%hs)\n", a0, a1);

    HICON rv = 0;
    __try {
        rv = Real_LoadIconA(a0, a1);
    } __finally {
        _PrintExit("LoadIconA(,) -> %p\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_LoadIconW(HINSTANCE a0,
                               LPCWSTR a1)
{
    _PrintEnter("LoadIconW(%p,%ls)\n", a0, a1);

    HICON rv = 0;
    __try {
        rv = Real_LoadIconW(a0, a1);
    } __finally {
        _PrintExit("LoadIconW(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_LoadImageA(HINSTANCE a0,
                                 LPCSTR a1,
                                 UINT a2,
                                 int a3,
                                 int a4,
                                 UINT a5)
{
    _PrintEnter("LoadImageA(%p,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_LoadImageA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LoadImageA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_LoadImageW(HINSTANCE a0,
                                 LPCWSTR a1,
                                 UINT a2,
                                 int a3,
                                 int a4,
                                 UINT a5)
{
    _PrintEnter("LoadImageW(%p,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_LoadImageW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LoadImageW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_LoadKeyboardLayoutA(LPCSTR a0,
                                       UINT a1)
{
    _PrintEnter("LoadKeyboardLayoutA(%hs,%p)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_LoadKeyboardLayoutA(a0, a1);
    } __finally {
        _PrintExit("LoadKeyboardLayoutA(,) -> %p\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_LoadKeyboardLayoutW(LPCWSTR a0,
                                       UINT a1)
{
    _PrintEnter("LoadKeyboardLayoutW(%ls,%p)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_LoadKeyboardLayoutW(a0, a1);
    } __finally {
        _PrintExit("LoadKeyboardLayoutW(,) -> %p\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryA(LPCSTR a0)
{
    _PrintEnter("LoadLibraryA(%hs)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryA(a0);
    } __finally {
        _PrintExit("LoadLibraryA() -> %p\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryExA(LPCSTR a0,
                                      HANDLE a1,
                                      DWORD a2)
{
    _PrintEnter("LoadLibraryExA(%hs,%p,%p)\n", a0, a1, a2);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryExA(a0, a1, a2);
    } __finally {
        _PrintExit("LoadLibraryExA(,,) -> %p\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryExW(LPCWSTR a0,
                                      HANDLE a1,
                                      DWORD a2)
{
    _PrintEnter("LoadLibraryExW(%ls,%p,%p)\n", a0, a1, a2);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryExW(a0, a1, a2);
    } __finally {
        _PrintExit("LoadLibraryExW(,,) -> %p\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryW(LPCWSTR a0)
{
    _PrintEnter("LoadLibraryW(%ls)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryW(a0);
    } __finally {
        _PrintExit("LoadLibraryW() -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuA(HINSTANCE a0,
                               LPCSTR a1)
{
    _PrintEnter("LoadMenuA(%p,%hs)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuA(a0, a1);
    } __finally {
        _PrintExit("LoadMenuA(,) -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuIndirectA(MENUTEMPLATEA* a0)
{
    _PrintEnter("LoadMenuIndirectA(%p)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuIndirectA(a0);
    } __finally {
        _PrintExit("LoadMenuIndirectA() -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuIndirectW(MENUTEMPLATEW* a0)
{
    _PrintEnter("LoadMenuIndirectW(%p)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuIndirectW(a0);
    } __finally {
        _PrintExit("LoadMenuIndirectW() -> %p\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuW(HINSTANCE a0,
                               LPCWSTR a1)
{
    _PrintEnter("LoadMenuW(%p,%ls)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuW(a0, a1);
    } __finally {
        _PrintExit("LoadMenuW(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_LoadModule(LPCSTR a0,
                                LPVOID a1)
{
    _PrintEnter("LoadModule(%hs,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_LoadModule(a0, a1);
    } __finally {
        _PrintExit("LoadModule(,) -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_LoadResource(HMODULE a0,
                                    HRSRC a1)
{
    _PrintEnter("LoadResource(%p,%p)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_LoadResource(a0, a1);
    } __finally {
        _PrintExit("LoadResource(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_LoadStringA(HINSTANCE a0,
                               UINT a1,
                               LPSTR a2,
                               int a3)
{
    _PrintEnter("LoadStringA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_LoadStringA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("LoadStringA(,,%hs,) -> %p\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_LoadStringW(HINSTANCE a0,
                               UINT a1,
                               LPWSTR a2,
                               int a3)
{
    _PrintEnter("LoadStringW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_LoadStringW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("LoadStringW(,,%ls,) -> %p\n", a2, rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalAlloc(UINT a0,
                                 SIZE_T a1)
{
    _PrintEnter("LocalAlloc(%p,%p)\n", a0, a1);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalAlloc(a0, a1);
    } __finally {
        _PrintExit("LocalAlloc(,) -> %p\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalCompact(UINT a0)
{
    _PrintEnter("LocalCompact(%p)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalCompact(a0);
    } __finally {
        _PrintExit("LocalCompact() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LocalFileTimeToFileTime(FILETIME* a0,
                                            LPFILETIME a1)
{
    _PrintEnter("LocalFileTimeToFileTime(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_LocalFileTimeToFileTime(a0, a1);
    } __finally {
        _PrintExit("LocalFileTimeToFileTime(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_LocalFlags(HLOCAL a0)
{
    _PrintEnter("LocalFlags(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_LocalFlags(a0);
    } __finally {
        _PrintExit("LocalFlags() -> %p\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalFree(HLOCAL a0)
{
    _PrintEnter("LocalFree(%p)\n", a0);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalFree(a0);
    } __finally {
        _PrintExit("LocalFree() -> %p\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalHandle(LPCVOID a0)
{
    _PrintEnter("LocalHandle(%p)\n", a0);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalHandle(a0);
    } __finally {
        _PrintExit("LocalHandle() -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_LocalLock(HLOCAL a0)
{
    _PrintEnter("LocalLock(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_LocalLock(a0);
    } __finally {
        _PrintExit("LocalLock() -> %p\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalReAlloc(HLOCAL a0,
                                   SIZE_T a1,
                                   UINT a2)
{
    _PrintEnter("LocalReAlloc(%p,%p,%p)\n", a0, a1, a2);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalReAlloc(a0, a1, a2);
    } __finally {
        _PrintExit("LocalReAlloc(,,) -> %p\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalShrink(HLOCAL a0,
                                  UINT a1)
{
    _PrintEnter("LocalShrink(%p,%p)\n", a0, a1);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalShrink(a0, a1);
    } __finally {
        _PrintExit("LocalShrink(,) -> %p\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalSize(HLOCAL a0)
{
    _PrintEnter("LocalSize(%p)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalSize(a0);
    } __finally {
        _PrintExit("LocalSize() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LocalUnlock(HLOCAL a0)
{
    _PrintEnter("LocalUnlock(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_LocalUnlock(a0);
    } __finally {
        _PrintExit("LocalUnlock() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockFile(HANDLE a0,
                             DWORD a1,
                             DWORD a2,
                             DWORD a3,
                             DWORD a4)
{
    _PrintEnter("LockFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_LockFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("LockFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockFileEx(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               DWORD a3,
                               DWORD a4,
                               LPOVERLAPPED a5)
{
    _PrintEnter("LockFileEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_LockFileEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LockFileEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_LockResource(HGLOBAL a0)
{
    _PrintEnter("LockResource(%p)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_LockResource(a0);
    } __finally {
        _PrintExit("LockResource() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockWindowUpdate(HWND a0)
{
    _PrintEnter("LockWindowUpdate(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_LockWindowUpdate(a0);
    } __finally {
        _PrintExit("LockWindowUpdate() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_LookupIconIdFromDirectory(PBYTE a0,
                                             BOOL a1)
{
    _PrintEnter("LookupIconIdFromDirectory(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_LookupIconIdFromDirectory(a0, a1);
    } __finally {
        _PrintExit("LookupIconIdFromDirectory(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_LookupIconIdFromDirectoryEx(PBYTE a0,
                                               BOOL a1,
                                               int a2,
                                               int a3,
                                               UINT a4)
{
    _PrintEnter("LookupIconIdFromDirectoryEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_LookupIconIdFromDirectoryEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("LookupIconIdFromDirectoryEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MapDialogRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("MapDialogRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MapDialogRect(a0, a1);
    } __finally {
        _PrintExit("MapDialogRect(,) -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_MapViewOfFile(HANDLE a0,
                                    DWORD a1,
                                    DWORD a2,
                                    DWORD a3,
                                    SIZE_T a4)
{
    _PrintEnter("MapViewOfFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LPVOID rv = 0;
    __try {
        rv = Real_MapViewOfFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MapViewOfFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_MapViewOfFileEx(HANDLE a0,
                                      DWORD a1,
                                      DWORD a2,
                                      DWORD a3,
                                      SIZE_T a4,
                                      LPVOID a5)
{
    _PrintEnter("MapViewOfFileEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    LPVOID rv = 0;
    __try {
        rv = Real_MapViewOfFileEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("MapViewOfFileEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyA(UINT a0,
                                   UINT a1)
{
    _PrintEnter("MapVirtualKeyA(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyA(a0, a1);
    } __finally {
        _PrintExit("MapVirtualKeyA(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyExA(UINT a0,
                                     UINT a1,
                                     HKL a2)
{
    _PrintEnter("MapVirtualKeyExA(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyExA(a0, a1, a2);
    } __finally {
        _PrintExit("MapVirtualKeyExA(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyExW(UINT a0,
                                     UINT a1,
                                     HKL a2)
{
    _PrintEnter("MapVirtualKeyExW(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyExW(a0, a1, a2);
    } __finally {
        _PrintExit("MapVirtualKeyExW(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyW(UINT a0,
                                   UINT a1)
{
    _PrintEnter("MapVirtualKeyW(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyW(a0, a1);
    } __finally {
        _PrintExit("MapVirtualKeyW(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MapWindowPoints(HWND a0,
                                   HWND a1,
                                   POINT* a2,
                                   UINT a3)
{
    _PrintEnter("MapWindowPoints(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MapWindowPoints(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MapWindowPoints(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MaskBlt(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4,
                            HDC a5,
                            int a6,
                            int a7,
                            HBITMAP a8,
                            int a9,
                            int a10,
                            DWORD a11)
{
    _PrintEnter("MaskBlt(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    BOOL rv = 0;
    __try {
        rv = Real_MaskBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("MaskBlt(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MenuItemFromPoint(HWND a0,
                                     HMENU a1,
                                     POINT a2)
{
    _PrintEnter("MenuItemFromPoint(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_MenuItemFromPoint(a0, a1, a2);
    } __finally {
        _PrintExit("MenuItemFromPoint(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MessageBeep(UINT a0)
{
    _PrintEnter("MessageBeep(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_MessageBeep(a0);
    } __finally {
        _PrintExit("MessageBeep() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxA(HWND a0,
                               LPCSTR a1,
                               LPCSTR a2,
                               UINT a3)
{
    _PrintEnter("MessageBoxA(%p,%hs,%hs,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MessageBoxA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MessageBoxA(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxExA(HWND a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 UINT a3,
                                 WORD a4)
{
    _PrintEnter("MessageBoxExA(%p,%hs,%hs,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_MessageBoxExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MessageBoxExA(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxExW(HWND a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 UINT a3,
                                 WORD a4)
{
    _PrintEnter("MessageBoxExW(%p,%ls,%ls,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_MessageBoxExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MessageBoxExW(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxIndirectA(MSGBOXPARAMSA* a0)
{
    _PrintEnter("MessageBoxIndirectA(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_MessageBoxIndirectA(a0);
    } __finally {
        _PrintExit("MessageBoxIndirectA() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxIndirectW(MSGBOXPARAMSW* a0)
{
    _PrintEnter("MessageBoxIndirectW(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_MessageBoxIndirectW(a0);
    } __finally {
        _PrintExit("MessageBoxIndirectW() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxW(HWND a0,
                               LPCWSTR a1,
                               LPCWSTR a2,
                               UINT a3)
{
    _PrintEnter("MessageBoxW(%p,%ls,%ls,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MessageBoxW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MessageBoxW(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MkParseDisplayName(IBindCtx* a0,
                                          LPCOLESTR a1,
                                          ULONG* a2,
                                          IMoniker** a3)
{
    _PrintEnter("MkParseDisplayName(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_MkParseDisplayName(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MkParseDisplayName(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyMenuA(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCSTR a4)
{
    _PrintEnter("ModifyMenuA(%p,%p,%p,%p,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ModifyMenuA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyMenuW(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCWSTR a4)
{
    _PrintEnter("ModifyMenuW(%p,%p,%p,%p,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ModifyMenuW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyWorldTransform(HDC a0,
                                         XFORM* a1,
                                         DWORD a2)
{
    _PrintEnter("ModifyWorldTransform(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyWorldTransform(a0, a1, a2);
    } __finally {
        _PrintExit("ModifyWorldTransform(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MonikerCommonPrefixWith(IMoniker* a0,
                                               IMoniker* a1,
                                               IMoniker** a2)
{
    _PrintEnter("MonikerCommonPrefixWith(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_MonikerCommonPrefixWith(a0, a1, a2);
    } __finally {
        _PrintExit("MonikerCommonPrefixWith(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MonikerRelativePathTo(IMoniker* a0,
                                             IMoniker* a1,
                                             IMoniker** a2,
                                             BOOL a3)
{
    _PrintEnter("MonikerRelativePathTo(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_MonikerRelativePathTo(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MonikerRelativePathTo(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileA(LPCSTR a0,
                              LPCSTR a1)
{
    _PrintEnter("MoveFileA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileA(a0, a1);
    } __finally {
        _PrintExit("MoveFileA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileExA(LPCSTR a0,
                                LPCSTR a1,
                                DWORD a2)
{
    _PrintEnter("MoveFileExA(%hs,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileExA(a0, a1, a2);
    } __finally {
        _PrintExit("MoveFileExA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileExW(LPCWSTR a0,
                                LPCWSTR a1,
                                DWORD a2)
{
    _PrintEnter("MoveFileExW(%ls,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileExW(a0, a1, a2);
    } __finally {
        _PrintExit("MoveFileExW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileW(LPCWSTR a0,
                              LPCWSTR a1)
{
    _PrintEnter("MoveFileW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileW(a0, a1);
    } __finally {
        _PrintExit("MoveFileW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveToEx(HDC a0,
                             int a1,
                             int a2,
                             POINT* a3)
{
    _PrintEnter("MoveToEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_MoveToEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MoveToEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveWindow(HWND a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               BOOL a5)
{
    _PrintEnter("MoveWindow(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_MoveWindow(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("MoveWindow(,,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_MsgWaitForMultipleObjects(DWORD a0,
                                               void** a1,
                                               BOOL a2,
                                               DWORD a3,
                                               DWORD a4)
{
    _PrintEnter("MsgWaitForMultipleObjects(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_MsgWaitForMultipleObjects(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MsgWaitForMultipleObjects(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_MsgWaitForMultipleObjectsEx(DWORD a0,
                                                 void** a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 DWORD a4)
{
    _PrintEnter("MsgWaitForMultipleObjectsEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_MsgWaitForMultipleObjectsEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MsgWaitForMultipleObjectsEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_MulDiv(int a0,
                          int a1,
                          int a2)
{
    _PrintEnter("MulDiv(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_MulDiv(a0, a1, a2);
    } __finally {
        _PrintExit("MulDiv(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_OemKeyScan(WORD a0)
{
    _PrintEnter("OemKeyScan(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_OemKeyScan(a0);
    } __finally {
        _PrintExit("OemKeyScan() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharA(LPCSTR a0,
                               LPSTR a1)
{
    _PrintEnter("OemToCharA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharA(a0, a1);
    } __finally {
        _PrintExit("OemToCharA(,%hs) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharBuffA(LPCSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("OemToCharBuffA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharBuffA(a0, a1, a2);
    } __finally {
        _PrintExit("OemToCharBuffA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharBuffW(LPCSTR a0,
                                   LPWSTR a1,
                                   DWORD a2)
{
    _PrintEnter("OemToCharBuffW(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharBuffW(a0, a1, a2);
    } __finally {
        _PrintExit("OemToCharBuffW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharW(LPCSTR a0,
                               LPWSTR a1)
{
    _PrintEnter("OemToCharW(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharW(a0, a1);
    } __finally {
        _PrintExit("OemToCharW(,%ls) -> %p\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_OffsetClipRgn(HDC a0,
                                 int a1,
                                 int a2)
{
    _PrintEnter("OffsetClipRgn(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_OffsetClipRgn(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetClipRgn(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetRect(LPRECT a0,
                               int a1,
                               int a2)
{
    _PrintEnter("OffsetRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetRect(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetRect(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_OffsetRgn(HRGN a0,
                             int a1,
                             int a2)
{
    _PrintEnter("OffsetRgn(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_OffsetRgn(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetRgn(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetViewportOrgEx(HDC a0,
                                        int a1,
                                        int a2,
                                        POINT* a3)
{
    _PrintEnter("OffsetViewportOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetViewportOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OffsetViewportOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetWindowOrgEx(HDC a0,
                                      int a1,
                                      int a2,
                                      POINT* a3)
{
    _PrintEnter("OffsetWindowOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetWindowOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OffsetWindowOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_OleBuildVersion(void)
{
    _PrintEnter("OleBuildVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_OleBuildVersion();
    } __finally {
        _PrintExit("OleBuildVersion() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertIStorageToOLESTREAM(LPSTORAGE a0,
                                                     LPOLESTREAM a1)
{
    _PrintEnter("OleConvertIStorageToOLESTREAM(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertIStorageToOLESTREAM(a0, a1);
    } __finally {
        _PrintExit("OleConvertIStorageToOLESTREAM(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertIStorageToOLESTREAMEx(LPSTORAGE a0,
                                                       CLIPFORMAT a1,
                                                       LONG a2,
                                                       LONG a3,
                                                       DWORD a4,
                                                       LPSTGMEDIUM a5,
                                                       LPOLESTREAM a6)
{
    _PrintEnter("OleConvertIStorageToOLESTREAMEx(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertIStorageToOLESTREAMEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleConvertIStorageToOLESTREAMEx(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertOLESTREAMToIStorage(LPOLESTREAM a0,
                                                     LPSTORAGE a1,
                                                     DVTARGETDEVICE* a2)
{
    _PrintEnter("OleConvertOLESTREAMToIStorage(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertOLESTREAMToIStorage(a0, a1, a2);
    } __finally {
        _PrintExit("OleConvertOLESTREAMToIStorage(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertOLESTREAMToIStorageEx(LPOLESTREAM a0,
                                                       LPSTORAGE a1,
                                                       CLIPFORMAT* a2,
                                                       LONG* a3,
                                                       LONG* a4,
                                                       DWORD* a5,
                                                       LPSTGMEDIUM a6)
{
    _PrintEnter("OleConvertOLESTREAMToIStorageEx(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertOLESTREAMToIStorageEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleConvertOLESTREAMToIStorageEx(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreate(CONST IID& a0,
                                 CONST IID& a1,
                                 DWORD a2,
                                 LPFORMATETC a3,
                                 LPOLECLIENTSITE a4,
                                 LPSTORAGE a5,
                                 LPVOID* a6)
{
    _PrintEnter("OleCreate(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreate(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreate(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateDefaultHandler(CONST IID& a0,
                                               LPUNKNOWN a1,
                                               CONST IID& a2,
                                               LPVOID* a3)
{
    _PrintEnter("OleCreateDefaultHandler(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateDefaultHandler(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleCreateDefaultHandler(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateEmbeddingHelper(CONST IID& a0,
                                                LPUNKNOWN a1,
                                                DWORD a2,
                                                LPCLASSFACTORY a3,
                                                CONST IID& a4,
                                                LPVOID* a5)
{
    _PrintEnter("OleCreateEmbeddingHelper(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateEmbeddingHelper(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("OleCreateEmbeddingHelper(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateEx(CONST IID& a0,
                                   CONST IID& a1,
                                   DWORD a2,
                                   DWORD a3,
                                   ULONG a4,
                                   DWORD* a5,
                                   LPFORMATETC a6,
                                   IAdviseSink* a7,
                                   DWORD* a8,
                                   LPOLECLIENTSITE a9,
                                   LPSTORAGE a10,
                                   LPVOID* a11)
{
    _PrintEnter("OleCreateEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateEx(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromData(IDataObject* a0,
                                         CONST IID& a1,
                                         DWORD a2,
                                         LPFORMATETC a3,
                                         LPOLECLIENTSITE a4,
                                         LPSTORAGE a5,
                                         LPVOID* a6)
{
    _PrintEnter("OleCreateFromData(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateFromData(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromDataEx(IDataObject* a0,
                                           CONST IID& a1,
                                           DWORD a2,
                                           DWORD a3,
                                           ULONG a4,
                                           DWORD* a5,
                                           LPFORMATETC a6,
                                           IAdviseSink* a7,
                                           DWORD* a8,
                                           LPOLECLIENTSITE a9,
                                           LPSTORAGE a10,
                                           LPVOID* a11)
{
    _PrintEnter("OleCreateFromDataEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromDataEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateFromDataEx(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromFile(CONST IID& a0,
                                         LPCOLESTR a1,
                                         CONST IID& a2,
                                         DWORD a3,
                                         LPFORMATETC a4,
                                         LPOLECLIENTSITE a5,
                                         LPSTORAGE a6,
                                         LPVOID* a7)
{
    _PrintEnter("OleCreateFromFile(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromFile(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("OleCreateFromFile(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromFileEx(CONST IID& a0,
                                           LPCOLESTR a1,
                                           CONST IID& a2,
                                           DWORD a3,
                                           DWORD a4,
                                           ULONG a5,
                                           DWORD* a6,
                                           LPFORMATETC a7,
                                           IAdviseSink* a8,
                                           DWORD* a9,
                                           LPOLECLIENTSITE a10,
                                           LPSTORAGE a11,
                                           LPVOID* a12)
{
    _PrintEnter("OleCreateFromFileEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromFileEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    } __finally {
        _PrintExit("OleCreateFromFileEx(,,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLink(IMoniker* a0,
                                     CONST IID& a1,
                                     DWORD a2,
                                     LPFORMATETC a3,
                                     LPOLECLIENTSITE a4,
                                     LPSTORAGE a5,
                                     LPVOID* a6)
{
    _PrintEnter("OleCreateLink(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLink(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLink(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkEx(IMoniker* a0,
                                       CONST IID& a1,
                                       DWORD a2,
                                       DWORD a3,
                                       ULONG a4,
                                       DWORD* a5,
                                       LPFORMATETC a6,
                                       IAdviseSink* a7,
                                       DWORD* a8,
                                       LPOLECLIENTSITE a9,
                                       LPSTORAGE a10,
                                       LPVOID* a11)
{
    _PrintEnter("OleCreateLinkEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkEx(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkFromData(IDataObject* a0,
                                             CONST IID& a1,
                                             DWORD a2,
                                             LPFORMATETC a3,
                                             LPOLECLIENTSITE a4,
                                             LPSTORAGE a5,
                                             LPVOID* a6)
{
    _PrintEnter("OleCreateLinkFromData(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLinkFromData(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkFromDataEx(IDataObject* a0,
                                               CONST IID& a1,
                                               DWORD a2,
                                               DWORD a3,
                                               ULONG a4,
                                               DWORD* a5,
                                               LPFORMATETC a6,
                                               IAdviseSink* a7,
                                               DWORD* a8,
                                               LPOLECLIENTSITE a9,
                                               LPSTORAGE a10,
                                               LPVOID* a11)
{
    _PrintEnter("OleCreateLinkFromDataEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkFromDataEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkFromDataEx(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkToFile(LPCOLESTR a0,
                                           CONST IID& a1,
                                           DWORD a2,
                                           LPFORMATETC a3,
                                           LPOLECLIENTSITE a4,
                                           LPSTORAGE a5,
                                           LPVOID* a6)
{
    _PrintEnter("OleCreateLinkToFile(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkToFile(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLinkToFile(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkToFileEx(LPCOLESTR a0,
                                             CONST IID& a1,
                                             DWORD a2,
                                             DWORD a3,
                                             ULONG a4,
                                             DWORD* a5,
                                             LPFORMATETC a6,
                                             IAdviseSink* a7,
                                             DWORD* a8,
                                             LPOLECLIENTSITE a9,
                                             LPSTORAGE a10,
                                             LPVOID* a11)
{
    _PrintEnter("OleCreateLinkToFileEx(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkToFileEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkToFileEx(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HOLEMENU __stdcall Mine_OleCreateMenuDescriptor(HMENU a0,
                                                LPOLEMENUGROUPWIDTHS a1)
{
    _PrintEnter("OleCreateMenuDescriptor(%p,%p)\n", a0, a1);

    HOLEMENU rv = 0;
    __try {
        rv = Real_OleCreateMenuDescriptor(a0, a1);
    } __finally {
        _PrintExit("OleCreateMenuDescriptor(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateStaticFromData(IDataObject* a0,
                                               CONST IID& a1,
                                               DWORD a2,
                                               LPFORMATETC a3,
                                               LPOLECLIENTSITE a4,
                                               LPSTORAGE a5,
                                               LPVOID* a6)
{
    _PrintEnter("OleCreateStaticFromData(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateStaticFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateStaticFromData(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDestroyMenuDescriptor(HOLEMENU a0)
{
    _PrintEnter("OleDestroyMenuDescriptor(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDestroyMenuDescriptor(a0);
    } __finally {
        _PrintExit("OleDestroyMenuDescriptor() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDoAutoConvert(LPSTORAGE a0,
                                        LPGUID a1)
{
    _PrintEnter("OleDoAutoConvert(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDoAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleDoAutoConvert(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDraw(LPUNKNOWN a0,
                               DWORD a1,
                               HDC a2,
                               LPCRECT a3)
{
    _PrintEnter("OleDraw(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDraw(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleDraw(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OleDuplicateData(HANDLE a0,
                                       CLIPFORMAT a1,
                                       UINT a2)
{
    _PrintEnter("OleDuplicateData(%p,%p,%p)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OleDuplicateData(a0, a1, a2);
    } __finally {
        _PrintExit("OleDuplicateData(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleFlushClipboard(void)
{
    _PrintEnter("OleFlushClipboard()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_OleFlushClipboard();
    } __finally {
        _PrintExit("OleFlushClipboard() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleGetAutoConvert(CONST IID& a0,
                                         LPGUID a1)
{
    _PrintEnter("OleGetAutoConvert(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleGetAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleGetAutoConvert(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleGetClipboard(IDataObject** a0)
{
    _PrintEnter("OleGetClipboard(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleGetClipboard(a0);
    } __finally {
        _PrintExit("OleGetClipboard() -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleGetIconOfClass(CONST IID& a0,
                                         LPOLESTR a1,
                                         BOOL a2)
{
    _PrintEnter("OleGetIconOfClass(%p,%p,%p)\n", a0, a1, a2);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleGetIconOfClass(a0, a1, a2);
    } __finally {
        _PrintExit("OleGetIconOfClass(,,) -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleGetIconOfFile(LPOLESTR a0,
                                        BOOL a1)
{
    _PrintEnter("OleGetIconOfFile(%p,%p)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleGetIconOfFile(a0, a1);
    } __finally {
        _PrintExit("OleGetIconOfFile(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleInitialize(LPVOID a0)
{
    _PrintEnter("OleInitialize(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleInitialize(a0);
    } __finally {
        _PrintExit("OleInitialize() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleIsCurrentClipboard(IDataObject* a0)
{
    _PrintEnter("OleIsCurrentClipboard(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleIsCurrentClipboard(a0);
    } __finally {
        _PrintExit("OleIsCurrentClipboard() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OleIsRunning(IOleObject* a0)
{
    _PrintEnter("OleIsRunning(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OleIsRunning(a0);
    } __finally {
        _PrintExit("OleIsRunning() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLoad(LPSTORAGE a0,
                               CONST IID& a1,
                               LPOLECLIENTSITE a2,
                               LPVOID* a3)
{
    _PrintEnter("OleLoad(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLoad(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleLoad(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLoadFromStream(LPSTREAM a0,
                                         CONST IID& a1,
                                         LPVOID* a2)
{
    _PrintEnter("OleLoadFromStream(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLoadFromStream(a0, a1, a2);
    } __finally {
        _PrintExit("OleLoadFromStream(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLockRunning(LPUNKNOWN a0,
                                      BOOL a1,
                                      BOOL a2)
{
    _PrintEnter("OleLockRunning(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLockRunning(a0, a1, a2);
    } __finally {
        _PrintExit("OleLockRunning(,,) -> %p\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleMetafilePictFromIconAndLabel(HICON a0,
                                                       LPOLESTR a1,
                                                       LPOLESTR a2,
                                                       UINT a3)
{
    _PrintEnter("OleMetafilePictFromIconAndLabel(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleMetafilePictFromIconAndLabel(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleMetafilePictFromIconAndLabel(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleNoteObjectVisible(LPUNKNOWN a0,
                                            BOOL a1)
{
    _PrintEnter("OleNoteObjectVisible(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleNoteObjectVisible(a0, a1);
    } __finally {
        _PrintExit("OleNoteObjectVisible(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleQueryCreateFromData(IDataObject* a0)
{
    _PrintEnter("OleQueryCreateFromData(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleQueryCreateFromData(a0);
    } __finally {
        _PrintExit("OleQueryCreateFromData() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleQueryLinkFromData(IDataObject* a0)
{
    _PrintEnter("OleQueryLinkFromData(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleQueryLinkFromData(a0);
    } __finally {
        _PrintExit("OleQueryLinkFromData() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegEnumFormatEtc(CONST IID& a0,
                                           DWORD a1,
                                           IEnumFORMATETC** a2)
{
    _PrintEnter("OleRegEnumFormatEtc(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegEnumFormatEtc(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegEnumFormatEtc(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegEnumVerbs(CONST IID& a0,
                                       IEnumOLEVERB** a1)
{
    _PrintEnter("OleRegEnumVerbs(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegEnumVerbs(a0, a1);
    } __finally {
        _PrintExit("OleRegEnumVerbs(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegGetMiscStatus(CONST IID& a0,
                                           DWORD a1,
                                           DWORD* a2)
{
    _PrintEnter("OleRegGetMiscStatus(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegGetMiscStatus(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegGetMiscStatus(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegGetUserType(CONST IID& a0,
                                         DWORD a1,
                                         LPOLESTR* a2)
{
    _PrintEnter("OleRegGetUserType(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegGetUserType(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegGetUserType(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRun(LPUNKNOWN a0)
{
    _PrintEnter("OleRun(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRun(a0);
    } __finally {
        _PrintExit("OleRun() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSave(LPPERSISTSTORAGE a0,
                               LPSTORAGE a1,
                               BOOL a2)
{
    _PrintEnter("OleSave(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSave(a0, a1, a2);
    } __finally {
        _PrintExit("OleSave(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSaveToStream(IPersistStream* a0,
                                       LPSTREAM a1)
{
    _PrintEnter("OleSaveToStream(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSaveToStream(a0, a1);
    } __finally {
        _PrintExit("OleSaveToStream(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetAutoConvert(CONST IID& a0,
                                         CONST IID& a1)
{
    _PrintEnter("OleSetAutoConvert(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleSetAutoConvert(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetClipboard(IDataObject* a0)
{
    _PrintEnter("OleSetClipboard(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetClipboard(a0);
    } __finally {
        _PrintExit("OleSetClipboard() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetContainedObject(LPUNKNOWN a0,
                                             BOOL a1)
{
    _PrintEnter("OleSetContainedObject(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetContainedObject(a0, a1);
    } __finally {
        _PrintExit("OleSetContainedObject(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetMenuDescriptor(HOLEMENU a0,
                                            HWND a1,
                                            HWND a2,
                                            LPOLEINPLACEFRAME a3,
                                            LPOLEINPLACEACTIVEOBJECT a4)
{
    _PrintEnter("OleSetMenuDescriptor(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetMenuDescriptor(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("OleSetMenuDescriptor(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleTranslateAccelerator(LPOLEINPLACEFRAME a0,
                                               LPOLEINPLACEFRAMEINFO a1,
                                               LPMSG a2)
{
    _PrintEnter("OleTranslateAccelerator(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleTranslateAccelerator(a0, a1, a2);
    } __finally {
        _PrintExit("OleTranslateAccelerator(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_OleUninitialize(void)
{
    _PrintEnter("OleUninitialize()\n");

    __try {
        Real_OleUninitialize();
    } __finally {
        _PrintExit("OleUninitialize() ->\n");
    };
}

BOOL __stdcall Mine_OpenClipboard(HWND a0)
{
    _PrintEnter("OpenClipboard(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OpenClipboard(a0);
    } __finally {
        _PrintExit("OpenClipboard() -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HDESK __stdcall Mine_OpenDesktopA(LPSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
#else
HDESK __stdcall Mine_OpenDesktopA(LPCSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
#endif
{
    _PrintEnter("OpenDesktopA(%hs,%p,%p,%p)\n", a0, a1, a2, a3);

    HDESK rv = 0;
    __try {
        rv = Real_OpenDesktopA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OpenDesktopA(,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HDESK __stdcall Mine_OpenDesktopW(LPWSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
#else
HDESK __stdcall Mine_OpenDesktopW(LPCWSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
#endif
{
    _PrintEnter("OpenDesktopW(%ls,%p,%p,%p)\n", a0, a1, a2, a3);

    HDESK rv = 0;
    __try {
        rv = Real_OpenDesktopW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OpenDesktopW(,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenEventA(DWORD a0,
                                 BOOL a1,
                                 LPCSTR a2)
{
    _PrintEnter("OpenEventA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenEventA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenEventA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenEventW(DWORD a0,
                                 BOOL a1,
                                 LPCWSTR a2)
{
    _PrintEnter("OpenEventW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenEventW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenEventW(,,) -> %p\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine_OpenFile(LPCSTR a0,
                              LPOFSTRUCT a1,
                              UINT a2)
{
    _PrintEnter("OpenFile(%hs,%p,%p)\n", a0, a1, a2);

    HFILE rv = 0;
    __try {
        rv = Real_OpenFile(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFile(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenFileMappingA(DWORD a0,
                                       BOOL a1,
                                       LPCSTR a2)
{
    _PrintEnter("OpenFileMappingA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenFileMappingA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFileMappingA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenFileMappingW(DWORD a0,
                                       BOOL a1,
                                       LPCWSTR a2)
{
    _PrintEnter("OpenFileMappingW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenFileMappingW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFileMappingW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OpenIcon(HWND a0)
{
    _PrintEnter("OpenIcon(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OpenIcon(a0);
    } __finally {
        _PrintExit("OpenIcon() -> %p\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_OpenInputDesktop(DWORD a0,
                                      BOOL a1,
                                      ACCESS_MASK a2)
{
    _PrintEnter("OpenInputDesktop(%p,%p,%p)\n", a0, a1, a2);

    HDESK rv = 0;
    __try {
        rv = Real_OpenInputDesktop(a0, a1, a2);
    } __finally {
        _PrintExit("OpenInputDesktop(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenMutexA(DWORD a0,
                                 BOOL a1,
                                 LPCSTR a2)
{
    _PrintEnter("OpenMutexA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenMutexA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenMutexA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenMutexW(DWORD a0,
                                 BOOL a1,
                                 LPCWSTR a2)
{
    _PrintEnter("OpenMutexW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenMutexW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenMutexW(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenProcess(DWORD a0,
                                  BOOL a1,
                                  DWORD pid)
{
    _PrintEnter("OpenProcess(%p,%p,pid=%d)\n", a0, a1, pid);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenProcess(a0, a1, pid);
    } __finally {
        _PrintExit("OpenProcess(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OpenProcessToken(__in   HANDLE ProcessHandle,
                                     __in   DWORD DesiredAccess,
                                     __out  PHANDLE TokenHandle
                                    )
{
    _PrintEnter("OpenProcessToken(%p,%p,%p)\n",
                ProcessHandle,
                DesiredAccess,
                TokenHandle);

    BOOL rv = 0;
    __try {
        rv = Real_OpenProcessToken(ProcessHandle,
                                   DesiredAccess,
                                   TokenHandle);

    } __finally {
        _PrintExit("OpenProcessToken(,,%p) -> %p\n",
                   TokenHandle != NULL ? *TokenHandle : 0,
                   rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenSemaphoreA(DWORD a0,
                                     BOOL a1,
                                     LPCSTR a2)
{
    _PrintEnter("OpenSemaphoreA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenSemaphoreA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenSemaphoreA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenSemaphoreW(DWORD a0,
                                     BOOL a1,
                                     LPCWSTR a2)
{
    _PrintEnter("OpenSemaphoreW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenSemaphoreW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenSemaphoreW(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenWaitableTimerA(DWORD a0,
                                         BOOL a1,
                                         LPCSTR a2)
{
    _PrintEnter("OpenWaitableTimerA(%p,%p,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenWaitableTimerA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWaitableTimerA(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenWaitableTimerW(DWORD a0,
                                         BOOL a1,
                                         LPCWSTR a2)
{
    _PrintEnter("OpenWaitableTimerW(%p,%p,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenWaitableTimerW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWaitableTimerW(,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWINSTA __stdcall Mine_OpenWindowStationA(LPSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
#else
HWINSTA __stdcall Mine_OpenWindowStationA(LPCSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
#endif
{
    _PrintEnter("OpenWindowStationA(%hs,%p,%p)\n", a0, a1, a2);

    HWINSTA rv = 0;
    __try {
        rv = Real_OpenWindowStationA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWindowStationA(,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HWINSTA __stdcall Mine_OpenWindowStationW(LPWSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
#else
HWINSTA __stdcall Mine_OpenWindowStationW(LPCWSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
#endif
{
    _PrintEnter("OpenWindowStationW(%ls,%p,%p)\n", a0, a1, a2);

    HWINSTA rv = 0;
    __try {
        rv = Real_OpenWindowStationW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWindowStationW(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_OutputDebugStringA(LPCSTR a0)
{
    _PrintEnter("OutputDebugStringA(%hs)\n", a0);

    __try {
        Real_OutputDebugStringA(a0);
    } __finally {
        _PrintExit("OutputDebugStringA() ->\n");
    };
}

void __stdcall Mine_OutputDebugStringW(LPCWSTR a0)
{
    _PrintEnter("OutputDebugStringW(%ls)\n", a0);

    __try {
        Real_OutputDebugStringW(a0);
    } __finally {
        _PrintExit("OutputDebugStringW() ->\n");
    };
}

LPARAM __stdcall Mine_PackDDElParam(UINT a0,
                                    UINT_PTR a1,
                                    UINT_PTR a2)
{
    _PrintEnter("PackDDElParam(%p,%p,%p)\n", a0, a1, a2);

    LPARAM rv = 0;
    __try {
        rv = Real_PackDDElParam(a0, a1, a2);
    } __finally {
        _PrintExit("PackDDElParam(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PaintDesktop(HDC a0)
{
    _PrintEnter("PaintDesktop(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_PaintDesktop(a0);
    } __finally {
        _PrintExit("PaintDesktop() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PaintRgn(HDC a0,
                             HRGN a1)
{
    _PrintEnter("PaintRgn(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PaintRgn(a0, a1);
    } __finally {
        _PrintExit("PaintRgn(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PatBlt(HDC a0,
                           int a1,
                           int a2,
                           int a3,
                           int a4,
                           DWORD a5)
{
    _PrintEnter("PatBlt(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_PatBlt(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("PatBlt(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_PathToRegion(HDC a0)
{
    _PrintEnter("PathToRegion(%p)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_PathToRegion(a0);
    } __finally {
        _PrintExit("PathToRegion() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekConsoleInputA(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("PeekConsoleInputA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PeekConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PeekConsoleInputA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekConsoleInputW(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("PeekConsoleInputW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PeekConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PeekConsoleInputW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekMessageA(LPMSG a0,
                                 HWND a1,
                                 UINT a2,
                                 UINT a3,
                                 UINT a4)
{
    _PrintEnter("PeekMessageA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_PeekMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("PeekMessageA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekMessageW(LPMSG a0,
                                 HWND a1,
                                 UINT a2,
                                 UINT a3,
                                 UINT a4)
{
    _PrintEnter("PeekMessageW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_PeekMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("PeekMessageW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekNamedPipe(HANDLE a0,
                                  LPVOID a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPDWORD a4,
                                  LPDWORD a5)
{
    _PrintEnter("PeekNamedPipe(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_PeekNamedPipe(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("PeekNamedPipe(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Pie(HDC a0,
                        int a1,
                        int a2,
                        int a3,
                        int a4,
                        int a5,
                        int a6,
                        int a7,
                        int a8)
{
    _PrintEnter("Pie(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Pie(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Pie(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayEnhMetaFile(HDC a0,
                                    HENHMETAFILE a1,
                                    RECT* a2)
{
    _PrintEnter("PlayEnhMetaFile(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PlayEnhMetaFile(a0, a1, a2);
    } __finally {
        _PrintExit("PlayEnhMetaFile(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayEnhMetaFileRecord(HDC a0,
                                          LPHANDLETABLE a1,
                                          ENHMETARECORD* a2,
                                          UINT a3)
{
    _PrintEnter("PlayEnhMetaFileRecord(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PlayEnhMetaFileRecord(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PlayEnhMetaFileRecord(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayMetaFile(HDC a0,
                                 HMETAFILE a1)
{
    _PrintEnter("PlayMetaFile(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PlayMetaFile(a0, a1);
    } __finally {
        _PrintExit("PlayMetaFile(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayMetaFileRecord(HDC a0,
                                       LPHANDLETABLE a1,
                                       LPMETARECORD a2,
                                       UINT a3)
{
    _PrintEnter("PlayMetaFileRecord(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PlayMetaFileRecord(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PlayMetaFileRecord(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlgBlt(HDC a0,
                           POINT* a1,
                           HDC a2,
                           int a3,
                           int a4,
                           int a5,
                           int a6,
                           HBITMAP a7,
                           int a8,
                           int a9)
{
    _PrintEnter("PlgBlt(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_PlgBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("PlgBlt(,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyBezier(HDC a0,
                               POINT* a1,
                               DWORD a2)
{
    _PrintEnter("PolyBezier(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyBezier(a0, a1, a2);
    } __finally {
        _PrintExit("PolyBezier(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyBezierTo(HDC a0,
                                 POINT* a1,
                                 DWORD a2)
{
    _PrintEnter("PolyBezierTo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyBezierTo(a0, a1, a2);
    } __finally {
        _PrintExit("PolyBezierTo(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyDraw(HDC a0,
                             POINT* a1,
                             BYTE* a2,
                             int a3)
{
    _PrintEnter("PolyDraw(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyDraw(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyDraw(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyPolygon(HDC a0,
                                POINT* a1,
                                INT* a2,
                                int a3)
{
    _PrintEnter("PolyPolygon(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyPolygon(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyPolygon(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyPolyline(HDC a0,
                                 POINT* a1,
                                 DWORD* a2,
                                 DWORD a3)
{
    _PrintEnter("PolyPolyline(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyPolyline(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyPolyline(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyTextOutA(HDC a0,
                                 POLYTEXTA* a1,
                                 int a2)
{
    _PrintEnter("PolyTextOutA(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyTextOutA(a0, a1, a2);
    } __finally {
        _PrintExit("PolyTextOutA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyTextOutW(HDC a0,
                                 POLYTEXTW* a1,
                                 int a2)
{
    _PrintEnter("PolyTextOutW(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyTextOutW(a0, a1, a2);
    } __finally {
        _PrintExit("PolyTextOutW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Polygon(HDC a0,
                            POINT* a1,
                            int a2)
{
    _PrintEnter("Polygon(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_Polygon(a0, a1, a2);
    } __finally {
        _PrintExit("Polygon(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Polyline(HDC a0,
                             POINT* a1,
                             int a2)
{
    _PrintEnter("Polyline(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_Polyline(a0, a1, a2);
    } __finally {
        _PrintExit("Polyline(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolylineTo(HDC a0,
                               POINT* a1,
                               DWORD a2)
{
    _PrintEnter("PolylineTo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolylineTo(a0, a1, a2);
    } __finally {
        _PrintExit("PolylineTo(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostMessageA(HWND a0,
                                 UINT a1,
                                 WPARAM a2,
                                 LPARAM a3)
{
    _PrintEnter("PostMessageA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostMessageA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostMessageW(HWND a0,
                                 UINT a1,
                                 WPARAM a2,
                                 LPARAM a3)
{
    _PrintEnter("PostMessageW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostMessageW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostQueuedCompletionStatus(HANDLE a0,
                                               DWORD a1,
                                               ULONG_PTR a2,
                                               LPOVERLAPPED a3)
{
    _PrintEnter("PostQueuedCompletionStatus(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostQueuedCompletionStatus(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostQueuedCompletionStatus(,,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_PostQuitMessage(int a0)
{
    _PrintEnter("PostQuitMessage(%p)\n", a0);

    __try {
        Real_PostQuitMessage(a0);
    } __finally {
        _PrintExit("PostQuitMessage() ->\n");
    };
}

BOOL __stdcall Mine_PostThreadMessageA(DWORD a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("PostThreadMessageA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostThreadMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostThreadMessageA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostThreadMessageW(DWORD a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("PostThreadMessageW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostThreadMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostThreadMessageW(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_PrepareTape(HANDLE a0,
                                 DWORD a1,
                                 BOOL a2)
{
    _PrintEnter("PrepareTape(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_PrepareTape(a0, a1, a2);
    } __finally {
        _PrintExit("PrepareTape(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ProgIDFromCLSID(CONST IID& a0,
                                       LPOLESTR* a1)
{
    _PrintEnter("ProgIDFromCLSID(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ProgIDFromCLSID(a0, a1);
    } __finally {
        _PrintExit("ProgIDFromCLSID(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_PropVariantClear(PROPVARIANT* a0)
{
    _PrintEnter("PropVariantClear(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_PropVariantClear(a0);
    } __finally {
        _PrintExit("PropVariantClear() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_PropVariantCopy(PROPVARIANT* a0,
                                       PROPVARIANT* a1)
{
    _PrintEnter("PropVariantCopy(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_PropVariantCopy(a0, a1);
    } __finally {
        _PrintExit("PropVariantCopy(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtInRect(RECT* a0,
                             POINT a1)
{
    _PrintEnter("PtInRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PtInRect(a0, a1);
    } __finally {
        _PrintExit("PtInRect(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtInRegion(HRGN a0,
                               int a1,
                               int a2)
{
    _PrintEnter("PtInRegion(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PtInRegion(a0, a1, a2);
    } __finally {
        _PrintExit("PtInRegion(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtVisible(HDC a0,
                              int a1,
                              int a2)
{
    _PrintEnter("PtVisible(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PtVisible(a0, a1, a2);
    } __finally {
        _PrintExit("PtVisible(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PulseEvent(HANDLE a0)
{
    _PrintEnter("PulseEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_PulseEvent(a0);
    } __finally {
        _PrintExit("PulseEvent() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PurgeComm(HANDLE a0,
                              DWORD a1)
{
    _PrintEnter("PurgeComm(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PurgeComm(a0, a1);
    } __finally {
        _PrintExit("PurgeComm(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueryDosDeviceA(LPCSTR a0,
                                     LPSTR a1,
                                     DWORD a2)
{
    _PrintEnter("QueryDosDeviceA(%hs,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueryDosDeviceA(a0, a1, a2);
    } __finally {
        _PrintExit("QueryDosDeviceA(,%hs,) -> %p\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueryDosDeviceW(LPCWSTR a0,
                                     LPWSTR a1,
                                     DWORD a2)
{
    _PrintEnter("QueryDosDeviceW(%ls,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueryDosDeviceW(a0, a1, a2);
    } __finally {
        _PrintExit("QueryDosDeviceW(,%ls,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_QueryPerformanceCounter(LARGE_INTEGER* a0)
{
    _PrintEnter("QueryPerformanceCounter(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_QueryPerformanceCounter(a0);
    } __finally {
        _PrintExit("QueryPerformanceCounter() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_QueryPerformanceFrequency(LARGE_INTEGER* a0)
{
    _PrintEnter("QueryPerformanceFrequency(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_QueryPerformanceFrequency(a0);
    } __finally {
        _PrintExit("QueryPerformanceFrequency() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueueUserAPC(PAPCFUNC a0,
                                  HANDLE a1,
                                  ULONG_PTR a2)
{
    _PrintEnter("QueueUserAPC(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueueUserAPC(a0, a1, a2);
    } __finally {
        _PrintExit("QueueUserAPC(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_RaiseException(DWORD a0,
                                   DWORD a1,
                                   DWORD a2,
                                   ULONG_PTR* a3)
{
    _PrintEnter("RaiseException(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    __try {
        Real_RaiseException(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RaiseException(,,,) ->\n");
    };
}

HRESULT __stdcall Mine_ReadClassStg(LPSTORAGE a0,
                                    CLSID* a1)
{
    _PrintEnter("ReadClassStg(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadClassStg(a0, a1);
    } __finally {
        _PrintExit("ReadClassStg(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ReadClassStm(LPSTREAM a0,
                                    CLSID* a1)
{
    _PrintEnter("ReadClassStm(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadClassStm(a0, a1);
    } __finally {
        _PrintExit("ReadClassStm(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleA(
                                 HANDLE a0,
                                 LPVOID a1,
                                 DWORD a2,
                                 LPDWORD a3,
#ifdef ENABLE_INSERT_MODE
                                 PCONSOLE_READCONSOLE_CONTROL a4
#else
                                 LPVOID a4
#endif
                                )
{
    _PrintEnter("ReadConsoleA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleInputA(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("ReadConsoleInputA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("ReadConsoleInputA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleInputW(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("ReadConsoleInputW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("ReadConsoleInputW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputA(HANDLE a0,
                                       PCHAR_INFO a1,
                                       COORD a2,
                                       COORD a3,
                                       PSMALL_RECT a4)
{
    _PrintEnter("ReadConsoleOutputA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputAttribute(HANDLE a0,
                                               LPWORD a1,
                                               DWORD a2,
                                               COORD a3,
                                               LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputAttribute(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputAttribute(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputCharacterA(HANDLE a0,
                                                LPSTR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputCharacterA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputCharacterA(,%hs,,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputCharacterW(HANDLE a0,
                                                LPWSTR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputCharacterW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputCharacterW(,%ls,,,) -> %p\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputW(HANDLE a0,
                                       PCHAR_INFO a1,
                                       COORD a2,
                                       COORD a3,
                                       PSMALL_RECT a4)
{
    _PrintEnter("ReadConsoleOutputW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleW(
                                 HANDLE a0,
                                 LPVOID a1,
                                 DWORD a2,
                                 LPDWORD a3,
#ifdef ENABLE_INSERT_MODE
                                 PCONSOLE_READCONSOLE_CONTROL a4
#else
                                 LPVOID a4
#endif
                                )
{
    _PrintEnter("ReadConsoleW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadDirectoryChangesW(HANDLE a0,
                                          LPVOID a1,
                                          DWORD a2,
                                          BOOL a3,
                                          DWORD a4,
                                          LPDWORD a5,
                                          LPOVERLAPPED a6,
                                          LPOVERLAPPED_COMPLETION_ROUTINE a7)
{
    _PrintEnter("ReadDirectoryChangesW(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ReadDirectoryChangesW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ReadDirectoryChangesW(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadFile(HANDLE a0,
                             LPVOID a1,
                             DWORD a2,
                             LPDWORD a3,
                             LPOVERLAPPED a4)
{
    _PrintEnter("ReadFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadFileEx(HANDLE a0,
                               LPVOID a1,
                               DWORD a2,
                               LPOVERLAPPED a3,
                               LPOVERLAPPED_COMPLETION_ROUTINE a4)
{
    _PrintEnter("ReadFileEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadFileEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ReadFmtUserTypeStg(LPSTORAGE a0,
                                          CLIPFORMAT* a1,
                                          LPOLESTR* a2)
{
    _PrintEnter("ReadFmtUserTypeStg(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadFmtUserTypeStg(a0, a1, a2);
    } __finally {
        _PrintExit("ReadFmtUserTypeStg(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadProcessMemory(HANDLE a0,
                                      LPCVOID lpBase,
                                      LPVOID lpBuf,
                                      DWORD_PTR nSize,
                                      PDWORD_PTR a4)
{
    _PrintEnter("ReadProcessMemory(%p,@%p..%p,%p,%p)\n",
                a0, lpBase,
                (PBYTE)lpBase + ((nSize > 0) ? nSize - 1 : 0),
                lpBuf, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadProcessMemory(a0, lpBase, lpBuf, nSize, a4);
    } __finally {
        _PrintExit("ReadProcessMemory(,,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RealizePalette(HDC a0)
{
    _PrintEnter("RealizePalette(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RealizePalette(a0);
    } __finally {
        _PrintExit("RealizePalette() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RectInRegion(HRGN a0,
                                 RECT* a1)
{
    _PrintEnter("RectInRegion(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RectInRegion(a0, a1);
    } __finally {
        _PrintExit("RectInRegion(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RectVisible(HDC a0,
                                RECT* a1)
{
    _PrintEnter("RectVisible(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RectVisible(a0, a1);
    } __finally {
        _PrintExit("RectVisible(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Rectangle(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4)
{
    _PrintEnter("Rectangle(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_Rectangle(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Rectangle(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RedrawWindow(HWND a0,
                                 RECT* a1,
                                 HRGN a2,
                                 UINT a3)
{
    _PrintEnter("RedrawWindow(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_RedrawWindow(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RedrawWindow(,,,) -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassA(WNDCLASSA* a0)
{
    _PrintEnter("RegisterClassA(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassA(a0);
    } __finally {
        _PrintExit("RegisterClassA() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassExA(WNDCLASSEXA* a0)
{
    _PrintEnter("RegisterClassExA(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassExA(a0);
    } __finally {
        _PrintExit("RegisterClassExA() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassExW(WNDCLASSEXW* a0)
{
    _PrintEnter("RegisterClassExW(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassExW(a0);
    } __finally {
        _PrintExit("RegisterClassExW() -> %p\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassW(WNDCLASSW* a0)
{
    _PrintEnter("RegisterClassW(%p)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassW(a0);
    } __finally {
        _PrintExit("RegisterClassW() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterClipboardFormatA(LPCSTR a0)
{
    _PrintEnter("RegisterClipboardFormatA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterClipboardFormatA(a0);
    } __finally {
        _PrintExit("RegisterClipboardFormatA() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterClipboardFormatW(LPCWSTR a0)
{
    _PrintEnter("RegisterClipboardFormatW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterClipboardFormatW(a0);
    } __finally {
        _PrintExit("RegisterClipboardFormatW() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_RegisterDragDrop(HWND a0,
                                        IDropTarget* a1)
{
    _PrintEnter("RegisterDragDrop(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_RegisterDragDrop(a0, a1);
    } __finally {
        _PrintExit("RegisterDragDrop(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RegisterHotKey(HWND a0,
                                   int a1,
                                   UINT a2,
                                   UINT a3)
{
    _PrintEnter("RegisterHotKey(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_RegisterHotKey(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RegisterHotKey(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterWindowMessageA(LPCSTR a0)
{
    _PrintEnter("RegisterWindowMessageA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterWindowMessageA(a0);
    } __finally {
        _PrintExit("RegisterWindowMessageA() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterWindowMessageW(LPCWSTR a0)
{
    _PrintEnter("RegisterWindowMessageW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterWindowMessageW(a0);
    } __finally {
        _PrintExit("RegisterWindowMessageW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseCapture(void)
{
    _PrintEnter("ReleaseCapture()\n");

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseCapture();
    } __finally {
        _PrintExit("ReleaseCapture() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ReleaseDC(HWND a0,
                             HDC a1)
{
    _PrintEnter("ReleaseDC(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ReleaseDC(a0, a1);
    } __finally {
        _PrintExit("ReleaseDC(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseMutex(HANDLE a0)
{
    _PrintEnter("ReleaseMutex(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseMutex(a0);
    } __finally {
        _PrintExit("ReleaseMutex() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseSemaphore(HANDLE a0,
                                     LONG a1,
                                     LPLONG a2)
{
    _PrintEnter("ReleaseSemaphore(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseSemaphore(a0, a1, a2);
    } __finally {
        _PrintExit("ReleaseSemaphore(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_ReleaseStgMedium(LPSTGMEDIUM a0)
{
    _PrintEnter("ReleaseStgMedium(%p)\n", a0);

    __try {
        Real_ReleaseStgMedium(a0);
    } __finally {
        _PrintExit("ReleaseStgMedium() ->\n");
    };
}

BOOL __stdcall Mine_RemoveDirectoryA(LPCSTR a0)
{
    _PrintEnter("RemoveDirectoryA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveDirectoryA(a0);
    } __finally {
        _PrintExit("RemoveDirectoryA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveDirectoryW(LPCWSTR a0)
{
    _PrintEnter("RemoveDirectoryW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveDirectoryW(a0);
    } __finally {
        _PrintExit("RemoveDirectoryW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveFontResourceA(LPCSTR a0)
{
    _PrintEnter("RemoveFontResourceA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveFontResourceA(a0);
    } __finally {
        _PrintExit("RemoveFontResourceA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveFontResourceW(LPCWSTR a0)
{
    _PrintEnter("RemoveFontResourceW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveFontResourceW(a0);
    } __finally {
        _PrintExit("RemoveFontResourceW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveMenu(HMENU a0,
                               UINT a1,
                               UINT a2)
{
    _PrintEnter("RemoveMenu(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveMenu(a0, a1, a2);
    } __finally {
        _PrintExit("RemoveMenu(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_RemovePropA(HWND a0,
                                  LPCSTR a1)
{
    _PrintEnter("RemovePropA(%p,%hs)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_RemovePropA(a0, a1);
    } __finally {
        _PrintExit("RemovePropA(,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_RemovePropW(HWND a0,
                                  LPCWSTR a1)
{
    _PrintEnter("RemovePropW(%p,%ls)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_RemovePropW(a0, a1);
    } __finally {
        _PrintExit("RemovePropW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReplyMessage(LRESULT a0)
{
    _PrintEnter("ReplyMessage(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ReplyMessage(a0);
    } __finally {
        _PrintExit("ReplyMessage() -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_ResetDCA(HDC a0,
                            CONST DEVMODEA* a1)
{
    _PrintEnter("ResetDCA(%p,%p)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_ResetDCA(a0, a1);
    } __finally {
        _PrintExit("ResetDCA(,) -> %p\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_ResetDCW(HDC a0,
                            CONST DEVMODEW* a1)
{
    _PrintEnter("ResetDCW(%p,%p)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_ResetDCW(a0, a1);
    } __finally {
        _PrintExit("ResetDCW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ResetEvent(HANDLE a0)
{
    _PrintEnter("ResetEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ResetEvent(a0);
    } __finally {
        _PrintExit("ResetEvent() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ResizePalette(HPALETTE a0,
                                  UINT a1)
{
    _PrintEnter("ResizePalette(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ResizePalette(a0, a1);
    } __finally {
        _PrintExit("ResizePalette(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RestoreDC(HDC a0,
                              int a1)
{
    _PrintEnter("RestoreDC(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RestoreDC(a0, a1);
    } __finally {
        _PrintExit("RestoreDC(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_ResumeThread(HANDLE a0)
{
    _PrintEnter("ResumeThread(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_ResumeThread(a0);
    } __finally {
        _PrintExit("ResumeThread() -> %p\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_ReuseDDElParam(LPARAM a0,
                                     UINT a1,
                                     UINT a2,
                                     UINT_PTR a3,
                                     UINT_PTR a4)
{
    _PrintEnter("ReuseDDElParam(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LPARAM rv = 0;
    __try {
        rv = Real_ReuseDDElParam(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReuseDDElParam(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_RevokeDragDrop(HWND a0)
{
    _PrintEnter("RevokeDragDrop(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_RevokeDragDrop(a0);
    } __finally {
        _PrintExit("RevokeDragDrop() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RoundRect(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4,
                              int a5,
                              int a6)
{
    _PrintEnter("RoundRect(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_RoundRect(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("RoundRect(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SaveDC(HDC a0)
{
    _PrintEnter("SaveDC(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_SaveDC(a0);
    } __finally {
        _PrintExit("SaveDC() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScaleViewportExtEx(HDC a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       int a4,
                                       SIZE* a5)
{
    _PrintEnter("ScaleViewportExtEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_ScaleViewportExtEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ScaleViewportExtEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScaleWindowExtEx(HDC a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     SIZE* a5)
{
    _PrintEnter("ScaleWindowExtEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_ScaleWindowExtEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ScaleWindowExtEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScreenToClient(HWND a0,
                                   POINT* a1)
{
    _PrintEnter("ScreenToClient(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ScreenToClient(a0, a1);
    } __finally {
        _PrintExit("ScreenToClient(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollConsoleScreenBufferA(HANDLE a0,
                                               SMALL_RECT* a1,
                                               SMALL_RECT* a2,
                                               COORD a3,
                                               CHAR_INFO* a4)
{
    _PrintEnter("ScrollConsoleScreenBufferA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollConsoleScreenBufferA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollConsoleScreenBufferA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollConsoleScreenBufferW(HANDLE a0,
                                               SMALL_RECT* a1,
                                               SMALL_RECT* a2,
                                               COORD a3,
                                               CHAR_INFO* a4)
{
    _PrintEnter("ScrollConsoleScreenBufferW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollConsoleScreenBufferW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollConsoleScreenBufferW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollDC(HDC a0,
                             int a1,
                             int a2,
                             RECT* a3,
                             RECT* a4,
                             HRGN a5,
                             LPRECT a6)
{
    _PrintEnter("ScrollDC(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollDC(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("ScrollDC(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollWindow(HWND a0,
                                 int a1,
                                 int a2,
                                 RECT* a3,
                                 RECT* a4)
{
    _PrintEnter("ScrollWindow(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollWindow(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollWindow(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ScrollWindowEx(HWND a0,
                                  int a1,
                                  int a2,
                                  RECT* a3,
                                  RECT* a4,
                                  HRGN a5,
                                  LPRECT a6,
                                  UINT a7)
{
    _PrintEnter("ScrollWindowEx(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    int rv = 0;
    __try {
        rv = Real_ScrollWindowEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ScrollWindowEx(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SearchPathA(LPCSTR a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 DWORD a3,
                                 LPSTR a4,
                                 LPSTR* a5)
{
    _PrintEnter("SearchPathA(%hs,%hs,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SearchPathA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SearchPathA(,,,,%hs,) -> %p\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_SearchPathW(LPCWSTR a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 DWORD a3,
                                 LPWSTR a4,
                                 LPWSTR* a5)
{
    _PrintEnter("SearchPathW(%ls,%ls,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SearchPathW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SearchPathW(,,,,%ls,) -> %p\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_SelectClipPath(HDC a0,
                                   int a1)
{
    _PrintEnter("SelectClipPath(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SelectClipPath(a0, a1);
    } __finally {
        _PrintExit("SelectClipPath(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SelectClipRgn(HDC a0,
                                 HRGN a1)
{
    _PrintEnter("SelectClipRgn(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SelectClipRgn(a0, a1);
    } __finally {
        _PrintExit("SelectClipRgn(,) -> %p\n", rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_SelectObject(HDC a0,
                                    HGDIOBJ a1)
{
    _PrintEnter("SelectObject(%p,%p)\n", a0, a1);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_SelectObject(a0, a1);
    } __finally {
        _PrintExit("SelectObject(,) -> %p\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_SelectPalette(HDC a0,
                                      HPALETTE a1,
                                      BOOL a2)
{
    _PrintEnter("SelectPalette(%p,%p,%p)\n", a0, a1, a2);

    HPALETTE rv = 0;
    __try {
        rv = Real_SelectPalette(a0, a1, a2);
    } __finally {
        _PrintExit("SelectPalette(,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendDlgItemMessageA(HWND a0,
                                           int a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
{
    _PrintEnter("SendDlgItemMessageA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_SendDlgItemMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SendDlgItemMessageA(,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendDlgItemMessageW(HWND a0,
                                           int a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
{
    _PrintEnter("SendDlgItemMessageW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_SendDlgItemMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SendDlgItemMessageW(,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageA(HWND a0,
                                    UINT a1,
                                    WPARAM a2,
                                    LPARAM a3)
{
    _PrintEnter("SendMessageA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendMessageA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendMessageCallbackA(HWND a0,
                                         UINT a1,
                                         WPARAM a2,
                                         LPARAM a3,
                                         SENDASYNCPROC a4,
                                         ULONG_PTR a5)
{
    _PrintEnter("SendMessageCallbackA(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SendMessageCallbackA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SendMessageCallbackA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendMessageCallbackW(HWND a0,
                                         UINT a1,
                                         WPARAM a2,
                                         LPARAM a3,
                                         SENDASYNCPROC a4,
                                         ULONG_PTR a5)
{
    _PrintEnter("SendMessageCallbackW(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SendMessageCallbackW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SendMessageCallbackW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageTimeoutA(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3,
                                           UINT a4,
                                           UINT a5,
                                           PULONG_PTR a6)
{
    _PrintEnter("SendMessageTimeoutA(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageTimeoutA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SendMessageTimeoutA(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageTimeoutW(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3,
                                           UINT a4,
                                           UINT a5,
                                           PULONG_PTR a6)
{
    _PrintEnter("SendMessageTimeoutW(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageTimeoutW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SendMessageTimeoutW(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageW(HWND a0,
                                    UINT a1,
                                    WPARAM a2,
                                    LPARAM a3)
{
    _PrintEnter("SendMessageW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendMessageW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendNotifyMessageA(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("SendNotifyMessageA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SendNotifyMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendNotifyMessageA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendNotifyMessageW(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("SendNotifyMessageW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SendNotifyMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendNotifyMessageW(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetAbortProc(HDC a0,
                                ABORTPROC a1)
{
    _PrintEnter("SetAbortProc(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetAbortProc(a0, a1);
    } __finally {
        _PrintExit("SetAbortProc(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetActiveWindow(HWND a0)
{
    _PrintEnter("SetActiveWindow(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetActiveWindow(a0);
    } __finally {
        _PrintExit("SetActiveWindow() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetArcDirection(HDC a0,
                                   int a1)
{
    _PrintEnter("SetArcDirection(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetArcDirection(a0, a1);
    } __finally {
        _PrintExit("SetArcDirection(,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetBitmapBits(HBITMAP a0,
                                  DWORD a1,
                                  void* a2)
{
    _PrintEnter("SetBitmapBits(%p,%p,%p)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetBitmapBits(a0, a1, a2);
    } __finally {
        _PrintExit("SetBitmapBits(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetBitmapDimensionEx(HBITMAP a0,
                                         int a1,
                                         int a2,
                                         SIZE* a3)
{
    _PrintEnter("SetBitmapDimensionEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetBitmapDimensionEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetBitmapDimensionEx(,,,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetBkColor(HDC a0,
                                   COLORREF a1)
{
    _PrintEnter("SetBkColor(%p,%p)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_SetBkColor(a0, a1);
    } __finally {
        _PrintExit("SetBkColor(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetBkMode(HDC a0,
                             int a1)
{
    _PrintEnter("SetBkMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetBkMode(a0, a1);
    } __finally {
        _PrintExit("SetBkMode(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetBoundsRect(HDC a0,
                                  RECT* a1,
                                  UINT a2)
{
    _PrintEnter("SetBoundsRect(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_SetBoundsRect(a0, a1, a2);
    } __finally {
        _PrintExit("SetBoundsRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetBrushOrgEx(HDC a0,
                                  int a1,
                                  int a2,
                                  POINT* a3)
{
    _PrintEnter("SetBrushOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetBrushOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetBrushOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetCapture(HWND a0)
{
    _PrintEnter("SetCapture(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetCapture(a0);
    } __finally {
        _PrintExit("SetCapture() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCaretBlinkTime(UINT a0)
{
    _PrintEnter("SetCaretBlinkTime(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCaretBlinkTime(a0);
    } __finally {
        _PrintExit("SetCaretBlinkTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCaretPos(int a0,
                                int a1)
{
    _PrintEnter("SetCaretPos(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCaretPos(a0, a1);
    } __finally {
        _PrintExit("SetCaretPos(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetClassLongA(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetClassLongA(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetClassLongA(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassLongA(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetClassLongW(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetClassLongW(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetClassLongW(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassLongW(,,) -> %p\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_SetClassWord(HWND a0,
                                 int a1,
                                 WORD a2)
{
    _PrintEnter("SetClassWord(%p,%p,%p)\n", a0, a1, a2);

    WORD rv = 0;
    __try {
        rv = Real_SetClassWord(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassWord(,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_SetClipboardData(UINT a0,
                                       HANDLE a1)
{
    _PrintEnter("SetClipboardData(%p,%p)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_SetClipboardData(a0, a1);
    } __finally {
        _PrintExit("SetClipboardData(,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetClipboardViewer(HWND a0)
{
    _PrintEnter("SetClipboardViewer(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetClipboardViewer(a0);
    } __finally {
        _PrintExit("SetClipboardViewer() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetColorAdjustment(HDC a0,
                                       COLORADJUSTMENT* a1)
{
    _PrintEnter("SetColorAdjustment(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetColorAdjustment(a0, a1);
    } __finally {
        _PrintExit("SetColorAdjustment(,) -> %p\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_SetColorSpace(HDC a0,
                                         HCOLORSPACE a1)
{
    _PrintEnter("SetColorSpace(%p,%p)\n", a0, a1);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_SetColorSpace(a0, a1);
    } __finally {
        _PrintExit("SetColorSpace(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommBreak(HANDLE a0)
{
    _PrintEnter("SetCommBreak(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommBreak(a0);
    } __finally {
        _PrintExit("SetCommBreak() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommConfig(HANDLE a0,
                                  LPCOMMCONFIG a1,
                                  DWORD a2)
{
    _PrintEnter("SetCommConfig(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommConfig(a0, a1, a2);
    } __finally {
        _PrintExit("SetCommConfig(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommMask(HANDLE a0,
                                DWORD a1)
{
    _PrintEnter("SetCommMask(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommMask(a0, a1);
    } __finally {
        _PrintExit("SetCommMask(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommState(HANDLE a0,
                                 LPDCB a1)
{
    _PrintEnter("SetCommState(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommState(a0, a1);
    } __finally {
        _PrintExit("SetCommState(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommTimeouts(HANDLE a0,
                                    LPCOMMTIMEOUTS a1)
{
    _PrintEnter("SetCommTimeouts(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommTimeouts(a0, a1);
    } __finally {
        _PrintExit("SetCommTimeouts(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetComputerNameA(LPCSTR a0)
{
    _PrintEnter("SetComputerNameA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetComputerNameA(a0);
    } __finally {
        _PrintExit("SetComputerNameA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetComputerNameW(LPCWSTR a0)
{
    _PrintEnter("SetComputerNameW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetComputerNameW(a0);
    } __finally {
        _PrintExit("SetComputerNameW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleActiveScreenBuffer(HANDLE a0)
{
    _PrintEnter("SetConsoleActiveScreenBuffer(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleActiveScreenBuffer(a0);
    } __finally {
        _PrintExit("SetConsoleActiveScreenBuffer() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCP(UINT a0)
{
    _PrintEnter("SetConsoleCP(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCP(a0);
    } __finally {
        _PrintExit("SetConsoleCP() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCtrlHandler(PHANDLER_ROUTINE a0,
                                          BOOL a1)
{
    _PrintEnter("SetConsoleCtrlHandler(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCtrlHandler(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCtrlHandler(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCursorInfo(HANDLE a0,
                                         CONSOLE_CURSOR_INFO* a1)
{
    _PrintEnter("SetConsoleCursorInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCursorInfo(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCursorInfo(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCursorPosition(HANDLE a0,
                                             COORD a1)
{
    _PrintEnter("SetConsoleCursorPosition(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCursorPosition(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCursorPosition(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleMode(HANDLE a0,
                                   DWORD a1)
{
    _PrintEnter("SetConsoleMode(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleMode(a0, a1);
    } __finally {
        _PrintExit("SetConsoleMode(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleOutputCP(UINT a0)
{
    _PrintEnter("SetConsoleOutputCP(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleOutputCP(a0);
    } __finally {
        _PrintExit("SetConsoleOutputCP() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleScreenBufferSize(HANDLE a0,
                                               COORD a1)
{
    _PrintEnter("SetConsoleScreenBufferSize(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleScreenBufferSize(a0, a1);
    } __finally {
        _PrintExit("SetConsoleScreenBufferSize(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTextAttribute(HANDLE a0,
                                            WORD a1)
{
    _PrintEnter("SetConsoleTextAttribute(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTextAttribute(a0, a1);
    } __finally {
        _PrintExit("SetConsoleTextAttribute(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTitleA(LPCSTR a0)
{
    _PrintEnter("SetConsoleTitleA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTitleA(a0);
    } __finally {
        _PrintExit("SetConsoleTitleA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTitleW(LPCWSTR a0)
{
    _PrintEnter("SetConsoleTitleW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTitleW(a0);
    } __finally {
        _PrintExit("SetConsoleTitleW() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleWindowInfo(HANDLE a0,
                                         BOOL a1,
                                         SMALL_RECT* a2)
{
    _PrintEnter("SetConsoleWindowInfo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleWindowInfo(a0, a1, a2);
    } __finally {
        _PrintExit("SetConsoleWindowInfo(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_SetConvertStg(LPSTORAGE a0,
                                     BOOL a1)
{
    _PrintEnter("SetConvertStg(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_SetConvertStg(a0, a1);
    } __finally {
        _PrintExit("SetConvertStg(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCurrentDirectoryA(LPCSTR a0)
{
    _PrintEnter("SetCurrentDirectoryA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCurrentDirectoryA(a0);
    } __finally {
        _PrintExit("SetCurrentDirectoryA() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCurrentDirectoryW(LPCWSTR a0)
{
    _PrintEnter("SetCurrentDirectoryW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCurrentDirectoryW(a0);
    } __finally {
        _PrintExit("SetCurrentDirectoryW() -> %p\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_SetCursor(HCURSOR a0)
{
    _PrintEnter("SetCursor(%p)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_SetCursor(a0);
    } __finally {
        _PrintExit("SetCursor() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCursorPos(int a0,
                                 int a1)
{
    _PrintEnter("SetCursorPos(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCursorPos(a0, a1);
    } __finally {
        _PrintExit("SetCursorPos(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetDIBColorTable(HDC a0,
                                     UINT a1,
                                     UINT a2,
                                     RGBQUAD* a3)
{
    _PrintEnter("SetDIBColorTable(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_SetDIBColorTable(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetDIBColorTable(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetDIBits(HDC a0,
                             HBITMAP a1,
                             UINT a2,
                             UINT a3,
                             void* a4,
                             BITMAPINFO* a5,
                             UINT a6)
{
    _PrintEnter("SetDIBits(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_SetDIBits(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SetDIBits(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetDIBitsToDevice(HDC a0,
                                     int a1,
                                     int a2,
                                     DWORD a3,
                                     DWORD a4,
                                     int a5,
                                     int a6,
                                     UINT a7,
                                     UINT a8,
                                     void* a9,
                                     BITMAPINFO* a10,
                                     UINT a11)
{
    _PrintEnter("SetDIBitsToDevice(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    int rv = 0;
    __try {
        rv = Real_SetDIBitsToDevice(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("SetDIBitsToDevice(,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDefaultCommConfigA(LPCSTR a0,
                                          LPCOMMCONFIG a1,
                                          DWORD a2)
{
    _PrintEnter("SetDefaultCommConfigA(%hs,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDefaultCommConfigA(a0, a1, a2);
    } __finally {
        _PrintExit("SetDefaultCommConfigA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDefaultCommConfigW(LPCWSTR a0,
                                          LPCOMMCONFIG a1,
                                          DWORD a2)
{
    _PrintEnter("SetDefaultCommConfigW(%ls,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDefaultCommConfigW(a0, a1, a2);
    } __finally {
        _PrintExit("SetDefaultCommConfigW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDeviceGammaRamp(HDC a0,
                                       LPVOID a1)
{
    _PrintEnter("SetDeviceGammaRamp(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetDeviceGammaRamp(a0, a1);
    } __finally {
        _PrintExit("SetDeviceGammaRamp(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemInt(HWND a0,
                                  int a1,
                                  UINT a2,
                                  BOOL a3)
{
    _PrintEnter("SetDlgItemInt(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemInt(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetDlgItemInt(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemTextA(HWND a0,
                                    int a1,
                                    LPCSTR a2)
{
    _PrintEnter("SetDlgItemTextA(%p,%p,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemTextA(a0, a1, a2);
    } __finally {
        _PrintExit("SetDlgItemTextA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemTextW(HWND a0,
                                    int a1,
                                    LPCWSTR a2)
{
    _PrintEnter("SetDlgItemTextW(%p,%p,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemTextW(a0, a1, a2);
    } __finally {
        _PrintExit("SetDlgItemTextW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDoubleClickTime(UINT a0)
{
    _PrintEnter("SetDoubleClickTime(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetDoubleClickTime(a0);
    } __finally {
        _PrintExit("SetDoubleClickTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEndOfFile(HANDLE a0)
{
    _PrintEnter("SetEndOfFile(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetEndOfFile(a0);
    } __finally {
        _PrintExit("SetEndOfFile() -> %p\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_SetEnhMetaFileBits(UINT a0,
                                               BYTE* a1)
{
    _PrintEnter("SetEnhMetaFileBits(%p,%p)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_SetEnhMetaFileBits(a0, a1);
    } __finally {
        _PrintExit("SetEnhMetaFileBits(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEnvironmentVariableA(LPCSTR a0,
                                            LPCSTR a1)
{
    _PrintEnter("SetEnvironmentVariableA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetEnvironmentVariableA(a0, a1);
    } __finally {
        _PrintExit("SetEnvironmentVariableA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEnvironmentVariableW(LPCWSTR a0,
                                            LPCWSTR a1)
{
    _PrintEnter("SetEnvironmentVariableW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetEnvironmentVariableW(a0, a1);
    } __finally {
        _PrintExit("SetEnvironmentVariableW(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetErrorMode(UINT a0)
{
    _PrintEnter("SetErrorMode(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_SetErrorMode(a0);
    } __finally {
        _PrintExit("SetErrorMode() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEvent(HANDLE a0)
{
    _PrintEnter("SetEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetEvent(a0);
    } __finally {
        _PrintExit("SetEvent() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_SetFileApisToANSI(void)
{
    _PrintEnter("SetFileApisToANSI()\n");

    __try {
        Real_SetFileApisToANSI();
    } __finally {
        _PrintExit("SetFileApisToANSI() ->\n");
    };
}

void __stdcall Mine_SetFileApisToOEM(void)
{
    _PrintEnter("SetFileApisToOEM()\n");

    __try {
        Real_SetFileApisToOEM();
    } __finally {
        _PrintExit("SetFileApisToOEM() ->\n");
    };
}

BOOL __stdcall Mine_SetFileAttributesA(LPCSTR a0,
                                       DWORD a1)
{
    _PrintEnter("SetFileAttributesA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileAttributesA(a0, a1);
    } __finally {
        _PrintExit("SetFileAttributesA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetFileAttributesW(LPCWSTR a0,
                                       DWORD a1)
{
    _PrintEnter("SetFileAttributesW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileAttributesW(a0, a1);
    } __finally {
        _PrintExit("SetFileAttributesW(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetFilePointer(HANDLE a0,
                                    LONG a1,
                                    PLONG a2,
                                    DWORD a3)
{
    _PrintEnter("SetFilePointer(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_SetFilePointer(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetFilePointer(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetFileTime(HANDLE a0,
                                FILETIME* a1,
                                FILETIME* a2,
                                FILETIME* a3)
{
    _PrintEnter("SetFileTime(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileTime(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetFileTime(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetFocus(HWND a0)
{
    _PrintEnter("SetFocus(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetFocus(a0);
    } __finally {
        _PrintExit("SetFocus() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetForegroundWindow(HWND a0)
{
    _PrintEnter("SetForegroundWindow(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetForegroundWindow(a0);
    } __finally {
        _PrintExit("SetForegroundWindow() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetGraphicsMode(HDC a0,
                                   int a1)
{
    _PrintEnter("SetGraphicsMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetGraphicsMode(a0, a1);
    } __finally {
        _PrintExit("SetGraphicsMode(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetHandleCount(UINT a0)
{
    _PrintEnter("SetHandleCount(%p)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_SetHandleCount(a0);
    } __finally {
        _PrintExit("SetHandleCount() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetHandleInformation(HANDLE a0,
                                         DWORD a1,
                                         DWORD a2)
{
    _PrintEnter("SetHandleInformation(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetHandleInformation(a0, a1, a2);
    } __finally {
        _PrintExit("SetHandleInformation(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetICMMode(HDC a0,
                              int a1)
{
    _PrintEnter("SetICMMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetICMMode(a0, a1);
    } __finally {
        _PrintExit("SetICMMode(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetICMProfileA(HDC a0,
                                   LPSTR a1)
{
    _PrintEnter("SetICMProfileA(%p,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetICMProfileA(a0, a1);
    } __finally {
        _PrintExit("SetICMProfileA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetICMProfileW(HDC a0,
                                   LPWSTR a1)
{
    _PrintEnter("SetICMProfileW(%p,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetICMProfileW(a0, a1);
    } __finally {
        _PrintExit("SetICMProfileW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetKeyboardState(LPBYTE a0)
{
    _PrintEnter("SetKeyboardState(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetKeyboardState(a0);
    } __finally {
        _PrintExit("SetKeyboardState() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocalTime(SYSTEMTIME* a0)
{
    _PrintEnter("SetLocalTime(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocalTime(a0);
    } __finally {
        _PrintExit("SetLocalTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocaleInfoA(LCID a0,
                                   LCTYPE a1,
                                   LPCSTR a2)
{
    _PrintEnter("SetLocaleInfoA(%p,%p,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocaleInfoA(a0, a1, a2);
    } __finally {
        _PrintExit("SetLocaleInfoA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocaleInfoW(LCID a0,
                                   LCTYPE a1,
                                   LPCWSTR a2)
{
    _PrintEnter("SetLocaleInfoW(%p,%p,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocaleInfoW(a0, a1, a2);
    } __finally {
        _PrintExit("SetLocaleInfoW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMailslotInfo(HANDLE a0,
                                    DWORD a1)
{
    _PrintEnter("SetMailslotInfo(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMailslotInfo(a0, a1);
    } __finally {
        _PrintExit("SetMailslotInfo(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetMapMode(HDC a0,
                              int a1)
{
    _PrintEnter("SetMapMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetMapMode(a0, a1);
    } __finally {
        _PrintExit("SetMapMode(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetMapperFlags(HDC a0,
                                    DWORD a1)
{
    _PrintEnter("SetMapperFlags(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SetMapperFlags(a0, a1);
    } __finally {
        _PrintExit("SetMapperFlags(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenu(HWND a0,
                            HMENU a1)
{
    _PrintEnter("SetMenu(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenu(a0, a1);
    } __finally {
        _PrintExit("SetMenu(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuContextHelpId(HMENU a0,
                                         DWORD a1)
{
    _PrintEnter("SetMenuContextHelpId(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuContextHelpId(a0, a1);
    } __finally {
        _PrintExit("SetMenuContextHelpId(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuDefaultItem(HMENU a0,
                                       UINT a1,
                                       UINT a2)
{
    _PrintEnter("SetMenuDefaultItem(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuDefaultItem(a0, a1, a2);
    } __finally {
        _PrintExit("SetMenuDefaultItem(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemBitmaps(HMENU a0,
                                       UINT a1,
                                       UINT a2,
                                       HBITMAP a3,
                                       HBITMAP a4)
{
    _PrintEnter("SetMenuItemBitmaps(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemBitmaps(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetMenuItemBitmaps(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemInfoA(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     MENUITEMINFOA* a3)
{
    _PrintEnter("SetMenuItemInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetMenuItemInfoA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemInfoW(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     MENUITEMINFOW* a3)
{
    _PrintEnter("SetMenuItemInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetMenuItemInfoW(,,,) -> %p\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_SetMessageExtraInfo(LPARAM a0)
{
    _PrintEnter("SetMessageExtraInfo(%p)\n", a0);

    LPARAM rv = 0;
    __try {
        rv = Real_SetMessageExtraInfo(a0);
    } __finally {
        _PrintExit("SetMessageExtraInfo() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMessageQueue(int a0)
{
    _PrintEnter("SetMessageQueue(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetMessageQueue(a0);
    } __finally {
        _PrintExit("SetMessageQueue() -> %p\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_SetMetaFileBitsEx(UINT a0,
                                           BYTE* a1)
{
    _PrintEnter("SetMetaFileBitsEx(%p,%p)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_SetMetaFileBitsEx(a0, a1);
    } __finally {
        _PrintExit("SetMetaFileBitsEx(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetMetaRgn(HDC a0)
{
    _PrintEnter("SetMetaRgn(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_SetMetaRgn(a0);
    } __finally {
        _PrintExit("SetMetaRgn() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMiterLimit(HDC a0,
                                  FLOAT a1,
                                  PFLOAT a2)
{
    _PrintEnter("SetMiterLimit(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetMiterLimit(a0, a1, a2);
    } __finally {
        _PrintExit("SetMiterLimit(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetNamedPipeHandleState(HANDLE a0,
                                            LPDWORD a1,
                                            LPDWORD a2,
                                            LPDWORD a3)
{
    _PrintEnter("SetNamedPipeHandleState(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetNamedPipeHandleState(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetNamedPipeHandleState(,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetPaletteEntries(HPALETTE a0,
                                      UINT a1,
                                      UINT a2,
                                      PALETTEENTRY* a3)
{
    _PrintEnter("SetPaletteEntries(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_SetPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPaletteEntries(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetParent(HWND a0,
                              HWND a1)
{
    _PrintEnter("SetParent(%p,%p)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_SetParent(a0, a1);
    } __finally {
        _PrintExit("SetParent(,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetPixel(HDC a0,
                                 int a1,
                                 int a2,
                                 COLORREF a3)
{
    _PrintEnter("SetPixel(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    COLORREF rv = 0;
    __try {
        rv = Real_SetPixel(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPixel(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPixelFormat(HDC a0,
                                   int a1,
                                   PIXELFORMATDESCRIPTOR* a2)
{
    _PrintEnter("SetPixelFormat(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPixelFormat(a0, a1, a2);
    } __finally {
        _PrintExit("SetPixelFormat(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPixelV(HDC a0,
                              int a1,
                              int a2,
                              COLORREF a3)
{
    _PrintEnter("SetPixelV(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetPixelV(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPixelV(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetPolyFillMode(HDC a0,
                                   int a1)
{
    _PrintEnter("SetPolyFillMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetPolyFillMode(a0, a1);
    } __finally {
        _PrintExit("SetPolyFillMode(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPriorityClass(HANDLE a0,
                                     DWORD a1)
{
    _PrintEnter("SetPriorityClass(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetPriorityClass(a0, a1);
    } __finally {
        _PrintExit("SetPriorityClass(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessAffinityMask(HANDLE a0,
                                           DWORD_PTR a1)
{
    _PrintEnter("SetProcessAffinityMask(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessAffinityMask(a0, a1);
    } __finally {
        _PrintExit("SetProcessAffinityMask(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessShutdownParameters(DWORD a0,
                                                 DWORD a1)
{
    _PrintEnter("SetProcessShutdownParameters(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessShutdownParameters(a0, a1);
    } __finally {
        _PrintExit("SetProcessShutdownParameters(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessWindowStation(HWINSTA a0)
{
    _PrintEnter("SetProcessWindowStation(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessWindowStation(a0);
    } __finally {
        _PrintExit("SetProcessWindowStation() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessWorkingSetSize(HANDLE a0,
                                             SIZE_T a1,
                                             SIZE_T a2)
{
    _PrintEnter("SetProcessWorkingSetSize(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessWorkingSetSize(a0, a1, a2);
    } __finally {
        _PrintExit("SetProcessWorkingSetSize(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPropA(HWND a0,
                             LPCSTR a1,
                             HANDLE a2)
{
    _PrintEnter("SetPropA(%p,%hs,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPropA(a0, a1, a2);
    } __finally {
        _PrintExit("SetPropA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPropW(HWND a0,
                             LPCWSTR a1,
                             HANDLE a2)
{
    _PrintEnter("SetPropW(%p,%ls,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPropW(a0, a1, a2);
    } __finally {
        _PrintExit("SetPropW(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetROP2(HDC a0,
                           int a1)
{
    _PrintEnter("SetROP2(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetROP2(a0, a1);
    } __finally {
        _PrintExit("SetROP2(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRect(LPRECT a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4)
{
    _PrintEnter("SetRect(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetRect(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRectEmpty(LPRECT a0)
{
    _PrintEnter("SetRectEmpty(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetRectEmpty(a0);
    } __finally {
        _PrintExit("SetRectEmpty() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRectRgn(HRGN a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4)
{
    _PrintEnter("SetRectRgn(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetRectRgn(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetRectRgn(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetScrollInfo(HWND a0,
                                 int a1,
                                 LPCSCROLLINFO a2,
                                 BOOL a3)
{
    _PrintEnter("SetScrollInfo(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_SetScrollInfo(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetScrollInfo(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetScrollPos(HWND a0,
                                int a1,
                                int a2,
                                BOOL a3)
{
    _PrintEnter("SetScrollPos(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_SetScrollPos(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetScrollPos(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetScrollRange(HWND a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   BOOL a4)
{
    _PrintEnter("SetScrollRange(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetScrollRange(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetScrollRange(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetStdHandle(DWORD a0,
                                 HANDLE a1)
{
    _PrintEnter("SetStdHandle(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetStdHandle(a0, a1);
    } __finally {
        _PrintExit("SetStdHandle(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetStretchBltMode(HDC a0,
                                     int a1)
{
    _PrintEnter("SetStretchBltMode(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetStretchBltMode(a0, a1);
    } __finally {
        _PrintExit("SetStretchBltMode(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSysColors(int a0,
                                 INT* a1,
                                 COLORREF* a2)
{
    _PrintEnter("SetSysColors(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetSysColors(a0, a1, a2);
    } __finally {
        _PrintExit("SetSysColors(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemCursor(HCURSOR a0,
                                    DWORD a1)
{
    _PrintEnter("SetSystemCursor(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemCursor(a0, a1);
    } __finally {
        _PrintExit("SetSystemCursor(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetSystemPaletteUse(HDC a0,
                                        UINT a1)
{
    _PrintEnter("SetSystemPaletteUse(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_SetSystemPaletteUse(a0, a1);
    } __finally {
        _PrintExit("SetSystemPaletteUse(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemPowerState(BOOL a0,
                                        BOOL a1)
{
    _PrintEnter("SetSystemPowerState(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemPowerState(a0, a1);
    } __finally {
        _PrintExit("SetSystemPowerState(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemTime(SYSTEMTIME* a0)
{
    _PrintEnter("SetSystemTime(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemTime(a0);
    } __finally {
        _PrintExit("SetSystemTime() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemTimeAdjustment(DWORD a0,
                                            BOOL a1)
{
    _PrintEnter("SetSystemTimeAdjustment(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemTimeAdjustment(a0, a1);
    } __finally {
        _PrintExit("SetSystemTimeAdjustment(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetTapeParameters(HANDLE a0,
                                       DWORD a1,
                                       LPVOID a2)
{
    _PrintEnter("SetTapeParameters(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetTapeParameters(a0, a1, a2);
    } __finally {
        _PrintExit("SetTapeParameters(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetTapePosition(HANDLE a0,
                                     DWORD a1,
                                     DWORD a2,
                                     DWORD a3,
                                     DWORD a4,
                                     BOOL a5)
{
    _PrintEnter("SetTapePosition(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SetTapePosition(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SetTapePosition(,,,,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetTextAlign(HDC a0,
                                 UINT a1)
{
    _PrintEnter("SetTextAlign(%p,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_SetTextAlign(a0, a1);
    } __finally {
        _PrintExit("SetTextAlign(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetTextCharacterExtra(HDC a0,
                                         int a1)
{
    _PrintEnter("SetTextCharacterExtra(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetTextCharacterExtra(a0, a1);
    } __finally {
        _PrintExit("SetTextCharacterExtra(,) -> %p\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetTextColor(HDC a0,
                                     COLORREF a1)
{
    _PrintEnter("SetTextColor(%p,%p)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_SetTextColor(a0, a1);
    } __finally {
        _PrintExit("SetTextColor(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetTextJustification(HDC a0,
                                         int a1,
                                         int a2)
{
    _PrintEnter("SetTextJustification(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetTextJustification(a0, a1, a2);
    } __finally {
        _PrintExit("SetTextJustification(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD_PTR __stdcall Mine_SetThreadAffinityMask(HANDLE a0,
                                           DWORD_PTR a1)
{
    _PrintEnter("SetThreadAffinityMask(%p,%p)\n", a0, a1);

    DWORD_PTR rv = 0;
    __try {
        rv = Real_SetThreadAffinityMask(a0, a1);
    } __finally {
        _PrintExit("SetThreadAffinityMask(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadContext(HANDLE a0,
                                     CONTEXT* a1)
{
    _PrintEnter("SetThreadContext(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadContext(a0, a1);
    } __finally {
        _PrintExit("SetThreadContext(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadDesktop(HDESK a0)
{
    _PrintEnter("SetThreadDesktop(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadDesktop(a0);
    } __finally {
        _PrintExit("SetThreadDesktop() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetThreadIdealProcessor(HANDLE a0,
                                             DWORD a1)
{
    _PrintEnter("SetThreadIdealProcessor(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SetThreadIdealProcessor(a0, a1);
    } __finally {
        _PrintExit("SetThreadIdealProcessor(,) -> %p\n", rv);
    };
    return rv;
}

#if(WINVER >= 0x0500)
BOOL __stdcall Mine_SetThreadLocale(LCID a0)
{
    _PrintEnter("SetThreadLocale(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadLocale(a0);
    } __finally {
        _PrintExit("SetThreadLocale() -> %p\n", rv);
    };
    return rv;
}
#endif // (WINVER >= 0x0500)

BOOL __stdcall Mine_SetThreadPriority(HANDLE a0,
                                      int a1)
{
    _PrintEnter("SetThreadPriority(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadPriority(a0, a1);
    } __finally {
        _PrintExit("SetThreadPriority(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadPriorityBoost(HANDLE a0,
                                           BOOL a1)
{
    _PrintEnter("SetThreadPriorityBoost(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("SetThreadPriorityBoost(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetTimeZoneInformation(TIME_ZONE_INFORMATION* a0)
{
    _PrintEnter("SetTimeZoneInformation(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetTimeZoneInformation(a0);
    } __finally {
        _PrintExit("SetTimeZoneInformation() -> %p\n", rv);
    };
    return rv;
}

UINT_PTR __stdcall Mine_SetTimer(HWND a0,
                                 UINT_PTR a1,
                                 UINT a2,
                                 TIMERPROC a3)
{
    _PrintEnter("SetTimer(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    UINT_PTR rv = 0;
    __try {
        rv = Real_SetTimer(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetTimer(,,,) -> %p\n", rv);
    };
    return rv;
}

LPTOP_LEVEL_EXCEPTION_FILTER __stdcall Mine_SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER a0)
{
    _PrintEnter("SetUnhandledExceptionFilter(%p)\n", a0);

    LPTOP_LEVEL_EXCEPTION_FILTER rv = 0;
    __try {
        rv = Real_SetUnhandledExceptionFilter(a0);
    } __finally {
        _PrintExit("SetUnhandledExceptionFilter() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectInformationA(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3)
{
    _PrintEnter("SetUserObjectInformationA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectInformationA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetUserObjectInformationA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectInformationW(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3)
{
    _PrintEnter("SetUserObjectInformationW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectInformationW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetUserObjectInformationW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectSecurity(HANDLE a0,
                                          PSECURITY_INFORMATION a1,
                                          PSECURITY_DESCRIPTOR a2)
{
    _PrintEnter("SetUserObjectSecurity(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectSecurity(a0, a1, a2);
    } __finally {
        _PrintExit("SetUserObjectSecurity(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetViewportExtEx(HDC a0,
                                     int a1,
                                     int a2,
                                     SIZE* a3)
{
    _PrintEnter("SetViewportExtEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetViewportExtEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetViewportExtEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetViewportOrgEx(HDC a0,
                                     int a1,
                                     int a2,
                                     POINT* a3)
{
    _PrintEnter("SetViewportOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetViewportOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetViewportOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetVolumeLabelA(LPCSTR a0,
                                    LPCSTR a1)
{
    _PrintEnter("SetVolumeLabelA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetVolumeLabelA(a0, a1);
    } __finally {
        _PrintExit("SetVolumeLabelA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetVolumeLabelW(LPCWSTR a0,
                                    LPCWSTR a1)
{
    _PrintEnter("SetVolumeLabelW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetVolumeLabelW(a0, a1);
    } __finally {
        _PrintExit("SetVolumeLabelW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWaitableTimer(HANDLE a0,
                                     LARGE_INTEGER* a1,
                                     LONG a2,
                                     PTIMERAPCROUTINE a3,
                                     LPVOID a4,
                                     BOOL a5)
{
    _PrintEnter("SetWaitableTimer(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SetWaitableTimer(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SetWaitableTimer(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_SetWinMetaFileBits(UINT a0,
                                               BYTE* a1,
                                               HDC a2,
                                               METAFILEPICT* a3)
{
    _PrintEnter("SetWinMetaFileBits(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_SetWinMetaFileBits(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWinMetaFileBits(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowContextHelpId(HWND a0,
                                           DWORD a1)
{
    _PrintEnter("SetWindowContextHelpId(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowContextHelpId(a0, a1);
    } __finally {
        _PrintExit("SetWindowContextHelpId(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowExtEx(HDC a0,
                                   int a1,
                                   int a2,
                                   SIZE* a3)
{
    _PrintEnter("SetWindowExtEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowExtEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowExtEx(,,,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetWindowLongA(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetWindowLongA(%p,%p,%p)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetWindowLongA(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowLongA(,,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetWindowLongW(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetWindowLongW(%p,%p,%p)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetWindowLongW(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowLongW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowOrgEx(HDC a0,
                                   int a1,
                                   int a2,
                                   POINT* a3)
{
    _PrintEnter("SetWindowOrgEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowOrgEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowPlacement(HWND a0,
                                       WINDOWPLACEMENT* a1)
{
    _PrintEnter("SetWindowPlacement(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowPlacement(a0, a1);
    } __finally {
        _PrintExit("SetWindowPlacement(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowPos(HWND a0,
                                 HWND a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 int a5,
                                 UINT a6)
{
    _PrintEnter("SetWindowPos(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowPos(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SetWindowPos(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetWindowRgn(HWND a0,
                                HRGN a1,
                                BOOL a2)
{
    _PrintEnter("SetWindowRgn(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_SetWindowRgn(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowRgn(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowTextA(HWND a0,
                                   LPCSTR a1)
{
    _PrintEnter("SetWindowTextA(%p,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowTextA(a0, a1);
    } __finally {
        _PrintExit("SetWindowTextA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowTextW(HWND a0,
                                   LPCWSTR a1)
{
    _PrintEnter("SetWindowTextW(%p,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowTextW(a0, a1);
    } __finally {
        _PrintExit("SetWindowTextW(,) -> %p\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_SetWindowWord(HWND a0,
                                  int a1,
                                  WORD a2)
{
    _PrintEnter("SetWindowWord(%p,%p,%p)\n", a0, a1, a2);

    WORD rv = 0;
    __try {
        rv = Real_SetWindowWord(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowWord(,,) -> %p\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookA(int a0,
                                     HOOKPROC a1)
{
    _PrintEnter("SetWindowsHookA(%p,%p)\n", a0, a1);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookA(a0, a1);
    } __finally {
        _PrintExit("SetWindowsHookA(,) -> %p\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookExA(int a0,
                                       HOOKPROC a1,
                                       HINSTANCE a2,
                                       DWORD a3)
{
    _PrintEnter("SetWindowsHookExA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowsHookExA(,,,) -> %p\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookExW(int a0,
                                       HOOKPROC a1,
                                       HINSTANCE a2,
                                       DWORD a3)
{
    _PrintEnter("SetWindowsHookExW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowsHookExW(,,,) -> %p\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookW(int a0,
                                     HOOKPROC a1)
{
    _PrintEnter("SetWindowsHookW(%p,%p)\n", a0, a1);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookW(a0, a1);
    } __finally {
        _PrintExit("SetWindowsHookW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWorldTransform(HDC a0,
                                      XFORM* a1)
{
    _PrintEnter("SetWorldTransform(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWorldTransform(a0, a1);
    } __finally {
        _PrintExit("SetWorldTransform(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetupComm(HANDLE a0,
                              DWORD a1,
                              DWORD a2)
{
    _PrintEnter("SetupComm(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetupComm(a0, a1, a2);
    } __finally {
        _PrintExit("SetupComm(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowCaret(HWND a0)
{
    _PrintEnter("ShowCaret(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ShowCaret(a0);
    } __finally {
        _PrintExit("ShowCaret() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ShowCursor(BOOL a0)
{
    _PrintEnter("ShowCursor(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_ShowCursor(a0);
    } __finally {
        _PrintExit("ShowCursor() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowOwnedPopups(HWND a0,
                                    BOOL a1)
{
    _PrintEnter("ShowOwnedPopups(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowOwnedPopups(a0, a1);
    } __finally {
        _PrintExit("ShowOwnedPopups(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowScrollBar(HWND a0,
                                  int a1,
                                  BOOL a2)
{
    _PrintEnter("ShowScrollBar(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ShowScrollBar(a0, a1, a2);
    } __finally {
        _PrintExit("ShowScrollBar(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowWindow(HWND a0,
                               int a1)
{
    _PrintEnter("ShowWindow(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowWindow(a0, a1);
    } __finally {
        _PrintExit("ShowWindow(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowWindowAsync(HWND a0,
                                    int a1)
{
    _PrintEnter("ShowWindowAsync(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowWindowAsync(a0, a1);
    } __finally {
        _PrintExit("ShowWindowAsync(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SignalObjectAndWait(HANDLE a0,
                                         HANDLE a1,
                                         DWORD a2,
                                         BOOL a3)
{
    _PrintEnter("SignalObjectAndWait(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_SignalObjectAndWait(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SignalObjectAndWait(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SizeofResource(HMODULE a0,
                                    HRSRC a1)
{
    _PrintEnter("SizeofResource(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SizeofResource(a0, a1);
    } __finally {
        _PrintExit("SizeofResource(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SleepEx(DWORD a0,
                             BOOL a1)
{
    _PrintEnter("SleepEx(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SleepEx(a0, a1);
    } __finally {
        _PrintExit("SleepEx(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartDocA(HDC a0,
                             DOCINFOA* a1)
{
    _PrintEnter("StartDocA(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_StartDocA(a0, a1);
    } __finally {
        _PrintExit("StartDocA(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartDocW(HDC a0,
                             DOCINFOW* a1)
{
    _PrintEnter("StartDocW(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_StartDocW(a0, a1);
    } __finally {
        _PrintExit("StartDocW(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartPage(HDC a0)
{
    _PrintEnter("StartPage(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_StartPage(a0);
    } __finally {
        _PrintExit("StartPage() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreateDocfile(OLECHAR* a0,
                                        DWORD a1,
                                        DWORD a2,
                                        IStorage** a3)
{
    _PrintEnter("StgCreateDocfile(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateDocfile(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgCreateDocfile(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreateDocfileOnILockBytes(ILockBytes* a0,
                                                    DWORD a1,
                                                    DWORD a2,
                                                    IStorage** a3)
{
    _PrintEnter("StgCreateDocfileOnILockBytes(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateDocfileOnILockBytes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgCreateDocfileOnILockBytes(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreatePropSetStg(IStorage* a0,
                                           DWORD a1,
                                           IPropertySetStorage** a2)
{
    _PrintEnter("StgCreatePropSetStg(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreatePropSetStg(a0, a1, a2);
    } __finally {
        _PrintExit("StgCreatePropSetStg(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreatePropStg(IUnknown* a0,
                                        CONST IID& a1,
                                        CLSID* a2,
                                        DWORD a3,
                                        DWORD a4,
                                        IPropertyStorage** a5)
{
    _PrintEnter("StgCreatePropStg(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreatePropStg(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgCreatePropStg(,,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HRESULT __stdcall Mine_StgCreateStorageEx(WCHAR* a0,
                                          DWORD a1,
                                          DWORD a2,
                                          DWORD a3,
                                          void* a4,
                                          void* a5,
                                          CONST IID& a6,
                                          void** a7)
#else
HRESULT __stdcall Mine_StgCreateStorageEx(WCHAR* a0,
                                          DWORD a1,
                                          DWORD a2,
                                          DWORD a3,
                                          STGOPTIONS* a4,
                                          void* a5,
                                          CONST IID& a6,
                                          void** a7)
#endif
{
    _PrintEnter("StgCreateStorageEx(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateStorageEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("StgCreateStorageEx(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgGetIFillLockBytesOnFile(OLECHAR* a0,
                                                  IFillLockBytes** a1)
{
    _PrintEnter("StgGetIFillLockBytesOnFile(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StgGetIFillLockBytesOnFile(a0, a1);
    } __finally {
        _PrintExit("StgGetIFillLockBytesOnFile(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgGetIFillLockBytesOnILockBytes(ILockBytes* a0,
                                                        IFillLockBytes** a1)
{
    _PrintEnter("StgGetIFillLockBytesOnILockBytes(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StgGetIFillLockBytesOnILockBytes(a0, a1);
    } __finally {
        _PrintExit("StgGetIFillLockBytesOnILockBytes(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgIsStorageFile(OLECHAR* a0)
{
    _PrintEnter("StgIsStorageFile(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_StgIsStorageFile(a0);
    } __finally {
        _PrintExit("StgIsStorageFile() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgIsStorageILockBytes(ILockBytes* a0)
{
    _PrintEnter("StgIsStorageILockBytes(%p)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_StgIsStorageILockBytes(a0);
    } __finally {
        _PrintExit("StgIsStorageILockBytes() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenAsyncDocfileOnIFillLockBytes(IFillLockBytes* a0,
                                                           DWORD a1,
                                                           DWORD a2,
                                                           IStorage** a3)
{
    _PrintEnter("StgOpenAsyncDocfileOnIFillLockBytes(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenAsyncDocfileOnIFillLockBytes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgOpenAsyncDocfileOnIFillLockBytes(,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenPropStg(IUnknown* a0,
                                      CONST IID& a1,
                                      DWORD a2,
                                      DWORD a3,
                                      IPropertyStorage** a4)
{
    _PrintEnter("StgOpenPropStg(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenPropStg(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("StgOpenPropStg(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenStorage(OLECHAR* a0,
                                      IStorage* a1,
                                      DWORD a2,
                                      SNB a3,
                                      DWORD a4,
                                      IStorage** a5)
{
    _PrintEnter("StgOpenStorage(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorage(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgOpenStorage(,,,,,) -> %p\n", rv);
    };
    return rv;
}

#if _MSC_VER < 1300
HRESULT __stdcall Mine_StgOpenStorageEx(WCHAR* a0,
                                        DWORD a1,
                                        DWORD a2,
                                        DWORD a3,
                                        void* a4,
                                        void* a5,
                                        CONST IID& a6,
                                        void** a7)
#else
HRESULT __stdcall Mine_StgOpenStorageEx(WCHAR* a0,
                                        DWORD a1,
                                        DWORD a2,
                                        DWORD a3,
                                        STGOPTIONS* a4,
                                        void* a5,
                                        CONST IID& a6,
                                        void** a7)
#endif
{
    _PrintEnter("StgOpenStorageEx(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorageEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("StgOpenStorageEx(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenStorageOnILockBytes(ILockBytes* a0,
                                                  IStorage* a1,
                                                  DWORD a2,
                                                  SNB a3,
                                                  DWORD a4,
                                                  IStorage** a5)
{
    _PrintEnter("StgOpenStorageOnILockBytes(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorageOnILockBytes(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgOpenStorageOnILockBytes(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgSetTimes(OLECHAR* a0,
                                   FILETIME* a1,
                                   FILETIME* a2,
                                   FILETIME* a3)
{
    _PrintEnter("StgSetTimes(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgSetTimes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgSetTimes(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StretchBlt(HDC a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               HDC a5,
                               int a6,
                               int a7,
                               int a8,
                               int a9,
                               DWORD a10)
{
    _PrintEnter("StretchBlt(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);

    BOOL rv = 0;
    __try {
        rv = Real_StretchBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
    } __finally {
        _PrintExit("StretchBlt(,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_StretchDIBits(HDC a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 int a5,
                                 int a6,
                                 int a7,
                                 int a8,
                                 void* a9,
                                 BITMAPINFO* a10,
                                 UINT a11,
                                 DWORD a12)
{
    _PrintEnter("StretchDIBits(%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

    int rv = 0;
    __try {
        rv = Real_StretchDIBits(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    } __finally {
        _PrintExit("StretchDIBits(,,,,,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StringFromCLSID(CONST IID& a0,
                                       LPOLESTR* a1)
{
    _PrintEnter("StringFromCLSID(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StringFromCLSID(a0, a1);
    } __finally {
        _PrintExit("StringFromCLSID(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_StringFromGUID2(CONST GUID& a0,
                                   LPOLESTR a1,
                                   int a2)
{
    _PrintEnter("StringFromGUID2(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_StringFromGUID2(a0, a1, a2);
    } __finally {
        _PrintExit("StringFromGUID2(,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StringFromIID(CONST IID& a0,
                                     LPOLESTR* a1)
{
    _PrintEnter("StringFromIID(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StringFromIID(a0, a1);
    } __finally {
        _PrintExit("StringFromIID(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StrokeAndFillPath(HDC a0)
{
    _PrintEnter("StrokeAndFillPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_StrokeAndFillPath(a0);
    } __finally {
        _PrintExit("StrokeAndFillPath() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StrokePath(HDC a0)
{
    _PrintEnter("StrokePath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_StrokePath(a0);
    } __finally {
        _PrintExit("StrokePath() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SubtractRect(LPRECT a0,
                                 RECT* a1,
                                 RECT* a2)
{
    _PrintEnter("SubtractRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SubtractRect(a0, a1, a2);
    } __finally {
        _PrintExit("SubtractRect(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SuspendThread(HANDLE a0)
{
    _PrintEnter("SuspendThread(%p)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_SuspendThread(a0);
    } __finally {
        _PrintExit("SuspendThread() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwapBuffers(HDC a0)
{
    _PrintEnter("SwapBuffers(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwapBuffers(a0);
    } __finally {
        _PrintExit("SwapBuffers() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwapMouseButton(BOOL a0)
{
    _PrintEnter("SwapMouseButton(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwapMouseButton(a0);
    } __finally {
        _PrintExit("SwapMouseButton() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwitchDesktop(HDESK a0)
{
    _PrintEnter("SwitchDesktop(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwitchDesktop(a0);
    } __finally {
        _PrintExit("SwitchDesktop() -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_SwitchToFiber(LPVOID a0)
{
    _PrintEnter("SwitchToFiber(%p)\n", a0);

    __try {
        Real_SwitchToFiber(a0);
    } __finally {
        _PrintExit("SwitchToFiber() ->\n");
    };
}

BOOL __stdcall Mine_SwitchToThread(void)
{
    _PrintEnter("SwitchToThread()\n");

    BOOL rv = 0;
    __try {
        rv = Real_SwitchToThread();
    } __finally {
        _PrintExit("SwitchToThread() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemParametersInfoA(UINT a0,
                                          UINT a1,
                                          PVOID a2,
                                          UINT a3)
{
    _PrintEnter("SystemParametersInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SystemParametersInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SystemParametersInfoA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemParametersInfoW(UINT a0,
                                          UINT a1,
                                          PVOID a2,
                                          UINT a3)
{
    _PrintEnter("SystemParametersInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SystemParametersInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SystemParametersInfoW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemTimeToFileTime(SYSTEMTIME* a0,
                                         LPFILETIME a1)
{
    _PrintEnter("SystemTimeToFileTime(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SystemTimeToFileTime(a0, a1);
    } __finally {
        _PrintExit("SystemTimeToFileTime(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemTimeToTzSpecificLocalTime(
#ifdef PIPE_ACCEPT_REMOTE_CLIENTS
                                                    const TIME_ZONE_INFORMATION *a0,
                                                    const SYSTEMTIME *a1,
#else
                                                    LPTIME_ZONE_INFORMATION a0,
                                                    LPSYSTEMTIME a1,
#endif
                                                    LPSYSTEMTIME a2
                                                   )
{
    _PrintEnter("SystemTimeToTzSpecificLocalTime(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SystemTimeToTzSpecificLocalTime(a0, a1, a2);
    } __finally {
        _PrintExit("SystemTimeToTzSpecificLocalTime(,,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_TabbedTextOutA(HDC a0,
                                   int a1,
                                   int a2,
                                   LPCSTR a3,
                                   int a4,
                                   int a5,
                                   INT* a6,
                                   int a7)
{
    _PrintEnter("TabbedTextOutA(%p,%p,%p,%hs,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    LONG rv = 0;
    __try {
        rv = Real_TabbedTextOutA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("TabbedTextOutA(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_TabbedTextOutW(HDC a0,
                                   int a1,
                                   int a2,
                                   LPCWSTR a3,
                                   int a4,
                                   int a5,
                                   INT* a6,
                                   int a7)
{
    _PrintEnter("TabbedTextOutW(%p,%p,%p,%ls,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    LONG rv = 0;
    __try {
        rv = Real_TabbedTextOutW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("TabbedTextOutW(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TerminateProcess(HANDLE a0,
                                     UINT a1)
{
    _PrintEnter("TerminateProcess(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TerminateProcess(a0, a1);
    } __finally {
        _PrintExit("TerminateProcess(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TerminateThread(HANDLE a0,
                                    DWORD a1)
{
    _PrintEnter("TerminateThread(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TerminateThread(a0, a1);
    } __finally {
        _PrintExit("TerminateThread(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TextOutA(HDC a0,
                             int a1,
                             int a2,
                             LPCSTR a3,
                             int a4)
{
    _PrintEnter("TextOutA(%p,%p,%p,%hs,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_TextOutA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TextOutA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TextOutW(HDC a0,
                             int a1,
                             int a2,
                             LPCWSTR a3,
                             int a4)
{
    _PrintEnter("TextOutW(%p,%p,%p,%ls,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_TextOutW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TextOutW(,,,,) -> %p\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_TileWindows(HWND a0,
                                UINT a1,
                                RECT* a2,
                                UINT a3,
                                struct HWND__** a4)
{
    _PrintEnter("TileWindows(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    WORD rv = 0;
    __try {
        rv = Real_TileWindows(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TileWindows(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToAscii(UINT a0,
                           UINT a1,
                           BYTE* a2,
                           LPWORD a3,
                           UINT a4)
{
    _PrintEnter("ToAscii(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_ToAscii(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ToAscii(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToAsciiEx(UINT a0,
                             UINT a1,
                             BYTE* a2,
                             LPWORD a3,
                             UINT a4,
                             HKL a5)
{
    _PrintEnter("ToAsciiEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ToAsciiEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ToAsciiEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToUnicode(UINT a0,
                             UINT a1,
                             BYTE* a2,
                             LPWSTR a3,
                             int a4,
                             UINT a5)
{
    _PrintEnter("ToUnicode(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ToUnicode(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ToUnicode(,,,%ls,,) -> %p\n", a3, rv);
    };
    return rv;
}

int __stdcall Mine_ToUnicodeEx(UINT a0,
                               UINT a1,
                               BYTE* a2,
                               LPWSTR a3,
                               int a4,
                               UINT a5,
                               HKL a6)
{
    _PrintEnter("ToUnicodeEx(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_ToUnicodeEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("ToUnicodeEx(,,,%ls,,,) -> %p\n", a3, rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackMouseEvent(TRACKMOUSEEVENT* a0)
{
    _PrintEnter("TrackMouseEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TrackMouseEvent(a0);
    } __finally {
        _PrintExit("TrackMouseEvent() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackPopupMenu(HMENU a0,
                                   UINT a1,
                                   int a2,
                                   int a3,
                                   int a4,
                                   HWND a5,
                                   RECT* a6)
{
    _PrintEnter("TrackPopupMenu(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_TrackPopupMenu(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("TrackPopupMenu(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackPopupMenuEx(HMENU a0,
                                     UINT a1,
                                     int a2,
                                     int a3,
                                     HWND a4,
                                     LPTPMPARAMS a5)
{
    _PrintEnter("TrackPopupMenuEx(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_TrackPopupMenuEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("TrackPopupMenuEx(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TransactNamedPipe(HANDLE a0,
                                      LPVOID a1,
                                      DWORD a2,
                                      LPVOID a3,
                                      DWORD a4,
                                      LPDWORD a5,
                                      LPOVERLAPPED a6)
{
    _PrintEnter("TransactNamedPipe(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_TransactNamedPipe(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("TransactNamedPipe(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_TranslateAcceleratorA(HWND a0,
                                         HACCEL a1,
                                         LPMSG a2)
{
    _PrintEnter("TranslateAcceleratorA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_TranslateAcceleratorA(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateAcceleratorA(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_TranslateAcceleratorW(HWND a0,
                                         HACCEL a1,
                                         LPMSG a2)
{
    _PrintEnter("TranslateAcceleratorW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_TranslateAcceleratorW(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateAcceleratorW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateCharsetInfo(DWORD* a0,
                                         CHARSETINFO* a1,
                                         DWORD a2)
{
    _PrintEnter("TranslateCharsetInfo(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateCharsetInfo(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateCharsetInfo(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateMDISysAccel(HWND a0,
                                         LPMSG a1)
{
    _PrintEnter("TranslateMDISysAccel(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateMDISysAccel(a0, a1);
    } __finally {
        _PrintExit("TranslateMDISysAccel(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateMessage(MSG* a0)
{
    _PrintEnter("TranslateMessage(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateMessage(a0);
    } __finally {
        _PrintExit("TranslateMessage() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TransmitCommChar(HANDLE a0,
                                     char a1)
{
    _PrintEnter("TransmitCommChar(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TransmitCommChar(a0, a1);
    } __finally {
        _PrintExit("TransmitCommChar(,) -> %p\n", rv);
    };
    return rv;
}

#if DETOUR_TryEnterCriticalSection_EVEN_IF_IT_EXERCISES_A_BUG_IN_RtlLookupFunctionTable
BOOL __stdcall Mine_TryEnterCriticalSection(LPCRITICAL_SECTION a0)
{
    _PrintEnter("TryEnterCriticalSection(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TryEnterCriticalSection(a0);
    } __finally {
        _PrintExit("TryEnterCriticalSection() -> %p\n", rv);
    };
    return rv;
}
#endif

BOOL __stdcall Mine_UnhookWindowsHook(int a0,
                                      HOOKPROC a1)
{
    _PrintEnter("UnhookWindowsHook(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnhookWindowsHook(a0, a1);
    } __finally {
        _PrintExit("UnhookWindowsHook(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnhookWindowsHookEx(HHOOK a0)
{
    _PrintEnter("UnhookWindowsHookEx(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnhookWindowsHookEx(a0);
    } __finally {
        _PrintExit("UnhookWindowsHookEx() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnionRect(LPRECT a0,
                              RECT* a1,
                              RECT* a2)
{
    _PrintEnter("UnionRect(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_UnionRect(a0, a1, a2);
    } __finally {
        _PrintExit("UnionRect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnloadKeyboardLayout(HKL a0)
{
    _PrintEnter("UnloadKeyboardLayout(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnloadKeyboardLayout(a0);
    } __finally {
        _PrintExit("UnloadKeyboardLayout() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnlockFile(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               DWORD a3,
                               DWORD a4)
{
    _PrintEnter("UnlockFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_UnlockFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("UnlockFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnlockFileEx(HANDLE a0,
                                 DWORD a1,
                                 DWORD a2,
                                 DWORD a3,
                                 LPOVERLAPPED a4)
{
    _PrintEnter("UnlockFileEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_UnlockFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("UnlockFileEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnmapViewOfFile(LPCVOID a0)
{
    _PrintEnter("UnmapViewOfFile(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnmapViewOfFile(a0);
    } __finally {
        _PrintExit("UnmapViewOfFile() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnpackDDElParam(UINT a0,
                                    LPARAM a1,
                                    PUINT_PTR a2,
                                    PUINT_PTR a3)
{
    _PrintEnter("UnpackDDElParam(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_UnpackDDElParam(a0, a1, a2, a3);
    } __finally {
        _PrintExit("UnpackDDElParam(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnrealizeObject(HGDIOBJ a0)
{
    _PrintEnter("UnrealizeObject(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnrealizeObject(a0);
    } __finally {
        _PrintExit("UnrealizeObject() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterClassA(LPCSTR a0,
                                     HINSTANCE a1)
{
    _PrintEnter("UnregisterClassA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterClassA(a0, a1);
    } __finally {
        _PrintExit("UnregisterClassA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterClassW(LPCWSTR a0,
                                     HINSTANCE a1)
{
    _PrintEnter("UnregisterClassW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterClassW(a0, a1);
    } __finally {
        _PrintExit("UnregisterClassW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterHotKey(HWND a0,
                                     int a1)
{
    _PrintEnter("UnregisterHotKey(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterHotKey(a0, a1);
    } __finally {
        _PrintExit("UnregisterHotKey(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateColors(HDC a0)
{
    _PrintEnter("UpdateColors(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateColors(a0);
    } __finally {
        _PrintExit("UpdateColors() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateResourceA(HANDLE a0,
                                    LPCSTR a1,
                                    LPCSTR a2,
                                    WORD a3,
                                    LPVOID a4,
                                    DWORD a5)
{
    _PrintEnter("UpdateResourceA(%p,%hs,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateResourceA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("UpdateResourceA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateResourceW(HANDLE a0,
                                    LPCWSTR a1,
                                    LPCWSTR a2,
                                    WORD a3,
                                    LPVOID a4,
                                    DWORD a5)
{
    _PrintEnter("UpdateResourceW(%p,%ls,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateResourceW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("UpdateResourceW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateWindow(HWND a0)
{
    _PrintEnter("UpdateWindow(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateWindow(a0);
    } __finally {
        _PrintExit("UpdateWindow() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ValidateRect(HWND a0,
                                 RECT* a1)
{
    _PrintEnter("ValidateRect(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ValidateRect(a0, a1);
    } __finally {
        _PrintExit("ValidateRect(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ValidateRgn(HWND a0,
                                HRGN a1)
{
    _PrintEnter("ValidateRgn(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ValidateRgn(a0, a1);
    } __finally {
        _PrintExit("ValidateRgn(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_VerLanguageNameA(DWORD a0,
                                      LPSTR a1,
                                      DWORD a2)
{
    _PrintEnter("VerLanguageNameA(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_VerLanguageNameA(a0, a1, a2);
    } __finally {
        _PrintExit("VerLanguageNameA(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_VerLanguageNameW(DWORD a0,
                                      LPWSTR a1,
                                      DWORD a2)
{
    _PrintEnter("VerLanguageNameW(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_VerLanguageNameW(a0, a1, a2);
    } __finally {
        _PrintExit("VerLanguageNameW(,,) -> %p\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_VirtualAllocEx(HANDLE a0,
                                     LPVOID a1,
                                     SIZE_T a2,
                                     DWORD a3,
                                     DWORD a4)
{
    _PrintEnter("VirtualAllocEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    LPVOID rv = 0;
    __try {
        rv = Real_VirtualAllocEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("VirtualAllocEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_VirtualFreeEx(HANDLE a0,
                                  LPVOID a1,
                                  SIZE_T a2,
                                  DWORD a3)
{
    _PrintEnter("VirtualFreeEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_VirtualFreeEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("VirtualFreeEx(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_VirtualProtectEx(HANDLE a0,
                                     LPVOID a1,
                                     SIZE_T a2,
                                     DWORD a3,
                                     PDWORD a4)
{
    _PrintEnter("VirtualProtectEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_VirtualProtectEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("VirtualProtectEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD_PTR __stdcall Mine_VirtualQueryEx(HANDLE a0,
                                        LPCVOID a1,
                                        PMEMORY_BASIC_INFORMATION a2,
                                        DWORD_PTR a3)
{
    _PrintEnter("VirtualQueryEx(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD_PTR rv = 0;
    __try {
        rv = Real_VirtualQueryEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("VirtualQueryEx(,,,) -> %p\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanA(CHAR a0)
{
    _PrintEnter("VkKeyScanA(%p)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanA(a0);
    } __finally {
        _PrintExit("VkKeyScanA() -> %p\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanExA(CHAR a0,
                                  HKL a1)
{
    _PrintEnter("VkKeyScanExA(%p,%p)\n", a0, a1);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanExA(a0, a1);
    } __finally {
        _PrintExit("VkKeyScanExA(,) -> %p\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanExW(WCHAR a0,
                                  HKL a1)
{
    _PrintEnter("VkKeyScanExW(%p,%p)\n", a0, a1);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanExW(a0, a1);
    } __finally {
        _PrintExit("VkKeyScanExW(,) -> %p\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanW(WCHAR a0)
{
    _PrintEnter("VkKeyScanW(%p)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanW(a0);
    } __finally {
        _PrintExit("VkKeyScanW() -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSAAccept(SOCKET a0,
                                sockaddr* a1,
                                LPINT a2,
                                LPCONDITIONPROC a3,
                                DWORD_PTR a4)
{
    _PrintEnter("WSAAccept(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    SOCKET rv = 0;
    __try {
        rv = Real_WSAAccept(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAccept(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAAddressToStringA(LPSOCKADDR a0,
                                       DWORD a1,
                                       LPWSAPROTOCOL_INFOA a2,
                                       LPSTR a3,
                                       LPDWORD a4)
{
    _PrintEnter("WSAAddressToStringA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAAddressToStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAddressToStringA(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAAddressToStringW(LPSOCKADDR a0,
                                       DWORD a1,
                                       LPWSAPROTOCOL_INFOW a2,
                                       LPWSTR a3,
                                       LPDWORD a4)
{
    _PrintEnter("WSAAddressToStringW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAAddressToStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAddressToStringW(,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetHostByAddr(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            int a3,
                                            int a4,
                                            char* a5,
                                            int a6)
{
    _PrintEnter("WSAAsyncGetHostByAddr(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetHostByAddr(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSAAsyncGetHostByAddr(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetHostByName(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            char* a3,
                                            int a4)
{
    _PrintEnter("WSAAsyncGetHostByName(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetHostByName(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetHostByName(,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetProtoByName(HWND a0,
                                             u_int a1,
                                             char* a2,
                                             char* a3,
                                             int a4)
{
    _PrintEnter("WSAAsyncGetProtoByName(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetProtoByName(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetProtoByName(,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetProtoByNumber(HWND a0,
                                               u_int a1,
                                               int a2,
                                               char* a3,
                                               int a4)
{
    _PrintEnter("WSAAsyncGetProtoByNumber(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetProtoByNumber(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetProtoByNumber(,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetServByName(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            char* a3,
                                            char* a4,
                                            int a5)
{
    _PrintEnter("WSAAsyncGetServByName(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetServByName(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSAAsyncGetServByName(,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetServByPort(HWND a0,
                                            u_int a1,
                                            int a2,
                                            char* a3,
                                            char* a4,
                                            int a5)
{
    _PrintEnter("WSAAsyncGetServByPort(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetServByPort(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSAAsyncGetServByPort(,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAAsyncSelect(SOCKET a0,
                                  HWND a1,
                                  u_int a2,
                                  long a3)
{
    _PrintEnter("WSAAsyncSelect(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_WSAAsyncSelect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAAsyncSelect(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACancelAsyncRequest(HANDLE a0)
{
    _PrintEnter("WSACancelAsyncRequest(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_WSACancelAsyncRequest(a0);
    } __finally {
        _PrintExit("WSACancelAsyncRequest() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACancelBlockingCall(void)
{
    _PrintEnter("WSACancelBlockingCall()\n");

    int rv = 0;
    __try {
        rv = Real_WSACancelBlockingCall();
    } __finally {
        _PrintExit("WSACancelBlockingCall() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACleanup(void)
{
    _PrintEnter("WSACleanup()\n");

    int rv = 0;
    __try {
        rv = Real_WSACleanup();
    } __finally {
        _PrintExit("WSACleanup() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSACloseEvent(HANDLE a0)
{
    _PrintEnter("WSACloseEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSACloseEvent(a0);
    } __finally {
        _PrintExit("WSACloseEvent() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAConnect(SOCKET a0,
                              sockaddr* a1,
                              int a2,
                              LPWSABUF a3,
                              LPWSABUF a4,
                              LPQOS a5,
                              LPQOS a6)
{
    _PrintEnter("WSAConnect(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSAConnect(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSAConnect(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSACreateEvent(void)
{
    _PrintEnter("WSACreateEvent()\n");

    HANDLE rv = 0;
    __try {
        rv = Real_WSACreateEvent();
    } __finally {
        _PrintExit("WSACreateEvent() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSADuplicateSocketA(SOCKET a0,
                                       DWORD a1,
                                       LPWSAPROTOCOL_INFOA a2)
{
    _PrintEnter("WSADuplicateSocketA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSADuplicateSocketA(a0, a1, a2);
    } __finally {
        _PrintExit("WSADuplicateSocketA(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSADuplicateSocketW(SOCKET a0,
                                       DWORD a1,
                                       LPWSAPROTOCOL_INFOW a2)
{
    _PrintEnter("WSADuplicateSocketW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSADuplicateSocketW(a0, a1, a2);
    } __finally {
        _PrintExit("WSADuplicateSocketW(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAEnumNameSpaceProvidersA(LPDWORD a0,
                                              LPWSANAMESPACE_INFOA a1)
{
    _PrintEnter("WSAEnumNameSpaceProvidersA(%p,%p)\n", a0, a1);

    INT rv = 0;
    __try {
        rv = Real_WSAEnumNameSpaceProvidersA(a0, a1);
    } __finally {
        _PrintExit("WSAEnumNameSpaceProvidersA(,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAEnumNameSpaceProvidersW(LPDWORD a0,
                                              LPWSANAMESPACE_INFOW a1)
{
    _PrintEnter("WSAEnumNameSpaceProvidersW(%p,%p)\n", a0, a1);

    INT rv = 0;
    __try {
        rv = Real_WSAEnumNameSpaceProvidersW(a0, a1);
    } __finally {
        _PrintExit("WSAEnumNameSpaceProvidersW(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumNetworkEvents(SOCKET a0,
                                        HANDLE a1,
                                        LPWSANETWORKEVENTS a2)
{
    _PrintEnter("WSAEnumNetworkEvents(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumNetworkEvents(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumNetworkEvents(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumProtocolsA(LPINT a0,
                                     LPWSAPROTOCOL_INFOA a1,
                                     LPDWORD a2)
{
    _PrintEnter("WSAEnumProtocolsA(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumProtocolsA(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumProtocolsA(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumProtocolsW(LPINT a0,
                                     LPWSAPROTOCOL_INFOW a1,
                                     LPDWORD a2)
{
    _PrintEnter("WSAEnumProtocolsW(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumProtocolsW(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumProtocolsW(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEventSelect(SOCKET a0,
                                  HANDLE a1,
                                  long a2)
{
    _PrintEnter("WSAEventSelect(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEventSelect(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEventSelect(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAGetOverlappedResult(SOCKET a0,
                                           LPWSAOVERLAPPED a1,
                                           LPDWORD a2,
                                           BOOL a3,
                                           LPDWORD a4)
{
    _PrintEnter("WSAGetOverlappedResult(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WSAGetOverlappedResult(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAGetOverlappedResult(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAGetQOSByName(SOCKET a0,
                                    LPWSABUF a1,
                                    LPQOS a2)
{
    _PrintEnter("WSAGetQOSByName(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WSAGetQOSByName(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetQOSByName(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassInfoA(LPGUID a0,
                                           LPGUID a1,
                                           LPDWORD a2,
                                           LPWSASERVICECLASSINFOA a3)
{
    _PrintEnter("WSAGetServiceClassInfoA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAGetServiceClassInfoA(,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassInfoW(LPGUID a0,
                                           LPGUID a1,
                                           LPDWORD a2,
                                           LPWSASERVICECLASSINFOW a3)
{
    _PrintEnter("WSAGetServiceClassInfoW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAGetServiceClassInfoW(,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassNameByClassIdA(LPGUID a0,
                                                    LPSTR a1,
                                                    LPDWORD a2)
{
    _PrintEnter("WSAGetServiceClassNameByClassIdA(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassNameByClassIdA(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetServiceClassNameByClassIdA(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassNameByClassIdW(LPGUID a0,
                                                    LPWSTR a1,
                                                    LPDWORD a2)
{
    _PrintEnter("WSAGetServiceClassNameByClassIdW(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassNameByClassIdW(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetServiceClassNameByClassIdW(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAHtonl(SOCKET a0,
                            u_long a1,
                            u_long* a2)
{
    _PrintEnter("WSAHtonl(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAHtonl(a0, a1, a2);
    } __finally {
        _PrintExit("WSAHtonl(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAHtons(SOCKET a0,
                            u_short a1,
                            u_short* a2)
{
    _PrintEnter("WSAHtons(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAHtons(a0, a1, a2);
    } __finally {
        _PrintExit("WSAHtons(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAInstallServiceClassA(LPWSASERVICECLASSINFOA a0)
{
    _PrintEnter("WSAInstallServiceClassA(%p)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSAInstallServiceClassA(a0);
    } __finally {
        _PrintExit("WSAInstallServiceClassA() -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAInstallServiceClassW(LPWSASERVICECLASSINFOW a0)
{
    _PrintEnter("WSAInstallServiceClassW(%p)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSAInstallServiceClassW(a0);
    } __finally {
        _PrintExit("WSAInstallServiceClassW() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAIoctl(SOCKET a0,
                            DWORD a1,
                            LPVOID a2,
                            DWORD a3,
                            LPVOID a4,
                            DWORD a5,
                            LPDWORD a6,
                            LPWSAOVERLAPPED a7,
                            LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSAIoctl(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSAIoctl(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSAIoctl(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAIsBlocking(void)
{
    _PrintEnter("WSAIsBlocking()\n");

    BOOL rv = 0;
    __try {
        rv = Real_WSAIsBlocking();
    } __finally {
        _PrintExit("WSAIsBlocking() -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSAJoinLeaf(SOCKET a0,
                                  sockaddr* a1,
                                  int a2,
                                  LPWSABUF a3,
                                  LPWSABUF a4,
                                  LPQOS a5,
                                  LPQOS a6,
                                  DWORD a7)
{
    _PrintEnter("WSAJoinLeaf(%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    SOCKET rv = 0;
    __try {
        rv = Real_WSAJoinLeaf(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("WSAJoinLeaf(,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceBeginA(LPWSAQUERYSETA a0,
                                          DWORD a1,
                                          LPHANDLE a2)
{
    _PrintEnter("WSALookupServiceBeginA(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceBeginA(a0, a1, a2);
    } __finally {
        _PrintExit("WSALookupServiceBeginA(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceBeginW(LPWSAQUERYSETW a0,
                                          DWORD a1,
                                          LPHANDLE a2)
{
    _PrintEnter("WSALookupServiceBeginW(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceBeginW(a0, a1, a2);
    } __finally {
        _PrintExit("WSALookupServiceBeginW(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceEnd(HANDLE a0)
{
    _PrintEnter("WSALookupServiceEnd(%p)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceEnd(a0);
    } __finally {
        _PrintExit("WSALookupServiceEnd() -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceNextA(HANDLE a0,
                                         DWORD a1,
                                         LPDWORD a2,
                                         LPWSAQUERYSETA a3)
{
    _PrintEnter("WSALookupServiceNextA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceNextA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSALookupServiceNextA(,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceNextW(HANDLE a0,
                                         DWORD a1,
                                         LPDWORD a2,
                                         LPWSAQUERYSETW a3)
{
    _PrintEnter("WSALookupServiceNextW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceNextW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSALookupServiceNextW(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSANtohl(SOCKET a0,
                            u_long a1,
                            u_long* a2)
{
    _PrintEnter("WSANtohl(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSANtohl(a0, a1, a2);
    } __finally {
        _PrintExit("WSANtohl(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSANtohs(SOCKET a0,
                            u_short a1,
                            u_short* a2)
{
    _PrintEnter("WSANtohs(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSANtohs(a0, a1, a2);
    } __finally {
        _PrintExit("WSANtohs(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAProviderConfigChange(LPHANDLE a0,
                                           LPWSAOVERLAPPED a1,
                                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a2)
{
    _PrintEnter("WSAProviderConfigChange(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAProviderConfigChange(a0, a1, a2);
    } __finally {
        _PrintExit("WSAProviderConfigChange(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecv(SOCKET a0,
                           LPWSABUF a1,
                           DWORD a2,
                           LPDWORD a3,
                           LPDWORD a4,
                           LPWSAOVERLAPPED a5,
                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
{
    _PrintEnter("WSARecv(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSARecv(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSARecv(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecvDisconnect(SOCKET a0,
                                     LPWSABUF a1)
{
    _PrintEnter("WSARecvDisconnect(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSARecvDisconnect(a0, a1);
    } __finally {
        _PrintExit("WSARecvDisconnect(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecvFrom(SOCKET a0,
                               LPWSABUF a1,
                               DWORD a2,
                               LPDWORD a3,
                               LPDWORD a4,
                               sockaddr* a5,
                               LPINT a6,
                               LPWSAOVERLAPPED a7,
                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSARecvFrom(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSARecvFrom(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSARecvFrom(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSARemoveServiceClass(LPGUID a0)
{
    _PrintEnter("WSARemoveServiceClass(%p)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSARemoveServiceClass(a0);
    } __finally {
        _PrintExit("WSARemoveServiceClass() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAResetEvent(HANDLE a0)
{
    _PrintEnter("WSAResetEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSAResetEvent(a0);
    } __finally {
        _PrintExit("WSAResetEvent() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASend(SOCKET a0,
                           LPWSABUF a1,
                           DWORD a2,
                           LPDWORD a3,
                           DWORD a4,
                           LPWSAOVERLAPPED a5,
                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
{
    _PrintEnter("WSASend(%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSASend(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSASend(,,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASendDisconnect(SOCKET a0,
                                     LPWSABUF a1)
{
    _PrintEnter("WSASendDisconnect(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSASendDisconnect(a0, a1);
    } __finally {
        _PrintExit("WSASendDisconnect(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASendTo(SOCKET a0,
                             LPWSABUF a1,
                             DWORD a2,
                             LPDWORD a3,
                             DWORD a4,
                             sockaddr* a5,
                             int a6,
                             LPWSAOVERLAPPED a7,
                             LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSASendTo(%p,%p,%p,%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSASendTo(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSASendTo(,,,,,,,,) -> %p\n", rv);
    };
    return rv;
}

FARPROC __stdcall Mine_WSASetBlockingHook(FARPROC a0)
{
    _PrintEnter("WSASetBlockingHook(%p)\n", a0);

    FARPROC rv = 0;
    __try {
        rv = Real_WSASetBlockingHook(a0);
    } __finally {
        _PrintExit("WSASetBlockingHook() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSASetEvent(HANDLE a0)
{
    _PrintEnter("WSASetEvent(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSASetEvent(a0);
    } __finally {
        _PrintExit("WSASetEvent() -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSASetServiceA(LPWSAQUERYSETA a0,
                                  WSAESETSERVICEOP a1,
                                  DWORD a2)
{
    _PrintEnter("WSASetServiceA(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSASetServiceA(a0, a1, a2);
    } __finally {
        _PrintExit("WSASetServiceA(,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSASetServiceW(LPWSAQUERYSETW a0,
                                  WSAESETSERVICEOP a1,
                                  DWORD a2)
{
    _PrintEnter("WSASetServiceW(%p,%p,%p)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSASetServiceW(a0, a1, a2);
    } __finally {
        _PrintExit("WSASetServiceW(,,) -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSASocketA(int a0,
                                 int a1,
                                 int a2,
                                 LPWSAPROTOCOL_INFOA a3,
                                 GROUP a4,
                                 DWORD a5)
{
    _PrintEnter("WSASocketA(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    SOCKET rv = 0;
    __try {
        rv = Real_WSASocketA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSASocketA(,,,,,) -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSASocketW(int a0,
                                 int a1,
                                 int a2,
                                 LPWSAPROTOCOL_INFOW a3,
                                 GROUP a4,
                                 DWORD a5)
{
    _PrintEnter("WSASocketW(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    SOCKET rv = 0;
    __try {
        rv = Real_WSASocketW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSASocketW(,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAStartup(WORD a0,
                              LPWSADATA a1)
{
    _PrintEnter("WSAStartup(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSAStartup(a0, a1);
    } __finally {
        _PrintExit("WSAStartup(,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAStringToAddressA(LPSTR a0,
                                       INT a1,
                                       LPWSAPROTOCOL_INFOA a2,
                                       LPSOCKADDR a3,
                                       LPINT a4)
{
    _PrintEnter("WSAStringToAddressA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAStringToAddressA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAStringToAddressA(,,,,) -> %p\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAStringToAddressW(LPWSTR a0,
                                       INT a1,
                                       LPWSAPROTOCOL_INFOW a2,
                                       LPSOCKADDR a3,
                                       LPINT a4)
{
    _PrintEnter("WSAStringToAddressW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAStringToAddressW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAStringToAddressW(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAUnhookBlockingHook(void)
{
    _PrintEnter("WSAUnhookBlockingHook()\n");

    int rv = 0;
    __try {
        rv = Real_WSAUnhookBlockingHook();
    } __finally {
        _PrintExit("WSAUnhookBlockingHook() -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WSAWaitForMultipleEvents(DWORD a0,
                                              void** a1,
                                              BOOL a2,
                                              DWORD a3,
                                              BOOL a4)
{
    _PrintEnter("WSAWaitForMultipleEvents(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_WSAWaitForMultipleEvents(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAWaitForMultipleEvents(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitCommEvent(HANDLE a0,
                                  LPDWORD a1,
                                  LPOVERLAPPED a2)
{
    _PrintEnter("WaitCommEvent(%p,%p,%p)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WaitCommEvent(a0, a1, a2);
    } __finally {
        _PrintExit("WaitCommEvent(,,) -> %p\n", rv);
    };
    return rv;
}

#if !defined(DETOURS_ARM)
BOOL __stdcall Mine_WaitForDebugEvent(LPDEBUG_EVENT a0,
                                      DWORD a1)
{
    _PrintEnter("WaitForDebugEvent(%p,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitForDebugEvent(a0, a1);
    } __finally {
        if (rv) {
            _PrintExit("WaitForDebugEvent(%d,) -> %p\n", a0->dwDebugEventCode, rv);
        }
        else {
            _PrintExit("WaitForDebugEvent(,) -> %p\n", rv);
        }
    };
    return rv;
}
#endif // !DETOURS_ARM

DWORD __stdcall Mine_WaitForInputIdle(HANDLE a0,
                                      DWORD a1)
{
    _PrintEnter("WaitForInputIdle(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForInputIdle(a0, a1);
    } __finally {
        _PrintExit("WaitForInputIdle(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForMultipleObjects(DWORD a0,
                                            void** a1,
                                            BOOL a2,
                                            DWORD a3)
{
    _PrintEnter("WaitForMultipleObjects(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForMultipleObjects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WaitForMultipleObjects(,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForMultipleObjectsEx(DWORD a0,
                                              void** a1,
                                              BOOL a2,
                                              DWORD a3,
                                              BOOL a4)
{
    _PrintEnter("WaitForMultipleObjectsEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForMultipleObjectsEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WaitForMultipleObjectsEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForSingleObject(HANDLE a0,
                                         DWORD a1)
{
    _PrintEnter("WaitForSingleObject(%p,%p)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForSingleObject(a0, a1);
    } __finally {
        _PrintExit("WaitForSingleObject(,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForSingleObjectEx(HANDLE a0,
                                           DWORD a1,
                                           BOOL a2)
{
    _PrintEnter("WaitForSingleObjectEx(%p,%p,%p)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForSingleObjectEx(a0, a1, a2);
    } __finally {
        _PrintExit("WaitForSingleObjectEx(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitMessage(void)
{
    _PrintEnter("WaitMessage()\n");

    BOOL rv = 0;
    __try {
        rv = Real_WaitMessage();
    } __finally {
        _PrintExit("WaitMessage() -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitNamedPipeA(LPCSTR a0,
                                   DWORD a1)
{
    _PrintEnter("WaitNamedPipeA(%hs,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitNamedPipeA(a0, a1);
    } __finally {
        _PrintExit("WaitNamedPipeA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitNamedPipeW(LPCWSTR a0,
                                   DWORD a1)
{
    _PrintEnter("WaitNamedPipeW(%ls,%p)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitNamedPipeW(a0, a1);
    } __finally {
        _PrintExit("WaitNamedPipeW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WidenPath(HDC a0)
{
    _PrintEnter("WidenPath(%p)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WidenPath(a0);
    } __finally {
        _PrintExit("WidenPath() -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_WinExec(LPCSTR a0,
                            UINT a1)
{
    _PrintEnter("WinExec(%hs,%p)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_WinExec(a0, a1);
    } __finally {
        _PrintExit("WinExec(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WinHelpA(HWND a0,
                             LPCSTR a1,
                             UINT a2,
                             ULONG_PTR a3)
{
    _PrintEnter("WinHelpA(%p,%hs,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WinHelpA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WinHelpA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WinHelpW(HWND a0,
                             LPCWSTR a1,
                             UINT a2,
                             ULONG_PTR a3)
{
    _PrintEnter("WinHelpW(%p,%ls,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WinHelpW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WinHelpW(,,,) -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_WindowFromDC(HDC a0)
{
    _PrintEnter("WindowFromDC(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_WindowFromDC(a0);
    } __finally {
        _PrintExit("WindowFromDC() -> %p\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_WindowFromPoint(POINT a0)
{
    _PrintEnter("WindowFromPoint(%p)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_WindowFromPoint(a0);
    } __finally {
        _PrintExit("WindowFromPoint() -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteClassStg(LPSTORAGE a0,
                                     CONST IID& a1)
{
    _PrintEnter("WriteClassStg(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteClassStg(a0, a1);
    } __finally {
        _PrintExit("WriteClassStg(,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteClassStm(LPSTREAM a0,
                                     CONST IID& a1)
{
    _PrintEnter("WriteClassStm(%p,%p)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteClassStm(a0, a1);
    } __finally {
        _PrintExit("WriteClassStm(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleA(HANDLE a0,
                                  void* a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPVOID a4)
{
    _PrintEnter("WriteConsoleA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleInputA(HANDLE a0,
                                       INPUT_RECORD* a1,
                                       DWORD a2,
                                       LPDWORD a3)
{
    _PrintEnter("WriteConsoleInputA(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteConsoleInputA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleInputW(HANDLE a0,
                                       INPUT_RECORD* a1,
                                       DWORD a2,
                                       LPDWORD a3)
{
    _PrintEnter("WriteConsoleInputW(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteConsoleInputW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputA(HANDLE a0,
                                        CHAR_INFO* a1,
                                        COORD a2,
                                        COORD a3,
                                        PSMALL_RECT a4)
{
    _PrintEnter("WriteConsoleOutputA(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputAttribute(HANDLE a0,
                                                WORD* a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputAttribute(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputAttribute(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputCharacterA(HANDLE a0,
                                                 LPCSTR a1,
                                                 DWORD a2,
                                                 COORD a3,
                                                 LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputCharacterA(%p,%hs,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputCharacterA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputCharacterW(HANDLE a0,
                                                 LPCWSTR a1,
                                                 DWORD a2,
                                                 COORD a3,
                                                 LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputCharacterW(%p,%ls,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputCharacterW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputW(HANDLE a0,
                                        CHAR_INFO* a1,
                                        COORD a2,
                                        COORD a3,
                                        PSMALL_RECT a4)
{
    _PrintEnter("WriteConsoleOutputW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleW(HANDLE a0,
                                  void* a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPVOID a4)
{
    _PrintEnter("WriteConsoleW(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteFile(HANDLE a0,
                              LPCVOID a1,
                              DWORD a2,
                              LPDWORD a3,
                              LPOVERLAPPED a4)
{
    _PrintEnter("WriteFile(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteFile(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteFileEx(HANDLE a0,
                                LPCVOID a1,
                                DWORD a2,
                                LPOVERLAPPED a3,
                                LPOVERLAPPED_COMPLETION_ROUTINE a4)
{
    _PrintEnter("WriteFileEx(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteFileEx(,,,,) -> %p\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteFmtUserTypeStg(LPSTORAGE a0,
                                           CLIPFORMAT a1,
                                           LPOLESTR a2)
{
    _PrintEnter("WriteFmtUserTypeStg(%p,%p,%p)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteFmtUserTypeStg(a0, a1, a2);
    } __finally {
        _PrintExit("WriteFmtUserTypeStg(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileSectionA(LPCSTR a0,
                                                LPCSTR a1,
                                                LPCSTR a2)
{
    _PrintEnter("WritePrivateProfileSectionA(%hs,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileSectionA(a0, a1, a2);
    } __finally {
        _PrintExit("WritePrivateProfileSectionA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileSectionW(LPCWSTR a0,
                                                LPCWSTR a1,
                                                LPCWSTR a2)
{
    _PrintEnter("WritePrivateProfileSectionW(%ls,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileSectionW(a0, a1, a2);
    } __finally {
        _PrintExit("WritePrivateProfileSectionW(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStringA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               LPCSTR a3)
{
    _PrintEnter("WritePrivateProfileStringA(%hs,%hs,%hs,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStringA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WritePrivateProfileStringA(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStringW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               LPCWSTR a3)
{
    _PrintEnter("WritePrivateProfileStringW(%ls,%ls,%ls,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStringW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WritePrivateProfileStringW(,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStructA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPVOID a2,
                                               UINT a3,
                                               LPCSTR a4)
{
    _PrintEnter("WritePrivateProfileStructA(%hs,%hs,%p,%p,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStructA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WritePrivateProfileStructA(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStructW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPVOID a2,
                                               UINT a3,
                                               LPCWSTR a4)
{
    _PrintEnter("WritePrivateProfileStructW(%ls,%ls,%p,%p,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStructW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WritePrivateProfileStructW(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProcessMemory(HANDLE a0,
                                       LPVOID lpBase,
                                       LPVOID lpBuf,
                                       DWORD_PTR nSize,
                                       PDWORD_PTR a4)
{
    _PrintEnter("WriteProcessMemory(%p,@%p..%p,%p,%p)\n",
                a0, lpBase,
                (PBYTE)lpBase + ((nSize > 0) ? nSize - 1 : 0),
                lpBuf, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProcessMemory(a0, lpBase, lpBuf, nSize, a4);
    } __finally {
        _PrintExit("WriteProcessMemory(,,,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileSectionA(LPCSTR a0,
                                         LPCSTR a1)
{
    _PrintEnter("WriteProfileSectionA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileSectionA(a0, a1);
    } __finally {
        _PrintExit("WriteProfileSectionA(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileSectionW(LPCWSTR a0,
                                         LPCWSTR a1)
{
    _PrintEnter("WriteProfileSectionW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileSectionW(a0, a1);
    } __finally {
        _PrintExit("WriteProfileSectionW(,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileStringA(LPCSTR a0,
                                        LPCSTR a1,
                                        LPCSTR a2)
{
    _PrintEnter("WriteProfileStringA(%hs,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileStringA(a0, a1, a2);
    } __finally {
        _PrintExit("WriteProfileStringA(,,) -> %p\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileStringW(LPCWSTR a0,
                                        LPCWSTR a1,
                                        LPCWSTR a2)
{
    _PrintEnter("WriteProfileStringW(%ls,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileStringW(a0, a1, a2);
    } __finally {
        _PrintExit("WriteProfileStringW(,,) -> %p\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WriteTapemark(HANDLE a0,
                                   DWORD a1,
                                   DWORD a2,
                                   BOOL a3)
{
    _PrintEnter("WriteTapemark(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_WriteTapemark(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteTapemark(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine___WSAFDIsSet(SOCKET a0,
                                fd_set* a1)
{
    _PrintEnter("__WSAFDIsSet(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real___WSAFDIsSet(a0, a1);
    } __finally {
        _PrintExit("__WSAFDIsSet(,) -> %p\n", rv);
    };
    return rv;
}

long __stdcall Mine__hread(HFILE a0,
                           LPVOID a1,
                           long a2)
{
    _PrintEnter("_hread(%p,%p,%p)\n", a0, a1, a2);

    long rv = 0;
    __try {
        rv = Real__hread(a0, a1, a2);
    } __finally {
        _PrintExit("_hread(,,) -> %p\n", rv);
    };
    return rv;
}

long __stdcall Mine__hwrite(HFILE a0,
                            LPCSTR a1,
                            long a2)
{
    _PrintEnter("_hwrite(%p,%hs,%p)\n", a0, a1, a2);

    long rv = 0;
    __try {
        rv = Real__hwrite(a0, a1, a2);
    } __finally {
        _PrintExit("_hwrite(,,) -> %p\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lclose(HFILE a0)
{
    _PrintEnter("_lclose(%p)\n", a0);

    HFILE rv = 0;
    __try {
        rv = Real__lclose(a0);
    } __finally {
        _PrintExit("_lclose() -> %p\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lcreat(LPCSTR a0,
                             int a1)
{
    _PrintEnter("_lcreat(%hs,%p)\n", a0, a1);

    HFILE rv = 0;
    __try {
        rv = Real__lcreat(a0, a1);
    } __finally {
        _PrintExit("_lcreat(,) -> %p\n", rv);
    };
    return rv;
}

LONG __stdcall Mine__llseek(HFILE a0,
                            LONG a1,
                            int a2)
{
    _PrintEnter("_llseek(%p,%p,%p)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real__llseek(a0, a1, a2);
    } __finally {
        _PrintExit("_llseek(,,) -> %p\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lopen(LPCSTR a0,
                            int a1)
{
    _PrintEnter("_lopen(%hs,%p)\n", a0, a1);

    HFILE rv = 0;
    __try {
        rv = Real__lopen(a0, a1);
    } __finally {
        _PrintExit("_lopen(,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine__lread(HFILE a0,
                           LPVOID a1,
                           UINT a2)
{
    _PrintEnter("_lread(%p,%p,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real__lread(a0, a1, a2);
    } __finally {
        _PrintExit("_lread(,,) -> %p\n", rv);
    };
    return rv;
}

UINT __stdcall Mine__lwrite(HFILE a0,
                            LPCSTR a1,
                            UINT a2)
{
    _PrintEnter("_lwrite(%p,%hs,%p)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real__lwrite(a0, a1, a2);
    } __finally {
        _PrintExit("_lwrite(,,) -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_accept(SOCKET a0,
                             sockaddr* a1,
                             int* a2)
{
    _PrintEnter("accept(%p,%p,%p)\n", a0, a1, a2);

    SOCKET rv = 0;
    __try {
        rv = Real_accept(a0, a1, a2);
    } __finally {
        _PrintExit("accept(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_bind(SOCKET a0,
                        sockaddr* a1,
                        int a2)
{
    _PrintEnter("bind(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_bind(a0, a1, a2);
    } __finally {
        _PrintExit("bind(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_closesocket(SOCKET a0)
{
    _PrintEnter("closesocket(%p)\n", a0);

    int rv = 0;
    __try {
        rv = Real_closesocket(a0);
    } __finally {
        _PrintExit("closesocket() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_connect(SOCKET a0,
                           sockaddr* a1,
                           int a2)
{
    _PrintEnter("connect(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_connect(a0, a1, a2);
    } __finally {
        _PrintExit("connect(,,) -> %p\n", rv);
    };
    return rv;
}

hostent* __stdcall Mine_gethostbyaddr(char* a0,
                                      int a1,
                                      int a2)
{
    _PrintEnter("gethostbyaddr(%p,%p,%p)\n", a0, a1, a2);

    hostent* rv = 0;
    __try {
        rv = Real_gethostbyaddr(a0, a1, a2);
    } __finally {
        _PrintExit("gethostbyaddr(,,) -> %p\n", rv);
    };
    return rv;
}

hostent* __stdcall Mine_gethostbyname(char* a0)
{
    _PrintEnter("gethostbyname(%p)\n", a0);

    hostent* rv = 0;
    __try {
        rv = Real_gethostbyname(a0);
    } __finally {
        _PrintExit("gethostbyname() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_gethostname(char* a0,
                               int a1)
{
    _PrintEnter("gethostname(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_gethostname(a0, a1);
    } __finally {
        _PrintExit("gethostname(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_getpeername(SOCKET a0,
                               sockaddr* a1,
                               int* a2)
{
    _PrintEnter("getpeername(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_getpeername(a0, a1, a2);
    } __finally {
        _PrintExit("getpeername(,,) -> %p\n", rv);
    };
    return rv;
}

protoent* __stdcall Mine_getprotobyname(char* a0)
{
    _PrintEnter("getprotobyname(%p)\n", a0);

    protoent* rv = 0;
    __try {
        rv = Real_getprotobyname(a0);
    } __finally {
        _PrintExit("getprotobyname() -> %p\n", rv);
    };
    return rv;
}

protoent* __stdcall Mine_getprotobynumber(int a0)
{
    _PrintEnter("getprotobynumber(%p)\n", a0);

    protoent* rv = 0;
    __try {
        rv = Real_getprotobynumber(a0);
    } __finally {
        _PrintExit("getprotobynumber() -> %p\n", rv);
    };
    return rv;
}

servent* __stdcall Mine_getservbyname(char* a0,
                                      char* a1)
{
    _PrintEnter("getservbyname(%p,%p)\n", a0, a1);

    servent* rv = 0;
    __try {
        rv = Real_getservbyname(a0, a1);
    } __finally {
        _PrintExit("getservbyname(,) -> %p\n", rv);
    };
    return rv;
}

servent* __stdcall Mine_getservbyport(int a0,
                                      char* a1)
{
    _PrintEnter("getservbyport(%p,%p)\n", a0, a1);

    servent* rv = 0;
    __try {
        rv = Real_getservbyport(a0, a1);
    } __finally {
        _PrintExit("getservbyport(,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_getsockname(SOCKET a0,
                               sockaddr* a1,
                               int* a2)
{
    _PrintEnter("getsockname(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_getsockname(a0, a1, a2);
    } __finally {
        _PrintExit("getsockname(,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_getsockopt(SOCKET a0,
                              int a1,
                              int a2,
                              char* a3,
                              int* a4)
{
    _PrintEnter("getsockopt(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_getsockopt(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("getsockopt(,,,,) -> %p\n", rv);
    };
    return rv;
}

u_long __stdcall Mine_htonl(u_long a0)
{
    _PrintEnter("htonl(%p)\n", a0);

    u_long rv = 0;
    __try {
        rv = Real_htonl(a0);
    } __finally {
        _PrintExit("htonl() -> %p\n", rv);
    };
    return rv;
}

u_short __stdcall Mine_htons(u_short a0)
{
    _PrintEnter("htons(%p)\n", a0);

    u_short rv = 0;
    __try {
        rv = Real_htons(a0);
    } __finally {
        _PrintExit("htons() -> %p\n", rv);
    };
    return rv;
}

unsigned long __stdcall Mine_inet_addr(char* a0)
{
    _PrintEnter("inet_addr(%p)\n", a0);

    unsigned long rv = 0;
    __try {
        rv = Real_inet_addr(a0);
    } __finally {
        _PrintExit("inet_addr() -> %p\n", rv);
    };
    return rv;
}

char* __stdcall Mine_inet_ntoa(in_addr a0)
{
    _PrintEnter("inet_ntoa(%p)\n", a0);

    char* rv = 0;
    __try {
        rv = Real_inet_ntoa(a0);
    } __finally {
        _PrintExit("inet_ntoa() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_ioctlsocket(SOCKET a0,
                               long a1,
                               u_long* a2)
{
    _PrintEnter("ioctlsocket(%p,%p,%p)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_ioctlsocket(a0, a1, a2);
    } __finally {
        _PrintExit("ioctlsocket(,,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_keybd_event(BYTE a0,
                                BYTE a1,
                                DWORD a2,
                                ULONG_PTR a3)
{
    _PrintEnter("keybd_event(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    __try {
        Real_keybd_event(a0, a1, a2, a3);
    } __finally {
        _PrintExit("keybd_event(,,,) ->\n");
    };
}

int __stdcall Mine_listen(SOCKET a0,
                          int a1)
{
    _PrintEnter("listen(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_listen(a0, a1);
    } __finally {
        _PrintExit("listen(,) -> %p\n", rv);
    };
    return rv;
}

void __stdcall Mine_mouse_event(DWORD a0,
                                DWORD a1,
                                DWORD a2,
                                DWORD a3,
                                ULONG_PTR a4)
{
    _PrintEnter("mouse_event(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    __try {
        Real_mouse_event(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("mouse_event(,,,,) ->\n");
    };
}

u_long __stdcall Mine_ntohl(u_long a0)
{
    _PrintEnter("ntohl(%p)\n", a0);

    u_long rv = 0;
    __try {
        rv = Real_ntohl(a0);
    } __finally {
        _PrintExit("ntohl() -> %p\n", rv);
    };
    return rv;
}

u_short __stdcall Mine_ntohs(u_short a0)
{
    _PrintEnter("ntohs(%p)\n", a0);

    u_short rv = 0;
    __try {
        rv = Real_ntohs(a0);
    } __finally {
        _PrintExit("ntohs() -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_recv(SOCKET a0,
                        char* a1,
                        int a2,
                        int a3)
{
    _PrintEnter("recv(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_recv(a0, a1, a2, a3);
    } __finally {
        _PrintExit("recv(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_recvfrom(SOCKET a0,
                            char* a1,
                            int a2,
                            int a3,
                            sockaddr* a4,
                            int* a5)
{
    _PrintEnter("recvfrom(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_recvfrom(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("recvfrom(,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_select(int a0,
                          fd_set* a1,
                          fd_set* a2,
                          fd_set* a3,
                          timeval* a4)
{
    _PrintEnter("select(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_select(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("select(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_send(SOCKET a0,
                        char* a1,
                        int a2,
                        int a3)
{
    _PrintEnter("send(%p,%p,%p,%p)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_send(a0, a1, a2, a3);
    } __finally {
        _PrintExit("send(,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_sendto(SOCKET a0,
                          char* a1,
                          int a2,
                          int a3,
                          sockaddr* a4,
                          int a5)
{
    _PrintEnter("sendto(%p,%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_sendto(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("sendto(,,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_setsockopt(SOCKET a0,
                              int a1,
                              int a2,
                              char* a3,
                              int a4)
{
    _PrintEnter("setsockopt(%p,%p,%p,%p,%p)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_setsockopt(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("setsockopt(,,,,) -> %p\n", rv);
    };
    return rv;
}

int __stdcall Mine_shutdown(SOCKET a0,
                            int a1)
{
    _PrintEnter("shutdown(%p,%p)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_shutdown(a0, a1);
    } __finally {
        _PrintExit("shutdown(,) -> %p\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_socket(int a0,
                             int a1,
                             int a2)
{
    _PrintEnter("socket(%x,%x,%x)\n", a0, a1, a2);

    SOCKET rv = 0;
    __try {
        rv = Real_socket(a0, a1, a2);
    } __finally {
        _PrintExit("socket(,,) -> %p\n", rv);
    };
    return rv;
}

////////////////////////////////////////////////////////////// AttachDetours.
//
static PCHAR DetRealName(PCHAR psz)
{
    PCHAR pszBeg = psz;
    // Move to end of name.
    while (*psz) {
        psz++;
    }
    // Move back through A-Za-z0-9 names.
    while (psz > pszBeg &&
           ((psz[-1] >= 'A' && psz[-1] <= 'Z') ||
            (psz[-1] >= 'a' && psz[-1] <= 'z') ||
            (psz[-1] >= '0' && psz[-1] <= '9'))) {
        psz--;
    }
    return psz;
}

static VOID Dump(PBYTE pbBytes, LONG nBytes, PBYTE pbTarget)
{
    CHAR szBuffer[256];
    PCHAR pszBuffer = szBuffer;

    for (LONG n = 0; n < nBytes; n += 12) {
        pszBuffer += StringCchPrintfA(pszBuffer, sizeof(szBuffer), "  %p: ", pbBytes + n);
        for (LONG m = n; m < n + 12; m++) {
            if (m >= nBytes) {
                pszBuffer += StringCchPrintfA(pszBuffer, sizeof(szBuffer), "   ");
            }
            else {
                pszBuffer += StringCchPrintfA(pszBuffer, sizeof(szBuffer), "%02x ", pbBytes[m]);
            }
        }
        if (n == 0) {
            pszBuffer += StringCchPrintfA(pszBuffer, sizeof(szBuffer), "[%p]", pbTarget);
        }
        pszBuffer += StringCchPrintfA(pszBuffer, sizeof(szBuffer), "\n");
    }

    Syelog(SYELOG_SEVERITY_INFORMATION, "%s", szBuffer);
}

static VOID Decode(PBYTE pbCode, LONG nInst)
{
    PBYTE pbSrc = pbCode;
    PBYTE pbEnd;
    PBYTE pbTarget;
    for (LONG n = 0; n < nInst; n++) {
        pbTarget = NULL;
        pbEnd = (PBYTE)DetourCopyInstruction(NULL, NULL, (PVOID)pbSrc, (PVOID*)&pbTarget, NULL);
        Dump(pbSrc, (int)(pbEnd - pbSrc), pbTarget);
        pbSrc = pbEnd;

        if (pbTarget != NULL) {
            break;
        }
    }
}

VOID DetAttach(PVOID *ppvReal, PVOID pvMine, PCHAR psz)
{
    PVOID pvReal = NULL;
    if (ppvReal == NULL) {
        ppvReal = &pvReal;
    }

    LONG l = DetourAttach(ppvReal, pvMine);
    if (l != 0) {
        Syelog(SYELOG_SEVERITY_NOTICE,
               "Attach failed: `%s': error %d\n", DetRealName(psz), l);

        Decode((PBYTE)*ppvReal, 3);
    }
}

VOID DetDetach(PVOID *ppvReal, PVOID pvMine, PCHAR psz)
{
    LONG l = DetourDetach(ppvReal, pvMine);
    if (l != 0) {
#if 0
        Syelog(SYELOG_SEVERITY_NOTICE,
               "Detach failed: `%s': error %d\n", DetRealName(psz), l);
#else
        (void)psz;
#endif
    }
}

#define ATTACH(x)       DetAttach(&(PVOID&)Real_##x,Mine_##x,#x)
#define DETACH(x)       DetDetach(&(PVOID&)Real_##x,Mine_##x,#x)

LONG AttachDetours(VOID)
{
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());

    // For this many APIs, we'll ignore one or two can't be detoured.
    DetourSetIgnoreTooSmall(TRUE);

    ATTACH(AbortDoc);
    ATTACH(AbortPath);
    ATTACH(ActivateKeyboardLayout);
    ATTACH(AddAtomA);
    ATTACH(AddAtomW);
    ATTACH(AddFontResourceA);
    ATTACH(AddFontResourceW);
    ATTACH(AdjustWindowRect);
    ATTACH(AdjustWindowRectEx);
    ATTACH(AllocConsole);
    ATTACH(AngleArc);
    ATTACH(AnimatePalette);
    ATTACH(AnyPopup);
    ATTACH(AppendMenuA);
    ATTACH(AppendMenuW);
    ATTACH(Arc);
    ATTACH(ArcTo);
    ATTACH(AreFileApisANSI);
    ATTACH(ArrangeIconicWindows);
    ATTACH(AttachThreadInput);
    ATTACH(BackupRead);
    ATTACH(BackupSeek);
    ATTACH(BackupWrite);
    ATTACH(Beep);
    ATTACH(BeginDeferWindowPos);
    ATTACH(BeginPaint);
    ATTACH(BeginPath);
    ATTACH(BeginUpdateResourceA);
    ATTACH(BeginUpdateResourceW);
    ATTACH(BindMoniker);
    ATTACH(BitBlt);
    ATTACH(BringWindowToTop);
    ATTACH(BroadcastSystemMessageA);
    ATTACH(BroadcastSystemMessageW);
    ATTACH(BuildCommDCBA);
    ATTACH(BuildCommDCBAndTimeoutsA);
    ATTACH(BuildCommDCBAndTimeoutsW);
    ATTACH(BuildCommDCBW);
    ATTACH(CLSIDFromProgID);
    ATTACH(CLSIDFromString);
    ATTACH(CallMsgFilterA);
    ATTACH(CallMsgFilterW);
    ATTACH(CallNamedPipeA);
    ATTACH(CallNamedPipeW);
    ATTACH(CallNextHookEx);
    ATTACH(CallWindowProcA);
    ATTACH(CallWindowProcW);
    ATTACH(CancelDC);
    ATTACH(CancelIo);
    ATTACH(CancelWaitableTimer);
    ATTACH(CascadeWindows);
    ATTACH(ChangeClipboardChain);
    ATTACH(ChangeDisplaySettingsA);
    ATTACH(ChangeDisplaySettingsExA);
    ATTACH(ChangeDisplaySettingsExW);
    ATTACH(ChangeDisplaySettingsW);
    ATTACH(ChangeMenuA);
    ATTACH(ChangeMenuW);
    ATTACH(CharLowerA);
    ATTACH(CharLowerBuffA);
    ATTACH(CharLowerBuffW);
    ATTACH(CharLowerW);
    ATTACH(CharNextA);
    ATTACH(CharNextExA);
    ATTACH(CharNextW);
    ATTACH(CharPrevA);
    ATTACH(CharPrevExA);
    ATTACH(CharPrevW);
    ATTACH(CharToOemA);
    ATTACH(CharToOemBuffA);
    ATTACH(CharToOemBuffW);
    ATTACH(CharToOemW);
    ATTACH(CharUpperA);
    ATTACH(CharUpperBuffA);
    ATTACH(CharUpperBuffW);
    ATTACH(CharUpperW);
    ATTACH(CheckColorsInGamut);
    ATTACH(CheckDlgButton);
    ATTACH(CheckMenuItem);
    ATTACH(CheckMenuRadioItem);
    ATTACH(CheckRadioButton);
    ATTACH(ChildWindowFromPoint);
    ATTACH(ChildWindowFromPointEx);
    ATTACH(ChoosePixelFormat);
    ATTACH(Chord);
    ATTACH(ClearCommBreak);
    ATTACH(ClearCommError);
    ATTACH(ClientToScreen);
    ATTACH(ClipCursor);
    ATTACH(CloseClipboard);
    ATTACH(CloseDesktop);
    ATTACH(CloseEnhMetaFile);
    ATTACH(CloseFigure);
    ATTACH(CloseHandle);
    ATTACH(CloseMetaFile);
    ATTACH(CloseWindow);
    ATTACH(CloseWindowStation);
    ATTACH(CoAddRefServerProcess);
    ATTACH(CoBuildVersion);
    ATTACH(CoCopyProxy);
    ATTACH(CoCreateFreeThreadedMarshaler);
    ATTACH(CoCreateGuid);
    ATTACH(CoCreateInstance);
    ATTACH(CoCreateInstanceEx);
    ATTACH(CoDisconnectObject);
    ATTACH(CoDosDateTimeToFileTime);
    ATTACH(CoFileTimeNow);
    ATTACH(CoFileTimeToDosDateTime);
    ATTACH(CoFreeAllLibraries);
    ATTACH(CoFreeLibrary);
    ATTACH(CoFreeUnusedLibraries);
    ATTACH(CoGetCallContext);
    ATTACH(CoGetClassObject);
    ATTACH(CoGetCurrentProcess);
    ATTACH(CoGetInstanceFromFile);
    ATTACH(CoGetInstanceFromIStorage);
    ATTACH(CoGetInterfaceAndReleaseStream);
    ATTACH(CoGetMalloc);
    ATTACH(CoGetMarshalSizeMax);
    ATTACH(CoGetObject);
    ATTACH(CoGetPSClsid);
    ATTACH(CoGetStandardMarshal);
    ATTACH(CoGetStdMarshalEx);
    ATTACH(CoGetTreatAsClass);
    ATTACH(CoImpersonateClient);
    ATTACH(CoInitialize);
    ATTACH(CoInitializeEx);
    ATTACH(CoInitializeSecurity);
    ATTACH(CoIsHandlerConnected);
    ATTACH(CoIsOle1Class);
    ATTACH(CoLoadLibrary);
    ATTACH(CoLockObjectExternal);
    ATTACH(CoMarshalHresult);
    ATTACH(CoMarshalInterThreadInterfaceInStream);
    ATTACH(CoMarshalInterface);
    ATTACH(CoQueryAuthenticationServices);
    ATTACH(CoQueryClientBlanket);
    ATTACH(CoQueryProxyBlanket);
    ATTACH(CoRegisterChannelHook);
    ATTACH(CoRegisterClassObject);
    ATTACH(CoRegisterMallocSpy);
    ATTACH(CoRegisterMessageFilter);
    ATTACH(CoRegisterPSClsid);
    ATTACH(CoRegisterSurrogate);
    ATTACH(CoReleaseMarshalData);
    ATTACH(CoReleaseServerProcess);
    ATTACH(CoResumeClassObjects);
    ATTACH(CoRevertToSelf);
    ATTACH(CoRevokeClassObject);
    ATTACH(CoRevokeMallocSpy);
    ATTACH(CoSetProxyBlanket);
    ATTACH(CoSuspendClassObjects);
    ATTACH(CoSwitchCallContext);
    ATTACH(CoTaskMemAlloc);
    ATTACH(CoTaskMemFree);
    ATTACH(CoTaskMemRealloc);
    ATTACH(CoTreatAsClass);
    ATTACH(CoUninitialize);
    ATTACH(CoUnmarshalHresult);
    ATTACH(CoUnmarshalInterface);
    ATTACH(ColorMatchToTarget);
    ATTACH(CombineRgn);
    ATTACH(CombineTransform);
    ATTACH(CommConfigDialogA);
    ATTACH(CommConfigDialogW);
    ATTACH(CompareFileTime);
    ATTACH(CompareStringA);
    ATTACH(CompareStringW);
    ATTACH(ConnectNamedPipe);
#if !defined(DETOURS_ARM)
    ATTACH(ContinueDebugEvent);
#endif // !DETOURS_ARM
    ATTACH(ConvertDefaultLocale);
    ATTACH(ConvertThreadToFiber);
    ATTACH(CopyAcceleratorTableA);
    ATTACH(CopyAcceleratorTableW);
    ATTACH(CopyEnhMetaFileA);
    ATTACH(CopyEnhMetaFileW);
    ATTACH(CopyFileA);
    ATTACH(CopyFileExA);
    ATTACH(CopyFileExW);
    ATTACH(CopyFileW);
    ATTACH(CopyIcon);
    ATTACH(CopyImage);
    ATTACH(CopyMetaFileA);
    ATTACH(CopyMetaFileW);
    ATTACH(CopyRect);
    ATTACH(CountClipboardFormats);
    ATTACH(CreateAcceleratorTableA);
    ATTACH(CreateAcceleratorTableW);
    ATTACH(CreateAntiMoniker);
    ATTACH(CreateBindCtx);
    ATTACH(CreateBitmap);
    ATTACH(CreateBitmapIndirect);
    ATTACH(CreateBrushIndirect);
    ATTACH(CreateCaret);
    ATTACH(CreateClassMoniker);
    ATTACH(CreateColorSpaceA);
    ATTACH(CreateColorSpaceW);
    ATTACH(CreateCompatibleBitmap);
    ATTACH(CreateCompatibleDC);
    ATTACH(CreateConsoleScreenBuffer);
    ATTACH(CreateCursor);
    ATTACH(CreateDCA);
    ATTACH(CreateDCW);
    ATTACH(CreateDIBPatternBrush);
    ATTACH(CreateDIBPatternBrushPt);
    ATTACH(CreateDIBSection);
    ATTACH(CreateDIBitmap);
    ATTACH(CreateDataAdviseHolder);
    ATTACH(CreateDataCache);
    ATTACH(CreateDesktopA);
    ATTACH(CreateDesktopW);
    ATTACH(CreateDialogIndirectParamA);
    ATTACH(CreateDialogIndirectParamW);
    ATTACH(CreateDialogParamA);
    ATTACH(CreateDialogParamW);
    ATTACH(CreateDirectoryA);
    ATTACH(CreateDirectoryExA);
    ATTACH(CreateDirectoryExW);
    ATTACH(CreateDirectoryW);
    ATTACH(CreateDiscardableBitmap);
    ATTACH(CreateEllipticRgn);
    ATTACH(CreateEllipticRgnIndirect);
    ATTACH(CreateEnhMetaFileA);
    ATTACH(CreateEnhMetaFileW);
    ATTACH(CreateEventA);
    ATTACH(CreateEventW);
    ATTACH(CreateFiber);
    ATTACH(CreateFileA);
    ATTACH(CreateFileMappingA);
    ATTACH(CreateFileMappingW);
    ATTACH(CreateFileMoniker);
    ATTACH(CreateFileW);
    ATTACH(CreateFontA);
    ATTACH(CreateFontIndirectA);
    ATTACH(CreateFontIndirectW);
    ATTACH(CreateFontW);
    ATTACH(CreateGenericComposite);
    ATTACH(CreateHalftonePalette);
    ATTACH(CreateHatchBrush);
    ATTACH(CreateICA);
    ATTACH(CreateICW);
    ATTACH(CreateILockBytesOnHGlobal);
    ATTACH(CreateIcon);
    ATTACH(CreateIconFromResource);
    ATTACH(CreateIconFromResourceEx);
    ATTACH(CreateIconIndirect);
    ATTACH(CreateIoCompletionPort);
    ATTACH(CreateItemMoniker);
    ATTACH(CreateMDIWindowA);
    ATTACH(CreateMDIWindowW);
    ATTACH(CreateMailslotA);
    ATTACH(CreateMailslotW);
    ATTACH(CreateMenu);
    ATTACH(CreateMetaFileA);
    ATTACH(CreateMetaFileW);
    ATTACH(CreateMutexA);
    ATTACH(CreateMutexW);
    ATTACH(CreateNamedPipeA);
    ATTACH(CreateNamedPipeW);
    ATTACH(CreateOleAdviseHolder);
    ATTACH(CreatePalette);
    ATTACH(CreatePatternBrush);
    ATTACH(CreatePen);
    ATTACH(CreatePenIndirect);
    ATTACH(CreatePipe);
    ATTACH(CreatePointerMoniker);
    ATTACH(CreatePolyPolygonRgn);
    ATTACH(CreatePolygonRgn);
    ATTACH(CreatePopupMenu);
    ATTACH(CreateProcessA);
    ATTACH(CreateProcessW);
    ATTACH(CreateProcessAsUserA);
    ATTACH(CreateProcessAsUserW);
#if(_WIN32_WINNT >= 0x0500)
    ATTACH(CreateProcessWithLogonW);
    ATTACH(CreateProcessWithTokenW);
#endif //(_WIN32_WINNT >= 0x0500)
    ATTACH(CreateRectRgn);
    ATTACH(CreateRectRgnIndirect);
    ATTACH(CreateRemoteThread);
    ATTACH(CreateRoundRectRgn);
    ATTACH(CreateScalableFontResourceA);
    ATTACH(CreateScalableFontResourceW);
    ATTACH(CreateSemaphoreA);
    ATTACH(CreateSemaphoreW);
    ATTACH(CreateSolidBrush);
    ATTACH(CreateStdProgressIndicator);
    ATTACH(CreateStreamOnHGlobal);
    ATTACH(CreateTapePartition);
    ATTACH(CreateThread);
    ATTACH(CreateWaitableTimerA);
    ATTACH(CreateWaitableTimerW);
    ATTACH(CreateWindowExA);
    ATTACH(CreateWindowExW);
    ATTACH(CreateWindowStationA);
    ATTACH(CreateWindowStationW);
    ATTACH(DPtoLP);
    ATTACH(DdeAbandonTransaction);
    ATTACH(DdeAccessData);
    ATTACH(DdeAddData);
    ATTACH(DdeClientTransaction);
    ATTACH(DdeCmpStringHandles);
    ATTACH(DdeConnect);
    ATTACH(DdeConnectList);
    ATTACH(DdeCreateDataHandle);
    ATTACH(DdeCreateStringHandleA);
    ATTACH(DdeCreateStringHandleW);
    ATTACH(DdeDisconnect);
    ATTACH(DdeDisconnectList);
    ATTACH(DdeEnableCallback);
    ATTACH(DdeFreeDataHandle);
    ATTACH(DdeFreeStringHandle);
    ATTACH(DdeGetData);
    ATTACH(DdeGetLastError);
    ATTACH(DdeImpersonateClient);
    ATTACH(DdeKeepStringHandle);
    ATTACH(DdeNameService);
    ATTACH(DdePostAdvise);
    ATTACH(DdeQueryConvInfo);
    ATTACH(DdeQueryNextServer);
    ATTACH(DdeQueryStringA);
    ATTACH(DdeQueryStringW);
    ATTACH(DdeReconnect);
    ATTACH(DdeSetQualityOfService);
    ATTACH(DdeSetUserHandle);
    ATTACH(DdeUnaccessData);
    ATTACH(DdeUninitialize);
    ATTACH(DebugActiveProcess);
    ATTACH(DebugActiveProcessStop);
    ATTACH(DebugBreak);
    ATTACH(DefDlgProcA);
    ATTACH(DefDlgProcW);
    ATTACH(DefFrameProcA);
    ATTACH(DefFrameProcW);
    ATTACH(DefMDIChildProcA);
    ATTACH(DefMDIChildProcW);
    ATTACH(DefWindowProcA);
    ATTACH(DefWindowProcW);
    ATTACH(DeferWindowPos);
    ATTACH(DefineDosDeviceA);
    ATTACH(DefineDosDeviceW);
    ATTACH(DeleteAtom);
    ATTACH(DeleteColorSpace);
    ATTACH(DeleteDC);
    ATTACH(DeleteEnhMetaFile);
    ATTACH(DeleteFiber);
    ATTACH(DeleteFileA);
    ATTACH(DeleteFileW);
    ATTACH(DeleteMenu);
    ATTACH(DeleteMetaFile);
    ATTACH(DeleteObject);
    ATTACH(DescribePixelFormat);
    ATTACH(DestroyAcceleratorTable);
    ATTACH(DestroyCaret);
    ATTACH(DestroyCursor);
    ATTACH(DestroyIcon);
    ATTACH(DestroyMenu);
    ATTACH(DestroyWindow);
    ATTACH(DeviceIoControl);
    ATTACH(DialogBoxIndirectParamA);
    ATTACH(DialogBoxIndirectParamW);
    ATTACH(DialogBoxParamA);
    ATTACH(DialogBoxParamW);
    ATTACH(DisableThreadLibraryCalls);
    ATTACH(DisconnectNamedPipe);
    ATTACH(DispatchMessageA);
    ATTACH(DispatchMessageW);
    ATTACH(DlgDirListA);
    ATTACH(DlgDirListComboBoxA);
    ATTACH(DlgDirListComboBoxW);
    ATTACH(DlgDirListW);
    ATTACH(DlgDirSelectComboBoxExA);
    ATTACH(DlgDirSelectComboBoxExW);
    ATTACH(DlgDirSelectExA);
    ATTACH(DlgDirSelectExW);
    ATTACH(DoDragDrop);
    ATTACH(DosDateTimeToFileTime);
    ATTACH(DragDetect);
    ATTACH(DragObject);
    ATTACH(DrawAnimatedRects);
    ATTACH(DrawCaption);
    ATTACH(DrawEdge);
    ATTACH(DrawEscape);
    ATTACH(DrawFocusRect);
    ATTACH(DrawFrameControl);
    ATTACH(DrawIcon);
    ATTACH(DrawIconEx);
    ATTACH(DrawMenuBar);
    ATTACH(DrawStateA);
    ATTACH(DrawStateW);
    ATTACH(DrawTextA);
    ATTACH(DrawTextExA);
    ATTACH(DrawTextExW);
    ATTACH(DrawTextW);
    ATTACH(DuplicateHandle);
    ATTACH(Ellipse);
    ATTACH(EmptyClipboard);
    ATTACH(EnableMenuItem);
    ATTACH(EnableScrollBar);
    ATTACH(EnableWindow);
    ATTACH(EndDeferWindowPos);
    ATTACH(EndDialog);
    ATTACH(EndDoc);
    ATTACH(EndPage);
    ATTACH(EndPaint);
    ATTACH(EndPath);
    ATTACH(EndUpdateResourceA);
    ATTACH(EndUpdateResourceW);
    ATTACH(EnumCalendarInfoA);
    ATTACH(EnumCalendarInfoW);
    ATTACH(EnumChildWindows);
    ATTACH(EnumClipboardFormats);
    ATTACH(EnumDateFormatsA);
    ATTACH(EnumDateFormatsW);
    ATTACH(EnumDesktopWindows);
    ATTACH(EnumDesktopsA);
    ATTACH(EnumDesktopsW);
    ATTACH(EnumDisplaySettingsA);
    ATTACH(EnumDisplaySettingsW);
    ATTACH(EnumEnhMetaFile);
    ATTACH(EnumFontFamiliesA);
    ATTACH(EnumFontFamiliesExA);
    ATTACH(EnumFontFamiliesExW);
    ATTACH(EnumFontFamiliesW);
    ATTACH(EnumFontsA);
    ATTACH(EnumFontsW);
    ATTACH(EnumICMProfilesA);
    ATTACH(EnumICMProfilesW);
    ATTACH(EnumMetaFile);
    ATTACH(EnumObjects);
    ATTACH(EnumPropsA);
    ATTACH(EnumPropsExA);
    ATTACH(EnumPropsExW);
    ATTACH(EnumPropsW);
    ATTACH(EnumResourceLanguagesA);
    ATTACH(EnumResourceLanguagesW);
    ATTACH(EnumResourceNamesA);
    ATTACH(EnumResourceNamesW);
    ATTACH(EnumResourceTypesA);
    ATTACH(EnumResourceTypesW);
    ATTACH(EnumSystemCodePagesA);
    ATTACH(EnumSystemCodePagesW);
#if(WINVER >= 0x0500)
    ATTACH(EnumSystemLocalesA);
    ATTACH(EnumSystemLocalesW);
#endif // (WINVER >= 0x0500)
    ATTACH(EnumThreadWindows);
    ATTACH(EnumTimeFormatsA);
    ATTACH(EnumTimeFormatsW);
    ATTACH(EnumWindowStationsA);
    ATTACH(EnumWindowStationsW);
    ATTACH(EnumWindows);
    ATTACH(EqualRect);
    ATTACH(EqualRgn);
    ATTACH(EraseTape);
    ATTACH(Escape);
    ATTACH(EscapeCommFunction);
    ATTACH(ExcludeClipRect);
    ATTACH(ExcludeUpdateRgn);
    ATTACH(ExitProcess);
    ATTACH(ExitThread);
    ATTACH(ExitWindowsEx);
    ATTACH(ExpandEnvironmentStringsA);
    ATTACH(ExpandEnvironmentStringsW);
    ATTACH(ExtCreatePen);
    ATTACH(ExtCreateRegion);
    ATTACH(ExtEscape);
    ATTACH(ExtFloodFill);
    ATTACH(ExtSelectClipRgn);
    ATTACH(ExtTextOutA);
    ATTACH(ExtTextOutW);
    ATTACH(FatalAppExitA);
    ATTACH(FatalAppExitW);
    ATTACH(FatalExit);
    ATTACH(FileTimeToDosDateTime);
    ATTACH(FileTimeToLocalFileTime);
    ATTACH(FileTimeToSystemTime);
    ATTACH(FillConsoleOutputAttribute);
    ATTACH(FillConsoleOutputCharacterA);
    ATTACH(FillConsoleOutputCharacterW);
    ATTACH(FillPath);
    ATTACH(FillRect);
    ATTACH(FillRgn);
    ATTACH(FindAtomA);
    ATTACH(FindAtomW);
    ATTACH(FindClose);
    ATTACH(FindCloseChangeNotification);
    ATTACH(FindFirstChangeNotificationA);
    ATTACH(FindFirstChangeNotificationW);
    ATTACH(FindFirstFileA);
    ATTACH(FindFirstFileExA);
    ATTACH(FindFirstFileExW);
    ATTACH(FindFirstFileW);
    ATTACH(FindNextChangeNotification);
    ATTACH(FindNextFileA);
    ATTACH(FindNextFileW);
    ATTACH(FindResourceA);
    ATTACH(FindResourceExA);
    ATTACH(FindResourceExW);
    ATTACH(FindResourceW);
    ATTACH(FindWindowA);
    ATTACH(FindWindowExA);
    ATTACH(FindWindowExW);
    ATTACH(FindWindowW);
    ATTACH(FixBrushOrgEx);
    ATTACH(FlashWindow);
    ATTACH(FlattenPath);
    ATTACH(FloodFill);
    ATTACH(FlushConsoleInputBuffer);
    ATTACH(FlushFileBuffers);
    ATTACH(FlushViewOfFile);
    ATTACH(FmtIdToPropStgName);
    ATTACH(FoldStringA);
    ATTACH(FoldStringW);
    ATTACH(FormatMessageA);
    ATTACH(FormatMessageW);
    ATTACH(FrameRect);
    ATTACH(FrameRgn);
    ATTACH(FreeConsole);
    ATTACH(FreeDDElParam);
    ATTACH(FreeEnvironmentStringsA);
    ATTACH(FreeEnvironmentStringsW);
    ATTACH(FreeLibrary);
    ATTACH(FreeLibraryAndExitThread);
    ATTACH(FreePropVariantArray);
    ATTACH(FreeResource);
    ATTACH(GdiComment);
    ATTACH(GdiFlush);
    ATTACH(GdiGetBatchLimit);
    ATTACH(GdiSetBatchLimit);
    ATTACH(GenerateConsoleCtrlEvent);
    ATTACH(GetACP);
    ATTACH(GetActiveWindow);
    ATTACH(GetArcDirection);
    ATTACH(GetAspectRatioFilterEx);
    ATTACH(GetAsyncKeyState);
    ATTACH(GetAtomNameA);
    ATTACH(GetAtomNameW);
    ATTACH(GetBinaryTypeA);
    ATTACH(GetBinaryTypeW);
    ATTACH(GetBitmapBits);
    ATTACH(GetBitmapDimensionEx);
    ATTACH(GetBkColor);
    ATTACH(GetBkMode);
    ATTACH(GetBoundsRect);
    ATTACH(GetBrushOrgEx);
    ATTACH(GetCPInfo);
    ATTACH(GetCapture);
    ATTACH(GetCaretBlinkTime);
    ATTACH(GetCaretPos);
    ATTACH(GetCharABCWidthsA);
    ATTACH(GetCharABCWidthsFloatA);
    ATTACH(GetCharABCWidthsFloatW);
    ATTACH(GetCharABCWidthsW);
    ATTACH(GetCharWidth32A);
    ATTACH(GetCharWidth32W);
    ATTACH(GetCharWidthA);
    ATTACH(GetCharWidthFloatA);
    ATTACH(GetCharWidthFloatW);
    ATTACH(GetCharWidthW);
    ATTACH(GetCharacterPlacementA);
    ATTACH(GetCharacterPlacementW);
    ATTACH(GetClassFile);
    ATTACH(GetClassInfoA);
    ATTACH(GetClassInfoExA);
    ATTACH(GetClassInfoExW);
    ATTACH(GetClassInfoW);
    ATTACH(GetClassLongA);
    ATTACH(GetClassLongW);
    ATTACH(GetClassNameA);
    ATTACH(GetClassNameW);
    ATTACH(GetClassWord);
    ATTACH(GetClientRect);
    ATTACH(GetClipBox);
    ATTACH(GetClipCursor);
    ATTACH(GetClipRgn);
    ATTACH(GetClipboardData);
    ATTACH(GetClipboardFormatNameA);
    ATTACH(GetClipboardFormatNameW);
    ATTACH(GetClipboardOwner);
    ATTACH(GetClipboardViewer);
    ATTACH(GetColorAdjustment);
    ATTACH(GetColorSpace);
    ATTACH(GetCommConfig);
    ATTACH(GetCommMask);
    ATTACH(GetCommModemStatus);
    ATTACH(GetCommProperties);
    ATTACH(GetCommState);
    ATTACH(GetCommTimeouts);
    ATTACH(GetCommandLineA);
    ATTACH(GetCommandLineW);
    ATTACH(GetComputerNameA);
    ATTACH(GetComputerNameW);
    ATTACH(GetConsoleCP);
    ATTACH(GetConsoleCursorInfo);
    ATTACH(GetConsoleMode);
    ATTACH(GetConsoleOutputCP);
    ATTACH(GetConsoleScreenBufferInfo);
    ATTACH(GetConsoleTitleA);
    ATTACH(GetConsoleTitleW);
    ATTACH(GetConvertStg);
    ATTACH(GetCurrencyFormatA);
    ATTACH(GetCurrencyFormatW);
    ATTACH(GetCurrentDirectoryA);
    ATTACH(GetCurrentDirectoryW);
    ATTACH(GetCurrentObject);
    ATTACH(GetCurrentPositionEx);
    ATTACH(GetCurrentProcess);
    ATTACH(GetCurrentProcessId);
    ATTACH(GetCurrentThreadId);
    ATTACH(GetCursor);
    ATTACH(GetCursorPos);
    ATTACH(GetDC);
    ATTACH(GetDCEx);
    ATTACH(GetDCOrgEx);
    ATTACH(GetDIBColorTable);
    ATTACH(GetDIBits);
    ATTACH(GetDateFormatA);
    ATTACH(GetDateFormatW);
    ATTACH(GetDefaultCommConfigA);
    ATTACH(GetDefaultCommConfigW);
    ATTACH(GetDesktopWindow);
    ATTACH(GetDeviceCaps);
    ATTACH(GetDeviceGammaRamp);
    ATTACH(GetDialogBaseUnits);
    ATTACH(GetDiskFreeSpaceA);
    ATTACH(GetDiskFreeSpaceExA);
    ATTACH(GetDiskFreeSpaceExW);
    ATTACH(GetDiskFreeSpaceW);
    ATTACH(GetDlgCtrlID);
    ATTACH(GetDlgItem);
    ATTACH(GetDlgItemInt);
    ATTACH(GetDlgItemTextA);
    ATTACH(GetDlgItemTextW);
    ATTACH(GetDoubleClickTime);
    ATTACH(GetDriveTypeA);
    ATTACH(GetDriveTypeW);
    ATTACH(GetEnhMetaFileA);
    ATTACH(GetEnhMetaFileBits);
    ATTACH(GetEnhMetaFileDescriptionA);
    ATTACH(GetEnhMetaFileDescriptionW);
    ATTACH(GetEnhMetaFileHeader);
    ATTACH(GetEnhMetaFilePaletteEntries);
    ATTACH(GetEnhMetaFilePixelFormat);
    ATTACH(GetEnhMetaFileW);
    ATTACH(GetEnvironmentStrings);
    ATTACH(GetEnvironmentStringsW);
    ATTACH(GetEnvironmentVariableA);
    ATTACH(GetEnvironmentVariableW);
    ATTACH(GetExitCodeProcess);
    ATTACH(GetExitCodeThread);
    ATTACH(GetFileAttributesA);
    ATTACH(GetFileAttributesExA);
    ATTACH(GetFileAttributesExW);
    ATTACH(GetFileAttributesW);
    ATTACH(GetFileInformationByHandle);
    ATTACH(GetFileSize);
    ATTACH(GetFileTime);
    ATTACH(GetFileType);
    ATTACH(GetFocus);
    ATTACH(GetFontData);
    ATTACH(GetFontLanguageInfo);
    ATTACH(GetForegroundWindow);
    ATTACH(GetFullPathNameA);
    ATTACH(GetFullPathNameW);
    ATTACH(GetGlyphOutlineA);
    ATTACH(GetGlyphOutlineW);
    ATTACH(GetGraphicsMode);
    ATTACH(GetHGlobalFromILockBytes);
    ATTACH(GetHGlobalFromStream);
    ATTACH(GetHandleInformation);
    ATTACH(GetICMProfileA);
    ATTACH(GetICMProfileW);
    ATTACH(GetIconInfo);
    ATTACH(GetInputState);
    ATTACH(GetKBCodePage);
    ATTACH(GetKerningPairsA);
    ATTACH(GetKerningPairsW);
    ATTACH(GetKeyNameTextA);
    ATTACH(GetKeyNameTextW);
    ATTACH(GetKeyState);
    ATTACH(GetKeyboardLayout);
    ATTACH(GetKeyboardLayoutList);
    ATTACH(GetKeyboardLayoutNameA);
    ATTACH(GetKeyboardLayoutNameW);
    ATTACH(GetKeyboardState);
    ATTACH(GetKeyboardType);
    ATTACH(GetLastActivePopup);
    ATTACH(GetLocalTime);
    ATTACH(GetLocaleInfoA);
    ATTACH(GetLocaleInfoW);
    ATTACH(GetLogColorSpaceA);
    ATTACH(GetLogColorSpaceW);
    ATTACH(GetLogicalDriveStringsA);
    ATTACH(GetLogicalDriveStringsW);
    ATTACH(GetLogicalDrives);
    ATTACH(GetMailslotInfo);
    ATTACH(GetMapMode);
    ATTACH(GetMenu);
    ATTACH(GetMenuCheckMarkDimensions);
    ATTACH(GetMenuContextHelpId);
    ATTACH(GetMenuDefaultItem);
    ATTACH(GetMenuItemCount);
    ATTACH(GetMenuItemID);
    ATTACH(GetMenuItemInfoA);
    ATTACH(GetMenuItemInfoW);
    ATTACH(GetMenuItemRect);
    ATTACH(GetMenuState);
    ATTACH(GetMenuStringA);
    ATTACH(GetMenuStringW);
    ATTACH(GetMessageA);
    ATTACH(GetMessageExtraInfo);
    ATTACH(GetMessagePos);
    ATTACH(GetMessageTime);
    ATTACH(GetMessageW);
    ATTACH(GetMetaFileA);
    ATTACH(GetMetaFileBitsEx);
    ATTACH(GetMetaFileW);
    ATTACH(GetMetaRgn);
    ATTACH(GetMiterLimit);
    ATTACH(GetModuleFileNameA);
    ATTACH(GetModuleFileNameW);
    ATTACH(GetModuleHandleA);
    ATTACH(GetModuleHandleW);
    ATTACH(GetNamedPipeHandleStateA);
    ATTACH(GetNamedPipeHandleStateW);
    ATTACH(GetNamedPipeInfo);
    ATTACH(GetNearestColor);
    ATTACH(GetNearestPaletteIndex);
    ATTACH(GetNextDlgGroupItem);
    ATTACH(GetNextDlgTabItem);
    ATTACH(GetNumberFormatA);
    ATTACH(GetNumberFormatW);
    ATTACH(GetNumberOfConsoleInputEvents);
    ATTACH(GetNumberOfConsoleMouseButtons);
    ATTACH(GetOEMCP);
    ATTACH(GetObjectA);
    ATTACH(GetObjectType);
    ATTACH(GetObjectW);
    ATTACH(GetOpenClipboardWindow);
    ATTACH(GetOutlineTextMetricsA);
    ATTACH(GetOutlineTextMetricsW);
    ATTACH(GetOverlappedResult);
    ATTACH(GetPaletteEntries);
    ATTACH(GetParent);
    ATTACH(GetPath);
    ATTACH(GetPixel);
    ATTACH(GetPixelFormat);
    ATTACH(GetPolyFillMode);
    ATTACH(GetPriorityClass);
    ATTACH(GetPriorityClipboardFormat);
    ATTACH(GetPrivateProfileIntA);
    ATTACH(GetPrivateProfileIntW);
    ATTACH(GetPrivateProfileSectionA);
    ATTACH(GetPrivateProfileSectionNamesA);
    ATTACH(GetPrivateProfileSectionNamesW);
    ATTACH(GetPrivateProfileSectionW);
    ATTACH(GetPrivateProfileStringA);
    ATTACH(GetPrivateProfileStringW);
    ATTACH(GetPrivateProfileStructA);
    ATTACH(GetPrivateProfileStructW);
    ATTACH(GetProcAddress);
    ATTACH(GetProcessAffinityMask);
    ATTACH(GetProcessHeaps);
    ATTACH(GetProcessShutdownParameters);
    ATTACH(GetProcessTimes);
    ATTACH(GetProcessVersion);
    ATTACH(GetProcessWindowStation);
    ATTACH(GetProcessWorkingSetSize);
    ATTACH(GetProfileIntA);
    ATTACH(GetProfileIntW);
    ATTACH(GetProfileSectionA);
    ATTACH(GetProfileSectionW);
    ATTACH(GetProfileStringA);
    ATTACH(GetProfileStringW);
    ATTACH(GetPropA);
    ATTACH(GetPropW);
    ATTACH(GetQueueStatus);
    ATTACH(GetQueuedCompletionStatus);
    ATTACH(GetROP2);
    ATTACH(GetRasterizerCaps);
    ATTACH(GetRegionData);
    ATTACH(GetRgnBox);
    ATTACH(GetRunningObjectTable);
    ATTACH(GetScrollInfo);
    ATTACH(GetScrollPos);
    ATTACH(GetScrollRange);
    ATTACH(GetShortPathNameA);
    ATTACH(GetShortPathNameW);
    ATTACH(GetStartupInfoA);
    ATTACH(GetStartupInfoW);
    ATTACH(GetStdHandle);
    ATTACH(GetStockObject);
    ATTACH(GetStretchBltMode);
    ATTACH(GetSubMenu);
    ATTACH(GetSysColor);
    ATTACH(GetSysColorBrush);
    ATTACH(GetSystemDefaultLCID);
    ATTACH(GetSystemDefaultLangID);
    ATTACH(GetSystemDirectoryA);
    ATTACH(GetSystemDirectoryW);
    ATTACH(GetSystemInfo);
    ATTACH(GetSystemMenu);
    ATTACH(GetSystemMetrics);
    ATTACH(GetSystemPaletteEntries);
    ATTACH(GetSystemPaletteUse);
    ATTACH(GetSystemPowerStatus);
    ATTACH(GetSystemTime);
    ATTACH(GetSystemTimeAdjustment);
    ATTACH(GetSystemTimeAsFileTime);
    ATTACH(GetTabbedTextExtentA);
    ATTACH(GetTabbedTextExtentW);
    ATTACH(GetTapeParameters);
    ATTACH(GetTapePosition);
    ATTACH(GetTapeStatus);
    ATTACH(GetTempFileNameA);
    ATTACH(GetTempFileNameW);
    ATTACH(GetTempPathA);
    ATTACH(GetTempPathW);
    ATTACH(GetTextAlign);
    ATTACH(GetTextCharacterExtra);
    ATTACH(GetTextCharset);
    ATTACH(GetTextCharsetInfo);
    ATTACH(GetTextColor);
    ATTACH(GetTextExtentExPointA);
    ATTACH(GetTextExtentExPointW);
    ATTACH(GetTextExtentPoint32A);
    ATTACH(GetTextExtentPoint32W);
    ATTACH(GetTextExtentPointA);
    ATTACH(GetTextExtentPointW);
    ATTACH(GetTextFaceA);
    ATTACH(GetTextFaceW);
    ATTACH(GetTextMetricsA);
    ATTACH(GetTextMetricsW);
    ATTACH(GetThreadContext);
    ATTACH(GetThreadDesktop);
#if(WINVER >= 0x0500)
    ATTACH(GetThreadLocale);
#endif // (WINVER >= 0x0500)
    ATTACH(GetThreadPriority);
    ATTACH(GetThreadPriorityBoost);
    ATTACH(GetThreadSelectorEntry);
    ATTACH(GetThreadTimes);
    ATTACH(GetTickCount);
    ATTACH(GetTimeFormatA);
    ATTACH(GetTimeFormatW);
    ATTACH(GetTimeZoneInformation);
    ATTACH(GetTopWindow);
    ATTACH(GetUpdateRect);
    ATTACH(GetUpdateRgn);
    ATTACH(GetUserDefaultLCID);
    ATTACH(GetUserDefaultLangID);
    ATTACH(GetUserObjectInformationA);
    ATTACH(GetUserObjectInformationW);
    ATTACH(GetUserObjectSecurity);
    ATTACH(GetVersion);
    ATTACH(GetVersionExA);
    ATTACH(GetVersionExW);
    ATTACH(GetViewportExtEx);
    ATTACH(GetViewportOrgEx);
    ATTACH(GetVolumeInformationA);
    ATTACH(GetVolumeInformationW);
    ATTACH(GetWinMetaFileBits);
    ATTACH(GetWindow);
    ATTACH(GetWindowContextHelpId);
    ATTACH(GetWindowDC);
    ATTACH(GetWindowExtEx);
    ATTACH(GetWindowLongA);
    ATTACH(GetWindowLongW);
    ATTACH(GetWindowOrgEx);
    ATTACH(GetWindowPlacement);
    ATTACH(GetWindowRect);
    ATTACH(GetWindowRgn);
    ATTACH(GetWindowTextA);
    ATTACH(GetWindowTextLengthA);
    ATTACH(GetWindowTextLengthW);
    ATTACH(GetWindowTextW);
    ATTACH(GetWindowThreadProcessId);
    ATTACH(GetWindowWord);
    ATTACH(GetWindowsDirectoryA);
    ATTACH(GetWindowsDirectoryW);
    ATTACH(GetWorldTransform);
    ATTACH(GlobalAddAtomA);
    ATTACH(GlobalAddAtomW);
    ATTACH(GlobalAlloc);
    ATTACH(GlobalCompact);
    ATTACH(GlobalDeleteAtom);
    ATTACH(GlobalFindAtomA);
    ATTACH(GlobalFindAtomW);
    ATTACH(GlobalFix);
    ATTACH(GlobalFlags);
    ATTACH(GlobalFree);
    ATTACH(GlobalGetAtomNameA);
    ATTACH(GlobalGetAtomNameW);
    ATTACH(GlobalHandle);
    ATTACH(GlobalLock);
    ATTACH(GlobalMemoryStatus);
    ATTACH(GlobalReAlloc);
    ATTACH(GlobalSize);
    ATTACH(GlobalUnWire);
    ATTACH(GlobalUnfix);
    ATTACH(GlobalUnlock);
    ATTACH(GlobalWire);
    ATTACH(GrayStringA);
    ATTACH(GrayStringW);
    ATTACH(HeapLock);
    ATTACH(HeapUnlock);
    ATTACH(HideCaret);
    ATTACH(HiliteMenuItem);
    ATTACH(IIDFromString);
    ATTACH(ImpersonateDdeClientWindow);
    ATTACH(InSendMessage);
    ATTACH(InflateRect);
    ATTACH(InitAtomTable);
    ATTACH(InsertMenuA);
    ATTACH(InsertMenuItemA);
    ATTACH(InsertMenuItemW);
    ATTACH(InsertMenuW);
    ATTACH(IntersectClipRect);
    ATTACH(IntersectRect);
    ATTACH(InvalidateRect);
    ATTACH(InvalidateRgn);
    ATTACH(InvertRect);
    ATTACH(InvertRgn);
    ATTACH(IsAccelerator);
    ATTACH(IsBadCodePtr);
    ATTACH(IsBadHugeReadPtr);
    ATTACH(IsBadHugeWritePtr);
    ATTACH(IsBadReadPtr);
    ATTACH(IsBadStringPtrA);
    ATTACH(IsBadStringPtrW);
    ATTACH(IsBadWritePtr);
    ATTACH(IsCharAlphaA);
    ATTACH(IsCharAlphaNumericA);
    ATTACH(IsCharAlphaNumericW);
    ATTACH(IsCharAlphaW);
    ATTACH(IsCharLowerA);
    ATTACH(IsCharLowerW);
    ATTACH(IsCharUpperA);
    ATTACH(IsCharUpperW);
    ATTACH(IsChild);
    ATTACH(IsClipboardFormatAvailable);
    ATTACH(IsDBCSLeadByte);
    ATTACH(IsDBCSLeadByteEx);
    ATTACH(IsDebuggerPresent);
    ATTACH(IsDialogMessageA);
    ATTACH(IsDialogMessageW);
    ATTACH(IsDlgButtonChecked);
    ATTACH(IsIconic);
    ATTACH(IsMenu);
#if !defined(DETOURS_ARM)
    ATTACH(IsProcessorFeaturePresent);
#endif // !DETOURS_ARM
    ATTACH(IsRectEmpty);
    ATTACH(IsValidCodePage);
    ATTACH(IsValidLocale);
    ATTACH(IsWindow);
    ATTACH(IsWindowEnabled);
    ATTACH(IsWindowUnicode);
    ATTACH(IsWindowVisible);
    ATTACH(IsZoomed);
    ATTACH(KillTimer);
    ATTACH(LPtoDP);
    ATTACH(LineDDA);
    ATTACH(LineTo);
    ATTACH(LoadAcceleratorsA);
    ATTACH(LoadAcceleratorsW);
    ATTACH(LoadBitmapA);
    ATTACH(LoadBitmapW);
    ATTACH(LoadCursorA);
    ATTACH(LoadCursorFromFileA);
    ATTACH(LoadCursorFromFileW);
    ATTACH(LoadCursorW);
    ATTACH(LoadIconA);
    ATTACH(LoadIconW);
    ATTACH(LoadImageA);
    ATTACH(LoadImageW);
    ATTACH(LoadKeyboardLayoutA);
    ATTACH(LoadKeyboardLayoutW);
    ATTACH(LoadLibraryA);
    ATTACH(LoadLibraryExA);
    ATTACH(LoadLibraryExW);
    ATTACH(LoadLibraryW);
    ATTACH(LoadMenuA);
    ATTACH(LoadMenuIndirectA);
    ATTACH(LoadMenuIndirectW);
    ATTACH(LoadMenuW);
    ATTACH(LoadModule);
    ATTACH(LoadResource);
    ATTACH(LoadStringA);
    ATTACH(LoadStringW);
    ATTACH(LocalAlloc);
    ATTACH(LocalCompact);
    ATTACH(LocalFileTimeToFileTime);
    ATTACH(LocalFlags);
    ATTACH(LocalFree);
    ATTACH(LocalHandle);
    ATTACH(LocalLock);
    ATTACH(LocalReAlloc);
    ATTACH(LocalShrink);
    ATTACH(LocalSize);
    ATTACH(LocalUnlock);
    ATTACH(LockFile);
    ATTACH(LockFileEx);
    ATTACH(LockResource);
    ATTACH(LockWindowUpdate);
    ATTACH(LookupIconIdFromDirectory);
    ATTACH(LookupIconIdFromDirectoryEx);
    ATTACH(MapDialogRect);
    ATTACH(MapViewOfFile);
    ATTACH(MapViewOfFileEx);
    ATTACH(MapVirtualKeyA);
    ATTACH(MapVirtualKeyExA);
    ATTACH(MapVirtualKeyExW);
    ATTACH(MapVirtualKeyW);
    ATTACH(MapWindowPoints);
    ATTACH(MaskBlt);
    ATTACH(MenuItemFromPoint);
    ATTACH(MessageBeep);
    ATTACH(MessageBoxA);
    ATTACH(MessageBoxExA);
    ATTACH(MessageBoxExW);
    ATTACH(MessageBoxIndirectA);
    ATTACH(MessageBoxIndirectW);
    ATTACH(MessageBoxW);
    ATTACH(MkParseDisplayName);
    ATTACH(ModifyMenuA);
    ATTACH(ModifyMenuW);
    ATTACH(ModifyWorldTransform);
    ATTACH(MonikerCommonPrefixWith);
    ATTACH(MonikerRelativePathTo);
    ATTACH(MoveFileA);
    ATTACH(MoveFileExA);
    ATTACH(MoveFileExW);
    ATTACH(MoveFileW);
    ATTACH(MoveToEx);
    ATTACH(MoveWindow);
    ATTACH(MsgWaitForMultipleObjects);
    ATTACH(MsgWaitForMultipleObjectsEx);
    ATTACH(MulDiv);
    ATTACH(OemKeyScan);
    ATTACH(OemToCharA);
    ATTACH(OemToCharBuffA);
    ATTACH(OemToCharBuffW);
    ATTACH(OemToCharW);
    ATTACH(OffsetClipRgn);
    ATTACH(OffsetRect);
    ATTACH(OffsetRgn);
    ATTACH(OffsetViewportOrgEx);
    ATTACH(OffsetWindowOrgEx);
    ATTACH(OleBuildVersion);
    ATTACH(OleConvertIStorageToOLESTREAM);
    ATTACH(OleConvertIStorageToOLESTREAMEx);
    ATTACH(OleConvertOLESTREAMToIStorage);
    ATTACH(OleConvertOLESTREAMToIStorageEx);
    ATTACH(OleCreate);
    ATTACH(OleCreateDefaultHandler);
    ATTACH(OleCreateEmbeddingHelper);
    ATTACH(OleCreateEx);
    ATTACH(OleCreateFromData);
    ATTACH(OleCreateFromDataEx);
    ATTACH(OleCreateFromFile);
    ATTACH(OleCreateFromFileEx);
    ATTACH(OleCreateLink);
    ATTACH(OleCreateLinkEx);
    ATTACH(OleCreateLinkFromData);
    ATTACH(OleCreateLinkFromDataEx);
    ATTACH(OleCreateLinkToFile);
    ATTACH(OleCreateLinkToFileEx);
    ATTACH(OleCreateMenuDescriptor);
    ATTACH(OleCreateStaticFromData);
    ATTACH(OleDestroyMenuDescriptor);
    ATTACH(OleDoAutoConvert);
    ATTACH(OleDraw);
    ATTACH(OleDuplicateData);
    ATTACH(OleFlushClipboard);
    ATTACH(OleGetAutoConvert);
    ATTACH(OleGetClipboard);
    ATTACH(OleGetIconOfClass);
    ATTACH(OleGetIconOfFile);
    ATTACH(OleInitialize);
    ATTACH(OleIsCurrentClipboard);
    ATTACH(OleIsRunning);
    ATTACH(OleLoad);
    ATTACH(OleLoadFromStream);
    ATTACH(OleLockRunning);
    ATTACH(OleMetafilePictFromIconAndLabel);
    ATTACH(OleNoteObjectVisible);
    ATTACH(OleQueryCreateFromData);
    ATTACH(OleQueryLinkFromData);
    ATTACH(OleRegEnumFormatEtc);
    ATTACH(OleRegEnumVerbs);
    ATTACH(OleRegGetMiscStatus);
    ATTACH(OleRegGetUserType);
    ATTACH(OleRun);
    ATTACH(OleSave);
    ATTACH(OleSaveToStream);
    ATTACH(OleSetAutoConvert);
    ATTACH(OleSetClipboard);
    ATTACH(OleSetContainedObject);
    ATTACH(OleSetMenuDescriptor);
    ATTACH(OleTranslateAccelerator);
    ATTACH(OleUninitialize);
    ATTACH(OpenClipboard);
    ATTACH(OpenDesktopA);
    ATTACH(OpenDesktopW);
    ATTACH(OpenEventA);
    ATTACH(OpenEventW);
    ATTACH(OpenFile);
    ATTACH(OpenFileMappingA);
    ATTACH(OpenFileMappingW);
    ATTACH(OpenIcon);
    ATTACH(OpenInputDesktop);
    ATTACH(OpenMutexA);
    ATTACH(OpenMutexW);
    ATTACH(OpenProcess);
    ATTACH(OpenProcessToken);
    ATTACH(OpenSemaphoreA);
    ATTACH(OpenSemaphoreW);
    ATTACH(OpenWaitableTimerA);
    ATTACH(OpenWaitableTimerW);
    ATTACH(OpenWindowStationA);
    ATTACH(OpenWindowStationW);
    ATTACH(OutputDebugStringA);
    ATTACH(OutputDebugStringW);
    ATTACH(PackDDElParam);
    ATTACH(PaintDesktop);
    ATTACH(PaintRgn);
    ATTACH(PatBlt);
    ATTACH(PathToRegion);
    ATTACH(PeekConsoleInputA);
    ATTACH(PeekConsoleInputW);
    ATTACH(PeekMessageA);
    ATTACH(PeekMessageW);
    ATTACH(PeekNamedPipe);
    ATTACH(Pie);
    ATTACH(PlayEnhMetaFile);
    ATTACH(PlayEnhMetaFileRecord);
    ATTACH(PlayMetaFile);
    ATTACH(PlayMetaFileRecord);
    ATTACH(PlgBlt);
    ATTACH(PolyBezier);
    ATTACH(PolyBezierTo);
    ATTACH(PolyDraw);
    ATTACH(PolyPolygon);
    ATTACH(PolyPolyline);
    ATTACH(PolyTextOutA);
    ATTACH(PolyTextOutW);
    ATTACH(Polygon);
    ATTACH(Polyline);
    ATTACH(PolylineTo);
    ATTACH(PostMessageA);
    ATTACH(PostMessageW);
    ATTACH(PostQueuedCompletionStatus);
    ATTACH(PostQuitMessage);
    ATTACH(PostThreadMessageA);
    ATTACH(PostThreadMessageW);
    ATTACH(PrepareTape);
    ATTACH(ProgIDFromCLSID);
    ATTACH(PropVariantClear);
    ATTACH(PropVariantCopy);
    ATTACH(PtInRect);
    ATTACH(PtInRegion);
    ATTACH(PtVisible);
    ATTACH(PulseEvent);
    ATTACH(PurgeComm);
    ATTACH(QueryDosDeviceA);
    ATTACH(QueryDosDeviceW);
    ATTACH(QueryPerformanceCounter);
    ATTACH(QueryPerformanceFrequency);
    ATTACH(QueueUserAPC);
    ATTACH(RaiseException);
    ATTACH(ReadClassStg);
    ATTACH(ReadClassStm);
    ATTACH(ReadConsoleA);
    ATTACH(ReadConsoleInputA);
    ATTACH(ReadConsoleInputW);
    ATTACH(ReadConsoleOutputA);
    ATTACH(ReadConsoleOutputAttribute);
    ATTACH(ReadConsoleOutputCharacterA);
    ATTACH(ReadConsoleOutputCharacterW);
    ATTACH(ReadConsoleOutputW);
    ATTACH(ReadConsoleW);
    ATTACH(ReadDirectoryChangesW);
    ATTACH(ReadFile);
    ATTACH(ReadFileEx);
    ATTACH(ReadFmtUserTypeStg);
    ATTACH(ReadProcessMemory);
    ATTACH(RealizePalette);
    ATTACH(RectInRegion);
    ATTACH(RectVisible);
    ATTACH(Rectangle);
    ATTACH(RedrawWindow);
    ATTACH(RegisterClassA);
    ATTACH(RegisterClassExA);
    ATTACH(RegisterClassExW);
    ATTACH(RegisterClassW);
    ATTACH(RegisterClipboardFormatA);
    ATTACH(RegisterClipboardFormatW);
    ATTACH(RegisterDragDrop);
    ATTACH(RegisterHotKey);
    ATTACH(RegisterWindowMessageA);
    ATTACH(RegisterWindowMessageW);
    ATTACH(ReleaseCapture);
    ATTACH(ReleaseDC);
    ATTACH(ReleaseMutex);
    ATTACH(ReleaseSemaphore);
    ATTACH(ReleaseStgMedium);
    ATTACH(RemoveDirectoryA);
    ATTACH(RemoveDirectoryW);
    ATTACH(RemoveFontResourceA);
    ATTACH(RemoveFontResourceW);
    ATTACH(RemoveMenu);
    ATTACH(RemovePropA);
    ATTACH(RemovePropW);
    ATTACH(ReplyMessage);
    ATTACH(ResetDCA);
    ATTACH(ResetDCW);
    ATTACH(ResetEvent);
    ATTACH(ResizePalette);
    ATTACH(RestoreDC);
    ATTACH(ResumeThread);
    ATTACH(ReuseDDElParam);
    ATTACH(RevokeDragDrop);
    ATTACH(RoundRect);
    ATTACH(SaveDC);
    ATTACH(ScaleViewportExtEx);
    ATTACH(ScaleWindowExtEx);
    ATTACH(ScreenToClient);
    ATTACH(ScrollConsoleScreenBufferA);
    ATTACH(ScrollConsoleScreenBufferW);
    ATTACH(ScrollDC);
    ATTACH(ScrollWindow);
    ATTACH(ScrollWindowEx);
    ATTACH(SearchPathA);
    ATTACH(SearchPathW);
    ATTACH(SelectClipPath);
    ATTACH(SelectClipRgn);
    ATTACH(SelectObject);
    ATTACH(SelectPalette);
    ATTACH(SendDlgItemMessageA);
    ATTACH(SendDlgItemMessageW);
    ATTACH(SendMessageA);
    ATTACH(SendMessageCallbackA);
    ATTACH(SendMessageCallbackW);
    ATTACH(SendMessageTimeoutA);
    ATTACH(SendMessageTimeoutW);
    ATTACH(SendMessageW);
    ATTACH(SendNotifyMessageA);
    ATTACH(SendNotifyMessageW);
    ATTACH(SetAbortProc);
    ATTACH(SetActiveWindow);
    ATTACH(SetArcDirection);
    ATTACH(SetBitmapBits);
    ATTACH(SetBitmapDimensionEx);
    ATTACH(SetBkColor);
    ATTACH(SetBkMode);
    ATTACH(SetBoundsRect);
    ATTACH(SetBrushOrgEx);
    ATTACH(SetCapture);
    ATTACH(SetCaretBlinkTime);
    ATTACH(SetCaretPos);
    ATTACH(SetClassLongA);
    ATTACH(SetClassLongW);
    ATTACH(SetClassWord);
    ATTACH(SetClipboardData);
    ATTACH(SetClipboardViewer);
    ATTACH(SetColorAdjustment);
    ATTACH(SetColorSpace);
    ATTACH(SetCommBreak);
    ATTACH(SetCommConfig);
    ATTACH(SetCommMask);
    ATTACH(SetCommState);
    ATTACH(SetCommTimeouts);
    ATTACH(SetComputerNameA);
    ATTACH(SetComputerNameW);
    ATTACH(SetConsoleActiveScreenBuffer);
    ATTACH(SetConsoleCP);
    ATTACH(SetConsoleCtrlHandler);
    ATTACH(SetConsoleCursorInfo);
    ATTACH(SetConsoleCursorPosition);
    ATTACH(SetConsoleMode);
    ATTACH(SetConsoleOutputCP);
    ATTACH(SetConsoleScreenBufferSize);
    ATTACH(SetConsoleTextAttribute);
    ATTACH(SetConsoleTitleA);
    ATTACH(SetConsoleTitleW);
    ATTACH(SetConsoleWindowInfo);
    ATTACH(SetConvertStg);
    ATTACH(SetCurrentDirectoryA);
    ATTACH(SetCurrentDirectoryW);
    ATTACH(SetCursor);
    ATTACH(SetCursorPos);
    ATTACH(SetDIBColorTable);
    ATTACH(SetDIBits);
    ATTACH(SetDIBitsToDevice);
    ATTACH(SetDefaultCommConfigA);
    ATTACH(SetDefaultCommConfigW);
    ATTACH(SetDeviceGammaRamp);
    ATTACH(SetDlgItemInt);
    ATTACH(SetDlgItemTextA);
    ATTACH(SetDlgItemTextW);
    ATTACH(SetDoubleClickTime);
    ATTACH(SetEndOfFile);
    ATTACH(SetEnhMetaFileBits);
    ATTACH(SetEnvironmentVariableA);
    ATTACH(SetEnvironmentVariableW);
    ATTACH(SetErrorMode);
    ATTACH(SetEvent);
    ATTACH(SetFileApisToANSI);
    ATTACH(SetFileApisToOEM);
    ATTACH(SetFileAttributesA);
    ATTACH(SetFileAttributesW);
    ATTACH(SetFilePointer);
    ATTACH(SetFileTime);
    ATTACH(SetFocus);
    ATTACH(SetForegroundWindow);
    ATTACH(SetGraphicsMode);
    ATTACH(SetHandleCount);
    ATTACH(SetHandleInformation);
    ATTACH(SetICMMode);
    ATTACH(SetICMProfileA);
    ATTACH(SetICMProfileW);
    ATTACH(SetKeyboardState);
    ATTACH(SetLocalTime);
    ATTACH(SetLocaleInfoA);
    ATTACH(SetLocaleInfoW);
    ATTACH(SetMailslotInfo);
    ATTACH(SetMapMode);
    ATTACH(SetMapperFlags);
    ATTACH(SetMenu);
    ATTACH(SetMenuContextHelpId);
    ATTACH(SetMenuDefaultItem);
    ATTACH(SetMenuItemBitmaps);
    ATTACH(SetMenuItemInfoA);
    ATTACH(SetMenuItemInfoW);
    ATTACH(SetMessageExtraInfo);
    ATTACH(SetMessageQueue);
    ATTACH(SetMetaFileBitsEx);
    ATTACH(SetMetaRgn);
    ATTACH(SetMiterLimit);
    ATTACH(SetNamedPipeHandleState);
    ATTACH(SetPaletteEntries);
    ATTACH(SetParent);
    ATTACH(SetPixel);
    ATTACH(SetPixelFormat);
    ATTACH(SetPixelV);
    ATTACH(SetPolyFillMode);
    ATTACH(SetPriorityClass);
    ATTACH(SetProcessAffinityMask);
    ATTACH(SetProcessShutdownParameters);
    ATTACH(SetProcessWindowStation);
    ATTACH(SetProcessWorkingSetSize);
    ATTACH(SetPropA);
    ATTACH(SetPropW);
    ATTACH(SetROP2);
    ATTACH(SetRect);
    ATTACH(SetRectEmpty);
    ATTACH(SetRectRgn);
    ATTACH(SetScrollInfo);
    ATTACH(SetScrollPos);
    ATTACH(SetScrollRange);
    ATTACH(SetStdHandle);
    ATTACH(SetStretchBltMode);
    ATTACH(SetSysColors);
    ATTACH(SetSystemCursor);
    ATTACH(SetSystemPaletteUse);
    ATTACH(SetSystemPowerState);
    ATTACH(SetSystemTime);
    ATTACH(SetSystemTimeAdjustment);
    ATTACH(SetTapeParameters);
    ATTACH(SetTapePosition);
    ATTACH(SetTextAlign);
    ATTACH(SetTextCharacterExtra);
    ATTACH(SetTextColor);
    ATTACH(SetTextJustification);
    ATTACH(SetThreadAffinityMask);
    ATTACH(SetThreadContext);
    ATTACH(SetThreadDesktop);
    ATTACH(SetThreadIdealProcessor);
#if(WINVER >= 0x0500)
    ATTACH(SetThreadLocale);
#endif // (WINVER >= 0x0500)
    ATTACH(SetThreadPriority);
    ATTACH(SetThreadPriorityBoost);
    ATTACH(SetTimeZoneInformation);
    ATTACH(SetTimer);
    ATTACH(SetUnhandledExceptionFilter);
    ATTACH(SetUserObjectInformationA);
    ATTACH(SetUserObjectInformationW);
    ATTACH(SetUserObjectSecurity);
    ATTACH(SetViewportExtEx);
    ATTACH(SetViewportOrgEx);
    ATTACH(SetVolumeLabelA);
    ATTACH(SetVolumeLabelW);
    ATTACH(SetWaitableTimer);
    ATTACH(SetWinMetaFileBits);
    ATTACH(SetWindowContextHelpId);
    ATTACH(SetWindowExtEx);
    ATTACH(SetWindowLongA);
    ATTACH(SetWindowLongW);
    ATTACH(SetWindowOrgEx);
    ATTACH(SetWindowPlacement);
    ATTACH(SetWindowPos);
    ATTACH(SetWindowRgn);
    ATTACH(SetWindowTextA);
    ATTACH(SetWindowTextW);
    ATTACH(SetWindowWord);
    ATTACH(SetWindowsHookA);
    ATTACH(SetWindowsHookExA);
    ATTACH(SetWindowsHookExW);
    ATTACH(SetWindowsHookW);
    ATTACH(SetWorldTransform);
    ATTACH(SetupComm);
    ATTACH(ShowCaret);
    ATTACH(ShowCursor);
    ATTACH(ShowOwnedPopups);
    ATTACH(ShowScrollBar);
    ATTACH(ShowWindow);
    ATTACH(ShowWindowAsync);
    ATTACH(SignalObjectAndWait);
    ATTACH(SizeofResource);
    ATTACH(SleepEx);
    ATTACH(StartDocA);
    ATTACH(StartDocW);
    ATTACH(StartPage);
    ATTACH(StgCreateDocfile);
    ATTACH(StgCreateDocfileOnILockBytes);
    ATTACH(StgCreatePropSetStg);
    ATTACH(StgCreatePropStg);
    ATTACH(StgCreateStorageEx);
    ATTACH(StgGetIFillLockBytesOnFile);
    ATTACH(StgGetIFillLockBytesOnILockBytes);
    ATTACH(StgIsStorageFile);
    ATTACH(StgIsStorageILockBytes);
    ATTACH(StgOpenAsyncDocfileOnIFillLockBytes);
    ATTACH(StgOpenPropStg);
    ATTACH(StgOpenStorage);
    ATTACH(StgOpenStorageEx);
    ATTACH(StgOpenStorageOnILockBytes);
    ATTACH(StgSetTimes);
    ATTACH(StretchBlt);
    ATTACH(StretchDIBits);
    ATTACH(StringFromCLSID);
    ATTACH(StringFromGUID2);
    ATTACH(StringFromIID);
    ATTACH(StrokeAndFillPath);
    ATTACH(StrokePath);
    ATTACH(SubtractRect);
    ATTACH(SuspendThread);
    ATTACH(SwapBuffers);
    ATTACH(SwapMouseButton);
    ATTACH(SwitchDesktop);
    ATTACH(SwitchToFiber);
    ATTACH(SwitchToThread);
    ATTACH(SystemParametersInfoA);
    ATTACH(SystemParametersInfoW);
    ATTACH(SystemTimeToFileTime);
    ATTACH(SystemTimeToTzSpecificLocalTime);
    ATTACH(TabbedTextOutA);
    ATTACH(TabbedTextOutW);
    ATTACH(TerminateProcess);
    ATTACH(TerminateThread);
    ATTACH(TextOutA);
    ATTACH(TextOutW);
    ATTACH(TileWindows);
    ATTACH(ToAscii);
    ATTACH(ToAsciiEx);
    ATTACH(ToUnicode);
    ATTACH(ToUnicodeEx);
    ATTACH(TrackMouseEvent);
    ATTACH(TrackPopupMenu);
    ATTACH(TrackPopupMenuEx);
    ATTACH(TransactNamedPipe);
    ATTACH(TranslateAcceleratorA);
    ATTACH(TranslateAcceleratorW);
    ATTACH(TranslateCharsetInfo);
    ATTACH(TranslateMDISysAccel);
    ATTACH(TranslateMessage);
    ATTACH(TransmitCommChar);
#if DETOUR_TryEnterCriticalSection_EVEN_IF_IT_EXERCISES_A_BUG_IN_RtlLookupFunctionTable
    ATTACH(TryEnterCriticalSection);
#endif
    ATTACH(UnhookWindowsHook);
    ATTACH(UnhookWindowsHookEx);
    ATTACH(UnionRect);
    ATTACH(UnloadKeyboardLayout);
    ATTACH(UnlockFile);
    ATTACH(UnlockFileEx);
    ATTACH(UnmapViewOfFile);
    ATTACH(UnpackDDElParam);
    ATTACH(UnrealizeObject);
    ATTACH(UnregisterClassA);
    ATTACH(UnregisterClassW);
    ATTACH(UnregisterHotKey);
    ATTACH(UpdateColors);
    ATTACH(UpdateResourceA);
    ATTACH(UpdateResourceW);
    ATTACH(UpdateWindow);
    ATTACH(ValidateRect);
    ATTACH(ValidateRgn);
    ATTACH(VerLanguageNameA);
    ATTACH(VerLanguageNameW);
    ATTACH(VirtualAllocEx);
    ATTACH(VirtualFreeEx);
    ATTACH(VirtualProtectEx);
    ATTACH(VirtualQueryEx);
    ATTACH(VkKeyScanA);
    ATTACH(VkKeyScanExA);
    ATTACH(VkKeyScanExW);
    ATTACH(VkKeyScanW);
    ATTACH(WSAAccept);
    ATTACH(WSAAddressToStringA);
    ATTACH(WSAAddressToStringW);
    ATTACH(WSAAsyncGetHostByAddr);
    ATTACH(WSAAsyncGetHostByName);
    ATTACH(WSAAsyncGetProtoByName);
    ATTACH(WSAAsyncGetProtoByNumber);
    ATTACH(WSAAsyncGetServByName);
    ATTACH(WSAAsyncGetServByPort);
    ATTACH(WSAAsyncSelect);
    ATTACH(WSACancelAsyncRequest);
    ATTACH(WSACancelBlockingCall);
    ATTACH(WSACleanup);
    ATTACH(WSACloseEvent);
    ATTACH(WSAConnect);
    ATTACH(WSACreateEvent);
    ATTACH(WSADuplicateSocketA);
    ATTACH(WSADuplicateSocketW);
    ATTACH(WSAEnumNameSpaceProvidersA);
    ATTACH(WSAEnumNameSpaceProvidersW);
    ATTACH(WSAEnumNetworkEvents);
    ATTACH(WSAEnumProtocolsA);
    ATTACH(WSAEnumProtocolsW);
    ATTACH(WSAEventSelect);
    ATTACH(WSAGetOverlappedResult);
    ATTACH(WSAGetQOSByName);
    ATTACH(WSAGetServiceClassInfoA);
    ATTACH(WSAGetServiceClassInfoW);
    ATTACH(WSAGetServiceClassNameByClassIdA);
    ATTACH(WSAGetServiceClassNameByClassIdW);
    ATTACH(WSAHtonl);
    ATTACH(WSAHtons);
    ATTACH(WSAInstallServiceClassA);
    ATTACH(WSAInstallServiceClassW);
    ATTACH(WSAIoctl);
    ATTACH(WSAIsBlocking);
    ATTACH(WSAJoinLeaf);
    ATTACH(WSALookupServiceBeginA);
    ATTACH(WSALookupServiceBeginW);
    ATTACH(WSALookupServiceEnd);
    ATTACH(WSALookupServiceNextA);
    ATTACH(WSALookupServiceNextW);
    ATTACH(WSANtohl);
    ATTACH(WSANtohs);
    ATTACH(WSAProviderConfigChange);
    ATTACH(WSARecv);
    ATTACH(WSARecvDisconnect);
    ATTACH(WSARecvFrom);
    ATTACH(WSARemoveServiceClass);
    ATTACH(WSAResetEvent);
    ATTACH(WSASend);
    ATTACH(WSASendDisconnect);
    ATTACH(WSASendTo);
    ATTACH(WSASetBlockingHook);
    ATTACH(WSASetEvent);
    ATTACH(WSASetServiceA);
    ATTACH(WSASetServiceW);
    ATTACH(WSASocketA);
    ATTACH(WSASocketW);
    ATTACH(WSAStartup);
    ATTACH(WSAStringToAddressA);
    ATTACH(WSAStringToAddressW);
    ATTACH(WSAUnhookBlockingHook);
    ATTACH(WSAWaitForMultipleEvents);
    ATTACH(WaitCommEvent);
#if !defined(DETOURS_ARM)
    ATTACH(WaitForDebugEvent);
#endif // !DETOURS_ARM
    ATTACH(WaitForInputIdle);
    ATTACH(WaitForMultipleObjects);
    ATTACH(WaitForMultipleObjectsEx);
    ATTACH(WaitForSingleObject);
    ATTACH(WaitForSingleObjectEx);
    ATTACH(WaitMessage);
    ATTACH(WaitNamedPipeA);
    ATTACH(WaitNamedPipeW);
    ATTACH(WidenPath);
    ATTACH(WinExec);
    ATTACH(WinHelpA);
    ATTACH(WinHelpW);
    ATTACH(WindowFromDC);
    ATTACH(WindowFromPoint);
    ATTACH(WriteClassStg);
    ATTACH(WriteClassStm);
    ATTACH(WriteConsoleA);
    ATTACH(WriteConsoleInputA);
    ATTACH(WriteConsoleInputW);
    ATTACH(WriteConsoleOutputA);
    ATTACH(WriteConsoleOutputAttribute);
    ATTACH(WriteConsoleOutputCharacterA);
    ATTACH(WriteConsoleOutputCharacterW);
    ATTACH(WriteConsoleOutputW);
    ATTACH(WriteConsoleW);
    ATTACH(WriteFile);
    ATTACH(WriteFileEx);
    ATTACH(WriteFmtUserTypeStg);
    ATTACH(WritePrivateProfileSectionA);
    ATTACH(WritePrivateProfileSectionW);
    ATTACH(WritePrivateProfileStringA);
    ATTACH(WritePrivateProfileStringW);
    ATTACH(WritePrivateProfileStructA);
    ATTACH(WritePrivateProfileStructW);
    ATTACH(WriteProcessMemory);
    ATTACH(WriteProfileSectionA);
    ATTACH(WriteProfileSectionW);
    ATTACH(WriteProfileStringA);
    ATTACH(WriteProfileStringW);
    ATTACH(WriteTapemark);
    ATTACH(__WSAFDIsSet);
    ATTACH(_hread);
    ATTACH(_hwrite);
    ATTACH(_lclose);
    ATTACH(_lcreat);
    ATTACH(_llseek);
    ATTACH(_lopen);
    ATTACH(_lread);
    ATTACH(_lwrite);
    ATTACH(accept);
    ATTACH(bind);
    ATTACH(closesocket);
    ATTACH(connect);
    ATTACH(gethostbyaddr);
    ATTACH(gethostbyname);
    ATTACH(gethostname);
    ATTACH(getpeername);
    ATTACH(getprotobyname);
    ATTACH(getprotobynumber);
    ATTACH(getservbyname);
    ATTACH(getservbyport);
    ATTACH(getsockname);
    ATTACH(getsockopt);
    ATTACH(htonl);
    ATTACH(htons);
    ATTACH(inet_addr);
    ATTACH(inet_ntoa);
    ATTACH(ioctlsocket);
    ATTACH(keybd_event);
    ATTACH(listen);
    ATTACH(mouse_event);
    ATTACH(ntohl);
    ATTACH(ntohs);
    ATTACH(recv);
    ATTACH(recvfrom);
    ATTACH(select);
    ATTACH(send);
    ATTACH(sendto);
    ATTACH(setsockopt);
    ATTACH(shutdown);
    ATTACH(socket);

    PVOID *ppbFailedPointer = NULL;
    LONG error = DetourTransactionCommitEx(&ppbFailedPointer);
    if (error != 0) {
        printf("traceapi.dll: Attach transaction failed to commit. Error %ld (%p/%p)",
               error, ppbFailedPointer, *ppbFailedPointer);
        return error;
    }
    return 0;
}

LONG DetachDetours(VOID)
{
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());

    // For this many APIs, we'll ignore one or two can't be detoured.
    DetourSetIgnoreTooSmall(TRUE);

    DETACH(AbortDoc);
    DETACH(AbortPath);
    DETACH(ActivateKeyboardLayout);
    DETACH(AddAtomA);
    DETACH(AddAtomW);
    DETACH(AddFontResourceA);
    DETACH(AddFontResourceW);
    DETACH(AdjustWindowRect);
    DETACH(AdjustWindowRectEx);
    DETACH(AllocConsole);
    DETACH(AngleArc);
    DETACH(AnimatePalette);
    DETACH(AnyPopup);
    DETACH(AppendMenuA);
    DETACH(AppendMenuW);
    DETACH(Arc);
    DETACH(ArcTo);
    DETACH(AreFileApisANSI);
    DETACH(ArrangeIconicWindows);
    DETACH(AttachThreadInput);
    DETACH(BackupRead);
    DETACH(BackupSeek);
    DETACH(BackupWrite);
    DETACH(Beep);
    DETACH(BeginDeferWindowPos);
    DETACH(BeginPaint);
    DETACH(BeginPath);
    DETACH(BeginUpdateResourceA);
    DETACH(BeginUpdateResourceW);
    DETACH(BindMoniker);
    DETACH(BitBlt);
    DETACH(BringWindowToTop);
    DETACH(BroadcastSystemMessageA);
    DETACH(BroadcastSystemMessageW);
    DETACH(BuildCommDCBA);
    DETACH(BuildCommDCBAndTimeoutsA);
    DETACH(BuildCommDCBAndTimeoutsW);
    DETACH(BuildCommDCBW);
    DETACH(CLSIDFromProgID);
    DETACH(CLSIDFromString);
    DETACH(CallMsgFilterA);
    DETACH(CallMsgFilterW);
    DETACH(CallNamedPipeA);
    DETACH(CallNamedPipeW);
    DETACH(CallNextHookEx);
    DETACH(CallWindowProcA);
    DETACH(CallWindowProcW);
    DETACH(CancelDC);
    DETACH(CancelIo);
    DETACH(CancelWaitableTimer);
    DETACH(CascadeWindows);
    DETACH(ChangeClipboardChain);
    DETACH(ChangeDisplaySettingsA);
    DETACH(ChangeDisplaySettingsExA);
    DETACH(ChangeDisplaySettingsExW);
    DETACH(ChangeDisplaySettingsW);
    DETACH(ChangeMenuA);
    DETACH(ChangeMenuW);
    DETACH(CharLowerA);
    DETACH(CharLowerBuffA);
    DETACH(CharLowerBuffW);
    DETACH(CharLowerW);
    DETACH(CharNextA);
    DETACH(CharNextExA);
    DETACH(CharNextW);
    DETACH(CharPrevA);
    DETACH(CharPrevExA);
    DETACH(CharPrevW);
    DETACH(CharToOemA);
    DETACH(CharToOemBuffA);
    DETACH(CharToOemBuffW);
    DETACH(CharToOemW);
    DETACH(CharUpperA);
    DETACH(CharUpperBuffA);
    DETACH(CharUpperBuffW);
    DETACH(CharUpperW);
    DETACH(CheckColorsInGamut);
    DETACH(CheckDlgButton);
    DETACH(CheckMenuItem);
    DETACH(CheckMenuRadioItem);
    DETACH(CheckRadioButton);
    DETACH(ChildWindowFromPoint);
    DETACH(ChildWindowFromPointEx);
    DETACH(ChoosePixelFormat);
    DETACH(Chord);
    DETACH(ClearCommBreak);
    DETACH(ClearCommError);
    DETACH(ClientToScreen);
    DETACH(ClipCursor);
    DETACH(CloseClipboard);
    DETACH(CloseDesktop);
    DETACH(CloseEnhMetaFile);
    DETACH(CloseFigure);
    DETACH(CloseHandle);
    DETACH(CloseMetaFile);
    DETACH(CloseWindow);
    DETACH(CloseWindowStation);
    DETACH(CoAddRefServerProcess);
    DETACH(CoBuildVersion);
    DETACH(CoCopyProxy);
    DETACH(CoCreateFreeThreadedMarshaler);
    DETACH(CoCreateGuid);
    DETACH(CoCreateInstance);
    DETACH(CoCreateInstanceEx);
    DETACH(CoDisconnectObject);
    DETACH(CoDosDateTimeToFileTime);
    DETACH(CoFileTimeNow);
    DETACH(CoFileTimeToDosDateTime);
    DETACH(CoFreeAllLibraries);
    DETACH(CoFreeLibrary);
    DETACH(CoFreeUnusedLibraries);
    DETACH(CoGetCallContext);
    DETACH(CoGetClassObject);
    DETACH(CoGetCurrentProcess);
    DETACH(CoGetInstanceFromFile);
    DETACH(CoGetInstanceFromIStorage);
    DETACH(CoGetInterfaceAndReleaseStream);
    DETACH(CoGetMalloc);
    DETACH(CoGetMarshalSizeMax);
    DETACH(CoGetObject);
    DETACH(CoGetPSClsid);
    DETACH(CoGetStandardMarshal);
    DETACH(CoGetStdMarshalEx);
    DETACH(CoGetTreatAsClass);
    DETACH(CoImpersonateClient);
    DETACH(CoInitialize);
    DETACH(CoInitializeEx);
    DETACH(CoInitializeSecurity);
    DETACH(CoIsHandlerConnected);
    DETACH(CoIsOle1Class);
    DETACH(CoLoadLibrary);
    DETACH(CoLockObjectExternal);
    DETACH(CoMarshalHresult);
    DETACH(CoMarshalInterThreadInterfaceInStream);
    DETACH(CoMarshalInterface);
    DETACH(CoQueryAuthenticationServices);
    DETACH(CoQueryClientBlanket);
    DETACH(CoQueryProxyBlanket);
    DETACH(CoRegisterChannelHook);
    DETACH(CoRegisterClassObject);
    DETACH(CoRegisterMallocSpy);
    DETACH(CoRegisterMessageFilter);
    DETACH(CoRegisterPSClsid);
    DETACH(CoRegisterSurrogate);
    DETACH(CoReleaseMarshalData);
    DETACH(CoReleaseServerProcess);
    DETACH(CoResumeClassObjects);
    DETACH(CoRevertToSelf);
    DETACH(CoRevokeClassObject);
    DETACH(CoRevokeMallocSpy);
    DETACH(CoSetProxyBlanket);
    DETACH(CoSuspendClassObjects);
    DETACH(CoSwitchCallContext);
    DETACH(CoTaskMemAlloc);
    DETACH(CoTaskMemFree);
    DETACH(CoTaskMemRealloc);
    DETACH(CoTreatAsClass);
    DETACH(CoUninitialize);
    DETACH(CoUnmarshalHresult);
    DETACH(CoUnmarshalInterface);
    DETACH(ColorMatchToTarget);
    DETACH(CombineRgn);
    DETACH(CombineTransform);
    DETACH(CommConfigDialogA);
    DETACH(CommConfigDialogW);
    DETACH(CompareFileTime);
    DETACH(CompareStringA);
    DETACH(CompareStringW);
    DETACH(ConnectNamedPipe);
#if !defined(DETOURS_ARM)
    DETACH(ContinueDebugEvent);
#endif // !DETOURS_ARM
    DETACH(ConvertDefaultLocale);
    DETACH(ConvertThreadToFiber);
    DETACH(CopyAcceleratorTableA);
    DETACH(CopyAcceleratorTableW);
    DETACH(CopyEnhMetaFileA);
    DETACH(CopyEnhMetaFileW);
    DETACH(CopyFileA);
    DETACH(CopyFileExA);
    DETACH(CopyFileExW);
    DETACH(CopyFileW);
    DETACH(CopyIcon);
    DETACH(CopyImage);
    DETACH(CopyMetaFileA);
    DETACH(CopyMetaFileW);
    DETACH(CopyRect);
    DETACH(CountClipboardFormats);
    DETACH(CreateAcceleratorTableA);
    DETACH(CreateAcceleratorTableW);
    DETACH(CreateAntiMoniker);
    DETACH(CreateBindCtx);
    DETACH(CreateBitmap);
    DETACH(CreateBitmapIndirect);
    DETACH(CreateBrushIndirect);
    DETACH(CreateCaret);
    DETACH(CreateClassMoniker);
    DETACH(CreateColorSpaceA);
    DETACH(CreateColorSpaceW);
    DETACH(CreateCompatibleBitmap);
    DETACH(CreateCompatibleDC);
    DETACH(CreateConsoleScreenBuffer);
    DETACH(CreateCursor);
    DETACH(CreateDCA);
    DETACH(CreateDCW);
    DETACH(CreateDIBPatternBrush);
    DETACH(CreateDIBPatternBrushPt);
    DETACH(CreateDIBSection);
    DETACH(CreateDIBitmap);
    DETACH(CreateDataAdviseHolder);
    DETACH(CreateDataCache);
    DETACH(CreateDesktopA);
    DETACH(CreateDesktopW);
    DETACH(CreateDialogIndirectParamA);
    DETACH(CreateDialogIndirectParamW);
    DETACH(CreateDialogParamA);
    DETACH(CreateDialogParamW);
    DETACH(CreateDirectoryA);
    DETACH(CreateDirectoryExA);
    DETACH(CreateDirectoryExW);
    DETACH(CreateDirectoryW);
    DETACH(CreateDiscardableBitmap);
    DETACH(CreateEllipticRgn);
    DETACH(CreateEllipticRgnIndirect);
    DETACH(CreateEnhMetaFileA);
    DETACH(CreateEnhMetaFileW);
    DETACH(CreateEventA);
    DETACH(CreateEventW);
    DETACH(CreateFiber);
    DETACH(CreateFileA);
    DETACH(CreateFileMappingA);
    DETACH(CreateFileMappingW);
    DETACH(CreateFileMoniker);
    DETACH(CreateFileW);
    DETACH(CreateFontA);
    DETACH(CreateFontIndirectA);
    DETACH(CreateFontIndirectW);
    DETACH(CreateFontW);
    DETACH(CreateGenericComposite);
    DETACH(CreateHalftonePalette);
    DETACH(CreateHatchBrush);
    DETACH(CreateICA);
    DETACH(CreateICW);
    DETACH(CreateILockBytesOnHGlobal);
    DETACH(CreateIcon);
    DETACH(CreateIconFromResource);
    DETACH(CreateIconFromResourceEx);
    DETACH(CreateIconIndirect);
    DETACH(CreateIoCompletionPort);
    DETACH(CreateItemMoniker);
    DETACH(CreateMDIWindowA);
    DETACH(CreateMDIWindowW);
    DETACH(CreateMailslotA);
    DETACH(CreateMailslotW);
    DETACH(CreateMenu);
    DETACH(CreateMetaFileA);
    DETACH(CreateMetaFileW);
    DETACH(CreateMutexA);
    DETACH(CreateMutexW);
    DETACH(CreateNamedPipeA);
    DETACH(CreateNamedPipeW);
    DETACH(CreateOleAdviseHolder);
    DETACH(CreatePalette);
    DETACH(CreatePatternBrush);
    DETACH(CreatePen);
    DETACH(CreatePenIndirect);
    DETACH(CreatePipe);
    DETACH(CreatePointerMoniker);
    DETACH(CreatePolyPolygonRgn);
    DETACH(CreatePolygonRgn);
    DETACH(CreatePopupMenu);
    DETACH(CreateProcessA);
    DETACH(CreateProcessW);
    DETACH(CreateProcessAsUserA);
    DETACH(CreateProcessAsUserW);
#if(_WIN32_WINNT >= 0x0500)
    DETACH(CreateProcessWithLogonW);
    DETACH(CreateProcessWithTokenW);
#endif //(_WIN32_WINNT >= 0x0500)
    DETACH(CreateRectRgn);
    DETACH(CreateRectRgnIndirect);
    DETACH(CreateRemoteThread);
    DETACH(CreateRoundRectRgn);
    DETACH(CreateScalableFontResourceA);
    DETACH(CreateScalableFontResourceW);
    DETACH(CreateSemaphoreA);
    DETACH(CreateSemaphoreW);
    DETACH(CreateSolidBrush);
    DETACH(CreateStdProgressIndicator);
    DETACH(CreateStreamOnHGlobal);
    DETACH(CreateTapePartition);
    DETACH(CreateThread);
    DETACH(CreateWaitableTimerA);
    DETACH(CreateWaitableTimerW);
    DETACH(CreateWindowExA);
    DETACH(CreateWindowExW);
    DETACH(CreateWindowStationA);
    DETACH(CreateWindowStationW);
    DETACH(DPtoLP);
    DETACH(DdeAbandonTransaction);
    DETACH(DdeAccessData);
    DETACH(DdeAddData);
    DETACH(DdeClientTransaction);
    DETACH(DdeCmpStringHandles);
    DETACH(DdeConnect);
    DETACH(DdeConnectList);
    DETACH(DdeCreateDataHandle);
    DETACH(DdeCreateStringHandleA);
    DETACH(DdeCreateStringHandleW);
    DETACH(DdeDisconnect);
    DETACH(DdeDisconnectList);
    DETACH(DdeEnableCallback);
    DETACH(DdeFreeDataHandle);
    DETACH(DdeFreeStringHandle);
    DETACH(DdeGetData);
    DETACH(DdeGetLastError);
    DETACH(DdeImpersonateClient);
    DETACH(DdeKeepStringHandle);
    DETACH(DdeNameService);
    DETACH(DdePostAdvise);
    DETACH(DdeQueryConvInfo);
    DETACH(DdeQueryNextServer);
    DETACH(DdeQueryStringA);
    DETACH(DdeQueryStringW);
    DETACH(DdeReconnect);
    DETACH(DdeSetQualityOfService);
    DETACH(DdeSetUserHandle);
    DETACH(DdeUnaccessData);
    DETACH(DdeUninitialize);
    DETACH(DebugActiveProcess);
    DETACH(DebugActiveProcessStop);
    DETACH(DebugBreak);
    DETACH(DefDlgProcA);
    DETACH(DefDlgProcW);
    DETACH(DefFrameProcA);
    DETACH(DefFrameProcW);
    DETACH(DefMDIChildProcA);
    DETACH(DefMDIChildProcW);
    DETACH(DefWindowProcA);
    DETACH(DefWindowProcW);
    DETACH(DeferWindowPos);
    DETACH(DefineDosDeviceA);
    DETACH(DefineDosDeviceW);
    DETACH(DeleteAtom);
    DETACH(DeleteColorSpace);
    DETACH(DeleteDC);
    DETACH(DeleteEnhMetaFile);
    DETACH(DeleteFiber);
    DETACH(DeleteFileA);
    DETACH(DeleteFileW);
    DETACH(DeleteMenu);
    DETACH(DeleteMetaFile);
    DETACH(DeleteObject);
    DETACH(DescribePixelFormat);
    DETACH(DestroyAcceleratorTable);
    DETACH(DestroyCaret);
    DETACH(DestroyCursor);
    DETACH(DestroyIcon);
    DETACH(DestroyMenu);
    DETACH(DestroyWindow);
    DETACH(DeviceIoControl);
    DETACH(DialogBoxIndirectParamA);
    DETACH(DialogBoxIndirectParamW);
    DETACH(DialogBoxParamA);
    DETACH(DialogBoxParamW);
    DETACH(DisableThreadLibraryCalls);
    DETACH(DisconnectNamedPipe);
    DETACH(DispatchMessageA);
    DETACH(DispatchMessageW);
    DETACH(DlgDirListA);
    DETACH(DlgDirListComboBoxA);
    DETACH(DlgDirListComboBoxW);
    DETACH(DlgDirListW);
    DETACH(DlgDirSelectComboBoxExA);
    DETACH(DlgDirSelectComboBoxExW);
    DETACH(DlgDirSelectExA);
    DETACH(DlgDirSelectExW);
    DETACH(DoDragDrop);
    DETACH(DosDateTimeToFileTime);
    DETACH(DragDetect);
    DETACH(DragObject);
    DETACH(DrawAnimatedRects);
    DETACH(DrawCaption);
    DETACH(DrawEdge);
    DETACH(DrawEscape);
    DETACH(DrawFocusRect);
    DETACH(DrawFrameControl);
    DETACH(DrawIcon);
    DETACH(DrawIconEx);
    DETACH(DrawMenuBar);
    DETACH(DrawStateA);
    DETACH(DrawStateW);
    DETACH(DrawTextA);
    DETACH(DrawTextExA);
    DETACH(DrawTextExW);
    DETACH(DrawTextW);
    DETACH(DuplicateHandle);
    DETACH(Ellipse);
    DETACH(EmptyClipboard);
    DETACH(EnableMenuItem);
    DETACH(EnableScrollBar);
    DETACH(EnableWindow);
    DETACH(EndDeferWindowPos);
    DETACH(EndDialog);
    DETACH(EndDoc);
    DETACH(EndPage);
    DETACH(EndPaint);
    DETACH(EndPath);
    DETACH(EndUpdateResourceA);
    DETACH(EndUpdateResourceW);
    DETACH(EnumCalendarInfoA);
    DETACH(EnumCalendarInfoW);
    DETACH(EnumChildWindows);
    DETACH(EnumClipboardFormats);
    DETACH(EnumDateFormatsA);
    DETACH(EnumDateFormatsW);
    DETACH(EnumDesktopWindows);
    DETACH(EnumDesktopsA);
    DETACH(EnumDesktopsW);
    DETACH(EnumDisplaySettingsA);
    DETACH(EnumDisplaySettingsW);
    DETACH(EnumEnhMetaFile);
    DETACH(EnumFontFamiliesA);
    DETACH(EnumFontFamiliesExA);
    DETACH(EnumFontFamiliesExW);
    DETACH(EnumFontFamiliesW);
    DETACH(EnumFontsA);
    DETACH(EnumFontsW);
    DETACH(EnumICMProfilesA);
    DETACH(EnumICMProfilesW);
    DETACH(EnumMetaFile);
    DETACH(EnumObjects);
    DETACH(EnumPropsA);
    DETACH(EnumPropsExA);
    DETACH(EnumPropsExW);
    DETACH(EnumPropsW);
    DETACH(EnumResourceLanguagesA);
    DETACH(EnumResourceLanguagesW);
    DETACH(EnumResourceNamesA);
    DETACH(EnumResourceNamesW);
    DETACH(EnumResourceTypesA);
    DETACH(EnumResourceTypesW);
    DETACH(EnumSystemCodePagesA);
    DETACH(EnumSystemCodePagesW);
#if(WINVER >= 0x0500)
    DETACH(EnumSystemLocalesA);
    DETACH(EnumSystemLocalesW);
#endif // (WINVER >= 0x0500)
    DETACH(EnumThreadWindows);
    DETACH(EnumTimeFormatsA);
    DETACH(EnumTimeFormatsW);
    DETACH(EnumWindowStationsA);
    DETACH(EnumWindowStationsW);
    DETACH(EnumWindows);
    DETACH(EqualRect);
    DETACH(EqualRgn);
    DETACH(EraseTape);
    DETACH(Escape);
    DETACH(EscapeCommFunction);
    DETACH(ExcludeClipRect);
    DETACH(ExcludeUpdateRgn);
    DETACH(ExitProcess);
    DETACH(ExitThread);
    DETACH(ExitWindowsEx);
    DETACH(ExpandEnvironmentStringsA);
    DETACH(ExpandEnvironmentStringsW);
    DETACH(ExtCreatePen);
    DETACH(ExtCreateRegion);
    DETACH(ExtEscape);
    DETACH(ExtFloodFill);
    DETACH(ExtSelectClipRgn);
    DETACH(ExtTextOutA);
    DETACH(ExtTextOutW);
    DETACH(FatalAppExitA);
    DETACH(FatalAppExitW);
    DETACH(FatalExit);
    DETACH(FileTimeToDosDateTime);
    DETACH(FileTimeToLocalFileTime);
    DETACH(FileTimeToSystemTime);
    DETACH(FillConsoleOutputAttribute);
    DETACH(FillConsoleOutputCharacterA);
    DETACH(FillConsoleOutputCharacterW);
    DETACH(FillPath);
    DETACH(FillRect);
    DETACH(FillRgn);
    DETACH(FindAtomA);
    DETACH(FindAtomW);
    DETACH(FindClose);
    DETACH(FindCloseChangeNotification);
    DETACH(FindFirstChangeNotificationA);
    DETACH(FindFirstChangeNotificationW);
    DETACH(FindFirstFileA);
    DETACH(FindFirstFileExA);
    DETACH(FindFirstFileExW);
    DETACH(FindFirstFileW);
    DETACH(FindNextChangeNotification);
    DETACH(FindNextFileA);
    DETACH(FindNextFileW);
    DETACH(FindResourceA);
    DETACH(FindResourceExA);
    DETACH(FindResourceExW);
    DETACH(FindResourceW);
    DETACH(FindWindowA);
    DETACH(FindWindowExA);
    DETACH(FindWindowExW);
    DETACH(FindWindowW);
    DETACH(FixBrushOrgEx);
    DETACH(FlashWindow);
    DETACH(FlattenPath);
    DETACH(FloodFill);
    DETACH(FlushConsoleInputBuffer);
    DETACH(FlushFileBuffers);
    DETACH(FlushViewOfFile);
    DETACH(FmtIdToPropStgName);
    DETACH(FoldStringA);
    DETACH(FoldStringW);
    DETACH(FormatMessageA);
    DETACH(FormatMessageW);
    DETACH(FrameRect);
    DETACH(FrameRgn);
    DETACH(FreeConsole);
    DETACH(FreeDDElParam);
    DETACH(FreeEnvironmentStringsA);
    DETACH(FreeEnvironmentStringsW);
    DETACH(FreeLibrary);
    DETACH(FreeLibraryAndExitThread);
    DETACH(FreePropVariantArray);
    DETACH(FreeResource);
    DETACH(GdiComment);
    DETACH(GdiFlush);
    DETACH(GdiGetBatchLimit);
    DETACH(GdiSetBatchLimit);
    DETACH(GenerateConsoleCtrlEvent);
    DETACH(GetACP);
    DETACH(GetActiveWindow);
    DETACH(GetArcDirection);
    DETACH(GetAspectRatioFilterEx);
    DETACH(GetAsyncKeyState);
    DETACH(GetAtomNameA);
    DETACH(GetAtomNameW);
    DETACH(GetBinaryTypeA);
    DETACH(GetBinaryTypeW);
    DETACH(GetBitmapBits);
    DETACH(GetBitmapDimensionEx);
    DETACH(GetBkColor);
    DETACH(GetBkMode);
    DETACH(GetBoundsRect);
    DETACH(GetBrushOrgEx);
    DETACH(GetCPInfo);
    DETACH(GetCapture);
    DETACH(GetCaretBlinkTime);
    DETACH(GetCaretPos);
    DETACH(GetCharABCWidthsA);
    DETACH(GetCharABCWidthsFloatA);
    DETACH(GetCharABCWidthsFloatW);
    DETACH(GetCharABCWidthsW);
    DETACH(GetCharWidth32A);
    DETACH(GetCharWidth32W);
    DETACH(GetCharWidthA);
    DETACH(GetCharWidthFloatA);
    DETACH(GetCharWidthFloatW);
    DETACH(GetCharWidthW);
    DETACH(GetCharacterPlacementA);
    DETACH(GetCharacterPlacementW);
    DETACH(GetClassFile);
    DETACH(GetClassInfoA);
    DETACH(GetClassInfoExA);
    DETACH(GetClassInfoExW);
    DETACH(GetClassInfoW);
    DETACH(GetClassLongA);
    DETACH(GetClassLongW);
    DETACH(GetClassNameA);
    DETACH(GetClassNameW);
    DETACH(GetClassWord);
    DETACH(GetClientRect);
    DETACH(GetClipBox);
    DETACH(GetClipCursor);
    DETACH(GetClipRgn);
    DETACH(GetClipboardData);
    DETACH(GetClipboardFormatNameA);
    DETACH(GetClipboardFormatNameW);
    DETACH(GetClipboardOwner);
    DETACH(GetClipboardViewer);
    DETACH(GetColorAdjustment);
    DETACH(GetColorSpace);
    DETACH(GetCommConfig);
    DETACH(GetCommMask);
    DETACH(GetCommModemStatus);
    DETACH(GetCommProperties);
    DETACH(GetCommState);
    DETACH(GetCommTimeouts);
    DETACH(GetCommandLineA);
    DETACH(GetCommandLineW);
    DETACH(GetComputerNameA);
    DETACH(GetComputerNameW);
    DETACH(GetConsoleCP);
    DETACH(GetConsoleCursorInfo);
    DETACH(GetConsoleMode);
    DETACH(GetConsoleOutputCP);
    DETACH(GetConsoleScreenBufferInfo);
    DETACH(GetConsoleTitleA);
    DETACH(GetConsoleTitleW);
    DETACH(GetConvertStg);
    DETACH(GetCurrencyFormatA);
    DETACH(GetCurrencyFormatW);
    DETACH(GetCurrentDirectoryA);
    DETACH(GetCurrentDirectoryW);
    DETACH(GetCurrentObject);
    DETACH(GetCurrentPositionEx);
    DETACH(GetCurrentProcess);
    DETACH(GetCurrentProcessId);
    DETACH(GetCurrentThreadId);
    DETACH(GetCursor);
    DETACH(GetCursorPos);
    DETACH(GetDC);
    DETACH(GetDCEx);
    DETACH(GetDCOrgEx);
    DETACH(GetDIBColorTable);
    DETACH(GetDIBits);
    DETACH(GetDateFormatA);
    DETACH(GetDateFormatW);
    DETACH(GetDefaultCommConfigA);
    DETACH(GetDefaultCommConfigW);
    DETACH(GetDesktopWindow);
    DETACH(GetDeviceCaps);
    DETACH(GetDeviceGammaRamp);
    DETACH(GetDialogBaseUnits);
    DETACH(GetDiskFreeSpaceA);
    DETACH(GetDiskFreeSpaceExA);
    DETACH(GetDiskFreeSpaceExW);
    DETACH(GetDiskFreeSpaceW);
    DETACH(GetDlgCtrlID);
    DETACH(GetDlgItem);
    DETACH(GetDlgItemInt);
    DETACH(GetDlgItemTextA);
    DETACH(GetDlgItemTextW);
    DETACH(GetDoubleClickTime);
    DETACH(GetDriveTypeA);
    DETACH(GetDriveTypeW);
    DETACH(GetEnhMetaFileA);
    DETACH(GetEnhMetaFileBits);
    DETACH(GetEnhMetaFileDescriptionA);
    DETACH(GetEnhMetaFileDescriptionW);
    DETACH(GetEnhMetaFileHeader);
    DETACH(GetEnhMetaFilePaletteEntries);
    DETACH(GetEnhMetaFilePixelFormat);
    DETACH(GetEnhMetaFileW);
    DETACH(GetEnvironmentStrings);
    DETACH(GetEnvironmentStringsW);
    DETACH(GetEnvironmentVariableA);
    DETACH(GetEnvironmentVariableW);
    DETACH(GetExitCodeProcess);
    DETACH(GetExitCodeThread);
    DETACH(GetFileAttributesA);
    DETACH(GetFileAttributesExA);
    DETACH(GetFileAttributesExW);
    DETACH(GetFileAttributesW);
    DETACH(GetFileInformationByHandle);
    DETACH(GetFileSize);
    DETACH(GetFileTime);
    DETACH(GetFileType);
    DETACH(GetFocus);
    DETACH(GetFontData);
    DETACH(GetFontLanguageInfo);
    DETACH(GetForegroundWindow);
    DETACH(GetFullPathNameA);
    DETACH(GetFullPathNameW);
    DETACH(GetGlyphOutlineA);
    DETACH(GetGlyphOutlineW);
    DETACH(GetGraphicsMode);
    DETACH(GetHGlobalFromILockBytes);
    DETACH(GetHGlobalFromStream);
    DETACH(GetHandleInformation);
    DETACH(GetICMProfileA);
    DETACH(GetICMProfileW);
    DETACH(GetIconInfo);
    DETACH(GetInputState);
    DETACH(GetKBCodePage);
    DETACH(GetKerningPairsA);
    DETACH(GetKerningPairsW);
    DETACH(GetKeyNameTextA);
    DETACH(GetKeyNameTextW);
    DETACH(GetKeyState);
    DETACH(GetKeyboardLayout);
    DETACH(GetKeyboardLayoutList);
    DETACH(GetKeyboardLayoutNameA);
    DETACH(GetKeyboardLayoutNameW);
    DETACH(GetKeyboardState);
    DETACH(GetKeyboardType);
    DETACH(GetLastActivePopup);
    DETACH(GetLocalTime);
    DETACH(GetLocaleInfoA);
    DETACH(GetLocaleInfoW);
    DETACH(GetLogColorSpaceA);
    DETACH(GetLogColorSpaceW);
    DETACH(GetLogicalDriveStringsA);
    DETACH(GetLogicalDriveStringsW);
    DETACH(GetLogicalDrives);
    DETACH(GetMailslotInfo);
    DETACH(GetMapMode);
    DETACH(GetMenu);
    DETACH(GetMenuCheckMarkDimensions);
    DETACH(GetMenuContextHelpId);
    DETACH(GetMenuDefaultItem);
    DETACH(GetMenuItemCount);
    DETACH(GetMenuItemID);
    DETACH(GetMenuItemInfoA);
    DETACH(GetMenuItemInfoW);
    DETACH(GetMenuItemRect);
    DETACH(GetMenuState);
    DETACH(GetMenuStringA);
    DETACH(GetMenuStringW);
    DETACH(GetMessageA);
    DETACH(GetMessageExtraInfo);
    DETACH(GetMessagePos);
    DETACH(GetMessageTime);
    DETACH(GetMessageW);
    DETACH(GetMetaFileA);
    DETACH(GetMetaFileBitsEx);
    DETACH(GetMetaFileW);
    DETACH(GetMetaRgn);
    DETACH(GetMiterLimit);
    DETACH(GetModuleFileNameA);
    DETACH(GetModuleFileNameW);
    DETACH(GetModuleHandleA);
    DETACH(GetModuleHandleW);
    DETACH(GetNamedPipeHandleStateA);
    DETACH(GetNamedPipeHandleStateW);
    DETACH(GetNamedPipeInfo);
    DETACH(GetNearestColor);
    DETACH(GetNearestPaletteIndex);
    DETACH(GetNextDlgGroupItem);
    DETACH(GetNextDlgTabItem);
    DETACH(GetNumberFormatA);
    DETACH(GetNumberFormatW);
    DETACH(GetNumberOfConsoleInputEvents);
    DETACH(GetNumberOfConsoleMouseButtons);
    DETACH(GetOEMCP);
    DETACH(GetObjectA);
    DETACH(GetObjectType);
    DETACH(GetObjectW);
    DETACH(GetOpenClipboardWindow);
    DETACH(GetOutlineTextMetricsA);
    DETACH(GetOutlineTextMetricsW);
    DETACH(GetOverlappedResult);
    DETACH(GetPaletteEntries);
    DETACH(GetParent);
    DETACH(GetPath);
    DETACH(GetPixel);
    DETACH(GetPixelFormat);
    DETACH(GetPolyFillMode);
    DETACH(GetPriorityClass);
    DETACH(GetPriorityClipboardFormat);
    DETACH(GetPrivateProfileIntA);
    DETACH(GetPrivateProfileIntW);
    DETACH(GetPrivateProfileSectionA);
    DETACH(GetPrivateProfileSectionNamesA);
    DETACH(GetPrivateProfileSectionNamesW);
    DETACH(GetPrivateProfileSectionW);
    DETACH(GetPrivateProfileStringA);
    DETACH(GetPrivateProfileStringW);
    DETACH(GetPrivateProfileStructA);
    DETACH(GetPrivateProfileStructW);
    DETACH(GetProcAddress);
    DETACH(GetProcessAffinityMask);
    DETACH(GetProcessHeaps);
    DETACH(GetProcessShutdownParameters);
    DETACH(GetProcessTimes);
    DETACH(GetProcessVersion);
    DETACH(GetProcessWindowStation);
    DETACH(GetProcessWorkingSetSize);
    DETACH(GetProfileIntA);
    DETACH(GetProfileIntW);
    DETACH(GetProfileSectionA);
    DETACH(GetProfileSectionW);
    DETACH(GetProfileStringA);
    DETACH(GetProfileStringW);
    DETACH(GetPropA);
    DETACH(GetPropW);
    DETACH(GetQueueStatus);
    DETACH(GetQueuedCompletionStatus);
    DETACH(GetROP2);
    DETACH(GetRasterizerCaps);
    DETACH(GetRegionData);
    DETACH(GetRgnBox);
    DETACH(GetRunningObjectTable);
    DETACH(GetScrollInfo);
    DETACH(GetScrollPos);
    DETACH(GetScrollRange);
    DETACH(GetShortPathNameA);
    DETACH(GetShortPathNameW);
    DETACH(GetStartupInfoA);
    DETACH(GetStartupInfoW);
    DETACH(GetStdHandle);
    DETACH(GetStockObject);
    DETACH(GetStretchBltMode);
    DETACH(GetSubMenu);
    DETACH(GetSysColor);
    DETACH(GetSysColorBrush);
    DETACH(GetSystemDefaultLCID);
    DETACH(GetSystemDefaultLangID);
    DETACH(GetSystemDirectoryA);
    DETACH(GetSystemDirectoryW);
    DETACH(GetSystemInfo);
    DETACH(GetSystemMenu);
    DETACH(GetSystemMetrics);
    DETACH(GetSystemPaletteEntries);
    DETACH(GetSystemPaletteUse);
    DETACH(GetSystemPowerStatus);
    DETACH(GetSystemTime);
    DETACH(GetSystemTimeAdjustment);
    DETACH(GetSystemTimeAsFileTime);
    DETACH(GetTabbedTextExtentA);
    DETACH(GetTabbedTextExtentW);
    DETACH(GetTapeParameters);
    DETACH(GetTapePosition);
    DETACH(GetTapeStatus);
    DETACH(GetTempFileNameA);
    DETACH(GetTempFileNameW);
    DETACH(GetTempPathA);
    DETACH(GetTempPathW);
    DETACH(GetTextAlign);
    DETACH(GetTextCharacterExtra);
    DETACH(GetTextCharset);
    DETACH(GetTextCharsetInfo);
    DETACH(GetTextColor);
    DETACH(GetTextExtentExPointA);
    DETACH(GetTextExtentExPointW);
    DETACH(GetTextExtentPoint32A);
    DETACH(GetTextExtentPoint32W);
    DETACH(GetTextExtentPointA);
    DETACH(GetTextExtentPointW);
    DETACH(GetTextFaceA);
    DETACH(GetTextFaceW);
    DETACH(GetTextMetricsA);
    DETACH(GetTextMetricsW);
    DETACH(GetThreadContext);
    DETACH(GetThreadDesktop);
#if(WINVER >= 0x0500)
    DETACH(GetThreadLocale);
#endif // (WINVER >= 0x0500)
    DETACH(GetThreadPriority);
    DETACH(GetThreadPriorityBoost);
    DETACH(GetThreadSelectorEntry);
    DETACH(GetThreadTimes);
    DETACH(GetTickCount);
    DETACH(GetTimeFormatA);
    DETACH(GetTimeFormatW);
    DETACH(GetTimeZoneInformation);
    DETACH(GetTopWindow);
    DETACH(GetUpdateRect);
    DETACH(GetUpdateRgn);
    DETACH(GetUserDefaultLCID);
    DETACH(GetUserDefaultLangID);
    DETACH(GetUserObjectInformationA);
    DETACH(GetUserObjectInformationW);
    DETACH(GetUserObjectSecurity);
    DETACH(GetVersion);
    DETACH(GetVersionExA);
    DETACH(GetVersionExW);
    DETACH(GetViewportExtEx);
    DETACH(GetViewportOrgEx);
    DETACH(GetVolumeInformationA);
    DETACH(GetVolumeInformationW);
    DETACH(GetWinMetaFileBits);
    DETACH(GetWindow);
    DETACH(GetWindowContextHelpId);
    DETACH(GetWindowDC);
    DETACH(GetWindowExtEx);
    DETACH(GetWindowLongA);
    DETACH(GetWindowLongW);
    DETACH(GetWindowOrgEx);
    DETACH(GetWindowPlacement);
    DETACH(GetWindowRect);
    DETACH(GetWindowRgn);
    DETACH(GetWindowTextA);
    DETACH(GetWindowTextLengthA);
    DETACH(GetWindowTextLengthW);
    DETACH(GetWindowTextW);
    DETACH(GetWindowThreadProcessId);
    DETACH(GetWindowWord);
    DETACH(GetWindowsDirectoryA);
    DETACH(GetWindowsDirectoryW);
    DETACH(GetWorldTransform);
    DETACH(GlobalAddAtomA);
    DETACH(GlobalAddAtomW);
    DETACH(GlobalAlloc);
    DETACH(GlobalCompact);
    DETACH(GlobalDeleteAtom);
    DETACH(GlobalFindAtomA);
    DETACH(GlobalFindAtomW);
    DETACH(GlobalFix);
    DETACH(GlobalFlags);
    DETACH(GlobalFree);
    DETACH(GlobalGetAtomNameA);
    DETACH(GlobalGetAtomNameW);
    DETACH(GlobalHandle);
    DETACH(GlobalLock);
    DETACH(GlobalMemoryStatus);
    DETACH(GlobalReAlloc);
    DETACH(GlobalSize);
    DETACH(GlobalUnWire);
    DETACH(GlobalUnfix);
    DETACH(GlobalUnlock);
    DETACH(GlobalWire);
    DETACH(GrayStringA);
    DETACH(GrayStringW);
    DETACH(HeapLock);
    DETACH(HeapUnlock);
    DETACH(HideCaret);
    DETACH(HiliteMenuItem);
    DETACH(IIDFromString);
    DETACH(ImpersonateDdeClientWindow);
    DETACH(InSendMessage);
    DETACH(InflateRect);
    DETACH(InitAtomTable);
    DETACH(InsertMenuA);
    DETACH(InsertMenuItemA);
    DETACH(InsertMenuItemW);
    DETACH(InsertMenuW);
    DETACH(IntersectClipRect);
    DETACH(IntersectRect);
    DETACH(InvalidateRect);
    DETACH(InvalidateRgn);
    DETACH(InvertRect);
    DETACH(InvertRgn);
    DETACH(IsAccelerator);
    DETACH(IsBadCodePtr);
    DETACH(IsBadHugeReadPtr);
    DETACH(IsBadHugeWritePtr);
    DETACH(IsBadReadPtr);
    DETACH(IsBadStringPtrA);
    DETACH(IsBadStringPtrW);
    DETACH(IsBadWritePtr);
    DETACH(IsCharAlphaA);
    DETACH(IsCharAlphaNumericA);
    DETACH(IsCharAlphaNumericW);
    DETACH(IsCharAlphaW);
    DETACH(IsCharLowerA);
    DETACH(IsCharLowerW);
    DETACH(IsCharUpperA);
    DETACH(IsCharUpperW);
    DETACH(IsChild);
    DETACH(IsClipboardFormatAvailable);
    DETACH(IsDBCSLeadByte);
    DETACH(IsDBCSLeadByteEx);
    DETACH(IsDebuggerPresent);
    DETACH(IsDialogMessageA);
    DETACH(IsDialogMessageW);
    DETACH(IsDlgButtonChecked);
    DETACH(IsIconic);
    DETACH(IsMenu);
#if !defined(DETOURS_ARM)
    DETACH(IsProcessorFeaturePresent);
#endif // !DETOURS_ARM
    DETACH(IsRectEmpty);
    DETACH(IsValidCodePage);
    DETACH(IsValidLocale);
    DETACH(IsWindow);
    DETACH(IsWindowEnabled);
    DETACH(IsWindowUnicode);
    DETACH(IsWindowVisible);
    DETACH(IsZoomed);
    DETACH(KillTimer);
    DETACH(LPtoDP);
    DETACH(LineDDA);
    DETACH(LineTo);
    DETACH(LoadAcceleratorsA);
    DETACH(LoadAcceleratorsW);
    DETACH(LoadBitmapA);
    DETACH(LoadBitmapW);
    DETACH(LoadCursorA);
    DETACH(LoadCursorFromFileA);
    DETACH(LoadCursorFromFileW);
    DETACH(LoadCursorW);
    DETACH(LoadIconA);
    DETACH(LoadIconW);
    DETACH(LoadImageA);
    DETACH(LoadImageW);
    DETACH(LoadKeyboardLayoutA);
    DETACH(LoadKeyboardLayoutW);
    DETACH(LoadLibraryA);
    DETACH(LoadLibraryExA);
    DETACH(LoadLibraryExW);
    DETACH(LoadLibraryW);
    DETACH(LoadMenuA);
    DETACH(LoadMenuIndirectA);
    DETACH(LoadMenuIndirectW);
    DETACH(LoadMenuW);
    DETACH(LoadModule);
    DETACH(LoadResource);
    DETACH(LoadStringA);
    DETACH(LoadStringW);
    DETACH(LocalAlloc);
    DETACH(LocalCompact);
    DETACH(LocalFileTimeToFileTime);
    DETACH(LocalFlags);
    DETACH(LocalFree);
    DETACH(LocalHandle);
    DETACH(LocalLock);
    DETACH(LocalReAlloc);
    DETACH(LocalShrink);
    DETACH(LocalSize);
    DETACH(LocalUnlock);
    DETACH(LockFile);
    DETACH(LockFileEx);
    DETACH(LockResource);
    DETACH(LockWindowUpdate);
    DETACH(LookupIconIdFromDirectory);
    DETACH(LookupIconIdFromDirectoryEx);
    DETACH(MapDialogRect);
    DETACH(MapViewOfFile);
    DETACH(MapViewOfFileEx);
    DETACH(MapVirtualKeyA);
    DETACH(MapVirtualKeyExA);
    DETACH(MapVirtualKeyExW);
    DETACH(MapVirtualKeyW);
    DETACH(MapWindowPoints);
    DETACH(MaskBlt);
    DETACH(MenuItemFromPoint);
    DETACH(MessageBeep);
    DETACH(MessageBoxA);
    DETACH(MessageBoxExA);
    DETACH(MessageBoxExW);
    DETACH(MessageBoxIndirectA);
    DETACH(MessageBoxIndirectW);
    DETACH(MessageBoxW);
    DETACH(MkParseDisplayName);
    DETACH(ModifyMenuA);
    DETACH(ModifyMenuW);
    DETACH(ModifyWorldTransform);
    DETACH(MonikerCommonPrefixWith);
    DETACH(MonikerRelativePathTo);
    DETACH(MoveFileA);
    DETACH(MoveFileExA);
    DETACH(MoveFileExW);
    DETACH(MoveFileW);
    DETACH(MoveToEx);
    DETACH(MoveWindow);
    DETACH(MsgWaitForMultipleObjects);
    DETACH(MsgWaitForMultipleObjectsEx);
    DETACH(MulDiv);
    DETACH(OemKeyScan);
    DETACH(OemToCharA);
    DETACH(OemToCharBuffA);
    DETACH(OemToCharBuffW);
    DETACH(OemToCharW);
    DETACH(OffsetClipRgn);
    DETACH(OffsetRect);
    DETACH(OffsetRgn);
    DETACH(OffsetViewportOrgEx);
    DETACH(OffsetWindowOrgEx);
    DETACH(OleBuildVersion);
    DETACH(OleConvertIStorageToOLESTREAM);
    DETACH(OleConvertIStorageToOLESTREAMEx);
    DETACH(OleConvertOLESTREAMToIStorage);
    DETACH(OleConvertOLESTREAMToIStorageEx);
    DETACH(OleCreate);
    DETACH(OleCreateDefaultHandler);
    DETACH(OleCreateEmbeddingHelper);
    DETACH(OleCreateEx);
    DETACH(OleCreateFromData);
    DETACH(OleCreateFromDataEx);
    DETACH(OleCreateFromFile);
    DETACH(OleCreateFromFileEx);
    DETACH(OleCreateLink);
    DETACH(OleCreateLinkEx);
    DETACH(OleCreateLinkFromData);
    DETACH(OleCreateLinkFromDataEx);
    DETACH(OleCreateLinkToFile);
    DETACH(OleCreateLinkToFileEx);
    DETACH(OleCreateMenuDescriptor);
    DETACH(OleCreateStaticFromData);
    DETACH(OleDestroyMenuDescriptor);
    DETACH(OleDoAutoConvert);
    DETACH(OleDraw);
    DETACH(OleDuplicateData);
    DETACH(OleFlushClipboard);
    DETACH(OleGetAutoConvert);
    DETACH(OleGetClipboard);
    DETACH(OleGetIconOfClass);
    DETACH(OleGetIconOfFile);
    DETACH(OleInitialize);
    DETACH(OleIsCurrentClipboard);
    DETACH(OleIsRunning);
    DETACH(OleLoad);
    DETACH(OleLoadFromStream);
    DETACH(OleLockRunning);
    DETACH(OleMetafilePictFromIconAndLabel);
    DETACH(OleNoteObjectVisible);
    DETACH(OleQueryCreateFromData);
    DETACH(OleQueryLinkFromData);
    DETACH(OleRegEnumFormatEtc);
    DETACH(OleRegEnumVerbs);
    DETACH(OleRegGetMiscStatus);
    DETACH(OleRegGetUserType);
    DETACH(OleRun);
    DETACH(OleSave);
    DETACH(OleSaveToStream);
    DETACH(OleSetAutoConvert);
    DETACH(OleSetClipboard);
    DETACH(OleSetContainedObject);
    DETACH(OleSetMenuDescriptor);
    DETACH(OleTranslateAccelerator);
    DETACH(OleUninitialize);
    DETACH(OpenClipboard);
    DETACH(OpenDesktopA);
    DETACH(OpenDesktopW);
    DETACH(OpenEventA);
    DETACH(OpenEventW);
    DETACH(OpenFile);
    DETACH(OpenFileMappingA);
    DETACH(OpenFileMappingW);
    DETACH(OpenIcon);
    DETACH(OpenInputDesktop);
    DETACH(OpenMutexA);
    DETACH(OpenMutexW);
    DETACH(OpenProcess);
    DETACH(OpenProcessToken);
    DETACH(OpenSemaphoreA);
    DETACH(OpenSemaphoreW);
    DETACH(OpenWaitableTimerA);
    DETACH(OpenWaitableTimerW);
    DETACH(OpenWindowStationA);
    DETACH(OpenWindowStationW);
    DETACH(OutputDebugStringA);
    DETACH(OutputDebugStringW);
    DETACH(PackDDElParam);
    DETACH(PaintDesktop);
    DETACH(PaintRgn);
    DETACH(PatBlt);
    DETACH(PathToRegion);
    DETACH(PeekConsoleInputA);
    DETACH(PeekConsoleInputW);
    DETACH(PeekMessageA);
    DETACH(PeekMessageW);
    DETACH(PeekNamedPipe);
    DETACH(Pie);
    DETACH(PlayEnhMetaFile);
    DETACH(PlayEnhMetaFileRecord);
    DETACH(PlayMetaFile);
    DETACH(PlayMetaFileRecord);
    DETACH(PlgBlt);
    DETACH(PolyBezier);
    DETACH(PolyBezierTo);
    DETACH(PolyDraw);
    DETACH(PolyPolygon);
    DETACH(PolyPolyline);
    DETACH(PolyTextOutA);
    DETACH(PolyTextOutW);
    DETACH(Polygon);
    DETACH(Polyline);
    DETACH(PolylineTo);
    DETACH(PostMessageA);
    DETACH(PostMessageW);
    DETACH(PostQueuedCompletionStatus);
    DETACH(PostQuitMessage);
    DETACH(PostThreadMessageA);
    DETACH(PostThreadMessageW);
    DETACH(PrepareTape);
    DETACH(ProgIDFromCLSID);
    DETACH(PropVariantClear);
    DETACH(PropVariantCopy);
    DETACH(PtInRect);
    DETACH(PtInRegion);
    DETACH(PtVisible);
    DETACH(PulseEvent);
    DETACH(PurgeComm);
    DETACH(QueryDosDeviceA);
    DETACH(QueryDosDeviceW);
    DETACH(QueryPerformanceCounter);
    DETACH(QueryPerformanceFrequency);
    DETACH(QueueUserAPC);
    DETACH(RaiseException);
    DETACH(ReadClassStg);
    DETACH(ReadClassStm);
    DETACH(ReadConsoleA);
    DETACH(ReadConsoleInputA);
    DETACH(ReadConsoleInputW);
    DETACH(ReadConsoleOutputA);
    DETACH(ReadConsoleOutputAttribute);
    DETACH(ReadConsoleOutputCharacterA);
    DETACH(ReadConsoleOutputCharacterW);
    DETACH(ReadConsoleOutputW);
    DETACH(ReadConsoleW);
    DETACH(ReadDirectoryChangesW);
    DETACH(ReadFile);
    DETACH(ReadFileEx);
    DETACH(ReadFmtUserTypeStg);
    DETACH(ReadProcessMemory);
    DETACH(RealizePalette);
    DETACH(RectInRegion);
    DETACH(RectVisible);
    DETACH(Rectangle);
    DETACH(RedrawWindow);
    DETACH(RegisterClassA);
    DETACH(RegisterClassExA);
    DETACH(RegisterClassExW);
    DETACH(RegisterClassW);
    DETACH(RegisterClipboardFormatA);
    DETACH(RegisterClipboardFormatW);
    DETACH(RegisterDragDrop);
    DETACH(RegisterHotKey);
    DETACH(RegisterWindowMessageA);
    DETACH(RegisterWindowMessageW);
    DETACH(ReleaseCapture);
    DETACH(ReleaseDC);
    DETACH(ReleaseMutex);
    DETACH(ReleaseSemaphore);
    DETACH(ReleaseStgMedium);
    DETACH(RemoveDirectoryA);
    DETACH(RemoveDirectoryW);
    DETACH(RemoveFontResourceA);
    DETACH(RemoveFontResourceW);
    DETACH(RemoveMenu);
    DETACH(RemovePropA);
    DETACH(RemovePropW);
    DETACH(ReplyMessage);
    DETACH(ResetDCA);
    DETACH(ResetDCW);
    DETACH(ResetEvent);
    DETACH(ResizePalette);
    DETACH(RestoreDC);
    DETACH(ResumeThread);
    DETACH(ReuseDDElParam);
    DETACH(RevokeDragDrop);
    DETACH(RoundRect);
    DETACH(SaveDC);
    DETACH(ScaleViewportExtEx);
    DETACH(ScaleWindowExtEx);
    DETACH(ScreenToClient);
    DETACH(ScrollConsoleScreenBufferA);
    DETACH(ScrollConsoleScreenBufferW);
    DETACH(ScrollDC);
    DETACH(ScrollWindow);
    DETACH(ScrollWindowEx);
    DETACH(SearchPathA);
    DETACH(SearchPathW);
    DETACH(SelectClipPath);
    DETACH(SelectClipRgn);
    DETACH(SelectObject);
    DETACH(SelectPalette);
    DETACH(SendDlgItemMessageA);
    DETACH(SendDlgItemMessageW);
    DETACH(SendMessageA);
    DETACH(SendMessageCallbackA);
    DETACH(SendMessageCallbackW);
    DETACH(SendMessageTimeoutA);
    DETACH(SendMessageTimeoutW);
    DETACH(SendMessageW);
    DETACH(SendNotifyMessageA);
    DETACH(SendNotifyMessageW);
    DETACH(SetAbortProc);
    DETACH(SetActiveWindow);
    DETACH(SetArcDirection);
    DETACH(SetBitmapBits);
    DETACH(SetBitmapDimensionEx);
    DETACH(SetBkColor);
    DETACH(SetBkMode);
    DETACH(SetBoundsRect);
    DETACH(SetBrushOrgEx);
    DETACH(SetCapture);
    DETACH(SetCaretBlinkTime);
    DETACH(SetCaretPos);
    DETACH(SetClassLongA);
    DETACH(SetClassLongW);
    DETACH(SetClassWord);
    DETACH(SetClipboardData);
    DETACH(SetClipboardViewer);
    DETACH(SetColorAdjustment);
    DETACH(SetColorSpace);
    DETACH(SetCommBreak);
    DETACH(SetCommConfig);
    DETACH(SetCommMask);
    DETACH(SetCommState);
    DETACH(SetCommTimeouts);
    DETACH(SetComputerNameA);
    DETACH(SetComputerNameW);
    DETACH(SetConsoleActiveScreenBuffer);
    DETACH(SetConsoleCP);
    DETACH(SetConsoleCtrlHandler);
    DETACH(SetConsoleCursorInfo);
    DETACH(SetConsoleCursorPosition);
    DETACH(SetConsoleMode);
    DETACH(SetConsoleOutputCP);
    DETACH(SetConsoleScreenBufferSize);
    DETACH(SetConsoleTextAttribute);
    DETACH(SetConsoleTitleA);
    DETACH(SetConsoleTitleW);
    DETACH(SetConsoleWindowInfo);
    DETACH(SetConvertStg);
    DETACH(SetCurrentDirectoryA);
    DETACH(SetCurrentDirectoryW);
    DETACH(SetCursor);
    DETACH(SetCursorPos);
    DETACH(SetDIBColorTable);
    DETACH(SetDIBits);
    DETACH(SetDIBitsToDevice);
    DETACH(SetDefaultCommConfigA);
    DETACH(SetDefaultCommConfigW);
    DETACH(SetDeviceGammaRamp);
    DETACH(SetDlgItemInt);
    DETACH(SetDlgItemTextA);
    DETACH(SetDlgItemTextW);
    DETACH(SetDoubleClickTime);
    DETACH(SetEndOfFile);
    DETACH(SetEnhMetaFileBits);
    DETACH(SetEnvironmentVariableA);
    DETACH(SetEnvironmentVariableW);
    DETACH(SetErrorMode);
    DETACH(SetEvent);
    DETACH(SetFileApisToANSI);
    DETACH(SetFileApisToOEM);
    DETACH(SetFileAttributesA);
    DETACH(SetFileAttributesW);
    DETACH(SetFilePointer);
    DETACH(SetFileTime);
    DETACH(SetFocus);
    DETACH(SetForegroundWindow);
    DETACH(SetGraphicsMode);
    DETACH(SetHandleCount);
    DETACH(SetHandleInformation);
    DETACH(SetICMMode);
    DETACH(SetICMProfileA);
    DETACH(SetICMProfileW);
    DETACH(SetKeyboardState);
    DETACH(SetLocalTime);
    DETACH(SetLocaleInfoA);
    DETACH(SetLocaleInfoW);
    DETACH(SetMailslotInfo);
    DETACH(SetMapMode);
    DETACH(SetMapperFlags);
    DETACH(SetMenu);
    DETACH(SetMenuContextHelpId);
    DETACH(SetMenuDefaultItem);
    DETACH(SetMenuItemBitmaps);
    DETACH(SetMenuItemInfoA);
    DETACH(SetMenuItemInfoW);
    DETACH(SetMessageExtraInfo);
    DETACH(SetMessageQueue);
    DETACH(SetMetaFileBitsEx);
    DETACH(SetMetaRgn);
    DETACH(SetMiterLimit);
    DETACH(SetNamedPipeHandleState);
    DETACH(SetPaletteEntries);
    DETACH(SetParent);
    DETACH(SetPixel);
    DETACH(SetPixelFormat);
    DETACH(SetPixelV);
    DETACH(SetPolyFillMode);
    DETACH(SetPriorityClass);
    DETACH(SetProcessAffinityMask);
    DETACH(SetProcessShutdownParameters);
    DETACH(SetProcessWindowStation);
    DETACH(SetProcessWorkingSetSize);
    DETACH(SetPropA);
    DETACH(SetPropW);
    DETACH(SetROP2);
    DETACH(SetRect);
    DETACH(SetRectEmpty);
    DETACH(SetRectRgn);
    DETACH(SetScrollInfo);
    DETACH(SetScrollPos);
    DETACH(SetScrollRange);
    DETACH(SetStdHandle);
    DETACH(SetStretchBltMode);
    DETACH(SetSysColors);
    DETACH(SetSystemCursor);
    DETACH(SetSystemPaletteUse);
    DETACH(SetSystemPowerState);
    DETACH(SetSystemTime);
    DETACH(SetSystemTimeAdjustment);
    DETACH(SetTapeParameters);
    DETACH(SetTapePosition);
    DETACH(SetTextAlign);
    DETACH(SetTextCharacterExtra);
    DETACH(SetTextColor);
    DETACH(SetTextJustification);
    DETACH(SetThreadAffinityMask);
    DETACH(SetThreadContext);
    DETACH(SetThreadDesktop);
    DETACH(SetThreadIdealProcessor);
#if(WINVER >= 0x0500)
    DETACH(SetThreadLocale);
#endif // (WINVER >= 0x0500)
    DETACH(SetThreadPriority);
    DETACH(SetThreadPriorityBoost);
    DETACH(SetTimeZoneInformation);
    DETACH(SetTimer);
    DETACH(SetUnhandledExceptionFilter);
    DETACH(SetUserObjectInformationA);
    DETACH(SetUserObjectInformationW);
    DETACH(SetUserObjectSecurity);
    DETACH(SetViewportExtEx);
    DETACH(SetViewportOrgEx);
    DETACH(SetVolumeLabelA);
    DETACH(SetVolumeLabelW);
    DETACH(SetWaitableTimer);
    DETACH(SetWinMetaFileBits);
    DETACH(SetWindowContextHelpId);
    DETACH(SetWindowExtEx);
    DETACH(SetWindowLongA);
    DETACH(SetWindowLongW);
    DETACH(SetWindowOrgEx);
    DETACH(SetWindowPlacement);
    DETACH(SetWindowPos);
    DETACH(SetWindowRgn);
    DETACH(SetWindowTextA);
    DETACH(SetWindowTextW);
    DETACH(SetWindowWord);
    DETACH(SetWindowsHookA);
    DETACH(SetWindowsHookExA);
    DETACH(SetWindowsHookExW);
    DETACH(SetWindowsHookW);
    DETACH(SetWorldTransform);
    DETACH(SetupComm);
    DETACH(ShowCaret);
    DETACH(ShowCursor);
    DETACH(ShowOwnedPopups);
    DETACH(ShowScrollBar);
    DETACH(ShowWindow);
    DETACH(ShowWindowAsync);
    DETACH(SignalObjectAndWait);
    DETACH(SizeofResource);
    DETACH(SleepEx);
    DETACH(StartDocA);
    DETACH(StartDocW);
    DETACH(StartPage);
    DETACH(StgCreateDocfile);
    DETACH(StgCreateDocfileOnILockBytes);
    DETACH(StgCreatePropSetStg);
    DETACH(StgCreatePropStg);
    DETACH(StgCreateStorageEx);
    DETACH(StgGetIFillLockBytesOnFile);
    DETACH(StgGetIFillLockBytesOnILockBytes);
    DETACH(StgIsStorageFile);
    DETACH(StgIsStorageILockBytes);
    DETACH(StgOpenAsyncDocfileOnIFillLockBytes);
    DETACH(StgOpenPropStg);
    DETACH(StgOpenStorage);
    DETACH(StgOpenStorageEx);
    DETACH(StgOpenStorageOnILockBytes);
    DETACH(StgSetTimes);
    DETACH(StretchBlt);
    DETACH(StretchDIBits);
    DETACH(StringFromCLSID);
    DETACH(StringFromGUID2);
    DETACH(StringFromIID);
    DETACH(StrokeAndFillPath);
    DETACH(StrokePath);
    DETACH(SubtractRect);
    DETACH(SuspendThread);
    DETACH(SwapBuffers);
    DETACH(SwapMouseButton);
    DETACH(SwitchDesktop);
    DETACH(SwitchToFiber);
    DETACH(SwitchToThread);
    DETACH(SystemParametersInfoA);
    DETACH(SystemParametersInfoW);
    DETACH(SystemTimeToFileTime);
    DETACH(SystemTimeToTzSpecificLocalTime);
    DETACH(TabbedTextOutA);
    DETACH(TabbedTextOutW);
    DETACH(TerminateProcess);
    DETACH(TerminateThread);
    DETACH(TextOutA);
    DETACH(TextOutW);
    DETACH(TileWindows);
    DETACH(ToAscii);
    DETACH(ToAsciiEx);
    DETACH(ToUnicode);
    DETACH(ToUnicodeEx);
    DETACH(TrackMouseEvent);
    DETACH(TrackPopupMenu);
    DETACH(TrackPopupMenuEx);
    DETACH(TransactNamedPipe);
    DETACH(TranslateAcceleratorA);
    DETACH(TranslateAcceleratorW);
    DETACH(TranslateCharsetInfo);
    DETACH(TranslateMDISysAccel);
    DETACH(TranslateMessage);
    DETACH(TransmitCommChar);
#if DETOUR_TryEnterCriticalSection_EVEN_IF_IT_EXERCISES_A_BUG_IN_RtlLookupFunctionTable
    DETACH(TryEnterCriticalSection);
#endif
    DETACH(UnhookWindowsHook);
    DETACH(UnhookWindowsHookEx);
    DETACH(UnionRect);
    DETACH(UnloadKeyboardLayout);
    DETACH(UnlockFile);
    DETACH(UnlockFileEx);
    DETACH(UnmapViewOfFile);
    DETACH(UnpackDDElParam);
    DETACH(UnrealizeObject);
    DETACH(UnregisterClassA);
    DETACH(UnregisterClassW);
    DETACH(UnregisterHotKey);
    DETACH(UpdateColors);
    DETACH(UpdateResourceA);
    DETACH(UpdateResourceW);
    DETACH(UpdateWindow);
    DETACH(ValidateRect);
    DETACH(ValidateRgn);
    DETACH(VerLanguageNameA);
    DETACH(VerLanguageNameW);
    DETACH(VirtualAllocEx);
    DETACH(VirtualFreeEx);
    DETACH(VirtualProtectEx);
    DETACH(VirtualQueryEx);
    DETACH(VkKeyScanA);
    DETACH(VkKeyScanExA);
    DETACH(VkKeyScanExW);
    DETACH(VkKeyScanW);
    DETACH(WSAAccept);
    DETACH(WSAAddressToStringA);
    DETACH(WSAAddressToStringW);
    DETACH(WSAAsyncGetHostByAddr);
    DETACH(WSAAsyncGetHostByName);
    DETACH(WSAAsyncGetProtoByName);
    DETACH(WSAAsyncGetProtoByNumber);
    DETACH(WSAAsyncGetServByName);
    DETACH(WSAAsyncGetServByPort);
    DETACH(WSAAsyncSelect);
    DETACH(WSACancelAsyncRequest);
    DETACH(WSACancelBlockingCall);
    DETACH(WSACleanup);
    DETACH(WSACloseEvent);
    DETACH(WSAConnect);
    DETACH(WSACreateEvent);
    DETACH(WSADuplicateSocketA);
    DETACH(WSADuplicateSocketW);
    DETACH(WSAEnumNameSpaceProvidersA);
    DETACH(WSAEnumNameSpaceProvidersW);
    DETACH(WSAEnumNetworkEvents);
    DETACH(WSAEnumProtocolsA);
    DETACH(WSAEnumProtocolsW);
    DETACH(WSAEventSelect);
    DETACH(WSAGetOverlappedResult);
    DETACH(WSAGetQOSByName);
    DETACH(WSAGetServiceClassInfoA);
    DETACH(WSAGetServiceClassInfoW);
    DETACH(WSAGetServiceClassNameByClassIdA);
    DETACH(WSAGetServiceClassNameByClassIdW);
    DETACH(WSAHtonl);
    DETACH(WSAHtons);
    DETACH(WSAInstallServiceClassA);
    DETACH(WSAInstallServiceClassW);
    DETACH(WSAIoctl);
    DETACH(WSAIsBlocking);
    DETACH(WSAJoinLeaf);
    DETACH(WSALookupServiceBeginA);
    DETACH(WSALookupServiceBeginW);
    DETACH(WSALookupServiceEnd);
    DETACH(WSALookupServiceNextA);
    DETACH(WSALookupServiceNextW);
    DETACH(WSANtohl);
    DETACH(WSANtohs);
    DETACH(WSAProviderConfigChange);
    DETACH(WSARecv);
    DETACH(WSARecvDisconnect);
    DETACH(WSARecvFrom);
    DETACH(WSARemoveServiceClass);
    DETACH(WSAResetEvent);
    DETACH(WSASend);
    DETACH(WSASendDisconnect);
    DETACH(WSASendTo);
    DETACH(WSASetBlockingHook);
    DETACH(WSASetEvent);
    DETACH(WSASetServiceA);
    DETACH(WSASetServiceW);
    DETACH(WSASocketA);
    DETACH(WSASocketW);
    DETACH(WSAStartup);
    DETACH(WSAStringToAddressA);
    DETACH(WSAStringToAddressW);
    DETACH(WSAUnhookBlockingHook);
    DETACH(WSAWaitForMultipleEvents);
    DETACH(WaitCommEvent);
#if !defined(DETOURS_ARM)
    DETACH(WaitForDebugEvent);
#endif // !DETOURS_ARM
    DETACH(WaitForInputIdle);
    DETACH(WaitForMultipleObjects);
    DETACH(WaitForMultipleObjectsEx);
    DETACH(WaitForSingleObject);
    DETACH(WaitForSingleObjectEx);
    DETACH(WaitMessage);
    DETACH(WaitNamedPipeA);
    DETACH(WaitNamedPipeW);
    DETACH(WidenPath);
    DETACH(WinExec);
    DETACH(WinHelpA);
    DETACH(WinHelpW);
    DETACH(WindowFromDC);
    DETACH(WindowFromPoint);
    DETACH(WriteClassStg);
    DETACH(WriteClassStm);
    DETACH(WriteConsoleA);
    DETACH(WriteConsoleInputA);
    DETACH(WriteConsoleInputW);
    DETACH(WriteConsoleOutputA);
    DETACH(WriteConsoleOutputAttribute);
    DETACH(WriteConsoleOutputCharacterA);
    DETACH(WriteConsoleOutputCharacterW);
    DETACH(WriteConsoleOutputW);
    DETACH(WriteConsoleW);
    DETACH(WriteFile);
    DETACH(WriteFileEx);
    DETACH(WriteFmtUserTypeStg);
    DETACH(WritePrivateProfileSectionA);
    DETACH(WritePrivateProfileSectionW);
    DETACH(WritePrivateProfileStringA);
    DETACH(WritePrivateProfileStringW);
    DETACH(WritePrivateProfileStructA);
    DETACH(WritePrivateProfileStructW);
    DETACH(WriteProcessMemory);
    DETACH(WriteProfileSectionA);
    DETACH(WriteProfileSectionW);
    DETACH(WriteProfileStringA);
    DETACH(WriteProfileStringW);
    DETACH(WriteTapemark);
    DETACH(__WSAFDIsSet);
    DETACH(_hread);
    DETACH(_hwrite);
    DETACH(_lclose);
    DETACH(_lcreat);
    DETACH(_llseek);
    DETACH(_lopen);
    DETACH(_lread);
    DETACH(_lwrite);
    DETACH(accept);
    DETACH(bind);
    DETACH(closesocket);
    DETACH(connect);
    DETACH(gethostbyaddr);
    DETACH(gethostbyname);
    DETACH(gethostname);
    DETACH(getpeername);
    DETACH(getprotobyname);
    DETACH(getprotobynumber);
    DETACH(getservbyname);
    DETACH(getservbyport);
    DETACH(getsockname);
    DETACH(getsockopt);
    DETACH(htonl);
    DETACH(htons);
    DETACH(inet_addr);
    DETACH(inet_ntoa);
    DETACH(ioctlsocket);
    DETACH(keybd_event);
    DETACH(listen);
    DETACH(mouse_event);
    DETACH(ntohl);
    DETACH(ntohs);
    DETACH(recv);
    DETACH(recvfrom);
    DETACH(select);
    DETACH(send);
    DETACH(sendto);
    DETACH(setsockopt);
    DETACH(shutdown);
    DETACH(socket);

    if (DetourTransactionCommit() != 0) {
        PVOID *ppbFailedPointer = NULL;
        LONG error = DetourTransactionCommitEx(&ppbFailedPointer);

        printf("traceapi.dll: Detach transaction failed to commit. Error %ld (%p/%p)",
               error, ppbFailedPointer, *ppbFailedPointer);
        return error;
    }
    return 0;
}
//
///////////////////////////////////////////////////////////////// End of File.
