Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

阅读：4452回复：28

关于ring3下Hook api的问题,请一定帮忙

楼主^#

更多发布于：2005-05-06 15:19

在Ring3下靠更改函数入口点为JMP XXX的方法HOOK API,其它函数都成功了,唯独像CreateRemoteThread和SetWindowsHookEx这种函数无法Hook成功,观察这两个函数的共同点都是参数里面有一个是其它过程的地址,我在想是不是由于正常函数被Hook后,在我的替代函数里的时候地址已经改变?VC 出现chkesp()出错,用SoftIce跟了一阵发现是在第N层一个系统函数出错,汗```,还请高手务必帮忙,感激不尽.....

请做过User Mode Api hook(非输入表更改)并且成功Hook了CreateRemoteThread或者SetWindowsHookEx的朋友帮帮忙...

如果能够解决问题,放分一百

喜欢1

最新喜欢：

cyliu

菜鸟也写Windows

riceworm

驱动小牛

注册日期2004-10-27
最后登录2008-10-22
粉丝0
关注0
积分5分
威望7点
贡献值0点
好评度6点
原创分0分
专家分0分

加关注写私信

沙发^#

发布于：2005-05-10 17:43

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkEx(struct IMoniker* a0,
   IID& a1,
   DWORD a2,
   DWORD a3,
   ULONG a4,
   DWORD* a5,
   LPFORMATETC a6,
   IAdviseSink* a7,
   DWORD* a8,
   LPOLECLIENTSITE a9,
   struct IStorage* a10,
   LPVOID* a11),
   OleCreateLinkEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkFromData(struct IDataObject* a0,
   IID& a1,
   DWORD a2,
   LPFORMATETC a3,
   LPOLECLIENTSITE a4,
   struct IStorage* a5,
   LPVOID* a6),
   OleCreateLinkFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkFromDataEx(struct IDataObject* a0,
   IID& a1,
   DWORD a2,
   DWORD a3,
   ULONG a4,
   DWORD* a5,
   LPFORMATETC a6,
   IAdviseSink* a7,
   DWORD* a8,
   LPOLECLIENTSITE a9,
   struct IStorage* a10,
   LPVOID* a11),
   OleCreateLinkFromDataEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkToFile(LPCOLESTR a0,
   IID& a1,
   DWORD a2,
   LPFORMATETC a3,
   LPOLECLIENTSITE a4,
   struct IStorage* a5,
   LPVOID* a6),
   OleCreateLinkToFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkToFileEx(LPCOLESTR a0,
   IID& a1,
   DWORD a2,
   DWORD a3,
   ULONG a4,
   DWORD* a5,
   LPFORMATETC a6,
   IAdviseSink* a7,
   DWORD* a8,
   LPOLECLIENTSITE a9,
   struct IStorage* a10,
   LPVOID* a11),
   OleCreateLinkToFileEx);

DETOUR_TRAMPOLINE(HOLEMENU __stdcall Real_OleCreateMenuDescriptor(HMENU a0,
   LPOLEMENUGROUPWIDTHS a1),
   OleCreateMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateStaticFromData(struct IDataObject* a0,
   IID& a1,
   DWORD a2,
   LPFORMATETC a3,
   LPOLECLIENTSITE a4,
   struct IStorage* a5,
   LPVOID* a6),
   OleCreateStaticFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDestroyMenuDescriptor(HOLEMENU a0),
   OleDestroyMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDoAutoConvert(struct IStorage* a0,
   struct _GUID* a1),
   OleDoAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDraw(LPUNKNOWN a0,
   DWORD a1,
   HDC a2,
   LPCRECT a3),
   OleDraw);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OleDuplicateData(HANDLE a0,
   CLIPFORMAT a1,
   UINT a2),
   OleDuplicateData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleFlushClipboard(void),
   OleFlushClipboard);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleGetAutoConvert(IID& a0,
   struct _GUID* a1),
   OleGetAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleGetClipboard(struct IDataObject** a0),
   OleGetClipboard);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleGetIconOfClass(IID& a0,
   LPOLESTR a1,
   BOOL a2),
   OleGetIconOfClass);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleGetIconOfFile(LPOLESTR a0,
   BOOL a1),
   OleGetIconOfFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleInitialize(LPVOID a0),
   OleInitialize);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleIsCurrentClipboard(struct IDataObject* a0),
   OleIsCurrentClipboard);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OleIsRunning(struct IOleObject* a0),
   OleIsRunning);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLoad(struct IStorage* a0,
   IID& a1,
   LPOLECLIENTSITE a2,
   LPVOID* a3),
   OleLoad);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLoadFromStream(LPSTREAM a0,
   IID& a1,
   LPVOID* a2),
   OleLoadFromStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLockRunning(LPUNKNOWN a0,
   BOOL a1,
   BOOL a2),
   OleLockRunning);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleMetafilePictFromIconAndLabel(HICON a0,
   LPOLESTR a1,
   LPOLESTR a2,
   UINT a3),
   OleMetafilePictFromIconAndLabel);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleNoteObjectVisible(LPUNKNOWN a0,
   BOOL a1),
   OleNoteObjectVisible);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleQueryCreateFromData(struct IDataObject* a0),
   OleQueryCreateFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleQueryLinkFromData(struct IDataObject* a0),
   OleQueryLinkFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegEnumFormatEtc(IID& a0,
   DWORD a1,
   struct IEnumFORMATETC** a2),
   OleRegEnumFormatEtc);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegEnumVerbs(IID& a0,
   struct IEnumOLEVERB** a1),
   OleRegEnumVerbs);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegGetMiscStatus(IID& a0,
   DWORD a1,
   DWORD* a2),
   OleRegGetMiscStatus);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegGetUserType(IID& a0,
   DWORD a1,
   LPOLESTR* a2),
   OleRegGetUserType);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRun(LPUNKNOWN a0),
   OleRun);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSave(LPPERSISTSTORAGE a0,
   struct IStorage* a1,
   BOOL a2),
   OleSave);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSaveToStream(struct IPersistStream* a0,
   LPSTREAM a1),
   OleSaveToStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetAutoConvert(IID& a0,
   IID& a1),
   OleSetAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetClipboard(struct IDataObject* a0),
   OleSetClipboard);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetContainedObject(LPUNKNOWN a0,
   BOOL a1),
   OleSetContainedObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetMenuDescriptor(HOLEMENU a0,
   HWND a1,
   HWND a2,
   LPOLEINPLACEFRAME a3,
   LPOLEINPLACEACTIVEOBJECT a4),
   OleSetMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleTranslateAccelerator(LPOLEINPLACEFRAME a0,
   LPOLEINPLACEFRAMEINFO a1,
   LPMSG a2),
   OleTranslateAccelerator);

DETOUR_TRAMPOLINE(void __stdcall Real_OleUninitialize(void),
   OleUninitialize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OpenClipboard(HWND a0),
   OpenClipboard);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenDesktopA(LPCSTR a0,
   DWORD a1,
   BOOL a2,
   ACCESS_MASK a3),
   OpenDesktopA);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenDesktopW(LPCWSTR a0,
   DWORD a1,
   BOOL a2,
   ACCESS_MASK a3),
   OpenDesktopW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenEventA(DWORD a0,
   BOOL a1,
   LPCSTR a2),
   OpenEventA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenEventW(DWORD a0,
   BOOL a1,
   LPCWSTR a2),
   OpenEventW);

DETOUR_TRAMPOLINE(HFILE __stdcall Real_OpenFile(LPCSTR a0,
   struct _OFSTRUCT* a1,
   UINT a2),
   OpenFile);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenFileMappingA(DWORD a0,
   BOOL a1,
   LPCSTR a2),
   OpenFileMappingA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenFileMappingW(DWORD a0,
   BOOL a1,
   LPCWSTR a2),
   OpenFileMappingW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OpenIcon(HWND a0),
   OpenIcon);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenInputDesktop(DWORD a0,
   BOOL a1,
   ACCESS_MASK a2),
   OpenInputDesktop);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenMutexA(DWORD a0,
   BOOL a1,
   LPCSTR a2),
   OpenMutexA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenMutexW(DWORD a0,
   BOOL a1,
   LPCWSTR a2),
   OpenMutexW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenProcess(DWORD a0,
   BOOL a1,
   DWORD a2),
   OpenProcess);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenSemaphoreA(DWORD a0,
   BOOL a1,
   LPCSTR a2),
   OpenSemaphoreA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenSemaphoreW(DWORD a0,
   BOOL a1,
   LPCWSTR a2),
   OpenSemaphoreW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenWaitableTimerA(DWORD a0,
   BOOL a1,
   LPCSTR a2),
   OpenWaitableTimerA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenWaitableTimerW(DWORD a0,
   BOOL a1,
   LPCWSTR a2),
   OpenWaitableTimerW);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_OpenWindowStationA(LPCSTR a0,
   BOOL a1,
   ACCESS_MASK a2),
   OpenWindowStationA);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_OpenWindowStationW(LPCWSTR a0,
   BOOL a1,
   ACCESS_MASK a2),
   OpenWindowStationW);

DETOUR_TRAMPOLINE(void __stdcall Real_OutputDebugStringA(LPCSTR a0),
   OutputDebugStringA);

DETOUR_TRAMPOLINE(void __stdcall Real_OutputDebugStringW(LPCWSTR a0),
   OutputDebugStringW);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_PackDDElParam(UINT a0,
   UINT_PTR a1,
   UINT_PTR a2),
   PackDDElParam);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PaintDesktop(HDC a0),
   PaintDesktop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PaintRgn(HDC a0,
   HRGN a1),
   PaintRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PatBlt(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4,
   DWORD a5),
   PatBlt);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_PathToRegion(HDC a0),
   PathToRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekConsoleInputA(HANDLE a0,
   PINPUT_RECORD a1,
   DWORD a2,
   LPDWORD a3),
   PeekConsoleInputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekConsoleInputW(HANDLE a0,
   PINPUT_RECORD a1,
   DWORD a2,
   LPDWORD a3),
   PeekConsoleInputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekMessageA(LPMSG a0,
   HWND a1,
   UINT a2,
   UINT a3,
   UINT a4),
   PeekMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekMessageW(LPMSG a0,
   HWND a1,
   UINT a2,
   UINT a3,
   UINT a4),
   PeekMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekNamedPipe(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   LPDWORD a3,
   LPDWORD a4,
   LPDWORD a5),
   PeekNamedPipe);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Pie(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4,
   int a5,
   int a6,
   int a7,
   int a8),
   Pie);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayEnhMetaFile(HDC a0,
   HENHMETAFILE a1,
   RECT* a2),
   PlayEnhMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayEnhMetaFileRecord(HDC a0,
   LPHANDLETABLE a1,
   ENHMETARECORD* a2,
   UINT a3),
   PlayEnhMetaFileRecord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayMetaFile(HDC a0,
   HMETAFILE a1),
   PlayMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayMetaFileRecord(HDC a0,
   LPHANDLETABLE a1,
   LPMETARECORD a2,
   UINT a3),
   PlayMetaFileRecord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlgBlt(HDC a0,
   POINT* a1,
   HDC a2,
   int a3,
   int a4,
   int a5,
   int a6,
   HBITMAP a7,
   int a8,
   int a9),
   PlgBlt);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyBezier(HDC a0,
   POINT* a1,
   DWORD a2),
   PolyBezier);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyBezierTo(HDC a0,
   POINT* a1,
   DWORD a2),
   PolyBezierTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyDraw(HDC a0,
   POINT* a1,
   BYTE* a2,
   int a3),
   PolyDraw);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyPolygon(HDC a0,
   POINT* a1,
   INT* a2,
   int a3),
   PolyPolygon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyPolyline(HDC a0,
   POINT* a1,
   DWORD* a2,
   DWORD a3),
   PolyPolyline);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyTextOutA(HDC a0,
   struct tagPOLYTEXTA* a1,
   int a2),
   PolyTextOutA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyTextOutW(HDC a0,
   struct tagPOLYTEXTW* a1,
   int a2),
   PolyTextOutW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Polygon(HDC a0,
   POINT* a1,
   int a2),
   Polygon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Polyline(HDC a0,
   POINT* a1,
   int a2),
   Polyline);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolylineTo(HDC a0,
   POINT* a1,
   DWORD a2),
   PolylineTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostMessageA(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   PostMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostMessageW(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   PostMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostQueuedCompletionStatus(HANDLE a0,
   DWORD a1,
   ULONG_PTR a2,
   LPOVERLAPPED a3),
   PostQueuedCompletionStatus);

DETOUR_TRAMPOLINE(void __stdcall Real_PostQuitMessage(int a0),
   PostQuitMessage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostThreadMessageA(DWORD a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   PostThreadMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostThreadMessageW(DWORD a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   PostThreadMessageW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_PrepareTape(HANDLE a0,
   DWORD a1,
   BOOL a2),
   PrepareTape);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ProgIDFromCLSID(IID& a0,
   LPOLESTR* a1),
   ProgIDFromCLSID);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropStgNameToFmtId(unsigned short* a0,
   FMTID* a1),
   PropStgNameToFmtId);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropVariantClear(PROPVARIANT* a0),
   PropVariantClear);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropVariantCopy(PROPVARIANT* a0,
   PROPVARIANT* a1),
   PropVariantCopy);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtInRect(RECT* a0,
   POINT a1),
   PtInRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtInRegion(HRGN a0,
   int a1,
   int a2),
   PtInRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtVisible(HDC a0,
   int a1,
   int a2),
   PtVisible);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PulseEvent(HANDLE a0),
   PulseEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PurgeComm(HANDLE a0,
   DWORD a1),
   PurgeComm);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueryDosDeviceA(LPCSTR a0,
   LPSTR a1,
   DWORD a2),
   QueryDosDeviceA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueryDosDeviceW(LPCWSTR a0,
   LPWSTR a1,
   DWORD a2),
   QueryDosDeviceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_QueryPerformanceCounter(LARGE_INTEGER* a0),
   QueryPerformanceCounter);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_QueryPerformanceFrequency(LARGE_INTEGER* a0),
   QueryPerformanceFrequency);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueueUserAPC(PAPCFUNC a0,
   HANDLE a1,
   ULONG_PTR a2),
   QueueUserAPC);

DETOUR_TRAMPOLINE(void __stdcall Real_RaiseException(DWORD a0,
   DWORD a1,
   DWORD a2,
   ULONG_PTR* a3),
   RaiseException);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadClassStg(struct IStorage* a0,
   CLSID* a1),
   ReadClassStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadClassStm(LPSTREAM a0,
   CLSID* a1),
   ReadClassStm);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleA(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   LPDWORD a3,
   LPVOID a4),
   ReadConsoleA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleInputA(HANDLE a0,
   PINPUT_RECORD a1,
   DWORD a2,
   LPDWORD a3),
   ReadConsoleInputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleInputW(HANDLE a0,
   PINPUT_RECORD a1,
   DWORD a2,
   LPDWORD a3),
   ReadConsoleInputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputA(HANDLE a0,
   PCHAR_INFO a1,
   COORD a2,
   COORD a3,
   PSMALL_RECT a4),
   ReadConsoleOutputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputAttribute(HANDLE a0,
   LPWORD a1,
   DWORD a2,
   COORD a3,
   LPDWORD a4),
   ReadConsoleOutputAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputCharacterA(HANDLE a0,
   LPSTR a1,
   DWORD a2,
   COORD a3,
   LPDWORD a4),
   ReadConsoleOutputCharacterA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputCharacterW(HANDLE a0,
   LPWSTR a1,
   DWORD a2,
   COORD a3,
   LPDWORD a4),
   ReadConsoleOutputCharacterW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputW(HANDLE a0,
   PCHAR_INFO a1,
   COORD a2,
   COORD a3,
   PSMALL_RECT a4),
   ReadConsoleOutputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleW(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   LPDWORD a3,
   LPVOID a4),
   ReadConsoleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadDirectoryChangesW(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   BOOL a3,
   DWORD a4,
   LPDWORD a5,
   LPOVERLAPPED a6,
   LPOVERLAPPED_COMPLETION_ROUTINE a7),
   ReadDirectoryChangesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadFile(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   LPDWORD a3,
   LPOVERLAPPED a4),
   ReadFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadFileEx(HANDLE a0,
   LPVOID a1,
   DWORD a2,
   LPOVERLAPPED a3,
   LPOVERLAPPED_COMPLETION_ROUTINE a4),
   ReadFileEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadFmtUserTypeStg(struct IStorage* a0,
   CLIPFORMAT* a1,
   LPOLESTR* a2),
   ReadFmtUserTypeStg);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadProcessMemory(HANDLE a0,
   LPCVOID a1,
   LPVOID a2,
   DWORD a3,
   LPDWORD a4),
   ReadProcessMemory);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RealizePalette(HDC a0),
   RealizePalette);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RectInRegion(HRGN a0,
   RECT* a1),
   RectInRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RectVisible(HDC a0,
   RECT* a1),
   RectVisible);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Rectangle(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4),
   Rectangle);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RedrawWindow(HWND a0,
   RECT* a1,
   HRGN a2,
   UINT a3),
   RedrawWindow);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassA(WNDCLASSA* a0),
   RegisterClassA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassExA(struct tagWNDCLASSEXA* a0),
   RegisterClassExA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassExW(struct tagWNDCLASSEXW* a0),
   RegisterClassExW);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassW(WNDCLASSW* a0),
   RegisterClassW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterClipboardFormatA(LPCSTR a0),
   RegisterClipboardFormatA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterClipboardFormatW(LPCWSTR a0),
   RegisterClipboardFormatW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_RegisterDragDrop(HWND a0,
   struct IDropTarget* a1),
   RegisterDragDrop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RegisterHotKey(HWND a0,
   int a1,
   UINT a2,
   UINT a3),
   RegisterHotKey);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterWindowMessageA(LPCSTR a0),
   RegisterWindowMessageA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterWindowMessageW(LPCWSTR a0),
   RegisterWindowMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseCapture(void),
   ReleaseCapture);

DETOUR_TRAMPOLINE(int __stdcall Real_ReleaseDC(HWND a0,
   HDC a1),
   ReleaseDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseMutex(HANDLE a0),
   ReleaseMutex);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseSemaphore(HANDLE a0,
   LONG a1,
   LPLONG a2),
   ReleaseSemaphore);

DETOUR_TRAMPOLINE(void __stdcall Real_ReleaseStgMedium(LPSTGMEDIUM a0),
   ReleaseStgMedium);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveDirectoryA(LPCSTR a0),
   RemoveDirectoryA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveDirectoryW(LPCWSTR a0),
   RemoveDirectoryW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveFontResourceA(LPCSTR a0),
   RemoveFontResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveFontResourceW(LPCWSTR a0),
   RemoveFontResourceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveMenu(HMENU a0,
   UINT a1,
   UINT a2),
   RemoveMenu);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_RemovePropA(HWND a0,
   LPCSTR a1),
   RemovePropA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_RemovePropW(HWND a0,
   LPCWSTR a1),
   RemovePropW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReplyMessage(LRESULT a0),
   ReplyMessage);

DETOUR_TRAMPOLINE(HDC __stdcall Real_ResetDCA(HDC a0,
   struct _devicemodeA* a1),
   ResetDCA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_ResetDCW(HDC a0,
   struct _devicemodeW* a1),
   ResetDCW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ResetEvent(HANDLE a0),
   ResetEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ResizePalette(HPALETTE a0,
   UINT a1),
   ResizePalette);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RestoreDC(HDC a0,
   int a1),
   RestoreDC);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_ResumeThread(HANDLE a0),
   ResumeThread);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_ReuseDDElParam(LPARAM a0,
   UINT a1,
   UINT a2,
   UINT_PTR a3,
   UINT_PTR a4),
   ReuseDDElParam);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_RevokeDragDrop(HWND a0),
   RevokeDragDrop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RoundRect(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4,
   int a5,
   int a6),
   RoundRect);

DETOUR_TRAMPOLINE(int __stdcall Real_SaveDC(HDC a0),
   SaveDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScaleViewportExtEx(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4,
   struct tagSIZE* a5),
   ScaleViewportExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScaleWindowExtEx(HDC a0,
   int a1,
   int a2,
   int a3,
   int a4,
   struct tagSIZE* a5),
   ScaleWindowExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScreenToClient(HWND a0,
   struct tagPOINT* a1),
   ScreenToClient);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollConsoleScreenBufferA(HANDLE a0,
   SMALL_RECT* a1,
   SMALL_RECT* a2,
   COORD a3,
   CHAR_INFO* a4),
   ScrollConsoleScreenBufferA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollConsoleScreenBufferW(HANDLE a0,
   SMALL_RECT* a1,
   SMALL_RECT* a2,
   COORD a3,
   CHAR_INFO* a4),
   ScrollConsoleScreenBufferW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollDC(HDC a0,
   int a1,
   int a2,
   RECT* a3,
   RECT* a4,
   HRGN a5,
   LPRECT a6),
   ScrollDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollWindow(HWND a0,
   int a1,
   int a2,
   RECT* a3,
   RECT* a4),
   ScrollWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_ScrollWindowEx(HWND a0,
   int a1,
   int a2,
   RECT* a3,
   RECT* a4,
   HRGN a5,
   LPRECT a6,
   UINT a7),
   ScrollWindowEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SearchPathA(LPCSTR a0,
   LPCSTR a1,
   LPCSTR a2,
   DWORD a3,
   LPSTR a4,
   LPSTR* a5),
   SearchPathA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SearchPathW(LPCWSTR a0,
   LPCWSTR a1,
   LPCWSTR a2,
   DWORD a3,
   LPWSTR a4,
   LPWSTR* a5),
   SearchPathW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SelectClipPath(HDC a0,
   int a1),
   SelectClipPath);

DETOUR_TRAMPOLINE(int __stdcall Real_SelectClipRgn(HDC a0,
   HRGN a1),
   SelectClipRgn);

DETOUR_TRAMPOLINE(HGDIOBJ __stdcall Real_SelectObject(HDC a0,
   HGDIOBJ a1),
   SelectObject);

DETOUR_TRAMPOLINE(HPALETTE __stdcall Real_SelectPalette(HDC a0,
   HPALETTE a1,
   BOOL a2),
   SelectPalette);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendDlgItemMessageA(HWND a0,
   int a1,
   UINT a2,
   WPARAM a3,
   LPARAM a4),
   SendDlgItemMessageA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendDlgItemMessageW(HWND a0,
   int a1,
   UINT a2,
   WPARAM a3,
   LPARAM a4),
   SendDlgItemMessageW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageA(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   SendMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendMessageCallbackA(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3,
   SENDASYNCPROC a4,
   ULONG_PTR a5),
   SendMessageCallbackA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendMessageCallbackW(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3,
   SENDASYNCPROC a4,
   ULONG_PTR a5),
   SendMessageCallbackW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageTimeoutA(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3,
   UINT a4,
   UINT a5,
   PULONG_PTR a6),
   SendMessageTimeoutA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageTimeoutW(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3,
   UINT a4,
   UINT a5,
   PULONG_PTR a6),
   SendMessageTimeoutW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageW(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   SendMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendNotifyMessageA(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   SendNotifyMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendNotifyMessageW(HWND a0,
   UINT a1,
   WPARAM a2,
   LPARAM a3),
   SendNotifyMessageW);

DETOUR_TRAMPOLINE(int __stdcall Real_SetAbortProc(HDC a0,
   ABORTPROC a1),
   SetAbortProc);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetActiveWindow(HWND a0),
   SetActiveWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_SetArcDirection(HDC a0,
   int a1),
   SetArcDirection);

DETOUR_TRAMPOLINE(LONG __stdcall Real_SetBitmapBits(HBITMAP a0,
   DWORD a1,
   void* a2),
   SetBitmapBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetBitmapDimensionEx(HBITMAP a0,
   int a1,
   int a2,
   struct tagSIZE* a3),
   SetBitmapDimensionEx);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_SetBkColor(HDC a0,
   COLORREF a1),
   SetBkColor);

DETOUR_TRAMPOLINE(int __stdcall Real_SetBkMode(HDC a0,
   int a1),
   SetBkMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetBoundsRect(HDC a0,
   RECT* a1,
   UINT a2),
   SetBoundsRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetBrushOrgEx(HDC a0,
   int a1,
   int a2,
   struct tagPOINT* a3),
   SetBrushOrgEx);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetCapture(HWND a0),
   SetCapture);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCaretBlinkTime(UINT a0),
   SetCaretBlinkTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCaretPos(int a0,
   int a1),
   SetCaretPos);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetClassLongA(HWND a0,
   int a1,
   LONG a2),
   SetClassLongA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetClassLongW(HWND a0,
   int a1,
   LONG a2),
   SetClassLongW);

DETOUR_TRAMPOLINE(WORD __stdcall Real_SetClassWord(HWND a0,
   int a1,
   WORD a2),
   SetClassWord);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_SetClipboardData(UINT a0,
   HANDLE a1),
   SetClipboardData);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetClipboardViewer(HWND a0),
   SetClipboardViewer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetColorAdjustment(HDC a0,
   COLORADJUSTMENT* a1),
   SetColorAdjustment);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_SetColorSpace(HDC a0,
   HCOLORSPACE a1),
   SetColorSpace);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommBreak(HANDLE a0),
   SetCommBreak);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommConfig(HANDLE a0,
   LPCOMMCONFIG a1,
   DWORD a2),
   SetCommConfig);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommMask(HANDLE a0,
   DWORD a1),
   SetCommMask);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommState(HANDLE a0,
   struct _DCB* a1),
   SetCommState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommTimeouts(HANDLE a0,
   struct _COMMTIMEOUTS* a1),
   SetCommTimeouts);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetComputerNameA(LPCSTR a0),
   SetComputerNameA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetComputerNameW(LPCWSTR a0),
   SetComputerNameW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleActiveScreenBuffer(HANDLE a0),
   SetConsoleActiveScreenBuffer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCP(UINT a0),
   SetConsoleCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCtrlHandler(PHANDLER_ROUTINE a0,
   BOOL a1),
   SetConsoleCtrlHandler);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCursorInfo(HANDLE a0,
   CONSOLE_CURSOR_INFO* a1),
   SetConsoleCursorInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCursorPosition(HANDLE a0,
   COORD a1),
   SetConsoleCursorPosition);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleMode(HANDLE a0,
   DWORD a1),
   SetConsoleMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleOutputCP(UINT a0),
   SetConsoleOutputCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleScreenBufferSize(HANDLE a0,
   COORD a1),
   SetConsoleScreenBufferSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTextAttribute(HANDLE a0,
   WORD a1),
   SetConsoleTextAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTitleA(LPCSTR a0),
   SetConsoleTitleA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTitleW(LPCWSTR a0),
   SetConsoleTitleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleWindowInfo(HANDLE a0,
   BOOL a1,
   SMALL_RECT* a2),
   SetConsoleWindowInfo);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_SetConvertStg(struct IStorage* a0,
   BOOL a1),
   SetConvertStg);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCurrentDirectoryA(LPCSTR a0),
   SetCurrentDirectoryA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCurrentDirectoryW(LPCWSTR a0),
   SetCurrentDirectoryW);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_SetCursor(HCURSOR a0),
   SetCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCursorPos(int a0,
   int a1),
   SetCursorPos);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetDIBColorTable(HDC a0,
   UINT a1,
   UINT a2,
   RGBQUAD* a3),
   SetDIBColorTable);

DETOUR_TRAMPOLINE(int __stdcall Real_SetDIBits(HDC a0,
   HBITMAP a1,
   UINT a2,
   UINT a3,
   void* a4,
   struct tagBITMAPINFO* a5,
   UINT a6),
   SetDIBits);

DETOUR_TRAMPOLINE(int __stdcall Real_SetDIBitsToDevice(HDC a0,
   int a1,
   int a2,
   DWORD a3,
   DWORD a4,
   int a5,
   int a6,
   UINT a7,
   UINT a8,
   void* a9,
   struct tagBITMAPINFO* a10,
   UINT a11),
   SetDIBitsToDevice);

DETOUR_TRAMPOLINE(void __stdcall Real_SetDebugErrorLevel(DWORD a0),
   SetDebugErrorLevel);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDefaultCommConfigA(LPCSTR a0,
   LPCOMMCONFIG a1,
   DWORD a2),
   SetDefaultCommConfigA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDefaultCommConfigW(LPCWSTR a0,
   LPCOMMCONFIG a1,
   DWORD a2),
   SetDefaultCommConfigW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDeviceGammaRamp(HDC a0,
   LPVOID a1),
   SetDeviceGammaRamp);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemInt(HWND a0,
   int a1,
   UINT a2,
   BOOL a3),
   SetDlgItemInt);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemTextA(HWND a0,
   int a1,
   LPCSTR a2),
   SetDlgItemTextA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemTextW(HWND a0,
   int a1,
   LPCWSTR a2),
   SetDlgItemTextW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDoubleClickTime(UINT a0),
   SetDoubleClickTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEndOfFile(HANDLE a0),
   SetEndOfFile);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_SetEnhMetaFileBits(UINT a0,
   BYTE* a1),
   SetEnhMetaFileBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEnvironmentVariableA(LPCSTR a0,
   LPCSTR a1),
   SetEnvironmentVariableA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEnvironmentVariableW(LPCWSTR a0,
   LPCWSTR a1),
   SetEnvironmentVariableW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetErrorMode(UINT a0),
   SetErrorMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEvent(HANDLE a0),
   SetEvent);

DETOUR_TRAMPOLINE(void __stdcall Real_SetFileApisToANSI(void),
   SetFileApisToANSI);

DETOUR_TRAMPOLINE(void __stdcall Real_SetFileApisToOEM(void),
   SetFileApisToOEM);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileAttributesA(LPCSTR a0,
   DWORD a1),
   SetFileAttributesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileAttributesW(LPCWSTR a0,
   DWORD a1),
   SetFileAttributesW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetFilePointer(HANDLE a0,
   LONG a1,
   PLONG a2,
   DWORD a3),
   SetFilePointer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileTime(HANDLE a0,
   FILETIME* a1,
   FILETIME* a2,
   FILETIME* a3),
   SetFileTime);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetFocus(HWND a0),
   SetFocus);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetForegroundWindow(HWND a0),
   SetForegroundWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_SetGraphicsMode(HDC a0,
   int a1),
   SetGraphicsMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetHandleCount(UINT a0),
   SetHandleCount);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetHandleInformation(HANDLE a0,
   DWORD a1,
   DWORD a2),
   SetHandleInformation);

DETOUR_TRAMPOLINE(int __stdcall Real_SetICMMode(HDC a0,
   int a1),
   SetICMMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetICMProfileA(HDC a0,
   LPSTR a1),
   SetICMProfileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetICMProfileW(HDC a0,
   LPWSTR a1),
   SetICMProfileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetKeyboardState(LPBYTE a0),
   SetKeyboardState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocalTime(SYSTEMTIME* a0),
   SetLocalTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocaleInfoA(LCID a0,
   LCTYPE a1,
   LPCSTR a2),
   SetLocaleInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocaleInfoW(LCID a0,
   LCTYPE a1,
   LPCWSTR a2),
   SetLocaleInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMailslotInfo(HANDLE a0,
   DWORD a1),
   SetMailslotInfo);

DETOUR_TRAMPOLINE(int __stdcall Real_SetMapMode(HDC a0,
   int a1),
   SetMapMode);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetMapperFlags(HDC a0,
   DWORD a1),
   SetMapperFlags);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenu(HWND a0,
   HMENU a1),
   SetMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuContextHelpId(HMENU a0,
   DWORD a1),
   SetMenuContextHelpId);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuDefaultItem(HMENU a0,
   UINT a1,
   UINT a2),
   SetMenuDefaultItem);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemBitmaps(HMENU a0,
   UINT a1,
   UINT a2,
   HBITMAP a3,
   HBITMAP a4),
   SetMenuItemBitmaps);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemInfoA(HMENU a0,
   UINT a1,
   BOOL a2,
   struct tagMENUITEMINFOA* a3),
   SetMenuItemInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemInfoW(HMENU a0,
   UINT a1,
   BOOL a2,
   struct tagMENUITEMINFOW* a3),
   SetMenuItemInfoW);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_SetMessageExtraInfo(LPARAM a0),
   SetMessageExtraInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMessageQueue(int a0),
   SetMessageQueue);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_SetMetaFileBitsEx(UINT a0,

回复喜欢

riceworm

驱动小牛

注册日期2004-10-27
最后登录2008-10-22
粉丝0
关注0
积分5分
威望7点
贡献值0点
好评度6点
原创分0分
专家分0分

加关注写私信

板凳^#

发布于：2005-05-10 17:41

DETOUR_TRAMPOLINE(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);

DETOUR_TRAMPOLINE(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);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EmptyClipboard(void),
   EmptyClipboard);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnableWindow(HWND a0,
   BOOL a1),
   EnableWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndDeferWindowPos(HDWP a0),
   EndDeferWindowPos);

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

DETOUR_TRAMPOLINE(int __stdcall Real_EndDoc(HDC a0),
   EndDoc);

DETOUR_TRAMPOLINE(int __stdcall Real_EndPage(HDC a0),
   EndPage);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndPath(HDC a0),
   EndPath);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndUpdateResourceA(HANDLE a0,
   BOOL a1),
   EndUpdateResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndUpdateResourceW(HANDLE a0,
   BOOL a1),
   EndUpdateResourceW);

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

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

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

DETOUR_TRAMPOLINE(UINT __stdcall Real_EnumClipboardFormats(UINT a0),
   EnumClipboardFormats);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceLanguagesA(HMODULE a0,
   LPCSTR a1,
   LPCSTR a2,
   ENUMRESLANGPROCA a3,
   LONG_PTR a4),
   EnumResourceLanguagesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceLanguagesW(HMODULE a0,
   LPCWSTR a1,
   LPCWSTR a2,
   ENUMRESLANGPROCW a3,
   LONG_PTR a4),
   EnumResourceLanguagesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceNamesA(HMODULE a0,
   LPCSTR a1,
   ENUMRESNAMEPROCA a2,
   LONG_PTR a3),
   EnumResourceNamesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceNamesW(HMODULE a0,
   LPCWSTR a1,
   ENUMRESNAMEPROCW a2,
   LONG_PTR a3),
   EnumResourceNamesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceTypesA(HMODULE a0,
   ENUMRESTYPEPROCA a1,
   LONG_PTR a2),
   EnumResourceTypesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceTypesW(HMODULE a0,
   ENUMRESTYPEPROCW a1,
   LONG_PTR a2),
   EnumResourceTypesW);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemLocalesA(LOCALE_ENUMPROCA a0,
   DWORD a1),
   EnumSystemLocalesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemLocalesW(LOCALE_ENUMPROCW a0,
   DWORD a1),
   EnumSystemLocalesW);

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EqualRgn(HRGN a0,
   HRGN a1),
   EqualRgn);

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

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

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

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

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

DETOUR_TRAMPOLINE(void __stdcall Real_ExitProcess(UINT a0),
   ExitProcess);

DETOUR_TRAMPOLINE(void __stdcall Real_ExitThread(DWORD a0),
   ExitThread);

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

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

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

DETOUR_TRAMPOLINE(HPEN __stdcall Real_ExtCreatePen(DWORD a0,
   DWORD a1,
   struct tagLOGBRUSH* a2,
   DWORD a3,
   DWORD* a4),
   ExtCreatePen);

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(void __stdcall Real_FatalExit(int a0),
   FatalExit);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FileTimeToSystemTime(FILETIME* a0,
   struct _SYSTEMTIME* a1),
   FileTimeToSystemTime);

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillPath(HDC a0),
   FillPath);

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

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

DETOUR_TRAMPOLINE(ATOM __stdcall Real_FindAtomA(LPCSTR a0),
   FindAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_FindAtomW(LPCWSTR a0),
   FindAtomW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindClose(HANDLE a0),
   FindClose);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindCloseChangeNotification(HANDLE a0),
   FindCloseChangeNotification);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindNextChangeNotification(HANDLE a0),
   FindNextChangeNotification);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowA(LPCSTR a0,
   LPCSTR a1),
   FindWindowA);

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

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

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowW(LPCWSTR a0,
   LPCWSTR a1),
   FindWindowW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FixBrushOrgEx(HDC a0,
   int a1,
   int a2,
   struct tagPOINT* a3),
   FixBrushOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlashWindow(HWND a0,
   BOOL a1),
   FlashWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlattenPath(HDC a0),
   FlattenPath);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlushConsoleInputBuffer(HANDLE a0),
   FlushConsoleInputBuffer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlushFileBuffers(HANDLE a0),
   FlushFileBuffers);

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeConsole(void),
   FreeConsole);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeEnvironmentStringsA(LPSTR a0),
   FreeEnvironmentStringsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeEnvironmentStringsW(LPWSTR a0),
   FreeEnvironmentStringsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeLibrary(HMODULE a0),
   FreeLibrary);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeResource(HGLOBAL a0),
   FreeResource);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GdiFlush(void),
   GdiFlush);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GdiGetBatchLimit(void),
   GdiGetBatchLimit);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GdiSetBatchLimit(DWORD a0),
   GdiSetBatchLimit);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GenerateConsoleCtrlEvent(DWORD a0,
   DWORD a1),
   GenerateConsoleCtrlEvent);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetACP(void),
   GetACP);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetActiveWindow(void),
   GetActiveWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_GetArcDirection(HDC a0),
   GetArcDirection);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetAspectRatioFilterEx(HDC a0,
   struct tagSIZE* a1),
   GetAspectRatioFilterEx);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_GetAsyncKeyState(int a0),
   GetAsyncKeyState);

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBitmapDimensionEx(HBITMAP a0,
   struct tagSIZE* a1),
   GetBitmapDimensionEx);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_GetBkColor(HDC a0),
   GetBkColor);

DETOUR_TRAMPOLINE(int __stdcall Real_GetBkMode(HDC a0),
   GetBkMode);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBrushOrgEx(HDC a0,
   struct tagPOINT* a1),
   GetBrushOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCPInfo(UINT a0,
   struct _cpinfo* a1),
   GetCPInfo);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetCapture(void),
   GetCapture);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetCaretBlinkTime(void),
   GetCaretBlinkTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCaretPos(struct tagPOINT* a0),
   GetCaretPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsA(HDC a0,
   UINT a1,
   UINT a2,
   struct _ABC* a3),
   GetCharABCWidthsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsFloatA(HDC a0,
   UINT a1,
   UINT a2,
   struct _ABCFLOAT* a3),
   GetCharABCWidthsFloatA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsFloatW(HDC a0,
   UINT a1,
   UINT a2,
   struct _ABCFLOAT* a3),
   GetCharABCWidthsFloatW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsW(HDC a0,
   UINT a1,
   UINT a2,
   struct _ABC* a3),
   GetCharABCWidthsW);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClipCursor(LPRECT a0),
   GetClipCursor);

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

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetClipboardData(UINT a0),
   GetClipboardData);

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

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

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetClipboardOwner(void),
   GetClipboardOwner);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetClipboardViewer(void),
   GetClipboardViewer);

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

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_GetColorSpace(HDC a0),
   GetColorSpace);

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommState(HANDLE a0,
   struct _DCB* a1),
   GetCommState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommTimeouts(HANDLE a0,
   struct _COMMTIMEOUTS* a1),
   GetCommTimeouts);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_GetCommandLineA(void),
   GetCommandLineA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_GetCommandLineW(void),
   GetCommandLineW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCompressedFileSizeA(LPCSTR a0,
   LPDWORD a1),
   GetCompressedFileSizeA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCompressedFileSizeW(LPCWSTR a0,
   LPDWORD a1),
   GetCompressedFileSizeW);

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

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

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetConsoleCP(void),
   GetConsoleCP);

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

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

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetConsoleOutputCP(void),
   GetConsoleOutputCP);

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetConsoleTitleA(LPSTR a0,
   DWORD a1),
   GetConsoleTitleA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetConsoleTitleW(LPWSTR a0,
   DWORD a1),
   GetConsoleTitleW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetConvertStg(struct IStorage* a0),
   GetConvertStg);

DETOUR_TRAMPOLINE(int __stdcall Real_GetCurrencyFormatA(LCID a0,
   DWORD a1,
   LPCSTR a2,
   struct _currencyfmtA* a3,
   LPSTR a4,
   int a5),
   GetCurrencyFormatA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetCurrencyFormatW(LCID a0,
   DWORD a1,
   LPCWSTR a2,
   struct _currencyfmtW* a3,
   LPWSTR a4,
   int a5),
   GetCurrencyFormatW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentDirectoryA(DWORD a0,
   LPSTR a1),
   GetCurrentDirectoryA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentDirectoryW(DWORD a0,
   LPWSTR a1),
   GetCurrentDirectoryW);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCurrentPositionEx(HDC a0,
   struct tagPOINT* a1),
   GetCurrentPositionEx);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetCurrentProcess(void),
   GetCurrentProcess);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentProcessId(void),
   GetCurrentProcessId);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentThreadId(void),
   GetCurrentThreadId);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_GetCursor(void),
   GetCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCursorPos(struct tagPOINT* a0),
   GetCursorPos);

DETOUR_TRAMPOLINE(HDC __stdcall Real_GetDC(HWND a0),
   GetDC);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDCOrgEx(HDC a0,
   struct tagPOINT* a1),
   GetDCOrgEx);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetDesktopWindow(void),
   GetDesktopWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDeviceCaps(HDC a0,
   int a1),
   GetDeviceCaps);

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

DETOUR_TRAMPOLINE(long __stdcall Real_GetDialogBaseUnits(void),
   GetDialogBaseUnits);

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

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

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

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

DETOUR_TRAMPOLINE(int __stdcall Real_GetDlgCtrlID(HWND a0),
   GetDlgCtrlID);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetDlgItem(HWND a0,
   int a1),
   GetDlgItem);

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

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

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

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDoubleClickTime(void),
   GetDoubleClickTime);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDriveTypeA(LPCSTR a0),
   GetDriveTypeA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDriveTypeW(LPCWSTR a0),
   GetDriveTypeW);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_GetEnhMetaFileA(LPCSTR a0),
   GetEnhMetaFileA);

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

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

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

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFileHeader(HENHMETAFILE a0,
   UINT a1,
   struct tagENHMETAHEADER* a2),
   GetEnhMetaFileHeader);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFilePaletteEntries(HENHMETAFILE a0,
   UINT a1,
   struct tagPALETTEENTRY* a2),
   GetEnhMetaFilePaletteEntries);

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

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_GetEnhMetaFileW(LPCWSTR a0),
   GetEnhMetaFileW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_GetEnvironmentStrings(void),
   GetEnvironmentStrings);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_GetEnvironmentStringsW(void),
   GetEnvironmentStringsW);

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

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

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

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileAttributesA(LPCSTR a0),
   GetFileAttributesA);

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

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileAttributesW(LPCWSTR a0),
   GetFileAttributesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetFileInformationByHandle(HANDLE a0,
   struct _BY_HANDLE_FILE_INFORMATION* a1),
   GetFileInformationByHandle);

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

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileType(HANDLE a0),
   GetFileType);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetFocus(void),
   GetFocus);

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFontLanguageInfo(HDC a0),
   GetFontLanguageInfo);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetForegroundWindow(void),
   GetForegroundWindow);

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

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

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

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

DETOUR_TRAMPOLINE(int __stdcall Real_GetGraphicsMode(HDC a0),
   GetGraphicsMode);

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetIconInfo(HICON a0,
   struct _ICONINFO* a1),
   GetIconInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetInputState(void),
   GetInputState);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetKBCodePage(void),
   GetKBCodePage);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetKerningPairsA(HDC a0,
   DWORD a1,
   struct tagKERNINGPAIR* a2),
   GetKerningPairsA);

回复喜欢

riceworm

驱动小牛

注册日期2004-10-27
最后登录2008-10-22
粉丝0
关注0
积分5分
威望7点
贡献值0点
好评度6点
原创分0分
专家分0分

加关注写私信

地板^#

发布于：2005-05-10 17:34

//////////////////////////////////////////////////////////////////////////////
//
// File: _win32.cpp
// Source: win32.cpp
//
// Copyright: 1996-2001, Microsoft Corporation
//

///////////////////////////////////////////////////////////////// Trampolines.
//

#pragma warning(disable:4100) // Trampolines don\'t use formal parameters.

DETOUR_TRAMPOLINE(int __stdcall Real_AbortDoc(HDC a0),
   AbortDoc);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AbortPath(HDC a0),
   AbortPath);

DETOUR_TRAMPOLINE(HKL __stdcall Real_ActivateKeyboardLayout(HKL a0,
   UINT a1),
   ActivateKeyboardLayout);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_AddAtomA(LPCSTR a0),
   AddAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_AddAtomW(LPCWSTR a0),
   AddAtomW);

DETOUR_TRAMPOLINE(int __stdcall Real_AddFontResourceA(LPCSTR a0),
   AddFontResourceA);

DETOUR_TRAMPOLINE(int __stdcall Real_AddFontResourceW(LPCWSTR a0),
   AddFontResourceW);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AllocConsole(void),
   AllocConsole);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AnyPopup(void),
   AnyPopup);

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AreFileApisANSI(void),
   AreFileApisANSI);

DETOUR_TRAMPOLINE(UINT __stdcall Real_ArrangeIconicWindows(HWND a0),
   ArrangeIconicWindows);

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Beep(DWORD a0,
   DWORD a1),
   Beep);

DETOUR_TRAMPOLINE(HDWP __stdcall Real_BeginDeferWindowPos(int a0),
   BeginDeferWindowPos);

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BeginPath(HDC a0),
   BeginPath);

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BringWindowToTop(HWND a0),
   BringWindowToTop);

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBA(LPCSTR a0,
   struct _DCB* a1),
   BuildCommDCBA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBAndTimeoutsA(LPCSTR a0,
   struct _DCB* a1,
   struct _COMMTIMEOUTS* a2),
   BuildCommDCBAndTimeoutsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBAndTimeoutsW(LPCWSTR a0,
   struct _DCB* a1,
   struct _COMMTIMEOUTS* a2),
   BuildCommDCBAndTimeoutsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBW(LPCWSTR a0,
   struct _DCB* a1),
   BuildCommDCBW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CLSIDFromProgID(LPCOLESTR a0,
   struct _GUID* a1),
   CLSIDFromProgID);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CLSIDFromString(LPOLESTR a0,
   struct _GUID* a1),
   CLSIDFromString);

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelDC(HDC a0),
   CancelDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelIo(HANDLE a0),
   CancelIo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelWaitableTimer(HANDLE a0),
   CancelWaitableTimer);

DETOUR_TRAMPOLINE(WORD __stdcall Real_CascadeWindows(HWND a0,
   UINT a1,
   RECT* a2,
   UINT a3,
   struct HWND__** a4),
   CascadeWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ChangeClipboardChain(HWND a0,
   HWND a1),
   ChangeClipboardChain);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharLowerA(LPSTR a0),
   CharLowerA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharLowerBuffA(LPSTR a0,
   DWORD a1),
   CharLowerBuffA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharLowerBuffW(LPWSTR a0,
   DWORD a1),
   CharLowerBuffW);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharLowerW(LPWSTR a0),
   CharLowerW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharNextA(LPCSTR a0),
   CharNextA);

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

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharNextW(LPCWSTR a0),
   CharNextW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharPrevA(LPCSTR a0,
   LPCSTR a1),
   CharPrevA);

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

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharPrevW(LPCWSTR a0,
   LPCWSTR a1),
   CharPrevW);

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

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

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

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

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharUpperA(LPSTR a0),
   CharUpperA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharUpperBuffA(LPSTR a0,
   DWORD a1),
   CharUpperBuffA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharUpperBuffW(LPWSTR a0,
   DWORD a1),
   CharUpperBuffW);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharUpperW(LPWSTR a0),
   CharUpperW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CheckColorsInGamut(HDC a0,
   LPVOID a1,
   LPVOID a2,
   DWORD a3),
   CheckColorsInGamut);

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

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

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

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

DETOUR_TRAMPOLINE(HWND __stdcall Real_ChildWindowFromPoint(HWND a0,
   POINT a1),
   ChildWindowFromPoint);

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClearCommBreak(HANDLE a0),
   ClearCommBreak);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClearCommError(HANDLE a0,
   LPDWORD a1,
   struct _COMSTAT* a2),
   ClearCommError);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClientToScreen(HWND a0,
   struct tagPOINT* a1),
   ClientToScreen);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClipCursor(RECT* a0),
   ClipCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseClipboard(void),
   CloseClipboard);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseDesktop(HDESK a0),
   CloseDesktop);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CloseEnhMetaFile(HDC a0),
   CloseEnhMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseFigure(HDC a0),
   CloseFigure);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseHandle(HANDLE a0),
   CloseHandle);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CloseMetaFile(HDC a0),
   CloseMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseWindow(HWND a0),
   CloseWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseWindowStation(HWINSTA a0),
   CloseWindowStation);

DETOUR_TRAMPOLINE(ULONG __stdcall Real_CoAddRefServerProcess(void),
   CoAddRefServerProcess);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CoBuildVersion(void),
   CoBuildVersion);

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateGuid(GUID* a0),
   CoCreateGuid);

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateInstanceEx(IID& a0,
   IUnknown* a1,
   DWORD a2,
   COSERVERINFO* a3,
   DWORD a4,
   struct tagMULTI_QI* a5),
   CoCreateInstanceEx);

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoFileTimeNow(FILETIME* a0),
   CoFileTimeNow);

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

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeAllLibraries(void),
   CoFreeAllLibraries);

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeLibrary(HINSTANCE a0),
   CoFreeLibrary);

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeUnusedLibraries(void),
   CoFreeUnusedLibraries);

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

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

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CoGetCurrentProcess(void),
   CoGetCurrentProcess);

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

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetTreatAsClass(IID& a0,
   struct _GUID* a1),
   CoGetTreatAsClass);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoImpersonateClient(void),
   CoImpersonateClient);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInitialize(LPVOID a0),
   CoInitialize);

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInstall(IBindCtx* a0,
   DWORD a1,
   uCLSSPEC* a2,
   struct tagQUERYCONTEXT* a3,
   LPWSTR a4),
   CoInstall);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoIsHandlerConnected(LPUNKNOWN a0),
   CoIsHandlerConnected);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoIsOle1Class(IID& a0),
   CoIsOle1Class);

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoMarshalHresult(LPSTREAM a0,
   HRESULT a1),
   CoMarshalHresult);

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoQueryAuthenticationServices(DWORD* a0,
   struct tagSOLE_AUTHENTICATION_SERVICE** a1),
   CoQueryAuthenticationServices);

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

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

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

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterMallocSpy(struct IMallocSpy* a0),
   CoRegisterMallocSpy);

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterPSClsid(IID& a0,
   IID& a1),
   CoRegisterPSClsid);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterSurrogate(LPSURROGATE a0),
   CoRegisterSurrogate);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoReleaseMarshalData(LPSTREAM a0),
   CoReleaseMarshalData);

DETOUR_TRAMPOLINE(ULONG __stdcall Real_CoReleaseServerProcess(void),
   CoReleaseServerProcess);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoResumeClassObjects(void),
   CoResumeClassObjects);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevertToSelf(void),
   CoRevertToSelf);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevokeClassObject(DWORD a0),
   CoRevokeClassObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevokeMallocSpy(void),
   CoRevokeMallocSpy);

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoSuspendClassObjects(void),
   CoSuspendClassObjects);

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

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CoTaskMemAlloc(ULONG a0),
   CoTaskMemAlloc);

DETOUR_TRAMPOLINE(void __stdcall Real_CoTaskMemFree(LPVOID a0),
   CoTaskMemFree);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CoTaskMemRealloc(LPVOID a0,
   ULONG a1),
   CoTaskMemRealloc);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoTreatAsClass(IID& a0,
   IID& a1),
   CoTreatAsClass);

DETOUR_TRAMPOLINE(void __stdcall Real_CoUninitialize(void),
   CoUninitialize);

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CombineTransform(struct tagXFORM* a0,
   XFORM* a1,
   XFORM* a2),
   CombineTransform);

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

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

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

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

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

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

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ContinueDebugEvent(DWORD a0,
   DWORD a1,
   DWORD a2),
   ContinueDebugEvent);

DETOUR_TRAMPOLINE(LCID __stdcall Real_ConvertDefaultLocale(LCID a0),
   ConvertDefaultLocale);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_ConvertThreadToFiber(LPVOID a0),
   ConvertThreadToFiber);

DETOUR_TRAMPOLINE(int __stdcall Real_CopyAcceleratorTableA(HACCEL a0,
   struct tagACCEL* a1,
   int a2),
   CopyAcceleratorTableA);

DETOUR_TRAMPOLINE(int __stdcall Real_CopyAcceleratorTableW(HACCEL a0,
   struct tagACCEL* a1,
   int a2),
   CopyAcceleratorTableW);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CopyEnhMetaFileA(HENHMETAFILE a0,
   LPCSTR a1),
   CopyEnhMetaFileA);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CopyEnhMetaFileW(HENHMETAFILE a0,
   LPCWSTR a1),
   CopyEnhMetaFileW);

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

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

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

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

DETOUR_TRAMPOLINE(HICON __stdcall Real_CopyIcon(HICON a0),
   CopyIcon);

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

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CopyMetaFileA(HMETAFILE a0,
   LPCSTR a1),
   CopyMetaFileA);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CopyMetaFileW(HMETAFILE a0,
   LPCWSTR a1),
   CopyMetaFileW);

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

DETOUR_TRAMPOLINE(int __stdcall Real_CountClipboardFormats(void),
   CountClipboardFormats);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_CreateAcceleratorTableA(struct tagACCEL* a0,
   int a1),
   CreateAcceleratorTableA);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_CreateAcceleratorTableW(struct tagACCEL* a0,
   int a1),
   CreateAcceleratorTableW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateAntiMoniker(struct IMoniker** a0),
   CreateAntiMoniker);

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

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

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateBitmapIndirect(BITMAP* a0),
   CreateBitmapIndirect);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateBrushIndirect(struct tagLOGBRUSH* a0),
   CreateBrushIndirect);

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

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateClassMoniker(IID& a0,
   struct IMoniker** a1),
   CreateClassMoniker);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_CreateColorSpaceA(struct tagLOGCOLORSPACEA* a0),
   CreateColorSpaceA);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_CreateColorSpaceW(struct tagLOGCOLORSPACEW* a0),
   CreateColorSpaceW);

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

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateCompatibleDC(HDC a0),
   CreateCompatibleDC);

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

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

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateDCA(LPCSTR a0,
   LPCSTR a1,
   LPCSTR a2,
   struct _devicemodeA* a3),
   CreateDCA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateDCW(LPCWSTR a0,
   LPCWSTR a1,
   LPCWSTR a2,
   struct _devicemodeW* a3),
   CreateDCW);

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

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

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateDIBSection(HDC a0,
   struct tagBITMAPINFO* a1,
   UINT a2,
   void** a3,
   HANDLE a4,
   DWORD a5),
   CreateDIBSection);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateDIBitmap(HDC a0,
   BITMAPINFOHEADER* a1,
   DWORD a2,
   void* a3,
   struct tagBITMAPINFO* a4,
   UINT a5),
   CreateDIBitmap);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateDataAdviseHolder(LPDATAADVISEHOLDER* a0),
   CreateDataAdviseHolder);

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

DETOUR_TRAMPOLINE(HDESK __stdcall Real_CreateDesktopA(LPCSTR a0,
   LPCSTR a1,
   LPDEVMODEA a2,
   DWORD a3,
   ACCESS_MASK a4,
   LPSECURITY_ATTRIBUTES a5),
   CreateDesktopA);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_CreateDesktopW(LPCWSTR a0,
   LPCWSTR a1,
   LPDEVMODEW a2,
   DWORD a3,
   ACCESS_MASK a4,
   LPSECURITY_ATTRIBUTES a5),
   CreateDesktopW);

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

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

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

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

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

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

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

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

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

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

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateEllipticRgnIndirect(RECT* a0),
   CreateEllipticRgnIndirect);

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

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

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

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

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CreateFiber(DWORD a0,
   LPFIBER_START_ROUTINE a1,
   LPVOID a2),
   CreateFiber);

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

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

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

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

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

DETOUR_TRAMPOLINE(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);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontIndirectA(LOGFONTA* a0),
   CreateFontIndirectA);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontIndirectW(LOGFONTW* a0),
   CreateFontIndirectW);

DETOUR_TRAMPOLINE(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);

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

DETOUR_TRAMPOLINE(HPALETTE __stdcall Real_CreateHalftonePalette(HDC a0),
   CreateHalftonePalette);

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

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateICA(LPCSTR a0,
   LPCSTR a1,
   LPCSTR a2,
   struct _devicemodeA* a3),
   CreateICA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateICW(LPCWSTR a0,
   LPCWSTR a1,
   LPCWSTR a2,
   struct _devicemodeW* a3),
   CreateICW);

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

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

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

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

DETOUR_TRAMPOLINE(HICON __stdcall Real_CreateIconIndirect(struct _ICONINFO* a0),
   CreateIconIndirect);

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

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

DETOUR_TRAMPOLINE(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);

DETOUR_TRAMPOLINE(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);

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

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

DETOUR_TRAMPOLINE(HMENU __stdcall Real_CreateMenu(void),
   CreateMenu);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateMetaFileA(LPCSTR a0),
   CreateMetaFileA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateMetaFileW(LPCWSTR a0),
   CreateMetaFileW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateMutexA(LPSECURITY_ATTRIBUTES a0,
   BOOL a1,

回复喜欢

riceworm 驱动小牛注册日期2004-10-27 最后登录2008-10-22 粉丝0 关注0 积分5分威望7点贡献值0点好评度6点原创分0分专家分0分加关注写私信	地下室^# 发布于：2005-05-10 17:18 晕
	回复(0) 喜欢(0)

zhaock 驱动太牛注册日期2002-01-26 最后登录2018-06-02 粉丝3 关注2 积分73328分威望362317点贡献值1点好评度226点原创分0分专家分0分加关注写私信	5楼^# 发布于：2005-05-10 17:14 呵呵，如果还搞不定，多给点分，把执行程序搞上来，这种问题，不需要代码跟踪一下也很easy，最好给debug版的
	回复(0) 喜欢(0)

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

6楼^#

发布于：2005-05-10 16:42

你把你最新的代码传上来，我看看
其实只要你熟悉汇编，用ice单步跟踪一下，这种问题很easy

呵呵,你说的是,但是hook Explorer的是公司的代码,我不敢
上传啊,反正思路就是为Explorer.exe创建一个远线程，然后
这个远线程的功能就是更改一些Explorer中API的入口点,包括CreateRemoteThread,其它的和开始发的工程代码是一模一样
的。

我再用ICE调调,上次用ICE调到系统N层的一个函数,好像是
KiWaitXXXX什么的出错,并且出错的函数都是系统内核函数,
并且每次出错的系统函数都不一样,很难确定到底哪儿出错了,
搞得我焦头烂额的.帖子明天或者后天结贴给分,你不要急
哈,我说话算话的.

菜鸟也写Windows

回复喜欢

zhaock 驱动太牛注册日期2002-01-26 最后登录2018-06-02 粉丝3 关注2 积分73328分威望362317点贡献值1点好评度226点原创分0分专家分0分加关注写私信	7楼^# 发布于：2005-05-10 16:21 你把你最新的代码传上来，我看看其实只要你熟悉汇编，用ice单步跟踪一下，这种问题很easy
	回复(0) 喜欢(0)

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

8楼^#

发布于：2005-05-10 16:07

要让Explorer调用CreateRemoteThread很简单,右键单击任务栏,

然后单击属性即可,感谢zhaock的帮忙,期待你的工程

[quote]
此案例怎么看有点像从detours改过来的啊，有修改好的工程可以传上来吗。你测试过其他函数可以hook吗,比如hook kernel32.dll中的WriteFile函数。
[quote]

WriteFile是可以成功Hook的,我测试过

菜鸟也写Windows

回复喜欢

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

9楼^#

发布于：2005-05-10 16:04

我试了本进程，和其他进程，都没有问题
为什么声明成_stdcall,因为你要hook的函数是_stdcall,
要一致，
你的代码存在两个问题，
1.leCreateRemoteDllThread直接用，是不对的
2.RealFun,与你要hook的fun 声明不一致。
改过来，就没有问题了

请把你HOOK其它进程成功的工程上传一下,我刚试了HOOK Explorer
的CreateRemoteThread还是出现chkesp错误.注意是Hook掉Explorer
的API CreateRemoteThread,而不是HOOK 本进程的CreateRemoteThread然后在Explorer中创建远线程.
HOOK后Explorer一调用CreateRemoteThread就出错。

我全部改成_cdecl或者全部改成_stdcall Explorer都要出错,巨汗......

菜鸟也写Windows

回复喜欢

riceworm 驱动小牛注册日期2004-10-27 最后登录2008-10-22 粉丝0 关注0 积分5分威望7点贡献值0点好评度6点原创分0分专家分0分加关注写私信	10楼^# 发布于：2005-05-10 15:56 此案例怎么看有点像从detours改过来的啊，有修改好的工程可以传上来吗。你测试过其他函数可以hook吗,比如hook kernel32.dll中的WriteFile函数。
	回复(0) 喜欢(0)

zhaock 驱动太牛注册日期2002-01-26 最后登录2018-06-02 粉丝3 关注2 积分73328分威望362317点贡献值1点好评度226点原创分0分专家分0分加关注写私信	11楼^# 发布于：2005-05-10 15:41 我试了本进程，和其他进程，都没有问题为什么声明成_stdcall,因为你要hook的函数是_stdcall, 要一致，你的代码存在两个问题， 1.leCreateRemoteDllThread直接用，是不对的 2.RealFun,与你要hook的fun 声明不一致。改过来，就没有问题了
	回复(0) 喜欢(0)

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

12楼^#

发布于：2005-05-10 15:29

这个错误非常简单，HANDLE MyCreateRemoteThread(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);
应该是_stdcall,（缺省是_cdecl）
看一下汇编代码，就很清楚了，这种错误一般都是声明不一致
导致的
改过来，就ok了，别忘了加100分，呵呵

呵呵,这个我早就试过了,当时我是将定义改成

typedef HANDLE (_cdecl *PCreateRemoteThread)(HANDLE,LPSECURITY_ATTRIBUTES,SIZE_T,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
结果Hook其它进程的CreateRemoteThread一样是失败的

但是经过你的一提醒,我发现改成上述定义后,HOOK 本进程的CreateRemoteThread用Release版本编译不错了,但是Debug仍然出错,
我先试试HOOK别的进程还错不错

菜鸟也写Windows

回复喜欢

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

13楼^#

发布于：2005-05-10 15:19

[quote]能说说你的程序的框架和大致设计思路行吗？
在HooKProc函数中的
hFile=CreateFile(\"c:\\\\xx.sys\",GENERIC_WRITE,

这里的c:\\\\xx.sys是什么驱动？文件找不到[quote]

你肯定是下载了我最旧的工程了,那个是Hook本进程

SetWindowsHookExW的时候,用C:\\xx.sys纪录键盘按下的键,并没有使

用驱动,但是和CreateRemoteThread一样,都要错误.目前我为了简洁

好让大家看得清楚,我只Hook CreateRemoteThread,应该只要解决了

CreateRemoteThread的错误,SetWindowsHookEx也肯定解决了.

大家调试时请以这个工程为准,这个工程最清楚明白,只Hook CreateRemoteThread,还是麻烦论坛的高手们露个头,帮个忙啊

附件名称/大小下载次数最后更新: 2005-05-10_TestDebugHookApi.rar (10KB) 9

菜鸟也写Windows

回复喜欢

zhaock

驱动太牛

注册日期2002-01-26
最后登录2018-06-02
粉丝3
关注2
积分73328分
威望362317点
贡献值1点
好评度226点
原创分0分
专家分0分

加关注写私信

14楼^#

发布于：2005-05-10 15:14

这个错误非常简单，HANDLE MyCreateRemoteThread(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);
应该是_stdcall,（缺省是_cdecl）
看一下汇编代码，就很清楚了，这种错误一般都是声明不一致
导致的
改过来，就ok了，别忘了加100分，呵呵

回复喜欢

riceworm 驱动小牛注册日期2004-10-27 最后登录2008-10-22 粉丝0 关注0 积分5分威望7点贡献值0点好评度6点原创分0分专家分0分加关注写私信	15楼^# 发布于：2005-05-10 14:43 能说说你的程序的框架和大致设计思路行吗？在HooKProc函数中的 hFile=CreateFile(\"c:\\\\xx.sys\",GENERIC_WRITE, 这里的c:\\\\xx.sys是什么驱动？文件找不到
	回复(0) 喜欢(0)

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

16楼^#

发布于：2005-05-10 14:09

[/quote]
如果要防止别的进程createromotethread,那就自己建立一个进程,这个进程createremotethread到所有的其他进程,在执行体中HOOK其他进程的createremotethread. [/quote]

呵呵,这个我知道并且已经试过了,关键就是\"执行体中HOOK其他进程的createremotethread\"是很困难的,HOOK掉CreateRemoteThread后,其它进程一调用CreateRemoteThread就会出现内存错误失败,为了便于调试,我先Hook本进程的CreateRemoteThread,但是仍然会出现错误,调试N久无果,郁闷啊.

:(

菜鸟也写Windows

回复喜欢

riceworm 驱动小牛注册日期2004-10-27 最后登录2008-10-22 粉丝0 关注0 积分5分威望7点贡献值0点好评度6点原创分0分专家分0分加关注写私信	17楼^# 发布于：2005-05-10 13:54 关注一下
	回复(0) 喜欢(0)

wywwwl

驱动大牛

注册日期2002-08-16
最后登录2018-04-07
粉丝1
关注0
积分-10分
威望135点
贡献值6点
好评度76点
原创分0分
专家分0分

加关注写私信

18楼^#

发布于：2005-05-10 13:17

另外我觉得最佳的方案应该是在MyCreateRemoteThread做一些处理,
因为如果想Hook别的进程的CreateRemoteThread,修改WriteProcessMemory可不行,只能在MyCreateRemoteThread做一些处理.

如果要防止别的进程createromotethread,那就自己建立一个进程,这个进程createremotethread到所有的其他进程,在执行体中HOOK其他进程的createremotethread.

琢磨悟真知

回复喜欢

Astronomy

驱动小牛

注册日期2005-04-11
最后登录2011-12-20
粉丝0
关注0
积分7分
威望31点
贡献值0点
好评度7点
原创分0分
专家分0分

加关注写私信

19楼^#

发布于：2005-05-10 13:11

我第一步肯定是想先Hook 本进程的CreateRemoteThread,
但是肯定不会为本进程创建一个远线程,肯定得想在其它
进程插入远线程,注意:一定要弄明白Hook本进程的CreateRemoteThread和在什么进程中创建远线程是完全不同的两个
概念,我可以HOOK 本进程的CreateRemoteThread但是我是在其它
进程中创建远线程

而Hook其它进程的CreateRemoteThread就是以后的事了,先把
本进程的CreateRemoteThread的Hook成功了再考虑吧.

菜鸟也写Windows

回复喜欢

您需要登录后才可以回帖，登录或者注册