diff options
Diffstat (limited to 'samples/traceapi')
| -rw-r--r-- | samples/traceapi/Makefile | 153 | ||||
| -rw-r--r-- | samples/traceapi/_win32.cpp | 37069 | ||||
| -rw-r--r-- | samples/traceapi/testapi.cpp | 94 | ||||
| -rw-r--r-- | samples/traceapi/trcapi.cpp | 473 | ||||
| -rw-r--r-- | samples/traceapi/trcapi.rc | 17 |
5 files changed, 37806 insertions, 0 deletions
diff --git a/samples/traceapi/Makefile b/samples/traceapi/Makefile new file mode 100644 index 0000000..61794b1 --- /dev/null +++ b/samples/traceapi/Makefile @@ -0,0 +1,153 @@ +############################################################################## +## +## Utility to trace Win32 APIs. +## +## Microsoft Research Detours Package +## +## Copyright (c) Microsoft Corporation. All rights reserved. +## + +!include ..\common.mak + +LIBS=$(LIBS) kernel32.lib gdi32.lib user32.lib shell32.lib advapi32.lib ole32.lib ws2_32.lib + +############################################################################## + +all: dirs \ + $(BIND)\trcapi$(DETOURS_BITS).dll \ + $(BIND)\testapi.exe \ +!IF $(DETOURS_SOURCE_BROWSING)==1 + $(OBJD)\trcapi$(DETOURS_BITS).bsc \ + $(OBJD)\testapi.bsc \ +!ENDIF + option + +############################################################################## + +clean: + -del *~ test.txt 2>nul + -del $(BIND)\trcapi*.* $(BIND)\testapi.* 2>nul + -rmdir /q /s $(OBJD) 2>nul + +realclean: clean + -rmdir /q /s $(OBJDS) 2>nul + +dirs: + @if not exist $(BIND) mkdir $(BIND) && echo. Created $(BIND) + @if not exist $(OBJD) mkdir $(OBJD) && echo. Created $(OBJD) + +$(OBJD)\trcapi.obj : trcapi.cpp _win32.cpp + +$(OBJD)\trcapi.res : trcapi.rc + +$(BIND)\trcapi$(DETOURS_BITS).dll: $(OBJD)\trcapi.obj $(OBJD)\trcapi.res $(DEPS) + cl /LD $(CFLAGS) /Fe$@ /Fd$(@R).pdb \ + $(OBJD)\trcapi.obj $(OBJD)\trcapi.res \ + /link $(LINKFLAGS) /release /subsystem:console \ + /export:DetourFinishHelperProcess,@1,NONAME \ + $(LIBS) + +$(OBJD)\trcapi$(DETOURS_BITS).bsc : $(OBJD)\trcapi.obj + bscmake /v /n /o $@ $(OBJD)\trcapi.sbr + +$(OBJD)\testapi.obj : testapi.cpp trcapi.cpp _win32.cpp + +$(BIND)\testapi.exe : $(OBJD)\testapi.obj $(DEPS) + cl $(CFLAGS) /Fe$@ /Fd$(@R).pdb $(OBJD)\testapi.obj \ + /link $(LINKFLAGS) $(LIBS) \ + /subsystem:console /fixed:no + +$(OBJD)\testapi.bsc : $(OBJD)\testapi.obj + bscmake /v /n /o $@ $(OBJD)\testapi.sbr + +############################################### Install non-bit-size binaries. + +!IF "$(DETOURS_OPTION_PROCESSOR)" != "" + +$(OPTD)\trcapi$(DETOURS_OPTION_BITS).dll: +$(OPTD)\trcapi$(DETOURS_OPTION_BITS).pdb: + +$(BIND)\trcapi$(DETOURS_OPTION_BITS).dll : $(OPTD)\trcapi$(DETOURS_OPTION_BITS).dll + @if exist $? copy /y $? $(BIND) >nul && echo $@ copied from $(DETOURS_OPTION_PROCESSOR). +$(BIND)\trcapi$(DETOURS_OPTION_BITS).pdb : $(OPTD)\trcapi$(DETOURS_OPTION_BITS).pdb + @if exist $? copy /y $? $(BIND) >nul && echo $@ copied from $(DETOURS_OPTION_PROCESSOR). + +option: \ + $(BIND)\trcapi$(DETOURS_OPTION_BITS).dll \ + $(BIND)\trcapi$(DETOURS_OPTION_BITS).pdb \ + +!ELSE + +option: + +!ENDIF + +############################################################################## + +test: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(BIND)\sleepold.exe + @echo -------- Log from syelog ------------- + type test.txt + +debug: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + windbg -o -g -G $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(BIND)\sleepold.exe + @echo -------- Log from syelog ------------- + type test.txt + +calc: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /q /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(SYSTEMROOT)\System32\calc.exe + @echo -------- Log from syelog ------------- + wc test.txt + +explorer: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /q /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(SYSTEMROOT)\explorer.exe + @echo -------- Log from syelog ------------- + wc test.txt + +wordpad: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /q /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(PROGRAMFILES)\Windows NT\Accessories\wordpad.exe + @echo -------- Log from syelog ------------- + wc test.txt + +notepad: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /q /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(SYSTEMROOT)\notepad.exe + @echo -------- Log from syelog ------------- + wc test.txt + +ie: all + @echo -------- Logging output to test.txt ------------ + start $(BIND)\syelogd.exe /q /o test.txt + $(BIND)\sleep5.exe 1 + @echo -------- Should load trcapi$(DETOURS_BITS).dll dynamically using withdll.exe ------------ + windbg -g -G -o $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll "$(PROGRAMFILES)\Internet Explorer\iexplore.exe" + @echo -------- Log from syelog ------------- + wc test.txt + +ws: all + $(BIND)\withdll -d:$(BIND)\trcapi$(DETOURS_BITS).dll $(BIND)\WebServiceTester.exe + +################################################################# End of File. diff --git a/samples/traceapi/_win32.cpp b/samples/traceapi/_win32.cpp new file mode 100644 index 0000000..f28daf3 --- /dev/null +++ b/samples/traceapi/_win32.cpp @@ -0,0 +1,37069 @@ +////////////////////////////////////////////////////////////////////////////// +// +// 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. diff --git a/samples/traceapi/testapi.cpp b/samples/traceapi/testapi.cpp new file mode 100644 index 0000000..d85fc02 --- /dev/null +++ b/samples/traceapi/testapi.cpp @@ -0,0 +1,94 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Detours Test Program (testapi.cpp of testapi.exe) +// +// Microsoft Research Detours Package +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +#include "trcapi.cpp" + +#if (_MSC_VER < 1299) +typedef ULONG * PULONG_PTR; +typedef ULONG ULONG_PTR; +typedef LONG * PLONG_PTR; +typedef LONG LONG_PTR; +#endif + +VOID SyelogOpen(PCSTR pszIdentifier, BYTE nFacility) +{ + (void)pszIdentifier; + (void)nFacility; +} + +VOID SyelogExV(BOOL fTerminate, BYTE nSeverity, PCSTR pszMsgf, va_list args) +{ + (void)fTerminate; + + CHAR szBuffer[1024]; + PCHAR psz = szBuffer; + BOOL fLf = FALSE; + + StringCchPrintfA(psz, szBuffer + sizeof(szBuffer) - psz, "--.%02x: ", nSeverity); + while (*psz) { + psz++; + } + + StringCchVPrintfA(psz, szBuffer + sizeof(szBuffer) - psz, pszMsgf, args); + for (psz = szBuffer; *psz; psz++) { + if (*psz == '\n') { + if (fLf) { + *psz = '\0'; + break; + } + fLf = TRUE; + } + } + if (!fLf) { + *psz++ = '\n'; + *psz = '\0'; + } + printf("%s", szBuffer); + Real_OutputDebugStringA(szBuffer); +} + +VOID SyelogV(BYTE nSeverity, PCSTR pszMsgf, va_list args) +{ + SyelogExV(FALSE, nSeverity, pszMsgf, args); +} + +VOID Syelog(BYTE nSeverity, PCSTR pszMsgf, ...) +{ + va_list args; + va_start(args, pszMsgf); + SyelogExV(FALSE, nSeverity, pszMsgf, args); + va_end(args); +} + +VOID SyelogEx(BOOL fTerminate, BYTE nSeverity, PCSTR pszMsgf, ...) +{ + va_list args; + va_start(args, pszMsgf); + SyelogExV(fTerminate, nSeverity, pszMsgf, args); + va_end(args); +} + +VOID SyelogClose(BOOL fTerminate) +{ + (void)fTerminate; +} + +DWORD main(int argc, char **argv) +{ + (void)argc; + (void)argv; + + printf("testapi: Starting\n"); + ProcessAttach(NULL); + Sleep(100); + ProcessDetach(NULL); + + return 0; +} +// +////////////////////////////////////////////////////////////////////////////// diff --git a/samples/traceapi/trcapi.cpp b/samples/traceapi/trcapi.cpp new file mode 100644 index 0000000..e7b7240 --- /dev/null +++ b/samples/traceapi/trcapi.cpp @@ -0,0 +1,473 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Detours Test Program (trcapi.cpp of trcapi.dll) +// +// Microsoft Research Detours Package +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +#undef WIN32_LEAN_AND_MEAN +#define _WIN32_WINNT 0x400 +#define WIN32 +#define NT +#define _WINSOCK_DEPRECATED_NO_WARNINGS + +#define DBG_TRACE 0 + +#if _MSC_VER >= 1300 +#include <winsock2.h> +#endif +#include <windows.h> +#include <stdio.h> +#pragma warning(push) +#if _MSC_VER > 1400 +#pragma warning(disable:6102 6103) // /analyze warnings +#endif +#include <strsafe.h> +#pragma warning(pop) +#include "detours.h" +#include "syelog.h" + +#if (_MSC_VER < 1299) +#define LONG_PTR LONG +#define ULONG_PTR ULONG +#define PLONG_PTR PLONG +#define PULONG_PTR PULONG +#define INT_PTR INT +#define UINT_PTR UINT +#define PINT_PTR PINT +#define PUINT_PTR PUINT +#define DWORD_PTR DWORD +#define PDWORD_PTR PDWORD +#endif + +#pragma warning(disable:4996) // We don't care about deprecated APIs. + +////////////////////////////////////////////////////////////////////////////// +#pragma warning(disable:4127) // Many of our asserts are constants. + +#define ASSERT_ALWAYS(x) \ + do { \ + if (!(x)) { \ + AssertMessage(#x, __FILE__, __LINE__); \ + DebugBreak(); \ + } \ + } while (0) + +#ifndef NDEBUG +#define ASSERT(x) ASSERT_ALWAYS(x) +#else +#define ASSERT(x) +#endif + +#define UNUSED(c) (c) = (c) + +////////////////////////////////////////////////////////////////////////////// +static HMODULE s_hInst = NULL; +static WCHAR s_wzDllPath[MAX_PATH]; +static CHAR s_szDllPath[MAX_PATH]; + +BOOL ProcessEnumerate(); +BOOL InstanceEnumerate(HINSTANCE hInst); + +VOID _PrintEnter(const CHAR *psz, ...); +VOID _PrintExit(const CHAR *psz, ...); +VOID _Print(const CHAR *psz, ...); +VOID _VPrint(PCSTR msg, va_list args, PCHAR pszBuf, LONG cbBuf); + +VOID AssertMessage(CONST PCHAR pszMsg, CONST PCHAR pszFile, ULONG nLine); + +////////////////////////////////////////////////////////////////////////////// +// +// Trampolines +// +extern "C" { + // Trampolines for SYELOG library. + // + extern HANDLE (WINAPI *Real_CreateFileW)(LPCWSTR a0, DWORD a1, DWORD a2, + LPSECURITY_ATTRIBUTES a3, DWORD a4, DWORD a5, + HANDLE a6); + extern BOOL (WINAPI *Real_WriteFile)(HANDLE hFile, + LPCVOID lpBuffer, + DWORD nNumberOfBytesToWrite, + LPDWORD lpNumberOfBytesWritten, + LPOVERLAPPED lpOverlapped); + extern BOOL (WINAPI *Real_FlushFileBuffers)(HANDLE hFile); + extern BOOL (WINAPI *Real_CloseHandle)(HANDLE hObject); + extern BOOL (WINAPI *Real_WaitNamedPipeW)(LPCWSTR lpNamedPipeName, DWORD nTimeOut); + extern BOOL (WINAPI *Real_SetNamedPipeHandleState)(HANDLE hNamedPipe, + LPDWORD lpMode, + LPDWORD lpMaxCollectionCount, + LPDWORD lpCollectDataTimeout); + extern DWORD (WINAPI *Real_GetCurrentProcessId)(VOID); + extern VOID (WINAPI *Real_GetSystemTimeAsFileTime)(LPFILETIME lpSystemTimeAsFileTime); + + VOID ( WINAPI * Real_InitializeCriticalSection)(LPCRITICAL_SECTION lpSection) + = InitializeCriticalSection; + VOID ( WINAPI * Real_EnterCriticalSection)(LPCRITICAL_SECTION lpSection) + = EnterCriticalSection; + VOID ( WINAPI * Real_LeaveCriticalSection)(LPCRITICAL_SECTION lpSection) + = LeaveCriticalSection; +} + +#include "_win32.cpp" + +////////////////////////////////////////////////////////////// Logging System. +// +static BOOL s_bLog = FALSE; +static LONG s_nTlsIndent = -1; +static LONG s_nTlsThread = -1; +static LONG s_nThreadCnt = 0; + +VOID _PrintEnter(const CHAR *psz, ...) +{ + DWORD dwErr = GetLastError(); + + LONG nIndent = 0; + LONG nThread = 0; + if (s_nTlsIndent >= 0) { + nIndent = (LONG)(LONG_PTR)TlsGetValue(s_nTlsIndent); + TlsSetValue(s_nTlsIndent, (PVOID)(LONG_PTR)(nIndent + 1)); + } + if (s_nTlsThread >= 0) { + nThread = (LONG)(LONG_PTR)TlsGetValue(s_nTlsThread); + } + + if (s_bLog && psz) { + CHAR szBuf[1024]; + PCHAR pszBuf = szBuf; + PCHAR pszEnd = szBuf + ARRAYSIZE(szBuf) - 1; + LONG nLen = (nIndent > 0) ? (nIndent < 35 ? nIndent * 2 : 70) : 0; + *pszBuf++ = (CHAR)('0' + ((nThread / 100) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 10) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 1) % 10)); + *pszBuf++ = ' '; + while (nLen-- > 0) { + *pszBuf++ = ' '; + } + *pszBuf++ = '+'; + *pszBuf = '\0'; + + va_list args; + va_start(args, psz); + + while ((*pszBuf++ = *psz++) != 0 && pszBuf < pszEnd) { + // Copy characters. + } + *pszEnd = '\0'; + SyelogV(SYELOG_SEVERITY_INFORMATION, szBuf, args); + + va_end(args); + } + SetLastError(dwErr); +} + +VOID _PrintExit(const CHAR *psz, ...) +{ + DWORD dwErr = GetLastError(); + + LONG nIndent = 0; + LONG nThread = 0; + if (s_nTlsIndent >= 0) { + nIndent = (LONG)(LONG_PTR)TlsGetValue(s_nTlsIndent) - 1; + ASSERT_ALWAYS(nIndent >= 0); + TlsSetValue(s_nTlsIndent, (PVOID)(LONG_PTR)nIndent); + } + if (s_nTlsThread >= 0) { + nThread = (LONG)(LONG_PTR)TlsGetValue(s_nTlsThread); + } + + if (s_bLog && psz) { + CHAR szBuf[1024]; + PCHAR pszEnd = szBuf + ARRAYSIZE(szBuf) - 1; + PCHAR pszBuf = szBuf; + LONG nLen = (nIndent > 0) ? (nIndent < 35 ? nIndent * 2 : 70) : 0; + *pszBuf++ = (CHAR)('0' + ((nThread / 100) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 10) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 1) % 10)); + *pszBuf++ = ' '; + while (nLen-- > 0) { + *pszBuf++ = ' '; + } + *pszBuf++ = '-'; + *pszBuf = '\0'; + + va_list args; + va_start(args, psz); + + while ((*pszBuf++ = *psz++) != 0 && pszBuf < pszEnd) { + // Copy characters. + } + *pszEnd = '\0'; + SyelogV(SYELOG_SEVERITY_INFORMATION, szBuf, args); + + va_end(args); + } + SetLastError(dwErr); +} + +VOID _Print(const CHAR *psz, ...) +{ + DWORD dwErr = GetLastError(); + + LONG nIndent = 0; + LONG nThread = 0; + if (s_nTlsIndent >= 0) { + nIndent = (LONG)(LONG_PTR)TlsGetValue(s_nTlsIndent); + } + if (s_nTlsThread >= 0) { + nThread = (LONG)(LONG_PTR)TlsGetValue(s_nTlsThread); + } + + if (s_bLog && psz) { + CHAR szBuf[1024]; + PCHAR pszEnd = szBuf + ARRAYSIZE(szBuf) - 1; + PCHAR pszBuf = szBuf; + LONG nLen = (nIndent > 0) ? (nIndent < 35 ? nIndent * 2 : 70) : 0; + *pszBuf++ = (CHAR)('0' + ((nThread / 100) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 10) % 10)); + *pszBuf++ = (CHAR)('0' + ((nThread / 1) % 10)); + *pszBuf++ = ' '; + while (nLen-- > 0) { + *pszBuf++ = ' '; + } + *pszBuf = '\0'; + + va_list args; + va_start(args, psz); + + while ((*pszBuf++ = *psz++) != 0 && pszBuf < pszEnd) { + // Copy characters. + } + *pszEnd = '\0'; + SyelogV(SYELOG_SEVERITY_INFORMATION, szBuf, args); + + va_end(args); + } + SetLastError(dwErr); +} + +VOID AssertMessage(CONST PCHAR pszMsg, CONST PCHAR pszFile, ULONG nLine) +{ + Syelog(SYELOG_SEVERITY_FATAL, + "ASSERT(%s) failed in %s, line %d.\n", pszMsg, pszFile, nLine); +} + +////////////////////////////////////////////////////////////////////////////// +// +PIMAGE_NT_HEADERS NtHeadersForInstance(HINSTANCE hInst) +{ + PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)hInst; + __try { + if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) { + SetLastError(ERROR_BAD_EXE_FORMAT); + return NULL; + } + + PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((PBYTE)pDosHeader + + pDosHeader->e_lfanew); + if (pNtHeader->Signature != IMAGE_NT_SIGNATURE) { + SetLastError(ERROR_INVALID_EXE_SIGNATURE); + return NULL; + } + if (pNtHeader->FileHeader.SizeOfOptionalHeader == 0) { + SetLastError(ERROR_EXE_MARKED_INVALID); + return NULL; + } + return pNtHeader; + } __except(EXCEPTION_EXECUTE_HANDLER) { + } + SetLastError(ERROR_EXE_MARKED_INVALID); + + return NULL; +} + +BOOL InstanceEnumerate(HINSTANCE hInst) +{ + WCHAR wzDllName[MAX_PATH]; + + PIMAGE_NT_HEADERS pinh = NtHeadersForInstance(hInst); + if (pinh && Real_GetModuleFileNameW(hInst, wzDllName, ARRAYSIZE(wzDllName))) { + Syelog(SYELOG_SEVERITY_INFORMATION, "### %p: %ls\n", hInst, wzDllName); + return TRUE; + } + return FALSE; +} + +BOOL ProcessEnumerate() +{ + Syelog(SYELOG_SEVERITY_INFORMATION, + "######################################################### Binaries\n"); + + PBYTE pbNext; + for (PBYTE pbRegion = (PBYTE)0x10000;; pbRegion = pbNext) { + MEMORY_BASIC_INFORMATION mbi; + ZeroMemory(&mbi, sizeof(mbi)); + + if (VirtualQuery((PVOID)pbRegion, &mbi, sizeof(mbi)) <= 0) { + break; + } + pbNext = (PBYTE)mbi.BaseAddress + mbi.RegionSize; + + // Skip free regions, reserver regions, and guard pages. + // + if (mbi.State == MEM_FREE || mbi.State == MEM_RESERVE) { + continue; + } + if (mbi.Protect & PAGE_GUARD || mbi.Protect & PAGE_NOCACHE) { + continue; + } + if (mbi.Protect == PAGE_NOACCESS) { + continue; + } + + // Skip over regions from the same allocation... + { + MEMORY_BASIC_INFORMATION mbiStep; + + while (VirtualQuery((PVOID)pbNext, &mbiStep, sizeof(mbiStep)) > 0) { + if ((PBYTE)mbiStep.AllocationBase != pbRegion) { + break; + } + pbNext = (PBYTE)mbiStep.BaseAddress + mbiStep.RegionSize; + mbi.Protect |= mbiStep.Protect; + } + } + + WCHAR wzDllName[MAX_PATH]; + PIMAGE_NT_HEADERS pinh = NtHeadersForInstance((HINSTANCE)pbRegion); + + if (pinh && + Real_GetModuleFileNameW((HINSTANCE)pbRegion,wzDllName,ARRAYSIZE(wzDllName))) { + + Syelog(SYELOG_SEVERITY_INFORMATION, + "### %p..%p: %ls\n", pbRegion, pbNext, wzDllName); + } + else { + Syelog(SYELOG_SEVERITY_INFORMATION, + "### %p..%p: State=%04x, Protect=%08x\n", + pbRegion, pbNext, mbi.State, mbi.Protect); + } + } + Syelog(SYELOG_SEVERITY_INFORMATION, "###\n"); + + LPVOID lpvEnv = Real_GetEnvironmentStrings(); + Syelog(SYELOG_SEVERITY_INFORMATION, "### Env= %08x [%08x %08x]\n", + lpvEnv, ((PVOID*)lpvEnv)[0], ((PVOID*)lpvEnv)[1]); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////// +// +// DLL module information +// +BOOL ThreadAttach(HMODULE hDll) +{ + (void)hDll; + + if (s_nTlsIndent >= 0) { + TlsSetValue(s_nTlsIndent, (PVOID)0); + } + if (s_nTlsThread >= 0) { + LONG nThread = InterlockedIncrement(&s_nThreadCnt); + TlsSetValue(s_nTlsThread, (PVOID)(LONG_PTR)nThread); + } + return TRUE; +} + +BOOL ThreadDetach(HMODULE hDll) +{ + (void)hDll; + + if (s_nTlsIndent >= 0) { + TlsSetValue(s_nTlsIndent, (PVOID)0); + } + if (s_nTlsThread >= 0) { + TlsSetValue(s_nTlsThread, (PVOID)0); + } + return TRUE; +} + +BOOL ProcessAttach(HMODULE hDll) +{ + s_bLog = FALSE; + s_nTlsIndent = TlsAlloc(); + s_nTlsThread = TlsAlloc(); + ThreadAttach(hDll); + + WCHAR wzExeName[MAX_PATH]; + + s_hInst = hDll; + Real_GetModuleFileNameW(hDll, s_wzDllPath, ARRAYSIZE(s_wzDllPath)); + Real_GetModuleFileNameW(NULL, wzExeName, ARRAYSIZE(wzExeName)); + StringCchPrintfA(s_szDllPath, ARRAYSIZE(s_szDllPath), "%ls", s_wzDllPath); + + SyelogOpen("trcapi" DETOURS_STRINGIFY(DETOURS_BITS), SYELOG_FACILITY_APPLICATION); + ProcessEnumerate(); + + LONG error = AttachDetours(); + if (error != NO_ERROR) { + Syelog(SYELOG_SEVERITY_FATAL, "### Error attaching detours: %d\n", error); + } + + s_bLog = TRUE; + return TRUE; +} + +BOOL ProcessDetach(HMODULE hDll) +{ + ThreadDetach(hDll); + s_bLog = FALSE; + + LONG error = DetachDetours(); + if (error != NO_ERROR) { + Syelog(SYELOG_SEVERITY_FATAL, "### Error detaching detours: %d\n", error); + } + + Syelog(SYELOG_SEVERITY_NOTICE, "### Closing.\n"); + SyelogClose(FALSE); + + if (s_nTlsIndent >= 0) { + TlsFree(s_nTlsIndent); + } + if (s_nTlsThread >= 0) { + TlsFree(s_nTlsThread); + } + return TRUE; +} + +BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD dwReason, PVOID lpReserved) +{ + (void)hModule; + (void)lpReserved; + BOOL ret; + + if (DetourIsHelperProcess()) { + return TRUE; + } + + switch (dwReason) { + case DLL_PROCESS_ATTACH: + DetourRestoreAfterWith(); + OutputDebugStringA("trcapi" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:" + " DllMain DLL_PROCESS_ATTACH\n"); + return ProcessAttach(hModule); + case DLL_PROCESS_DETACH: + ret = ProcessDetach(hModule); + OutputDebugStringA("trcapi" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:" + " DllMain DLL_PROCESS_DETACH\n"); + return ret; + case DLL_THREAD_ATTACH: + OutputDebugStringA("trcapi" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:" + " DllMain DLL_THREAD_ATTACH\n"); + return ThreadAttach(hModule); + case DLL_THREAD_DETACH: + OutputDebugStringA("trcapi" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:" + " DllMain DLL_THREAD_DETACH\n"); + return ThreadDetach(hModule); + } + return TRUE; +} +// +///////////////////////////////////////////////////////////////// End of File. diff --git a/samples/traceapi/trcapi.rc b/samples/traceapi/trcapi.rc new file mode 100644 index 0000000..dc1975f --- /dev/null +++ b/samples/traceapi/trcapi.rc @@ -0,0 +1,17 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Version information for trcapi.rc. +// +// Microsoft Research Detours Package +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// + +#include "detver.h" + +#define VER_INTERNALNAME_STR "trcapi" DETOURS_STRINGIFY(DETOURS_BITS) +#define VER_ORIGINALFILENAME_STR "trcapi" DETOURS_STRINGIFY(DETOURS_BITS) ".dll" +#define VER_FILEDESCRIPTION_STR "Detours Win32 API Tracing Module" +#define VER_COMPANYNAME_STR "Microsoft Corporation" + +#include "common.ver" |