From edc8b7d8daa57911b4663ccd684a8df2f2ad1ecf Mon Sep 17 00:00:00 2001 From: vxiiduu <73044267+vxiiduu@users.noreply.github.com> Date: Sat, 26 Mar 2022 15:16:28 +1000 Subject: [PATCH] Add files via upload --- ChangeLog.txt | Bin 0 -> 134 bytes KexCfg/KexCfg.c | 161 ++ KexCfg/KexCfg.vcxproj | 155 ++ KexCfg/KexCfg.vcxproj.filters | 22 + KexCfg/KexCfg.vcxproj.user | 7 + KexComm.h | 120 ++ KexComm/File.c | 43 + KexComm/KexComm.vcxproj | 162 ++ KexComm/KexComm.vcxproj.filters | 36 + KexComm/KexComm.vcxproj.user | 3 + KexComm/Memory.c | 40 + KexComm/Msgbox.c | 65 + KexComm/Registry.c | 114 ++ KexDll.h | 21 + KexExprt/KexExprt.c | 237 +++ KexExprt/KexExprt.rc | Bin 0 -> 2846 bytes KexExprt/KexExprt.vcxproj | 163 ++ KexExprt/KexExprt.vcxproj.filters | 32 + KexExprt/KexExprt.vcxproj.user | 3 + KexExprt/resource.h | 56 + KexSetup/KexSetup.c | 956 ++++++++++ KexSetup/KexSetup.rc | Bin 0 -> 15972 bytes KexSetup/KexSetup.vcxproj | 177 ++ KexSetup/KexSetup.vcxproj.filters | 32 + KexSetup/KexSetup.vcxproj.user | 3 + KexSetup/disc1.ico | Bin 0 -> 9662 bytes KexSetup/resource.h | 94 + KexShlEx/KexShlEx.cpp | 664 +++++++ KexShlEx/KexShlEx.def | 6 + KexShlEx/KexShlEx.rc | Bin 0 -> 3808 bytes KexShlEx/KexShlEx.vcxproj | 168 ++ KexShlEx/KexShlEx.vcxproj.filters | 37 + KexShlEx/KexShlEx.vcxproj.user | 3 + KexShlEx/resource.h | 48 + NtDll.h | 528 ++++++ VxKexLdr.sln | 191 ++ VxKexLdr/VXKEXLDR.vcxproj | 190 ++ VxKexLdr/VXKEXLDR.vcxproj.filters | 38 + VxKexLdr/VXKEXLDR.vcxproj.user | 33 + VxKexLdr/VaRw.c | 145 ++ VxKexLdr/VaRw.h | 61 + VxKexLdr/VxKexLdr.aps | Bin 0 -> 34252 bytes VxKexLdr/VxKexLdr.c | 1026 +++++++++++ VxKexLdr/VxKexLdr.rc | Bin 0 -> 2942 bytes VxKexLdr/resource.h | Bin 0 -> 704 bytes Vxkex.h | 5 + combase/combase.c | 143 ++ combase/combase.vcxproj | 147 ++ combase/combase.vcxproj.filters | 22 + combase/combase.vcxproj.user | 3 + dxg1/dxg1.c | 13 + dxg1/dxg1.vcxproj | 152 ++ dxg1/dxg1.vcxproj.filters | 25 + dxg1/dxg1.vcxproj.user | 3 + dxg1/forwarders.c | 51 + kernel33/forwarders.c | 2766 +++++++++++++++++++++++++++++ kernel33/k32defs.h | 221 +++ kernel33/k32func.h | 6 + kernel33/kernel33.c | 165 ++ kernel33/kernel33.vcxproj | 161 ++ kernel33/kernel33.vcxproj.filters | 36 + kernel33/kernel33.vcxproj.user | 3 + kernel33/woa.c | 191 ++ ntdll_x64.lib | Bin 0 -> 447634 bytes ntdll_x86.lib | Bin 0 -> 489616 bytes ole33/forwarders.c | 460 +++++ ole33/ole33.c | 11 + ole33/ole33.vcxproj | 160 ++ ole33/ole33.vcxproj.filters | 25 + ole33/ole33.vcxproj.user | 3 + shcore/shcore.c | 162 ++ shcore/shcore.vcxproj | 147 ++ shcore/shcore.vcxproj.filters | 22 + shcore/shcore.vcxproj.user | 3 + user33/forwarders.c | 847 +++++++++ user33/user33.c | 315 ++++ user33/user33.vcxproj | 168 ++ user33/user33.vcxproj.filters | 25 + user33/user33.vcxproj.user | 3 + 79 files changed, 12304 insertions(+) create mode 100644 ChangeLog.txt create mode 100644 KexCfg/KexCfg.c create mode 100644 KexCfg/KexCfg.vcxproj create mode 100644 KexCfg/KexCfg.vcxproj.filters create mode 100644 KexCfg/KexCfg.vcxproj.user create mode 100644 KexComm.h create mode 100644 KexComm/File.c create mode 100644 KexComm/KexComm.vcxproj create mode 100644 KexComm/KexComm.vcxproj.filters create mode 100644 KexComm/KexComm.vcxproj.user create mode 100644 KexComm/Memory.c create mode 100644 KexComm/Msgbox.c create mode 100644 KexComm/Registry.c create mode 100644 KexDll.h create mode 100644 KexExprt/KexExprt.c create mode 100644 KexExprt/KexExprt.rc create mode 100644 KexExprt/KexExprt.vcxproj create mode 100644 KexExprt/KexExprt.vcxproj.filters create mode 100644 KexExprt/KexExprt.vcxproj.user create mode 100644 KexExprt/resource.h create mode 100644 KexSetup/KexSetup.c create mode 100644 KexSetup/KexSetup.rc create mode 100644 KexSetup/KexSetup.vcxproj create mode 100644 KexSetup/KexSetup.vcxproj.filters create mode 100644 KexSetup/KexSetup.vcxproj.user create mode 100644 KexSetup/disc1.ico create mode 100644 KexSetup/resource.h create mode 100644 KexShlEx/KexShlEx.cpp create mode 100644 KexShlEx/KexShlEx.def create mode 100644 KexShlEx/KexShlEx.rc create mode 100644 KexShlEx/KexShlEx.vcxproj create mode 100644 KexShlEx/KexShlEx.vcxproj.filters create mode 100644 KexShlEx/KexShlEx.vcxproj.user create mode 100644 KexShlEx/resource.h create mode 100644 NtDll.h create mode 100644 VxKexLdr.sln create mode 100644 VxKexLdr/VXKEXLDR.vcxproj create mode 100644 VxKexLdr/VXKEXLDR.vcxproj.filters create mode 100644 VxKexLdr/VXKEXLDR.vcxproj.user create mode 100644 VxKexLdr/VaRw.c create mode 100644 VxKexLdr/VaRw.h create mode 100644 VxKexLdr/VxKexLdr.aps create mode 100644 VxKexLdr/VxKexLdr.c create mode 100644 VxKexLdr/VxKexLdr.rc create mode 100644 VxKexLdr/resource.h create mode 100644 Vxkex.h create mode 100644 combase/combase.c create mode 100644 combase/combase.vcxproj create mode 100644 combase/combase.vcxproj.filters create mode 100644 combase/combase.vcxproj.user create mode 100644 dxg1/dxg1.c create mode 100644 dxg1/dxg1.vcxproj create mode 100644 dxg1/dxg1.vcxproj.filters create mode 100644 dxg1/dxg1.vcxproj.user create mode 100644 dxg1/forwarders.c create mode 100644 kernel33/forwarders.c create mode 100644 kernel33/k32defs.h create mode 100644 kernel33/k32func.h create mode 100644 kernel33/kernel33.c create mode 100644 kernel33/kernel33.vcxproj create mode 100644 kernel33/kernel33.vcxproj.filters create mode 100644 kernel33/kernel33.vcxproj.user create mode 100644 kernel33/woa.c create mode 100644 ntdll_x64.lib create mode 100644 ntdll_x86.lib create mode 100644 ole33/forwarders.c create mode 100644 ole33/ole33.c create mode 100644 ole33/ole33.vcxproj create mode 100644 ole33/ole33.vcxproj.filters create mode 100644 ole33/ole33.vcxproj.user create mode 100644 shcore/shcore.c create mode 100644 shcore/shcore.vcxproj create mode 100644 shcore/shcore.vcxproj.filters create mode 100644 shcore/shcore.vcxproj.user create mode 100644 user33/forwarders.c create mode 100644 user33/user33.c create mode 100644 user33/user33.vcxproj create mode 100644 user33/user33.vcxproj.filters create mode 100644 user33/user33.vcxproj.user diff --git a/ChangeLog.txt b/ChangeLog.txt new file mode 100644 index 0000000000000000000000000000000000000000..1f31e58cd0ab9a3e85d05fb2703a00ae6efc1f8c GIT binary patch literal 134 zcmX|&O$tC@6h+UJvIi>=TTlij6lE@ +#include +#include +#include +#include + +#define APPNAME T("KexCfg") +#define FRIENDLYAPPNAME T("VxKex Configuration Tool") + +#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") + +// KexCfg is a helper program which is used to enable or disable VxKex for +// specific .EXE files. It is only meant to be invoked by the configuration +// shell extension or other programs which are associated with VxKex. The +// reason why we need a helper program is because this program might need to +// be restarted with administrator privileges in order to change the IFEO +// registry options. +// +// The command line must be in the following format: +// A STR parameter is a quoted string. The string must be double quoted. +// There is no escape character and therefore STR parameters cannot contain +// double quotes. +// A BOOL parameter is an unquoted number either 1 or 0. +// +// <> +// +// STR1 parameter indicates the full path of the .exe file of the program +// which configuration is being set for. +// BOOL1 parameter is whether or not to enable VxKex for this program. +// STR2 parameter may consist of the following values and determines whether +// the Windows version reported to the application will be spoofed: +// NONE - no spoofing +// WIN8 - Windows 8 +// WIN81 - Windows 8.1 +// WIN10 - Windows 10 +// WIN11 - Windows 11 +// Any unrecognized value is equivalent to NONE. +// BOOL2 parameter is whether debugging information will always be shown. +// BOOL3 parameter is whether VxKex will be disabled for child processes. +// BOOL4 parameter is whether all app-specific hacks will be disabled. +// BOOL5 parameter is whether the VxKexLdr will wait for its child to exit +// before itself exiting. +// +// The behavior of the program when arguments are provided but do not match +// the template is undefined. + +INT APIENTRY tWinMain( + IN HINSTANCE hInstance, + IN HINSTANCE hPrevInstance, + IN LPTSTR lpszCmdLine, + IN INT iCmdShow) +{ + BOOL bRetryAsAdminOnFailure = FALSE; + TCHAR szExePath[MAX_PATH]; + TCHAR szExeName[MAX_PATH]; + TCHAR szWinVerSpoof[6]; + TCHAR szVxKexLdrPath[MAX_PATH]; + TCHAR szIfeoKey[74 + MAX_PATH] = T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\"); + TCHAR szKexIfeoKey[54 + MAX_PATH] = T("SOFTWARE\\VXsoft\\VxKexLdr\\Image File Execution Options\\"); + TCHAR szSystem32Path[MAX_PATH]; + + DWORD dwEnableVxKex; + DWORD dwAlwaysShowDebug; + DWORD dwDisableForChild; + DWORD dwDisableAppSpecific; + DWORD dwWaitForChild; + + SetFriendlyAppName(FRIENDLYAPPNAME); + + if (lpszCmdLine == NULL || strlen(lpszCmdLine) == 0) { + // TODO: display something more useful to the user here e.g. a global configuration panel + InfoBoxF(T("This application is not intended to be used standalone. To configure VxKex for a program, ") + T("open the Properties dialog for that program and select the 'VxKex' tab.")); + ExitProcess(0); + } + + sscanf_s(lpszCmdLine, T("\"%259[^\"]\" %I32u \"%5[^\"]\" %I32u %I32u %I32u %I32u"), + szExePath, ARRAYSIZE(szExePath), + &dwEnableVxKex, + szWinVerSpoof, ARRAYSIZE(szWinVerSpoof), + &dwAlwaysShowDebug, + &dwDisableForChild, + &dwDisableAppSpecific, + &dwWaitForChild); + + if (PathIsRelative(szExePath)) { + CriticalErrorBoxF(T("An absolute path must be passed to ") APPNAME T(".")); + } + + strcpy_s(szExeName, ARRAYSIZE(szExeName), szExePath); + PathStripPath(szExeName); + strcat_s(szIfeoKey, ARRAYSIZE(szIfeoKey), szExeName); + strcat_s(szKexIfeoKey, ARRAYSIZE(szKexIfeoKey), szExePath); + CHECKED(RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szVxKexLdrPath, ARRAYSIZE(szVxKexLdrPath))); + strcat_s(szVxKexLdrPath, ARRAYSIZE(szVxKexLdrPath), T("\\VxKexLdr.exe")); + CHECKED(GetSystemDirectory(szSystem32Path, ARRAYSIZE(szSystem32Path))); + bRetryAsAdminOnFailure = TRUE; + + if (dwEnableVxKex) { + TCHAR szOldDebugger[MAX_PATH]; + + if (RegReadSz(HKEY_LOCAL_MACHINE, szIfeoKey, T("Debugger"), szOldDebugger, ARRAYSIZE(szOldDebugger)) && + !lstrcmpi(szOldDebugger, szVxKexLdrPath)) { + // no need to try to write anything to the "Debugger" value + // do nothing + } else { + CHECKED(RegWriteSz(HKEY_LOCAL_MACHINE, szIfeoKey, T("Debugger"), szVxKexLdrPath)); + } + } else { + TCHAR szOldDebugger[MAX_PATH]; + + // Likewise, only delete the registry key if it exists. This helps avoid spurious + // UAC prompts. + if (RegReadSz(HKEY_LOCAL_MACHINE, szIfeoKey, T("Debugger"), szOldDebugger, ARRAYSIZE(szOldDebugger))) { + // Don't use CHECKED() here because it will sometimes fail wrongly + // when the "Debugger" value doesn't exist (e.g. if you disable VxKex twice in a row) + if (!RegDelValue(HKEY_LOCAL_MACHINE, szIfeoKey, T("Debugger")) && GetLastError() != ERROR_FILE_NOT_FOUND) { + goto Error; + } + } + } + + // This creates a tree structure under the kex IFEO key. + // VxKexLdr + // Image File Execution Options + // C: + // Users + // Bob + // Programs + // program.exe + // EnableVxKex(REG_DWORD) = 1 + // WinVerSpoof(REG_SZ) = "WIN10" + // etc., since backslashes aren't permitted in registry key names. + CHECKED(RegWriteDw(HKEY_CURRENT_USER, szKexIfeoKey, T("EnableVxKex"), dwEnableVxKex)); + CHECKED(RegWriteSz(HKEY_CURRENT_USER, szKexIfeoKey, T("WinVerSpoof"), szWinVerSpoof)); + CHECKED(RegWriteDw(HKEY_CURRENT_USER, szKexIfeoKey, T("AlwaysShowDebug"), dwAlwaysShowDebug)); + CHECKED(RegWriteDw(HKEY_CURRENT_USER, szKexIfeoKey, T("DisableForChild"), dwDisableForChild)); + CHECKED(RegWriteDw(HKEY_CURRENT_USER, szKexIfeoKey, T("DisableAppSpecific"), dwDisableAppSpecific)); + CHECKED(RegWriteDw(HKEY_CURRENT_USER, szKexIfeoKey, T("WaitForChild"), dwWaitForChild)); + + ExitProcess(0); + +Error: + if (bRetryAsAdminOnFailure && GetLastError() == ERROR_ACCESS_DENIED) { + TCHAR szSelfPath[MAX_PATH]; + + // if a CHECKED statement fails in here, we will effectively "fall through" to the + // other code path which just gives up. + bRetryAsAdminOnFailure = FALSE; + + CHECKED(GetModuleFileName(NULL, szSelfPath, ARRAYSIZE(szSelfPath))); + CHECKED(ShellExecute(NULL, T("runas"), szSelfPath, lpszCmdLine, NULL, 0) > (HINSTANCE) 32); + ExitProcess(0); + } else if (GetLastError() == ERROR_CANCELLED) { + // don't display an unnecessary warning box if the user simply clicked no on the UAC box + ExitProcess(0); + } else { + CriticalErrorBoxF(T("A critical error was encountered while attempting to operate on %s.\nError code: %#010I32x: %s"), + szExePath, GetLastError(), GetLastErrorAsString()); + } +} \ No newline at end of file diff --git a/KexCfg/KexCfg.vcxproj b/KexCfg/KexCfg.vcxproj new file mode 100644 index 0000000..24660e3 --- /dev/null +++ b/KexCfg/KexCfg.vcxproj @@ -0,0 +1,155 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3E126701-0D6C-404F-821D-F51F2B1BB0FB} + Win32Proj + KexCfg + + + + Application + true + Unicode + + + Application + true + Unicode + + + Application + false + true + Unicode + + + Application + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;KexComm.lib;%(AdditionalDependencies) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;KexComm.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;KexComm.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;KexComm.lib;%(AdditionalDependencies) + + + + + + + + + \ No newline at end of file diff --git a/KexCfg/KexCfg.vcxproj.filters b/KexCfg/KexCfg.vcxproj.filters new file mode 100644 index 0000000..4e29330 --- /dev/null +++ b/KexCfg/KexCfg.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + \ No newline at end of file diff --git a/KexCfg/KexCfg.vcxproj.user b/KexCfg/KexCfg.vcxproj.user new file mode 100644 index 0000000..59411ea --- /dev/null +++ b/KexCfg/KexCfg.vcxproj.user @@ -0,0 +1,7 @@ + + + + "C:\Users\vxiiduu\Documents\Code\bespoke\BespokeSynth.exe" 0 "NONE" 0 0 0 0 + WindowsLocalDebugger + + \ No newline at end of file diff --git a/KexComm.h b/KexComm.h new file mode 100644 index 0000000..222367d --- /dev/null +++ b/KexComm.h @@ -0,0 +1,120 @@ +#pragma once +#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") + +#include +#include +#include +#include +#include +#include + +#define T TEXT +#define ASSUME __assume +#define NORETURN __declspec(noreturn) +#define STATIC static +#define INLINE _inline +#define VOLATILE volatile +#define DECLSPEC_EXPORT __declspec(dllexport) +#define CHECKED(x) if (!(x)) goto Error +#define tWinMain _tWinMain +#define getch _getch +#define cprintf _tcprintf +#define caprintf _cprintf +#define cwprintf _cwprintf +#define strlen _tcslen +#define stricmp _tcsicmp +#define strnicmp _tcsnicmp +#define strcpy_s _tcscpy_s +#define strcat_s _tcscat_s +#define scprintf _sctprintf +#define vscprintf _vsctprintf +#define vsprintf_s _vstprintf_s +#define sprintf_s _stprintf_s +#define snprintf_s _sntprintf_s +#define sscanf_s _stscanf_s +#define StackAlloc _alloca + +#define until (condition) while (!(condition)) +#define unless (condition) if (!(condition)) + +typedef LPVOID *PPVOID; +typedef unsigned __int64 QWORD, *PQWORD, *LPQWORD, **PPQWORD; +typedef LONG KPRIORITY; + +EXTERN_C VOID SetFriendlyAppName( + IN LPCTSTR lpszFriendlyName); + +EXTERN_C LPCTSTR GetLastErrorAsString( + VOID); + +EXTERN_C VOID MessageBoxV( + IN UINT uType OPTIONAL, + IN LPCTSTR lpszFmt, + IN va_list ap); + +EXTERN_C VOID ErrorBoxF( + IN LPCTSTR lpszFmt, ...); + +EXTERN_C NORETURN VOID CriticalErrorBoxF( + IN LPCTSTR lpszFmt, ...); + +EXTERN_C VOID InfoBoxF( + IN LPCTSTR lpszFmt, ...); + +EXTERN_C BOOL RegReadSz( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + OUT LPTSTR lpszData, + IN DWORD dwcchData); + +EXTERN_C BOOL RegWriteSz( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + IN LPCTSTR lpszData OPTIONAL); + +EXTERN_C BOOL RegReadDw( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + OUT LPDWORD lpdwData); + +EXTERN_C BOOL RegWriteDw( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + IN DWORD dwData); + +EXTERN_C BOOL RegDelValue( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName); + +HANDLE CreateTempFile( + IN LPCTSTR lpszPrefix, + IN DWORD dwDesiredAccess, + IN DWORD dwShareMode, + IN LPSECURITY_ATTRIBUTES lpSecurityAttributes); + +BOOL WriteFileWF( + IN HANDLE hFile, + IN LPCWSTR lpszFmt, ...); + +LPVOID __AutoHeapAllocHelper( + IN SIZE_T cb); + +LPVOID __AutoStackAllocHelper( + IN LPVOID lpv); + +VOID AutoFree( + IN LPVOID lpv); + +#define __MAX_STACK_ALLOC_SIZE 1024 +#define AutoAlloc(cb) (((cb) < __MAX_STACK_ALLOC_SIZE) ? __AutoStackAllocHelper(StackAlloc((cb) + 1)) : __AutoHeapAllocHelper((cb) + 1)) + +#ifdef UNICODE +#define WriteFileF WriteFileWF +#else +#define WriteFileF WriteFileAF +#endif \ No newline at end of file diff --git a/KexComm/File.c b/KexComm/File.c new file mode 100644 index 0000000..b403a50 --- /dev/null +++ b/KexComm/File.c @@ -0,0 +1,43 @@ +#include +#include + +HANDLE CreateTempFile( + IN LPCTSTR lpszPrefix, + IN DWORD dwDesiredAccess, + IN DWORD dwShareMode, + IN LPSECURITY_ATTRIBUTES lpSecurityAttributes) +{ + static TCHAR szTempDir[MAX_PATH]; + static TCHAR szTempPath[MAX_PATH]; + GetTempPath(ARRAYSIZE(szTempDir), szTempDir); + GetTempFileName(szTempDir, lpszPrefix, 0, szTempPath); + return CreateFile(szTempPath, dwDesiredAccess, dwShareMode, lpSecurityAttributes, + CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE, NULL); +} + +BOOL WriteFileWF( + IN HANDLE hFile, + IN LPCWSTR lpszFmt, ...) +{ + va_list ap; + DWORD cch; + DWORD cb; + LPWSTR lpszBuf; + BOOL bResult; + DWORD dwDiscard; + DWORD dwError; + + va_start(ap, lpszFmt); + + cch = _vscwprintf(lpszFmt, ap) + 1; + cb = cch * sizeof(WCHAR); + lpszBuf = (LPTSTR) AutoAlloc(cb); + vswprintf_s(lpszBuf, cch, lpszFmt, ap); + bResult = WriteFile(hFile, lpszBuf, cb - sizeof(WCHAR), &dwDiscard, NULL); + dwError = GetLastError(); + + AutoFree(lpszBuf); + va_end(ap); + SetLastError(dwError); + return bResult; +} \ No newline at end of file diff --git a/KexComm/KexComm.vcxproj b/KexComm/KexComm.vcxproj new file mode 100644 index 0000000..4d79711 --- /dev/null +++ b/KexComm/KexComm.vcxproj @@ -0,0 +1,162 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + + + + + + + + + + {24FC500A-AA39-4886-B19F-4ADB19642DB9} + Win32Proj + KexComm + + + + StaticLibrary + true + Unicode + + + StaticLibrary + true + Unicode + + + StaticLibrary + false + true + Unicode + + + StaticLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + Sync + true + CompileAsC + $(SolutionDir) + + + Windows + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + Sync + true + CompileAsC + $(SolutionDir) + + + Windows + true + + + + + Level3 + + + MinSpace + true + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + OnlyExplicitInline + Size + true + true + false + false + CompileAsC + $(SolutionDir) + + + Windows + true + true + true + + + + + Level3 + + + MinSpace + true + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + OnlyExplicitInline + Size + true + true + false + false + CompileAsC + $(SolutionDir) + + + Windows + true + true + true + + + + + + \ No newline at end of file diff --git a/KexComm/KexComm.vcxproj.filters b/KexComm/KexComm.vcxproj.filters new file mode 100644 index 0000000..737bcd2 --- /dev/null +++ b/KexComm/KexComm.vcxproj.filters @@ -0,0 +1,36 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + \ No newline at end of file diff --git a/KexComm/KexComm.vcxproj.user b/KexComm/KexComm.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/KexComm/KexComm.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/KexComm/Memory.c b/KexComm/Memory.c new file mode 100644 index 0000000..469b16c --- /dev/null +++ b/KexComm/Memory.c @@ -0,0 +1,40 @@ +#include +#include +#include + +typedef enum _AUTOALLOCTYPE { + AutoInvalidAlloc, + AutoStackAlloc, + AutoHeapAlloc +} AUTOALLOCTYPE, *PAUTOALLOCTYPE, *LPAUTOALLOCTYPE; + +LPVOID __AutoHeapAllocHelper( + IN SIZE_T cb) +{ + LPBYTE lpb = (LPBYTE) HeapAlloc(NtCurrentPeb()->ProcessHeap, 0, cb); + + if (!lpb) { + return NULL; + } + + *lpb = AutoHeapAlloc; + return (LPVOID) (lpb + 1); +} + +LPVOID __AutoStackAllocHelper( + IN LPVOID lpv) +{ + LPBYTE lpb = (LPBYTE) lpv; + *lpb = AutoStackAlloc; + return (LPVOID) (lpb + 1); +} + +VOID AutoFree( + IN LPVOID lpv) +{ + LPBYTE lpb = ((LPBYTE) lpv) - 1; + + if (lpv != NULL && *lpb == AutoHeapAlloc) { + HeapFree(NtCurrentPeb()->ProcessHeap, 0, lpb); + } +} \ No newline at end of file diff --git a/KexComm/Msgbox.c b/KexComm/Msgbox.c new file mode 100644 index 0000000..71656b3 --- /dev/null +++ b/KexComm/Msgbox.c @@ -0,0 +1,65 @@ +#include +#include + +#ifdef _DEBUG +TCHAR szFriendlyAppName[64] = T("YOU MUST CALL SetFriendlyAppName()"); +#else +TCHAR szFriendlyAppName[64]; +#endif + +VOID SetFriendlyAppName( + IN LPCTSTR lpszFriendlyName) +{ + strcpy_s(szFriendlyAppName, ARRAYSIZE(szFriendlyAppName), lpszFriendlyName); +} + +LPCTSTR GetLastErrorAsString( + VOID) +{ + static TCHAR lpszErrMsg[256]; + FormatMessage( + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, GetLastError(), 0, lpszErrMsg, + ARRAYSIZE(lpszErrMsg) - 1, NULL); + return lpszErrMsg; +} + +VOID MessageBoxV( + IN UINT uType OPTIONAL, + IN LPCTSTR lpszFmt, + IN va_list ap) +{ + SIZE_T cch = vscprintf(lpszFmt, ap) + 1; + LPTSTR lpText = (LPTSTR) malloc(cch * sizeof(TCHAR)); + vsprintf_s(lpText, cch, lpszFmt, ap); + MessageBox(NULL, lpText, szFriendlyAppName, uType); + free(lpText); +} + +VOID ErrorBoxF( + IN LPCTSTR lpszFmt, ...) +{ + va_list ap; + va_start(ap, lpszFmt); + MessageBoxV(MB_ICONERROR | MB_OK, lpszFmt, ap); + va_end(ap); +} + +NORETURN VOID CriticalErrorBoxF( + IN LPCTSTR lpszFmt, ...) +{ + va_list ap; + va_start(ap, lpszFmt); + MessageBoxV(MB_ICONERROR | MB_OK, lpszFmt, ap); + va_end(ap); + ExitProcess(0); +} + +VOID InfoBoxF( + IN LPCTSTR lpszFmt, ...) +{ + va_list ap; + va_start(ap, lpszFmt); + MessageBoxV(MB_ICONINFORMATION | MB_OK, lpszFmt, ap); + va_end(ap); +} \ No newline at end of file diff --git a/KexComm/Registry.c b/KexComm/Registry.c new file mode 100644 index 0000000..8170eb8 --- /dev/null +++ b/KexComm/Registry.c @@ -0,0 +1,114 @@ +#include +#include + +BOOL RegReadSz( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + OUT LPTSTR lpszData, + IN DWORD dwcchData) +{ + HKEY hSubKey; + LSTATUS lStatus; + + dwcchData *= sizeof(TCHAR); + lStatus = RegOpenKeyEx(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey); + if (lStatus != ERROR_SUCCESS) goto Error; + lStatus = RegQueryValueEx(hSubKey, lpszValueName, 0, NULL, (LPBYTE) lpszData, &dwcchData); + if (lStatus != ERROR_SUCCESS) goto Error; + + RegCloseKey(hSubKey); + return TRUE; + +Error: + SetLastError(lStatus); + return FALSE; +} + +BOOL RegWriteSz( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + IN LPCTSTR lpszData OPTIONAL) +{ + HKEY hSubKey; + LSTATUS lStatus; + + lStatus = RegCreateKeyEx(hKey, lpszSubKey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hSubKey, NULL); + if (lStatus != ERROR_SUCCESS) goto Error; + lStatus = RegSetValueEx(hSubKey, lpszValueName, 0, REG_SZ, (LPBYTE) lpszData, (DWORD) (strlen(lpszData) + 1) * sizeof(TCHAR)); + if (lStatus != ERROR_SUCCESS) goto Error; + + RegCloseKey(hSubKey); + return TRUE; + +Error: + SetLastError(lStatus); + return FALSE; +} + +BOOL RegReadDw( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + OUT LPDWORD lpdwData) +{ + HKEY hSubKey; + LSTATUS lStatus; + DWORD dwcbData = sizeof(DWORD); + + lStatus = RegOpenKeyEx(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey); + if (lStatus != ERROR_SUCCESS) goto Error; + lStatus = RegQueryValueEx(hSubKey, lpszValueName, 0, NULL, (LPBYTE) lpdwData, &dwcbData); + if (lStatus != ERROR_SUCCESS) goto Error; + + RegCloseKey(hSubKey); + return TRUE; + +Error: + SetLastError(lStatus); + return FALSE; +} + +BOOL RegWriteDw( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName OPTIONAL, + IN DWORD dwData) +{ + HKEY hSubKey; + LSTATUS lStatus; + + lStatus = RegCreateKeyEx(hKey, lpszSubKey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hSubKey, NULL); + if (lStatus != ERROR_SUCCESS) goto Error; + lStatus = RegSetValueEx(hSubKey, lpszValueName, 0, REG_DWORD, (LPBYTE) &dwData, sizeof(DWORD)); + if (lStatus != ERROR_SUCCESS) goto Error; + + RegCloseKey(hSubKey); + return TRUE; + +Error: + SetLastError(lStatus); + return FALSE; +} + +BOOL RegDelValue( + IN HKEY hKey, + IN LPCTSTR lpszSubKey, + IN LPCTSTR lpszValueName) +{ + HKEY hSubKey; + LSTATUS lStatus; + + lStatus = RegOpenKeyEx(hKey, lpszSubKey, 0, KEY_SET_VALUE, &hSubKey); + if (lStatus != ERROR_SUCCESS) goto Error; + lStatus = RegDeleteValue(hSubKey, lpszValueName); + if (lStatus != ERROR_SUCCESS) goto Error; + + RegCloseKey(hSubKey); + return TRUE; + +Error: + SetLastError(lStatus); + return FALSE; +} \ No newline at end of file diff --git a/KexDll.h b/KexDll.h new file mode 100644 index 0000000..a5f4ac4 --- /dev/null +++ b/KexDll.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include +#include + +#define DLLAPI DECLSPEC_EXPORT +#undef WINBASEAPI +#define WINBASEAPI DECLSPEC_EXPORT +#undef WINUSERAPI +#define WINUSERAPI DECLSPEC_EXPORT + +#define _STR(x) #x +#define STR(x) _STR(x) + +#ifdef _DEBUG +# define ODS(...) { TCHAR __ods_buf[256]; sprintf_s(__ods_buf, ARRAYSIZE(__ods_buf), T(__FUNCTION__) T("(") T(__FILE__) T(":") T(STR(__LINE__)) T("): ") __VA_ARGS__); OutputDebugString(__ods_buf); } +# define ODS_ENTRY(...) { TCHAR __ods_buf[256]; sprintf_s(__ods_buf, ARRAYSIZE(__ods_buf), T("Function called: ") T(__FUNCTION__) __VA_ARGS__); OutputDebugString(__ods_buf); } +#else +# define ODS(...) +# define ODS_ENTRY(...) +#endif \ No newline at end of file diff --git a/KexExprt/KexExprt.c b/KexExprt/KexExprt.c new file mode 100644 index 0000000..09b9a53 --- /dev/null +++ b/KexExprt/KexExprt.c @@ -0,0 +1,237 @@ +#include +#include +#include +#include +#include +#include + +#include "resource.h" + +#define APPNAME T("KexExprt") + +#ifdef _M_X64 +# define FRIENDLYAPPNAME T("Module-Definition File Generator (64 bit)") +#else +# define FRIENDLYAPPNAME T("Module-Definition File Generator (32 bit)") +#endif + +#ifdef _M_X64 +# define BITS 64 +#else +# define BITS 32 +#endif + +DWORD WINAPI ThreadProc( + IN LPVOID lpParameter) +{ +#define RVA_TO_VA(rva) (((LPBYTE) hMod) + (rva)) + + HWND hWnd = (HWND) lpParameter; + HWND hWndEdit = GetDlgItem(hWnd, IDRESULT); + TCHAR szDllPath[MAX_PATH]; + HMODULE hMod; + HANDLE hProc = GetCurrentProcess(); + UINT i; + + HANDLE hTempFile = CreateTempFile(T("kxp"), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL); + HANDLE hMapping; + LPCTSTR lpszDocument; + DWORD dwDiscard; + + PIMAGE_DOS_HEADER lpDosHdr; + PIMAGE_NT_HEADERS lpNtHdr; + PIMAGE_EXPORT_DIRECTORY lpExportDir; + + LPDWORD lpNameRvas; + LPWORD lpNameOrdinals; + LPDWORD lpFunctionRvas; + PBOOLEAN lpOrdinalHasName; + + BOOL bPragma = FALSE; + + GetDlgItemText(hWnd, IDFILEPATH, szDllPath, ARRAYSIZE(szDllPath)); + hMod = LoadLibraryEx(szDllPath, NULL, DONT_RESOLVE_DLL_REFERENCES); + + if (!hMod) { + ErrorBoxF(T("Could not load the DLL file \"%s\": %s"), szDllPath, GetLastErrorAsString()); + goto FinishThreadProc; + } + + if (IsDlgButtonChecked(hWnd, IDRBPRAGMA)) { + bPragma = TRUE; + } + + GetModuleFileName(hMod, szDllPath, ARRAYSIZE(szDllPath)); + WriteFileWF(hTempFile, T("%s Generated by KexExprt (%d bit) from %s\r\n"), bPragma ? T("//") : T(";;"), BITS, szDllPath); + PathStripPath(szDllPath); + PathRemoveExtension(szDllPath); + + lpDosHdr = (PIMAGE_DOS_HEADER) hMod; + lpNtHdr = (PIMAGE_NT_HEADERS) RVA_TO_VA(lpDosHdr->e_lfanew); + + if (lpNtHdr->OptionalHeader.NumberOfRvaAndSizes == 0) { + InfoBoxF(T("This DLL contains no exports.")); + goto FinishThreadProc; + } + + lpExportDir = (PIMAGE_EXPORT_DIRECTORY) RVA_TO_VA(lpNtHdr->OptionalHeader.DataDirectory[0].VirtualAddress); + lpNameRvas = (LPDWORD) RVA_TO_VA(lpExportDir->AddressOfNames); + lpNameOrdinals = (LPWORD) RVA_TO_VA(lpExportDir->AddressOfNameOrdinals); + lpFunctionRvas = (LPDWORD) RVA_TO_VA(lpExportDir->AddressOfFunctions); + lpOrdinalHasName = (PBOOLEAN) AutoAlloc(lpExportDir->NumberOfFunctions); + ZeroMemory(lpOrdinalHasName, lpExportDir->NumberOfFunctions); + + if (!bPragma) { + WriteFileWF(hTempFile, T("EXPORTS\r\n")); + } + + for (i = 0; i < lpExportDir->NumberOfNames; ++i) { + LPCSTR lpszName = (LPCSTR) RVA_TO_VA(lpNameRvas[i]); + WORD wNameOrdinal = lpNameOrdinals[i]; + DWORD dwOrdinal = lpExportDir->Base + wNameOrdinal; + + if (bPragma) { + WriteFileWF(hTempFile, T("#pragma comment(linker, \"/export:%S=%s.%S,@%I32u\")\r\n"), lpszName, szDllPath, lpszName, dwOrdinal); + } else { + WriteFileWF(hTempFile, T("\t%S = %s.%S @%I32u\r\n"), lpszName, szDllPath, lpszName, dwOrdinal); + } + + lpOrdinalHasName[wNameOrdinal] = TRUE; + } + + for (i = 0; i < lpExportDir->NumberOfFunctions; ++i) { + DWORD dwOrdinal = lpExportDir->Base + i; + + if (lpOrdinalHasName[i] != TRUE && lpFunctionRvas[dwOrdinal - lpExportDir->Base] != 0) { + if (bPragma) { + WriteFileWF(hTempFile, T("#pragma comment(linker, \"/export:__OrdinalFunction%I32X=%s.#%I32u,@%I32u,NONAME\")\r\n"), dwOrdinal, szDllPath, dwOrdinal, dwOrdinal); + } else { + WriteFileWF(hTempFile, T("\t__OrdinalFunction%I32X = %s.#%I32u @%I32u NONAME\r\n"), dwOrdinal, szDllPath, dwOrdinal, dwOrdinal); + } + } + } + + AutoFree(lpOrdinalHasName); + + WriteFile(hTempFile, T(""), sizeof(TCHAR), &dwDiscard, NULL); + hMapping = CreateFileMapping(hTempFile, NULL, PAGE_READONLY, 0, 0, NULL); + lpszDocument = (LPCTSTR) MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0); + Edit_SetText(hWndEdit, lpszDocument); + UnmapViewOfFile(lpszDocument); + CloseHandle(hMapping); + CloseHandle(hTempFile); + +FinishThreadProc: + EnableWindow(GetDlgItem(hWnd, IDFILEPATH), TRUE); + EnableWindow(GetDlgItem(hWnd, IDOK), TRUE); + FreeLibrary(hMod); + ExitThread(0); + +#undef RVA_TO_VA +} + +HGDIOBJ SetStaticCtlBk( + IN HWND hWndDlg, + IN HWND hWndCtl, + IN HDC hDC) +{ + if (GetWindowLongPtr(hWndCtl, GWLP_ID) == IDRESULT) { + // Note: don't use hollow brush, that causes glitches when you change the text + // in a text control. + return GetStockObject(WHITE_BRUSH); + } + + return FALSE; +} + +INT_PTR CALLBACK DlgProc( + IN HWND hWnd, + IN UINT uMsg, + IN WPARAM wParam, + IN LPARAM lParam) +{ + UINT uTabStops = 16; + TCHAR szFilename[MAX_PATH] = T(""); + + switch (uMsg) { + case WM_INITDIALOG: + SetWindowText(hWnd, FRIENDLYAPPNAME); + EnableWindow(GetDlgItem(hWnd, IDOK), FALSE); + CheckDlgButton(hWnd, IDRBDEF, TRUE); + DragAcceptFiles(hWnd, TRUE); + SendMessage(GetDlgItem(hWnd, IDRESULT), WM_SETFONT, (WPARAM) CreateFont( + -MulDiv(8, GetDeviceCaps(GetDC(GetDlgItem(hWnd, IDRESULT)), LOGPIXELSY), 72), + 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, + CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_DONTCARE, + T("Consolas")), MAKELPARAM(TRUE, 0)); + Edit_SetTabStops(GetDlgItem(hWnd, IDRESULT), 1, &uTabStops); + return TRUE; + case WM_COMMAND: + if (LOWORD(wParam) == IDCANCEL) { + EndDialog(hWnd, 0); + } else if (LOWORD(wParam) == IDBROWSE) { + OPENFILENAME ofn; + + if (GetFocus() == GetDlgItem(hWnd, IDFILEPATH)) { + PostMessage(hWnd, WM_COMMAND, IDOK, 0); + return TRUE; + } + + ZeroMemory(&ofn, sizeof(ofn)); + ofn.lStructSize = sizeof(ofn); + ofn.hwndOwner = hWnd; + ofn.lpstrFilter = T("Application extension (*.dll)\0*.dll\0All Files (*.*)\0*.*\0"); + ofn.lpstrFile = szFilename; + ofn.nMaxFile = MAX_PATH; + ofn.lpstrInitialDir = T("C:\\Program Files\\"); + ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY; + ofn.lpstrDefExt = T("exe"); + + if (GetOpenFileName(&ofn)) { + SetDlgItemText(hWnd, IDFILEPATH, szFilename); + } + } else if (LOWORD(wParam) == IDOK) { + HANDLE hThread; + EnableWindow(GetDlgItem(hWnd, IDOK), FALSE); + EnableWindow(GetDlgItem(hWnd, IDFILEPATH), FALSE); + + if ((hThread = CreateThread(NULL, 0, ThreadProc, hWnd, 0, NULL))) { + CloseHandle(hThread); + } else { + EnableWindow(GetDlgItem(hWnd, IDFILEPATH), TRUE); + EnableWindow(GetDlgItem(hWnd, IDOK), TRUE); + } + } else if (LOWORD(wParam) == IDFILEPATH) { + if (HIWORD(wParam) == EN_CHANGE) { + INT iTextLength = GetWindowTextLength(GetDlgItem(hWnd, IDFILEPATH)); + EnableWindow(GetDlgItem(hWnd, IDOK), !!iTextLength); + } else { + return FALSE; + } + } else { + return FALSE; + } + + return TRUE; + case WM_DROPFILES: + DragQueryFile((HDROP) wParam, 0, szFilename, MAX_PATH); + SetDlgItemText(hWnd, IDFILEPATH, szFilename); + DragFinish((HDROP) wParam); + return FALSE; + case WM_CTLCOLORSTATIC:; + return (INT_PTR) SetStaticCtlBk(hWnd, (HWND) lParam, (HDC) wParam); + } + + return FALSE; +} + +INT APIENTRY tWinMain( + IN HINSTANCE hInstance, + IN HINSTANCE hPrevInstance, + IN LPTSTR lpszCmdLine, + IN INT iCmdShow) +{ + SetFriendlyAppName(FRIENDLYAPPNAME); + DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DlgProc); + ExitProcess(0); +} \ No newline at end of file diff --git a/KexExprt/KexExprt.rc b/KexExprt/KexExprt.rc new file mode 100644 index 0000000000000000000000000000000000000000..b3ff7a2b0adf84f61e0f8ff05c073f58e4d21ecc GIT binary patch literal 2846 zcmb7`+ioL85Qgj4NW8;nkoF3aIB{55AtXC?5(_6|#U|OkTA8fZSb{k60fJy(9r*t0 z={aO48_;Nay1T0D@YkW|pTEDbrQO-B{bD{bZ`CizWrto>@SJgj%Obo4|p+W9I>}XYVc5!>-wW-eYiKslgIaHSR(nZ zVol1q*LW?dYbbN@NbunSUfI6MPb7B1N!cO1zB0*u5ABXON=*tp6Y$q*$(%u7{U=+m zoj+=O@KUL$v1;Mkm(^+-?QpW*EWZ-sRkVO7`zZ^+wnrR)v5gB=4< z>idp%hs^ubQ=geKIwO{<@akHAh5C(SmD=X?jmw$ZIeA|{E9yDO43T?Y)b)hf8?>pS z`(E=W%vJa5D~bJ8>|bC}-z__Z(j_l-rle0?`UqL-K#~xsH@Q^xi7DDet5U}7jH%zT z+b%>hW&x*C(l_o;idOZf2^Fh~QO)!j7kMVd9x`(KUo*C#Oq_R4HE!Xb`5D=ncqOT> z5-2Oi9nsWEJ!#E%!K$n#Ro#MJ^?`fmP>0#`98VngGyG5-2Zeq`p-tTNec2e3GGYn! zU2^MGK%wr<3oKvZOPO=8Di(x}+bxi;>OaI1t&ehhN(}>S9&$!e7iz(qcz=wEcFd@b z9lMM+9a*vty)y?bN4_)gcy~c!N+i!&oscgXR*!OjgwLtRTshNoPVp))QhUM98V_|l z>c-QfE)s0&xh&<>!1tcc|A6M#g|8ulj*E4t5nbIuQSD9ykfva6h-$2~qi!MPu)4 z3%cyAf`IH&ckR+WE*Pc#Wu6PsI`up4mwBbSZjN#No(lIwh;T+fmz3us+eS~vIgfHX zs + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {1E020116-467E-4D16-8C80-0CC2867965E5} + Win32Proj + KexExprt + + + + Application + true + Unicode + + + Application + true + Unicode + + + Application + false + true + Unicode + + + Application + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + $(ProjectName)64 + + + false + + + false + $(ProjectName)64 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Shlwapi.lib;KexComm.lib;comctl32.lib;KexComm.lib;%(AdditionalDependencies) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Shlwapi.lib;KexComm.lib;comctl32.lib;KexComm.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Shlwapi.lib;KexComm.lib;comctl32.lib;KexComm.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + $(TargetDir) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Shlwapi.lib;KexComm.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/KexExprt/KexExprt.vcxproj.filters b/KexExprt/KexExprt.vcxproj.filters new file mode 100644 index 0000000..2122b4d --- /dev/null +++ b/KexExprt/KexExprt.vcxproj.filters @@ -0,0 +1,32 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Header Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/KexExprt/KexExprt.vcxproj.user b/KexExprt/KexExprt.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/KexExprt/KexExprt.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/KexExprt/resource.h b/KexExprt/resource.h new file mode 100644 index 0000000..566f9c4 --- /dev/null +++ b/KexExprt/resource.h @@ -0,0 +1,56 @@ +#pragma once + +#define DIALOG1_WIDTH 400 +#define DIALOG1_HEIGHT 300 +#define IDD_DIALOG1 101 +#define IDGUIDETEXT 102 +#define IDLOCATION 103 +#define IDFILEPATH 104 +#define IDBROWSE 105 +#define IDSTYLESEL 106 +#define IDRBDEF 107 +#define IDRBPRAGMA 108 +#define IDRESULT 109 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/KexSetup/KexSetup.c b/KexSetup/KexSetup.c new file mode 100644 index 0000000..8255179 --- /dev/null +++ b/KexSetup/KexSetup.c @@ -0,0 +1,956 @@ +#define CINTERFACE +#define COBJMACROS +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "resource.h" + +#define APPNAME T("KexSetup") +#define FRIENDLYAPPNAME T("VxKex Setup") + +INT g_iScene = 0; + +LPCTSTR g_lpszInstallerVersion = T(KEX_VERSION_STR); +DWORD g_dwInstallerVersion; +LPCTSTR g_lpszInstalledVersion; +DWORD g_dwInstalledVersion; +TCHAR g_szInstalledKexDir[MAX_PATH] = T(""); +DWORD g_dwDiskSpaceRequired = 0; + +HANDLE g_hWorkThread = NULL; + +// +// Worker functions +// + +VOID ElevateIfNotElevated( + IN LPCTSTR lpszCmdLine, + IN INT iCmdShow) +{ + // Apparently using the manifest to do this can cause bluescreens on XP if you don't + // do it properly. Better safe than sorry. + if (!IsUserAnAdmin()) { + if (LOBYTE(LOWORD(GetVersion())) >= 6) { + TCHAR szSelfPath[MAX_PATH]; + GetModuleFileName(NULL, szSelfPath, ARRAYSIZE(szSelfPath)); + ShellExecute(NULL, T("runas"), szSelfPath, lpszCmdLine, NULL, iCmdShow); + ExitProcess(0); + } else { + CriticalErrorBoxF(T("You need to be an Administrator to run %s."), APPNAME); + } + } +} + +DWORD GetInstalledVersion( + VOID) +{ + DWORD dwResult; + + if (!RegReadDw(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("InstalledVersion"), &dwResult)) { + dwResult = 0; + } + + return dwResult; +} + +LPCTSTR GetInstalledVersionAsString( + VOID) +{ + static TCHAR szVersion[16]; // "255.255.255.255\0" + DWORD dwVersion = GetInstalledVersion(); + sprintf_s(szVersion, ARRAYSIZE(szVersion), T("%hhu.%hhu.%hhu.%hhu"), + HIBYTE(HIWORD(dwVersion)), LOBYTE(HIWORD(dwVersion)), + HIBYTE(LOWORD(dwVersion)), LOBYTE(LOWORD(dwVersion))); + return szVersion; +} + +DWORD GetVersionFromString( + IN LPCTSTR lpszVersion) +{ + union { + DWORD dwVersion; + + struct { + BYTE bDigit4; + BYTE bDigit3; + BYTE bDigit2; + BYTE bDigit1; + BYTE extra_padding; // required because %hhu isnt properly supported in vs2010 + // it is treated as %hu which means 1 extra byte is written + }; + } u; + + sscanf_s(lpszVersion, T("%hhu.%hhu.%hhu.%hhu"), &u.bDigit1, &u.bDigit2, &u.bDigit3, &u.bDigit4); + return u.dwVersion; +} + +INLINE LPCTSTR GetInstallerVersionAsString( + VOID) +{ + return T(KEX_VERSION_STR); +} + +INLINE DWORD GetInstallerVersion( + VOID) +{ + return GetVersionFromString(GetInstallerVersionAsString()); +} + +HGDIOBJ SetStaticCtlBk( + IN HWND hWndDlg, + IN HWND hWndCtl, + IN HDC hDC) +{ + static HFONT hFontBold = NULL; + + if (!hFontBold) { + hFontBold = CreateFont( + -MulDiv(8, GetDeviceCaps(hDC, LOGPIXELSY), 72), + 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, + CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_DONTCARE, + T("MS Shell Dlg 2")); + } + + switch (GetWindowLongPtr(hWndCtl, GWLP_ID)) { + case IDHDRTEXT: + SelectObject(hDC, hFontBold); + // fall through + case IDHDRSUBTEXT: + case IDS11CHANGELOG: + // Note: don't use hollow brush, that causes glitches when you change the text + // in a text control. + return GetStockObject(WHITE_BRUSH); + } + + return FALSE; +} + +// show the appropriate folder picker interface and return path to the directory +LPCTSTR PickFolder( + IN HWND hWndOwner, + IN LPCTSTR lpszDefaultValue OPTIONAL) +{ + static TCHAR szDirPath[MAX_PATH]; + IFileDialog *pfd = NULL; + HRESULT hr = CoCreateInstance(&CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, &IID_IFileOpenDialog, &pfd); + + if (!lpszDefaultValue) { + lpszDefaultValue = T(""); + } + + if (SUCCEEDED(hr)) { + // we can use the vista+ folder picker + IShellItem *psi = NULL; + LPTSTR lpszShellName; + DWORD dwFlags; + + IFileDialog_GetOptions(pfd, &dwFlags); + IFileDialog_SetOptions(pfd, dwFlags | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM | FOS_NOREADONLYRETURN); + IFileDialog_Show(pfd, hWndOwner); + IFileDialog_GetResult(pfd, &psi); + IFileDialog_Release(pfd); + + if (psi) { + IShellItem_GetDisplayName(psi, SIGDN_FILESYSPATH, &lpszShellName); + strcpy_s(szDirPath, ARRAYSIZE(szDirPath), lpszShellName); + CoTaskMemFree(lpszShellName); + IShellItem_Release(psi); + } else { + return lpszDefaultValue; + } + } else { + // display old style folder picker + BROWSEINFO bi; + LPITEMIDLIST lpIdl; + + bi.hwndOwner = hWndOwner; + bi.pidlRoot = NULL; + bi.pszDisplayName = NULL; + bi.lpszTitle = T("Select the installation directory."); + bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE; + bi.lpfn = NULL; + bi.lParam = 0; + bi.iImage = 0; + + CoInitialize(NULL); + lpIdl = SHBrowseForFolder(&bi); + + if (lpIdl) { + SHGetPathFromIDList(lpIdl, szDirPath); + CoTaskMemFree(lpIdl); + } + + CoUninitialize(); + + if (!lpIdl) { + return lpszDefaultValue; + } + } + + if (szDirPath[strlen(szDirPath) - 1] != '\\') { + strcat_s(szDirPath, ARRAYSIZE(szDirPath), T("\\")); + } + + strcat_s(szDirPath, ARRAYSIZE(szDirPath), T("VxKex")); + return szDirPath; +} + +// If lParam is NULL, this function will add up resource size into g_dwDiskSpaceRequired +// Otherwise lParam will be treated as a LPCTSTR containing the installation directory +// and will install all the resources into that directory. +BOOL WINAPI KexEnumResources( + IN HMODULE hModule OPTIONAL, + IN LPCTSTR lpszType, + IN LPWSTR lpszName, + IN LPARAM lParam) +{ + HRSRC hResource; + DWORD dwcbData; + + hResource = FindResource(hModule, lpszName, lpszType); + dwcbData = SizeofResource(hModule, hResource); + + if (!lParam) { + g_dwDiskSpaceRequired += dwcbData; + } else { + LPCTSTR lpszInstallDir = (LPCTSTR) lParam; + LPVOID lpData = (LPVOID) LoadResource(hModule, hResource); + TCHAR szFilePath[MAX_PATH]; + HANDLE hFile; + BOOL bSuccess; + DWORD dwcbWritten; + + sprintf_s(szFilePath, ARRAYSIZE(szFilePath), T("%s\\%s"), lpszInstallDir, lpszName); + hFile = CreateFile(szFilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + + if (!hFile) { + CriticalErrorBoxF(T("Failed to create or open the file %s: %s\nThe system may be in an inconsistent state. Correct the error before trying again (run the installer again and select Repair)."), + szFilePath, GetLastErrorAsString()); + } + + bSuccess = WriteFile(hFile, lpData, dwcbData, &dwcbWritten, NULL); + + if (!bSuccess) { + // most of the time this is caused by some app that has the DLLs opened. + CriticalErrorBoxF(T("Failed to write the file %s: %s\nThe system may be in an inconsistent state. Restart the computer before trying again (run the installer again and select Repair)."), + szFilePath, GetLastErrorAsString()); + } + + CloseHandle(hFile); + } + + return TRUE; +} + +VOID SetScene( + IN HWND hWnd, + IN INT iScene) +{ + g_iScene = iScene; + + // hide everything + ShowWindow(GetDlgItem(hWnd, IDPROGRESS), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS1GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS1RBUNINST), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS1RBREPAIR), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS1RBUPDATE), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS1CURRENTINFO), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS1INSTALLINFO), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS2GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS2DIRPATH), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS2BROWSE), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS2SPACEREQ), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS2SPACEAVAIL), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS3GUIDETEXT), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS4GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS4KEXCFG), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS4OPENGUIDE), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS5GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS5GUIDETEXT2), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS5UNDERSTAND), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS6GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS7GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS8GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS9GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS10GUIDETEXT), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS11GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS11GUIDETEXT2), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS11CHANGELOG), FALSE); + + ShowWindow(GetDlgItem(hWnd, IDS12GUIDETEXT), FALSE); + ShowWindow(GetDlgItem(hWnd, IDS13GUIDETEXT), FALSE); + + SendDlgItemMessage(hWnd, IDPROGRESS, PBM_SETMARQUEE, TRUE, 0); + EnableWindow(GetDlgItem(hWnd, IDBACK), TRUE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Next >")); + + // only show what we want to show + + if (iScene == 1) { + // operation selection + TCHAR szCurrentInfo[35 + 15 + MAX_PATH]; + TCHAR szInstallInfo[25 + 15 + 1]; + + SetDlgItemText(hWnd, IDHDRTEXT, T("Select Operation")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("VxKex is already installed. Choose what you want Setup to do:")); + ShowWindow(GetDlgItem(hWnd, IDS1GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS1RBUNINST), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS1RBREPAIR), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS1RBUPDATE), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS1CURRENTINFO), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS1INSTALLINFO), TRUE); + + sprintf_s(szCurrentInfo, ARRAYSIZE(szCurrentInfo), T("Version %s is currently installed in %s"), + g_lpszInstalledVersion, g_szInstalledKexDir); + SetDlgItemText(hWnd, IDS1CURRENTINFO, szCurrentInfo); + + if (g_dwInstallerVersion > g_dwInstalledVersion) { + EnableWindow(GetDlgItem(hWnd, IDS1RBUPDATE), TRUE); + } + + sprintf_s(szInstallInfo, ARRAYSIZE(szInstallInfo), T("The installer version is %s"), g_lpszInstallerVersion); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + + if (!(IsDlgButtonChecked(hWnd, IDS1RBUNINST) || IsDlgButtonChecked(hWnd, IDS1RBREPAIR) || IsDlgButtonChecked(hWnd, IDS1RBUPDATE))) { + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } + SetDlgItemText(hWnd, IDS1INSTALLINFO, szInstallInfo); + } else if (iScene == 2) { + // install -> select installation directory + // not shown during "repair/reinstall" or "update" because we already know kex dir in that case + TCHAR szInstallDir[MAX_PATH]; + TCHAR szFormattedSize[16]; + TCHAR szLabelStr[21 + ARRAYSIZE(szFormattedSize)] = T("Disk space required: "); + GetDlgItemText(hWnd, IDS2DIRPATH, szInstallDir, ARRAYSIZE(szInstallDir)); + + if (!(*szInstallDir)) { + ExpandEnvironmentStrings(T("%PROGRAMFILES%\\VxKex"), szInstallDir, ARRAYSIZE(szInstallDir)); + } + + SetDlgItemText(hWnd, IDHDRTEXT, T("Choose Install Location")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Choose where you want VxKex to install files.")); + ShowWindow(GetDlgItem(hWnd, IDS2GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS2DIRPATH), TRUE); + SetDlgItemText(hWnd, IDS2DIRPATH, szInstallDir); + ShowWindow(GetDlgItem(hWnd, IDS2BROWSE), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS2SPACEREQ), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS2SPACEAVAIL), TRUE); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + SetDlgItemText(hWnd, IDNEXT, T("&Install >")); + + EnumResourceNames(NULL, RT_RCDATA, KexEnumResources, 0); + StrFormatByteSize(g_dwDiskSpaceRequired, szFormattedSize, ARRAYSIZE(szFormattedSize)); + strcat_s(szLabelStr, ARRAYSIZE(szLabelStr), szFormattedSize); + SetDlgItemText(hWnd, IDS2SPACEREQ, szLabelStr); + } else if (iScene == 3) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Installing...")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Installation is now in progress.")); + ShowWindow(GetDlgItem(hWnd, IDS3GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDPROGRESS), TRUE); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } else if (iScene == 4) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Installation Complete")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("The components installed are now ready for use.")); + ShowWindow(GetDlgItem(hWnd, IDS4GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS4KEXCFG), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS4OPENGUIDE), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Finish")); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + } else if (iScene == 5) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Uninstall VxKex")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Review the information below, and then click Uninstall")); + ShowWindow(GetDlgItem(hWnd, IDS5GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS5GUIDETEXT2), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS5UNDERSTAND), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Uninstall >")); + Button_SetCheck(GetDlgItem(hWnd, IDS5UNDERSTAND), FALSE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } else if (iScene == 6) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Uninstalling...")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Uninstallation is now in progress.")); + ShowWindow(GetDlgItem(hWnd, IDS6GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDPROGRESS), TRUE); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } else if (iScene == 7) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Uninstallation Complete")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("The components have been completely removed from your computer.")); + ShowWindow(GetDlgItem(hWnd, IDS7GUIDETEXT), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Finish")); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + } else if (iScene == 8) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Repair VxKex")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Review the information below, and then click Repair")); + ShowWindow(GetDlgItem(hWnd, IDS8GUIDETEXT), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Repair")); + } else if (iScene == 9) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Repairing...")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Repair is now in progress.")); + ShowWindow(GetDlgItem(hWnd, IDS9GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDPROGRESS), TRUE); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } else if (iScene == 10) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Repair Complete")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("")); + ShowWindow(GetDlgItem(hWnd, IDS10GUIDETEXT), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Finish")); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + } else if (iScene == 11) { + HRSRC hChangeLog = FindResource(NULL, T("ChangeLog.txt"), (LPCWSTR) RCTEXT); + LPWSTR lpszChangeLog = (LPWSTR) LoadResource(NULL, hChangeLog); + lpszChangeLog[SizeofResource(NULL, hChangeLog)] = '\0'; + + SetDlgItemText(hWnd, IDHDRTEXT, T("Update VxKex")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Review the information below, and then click Update")); + ShowWindow(GetDlgItem(hWnd, IDS11GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS11GUIDETEXT2), TRUE); + ShowWindow(GetDlgItem(hWnd, IDS11CHANGELOG), TRUE); + SetDlgItemText(hWnd, IDS11CHANGELOG, lpszChangeLog); + SetDlgItemText(hWnd, IDNEXT, T("&Update")); + } else if (iScene == 12) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Updating...")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("Update is now in progress.")); + ShowWindow(GetDlgItem(hWnd, IDS12GUIDETEXT), TRUE); + ShowWindow(GetDlgItem(hWnd, IDPROGRESS), TRUE); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + EnableWindow(GetDlgItem(hWnd, IDNEXT), FALSE); + } else if (iScene == 13) { + SetDlgItemText(hWnd, IDHDRTEXT, T("Update Complete")); + SetDlgItemText(hWnd, IDHDRSUBTEXT, T("")); + ShowWindow(GetDlgItem(hWnd, IDS13GUIDETEXT), TRUE); + SetDlgItemText(hWnd, IDNEXT, T("&Finish")); + EnableWindow(GetDlgItem(hWnd, IDBACK), FALSE); + } +} + +VOID UpdateDiskFreeSpace( + IN HWND hWnd) +{ + TCHAR szInstallDir[MAX_PATH]; + TCHAR szVolumeMnt[MAX_PATH]; + TCHAR szFormattedSize[16]; + TCHAR szLabelStr[22 + ARRAYSIZE(szFormattedSize)] = T("Disk space available: "); + ULARGE_INTEGER uliFreeSpace; + + GetDlgItemText(hWnd, IDS2DIRPATH, szInstallDir, ARRAYSIZE(szInstallDir)); + GetVolumePathName(szInstallDir, szVolumeMnt, ARRAYSIZE(szVolumeMnt)); + + if (GetDiskFreeSpaceEx(szVolumeMnt, &uliFreeSpace, NULL, NULL)) { + if (StrFormatByteSize(uliFreeSpace.QuadPart, szFormattedSize, ARRAYSIZE(szFormattedSize))) { + strcat_s(szLabelStr, ARRAYSIZE(szLabelStr), szFormattedSize); + SetDlgItemText(hWnd, IDS2SPACEAVAIL, szLabelStr); + return; + } + } + + // dont display anything if the directory is invalid + SetDlgItemText(hWnd, IDS2SPACEAVAIL, T("")); +} + +BOOL TerminateProcessByImageName( + LPCTSTR lpszImageName) +{ + HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); + PROCESSENTRY32 psEntry; + + psEntry.dwSize = sizeof(psEntry); + + if (hSnapshot == INVALID_HANDLE_VALUE || !Process32First(hSnapshot, &psEntry)) { + goto ErrorReturn; + } + + do { + if (!lstrcmpi(psEntry.szExeFile, lpszImageName)) { + HANDLE hProc = OpenProcess(PROCESS_TERMINATE, 0, psEntry.th32ProcessID); + + if (!hProc) { + CloseHandle(hProc); + goto ErrorReturn; + } + + TerminateProcess(hProc, 0); + } + } while (Process32Next(hSnapshot, &psEntry)); + + CloseHandle(hSnapshot); + return TRUE; + +ErrorReturn: + CloseHandle(hSnapshot); + return FALSE; +} + +// VxKex must still be installed for this function to succeed. +// Namely, the "KexDir" registry entry must still exist. +VOID KexShlExDllInstall( + IN BOOL bInstall) +{ + TCHAR szKexShlEx[MAX_PATH]; + HMODULE hKexShlEx; + HRESULT (STDAPICALLTYPE *lpfnKexShlExDllInstall)(BOOL, LPCWSTR); + + RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexShlEx, ARRAYSIZE(szKexShlEx)); + strcat_s(szKexShlEx, ARRAYSIZE(szKexShlEx), T("\\KexShlEx.dll")); + hKexShlEx = LoadLibrary(szKexShlEx); + + if (hKexShlEx) { + lpfnKexShlExDllInstall = (HRESULT (STDAPICALLTYPE *)(BOOL, LPCWSTR)) GetProcAddress(hKexShlEx, "DllInstall"); + + if (lpfnKexShlExDllInstall) { + lpfnKexShlExDllInstall(bInstall, NULL); + } + + FreeLibrary(hKexShlEx); + } +} + +#define ADD_UNINSTALL_VALUE(func, value, data) func(HKEY_LOCAL_MACHINE, T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\VxKex"), value, data) +#define ADD_DLL_REWRITE_ENTRY(original, rewrite) RegWriteSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr\\DllRewrite"), original, rewrite) + +BOOL KexInstall( + IN HWND hWnd OPTIONAL, + IN LPTSTR lpszInstallDir) +{ + PathRemoveBackslash(lpszInstallDir); + + // populate the base entries under HKLM\\SOFTWARE\\VXsoft\\VxKexLdr + RegWriteSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), lpszInstallDir); + RegWriteDw(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("InstalledVersion"), g_dwInstallerVersion); + + // create uninstall entries so control panel can uninstall + { + TCHAR szFormattedDate[9]; // YYYYMMDD\0 + TCHAR szUninstallString[MAX_PATH + 10]; + TCHAR szModifyString[MAX_PATH]; + GetDateFormat(LOCALE_INVARIANT, 0, NULL, T("yyyyMMdd"), szFormattedDate, ARRAYSIZE(szFormattedDate)); + sprintf_s(szUninstallString, ARRAYSIZE(szUninstallString), T("%s\\KexSetup.exe /UNINSTALL"), lpszInstallDir); + sprintf_s(szModifyString, ARRAYSIZE(szModifyString), T("%s\\KexSetup.exe"), lpszInstallDir); + + ADD_UNINSTALL_VALUE(RegWriteSz, T("DisplayName"), T("VX Kernel Extension for Windows 7")); + ADD_UNINSTALL_VALUE(RegWriteSz, T("DisplayVersion"), g_lpszInstallerVersion); + ADD_UNINSTALL_VALUE(RegWriteSz, T("Publisher"), T("VXsoft")); + ADD_UNINSTALL_VALUE(RegWriteSz, T("InstallDate"), szFormattedDate); + ADD_UNINSTALL_VALUE(RegWriteSz, T("InstallLocation"), lpszInstallDir); + ADD_UNINSTALL_VALUE(RegWriteSz, T("HelpLink"), T("https://github.com/vxiiduu/VxKex")); + ADD_UNINSTALL_VALUE(RegWriteSz, T("UninstallString"), szUninstallString); + ADD_UNINSTALL_VALUE(RegWriteSz, T("ModifyPath"), szModifyString); + ADD_UNINSTALL_VALUE(RegWriteSz, T("Size"), T("")); + ADD_UNINSTALL_VALUE(RegWriteDw, T("EstimatedSize"), g_dwDiskSpaceRequired / 1024); + ADD_UNINSTALL_VALUE(RegWriteDw, T("NoRepair"), 1); + } + + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-com-l1-1-0.dll"), T("ole33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-com-l1-1-1.dll"), T("ole33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-rtlsupport-l1-2-0.dll"), T("ntdll.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-psapi-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-sidebyside-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-console-l2-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-datetime-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-errorhandling-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-fibers-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-file-l1-2-2.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-file-l2-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-heap-obsolete-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-heap-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-heap-l2-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-io-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-kernel32-legacy-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-kernel32-legacy-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-largeinteger-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-libraryloader-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-libraryloader-l1-2-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-localization-l1-2-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-localization-obsolete-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-processthreads-l1-1-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-processthreads-l1-1-2.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-processthreads-l1-1-3.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-processtopology-obsolete-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-downlevel-kernel32-l2-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-synch-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-synch-l1-2-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-sysinfo-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-sysinfo-l1-2-1.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-systemtopology-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-threadpool-legacy-l1-1-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-threadpool-l1-2-0.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-versionansi-l1-1-0.dll"), T("version.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-version-l1-1-0.dll"), T("version.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-winrt-error-l1-1-0.dll"), T("combase.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-winrt-error-l1-1-1.dll"), T("combase.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-winrt-l1-1-0.dll"), T("combase.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-winrt-string-l1-1-0.dll"), T("combase.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-registry-l1-1-0.dll"), T("advapi32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-core-registry-l2-1-0.dll"), T("advapi32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-eventing-classicprovider-l1-1-0.dll"), T("advapi32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-eventing-provider-l1-1-0.dll"), T("advapi32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-security-systemfunctions-l1-1-0.dll"), T("advapi32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-mm-time-l1-1-0.dll"), T("winmm.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-ntuser-sysparams-l1-1-0.dll"), T("user33.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-shell-namespace-l1-1-0.dll"), T("shell32.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-shcore-obsolete-l1-1-0.dll"), T("shcore.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-shcore-scaling-l1-1-0.dll"), T("shcore.dll")); + ADD_DLL_REWRITE_ENTRY(T("api-ms-win-shcore-scaling-l1-1-1.dll"), T("shcore.dll")); + ADD_DLL_REWRITE_ENTRY(T("ext-ms-win-uiacore-l1-1-0.dll"), T("uiautomationcore.dll")); + ADD_DLL_REWRITE_ENTRY(T("ext-ms-win-uiacore-l1-1-1.dll"), T("uiautomationcore.dll")); + ADD_DLL_REWRITE_ENTRY(T("dxgi.dll"), T("dxg1.dll")); + ADD_DLL_REWRITE_ENTRY(T("kernel32.dll"), T("kernel33.dll")); + ADD_DLL_REWRITE_ENTRY(T("ole32.dll"), T("ole33.dll")); + ADD_DLL_REWRITE_ENTRY(T("user32.dll"), T("user33.dll")); + ADD_DLL_REWRITE_ENTRY(T("xinput1_4.dll"), T("xinput1_3.dll")); + + // create KexDir and subdirectories if it doesn't exist, and copy self-EXE to it + { + TCHAR szSelfPath[MAX_PATH]; + TCHAR szDestPath[MAX_PATH]; + TCHAR szKex3264[MAX_PATH]; + CreateDirectory(lpszInstallDir, NULL); + sprintf_s(szKex3264, ARRAYSIZE(szKex3264), T("%s\\Kex32"), lpszInstallDir); + CreateDirectory(szKex3264, NULL); +#ifdef _WIN64 + sprintf_s(szKex3264, ARRAYSIZE(szKex3264), T("%s\\Kex64"), lpszInstallDir); + CreateDirectory(szKex3264, NULL); +#endif + GetModuleFileName(NULL, szSelfPath, ARRAYSIZE(szSelfPath)); + sprintf_s(szDestPath, ARRAYSIZE(szDestPath), T("%s\\KEXSETUP.EXE"), lpszInstallDir); + CopyFile(szSelfPath, szDestPath, FALSE); + } + + // copy VxKex files into KexDir + if (EnumResourceNames(NULL, RT_RCDATA, KexEnumResources, (LPARAM) lpszInstallDir) == FALSE) { + CriticalErrorBoxF(T("Unable to enumerate resources: %s\nThe system may be in an inconsistent state. Correct the error before trying again (run the installer again and select Repair)."), + GetLastErrorAsString()); + } + + // register shell extension + KexShlExDllInstall(TRUE); + + return TRUE; +} + +BOOL KexUninstall( + IN HWND hWnd OPTIONAL, + IN BOOL bPreserveSettings) +{ + TCHAR szKexDir[MAX_PATH]; + + if (!RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexDir, ARRAYSIZE(szKexDir))) { + return FALSE; + } + + // delete user settings if we need to do that + if (!bPreserveSettings) { + HKEY hKeyIfeo; + TCHAR szRegKey[MAX_PATH]; + TCHAR szVxKexLdr[MAX_PATH]; + DWORD dwIdx = 0; + + sprintf_s(szVxKexLdr, ARRAYSIZE(szVxKexLdr), T("%s\\VxKexLdr.exe"), szKexDir); + RegOpenKey(HKEY_LOCAL_MACHINE, T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options"), &hKeyIfeo); + + while (RegEnumKey(hKeyIfeo, dwIdx++, szRegKey, ARRAYSIZE(szRegKey)) == ERROR_SUCCESS) { + TCHAR szRegData[MAX_PATH]; + + if (RegReadSz(hKeyIfeo, szRegKey, T("Debugger"), szRegData, ARRAYSIZE(szRegData))) { + if (!stricmp(szRegData, szVxKexLdr)) { + RegDelValue(hKeyIfeo, szRegKey, T("Debugger")); + } + } + } + + RegCloseKey(hKeyIfeo); + SHDeleteKey(HKEY_CURRENT_USER, T("SOFTWARE\\VXsoft\\VxKexLdr")); + } + + // unregister property sheet shell extension and extended context menu entry + KexShlExDllInstall(FALSE); + + // delete KexDir\Kex32 and KexDir\Kex64 recursively as well as: + // KexDir\VxKexLdr.exe + // KexDir\KexCfg.exe + // KexDir\KexShlEx.dll + { + TCHAR szDeletionTarget[MAX_PATH + 1]; + SHFILEOPSTRUCTW shop; + + shop.hwnd = hWnd; + shop.wFunc = FO_DELETE; + shop.pFrom = szDeletionTarget; + shop.pTo = NULL; + shop.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR; + + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\Kex32"), szKexDir); + szDeletionTarget[strlen(szDeletionTarget) + 1] = T('\0'); + SHFileOperation(&shop); +#ifdef _WIN64 + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\Kex64"), szKexDir); + szDeletionTarget[strlen(szDeletionTarget) + 1] = T('\0'); + SHFileOperation(&shop); +#endif + + TerminateProcessByImageName(T("VxKexLdr.exe")); + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\VxKexLdr.exe"), szKexDir); + DeleteFile(szDeletionTarget); + TerminateProcessByImageName(T("KexCfg.exe")); + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\KexCfg.exe"), szKexDir); + DeleteFile(szDeletionTarget); + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\KexShlEx.dll"), szKexDir); + + if (!DeleteFile(szDeletionTarget)) { + // It may be loaded by explorer.exe so we have to kill and restart Explorer. + STARTUPINFO startupInfo; + PROCESS_INFORMATION procInfo; + TCHAR szExplorer[MAX_PATH]; + + if (TerminateProcessByImageName(T("explorer.exe"))) { + Sleep(500); + DeleteFile(szDeletionTarget); // and hopefully it works now + GetStartupInfo(&startupInfo); + ExpandEnvironmentStrings(T("%WINDIR\\explorer.exe"), szExplorer, ARRAYSIZE(szExplorer)); + CreateProcess(szExplorer, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &procInfo); + } + } + + sprintf_s(szDeletionTarget, ARRAYSIZE(szDeletionTarget), T("%s\\KexSetup.exe"), szKexDir); + + if (!DeleteFile(szDeletionTarget)) { + // If we are executing from the KexSetup.exe in KexDir, we can't just delete that. + // So we just schedule it to be removed when the system reboots. + MoveFileEx(szDeletionTarget, NULL, MOVEFILE_DELAY_UNTIL_REBOOT); + } + + // also delete KexDir if empty, following the same treatment as above + if (!RemoveDirectory(szKexDir)) { + MoveFileEx(szKexDir, NULL, MOVEFILE_DELAY_UNTIL_REBOOT); + } + } + + // Do this as the penultimate step since the absence of this key will prevent future uninstall attempts. + SHDeleteKey(HKEY_LOCAL_MACHINE, T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\VxKex")); + SHDeleteKey(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr")); + + // TODO: Remove uninstallation entry. + + return TRUE; +} + +DWORD WINAPI InstallThreadProc( + IN LPVOID lpParam) +{ + TCHAR szInstallDir[MAX_PATH]; + HWND hWnd = (HWND) lpParam; + GetDlgItemText(hWnd, IDS2DIRPATH, szInstallDir, ARRAYSIZE(szInstallDir)); + KexInstall(hWnd, szInstallDir); + SetScene(hWnd, 4); + CloseHandle(g_hWorkThread); + g_hWorkThread = NULL; + ExitThread(0); +} + +DWORD WINAPI UninstallThreadProc( + IN LPVOID lpParam) +{ + HWND hWnd = (HWND) lpParam; + KexUninstall(hWnd, FALSE); + SetScene(hWnd, 7); + CloseHandle(g_hWorkThread); + g_hWorkThread = NULL; + ExitThread(0); +} + +DWORD WINAPI RepairThreadProc( + IN LPVOID lpParam) +{ + TCHAR szKexDir[MAX_PATH]; + HWND hWnd = (HWND) lpParam; + RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexDir, ARRAYSIZE(szKexDir)); + KexUninstall(hWnd, TRUE); + KexInstall(hWnd, szKexDir); + SetScene(hWnd, 10); + CloseHandle(g_hWorkThread); + g_hWorkThread = NULL; + ExitThread(0); +} + +DWORD WINAPI UpdateThreadProc( + IN LPVOID lpParam) +{ + TCHAR szKexDir[MAX_PATH]; + HWND hWnd = (HWND) lpParam; + RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexDir, ARRAYSIZE(szKexDir)); + KexUninstall(hWnd, TRUE); + KexInstall(hWnd, szKexDir); + SetScene(hWnd, 13); + CloseHandle(g_hWorkThread); + g_hWorkThread = NULL; + ExitThread(0); +} + +// +// Dialog functions +// + +INT_PTR CALLBACK DlgProc( + IN HWND hWnd, + IN UINT uMsg, + IN WPARAM wParam, + IN LPARAM lParam) +{ + if (uMsg == WM_INITDIALOG) { + if (!g_iScene) { + if (*g_szInstalledKexDir) { + SetScene(hWnd, 1); + } else { + SetScene(hWnd, 2); + } + } else { + SetScene(hWnd, g_iScene); + } + + return TRUE; + } else if (uMsg == WM_COMMAND) { + if (LOWORD(wParam) == IDCANCEL) { + if (g_hWorkThread) { + SuspendThread(g_hWorkThread); + + if (MessageBox(hWnd, T("Installation or removal is in progress. If you cancel now, the software may be left in an inconsistent state. Cancel anyway?"), + T("Confirm Cancellation"), MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2 | MB_APPLMODAL) == IDYES) { + EndDialog(hWnd, 0); + } else { + ResumeThread(g_hWorkThread); + } + } else if (g_iScene == 1 || g_iScene == 4 || g_iScene == 5 || g_iScene == 7) { + EndDialog(hWnd, 0); + } else { + if (MessageBox(hWnd, T("Are you sure you want to cancel Setup?"), T("Confirm Cancellation"), + MB_ICONINFORMATION | MB_YESNO | MB_DEFBUTTON2 | MB_APPLMODAL) == IDYES) { + EndDialog(hWnd, 0); + } + } + } else if (LOWORD(wParam) == IDBACK) { + switch (g_iScene) { + case 5: + case 8: + case 11: + SetScene(hWnd, 1); + } + } else if (LOWORD(wParam) == IDNEXT) { + switch (g_iScene) { + case 1: + // set scene based on radio button selection + if (IsDlgButtonChecked(hWnd, IDS1RBUNINST)) { + SetScene(hWnd, 5); + } else if (IsDlgButtonChecked(hWnd, IDS1RBREPAIR)) { + SetScene(hWnd, 8); + } else if (IsDlgButtonChecked(hWnd, IDS1RBUPDATE)) { + SetScene(hWnd, 11); + } + + break; + case 2: + SetScene(hWnd, 3); + g_hWorkThread = CreateThread(NULL, 0, InstallThreadProc, hWnd, 0, NULL); + break; + case 5: + SetScene(hWnd, 6); + g_hWorkThread = CreateThread(NULL, 0, UninstallThreadProc, hWnd, 0, NULL); + break; + case 8: + SetScene(hWnd, 9); + g_hWorkThread = CreateThread(NULL, 0, RepairThreadProc, hWnd, 0, NULL); + break; + case 11: + SetScene(hWnd, 12); + g_hWorkThread = CreateThread(NULL, 0, UpdateThreadProc, hWnd, 0, NULL); + break; + + case 4: // fallthrough + case 7: + case 10: + case 13: + EndDialog(hWnd, 0); + break; + } + } else if (LOWORD(wParam) == IDS2BROWSE) { + TCHAR szOldValue[MAX_PATH]; + GetDlgItemText(hWnd, IDS2DIRPATH, szOldValue, ARRAYSIZE(szOldValue)); + SetDlgItemText(hWnd, IDS2DIRPATH, PickFolder(hWnd, szOldValue)); + } else if (LOWORD(wParam) == IDS2DIRPATH) { + UpdateDiskFreeSpace(hWnd); + } else if (LOWORD(wParam) == IDS1RBUNINST || + LOWORD(wParam) == IDS1RBREPAIR || + LOWORD(wParam) == IDS1RBUPDATE) { + EnableWindow(GetDlgItem(hWnd, IDNEXT), IsDlgButtonChecked(hWnd, LOWORD(wParam))); + } else if (LOWORD(wParam) == IDS5UNDERSTAND) { + EnableWindow(GetDlgItem(hWnd, IDNEXT), IsDlgButtonChecked(hWnd, LOWORD(wParam))); + } + + return TRUE; + } else if (uMsg == WM_CTLCOLORSTATIC) { + return (INT_PTR) SetStaticCtlBk(hWnd, (HWND) lParam, (HDC) wParam); + } + + return FALSE; +} + +BOOL IsWow64( + VOID) +{ + BOOL bWow64; + BOOL (WINAPI *lpfnIsWow64Process) (HANDLE, LPBOOL) = + (BOOL (WINAPI *) (HANDLE, LPBOOL)) GetProcAddress(GetModuleHandle(T("kernel32.dll")), "IsWow64Process"); + + if (lpfnIsWow64Process) { + if (lpfnIsWow64Process(GetCurrentProcess(), &bWow64) && bWow64) { + return TRUE; + } + } + + return FALSE; +} + +INT APIENTRY tWinMain( + IN HINSTANCE hInstance, + IN HINSTANCE hPrevInstance, + IN LPTSTR lpszCmdLine, + IN INT iCmdShow) +{ + SetFriendlyAppName(FRIENDLYAPPNAME); + +#if !defined(_WIN64) && !defined(_DEBUG) + if (IsWow64()) { + CriticalErrorBoxF(T("Installing the 32-bit version of the software on a 64-bit system is not recommended. Please use the 64-bit installer instead.")); + } +#endif + + ElevateIfNotElevated(lpszCmdLine, iCmdShow); + + g_dwInstalledVersion = GetInstalledVersion(); + g_dwInstallerVersion = GetInstallerVersion(); + g_lpszInstalledVersion = GetInstalledVersionAsString(); + g_lpszInstallerVersion = GetInstallerVersionAsString(); + RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), g_szInstalledKexDir, ARRAYSIZE(g_szInstalledKexDir)); + + if (StrStrI(lpszCmdLine, T("/UNINSTALL"))) { + g_iScene = 5; + } + + InitCommonControls(); + DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DlgProc); + ExitProcess(0); +} \ No newline at end of file diff --git a/KexSetup/KexSetup.rc b/KexSetup/KexSetup.rc new file mode 100644 index 0000000000000000000000000000000000000000..9b94311c386507956045537faf42fdd42384654a GIT binary patch literal 15972 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 at + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {9B3D1588-BDBB-4F20-9362-B9508168A675} + Win32Proj + KexSetup + + + + Application + true + Unicode + + + Application + true + Unicode + + + Application + false + true + Unicode + + + Application + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;version.lib;KexComm.lib;%(AdditionalDependencies) + $(TargetDir) + + + $(SolutionDir);$(TargetDir) + _DEBUG;DBGREL=$(Configuration);_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + + + + + Level3 + Disabled + WIN32;_WIN64;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;version.lib;KexComm.lib;%(AdditionalDependencies) + $(TargetDir) + + + $(SolutionDir);$(TargetDir) + _DEBUG;DBGREL=$(Configuration);_WIN64;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;version.lib;KexComm.lib;%(AdditionalDependencies) + $(TargetDir) + + + $(SolutionDir);$(TargetDir) + DBGREL=$(Configuration);_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;_WIN64;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;version.lib;KexComm.lib;%(AdditionalDependencies) + $(TargetDir) + + + $(SolutionDir);$(TargetDir) + DBGREL=$(Configuration);_WIN64;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/KexSetup/KexSetup.vcxproj.filters b/KexSetup/KexSetup.vcxproj.filters new file mode 100644 index 0000000..c357a02 --- /dev/null +++ b/KexSetup/KexSetup.vcxproj.filters @@ -0,0 +1,32 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Header Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/KexSetup/KexSetup.vcxproj.user b/KexSetup/KexSetup.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/KexSetup/KexSetup.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/KexSetup/disc1.ico b/KexSetup/disc1.ico new file mode 100644 index 0000000000000000000000000000000000000000..632518d06f98732f7e623b81d07fc0107228091d GIT binary patch literal 9662 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 literal 0 HcmV?d00001 diff --git a/KexSetup/resource.h b/KexSetup/resource.h new file mode 100644 index 0000000..ccd06a3 --- /dev/null +++ b/KexSetup/resource.h @@ -0,0 +1,94 @@ +#define RCTEXT 256 + +#define IDSTATIC -1 +#define IDARROW -2 +#define IDD_DIALOG1 101 +#define DIALOG1_WIDTH 333 +#define DIALOG1_HEIGHT 222 +#define IDBACK 102 +#define IDNEXT 103 +#define IDHDRTEXT 104 +#define IDHDRSUBTEXT 105 +#define IDPROGRESS 106 + +#define IDS1GUIDETEXT 110 +#define IDS1RBUNINST 111 +#define IDS1RBREPAIR 112 +#define IDS1RBUPDATE 113 +#define IDS1CURRENTINFO 114 +#define IDS1INSTALLINFO 115 + +#define IDS2GUIDETEXT 120 +#define IDS2DIRPATH 121 +#define IDS2BROWSE 122 +#define IDS2SPACEREQ 123 +#define IDS2SPACEAVAIL 124 + +#define IDS3GUIDETEXT 130 + +#define IDS4GUIDETEXT 140 +#define IDS4KEXCFG 141 +#define IDS4OPENGUIDE 142 + +#define IDS5GUIDETEXT 150 +#define IDS5GUIDETEXT2 151 +#define IDS5UNDERSTAND 152 + +#define IDS6GUIDETEXT 160 + +#define IDS7GUIDETEXT 170 + +#define IDS8GUIDETEXT 180 + +#define IDS9GUIDETEXT 190 + +#define IDS10GUIDETEXT 200 + +#define IDS11GUIDETEXT 210 +#define IDS11GUIDETEXT2 211 +#define IDS11CHANGELOG 212 + +#define IDS12GUIDETEXT 220 + +#define IDS13GUIDETEXT 230 + +#define IDI_ICON1 501 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/KexShlEx/KexShlEx.cpp b/KexShlEx/KexShlEx.cpp new file mode 100644 index 0000000..93d265a --- /dev/null +++ b/KexShlEx/KexShlEx.cpp @@ -0,0 +1,664 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "resource.h" + +// {9AACA888-A5F5-4C01-852E-8A2005C1D45F} +DEFINE_GUID(CLSID_KexShlEx, 0x9aaca888, 0xa5f5, 0x4c01, 0x85, 0x2e, 0x8a, 0x20, 0x5, 0xc1, 0xd4, 0x5f); + +#define CLSID_STRING_KEXSHLEX T("{9AACA888-A5F5-4C01-852E-8A2005C1D45F}") +#define APPNAME T("KexShlEx") +#define FRIENDLYAPPNAME T("VxKex Configuration Properties") +#define REPORT_BUG_URL T("https://github.com/vxiiduu/VxKex/issues") +#define DLLAPI EXTERN_C DECLSPEC_EXPORT + +#ifdef _WIN64 +# define X64 TRUE +# define X86 FALSE +#else +# define X86 TRUE +# define X64 FALSE +#endif + +// +// GLOBAL VARIABLES +// + +UINT g_cRefDll = 0; +HINSTANCE g_hInst = NULL; + +// Misc function declarations + +UINT WINAPI CallbackProc( + IN HWND hWnd, + IN UINT uMsg, + IN OUT LPPROPSHEETPAGE lpPsp); + +INT_PTR DialogProc( + IN HWND hWnd, + IN UINT uMsg, + IN WPARAM wParam, + IN LPARAM lParam); + +// +// COM INTERFACES +// + +typedef interface CKexShlEx : public IShellExtInit, IShellPropSheetExt +{ +private: + INT m_cRef; + +public: + TCHAR m_szExe[MAX_PATH]; + + CKexShlEx() + { + ++g_cRefDll; + m_cRef = 1; + m_szExe[0] = '\0'; + } + + ~CKexShlEx() + { + --g_cRefDll; + } + + // IUnknown + STDMETHODIMP QueryInterface( + IN REFIID riid, + OUT PPVOID ppv) + { + if (IsEqualIID(riid, IID_IUnknown)) { + *ppv = this; + } else if (IsEqualIID(riid, IID_IShellExtInit)) { + *ppv = (LPSHELLEXTINIT) this; + } else if (IsEqualIID(riid, IID_IShellPropSheetExt)) { + *ppv = (LPSHELLPROPSHEETEXT) this; + } else { + *ppv = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; + } + + STDMETHODIMP_(ULONG) AddRef( + VOID) + { + return ++m_cRef; + } + + STDMETHODIMP_(ULONG) Release( + VOID) + { + if (--m_cRef == 0) { + delete this; + } + + return m_cRef; + } + + // IShellExtInit + STDMETHODIMP Initialize( + IN LPCITEMIDLIST lpidlFolder OPTIONAL, + IN LPDATAOBJECT lpDataObj, + IN HKEY hKeyProgID) + { + UINT uCount; // number of files that were selected + FORMATETC fmt; + STGMEDIUM med; + + if (lpDataObj == NULL) { + return E_INVALIDARG; + } + + // get filename of the .exe + fmt.cfFormat = CF_HDROP; + fmt.ptd = NULL; + fmt.dwAspect = DVASPECT_CONTENT; + fmt.lindex = -1; + fmt.tymed = TYMED_HGLOBAL; + + if (SUCCEEDED(lpDataObj->GetData(&fmt, &med))) { + HDROP hDrop = (HDROP) med.hGlobal; + uCount = DragQueryFile(hDrop, (UINT) -1, NULL, 0); + + // if the user selected more than one exe, don't display the property sheet + if (uCount != 1) { + ReleaseStgMedium(&med); + return E_NOTIMPL; + } + + DragQueryFile(hDrop, 0, m_szExe, ARRAYSIZE(m_szExe)); + ReleaseStgMedium(&med); + } else { + return E_FAIL; + } + + // full path of the .exe file is now stored in m_szExe + return S_OK; + } + + // IShellPropSheetExt + STDMETHODIMP AddPages( + IN LPFNADDPROPSHEETPAGE lpfnAddPage, + IN LPARAM lParam) + { + PROPSHEETPAGE psp; + HPROPSHEETPAGE hPsp; + + if (m_szExe[0] == '\0') { + return E_UNEXPECTED; + } + + ZeroMemory(&psp, sizeof(psp)); + psp.dwSize = sizeof(psp); + psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK; + psp.hInstance = g_hInst; + psp.pszTemplate = MAKEINTRESOURCE(IDD_DIALOG1); + psp.hIcon = NULL; + psp.pszTitle = T("VxKex"); + psp.pfnDlgProc = (DLGPROC) DialogProc; + psp.pcRefParent = &g_cRefDll; + psp.pfnCallback = CallbackProc; + psp.lParam = (LPARAM) this; + + hPsp = CreatePropertySheetPage(&psp); + + if (hPsp) { + if (lpfnAddPage(hPsp, lParam)) { + AddRef(); + return S_OK; + } else { + DestroyPropertySheetPage(hPsp); + return E_FAIL; + } + } else { + return E_OUTOFMEMORY; + } + } + + STDMETHODIMP ReplacePage( + IN UINT uPageID, + IN LPFNADDPROPSHEETPAGE lpfnReplaceWith, + IN LPARAM lParam) + { + return E_NOTIMPL; + } +} CKEXSHLEX, *PCKEXSHLEX, *LPCKEXSHLEX; + +typedef interface CClassFactory : public IClassFactory +{ +protected: + INT m_cRef; + +public: + CClassFactory() + { + ++g_cRefDll; + m_cRef = 1; + } + + ~CClassFactory() + { + --g_cRefDll; + } + + // IUnknown + STDMETHODIMP QueryInterface( + IN REFIID riid, + OUT PPVOID ppv) + { + if (IsEqualIID(riid, IID_IUnknown)) { + *ppv = this; + } else if (IsEqualIID(riid, IID_IClassFactory)) { + *ppv = (LPCLASSFACTORY) this; + } else { + *ppv = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; + } + + STDMETHODIMP_(ULONG) AddRef( + VOID) + { + return ++m_cRef; + } + + STDMETHODIMP_(ULONG) Release( + VOID) + { + if (--m_cRef == 0) { + delete this; + } + + return m_cRef; + } + + // IClassFactory + STDMETHODIMP CreateInstance( + IN LPUNKNOWN pUnk, + IN REFIID riid, + OUT PPVOID ppv) + { + HRESULT hr; + LPCKEXSHLEX lpKexShlEx; + + *ppv = NULL; + + if (pUnk) { + return CLASS_E_NOAGGREGATION; + } + + if ((lpKexShlEx = new CKexShlEx) == NULL) { + return E_OUTOFMEMORY; + } + + hr = lpKexShlEx->QueryInterface(riid, ppv); + lpKexShlEx->Release(); + return hr; + } + + STDMETHODIMP LockServer( + BOOL) + { + return E_NOTIMPL; + } +} CCLASSFACTORY, *PCCLASSFACTORY, *LPCCLASSFACTORY; + +// +// DIALOG FUNCTIONS +// + +HWND CreateToolTip( + IN HWND hDlg, + IN INT iToolID, + IN LPTSTR lpszText) +{ + TOOLINFO ToolInfo; + HWND hWndTool; + HWND hWndTip; + + if (!iToolID || !hDlg || !lpszText) { + return NULL; + } + + // Get the window of the tool. + hWndTool = GetDlgItem(hDlg, iToolID); + + // Create the tooltip. + hWndTip = CreateWindowEx( + 0, TOOLTIPS_CLASS, NULL, + WS_POPUP | TTS_ALWAYSTIP, + CW_USEDEFAULT, CW_USEDEFAULT, + CW_USEDEFAULT, CW_USEDEFAULT, + hDlg, NULL, + NULL, NULL); + + if (!hWndTool || !hWndTip) { + return NULL; + } + + // Associate the tooltip with the tool. + ZeroMemory(&ToolInfo, sizeof(ToolInfo)); + ToolInfo.cbSize = sizeof(ToolInfo); + ToolInfo.hwnd = hDlg; + ToolInfo.uFlags = TTF_IDISHWND | TTF_SUBCLASS; + ToolInfo.uId = (UINT_PTR) hWndTool; + ToolInfo.lpszText = lpszText; + SendMessage(hWndTip, TTM_ADDTOOL, 0, (LPARAM) &ToolInfo); + SendMessage(hWndTip, TTM_SETMAXTIPWIDTH, 0, (LPARAM) 300); + + return hWndTip; +} + +UINT WINAPI CallbackProc( + IN HWND hWnd, + IN UINT uMsg, + IN OUT LPPROPSHEETPAGE lpPsp) +{ + if (uMsg == PSPCB_RELEASE) { + } + + return TRUE; +} + +INT_PTR DialogProc( + IN HWND hWnd, + IN UINT uMsg, + IN WPARAM wParam, + IN LPARAM lParam) +{ + static BOOL bSettingsChanged = FALSE; + + if (uMsg == WM_INITDIALOG) { + DWORD dwEnableVxKex = FALSE; + TCHAR szWinVerSpoof[6]; + DWORD dwAlwaysShowDebug = FALSE; + DWORD dwDisableForChild = FALSE; + DWORD dwDisableAppSpecific = FALSE; + DWORD dwWaitForChild = FALSE; + TCHAR szVxKexLdrPath[MAX_PATH]; + TCHAR szIfeoDebugger[MAX_PATH]; + TCHAR szIfeoKey[74 + MAX_PATH] = T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\"); + TCHAR szKexIfeoKey[54 + MAX_PATH] = T("SOFTWARE\\VXsoft\\VxKexLdr\\Image File Execution Options\\"); + LPCTSTR lpszExePath = ((LPCKEXSHLEX) (((LPPROPSHEETPAGE) lParam)->lParam))->m_szExe; + TCHAR szExePath[MAX_PATH]; + TCHAR szExeName[MAX_PATH]; + CONST HWND hWndWinVer = GetDlgItem(hWnd, IDWINVERCOMBOBOX); + + // store the pointer to the name of the .EXE in the userdata of the dialog + // for convenience purposes. These casts are confusing and horrible, but + // it works so don't mess with it. :^) + strcpy_s(szExePath, ARRAYSIZE(szExePath), lpszExePath); + SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR) lpszExePath); + + // populate and set up the Windows version selector + ComboBox_AddString(hWndWinVer, T("Windows 8")); + ComboBox_AddString(hWndWinVer, T("Windows 8.1")); + ComboBox_AddString(hWndWinVer, T("Windows 10")); + ComboBox_AddString(hWndWinVer, T("Windows 11")); + ComboBox_SetItemData(hWndWinVer, 0, T("WIN8")); + ComboBox_SetItemData(hWndWinVer, 1, T("WIN81")); + ComboBox_SetItemData(hWndWinVer, 2, T("WIN10")); + ComboBox_SetItemData(hWndWinVer, 3, T("WIN11")); + ComboBox_SetCurSel(hWndWinVer, 2); // set default selection to Windows 10 + + strcat_s(szKexIfeoKey, ARRAYSIZE(szKexIfeoKey), szExePath); + strcpy_s(szExeName, ARRAYSIZE(szExeName), szExePath); + PathStripPath(szExeName); + strcat_s(szIfeoKey, ARRAYSIZE(szIfeoKey), szExeName); + CHECKED(RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szVxKexLdrPath, ARRAYSIZE(szVxKexLdrPath))); + strcat_s(szVxKexLdrPath, ARRAYSIZE(szVxKexLdrPath), T("\\VxKexLdr.exe")); + + if (RegReadSz(HKEY_LOCAL_MACHINE, szIfeoKey, T("Debugger"), szIfeoDebugger, ARRAYSIZE(szIfeoDebugger)) && + !lstrcmp(szIfeoDebugger, szVxKexLdrPath) && + RegReadDw(HKEY_CURRENT_USER, szKexIfeoKey, T("EnableVxKex"), &dwEnableVxKex) && dwEnableVxKex) { + CheckDlgButton(hWnd, IDUSEVXKEX, TRUE); + } + + if (RegReadSz(HKEY_CURRENT_USER, szKexIfeoKey, T("WinVerSpoof"), szWinVerSpoof, ARRAYSIZE(szWinVerSpoof))) { + if (lstrcmpi(szWinVerSpoof, T("NONE"))) { + CheckDlgButton(hWnd, IDSPOOFVERSIONCHECK, TRUE); + ComboBox_Enable(hWndWinVer, TRUE); + + if (!lstrcmpi(szWinVerSpoof, T("WIN8"))) { + ComboBox_SetCurSel(hWndWinVer, 0); + } else if (!lstrcmpi(szWinVerSpoof, T("WIN81"))) { + ComboBox_SetCurSel(hWndWinVer, 1); + } else if (!lstrcmpi(szWinVerSpoof, T("WIN10"))) { + ComboBox_SetCurSel(hWndWinVer, 2); + } else if (!lstrcmpi(szWinVerSpoof, T("WIN11"))) { + ComboBox_SetCurSel(hWndWinVer, 3); + } + } + } + + RegReadDw(HKEY_CURRENT_USER, szKexIfeoKey, T("AlwaysShowDebug"), &dwAlwaysShowDebug); + RegReadDw(HKEY_CURRENT_USER, szKexIfeoKey, T("DisableForChild"), &dwDisableForChild); + RegReadDw(HKEY_CURRENT_USER, szKexIfeoKey, T("DisableAppSpecific"), &dwDisableAppSpecific); + RegReadDw(HKEY_CURRENT_USER, szKexIfeoKey, T("WaitForChild"), &dwWaitForChild); + + CheckDlgButton(hWnd, IDALWAYSSHOWDEBUG, dwAlwaysShowDebug); + CheckDlgButton(hWnd, IDDISABLEFORCHILD, dwDisableForChild); + CheckDlgButton(hWnd, IDDISABLEAPPSPECIFIC, dwDisableAppSpecific); + CheckDlgButton(hWnd, IDWAITONCHILD, dwWaitForChild); + + PathRemoveFileSpec(szVxKexLdrPath); + + if (PathIsPrefix(szVxKexLdrPath, szExePath)) { + // Discourage the user from enabling VxKex for VxKex executables, since they certainly + // don't need it and it could cause major problems (especially for VxKexLdr.exe itself) + EnableWindow(GetDlgItem(hWnd, IDUSEVXKEX), FALSE); + EnableWindow(GetDlgItem(hWnd, IDSPOOFVERSIONCHECK), FALSE); + EnableWindow(hWndWinVer, FALSE); + EnableWindow(GetDlgItem(hWnd, IDALWAYSSHOWDEBUG), FALSE); + EnableWindow(GetDlgItem(hWnd, IDDISABLEFORCHILD), FALSE); + EnableWindow(GetDlgItem(hWnd, IDDISABLEAPPSPECIFIC), FALSE); + EnableWindow(GetDlgItem(hWnd, IDWAITONCHILD), FALSE); + } + + CreateToolTip(hWnd, IDUSEVXKEX, T("Enable or disable the main VxKex compatibility layer.")); + CreateToolTip(hWnd, IDSPOOFVERSIONCHECK, T("Some applications check the Windows version and refuse to run if it is incorrect. ") + T("This option can help these applications to run correctly.")); + CreateToolTip(hWnd, IDALWAYSSHOWDEBUG, T("Creates a console window and displays some additional ") + T("information which may be useful for troubleshooting.")); + CreateToolTip(hWnd, IDDISABLEFORCHILD, T("By default, if this program launches another program, VxKex will be enabled ") + T("for the second program and all subsequent programs which are launched. This option ") + T("disables such behavior.")); + CreateToolTip(hWnd, IDDISABLEAPPSPECIFIC, T("Disable application-specific code. This is mainly useful for VxKex developers. ") + T("Usually, enabling this option will degrade application compatibility.")); + CreateToolTip(hWnd, IDWAITONCHILD, T("Wait for the child process to exit before exiting the loader. This is useful in combination ") + T("with the 'Always show debugging information' option which lets you view debug strings. It ") + T("may also be useful to support programs that wait for child processes to exit.")); + CreateToolTip(hWnd, IDREPORTBUG, REPORT_BUG_URL); + + SetFocus(GetDlgItem(hWnd, IDUSEVXKEX)); + return TRUE; + } else if (uMsg == WM_COMMAND) { + if (LOWORD(wParam) == IDSPOOFVERSIONCHECK) { + EnableWindow(GetDlgItem(hWnd, IDWINVERCOMBOBOX), !!IsDlgButtonChecked(hWnd, IDSPOOFVERSIONCHECK)); + } + + // enable the "Apply" button if it's not already enabled + PropSheet_Changed(GetParent(hWnd), hWnd); + bSettingsChanged = TRUE; + + return TRUE; + } else if (uMsg == WM_NOTIFY && ((LPNMHDR) lParam)->code == PSN_APPLY && bSettingsChanged) { + // OK or Apply button was clicked and we need to apply new settings + + HWND hWndWinVer = GetDlgItem(hWnd, IDWINVERCOMBOBOX); + STARTUPINFO startupInfo; + PROCESS_INFORMATION procInfo; + LPCTSTR lpszExeFullPath = (LPCTSTR) GetWindowLongPtr(hWnd, GWLP_USERDATA); + TCHAR szKexCfgFullPath[MAX_PATH]; + TCHAR szKexCfgCmdLine[542]; + + CHECKED(RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexCfgFullPath, ARRAYSIZE(szKexCfgFullPath))); + strcat_s(szKexCfgFullPath, MAX_PATH, T("\\KexCfg.exe")); + + sprintf_s(szKexCfgCmdLine, ARRAYSIZE(szKexCfgCmdLine), T("\"%s\" \"%s\" %d \"%s\" %d %d %d %d"), + szKexCfgFullPath, lpszExeFullPath, + !!IsDlgButtonChecked(hWnd, IDUSEVXKEX), + !!IsDlgButtonChecked(hWnd, IDSPOOFVERSIONCHECK) ? (LPCTSTR) ComboBox_GetItemData(hWndWinVer, ComboBox_GetCurSel(hWndWinVer)) + : T("NONE"), + !!IsDlgButtonChecked(hWnd, IDALWAYSSHOWDEBUG), + !!IsDlgButtonChecked(hWnd, IDDISABLEFORCHILD), + !!IsDlgButtonChecked(hWnd, IDDISABLEAPPSPECIFIC), + !!IsDlgButtonChecked(hWnd, IDWAITONCHILD)); + GetStartupInfo(&startupInfo); + + if (CreateProcess(szKexCfgFullPath, szKexCfgCmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &procInfo) == FALSE) { + ErrorBoxF(T("Failed to start KexCfg helper process. Error code: %#010I32x: %s"), + GetLastError(), GetLastErrorAsString()); + goto Error; + } + + CloseHandle(procInfo.hThread); + CloseHandle(procInfo.hProcess); + + bSettingsChanged = FALSE; + return TRUE; + } else if ((uMsg == WM_NOTIFY && ((LPNMHDR) lParam)->code == NM_CLICK || + uMsg == WM_NOTIFY && ((LPNMHDR) lParam)->code == NM_RETURN) && + wParam == IDREPORTBUG) { + // user wants to report a bug on the github + ShellExecute(hWnd, T("open"), REPORT_BUG_URL, NULL, NULL, SW_NORMAL); + + return TRUE; + } + +Error: + return FALSE; +} + +// +// DLL EXPORTED FUNCTIONS +// + +DLLAPI BOOL WINAPI DllMain( + IN HINSTANCE hInstance, + IN DWORD dwReason, + IN LPVOID lpReserved) +{ + if (dwReason == DLL_PROCESS_ATTACH) { + g_hInst = hInstance; + DisableThreadLibraryCalls(hInstance); + SetFriendlyAppName(FRIENDLYAPPNAME); + } + + return TRUE; +} + +STDAPI DllCanUnloadNow( + VOID) +{ + return ((g_cRefDll == 0) ? S_OK : S_FALSE); +} + +STDAPI DllGetClassObject( + IN REFCLSID rclsid, + IN REFIID riid, + OUT PPVOID ppv) +{ + *ppv = NULL; + + if (IsEqualIID(rclsid, CLSID_KexShlEx)) { + HRESULT hr; + LPCCLASSFACTORY lpCClassFactory = new CClassFactory; + + if (lpCClassFactory == NULL) { + return E_OUTOFMEMORY; + } + + hr = lpCClassFactory->QueryInterface(riid, ppv); + lpCClassFactory->Release(); + return hr; + } + + return CLASS_E_CLASSNOTAVAILABLE; +} + +// NEVER REMOVE THE DELETION OF ANY REGISTRY ENTRIES HERE! Even if a newer version +// of the software stops creating a particular registry key, it may still be left over +// from a previous version. +STDAPI DllUnregisterServer( + VOID) +{ + SHDeleteKey(HKEY_CLASSES_ROOT, T("CLSID\\") CLSID_STRING_KEXSHLEX); + + if (X64) { + SHDeleteKey(HKEY_CLASSES_ROOT, T("Wow6432Node\\CLSID\\") CLSID_STRING_KEXSHLEX); + } + + return S_OK; +} + +// IF YOU ADD A REGISTRY ENTRY HERE, YOU MUST ALSO UPDATE DllUnregisterServer TO +// REMOVE THAT REGISTRY ENTRY! YOU MUST ALSO UPDATE THE FOLLOWING TREE DIAGRAM: +// +// HKEY_CLASSES_ROOT +// CLSID +// {9AACA888-A5F5-4C01-852E-8A2005C1D45F} (*) +// InProcServer32 +// (Default) = REG_SZ "\KexShlEx.dll" +// ThreadingModel = REG_SZ "Apartment" +// +// A (*) next to a key indicates that this key is "owned" by VxKexLdr and may be +// safely deleted, along with all its subkeys, when the program is uninstalled. +// +// The above tree diagram must also be replicated into the Wow6432Node (but only +// if running on a 64-bits system). For 32-bits, the name of KexShlEx.dll changes +// to KexShl32.dll. +// +// The value of can be found from the registry key +// HKEY_LOCAL_MACHINE\Software\VXsoft\VxKexLdr\KexDir (REG_SZ). This registry key is +// created by the VxKexLdr installer, and its absence indicates an incorrect usage of +// the DllRegisterServer function. +STDAPI DllRegisterServer( + VOID) +{ + BOOL bSuccess; + TCHAR szKexShlExDll32[MAX_PATH]; + TCHAR szKexShlExDll64[MAX_PATH]; + LPCTSTR szKexShlExDllNative = NULL; + + if (X64) { + szKexShlExDllNative = szKexShlExDll64; + } else if (X86) { + szKexShlExDllNative = szKexShlExDll32; + } + + bSuccess = RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexShlExDll32, ARRAYSIZE(szKexShlExDll32)); + if (bSuccess == FALSE) return E_UNEXPECTED; + + strcpy_s(szKexShlExDll64, MAX_PATH, szKexShlExDll32); + strcat_s(szKexShlExDll32, MAX_PATH, T("\\KexShl32.dll")); + strcat_s(szKexShlExDll64, MAX_PATH, T("\\KexShlEx.dll")); + + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("CLSID\\") CLSID_STRING_KEXSHLEX T("\\InProcServer32"), NULL, szKexShlExDllNative)); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("CLSID\\") CLSID_STRING_KEXSHLEX T("\\InProcServer32"), T("ThreadingModel"), T("Apartment"))); + + if (X64) { + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("Wow6432Node\\CLSID\\") CLSID_STRING_KEXSHLEX T("\\InProcServer32"), NULL, szKexShlExDll32)); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("Wow6432Node\\CLSID\\") CLSID_STRING_KEXSHLEX T("\\InProcServer32"), T("ThreadingModel"), T("Apartment"))); + } + + return S_OK; + +Error: + DllUnregisterServer(); + return SELFREG_E_CLASS; +} + +// HKEY_CLASSES_ROOT +// exefile +// shellex +// PropertySheetHandlers +// KexShlEx Property Page (*) +// (Default) = REG_SZ "{9AACA888-A5F5-4C01-852E-8A2005C1D45F}" +STDAPI DllInstall( + IN BOOL bInstall, + IN LPCWSTR lpszCmdLine OPTIONAL) +{ + if (bInstall) { + TCHAR szVxKexLdr[MAX_PATH]; + TCHAR szOpenVxKexCommand[MAX_PATH + 17]; + + CHECKED(DllRegisterServer() == S_OK); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("exefile\\shellex\\PropertySheetHandlers\\KexShlEx Property Page"), NULL, CLSID_STRING_KEXSHLEX)); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("exefile\\shell\\open_vxkex"), NULL, T("Run with VxKex enabled"))); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("exefile\\shell\\open_vxkex"), T("Extended"), T(""))); + CHECKED(RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szVxKexLdr, ARRAYSIZE(szVxKexLdr))); + CHECKED(!strcat_s(szVxKexLdr, ARRAYSIZE(szVxKexLdr), T("\\VxKexLdr.exe"))); + CHECKED(sprintf_s(szOpenVxKexCommand, ARRAYSIZE(szOpenVxKexCommand), T("\"%s\" /FORCE \"%%1\" \"%%*\""), szVxKexLdr) != -1); + CHECKED(RegWriteSz(HKEY_CLASSES_ROOT, T("exefile\\shell\\open_vxkex\\command"), NULL, szOpenVxKexCommand)); + } else { + // Important note: You cannot "goto Error" from this section, so no CHECKED(x) + // is permitted here. Otherwise it will cause recursion in the case of an error. + + // We use SHDeleteKeyA in preference to RegDeleteTree because it basically does + // the same thing but is available since Win2k (instead of only since Vista) + SHDeleteKey(HKEY_CLASSES_ROOT, T("exefile\\shellex\\PropertySheetHandlers\\KexShlEx Property Page")); + SHDeleteKey(HKEY_CLASSES_ROOT, T("exefile\\shell\\open_vxkex")); + DllUnregisterServer(); + } + + return S_OK; + +Error: + DllInstall(FALSE, NULL); + return E_FAIL; +} \ No newline at end of file diff --git a/KexShlEx/KexShlEx.def b/KexShlEx/KexShlEx.def new file mode 100644 index 0000000..0991182 --- /dev/null +++ b/KexShlEx/KexShlEx.def @@ -0,0 +1,6 @@ +EXPORTS + DllCanUnloadNow PRIVATE + DllGetClassObject PRIVATE + DllRegisterServer PRIVATE + DllUnregisterServer PRIVATE + DllInstall PRIVATE \ No newline at end of file diff --git a/KexShlEx/KexShlEx.rc b/KexShlEx/KexShlEx.rc new file mode 100644 index 0000000000000000000000000000000000000000..c1fbb2c5bd245318dc15b7f03858059f0b72f4bb GIT binary patch literal 3808 zcmbuCYfl?T6o$`ND)m3Cwh~|3a3={7iUeLlP#tW6xqU(yjAMm>YnuRS``6n(@0lHT z7ZylVt-L$ToH_H(d#?QZ&o4HxOFOj-yS6jySz@bp;B#koWj8jq8T)MS?PvSR>SWtC zvRx!5&&s7p_0V<2DI-qnxpeAUrFoun_ie*=(6wbP+vdG(9~fzMiqV!eS+B|@HfO(; zepT5Px};U#W3+W1=<3*!wb3b=53C+r#u-hQT4#RKF$A6K%(tvzzayQZZ^A9aTc4c+ zxa%Q%Y3JN8MdHu=q$#WJo3ka*uJBu8W$uCO6gbv6XU{REoOWejd3tD`z+K8+r|zHB zIiJ{&m3KDF(+A0f*=y^_(%a9(U zPd6TN!T`;eB{V7f4!O0oj#%lzN5UO$krnoFz9WIR&%Ro}{xXt%KOyQX^O3^lOzHQu zF4;-Ag!BZY+q}hbRa;<4crW}WPwQ(rFXBGvi>&Fds@@caHehPkKEl05Gr7kV+W*e2 z5x#Z4w~yY@3tm^XV+Z*Yx5EYBvi%f4xBP-v7Jtb%!`T7H1}tShquDLSnMcc(`)i9x zQT%4C$ba>>ZWp36zT3ohi+DS>PpoQx0~tl!CVri;@_79yUk_MziP0lxPG>2m#pDJv zP54mG=%D8>eh0qV08N{@kWYe+Lhh}fnu11IqU@O&Ht*+g@h}fG(Wkq0h?W%1=j;`? zdJlOn@PpG5%L&}~><=Pu;G?liChX{uTjhlb5vp(W>V)W$)@lwGLwBrP^ZkncJHB1^ z>D(@-YBXV8=UqD<<${E<^eRtjUD2m(7c)STXNh5sxQncAFme6zmOIBb;Q+n6gGTJ(^S74aO=X9qB?7Usa*^H_IaXy~Zq6({`8Kz7a} z-wPGy`#kYo34P$V4MQy=uv(i7&V;$R#j-{2>u%9N(+KQ=s`Sch<+XiQ8m=Su z70-G38aDZcZPbnR7%LML_4Z-?k9@rB<12nc$rnB@CSLZNHL}4Ci0<5n$9S_k!UW$} z#C6FoeV&+K^bMY`3{|c(Wvr?Y2k>ErE~7p<=6+ddgcVh}>#B0-*XwIsQHfPEB^kPEMWO1m)W|Av}qxU?_qF83_5 mTI|HsDJY|=mbQI9bPIKTLhShx`<4BnCf9d|&vz7|XZ;VT`v0c@ literal 0 HcmV?d00001 diff --git a/KexShlEx/KexShlEx.vcxproj b/KexShlEx/KexShlEx.vcxproj new file mode 100644 index 0000000..1816fc8 --- /dev/null +++ b/KexShlEx/KexShlEx.vcxproj @@ -0,0 +1,168 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {0C454599-73FB-4F57-B8C9-0BE68AF3110E} + Win32Proj + KexShlEx + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;KexComm.lib;ntdll_x86.lib;%(AdditionalDependencies) + KexShlEx.def + $(SolutionDir);$(TargetDir) + + + + + + + Level3 + Disabled + WIN32;_WIN64;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;KexComm.lib;ntdll_x64.lib;%(AdditionalDependencies) + KexShlEx.def + $(SolutionDir);$(TargetDir) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;KexComm.lib;ntdll_x86.lib;%(AdditionalDependencies) + KexShlEx.def + $(SolutionDir);$(TargetDir) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;_WIN64;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;comctl32.lib;shlwapi.lib;KexComm.lib;ntdll_x64.lib;%(AdditionalDependencies) + KexShlEx.def + $(SolutionDir);$(TargetDir) + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/KexShlEx/KexShlEx.vcxproj.filters b/KexShlEx/KexShlEx.vcxproj.filters new file mode 100644 index 0000000..3fa23ba --- /dev/null +++ b/KexShlEx/KexShlEx.vcxproj.filters @@ -0,0 +1,37 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Source Files + + + + + Resource Files + + + + + Header Files + + + \ No newline at end of file diff --git a/KexShlEx/KexShlEx.vcxproj.user b/KexShlEx/KexShlEx.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/KexShlEx/KexShlEx.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/KexShlEx/resource.h b/KexShlEx/resource.h new file mode 100644 index 0000000..5106d0b --- /dev/null +++ b/KexShlEx/resource.h @@ -0,0 +1,48 @@ +#include + +#define IDSTATIC -1 +#define IDD_DIALOG1 101 +#define IDUSEVXKEX 102 +#define IDDISABLEFORCHILD 103 +#define IDSPOOFVERSIONCHECK 104 +#define IDWINVERCOMBOBOX 105 +#define IDALWAYSSHOWDEBUG 106 +#define IDDISABLEAPPSPECIFIC 107 +#define IDREPORTBUG 108 +#define IDWAITONCHILD 109 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/NtDll.h b/NtDll.h new file mode 100644 index 0000000..2bd238a --- /dev/null +++ b/NtDll.h @@ -0,0 +1,528 @@ +#pragma once +#include +#include + +#define RTL_MAX_DRIVE_LETTERS 32 +#define PROCESSOR_FEATURE_MAX 64 +#define GDI_HANDLE_BUFFER_SIZE32 34 +#define GDI_HANDLE_BUFFER_SIZE64 60 + +#define PF_FLOATING_POINT_PRECISION_ERRATA 0 +#define PF_FLOATING_POINT_EMULATED 1 +#define PF_COMPARE_EXCHANGE_DOUBLE 2 +#define PF_MMX_INSTRUCTIONS_AVAILABLE 3 +#define PF_PPC_MOVEMEM_64BIT_OK 4 +#define PF_ALPHA_BYTE_INSTRUCTIONS 5 +#define PF_XMMI_INSTRUCTIONS_AVAILABLE 6 +#define PF_3DNOW_INSTRUCTIONS_AVAILABLE 7 +#define PF_RDTSC_INSTRUCTION_AVAILABLE 8 +#define PF_PAE_ENABLED 9 +#define PF_XMMI64_INSTRUCTIONS_AVAILABLE 10 +#define PF_SSE_DAZ_MODE_AVAILABLE 11 +#define PF_NX_ENABLED 12 +#define PF_SSE3_INSTRUCTIONS_AVAILABLE 13 +#define PF_COMPARE_EXCHANGE128 14 +#define PF_COMPARE64_EXCHANGE128 15 +#define PF_CHANNELS_ENABLED 16 +#define PF_XSAVE_ENABLED 17 + +#ifdef _M_X64 +# define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE64 +#else +# define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE32 +#endif + +// +// Data type definitions +// + +typedef ULONG GDI_HANDLE_BUFFER32[GDI_HANDLE_BUFFER_SIZE32]; +typedef ULONG GDI_HANDLE_BUFFER64[GDI_HANDLE_BUFFER_SIZE64]; +typedef ULONG GDI_HANDLE_BUFFER[GDI_HANDLE_BUFFER_SIZE]; + +typedef VOID (*PPS_POST_PROCESS_INIT_ROUTINE) (VOID); + +typedef enum _PROCESSINFOCLASS { + ProcessBasicInformation, + ProcessQuotaLimits, + ProcessIoCounters, + ProcessVmCounters, + ProcessTimes, + ProcessBasePriority, + ProcessRaisePriority, + ProcessDebugPort, + ProcessExceptionPort, + ProcessAccessToken, + ProcessLdtInformation, + ProcessLdtSize, + ProcessDefaultHardErrorMode, + ProcessIoPortHandlers, + ProcessPooledUsageAndLimits, + ProcessWorkingSetWatch, + ProcessUserModeIOPL, + ProcessEnableAlignmentFaultFixup, + ProcessPriorityClass, + ProcessWx86Information, + ProcessHandleCount, + ProcessAffinityMask, + ProcessPriorityBoost, + ProcessDeviceMap, + ProcessSessionInformation, + ProcessForegroundInformation, + ProcessWow64Information, + ProcessImageFileName, + ProcessLUIDDeviceMapsEnabled, + ProcessBreakOnTermination, + ProcessDebugObjectHandle, + ProcessDebugFlags, + ProcessHandleTracing +} PROCESSINFOCLASS; + +typedef enum _NT_PRODUCT_TYPE { + NtProductWinNt = 1, + NtProductLanManNt, + NtProductServer +} NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE; + +typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE { + StandardDesign, + NEC98x86 +} ALTERNATIVE_ARCHITECTURE_TYPE; + +typedef struct _STRING { + USHORT Length; + USHORT MaximumLength; + PCHAR Buffer; +} STRING, ANSI_STRING, *PSTRING, *PANSI_STRING; + +typedef struct _UNICODE_STRING { + USHORT Length; + USHORT MaximumLength; + PWCHAR Buffer; +} UNICODE_STRING, *PUNICODE_STRING; + +typedef struct _PEB_LDR_DATA { // 3.51+ + ULONG Length; + BOOLEAN Initialized; + PVOID SsHandle; + LIST_ENTRY InLoadOrderModuleList; + LIST_ENTRY InMemoryOrderModuleList; + LIST_ENTRY InInitializationOrderModuleList; + PVOID EntryInProgress; // this and the following 5.1+ + BOOLEAN ShutdownInProgress; // 6.0SP1+ + HANDLE ShutdownThreadId; +} PEB_LDR_DATA, *PPEB_LDR_DATA; + +typedef struct _CURDIR { + UNICODE_STRING DosPath; + HANDLE Handle; +} CURDIR, *PCURDIR; + +typedef struct _RTL_DRIVE_LETTER_CURDIR { + USHORT Flags; + USHORT Length; + ULONG TimeStamp; + STRING DosPath; +} RTL_DRIVE_LETTER_CURDIR, *PRTL_DRIVE_LETTER_CURDIR; + +typedef struct _PEB_FREE_BLOCK { + struct _PEB_FREE_BLOCK *Next; + ULONG Size; +} PEB_FREE_BLOCK, *PPEB_FREE_BLOCK; + +typedef struct _RTL_USER_PROCESS_PARAMETERS { + ULONG MaximumLength; + ULONG Length; + + ULONG Flags; + ULONG DebugFlags; + + HANDLE ConsoleHandle; + ULONG ConsoleFlags; + HANDLE StandardInput; + HANDLE StandardOutput; + HANDLE StandardError; + + CURDIR CurrentDirectory; + UNICODE_STRING DllPath; + UNICODE_STRING ImagePathName; + UNICODE_STRING CommandLine; + PVOID Environment; + + ULONG StartingX; + ULONG StartingY; + ULONG CountX; + ULONG CountY; + ULONG CountCharsX; + ULONG CountCharsY; + ULONG FillAttribute; + + ULONG WindowFlags; + ULONG ShowWindowFlags; + UNICODE_STRING WindowTitle; + UNICODE_STRING DesktopInfo; + UNICODE_STRING ShellInfo; + UNICODE_STRING RuntimeData; + RTL_DRIVE_LETTER_CURDIR CurrentDirectories[RTL_MAX_DRIVE_LETTERS]; +} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS; + +typedef struct _PEB { // 3.51+ + BOOLEAN InheritedAddressSpace; + BOOLEAN ReadImageFileExecOptions; + BOOLEAN BeingDebugged; + union { + BOOLEAN SpareBool; + UCHAR BitField; // this and the following struct 5.2+ + struct { + UCHAR ImageUsedLargePages : 1; + UCHAR IsProtectedProcess : 1; // this and the following bitfields 6.0+ + UCHAR IsLegacyProcess : 1; + UCHAR IsImageDynamicallyRelocated : 1; + UCHAR SkipPatchingUser32Forwarders : 1; + UCHAR SpareBits0 : 3; + }; + }; + + HANDLE Mutant; + PVOID ImageBaseAddress; + PPEB_LDR_DATA Ldr; + PRTL_USER_PROCESS_PARAMETERS ProcessParameters; + PVOID SubSystemData; + PVOID ProcessHeap; + PRTL_CRITICAL_SECTION FastPebLock; + + union { + PVOID FastPebLockRoutine; // 3.10-5.1 + PVOID SparePtr1; // 5.2 + PVOID AtlThunkSListPtr; // 5.2+ + }; + + union { + PVOID FastPebUnlockRoutine; // 3.10-5.1 + PVOID SparePtr2; // 5.2 + PVOID IFEOKey; // 5.2+ + }; + + union { + ULONG EnvironmentUpdateCount; // 3.50-5.2 + union { + ULONG CrossProcessFlags; // this and the following struct 6.0+ + struct { + ULONG ProcessInJob : 1; + ULONG ProcessInitializing : 1; + ULONG ProcessUsingVEH : 1; // this and the following bitfields 6.1+ + ULONG ProcessUsingVCH : 1; + ULONG ProcessUsingFTH : 1; + ULONG ReservedBits0 : 27; + }; + }; + }; + + union { + PVOID KernelCallbackTable; + PVOID UserSharedInfoPtr; // 6.0+ + }; + + ULONG SystemReserved[1]; + + union { + struct { // 5.1-5.2 + ULONG ExecuteOptions : 2; + ULONG SpareBits1 : 30; + }; + + ULONG SpareUlong; // 5.2-6.0 + ULONG AtlThunkSListPtr32; // 6.1+ + }; + + union { + PPEB_FREE_BLOCK FreeList; // 3.10-6.0 + ULONG SparePebPtr0; // 6.0 + PVOID ApiSetMap; // 6.1+ + }; + + ULONG TlsExpansionCounter; + PVOID TlsBitmap; + ULONG TlsBitmapBits[2]; + PVOID ReadOnlySharedMemoryBase; + + union { + PVOID ReadOnlySharedMemoryHeap; // 3.10-5.2 + PVOID HotpatchInformation; // 6.0-6.1 + }; + + PPVOID ReadOnlyStaticServerData; + PVOID AnsiCodePageData; + PVOID OemCodePageData; + PVOID UnicodeCaseTableData; + + ULONG NumberOfProcessors; + ULONG NtGlobalFlag; + + LARGE_INTEGER CriticalSectionTimeout; + SIZE_T HeapSegmentReserve; // this and all following members 3.51+ + SIZE_T HeapSegmentCommit; + SIZE_T HeapDeCommitTotalFreeThreshold; + SIZE_T HeapDeCommitFreeBlockThreshold; + + ULONG NumberOfHeaps; + ULONG MaximumNumberOfHeaps; + PPVOID ProcessHeaps; + + PVOID GdiSharedHandleTable; // this and all following members 4.0+ + PVOID ProcessStarterHelper; + ULONG GdiDCAttributeList; + PRTL_CRITICAL_SECTION LoaderLock; + + ULONG OSMajorVersion; + ULONG OSMinorVersion; + USHORT OSBuildNumber; + USHORT OSCSDVersion; + ULONG OSPlatformId; + ULONG ImageSubsystem; + ULONG ImageSubsystemMajorVersion; + ULONG ImageSubsystemMinorVersion; + ULONG_PTR ImageProcessAffinityMask; + GDI_HANDLE_BUFFER GdiHandleBuffer; + + PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine; // this and all following members 5.0+ + PVOID TlsExpansionBitmap; + ULONG TlsExpansionBitmapBits[32]; + ULONG SessionId; + + union { + struct { + PVOID AppCompatInfo; + UNICODE_STRING CSDVersion; + } nt50; + + struct { // 5.1+ + ULARGE_INTEGER AppCompatFlags; + ULARGE_INTEGER AppCompatFlagsUser; + PVOID pShimData; + + PVOID AppCompatInfo; + UNICODE_STRING CSDVersion; + } nt51; + } AppCompatUnion; + + PVOID ActivationContextData; // this and all following members 5.1+ + PVOID ProcessAssemblyStorageMap; + PVOID SystemDefaultActivationContextData; + PVOID SystemAssemblyStorageMap; + + SIZE_T MinimumStackCommit; + + PPVOID FlsCallback; // this and all following members 5.2+ + PVOID SparePointers[4]; + LIST_ENTRY FlsListHead; + PVOID FlsBitmap; + ULONG FlsBitmapBits[4]; + ULONG FlsHighIndex; + + PVOID WerRegistrationData; // this and all following members 6.0+ + PVOID WerShipAssetPtr; + + PVOID pContextData; // this and all following members 6.1+ + PVOID pImageHeaderHash; + + union { + ULONG TracingFlags; + struct { + ULONG HeapTracingEnabled : 1; + ULONG CritSecTracingEnabled : 1; + ULONG SpareTracingBits : 30; + }; + }; +} PEB, *PPEB; + +typedef struct _KSYSTEM_TIME { + ULONG LowPart; + LONG High1Time; + LONG High2Time; +} KSYSTEM_TIME, *PKSYSTEM_TIME; + +typedef struct _KUSER_SHARED_DATA { // 3.50+ + ULONG VOLATILE TickCountLow; + ULONG TickCountMultiplier; + KSYSTEM_TIME VOLATILE InterruptTime; + KSYSTEM_TIME VOLATILE SystemTime; + KSYSTEM_TIME VOLATILE TimeZoneBias; + + USHORT ImageNumberLow; // 3.51+ + USHORT ImageNumberHigh; + WCHAR NtSystemRoot[MAX_PATH]; + + union { // 4.0+ + ULONG DosDeviceMap; // 4.0 + ULONG MaxStackTraceDepth; // 5.0+ + }; + + ULONG CryptoExponent; + ULONG TimeZoneId; + + ULONG LargePageMinimum; // 5.2+ + ULONG Reserved2[7]; + + NT_PRODUCT_TYPE NtProductType; // 4.0+ + BOOLEAN ProductTypeIsValid; + + ULONG NtMajorVersion; + ULONG NtMinorVersion; + + BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX]; // search for PF_ + + ULONG Reserved1; + ULONG Reserved3; + + ULONG VOLATILE TimeSlip; + ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture; + LARGE_INTEGER SystemExpirationDate; + ULONG SuiteMask; + BOOLEAN KdDebuggerEnabled; + ULONG VOLATILE ActiveConsoleId; + ULONG VOLATILE DismountCount; + ULONG ComPlusPackage; + ULONG LastSystemRITEventTickCount; + ULONG NumberOfPhysicalPages; + BOOLEAN SafeBootMode; + ULONG TraceLogging; + ULONGLONG Fill0; + ULONGLONG SystemCall[4]; + + union { + KSYSTEM_TIME VOLATILE TickCount; + ULONG64 VOLATILE TickCountQuad; + }; +} KUSER_SHARED_DATA, *PKUSER_SHARED_DATA; + +STATIC CONST PKUSER_SHARED_DATA SharedUserData = (PKUSER_SHARED_DATA) 0x7FFE0000; + +FORCEINLINE PPEB NtCurrentPeb( + VOID) +{ +#ifdef _M_X64 + return (PPEB) __readgsqword(0x60); +#else + return (PPEB) __readfsdword(0x30); +#endif +} + +// ntpsapi.h +typedef struct _PROCESS_BASIC_INFORMATION { + NTSTATUS ExitStatus; + PPEB PebBaseAddress; + ULONG_PTR AffinityMask; + KPRIORITY BasePriority; + ULONG_PTR UniqueProcessId; + ULONG_PTR InheritedFromUniqueProcessId; +} PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION; + +// +// NTDLL function declarations +// + +NTSYSAPI NTSTATUS NTAPI NtQueryInformationProcess( + IN HANDLE ProcessHandle, + IN PROCESSINFOCLASS ProcessInformationClass, + OUT PVOID ProcessInformation, + IN ULONG ProcessInformationLength, + OUT PULONG ReturnLength OPTIONAL); + +NTSYSAPI VOID NTAPI RtlInitUnicodeString( + OUT PUNICODE_STRING DestinationString, + IN PCWSTR SourceString OPTIONAL); + +// +// Miscellaneous macros and inline functions +// + +#define GetProcessHeap() (NtCurrentPeb()->ProcessHeap) + +// doubly linked list functions + +#ifndef __INTELLISENSE__ +# define ForEachListEntry(pListHead, pListEntry) for (((PLIST_ENTRY) (pListEntry)) = (pListHead)->Flink; ((PLIST_ENTRY) (pListEntry)) != (pListHead); ((PLIST_ENTRY) (pListEntry)) = ((PLIST_ENTRY) (pListEntry))->Flink) +#else +# define ForEachListEntry(pListHead, pListEntry) +#endif + +FORCEINLINE VOID InitializeListHead( + OUT PLIST_ENTRY ListHead) +{ + ListHead->Flink = ListHead; + ListHead->Blink = ListHead; +} + +FORCEINLINE BOOL IsListEmpty( + IN PLIST_ENTRY ListHead) +{ + return ListHead->Flink == ListHead; +} + +FORCEINLINE VOID RemoveEntryList( + OUT PLIST_ENTRY Entry) +{ + PLIST_ENTRY Blink = Entry->Blink; + PLIST_ENTRY Flink = Entry->Flink; + Blink->Flink = Flink; + Flink->Blink = Blink; +} + +FORCEINLINE PLIST_ENTRY RemoveHeadList( + OUT PLIST_ENTRY ListHead) +{ + PLIST_ENTRY Ret = ListHead->Flink; + RemoveEntryList(ListHead->Flink); + return Ret; +} + +FORCEINLINE PLIST_ENTRY RemoveTailList( + OUT PLIST_ENTRY ListHead) +{ + PLIST_ENTRY Blink = ListHead->Blink; + RemoveEntryList(ListHead->Blink); + return Blink; +} + +FORCEINLINE VOID InsertTailList( + OUT PLIST_ENTRY ListHead, + IN PLIST_ENTRY Entry) +{ + Entry->Flink = ListHead; + Entry->Blink = ListHead->Blink; + ListHead->Blink->Flink = Entry; + ListHead->Blink = Entry; +} + +FORCEINLINE VOID InsertHeadList( + OUT PLIST_ENTRY ListHead, + IN PLIST_ENTRY Entry) +{ + Entry->Flink = ListHead->Flink; + Entry->Blink = ListHead; + ListHead->Flink->Blink = Entry; + ListHead->Flink = Entry; +} + +// singly linked list functions + +FORCEINLINE VOID PushEntryList( + OUT PSINGLE_LIST_ENTRY ListHead, + IN PSINGLE_LIST_ENTRY Entry) +{ + Entry->Next = ListHead->Next; + ListHead->Next = Entry; +} + +FORCEINLINE PSINGLE_LIST_ENTRY PopEntryList( + OUT PSINGLE_LIST_ENTRY ListHead) +{ + PSINGLE_LIST_ENTRY FirstEntry = ListHead->Next; + + if (FirstEntry) { + ListHead->Next = FirstEntry->Next; + } + + return FirstEntry; +} \ No newline at end of file diff --git a/VxKexLdr.sln b/VxKexLdr.sln new file mode 100644 index 0000000..230ece4 --- /dev/null +++ b/VxKexLdr.sln @@ -0,0 +1,191 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VxKexLdr", "VxKexLdr\VXKEXLDR.vcxproj", "{3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}" + ProjectSection(ProjectDependencies) = postProject + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {24FC500A-AA39-4886-B19F-4ADB19642DB9} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KexShlEx", "KexShlEx\KexShlEx.vcxproj", "{0C454599-73FB-4F57-B8C9-0BE68AF3110E}" + ProjectSection(ProjectDependencies) = postProject + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {24FC500A-AA39-4886-B19F-4ADB19642DB9} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KexCfg", "KexCfg\KexCfg.vcxproj", "{3E126701-0D6C-404F-821D-F51F2B1BB0FB}" + ProjectSection(ProjectDependencies) = postProject + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {24FC500A-AA39-4886-B19F-4ADB19642DB9} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KexSetup", "KexSetup\KexSetup.vcxproj", "{9B3D1588-BDBB-4F20-9362-B9508168A675}" + ProjectSection(ProjectDependencies) = postProject + {3E126701-0D6C-404F-821D-F51F2B1BB0FB} = {3E126701-0D6C-404F-821D-F51F2B1BB0FB} + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {24FC500A-AA39-4886-B19F-4ADB19642DB9} + {3688EE16-AA48-414C-A8FA-6814C767CAEC} = {3688EE16-AA48-414C-A8FA-6814C767CAEC} + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E} = {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E} + {09F0931A-069E-4158-AE74-976DA2ED315C} = {09F0931A-069E-4158-AE74-976DA2ED315C} + {49450E57-202A-45E9-8A62-FB849AEF0880} = {49450E57-202A-45E9-8A62-FB849AEF0880} + {B66C9C69-C6C1-421C-97CB-5EA5BED49794} = {B66C9C69-C6C1-421C-97CB-5EA5BED49794} + {8FED5F6A-0C4A-479F-9C85-763C33621454} = {8FED5F6A-0C4A-479F-9C85-763C33621454} + {0C454599-73FB-4F57-B8C9-0BE68AF3110E} = {0C454599-73FB-4F57-B8C9-0BE68AF3110E} + {167208CD-E59F-4709-9ADD-6880115C11D8} = {167208CD-E59F-4709-9ADD-6880115C11D8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "combase", "combase\combase.vcxproj", "{49450E57-202A-45E9-8A62-FB849AEF0880}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dxg1", "dxg1\dxg1.vcxproj", "{167208CD-E59F-4709-9ADD-6880115C11D8}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "kernel33", "kernel33\kernel33.vcxproj", "{3688EE16-AA48-414C-A8FA-6814C767CAEC}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ole33", "ole33\ole33.vcxproj", "{09F0931A-069E-4158-AE74-976DA2ED315C}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ExtendedDlls", "ExtendedDlls", "{24B3C1A8-9F57-443A-9BF8-D7A82313C934}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "KexComponents", "KexComponents", "{7457560B-11A4-45FE-919A-52760C90A533}" + ProjectSection(SolutionItems) = preProject + ChangeLog.txt = ChangeLog.txt + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "shcore", "shcore\shcore.vcxproj", "{8FED5F6A-0C4A-479F-9C85-763C33621454}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "user33", "user33\user33.vcxproj", "{B66C9C69-C6C1-421C-97CB-5EA5BED49794}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DevUtils", "DevUtils", "{AD8ACE63-A6D9-4859-B00A-ADD908FC3C5A}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Common Headers", "Common Headers", "{14941210-9C7B-4C81-8BE8-9B0AEDEE42C3}" + ProjectSection(SolutionItems) = preProject + KexComm.h = KexComm.h + KexDll.h = KexDll.h + NtDll.h = NtDll.h + VxKex.h = VxKex.h + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KexComm", "KexComm\KexComm.vcxproj", "{24FC500A-AA39-4886-B19F-4ADB19642DB9}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KexExprt", "KexExprt\KexExprt.vcxproj", "{1E020116-467E-4D16-8C80-0CC2867965E5}" + ProjectSection(ProjectDependencies) = postProject + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {24FC500A-AA39-4886-B19F-4ADB19642DB9} + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Debug|Win32.ActiveCfg = Debug|Win32 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Debug|Win32.Build.0 = Debug|Win32 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Debug|x64.ActiveCfg = Debug|x64 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Debug|x64.Build.0 = Debug|x64 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Release|Win32.ActiveCfg = Release|Win32 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Release|Win32.Build.0 = Release|Win32 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Release|x64.ActiveCfg = Release|x64 + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E}.Release|x64.Build.0 = Release|x64 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Debug|Win32.ActiveCfg = Debug|Win32 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Debug|Win32.Build.0 = Debug|Win32 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Debug|x64.ActiveCfg = Debug|x64 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Debug|x64.Build.0 = Debug|x64 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Release|Win32.ActiveCfg = Release|Win32 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Release|Win32.Build.0 = Release|Win32 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Release|x64.ActiveCfg = Release|x64 + {0C454599-73FB-4F57-B8C9-0BE68AF3110E}.Release|x64.Build.0 = Release|x64 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Debug|Win32.ActiveCfg = Debug|Win32 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Debug|Win32.Build.0 = Debug|Win32 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Debug|x64.ActiveCfg = Debug|x64 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Debug|x64.Build.0 = Debug|x64 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Release|Win32.ActiveCfg = Release|Win32 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Release|Win32.Build.0 = Release|Win32 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Release|x64.ActiveCfg = Release|x64 + {3E126701-0D6C-404F-821D-F51F2B1BB0FB}.Release|x64.Build.0 = Release|x64 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Debug|Win32.ActiveCfg = Debug|Win32 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Debug|Win32.Build.0 = Debug|Win32 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Debug|x64.ActiveCfg = Debug|x64 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Debug|x64.Build.0 = Debug|x64 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Release|Win32.ActiveCfg = Release|Win32 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Release|Win32.Build.0 = Release|Win32 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Release|x64.ActiveCfg = Release|x64 + {9B3D1588-BDBB-4F20-9362-B9508168A675}.Release|x64.Build.0 = Release|x64 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Debug|Win32.ActiveCfg = Debug|Win32 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Debug|Win32.Build.0 = Debug|Win32 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Debug|x64.ActiveCfg = Debug|x64 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Debug|x64.Build.0 = Debug|x64 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Release|Win32.ActiveCfg = Release|Win32 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Release|Win32.Build.0 = Release|Win32 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Release|x64.ActiveCfg = Release|x64 + {49450E57-202A-45E9-8A62-FB849AEF0880}.Release|x64.Build.0 = Release|x64 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Debug|Win32.ActiveCfg = Debug|Win32 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Debug|Win32.Build.0 = Debug|Win32 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Debug|x64.ActiveCfg = Debug|x64 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Debug|x64.Build.0 = Debug|x64 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Release|Win32.ActiveCfg = Release|Win32 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Release|Win32.Build.0 = Release|Win32 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Release|x64.ActiveCfg = Release|x64 + {167208CD-E59F-4709-9ADD-6880115C11D8}.Release|x64.Build.0 = Release|x64 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Debug|Win32.ActiveCfg = Debug|Win32 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Debug|Win32.Build.0 = Debug|Win32 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Debug|x64.ActiveCfg = Debug|x64 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Debug|x64.Build.0 = Debug|x64 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Release|Win32.ActiveCfg = Release|Win32 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Release|Win32.Build.0 = Release|Win32 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Release|x64.ActiveCfg = Release|x64 + {3688EE16-AA48-414C-A8FA-6814C767CAEC}.Release|x64.Build.0 = Release|x64 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Debug|Win32.ActiveCfg = Debug|Win32 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Debug|Win32.Build.0 = Debug|Win32 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Debug|x64.ActiveCfg = Debug|x64 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Debug|x64.Build.0 = Debug|x64 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Release|Win32.ActiveCfg = Release|Win32 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Release|Win32.Build.0 = Release|Win32 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Release|x64.ActiveCfg = Release|x64 + {09F0931A-069E-4158-AE74-976DA2ED315C}.Release|x64.Build.0 = Release|x64 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Debug|Win32.ActiveCfg = Debug|Win32 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Debug|Win32.Build.0 = Debug|Win32 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Debug|x64.ActiveCfg = Debug|x64 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Debug|x64.Build.0 = Debug|x64 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Release|Win32.ActiveCfg = Release|Win32 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Release|Win32.Build.0 = Release|Win32 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Release|x64.ActiveCfg = Release|x64 + {8FED5F6A-0C4A-479F-9C85-763C33621454}.Release|x64.Build.0 = Release|x64 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Debug|Win32.ActiveCfg = Debug|Win32 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Debug|Win32.Build.0 = Debug|Win32 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Debug|x64.ActiveCfg = Debug|x64 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Debug|x64.Build.0 = Debug|x64 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Release|Win32.ActiveCfg = Release|Win32 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Release|Win32.Build.0 = Release|Win32 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Release|x64.ActiveCfg = Release|x64 + {B66C9C69-C6C1-421C-97CB-5EA5BED49794}.Release|x64.Build.0 = Release|x64 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Debug|Win32.ActiveCfg = Debug|Win32 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Debug|Win32.Build.0 = Debug|Win32 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Debug|x64.ActiveCfg = Debug|x64 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Debug|x64.Build.0 = Debug|x64 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Release|Win32.ActiveCfg = Release|Win32 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Release|Win32.Build.0 = Release|Win32 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Release|x64.ActiveCfg = Release|x64 + {24FC500A-AA39-4886-B19F-4ADB19642DB9}.Release|x64.Build.0 = Release|x64 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Debug|Win32.ActiveCfg = Debug|Win32 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Debug|Win32.Build.0 = Debug|Win32 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Debug|x64.ActiveCfg = Debug|x64 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Debug|x64.Build.0 = Debug|x64 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Release|Win32.ActiveCfg = Release|Win32 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Release|Win32.Build.0 = Release|Win32 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Release|x64.ActiveCfg = Release|x64 + {1E020116-467E-4D16-8C80-0CC2867965E5}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {0C454599-73FB-4F57-B8C9-0BE68AF3110E} = {7457560B-11A4-45FE-919A-52760C90A533} + {3E126701-0D6C-404F-821D-F51F2B1BB0FB} = {7457560B-11A4-45FE-919A-52760C90A533} + {9B3D1588-BDBB-4F20-9362-B9508168A675} = {7457560B-11A4-45FE-919A-52760C90A533} + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E} = {7457560B-11A4-45FE-919A-52760C90A533} + {24FC500A-AA39-4886-B19F-4ADB19642DB9} = {7457560B-11A4-45FE-919A-52760C90A533} + {167208CD-E59F-4709-9ADD-6880115C11D8} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {3688EE16-AA48-414C-A8FA-6814C767CAEC} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {09F0931A-069E-4158-AE74-976DA2ED315C} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {49450E57-202A-45E9-8A62-FB849AEF0880} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {8FED5F6A-0C4A-479F-9C85-763C33621454} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {B66C9C69-C6C1-421C-97CB-5EA5BED49794} = {24B3C1A8-9F57-443A-9BF8-D7A82313C934} + {1E020116-467E-4D16-8C80-0CC2867965E5} = {AD8ACE63-A6D9-4859-B00A-ADD908FC3C5A} + EndGlobalSection +EndGlobal diff --git a/VxKexLdr/VXKEXLDR.vcxproj b/VxKexLdr/VXKEXLDR.vcxproj new file mode 100644 index 0000000..c9fdf25 --- /dev/null +++ b/VxKexLdr/VXKEXLDR.vcxproj @@ -0,0 +1,190 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3D66E318-A1FC-470A-84B0-C5B35DBA7E4E} + Win32Proj + VXKEXLDR + VxKexLdr + + + + Application + true + Unicode + + + Application + true + Unicode + + + Application + false + true + Unicode + + + Application + false + true + Unicode + + + + + + + + + + + + + + + + + + + + + MinimumRecommendedRules.ruleset + + + + + MinimumRecommendedRules.ruleset + + + false + MinimumRecommendedRules.ruleset + + + false + MinimumRecommendedRules.ruleset + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + false + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;psapi.lib;comctl32.lib;KexComm.lib;ntdll_x86.lib;%(AdditionalDependencies) + true + $(SolutionDir);$(TargetDir) + false + + + $(SolutionDir) + + + + + + + Level3 + Disabled + WIN32;_WIN64;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + false + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;psapi.lib;comctl32.lib;KexComm.lib;ntdll_x64.lib;%(AdditionalDependencies) + true + $(SolutionDir);$(TargetDir) + false + + + $(SolutionDir) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + false + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;psapi.lib;comctl32.lib;KexComm.lib;ntdll_x86.lib;%(AdditionalDependencies) + $(SolutionDir);$(TargetDir) + + + $(SolutionDir) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;_WIN64;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + $(SolutionDir) + false + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;shlwapi.lib;psapi.lib;comctl32.lib;KexComm.lib;ntdll_x64.lib;%(AdditionalDependencies) + $(SolutionDir);$(TargetDir) + + + $(SolutionDir) + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VxKexLdr/VXKEXLDR.vcxproj.filters b/VxKexLdr/VXKEXLDR.vcxproj.filters new file mode 100644 index 0000000..fec2ad6 --- /dev/null +++ b/VxKexLdr/VXKEXLDR.vcxproj.filters @@ -0,0 +1,38 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/VxKexLdr/VXKEXLDR.vcxproj.user b/VxKexLdr/VXKEXLDR.vcxproj.user new file mode 100644 index 0000000..5da3776 --- /dev/null +++ b/VxKexLdr/VXKEXLDR.vcxproj.user @@ -0,0 +1,33 @@ + + + + + + WindowsLocalDebugger + C:\Users\vxiiduu\Documents\Visual Studio 2010\Projects\VXKEXLDR\x64\Debug + $(TargetPath) + + + + + + + C:\Users\vxiiduu\Documents\Visual Studio 2010\Projects\VXKEXLDR\x64\Debug + WindowsLocalDebugger + + + C:\Users\vxiiduu\Documents\Visual Studio 2010\Projects\VXKEXLDR\x64\Debug\KeyMouse.exe + + + C:\Users\vxiiduu\Documents\Visual Studio 2010\Projects\VXKEXLDR\x64\Debug + WindowsLocalDebugger + + + + + + + C:\Users\vxiiduu\Documents\Visual Studio 2010\Projects\VXKEXLDR\x64\Debug + WindowsLocalDebugger + + \ No newline at end of file diff --git a/VxKexLdr/VaRw.c b/VxKexLdr/VaRw.c new file mode 100644 index 0000000..7bedd3a --- /dev/null +++ b/VxKexLdr/VaRw.c @@ -0,0 +1,145 @@ +#include "VaRw.h" + +extern HANDLE g_hProc; + +VOID VaRead( + IN ULONG_PTR ulSrc, + OUT LPVOID lpDst, + IN SIZE_T nSize) +{ + if (ReadProcessMemory(g_hProc, (LPCVOID) ulSrc, lpDst, nSize, NULL) == FALSE) { + if (GetLastError() != ERROR_PARTIAL_COPY) { + CriticalErrorBoxF(T("Failed to read process memory at offset %p: %s"), + ulSrc, GetLastErrorAsString()); + } + } +} + +VOID VaWrite( + IN ULONG_PTR ulDst, + IN LPCVOID lpSrc, + IN SIZE_T nSize) +{ + DWORD dwOldProtect; + + if (VirtualProtectEx(g_hProc, (LPVOID) ulDst, nSize, PAGE_EXECUTE_READWRITE, &dwOldProtect) == FALSE) { + CriticalErrorBoxF(T("Failed to set access protections on process: %s"), GetLastErrorAsString()); + } + + if (WriteProcessMemory(g_hProc, (LPVOID) ulDst, lpSrc, nSize, NULL) == FALSE) { + CriticalErrorBoxF(T("Failed to write process memory at offset %p with %llu bytes of data: %s"), + ulDst, nSize, GetLastErrorAsString()); + } + + if (VirtualProtectEx(g_hProc, (LPVOID) ulDst, nSize, dwOldProtect, &dwOldProtect) == FALSE) { + CriticalErrorBoxF(T("Failed to un-set access protections on process: %s"), GetLastErrorAsString()); + } +} + +VOID VaWriteByte( + IN ULONG_PTR ulDst, + IN BYTE btData) +{ + VaWrite(ulDst, &btData, sizeof(BYTE)); +} + +VOID VaWriteWord( + IN ULONG_PTR ulDst, + IN WORD wData) +{ + VaWrite(ulDst, &wData, sizeof(WORD)); +} + +VOID VaWriteDword( + IN ULONG_PTR ulDst, + IN DWORD dwData) +{ + VaWrite(ulDst, &dwData, sizeof(DWORD)); +} + +VOID VaWriteQword( + IN ULONG_PTR ulDst, + IN QWORD qwData) +{ + VaWrite(ulDst, &qwData, sizeof(QWORD)); +} + +VOID VaWritePtr( + IN ULONG_PTR ulDst, + IN ULONG_PTR ulData) +{ + VaWrite(ulDst, &ulData, sizeof(ULONG_PTR)); +} + +// write the ANSI string including the ending 0 byte +VOID VaWriteSzA( + IN ULONG_PTR ulDst, + IN LPCTSTR lpszSrc) +{ + SIZE_T cch = strlen(lpszSrc) + 1; +#ifdef UNICODE + CHAR szAnsiString[MAX_PATH]; + WideCharToMultiByte(CP_UTF8, 0, lpszSrc, -1, szAnsiString, sizeof(szAnsiString), NULL, NULL); + VaWrite(ulDst, szAnsiString, cch); +#else + VaWrite(ulDst, lpszSrc, cch); +#endif +} + +BYTE VaReadByte( + IN ULONG_PTR ulSrc) +{ + BYTE btRet; + VaRead(ulSrc, &btRet, sizeof(BYTE)); + return btRet; +} + +WORD VaReadWord( + IN ULONG_PTR ulSrc) +{ + WORD wRet; + VaRead(ulSrc, &wRet, sizeof(WORD)); + return wRet; +} + +DWORD VaReadDword( + IN ULONG_PTR ulSrc) +{ + DWORD dwRet; + VaRead(ulSrc, &dwRet, sizeof(DWORD)); + return dwRet; +} + +QWORD VaReadQword( + IN ULONG_PTR ulSrc) +{ + QWORD qwRet; + VaRead(ulSrc, &qwRet, sizeof(QWORD)); + return qwRet; +} + +ULONG_PTR VaReadPtr( + IN ULONG_PTR ulSrc) +{ + ULONG_PTR ulRet; + VaRead(ulSrc, &ulRet, sizeof(ULONG_PTR)); + return ulRet; +} + +VOID VaReadSzA( + IN ULONG_PTR ulSrc, + IN LPSTR lpszDest, + IN DWORD dwcchDest) +{ + DWORD i = 0; + while (i < (dwcchDest - 1) && (lpszDest[i++] = VaReadByte(ulSrc++))); +} + +VOID VaReadSzW( + IN ULONG_PTR ulSrc, + IN LPWSTR lpszDest, + IN DWORD dwcchDest) +{ + DWORD i = 0; + while (i < (dwcchDest - 1) && (lpszDest[i++] = VaReadWord(ulSrc))) ulSrc += 2; +} \ No newline at end of file diff --git a/VxKexLdr/VaRw.h b/VxKexLdr/VaRw.h new file mode 100644 index 0000000..422b176 --- /dev/null +++ b/VxKexLdr/VaRw.h @@ -0,0 +1,61 @@ +#pragma once +#include + +VOID VaRead( + IN ULONG_PTR ulSrc, + OUT LPVOID lpDst, + IN SIZE_T nSize); + +VOID VaWrite( + IN ULONG_PTR ulDst, + IN LPCVOID lpSrc, + IN SIZE_T nSize); + +VOID VaWriteByte( + IN ULONG_PTR ulDst, + IN BYTE btData); + +VOID VaWriteWord( + IN ULONG_PTR ulDst, + IN WORD wData); + +VOID VaWriteDword( + IN ULONG_PTR ulDst, + IN DWORD dwData); + +VOID VaWriteQword( + IN ULONG_PTR ulDst, + IN QWORD qwData); + +VOID VaWritePtr( + IN ULONG_PTR ulDst, + IN ULONG_PTR ulData); + +VOID VaWriteSzA( + IN ULONG_PTR ulDst, + IN LPCTSTR lpszSrc); + +BYTE VaReadByte( + IN ULONG_PTR ulSrc); + +WORD VaReadWord( + IN ULONG_PTR ulSrc); + +DWORD VaReadDword( + IN ULONG_PTR ulSrc); + +QWORD VaReadQword( + IN ULONG_PTR ulSrc); + +ULONG_PTR VaReadPtr( + IN ULONG_PTR ulSrc); + +VOID VaReadSzA( + IN ULONG_PTR ulSrc, + IN LPSTR lpszDest, + IN DWORD dwcchDest); + +VOID VaReadSzW( + IN ULONG_PTR ulSrc, + IN LPWSTR lpszDest, + IN DWORD dwcchDest); \ No newline at end of file diff --git a/VxKexLdr/VxKexLdr.aps b/VxKexLdr/VxKexLdr.aps new file mode 100644 index 0000000000000000000000000000000000000000..39f4973e24f443ed26e7ba881eec71c84ea8b315 GIT binary patch literal 34252 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "VaRw.h" +#include "resource.h" + +#define APPNAME T("VxKexLdr") +#define FRIENDLYAPPNAME T("VxKex Loader") +#define EXCEPTION_WX86_BREAKPOINT 0x4000001F + +// +// Global vars +// + +TCHAR g_szExeFullPath[MAX_PATH]; +ULONG_PTR g_vaExeBase; +ULONG_PTR g_vaPebBase; +HANDLE g_hProc = NULL; +HANDLE g_hThread = NULL; +DWORD g_dwProcId; +DWORD g_dwThreadId; +BOOL g_bExe64 = -1; + +// +// Utility functions +// + +VOID Pause( + VOID) +{ + HWND hWndConsole = GetConsoleWindow(); + if (hWndConsole && IsWindowVisible(hWndConsole)) { + cprintf(T("Press any key to continue . . . ")); + getch(); + } +} + +NORETURN VOID Exit( + IN DWORD dwExitCode) +{ + Pause(); + FreeConsole(); + ExitProcess(dwExitCode); +} + +// FailExit() should only be called on failure. +NORETURN VOID FailExit( + VOID) +{ + TerminateProcess(g_hProc, 0); + Exit(0); +} + +// +// Worker functions +// + +// The purpose of this function is to avoid the subsystem version check performed by kernel32.dll +// as a part of the CreateProcess() routine. +// There is a function called BasepCheckImageVersion (on XP, it's called BasepIsImageVersionOk) which +// queries two memory addresses: +// 0x7ffe026c: Subsystem Major Version (DWORD) +// 0x7ffe0270: Subsystem Minor Version (DWORD) +// These two values are part of the USER_SHARED_DATA structure, which is read-only. However we can +// patch the memory values themselves to point to our own fake subsystem image numbers. +// It turns out that we can simply scan the in-memory kernel32.dll for these two addresses (works +// on XP, Vista and 7 - x86, x64 and WOW64) and only one result will come up. What a stroke of luck. +// Then we rewrite those addresses to point at our fake numbers. +VOID PatchKernel32ImageVersionCheck( + BOOL bPatch) +{ + static BOOL bAlreadyPatched = FALSE; + static LPDWORD lpMajorAddress = NULL; // addresses within kernel32.dll that we are patching + static LPDWORD lpMinorAddress = NULL; // ^ + static LPDWORD lpdwFakeMajorVersion = NULL; + static LPDWORD lpdwFakeMinorVersion = NULL; + DWORD dwOldProtect; + + if (bPatch) { + // patch + MODULEINFO k32ModInfo; + LPBYTE lpPtr; + LPBYTE lpEndPtr; + + if (bAlreadyPatched) { + // this shouldn't happen +#ifdef _DEBUG + CriticalErrorBoxF(T("Internal error: %s(bPatch=TRUE) called inappropriately"), __FUNCTION__); +#else + return; +#endif + } + + if (!lpdwFakeMajorVersion) { + lpdwFakeMajorVersion = (LPDWORD) VirtualAlloc(NULL, sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + + if (!lpdwFakeMajorVersion) { +#ifdef _DEBUG + CriticalErrorBoxF(T("Failed to allocate memory: %s"), GetLastErrorAsString()); +#else + return; +#endif + } + + *lpdwFakeMajorVersion = 0xFFFFFFFF; + VirtualProtect(lpdwFakeMajorVersion, sizeof(DWORD), PAGE_READONLY, &dwOldProtect); + } + + if (!lpdwFakeMinorVersion) { + lpdwFakeMinorVersion = (LPDWORD) VirtualAlloc(NULL, sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + + if (!lpdwFakeMinorVersion) { +#ifdef _DEBUG + CriticalErrorBoxF(T("Failed to allocate memory: %s"), GetLastErrorAsString()); +#else + return; +#endif + } + + *lpdwFakeMinorVersion = 0xFFFFFFFF; + VirtualProtect(lpdwFakeMinorVersion, sizeof(DWORD), PAGE_READONLY, &dwOldProtect); + } + + + if ((DWORD_PTR) lpdwFakeMajorVersion > 0xFFFFFFFC || (DWORD_PTR) lpdwFakeMinorVersion > 0xFFFFFFFC) { + // this shouldn't happen on win7 and earlier, they only started adding ASLR stuff + // in windows 8 IIRC (and we don't care about those) +#ifdef _DEBUG + CriticalErrorBoxF(T("Internal error: Pointer to faked subsystem version too large.")); +#else + return; +#endif + } + + if (GetModuleInformation(GetCurrentProcess(), GetModuleHandle(T("kernel32.dll")), &k32ModInfo, sizeof(k32ModInfo)) == FALSE) { + // give up and hope that the .exe file the user wants to launch doesn't need this + // workaround +#ifdef _DEBUG + CriticalErrorBoxF(T("Failed to retrieve module information of KERNEL32.DLL: %s"), GetLastErrorAsString()); +#else + return; +#endif + } + + lpEndPtr = (LPBYTE) k32ModInfo.lpBaseOfDll + k32ModInfo.SizeOfImage; + + for (lpPtr = (LPBYTE) k32ModInfo.lpBaseOfDll; lpPtr < (lpEndPtr - sizeof(DWORD)); ++lpPtr) { + LPDWORD lpDw = (LPDWORD) lpPtr; + + if (lpMajorAddress && lpMinorAddress) { + // we have already patched both required values + break; + } + + if (*lpDw == 0x7FFE026C) { + DWORD dwOldProtect; + lpMajorAddress = lpDw; + VirtualProtect(lpDw, sizeof(DWORD), PAGE_EXECUTE_WRITECOPY, &dwOldProtect); + *lpDw = (DWORD) lpdwFakeMajorVersion; + VirtualProtect(lpDw, sizeof(DWORD), dwOldProtect, &dwOldProtect); + } else if (*lpDw == 0x7FFE0270) { + DWORD dwOldProtect; + lpMinorAddress = lpDw; + VirtualProtect(lpDw, sizeof(DWORD), PAGE_EXECUTE_WRITECOPY, &dwOldProtect); + *lpDw = (DWORD) lpdwFakeMinorVersion; + VirtualProtect(lpDw, sizeof(DWORD), dwOldProtect, &dwOldProtect); + } + } + + bAlreadyPatched = TRUE; + } else if (bAlreadyPatched) { + // unpatch + VirtualProtect(lpMajorAddress, sizeof(DWORD), PAGE_EXECUTE_WRITECOPY, &dwOldProtect); + *lpMajorAddress = 0x7FFE026C; + VirtualProtect(lpMajorAddress, sizeof(DWORD), dwOldProtect, &dwOldProtect); + + VirtualProtect(lpMinorAddress, sizeof(DWORD), PAGE_EXECUTE_WRITECOPY, &dwOldProtect); + *lpMinorAddress = 0x7FFE0270; + VirtualProtect(lpMinorAddress, sizeof(DWORD), dwOldProtect, &dwOldProtect); + + lpMajorAddress = NULL; + lpMinorAddress = NULL; + VirtualFree(lpdwFakeMajorVersion, 0, MEM_RELEASE); lpdwFakeMajorVersion = NULL; + VirtualFree(lpdwFakeMinorVersion, 0, MEM_RELEASE); lpdwFakeMinorVersion = NULL; + bAlreadyPatched = FALSE; + } +} + + +VOID GetProcessBaseAddressAndPebBaseAddress( + IN HANDLE hProc) +{ + NTSTATUS st; + PROCESS_BASIC_INFORMATION BasicInfo; + + // Using GetModuleInformation will fail with ERROR_INVALID_HANDLE if Peb(child)->Ldr + // is NULL, which is the case when we start a suspended process - since the Ldr struct + // is initialized by NTDLL. See nt5src\Win2K3\sdktools\psapi\process.c for more info. + // Anyway, that means we must use NtQueryInformationProcess. + + st = NtQueryInformationProcess( + hProc, + ProcessBasicInformation, + &BasicInfo, + sizeof(BasicInfo), + NULL); + + if (!SUCCEEDED(st)) { + CriticalErrorBoxF(T("Failed to query process information.\nNTSTATUS error code: %#010I32x"), st); + } else { + // The returned PebBaseAddress is in the virtual address space of the + // created process, not ours. + g_vaPebBase = (ULONG_PTR) BasicInfo.PebBaseAddress; + ReadProcessMemory(hProc, &BasicInfo.PebBaseAddress->ImageBaseAddress, &g_vaExeBase, sizeof(g_vaExeBase), NULL); + } +} + +BOOL ProcessIs32Bit( + IN HANDLE hProc) +{ +#ifndef _WIN64 + return TRUE; +#else + // IsWow64Process doesn't work. Always returns FALSE. + WORD w; + GetProcessBaseAddressAndPebBaseAddress((g_hProc = hProc)); + w = VaReadWord(g_vaExeBase + VaReadDword(g_vaExeBase + 0x3C) + 4); + return (w == 0x014C); +#endif +} + +// this allows programs to load our DLLs +// avoids having to add entries to clutter up the system PATH +VOID AppendKex3264ToPath( + IN INT bits) +{ + TCHAR szKexDir[MAX_PATH]; + TCHAR szPathAppend[MAX_PATH * 2]; + LPTSTR szPath; + DWORD dwcchPath; + + RegReadSz(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("KexDir"), szKexDir, ARRAYSIZE(szKexDir)); + sprintf_s(szPathAppend, ARRAYSIZE(szPathAppend), T(";%s\\Kex%d"), szKexDir, bits); + dwcchPath = GetEnvironmentVariable(T("Path"), NULL, 0) + (DWORD) strlen(szPathAppend); + szPath = (LPTSTR) StackAlloc(dwcchPath * sizeof(TCHAR)); + GetEnvironmentVariable(T("Path"), szPath, dwcchPath); + strcat_s(szPath, dwcchPath, szPathAppend); + SetEnvironmentVariable(T("Path"), szPath); +} + +VOID CreateSuspendedProcess( + IN LPTSTR lpszCmdLine) // Full command-line of the process incl. executable name +{ + BOOL bSuccess; + BOOL bRetryPatchKernel32 = FALSE; + BOOL bRetryAppendPath = FALSE; + DWORD dwCpError; + STARTUPINFO StartupInfo; + PROCESS_INFORMATION ProcInfo; + + GetStartupInfo(&StartupInfo); + +RetryCreateProcess: + bSuccess = CreateProcess( + NULL, + lpszCmdLine, + NULL, + NULL, + FALSE, + CREATE_SUSPENDED | DEBUG_ONLY_THIS_PROCESS, + NULL, + NULL, + &StartupInfo, + &ProcInfo); + dwCpError = GetLastError(); + + PatchKernel32ImageVersionCheck(FALSE); + + if (!bSuccess) { + if (dwCpError == ERROR_BAD_EXE_FORMAT) { + if (!bRetryPatchKernel32) { + // Since patching kernel32 carries a performance penalty (have to scan through memory), we + // only patch kernel32 if CreateProcess fails (which, in most cases, is due to not passing + // the image subsystem version check). + bRetryPatchKernel32 = TRUE; + PatchKernel32ImageVersionCheck(TRUE); + goto RetryCreateProcess; + } else { + // Windows doesn't provide any pre-defined error message for this scenario. + // Therefore to prevent user confusion we have to display our own error message. + CriticalErrorBoxF(T("Failed to create process: %#010I32x: The executable file is invalid."), dwCpError); + } + } else if (dwCpError = ERROR_ELEVATION_REQUIRED && !IsUserAnAdmin()) { + // Debugging elevated processes as a non-elevated process isn't allowed so we need to re-exec + // ourselves as admin. + TCHAR szVxKexLdr[MAX_PATH]; + LPCTSTR lpszCommandLine = GetCommandLine(); + LPCTSTR lpszSubStr; + GetModuleFileName(NULL, szVxKexLdr, ARRAYSIZE(szVxKexLdr)); + lpszSubStr = StrStrI(lpszCommandLine, szVxKexLdr); + + if (lpszSubStr == lpszCommandLine || lpszSubStr == lpszCommandLine + 1) { + lpszCommandLine = lpszSubStr + lstrlen(szVxKexLdr); + } + + if (*lpszCommandLine == '\"') { + ++lpszCommandLine; + } + + ShellExecute(NULL, T("runas"), szVxKexLdr, lpszCommandLine, NULL, TRUE); + ExitProcess(0); + } + + CriticalErrorBoxF(T("Failed to create process: %#010I32x: %s"), dwCpError, GetLastErrorAsString()); + } + + if (!bRetryAppendPath) { + // The most reliable way to find out whether any given process is 32 bits is just to + // start it and check. It's bloat but it works. + // In the future maybe we will find a way to inject environment variables into a started + // process and avoid having to start the process twice. + g_bExe64 = !ProcessIs32Bit(ProcInfo.hProcess); + AppendKex3264ToPath(g_bExe64 ? 64 : 32); + DebugActiveProcessStop(ProcInfo.dwProcessId); // avoid spurious debug events later + TerminateProcess(ProcInfo.hProcess, 0); + CloseHandle(ProcInfo.hProcess); + CloseHandle(ProcInfo.hThread); + bRetryAppendPath = TRUE; + goto RetryCreateProcess; + } + + DebugSetProcessKillOnExit(FALSE); + g_hProc = ProcInfo.hProcess; + g_hThread = ProcInfo.hThread; + g_dwProcId = ProcInfo.dwProcessId; + g_dwThreadId = ProcInfo.dwThreadId; +} + +ULONG_PTR GetEntryPointVa( + IN ULONG_PTR vaPeBase) +{ + CONST ULONG_PTR vaPeSig = vaPeBase + VaReadDword(vaPeBase + 0x3C); + CONST ULONG_PTR vaCoffHdr = vaPeSig + 4; + CONST ULONG_PTR vaOptHdr = vaCoffHdr + 20; + return vaPeBase + VaReadDword(vaOptHdr + 16); +} + +LPCTSTR KexpGetIfeoKey( + IN LPCTSTR lpszExeFullPath OPTIONAL) +{ + static TCHAR szKexIfeoKey[54 + MAX_PATH]; + + if (lpszExeFullPath == NULL) { + lpszExeFullPath = g_szExeFullPath; + } + + strcpy_s(szKexIfeoKey, ARRAYSIZE(szKexIfeoKey), T("SOFTWARE\\VXsoft\\VxKexLdr\\Image File Execution Options\\")); + strcat_s(szKexIfeoKey, ARRAYSIZE(szKexIfeoKey), lpszExeFullPath); + return szKexIfeoKey; +} + +BOOL KexQueryIfeoDw( + IN LPCTSTR lpszExeFullPath OPTIONAL, + IN LPCTSTR lpszValueName, + OUT LPDWORD lpdwResult) +{ + return RegReadDw(HKEY_CURRENT_USER, KexpGetIfeoKey(lpszExeFullPath), lpszValueName, lpdwResult); +} + +BOOL KexQueryIfeoSz( + IN LPCTSTR lpszExeFullPath OPTIONAL, + IN LPCTSTR lpszValueName, + OUT LPTSTR lpszResult, + IN DWORD dwcchResult) +{ + return RegReadSz(HKEY_CURRENT_USER, KexpGetIfeoKey(lpszExeFullPath), lpszValueName, lpszResult, dwcchResult); +} + +BOOL ShouldAllocConsole( + IN LPCTSTR lpszExeFullPath OPTIONAL) +{ + DWORD dwShouldAllocConsole; + + if (lpszExeFullPath) { + if (RegReadDw(HKEY_CURRENT_USER, T("SOFTWARE\\VXsoft\\VxKexLdr"), T("ShowDebugInfoByDefault"), &dwShouldAllocConsole)) { + return dwShouldAllocConsole; + } else { + return FALSE; + } + } else { + if (KexQueryIfeoDw(lpszExeFullPath, T("AlwaysShowDebug"), &dwShouldAllocConsole)) { + return dwShouldAllocConsole; + } else { + return FALSE; + } + } +} + +BOOL ShouldDetachAfterDllRewrite( + IN LPCTSTR lpszExeFullPath) +{ + DWORD dwShouldNotDetach; + + if (KexQueryIfeoDw(lpszExeFullPath, T("WaitForChild"), &dwShouldNotDetach)) { + return !dwShouldNotDetach; + } else { + return TRUE; + } +} + +// user32.dll -> user33.dll etc etc +VOID RewriteImports( + IN LPCTSTR lpszImageName OPTIONAL, + IN ULONG_PTR vaPeBase) +{ + CONST ULONG_PTR vaPeSig = vaPeBase + VaReadDword(vaPeBase + 0x3C); + CONST ULONG_PTR vaCoffHdr = vaPeSig + 4; + CONST ULONG_PTR vaOptHdr = vaCoffHdr + 20; + CONST BOOL bPe64 = (VaReadWord(vaCoffHdr) == 0x8664) ? TRUE : FALSE; + CONST ULONG_PTR vaOptHdrWin = vaOptHdr + (bPe64 ? 24 : 28); + CONST ULONG_PTR vaOptHdrDir = vaOptHdr + (bPe64 ? 112 : 96); + CONST ULONG_PTR vaImportDir = vaOptHdr + (bPe64 ? 120 : 104); + CONST ULONG_PTR ulImportDir = VaReadPtr(vaImportDir); + CONST ULONG_PTR vaImportTbl = vaPeBase + (ulImportDir & 0x00000000FFFFFFFF); + + HKEY hKeyDllRewrite; + ULONG_PTR idxIntoImportTbl; + LSTATUS lStatus; + + if (g_bExe64 != bPe64) { + // Provide a more useful error message to the user than the cryptic shit + // which ntdll displays by default. + CriticalErrorBoxF(T("The %d-bit DLL '%s' was loaded into a %d-bit application.\n") + T("Architecture of DLLs and applications must match for successful program operation."), + bPe64 ? 64 : 32, lpszImageName ? lpszImageName : T("(unknown)"), g_bExe64 ? 64 : 32); + } + + if (ulImportDir == 0) { + cprintf(T(" This DLL contains no import directory - skipping\n")); + return; + } + + lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\VxKexLdr\\DllRewrite"), + 0, KEY_QUERY_VALUE | KEY_WOW64_64KEY, &hKeyDllRewrite); + + if (lStatus != ERROR_SUCCESS) { + SetLastError(lStatus); + CriticalErrorBoxF(T("Failed to open DLL rewrite registry key: %s"), GetLastErrorAsString()); + } + + for (idxIntoImportTbl = 0;; ++idxIntoImportTbl) { + CONST ULONG_PTR ulPtr = vaImportTbl + (idxIntoImportTbl * 20); + CONST DWORD rvaDllName = VaReadDword(ulPtr + 12); + CONST ULONG_PTR vaDllName = vaPeBase + rvaDllName; +#ifdef UNICODE + CHAR originalDllNameData[MAX_PATH * sizeof(TCHAR)]; +#endif + TCHAR szOriginalDllName[MAX_PATH]; + TCHAR szRewriteDllName[MAX_PATH]; + DWORD dwMaxPath = MAX_PATH; + + if (rvaDllName == 0) { + // Reached end of imports + break; + } + +#ifdef UNICODE + VaReadSzA(vaDllName, originalDllNameData, ARRAYSIZE(originalDllNameData)); + MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) originalDllNameData, -1, szOriginalDllName, ARRAYSIZE(szOriginalDllName)); +#else + VaReadSzA(vaDllName, szOriginalDllName, ARRAYSIZE(szOriginalDllName)); +#endif + + lStatus = RegQueryValueEx(hKeyDllRewrite, szOriginalDllName, NULL, NULL, + (LPBYTE) szRewriteDllName, &dwMaxPath); + + if (lStatus == ERROR_SUCCESS) { + CONST DWORD dwOriginalLength = (DWORD) strlen(szOriginalDllName); + CONST DWORD dwRewriteLength = (DWORD) strlen(szRewriteDllName); + + if (dwRewriteLength > dwOriginalLength) { + // IMPORTANT NOTE: When you add more rewrite DLLs to the registry, the length of the + // rewrite DLL name MUST BE LESS THAN OR EQUAL to the length of the original DLL name. + cprintf(T(" WARNING: The rewrite DLL name %s for original DLL %s is too long. ") + T("It is %u bytes but the maximum is %u. Skipping.\n"), + szRewriteDllName, szOriginalDllName, dwRewriteLength, dwOriginalLength); + } else { + cprintf(T(" Rewriting DLL import %s -> %s\n"), szOriginalDllName, szRewriteDllName); + VaWriteSzA(vaDllName, szRewriteDllName); + } + } else if (lStatus == ERROR_MORE_DATA) { + // The data for the registry entry was too long + cprintf(T(" WARNING: The rewrite DLL registry entry for the DLL %s ") + T("contains invalid data. Skipping.\n"), szOriginalDllName); + } else { + // No rewrite entry was found + cprintf(T(" Found DLL import %s - not rewriting\n"), szOriginalDllName); + } + } + + RegCloseKey(hKeyDllRewrite); +} + +BOOL ShouldRewriteImportsOfDll( + IN LPCTSTR lpszDllName) +{ + TCHAR szKexDir[MAX_PATH]; + TCHAR szWinDir[MAX_PATH]; + TCHAR szDllDir[MAX_PATH]; + LSTATUS lStatus; + HKEY hKeyMainConf; + + lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, T("SOFTWARE\\VXsoft\\" APPNAME), + 0, KEY_QUERY_VALUE | KEY_WOW64_64KEY, &hKeyMainConf); + if (lStatus != ERROR_SUCCESS) { + SetLastError(lStatus); + CriticalErrorBoxF(T("Could not open configuration registry key: %s"), GetLastErrorAsString()); + } else { + DWORD dwMaxPath = MAX_PATH; + lStatus = RegQueryValueEx(hKeyMainConf, T("KexDir"), NULL, NULL, + (LPBYTE) szKexDir, &dwMaxPath); + } + + if (!lpszDllName || !strlen(lpszDllName) || PathIsRelative(lpszDllName)) { + // just be safe and don't rewrite it, since we don't even know what it is + // for relative path: usually only NTDLL is specified as a relative path, + // and we don't want to rewrite that either (especially since it has no + // imports anyway) + return FALSE; + } + + GetWindowsDirectory(szWinDir, ARRAYSIZE(szWinDir)); + strcpy_s(szDllDir, ARRAYSIZE(szDllDir), lpszDllName); + PathRemoveFileSpec(szDllDir); + + if (PathIsPrefix(szWinDir, szDllDir) || PathIsPrefix(szKexDir, szDllDir)) { + // don't rewrite any imports if the particular DLL is in the Windows folder + // or the kernel extensions folder + return FALSE; + } + + return TRUE; +} + +// TODO: Make an XP compatible version +LPTSTR GetFilePathFromHandle( + IN HANDLE hFile) +{ + static TCHAR szPath[MAX_PATH + 4]; + + if (!GetFinalPathNameByHandle(hFile, szPath, ARRAYSIZE(szPath), 0)) { + return NULL; + } + + if (szPath[0] == '\\' && szPath[1] == '\\' && szPath[2] == '?' && szPath[3] == '\\') { + return szPath + 4; + } else { + return szPath; + } +} + +// fake version info, etc. +VOID PerformPostInitializationSteps( + VOID) +{ + TCHAR szFakedVersion[6]; + DWORD dwDebuggerSpoof; + + cprintf(T("[KE] Performing post-initialization steps\n")); + + if (KexQueryIfeoSz(g_szExeFullPath, T("WinVerSpoof"), szFakedVersion, ARRAYSIZE(szFakedVersion)) == TRUE) { + ULONG_PTR vaMajorVersion = g_vaPebBase + (g_bExe64 ? 0x118 : 0xA4); + ULONG_PTR vaMinorVersion = vaMajorVersion + sizeof(ULONG); + ULONG_PTR vaBuildNumber = vaMinorVersion + sizeof(ULONG); + ULONG_PTR vaCSDVersion = vaBuildNumber + sizeof(USHORT); + ULONG_PTR vaCSDVersionUS = g_vaPebBase + (g_bExe64 ? 0x2E8 : 0x1F0); + UNICODE_STRING usFakeCSDVersion; + + // buffer points to its own length (which is 0, the null terminator) + usFakeCSDVersion.Length = 0; + usFakeCSDVersion.MaximumLength = 0; + usFakeCSDVersion.Buffer = (PWSTR) vaCSDVersionUS; + + if (!lstrcmpi(szFakedVersion, T("WIN8"))) { + VaWriteDword(vaMajorVersion, 6); + VaWriteDword(vaMinorVersion, 2); + VaWriteWord(vaBuildNumber, 9200); + VaWriteWord(vaCSDVersion, 0); + VaWrite(vaCSDVersionUS, &usFakeCSDVersion, sizeof(usFakeCSDVersion)); + } else if (!lstrcmpi(szFakedVersion, T("WIN81"))) { + VaWriteDword(vaMajorVersion, 6); + VaWriteDword(vaMinorVersion, 3); + VaWriteWord(vaBuildNumber, 9600); + VaWriteWord(vaCSDVersion, 0); + VaWrite(vaCSDVersionUS, &usFakeCSDVersion, sizeof(usFakeCSDVersion)); + } else if (!lstrcmpi(szFakedVersion, T("WIN10"))) { + VaWriteDword(vaMajorVersion, 10); + VaWriteDword(vaMinorVersion, 0); + VaWriteWord(vaBuildNumber, 19044); + VaWriteWord(vaCSDVersion, 0); + VaWrite(vaCSDVersionUS, &usFakeCSDVersion, sizeof(usFakeCSDVersion)); + } else if (!lstrcmpi(szFakedVersion, T("WIN11"))) { + VaWriteDword(vaMajorVersion, 10); + VaWriteDword(vaMinorVersion, 0); + VaWriteWord(vaBuildNumber, 22000); + VaWriteWord(vaCSDVersion, 0); + VaWrite(vaCSDVersionUS, &usFakeCSDVersion, sizeof(usFakeCSDVersion)); + } + + cprintf(T("[KE] Faked Windows version: %s\n"), szFakedVersion); + } + + if (KexQueryIfeoDw(g_szExeFullPath, T("DebuggerSpoof"), &dwDebuggerSpoof)) { + ULONG_PTR vaDebuggerPresent = g_vaPebBase + FIELD_OFFSET(PEB, BeingDebugged); + VaWriteByte(vaDebuggerPresent, !dwDebuggerSpoof); + cprintf(T("[KE] Spoofed debugger presence\n")); + } +} + +// Monitors the process for DLL imports. +VOID RewriteDllImports( + VOID) +{ + DEBUG_EVENT DbgEvent; + BOOL bResumed = FALSE; + CONST ULONG_PTR vaEntryPoint = GetEntryPointVa(g_vaExeBase); + CONST BYTE btOriginal = VaReadByte(vaEntryPoint); + + cprintf(T("[KE ProcId=%lu, ThreadId=%lu]\tProcess entry point: %p, Original byte: 0x%02X\n"), + g_dwProcId, g_dwThreadId, vaEntryPoint, btOriginal); + VaWriteByte(vaEntryPoint, 0xCC); + + DbgEvent.dwProcessId = g_dwProcId; + DbgEvent.dwThreadId = g_dwThreadId; + + while (TRUE) { + if (!bResumed) { + ResumeThread(g_hThread); + bResumed = TRUE; + } else { + ContinueDebugEvent(DbgEvent.dwProcessId, DbgEvent.dwThreadId, DBG_EXCEPTION_NOT_HANDLED); + } + + WaitForDebugEvent(&DbgEvent, INFINITE); + + if (DbgEvent.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) { + cprintf(T("[CP ProcId=%lu]\t\tProcess created.\n"), DbgEvent.dwProcessId); + CloseHandle(DbgEvent.u.CreateProcessInfo.hFile); + CloseHandle(DbgEvent.u.CreateProcessInfo.hThread); + CloseHandle(DbgEvent.u.CreateProcessInfo.hProcess); + } else if (DbgEvent.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) { + HANDLE hDllFile = DbgEvent.u.LoadDll.hFile; + LPTSTR lpszDllName; + + if (!hDllFile || (lpszDllName = GetFilePathFromHandle(hDllFile)) == NULL) { + continue; + } + + cprintf(T("[LD ProcId=%lu, ThreadId=%lu]\tDLL loaded: %s"), DbgEvent.dwProcessId, DbgEvent.dwThreadId, lpszDllName); + + if (ShouldRewriteImportsOfDll(lpszDllName)) { + cprintf(T(" (imports will be rewritten)\n")); + PathStripPath(lpszDllName); + RewriteImports(lpszDllName, (ULONG_PTR) DbgEvent.u.LoadDll.lpBaseOfDll); + } else { + cprintf(T(" (imports will NOT be rewritten)\n")); + } + } else if (DbgEvent.dwDebugEventCode == UNLOAD_DLL_DEBUG_EVENT) { + cprintf(T("[UL ProcId=%lu, ThreadId=%lu]\tThe DLL at %p was unloaded.\n"), + DbgEvent.dwProcessId, DbgEvent.dwThreadId, DbgEvent.u.UnloadDll.lpBaseOfDll); + } else if (DbgEvent.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) { + cprintf(T("[EP ProcId=%lu]\t\tAttached process has exited.\n"), DbgEvent.dwProcessId); + + if (DbgEvent.dwProcessId == g_dwProcId) { + DWORD dwExitCode; + GetExitCodeProcess(g_hProc, &dwExitCode); + Exit(dwExitCode); + } + } else if (DbgEvent.dwDebugEventCode == EXCEPTION_DEBUG_EVENT && + (DbgEvent.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT || + DbgEvent.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_WX86_BREAKPOINT) && + DbgEvent.u.Exception.ExceptionRecord.ExceptionAddress == (PVOID) vaEntryPoint) { + CONTEXT Ctx; +#ifdef _WIN64 + WOW64_CONTEXT W64Ctx; +#endif + + // Must decrement EIP/RIP, restore the original byte, detach the debugger and + // resume program execution. Then exit the loader. + cprintf(T("[KE ProcId=%lu, ThreadId=%lu]\tProcess has finished loading.\n"), + DbgEvent.dwProcessId, DbgEvent.dwThreadId); + + if (g_bExe64) { +#ifdef _WIN64 // 64 bit loader running 64 bit program + Ctx.ContextFlags = CONTEXT_CONTROL; + GetThreadContext(g_hThread, &Ctx); + Ctx.Rip--; + SetThreadContext(g_hThread, &Ctx); +#endif + } else { +#ifdef _WIN64 // 64 bit loader running 32 bit program + W64Ctx.ContextFlags = CONTEXT_CONTROL; + Wow64GetThreadContext(g_hThread, &W64Ctx); + W64Ctx.Eip--; + Wow64SetThreadContext(g_hThread, &W64Ctx); +#else // 32 bit loader running 32 bit program + Ctx.ContextFlags = CONTEXT_CONTROL; + GetThreadContext(g_hThread, &Ctx); + Ctx.Eip--; + SetThreadContext(g_hThread, &Ctx); +#endif + } + + VaWriteByte(vaEntryPoint, btOriginal); + PerformPostInitializationSteps(); + ContinueDebugEvent(DbgEvent.dwProcessId, DbgEvent.dwThreadId, DBG_CONTINUE); + + if (ShouldDetachAfterDllRewrite(g_szExeFullPath)) { + DebugActiveProcessStop(g_dwProcId); + cprintf(T("[KE] Detached from process.\n")); + return; + } + } else if (DbgEvent.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT) { + HANDLE hProc = NULL; + LPTSTR lpszBuf = NULL; + SIZE_T BufSize = DbgEvent.u.DebugString.nDebugStringLength; + + if ((lpszBuf = (LPTSTR) malloc(BufSize)) == NULL) { + continue; + } + + if ((hProc = OpenProcess(PROCESS_VM_READ, FALSE, DbgEvent.dwProcessId)) == NULL) { + continue; + } + + if (ReadProcessMemory(hProc, DbgEvent.u.DebugString.lpDebugStringData, lpszBuf, BufSize, NULL) == FALSE) { + continue; + } + + CloseHandle(hProc); + +#ifdef UNICODE + cprintf(T("[DS ProcId=%lu, ThreadId=%lu]\t%S\n"), DbgEvent.dwProcessId, DbgEvent.dwThreadId, lpszBuf); +#else + cprintf(T("[DS ProcId=%lu, ThreadId=%lu]\t%s\n"), DbgEvent.dwProcessId, DbgEvent.dwThreadId, lpszBuf); +#endif + + free(lpszBuf); + } else { + cprintf(T("[?? ProcId=%lu, ThreadId=%lu]\tUnknown debug event received: %lu\n"), + DbgEvent.dwProcessId, DbgEvent.dwThreadId, DbgEvent.dwDebugEventCode); + } + } +} + +VOID GetProcessImageFullPath( + IN HANDLE hProc, + OUT LPTSTR szFullPath) +{ + TCHAR szImageFileName[MAX_PATH]; + TCHAR szDosDevice[3] = T("A:"); + TCHAR szNtDevice[MAX_PATH]; + + // This returns a NT style path such as "\Device\HarddiskVolume3\Program Files\whatever.exe" + // which is pretty much the verbatim output of NtQueryInformationProcess ProcessImageFileName. + GetProcessImageFileName(hProc, szImageFileName, ARRAYSIZE(szImageFileName)); + + for (; szDosDevice[0] <= 'Z'; szDosDevice[0]++) { + if (QueryDosDevice(szDosDevice, szNtDevice, ARRAYSIZE(szNtDevice) - 1)) { + if (!strnicmp(szNtDevice, szImageFileName, strlen(szNtDevice))) { + break; + } + } + } + + if (szDosDevice[0] > 'Z') { + CriticalErrorBoxF(T("%s was unable to resolve the DOS device name of the executable file '%s'.\n") + T("This may be caused by the file residing on a network share or unmapped drive. ") + T("%s does not currently support this scenario, please ensure all executable files ") + T("are on mapped drives with drive letters."), + FRIENDLYAPPNAME, FRIENDLYAPPNAME); + } + + strcpy_s(g_szExeFullPath, ARRAYSIZE(g_szExeFullPath), szDosDevice); + strcat_s(g_szExeFullPath, ARRAYSIZE(g_szExeFullPath), szImageFileName + strlen(szNtDevice)); +} + +BOOL SpawnProgramUnderLoader( + IN LPTSTR lpszCmdLine, + IN BOOL bCalledFromDialog, + IN BOOL bForce) +{ + DWORD dwEnableVxKex; + + CreateSuspendedProcess(lpszCmdLine); + GetProcessImageFullPath(g_hProc, g_szExeFullPath); + + if (!bCalledFromDialog && !bForce && (!KexQueryIfeoDw(g_szExeFullPath, T("EnableVxKex"), &dwEnableVxKex) || !dwEnableVxKex)) { + // Since the IFEO in HKLM doesn't discriminate by image path and only by name, this check has to + // be performed - if we aren't actually supposed to be enabled for this executable, just resume + // the thread and be done with it. + ResumeThread(g_hThread); + return FALSE; + } + + if (!bCalledFromDialog && (ShouldAllocConsole(NULL) || ShouldAllocConsole(g_szExeFullPath))) { + // You can't call cprintf() anywhere before this. If you do, all console output + // fails to work. + AllocConsole(); + } + + GetProcessBaseAddressAndPebBaseAddress(g_hProc); + cprintf(T("The process is %d-bit and its base address is %p (PEB base address: %p)\n"), + g_bExe64 ? 64 : 32, g_vaExeBase, g_vaPebBase); + RewriteImports(NULL, g_vaExeBase); + RewriteDllImports(); + + return TRUE; +} + +HWND CreateToolTip( + IN HWND hDlg, + IN INT iToolID, + IN LPTSTR lpszText) +{ + TOOLINFO ToolInfo; + HWND hWndTool; + HWND hWndTip; + + if (!iToolID || !hDlg || !lpszText) { + return NULL; + } + + // Get the window of the tool. + hWndTool = GetDlgItem(hDlg, iToolID); + + // Create the tooltip. + hWndTip = CreateWindowEx( + 0, TOOLTIPS_CLASS, NULL, + WS_POPUP | TTS_ALWAYSTIP, + CW_USEDEFAULT, CW_USEDEFAULT, + CW_USEDEFAULT, CW_USEDEFAULT, + hDlg, NULL, + NULL, NULL); + + if (!hWndTool || !hWndTip) { + return NULL; + } + + // Associate the tooltip with the tool. + ZeroMemory(&ToolInfo, sizeof(ToolInfo)); + ToolInfo.cbSize = sizeof(ToolInfo); + ToolInfo.hwnd = hDlg; + ToolInfo.uFlags = TTF_IDISHWND | TTF_SUBCLASS; + ToolInfo.uId = (UINT_PTR) hWndTool; + ToolInfo.lpszText = lpszText; + SendMessage(hWndTip, TTM_ADDTOOL, 0, (LPARAM) &ToolInfo); + + return hWndTip; +} + +INT_PTR CALLBACK DlgProc( + IN HWND hWnd, + IN UINT uMsg, + IN WPARAM wParam, + IN LPARAM lParam) +{ + LSTATUS lStatus; + HKEY hKeyUserSpecificConfig; + CONST TCHAR szUserSpecificConfigKey[] = T("SOFTWARE\\VXsoft\\") APPNAME; + TCHAR szFilename[MAX_PATH + 2] = T(""); + DWORD dwcbFilename = sizeof(szFilename); + BOOL bShouldShowDebugInfo; + DWORD dwcbShouldShowDebugInfo = sizeof(bShouldShowDebugInfo); + + switch (uMsg) { + case WM_INITDIALOG: + // read last successful command line from registry + lStatus = RegOpenKeyEx( + HKEY_CURRENT_USER, + szUserSpecificConfigKey, + 0, KEY_QUERY_VALUE | KEY_WOW64_64KEY, + &hKeyUserSpecificConfig); + + if (lStatus == ERROR_SUCCESS) { + RegQueryValueEx( + hKeyUserSpecificConfig, T("LastCmdLine"), + 0, NULL, (LPBYTE) szFilename, &dwcbFilename); + lStatus = RegQueryValueEx( + hKeyUserSpecificConfig, T("ShowDebugInfo"), + 0, NULL, (LPBYTE) &bShouldShowDebugInfo, &dwcbShouldShowDebugInfo); + + if (lStatus != ERROR_SUCCESS) { + bShouldShowDebugInfo = 0; + } + + CheckDlgButton(hWnd, IDCHKDEBUG, bShouldShowDebugInfo ? BST_CHECKED : BST_UNCHECKED); + RegCloseKey(hKeyUserSpecificConfig); + SetDlgItemText(hWnd, IDFILEPATH, szFilename); + } + + CreateToolTip(hWnd, IDCHKDEBUG, T("Creates a console window to display additional debugging information")); + DragAcceptFiles(hWnd, TRUE); + return TRUE; + case WM_COMMAND: + if (LOWORD(wParam) == IDBROWSE) { + OPENFILENAME ofn; + + // If user was typing in the edit box and pressed enter, just run the program + // instead of displaying the file selector (which is confusing and unintended) + if (GetFocus() == GetDlgItem(hWnd, IDFILEPATH)) { + PostMessage(hWnd, WM_COMMAND, IDOK, 0); + break; + } + + ZeroMemory(&ofn, sizeof(ofn)); + ofn.lStructSize = sizeof(ofn); + ofn.hwndOwner = hWnd; + ofn.lpstrFilter = T("Applications (*.exe)\0*.exe\0All Files (*.*)\0*.*\0"); + ofn.lpstrFile = szFilename + 1; + ofn.nMaxFile = MAX_PATH; + ofn.lpstrInitialDir = T("C:\\Program Files\\"); + ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY; + ofn.lpstrDefExt = T("exe"); + + if (GetOpenFileName(&ofn)) { + // Give the filename some quotes. + szFilename[0] = '\"'; + strcat_s(szFilename, ARRAYSIZE(szFilename), T("\"")); + SetDlgItemText(hWnd, IDFILEPATH, szFilename); + } + + break; + } else if (LOWORD(wParam) == IDOK) { + GetDlgItemText(hWnd, IDFILEPATH, szFilename, dwcbFilename); + bShouldShowDebugInfo = IsDlgButtonChecked(hWnd, IDCHKDEBUG); + + if (bShouldShowDebugInfo) { + AllocConsole(); + } + + EndDialog(hWnd, 0); + SpawnProgramUnderLoader(szFilename, TRUE, TRUE); + + // save dialog information in the registry + lStatus = RegCreateKeyEx( + HKEY_CURRENT_USER, + szUserSpecificConfigKey, + 0, NULL, 0, KEY_WRITE, NULL, + &hKeyUserSpecificConfig, NULL); + + if (lStatus == ERROR_SUCCESS) { + RegSetValueEx( + hKeyUserSpecificConfig, + T("LastCmdLine"), 0, REG_SZ, + (LPBYTE) szFilename, + (DWORD) strlen(szFilename) * sizeof(TCHAR)); + RegSetValueEx( + hKeyUserSpecificConfig, + T("ShowDebugInfo"), 0, REG_DWORD, + (LPBYTE) &bShouldShowDebugInfo, + sizeof(bShouldShowDebugInfo)); + RegCloseKey(hKeyUserSpecificConfig); + } + + Exit(0); + } else if (LOWORD(wParam) == IDCANCEL) { + EndDialog(hWnd, 0); + } else if (LOWORD(wParam) == IDFILEPATH) { + if (HIWORD(wParam) == EN_CHANGE) { + INT iTextLength = GetWindowTextLength(GetDlgItem(hWnd, IDFILEPATH)); + EnableWindow(GetDlgItem(hWnd, IDOK), !!iTextLength); + } + } + + break; + case WM_DROPFILES: + DragQueryFile((HDROP) wParam, 0, szFilename + 1, MAX_PATH); + strcpy_s(szFilename + strlen(szFilename), 2, T("\"")); + SetDlgItemText(hWnd, IDFILEPATH, szFilename); + DragFinish((HDROP) wParam); + break; + } + + return FALSE; +} + +#define FORCE_FLAG T("/FORCE ") + +INT APIENTRY tWinMain( + IN HINSTANCE hInstance, + IN HINSTANCE hPrevInstance, + IN LPTSTR lpszCmdLine, + IN INT iCmdShow) +{ + SetFriendlyAppName(FRIENDLYAPPNAME); + + if (strlen(lpszCmdLine) == 0) { + InitCommonControls(); + DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DlgProc); + } else { + CONST SIZE_T cchForceFlag = strlen(FORCE_FLAG); + BOOL bForce = FALSE; + + if (!strnicmp(lpszCmdLine, FORCE_FLAG, cchForceFlag)) { + // This flag is used to bypass the usual checking that we're "supposed" to launch + // the program with VxKex enabled. For example, the shell extended context menu entry + // will use this flag, to let the user try out VxKex without having to go into the + // property sheet and (possibly) accept the UAC dialog etc etc. + bForce = TRUE; + lpszCmdLine += cchForceFlag; + } + + SpawnProgramUnderLoader(lpszCmdLine, FALSE, bForce); + } + + Exit(0); +} \ No newline at end of file diff --git a/VxKexLdr/VxKexLdr.rc b/VxKexLdr/VxKexLdr.rc new file mode 100644 index 0000000000000000000000000000000000000000..0d58f8b1baf4d30808832436cc3471deea101826 GIT binary patch literal 2942 zcma);dutn45XI+T7xEpJEtnKy$5NcM4W*#R+7?kP5vj5Q1>uLP2ol@qk+`(|>TP~! z?ymMB$1aO>@7_Ci=FH5Qx%=P0-`m`-?b1Hl+OBMBk^N$4zIJ6d_QjUAZy)Sedt%?& zeX=9Fvp1Z(dr&U61u{!Cu9;mjm)6*|N^=dnBTMX^4Xk55JLUh>j+kk8hgrwE?3ZOC zEGIU$No9S4{HSuWhi2K(I6?QYvOl!<)<>IUj@X@8gZI8mHCaD)L;+0`EIn&sJ;H~9 zt?)@voN;naB&Wz;+aGuvBk@;iX~)Xv4(!kl>}P(5>>N~NcfirW&Toz>#@da2;+dj( zMI>W;MqIKdCYmdrTXtUCbDkMUR;;e=f>>Yr>F4&DJk5EoSYIQRXRpiJ0h-T|g6aZj9IB#DbkE@rdx@4q0JerY9nNyRmcU-2bsVa(&t9qW9n8 zzs~zTT>ZHv~ zOzlx4s^j9j{F1(BoB!f&jnikYXJ{ubQ{6owDjoEmZ0c26eUCL&YTIkM#a#8Q?h)DF zoAtLKYCEzcb{h89&*b|9v?gfk5=C{KVS4&3)vEd*VqJSdZ`kRx(x)!_j$IMyF$-~O zVW)UXb^8IH-@tqI)&>=N3)|*YWHATfbdKXEk46k;b*%w9R7a|$HvhAfDb>Ez^(c(_ z4}GC(UD=PYdmo0#p29=*@u~fQ)C$ZIj9L4cFCbPoiSXl3eyW^Lyvf@Rqt2D0t1CJaY$xdLpi%XaGb6W|-K>3b8LCiwb^1Wr^SX(X z#aPtsRS8GUUbsZ!_0u52Ln`Bhw-(;^ywU9{Ntu z6S}fu)O1~{#3aS@P)=TgF`%w*|-y|RDkG0XFo`OxxCq5HlG%CVzVO$uWKUVS%R zkk6Uly7~?fE5jGS!Z}>*wjl<^NNO(MWakZI;xRc+k#Fa}>T$74iia6%YgYC#(R?Qp7iLrgrHSy$hKYq}p4gEHEX5$%M&D=h<9 ys;?-q`Y|su4>iV|*ri9Qi)H?Vh&N!JZjf$@p^CNWQ_iNUR5=3=dnDZ9CjAOTUTrHFULL0O(+FDyZYK7

Ock(*e3)^niLI3>lC!s_TJWdP5&MnlEmF3p9o=BZ zXfsu)k*yd&1bR5&9D1(ns*>$!$R;Ly(V$eVpqiDG*`Ci9GwP=N8-H^a +#define DLLAPI __declspec(dllexport) +DECLARE_HANDLE(HSTRING); + +typedef LPVOID *PPVOID; + +typedef enum RO_INIT_TYPE { + RO_INIT_SINGLETHREADED, + RO_INIT_MULTITHREADED +} RO_INIT_TYPE; + +DLLAPI HRESULT RoGetActivationFactory( + IN HSTRING activatableClassId, + IN REFIID riid, + IN PPVOID factory) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT RoInitialize( + IN RO_INIT_TYPE initType) +{ + if (initType == RO_INIT_SINGLETHREADED) { + return CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); + } else { + return CoInitializeEx(NULL, COINIT_MULTITHREADED); + } +} + +DLLAPI VOID RoUninitialize( + VOID) +{ + CoUninitialize(); + return; +} + +DLLAPI HRESULT RoGetMatchingRestrictedErrorInfo( + HRESULT hrIn, + PPVOID ppRestrictedErrorInfo) +{ + return E_NOTIMPL; +} + +DLLAPI BOOL RoOriginateLanguageException( + HRESULT error, + HSTRING message, + LPVOID languageException) +{ + return TRUE; +} + +typedef struct HSTRING_HEADER { + union { + LPVOID Reserved1; + CHAR Reserved2[24]; + } Reserved; +} HSTRING_HEADER; + +DLLAPI HRESULT WindowsCreateString( + PCNZWCH sourceString, + UINT32 length, + HSTRING *string) +{ + return E_NOTIMPL; +} + +DLLAPI PCWSTR WindowsGetStringRawBuffer( + HSTRING string, + UINT32 *length) +{ + return L"Windows String"; +} + +DLLAPI HRESULT WindowsDeleteString( + HSTRING string) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT WindowsCreateStringReference( + PCWSTR sourceString, + UINT32 length, + HSTRING_HEADER *hstringHeader, + HSTRING *string) +{ + return E_NOTIMPL; +} + +DLLAPI BOOL WindowsIsStringEmpty( + IN HSTRING string) +{ + return TRUE; +} + +DLLAPI HRESULT WindowsStringHasEmbeddedNull( + IN HSTRING string, + OUT LPBOOL hasEmbedNull) +{ + *hasEmbedNull = FALSE; + return S_OK; +} + +DLLAPI HRESULT SetRestrictedErrorInfo( + PVOID pRestrictedErrorInfo) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT GetRestrictedErrorInfo( + PVOID pRestrictedErrorInfo) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT RoOriginateError( + IN HRESULT error, + IN HSTRING message) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT RoOriginateErrorW( + IN HRESULT error, + IN UINT cchMax, + IN PCWSTR message) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT RoRegisterActivationFactories( + IN HSTRING *activatableClassIds, + IN PPVOID *activationFactoryCallbacks, + IN UINT32 count, + OUT PPVOID cookie) +{ + return E_NOTIMPL; +} + +DLLAPI HRESULT RoRevokeActivationFactories( + IN LPVOID cookie) +{ + return E_NOTIMPL; +} \ No newline at end of file diff --git a/combase/combase.vcxproj b/combase/combase.vcxproj new file mode 100644 index 0000000..8213fbc --- /dev/null +++ b/combase/combase.vcxproj @@ -0,0 +1,147 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {49450E57-202A-45E9-8A62-FB849AEF0880} + Win32Proj + combase + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;COMBASE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;COMBASE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;COMBASE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;COMBASE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/combase/combase.vcxproj.filters b/combase/combase.vcxproj.filters new file mode 100644 index 0000000..713e652 --- /dev/null +++ b/combase/combase.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + \ No newline at end of file diff --git a/combase/combase.vcxproj.user b/combase/combase.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/combase/combase.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/dxg1/dxg1.c b/dxg1/dxg1.c new file mode 100644 index 0000000..6688d88 --- /dev/null +++ b/dxg1/dxg1.c @@ -0,0 +1,13 @@ +#include +#include +#define DLLAPI __declspec(dllexport) + +typedef LPVOID *PPVOID; + +DLLAPI HRESULT CreateDXGIFactory2( + IN UINT Flags, + IN REFIID riid, + OUT PPVOID ppFactory) +{ + return CreateDXGIFactory1(riid, ppFactory); +} \ No newline at end of file diff --git a/dxg1/dxg1.vcxproj b/dxg1/dxg1.vcxproj new file mode 100644 index 0000000..12cb048 --- /dev/null +++ b/dxg1/dxg1.vcxproj @@ -0,0 +1,152 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {167208CD-E59F-4709-9ADD-6880115C11D8} + Win32Proj + dxg1 + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;DXG1_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;DXG1_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;DXG1_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;DXG1_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies) + + + + + + + + + + \ No newline at end of file diff --git a/dxg1/dxg1.vcxproj.filters b/dxg1/dxg1.vcxproj.filters new file mode 100644 index 0000000..66858b7 --- /dev/null +++ b/dxg1/dxg1.vcxproj.filters @@ -0,0 +1,25 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/dxg1/dxg1.vcxproj.user b/dxg1/dxg1.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/dxg1/dxg1.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/dxg1/forwarders.c b/dxg1/forwarders.c new file mode 100644 index 0000000..1b3275c --- /dev/null +++ b/dxg1/forwarders.c @@ -0,0 +1,51 @@ +// Generated by KexExprt (32 bit) from C:\Windows\system32\dxgi.DLL +#pragma comment(linker, "/export:CheckETWTLS=dxgi.CheckETWTLS,@1") +#pragma comment(linker, "/export:CompatString=dxgi.CompatString,@2") +#pragma comment(linker, "/export:CompatValue=dxgi.CompatValue,@3") +#pragma comment(linker, "/export:CreateDXGIFactory=dxgi.CreateDXGIFactory,@20") +#pragma comment(linker, "/export:CreateDXGIFactory1=dxgi.CreateDXGIFactory1,@19") +#pragma comment(linker, "/export:D3DKMTCloseAdapter=dxgi.D3DKMTCloseAdapter,@4") +#pragma comment(linker, "/export:D3DKMTCreateAllocation=dxgi.D3DKMTCreateAllocation,@21") +#pragma comment(linker, "/export:D3DKMTCreateContext=dxgi.D3DKMTCreateContext,@22") +#pragma comment(linker, "/export:D3DKMTCreateDevice=dxgi.D3DKMTCreateDevice,@23") +#pragma comment(linker, "/export:D3DKMTCreateSynchronizationObject=dxgi.D3DKMTCreateSynchronizationObject,@24") +#pragma comment(linker, "/export:D3DKMTDestroyAllocation=dxgi.D3DKMTDestroyAllocation,@5") +#pragma comment(linker, "/export:D3DKMTDestroyContext=dxgi.D3DKMTDestroyContext,@6") +#pragma comment(linker, "/export:D3DKMTDestroyDevice=dxgi.D3DKMTDestroyDevice,@7") +#pragma comment(linker, "/export:D3DKMTDestroySynchronizationObject=dxgi.D3DKMTDestroySynchronizationObject,@8") +#pragma comment(linker, "/export:D3DKMTEscape=dxgi.D3DKMTEscape,@25") +#pragma comment(linker, "/export:D3DKMTGetContextSchedulingPriority=dxgi.D3DKMTGetContextSchedulingPriority,@26") +#pragma comment(linker, "/export:D3DKMTGetDeviceState=dxgi.D3DKMTGetDeviceState,@27") +#pragma comment(linker, "/export:D3DKMTGetDisplayModeList=dxgi.D3DKMTGetDisplayModeList,@28") +#pragma comment(linker, "/export:D3DKMTGetMultisampleMethodList=dxgi.D3DKMTGetMultisampleMethodList,@29") +#pragma comment(linker, "/export:D3DKMTGetRuntimeData=dxgi.D3DKMTGetRuntimeData,@30") +#pragma comment(linker, "/export:D3DKMTGetSharedPrimaryHandle=dxgi.D3DKMTGetSharedPrimaryHandle,@31") +#pragma comment(linker, "/export:D3DKMTLock=dxgi.D3DKMTLock,@32") +#pragma comment(linker, "/export:D3DKMTOpenAdapterFromHdc=dxgi.D3DKMTOpenAdapterFromHdc,@33") +#pragma comment(linker, "/export:D3DKMTOpenResource=dxgi.D3DKMTOpenResource,@34") +#pragma comment(linker, "/export:D3DKMTPresent=dxgi.D3DKMTPresent,@35") +#pragma comment(linker, "/export:D3DKMTQueryAdapterInfo=dxgi.D3DKMTQueryAdapterInfo,@9") +#pragma comment(linker, "/export:D3DKMTQueryAllocationResidency=dxgi.D3DKMTQueryAllocationResidency,@36") +#pragma comment(linker, "/export:D3DKMTQueryResourceInfo=dxgi.D3DKMTQueryResourceInfo,@37") +#pragma comment(linker, "/export:D3DKMTRender=dxgi.D3DKMTRender,@38") +#pragma comment(linker, "/export:D3DKMTSetAllocationPriority=dxgi.D3DKMTSetAllocationPriority,@39") +#pragma comment(linker, "/export:D3DKMTSetContextSchedulingPriority=dxgi.D3DKMTSetContextSchedulingPriority,@40") +#pragma comment(linker, "/export:D3DKMTSetDisplayMode=dxgi.D3DKMTSetDisplayMode,@41") +#pragma comment(linker, "/export:D3DKMTSetDisplayPrivateDriverFormat=dxgi.D3DKMTSetDisplayPrivateDriverFormat,@10") +#pragma comment(linker, "/export:D3DKMTSetGammaRamp=dxgi.D3DKMTSetGammaRamp,@42") +#pragma comment(linker, "/export:D3DKMTSetVidPnSourceOwner=dxgi.D3DKMTSetVidPnSourceOwner,@43") +#pragma comment(linker, "/export:D3DKMTSignalSynchronizationObject=dxgi.D3DKMTSignalSynchronizationObject,@11") +#pragma comment(linker, "/export:D3DKMTUnlock=dxgi.D3DKMTUnlock,@12") +#pragma comment(linker, "/export:D3DKMTWaitForSynchronizationObject=dxgi.D3DKMTWaitForSynchronizationObject,@13") +#pragma comment(linker, "/export:D3DKMTWaitForVerticalBlankEvent=dxgi.D3DKMTWaitForVerticalBlankEvent,@44") +#pragma comment(linker, "/export:DXGID3D10CreateDevice=dxgi.DXGID3D10CreateDevice,@45") +#pragma comment(linker, "/export:DXGID3D10CreateLayeredDevice=dxgi.DXGID3D10CreateLayeredDevice,@46") +#pragma comment(linker, "/export:DXGID3D10ETWRundown=dxgi.DXGID3D10ETWRundown,@47") +#pragma comment(linker, "/export:DXGID3D10GetLayeredDeviceSize=dxgi.DXGID3D10GetLayeredDeviceSize,@48") +#pragma comment(linker, "/export:DXGID3D10RegisterLayers=dxgi.DXGID3D10RegisterLayers,@49") +#pragma comment(linker, "/export:DXGIDumpJournal=dxgi.DXGIDumpJournal,@14") +#pragma comment(linker, "/export:DXGIReportAdapterConfiguration=dxgi.DXGIReportAdapterConfiguration,@50") +#pragma comment(linker, "/export:DXGIRevertToSxS=dxgi.DXGIRevertToSxS,@15") +#pragma comment(linker, "/export:OpenAdapter10=dxgi.OpenAdapter10,@16") +#pragma comment(linker, "/export:OpenAdapter10_2=dxgi.OpenAdapter10_2,@17") +#pragma comment(linker, "/export:SetAppCompatStringPointer=dxgi.SetAppCompatStringPointer,@18") \ No newline at end of file diff --git a/kernel33/forwarders.c b/kernel33/forwarders.c new file mode 100644 index 0000000..185d3f9 --- /dev/null +++ b/kernel33/forwarders.c @@ -0,0 +1,2766 @@ +#pragma comment(linker, "/export:LoadStringA=user33.LoadStringA") +#pragma comment(linker, "/export:LoadStringW=user33.LoadStringW") + +#ifdef _M_AMD64 +// Generated by KexExprt (64 bit) from C:\Windows\system32\kernel32.dll +#pragma comment(linker, "/export:AcquireSRWLockExclusive=kernel32.AcquireSRWLockExclusive,@1") +#pragma comment(linker, "/export:AcquireSRWLockShared=kernel32.AcquireSRWLockShared,@2") +#pragma comment(linker, "/export:ActivateActCtx=kernel32.ActivateActCtx,@3") +#pragma comment(linker, "/export:AddAtomA=kernel32.AddAtomA,@4") +#pragma comment(linker, "/export:AddAtomW=kernel32.AddAtomW,@5") +#pragma comment(linker, "/export:AddConsoleAliasA=kernel32.AddConsoleAliasA,@6") +#pragma comment(linker, "/export:AddConsoleAliasW=kernel32.AddConsoleAliasW,@7") +#pragma comment(linker, "/export:AddDllDirectory=kernel32.AddDllDirectory,@8") +#pragma comment(linker, "/export:AddIntegrityLabelToBoundaryDescriptor=kernel32.AddIntegrityLabelToBoundaryDescriptor,@9") +#pragma comment(linker, "/export:AddLocalAlternateComputerNameA=kernel32.AddLocalAlternateComputerNameA,@10") +#pragma comment(linker, "/export:AddLocalAlternateComputerNameW=kernel32.AddLocalAlternateComputerNameW,@11") +#pragma comment(linker, "/export:AddRefActCtx=kernel32.AddRefActCtx,@12") +#pragma comment(linker, "/export:AddSIDToBoundaryDescriptor=kernel32.AddSIDToBoundaryDescriptor,@13") +#pragma comment(linker, "/export:AddSecureMemoryCacheCallback=kernel32.AddSecureMemoryCacheCallback,@14") +#pragma comment(linker, "/export:AddVectoredContinueHandler=kernel32.AddVectoredContinueHandler,@15") +#pragma comment(linker, "/export:AddVectoredExceptionHandler=kernel32.AddVectoredExceptionHandler,@16") +#pragma comment(linker, "/export:AdjustCalendarDate=kernel32.AdjustCalendarDate,@17") +#pragma comment(linker, "/export:AllocConsole=kernel32.AllocConsole,@18") +#pragma comment(linker, "/export:AllocateUserPhysicalPages=kernel32.AllocateUserPhysicalPages,@19") +#pragma comment(linker, "/export:AllocateUserPhysicalPagesNuma=kernel32.AllocateUserPhysicalPagesNuma,@20") +#pragma comment(linker, "/export:ApplicationRecoveryFinished=kernel32.ApplicationRecoveryFinished,@21") +#pragma comment(linker, "/export:ApplicationRecoveryInProgress=kernel32.ApplicationRecoveryInProgress,@22") +#pragma comment(linker, "/export:AreFileApisANSI=kernel32.AreFileApisANSI,@23") +#pragma comment(linker, "/export:AssignProcessToJobObject=kernel32.AssignProcessToJobObject,@24") +#pragma comment(linker, "/export:AttachConsole=kernel32.AttachConsole,@25") +#pragma comment(linker, "/export:BackupRead=kernel32.BackupRead,@26") +#pragma comment(linker, "/export:BackupSeek=kernel32.BackupSeek,@27") +#pragma comment(linker, "/export:BackupWrite=kernel32.BackupWrite,@28") +#pragma comment(linker, "/export:BaseCheckAppcompatCache=kernel32.BaseCheckAppcompatCache,@29") +#pragma comment(linker, "/export:BaseCheckAppcompatCacheEx=kernel32.BaseCheckAppcompatCacheEx,@30") +#pragma comment(linker, "/export:BaseCheckRunApp=kernel32.BaseCheckRunApp,@31") +#pragma comment(linker, "/export:BaseCleanupAppcompatCacheSupport=kernel32.BaseCleanupAppcompatCacheSupport,@32") +#pragma comment(linker, "/export:BaseDllReadWriteIniFile=kernel32.BaseDllReadWriteIniFile,@33") +#pragma comment(linker, "/export:BaseDumpAppcompatCache=kernel32.BaseDumpAppcompatCache,@34") +#pragma comment(linker, "/export:BaseFlushAppcompatCache=kernel32.BaseFlushAppcompatCache,@35") +#pragma comment(linker, "/export:BaseFormatObjectAttributes=kernel32.BaseFormatObjectAttributes,@36") +#pragma comment(linker, "/export:BaseFormatTimeOut=kernel32.BaseFormatTimeOut,@37") +#pragma comment(linker, "/export:BaseGenerateAppCompatData=kernel32.BaseGenerateAppCompatData,@38") +#pragma comment(linker, "/export:BaseGetNamedObjectDirectory=kernel32.BaseGetNamedObjectDirectory,@39") +#pragma comment(linker, "/export:BaseInitAppcompatCacheSupport=kernel32.BaseInitAppcompatCacheSupport,@40") +#pragma comment(linker, "/export:BaseIsAppcompatInfrastructureDisabled=kernel32.BaseIsAppcompatInfrastructureDisabled,@41") +#pragma comment(linker, "/export:BaseQueryModuleData=kernel32.BaseQueryModuleData,@42") +#pragma comment(linker, "/export:BaseSetLastNTError=kernel32.BaseSetLastNTError,@43") +#pragma comment(linker, "/export:BaseThreadInitThunk=kernel32.BaseThreadInitThunk,@44") +#pragma comment(linker, "/export:BaseUpdateAppcompatCache=kernel32.BaseUpdateAppcompatCache,@45") +#pragma comment(linker, "/export:BaseVerifyUnicodeString=kernel32.BaseVerifyUnicodeString,@46") +#pragma comment(linker, "/export:Basep8BitStringToDynamicUnicodeString=kernel32.Basep8BitStringToDynamicUnicodeString,@47") +#pragma comment(linker, "/export:BasepAllocateActivationContextActivationBlock=kernel32.BasepAllocateActivationContextActivationBlock,@48") +#pragma comment(linker, "/export:BasepAnsiStringToDynamicUnicodeString=kernel32.BasepAnsiStringToDynamicUnicodeString,@49") +#pragma comment(linker, "/export:BasepCheckAppCompat=kernel32.BasepCheckAppCompat,@50") +#pragma comment(linker, "/export:BasepCheckBadapp=kernel32.BasepCheckBadapp,@51") +#pragma comment(linker, "/export:BasepCheckWinSaferRestrictions=kernel32.BasepCheckWinSaferRestrictions,@52") +#pragma comment(linker, "/export:BasepFreeActivationContextActivationBlock=kernel32.BasepFreeActivationContextActivationBlock,@53") +#pragma comment(linker, "/export:BasepFreeAppCompatData=kernel32.BasepFreeAppCompatData,@54") +#pragma comment(linker, "/export:BasepMapModuleHandle=kernel32.BasepMapModuleHandle,@55") +#pragma comment(linker, "/export:Beep=kernel32.Beep,@56") +#pragma comment(linker, "/export:BeginUpdateResourceA=kernel32.BeginUpdateResourceA,@57") +#pragma comment(linker, "/export:BeginUpdateResourceW=kernel32.BeginUpdateResourceW,@58") +#pragma comment(linker, "/export:BindIoCompletionCallback=kernel32.BindIoCompletionCallback,@59") +#pragma comment(linker, "/export:BuildCommDCBA=kernel32.BuildCommDCBA,@60") +#pragma comment(linker, "/export:BuildCommDCBAndTimeoutsA=kernel32.BuildCommDCBAndTimeoutsA,@61") +#pragma comment(linker, "/export:BuildCommDCBAndTimeoutsW=kernel32.BuildCommDCBAndTimeoutsW,@62") +#pragma comment(linker, "/export:BuildCommDCBW=kernel32.BuildCommDCBW,@63") +#pragma comment(linker, "/export:CallNamedPipeA=kernel32.CallNamedPipeA,@64") +#pragma comment(linker, "/export:CallNamedPipeW=kernel32.CallNamedPipeW,@65") +#pragma comment(linker, "/export:CallbackMayRunLong=kernel32.CallbackMayRunLong,@66") +#pragma comment(linker, "/export:CancelDeviceWakeupRequest=kernel32.CancelDeviceWakeupRequest,@67") +#pragma comment(linker, "/export:CancelIo=kernel32.CancelIo,@68") +#pragma comment(linker, "/export:CancelIoEx=kernel32.CancelIoEx,@69") +#pragma comment(linker, "/export:CancelSynchronousIo=kernel32.CancelSynchronousIo,@70") +#pragma comment(linker, "/export:CancelThreadpoolIo=kernel32.CancelThreadpoolIo,@71") +#pragma comment(linker, "/export:CancelTimerQueueTimer=kernel32.CancelTimerQueueTimer,@72") +#pragma comment(linker, "/export:CancelWaitableTimer=kernel32.CancelWaitableTimer,@73") +#pragma comment(linker, "/export:ChangeTimerQueueTimer=kernel32.ChangeTimerQueueTimer,@74") +#pragma comment(linker, "/export:CheckElevation=kernel32.CheckElevation,@75") +#pragma comment(linker, "/export:CheckElevationEnabled=kernel32.CheckElevationEnabled,@76") +#pragma comment(linker, "/export:CheckForReadOnlyResource=kernel32.CheckForReadOnlyResource,@77") +#pragma comment(linker, "/export:CheckNameLegalDOS8Dot3A=kernel32.CheckNameLegalDOS8Dot3A,@78") +#pragma comment(linker, "/export:CheckNameLegalDOS8Dot3W=kernel32.CheckNameLegalDOS8Dot3W,@79") +#pragma comment(linker, "/export:CheckRemoteDebuggerPresent=kernel32.CheckRemoteDebuggerPresent,@80") +#pragma comment(linker, "/export:ClearCommBreak=kernel32.ClearCommBreak,@81") +#pragma comment(linker, "/export:ClearCommError=kernel32.ClearCommError,@82") +#pragma comment(linker, "/export:CloseConsoleHandle=kernel32.CloseConsoleHandle,@83") +#pragma comment(linker, "/export:CloseHandle=kernel32.CloseHandle,@84") +#pragma comment(linker, "/export:ClosePrivateNamespace=kernel32.ClosePrivateNamespace,@85") +#pragma comment(linker, "/export:CloseProfileUserMapping=kernel32.CloseProfileUserMapping,@86") +#pragma comment(linker, "/export:CloseThreadpool=kernel32.CloseThreadpool,@87") +#pragma comment(linker, "/export:CloseThreadpoolCleanupGroup=kernel32.CloseThreadpoolCleanupGroup,@88") +#pragma comment(linker, "/export:CloseThreadpoolCleanupGroupMembers=kernel32.CloseThreadpoolCleanupGroupMembers,@89") +#pragma comment(linker, "/export:CloseThreadpoolIo=kernel32.CloseThreadpoolIo,@90") +#pragma comment(linker, "/export:CloseThreadpoolTimer=kernel32.CloseThreadpoolTimer,@91") +#pragma comment(linker, "/export:CloseThreadpoolWait=kernel32.CloseThreadpoolWait,@92") +#pragma comment(linker, "/export:CloseThreadpoolWork=kernel32.CloseThreadpoolWork,@93") +#pragma comment(linker, "/export:CmdBatNotification=kernel32.CmdBatNotification,@94") +#pragma comment(linker, "/export:CommConfigDialogA=kernel32.CommConfigDialogA,@95") +#pragma comment(linker, "/export:CommConfigDialogW=kernel32.CommConfigDialogW,@96") +#pragma comment(linker, "/export:CompareCalendarDates=kernel32.CompareCalendarDates,@97") +#pragma comment(linker, "/export:CompareFileTime=kernel32.CompareFileTime,@98") +#pragma comment(linker, "/export:CompareStringA=kernel32.CompareStringA,@99") +#pragma comment(linker, "/export:CompareStringEx=kernel32.CompareStringEx,@100") +#pragma comment(linker, "/export:CompareStringOrdinal=kernel32.CompareStringOrdinal,@101") +#pragma comment(linker, "/export:CompareStringW=kernel32.CompareStringW,@102") +#pragma comment(linker, "/export:ConnectNamedPipe=kernel32.ConnectNamedPipe,@103") +#pragma comment(linker, "/export:ConsoleMenuControl=kernel32.ConsoleMenuControl,@104") +#pragma comment(linker, "/export:ContinueDebugEvent=kernel32.ContinueDebugEvent,@105") +#pragma comment(linker, "/export:ConvertCalDateTimeToSystemTime=kernel32.ConvertCalDateTimeToSystemTime,@106") +#pragma comment(linker, "/export:ConvertDefaultLocale=kernel32.ConvertDefaultLocale,@107") +#pragma comment(linker, "/export:ConvertFiberToThread=kernel32.ConvertFiberToThread,@108") +#pragma comment(linker, "/export:ConvertNLSDayOfWeekToWin32DayOfWeek=kernel32.ConvertNLSDayOfWeekToWin32DayOfWeek,@109") +#pragma comment(linker, "/export:ConvertSystemTimeToCalDateTime=kernel32.ConvertSystemTimeToCalDateTime,@110") +#pragma comment(linker, "/export:ConvertThreadToFiber=kernel32.ConvertThreadToFiber,@111") +#pragma comment(linker, "/export:ConvertThreadToFiberEx=kernel32.ConvertThreadToFiberEx,@112") +#pragma comment(linker, "/export:CopyContext=kernel32.CopyContext,@113") +#pragma comment(linker, "/export:CopyFileA=kernel32.CopyFileA,@114") +#pragma comment(linker, "/export:CopyFileExA=kernel32.CopyFileExA,@115") +#pragma comment(linker, "/export:CopyFileExW=kernel32.CopyFileExW,@116") +#pragma comment(linker, "/export:CopyFileTransactedA=kernel32.CopyFileTransactedA,@117") +#pragma comment(linker, "/export:CopyFileTransactedW=kernel32.CopyFileTransactedW,@118") +#pragma comment(linker, "/export:CopyFileW=kernel32.CopyFileW,@119") +#pragma comment(linker, "/export:CopyLZFile=kernel32.CopyLZFile,@120") +#pragma comment(linker, "/export:CreateActCtxA=kernel32.CreateActCtxA,@121") +#pragma comment(linker, "/export:CreateActCtxW=kernel32.CreateActCtxW,@122") +#pragma comment(linker, "/export:CreateBoundaryDescriptorA=kernel32.CreateBoundaryDescriptorA,@123") +#pragma comment(linker, "/export:CreateBoundaryDescriptorW=kernel32.CreateBoundaryDescriptorW,@124") +#pragma comment(linker, "/export:CreateConsoleScreenBuffer=kernel32.CreateConsoleScreenBuffer,@125") +#pragma comment(linker, "/export:CreateDirectoryA=kernel32.CreateDirectoryA,@126") +#pragma comment(linker, "/export:CreateDirectoryExA=kernel32.CreateDirectoryExA,@127") +#pragma comment(linker, "/export:CreateDirectoryExW=kernel32.CreateDirectoryExW,@128") +#pragma comment(linker, "/export:CreateDirectoryTransactedA=kernel32.CreateDirectoryTransactedA,@129") +#pragma comment(linker, "/export:CreateDirectoryTransactedW=kernel32.CreateDirectoryTransactedW,@130") +#pragma comment(linker, "/export:CreateDirectoryW=kernel32.CreateDirectoryW,@131") +#pragma comment(linker, "/export:CreateEventA=kernel32.CreateEventA,@132") +#pragma comment(linker, "/export:CreateEventExA=kernel32.CreateEventExA,@133") +#pragma comment(linker, "/export:CreateEventExW=kernel32.CreateEventExW,@134") +#pragma comment(linker, "/export:CreateEventW=kernel32.CreateEventW,@135") +#pragma comment(linker, "/export:CreateFiber=kernel32.CreateFiber,@136") +#pragma comment(linker, "/export:CreateFiberEx=kernel32.CreateFiberEx,@137") +#pragma comment(linker, "/export:CreateFileA=kernel32.CreateFileA,@138") +#pragma comment(linker, "/export:CreateFileMappingA=kernel32.CreateFileMappingA,@139") +#pragma comment(linker, "/export:CreateFileMappingNumaA=kernel32.CreateFileMappingNumaA,@140") +#pragma comment(linker, "/export:CreateFileMappingNumaW=kernel32.CreateFileMappingNumaW,@141") +#pragma comment(linker, "/export:CreateFileMappingW=kernel32.CreateFileMappingW,@142") +#pragma comment(linker, "/export:CreateFileTransactedA=kernel32.CreateFileTransactedA,@143") +#pragma comment(linker, "/export:CreateFileTransactedW=kernel32.CreateFileTransactedW,@144") +#pragma comment(linker, "/export:CreateFileW=kernel32.CreateFileW,@145") +#pragma comment(linker, "/export:CreateHardLinkA=kernel32.CreateHardLinkA,@146") +#pragma comment(linker, "/export:CreateHardLinkTransactedA=kernel32.CreateHardLinkTransactedA,@147") +#pragma comment(linker, "/export:CreateHardLinkTransactedW=kernel32.CreateHardLinkTransactedW,@148") +#pragma comment(linker, "/export:CreateHardLinkW=kernel32.CreateHardLinkW,@149") +#pragma comment(linker, "/export:CreateIoCompletionPort=kernel32.CreateIoCompletionPort,@150") +#pragma comment(linker, "/export:CreateJobObjectA=kernel32.CreateJobObjectA,@151") +#pragma comment(linker, "/export:CreateJobObjectW=kernel32.CreateJobObjectW,@152") +#pragma comment(linker, "/export:CreateJobSet=kernel32.CreateJobSet,@153") +#pragma comment(linker, "/export:CreateMailslotA=kernel32.CreateMailslotA,@154") +#pragma comment(linker, "/export:CreateMailslotW=kernel32.CreateMailslotW,@155") +#pragma comment(linker, "/export:CreateMemoryResourceNotification=kernel32.CreateMemoryResourceNotification,@156") +#pragma comment(linker, "/export:CreateMutexA=kernel32.CreateMutexA,@157") +#pragma comment(linker, "/export:CreateMutexExA=kernel32.CreateMutexExA,@158") +#pragma comment(linker, "/export:CreateMutexExW=kernel32.CreateMutexExW,@159") +#pragma comment(linker, "/export:CreateMutexW=kernel32.CreateMutexW,@160") +#pragma comment(linker, "/export:CreateNamedPipeA=kernel32.CreateNamedPipeA,@161") +#pragma comment(linker, "/export:CreateNamedPipeW=kernel32.CreateNamedPipeW,@162") +#pragma comment(linker, "/export:CreatePipe=kernel32.CreatePipe,@163") +#pragma comment(linker, "/export:CreatePrivateNamespaceA=kernel32.CreatePrivateNamespaceA,@164") +#pragma comment(linker, "/export:CreatePrivateNamespaceW=kernel32.CreatePrivateNamespaceW,@165") +#pragma comment(linker, "/export:CreateProcessA=kernel32.CreateProcessA,@166") +#pragma comment(linker, "/export:CreateProcessAsUserW=kernel32.CreateProcessAsUserW,@167") +#pragma comment(linker, "/export:CreateProcessInternalA=kernel32.CreateProcessInternalA,@168") +#pragma comment(linker, "/export:CreateProcessInternalW=kernel32.CreateProcessInternalW,@169") +#pragma comment(linker, "/export:CreateProcessW=kernel32.CreateProcessW,@170") +#pragma comment(linker, "/export:CreateRemoteThread=kernel32.CreateRemoteThread,@171") +#pragma comment(linker, "/export:CreateRemoteThreadEx=kernel32.CreateRemoteThreadEx,@172") +#pragma comment(linker, "/export:CreateSemaphoreA=kernel32.CreateSemaphoreA,@173") +#pragma comment(linker, "/export:CreateSemaphoreExA=kernel32.CreateSemaphoreExA,@174") +#pragma comment(linker, "/export:CreateSemaphoreExW=kernel32.CreateSemaphoreExW,@175") +#pragma comment(linker, "/export:CreateSemaphoreW=kernel32.CreateSemaphoreW,@176") +#pragma comment(linker, "/export:CreateSymbolicLinkA=kernel32.CreateSymbolicLinkA,@177") +#pragma comment(linker, "/export:CreateSymbolicLinkTransactedA=kernel32.CreateSymbolicLinkTransactedA,@178") +#pragma comment(linker, "/export:CreateSymbolicLinkTransactedW=kernel32.CreateSymbolicLinkTransactedW,@179") +#pragma comment(linker, "/export:CreateSymbolicLinkW=kernel32.CreateSymbolicLinkW,@180") +#pragma comment(linker, "/export:CreateTapePartition=kernel32.CreateTapePartition,@181") +#pragma comment(linker, "/export:CreateThread=kernel32.CreateThread,@182") +#pragma comment(linker, "/export:CreateThreadpool=kernel32.CreateThreadpool,@183") +#pragma comment(linker, "/export:CreateThreadpoolCleanupGroup=kernel32.CreateThreadpoolCleanupGroup,@184") +#pragma comment(linker, "/export:CreateThreadpoolIo=kernel32.CreateThreadpoolIo,@185") +#pragma comment(linker, "/export:CreateThreadpoolTimer=kernel32.CreateThreadpoolTimer,@186") +#pragma comment(linker, "/export:CreateThreadpoolWait=kernel32.CreateThreadpoolWait,@187") +#pragma comment(linker, "/export:CreateThreadpoolWork=kernel32.CreateThreadpoolWork,@188") +#pragma comment(linker, "/export:CreateTimerQueue=kernel32.CreateTimerQueue,@189") +#pragma comment(linker, "/export:CreateTimerQueueTimer=kernel32.CreateTimerQueueTimer,@190") +#pragma comment(linker, "/export:CreateToolhelp32Snapshot=kernel32.CreateToolhelp32Snapshot,@191") +#pragma comment(linker, "/export:CreateUmsCompletionList=kernel32.CreateUmsCompletionList,@192") +#pragma comment(linker, "/export:CreateUmsThreadContext=kernel32.CreateUmsThreadContext,@193") +#pragma comment(linker, "/export:CreateWaitableTimerA=kernel32.CreateWaitableTimerA,@194") +#pragma comment(linker, "/export:CreateWaitableTimerExA=kernel32.CreateWaitableTimerExA,@195") +#pragma comment(linker, "/export:CreateWaitableTimerExW=kernel32.CreateWaitableTimerExW,@196") +#pragma comment(linker, "/export:CreateWaitableTimerW=kernel32.CreateWaitableTimerW,@197") +#pragma comment(linker, "/export:CtrlRoutine=kernel32.CtrlRoutine,@198") +#pragma comment(linker, "/export:DeactivateActCtx=kernel32.DeactivateActCtx,@199") +#pragma comment(linker, "/export:DebugActiveProcess=kernel32.DebugActiveProcess,@200") +#pragma comment(linker, "/export:DebugActiveProcessStop=kernel32.DebugActiveProcessStop,@201") +#pragma comment(linker, "/export:DebugBreak=kernel32.DebugBreak,@202") +#pragma comment(linker, "/export:DebugBreakProcess=kernel32.DebugBreakProcess,@203") +#pragma comment(linker, "/export:DebugSetProcessKillOnExit=kernel32.DebugSetProcessKillOnExit,@204") +#pragma comment(linker, "/export:DecodePointer=kernel32.DecodePointer,@205") +#pragma comment(linker, "/export:DecodeSystemPointer=kernel32.DecodeSystemPointer,@206") +#pragma comment(linker, "/export:DefineDosDeviceA=kernel32.DefineDosDeviceA,@207") +#pragma comment(linker, "/export:DefineDosDeviceW=kernel32.DefineDosDeviceW,@208") +#pragma comment(linker, "/export:DelayLoadFailureHook=kernel32.DelayLoadFailureHook,@209") +#pragma comment(linker, "/export:DeleteAtom=kernel32.DeleteAtom,@210") +#pragma comment(linker, "/export:DeleteBoundaryDescriptor=kernel32.DeleteBoundaryDescriptor,@211") +#pragma comment(linker, "/export:DeleteCriticalSection=kernel32.DeleteCriticalSection,@212") +#pragma comment(linker, "/export:DeleteFiber=kernel32.DeleteFiber,@213") +#pragma comment(linker, "/export:DeleteFileA=kernel32.DeleteFileA,@214") +#pragma comment(linker, "/export:DeleteFileTransactedA=kernel32.DeleteFileTransactedA,@215") +#pragma comment(linker, "/export:DeleteFileTransactedW=kernel32.DeleteFileTransactedW,@216") +#pragma comment(linker, "/export:DeleteFileW=kernel32.DeleteFileW,@217") +#pragma comment(linker, "/export:DeleteProcThreadAttributeList=kernel32.DeleteProcThreadAttributeList,@218") +#pragma comment(linker, "/export:DeleteTimerQueue=kernel32.DeleteTimerQueue,@219") +#pragma comment(linker, "/export:DeleteTimerQueueEx=kernel32.DeleteTimerQueueEx,@220") +#pragma comment(linker, "/export:DeleteTimerQueueTimer=kernel32.DeleteTimerQueueTimer,@221") +#pragma comment(linker, "/export:DeleteUmsCompletionList=kernel32.DeleteUmsCompletionList,@222") +#pragma comment(linker, "/export:DeleteUmsThreadContext=kernel32.DeleteUmsThreadContext,@223") +#pragma comment(linker, "/export:DeleteVolumeMountPointA=kernel32.DeleteVolumeMountPointA,@224") +#pragma comment(linker, "/export:DeleteVolumeMountPointW=kernel32.DeleteVolumeMountPointW,@225") +#pragma comment(linker, "/export:DequeueUmsCompletionListItems=kernel32.DequeueUmsCompletionListItems,@226") +#pragma comment(linker, "/export:DeviceIoControl=kernel32.DeviceIoControl,@227") +#pragma comment(linker, "/export:DisableThreadLibraryCalls=kernel32.DisableThreadLibraryCalls,@228") +#pragma comment(linker, "/export:DisableThreadProfiling=kernel32.DisableThreadProfiling,@229") +#pragma comment(linker, "/export:DisassociateCurrentThreadFromCallback=kernel32.DisassociateCurrentThreadFromCallback,@230") +#pragma comment(linker, "/export:DisconnectNamedPipe=kernel32.DisconnectNamedPipe,@231") +#pragma comment(linker, "/export:DnsHostnameToComputerNameA=kernel32.DnsHostnameToComputerNameA,@232") +#pragma comment(linker, "/export:DnsHostnameToComputerNameW=kernel32.DnsHostnameToComputerNameW,@233") +#pragma comment(linker, "/export:DosDateTimeToFileTime=kernel32.DosDateTimeToFileTime,@234") +#pragma comment(linker, "/export:DosPathToSessionPathA=kernel32.DosPathToSessionPathA,@235") +#pragma comment(linker, "/export:DosPathToSessionPathW=kernel32.DosPathToSessionPathW,@236") +#pragma comment(linker, "/export:DuplicateConsoleHandle=kernel32.DuplicateConsoleHandle,@237") +#pragma comment(linker, "/export:DuplicateHandle=kernel32.DuplicateHandle,@238") +#pragma comment(linker, "/export:EnableThreadProfiling=kernel32.EnableThreadProfiling,@239") +#pragma comment(linker, "/export:EncodePointer=kernel32.EncodePointer,@240") +#pragma comment(linker, "/export:EncodeSystemPointer=kernel32.EncodeSystemPointer,@241") +#pragma comment(linker, "/export:EndUpdateResourceA=kernel32.EndUpdateResourceA,@242") +#pragma comment(linker, "/export:EndUpdateResourceW=kernel32.EndUpdateResourceW,@243") +#pragma comment(linker, "/export:EnterCriticalSection=kernel32.EnterCriticalSection,@244") +#pragma comment(linker, "/export:EnterUmsSchedulingMode=kernel32.EnterUmsSchedulingMode,@245") +#pragma comment(linker, "/export:EnumCalendarInfoA=kernel32.EnumCalendarInfoA,@246") +#pragma comment(linker, "/export:EnumCalendarInfoExA=kernel32.EnumCalendarInfoExA,@247") +#pragma comment(linker, "/export:EnumCalendarInfoExEx=kernel32.EnumCalendarInfoExEx,@248") +#pragma comment(linker, "/export:EnumCalendarInfoExW=kernel32.EnumCalendarInfoExW,@249") +#pragma comment(linker, "/export:EnumCalendarInfoW=kernel32.EnumCalendarInfoW,@250") +#pragma comment(linker, "/export:EnumDateFormatsA=kernel32.EnumDateFormatsA,@251") +#pragma comment(linker, "/export:EnumDateFormatsExA=kernel32.EnumDateFormatsExA,@252") +#pragma comment(linker, "/export:EnumDateFormatsExEx=kernel32.EnumDateFormatsExEx,@253") +#pragma comment(linker, "/export:EnumDateFormatsExW=kernel32.EnumDateFormatsExW,@254") +#pragma comment(linker, "/export:EnumDateFormatsW=kernel32.EnumDateFormatsW,@255") +#pragma comment(linker, "/export:EnumLanguageGroupLocalesA=kernel32.EnumLanguageGroupLocalesA,@256") +#pragma comment(linker, "/export:EnumLanguageGroupLocalesW=kernel32.EnumLanguageGroupLocalesW,@257") +#pragma comment(linker, "/export:EnumResourceLanguagesA=kernel32.EnumResourceLanguagesA,@258") +#pragma comment(linker, "/export:EnumResourceLanguagesExA=kernel32.EnumResourceLanguagesExA,@259") +#pragma comment(linker, "/export:EnumResourceLanguagesExW=kernel32.EnumResourceLanguagesExW,@260") +#pragma comment(linker, "/export:EnumResourceLanguagesW=kernel32.EnumResourceLanguagesW,@261") +#pragma comment(linker, "/export:EnumResourceNamesA=kernel32.EnumResourceNamesA,@262") +#pragma comment(linker, "/export:EnumResourceNamesExA=kernel32.EnumResourceNamesExA,@263") +#pragma comment(linker, "/export:EnumResourceNamesExW=kernel32.EnumResourceNamesExW,@264") +#pragma comment(linker, "/export:EnumResourceNamesW=kernel32.EnumResourceNamesW,@265") +#pragma comment(linker, "/export:EnumResourceTypesA=kernel32.EnumResourceTypesA,@266") +#pragma comment(linker, "/export:EnumResourceTypesExA=kernel32.EnumResourceTypesExA,@267") +#pragma comment(linker, "/export:EnumResourceTypesExW=kernel32.EnumResourceTypesExW,@268") +#pragma comment(linker, "/export:EnumResourceTypesW=kernel32.EnumResourceTypesW,@269") +#pragma comment(linker, "/export:EnumSystemCodePagesA=kernel32.EnumSystemCodePagesA,@270") +#pragma comment(linker, "/export:EnumSystemCodePagesW=kernel32.EnumSystemCodePagesW,@271") +#pragma comment(linker, "/export:EnumSystemFirmwareTables=kernel32.EnumSystemFirmwareTables,@272") +#pragma comment(linker, "/export:EnumSystemGeoID=kernel32.EnumSystemGeoID,@273") +#pragma comment(linker, "/export:EnumSystemLanguageGroupsA=kernel32.EnumSystemLanguageGroupsA,@274") +#pragma comment(linker, "/export:EnumSystemLanguageGroupsW=kernel32.EnumSystemLanguageGroupsW,@275") +#pragma comment(linker, "/export:EnumSystemLocalesA=kernel32.EnumSystemLocalesA,@276") +#pragma comment(linker, "/export:EnumSystemLocalesEx=kernel32.EnumSystemLocalesEx,@277") +#pragma comment(linker, "/export:EnumSystemLocalesW=kernel32.EnumSystemLocalesW,@278") +#pragma comment(linker, "/export:EnumTimeFormatsA=kernel32.EnumTimeFormatsA,@279") +#pragma comment(linker, "/export:EnumTimeFormatsEx=kernel32.EnumTimeFormatsEx,@280") +#pragma comment(linker, "/export:EnumTimeFormatsW=kernel32.EnumTimeFormatsW,@281") +#pragma comment(linker, "/export:EnumUILanguagesA=kernel32.EnumUILanguagesA,@282") +#pragma comment(linker, "/export:EnumUILanguagesW=kernel32.EnumUILanguagesW,@283") +#pragma comment(linker, "/export:EnumerateLocalComputerNamesA=kernel32.EnumerateLocalComputerNamesA,@284") +#pragma comment(linker, "/export:EnumerateLocalComputerNamesW=kernel32.EnumerateLocalComputerNamesW,@285") +#pragma comment(linker, "/export:EraseTape=kernel32.EraseTape,@286") +#pragma comment(linker, "/export:EscapeCommFunction=kernel32.EscapeCommFunction,@287") +#pragma comment(linker, "/export:ExecuteUmsThread=kernel32.ExecuteUmsThread,@288") +#pragma comment(linker, "/export:ExitProcess=kernel32.ExitProcess,@289") +#pragma comment(linker, "/export:ExitThread=kernel32.ExitThread,@290") +#pragma comment(linker, "/export:ExitVDM=kernel32.ExitVDM,@291") +#pragma comment(linker, "/export:ExpandEnvironmentStringsA=kernel32.ExpandEnvironmentStringsA,@292") +#pragma comment(linker, "/export:ExpandEnvironmentStringsW=kernel32.ExpandEnvironmentStringsW,@293") +#pragma comment(linker, "/export:ExpungeConsoleCommandHistoryA=kernel32.ExpungeConsoleCommandHistoryA,@294") +#pragma comment(linker, "/export:ExpungeConsoleCommandHistoryW=kernel32.ExpungeConsoleCommandHistoryW,@295") +#pragma comment(linker, "/export:FatalAppExitA=kernel32.FatalAppExitA,@296") +#pragma comment(linker, "/export:FatalAppExitW=kernel32.FatalAppExitW,@297") +#pragma comment(linker, "/export:FatalExit=kernel32.FatalExit,@298") +#pragma comment(linker, "/export:FileTimeToDosDateTime=kernel32.FileTimeToDosDateTime,@299") +#pragma comment(linker, "/export:FileTimeToLocalFileTime=kernel32.FileTimeToLocalFileTime,@300") +#pragma comment(linker, "/export:FileTimeToSystemTime=kernel32.FileTimeToSystemTime,@301") +#pragma comment(linker, "/export:FillConsoleOutputAttribute=kernel32.FillConsoleOutputAttribute,@302") +#pragma comment(linker, "/export:FillConsoleOutputCharacterA=kernel32.FillConsoleOutputCharacterA,@303") +#pragma comment(linker, "/export:FillConsoleOutputCharacterW=kernel32.FillConsoleOutputCharacterW,@304") +#pragma comment(linker, "/export:FindActCtxSectionGuid=kernel32.FindActCtxSectionGuid,@305") +#pragma comment(linker, "/export:FindActCtxSectionStringA=kernel32.FindActCtxSectionStringA,@306") +#pragma comment(linker, "/export:FindActCtxSectionStringW=kernel32.FindActCtxSectionStringW,@307") +#pragma comment(linker, "/export:FindAtomA=kernel32.FindAtomA,@308") +#pragma comment(linker, "/export:FindAtomW=kernel32.FindAtomW,@309") +#pragma comment(linker, "/export:FindClose=kernel32.FindClose,@310") +#pragma comment(linker, "/export:FindCloseChangeNotification=kernel32.FindCloseChangeNotification,@311") +#pragma comment(linker, "/export:FindFirstChangeNotificationA=kernel32.FindFirstChangeNotificationA,@312") +#pragma comment(linker, "/export:FindFirstChangeNotificationW=kernel32.FindFirstChangeNotificationW,@313") +#pragma comment(linker, "/export:FindFirstFileA=kernel32.FindFirstFileA,@314") +#pragma comment(linker, "/export:FindFirstFileExA=kernel32.FindFirstFileExA,@315") +#pragma comment(linker, "/export:FindFirstFileExW=kernel32.FindFirstFileExW,@316") +#pragma comment(linker, "/export:FindFirstFileNameTransactedW=kernel32.FindFirstFileNameTransactedW,@317") +#pragma comment(linker, "/export:FindFirstFileNameW=kernel32.FindFirstFileNameW,@318") +#pragma comment(linker, "/export:FindFirstFileTransactedA=kernel32.FindFirstFileTransactedA,@319") +#pragma comment(linker, "/export:FindFirstFileTransactedW=kernel32.FindFirstFileTransactedW,@320") +#pragma comment(linker, "/export:FindFirstFileW=kernel32.FindFirstFileW,@321") +#pragma comment(linker, "/export:FindFirstStreamTransactedW=kernel32.FindFirstStreamTransactedW,@322") +#pragma comment(linker, "/export:FindFirstStreamW=kernel32.FindFirstStreamW,@323") +#pragma comment(linker, "/export:FindFirstVolumeA=kernel32.FindFirstVolumeA,@324") +#pragma comment(linker, "/export:FindFirstVolumeMountPointA=kernel32.FindFirstVolumeMountPointA,@325") +#pragma comment(linker, "/export:FindFirstVolumeMountPointW=kernel32.FindFirstVolumeMountPointW,@326") +#pragma comment(linker, "/export:FindFirstVolumeW=kernel32.FindFirstVolumeW,@327") +#pragma comment(linker, "/export:FindNLSString=kernel32.FindNLSString,@328") +#pragma comment(linker, "/export:FindNLSStringEx=kernel32.FindNLSStringEx,@329") +#pragma comment(linker, "/export:FindNextChangeNotification=kernel32.FindNextChangeNotification,@330") +#pragma comment(linker, "/export:FindNextFileA=kernel32.FindNextFileA,@331") +#pragma comment(linker, "/export:FindNextFileNameW=kernel32.FindNextFileNameW,@332") +#pragma comment(linker, "/export:FindNextFileW=kernel32.FindNextFileW,@333") +#pragma comment(linker, "/export:FindNextStreamW=kernel32.FindNextStreamW,@334") +#pragma comment(linker, "/export:FindNextVolumeA=kernel32.FindNextVolumeA,@335") +#pragma comment(linker, "/export:FindNextVolumeMountPointA=kernel32.FindNextVolumeMountPointA,@336") +#pragma comment(linker, "/export:FindNextVolumeMountPointW=kernel32.FindNextVolumeMountPointW,@337") +#pragma comment(linker, "/export:FindNextVolumeW=kernel32.FindNextVolumeW,@338") +#pragma comment(linker, "/export:FindResourceA=kernel32.FindResourceA,@339") +#pragma comment(linker, "/export:FindResourceExA=kernel32.FindResourceExA,@340") +#pragma comment(linker, "/export:FindResourceExW=kernel32.FindResourceExW,@341") +#pragma comment(linker, "/export:FindResourceW=kernel32.FindResourceW,@342") +#pragma comment(linker, "/export:FindStringOrdinal=kernel32.FindStringOrdinal,@343") +#pragma comment(linker, "/export:FindVolumeClose=kernel32.FindVolumeClose,@344") +#pragma comment(linker, "/export:FindVolumeMountPointClose=kernel32.FindVolumeMountPointClose,@345") +#pragma comment(linker, "/export:FlsAlloc=kernel32.FlsAlloc,@346") +#pragma comment(linker, "/export:FlsFree=kernel32.FlsFree,@347") +#pragma comment(linker, "/export:FlsGetValue=kernel32.FlsGetValue,@348") +#pragma comment(linker, "/export:FlsSetValue=kernel32.FlsSetValue,@349") +#pragma comment(linker, "/export:FlushConsoleInputBuffer=kernel32.FlushConsoleInputBuffer,@350") +#pragma comment(linker, "/export:FlushFileBuffers=kernel32.FlushFileBuffers,@351") +#pragma comment(linker, "/export:FlushInstructionCache=kernel32.FlushInstructionCache,@352") +#pragma comment(linker, "/export:FlushProcessWriteBuffers=kernel32.FlushProcessWriteBuffers,@353") +#pragma comment(linker, "/export:FlushViewOfFile=kernel32.FlushViewOfFile,@354") +#pragma comment(linker, "/export:FoldStringA=kernel32.FoldStringA,@355") +#pragma comment(linker, "/export:FoldStringW=kernel32.FoldStringW,@356") +#pragma comment(linker, "/export:FormatMessageA=kernel32.FormatMessageA,@357") +#pragma comment(linker, "/export:FormatMessageW=kernel32.FormatMessageW,@358") +#pragma comment(linker, "/export:FreeConsole=kernel32.FreeConsole,@359") +#pragma comment(linker, "/export:FreeEnvironmentStringsA=kernel32.FreeEnvironmentStringsA,@360") +#pragma comment(linker, "/export:FreeEnvironmentStringsW=kernel32.FreeEnvironmentStringsW,@361") +#pragma comment(linker, "/export:FreeLibrary=kernel32.FreeLibrary,@362") +#pragma comment(linker, "/export:FreeLibraryAndExitThread=kernel32.FreeLibraryAndExitThread,@363") +#pragma comment(linker, "/export:FreeLibraryWhenCallbackReturns=kernel32.FreeLibraryWhenCallbackReturns,@364") +#pragma comment(linker, "/export:FreeResource=kernel32.FreeResource,@365") +#pragma comment(linker, "/export:FreeUserPhysicalPages=kernel32.FreeUserPhysicalPages,@366") +#pragma comment(linker, "/export:GenerateConsoleCtrlEvent=kernel32.GenerateConsoleCtrlEvent,@367") +#pragma comment(linker, "/export:GetACP=kernel32.GetACP,@368") +#pragma comment(linker, "/export:GetActiveProcessorCount=kernel32.GetActiveProcessorCount,@369") +#pragma comment(linker, "/export:GetActiveProcessorGroupCount=kernel32.GetActiveProcessorGroupCount,@370") +#pragma comment(linker, "/export:GetApplicationRecoveryCallback=kernel32.GetApplicationRecoveryCallback,@371") +#pragma comment(linker, "/export:GetApplicationRestartSettings=kernel32.GetApplicationRestartSettings,@372") +#pragma comment(linker, "/export:GetAtomNameA=kernel32.GetAtomNameA,@373") +#pragma comment(linker, "/export:GetAtomNameW=kernel32.GetAtomNameW,@374") +#pragma comment(linker, "/export:GetBinaryType=kernel32.GetBinaryType,@375") +#pragma comment(linker, "/export:GetBinaryTypeA=kernel32.GetBinaryTypeA,@376") +#pragma comment(linker, "/export:GetBinaryTypeW=kernel32.GetBinaryTypeW,@377") +#pragma comment(linker, "/export:GetCPInfo=kernel32.GetCPInfo,@378") +#pragma comment(linker, "/export:GetCPInfoExA=kernel32.GetCPInfoExA,@379") +#pragma comment(linker, "/export:GetCPInfoExW=kernel32.GetCPInfoExW,@380") +#pragma comment(linker, "/export:GetCalendarDateFormat=kernel32.GetCalendarDateFormat,@381") +#pragma comment(linker, "/export:GetCalendarDateFormatEx=kernel32.GetCalendarDateFormatEx,@382") +#pragma comment(linker, "/export:GetCalendarDaysInMonth=kernel32.GetCalendarDaysInMonth,@383") +#pragma comment(linker, "/export:GetCalendarDifferenceInDays=kernel32.GetCalendarDifferenceInDays,@384") +#pragma comment(linker, "/export:GetCalendarInfoA=kernel32.GetCalendarInfoA,@385") +#pragma comment(linker, "/export:GetCalendarInfoEx=kernel32.GetCalendarInfoEx,@386") +#pragma comment(linker, "/export:GetCalendarInfoW=kernel32.GetCalendarInfoW,@387") +#pragma comment(linker, "/export:GetCalendarMonthsInYear=kernel32.GetCalendarMonthsInYear,@388") +#pragma comment(linker, "/export:GetCalendarSupportedDateRange=kernel32.GetCalendarSupportedDateRange,@389") +#pragma comment(linker, "/export:GetCalendarWeekNumber=kernel32.GetCalendarWeekNumber,@390") +#pragma comment(linker, "/export:GetComPlusPackageInstallStatus=kernel32.GetComPlusPackageInstallStatus,@391") +#pragma comment(linker, "/export:GetCommConfig=kernel32.GetCommConfig,@392") +#pragma comment(linker, "/export:GetCommMask=kernel32.GetCommMask,@393") +#pragma comment(linker, "/export:GetCommModemStatus=kernel32.GetCommModemStatus,@394") +#pragma comment(linker, "/export:GetCommProperties=kernel32.GetCommProperties,@395") +#pragma comment(linker, "/export:GetCommState=kernel32.GetCommState,@396") +#pragma comment(linker, "/export:GetCommTimeouts=kernel32.GetCommTimeouts,@397") +#pragma comment(linker, "/export:GetCommandLineA=kernel32.GetCommandLineA,@398") +#pragma comment(linker, "/export:GetCommandLineW=kernel32.GetCommandLineW,@399") +#pragma comment(linker, "/export:GetCompressedFileSizeA=kernel32.GetCompressedFileSizeA,@400") +#pragma comment(linker, "/export:GetCompressedFileSizeTransactedA=kernel32.GetCompressedFileSizeTransactedA,@401") +#pragma comment(linker, "/export:GetCompressedFileSizeTransactedW=kernel32.GetCompressedFileSizeTransactedW,@402") +#pragma comment(linker, "/export:GetCompressedFileSizeW=kernel32.GetCompressedFileSizeW,@403") +#pragma comment(linker, "/export:GetComputerNameA=kernel32.GetComputerNameA,@404") +#pragma comment(linker, "/export:GetComputerNameExA=kernel32.GetComputerNameExA,@405") +#pragma comment(linker, "/export:GetComputerNameExW=kernel32.GetComputerNameExW,@406") +#pragma comment(linker, "/export:GetComputerNameW=kernel32.GetComputerNameW,@407") +#pragma comment(linker, "/export:GetConsoleAliasA=kernel32.GetConsoleAliasA,@408") +#pragma comment(linker, "/export:GetConsoleAliasExesA=kernel32.GetConsoleAliasExesA,@409") +#pragma comment(linker, "/export:GetConsoleAliasExesLengthA=kernel32.GetConsoleAliasExesLengthA,@410") +#pragma comment(linker, "/export:GetConsoleAliasExesLengthW=kernel32.GetConsoleAliasExesLengthW,@411") +#pragma comment(linker, "/export:GetConsoleAliasExesW=kernel32.GetConsoleAliasExesW,@412") +#pragma comment(linker, "/export:GetConsoleAliasW=kernel32.GetConsoleAliasW,@413") +#pragma comment(linker, "/export:GetConsoleAliasesA=kernel32.GetConsoleAliasesA,@414") +#pragma comment(linker, "/export:GetConsoleAliasesLengthA=kernel32.GetConsoleAliasesLengthA,@415") +#pragma comment(linker, "/export:GetConsoleAliasesLengthW=kernel32.GetConsoleAliasesLengthW,@416") +#pragma comment(linker, "/export:GetConsoleAliasesW=kernel32.GetConsoleAliasesW,@417") +#pragma comment(linker, "/export:GetConsoleCP=kernel32.GetConsoleCP,@418") +#pragma comment(linker, "/export:GetConsoleCharType=kernel32.GetConsoleCharType,@419") +#pragma comment(linker, "/export:GetConsoleCommandHistoryA=kernel32.GetConsoleCommandHistoryA,@420") +#pragma comment(linker, "/export:GetConsoleCommandHistoryLengthA=kernel32.GetConsoleCommandHistoryLengthA,@421") +#pragma comment(linker, "/export:GetConsoleCommandHistoryLengthW=kernel32.GetConsoleCommandHistoryLengthW,@422") +#pragma comment(linker, "/export:GetConsoleCommandHistoryW=kernel32.GetConsoleCommandHistoryW,@423") +#pragma comment(linker, "/export:GetConsoleCursorInfo=kernel32.GetConsoleCursorInfo,@424") +#pragma comment(linker, "/export:GetConsoleCursorMode=kernel32.GetConsoleCursorMode,@425") +#pragma comment(linker, "/export:GetConsoleDisplayMode=kernel32.GetConsoleDisplayMode,@426") +#pragma comment(linker, "/export:GetConsoleFontInfo=kernel32.GetConsoleFontInfo,@427") +#pragma comment(linker, "/export:GetConsoleFontSize=kernel32.GetConsoleFontSize,@428") +#pragma comment(linker, "/export:GetConsoleHardwareState=kernel32.GetConsoleHardwareState,@429") +#pragma comment(linker, "/export:GetConsoleHistoryInfo=kernel32.GetConsoleHistoryInfo,@430") +#pragma comment(linker, "/export:GetConsoleInputExeNameA=kernel32.GetConsoleInputExeNameA,@431") +#pragma comment(linker, "/export:GetConsoleInputExeNameW=kernel32.GetConsoleInputExeNameW,@432") +#pragma comment(linker, "/export:GetConsoleInputWaitHandle=kernel32.GetConsoleInputWaitHandle,@433") +#pragma comment(linker, "/export:GetConsoleKeyboardLayoutNameA=kernel32.GetConsoleKeyboardLayoutNameA,@434") +#pragma comment(linker, "/export:GetConsoleKeyboardLayoutNameW=kernel32.GetConsoleKeyboardLayoutNameW,@435") +#pragma comment(linker, "/export:GetConsoleMode=kernel32.GetConsoleMode,@436") +#pragma comment(linker, "/export:GetConsoleNlsMode=kernel32.GetConsoleNlsMode,@437") +#pragma comment(linker, "/export:GetConsoleOriginalTitleA=kernel32.GetConsoleOriginalTitleA,@438") +#pragma comment(linker, "/export:GetConsoleOriginalTitleW=kernel32.GetConsoleOriginalTitleW,@439") +#pragma comment(linker, "/export:GetConsoleOutputCP=kernel32.GetConsoleOutputCP,@440") +#pragma comment(linker, "/export:GetConsoleProcessList=kernel32.GetConsoleProcessList,@441") +#pragma comment(linker, "/export:GetConsoleScreenBufferInfo=kernel32.GetConsoleScreenBufferInfo,@442") +#pragma comment(linker, "/export:GetConsoleScreenBufferInfoEx=kernel32.GetConsoleScreenBufferInfoEx,@443") +#pragma comment(linker, "/export:GetConsoleSelectionInfo=kernel32.GetConsoleSelectionInfo,@444") +#pragma comment(linker, "/export:GetConsoleTitleA=kernel32.GetConsoleTitleA,@445") +#pragma comment(linker, "/export:GetConsoleTitleW=kernel32.GetConsoleTitleW,@446") +#pragma comment(linker, "/export:GetConsoleWindow=kernel32.GetConsoleWindow,@447") +#pragma comment(linker, "/export:GetCurrencyFormatA=kernel32.GetCurrencyFormatA,@448") +#pragma comment(linker, "/export:GetCurrencyFormatEx=kernel32.GetCurrencyFormatEx,@449") +#pragma comment(linker, "/export:GetCurrencyFormatW=kernel32.GetCurrencyFormatW,@450") +#pragma comment(linker, "/export:GetCurrentActCtx=kernel32.GetCurrentActCtx,@451") +#pragma comment(linker, "/export:GetCurrentConsoleFont=kernel32.GetCurrentConsoleFont,@452") +#pragma comment(linker, "/export:GetCurrentConsoleFontEx=kernel32.GetCurrentConsoleFontEx,@453") +#pragma comment(linker, "/export:GetCurrentDirectoryA=kernel32.GetCurrentDirectoryA,@454") +#pragma comment(linker, "/export:GetCurrentDirectoryW=kernel32.GetCurrentDirectoryW,@455") +#pragma comment(linker, "/export:GetCurrentProcess=kernel32.GetCurrentProcess,@456") +#pragma comment(linker, "/export:GetCurrentProcessId=kernel32.GetCurrentProcessId,@457") +#pragma comment(linker, "/export:GetCurrentProcessorNumber=kernel32.GetCurrentProcessorNumber,@458") +#pragma comment(linker, "/export:GetCurrentProcessorNumberEx=kernel32.GetCurrentProcessorNumberEx,@459") +#pragma comment(linker, "/export:GetCurrentThread=kernel32.GetCurrentThread,@460") +#pragma comment(linker, "/export:GetCurrentThreadId=kernel32.GetCurrentThreadId,@461") +#pragma comment(linker, "/export:GetCurrentUmsThread=kernel32.GetCurrentUmsThread,@462") +#pragma comment(linker, "/export:GetDateFormatA=kernel32.GetDateFormatA,@463") +#pragma comment(linker, "/export:GetDateFormatEx=kernel32.GetDateFormatEx,@464") +#pragma comment(linker, "/export:GetDateFormatW=kernel32.GetDateFormatW,@465") +#pragma comment(linker, "/export:GetDefaultCommConfigA=kernel32.GetDefaultCommConfigA,@466") +#pragma comment(linker, "/export:GetDefaultCommConfigW=kernel32.GetDefaultCommConfigW,@467") +#pragma comment(linker, "/export:GetDevicePowerState=kernel32.GetDevicePowerState,@468") +#pragma comment(linker, "/export:GetDiskFreeSpaceA=kernel32.GetDiskFreeSpaceA,@469") +#pragma comment(linker, "/export:GetDiskFreeSpaceExA=kernel32.GetDiskFreeSpaceExA,@470") +#pragma comment(linker, "/export:GetDiskFreeSpaceExW=kernel32.GetDiskFreeSpaceExW,@471") +#pragma comment(linker, "/export:GetDiskFreeSpaceW=kernel32.GetDiskFreeSpaceW,@472") +#pragma comment(linker, "/export:GetDllDirectoryA=kernel32.GetDllDirectoryA,@473") +#pragma comment(linker, "/export:GetDllDirectoryW=kernel32.GetDllDirectoryW,@474") +#pragma comment(linker, "/export:GetDriveTypeA=kernel32.GetDriveTypeA,@475") +#pragma comment(linker, "/export:GetDriveTypeW=kernel32.GetDriveTypeW,@476") +#pragma comment(linker, "/export:GetDurationFormat=kernel32.GetDurationFormat,@477") +#pragma comment(linker, "/export:GetDurationFormatEx=kernel32.GetDurationFormatEx,@478") +#pragma comment(linker, "/export:GetDynamicTimeZoneInformation=kernel32.GetDynamicTimeZoneInformation,@479") +#pragma comment(linker, "/export:GetEnabledXStateFeatures=kernel32.GetEnabledXStateFeatures,@480") +#pragma comment(linker, "/export:GetEnvironmentStrings=kernel32.GetEnvironmentStrings,@481") +#pragma comment(linker, "/export:GetEnvironmentStringsA=kernel32.GetEnvironmentStringsA,@482") +#pragma comment(linker, "/export:GetEnvironmentStringsW=kernel32.GetEnvironmentStringsW,@483") +#pragma comment(linker, "/export:GetEnvironmentVariableA=kernel32.GetEnvironmentVariableA,@484") +#pragma comment(linker, "/export:GetEnvironmentVariableW=kernel32.GetEnvironmentVariableW,@485") +#pragma comment(linker, "/export:GetEraNameCountedString=kernel32.GetEraNameCountedString,@486") +#pragma comment(linker, "/export:GetErrorMode=kernel32.GetErrorMode,@487") +#pragma comment(linker, "/export:GetExitCodeProcess=kernel32.GetExitCodeProcess,@488") +#pragma comment(linker, "/export:GetExitCodeThread=kernel32.GetExitCodeThread,@489") +#pragma comment(linker, "/export:GetExpandedNameA=kernel32.GetExpandedNameA,@490") +#pragma comment(linker, "/export:GetExpandedNameW=kernel32.GetExpandedNameW,@491") +#pragma comment(linker, "/export:GetFileAttributesA=kernel32.GetFileAttributesA,@492") +#pragma comment(linker, "/export:GetFileAttributesExA=kernel32.GetFileAttributesExA,@493") +#pragma comment(linker, "/export:GetFileAttributesExW=kernel32.GetFileAttributesExW,@494") +#pragma comment(linker, "/export:GetFileAttributesTransactedA=kernel32.GetFileAttributesTransactedA,@495") +#pragma comment(linker, "/export:GetFileAttributesTransactedW=kernel32.GetFileAttributesTransactedW,@496") +#pragma comment(linker, "/export:GetFileAttributesW=kernel32.GetFileAttributesW,@497") +#pragma comment(linker, "/export:GetFileBandwidthReservation=kernel32.GetFileBandwidthReservation,@498") +#pragma comment(linker, "/export:GetFileInformationByHandle=kernel32.GetFileInformationByHandle,@499") +#pragma comment(linker, "/export:GetFileInformationByHandleEx=kernel32.GetFileInformationByHandleEx,@500") +#pragma comment(linker, "/export:GetFileMUIInfo=kernel32.GetFileMUIInfo,@501") +#pragma comment(linker, "/export:GetFileMUIPath=kernel32.GetFileMUIPath,@502") +#pragma comment(linker, "/export:GetFileSize=kernel32.GetFileSize,@503") +#pragma comment(linker, "/export:GetFileSizeEx=kernel32.GetFileSizeEx,@504") +#pragma comment(linker, "/export:GetFileTime=kernel32.GetFileTime,@505") +#pragma comment(linker, "/export:GetFileType=kernel32.GetFileType,@506") +#pragma comment(linker, "/export:GetFinalPathNameByHandleA=kernel32.GetFinalPathNameByHandleA,@507") +#pragma comment(linker, "/export:GetFinalPathNameByHandleW=kernel32.GetFinalPathNameByHandleW,@508") +#pragma comment(linker, "/export:GetFirmwareEnvironmentVariableA=kernel32.GetFirmwareEnvironmentVariableA,@509") +#pragma comment(linker, "/export:GetFirmwareEnvironmentVariableW=kernel32.GetFirmwareEnvironmentVariableW,@510") +#pragma comment(linker, "/export:GetFullPathNameA=kernel32.GetFullPathNameA,@511") +#pragma comment(linker, "/export:GetFullPathNameTransactedA=kernel32.GetFullPathNameTransactedA,@512") +#pragma comment(linker, "/export:GetFullPathNameTransactedW=kernel32.GetFullPathNameTransactedW,@513") +#pragma comment(linker, "/export:GetFullPathNameW=kernel32.GetFullPathNameW,@514") +#pragma comment(linker, "/export:GetGeoInfoA=kernel32.GetGeoInfoA,@515") +#pragma comment(linker, "/export:GetGeoInfoW=kernel32.GetGeoInfoW,@516") +#pragma comment(linker, "/export:GetHandleInformation=kernel32.GetHandleInformation,@517") +#pragma comment(linker, "/export:GetLargePageMinimum=kernel32.GetLargePageMinimum,@518") +#pragma comment(linker, "/export:GetLargestConsoleWindowSize=kernel32.GetLargestConsoleWindowSize,@519") +#pragma comment(linker, "/export:GetLastError=kernel32.GetLastError,@520") +#pragma comment(linker, "/export:GetLocalTime=kernel32.GetLocalTime,@521") +#pragma comment(linker, "/export:GetLocaleInfoA=kernel32.GetLocaleInfoA,@522") +#pragma comment(linker, "/export:GetLocaleInfoEx=kernel32.GetLocaleInfoEx,@523") +#pragma comment(linker, "/export:GetLocaleInfoW=kernel32.GetLocaleInfoW,@524") +#pragma comment(linker, "/export:GetLogicalDriveStringsA=kernel32.GetLogicalDriveStringsA,@525") +#pragma comment(linker, "/export:GetLogicalDriveStringsW=kernel32.GetLogicalDriveStringsW,@526") +#pragma comment(linker, "/export:GetLogicalDrives=kernel32.GetLogicalDrives,@527") +#pragma comment(linker, "/export:GetLogicalProcessorInformation=kernel32.GetLogicalProcessorInformation,@528") +#pragma comment(linker, "/export:GetLogicalProcessorInformationEx=kernel32.GetLogicalProcessorInformationEx,@529") +#pragma comment(linker, "/export:GetLongPathNameA=kernel32.GetLongPathNameA,@530") +#pragma comment(linker, "/export:GetLongPathNameTransactedA=kernel32.GetLongPathNameTransactedA,@531") +#pragma comment(linker, "/export:GetLongPathNameTransactedW=kernel32.GetLongPathNameTransactedW,@532") +#pragma comment(linker, "/export:GetLongPathNameW=kernel32.GetLongPathNameW,@533") +#pragma comment(linker, "/export:GetMailslotInfo=kernel32.GetMailslotInfo,@534") +#pragma comment(linker, "/export:GetMaximumProcessorCount=kernel32.GetMaximumProcessorCount,@535") +#pragma comment(linker, "/export:GetMaximumProcessorGroupCount=kernel32.GetMaximumProcessorGroupCount,@536") +#pragma comment(linker, "/export:GetModuleFileNameA=kernel32.GetModuleFileNameA,@537") +#pragma comment(linker, "/export:GetModuleFileNameW=kernel32.GetModuleFileNameW,@538") +#pragma comment(linker, "/export:GetModuleHandleA=kernel32.GetModuleHandleA,@539") +#pragma comment(linker, "/export:GetModuleHandleExA=kernel32.GetModuleHandleExA,@540") +#pragma comment(linker, "/export:GetModuleHandleExW=kernel32.GetModuleHandleExW,@541") +#pragma comment(linker, "/export:GetModuleHandleW=kernel32.GetModuleHandleW,@542") +#pragma comment(linker, "/export:GetNLSVersion=kernel32.GetNLSVersion,@543") +#pragma comment(linker, "/export:GetNLSVersionEx=kernel32.GetNLSVersionEx,@544") +#pragma comment(linker, "/export:GetNamedPipeAttribute=kernel32.GetNamedPipeAttribute,@545") +#pragma comment(linker, "/export:GetNamedPipeClientComputerNameA=kernel32.GetNamedPipeClientComputerNameA,@546") +#pragma comment(linker, "/export:GetNamedPipeClientComputerNameW=kernel32.GetNamedPipeClientComputerNameW,@547") +#pragma comment(linker, "/export:GetNamedPipeClientProcessId=kernel32.GetNamedPipeClientProcessId,@548") +#pragma comment(linker, "/export:GetNamedPipeClientSessionId=kernel32.GetNamedPipeClientSessionId,@549") +#pragma comment(linker, "/export:GetNamedPipeHandleStateA=kernel32.GetNamedPipeHandleStateA,@550") +#pragma comment(linker, "/export:GetNamedPipeHandleStateW=kernel32.GetNamedPipeHandleStateW,@551") +#pragma comment(linker, "/export:GetNamedPipeInfo=kernel32.GetNamedPipeInfo,@552") +#pragma comment(linker, "/export:GetNamedPipeServerProcessId=kernel32.GetNamedPipeServerProcessId,@553") +#pragma comment(linker, "/export:GetNamedPipeServerSessionId=kernel32.GetNamedPipeServerSessionId,@554") +#pragma comment(linker, "/export:GetNativeSystemInfo=kernel32.GetNativeSystemInfo,@555") +#pragma comment(linker, "/export:GetNextUmsListItem=kernel32.GetNextUmsListItem,@556") +#pragma comment(linker, "/export:GetNextVDMCommand=kernel32.GetNextVDMCommand,@557") +#pragma comment(linker, "/export:GetNumaAvailableMemoryNode=kernel32.GetNumaAvailableMemoryNode,@558") +#pragma comment(linker, "/export:GetNumaAvailableMemoryNodeEx=kernel32.GetNumaAvailableMemoryNodeEx,@559") +#pragma comment(linker, "/export:GetNumaHighestNodeNumber=kernel32.GetNumaHighestNodeNumber,@560") +#pragma comment(linker, "/export:GetNumaNodeNumberFromHandle=kernel32.GetNumaNodeNumberFromHandle,@561") +#pragma comment(linker, "/export:GetNumaNodeProcessorMask=kernel32.GetNumaNodeProcessorMask,@562") +#pragma comment(linker, "/export:GetNumaNodeProcessorMaskEx=kernel32.GetNumaNodeProcessorMaskEx,@563") +#pragma comment(linker, "/export:GetNumaProcessorNode=kernel32.GetNumaProcessorNode,@564") +#pragma comment(linker, "/export:GetNumaProcessorNodeEx=kernel32.GetNumaProcessorNodeEx,@565") +#pragma comment(linker, "/export:GetNumaProximityNode=kernel32.GetNumaProximityNode,@566") +#pragma comment(linker, "/export:GetNumaProximityNodeEx=kernel32.GetNumaProximityNodeEx,@567") +#pragma comment(linker, "/export:GetNumberFormatA=kernel32.GetNumberFormatA,@568") +#pragma comment(linker, "/export:GetNumberFormatEx=kernel32.GetNumberFormatEx,@569") +#pragma comment(linker, "/export:GetNumberFormatW=kernel32.GetNumberFormatW,@570") +#pragma comment(linker, "/export:GetNumberOfConsoleFonts=kernel32.GetNumberOfConsoleFonts,@571") +#pragma comment(linker, "/export:GetNumberOfConsoleInputEvents=kernel32.GetNumberOfConsoleInputEvents,@572") +#pragma comment(linker, "/export:GetNumberOfConsoleMouseButtons=kernel32.GetNumberOfConsoleMouseButtons,@573") +#pragma comment(linker, "/export:GetOEMCP=kernel32.GetOEMCP,@574") +#pragma comment(linker, "/export:GetOverlappedResult=kernel32.GetOverlappedResult,@575") +#pragma comment(linker, "/export:GetPhysicallyInstalledSystemMemory=kernel32.GetPhysicallyInstalledSystemMemory,@576") +#pragma comment(linker, "/export:GetPriorityClass=kernel32.GetPriorityClass,@577") +#pragma comment(linker, "/export:GetPrivateProfileIntA=kernel32.GetPrivateProfileIntA,@578") +#pragma comment(linker, "/export:GetPrivateProfileIntW=kernel32.GetPrivateProfileIntW,@579") +#pragma comment(linker, "/export:GetPrivateProfileSectionA=kernel32.GetPrivateProfileSectionA,@580") +#pragma comment(linker, "/export:GetPrivateProfileSectionNamesA=kernel32.GetPrivateProfileSectionNamesA,@581") +#pragma comment(linker, "/export:GetPrivateProfileSectionNamesW=kernel32.GetPrivateProfileSectionNamesW,@582") +#pragma comment(linker, "/export:GetPrivateProfileSectionW=kernel32.GetPrivateProfileSectionW,@583") +#pragma comment(linker, "/export:GetPrivateProfileStringA=kernel32.GetPrivateProfileStringA,@584") +#pragma comment(linker, "/export:GetPrivateProfileStringW=kernel32.GetPrivateProfileStringW,@585") +#pragma comment(linker, "/export:GetPrivateProfileStructA=kernel32.GetPrivateProfileStructA,@586") +#pragma comment(linker, "/export:GetPrivateProfileStructW=kernel32.GetPrivateProfileStructW,@587") +#pragma comment(linker, "/export:GetProcAddress=kernel32.GetProcAddress,@588") +#pragma comment(linker, "/export:GetProcessAffinityMask=kernel32.GetProcessAffinityMask,@589") +#pragma comment(linker, "/export:GetProcessDEPPolicy=kernel32.GetProcessDEPPolicy,@590") +#pragma comment(linker, "/export:GetProcessGroupAffinity=kernel32.GetProcessGroupAffinity,@591") +#pragma comment(linker, "/export:GetProcessHandleCount=kernel32.GetProcessHandleCount,@592") +#pragma comment(linker, "/export:GetProcessHeap=kernel32.GetProcessHeap,@593") +#pragma comment(linker, "/export:GetProcessHeaps=kernel32.GetProcessHeaps,@594") +#pragma comment(linker, "/export:GetProcessId=kernel32.GetProcessId,@595") +#pragma comment(linker, "/export:GetProcessIdOfThread=kernel32.GetProcessIdOfThread,@596") +#pragma comment(linker, "/export:GetProcessIoCounters=kernel32.GetProcessIoCounters,@597") +#pragma comment(linker, "/export:GetProcessPreferredUILanguages=kernel32.GetProcessPreferredUILanguages,@598") +#pragma comment(linker, "/export:GetProcessPriorityBoost=kernel32.GetProcessPriorityBoost,@599") +#pragma comment(linker, "/export:GetProcessShutdownParameters=kernel32.GetProcessShutdownParameters,@600") +#pragma comment(linker, "/export:GetProcessTimes=kernel32.GetProcessTimes,@601") +#pragma comment(linker, "/export:GetProcessUserModeExceptionPolicy=kernel32.GetProcessUserModeExceptionPolicy,@602") +#pragma comment(linker, "/export:GetProcessVersion=kernel32.GetProcessVersion,@603") +#pragma comment(linker, "/export:GetProcessWorkingSetSize=kernel32.GetProcessWorkingSetSize,@604") +#pragma comment(linker, "/export:GetProcessWorkingSetSizeEx=kernel32.GetProcessWorkingSetSizeEx,@605") +#pragma comment(linker, "/export:GetProcessorSystemCycleTime=kernel32.GetProcessorSystemCycleTime,@606") +#pragma comment(linker, "/export:GetProductInfo=kernel32.GetProductInfo,@607") +#pragma comment(linker, "/export:GetProfileIntA=kernel32.GetProfileIntA,@608") +#pragma comment(linker, "/export:GetProfileIntW=kernel32.GetProfileIntW,@609") +#pragma comment(linker, "/export:GetProfileSectionA=kernel32.GetProfileSectionA,@610") +#pragma comment(linker, "/export:GetProfileSectionW=kernel32.GetProfileSectionW,@611") +#pragma comment(linker, "/export:GetProfileStringA=kernel32.GetProfileStringA,@612") +#pragma comment(linker, "/export:GetProfileStringW=kernel32.GetProfileStringW,@613") +#pragma comment(linker, "/export:GetQueuedCompletionStatus=kernel32.GetQueuedCompletionStatus,@614") +#pragma comment(linker, "/export:GetQueuedCompletionStatusEx=kernel32.GetQueuedCompletionStatusEx,@615") +#pragma comment(linker, "/export:GetShortPathNameA=kernel32.GetShortPathNameA,@616") +#pragma comment(linker, "/export:GetShortPathNameW=kernel32.GetShortPathNameW,@617") +#pragma comment(linker, "/export:GetStartupInfoA=kernel32.GetStartupInfoA,@618") +#pragma comment(linker, "/export:GetStartupInfoW=kernel32.GetStartupInfoW,@619") +#pragma comment(linker, "/export:GetStdHandle=kernel32.GetStdHandle,@620") +#pragma comment(linker, "/export:GetStringScripts=kernel32.GetStringScripts,@621") +#pragma comment(linker, "/export:GetStringTypeA=kernel32.GetStringTypeA,@622") +#pragma comment(linker, "/export:GetStringTypeExA=kernel32.GetStringTypeExA,@623") +#pragma comment(linker, "/export:GetStringTypeExW=kernel32.GetStringTypeExW,@624") +#pragma comment(linker, "/export:GetStringTypeW=kernel32.GetStringTypeW,@625") +#pragma comment(linker, "/export:GetSystemDEPPolicy=kernel32.GetSystemDEPPolicy,@626") +#pragma comment(linker, "/export:GetSystemDefaultLCID=kernel32.GetSystemDefaultLCID,@627") +#pragma comment(linker, "/export:GetSystemDefaultLangID=kernel32.GetSystemDefaultLangID,@628") +#pragma comment(linker, "/export:GetSystemDefaultLocaleName=kernel32.GetSystemDefaultLocaleName,@629") +#pragma comment(linker, "/export:GetSystemDefaultUILanguage=kernel32.GetSystemDefaultUILanguage,@630") +#pragma comment(linker, "/export:GetSystemDirectoryA=kernel32.GetSystemDirectoryA,@631") +#pragma comment(linker, "/export:GetSystemDirectoryW=kernel32.GetSystemDirectoryW,@632") +#pragma comment(linker, "/export:GetSystemFileCacheSize=kernel32.GetSystemFileCacheSize,@633") +#pragma comment(linker, "/export:GetSystemFirmwareTable=kernel32.GetSystemFirmwareTable,@634") +#pragma comment(linker, "/export:GetSystemInfo=kernel32.GetSystemInfo,@635") +#pragma comment(linker, "/export:GetSystemPowerStatus=kernel32.GetSystemPowerStatus,@636") +#pragma comment(linker, "/export:GetSystemPreferredUILanguages=kernel32.GetSystemPreferredUILanguages,@637") +#pragma comment(linker, "/export:GetSystemRegistryQuota=kernel32.GetSystemRegistryQuota,@638") +#pragma comment(linker, "/export:GetSystemTime=kernel32.GetSystemTime,@639") +#pragma comment(linker, "/export:GetSystemTimeAdjustment=kernel32.GetSystemTimeAdjustment,@640") +#pragma comment(linker, "/export:GetSystemTimeAsFileTime=kernel32.GetSystemTimeAsFileTime,@641") +#pragma comment(linker, "/export:GetSystemTimes=kernel32.GetSystemTimes,@642") +#pragma comment(linker, "/export:GetSystemWindowsDirectoryA=kernel32.GetSystemWindowsDirectoryA,@643") +#pragma comment(linker, "/export:GetSystemWindowsDirectoryW=kernel32.GetSystemWindowsDirectoryW,@644") +#pragma comment(linker, "/export:GetSystemWow64DirectoryA=kernel32.GetSystemWow64DirectoryA,@645") +#pragma comment(linker, "/export:GetSystemWow64DirectoryW=kernel32.GetSystemWow64DirectoryW,@646") +#pragma comment(linker, "/export:GetTapeParameters=kernel32.GetTapeParameters,@647") +#pragma comment(linker, "/export:GetTapePosition=kernel32.GetTapePosition,@648") +#pragma comment(linker, "/export:GetTapeStatus=kernel32.GetTapeStatus,@649") +#pragma comment(linker, "/export:GetTempFileNameA=kernel32.GetTempFileNameA,@650") +#pragma comment(linker, "/export:GetTempFileNameW=kernel32.GetTempFileNameW,@651") +#pragma comment(linker, "/export:GetTempPathA=kernel32.GetTempPathA,@652") +#pragma comment(linker, "/export:GetTempPathW=kernel32.GetTempPathW,@653") +#pragma comment(linker, "/export:GetThreadContext=kernel32.GetThreadContext,@654") +#pragma comment(linker, "/export:GetThreadErrorMode=kernel32.GetThreadErrorMode,@655") +#pragma comment(linker, "/export:GetThreadGroupAffinity=kernel32.GetThreadGroupAffinity,@656") +#pragma comment(linker, "/export:GetThreadIOPendingFlag=kernel32.GetThreadIOPendingFlag,@657") +#pragma comment(linker, "/export:GetThreadId=kernel32.GetThreadId,@658") +#pragma comment(linker, "/export:GetThreadIdealProcessorEx=kernel32.GetThreadIdealProcessorEx,@659") +#pragma comment(linker, "/export:GetThreadLocale=kernel32.GetThreadLocale,@660") +#pragma comment(linker, "/export:GetThreadPreferredUILanguages=kernel32.GetThreadPreferredUILanguages,@661") +#pragma comment(linker, "/export:GetThreadPriority=kernel32.GetThreadPriority,@662") +#pragma comment(linker, "/export:GetThreadPriorityBoost=kernel32.GetThreadPriorityBoost,@663") +#pragma comment(linker, "/export:GetThreadSelectorEntry=kernel32.GetThreadSelectorEntry,@664") +#pragma comment(linker, "/export:GetThreadTimes=kernel32.GetThreadTimes,@665") +#pragma comment(linker, "/export:GetThreadUILanguage=kernel32.GetThreadUILanguage,@666") +#pragma comment(linker, "/export:GetTickCount=kernel32.GetTickCount,@667") +#pragma comment(linker, "/export:GetTickCount64=kernel32.GetTickCount64,@668") +#pragma comment(linker, "/export:GetTimeFormatA=kernel32.GetTimeFormatA,@669") +#pragma comment(linker, "/export:GetTimeFormatEx=kernel32.GetTimeFormatEx,@670") +#pragma comment(linker, "/export:GetTimeFormatW=kernel32.GetTimeFormatW,@671") +#pragma comment(linker, "/export:GetTimeZoneInformation=kernel32.GetTimeZoneInformation,@672") +#pragma comment(linker, "/export:GetTimeZoneInformationForYear=kernel32.GetTimeZoneInformationForYear,@673") +#pragma comment(linker, "/export:GetUILanguageInfo=kernel32.GetUILanguageInfo,@674") +#pragma comment(linker, "/export:GetUmsCompletionListEvent=kernel32.GetUmsCompletionListEvent,@675") +#pragma comment(linker, "/export:GetUmsSystemThreadInformation=kernel32.GetUmsSystemThreadInformation,@676") +#pragma comment(linker, "/export:GetUserDefaultLCID=kernel32.GetUserDefaultLCID,@677") +#pragma comment(linker, "/export:GetUserDefaultLangID=kernel32.GetUserDefaultLangID,@678") +#pragma comment(linker, "/export:GetUserDefaultLocaleName=kernel32.GetUserDefaultLocaleName,@679") +#pragma comment(linker, "/export:GetUserDefaultUILanguage=kernel32.GetUserDefaultUILanguage,@680") +#pragma comment(linker, "/export:GetUserGeoID=kernel32.GetUserGeoID,@681") +#pragma comment(linker, "/export:GetUserPreferredUILanguages=kernel32.GetUserPreferredUILanguages,@682") +#pragma comment(linker, "/export:GetVDMCurrentDirectories=kernel32.GetVDMCurrentDirectories,@683") +#pragma comment(linker, "/export:GetVersion=kernel32.GetVersion,@684") +#pragma comment(linker, "/export:GetVersionExA=kernel32.GetVersionExA,@685") +#pragma comment(linker, "/export:GetVersionExW=kernel32.GetVersionExW,@686") +#pragma comment(linker, "/export:GetVolumeInformationA=kernel32.GetVolumeInformationA,@687") +#pragma comment(linker, "/export:GetVolumeInformationByHandleW=kernel32.GetVolumeInformationByHandleW,@688") +#pragma comment(linker, "/export:GetVolumeInformationW=kernel32.GetVolumeInformationW,@689") +#pragma comment(linker, "/export:GetVolumeNameForVolumeMountPointA=kernel32.GetVolumeNameForVolumeMountPointA,@690") +#pragma comment(linker, "/export:GetVolumeNameForVolumeMountPointW=kernel32.GetVolumeNameForVolumeMountPointW,@691") +#pragma comment(linker, "/export:GetVolumePathNameA=kernel32.GetVolumePathNameA,@692") +#pragma comment(linker, "/export:GetVolumePathNameW=kernel32.GetVolumePathNameW,@693") +#pragma comment(linker, "/export:GetVolumePathNamesForVolumeNameA=kernel32.GetVolumePathNamesForVolumeNameA,@694") +#pragma comment(linker, "/export:GetVolumePathNamesForVolumeNameW=kernel32.GetVolumePathNamesForVolumeNameW,@695") +#pragma comment(linker, "/export:GetWindowsDirectoryA=kernel32.GetWindowsDirectoryA,@696") +#pragma comment(linker, "/export:GetWindowsDirectoryW=kernel32.GetWindowsDirectoryW,@697") +#pragma comment(linker, "/export:GetWriteWatch=kernel32.GetWriteWatch,@698") +#pragma comment(linker, "/export:GetXStateFeaturesMask=kernel32.GetXStateFeaturesMask,@699") +#pragma comment(linker, "/export:GlobalAddAtomA=kernel32.GlobalAddAtomA,@700") +#pragma comment(linker, "/export:GlobalAddAtomW=kernel32.GlobalAddAtomW,@701") +#pragma comment(linker, "/export:GlobalAlloc=kernel32.GlobalAlloc,@702") +#pragma comment(linker, "/export:GlobalCompact=kernel32.GlobalCompact,@703") +#pragma comment(linker, "/export:GlobalDeleteAtom=kernel32.GlobalDeleteAtom,@704") +#pragma comment(linker, "/export:GlobalFindAtomA=kernel32.GlobalFindAtomA,@705") +#pragma comment(linker, "/export:GlobalFindAtomW=kernel32.GlobalFindAtomW,@706") +#pragma comment(linker, "/export:GlobalFix=kernel32.GlobalFix,@707") +#pragma comment(linker, "/export:GlobalFlags=kernel32.GlobalFlags,@708") +#pragma comment(linker, "/export:GlobalFree=kernel32.GlobalFree,@709") +#pragma comment(linker, "/export:GlobalGetAtomNameA=kernel32.GlobalGetAtomNameA,@710") +#pragma comment(linker, "/export:GlobalGetAtomNameW=kernel32.GlobalGetAtomNameW,@711") +#pragma comment(linker, "/export:GlobalHandle=kernel32.GlobalHandle,@712") +#pragma comment(linker, "/export:GlobalLock=kernel32.GlobalLock,@713") +#pragma comment(linker, "/export:GlobalMemoryStatus=kernel32.GlobalMemoryStatus,@714") +#pragma comment(linker, "/export:GlobalMemoryStatusEx=kernel32.GlobalMemoryStatusEx,@715") +#pragma comment(linker, "/export:GlobalReAlloc=kernel32.GlobalReAlloc,@716") +#pragma comment(linker, "/export:GlobalSize=kernel32.GlobalSize,@717") +#pragma comment(linker, "/export:GlobalUnWire=kernel32.GlobalUnWire,@718") +#pragma comment(linker, "/export:GlobalUnfix=kernel32.GlobalUnfix,@719") +#pragma comment(linker, "/export:GlobalUnlock=kernel32.GlobalUnlock,@720") +#pragma comment(linker, "/export:GlobalWire=kernel32.GlobalWire,@721") +#pragma comment(linker, "/export:Heap32First=kernel32.Heap32First,@722") +#pragma comment(linker, "/export:Heap32ListFirst=kernel32.Heap32ListFirst,@723") +#pragma comment(linker, "/export:Heap32ListNext=kernel32.Heap32ListNext,@724") +#pragma comment(linker, "/export:Heap32Next=kernel32.Heap32Next,@725") +#pragma comment(linker, "/export:HeapAlloc=kernel32.HeapAlloc,@726") +#pragma comment(linker, "/export:HeapCompact=kernel32.HeapCompact,@727") +#pragma comment(linker, "/export:HeapCreate=kernel32.HeapCreate,@728") +#pragma comment(linker, "/export:HeapDestroy=kernel32.HeapDestroy,@729") +#pragma comment(linker, "/export:HeapFree=kernel32.HeapFree,@730") +#pragma comment(linker, "/export:HeapLock=kernel32.HeapLock,@731") +#pragma comment(linker, "/export:HeapQueryInformation=kernel32.HeapQueryInformation,@732") +#pragma comment(linker, "/export:HeapReAlloc=kernel32.HeapReAlloc,@733") +#pragma comment(linker, "/export:HeapSetInformation=kernel32.HeapSetInformation,@734") +#pragma comment(linker, "/export:HeapSize=kernel32.HeapSize,@735") +#pragma comment(linker, "/export:HeapSummary=kernel32.HeapSummary,@736") +#pragma comment(linker, "/export:HeapUnlock=kernel32.HeapUnlock,@737") +#pragma comment(linker, "/export:HeapValidate=kernel32.HeapValidate,@738") +#pragma comment(linker, "/export:HeapWalk=kernel32.HeapWalk,@739") +#pragma comment(linker, "/export:IdnToAscii=kernel32.IdnToAscii,@740") +#pragma comment(linker, "/export:IdnToNameprepUnicode=kernel32.IdnToNameprepUnicode,@741") +#pragma comment(linker, "/export:IdnToUnicode=kernel32.IdnToUnicode,@742") +#pragma comment(linker, "/export:InitAtomTable=kernel32.InitAtomTable,@743") +#pragma comment(linker, "/export:InitOnceBeginInitialize=kernel32.InitOnceBeginInitialize,@744") +#pragma comment(linker, "/export:InitOnceComplete=kernel32.InitOnceComplete,@745") +#pragma comment(linker, "/export:InitOnceExecuteOnce=kernel32.InitOnceExecuteOnce,@746") +#pragma comment(linker, "/export:InitOnceInitialize=kernel32.InitOnceInitialize,@747") +#pragma comment(linker, "/export:InitializeConditionVariable=kernel32.InitializeConditionVariable,@748") +#pragma comment(linker, "/export:InitializeContext=kernel32.InitializeContext,@749") +#pragma comment(linker, "/export:InitializeCriticalSection=kernel32.InitializeCriticalSection,@750") +#pragma comment(linker, "/export:InitializeCriticalSectionAndSpinCount=kernel32.InitializeCriticalSectionAndSpinCount,@751") +#pragma comment(linker, "/export:InitializeCriticalSectionEx=kernel32.InitializeCriticalSectionEx,@752") +#pragma comment(linker, "/export:InitializeProcThreadAttributeList=kernel32.InitializeProcThreadAttributeList,@753") +#pragma comment(linker, "/export:InitializeSListHead=kernel32.InitializeSListHead,@754") +#pragma comment(linker, "/export:InitializeSRWLock=kernel32.InitializeSRWLock,@755") +#pragma comment(linker, "/export:InterlockedFlushSList=kernel32.InterlockedFlushSList,@756") +#pragma comment(linker, "/export:InterlockedPopEntrySList=kernel32.InterlockedPopEntrySList,@757") +#pragma comment(linker, "/export:InterlockedPushEntrySList=kernel32.InterlockedPushEntrySList,@758") +#pragma comment(linker, "/export:InterlockedPushListSList=kernel32.InterlockedPushListSList,@759") +#pragma comment(linker, "/export:InvalidateConsoleDIBits=kernel32.InvalidateConsoleDIBits,@760") +#pragma comment(linker, "/export:IsBadCodePtr=kernel32.IsBadCodePtr,@761") +#pragma comment(linker, "/export:IsBadHugeReadPtr=kernel32.IsBadHugeReadPtr,@762") +#pragma comment(linker, "/export:IsBadHugeWritePtr=kernel32.IsBadHugeWritePtr,@763") +#pragma comment(linker, "/export:IsBadReadPtr=kernel32.IsBadReadPtr,@764") +#pragma comment(linker, "/export:IsBadStringPtrA=kernel32.IsBadStringPtrA,@765") +#pragma comment(linker, "/export:IsBadStringPtrW=kernel32.IsBadStringPtrW,@766") +#pragma comment(linker, "/export:IsBadWritePtr=kernel32.IsBadWritePtr,@767") +#pragma comment(linker, "/export:IsCalendarLeapDay=kernel32.IsCalendarLeapDay,@768") +#pragma comment(linker, "/export:IsCalendarLeapMonth=kernel32.IsCalendarLeapMonth,@769") +#pragma comment(linker, "/export:IsCalendarLeapYear=kernel32.IsCalendarLeapYear,@770") +#pragma comment(linker, "/export:IsDBCSLeadByte=kernel32.IsDBCSLeadByte,@771") +#pragma comment(linker, "/export:IsDBCSLeadByteEx=kernel32.IsDBCSLeadByteEx,@772") +#pragma comment(linker, "/export:IsDebuggerPresent=kernel32.IsDebuggerPresent,@773") +#pragma comment(linker, "/export:IsNLSDefinedString=kernel32.IsNLSDefinedString,@774") +#pragma comment(linker, "/export:IsNormalizedString=kernel32.IsNormalizedString,@775") +#pragma comment(linker, "/export:IsProcessInJob=kernel32.IsProcessInJob,@776") +#pragma comment(linker, "/export:IsProcessorFeaturePresent=kernel32.IsProcessorFeaturePresent,@777") +#pragma comment(linker, "/export:IsSystemResumeAutomatic=kernel32.IsSystemResumeAutomatic,@778") +#pragma comment(linker, "/export:IsThreadAFiber=kernel32.IsThreadAFiber,@779") +#pragma comment(linker, "/export:IsThreadpoolTimerSet=kernel32.IsThreadpoolTimerSet,@780") +#pragma comment(linker, "/export:IsTimeZoneRedirectionEnabled=kernel32.IsTimeZoneRedirectionEnabled,@781") +#pragma comment(linker, "/export:IsValidCalDateTime=kernel32.IsValidCalDateTime,@782") +#pragma comment(linker, "/export:IsValidCodePage=kernel32.IsValidCodePage,@783") +#pragma comment(linker, "/export:IsValidLanguageGroup=kernel32.IsValidLanguageGroup,@784") +#pragma comment(linker, "/export:IsValidLocale=kernel32.IsValidLocale,@785") +#pragma comment(linker, "/export:IsValidLocaleName=kernel32.IsValidLocaleName,@786") +#pragma comment(linker, "/export:IsWow64Process=kernel32.IsWow64Process,@787") +#pragma comment(linker, "/export:K32EmptyWorkingSet=kernel32.K32EmptyWorkingSet,@788") +#pragma comment(linker, "/export:K32EnumDeviceDrivers=kernel32.K32EnumDeviceDrivers,@789") +#pragma comment(linker, "/export:K32EnumPageFilesA=kernel32.K32EnumPageFilesA,@790") +#pragma comment(linker, "/export:K32EnumPageFilesW=kernel32.K32EnumPageFilesW,@791") +#pragma comment(linker, "/export:K32EnumProcessModules=kernel32.K32EnumProcessModules,@792") +#pragma comment(linker, "/export:K32EnumProcessModulesEx=kernel32.K32EnumProcessModulesEx,@793") +#pragma comment(linker, "/export:K32EnumProcesses=kernel32.K32EnumProcesses,@794") +#pragma comment(linker, "/export:K32GetDeviceDriverBaseNameA=kernel32.K32GetDeviceDriverBaseNameA,@795") +#pragma comment(linker, "/export:K32GetDeviceDriverBaseNameW=kernel32.K32GetDeviceDriverBaseNameW,@796") +#pragma comment(linker, "/export:K32GetDeviceDriverFileNameA=kernel32.K32GetDeviceDriverFileNameA,@797") +#pragma comment(linker, "/export:K32GetDeviceDriverFileNameW=kernel32.K32GetDeviceDriverFileNameW,@798") +#pragma comment(linker, "/export:K32GetMappedFileNameA=kernel32.K32GetMappedFileNameA,@799") +#pragma comment(linker, "/export:K32GetMappedFileNameW=kernel32.K32GetMappedFileNameW,@800") +#pragma comment(linker, "/export:K32GetModuleBaseNameA=kernel32.K32GetModuleBaseNameA,@801") +#pragma comment(linker, "/export:K32GetModuleBaseNameW=kernel32.K32GetModuleBaseNameW,@802") +#pragma comment(linker, "/export:K32GetModuleFileNameExA=kernel32.K32GetModuleFileNameExA,@803") +#pragma comment(linker, "/export:K32GetModuleFileNameExW=kernel32.K32GetModuleFileNameExW,@804") +#pragma comment(linker, "/export:K32GetModuleInformation=kernel32.K32GetModuleInformation,@805") +#pragma comment(linker, "/export:K32GetPerformanceInfo=kernel32.K32GetPerformanceInfo,@806") +#pragma comment(linker, "/export:K32GetProcessImageFileNameA=kernel32.K32GetProcessImageFileNameA,@807") +#pragma comment(linker, "/export:K32GetProcessImageFileNameW=kernel32.K32GetProcessImageFileNameW,@808") +#pragma comment(linker, "/export:K32GetProcessMemoryInfo=kernel32.K32GetProcessMemoryInfo,@809") +#pragma comment(linker, "/export:K32GetWsChanges=kernel32.K32GetWsChanges,@810") +#pragma comment(linker, "/export:K32GetWsChangesEx=kernel32.K32GetWsChangesEx,@811") +#pragma comment(linker, "/export:K32InitializeProcessForWsWatch=kernel32.K32InitializeProcessForWsWatch,@812") +#pragma comment(linker, "/export:K32QueryWorkingSet=kernel32.K32QueryWorkingSet,@813") +#pragma comment(linker, "/export:K32QueryWorkingSetEx=kernel32.K32QueryWorkingSetEx,@814") +#pragma comment(linker, "/export:LCIDToLocaleName=kernel32.LCIDToLocaleName,@815") +#pragma comment(linker, "/export:LCMapStringA=kernel32.LCMapStringA,@816") +#pragma comment(linker, "/export:LCMapStringEx=kernel32.LCMapStringEx,@817") +#pragma comment(linker, "/export:LCMapStringW=kernel32.LCMapStringW,@818") +#pragma comment(linker, "/export:LZClose=kernel32.LZClose,@819") +#pragma comment(linker, "/export:LZCloseFile=kernel32.LZCloseFile,@820") +#pragma comment(linker, "/export:LZCopy=kernel32.LZCopy,@821") +#pragma comment(linker, "/export:LZCreateFileW=kernel32.LZCreateFileW,@822") +#pragma comment(linker, "/export:LZDone=kernel32.LZDone,@823") +#pragma comment(linker, "/export:LZInit=kernel32.LZInit,@824") +#pragma comment(linker, "/export:LZOpenFileA=kernel32.LZOpenFileA,@825") +#pragma comment(linker, "/export:LZOpenFileW=kernel32.LZOpenFileW,@826") +#pragma comment(linker, "/export:LZRead=kernel32.LZRead,@827") +#pragma comment(linker, "/export:LZSeek=kernel32.LZSeek,@828") +#pragma comment(linker, "/export:LZStart=kernel32.LZStart,@829") +#pragma comment(linker, "/export:LeaveCriticalSection=kernel32.LeaveCriticalSection,@830") +#pragma comment(linker, "/export:LeaveCriticalSectionWhenCallbackReturns=kernel32.LeaveCriticalSectionWhenCallbackReturns,@831") +#pragma comment(linker, "/export:LoadAppInitDlls=kernel32.LoadAppInitDlls,@832") +#pragma comment(linker, "/export:LoadLibraryA=kernel32.LoadLibraryA,@833") +#pragma comment(linker, "/export:LoadLibraryExA=kernel32.LoadLibraryExA,@834") +#pragma comment(linker, "/export:LoadLibraryExW=kernel32.LoadLibraryExW,@835") +#pragma comment(linker, "/export:LoadLibraryW=kernel32.LoadLibraryW,@836") +#pragma comment(linker, "/export:LoadModule=kernel32.LoadModule,@837") +#pragma comment(linker, "/export:LoadResource=kernel32.LoadResource,@838") +#pragma comment(linker, "/export:LoadStringBaseExW=kernel32.LoadStringBaseExW,@839") +#pragma comment(linker, "/export:LoadStringBaseW=kernel32.LoadStringBaseW,@840") +#pragma comment(linker, "/export:LocalAlloc=kernel32.LocalAlloc,@841") +#pragma comment(linker, "/export:LocalCompact=kernel32.LocalCompact,@842") +#pragma comment(linker, "/export:LocalFileTimeToFileTime=kernel32.LocalFileTimeToFileTime,@843") +#pragma comment(linker, "/export:LocalFlags=kernel32.LocalFlags,@844") +#pragma comment(linker, "/export:LocalFree=kernel32.LocalFree,@845") +#pragma comment(linker, "/export:LocalHandle=kernel32.LocalHandle,@846") +#pragma comment(linker, "/export:LocalLock=kernel32.LocalLock,@847") +#pragma comment(linker, "/export:LocalReAlloc=kernel32.LocalReAlloc,@848") +#pragma comment(linker, "/export:LocalShrink=kernel32.LocalShrink,@849") +#pragma comment(linker, "/export:LocalSize=kernel32.LocalSize,@850") +#pragma comment(linker, "/export:LocalUnlock=kernel32.LocalUnlock,@851") +#pragma comment(linker, "/export:LocaleNameToLCID=kernel32.LocaleNameToLCID,@852") +#pragma comment(linker, "/export:LocateXStateFeature=kernel32.LocateXStateFeature,@853") +#pragma comment(linker, "/export:LockFile=kernel32.LockFile,@854") +#pragma comment(linker, "/export:LockFileEx=kernel32.LockFileEx,@855") +#pragma comment(linker, "/export:LockResource=kernel32.LockResource,@856") +#pragma comment(linker, "/export:MapUserPhysicalPages=kernel32.MapUserPhysicalPages,@857") +#pragma comment(linker, "/export:MapUserPhysicalPagesScatter=kernel32.MapUserPhysicalPagesScatter,@858") +#pragma comment(linker, "/export:MapViewOfFile=kernel32.MapViewOfFile,@859") +#pragma comment(linker, "/export:MapViewOfFileEx=kernel32.MapViewOfFileEx,@860") +#pragma comment(linker, "/export:MapViewOfFileExNuma=kernel32.MapViewOfFileExNuma,@861") +#pragma comment(linker, "/export:Module32First=kernel32.Module32First,@862") +#pragma comment(linker, "/export:Module32FirstW=kernel32.Module32FirstW,@863") +#pragma comment(linker, "/export:Module32Next=kernel32.Module32Next,@864") +#pragma comment(linker, "/export:Module32NextW=kernel32.Module32NextW,@865") +#pragma comment(linker, "/export:MoveFileA=kernel32.MoveFileA,@866") +#pragma comment(linker, "/export:MoveFileExA=kernel32.MoveFileExA,@867") +#pragma comment(linker, "/export:MoveFileExW=kernel32.MoveFileExW,@868") +#pragma comment(linker, "/export:MoveFileTransactedA=kernel32.MoveFileTransactedA,@869") +#pragma comment(linker, "/export:MoveFileTransactedW=kernel32.MoveFileTransactedW,@870") +#pragma comment(linker, "/export:MoveFileW=kernel32.MoveFileW,@871") +#pragma comment(linker, "/export:MoveFileWithProgressA=kernel32.MoveFileWithProgressA,@872") +#pragma comment(linker, "/export:MoveFileWithProgressW=kernel32.MoveFileWithProgressW,@873") +#pragma comment(linker, "/export:MulDiv=kernel32.MulDiv,@874") +#pragma comment(linker, "/export:MultiByteToWideChar=kernel32.MultiByteToWideChar,@875") +#pragma comment(linker, "/export:NeedCurrentDirectoryForExePathA=kernel32.NeedCurrentDirectoryForExePathA,@876") +#pragma comment(linker, "/export:NeedCurrentDirectoryForExePathW=kernel32.NeedCurrentDirectoryForExePathW,@877") +#pragma comment(linker, "/export:NlsCheckPolicy=kernel32.NlsCheckPolicy,@878") +#pragma comment(linker, "/export:NlsEventDataDescCreate=kernel32.NlsEventDataDescCreate,@879") +#pragma comment(linker, "/export:NlsGetCacheUpdateCount=kernel32.NlsGetCacheUpdateCount,@880") +#pragma comment(linker, "/export:NlsUpdateLocale=kernel32.NlsUpdateLocale,@881") +#pragma comment(linker, "/export:NlsUpdateSystemLocale=kernel32.NlsUpdateSystemLocale,@882") +#pragma comment(linker, "/export:NlsWriteEtwEvent=kernel32.NlsWriteEtwEvent,@883") +#pragma comment(linker, "/export:NormalizeString=kernel32.NormalizeString,@884") +#pragma comment(linker, "/export:NotifyMountMgr=kernel32.NotifyMountMgr,@885") +#pragma comment(linker, "/export:NotifyUILanguageChange=kernel32.NotifyUILanguageChange,@886") +#pragma comment(linker, "/export:OpenConsoleW=kernel32.OpenConsoleW,@887") +#pragma comment(linker, "/export:OpenEventA=kernel32.OpenEventA,@888") +#pragma comment(linker, "/export:OpenEventW=kernel32.OpenEventW,@889") +#pragma comment(linker, "/export:OpenFile=kernel32.OpenFile,@890") +#pragma comment(linker, "/export:OpenFileById=kernel32.OpenFileById,@891") +#pragma comment(linker, "/export:OpenFileMappingA=kernel32.OpenFileMappingA,@892") +#pragma comment(linker, "/export:OpenFileMappingW=kernel32.OpenFileMappingW,@893") +#pragma comment(linker, "/export:OpenJobObjectA=kernel32.OpenJobObjectA,@894") +#pragma comment(linker, "/export:OpenJobObjectW=kernel32.OpenJobObjectW,@895") +#pragma comment(linker, "/export:OpenMutexA=kernel32.OpenMutexA,@896") +#pragma comment(linker, "/export:OpenMutexW=kernel32.OpenMutexW,@897") +#pragma comment(linker, "/export:OpenPrivateNamespaceA=kernel32.OpenPrivateNamespaceA,@898") +#pragma comment(linker, "/export:OpenPrivateNamespaceW=kernel32.OpenPrivateNamespaceW,@899") +#pragma comment(linker, "/export:OpenProcess=kernel32.OpenProcess,@900") +#pragma comment(linker, "/export:OpenProcessToken=kernel32.OpenProcessToken,@901") +#pragma comment(linker, "/export:OpenProfileUserMapping=kernel32.OpenProfileUserMapping,@902") +#pragma comment(linker, "/export:OpenSemaphoreA=kernel32.OpenSemaphoreA,@903") +#pragma comment(linker, "/export:OpenSemaphoreW=kernel32.OpenSemaphoreW,@904") +#pragma comment(linker, "/export:OpenThread=kernel32.OpenThread,@905") +#pragma comment(linker, "/export:OpenThreadToken=kernel32.OpenThreadToken,@906") +#pragma comment(linker, "/export:OpenWaitableTimerA=kernel32.OpenWaitableTimerA,@907") +#pragma comment(linker, "/export:OpenWaitableTimerW=kernel32.OpenWaitableTimerW,@908") +#pragma comment(linker, "/export:OutputDebugStringA=kernel32.OutputDebugStringA,@909") +#pragma comment(linker, "/export:OutputDebugStringW=kernel32.OutputDebugStringW,@910") +#pragma comment(linker, "/export:PeekConsoleInputA=kernel32.PeekConsoleInputA,@911") +#pragma comment(linker, "/export:PeekConsoleInputW=kernel32.PeekConsoleInputW,@912") +#pragma comment(linker, "/export:PeekNamedPipe=kernel32.PeekNamedPipe,@913") +#pragma comment(linker, "/export:PostQueuedCompletionStatus=kernel32.PostQueuedCompletionStatus,@914") +#pragma comment(linker, "/export:PowerClearRequest=kernel32.PowerClearRequest,@915") +#pragma comment(linker, "/export:PowerCreateRequest=kernel32.PowerCreateRequest,@916") +#pragma comment(linker, "/export:PowerSetRequest=kernel32.PowerSetRequest,@917") +#pragma comment(linker, "/export:PrepareTape=kernel32.PrepareTape,@918") +#pragma comment(linker, "/export:PrivCopyFileExW=kernel32.PrivCopyFileExW,@919") +#pragma comment(linker, "/export:PrivMoveFileIdentityW=kernel32.PrivMoveFileIdentityW,@920") +#pragma comment(linker, "/export:Process32First=kernel32.Process32First,@921") +#pragma comment(linker, "/export:Process32FirstW=kernel32.Process32FirstW,@922") +#pragma comment(linker, "/export:Process32Next=kernel32.Process32Next,@923") +#pragma comment(linker, "/export:Process32NextW=kernel32.Process32NextW,@924") +#pragma comment(linker, "/export:ProcessIdToSessionId=kernel32.ProcessIdToSessionId,@925") +#pragma comment(linker, "/export:PulseEvent=kernel32.PulseEvent,@926") +#pragma comment(linker, "/export:PurgeComm=kernel32.PurgeComm,@927") +#pragma comment(linker, "/export:QueryActCtxSettingsW=kernel32.QueryActCtxSettingsW,@928") +#pragma comment(linker, "/export:QueryActCtxW=kernel32.QueryActCtxW,@929") +#pragma comment(linker, "/export:QueryDepthSList=kernel32.QueryDepthSList,@930") +#pragma comment(linker, "/export:QueryDosDeviceA=kernel32.QueryDosDeviceA,@931") +#pragma comment(linker, "/export:QueryDosDeviceW=kernel32.QueryDosDeviceW,@932") +#pragma comment(linker, "/export:QueryFullProcessImageNameA=kernel32.QueryFullProcessImageNameA,@933") +#pragma comment(linker, "/export:QueryFullProcessImageNameW=kernel32.QueryFullProcessImageNameW,@934") +#pragma comment(linker, "/export:QueryIdleProcessorCycleTime=kernel32.QueryIdleProcessorCycleTime,@935") +#pragma comment(linker, "/export:QueryIdleProcessorCycleTimeEx=kernel32.QueryIdleProcessorCycleTimeEx,@936") +#pragma comment(linker, "/export:QueryInformationJobObject=kernel32.QueryInformationJobObject,@937") +#pragma comment(linker, "/export:QueryMemoryResourceNotification=kernel32.QueryMemoryResourceNotification,@938") +#pragma comment(linker, "/export:QueryPerformanceCounter=kernel32.QueryPerformanceCounter,@939") +#pragma comment(linker, "/export:QueryPerformanceFrequency=kernel32.QueryPerformanceFrequency,@940") +#pragma comment(linker, "/export:QueryProcessAffinityUpdateMode=kernel32.QueryProcessAffinityUpdateMode,@941") +#pragma comment(linker, "/export:QueryProcessCycleTime=kernel32.QueryProcessCycleTime,@942") +#pragma comment(linker, "/export:QueryThreadCycleTime=kernel32.QueryThreadCycleTime,@943") +#pragma comment(linker, "/export:QueryThreadProfiling=kernel32.QueryThreadProfiling,@944") +#pragma comment(linker, "/export:QueryThreadpoolStackInformation=kernel32.QueryThreadpoolStackInformation,@945") +#pragma comment(linker, "/export:QueryUmsThreadInformation=kernel32.QueryUmsThreadInformation,@946") +#pragma comment(linker, "/export:QueryUnbiasedInterruptTime=kernel32.QueryUnbiasedInterruptTime,@947") +#pragma comment(linker, "/export:QueueUserAPC=kernel32.QueueUserAPC,@948") +#pragma comment(linker, "/export:QueueUserWorkItem=kernel32.QueueUserWorkItem,@949") +#pragma comment(linker, "/export:RaiseException=kernel32.RaiseException,@950") +#pragma comment(linker, "/export:RaiseFailFastException=kernel32.RaiseFailFastException,@951") +#pragma comment(linker, "/export:ReOpenFile=kernel32.ReOpenFile,@952") +#pragma comment(linker, "/export:ReadConsoleA=kernel32.ReadConsoleA,@953") +#pragma comment(linker, "/export:ReadConsoleInputA=kernel32.ReadConsoleInputA,@954") +#pragma comment(linker, "/export:ReadConsoleInputExA=kernel32.ReadConsoleInputExA,@955") +#pragma comment(linker, "/export:ReadConsoleInputExW=kernel32.ReadConsoleInputExW,@956") +#pragma comment(linker, "/export:ReadConsoleInputW=kernel32.ReadConsoleInputW,@957") +#pragma comment(linker, "/export:ReadConsoleOutputA=kernel32.ReadConsoleOutputA,@958") +#pragma comment(linker, "/export:ReadConsoleOutputAttribute=kernel32.ReadConsoleOutputAttribute,@959") +#pragma comment(linker, "/export:ReadConsoleOutputCharacterA=kernel32.ReadConsoleOutputCharacterA,@960") +#pragma comment(linker, "/export:ReadConsoleOutputCharacterW=kernel32.ReadConsoleOutputCharacterW,@961") +#pragma comment(linker, "/export:ReadConsoleOutputW=kernel32.ReadConsoleOutputW,@962") +#pragma comment(linker, "/export:ReadConsoleW=kernel32.ReadConsoleW,@963") +#pragma comment(linker, "/export:ReadDirectoryChangesW=kernel32.ReadDirectoryChangesW,@964") +#pragma comment(linker, "/export:ReadFile=kernel32.ReadFile,@965") +#pragma comment(linker, "/export:ReadFileEx=kernel32.ReadFileEx,@966") +#pragma comment(linker, "/export:ReadFileScatter=kernel32.ReadFileScatter,@967") +#pragma comment(linker, "/export:ReadProcessMemory=kernel32.ReadProcessMemory,@968") +#pragma comment(linker, "/export:ReadThreadProfilingData=kernel32.ReadThreadProfilingData,@969") +#pragma comment(linker, "/export:RegCloseKey=kernel32.RegCloseKey,@970") +#pragma comment(linker, "/export:RegCreateKeyExA=kernel32.RegCreateKeyExA,@971") +#pragma comment(linker, "/export:RegCreateKeyExW=kernel32.RegCreateKeyExW,@972") +#pragma comment(linker, "/export:RegDeleteKeyExA=kernel32.RegDeleteKeyExA,@973") +#pragma comment(linker, "/export:RegDeleteKeyExW=kernel32.RegDeleteKeyExW,@974") +#pragma comment(linker, "/export:RegDeleteTreeA=kernel32.RegDeleteTreeA,@975") +#pragma comment(linker, "/export:RegDeleteTreeW=kernel32.RegDeleteTreeW,@976") +#pragma comment(linker, "/export:RegDeleteValueA=kernel32.RegDeleteValueA,@977") +#pragma comment(linker, "/export:RegDeleteValueW=kernel32.RegDeleteValueW,@978") +#pragma comment(linker, "/export:RegDisablePredefinedCacheEx=kernel32.RegDisablePredefinedCacheEx,@979") +#pragma comment(linker, "/export:RegEnumKeyExA=kernel32.RegEnumKeyExA,@980") +#pragma comment(linker, "/export:RegEnumKeyExW=kernel32.RegEnumKeyExW,@981") +#pragma comment(linker, "/export:RegEnumValueA=kernel32.RegEnumValueA,@982") +#pragma comment(linker, "/export:RegEnumValueW=kernel32.RegEnumValueW,@983") +#pragma comment(linker, "/export:RegFlushKey=kernel32.RegFlushKey,@984") +#pragma comment(linker, "/export:RegGetKeySecurity=kernel32.RegGetKeySecurity,@985") +#pragma comment(linker, "/export:RegGetValueA=kernel32.RegGetValueA,@986") +#pragma comment(linker, "/export:RegGetValueW=kernel32.RegGetValueW,@987") +#pragma comment(linker, "/export:RegKrnGetGlobalState=kernel32.RegKrnGetGlobalState,@988") +#pragma comment(linker, "/export:RegKrnInitialize=kernel32.RegKrnInitialize,@989") +#pragma comment(linker, "/export:RegLoadKeyA=kernel32.RegLoadKeyA,@990") +#pragma comment(linker, "/export:RegLoadKeyW=kernel32.RegLoadKeyW,@991") +#pragma comment(linker, "/export:RegLoadMUIStringA=kernel32.RegLoadMUIStringA,@992") +#pragma comment(linker, "/export:RegLoadMUIStringW=kernel32.RegLoadMUIStringW,@993") +#pragma comment(linker, "/export:RegNotifyChangeKeyValue=kernel32.RegNotifyChangeKeyValue,@994") +#pragma comment(linker, "/export:RegOpenCurrentUser=kernel32.RegOpenCurrentUser,@995") +#pragma comment(linker, "/export:RegOpenKeyExA=kernel32.RegOpenKeyExA,@996") +#pragma comment(linker, "/export:RegOpenKeyExW=kernel32.RegOpenKeyExW,@997") +#pragma comment(linker, "/export:RegOpenUserClassesRoot=kernel32.RegOpenUserClassesRoot,@998") +#pragma comment(linker, "/export:RegQueryInfoKeyA=kernel32.RegQueryInfoKeyA,@999") +#pragma comment(linker, "/export:RegQueryInfoKeyW=kernel32.RegQueryInfoKeyW,@1000") +#pragma comment(linker, "/export:RegQueryValueExA=kernel32.RegQueryValueExA,@1001") +#pragma comment(linker, "/export:RegQueryValueExW=kernel32.RegQueryValueExW,@1002") +#pragma comment(linker, "/export:RegRestoreKeyA=kernel32.RegRestoreKeyA,@1003") +#pragma comment(linker, "/export:RegRestoreKeyW=kernel32.RegRestoreKeyW,@1004") +#pragma comment(linker, "/export:RegSaveKeyExA=kernel32.RegSaveKeyExA,@1005") +#pragma comment(linker, "/export:RegSaveKeyExW=kernel32.RegSaveKeyExW,@1006") +#pragma comment(linker, "/export:RegSetKeySecurity=kernel32.RegSetKeySecurity,@1007") +#pragma comment(linker, "/export:RegSetValueExA=kernel32.RegSetValueExA,@1008") +#pragma comment(linker, "/export:RegSetValueExW=kernel32.RegSetValueExW,@1009") +#pragma comment(linker, "/export:RegUnLoadKeyA=kernel32.RegUnLoadKeyA,@1010") +#pragma comment(linker, "/export:RegUnLoadKeyW=kernel32.RegUnLoadKeyW,@1011") +#pragma comment(linker, "/export:RegisterApplicationRecoveryCallback=kernel32.RegisterApplicationRecoveryCallback,@1012") +#pragma comment(linker, "/export:RegisterApplicationRestart=kernel32.RegisterApplicationRestart,@1013") +#pragma comment(linker, "/export:RegisterConsoleIME=kernel32.RegisterConsoleIME,@1014") +#pragma comment(linker, "/export:RegisterConsoleOS2=kernel32.RegisterConsoleOS2,@1015") +#pragma comment(linker, "/export:RegisterConsoleVDM=kernel32.RegisterConsoleVDM,@1016") +#pragma comment(linker, "/export:RegisterWaitForInputIdle=kernel32.RegisterWaitForInputIdle,@1017") +#pragma comment(linker, "/export:RegisterWaitForSingleObject=kernel32.RegisterWaitForSingleObject,@1018") +#pragma comment(linker, "/export:RegisterWaitForSingleObjectEx=kernel32.RegisterWaitForSingleObjectEx,@1019") +#pragma comment(linker, "/export:RegisterWowBaseHandlers=kernel32.RegisterWowBaseHandlers,@1020") +#pragma comment(linker, "/export:RegisterWowExec=kernel32.RegisterWowExec,@1021") +#pragma comment(linker, "/export:ReleaseActCtx=kernel32.ReleaseActCtx,@1022") +#pragma comment(linker, "/export:ReleaseMutex=kernel32.ReleaseMutex,@1023") +#pragma comment(linker, "/export:ReleaseMutexWhenCallbackReturns=kernel32.ReleaseMutexWhenCallbackReturns,@1024") +#pragma comment(linker, "/export:ReleaseSRWLockExclusive=kernel32.ReleaseSRWLockExclusive,@1025") +#pragma comment(linker, "/export:ReleaseSRWLockShared=kernel32.ReleaseSRWLockShared,@1026") +#pragma comment(linker, "/export:ReleaseSemaphore=kernel32.ReleaseSemaphore,@1027") +#pragma comment(linker, "/export:ReleaseSemaphoreWhenCallbackReturns=kernel32.ReleaseSemaphoreWhenCallbackReturns,@1028") +#pragma comment(linker, "/export:RemoveDirectoryA=kernel32.RemoveDirectoryA,@1029") +#pragma comment(linker, "/export:RemoveDirectoryTransactedA=kernel32.RemoveDirectoryTransactedA,@1030") +#pragma comment(linker, "/export:RemoveDirectoryTransactedW=kernel32.RemoveDirectoryTransactedW,@1031") +#pragma comment(linker, "/export:RemoveDirectoryW=kernel32.RemoveDirectoryW,@1032") +#pragma comment(linker, "/export:RemoveDllDirectory=kernel32.RemoveDllDirectory,@1033") +#pragma comment(linker, "/export:RemoveLocalAlternateComputerNameA=kernel32.RemoveLocalAlternateComputerNameA,@1034") +#pragma comment(linker, "/export:RemoveLocalAlternateComputerNameW=kernel32.RemoveLocalAlternateComputerNameW,@1035") +#pragma comment(linker, "/export:RemoveSecureMemoryCacheCallback=kernel32.RemoveSecureMemoryCacheCallback,@1036") +#pragma comment(linker, "/export:RemoveVectoredContinueHandler=kernel32.RemoveVectoredContinueHandler,@1037") +#pragma comment(linker, "/export:RemoveVectoredExceptionHandler=kernel32.RemoveVectoredExceptionHandler,@1038") +#pragma comment(linker, "/export:ReplaceFile=kernel32.ReplaceFile,@1039") +#pragma comment(linker, "/export:ReplaceFileA=kernel32.ReplaceFileA,@1040") +#pragma comment(linker, "/export:ReplaceFileW=kernel32.ReplaceFileW,@1041") +#pragma comment(linker, "/export:ReplacePartitionUnit=kernel32.ReplacePartitionUnit,@1042") +#pragma comment(linker, "/export:RequestDeviceWakeup=kernel32.RequestDeviceWakeup,@1043") +#pragma comment(linker, "/export:RequestWakeupLatency=kernel32.RequestWakeupLatency,@1044") +#pragma comment(linker, "/export:ResetEvent=kernel32.ResetEvent,@1045") +#pragma comment(linker, "/export:ResetWriteWatch=kernel32.ResetWriteWatch,@1046") +#pragma comment(linker, "/export:ResolveLocaleName=kernel32.ResolveLocaleName,@1047") +#pragma comment(linker, "/export:RestoreLastError=kernel32.RestoreLastError,@1048") +#pragma comment(linker, "/export:ResumeThread=kernel32.ResumeThread,@1049") +#pragma comment(linker, "/export:RtlAddFunctionTable=kernel32.RtlAddFunctionTable,@1050") +#pragma comment(linker, "/export:RtlCaptureContext=kernel32.RtlCaptureContext,@1051") +#pragma comment(linker, "/export:RtlCaptureStackBackTrace=kernel32.RtlCaptureStackBackTrace,@1052") +#pragma comment(linker, "/export:RtlCompareMemory=kernel32.RtlCompareMemory,@1053") +#pragma comment(linker, "/export:RtlCopyMemory=kernel32.RtlCopyMemory,@1054") +#pragma comment(linker, "/export:RtlDeleteFunctionTable=kernel32.RtlDeleteFunctionTable,@1055") +#pragma comment(linker, "/export:RtlFillMemory=kernel32.RtlFillMemory,@1056") +#pragma comment(linker, "/export:RtlInstallFunctionTableCallback=kernel32.RtlInstallFunctionTableCallback,@1057") +#pragma comment(linker, "/export:RtlLookupFunctionEntry=kernel32.RtlLookupFunctionEntry,@1058") +#pragma comment(linker, "/export:RtlMoveMemory=kernel32.RtlMoveMemory,@1059") +#pragma comment(linker, "/export:RtlPcToFileHeader=kernel32.RtlPcToFileHeader,@1060") +#pragma comment(linker, "/export:RtlRaiseException=kernel32.RtlRaiseException,@1061") +#pragma comment(linker, "/export:RtlRestoreContext=kernel32.RtlRestoreContext,@1062") +#pragma comment(linker, "/export:RtlUnwind=kernel32.RtlUnwind,@1063") +#pragma comment(linker, "/export:RtlUnwindEx=kernel32.RtlUnwindEx,@1064") +#pragma comment(linker, "/export:RtlVirtualUnwind=kernel32.RtlVirtualUnwind,@1065") +#pragma comment(linker, "/export:RtlZeroMemory=kernel32.RtlZeroMemory,@1066") +#pragma comment(linker, "/export:ScrollConsoleScreenBufferA=kernel32.ScrollConsoleScreenBufferA,@1067") +#pragma comment(linker, "/export:ScrollConsoleScreenBufferW=kernel32.ScrollConsoleScreenBufferW,@1068") +#pragma comment(linker, "/export:SearchPathA=kernel32.SearchPathA,@1069") +#pragma comment(linker, "/export:SearchPathW=kernel32.SearchPathW,@1070") +#pragma comment(linker, "/export:SetCalendarInfoA=kernel32.SetCalendarInfoA,@1071") +#pragma comment(linker, "/export:SetCalendarInfoW=kernel32.SetCalendarInfoW,@1072") +#pragma comment(linker, "/export:SetClientDynamicTimeZoneInformation=kernel32.SetClientDynamicTimeZoneInformation,@1073") +#pragma comment(linker, "/export:SetClientTimeZoneInformation=kernel32.SetClientTimeZoneInformation,@1074") +#pragma comment(linker, "/export:SetComPlusPackageInstallStatus=kernel32.SetComPlusPackageInstallStatus,@1075") +#pragma comment(linker, "/export:SetCommBreak=kernel32.SetCommBreak,@1076") +#pragma comment(linker, "/export:SetCommConfig=kernel32.SetCommConfig,@1077") +#pragma comment(linker, "/export:SetCommMask=kernel32.SetCommMask,@1078") +#pragma comment(linker, "/export:SetCommState=kernel32.SetCommState,@1079") +#pragma comment(linker, "/export:SetCommTimeouts=kernel32.SetCommTimeouts,@1080") +#pragma comment(linker, "/export:SetComputerNameA=kernel32.SetComputerNameA,@1081") +#pragma comment(linker, "/export:SetComputerNameExA=kernel32.SetComputerNameExA,@1082") +#pragma comment(linker, "/export:SetComputerNameExW=kernel32.SetComputerNameExW,@1083") +#pragma comment(linker, "/export:SetComputerNameW=kernel32.SetComputerNameW,@1084") +#pragma comment(linker, "/export:SetConsoleActiveScreenBuffer=kernel32.SetConsoleActiveScreenBuffer,@1085") +#pragma comment(linker, "/export:SetConsoleCP=kernel32.SetConsoleCP,@1086") +#pragma comment(linker, "/export:SetConsoleCtrlHandler=kernel32.SetConsoleCtrlHandler,@1087") +#pragma comment(linker, "/export:SetConsoleCursor=kernel32.SetConsoleCursor,@1088") +#pragma comment(linker, "/export:SetConsoleCursorInfo=kernel32.SetConsoleCursorInfo,@1089") +#pragma comment(linker, "/export:SetConsoleCursorMode=kernel32.SetConsoleCursorMode,@1090") +#pragma comment(linker, "/export:SetConsoleCursorPosition=kernel32.SetConsoleCursorPosition,@1091") +#pragma comment(linker, "/export:SetConsoleDisplayMode=kernel32.SetConsoleDisplayMode,@1092") +#pragma comment(linker, "/export:SetConsoleFont=kernel32.SetConsoleFont,@1093") +#pragma comment(linker, "/export:SetConsoleHardwareState=kernel32.SetConsoleHardwareState,@1094") +#pragma comment(linker, "/export:SetConsoleHistoryInfo=kernel32.SetConsoleHistoryInfo,@1095") +#pragma comment(linker, "/export:SetConsoleIcon=kernel32.SetConsoleIcon,@1096") +#pragma comment(linker, "/export:SetConsoleInputExeNameA=kernel32.SetConsoleInputExeNameA,@1097") +#pragma comment(linker, "/export:SetConsoleInputExeNameW=kernel32.SetConsoleInputExeNameW,@1098") +#pragma comment(linker, "/export:SetConsoleKeyShortcuts=kernel32.SetConsoleKeyShortcuts,@1099") +#pragma comment(linker, "/export:SetConsoleLocalEUDC=kernel32.SetConsoleLocalEUDC,@1100") +#pragma comment(linker, "/export:SetConsoleMaximumWindowSize=kernel32.SetConsoleMaximumWindowSize,@1101") +#pragma comment(linker, "/export:SetConsoleMenuClose=kernel32.SetConsoleMenuClose,@1102") +#pragma comment(linker, "/export:SetConsoleMode=kernel32.SetConsoleMode,@1103") +#pragma comment(linker, "/export:SetConsoleNlsMode=kernel32.SetConsoleNlsMode,@1104") +#pragma comment(linker, "/export:SetConsoleNumberOfCommandsA=kernel32.SetConsoleNumberOfCommandsA,@1105") +#pragma comment(linker, "/export:SetConsoleNumberOfCommandsW=kernel32.SetConsoleNumberOfCommandsW,@1106") +#pragma comment(linker, "/export:SetConsoleOS2OemFormat=kernel32.SetConsoleOS2OemFormat,@1107") +#pragma comment(linker, "/export:SetConsoleOutputCP=kernel32.SetConsoleOutputCP,@1108") +#pragma comment(linker, "/export:SetConsolePalette=kernel32.SetConsolePalette,@1109") +#pragma comment(linker, "/export:SetConsoleScreenBufferInfoEx=kernel32.SetConsoleScreenBufferInfoEx,@1110") +#pragma comment(linker, "/export:SetConsoleScreenBufferSize=kernel32.SetConsoleScreenBufferSize,@1111") +#pragma comment(linker, "/export:SetConsoleTextAttribute=kernel32.SetConsoleTextAttribute,@1112") +#pragma comment(linker, "/export:SetConsoleTitleA=kernel32.SetConsoleTitleA,@1113") +#pragma comment(linker, "/export:SetConsoleTitleW=kernel32.SetConsoleTitleW,@1114") +#pragma comment(linker, "/export:SetConsoleWindowInfo=kernel32.SetConsoleWindowInfo,@1115") +#pragma comment(linker, "/export:SetCriticalSectionSpinCount=kernel32.SetCriticalSectionSpinCount,@1116") +#pragma comment(linker, "/export:SetCurrentConsoleFontEx=kernel32.SetCurrentConsoleFontEx,@1117") +#pragma comment(linker, "/export:SetCurrentDirectoryA=kernel32.SetCurrentDirectoryA,@1118") +#pragma comment(linker, "/export:SetCurrentDirectoryW=kernel32.SetCurrentDirectoryW,@1119") +#pragma comment(linker, "/export:SetDefaultCommConfigA=kernel32.SetDefaultCommConfigA,@1120") +#pragma comment(linker, "/export:SetDefaultCommConfigW=kernel32.SetDefaultCommConfigW,@1121") +#pragma comment(linker, "/export:SetDefaultDllDirectories=kernel32.SetDefaultDllDirectories,@1122") +#pragma comment(linker, "/export:SetDllDirectoryA=kernel32.SetDllDirectoryA,@1123") +#pragma comment(linker, "/export:SetDllDirectoryW=kernel32.SetDllDirectoryW,@1124") +#pragma comment(linker, "/export:SetDynamicTimeZoneInformation=kernel32.SetDynamicTimeZoneInformation,@1125") +#pragma comment(linker, "/export:SetEndOfFile=kernel32.SetEndOfFile,@1126") +#pragma comment(linker, "/export:SetEnvironmentStringsA=kernel32.SetEnvironmentStringsA,@1127") +#pragma comment(linker, "/export:SetEnvironmentStringsW=kernel32.SetEnvironmentStringsW,@1128") +#pragma comment(linker, "/export:SetEnvironmentVariableA=kernel32.SetEnvironmentVariableA,@1129") +#pragma comment(linker, "/export:SetEnvironmentVariableW=kernel32.SetEnvironmentVariableW,@1130") +#pragma comment(linker, "/export:SetErrorMode=kernel32.SetErrorMode,@1131") +#pragma comment(linker, "/export:SetEvent=kernel32.SetEvent,@1132") +#pragma comment(linker, "/export:SetEventWhenCallbackReturns=kernel32.SetEventWhenCallbackReturns,@1133") +#pragma comment(linker, "/export:SetFileApisToANSI=kernel32.SetFileApisToANSI,@1134") +#pragma comment(linker, "/export:SetFileApisToOEM=kernel32.SetFileApisToOEM,@1135") +#pragma comment(linker, "/export:SetFileAttributesA=kernel32.SetFileAttributesA,@1136") +#pragma comment(linker, "/export:SetFileAttributesTransactedA=kernel32.SetFileAttributesTransactedA,@1137") +#pragma comment(linker, "/export:SetFileAttributesTransactedW=kernel32.SetFileAttributesTransactedW,@1138") +#pragma comment(linker, "/export:SetFileAttributesW=kernel32.SetFileAttributesW,@1139") +#pragma comment(linker, "/export:SetFileBandwidthReservation=kernel32.SetFileBandwidthReservation,@1140") +#pragma comment(linker, "/export:SetFileCompletionNotificationModes=kernel32.SetFileCompletionNotificationModes,@1141") +#pragma comment(linker, "/export:SetFileInformationByHandle=kernel32.SetFileInformationByHandle,@1142") +#pragma comment(linker, "/export:SetFileIoOverlappedRange=kernel32.SetFileIoOverlappedRange,@1143") +#pragma comment(linker, "/export:SetFilePointer=kernel32.SetFilePointer,@1144") +#pragma comment(linker, "/export:SetFilePointerEx=kernel32.SetFilePointerEx,@1145") +#pragma comment(linker, "/export:SetFileShortNameA=kernel32.SetFileShortNameA,@1146") +#pragma comment(linker, "/export:SetFileShortNameW=kernel32.SetFileShortNameW,@1147") +#pragma comment(linker, "/export:SetFileTime=kernel32.SetFileTime,@1148") +#pragma comment(linker, "/export:SetFileValidData=kernel32.SetFileValidData,@1149") +#pragma comment(linker, "/export:SetFirmwareEnvironmentVariableA=kernel32.SetFirmwareEnvironmentVariableA,@1150") +#pragma comment(linker, "/export:SetFirmwareEnvironmentVariableW=kernel32.SetFirmwareEnvironmentVariableW,@1151") +#pragma comment(linker, "/export:SetHandleCount=kernel32.SetHandleCount,@1152") +#pragma comment(linker, "/export:SetHandleInformation=kernel32.SetHandleInformation,@1153") +#pragma comment(linker, "/export:SetInformationJobObject=kernel32.SetInformationJobObject,@1154") +#pragma comment(linker, "/export:SetLastConsoleEventActive=kernel32.SetLastConsoleEventActive,@1155") +#pragma comment(linker, "/export:SetLastError=kernel32.SetLastError,@1156") +#pragma comment(linker, "/export:SetLocalPrimaryComputerNameA=kernel32.SetLocalPrimaryComputerNameA,@1157") +#pragma comment(linker, "/export:SetLocalPrimaryComputerNameW=kernel32.SetLocalPrimaryComputerNameW,@1158") +#pragma comment(linker, "/export:SetLocalTime=kernel32.SetLocalTime,@1159") +#pragma comment(linker, "/export:SetLocaleInfoA=kernel32.SetLocaleInfoA,@1160") +#pragma comment(linker, "/export:SetLocaleInfoW=kernel32.SetLocaleInfoW,@1161") +#pragma comment(linker, "/export:SetMailslotInfo=kernel32.SetMailslotInfo,@1162") +#pragma comment(linker, "/export:SetMessageWaitingIndicator=kernel32.SetMessageWaitingIndicator,@1163") +#pragma comment(linker, "/export:SetNamedPipeAttribute=kernel32.SetNamedPipeAttribute,@1164") +#pragma comment(linker, "/export:SetNamedPipeHandleState=kernel32.SetNamedPipeHandleState,@1165") +#pragma comment(linker, "/export:SetPriorityClass=kernel32.SetPriorityClass,@1166") +#pragma comment(linker, "/export:SetProcessAffinityMask=kernel32.SetProcessAffinityMask,@1167") +#pragma comment(linker, "/export:SetProcessAffinityUpdateMode=kernel32.SetProcessAffinityUpdateMode,@1168") +#pragma comment(linker, "/export:SetProcessDEPPolicy=kernel32.SetProcessDEPPolicy,@1169") +#pragma comment(linker, "/export:SetProcessPreferredUILanguages=kernel32.SetProcessPreferredUILanguages,@1170") +#pragma comment(linker, "/export:SetProcessPriorityBoost=kernel32.SetProcessPriorityBoost,@1171") +#pragma comment(linker, "/export:SetProcessShutdownParameters=kernel32.SetProcessShutdownParameters,@1172") +#pragma comment(linker, "/export:SetProcessUserModeExceptionPolicy=kernel32.SetProcessUserModeExceptionPolicy,@1173") +#pragma comment(linker, "/export:SetProcessWorkingSetSize=kernel32.SetProcessWorkingSetSize,@1174") +#pragma comment(linker, "/export:SetProcessWorkingSetSizeEx=kernel32.SetProcessWorkingSetSizeEx,@1175") +#pragma comment(linker, "/export:SetSearchPathMode=kernel32.SetSearchPathMode,@1176") +#pragma comment(linker, "/export:SetStdHandle=kernel32.SetStdHandle,@1177") +#pragma comment(linker, "/export:SetStdHandleEx=kernel32.SetStdHandleEx,@1178") +#pragma comment(linker, "/export:SetSystemFileCacheSize=kernel32.SetSystemFileCacheSize,@1179") +#pragma comment(linker, "/export:SetSystemPowerState=kernel32.SetSystemPowerState,@1180") +#pragma comment(linker, "/export:SetSystemTime=kernel32.SetSystemTime,@1181") +#pragma comment(linker, "/export:SetSystemTimeAdjustment=kernel32.SetSystemTimeAdjustment,@1182") +#pragma comment(linker, "/export:SetTapeParameters=kernel32.SetTapeParameters,@1183") +#pragma comment(linker, "/export:SetTapePosition=kernel32.SetTapePosition,@1184") +#pragma comment(linker, "/export:SetTermsrvAppInstallMode=kernel32.SetTermsrvAppInstallMode,@1185") +#pragma comment(linker, "/export:SetThreadAffinityMask=kernel32.SetThreadAffinityMask,@1186") +#pragma comment(linker, "/export:SetThreadContext=kernel32.SetThreadContext,@1187") +#pragma comment(linker, "/export:SetThreadErrorMode=kernel32.SetThreadErrorMode,@1188") +#pragma comment(linker, "/export:SetThreadExecutionState=kernel32.SetThreadExecutionState,@1189") +#pragma comment(linker, "/export:SetThreadGroupAffinity=kernel32.SetThreadGroupAffinity,@1190") +#pragma comment(linker, "/export:SetThreadIdealProcessor=kernel32.SetThreadIdealProcessor,@1191") +#pragma comment(linker, "/export:SetThreadIdealProcessorEx=kernel32.SetThreadIdealProcessorEx,@1192") +#pragma comment(linker, "/export:SetThreadLocale=kernel32.SetThreadLocale,@1193") +#pragma comment(linker, "/export:SetThreadPreferredUILanguages=kernel32.SetThreadPreferredUILanguages,@1194") +#pragma comment(linker, "/export:SetThreadPriority=kernel32.SetThreadPriority,@1195") +#pragma comment(linker, "/export:SetThreadPriorityBoost=kernel32.SetThreadPriorityBoost,@1196") +#pragma comment(linker, "/export:SetThreadStackGuarantee=kernel32.SetThreadStackGuarantee,@1197") +#pragma comment(linker, "/export:SetThreadToken=kernel32.SetThreadToken,@1198") +#pragma comment(linker, "/export:SetThreadUILanguage=kernel32.SetThreadUILanguage,@1199") +#pragma comment(linker, "/export:SetThreadpoolStackInformation=kernel32.SetThreadpoolStackInformation,@1200") +#pragma comment(linker, "/export:SetThreadpoolThreadMaximum=kernel32.SetThreadpoolThreadMaximum,@1201") +#pragma comment(linker, "/export:SetThreadpoolThreadMinimum=kernel32.SetThreadpoolThreadMinimum,@1202") +#pragma comment(linker, "/export:SetThreadpoolTimer=kernel32.SetThreadpoolTimer,@1203") +#pragma comment(linker, "/export:SetThreadpoolWait=kernel32.SetThreadpoolWait,@1204") +#pragma comment(linker, "/export:SetTimeZoneInformation=kernel32.SetTimeZoneInformation,@1205") +#pragma comment(linker, "/export:SetTimerQueueTimer=kernel32.SetTimerQueueTimer,@1206") +#pragma comment(linker, "/export:SetUmsThreadInformation=kernel32.SetUmsThreadInformation,@1207") +#pragma comment(linker, "/export:SetUnhandledExceptionFilter=kernel32.SetUnhandledExceptionFilter,@1208") +#pragma comment(linker, "/export:SetUserGeoID=kernel32.SetUserGeoID,@1209") +#pragma comment(linker, "/export:SetVDMCurrentDirectories=kernel32.SetVDMCurrentDirectories,@1210") +#pragma comment(linker, "/export:SetVolumeLabelA=kernel32.SetVolumeLabelA,@1211") +#pragma comment(linker, "/export:SetVolumeLabelW=kernel32.SetVolumeLabelW,@1212") +#pragma comment(linker, "/export:SetVolumeMountPointA=kernel32.SetVolumeMountPointA,@1213") +#pragma comment(linker, "/export:SetVolumeMountPointW=kernel32.SetVolumeMountPointW,@1214") +#pragma comment(linker, "/export:SetWaitableTimer=kernel32.SetWaitableTimer,@1215") +#pragma comment(linker, "/export:SetWaitableTimerEx=kernel32.SetWaitableTimerEx,@1216") +#pragma comment(linker, "/export:SetXStateFeaturesMask=kernel32.SetXStateFeaturesMask,@1217") +#pragma comment(linker, "/export:SetupComm=kernel32.SetupComm,@1218") +#pragma comment(linker, "/export:ShowConsoleCursor=kernel32.ShowConsoleCursor,@1219") +#pragma comment(linker, "/export:SignalObjectAndWait=kernel32.SignalObjectAndWait,@1220") +#pragma comment(linker, "/export:SizeofResource=kernel32.SizeofResource,@1221") +#pragma comment(linker, "/export:Sleep=kernel32.Sleep,@1222") +#pragma comment(linker, "/export:SleepConditionVariableCS=kernel32.SleepConditionVariableCS,@1223") +#pragma comment(linker, "/export:SleepConditionVariableSRW=kernel32.SleepConditionVariableSRW,@1224") +#pragma comment(linker, "/export:SleepEx=kernel32.SleepEx,@1225") +#pragma comment(linker, "/export:SortCloseHandle=kernel32.SortCloseHandle,@1226") +#pragma comment(linker, "/export:SortGetHandle=kernel32.SortGetHandle,@1227") +#pragma comment(linker, "/export:StartThreadpoolIo=kernel32.StartThreadpoolIo,@1228") +#pragma comment(linker, "/export:SubmitThreadpoolWork=kernel32.SubmitThreadpoolWork,@1229") +#pragma comment(linker, "/export:SuspendThread=kernel32.SuspendThread,@1230") +#pragma comment(linker, "/export:SwitchToFiber=kernel32.SwitchToFiber,@1231") +#pragma comment(linker, "/export:SwitchToThread=kernel32.SwitchToThread,@1232") +#pragma comment(linker, "/export:SystemTimeToFileTime=kernel32.SystemTimeToFileTime,@1233") +#pragma comment(linker, "/export:SystemTimeToTzSpecificLocalTime=kernel32.SystemTimeToTzSpecificLocalTime,@1234") +#pragma comment(linker, "/export:SystemTimeToTzSpecificLocalTimeEx=kernel32.SystemTimeToTzSpecificLocalTimeEx,@1235") +#pragma comment(linker, "/export:TerminateJobObject=kernel32.TerminateJobObject,@1236") +#pragma comment(linker, "/export:TerminateProcess=kernel32.TerminateProcess,@1237") +#pragma comment(linker, "/export:TerminateThread=kernel32.TerminateThread,@1238") +#pragma comment(linker, "/export:TermsrvAppInstallMode=kernel32.TermsrvAppInstallMode,@1239") +#pragma comment(linker, "/export:Thread32First=kernel32.Thread32First,@1240") +#pragma comment(linker, "/export:Thread32Next=kernel32.Thread32Next,@1241") +#pragma comment(linker, "/export:TlsAlloc=kernel32.TlsAlloc,@1242") +#pragma comment(linker, "/export:TlsFree=kernel32.TlsFree,@1243") +#pragma comment(linker, "/export:TlsGetValue=kernel32.TlsGetValue,@1244") +#pragma comment(linker, "/export:TlsSetValue=kernel32.TlsSetValue,@1245") +#pragma comment(linker, "/export:Toolhelp32ReadProcessMemory=kernel32.Toolhelp32ReadProcessMemory,@1246") +#pragma comment(linker, "/export:TransactNamedPipe=kernel32.TransactNamedPipe,@1247") +#pragma comment(linker, "/export:TransmitCommChar=kernel32.TransmitCommChar,@1248") +#pragma comment(linker, "/export:TryAcquireSRWLockExclusive=kernel32.TryAcquireSRWLockExclusive,@1249") +#pragma comment(linker, "/export:TryAcquireSRWLockShared=kernel32.TryAcquireSRWLockShared,@1250") +#pragma comment(linker, "/export:TryEnterCriticalSection=kernel32.TryEnterCriticalSection,@1251") +#pragma comment(linker, "/export:TrySubmitThreadpoolCallback=kernel32.TrySubmitThreadpoolCallback,@1252") +#pragma comment(linker, "/export:TzSpecificLocalTimeToSystemTime=kernel32.TzSpecificLocalTimeToSystemTime,@1253") +#pragma comment(linker, "/export:TzSpecificLocalTimeToSystemTimeEx=kernel32.TzSpecificLocalTimeToSystemTimeEx,@1254") +#pragma comment(linker, "/export:UTRegister=kernel32.UTRegister,@1255") +#pragma comment(linker, "/export:UTUnRegister=kernel32.UTUnRegister,@1256") +#pragma comment(linker, "/export:UmsThreadYield=kernel32.UmsThreadYield,@1257") +#pragma comment(linker, "/export:UnhandledExceptionFilter=kernel32.UnhandledExceptionFilter,@1258") +#pragma comment(linker, "/export:UnlockFile=kernel32.UnlockFile,@1259") +#pragma comment(linker, "/export:UnlockFileEx=kernel32.UnlockFileEx,@1260") +#pragma comment(linker, "/export:UnmapViewOfFile=kernel32.UnmapViewOfFile,@1261") +#pragma comment(linker, "/export:UnregisterApplicationRecoveryCallback=kernel32.UnregisterApplicationRecoveryCallback,@1262") +#pragma comment(linker, "/export:UnregisterApplicationRestart=kernel32.UnregisterApplicationRestart,@1263") +#pragma comment(linker, "/export:UnregisterConsoleIME=kernel32.UnregisterConsoleIME,@1264") +#pragma comment(linker, "/export:UnregisterWait=kernel32.UnregisterWait,@1265") +#pragma comment(linker, "/export:UnregisterWaitEx=kernel32.UnregisterWaitEx,@1266") +#pragma comment(linker, "/export:UpdateCalendarDayOfWeek=kernel32.UpdateCalendarDayOfWeek,@1267") +#pragma comment(linker, "/export:UpdateProcThreadAttribute=kernel32.UpdateProcThreadAttribute,@1268") +#pragma comment(linker, "/export:UpdateResourceA=kernel32.UpdateResourceA,@1269") +#pragma comment(linker, "/export:UpdateResourceW=kernel32.UpdateResourceW,@1270") +#pragma comment(linker, "/export:VDMConsoleOperation=kernel32.VDMConsoleOperation,@1271") +#pragma comment(linker, "/export:VDMOperationStarted=kernel32.VDMOperationStarted,@1272") +#pragma comment(linker, "/export:VerLanguageNameA=kernel32.VerLanguageNameA,@1273") +#pragma comment(linker, "/export:VerLanguageNameW=kernel32.VerLanguageNameW,@1274") +#pragma comment(linker, "/export:VerSetConditionMask=kernel32.VerSetConditionMask,@1275") +#pragma comment(linker, "/export:VerifyConsoleIoHandle=kernel32.VerifyConsoleIoHandle,@1276") +#pragma comment(linker, "/export:VerifyScripts=kernel32.VerifyScripts,@1277") +#pragma comment(linker, "/export:VerifyVersionInfoA=kernel32.VerifyVersionInfoA,@1278") +#pragma comment(linker, "/export:VerifyVersionInfoW=kernel32.VerifyVersionInfoW,@1279") +#pragma comment(linker, "/export:VirtualAlloc=kernel32.VirtualAlloc,@1280") +#pragma comment(linker, "/export:VirtualAllocEx=kernel32.VirtualAllocEx,@1281") +#pragma comment(linker, "/export:VirtualAllocExNuma=kernel32.VirtualAllocExNuma,@1282") +#pragma comment(linker, "/export:VirtualFree=kernel32.VirtualFree,@1283") +#pragma comment(linker, "/export:VirtualFreeEx=kernel32.VirtualFreeEx,@1284") +#pragma comment(linker, "/export:VirtualLock=kernel32.VirtualLock,@1285") +#pragma comment(linker, "/export:VirtualProtect=kernel32.VirtualProtect,@1286") +#pragma comment(linker, "/export:VirtualProtectEx=kernel32.VirtualProtectEx,@1287") +#pragma comment(linker, "/export:VirtualQuery=kernel32.VirtualQuery,@1288") +#pragma comment(linker, "/export:VirtualQueryEx=kernel32.VirtualQueryEx,@1289") +#pragma comment(linker, "/export:VirtualUnlock=kernel32.VirtualUnlock,@1290") +#pragma comment(linker, "/export:WTSGetActiveConsoleSessionId=kernel32.WTSGetActiveConsoleSessionId,@1291") +#pragma comment(linker, "/export:WaitCommEvent=kernel32.WaitCommEvent,@1292") +#pragma comment(linker, "/export:WaitForDebugEvent=kernel32.WaitForDebugEvent,@1293") +#pragma comment(linker, "/export:WaitForMultipleObjects=kernel32.WaitForMultipleObjects,@1294") +#pragma comment(linker, "/export:WaitForMultipleObjectsEx=kernel32.WaitForMultipleObjectsEx,@1295") +#pragma comment(linker, "/export:WaitForSingleObject=kernel32.WaitForSingleObject,@1296") +#pragma comment(linker, "/export:WaitForSingleObjectEx=kernel32.WaitForSingleObjectEx,@1297") +#pragma comment(linker, "/export:WaitForThreadpoolIoCallbacks=kernel32.WaitForThreadpoolIoCallbacks,@1298") +#pragma comment(linker, "/export:WaitForThreadpoolTimerCallbacks=kernel32.WaitForThreadpoolTimerCallbacks,@1299") +#pragma comment(linker, "/export:WaitForThreadpoolWaitCallbacks=kernel32.WaitForThreadpoolWaitCallbacks,@1300") +#pragma comment(linker, "/export:WaitForThreadpoolWorkCallbacks=kernel32.WaitForThreadpoolWorkCallbacks,@1301") +#pragma comment(linker, "/export:WaitNamedPipeA=kernel32.WaitNamedPipeA,@1302") +#pragma comment(linker, "/export:WaitNamedPipeW=kernel32.WaitNamedPipeW,@1303") +#pragma comment(linker, "/export:WakeAllConditionVariable=kernel32.WakeAllConditionVariable,@1304") +#pragma comment(linker, "/export:WakeConditionVariable=kernel32.WakeConditionVariable,@1305") +#pragma comment(linker, "/export:WerGetFlags=kernel32.WerGetFlags,@1306") +#pragma comment(linker, "/export:WerRegisterFile=kernel32.WerRegisterFile,@1307") +#pragma comment(linker, "/export:WerRegisterMemoryBlock=kernel32.WerRegisterMemoryBlock,@1308") +#pragma comment(linker, "/export:WerRegisterRuntimeExceptionModule=kernel32.WerRegisterRuntimeExceptionModule,@1309") +#pragma comment(linker, "/export:WerSetFlags=kernel32.WerSetFlags,@1310") +#pragma comment(linker, "/export:WerUnregisterFile=kernel32.WerUnregisterFile,@1311") +#pragma comment(linker, "/export:WerUnregisterMemoryBlock=kernel32.WerUnregisterMemoryBlock,@1312") +#pragma comment(linker, "/export:WerUnregisterRuntimeExceptionModule=kernel32.WerUnregisterRuntimeExceptionModule,@1313") +#pragma comment(linker, "/export:WerpCleanupMessageMapping=kernel32.WerpCleanupMessageMapping,@1314") +#pragma comment(linker, "/export:WerpInitiateRemoteRecovery=kernel32.WerpInitiateRemoteRecovery,@1315") +#pragma comment(linker, "/export:WerpNotifyLoadStringResource=kernel32.WerpNotifyLoadStringResource,@1316") +#pragma comment(linker, "/export:WerpNotifyLoadStringResourceEx=kernel32.WerpNotifyLoadStringResourceEx,@1317") +#pragma comment(linker, "/export:WerpNotifyUseStringResource=kernel32.WerpNotifyUseStringResource,@1318") +#pragma comment(linker, "/export:WerpStringLookup=kernel32.WerpStringLookup,@1319") +#pragma comment(linker, "/export:WideCharToMultiByte=kernel32.WideCharToMultiByte,@1320") +#pragma comment(linker, "/export:WinExec=kernel32.WinExec,@1321") +#pragma comment(linker, "/export:Wow64DisableWow64FsRedirection=kernel32.Wow64DisableWow64FsRedirection,@1322") +#pragma comment(linker, "/export:Wow64EnableWow64FsRedirection=kernel32.Wow64EnableWow64FsRedirection,@1323") +#pragma comment(linker, "/export:Wow64GetThreadContext=kernel32.Wow64GetThreadContext,@1324") +#pragma comment(linker, "/export:Wow64GetThreadSelectorEntry=kernel32.Wow64GetThreadSelectorEntry,@1325") +#pragma comment(linker, "/export:Wow64RevertWow64FsRedirection=kernel32.Wow64RevertWow64FsRedirection,@1326") +#pragma comment(linker, "/export:Wow64SetThreadContext=kernel32.Wow64SetThreadContext,@1327") +#pragma comment(linker, "/export:Wow64SuspendThread=kernel32.Wow64SuspendThread,@1328") +#pragma comment(linker, "/export:WriteConsoleA=kernel32.WriteConsoleA,@1329") +#pragma comment(linker, "/export:WriteConsoleInputA=kernel32.WriteConsoleInputA,@1330") +#pragma comment(linker, "/export:WriteConsoleInputVDMA=kernel32.WriteConsoleInputVDMA,@1331") +#pragma comment(linker, "/export:WriteConsoleInputVDMW=kernel32.WriteConsoleInputVDMW,@1332") +#pragma comment(linker, "/export:WriteConsoleInputW=kernel32.WriteConsoleInputW,@1333") +#pragma comment(linker, "/export:WriteConsoleOutputA=kernel32.WriteConsoleOutputA,@1334") +#pragma comment(linker, "/export:WriteConsoleOutputAttribute=kernel32.WriteConsoleOutputAttribute,@1335") +#pragma comment(linker, "/export:WriteConsoleOutputCharacterA=kernel32.WriteConsoleOutputCharacterA,@1336") +#pragma comment(linker, "/export:WriteConsoleOutputCharacterW=kernel32.WriteConsoleOutputCharacterW,@1337") +#pragma comment(linker, "/export:WriteConsoleOutputW=kernel32.WriteConsoleOutputW,@1338") +#pragma comment(linker, "/export:WriteConsoleW=kernel32.WriteConsoleW,@1339") +#pragma comment(linker, "/export:WriteFile=kernel32.WriteFile,@1340") +#pragma comment(linker, "/export:WriteFileEx=kernel32.WriteFileEx,@1341") +#pragma comment(linker, "/export:WriteFileGather=kernel32.WriteFileGather,@1342") +#pragma comment(linker, "/export:WritePrivateProfileSectionA=kernel32.WritePrivateProfileSectionA,@1343") +#pragma comment(linker, "/export:WritePrivateProfileSectionW=kernel32.WritePrivateProfileSectionW,@1344") +#pragma comment(linker, "/export:WritePrivateProfileStringA=kernel32.WritePrivateProfileStringA,@1345") +#pragma comment(linker, "/export:WritePrivateProfileStringW=kernel32.WritePrivateProfileStringW,@1346") +#pragma comment(linker, "/export:WritePrivateProfileStructA=kernel32.WritePrivateProfileStructA,@1347") +#pragma comment(linker, "/export:WritePrivateProfileStructW=kernel32.WritePrivateProfileStructW,@1348") +#pragma comment(linker, "/export:WriteProcessMemory=kernel32.WriteProcessMemory,@1349") +#pragma comment(linker, "/export:WriteProfileSectionA=kernel32.WriteProfileSectionA,@1350") +#pragma comment(linker, "/export:WriteProfileSectionW=kernel32.WriteProfileSectionW,@1351") +#pragma comment(linker, "/export:WriteProfileStringA=kernel32.WriteProfileStringA,@1352") +#pragma comment(linker, "/export:WriteProfileStringW=kernel32.WriteProfileStringW,@1353") +#pragma comment(linker, "/export:WriteTapemark=kernel32.WriteTapemark,@1354") +#pragma comment(linker, "/export:ZombifyActCtx=kernel32.ZombifyActCtx,@1355") +#pragma comment(linker, "/export:__C_specific_handler=kernel32.__C_specific_handler,@1356") +#pragma comment(linker, "/export:__chkstk=kernel32.__chkstk,@1357") +#pragma comment(linker, "/export:__misaligned_access=kernel32.__misaligned_access,@1358") +#pragma comment(linker, "/export:_hread=kernel32._hread,@1359") +#pragma comment(linker, "/export:_hwrite=kernel32._hwrite,@1360") +#pragma comment(linker, "/export:_lclose=kernel32._lclose,@1361") +#pragma comment(linker, "/export:_lcreat=kernel32._lcreat,@1362") +#pragma comment(linker, "/export:_llseek=kernel32._llseek,@1363") +#pragma comment(linker, "/export:_local_unwind=kernel32._local_unwind,@1364") +#pragma comment(linker, "/export:_lopen=kernel32._lopen,@1365") +#pragma comment(linker, "/export:_lread=kernel32._lread,@1366") +#pragma comment(linker, "/export:_lwrite=kernel32._lwrite,@1367") +#pragma comment(linker, "/export:lstrcat=kernel32.lstrcat,@1368") +#pragma comment(linker, "/export:lstrcatA=kernel32.lstrcatA,@1369") +#pragma comment(linker, "/export:lstrcatW=kernel32.lstrcatW,@1370") +#pragma comment(linker, "/export:lstrcmp=kernel32.lstrcmp,@1371") +#pragma comment(linker, "/export:lstrcmpA=kernel32.lstrcmpA,@1372") +#pragma comment(linker, "/export:lstrcmpW=kernel32.lstrcmpW,@1373") +#pragma comment(linker, "/export:lstrcmpi=kernel32.lstrcmpi,@1374") +#pragma comment(linker, "/export:lstrcmpiA=kernel32.lstrcmpiA,@1375") +#pragma comment(linker, "/export:lstrcmpiW=kernel32.lstrcmpiW,@1376") +#pragma comment(linker, "/export:lstrcpy=kernel32.lstrcpy,@1377") +#pragma comment(linker, "/export:lstrcpyA=kernel32.lstrcpyA,@1378") +#pragma comment(linker, "/export:lstrcpyW=kernel32.lstrcpyW,@1379") +#pragma comment(linker, "/export:lstrcpyn=kernel32.lstrcpyn,@1380") +#pragma comment(linker, "/export:lstrcpynA=kernel32.lstrcpynA,@1381") +#pragma comment(linker, "/export:lstrcpynW=kernel32.lstrcpynW,@1382") +#pragma comment(linker, "/export:lstrlen=kernel32.lstrlen,@1383") +#pragma comment(linker, "/export:lstrlenA=kernel32.lstrlenA,@1384") +#pragma comment(linker, "/export:lstrlenW=kernel32.lstrlenW,@1385") +#pragma comment(linker, "/export:uaw_lstrcmpW=kernel32.uaw_lstrcmpW,@1386") +#pragma comment(linker, "/export:uaw_lstrcmpiW=kernel32.uaw_lstrcmpiW,@1387") +#pragma comment(linker, "/export:uaw_lstrlenW=kernel32.uaw_lstrlenW,@1388") +#pragma comment(linker, "/export:uaw_wcschr=kernel32.uaw_wcschr,@1389") +#pragma comment(linker, "/export:uaw_wcscpy=kernel32.uaw_wcscpy,@1390") +#pragma comment(linker, "/export:uaw_wcsicmp=kernel32.uaw_wcsicmp,@1391") +#pragma comment(linker, "/export:uaw_wcslen=kernel32.uaw_wcslen,@1392") +#pragma comment(linker, "/export:uaw_wcsrchr=kernel32.uaw_wcsrchr,@1393") +#else +// Generated by KexExprt (32 bit) from C:\Windows\syswow64\kernel32.dll +#pragma comment(linker, "/export:AcquireSRWLockExclusive=kernel32.AcquireSRWLockExclusive,@3") +#pragma comment(linker, "/export:AcquireSRWLockShared=kernel32.AcquireSRWLockShared,@4") +#pragma comment(linker, "/export:ActivateActCtx=kernel32.ActivateActCtx,@5") +#pragma comment(linker, "/export:AddAtomA=kernel32.AddAtomA,@6") +#pragma comment(linker, "/export:AddAtomW=kernel32.AddAtomW,@7") +#pragma comment(linker, "/export:AddConsoleAliasA=kernel32.AddConsoleAliasA,@8") +#pragma comment(linker, "/export:AddConsoleAliasW=kernel32.AddConsoleAliasW,@9") +#pragma comment(linker, "/export:AddDllDirectory=kernel32.AddDllDirectory,@10") +#pragma comment(linker, "/export:AddIntegrityLabelToBoundaryDescriptor=kernel32.AddIntegrityLabelToBoundaryDescriptor,@11") +#pragma comment(linker, "/export:AddLocalAlternateComputerNameA=kernel32.AddLocalAlternateComputerNameA,@12") +#pragma comment(linker, "/export:AddLocalAlternateComputerNameW=kernel32.AddLocalAlternateComputerNameW,@13") +#pragma comment(linker, "/export:AddRefActCtx=kernel32.AddRefActCtx,@14") +#pragma comment(linker, "/export:AddSIDToBoundaryDescriptor=kernel32.AddSIDToBoundaryDescriptor,@15") +#pragma comment(linker, "/export:AddSecureMemoryCacheCallback=kernel32.AddSecureMemoryCacheCallback,@16") +#pragma comment(linker, "/export:AddVectoredContinueHandler=kernel32.AddVectoredContinueHandler,@17") +#pragma comment(linker, "/export:AddVectoredExceptionHandler=kernel32.AddVectoredExceptionHandler,@18") +#pragma comment(linker, "/export:AdjustCalendarDate=kernel32.AdjustCalendarDate,@19") +#pragma comment(linker, "/export:AllocConsole=kernel32.AllocConsole,@20") +#pragma comment(linker, "/export:AllocateUserPhysicalPages=kernel32.AllocateUserPhysicalPages,@21") +#pragma comment(linker, "/export:AllocateUserPhysicalPagesNuma=kernel32.AllocateUserPhysicalPagesNuma,@22") +#pragma comment(linker, "/export:ApplicationRecoveryFinished=kernel32.ApplicationRecoveryFinished,@23") +#pragma comment(linker, "/export:ApplicationRecoveryInProgress=kernel32.ApplicationRecoveryInProgress,@24") +#pragma comment(linker, "/export:AreFileApisANSI=kernel32.AreFileApisANSI,@25") +#pragma comment(linker, "/export:AssignProcessToJobObject=kernel32.AssignProcessToJobObject,@26") +#pragma comment(linker, "/export:AttachConsole=kernel32.AttachConsole,@27") +#pragma comment(linker, "/export:BackupRead=kernel32.BackupRead,@28") +#pragma comment(linker, "/export:BackupSeek=kernel32.BackupSeek,@29") +#pragma comment(linker, "/export:BackupWrite=kernel32.BackupWrite,@30") +#pragma comment(linker, "/export:BaseCheckAppcompatCache=kernel32.BaseCheckAppcompatCache,@31") +#pragma comment(linker, "/export:BaseCheckAppcompatCacheEx=kernel32.BaseCheckAppcompatCacheEx,@32") +#pragma comment(linker, "/export:BaseCheckRunApp=kernel32.BaseCheckRunApp,@33") +#pragma comment(linker, "/export:BaseCleanupAppcompatCacheSupport=kernel32.BaseCleanupAppcompatCacheSupport,@34") +#pragma comment(linker, "/export:BaseDllReadWriteIniFile=kernel32.BaseDllReadWriteIniFile,@35") +#pragma comment(linker, "/export:BaseDumpAppcompatCache=kernel32.BaseDumpAppcompatCache,@36") +#pragma comment(linker, "/export:BaseFlushAppcompatCache=kernel32.BaseFlushAppcompatCache,@37") +#pragma comment(linker, "/export:BaseFormatObjectAttributes=kernel32.BaseFormatObjectAttributes,@38") +#pragma comment(linker, "/export:BaseFormatTimeOut=kernel32.BaseFormatTimeOut,@39") +#pragma comment(linker, "/export:BaseGenerateAppCompatData=kernel32.BaseGenerateAppCompatData,@40") +#pragma comment(linker, "/export:BaseGetNamedObjectDirectory=kernel32.BaseGetNamedObjectDirectory,@41") +#pragma comment(linker, "/export:BaseInitAppcompatCacheSupport=kernel32.BaseInitAppcompatCacheSupport,@42") +#pragma comment(linker, "/export:BaseIsAppcompatInfrastructureDisabled=kernel32.BaseIsAppcompatInfrastructureDisabled,@43") +#pragma comment(linker, "/export:BaseQueryModuleData=kernel32.BaseQueryModuleData,@44") +#pragma comment(linker, "/export:BaseSetLastNTError=kernel32.BaseSetLastNTError,@45") +#pragma comment(linker, "/export:BaseThreadInitThunk=kernel32.BaseThreadInitThunk,@1") +#pragma comment(linker, "/export:BaseUpdateAppcompatCache=kernel32.BaseUpdateAppcompatCache,@46") +#pragma comment(linker, "/export:BaseVerifyUnicodeString=kernel32.BaseVerifyUnicodeString,@47") +#pragma comment(linker, "/export:Basep8BitStringToDynamicUnicodeString=kernel32.Basep8BitStringToDynamicUnicodeString,@48") +#pragma comment(linker, "/export:BasepAllocateActivationContextActivationBlock=kernel32.BasepAllocateActivationContextActivationBlock,@49") +#pragma comment(linker, "/export:BasepAnsiStringToDynamicUnicodeString=kernel32.BasepAnsiStringToDynamicUnicodeString,@50") +#pragma comment(linker, "/export:BasepCheckAppCompat=kernel32.BasepCheckAppCompat,@51") +#pragma comment(linker, "/export:BasepCheckBadapp=kernel32.BasepCheckBadapp,@52") +#pragma comment(linker, "/export:BasepCheckWinSaferRestrictions=kernel32.BasepCheckWinSaferRestrictions,@53") +#pragma comment(linker, "/export:BasepFreeActivationContextActivationBlock=kernel32.BasepFreeActivationContextActivationBlock,@54") +#pragma comment(linker, "/export:BasepFreeAppCompatData=kernel32.BasepFreeAppCompatData,@55") +#pragma comment(linker, "/export:BasepMapModuleHandle=kernel32.BasepMapModuleHandle,@56") +#pragma comment(linker, "/export:Beep=kernel32.Beep,@57") +#pragma comment(linker, "/export:BeginUpdateResourceA=kernel32.BeginUpdateResourceA,@58") +#pragma comment(linker, "/export:BeginUpdateResourceW=kernel32.BeginUpdateResourceW,@59") +#pragma comment(linker, "/export:BindIoCompletionCallback=kernel32.BindIoCompletionCallback,@60") +#pragma comment(linker, "/export:BuildCommDCBA=kernel32.BuildCommDCBA,@61") +#pragma comment(linker, "/export:BuildCommDCBAndTimeoutsA=kernel32.BuildCommDCBAndTimeoutsA,@62") +#pragma comment(linker, "/export:BuildCommDCBAndTimeoutsW=kernel32.BuildCommDCBAndTimeoutsW,@63") +#pragma comment(linker, "/export:BuildCommDCBW=kernel32.BuildCommDCBW,@64") +#pragma comment(linker, "/export:CallNamedPipeA=kernel32.CallNamedPipeA,@65") +#pragma comment(linker, "/export:CallNamedPipeW=kernel32.CallNamedPipeW,@66") +#pragma comment(linker, "/export:CallbackMayRunLong=kernel32.CallbackMayRunLong,@67") +#pragma comment(linker, "/export:CancelDeviceWakeupRequest=kernel32.CancelDeviceWakeupRequest,@68") +#pragma comment(linker, "/export:CancelIo=kernel32.CancelIo,@69") +#pragma comment(linker, "/export:CancelIoEx=kernel32.CancelIoEx,@70") +#pragma comment(linker, "/export:CancelSynchronousIo=kernel32.CancelSynchronousIo,@71") +#pragma comment(linker, "/export:CancelThreadpoolIo=kernel32.CancelThreadpoolIo,@72") +#pragma comment(linker, "/export:CancelTimerQueueTimer=kernel32.CancelTimerQueueTimer,@73") +#pragma comment(linker, "/export:CancelWaitableTimer=kernel32.CancelWaitableTimer,@74") +#pragma comment(linker, "/export:ChangeTimerQueueTimer=kernel32.ChangeTimerQueueTimer,@75") +#pragma comment(linker, "/export:CheckElevation=kernel32.CheckElevation,@76") +#pragma comment(linker, "/export:CheckElevationEnabled=kernel32.CheckElevationEnabled,@77") +#pragma comment(linker, "/export:CheckForReadOnlyResource=kernel32.CheckForReadOnlyResource,@78") +#pragma comment(linker, "/export:CheckNameLegalDOS8Dot3A=kernel32.CheckNameLegalDOS8Dot3A,@79") +#pragma comment(linker, "/export:CheckNameLegalDOS8Dot3W=kernel32.CheckNameLegalDOS8Dot3W,@80") +#pragma comment(linker, "/export:CheckRemoteDebuggerPresent=kernel32.CheckRemoteDebuggerPresent,@81") +#pragma comment(linker, "/export:ClearCommBreak=kernel32.ClearCommBreak,@82") +#pragma comment(linker, "/export:ClearCommError=kernel32.ClearCommError,@83") +#pragma comment(linker, "/export:CloseConsoleHandle=kernel32.CloseConsoleHandle,@84") +#pragma comment(linker, "/export:CloseHandle=kernel32.CloseHandle,@85") +#pragma comment(linker, "/export:ClosePrivateNamespace=kernel32.ClosePrivateNamespace,@86") +#pragma comment(linker, "/export:CloseProfileUserMapping=kernel32.CloseProfileUserMapping,@87") +#pragma comment(linker, "/export:CloseThreadpool=kernel32.CloseThreadpool,@88") +#pragma comment(linker, "/export:CloseThreadpoolCleanupGroup=kernel32.CloseThreadpoolCleanupGroup,@89") +#pragma comment(linker, "/export:CloseThreadpoolCleanupGroupMembers=kernel32.CloseThreadpoolCleanupGroupMembers,@90") +#pragma comment(linker, "/export:CloseThreadpoolIo=kernel32.CloseThreadpoolIo,@91") +#pragma comment(linker, "/export:CloseThreadpoolTimer=kernel32.CloseThreadpoolTimer,@92") +#pragma comment(linker, "/export:CloseThreadpoolWait=kernel32.CloseThreadpoolWait,@93") +#pragma comment(linker, "/export:CloseThreadpoolWork=kernel32.CloseThreadpoolWork,@94") +#pragma comment(linker, "/export:CmdBatNotification=kernel32.CmdBatNotification,@95") +#pragma comment(linker, "/export:CommConfigDialogA=kernel32.CommConfigDialogA,@96") +#pragma comment(linker, "/export:CommConfigDialogW=kernel32.CommConfigDialogW,@97") +#pragma comment(linker, "/export:CompareCalendarDates=kernel32.CompareCalendarDates,@98") +#pragma comment(linker, "/export:CompareFileTime=kernel32.CompareFileTime,@99") +#pragma comment(linker, "/export:CompareStringA=kernel32.CompareStringA,@100") +#pragma comment(linker, "/export:CompareStringEx=kernel32.CompareStringEx,@101") +#pragma comment(linker, "/export:CompareStringOrdinal=kernel32.CompareStringOrdinal,@102") +#pragma comment(linker, "/export:CompareStringW=kernel32.CompareStringW,@103") +#pragma comment(linker, "/export:ConnectNamedPipe=kernel32.ConnectNamedPipe,@104") +#pragma comment(linker, "/export:ConsoleMenuControl=kernel32.ConsoleMenuControl,@105") +#pragma comment(linker, "/export:ContinueDebugEvent=kernel32.ContinueDebugEvent,@106") +#pragma comment(linker, "/export:ConvertCalDateTimeToSystemTime=kernel32.ConvertCalDateTimeToSystemTime,@107") +#pragma comment(linker, "/export:ConvertDefaultLocale=kernel32.ConvertDefaultLocale,@108") +#pragma comment(linker, "/export:ConvertFiberToThread=kernel32.ConvertFiberToThread,@109") +#pragma comment(linker, "/export:ConvertNLSDayOfWeekToWin32DayOfWeek=kernel32.ConvertNLSDayOfWeekToWin32DayOfWeek,@110") +#pragma comment(linker, "/export:ConvertSystemTimeToCalDateTime=kernel32.ConvertSystemTimeToCalDateTime,@111") +#pragma comment(linker, "/export:ConvertThreadToFiber=kernel32.ConvertThreadToFiber,@112") +#pragma comment(linker, "/export:ConvertThreadToFiberEx=kernel32.ConvertThreadToFiberEx,@113") +#pragma comment(linker, "/export:CopyContext=kernel32.CopyContext,@114") +#pragma comment(linker, "/export:CopyFileA=kernel32.CopyFileA,@115") +#pragma comment(linker, "/export:CopyFileExA=kernel32.CopyFileExA,@116") +#pragma comment(linker, "/export:CopyFileExW=kernel32.CopyFileExW,@117") +#pragma comment(linker, "/export:CopyFileTransactedA=kernel32.CopyFileTransactedA,@118") +#pragma comment(linker, "/export:CopyFileTransactedW=kernel32.CopyFileTransactedW,@119") +#pragma comment(linker, "/export:CopyFileW=kernel32.CopyFileW,@120") +#pragma comment(linker, "/export:CopyLZFile=kernel32.CopyLZFile,@121") +#pragma comment(linker, "/export:CreateActCtxA=kernel32.CreateActCtxA,@122") +#pragma comment(linker, "/export:CreateActCtxW=kernel32.CreateActCtxW,@123") +#pragma comment(linker, "/export:CreateBoundaryDescriptorA=kernel32.CreateBoundaryDescriptorA,@124") +#pragma comment(linker, "/export:CreateBoundaryDescriptorW=kernel32.CreateBoundaryDescriptorW,@125") +#pragma comment(linker, "/export:CreateConsoleScreenBuffer=kernel32.CreateConsoleScreenBuffer,@126") +#pragma comment(linker, "/export:CreateDirectoryA=kernel32.CreateDirectoryA,@127") +#pragma comment(linker, "/export:CreateDirectoryExA=kernel32.CreateDirectoryExA,@128") +#pragma comment(linker, "/export:CreateDirectoryExW=kernel32.CreateDirectoryExW,@129") +#pragma comment(linker, "/export:CreateDirectoryTransactedA=kernel32.CreateDirectoryTransactedA,@130") +#pragma comment(linker, "/export:CreateDirectoryTransactedW=kernel32.CreateDirectoryTransactedW,@131") +#pragma comment(linker, "/export:CreateDirectoryW=kernel32.CreateDirectoryW,@132") +#pragma comment(linker, "/export:CreateEventA=kernel32.CreateEventA,@133") +#pragma comment(linker, "/export:CreateEventExA=kernel32.CreateEventExA,@134") +#pragma comment(linker, "/export:CreateEventExW=kernel32.CreateEventExW,@135") +#pragma comment(linker, "/export:CreateEventW=kernel32.CreateEventW,@136") +#pragma comment(linker, "/export:CreateFiber=kernel32.CreateFiber,@137") +#pragma comment(linker, "/export:CreateFiberEx=kernel32.CreateFiberEx,@138") +#pragma comment(linker, "/export:CreateFileA=kernel32.CreateFileA,@139") +#pragma comment(linker, "/export:CreateFileMappingA=kernel32.CreateFileMappingA,@140") +#pragma comment(linker, "/export:CreateFileMappingNumaA=kernel32.CreateFileMappingNumaA,@141") +#pragma comment(linker, "/export:CreateFileMappingNumaW=kernel32.CreateFileMappingNumaW,@142") +#pragma comment(linker, "/export:CreateFileMappingW=kernel32.CreateFileMappingW,@143") +#pragma comment(linker, "/export:CreateFileTransactedA=kernel32.CreateFileTransactedA,@144") +#pragma comment(linker, "/export:CreateFileTransactedW=kernel32.CreateFileTransactedW,@145") +#pragma comment(linker, "/export:CreateFileW=kernel32.CreateFileW,@146") +#pragma comment(linker, "/export:CreateHardLinkA=kernel32.CreateHardLinkA,@147") +#pragma comment(linker, "/export:CreateHardLinkTransactedA=kernel32.CreateHardLinkTransactedA,@148") +#pragma comment(linker, "/export:CreateHardLinkTransactedW=kernel32.CreateHardLinkTransactedW,@149") +#pragma comment(linker, "/export:CreateHardLinkW=kernel32.CreateHardLinkW,@150") +#pragma comment(linker, "/export:CreateIoCompletionPort=kernel32.CreateIoCompletionPort,@151") +#pragma comment(linker, "/export:CreateJobObjectA=kernel32.CreateJobObjectA,@152") +#pragma comment(linker, "/export:CreateJobObjectW=kernel32.CreateJobObjectW,@153") +#pragma comment(linker, "/export:CreateJobSet=kernel32.CreateJobSet,@154") +#pragma comment(linker, "/export:CreateMailslotA=kernel32.CreateMailslotA,@155") +#pragma comment(linker, "/export:CreateMailslotW=kernel32.CreateMailslotW,@156") +#pragma comment(linker, "/export:CreateMemoryResourceNotification=kernel32.CreateMemoryResourceNotification,@157") +#pragma comment(linker, "/export:CreateMutexA=kernel32.CreateMutexA,@158") +#pragma comment(linker, "/export:CreateMutexExA=kernel32.CreateMutexExA,@159") +#pragma comment(linker, "/export:CreateMutexExW=kernel32.CreateMutexExW,@160") +#pragma comment(linker, "/export:CreateMutexW=kernel32.CreateMutexW,@161") +#pragma comment(linker, "/export:CreateNamedPipeA=kernel32.CreateNamedPipeA,@162") +#pragma comment(linker, "/export:CreateNamedPipeW=kernel32.CreateNamedPipeW,@163") +#pragma comment(linker, "/export:CreatePipe=kernel32.CreatePipe,@164") +#pragma comment(linker, "/export:CreatePrivateNamespaceA=kernel32.CreatePrivateNamespaceA,@165") +#pragma comment(linker, "/export:CreatePrivateNamespaceW=kernel32.CreatePrivateNamespaceW,@166") +#pragma comment(linker, "/export:CreateProcessA=kernel32.CreateProcessA,@167") +#pragma comment(linker, "/export:CreateProcessAsUserW=kernel32.CreateProcessAsUserW,@168") +#pragma comment(linker, "/export:CreateProcessInternalA=kernel32.CreateProcessInternalA,@169") +#pragma comment(linker, "/export:CreateProcessInternalW=kernel32.CreateProcessInternalW,@170") +#pragma comment(linker, "/export:CreateProcessW=kernel32.CreateProcessW,@171") +#pragma comment(linker, "/export:CreateRemoteThread=kernel32.CreateRemoteThread,@172") +#pragma comment(linker, "/export:CreateRemoteThreadEx=kernel32.CreateRemoteThreadEx,@173") +#pragma comment(linker, "/export:CreateSemaphoreA=kernel32.CreateSemaphoreA,@174") +#pragma comment(linker, "/export:CreateSemaphoreExA=kernel32.CreateSemaphoreExA,@175") +#pragma comment(linker, "/export:CreateSemaphoreExW=kernel32.CreateSemaphoreExW,@176") +#pragma comment(linker, "/export:CreateSemaphoreW=kernel32.CreateSemaphoreW,@177") +#pragma comment(linker, "/export:CreateSocketHandle=kernel32.CreateSocketHandle,@178") +#pragma comment(linker, "/export:CreateSymbolicLinkA=kernel32.CreateSymbolicLinkA,@179") +#pragma comment(linker, "/export:CreateSymbolicLinkTransactedA=kernel32.CreateSymbolicLinkTransactedA,@180") +#pragma comment(linker, "/export:CreateSymbolicLinkTransactedW=kernel32.CreateSymbolicLinkTransactedW,@181") +#pragma comment(linker, "/export:CreateSymbolicLinkW=kernel32.CreateSymbolicLinkW,@182") +#pragma comment(linker, "/export:CreateTapePartition=kernel32.CreateTapePartition,@183") +#pragma comment(linker, "/export:CreateThread=kernel32.CreateThread,@184") +#pragma comment(linker, "/export:CreateThreadpool=kernel32.CreateThreadpool,@185") +#pragma comment(linker, "/export:CreateThreadpoolCleanupGroup=kernel32.CreateThreadpoolCleanupGroup,@186") +#pragma comment(linker, "/export:CreateThreadpoolIo=kernel32.CreateThreadpoolIo,@187") +#pragma comment(linker, "/export:CreateThreadpoolTimer=kernel32.CreateThreadpoolTimer,@188") +#pragma comment(linker, "/export:CreateThreadpoolWait=kernel32.CreateThreadpoolWait,@189") +#pragma comment(linker, "/export:CreateThreadpoolWork=kernel32.CreateThreadpoolWork,@190") +#pragma comment(linker, "/export:CreateTimerQueue=kernel32.CreateTimerQueue,@191") +#pragma comment(linker, "/export:CreateTimerQueueTimer=kernel32.CreateTimerQueueTimer,@192") +#pragma comment(linker, "/export:CreateToolhelp32Snapshot=kernel32.CreateToolhelp32Snapshot,@193") +#pragma comment(linker, "/export:CreateWaitableTimerA=kernel32.CreateWaitableTimerA,@194") +#pragma comment(linker, "/export:CreateWaitableTimerExA=kernel32.CreateWaitableTimerExA,@195") +#pragma comment(linker, "/export:CreateWaitableTimerExW=kernel32.CreateWaitableTimerExW,@196") +#pragma comment(linker, "/export:CreateWaitableTimerW=kernel32.CreateWaitableTimerW,@197") +#pragma comment(linker, "/export:CtrlRoutine=kernel32.CtrlRoutine,@198") +#pragma comment(linker, "/export:DeactivateActCtx=kernel32.DeactivateActCtx,@199") +#pragma comment(linker, "/export:DebugActiveProcess=kernel32.DebugActiveProcess,@200") +#pragma comment(linker, "/export:DebugActiveProcessStop=kernel32.DebugActiveProcessStop,@201") +#pragma comment(linker, "/export:DebugBreak=kernel32.DebugBreak,@202") +#pragma comment(linker, "/export:DebugBreakProcess=kernel32.DebugBreakProcess,@203") +#pragma comment(linker, "/export:DebugSetProcessKillOnExit=kernel32.DebugSetProcessKillOnExit,@204") +#pragma comment(linker, "/export:DecodePointer=kernel32.DecodePointer,@205") +#pragma comment(linker, "/export:DecodeSystemPointer=kernel32.DecodeSystemPointer,@206") +#pragma comment(linker, "/export:DefineDosDeviceA=kernel32.DefineDosDeviceA,@207") +#pragma comment(linker, "/export:DefineDosDeviceW=kernel32.DefineDosDeviceW,@208") +#pragma comment(linker, "/export:DelayLoadFailureHook=kernel32.DelayLoadFailureHook,@209") +#pragma comment(linker, "/export:DeleteAtom=kernel32.DeleteAtom,@210") +#pragma comment(linker, "/export:DeleteBoundaryDescriptor=kernel32.DeleteBoundaryDescriptor,@211") +#pragma comment(linker, "/export:DeleteCriticalSection=kernel32.DeleteCriticalSection,@212") +#pragma comment(linker, "/export:DeleteFiber=kernel32.DeleteFiber,@213") +#pragma comment(linker, "/export:DeleteFileA=kernel32.DeleteFileA,@214") +#pragma comment(linker, "/export:DeleteFileTransactedA=kernel32.DeleteFileTransactedA,@215") +#pragma comment(linker, "/export:DeleteFileTransactedW=kernel32.DeleteFileTransactedW,@216") +#pragma comment(linker, "/export:DeleteFileW=kernel32.DeleteFileW,@217") +#pragma comment(linker, "/export:DeleteProcThreadAttributeList=kernel32.DeleteProcThreadAttributeList,@218") +#pragma comment(linker, "/export:DeleteTimerQueue=kernel32.DeleteTimerQueue,@219") +#pragma comment(linker, "/export:DeleteTimerQueueEx=kernel32.DeleteTimerQueueEx,@220") +#pragma comment(linker, "/export:DeleteTimerQueueTimer=kernel32.DeleteTimerQueueTimer,@221") +#pragma comment(linker, "/export:DeleteVolumeMountPointA=kernel32.DeleteVolumeMountPointA,@222") +#pragma comment(linker, "/export:DeleteVolumeMountPointW=kernel32.DeleteVolumeMountPointW,@223") +#pragma comment(linker, "/export:DeviceIoControl=kernel32.DeviceIoControl,@224") +#pragma comment(linker, "/export:DisableThreadLibraryCalls=kernel32.DisableThreadLibraryCalls,@225") +#pragma comment(linker, "/export:DisableThreadProfiling=kernel32.DisableThreadProfiling,@226") +#pragma comment(linker, "/export:DisassociateCurrentThreadFromCallback=kernel32.DisassociateCurrentThreadFromCallback,@227") +#pragma comment(linker, "/export:DisconnectNamedPipe=kernel32.DisconnectNamedPipe,@228") +#pragma comment(linker, "/export:DnsHostnameToComputerNameA=kernel32.DnsHostnameToComputerNameA,@229") +#pragma comment(linker, "/export:DnsHostnameToComputerNameW=kernel32.DnsHostnameToComputerNameW,@230") +#pragma comment(linker, "/export:DosDateTimeToFileTime=kernel32.DosDateTimeToFileTime,@231") +#pragma comment(linker, "/export:DosPathToSessionPathA=kernel32.DosPathToSessionPathA,@232") +#pragma comment(linker, "/export:DosPathToSessionPathW=kernel32.DosPathToSessionPathW,@233") +#pragma comment(linker, "/export:DuplicateConsoleHandle=kernel32.DuplicateConsoleHandle,@234") +#pragma comment(linker, "/export:DuplicateHandle=kernel32.DuplicateHandle,@235") +#pragma comment(linker, "/export:EnableThreadProfiling=kernel32.EnableThreadProfiling,@236") +#pragma comment(linker, "/export:EncodePointer=kernel32.EncodePointer,@237") +#pragma comment(linker, "/export:EncodeSystemPointer=kernel32.EncodeSystemPointer,@238") +#pragma comment(linker, "/export:EndUpdateResourceA=kernel32.EndUpdateResourceA,@239") +#pragma comment(linker, "/export:EndUpdateResourceW=kernel32.EndUpdateResourceW,@240") +#pragma comment(linker, "/export:EnterCriticalSection=kernel32.EnterCriticalSection,@241") +#pragma comment(linker, "/export:EnumCalendarInfoA=kernel32.EnumCalendarInfoA,@242") +#pragma comment(linker, "/export:EnumCalendarInfoExA=kernel32.EnumCalendarInfoExA,@243") +#pragma comment(linker, "/export:EnumCalendarInfoExEx=kernel32.EnumCalendarInfoExEx,@244") +#pragma comment(linker, "/export:EnumCalendarInfoExW=kernel32.EnumCalendarInfoExW,@245") +#pragma comment(linker, "/export:EnumCalendarInfoW=kernel32.EnumCalendarInfoW,@246") +#pragma comment(linker, "/export:EnumDateFormatsA=kernel32.EnumDateFormatsA,@247") +#pragma comment(linker, "/export:EnumDateFormatsExA=kernel32.EnumDateFormatsExA,@248") +#pragma comment(linker, "/export:EnumDateFormatsExEx=kernel32.EnumDateFormatsExEx,@249") +#pragma comment(linker, "/export:EnumDateFormatsExW=kernel32.EnumDateFormatsExW,@250") +#pragma comment(linker, "/export:EnumDateFormatsW=kernel32.EnumDateFormatsW,@251") +#pragma comment(linker, "/export:EnumLanguageGroupLocalesA=kernel32.EnumLanguageGroupLocalesA,@252") +#pragma comment(linker, "/export:EnumLanguageGroupLocalesW=kernel32.EnumLanguageGroupLocalesW,@253") +#pragma comment(linker, "/export:EnumResourceLanguagesA=kernel32.EnumResourceLanguagesA,@254") +#pragma comment(linker, "/export:EnumResourceLanguagesExA=kernel32.EnumResourceLanguagesExA,@255") +#pragma comment(linker, "/export:EnumResourceLanguagesExW=kernel32.EnumResourceLanguagesExW,@256") +#pragma comment(linker, "/export:EnumResourceLanguagesW=kernel32.EnumResourceLanguagesW,@257") +#pragma comment(linker, "/export:EnumResourceNamesA=kernel32.EnumResourceNamesA,@258") +#pragma comment(linker, "/export:EnumResourceNamesExA=kernel32.EnumResourceNamesExA,@259") +#pragma comment(linker, "/export:EnumResourceNamesExW=kernel32.EnumResourceNamesExW,@260") +#pragma comment(linker, "/export:EnumResourceNamesW=kernel32.EnumResourceNamesW,@261") +#pragma comment(linker, "/export:EnumResourceTypesA=kernel32.EnumResourceTypesA,@262") +#pragma comment(linker, "/export:EnumResourceTypesExA=kernel32.EnumResourceTypesExA,@263") +#pragma comment(linker, "/export:EnumResourceTypesExW=kernel32.EnumResourceTypesExW,@264") +#pragma comment(linker, "/export:EnumResourceTypesW=kernel32.EnumResourceTypesW,@265") +#pragma comment(linker, "/export:EnumSystemCodePagesA=kernel32.EnumSystemCodePagesA,@266") +#pragma comment(linker, "/export:EnumSystemCodePagesW=kernel32.EnumSystemCodePagesW,@267") +#pragma comment(linker, "/export:EnumSystemFirmwareTables=kernel32.EnumSystemFirmwareTables,@268") +#pragma comment(linker, "/export:EnumSystemGeoID=kernel32.EnumSystemGeoID,@269") +#pragma comment(linker, "/export:EnumSystemLanguageGroupsA=kernel32.EnumSystemLanguageGroupsA,@270") +#pragma comment(linker, "/export:EnumSystemLanguageGroupsW=kernel32.EnumSystemLanguageGroupsW,@271") +#pragma comment(linker, "/export:EnumSystemLocalesA=kernel32.EnumSystemLocalesA,@272") +#pragma comment(linker, "/export:EnumSystemLocalesEx=kernel32.EnumSystemLocalesEx,@273") +#pragma comment(linker, "/export:EnumSystemLocalesW=kernel32.EnumSystemLocalesW,@274") +#pragma comment(linker, "/export:EnumTimeFormatsA=kernel32.EnumTimeFormatsA,@275") +#pragma comment(linker, "/export:EnumTimeFormatsEx=kernel32.EnumTimeFormatsEx,@276") +#pragma comment(linker, "/export:EnumTimeFormatsW=kernel32.EnumTimeFormatsW,@277") +#pragma comment(linker, "/export:EnumUILanguagesA=kernel32.EnumUILanguagesA,@278") +#pragma comment(linker, "/export:EnumUILanguagesW=kernel32.EnumUILanguagesW,@279") +#pragma comment(linker, "/export:EnumerateLocalComputerNamesA=kernel32.EnumerateLocalComputerNamesA,@280") +#pragma comment(linker, "/export:EnumerateLocalComputerNamesW=kernel32.EnumerateLocalComputerNamesW,@281") +#pragma comment(linker, "/export:EraseTape=kernel32.EraseTape,@282") +#pragma comment(linker, "/export:EscapeCommFunction=kernel32.EscapeCommFunction,@283") +#pragma comment(linker, "/export:ExitProcess=kernel32.ExitProcess,@284") +#pragma comment(linker, "/export:ExitThread=kernel32.ExitThread,@285") +#pragma comment(linker, "/export:ExitVDM=kernel32.ExitVDM,@286") +#pragma comment(linker, "/export:ExpandEnvironmentStringsA=kernel32.ExpandEnvironmentStringsA,@287") +#pragma comment(linker, "/export:ExpandEnvironmentStringsW=kernel32.ExpandEnvironmentStringsW,@288") +#pragma comment(linker, "/export:ExpungeConsoleCommandHistoryA=kernel32.ExpungeConsoleCommandHistoryA,@289") +#pragma comment(linker, "/export:ExpungeConsoleCommandHistoryW=kernel32.ExpungeConsoleCommandHistoryW,@290") +#pragma comment(linker, "/export:FatalAppExitA=kernel32.FatalAppExitA,@291") +#pragma comment(linker, "/export:FatalAppExitW=kernel32.FatalAppExitW,@292") +#pragma comment(linker, "/export:FatalExit=kernel32.FatalExit,@293") +#pragma comment(linker, "/export:FileTimeToDosDateTime=kernel32.FileTimeToDosDateTime,@294") +#pragma comment(linker, "/export:FileTimeToLocalFileTime=kernel32.FileTimeToLocalFileTime,@295") +#pragma comment(linker, "/export:FileTimeToSystemTime=kernel32.FileTimeToSystemTime,@296") +#pragma comment(linker, "/export:FillConsoleOutputAttribute=kernel32.FillConsoleOutputAttribute,@297") +#pragma comment(linker, "/export:FillConsoleOutputCharacterA=kernel32.FillConsoleOutputCharacterA,@298") +#pragma comment(linker, "/export:FillConsoleOutputCharacterW=kernel32.FillConsoleOutputCharacterW,@299") +#pragma comment(linker, "/export:FindActCtxSectionGuid=kernel32.FindActCtxSectionGuid,@300") +#pragma comment(linker, "/export:FindActCtxSectionStringA=kernel32.FindActCtxSectionStringA,@301") +#pragma comment(linker, "/export:FindActCtxSectionStringW=kernel32.FindActCtxSectionStringW,@302") +#pragma comment(linker, "/export:FindAtomA=kernel32.FindAtomA,@303") +#pragma comment(linker, "/export:FindAtomW=kernel32.FindAtomW,@304") +#pragma comment(linker, "/export:FindClose=kernel32.FindClose,@305") +#pragma comment(linker, "/export:FindCloseChangeNotification=kernel32.FindCloseChangeNotification,@306") +#pragma comment(linker, "/export:FindFirstChangeNotificationA=kernel32.FindFirstChangeNotificationA,@307") +#pragma comment(linker, "/export:FindFirstChangeNotificationW=kernel32.FindFirstChangeNotificationW,@308") +#pragma comment(linker, "/export:FindFirstFileA=kernel32.FindFirstFileA,@309") +#pragma comment(linker, "/export:FindFirstFileExA=kernel32.FindFirstFileExA,@310") +#pragma comment(linker, "/export:FindFirstFileExW=kernel32.FindFirstFileExW,@311") +#pragma comment(linker, "/export:FindFirstFileNameTransactedW=kernel32.FindFirstFileNameTransactedW,@312") +#pragma comment(linker, "/export:FindFirstFileNameW=kernel32.FindFirstFileNameW,@313") +#pragma comment(linker, "/export:FindFirstFileTransactedA=kernel32.FindFirstFileTransactedA,@314") +#pragma comment(linker, "/export:FindFirstFileTransactedW=kernel32.FindFirstFileTransactedW,@315") +#pragma comment(linker, "/export:FindFirstFileW=kernel32.FindFirstFileW,@316") +#pragma comment(linker, "/export:FindFirstStreamTransactedW=kernel32.FindFirstStreamTransactedW,@317") +#pragma comment(linker, "/export:FindFirstStreamW=kernel32.FindFirstStreamW,@318") +#pragma comment(linker, "/export:FindFirstVolumeA=kernel32.FindFirstVolumeA,@319") +#pragma comment(linker, "/export:FindFirstVolumeMountPointA=kernel32.FindFirstVolumeMountPointA,@320") +#pragma comment(linker, "/export:FindFirstVolumeMountPointW=kernel32.FindFirstVolumeMountPointW,@321") +#pragma comment(linker, "/export:FindFirstVolumeW=kernel32.FindFirstVolumeW,@322") +#pragma comment(linker, "/export:FindNLSString=kernel32.FindNLSString,@323") +#pragma comment(linker, "/export:FindNLSStringEx=kernel32.FindNLSStringEx,@324") +#pragma comment(linker, "/export:FindNextChangeNotification=kernel32.FindNextChangeNotification,@325") +#pragma comment(linker, "/export:FindNextFileA=kernel32.FindNextFileA,@326") +#pragma comment(linker, "/export:FindNextFileNameW=kernel32.FindNextFileNameW,@327") +#pragma comment(linker, "/export:FindNextFileW=kernel32.FindNextFileW,@328") +#pragma comment(linker, "/export:FindNextStreamW=kernel32.FindNextStreamW,@329") +#pragma comment(linker, "/export:FindNextVolumeA=kernel32.FindNextVolumeA,@330") +#pragma comment(linker, "/export:FindNextVolumeMountPointA=kernel32.FindNextVolumeMountPointA,@331") +#pragma comment(linker, "/export:FindNextVolumeMountPointW=kernel32.FindNextVolumeMountPointW,@332") +#pragma comment(linker, "/export:FindNextVolumeW=kernel32.FindNextVolumeW,@333") +#pragma comment(linker, "/export:FindResourceA=kernel32.FindResourceA,@334") +#pragma comment(linker, "/export:FindResourceExA=kernel32.FindResourceExA,@335") +#pragma comment(linker, "/export:FindResourceExW=kernel32.FindResourceExW,@336") +#pragma comment(linker, "/export:FindResourceW=kernel32.FindResourceW,@337") +#pragma comment(linker, "/export:FindStringOrdinal=kernel32.FindStringOrdinal,@338") +#pragma comment(linker, "/export:FindVolumeClose=kernel32.FindVolumeClose,@339") +#pragma comment(linker, "/export:FindVolumeMountPointClose=kernel32.FindVolumeMountPointClose,@340") +#pragma comment(linker, "/export:FlsAlloc=kernel32.FlsAlloc,@341") +#pragma comment(linker, "/export:FlsFree=kernel32.FlsFree,@342") +#pragma comment(linker, "/export:FlsGetValue=kernel32.FlsGetValue,@343") +#pragma comment(linker, "/export:FlsSetValue=kernel32.FlsSetValue,@344") +#pragma comment(linker, "/export:FlushConsoleInputBuffer=kernel32.FlushConsoleInputBuffer,@345") +#pragma comment(linker, "/export:FlushFileBuffers=kernel32.FlushFileBuffers,@346") +#pragma comment(linker, "/export:FlushInstructionCache=kernel32.FlushInstructionCache,@347") +#pragma comment(linker, "/export:FlushProcessWriteBuffers=kernel32.FlushProcessWriteBuffers,@348") +#pragma comment(linker, "/export:FlushViewOfFile=kernel32.FlushViewOfFile,@349") +#pragma comment(linker, "/export:FoldStringA=kernel32.FoldStringA,@350") +#pragma comment(linker, "/export:FoldStringW=kernel32.FoldStringW,@351") +#pragma comment(linker, "/export:FormatMessageA=kernel32.FormatMessageA,@352") +#pragma comment(linker, "/export:FormatMessageW=kernel32.FormatMessageW,@353") +#pragma comment(linker, "/export:FreeConsole=kernel32.FreeConsole,@354") +#pragma comment(linker, "/export:FreeEnvironmentStringsA=kernel32.FreeEnvironmentStringsA,@355") +#pragma comment(linker, "/export:FreeEnvironmentStringsW=kernel32.FreeEnvironmentStringsW,@356") +#pragma comment(linker, "/export:FreeLibrary=kernel32.FreeLibrary,@357") +#pragma comment(linker, "/export:FreeLibraryAndExitThread=kernel32.FreeLibraryAndExitThread,@358") +#pragma comment(linker, "/export:FreeLibraryWhenCallbackReturns=kernel32.FreeLibraryWhenCallbackReturns,@359") +#pragma comment(linker, "/export:FreeResource=kernel32.FreeResource,@360") +#pragma comment(linker, "/export:FreeUserPhysicalPages=kernel32.FreeUserPhysicalPages,@361") +#pragma comment(linker, "/export:GenerateConsoleCtrlEvent=kernel32.GenerateConsoleCtrlEvent,@362") +#pragma comment(linker, "/export:GetACP=kernel32.GetACP,@363") +#pragma comment(linker, "/export:GetActiveProcessorCount=kernel32.GetActiveProcessorCount,@364") +#pragma comment(linker, "/export:GetActiveProcessorGroupCount=kernel32.GetActiveProcessorGroupCount,@365") +#pragma comment(linker, "/export:GetApplicationRecoveryCallback=kernel32.GetApplicationRecoveryCallback,@366") +#pragma comment(linker, "/export:GetApplicationRestartSettings=kernel32.GetApplicationRestartSettings,@367") +#pragma comment(linker, "/export:GetAtomNameA=kernel32.GetAtomNameA,@368") +#pragma comment(linker, "/export:GetAtomNameW=kernel32.GetAtomNameW,@369") +#pragma comment(linker, "/export:GetBinaryType=kernel32.GetBinaryType,@370") +#pragma comment(linker, "/export:GetBinaryTypeA=kernel32.GetBinaryTypeA,@371") +#pragma comment(linker, "/export:GetBinaryTypeW=kernel32.GetBinaryTypeW,@372") +#pragma comment(linker, "/export:GetCPInfo=kernel32.GetCPInfo,@373") +#pragma comment(linker, "/export:GetCPInfoExA=kernel32.GetCPInfoExA,@374") +#pragma comment(linker, "/export:GetCPInfoExW=kernel32.GetCPInfoExW,@375") +#pragma comment(linker, "/export:GetCalendarDateFormat=kernel32.GetCalendarDateFormat,@376") +#pragma comment(linker, "/export:GetCalendarDateFormatEx=kernel32.GetCalendarDateFormatEx,@377") +#pragma comment(linker, "/export:GetCalendarDaysInMonth=kernel32.GetCalendarDaysInMonth,@378") +#pragma comment(linker, "/export:GetCalendarDifferenceInDays=kernel32.GetCalendarDifferenceInDays,@379") +#pragma comment(linker, "/export:GetCalendarInfoA=kernel32.GetCalendarInfoA,@380") +#pragma comment(linker, "/export:GetCalendarInfoEx=kernel32.GetCalendarInfoEx,@381") +#pragma comment(linker, "/export:GetCalendarInfoW=kernel32.GetCalendarInfoW,@382") +#pragma comment(linker, "/export:GetCalendarMonthsInYear=kernel32.GetCalendarMonthsInYear,@383") +#pragma comment(linker, "/export:GetCalendarSupportedDateRange=kernel32.GetCalendarSupportedDateRange,@384") +#pragma comment(linker, "/export:GetCalendarWeekNumber=kernel32.GetCalendarWeekNumber,@385") +#pragma comment(linker, "/export:GetComPlusPackageInstallStatus=kernel32.GetComPlusPackageInstallStatus,@386") +#pragma comment(linker, "/export:GetCommConfig=kernel32.GetCommConfig,@387") +#pragma comment(linker, "/export:GetCommMask=kernel32.GetCommMask,@388") +#pragma comment(linker, "/export:GetCommModemStatus=kernel32.GetCommModemStatus,@389") +#pragma comment(linker, "/export:GetCommProperties=kernel32.GetCommProperties,@390") +#pragma comment(linker, "/export:GetCommState=kernel32.GetCommState,@391") +#pragma comment(linker, "/export:GetCommTimeouts=kernel32.GetCommTimeouts,@392") +#pragma comment(linker, "/export:GetCommandLineA=kernel32.GetCommandLineA,@393") +#pragma comment(linker, "/export:GetCommandLineW=kernel32.GetCommandLineW,@394") +#pragma comment(linker, "/export:GetCompressedFileSizeA=kernel32.GetCompressedFileSizeA,@395") +#pragma comment(linker, "/export:GetCompressedFileSizeTransactedA=kernel32.GetCompressedFileSizeTransactedA,@396") +#pragma comment(linker, "/export:GetCompressedFileSizeTransactedW=kernel32.GetCompressedFileSizeTransactedW,@397") +#pragma comment(linker, "/export:GetCompressedFileSizeW=kernel32.GetCompressedFileSizeW,@398") +#pragma comment(linker, "/export:GetComputerNameA=kernel32.GetComputerNameA,@399") +#pragma comment(linker, "/export:GetComputerNameExA=kernel32.GetComputerNameExA,@400") +#pragma comment(linker, "/export:GetComputerNameExW=kernel32.GetComputerNameExW,@401") +#pragma comment(linker, "/export:GetComputerNameW=kernel32.GetComputerNameW,@402") +#pragma comment(linker, "/export:GetConsoleAliasA=kernel32.GetConsoleAliasA,@403") +#pragma comment(linker, "/export:GetConsoleAliasExesA=kernel32.GetConsoleAliasExesA,@404") +#pragma comment(linker, "/export:GetConsoleAliasExesLengthA=kernel32.GetConsoleAliasExesLengthA,@405") +#pragma comment(linker, "/export:GetConsoleAliasExesLengthW=kernel32.GetConsoleAliasExesLengthW,@406") +#pragma comment(linker, "/export:GetConsoleAliasExesW=kernel32.GetConsoleAliasExesW,@407") +#pragma comment(linker, "/export:GetConsoleAliasW=kernel32.GetConsoleAliasW,@408") +#pragma comment(linker, "/export:GetConsoleAliasesA=kernel32.GetConsoleAliasesA,@409") +#pragma comment(linker, "/export:GetConsoleAliasesLengthA=kernel32.GetConsoleAliasesLengthA,@410") +#pragma comment(linker, "/export:GetConsoleAliasesLengthW=kernel32.GetConsoleAliasesLengthW,@411") +#pragma comment(linker, "/export:GetConsoleAliasesW=kernel32.GetConsoleAliasesW,@412") +#pragma comment(linker, "/export:GetConsoleCP=kernel32.GetConsoleCP,@413") +#pragma comment(linker, "/export:GetConsoleCharType=kernel32.GetConsoleCharType,@414") +#pragma comment(linker, "/export:GetConsoleCommandHistoryA=kernel32.GetConsoleCommandHistoryA,@415") +#pragma comment(linker, "/export:GetConsoleCommandHistoryLengthA=kernel32.GetConsoleCommandHistoryLengthA,@416") +#pragma comment(linker, "/export:GetConsoleCommandHistoryLengthW=kernel32.GetConsoleCommandHistoryLengthW,@417") +#pragma comment(linker, "/export:GetConsoleCommandHistoryW=kernel32.GetConsoleCommandHistoryW,@418") +#pragma comment(linker, "/export:GetConsoleCursorInfo=kernel32.GetConsoleCursorInfo,@419") +#pragma comment(linker, "/export:GetConsoleCursorMode=kernel32.GetConsoleCursorMode,@420") +#pragma comment(linker, "/export:GetConsoleDisplayMode=kernel32.GetConsoleDisplayMode,@421") +#pragma comment(linker, "/export:GetConsoleFontInfo=kernel32.GetConsoleFontInfo,@422") +#pragma comment(linker, "/export:GetConsoleFontSize=kernel32.GetConsoleFontSize,@423") +#pragma comment(linker, "/export:GetConsoleHardwareState=kernel32.GetConsoleHardwareState,@424") +#pragma comment(linker, "/export:GetConsoleHistoryInfo=kernel32.GetConsoleHistoryInfo,@425") +#pragma comment(linker, "/export:GetConsoleInputExeNameA=kernel32.GetConsoleInputExeNameA,@426") +#pragma comment(linker, "/export:GetConsoleInputExeNameW=kernel32.GetConsoleInputExeNameW,@427") +#pragma comment(linker, "/export:GetConsoleInputWaitHandle=kernel32.GetConsoleInputWaitHandle,@428") +#pragma comment(linker, "/export:GetConsoleKeyboardLayoutNameA=kernel32.GetConsoleKeyboardLayoutNameA,@429") +#pragma comment(linker, "/export:GetConsoleKeyboardLayoutNameW=kernel32.GetConsoleKeyboardLayoutNameW,@430") +#pragma comment(linker, "/export:GetConsoleMode=kernel32.GetConsoleMode,@431") +#pragma comment(linker, "/export:GetConsoleNlsMode=kernel32.GetConsoleNlsMode,@432") +#pragma comment(linker, "/export:GetConsoleOriginalTitleA=kernel32.GetConsoleOriginalTitleA,@433") +#pragma comment(linker, "/export:GetConsoleOriginalTitleW=kernel32.GetConsoleOriginalTitleW,@434") +#pragma comment(linker, "/export:GetConsoleOutputCP=kernel32.GetConsoleOutputCP,@435") +#pragma comment(linker, "/export:GetConsoleProcessList=kernel32.GetConsoleProcessList,@436") +#pragma comment(linker, "/export:GetConsoleScreenBufferInfo=kernel32.GetConsoleScreenBufferInfo,@437") +#pragma comment(linker, "/export:GetConsoleScreenBufferInfoEx=kernel32.GetConsoleScreenBufferInfoEx,@438") +#pragma comment(linker, "/export:GetConsoleSelectionInfo=kernel32.GetConsoleSelectionInfo,@439") +#pragma comment(linker, "/export:GetConsoleTitleA=kernel32.GetConsoleTitleA,@440") +#pragma comment(linker, "/export:GetConsoleTitleW=kernel32.GetConsoleTitleW,@441") +#pragma comment(linker, "/export:GetConsoleWindow=kernel32.GetConsoleWindow,@442") +#pragma comment(linker, "/export:GetCurrencyFormatA=kernel32.GetCurrencyFormatA,@443") +#pragma comment(linker, "/export:GetCurrencyFormatEx=kernel32.GetCurrencyFormatEx,@444") +#pragma comment(linker, "/export:GetCurrencyFormatW=kernel32.GetCurrencyFormatW,@445") +#pragma comment(linker, "/export:GetCurrentActCtx=kernel32.GetCurrentActCtx,@446") +#pragma comment(linker, "/export:GetCurrentConsoleFont=kernel32.GetCurrentConsoleFont,@447") +#pragma comment(linker, "/export:GetCurrentConsoleFontEx=kernel32.GetCurrentConsoleFontEx,@448") +#pragma comment(linker, "/export:GetCurrentDirectoryA=kernel32.GetCurrentDirectoryA,@449") +#pragma comment(linker, "/export:GetCurrentDirectoryW=kernel32.GetCurrentDirectoryW,@450") +#pragma comment(linker, "/export:GetCurrentProcess=kernel32.GetCurrentProcess,@451") +#pragma comment(linker, "/export:GetCurrentProcessId=kernel32.GetCurrentProcessId,@452") +#pragma comment(linker, "/export:GetCurrentProcessorNumber=kernel32.GetCurrentProcessorNumber,@453") +#pragma comment(linker, "/export:GetCurrentProcessorNumberEx=kernel32.GetCurrentProcessorNumberEx,@454") +#pragma comment(linker, "/export:GetCurrentThread=kernel32.GetCurrentThread,@455") +#pragma comment(linker, "/export:GetCurrentThreadId=kernel32.GetCurrentThreadId,@456") +#pragma comment(linker, "/export:GetDateFormatA=kernel32.GetDateFormatA,@457") +#pragma comment(linker, "/export:GetDateFormatEx=kernel32.GetDateFormatEx,@458") +#pragma comment(linker, "/export:GetDateFormatW=kernel32.GetDateFormatW,@459") +#pragma comment(linker, "/export:GetDefaultCommConfigA=kernel32.GetDefaultCommConfigA,@460") +#pragma comment(linker, "/export:GetDefaultCommConfigW=kernel32.GetDefaultCommConfigW,@461") +#pragma comment(linker, "/export:GetDevicePowerState=kernel32.GetDevicePowerState,@462") +#pragma comment(linker, "/export:GetDiskFreeSpaceA=kernel32.GetDiskFreeSpaceA,@463") +#pragma comment(linker, "/export:GetDiskFreeSpaceExA=kernel32.GetDiskFreeSpaceExA,@464") +#pragma comment(linker, "/export:GetDiskFreeSpaceExW=kernel32.GetDiskFreeSpaceExW,@465") +#pragma comment(linker, "/export:GetDiskFreeSpaceW=kernel32.GetDiskFreeSpaceW,@466") +#pragma comment(linker, "/export:GetDllDirectoryA=kernel32.GetDllDirectoryA,@467") +#pragma comment(linker, "/export:GetDllDirectoryW=kernel32.GetDllDirectoryW,@468") +#pragma comment(linker, "/export:GetDriveTypeA=kernel32.GetDriveTypeA,@469") +#pragma comment(linker, "/export:GetDriveTypeW=kernel32.GetDriveTypeW,@470") +#pragma comment(linker, "/export:GetDurationFormat=kernel32.GetDurationFormat,@471") +#pragma comment(linker, "/export:GetDurationFormatEx=kernel32.GetDurationFormatEx,@472") +#pragma comment(linker, "/export:GetDynamicTimeZoneInformation=kernel32.GetDynamicTimeZoneInformation,@473") +#pragma comment(linker, "/export:GetEnabledXStateFeatures=kernel32.GetEnabledXStateFeatures,@474") +#pragma comment(linker, "/export:GetEnvironmentStrings=kernel32.GetEnvironmentStrings,@475") +#pragma comment(linker, "/export:GetEnvironmentStringsA=kernel32.GetEnvironmentStringsA,@476") +#pragma comment(linker, "/export:GetEnvironmentStringsW=kernel32.GetEnvironmentStringsW,@477") +#pragma comment(linker, "/export:GetEnvironmentVariableA=kernel32.GetEnvironmentVariableA,@478") +#pragma comment(linker, "/export:GetEnvironmentVariableW=kernel32.GetEnvironmentVariableW,@479") +#pragma comment(linker, "/export:GetEraNameCountedString=kernel32.GetEraNameCountedString,@480") +#pragma comment(linker, "/export:GetErrorMode=kernel32.GetErrorMode,@481") +#pragma comment(linker, "/export:GetExitCodeProcess=kernel32.GetExitCodeProcess,@482") +#pragma comment(linker, "/export:GetExitCodeThread=kernel32.GetExitCodeThread,@483") +#pragma comment(linker, "/export:GetExpandedNameA=kernel32.GetExpandedNameA,@484") +#pragma comment(linker, "/export:GetExpandedNameW=kernel32.GetExpandedNameW,@485") +#pragma comment(linker, "/export:GetFileAttributesA=kernel32.GetFileAttributesA,@486") +#pragma comment(linker, "/export:GetFileAttributesExA=kernel32.GetFileAttributesExA,@487") +#pragma comment(linker, "/export:GetFileAttributesExW=kernel32.GetFileAttributesExW,@488") +#pragma comment(linker, "/export:GetFileAttributesTransactedA=kernel32.GetFileAttributesTransactedA,@489") +#pragma comment(linker, "/export:GetFileAttributesTransactedW=kernel32.GetFileAttributesTransactedW,@490") +#pragma comment(linker, "/export:GetFileAttributesW=kernel32.GetFileAttributesW,@491") +#pragma comment(linker, "/export:GetFileBandwidthReservation=kernel32.GetFileBandwidthReservation,@492") +#pragma comment(linker, "/export:GetFileInformationByHandle=kernel32.GetFileInformationByHandle,@493") +#pragma comment(linker, "/export:GetFileInformationByHandleEx=kernel32.GetFileInformationByHandleEx,@494") +#pragma comment(linker, "/export:GetFileMUIInfo=kernel32.GetFileMUIInfo,@495") +#pragma comment(linker, "/export:GetFileMUIPath=kernel32.GetFileMUIPath,@496") +#pragma comment(linker, "/export:GetFileSize=kernel32.GetFileSize,@497") +#pragma comment(linker, "/export:GetFileSizeEx=kernel32.GetFileSizeEx,@498") +#pragma comment(linker, "/export:GetFileTime=kernel32.GetFileTime,@499") +#pragma comment(linker, "/export:GetFileType=kernel32.GetFileType,@500") +#pragma comment(linker, "/export:GetFinalPathNameByHandleA=kernel32.GetFinalPathNameByHandleA,@501") +#pragma comment(linker, "/export:GetFinalPathNameByHandleW=kernel32.GetFinalPathNameByHandleW,@502") +#pragma comment(linker, "/export:GetFirmwareEnvironmentVariableA=kernel32.GetFirmwareEnvironmentVariableA,@503") +#pragma comment(linker, "/export:GetFirmwareEnvironmentVariableW=kernel32.GetFirmwareEnvironmentVariableW,@504") +#pragma comment(linker, "/export:GetFullPathNameA=kernel32.GetFullPathNameA,@505") +#pragma comment(linker, "/export:GetFullPathNameTransactedA=kernel32.GetFullPathNameTransactedA,@506") +#pragma comment(linker, "/export:GetFullPathNameTransactedW=kernel32.GetFullPathNameTransactedW,@507") +#pragma comment(linker, "/export:GetFullPathNameW=kernel32.GetFullPathNameW,@508") +#pragma comment(linker, "/export:GetGeoInfoA=kernel32.GetGeoInfoA,@509") +#pragma comment(linker, "/export:GetGeoInfoW=kernel32.GetGeoInfoW,@510") +#pragma comment(linker, "/export:GetHandleContext=kernel32.GetHandleContext,@511") +#pragma comment(linker, "/export:GetHandleInformation=kernel32.GetHandleInformation,@512") +#pragma comment(linker, "/export:GetLargePageMinimum=kernel32.GetLargePageMinimum,@513") +#pragma comment(linker, "/export:GetLargestConsoleWindowSize=kernel32.GetLargestConsoleWindowSize,@514") +#pragma comment(linker, "/export:GetLastError=kernel32.GetLastError,@515") +#pragma comment(linker, "/export:GetLocalTime=kernel32.GetLocalTime,@516") +#pragma comment(linker, "/export:GetLocaleInfoA=kernel32.GetLocaleInfoA,@517") +#pragma comment(linker, "/export:GetLocaleInfoEx=kernel32.GetLocaleInfoEx,@518") +#pragma comment(linker, "/export:GetLocaleInfoW=kernel32.GetLocaleInfoW,@519") +#pragma comment(linker, "/export:GetLogicalDriveStringsA=kernel32.GetLogicalDriveStringsA,@520") +#pragma comment(linker, "/export:GetLogicalDriveStringsW=kernel32.GetLogicalDriveStringsW,@521") +#pragma comment(linker, "/export:GetLogicalDrives=kernel32.GetLogicalDrives,@522") +#pragma comment(linker, "/export:GetLogicalProcessorInformation=kernel32.GetLogicalProcessorInformation,@523") +#pragma comment(linker, "/export:GetLogicalProcessorInformationEx=kernel32.GetLogicalProcessorInformationEx,@524") +#pragma comment(linker, "/export:GetLongPathNameA=kernel32.GetLongPathNameA,@525") +#pragma comment(linker, "/export:GetLongPathNameTransactedA=kernel32.GetLongPathNameTransactedA,@526") +#pragma comment(linker, "/export:GetLongPathNameTransactedW=kernel32.GetLongPathNameTransactedW,@527") +#pragma comment(linker, "/export:GetLongPathNameW=kernel32.GetLongPathNameW,@528") +#pragma comment(linker, "/export:GetMailslotInfo=kernel32.GetMailslotInfo,@529") +#pragma comment(linker, "/export:GetMaximumProcessorCount=kernel32.GetMaximumProcessorCount,@530") +#pragma comment(linker, "/export:GetMaximumProcessorGroupCount=kernel32.GetMaximumProcessorGroupCount,@531") +#pragma comment(linker, "/export:GetModuleFileNameA=kernel32.GetModuleFileNameA,@532") +#pragma comment(linker, "/export:GetModuleFileNameW=kernel32.GetModuleFileNameW,@533") +#pragma comment(linker, "/export:GetModuleHandleA=kernel32.GetModuleHandleA,@534") +#pragma comment(linker, "/export:GetModuleHandleExA=kernel32.GetModuleHandleExA,@535") +#pragma comment(linker, "/export:GetModuleHandleExW=kernel32.GetModuleHandleExW,@536") +#pragma comment(linker, "/export:GetModuleHandleW=kernel32.GetModuleHandleW,@537") +#pragma comment(linker, "/export:GetNLSVersion=kernel32.GetNLSVersion,@538") +#pragma comment(linker, "/export:GetNLSVersionEx=kernel32.GetNLSVersionEx,@539") +#pragma comment(linker, "/export:GetNamedPipeAttribute=kernel32.GetNamedPipeAttribute,@540") +#pragma comment(linker, "/export:GetNamedPipeClientComputerNameA=kernel32.GetNamedPipeClientComputerNameA,@541") +#pragma comment(linker, "/export:GetNamedPipeClientComputerNameW=kernel32.GetNamedPipeClientComputerNameW,@542") +#pragma comment(linker, "/export:GetNamedPipeClientProcessId=kernel32.GetNamedPipeClientProcessId,@543") +#pragma comment(linker, "/export:GetNamedPipeClientSessionId=kernel32.GetNamedPipeClientSessionId,@544") +#pragma comment(linker, "/export:GetNamedPipeHandleStateA=kernel32.GetNamedPipeHandleStateA,@545") +#pragma comment(linker, "/export:GetNamedPipeHandleStateW=kernel32.GetNamedPipeHandleStateW,@546") +#pragma comment(linker, "/export:GetNamedPipeInfo=kernel32.GetNamedPipeInfo,@547") +#pragma comment(linker, "/export:GetNamedPipeServerProcessId=kernel32.GetNamedPipeServerProcessId,@548") +#pragma comment(linker, "/export:GetNamedPipeServerSessionId=kernel32.GetNamedPipeServerSessionId,@549") +#pragma comment(linker, "/export:GetNativeSystemInfo=kernel32.GetNativeSystemInfo,@550") +#pragma comment(linker, "/export:GetNextVDMCommand=kernel32.GetNextVDMCommand,@551") +#pragma comment(linker, "/export:GetNumaAvailableMemoryNode=kernel32.GetNumaAvailableMemoryNode,@552") +#pragma comment(linker, "/export:GetNumaAvailableMemoryNodeEx=kernel32.GetNumaAvailableMemoryNodeEx,@553") +#pragma comment(linker, "/export:GetNumaHighestNodeNumber=kernel32.GetNumaHighestNodeNumber,@554") +#pragma comment(linker, "/export:GetNumaNodeNumberFromHandle=kernel32.GetNumaNodeNumberFromHandle,@555") +#pragma comment(linker, "/export:GetNumaNodeProcessorMask=kernel32.GetNumaNodeProcessorMask,@556") +#pragma comment(linker, "/export:GetNumaNodeProcessorMaskEx=kernel32.GetNumaNodeProcessorMaskEx,@557") +#pragma comment(linker, "/export:GetNumaProcessorNode=kernel32.GetNumaProcessorNode,@558") +#pragma comment(linker, "/export:GetNumaProcessorNodeEx=kernel32.GetNumaProcessorNodeEx,@559") +#pragma comment(linker, "/export:GetNumaProximityNode=kernel32.GetNumaProximityNode,@560") +#pragma comment(linker, "/export:GetNumaProximityNodeEx=kernel32.GetNumaProximityNodeEx,@561") +#pragma comment(linker, "/export:GetNumberFormatA=kernel32.GetNumberFormatA,@562") +#pragma comment(linker, "/export:GetNumberFormatEx=kernel32.GetNumberFormatEx,@563") +#pragma comment(linker, "/export:GetNumberFormatW=kernel32.GetNumberFormatW,@564") +#pragma comment(linker, "/export:GetNumberOfConsoleFonts=kernel32.GetNumberOfConsoleFonts,@565") +#pragma comment(linker, "/export:GetNumberOfConsoleInputEvents=kernel32.GetNumberOfConsoleInputEvents,@566") +#pragma comment(linker, "/export:GetNumberOfConsoleMouseButtons=kernel32.GetNumberOfConsoleMouseButtons,@567") +#pragma comment(linker, "/export:GetOEMCP=kernel32.GetOEMCP,@568") +#pragma comment(linker, "/export:GetOverlappedResult=kernel32.GetOverlappedResult,@569") +#pragma comment(linker, "/export:GetPhysicallyInstalledSystemMemory=kernel32.GetPhysicallyInstalledSystemMemory,@570") +#pragma comment(linker, "/export:GetPriorityClass=kernel32.GetPriorityClass,@571") +#pragma comment(linker, "/export:GetPrivateProfileIntA=kernel32.GetPrivateProfileIntA,@572") +#pragma comment(linker, "/export:GetPrivateProfileIntW=kernel32.GetPrivateProfileIntW,@573") +#pragma comment(linker, "/export:GetPrivateProfileSectionA=kernel32.GetPrivateProfileSectionA,@574") +#pragma comment(linker, "/export:GetPrivateProfileSectionNamesA=kernel32.GetPrivateProfileSectionNamesA,@575") +#pragma comment(linker, "/export:GetPrivateProfileSectionNamesW=kernel32.GetPrivateProfileSectionNamesW,@576") +#pragma comment(linker, "/export:GetPrivateProfileSectionW=kernel32.GetPrivateProfileSectionW,@577") +#pragma comment(linker, "/export:GetPrivateProfileStringA=kernel32.GetPrivateProfileStringA,@578") +#pragma comment(linker, "/export:GetPrivateProfileStringW=kernel32.GetPrivateProfileStringW,@579") +#pragma comment(linker, "/export:GetPrivateProfileStructA=kernel32.GetPrivateProfileStructA,@580") +#pragma comment(linker, "/export:GetPrivateProfileStructW=kernel32.GetPrivateProfileStructW,@581") +#pragma comment(linker, "/export:GetProcAddress=kernel32.GetProcAddress,@582") +#pragma comment(linker, "/export:GetProcessAffinityMask=kernel32.GetProcessAffinityMask,@583") +#pragma comment(linker, "/export:GetProcessDEPPolicy=kernel32.GetProcessDEPPolicy,@584") +#pragma comment(linker, "/export:GetProcessGroupAffinity=kernel32.GetProcessGroupAffinity,@585") +#pragma comment(linker, "/export:GetProcessHandleCount=kernel32.GetProcessHandleCount,@586") +#pragma comment(linker, "/export:GetProcessHeap=kernel32.GetProcessHeap,@587") +#pragma comment(linker, "/export:GetProcessHeaps=kernel32.GetProcessHeaps,@588") +#pragma comment(linker, "/export:GetProcessId=kernel32.GetProcessId,@589") +#pragma comment(linker, "/export:GetProcessIdOfThread=kernel32.GetProcessIdOfThread,@590") +#pragma comment(linker, "/export:GetProcessIoCounters=kernel32.GetProcessIoCounters,@591") +#pragma comment(linker, "/export:GetProcessPreferredUILanguages=kernel32.GetProcessPreferredUILanguages,@592") +#pragma comment(linker, "/export:GetProcessPriorityBoost=kernel32.GetProcessPriorityBoost,@593") +#pragma comment(linker, "/export:GetProcessShutdownParameters=kernel32.GetProcessShutdownParameters,@594") +#pragma comment(linker, "/export:GetProcessTimes=kernel32.GetProcessTimes,@595") +#pragma comment(linker, "/export:GetProcessUserModeExceptionPolicy=kernel32.GetProcessUserModeExceptionPolicy,@596") +#pragma comment(linker, "/export:GetProcessVersion=kernel32.GetProcessVersion,@597") +#pragma comment(linker, "/export:GetProcessWorkingSetSize=kernel32.GetProcessWorkingSetSize,@598") +#pragma comment(linker, "/export:GetProcessWorkingSetSizeEx=kernel32.GetProcessWorkingSetSizeEx,@599") +#pragma comment(linker, "/export:GetProcessorSystemCycleTime=kernel32.GetProcessorSystemCycleTime,@600") +#pragma comment(linker, "/export:GetProductInfo=kernel32.GetProductInfo,@601") +#pragma comment(linker, "/export:GetProfileIntA=kernel32.GetProfileIntA,@602") +#pragma comment(linker, "/export:GetProfileIntW=kernel32.GetProfileIntW,@603") +#pragma comment(linker, "/export:GetProfileSectionA=kernel32.GetProfileSectionA,@604") +#pragma comment(linker, "/export:GetProfileSectionW=kernel32.GetProfileSectionW,@605") +#pragma comment(linker, "/export:GetProfileStringA=kernel32.GetProfileStringA,@606") +#pragma comment(linker, "/export:GetProfileStringW=kernel32.GetProfileStringW,@607") +#pragma comment(linker, "/export:GetQueuedCompletionStatus=kernel32.GetQueuedCompletionStatus,@608") +#pragma comment(linker, "/export:GetQueuedCompletionStatusEx=kernel32.GetQueuedCompletionStatusEx,@609") +#pragma comment(linker, "/export:GetShortPathNameA=kernel32.GetShortPathNameA,@610") +#pragma comment(linker, "/export:GetShortPathNameW=kernel32.GetShortPathNameW,@611") +#pragma comment(linker, "/export:GetStartupInfoA=kernel32.GetStartupInfoA,@612") +#pragma comment(linker, "/export:GetStartupInfoW=kernel32.GetStartupInfoW,@613") +#pragma comment(linker, "/export:GetStdHandle=kernel32.GetStdHandle,@614") +#pragma comment(linker, "/export:GetStringScripts=kernel32.GetStringScripts,@615") +#pragma comment(linker, "/export:GetStringTypeA=kernel32.GetStringTypeA,@616") +#pragma comment(linker, "/export:GetStringTypeExA=kernel32.GetStringTypeExA,@617") +#pragma comment(linker, "/export:GetStringTypeExW=kernel32.GetStringTypeExW,@618") +#pragma comment(linker, "/export:GetStringTypeW=kernel32.GetStringTypeW,@619") +#pragma comment(linker, "/export:GetSystemDEPPolicy=kernel32.GetSystemDEPPolicy,@620") +#pragma comment(linker, "/export:GetSystemDefaultLCID=kernel32.GetSystemDefaultLCID,@621") +#pragma comment(linker, "/export:GetSystemDefaultLangID=kernel32.GetSystemDefaultLangID,@622") +#pragma comment(linker, "/export:GetSystemDefaultLocaleName=kernel32.GetSystemDefaultLocaleName,@623") +#pragma comment(linker, "/export:GetSystemDefaultUILanguage=kernel32.GetSystemDefaultUILanguage,@624") +#pragma comment(linker, "/export:GetSystemDirectoryA=kernel32.GetSystemDirectoryA,@625") +#pragma comment(linker, "/export:GetSystemDirectoryW=kernel32.GetSystemDirectoryW,@626") +#pragma comment(linker, "/export:GetSystemFileCacheSize=kernel32.GetSystemFileCacheSize,@627") +#pragma comment(linker, "/export:GetSystemFirmwareTable=kernel32.GetSystemFirmwareTable,@628") +#pragma comment(linker, "/export:GetSystemInfo=kernel32.GetSystemInfo,@629") +#pragma comment(linker, "/export:GetSystemPowerStatus=kernel32.GetSystemPowerStatus,@630") +#pragma comment(linker, "/export:GetSystemPreferredUILanguages=kernel32.GetSystemPreferredUILanguages,@631") +#pragma comment(linker, "/export:GetSystemRegistryQuota=kernel32.GetSystemRegistryQuota,@632") +#pragma comment(linker, "/export:GetSystemTime=kernel32.GetSystemTime,@633") +#pragma comment(linker, "/export:GetSystemTimeAdjustment=kernel32.GetSystemTimeAdjustment,@634") +#pragma comment(linker, "/export:GetSystemTimeAsFileTime=kernel32.GetSystemTimeAsFileTime,@635") +#pragma comment(linker, "/export:GetSystemTimes=kernel32.GetSystemTimes,@636") +#pragma comment(linker, "/export:GetSystemWindowsDirectoryA=kernel32.GetSystemWindowsDirectoryA,@637") +#pragma comment(linker, "/export:GetSystemWindowsDirectoryW=kernel32.GetSystemWindowsDirectoryW,@638") +#pragma comment(linker, "/export:GetSystemWow64DirectoryA=kernel32.GetSystemWow64DirectoryA,@639") +#pragma comment(linker, "/export:GetSystemWow64DirectoryW=kernel32.GetSystemWow64DirectoryW,@640") +#pragma comment(linker, "/export:GetTapeParameters=kernel32.GetTapeParameters,@641") +#pragma comment(linker, "/export:GetTapePosition=kernel32.GetTapePosition,@642") +#pragma comment(linker, "/export:GetTapeStatus=kernel32.GetTapeStatus,@643") +#pragma comment(linker, "/export:GetTempFileNameA=kernel32.GetTempFileNameA,@644") +#pragma comment(linker, "/export:GetTempFileNameW=kernel32.GetTempFileNameW,@645") +#pragma comment(linker, "/export:GetTempPathA=kernel32.GetTempPathA,@646") +#pragma comment(linker, "/export:GetTempPathW=kernel32.GetTempPathW,@647") +#pragma comment(linker, "/export:GetThreadContext=kernel32.GetThreadContext,@648") +#pragma comment(linker, "/export:GetThreadErrorMode=kernel32.GetThreadErrorMode,@649") +#pragma comment(linker, "/export:GetThreadGroupAffinity=kernel32.GetThreadGroupAffinity,@650") +#pragma comment(linker, "/export:GetThreadIOPendingFlag=kernel32.GetThreadIOPendingFlag,@651") +#pragma comment(linker, "/export:GetThreadId=kernel32.GetThreadId,@652") +#pragma comment(linker, "/export:GetThreadIdealProcessorEx=kernel32.GetThreadIdealProcessorEx,@653") +#pragma comment(linker, "/export:GetThreadLocale=kernel32.GetThreadLocale,@654") +#pragma comment(linker, "/export:GetThreadPreferredUILanguages=kernel32.GetThreadPreferredUILanguages,@655") +#pragma comment(linker, "/export:GetThreadPriority=kernel32.GetThreadPriority,@656") +#pragma comment(linker, "/export:GetThreadPriorityBoost=kernel32.GetThreadPriorityBoost,@657") +#pragma comment(linker, "/export:GetThreadSelectorEntry=kernel32.GetThreadSelectorEntry,@658") +#pragma comment(linker, "/export:GetThreadTimes=kernel32.GetThreadTimes,@659") +#pragma comment(linker, "/export:GetThreadUILanguage=kernel32.GetThreadUILanguage,@660") +#pragma comment(linker, "/export:GetTickCount=kernel32.GetTickCount,@662") +#pragma comment(linker, "/export:GetTickCount64=kernel32.GetTickCount64,@661") +#pragma comment(linker, "/export:GetTimeFormatA=kernel32.GetTimeFormatA,@663") +#pragma comment(linker, "/export:GetTimeFormatEx=kernel32.GetTimeFormatEx,@664") +#pragma comment(linker, "/export:GetTimeFormatW=kernel32.GetTimeFormatW,@665") +#pragma comment(linker, "/export:GetTimeZoneInformation=kernel32.GetTimeZoneInformation,@666") +#pragma comment(linker, "/export:GetTimeZoneInformationForYear=kernel32.GetTimeZoneInformationForYear,@667") +#pragma comment(linker, "/export:GetUILanguageInfo=kernel32.GetUILanguageInfo,@668") +#pragma comment(linker, "/export:GetUserDefaultLCID=kernel32.GetUserDefaultLCID,@669") +#pragma comment(linker, "/export:GetUserDefaultLangID=kernel32.GetUserDefaultLangID,@670") +#pragma comment(linker, "/export:GetUserDefaultLocaleName=kernel32.GetUserDefaultLocaleName,@671") +#pragma comment(linker, "/export:GetUserDefaultUILanguage=kernel32.GetUserDefaultUILanguage,@672") +#pragma comment(linker, "/export:GetUserGeoID=kernel32.GetUserGeoID,@673") +#pragma comment(linker, "/export:GetUserPreferredUILanguages=kernel32.GetUserPreferredUILanguages,@674") +#pragma comment(linker, "/export:GetVDMCurrentDirectories=kernel32.GetVDMCurrentDirectories,@675") +#pragma comment(linker, "/export:GetVersion=kernel32.GetVersion,@676") +#pragma comment(linker, "/export:GetVersionExA=kernel32.GetVersionExA,@677") +#pragma comment(linker, "/export:GetVersionExW=kernel32.GetVersionExW,@678") +#pragma comment(linker, "/export:GetVolumeInformationA=kernel32.GetVolumeInformationA,@679") +#pragma comment(linker, "/export:GetVolumeInformationByHandleW=kernel32.GetVolumeInformationByHandleW,@680") +#pragma comment(linker, "/export:GetVolumeInformationW=kernel32.GetVolumeInformationW,@681") +#pragma comment(linker, "/export:GetVolumeNameForVolumeMountPointA=kernel32.GetVolumeNameForVolumeMountPointA,@682") +#pragma comment(linker, "/export:GetVolumeNameForVolumeMountPointW=kernel32.GetVolumeNameForVolumeMountPointW,@683") +#pragma comment(linker, "/export:GetVolumePathNameA=kernel32.GetVolumePathNameA,@684") +#pragma comment(linker, "/export:GetVolumePathNameW=kernel32.GetVolumePathNameW,@685") +#pragma comment(linker, "/export:GetVolumePathNamesForVolumeNameA=kernel32.GetVolumePathNamesForVolumeNameA,@686") +#pragma comment(linker, "/export:GetVolumePathNamesForVolumeNameW=kernel32.GetVolumePathNamesForVolumeNameW,@687") +#pragma comment(linker, "/export:GetWindowsDirectoryA=kernel32.GetWindowsDirectoryA,@688") +#pragma comment(linker, "/export:GetWindowsDirectoryW=kernel32.GetWindowsDirectoryW,@689") +#pragma comment(linker, "/export:GetWriteWatch=kernel32.GetWriteWatch,@690") +#pragma comment(linker, "/export:GetXStateFeaturesMask=kernel32.GetXStateFeaturesMask,@691") +#pragma comment(linker, "/export:GlobalAddAtomA=kernel32.GlobalAddAtomA,@692") +#pragma comment(linker, "/export:GlobalAddAtomW=kernel32.GlobalAddAtomW,@693") +#pragma comment(linker, "/export:GlobalAlloc=kernel32.GlobalAlloc,@694") +#pragma comment(linker, "/export:GlobalCompact=kernel32.GlobalCompact,@695") +#pragma comment(linker, "/export:GlobalDeleteAtom=kernel32.GlobalDeleteAtom,@696") +#pragma comment(linker, "/export:GlobalFindAtomA=kernel32.GlobalFindAtomA,@697") +#pragma comment(linker, "/export:GlobalFindAtomW=kernel32.GlobalFindAtomW,@698") +#pragma comment(linker, "/export:GlobalFix=kernel32.GlobalFix,@699") +#pragma comment(linker, "/export:GlobalFlags=kernel32.GlobalFlags,@700") +#pragma comment(linker, "/export:GlobalFree=kernel32.GlobalFree,@701") +#pragma comment(linker, "/export:GlobalGetAtomNameA=kernel32.GlobalGetAtomNameA,@702") +#pragma comment(linker, "/export:GlobalGetAtomNameW=kernel32.GlobalGetAtomNameW,@703") +#pragma comment(linker, "/export:GlobalHandle=kernel32.GlobalHandle,@704") +#pragma comment(linker, "/export:GlobalLock=kernel32.GlobalLock,@705") +#pragma comment(linker, "/export:GlobalMemoryStatus=kernel32.GlobalMemoryStatus,@706") +#pragma comment(linker, "/export:GlobalMemoryStatusEx=kernel32.GlobalMemoryStatusEx,@707") +#pragma comment(linker, "/export:GlobalReAlloc=kernel32.GlobalReAlloc,@708") +#pragma comment(linker, "/export:GlobalSize=kernel32.GlobalSize,@709") +#pragma comment(linker, "/export:GlobalUnWire=kernel32.GlobalUnWire,@710") +#pragma comment(linker, "/export:GlobalUnfix=kernel32.GlobalUnfix,@711") +#pragma comment(linker, "/export:GlobalUnlock=kernel32.GlobalUnlock,@712") +#pragma comment(linker, "/export:GlobalWire=kernel32.GlobalWire,@713") +#pragma comment(linker, "/export:Heap32First=kernel32.Heap32First,@714") +#pragma comment(linker, "/export:Heap32ListFirst=kernel32.Heap32ListFirst,@715") +#pragma comment(linker, "/export:Heap32ListNext=kernel32.Heap32ListNext,@716") +#pragma comment(linker, "/export:Heap32Next=kernel32.Heap32Next,@717") +#pragma comment(linker, "/export:HeapAlloc=kernel32.HeapAlloc,@718") +#pragma comment(linker, "/export:HeapCompact=kernel32.HeapCompact,@719") +#pragma comment(linker, "/export:HeapCreate=kernel32.HeapCreate,@720") +#pragma comment(linker, "/export:HeapDestroy=kernel32.HeapDestroy,@721") +#pragma comment(linker, "/export:HeapFree=kernel32.HeapFree,@722") +#pragma comment(linker, "/export:HeapLock=kernel32.HeapLock,@723") +#pragma comment(linker, "/export:HeapQueryInformation=kernel32.HeapQueryInformation,@724") +#pragma comment(linker, "/export:HeapReAlloc=kernel32.HeapReAlloc,@725") +#pragma comment(linker, "/export:HeapSetInformation=kernel32.HeapSetInformation,@726") +#pragma comment(linker, "/export:HeapSize=kernel32.HeapSize,@727") +#pragma comment(linker, "/export:HeapSummary=kernel32.HeapSummary,@728") +#pragma comment(linker, "/export:HeapUnlock=kernel32.HeapUnlock,@729") +#pragma comment(linker, "/export:HeapValidate=kernel32.HeapValidate,@730") +#pragma comment(linker, "/export:HeapWalk=kernel32.HeapWalk,@731") +#pragma comment(linker, "/export:IdnToAscii=kernel32.IdnToAscii,@732") +#pragma comment(linker, "/export:IdnToNameprepUnicode=kernel32.IdnToNameprepUnicode,@733") +#pragma comment(linker, "/export:IdnToUnicode=kernel32.IdnToUnicode,@734") +#pragma comment(linker, "/export:InitAtomTable=kernel32.InitAtomTable,@735") +#pragma comment(linker, "/export:InitOnceBeginInitialize=kernel32.InitOnceBeginInitialize,@736") +#pragma comment(linker, "/export:InitOnceComplete=kernel32.InitOnceComplete,@737") +#pragma comment(linker, "/export:InitOnceExecuteOnce=kernel32.InitOnceExecuteOnce,@738") +#pragma comment(linker, "/export:InitOnceInitialize=kernel32.InitOnceInitialize,@739") +#pragma comment(linker, "/export:InitializeConditionVariable=kernel32.InitializeConditionVariable,@740") +#pragma comment(linker, "/export:InitializeContext=kernel32.InitializeContext,@741") +#pragma comment(linker, "/export:InitializeCriticalSection=kernel32.InitializeCriticalSection,@742") +#pragma comment(linker, "/export:InitializeCriticalSectionAndSpinCount=kernel32.InitializeCriticalSectionAndSpinCount,@743") +#pragma comment(linker, "/export:InitializeCriticalSectionEx=kernel32.InitializeCriticalSectionEx,@744") +#pragma comment(linker, "/export:InitializeProcThreadAttributeList=kernel32.InitializeProcThreadAttributeList,@745") +#pragma comment(linker, "/export:InitializeSListHead=kernel32.InitializeSListHead,@746") +#pragma comment(linker, "/export:InitializeSRWLock=kernel32.InitializeSRWLock,@747") +#pragma comment(linker, "/export:InterlockedCompareExchange=kernel32.InterlockedCompareExchange,@749") +#pragma comment(linker, "/export:InterlockedCompareExchange64=kernel32.InterlockedCompareExchange64,@748") +#pragma comment(linker, "/export:InterlockedDecrement=kernel32.InterlockedDecrement,@750") +#pragma comment(linker, "/export:InterlockedExchange=kernel32.InterlockedExchange,@751") +#pragma comment(linker, "/export:InterlockedExchangeAdd=kernel32.InterlockedExchangeAdd,@752") +#pragma comment(linker, "/export:InterlockedFlushSList=kernel32.InterlockedFlushSList,@753") +#pragma comment(linker, "/export:InterlockedIncrement=kernel32.InterlockedIncrement,@754") +#pragma comment(linker, "/export:InterlockedPopEntrySList=kernel32.InterlockedPopEntrySList,@755") +#pragma comment(linker, "/export:InterlockedPushEntrySList=kernel32.InterlockedPushEntrySList,@756") +#pragma comment(linker, "/export:InterlockedPushListSList=kernel32.InterlockedPushListSList,@2") +#pragma comment(linker, "/export:InvalidateConsoleDIBits=kernel32.InvalidateConsoleDIBits,@757") +#pragma comment(linker, "/export:IsBadCodePtr=kernel32.IsBadCodePtr,@758") +#pragma comment(linker, "/export:IsBadHugeReadPtr=kernel32.IsBadHugeReadPtr,@759") +#pragma comment(linker, "/export:IsBadHugeWritePtr=kernel32.IsBadHugeWritePtr,@760") +#pragma comment(linker, "/export:IsBadReadPtr=kernel32.IsBadReadPtr,@761") +#pragma comment(linker, "/export:IsBadStringPtrA=kernel32.IsBadStringPtrA,@762") +#pragma comment(linker, "/export:IsBadStringPtrW=kernel32.IsBadStringPtrW,@763") +#pragma comment(linker, "/export:IsBadWritePtr=kernel32.IsBadWritePtr,@764") +#pragma comment(linker, "/export:IsCalendarLeapDay=kernel32.IsCalendarLeapDay,@765") +#pragma comment(linker, "/export:IsCalendarLeapMonth=kernel32.IsCalendarLeapMonth,@766") +#pragma comment(linker, "/export:IsCalendarLeapYear=kernel32.IsCalendarLeapYear,@767") +#pragma comment(linker, "/export:IsDBCSLeadByte=kernel32.IsDBCSLeadByte,@768") +#pragma comment(linker, "/export:IsDBCSLeadByteEx=kernel32.IsDBCSLeadByteEx,@769") +#pragma comment(linker, "/export:IsDebuggerPresent=kernel32.IsDebuggerPresent,@770") +#pragma comment(linker, "/export:IsNLSDefinedString=kernel32.IsNLSDefinedString,@771") +#pragma comment(linker, "/export:IsNormalizedString=kernel32.IsNormalizedString,@772") +#pragma comment(linker, "/export:IsProcessInJob=kernel32.IsProcessInJob,@773") +#pragma comment(linker, "/export:IsProcessorFeaturePresent=kernel32.IsProcessorFeaturePresent,@774") +#pragma comment(linker, "/export:IsSystemResumeAutomatic=kernel32.IsSystemResumeAutomatic,@775") +#pragma comment(linker, "/export:IsThreadAFiber=kernel32.IsThreadAFiber,@776") +#pragma comment(linker, "/export:IsThreadpoolTimerSet=kernel32.IsThreadpoolTimerSet,@777") +#pragma comment(linker, "/export:IsTimeZoneRedirectionEnabled=kernel32.IsTimeZoneRedirectionEnabled,@778") +#pragma comment(linker, "/export:IsValidCalDateTime=kernel32.IsValidCalDateTime,@779") +#pragma comment(linker, "/export:IsValidCodePage=kernel32.IsValidCodePage,@780") +#pragma comment(linker, "/export:IsValidLanguageGroup=kernel32.IsValidLanguageGroup,@781") +#pragma comment(linker, "/export:IsValidLocale=kernel32.IsValidLocale,@782") +#pragma comment(linker, "/export:IsValidLocaleName=kernel32.IsValidLocaleName,@783") +#pragma comment(linker, "/export:IsWow64Process=kernel32.IsWow64Process,@784") +#pragma comment(linker, "/export:K32EmptyWorkingSet=kernel32.K32EmptyWorkingSet,@785") +#pragma comment(linker, "/export:K32EnumDeviceDrivers=kernel32.K32EnumDeviceDrivers,@786") +#pragma comment(linker, "/export:K32EnumPageFilesA=kernel32.K32EnumPageFilesA,@787") +#pragma comment(linker, "/export:K32EnumPageFilesW=kernel32.K32EnumPageFilesW,@788") +#pragma comment(linker, "/export:K32EnumProcessModules=kernel32.K32EnumProcessModules,@789") +#pragma comment(linker, "/export:K32EnumProcessModulesEx=kernel32.K32EnumProcessModulesEx,@790") +#pragma comment(linker, "/export:K32EnumProcesses=kernel32.K32EnumProcesses,@791") +#pragma comment(linker, "/export:K32GetDeviceDriverBaseNameA=kernel32.K32GetDeviceDriverBaseNameA,@792") +#pragma comment(linker, "/export:K32GetDeviceDriverBaseNameW=kernel32.K32GetDeviceDriverBaseNameW,@793") +#pragma comment(linker, "/export:K32GetDeviceDriverFileNameA=kernel32.K32GetDeviceDriverFileNameA,@794") +#pragma comment(linker, "/export:K32GetDeviceDriverFileNameW=kernel32.K32GetDeviceDriverFileNameW,@795") +#pragma comment(linker, "/export:K32GetMappedFileNameA=kernel32.K32GetMappedFileNameA,@796") +#pragma comment(linker, "/export:K32GetMappedFileNameW=kernel32.K32GetMappedFileNameW,@797") +#pragma comment(linker, "/export:K32GetModuleBaseNameA=kernel32.K32GetModuleBaseNameA,@798") +#pragma comment(linker, "/export:K32GetModuleBaseNameW=kernel32.K32GetModuleBaseNameW,@799") +#pragma comment(linker, "/export:K32GetModuleFileNameExA=kernel32.K32GetModuleFileNameExA,@800") +#pragma comment(linker, "/export:K32GetModuleFileNameExW=kernel32.K32GetModuleFileNameExW,@801") +#pragma comment(linker, "/export:K32GetModuleInformation=kernel32.K32GetModuleInformation,@802") +#pragma comment(linker, "/export:K32GetPerformanceInfo=kernel32.K32GetPerformanceInfo,@803") +#pragma comment(linker, "/export:K32GetProcessImageFileNameA=kernel32.K32GetProcessImageFileNameA,@804") +#pragma comment(linker, "/export:K32GetProcessImageFileNameW=kernel32.K32GetProcessImageFileNameW,@805") +#pragma comment(linker, "/export:K32GetProcessMemoryInfo=kernel32.K32GetProcessMemoryInfo,@806") +#pragma comment(linker, "/export:K32GetWsChanges=kernel32.K32GetWsChanges,@807") +#pragma comment(linker, "/export:K32GetWsChangesEx=kernel32.K32GetWsChangesEx,@808") +#pragma comment(linker, "/export:K32InitializeProcessForWsWatch=kernel32.K32InitializeProcessForWsWatch,@809") +#pragma comment(linker, "/export:K32QueryWorkingSet=kernel32.K32QueryWorkingSet,@810") +#pragma comment(linker, "/export:K32QueryWorkingSetEx=kernel32.K32QueryWorkingSetEx,@811") +#pragma comment(linker, "/export:LCIDToLocaleName=kernel32.LCIDToLocaleName,@812") +#pragma comment(linker, "/export:LCMapStringA=kernel32.LCMapStringA,@813") +#pragma comment(linker, "/export:LCMapStringEx=kernel32.LCMapStringEx,@814") +#pragma comment(linker, "/export:LCMapStringW=kernel32.LCMapStringW,@815") +#pragma comment(linker, "/export:LZClose=kernel32.LZClose,@816") +#pragma comment(linker, "/export:LZCloseFile=kernel32.LZCloseFile,@817") +#pragma comment(linker, "/export:LZCopy=kernel32.LZCopy,@818") +#pragma comment(linker, "/export:LZCreateFileW=kernel32.LZCreateFileW,@819") +#pragma comment(linker, "/export:LZDone=kernel32.LZDone,@820") +#pragma comment(linker, "/export:LZInit=kernel32.LZInit,@821") +#pragma comment(linker, "/export:LZOpenFileA=kernel32.LZOpenFileA,@822") +#pragma comment(linker, "/export:LZOpenFileW=kernel32.LZOpenFileW,@823") +#pragma comment(linker, "/export:LZRead=kernel32.LZRead,@824") +#pragma comment(linker, "/export:LZSeek=kernel32.LZSeek,@825") +#pragma comment(linker, "/export:LZStart=kernel32.LZStart,@826") +#pragma comment(linker, "/export:LeaveCriticalSection=kernel32.LeaveCriticalSection,@827") +#pragma comment(linker, "/export:LeaveCriticalSectionWhenCallbackReturns=kernel32.LeaveCriticalSectionWhenCallbackReturns,@828") +#pragma comment(linker, "/export:LoadAppInitDlls=kernel32.LoadAppInitDlls,@829") +#pragma comment(linker, "/export:LoadLibraryA=kernel32.LoadLibraryA,@830") +#pragma comment(linker, "/export:LoadLibraryExA=kernel32.LoadLibraryExA,@831") +#pragma comment(linker, "/export:LoadLibraryExW=kernel32.LoadLibraryExW,@832") +#pragma comment(linker, "/export:LoadLibraryW=kernel32.LoadLibraryW,@833") +#pragma comment(linker, "/export:LoadModule=kernel32.LoadModule,@834") +#pragma comment(linker, "/export:LoadResource=kernel32.LoadResource,@835") +#pragma comment(linker, "/export:LoadStringBaseExW=kernel32.LoadStringBaseExW,@836") +#pragma comment(linker, "/export:LoadStringBaseW=kernel32.LoadStringBaseW,@837") +#pragma comment(linker, "/export:LocalAlloc=kernel32.LocalAlloc,@838") +#pragma comment(linker, "/export:LocalCompact=kernel32.LocalCompact,@839") +#pragma comment(linker, "/export:LocalFileTimeToFileTime=kernel32.LocalFileTimeToFileTime,@840") +#pragma comment(linker, "/export:LocalFlags=kernel32.LocalFlags,@841") +#pragma comment(linker, "/export:LocalFree=kernel32.LocalFree,@842") +#pragma comment(linker, "/export:LocalHandle=kernel32.LocalHandle,@843") +#pragma comment(linker, "/export:LocalLock=kernel32.LocalLock,@844") +#pragma comment(linker, "/export:LocalReAlloc=kernel32.LocalReAlloc,@845") +#pragma comment(linker, "/export:LocalShrink=kernel32.LocalShrink,@846") +#pragma comment(linker, "/export:LocalSize=kernel32.LocalSize,@847") +#pragma comment(linker, "/export:LocalUnlock=kernel32.LocalUnlock,@848") +#pragma comment(linker, "/export:LocaleNameToLCID=kernel32.LocaleNameToLCID,@849") +#pragma comment(linker, "/export:LocateXStateFeature=kernel32.LocateXStateFeature,@850") +#pragma comment(linker, "/export:LockFile=kernel32.LockFile,@851") +#pragma comment(linker, "/export:LockFileEx=kernel32.LockFileEx,@852") +#pragma comment(linker, "/export:LockResource=kernel32.LockResource,@853") +#pragma comment(linker, "/export:MapUserPhysicalPages=kernel32.MapUserPhysicalPages,@854") +#pragma comment(linker, "/export:MapUserPhysicalPagesScatter=kernel32.MapUserPhysicalPagesScatter,@855") +#pragma comment(linker, "/export:MapViewOfFile=kernel32.MapViewOfFile,@856") +#pragma comment(linker, "/export:MapViewOfFileEx=kernel32.MapViewOfFileEx,@857") +#pragma comment(linker, "/export:MapViewOfFileExNuma=kernel32.MapViewOfFileExNuma,@858") +#pragma comment(linker, "/export:Module32First=kernel32.Module32First,@859") +#pragma comment(linker, "/export:Module32FirstW=kernel32.Module32FirstW,@860") +#pragma comment(linker, "/export:Module32Next=kernel32.Module32Next,@861") +#pragma comment(linker, "/export:Module32NextW=kernel32.Module32NextW,@862") +#pragma comment(linker, "/export:MoveFileA=kernel32.MoveFileA,@863") +#pragma comment(linker, "/export:MoveFileExA=kernel32.MoveFileExA,@864") +#pragma comment(linker, "/export:MoveFileExW=kernel32.MoveFileExW,@865") +#pragma comment(linker, "/export:MoveFileTransactedA=kernel32.MoveFileTransactedA,@866") +#pragma comment(linker, "/export:MoveFileTransactedW=kernel32.MoveFileTransactedW,@867") +#pragma comment(linker, "/export:MoveFileW=kernel32.MoveFileW,@868") +#pragma comment(linker, "/export:MoveFileWithProgressA=kernel32.MoveFileWithProgressA,@869") +#pragma comment(linker, "/export:MoveFileWithProgressW=kernel32.MoveFileWithProgressW,@870") +#pragma comment(linker, "/export:MulDiv=kernel32.MulDiv,@871") +#pragma comment(linker, "/export:MultiByteToWideChar=kernel32.MultiByteToWideChar,@872") +#pragma comment(linker, "/export:NeedCurrentDirectoryForExePathA=kernel32.NeedCurrentDirectoryForExePathA,@873") +#pragma comment(linker, "/export:NeedCurrentDirectoryForExePathW=kernel32.NeedCurrentDirectoryForExePathW,@874") +#pragma comment(linker, "/export:NlsCheckPolicy=kernel32.NlsCheckPolicy,@875") +#pragma comment(linker, "/export:NlsEventDataDescCreate=kernel32.NlsEventDataDescCreate,@876") +#pragma comment(linker, "/export:NlsGetCacheUpdateCount=kernel32.NlsGetCacheUpdateCount,@877") +#pragma comment(linker, "/export:NlsUpdateLocale=kernel32.NlsUpdateLocale,@878") +#pragma comment(linker, "/export:NlsUpdateSystemLocale=kernel32.NlsUpdateSystemLocale,@879") +#pragma comment(linker, "/export:NlsWriteEtwEvent=kernel32.NlsWriteEtwEvent,@880") +#pragma comment(linker, "/export:NormalizeString=kernel32.NormalizeString,@881") +#pragma comment(linker, "/export:NotifyMountMgr=kernel32.NotifyMountMgr,@882") +#pragma comment(linker, "/export:NotifyUILanguageChange=kernel32.NotifyUILanguageChange,@883") +#pragma comment(linker, "/export:OpenConsoleW=kernel32.OpenConsoleW,@884") +#pragma comment(linker, "/export:OpenEventA=kernel32.OpenEventA,@885") +#pragma comment(linker, "/export:OpenEventW=kernel32.OpenEventW,@886") +#pragma comment(linker, "/export:OpenFile=kernel32.OpenFile,@887") +#pragma comment(linker, "/export:OpenFileById=kernel32.OpenFileById,@888") +#pragma comment(linker, "/export:OpenFileMappingA=kernel32.OpenFileMappingA,@889") +#pragma comment(linker, "/export:OpenFileMappingW=kernel32.OpenFileMappingW,@890") +#pragma comment(linker, "/export:OpenJobObjectA=kernel32.OpenJobObjectA,@891") +#pragma comment(linker, "/export:OpenJobObjectW=kernel32.OpenJobObjectW,@892") +#pragma comment(linker, "/export:OpenMutexA=kernel32.OpenMutexA,@893") +#pragma comment(linker, "/export:OpenMutexW=kernel32.OpenMutexW,@894") +#pragma comment(linker, "/export:OpenPrivateNamespaceA=kernel32.OpenPrivateNamespaceA,@895") +#pragma comment(linker, "/export:OpenPrivateNamespaceW=kernel32.OpenPrivateNamespaceW,@896") +#pragma comment(linker, "/export:OpenProcess=kernel32.OpenProcess,@897") +#pragma comment(linker, "/export:OpenProcessToken=kernel32.OpenProcessToken,@898") +#pragma comment(linker, "/export:OpenProfileUserMapping=kernel32.OpenProfileUserMapping,@899") +#pragma comment(linker, "/export:OpenSemaphoreA=kernel32.OpenSemaphoreA,@900") +#pragma comment(linker, "/export:OpenSemaphoreW=kernel32.OpenSemaphoreW,@901") +#pragma comment(linker, "/export:OpenThread=kernel32.OpenThread,@902") +#pragma comment(linker, "/export:OpenThreadToken=kernel32.OpenThreadToken,@903") +#pragma comment(linker, "/export:OpenWaitableTimerA=kernel32.OpenWaitableTimerA,@904") +#pragma comment(linker, "/export:OpenWaitableTimerW=kernel32.OpenWaitableTimerW,@905") +#pragma comment(linker, "/export:OutputDebugStringA=kernel32.OutputDebugStringA,@906") +#pragma comment(linker, "/export:OutputDebugStringW=kernel32.OutputDebugStringW,@907") +#pragma comment(linker, "/export:PeekConsoleInputA=kernel32.PeekConsoleInputA,@908") +#pragma comment(linker, "/export:PeekConsoleInputW=kernel32.PeekConsoleInputW,@909") +#pragma comment(linker, "/export:PeekNamedPipe=kernel32.PeekNamedPipe,@910") +#pragma comment(linker, "/export:PostQueuedCompletionStatus=kernel32.PostQueuedCompletionStatus,@911") +#pragma comment(linker, "/export:PowerClearRequest=kernel32.PowerClearRequest,@912") +#pragma comment(linker, "/export:PowerCreateRequest=kernel32.PowerCreateRequest,@913") +#pragma comment(linker, "/export:PowerSetRequest=kernel32.PowerSetRequest,@914") +#pragma comment(linker, "/export:PrepareTape=kernel32.PrepareTape,@915") +#pragma comment(linker, "/export:PrivCopyFileExW=kernel32.PrivCopyFileExW,@916") +#pragma comment(linker, "/export:PrivMoveFileIdentityW=kernel32.PrivMoveFileIdentityW,@917") +#pragma comment(linker, "/export:Process32First=kernel32.Process32First,@918") +#pragma comment(linker, "/export:Process32FirstW=kernel32.Process32FirstW,@919") +#pragma comment(linker, "/export:Process32Next=kernel32.Process32Next,@920") +#pragma comment(linker, "/export:Process32NextW=kernel32.Process32NextW,@921") +#pragma comment(linker, "/export:ProcessIdToSessionId=kernel32.ProcessIdToSessionId,@922") +#pragma comment(linker, "/export:PulseEvent=kernel32.PulseEvent,@923") +#pragma comment(linker, "/export:PurgeComm=kernel32.PurgeComm,@924") +#pragma comment(linker, "/export:QueryActCtxSettingsW=kernel32.QueryActCtxSettingsW,@925") +#pragma comment(linker, "/export:QueryActCtxW=kernel32.QueryActCtxW,@926") +#pragma comment(linker, "/export:QueryDepthSList=kernel32.QueryDepthSList,@927") +#pragma comment(linker, "/export:QueryDosDeviceA=kernel32.QueryDosDeviceA,@928") +#pragma comment(linker, "/export:QueryDosDeviceW=kernel32.QueryDosDeviceW,@929") +#pragma comment(linker, "/export:QueryFullProcessImageNameA=kernel32.QueryFullProcessImageNameA,@930") +#pragma comment(linker, "/export:QueryFullProcessImageNameW=kernel32.QueryFullProcessImageNameW,@931") +#pragma comment(linker, "/export:QueryIdleProcessorCycleTime=kernel32.QueryIdleProcessorCycleTime,@932") +#pragma comment(linker, "/export:QueryIdleProcessorCycleTimeEx=kernel32.QueryIdleProcessorCycleTimeEx,@933") +#pragma comment(linker, "/export:QueryInformationJobObject=kernel32.QueryInformationJobObject,@934") +#pragma comment(linker, "/export:QueryMemoryResourceNotification=kernel32.QueryMemoryResourceNotification,@935") +#pragma comment(linker, "/export:QueryPerformanceCounter=kernel32.QueryPerformanceCounter,@936") +#pragma comment(linker, "/export:QueryPerformanceFrequency=kernel32.QueryPerformanceFrequency,@937") +#pragma comment(linker, "/export:QueryProcessAffinityUpdateMode=kernel32.QueryProcessAffinityUpdateMode,@938") +#pragma comment(linker, "/export:QueryProcessCycleTime=kernel32.QueryProcessCycleTime,@939") +#pragma comment(linker, "/export:QueryThreadCycleTime=kernel32.QueryThreadCycleTime,@940") +#pragma comment(linker, "/export:QueryThreadProfiling=kernel32.QueryThreadProfiling,@941") +#pragma comment(linker, "/export:QueryThreadpoolStackInformation=kernel32.QueryThreadpoolStackInformation,@942") +#pragma comment(linker, "/export:QueryUnbiasedInterruptTime=kernel32.QueryUnbiasedInterruptTime,@943") +#pragma comment(linker, "/export:QueueUserAPC=kernel32.QueueUserAPC,@944") +#pragma comment(linker, "/export:QueueUserWorkItem=kernel32.QueueUserWorkItem,@945") +#pragma comment(linker, "/export:RaiseException=kernel32.RaiseException,@946") +#pragma comment(linker, "/export:RaiseFailFastException=kernel32.RaiseFailFastException,@947") +#pragma comment(linker, "/export:ReOpenFile=kernel32.ReOpenFile,@948") +#pragma comment(linker, "/export:ReadConsoleA=kernel32.ReadConsoleA,@949") +#pragma comment(linker, "/export:ReadConsoleInputA=kernel32.ReadConsoleInputA,@950") +#pragma comment(linker, "/export:ReadConsoleInputExA=kernel32.ReadConsoleInputExA,@951") +#pragma comment(linker, "/export:ReadConsoleInputExW=kernel32.ReadConsoleInputExW,@952") +#pragma comment(linker, "/export:ReadConsoleInputW=kernel32.ReadConsoleInputW,@953") +#pragma comment(linker, "/export:ReadConsoleOutputA=kernel32.ReadConsoleOutputA,@954") +#pragma comment(linker, "/export:ReadConsoleOutputAttribute=kernel32.ReadConsoleOutputAttribute,@955") +#pragma comment(linker, "/export:ReadConsoleOutputCharacterA=kernel32.ReadConsoleOutputCharacterA,@956") +#pragma comment(linker, "/export:ReadConsoleOutputCharacterW=kernel32.ReadConsoleOutputCharacterW,@957") +#pragma comment(linker, "/export:ReadConsoleOutputW=kernel32.ReadConsoleOutputW,@958") +#pragma comment(linker, "/export:ReadConsoleW=kernel32.ReadConsoleW,@959") +#pragma comment(linker, "/export:ReadDirectoryChangesW=kernel32.ReadDirectoryChangesW,@960") +#pragma comment(linker, "/export:ReadFile=kernel32.ReadFile,@961") +#pragma comment(linker, "/export:ReadFileEx=kernel32.ReadFileEx,@962") +#pragma comment(linker, "/export:ReadFileScatter=kernel32.ReadFileScatter,@963") +#pragma comment(linker, "/export:ReadProcessMemory=kernel32.ReadProcessMemory,@964") +#pragma comment(linker, "/export:ReadThreadProfilingData=kernel32.ReadThreadProfilingData,@965") +#pragma comment(linker, "/export:RegCloseKey=kernel32.RegCloseKey,@966") +#pragma comment(linker, "/export:RegCreateKeyExA=kernel32.RegCreateKeyExA,@967") +#pragma comment(linker, "/export:RegCreateKeyExW=kernel32.RegCreateKeyExW,@968") +#pragma comment(linker, "/export:RegDeleteKeyExA=kernel32.RegDeleteKeyExA,@969") +#pragma comment(linker, "/export:RegDeleteKeyExW=kernel32.RegDeleteKeyExW,@970") +#pragma comment(linker, "/export:RegDeleteTreeA=kernel32.RegDeleteTreeA,@971") +#pragma comment(linker, "/export:RegDeleteTreeW=kernel32.RegDeleteTreeW,@972") +#pragma comment(linker, "/export:RegDeleteValueA=kernel32.RegDeleteValueA,@973") +#pragma comment(linker, "/export:RegDeleteValueW=kernel32.RegDeleteValueW,@974") +#pragma comment(linker, "/export:RegDisablePredefinedCacheEx=kernel32.RegDisablePredefinedCacheEx,@975") +#pragma comment(linker, "/export:RegEnumKeyExA=kernel32.RegEnumKeyExA,@976") +#pragma comment(linker, "/export:RegEnumKeyExW=kernel32.RegEnumKeyExW,@977") +#pragma comment(linker, "/export:RegEnumValueA=kernel32.RegEnumValueA,@978") +#pragma comment(linker, "/export:RegEnumValueW=kernel32.RegEnumValueW,@979") +#pragma comment(linker, "/export:RegFlushKey=kernel32.RegFlushKey,@980") +#pragma comment(linker, "/export:RegGetKeySecurity=kernel32.RegGetKeySecurity,@981") +#pragma comment(linker, "/export:RegGetValueA=kernel32.RegGetValueA,@982") +#pragma comment(linker, "/export:RegGetValueW=kernel32.RegGetValueW,@983") +#pragma comment(linker, "/export:RegKrnGetGlobalState=kernel32.RegKrnGetGlobalState,@984") +#pragma comment(linker, "/export:RegKrnInitialize=kernel32.RegKrnInitialize,@985") +#pragma comment(linker, "/export:RegLoadKeyA=kernel32.RegLoadKeyA,@986") +#pragma comment(linker, "/export:RegLoadKeyW=kernel32.RegLoadKeyW,@987") +#pragma comment(linker, "/export:RegLoadMUIStringA=kernel32.RegLoadMUIStringA,@988") +#pragma comment(linker, "/export:RegLoadMUIStringW=kernel32.RegLoadMUIStringW,@989") +#pragma comment(linker, "/export:RegNotifyChangeKeyValue=kernel32.RegNotifyChangeKeyValue,@990") +#pragma comment(linker, "/export:RegOpenCurrentUser=kernel32.RegOpenCurrentUser,@991") +#pragma comment(linker, "/export:RegOpenKeyExA=kernel32.RegOpenKeyExA,@992") +#pragma comment(linker, "/export:RegOpenKeyExW=kernel32.RegOpenKeyExW,@993") +#pragma comment(linker, "/export:RegOpenUserClassesRoot=kernel32.RegOpenUserClassesRoot,@994") +#pragma comment(linker, "/export:RegQueryInfoKeyA=kernel32.RegQueryInfoKeyA,@995") +#pragma comment(linker, "/export:RegQueryInfoKeyW=kernel32.RegQueryInfoKeyW,@996") +#pragma comment(linker, "/export:RegQueryValueExA=kernel32.RegQueryValueExA,@997") +#pragma comment(linker, "/export:RegQueryValueExW=kernel32.RegQueryValueExW,@998") +#pragma comment(linker, "/export:RegRestoreKeyA=kernel32.RegRestoreKeyA,@999") +#pragma comment(linker, "/export:RegRestoreKeyW=kernel32.RegRestoreKeyW,@1000") +#pragma comment(linker, "/export:RegSaveKeyExA=kernel32.RegSaveKeyExA,@1001") +#pragma comment(linker, "/export:RegSaveKeyExW=kernel32.RegSaveKeyExW,@1002") +#pragma comment(linker, "/export:RegSetKeySecurity=kernel32.RegSetKeySecurity,@1003") +#pragma comment(linker, "/export:RegSetValueExA=kernel32.RegSetValueExA,@1004") +#pragma comment(linker, "/export:RegSetValueExW=kernel32.RegSetValueExW,@1005") +#pragma comment(linker, "/export:RegUnLoadKeyA=kernel32.RegUnLoadKeyA,@1006") +#pragma comment(linker, "/export:RegUnLoadKeyW=kernel32.RegUnLoadKeyW,@1007") +#pragma comment(linker, "/export:RegisterApplicationRecoveryCallback=kernel32.RegisterApplicationRecoveryCallback,@1008") +#pragma comment(linker, "/export:RegisterApplicationRestart=kernel32.RegisterApplicationRestart,@1009") +#pragma comment(linker, "/export:RegisterConsoleIME=kernel32.RegisterConsoleIME,@1010") +#pragma comment(linker, "/export:RegisterConsoleOS2=kernel32.RegisterConsoleOS2,@1011") +#pragma comment(linker, "/export:RegisterConsoleVDM=kernel32.RegisterConsoleVDM,@1012") +#pragma comment(linker, "/export:RegisterWaitForInputIdle=kernel32.RegisterWaitForInputIdle,@1013") +#pragma comment(linker, "/export:RegisterWaitForSingleObject=kernel32.RegisterWaitForSingleObject,@1014") +#pragma comment(linker, "/export:RegisterWaitForSingleObjectEx=kernel32.RegisterWaitForSingleObjectEx,@1015") +#pragma comment(linker, "/export:RegisterWowBaseHandlers=kernel32.RegisterWowBaseHandlers,@1016") +#pragma comment(linker, "/export:RegisterWowExec=kernel32.RegisterWowExec,@1017") +#pragma comment(linker, "/export:ReleaseActCtx=kernel32.ReleaseActCtx,@1018") +#pragma comment(linker, "/export:ReleaseMutex=kernel32.ReleaseMutex,@1019") +#pragma comment(linker, "/export:ReleaseMutexWhenCallbackReturns=kernel32.ReleaseMutexWhenCallbackReturns,@1020") +#pragma comment(linker, "/export:ReleaseSRWLockExclusive=kernel32.ReleaseSRWLockExclusive,@1021") +#pragma comment(linker, "/export:ReleaseSRWLockShared=kernel32.ReleaseSRWLockShared,@1022") +#pragma comment(linker, "/export:ReleaseSemaphore=kernel32.ReleaseSemaphore,@1023") +#pragma comment(linker, "/export:ReleaseSemaphoreWhenCallbackReturns=kernel32.ReleaseSemaphoreWhenCallbackReturns,@1024") +#pragma comment(linker, "/export:RemoveDirectoryA=kernel32.RemoveDirectoryA,@1025") +#pragma comment(linker, "/export:RemoveDirectoryTransactedA=kernel32.RemoveDirectoryTransactedA,@1026") +#pragma comment(linker, "/export:RemoveDirectoryTransactedW=kernel32.RemoveDirectoryTransactedW,@1027") +#pragma comment(linker, "/export:RemoveDirectoryW=kernel32.RemoveDirectoryW,@1028") +#pragma comment(linker, "/export:RemoveDllDirectory=kernel32.RemoveDllDirectory,@1029") +#pragma comment(linker, "/export:RemoveLocalAlternateComputerNameA=kernel32.RemoveLocalAlternateComputerNameA,@1030") +#pragma comment(linker, "/export:RemoveLocalAlternateComputerNameW=kernel32.RemoveLocalAlternateComputerNameW,@1031") +#pragma comment(linker, "/export:RemoveSecureMemoryCacheCallback=kernel32.RemoveSecureMemoryCacheCallback,@1032") +#pragma comment(linker, "/export:RemoveVectoredContinueHandler=kernel32.RemoveVectoredContinueHandler,@1033") +#pragma comment(linker, "/export:RemoveVectoredExceptionHandler=kernel32.RemoveVectoredExceptionHandler,@1034") +#pragma comment(linker, "/export:ReplaceFile=kernel32.ReplaceFile,@1035") +#pragma comment(linker, "/export:ReplaceFileA=kernel32.ReplaceFileA,@1036") +#pragma comment(linker, "/export:ReplaceFileW=kernel32.ReplaceFileW,@1037") +#pragma comment(linker, "/export:ReplacePartitionUnit=kernel32.ReplacePartitionUnit,@1038") +#pragma comment(linker, "/export:RequestDeviceWakeup=kernel32.RequestDeviceWakeup,@1039") +#pragma comment(linker, "/export:RequestWakeupLatency=kernel32.RequestWakeupLatency,@1040") +#pragma comment(linker, "/export:ResetEvent=kernel32.ResetEvent,@1041") +#pragma comment(linker, "/export:ResetWriteWatch=kernel32.ResetWriteWatch,@1042") +#pragma comment(linker, "/export:ResolveLocaleName=kernel32.ResolveLocaleName,@1043") +#pragma comment(linker, "/export:RestoreLastError=kernel32.RestoreLastError,@1044") +#pragma comment(linker, "/export:ResumeThread=kernel32.ResumeThread,@1045") +#pragma comment(linker, "/export:RtlCaptureContext=kernel32.RtlCaptureContext,@1046") +#pragma comment(linker, "/export:RtlCaptureStackBackTrace=kernel32.RtlCaptureStackBackTrace,@1047") +#pragma comment(linker, "/export:RtlFillMemory=kernel32.RtlFillMemory,@1048") +#pragma comment(linker, "/export:RtlMoveMemory=kernel32.RtlMoveMemory,@1049") +#pragma comment(linker, "/export:RtlUnwind=kernel32.RtlUnwind,@1050") +#pragma comment(linker, "/export:RtlZeroMemory=kernel32.RtlZeroMemory,@1051") +#pragma comment(linker, "/export:ScrollConsoleScreenBufferA=kernel32.ScrollConsoleScreenBufferA,@1052") +#pragma comment(linker, "/export:ScrollConsoleScreenBufferW=kernel32.ScrollConsoleScreenBufferW,@1053") +#pragma comment(linker, "/export:SearchPathA=kernel32.SearchPathA,@1054") +#pragma comment(linker, "/export:SearchPathW=kernel32.SearchPathW,@1055") +#pragma comment(linker, "/export:SetCalendarInfoA=kernel32.SetCalendarInfoA,@1056") +#pragma comment(linker, "/export:SetCalendarInfoW=kernel32.SetCalendarInfoW,@1057") +#pragma comment(linker, "/export:SetClientDynamicTimeZoneInformation=kernel32.SetClientDynamicTimeZoneInformation,@1058") +#pragma comment(linker, "/export:SetClientTimeZoneInformation=kernel32.SetClientTimeZoneInformation,@1059") +#pragma comment(linker, "/export:SetComPlusPackageInstallStatus=kernel32.SetComPlusPackageInstallStatus,@1060") +#pragma comment(linker, "/export:SetCommBreak=kernel32.SetCommBreak,@1061") +#pragma comment(linker, "/export:SetCommConfig=kernel32.SetCommConfig,@1062") +#pragma comment(linker, "/export:SetCommMask=kernel32.SetCommMask,@1063") +#pragma comment(linker, "/export:SetCommState=kernel32.SetCommState,@1064") +#pragma comment(linker, "/export:SetCommTimeouts=kernel32.SetCommTimeouts,@1065") +#pragma comment(linker, "/export:SetComputerNameA=kernel32.SetComputerNameA,@1066") +#pragma comment(linker, "/export:SetComputerNameExA=kernel32.SetComputerNameExA,@1067") +#pragma comment(linker, "/export:SetComputerNameExW=kernel32.SetComputerNameExW,@1068") +#pragma comment(linker, "/export:SetComputerNameW=kernel32.SetComputerNameW,@1069") +#pragma comment(linker, "/export:SetConsoleActiveScreenBuffer=kernel32.SetConsoleActiveScreenBuffer,@1070") +#pragma comment(linker, "/export:SetConsoleCP=kernel32.SetConsoleCP,@1071") +#pragma comment(linker, "/export:SetConsoleCtrlHandler=kernel32.SetConsoleCtrlHandler,@1072") +#pragma comment(linker, "/export:SetConsoleCursor=kernel32.SetConsoleCursor,@1073") +#pragma comment(linker, "/export:SetConsoleCursorInfo=kernel32.SetConsoleCursorInfo,@1074") +#pragma comment(linker, "/export:SetConsoleCursorMode=kernel32.SetConsoleCursorMode,@1075") +#pragma comment(linker, "/export:SetConsoleCursorPosition=kernel32.SetConsoleCursorPosition,@1076") +#pragma comment(linker, "/export:SetConsoleDisplayMode=kernel32.SetConsoleDisplayMode,@1077") +#pragma comment(linker, "/export:SetConsoleFont=kernel32.SetConsoleFont,@1078") +#pragma comment(linker, "/export:SetConsoleHardwareState=kernel32.SetConsoleHardwareState,@1079") +#pragma comment(linker, "/export:SetConsoleHistoryInfo=kernel32.SetConsoleHistoryInfo,@1080") +#pragma comment(linker, "/export:SetConsoleIcon=kernel32.SetConsoleIcon,@1081") +#pragma comment(linker, "/export:SetConsoleInputExeNameA=kernel32.SetConsoleInputExeNameA,@1082") +#pragma comment(linker, "/export:SetConsoleInputExeNameW=kernel32.SetConsoleInputExeNameW,@1083") +#pragma comment(linker, "/export:SetConsoleKeyShortcuts=kernel32.SetConsoleKeyShortcuts,@1084") +#pragma comment(linker, "/export:SetConsoleLocalEUDC=kernel32.SetConsoleLocalEUDC,@1085") +#pragma comment(linker, "/export:SetConsoleMaximumWindowSize=kernel32.SetConsoleMaximumWindowSize,@1086") +#pragma comment(linker, "/export:SetConsoleMenuClose=kernel32.SetConsoleMenuClose,@1087") +#pragma comment(linker, "/export:SetConsoleMode=kernel32.SetConsoleMode,@1088") +#pragma comment(linker, "/export:SetConsoleNlsMode=kernel32.SetConsoleNlsMode,@1089") +#pragma comment(linker, "/export:SetConsoleNumberOfCommandsA=kernel32.SetConsoleNumberOfCommandsA,@1090") +#pragma comment(linker, "/export:SetConsoleNumberOfCommandsW=kernel32.SetConsoleNumberOfCommandsW,@1091") +#pragma comment(linker, "/export:SetConsoleOS2OemFormat=kernel32.SetConsoleOS2OemFormat,@1092") +#pragma comment(linker, "/export:SetConsoleOutputCP=kernel32.SetConsoleOutputCP,@1093") +#pragma comment(linker, "/export:SetConsolePalette=kernel32.SetConsolePalette,@1094") +#pragma comment(linker, "/export:SetConsoleScreenBufferInfoEx=kernel32.SetConsoleScreenBufferInfoEx,@1095") +#pragma comment(linker, "/export:SetConsoleScreenBufferSize=kernel32.SetConsoleScreenBufferSize,@1096") +#pragma comment(linker, "/export:SetConsoleTextAttribute=kernel32.SetConsoleTextAttribute,@1097") +#pragma comment(linker, "/export:SetConsoleTitleA=kernel32.SetConsoleTitleA,@1098") +#pragma comment(linker, "/export:SetConsoleTitleW=kernel32.SetConsoleTitleW,@1099") +#pragma comment(linker, "/export:SetConsoleWindowInfo=kernel32.SetConsoleWindowInfo,@1100") +#pragma comment(linker, "/export:SetCriticalSectionSpinCount=kernel32.SetCriticalSectionSpinCount,@1101") +#pragma comment(linker, "/export:SetCurrentConsoleFontEx=kernel32.SetCurrentConsoleFontEx,@1102") +#pragma comment(linker, "/export:SetCurrentDirectoryA=kernel32.SetCurrentDirectoryA,@1103") +#pragma comment(linker, "/export:SetCurrentDirectoryW=kernel32.SetCurrentDirectoryW,@1104") +#pragma comment(linker, "/export:SetDefaultCommConfigA=kernel32.SetDefaultCommConfigA,@1105") +#pragma comment(linker, "/export:SetDefaultCommConfigW=kernel32.SetDefaultCommConfigW,@1106") +#pragma comment(linker, "/export:SetDefaultDllDirectories=kernel32.SetDefaultDllDirectories,@1107") +#pragma comment(linker, "/export:SetDllDirectoryA=kernel32.SetDllDirectoryA,@1108") +#pragma comment(linker, "/export:SetDllDirectoryW=kernel32.SetDllDirectoryW,@1109") +#pragma comment(linker, "/export:SetDynamicTimeZoneInformation=kernel32.SetDynamicTimeZoneInformation,@1110") +#pragma comment(linker, "/export:SetEndOfFile=kernel32.SetEndOfFile,@1111") +#pragma comment(linker, "/export:SetEnvironmentStringsA=kernel32.SetEnvironmentStringsA,@1112") +#pragma comment(linker, "/export:SetEnvironmentStringsW=kernel32.SetEnvironmentStringsW,@1113") +#pragma comment(linker, "/export:SetEnvironmentVariableA=kernel32.SetEnvironmentVariableA,@1114") +#pragma comment(linker, "/export:SetEnvironmentVariableW=kernel32.SetEnvironmentVariableW,@1115") +#pragma comment(linker, "/export:SetErrorMode=kernel32.SetErrorMode,@1116") +#pragma comment(linker, "/export:SetEvent=kernel32.SetEvent,@1117") +#pragma comment(linker, "/export:SetEventWhenCallbackReturns=kernel32.SetEventWhenCallbackReturns,@1118") +#pragma comment(linker, "/export:SetFileApisToANSI=kernel32.SetFileApisToANSI,@1119") +#pragma comment(linker, "/export:SetFileApisToOEM=kernel32.SetFileApisToOEM,@1120") +#pragma comment(linker, "/export:SetFileAttributesA=kernel32.SetFileAttributesA,@1121") +#pragma comment(linker, "/export:SetFileAttributesTransactedA=kernel32.SetFileAttributesTransactedA,@1122") +#pragma comment(linker, "/export:SetFileAttributesTransactedW=kernel32.SetFileAttributesTransactedW,@1123") +#pragma comment(linker, "/export:SetFileAttributesW=kernel32.SetFileAttributesW,@1124") +#pragma comment(linker, "/export:SetFileBandwidthReservation=kernel32.SetFileBandwidthReservation,@1125") +#pragma comment(linker, "/export:SetFileCompletionNotificationModes=kernel32.SetFileCompletionNotificationModes,@1126") +#pragma comment(linker, "/export:SetFileInformationByHandle=kernel32.SetFileInformationByHandle,@1127") +#pragma comment(linker, "/export:SetFileIoOverlappedRange=kernel32.SetFileIoOverlappedRange,@1128") +#pragma comment(linker, "/export:SetFilePointer=kernel32.SetFilePointer,@1129") +#pragma comment(linker, "/export:SetFilePointerEx=kernel32.SetFilePointerEx,@1130") +#pragma comment(linker, "/export:SetFileShortNameA=kernel32.SetFileShortNameA,@1131") +#pragma comment(linker, "/export:SetFileShortNameW=kernel32.SetFileShortNameW,@1132") +#pragma comment(linker, "/export:SetFileTime=kernel32.SetFileTime,@1133") +#pragma comment(linker, "/export:SetFileValidData=kernel32.SetFileValidData,@1134") +#pragma comment(linker, "/export:SetFirmwareEnvironmentVariableA=kernel32.SetFirmwareEnvironmentVariableA,@1135") +#pragma comment(linker, "/export:SetFirmwareEnvironmentVariableW=kernel32.SetFirmwareEnvironmentVariableW,@1136") +#pragma comment(linker, "/export:SetHandleContext=kernel32.SetHandleContext,@1137") +#pragma comment(linker, "/export:SetHandleCount=kernel32.SetHandleCount,@1138") +#pragma comment(linker, "/export:SetHandleInformation=kernel32.SetHandleInformation,@1139") +#pragma comment(linker, "/export:SetInformationJobObject=kernel32.SetInformationJobObject,@1140") +#pragma comment(linker, "/export:SetLastConsoleEventActive=kernel32.SetLastConsoleEventActive,@1141") +#pragma comment(linker, "/export:SetLastError=kernel32.SetLastError,@1142") +#pragma comment(linker, "/export:SetLocalPrimaryComputerNameA=kernel32.SetLocalPrimaryComputerNameA,@1143") +#pragma comment(linker, "/export:SetLocalPrimaryComputerNameW=kernel32.SetLocalPrimaryComputerNameW,@1144") +#pragma comment(linker, "/export:SetLocalTime=kernel32.SetLocalTime,@1145") +#pragma comment(linker, "/export:SetLocaleInfoA=kernel32.SetLocaleInfoA,@1146") +#pragma comment(linker, "/export:SetLocaleInfoW=kernel32.SetLocaleInfoW,@1147") +#pragma comment(linker, "/export:SetMailslotInfo=kernel32.SetMailslotInfo,@1148") +#pragma comment(linker, "/export:SetMessageWaitingIndicator=kernel32.SetMessageWaitingIndicator,@1149") +#pragma comment(linker, "/export:SetNamedPipeAttribute=kernel32.SetNamedPipeAttribute,@1150") +#pragma comment(linker, "/export:SetNamedPipeHandleState=kernel32.SetNamedPipeHandleState,@1151") +#pragma comment(linker, "/export:SetPriorityClass=kernel32.SetPriorityClass,@1152") +#pragma comment(linker, "/export:SetProcessAffinityMask=kernel32.SetProcessAffinityMask,@1153") +#pragma comment(linker, "/export:SetProcessAffinityUpdateMode=kernel32.SetProcessAffinityUpdateMode,@1154") +#pragma comment(linker, "/export:SetProcessDEPPolicy=kernel32.SetProcessDEPPolicy,@1155") +#pragma comment(linker, "/export:SetProcessPreferredUILanguages=kernel32.SetProcessPreferredUILanguages,@1156") +#pragma comment(linker, "/export:SetProcessPriorityBoost=kernel32.SetProcessPriorityBoost,@1157") +#pragma comment(linker, "/export:SetProcessShutdownParameters=kernel32.SetProcessShutdownParameters,@1158") +#pragma comment(linker, "/export:SetProcessUserModeExceptionPolicy=kernel32.SetProcessUserModeExceptionPolicy,@1159") +#pragma comment(linker, "/export:SetProcessWorkingSetSize=kernel32.SetProcessWorkingSetSize,@1160") +#pragma comment(linker, "/export:SetProcessWorkingSetSizeEx=kernel32.SetProcessWorkingSetSizeEx,@1161") +#pragma comment(linker, "/export:SetSearchPathMode=kernel32.SetSearchPathMode,@1162") +#pragma comment(linker, "/export:SetStdHandle=kernel32.SetStdHandle,@1163") +#pragma comment(linker, "/export:SetStdHandleEx=kernel32.SetStdHandleEx,@1164") +#pragma comment(linker, "/export:SetSystemFileCacheSize=kernel32.SetSystemFileCacheSize,@1165") +#pragma comment(linker, "/export:SetSystemPowerState=kernel32.SetSystemPowerState,@1166") +#pragma comment(linker, "/export:SetSystemTime=kernel32.SetSystemTime,@1167") +#pragma comment(linker, "/export:SetSystemTimeAdjustment=kernel32.SetSystemTimeAdjustment,@1168") +#pragma comment(linker, "/export:SetTapeParameters=kernel32.SetTapeParameters,@1169") +#pragma comment(linker, "/export:SetTapePosition=kernel32.SetTapePosition,@1170") +#pragma comment(linker, "/export:SetTermsrvAppInstallMode=kernel32.SetTermsrvAppInstallMode,@1171") +#pragma comment(linker, "/export:SetThreadAffinityMask=kernel32.SetThreadAffinityMask,@1172") +#pragma comment(linker, "/export:SetThreadContext=kernel32.SetThreadContext,@1173") +#pragma comment(linker, "/export:SetThreadErrorMode=kernel32.SetThreadErrorMode,@1174") +#pragma comment(linker, "/export:SetThreadExecutionState=kernel32.SetThreadExecutionState,@1175") +#pragma comment(linker, "/export:SetThreadGroupAffinity=kernel32.SetThreadGroupAffinity,@1176") +#pragma comment(linker, "/export:SetThreadIdealProcessor=kernel32.SetThreadIdealProcessor,@1177") +#pragma comment(linker, "/export:SetThreadIdealProcessorEx=kernel32.SetThreadIdealProcessorEx,@1178") +#pragma comment(linker, "/export:SetThreadLocale=kernel32.SetThreadLocale,@1179") +#pragma comment(linker, "/export:SetThreadPreferredUILanguages=kernel32.SetThreadPreferredUILanguages,@1180") +#pragma comment(linker, "/export:SetThreadPriority=kernel32.SetThreadPriority,@1181") +#pragma comment(linker, "/export:SetThreadPriorityBoost=kernel32.SetThreadPriorityBoost,@1182") +#pragma comment(linker, "/export:SetThreadStackGuarantee=kernel32.SetThreadStackGuarantee,@1183") +#pragma comment(linker, "/export:SetThreadToken=kernel32.SetThreadToken,@1184") +#pragma comment(linker, "/export:SetThreadUILanguage=kernel32.SetThreadUILanguage,@1185") +#pragma comment(linker, "/export:SetThreadpoolStackInformation=kernel32.SetThreadpoolStackInformation,@1186") +#pragma comment(linker, "/export:SetThreadpoolThreadMaximum=kernel32.SetThreadpoolThreadMaximum,@1187") +#pragma comment(linker, "/export:SetThreadpoolThreadMinimum=kernel32.SetThreadpoolThreadMinimum,@1188") +#pragma comment(linker, "/export:SetThreadpoolTimer=kernel32.SetThreadpoolTimer,@1189") +#pragma comment(linker, "/export:SetThreadpoolWait=kernel32.SetThreadpoolWait,@1190") +#pragma comment(linker, "/export:SetTimeZoneInformation=kernel32.SetTimeZoneInformation,@1191") +#pragma comment(linker, "/export:SetTimerQueueTimer=kernel32.SetTimerQueueTimer,@1192") +#pragma comment(linker, "/export:SetUnhandledExceptionFilter=kernel32.SetUnhandledExceptionFilter,@1193") +#pragma comment(linker, "/export:SetUserGeoID=kernel32.SetUserGeoID,@1194") +#pragma comment(linker, "/export:SetVDMCurrentDirectories=kernel32.SetVDMCurrentDirectories,@1195") +#pragma comment(linker, "/export:SetVolumeLabelA=kernel32.SetVolumeLabelA,@1196") +#pragma comment(linker, "/export:SetVolumeLabelW=kernel32.SetVolumeLabelW,@1197") +#pragma comment(linker, "/export:SetVolumeMountPointA=kernel32.SetVolumeMountPointA,@1198") +#pragma comment(linker, "/export:SetVolumeMountPointW=kernel32.SetVolumeMountPointW,@1199") +#pragma comment(linker, "/export:SetWaitableTimer=kernel32.SetWaitableTimer,@1200") +#pragma comment(linker, "/export:SetWaitableTimerEx=kernel32.SetWaitableTimerEx,@1201") +#pragma comment(linker, "/export:SetXStateFeaturesMask=kernel32.SetXStateFeaturesMask,@1202") +#pragma comment(linker, "/export:SetupComm=kernel32.SetupComm,@1203") +#pragma comment(linker, "/export:ShowConsoleCursor=kernel32.ShowConsoleCursor,@1204") +#pragma comment(linker, "/export:SignalObjectAndWait=kernel32.SignalObjectAndWait,@1205") +#pragma comment(linker, "/export:SizeofResource=kernel32.SizeofResource,@1206") +#pragma comment(linker, "/export:Sleep=kernel32.Sleep,@1207") +#pragma comment(linker, "/export:SleepConditionVariableCS=kernel32.SleepConditionVariableCS,@1208") +#pragma comment(linker, "/export:SleepConditionVariableSRW=kernel32.SleepConditionVariableSRW,@1209") +#pragma comment(linker, "/export:SleepEx=kernel32.SleepEx,@1210") +#pragma comment(linker, "/export:SortCloseHandle=kernel32.SortCloseHandle,@1211") +#pragma comment(linker, "/export:SortGetHandle=kernel32.SortGetHandle,@1212") +#pragma comment(linker, "/export:StartThreadpoolIo=kernel32.StartThreadpoolIo,@1213") +#pragma comment(linker, "/export:SubmitThreadpoolWork=kernel32.SubmitThreadpoolWork,@1214") +#pragma comment(linker, "/export:SuspendThread=kernel32.SuspendThread,@1215") +#pragma comment(linker, "/export:SwitchToFiber=kernel32.SwitchToFiber,@1216") +#pragma comment(linker, "/export:SwitchToThread=kernel32.SwitchToThread,@1217") +#pragma comment(linker, "/export:SystemTimeToFileTime=kernel32.SystemTimeToFileTime,@1218") +#pragma comment(linker, "/export:SystemTimeToTzSpecificLocalTime=kernel32.SystemTimeToTzSpecificLocalTime,@1219") +#pragma comment(linker, "/export:SystemTimeToTzSpecificLocalTimeEx=kernel32.SystemTimeToTzSpecificLocalTimeEx,@1220") +#pragma comment(linker, "/export:TerminateJobObject=kernel32.TerminateJobObject,@1221") +#pragma comment(linker, "/export:TerminateProcess=kernel32.TerminateProcess,@1222") +#pragma comment(linker, "/export:TerminateThread=kernel32.TerminateThread,@1223") +#pragma comment(linker, "/export:TermsrvAppInstallMode=kernel32.TermsrvAppInstallMode,@1224") +#pragma comment(linker, "/export:Thread32First=kernel32.Thread32First,@1225") +#pragma comment(linker, "/export:Thread32Next=kernel32.Thread32Next,@1226") +#pragma comment(linker, "/export:TlsAlloc=kernel32.TlsAlloc,@1227") +#pragma comment(linker, "/export:TlsFree=kernel32.TlsFree,@1228") +#pragma comment(linker, "/export:TlsGetValue=kernel32.TlsGetValue,@1229") +#pragma comment(linker, "/export:TlsSetValue=kernel32.TlsSetValue,@1230") +#pragma comment(linker, "/export:Toolhelp32ReadProcessMemory=kernel32.Toolhelp32ReadProcessMemory,@1231") +#pragma comment(linker, "/export:TransactNamedPipe=kernel32.TransactNamedPipe,@1232") +#pragma comment(linker, "/export:TransmitCommChar=kernel32.TransmitCommChar,@1233") +#pragma comment(linker, "/export:TryAcquireSRWLockExclusive=kernel32.TryAcquireSRWLockExclusive,@1234") +#pragma comment(linker, "/export:TryAcquireSRWLockShared=kernel32.TryAcquireSRWLockShared,@1235") +#pragma comment(linker, "/export:TryEnterCriticalSection=kernel32.TryEnterCriticalSection,@1236") +#pragma comment(linker, "/export:TrySubmitThreadpoolCallback=kernel32.TrySubmitThreadpoolCallback,@1237") +#pragma comment(linker, "/export:TzSpecificLocalTimeToSystemTime=kernel32.TzSpecificLocalTimeToSystemTime,@1238") +#pragma comment(linker, "/export:TzSpecificLocalTimeToSystemTimeEx=kernel32.TzSpecificLocalTimeToSystemTimeEx,@1239") +#pragma comment(linker, "/export:UTRegister=kernel32.UTRegister,@1240") +#pragma comment(linker, "/export:UTUnRegister=kernel32.UTUnRegister,@1241") +#pragma comment(linker, "/export:UnhandledExceptionFilter=kernel32.UnhandledExceptionFilter,@1242") +#pragma comment(linker, "/export:UnlockFile=kernel32.UnlockFile,@1243") +#pragma comment(linker, "/export:UnlockFileEx=kernel32.UnlockFileEx,@1244") +#pragma comment(linker, "/export:UnmapViewOfFile=kernel32.UnmapViewOfFile,@1245") +#pragma comment(linker, "/export:UnregisterApplicationRecoveryCallback=kernel32.UnregisterApplicationRecoveryCallback,@1246") +#pragma comment(linker, "/export:UnregisterApplicationRestart=kernel32.UnregisterApplicationRestart,@1247") +#pragma comment(linker, "/export:UnregisterConsoleIME=kernel32.UnregisterConsoleIME,@1248") +#pragma comment(linker, "/export:UnregisterWait=kernel32.UnregisterWait,@1249") +#pragma comment(linker, "/export:UnregisterWaitEx=kernel32.UnregisterWaitEx,@1250") +#pragma comment(linker, "/export:UpdateCalendarDayOfWeek=kernel32.UpdateCalendarDayOfWeek,@1251") +#pragma comment(linker, "/export:UpdateProcThreadAttribute=kernel32.UpdateProcThreadAttribute,@1252") +#pragma comment(linker, "/export:UpdateResourceA=kernel32.UpdateResourceA,@1253") +#pragma comment(linker, "/export:UpdateResourceW=kernel32.UpdateResourceW,@1254") +#pragma comment(linker, "/export:VDMConsoleOperation=kernel32.VDMConsoleOperation,@1255") +#pragma comment(linker, "/export:VDMOperationStarted=kernel32.VDMOperationStarted,@1256") +#pragma comment(linker, "/export:VerLanguageNameA=kernel32.VerLanguageNameA,@1257") +#pragma comment(linker, "/export:VerLanguageNameW=kernel32.VerLanguageNameW,@1258") +#pragma comment(linker, "/export:VerSetConditionMask=kernel32.VerSetConditionMask,@1259") +#pragma comment(linker, "/export:VerifyConsoleIoHandle=kernel32.VerifyConsoleIoHandle,@1260") +#pragma comment(linker, "/export:VerifyScripts=kernel32.VerifyScripts,@1261") +#pragma comment(linker, "/export:VerifyVersionInfoA=kernel32.VerifyVersionInfoA,@1262") +#pragma comment(linker, "/export:VerifyVersionInfoW=kernel32.VerifyVersionInfoW,@1263") +#pragma comment(linker, "/export:VirtualAlloc=kernel32.VirtualAlloc,@1264") +#pragma comment(linker, "/export:VirtualAllocEx=kernel32.VirtualAllocEx,@1265") +#pragma comment(linker, "/export:VirtualAllocExNuma=kernel32.VirtualAllocExNuma,@1266") +#pragma comment(linker, "/export:VirtualFree=kernel32.VirtualFree,@1267") +#pragma comment(linker, "/export:VirtualFreeEx=kernel32.VirtualFreeEx,@1268") +#pragma comment(linker, "/export:VirtualLock=kernel32.VirtualLock,@1269") +#pragma comment(linker, "/export:VirtualProtect=kernel32.VirtualProtect,@1270") +#pragma comment(linker, "/export:VirtualProtectEx=kernel32.VirtualProtectEx,@1271") +#pragma comment(linker, "/export:VirtualQuery=kernel32.VirtualQuery,@1272") +#pragma comment(linker, "/export:VirtualQueryEx=kernel32.VirtualQueryEx,@1273") +#pragma comment(linker, "/export:VirtualUnlock=kernel32.VirtualUnlock,@1274") +#pragma comment(linker, "/export:WTSGetActiveConsoleSessionId=kernel32.WTSGetActiveConsoleSessionId,@1275") +#pragma comment(linker, "/export:WaitCommEvent=kernel32.WaitCommEvent,@1276") +#pragma comment(linker, "/export:WaitForDebugEvent=kernel32.WaitForDebugEvent,@1277") +#pragma comment(linker, "/export:WaitForMultipleObjects=kernel32.WaitForMultipleObjects,@1278") +#pragma comment(linker, "/export:WaitForMultipleObjectsEx=kernel32.WaitForMultipleObjectsEx,@1279") +#pragma comment(linker, "/export:WaitForSingleObject=kernel32.WaitForSingleObject,@1280") +#pragma comment(linker, "/export:WaitForSingleObjectEx=kernel32.WaitForSingleObjectEx,@1281") +#pragma comment(linker, "/export:WaitForThreadpoolIoCallbacks=kernel32.WaitForThreadpoolIoCallbacks,@1282") +#pragma comment(linker, "/export:WaitForThreadpoolTimerCallbacks=kernel32.WaitForThreadpoolTimerCallbacks,@1283") +#pragma comment(linker, "/export:WaitForThreadpoolWaitCallbacks=kernel32.WaitForThreadpoolWaitCallbacks,@1284") +#pragma comment(linker, "/export:WaitForThreadpoolWorkCallbacks=kernel32.WaitForThreadpoolWorkCallbacks,@1285") +#pragma comment(linker, "/export:WaitNamedPipeA=kernel32.WaitNamedPipeA,@1286") +#pragma comment(linker, "/export:WaitNamedPipeW=kernel32.WaitNamedPipeW,@1287") +#pragma comment(linker, "/export:WakeAllConditionVariable=kernel32.WakeAllConditionVariable,@1288") +#pragma comment(linker, "/export:WakeConditionVariable=kernel32.WakeConditionVariable,@1289") +#pragma comment(linker, "/export:WerGetFlags=kernel32.WerGetFlags,@1290") +#pragma comment(linker, "/export:WerRegisterFile=kernel32.WerRegisterFile,@1291") +#pragma comment(linker, "/export:WerRegisterMemoryBlock=kernel32.WerRegisterMemoryBlock,@1292") +#pragma comment(linker, "/export:WerRegisterRuntimeExceptionModule=kernel32.WerRegisterRuntimeExceptionModule,@1293") +#pragma comment(linker, "/export:WerSetFlags=kernel32.WerSetFlags,@1294") +#pragma comment(linker, "/export:WerUnregisterFile=kernel32.WerUnregisterFile,@1295") +#pragma comment(linker, "/export:WerUnregisterMemoryBlock=kernel32.WerUnregisterMemoryBlock,@1296") +#pragma comment(linker, "/export:WerUnregisterRuntimeExceptionModule=kernel32.WerUnregisterRuntimeExceptionModule,@1297") +#pragma comment(linker, "/export:WerpCleanupMessageMapping=kernel32.WerpCleanupMessageMapping,@1298") +#pragma comment(linker, "/export:WerpInitiateRemoteRecovery=kernel32.WerpInitiateRemoteRecovery,@1299") +#pragma comment(linker, "/export:WerpNotifyLoadStringResource=kernel32.WerpNotifyLoadStringResource,@1300") +#pragma comment(linker, "/export:WerpNotifyLoadStringResourceEx=kernel32.WerpNotifyLoadStringResourceEx,@1301") +#pragma comment(linker, "/export:WerpNotifyUseStringResource=kernel32.WerpNotifyUseStringResource,@1302") +#pragma comment(linker, "/export:WerpStringLookup=kernel32.WerpStringLookup,@1303") +#pragma comment(linker, "/export:WideCharToMultiByte=kernel32.WideCharToMultiByte,@1304") +#pragma comment(linker, "/export:WinExec=kernel32.WinExec,@1305") +#pragma comment(linker, "/export:Wow64DisableWow64FsRedirection=kernel32.Wow64DisableWow64FsRedirection,@1306") +#pragma comment(linker, "/export:Wow64EnableWow64FsRedirection=kernel32.Wow64EnableWow64FsRedirection,@1307") +#pragma comment(linker, "/export:Wow64GetThreadContext=kernel32.Wow64GetThreadContext,@1308") +#pragma comment(linker, "/export:Wow64GetThreadSelectorEntry=kernel32.Wow64GetThreadSelectorEntry,@1309") +#pragma comment(linker, "/export:Wow64RevertWow64FsRedirection=kernel32.Wow64RevertWow64FsRedirection,@1310") +#pragma comment(linker, "/export:Wow64SetThreadContext=kernel32.Wow64SetThreadContext,@1311") +#pragma comment(linker, "/export:Wow64SuspendThread=kernel32.Wow64SuspendThread,@1312") +#pragma comment(linker, "/export:WriteConsoleA=kernel32.WriteConsoleA,@1313") +#pragma comment(linker, "/export:WriteConsoleInputA=kernel32.WriteConsoleInputA,@1314") +#pragma comment(linker, "/export:WriteConsoleInputVDMA=kernel32.WriteConsoleInputVDMA,@1315") +#pragma comment(linker, "/export:WriteConsoleInputVDMW=kernel32.WriteConsoleInputVDMW,@1316") +#pragma comment(linker, "/export:WriteConsoleInputW=kernel32.WriteConsoleInputW,@1317") +#pragma comment(linker, "/export:WriteConsoleOutputA=kernel32.WriteConsoleOutputA,@1318") +#pragma comment(linker, "/export:WriteConsoleOutputAttribute=kernel32.WriteConsoleOutputAttribute,@1319") +#pragma comment(linker, "/export:WriteConsoleOutputCharacterA=kernel32.WriteConsoleOutputCharacterA,@1320") +#pragma comment(linker, "/export:WriteConsoleOutputCharacterW=kernel32.WriteConsoleOutputCharacterW,@1321") +#pragma comment(linker, "/export:WriteConsoleOutputW=kernel32.WriteConsoleOutputW,@1322") +#pragma comment(linker, "/export:WriteConsoleW=kernel32.WriteConsoleW,@1323") +#pragma comment(linker, "/export:WriteFile=kernel32.WriteFile,@1324") +#pragma comment(linker, "/export:WriteFileEx=kernel32.WriteFileEx,@1325") +#pragma comment(linker, "/export:WriteFileGather=kernel32.WriteFileGather,@1326") +#pragma comment(linker, "/export:WritePrivateProfileSectionA=kernel32.WritePrivateProfileSectionA,@1327") +#pragma comment(linker, "/export:WritePrivateProfileSectionW=kernel32.WritePrivateProfileSectionW,@1328") +#pragma comment(linker, "/export:WritePrivateProfileStringA=kernel32.WritePrivateProfileStringA,@1329") +#pragma comment(linker, "/export:WritePrivateProfileStringW=kernel32.WritePrivateProfileStringW,@1330") +#pragma comment(linker, "/export:WritePrivateProfileStructA=kernel32.WritePrivateProfileStructA,@1331") +#pragma comment(linker, "/export:WritePrivateProfileStructW=kernel32.WritePrivateProfileStructW,@1332") +#pragma comment(linker, "/export:WriteProcessMemory=kernel32.WriteProcessMemory,@1333") +#pragma comment(linker, "/export:WriteProfileSectionA=kernel32.WriteProfileSectionA,@1334") +#pragma comment(linker, "/export:WriteProfileSectionW=kernel32.WriteProfileSectionW,@1335") +#pragma comment(linker, "/export:WriteProfileStringA=kernel32.WriteProfileStringA,@1336") +#pragma comment(linker, "/export:WriteProfileStringW=kernel32.WriteProfileStringW,@1337") +#pragma comment(linker, "/export:WriteTapemark=kernel32.WriteTapemark,@1338") +#pragma comment(linker, "/export:ZombifyActCtx=kernel32.ZombifyActCtx,@1339") +#pragma comment(linker, "/export:_hread=kernel32._hread,@1340") +#pragma comment(linker, "/export:_hwrite=kernel32._hwrite,@1341") +#pragma comment(linker, "/export:_lclose=kernel32._lclose,@1342") +#pragma comment(linker, "/export:_lcreat=kernel32._lcreat,@1343") +#pragma comment(linker, "/export:_llseek=kernel32._llseek,@1344") +#pragma comment(linker, "/export:_lopen=kernel32._lopen,@1345") +#pragma comment(linker, "/export:_lread=kernel32._lread,@1346") +#pragma comment(linker, "/export:_lwrite=kernel32._lwrite,@1347") +#pragma comment(linker, "/export:lstrcat=kernel32.lstrcat,@1348") +#pragma comment(linker, "/export:lstrcatA=kernel32.lstrcatA,@1349") +#pragma comment(linker, "/export:lstrcatW=kernel32.lstrcatW,@1350") +#pragma comment(linker, "/export:lstrcmp=kernel32.lstrcmp,@1351") +#pragma comment(linker, "/export:lstrcmpA=kernel32.lstrcmpA,@1352") +#pragma comment(linker, "/export:lstrcmpW=kernel32.lstrcmpW,@1353") +#pragma comment(linker, "/export:lstrcmpi=kernel32.lstrcmpi,@1354") +#pragma comment(linker, "/export:lstrcmpiA=kernel32.lstrcmpiA,@1355") +#pragma comment(linker, "/export:lstrcmpiW=kernel32.lstrcmpiW,@1356") +#pragma comment(linker, "/export:lstrcpy=kernel32.lstrcpy,@1357") +#pragma comment(linker, "/export:lstrcpyA=kernel32.lstrcpyA,@1358") +#pragma comment(linker, "/export:lstrcpyW=kernel32.lstrcpyW,@1359") +#pragma comment(linker, "/export:lstrcpyn=kernel32.lstrcpyn,@1360") +#pragma comment(linker, "/export:lstrcpynA=kernel32.lstrcpynA,@1361") +#pragma comment(linker, "/export:lstrcpynW=kernel32.lstrcpynW,@1362") +#pragma comment(linker, "/export:lstrlen=kernel32.lstrlen,@1363") +#pragma comment(linker, "/export:lstrlenA=kernel32.lstrlenA,@1364") +#pragma comment(linker, "/export:lstrlenW=kernel32.lstrlenW,@1365") +#endif \ No newline at end of file diff --git a/kernel33/k32defs.h b/kernel33/k32defs.h new file mode 100644 index 0000000..bb51997 --- /dev/null +++ b/kernel33/k32defs.h @@ -0,0 +1,221 @@ +#pragma once +#include +#include + +#define APPMODEL_ERROR_NO_PACKAGE 15700L + +typedef enum _PROCESS_INFORMATION_CLASS { + ProcessMemoryPriority, + ProcessMemoryExhaustionInfo, + ProcessAppMemoryInfo, + ProcessInPrivateInfo, + ProcessPowerThrottling, + ProcessReservedValue1, + ProcessTelemetryCoverageInfo, + ProcessProtectionLevelInfo, + ProcessLeapSecondInfo, + ProcessMachineTypeInfo, + ProcessInformationClassMax +} PROCESS_INFORMATION_CLASS; + +typedef enum _THREAD_INFORMATION_CLASS { + ThreadMemoryPriority, + ThreadAbsoluteCpuPriority, + ThreadDynamicCodePolicy, + ThreadPowerThrottling, + ThreadInformationClassMax +} THREAD_INFORMATION_CLASS; + +typedef enum _PROCESS_MITIGATION_POLICY { + ProcessDEPPolicy, + ProcessASLRPolicy, + ProcessDynamicCodePolicy, + ProcessStrictHandleCheckPolicy, + ProcessSystemCallDisablePolicy, + ProcessMitigationOptionsMask, + ProcessExtensionPointDisablePolicy, + ProcessControlFlowGuardPolicy, + ProcessSignaturePolicy, + ProcessFontDisablePolicy, + ProcessImageLoadPolicy, + ProcessSystemCallFilterPolicy, + ProcessPayloadRestrictionPolicy, + ProcessChildProcessPolicy, + ProcessSideChannelIsolationPolicy, + ProcessUserShadowStackPolicy, + ProcessRedirectionTrustPolicy, + MaxProcessMitigationPolicy +} PROCESS_MITIGATION_POLICY, *PPROCESS_MITIGATION_POLICY; + +typedef struct _PROCESS_MITIGATION_DEP_POLICY { + union { + DWORD Flags; + + struct { + DWORD Enable : 1; + DWORD DisableAtlThunkEmulation : 1; + DWORD ReservedFlags : 30; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + + BOOLEAN Permanent; +} PROCESS_MITIGATION_DEP_POLICY, *PPROCESS_MITIGATION_DEP_POLICY; + +typedef struct _PROCESS_MITIGATION_ASLR_POLICY { + union { + DWORD Flags; + + struct { + DWORD EnableBottomUpRandomization : 1; + DWORD EnableForceRelocateImages : 1; + DWORD EnableHighEntropy : 1; + DWORD DisallowStrippedImages : 1; + DWORD ReservedFlags : 28; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_ASLR_POLICY, *PPROCESS_MITIGATION_ASLR_POLICY; + +typedef struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY { + union { + DWORD Flags; + + struct { + DWORD ProhibitDynamicCode : 1; + DWORD AllowThreadOptOut : 1; + DWORD AllowRemoteDowngrade : 1; + DWORD AuditProhibitDynamicCode : 1; + DWORD ReservedFlags : 28; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, *PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY; + +typedef struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY { + union { + DWORD Flags; + + struct { + DWORD RaiseExceptionOnInvalidHandleReference : 1; + DWORD HandleExceptionsPermanentlyEnabled : 1; + DWORD ReservedFlags : 30; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, *PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; + +typedef struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { + union { + DWORD Flags; + + struct { + DWORD DisallowWin32kSystemCalls : 1; + DWORD AuditDisallowWin32kSystemCalls : 1; + DWORD ReservedFlags : 30; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, *PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; + +typedef struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { + union { + DWORD Flags; + + struct { + DWORD DisableExtensionPoints : 1; + DWORD ReservedFlags : 31; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, *PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; + +typedef struct _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY { + union { + DWORD Flags; + + struct { + DWORD EnableControlFlowGuard : 1; + DWORD EnableExportSuppression : 1; + DWORD StrictMode : 1; + DWORD EnableXfg : 1; + DWORD EnableXfgAuditMode : 1; + DWORD ReservedFlags : 27; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, *PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY; + +typedef struct _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY { + union { + DWORD Flags; + + struct { + DWORD MicrosoftSignedOnly : 1; + DWORD StoreSignedOnly : 1; + DWORD MitigationOptIn : 1; + DWORD AuditMicrosoftSignedOnly : 1; + DWORD AuditStoreSignedOnly : 1; + DWORD ReservedFlags : 27; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, *PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY; + +typedef struct _PROCESS_MITIGATION_FONT_DISABLE_POLICY { + union { + DWORD Flags; + + struct { + DWORD DisableNonSystemFonts : 1; + DWORD AuditNonSystemFontLoading : 1; + DWORD ReservedFlags : 30; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_FONT_DISABLE_POLICY, *PPROCESS_MITIGATION_FONT_DISABLE_POLICY; + +typedef struct _PROCESS_MITIGATION_IMAGE_LOAD_POLICY { + union { + DWORD Flags; + + struct { + DWORD NoRemoteImages : 1; + DWORD NoLowMandatoryLabelImages : 1; + DWORD PreferSystem32Images : 1; + DWORD AuditNoRemoteImages : 1; + DWORD AuditNoLowMandatoryLabelImages : 1; + DWORD ReservedFlags : 27; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_IMAGE_LOAD_POLICY, *PPROCESS_MITIGATION_IMAGE_LOAD_POLICY; + +typedef struct _PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY { + union { + DWORD Flags; + + struct { + DWORD SmtBranchTargetIsolation : 1; + DWORD IsolateSecurityDomain : 1; + DWORD DisablePageCombine : 1; + DWORD SpeculativeStoreBypassDisable : 1; + DWORD ReservedFlags : 28; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY, *PPROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY; + +typedef struct _PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY { + union { + DWORD Flags; + + struct { + DWORD EnableUserShadowStack : 1; + DWORD AuditUserShadowStack : 1; + DWORD SetContextIpValidation : 1; + DWORD AuditSetContextIpValidation : 1; + DWORD EnableUserShadowStackStrictMode : 1; + DWORD BlockNonCetBinaries : 1; + DWORD BlockNonCetBinariesNonEhcont : 1; + DWORD AuditBlockNonCetBinaries : 1; + DWORD CetDynamicApisOutOfProcOnly : 1; + DWORD SetContextIpValidationRelaxedMode : 1; + DWORD ReservedFlags : 22; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY, *PPROCESS_MITIGATION_USER_SHADOW_STACK_POLICY; + +typedef struct _WIN32_MEMORY_RANGE_ENTRY { + LPVOID VirtualAddress; + SIZE_T NumberOfBytes; +} WIN32_MEMORY_RANGE_ENTRY, *PWIN32_MEMORY_RANGE_ENTRY; \ No newline at end of file diff --git a/kernel33/k32func.h b/kernel33/k32func.h new file mode 100644 index 0000000..9bc32c3 --- /dev/null +++ b/kernel33/k32func.h @@ -0,0 +1,6 @@ +#pragma once +#include +#include + +INLINE VOID DllMain_InitWoa( + VOID); \ No newline at end of file diff --git a/kernel33/kernel33.c b/kernel33/kernel33.c new file mode 100644 index 0000000..f95f133 --- /dev/null +++ b/kernel33/kernel33.c @@ -0,0 +1,165 @@ +#include +#include + +#include "k32func.h" +#include "k32defs.h" + +BOOL WINAPI DllMain( + IN HINSTANCE hInstance, + IN DWORD dwReason, + IN LPVOID lpReserved) +{ + if (dwReason == DLL_PROCESS_ATTACH) { + DisableThreadLibraryCalls(hInstance); + DllMain_InitWoa(); + } + + return TRUE; +} + +// +// EXPORTED FUNCTIONS +// + +WINBASEAPI VOID WINAPI GetSystemTimePreciseAsFileTime( + OUT LPFILETIME lpSystemTimeAsFileTime) +{ + ODS_ENTRY(); + GetSystemTimeAsFileTime(lpSystemTimeAsFileTime); +} + +WINBASEAPI BOOL WINAPI GetCurrentPackageId( + IN OUT LPDWORD lpdwBufferLength, + OUT LPBYTE buffer) +{ + ODS_ENTRY(); + return APPMODEL_ERROR_NO_PACKAGE; +} + +// Memory priority etc. not supported by win7 +// TODO: Investigate using undocumented NTAPI to do this properly. +WINBASEAPI BOOL WINAPI SetProcessInformation( + IN HANDLE hProcess, + IN PROCESS_INFORMATION_CLASS ProcessInformationClass, + IN LPVOID ProcessInformation, + IN DWORD ProcessInformationSize) +{ + ODS_ENTRY(); + return TRUE; +} + +// TODO: Use NtSetInformationThread to properly emulate memory priority +WINBASEAPI BOOL WINAPI SetThreadInformation( + IN HANDLE hThread, + IN THREAD_INFORMATION_CLASS ThreadInformationClass, + IN LPVOID ThreadInformation, + IN DWORD ThreadInformationSize) +{ + ODS_ENTRY(); + return TRUE; +} + +// (Get/Set)ThreadDescription is basically just used for setting a pretty name for threads +// so that you can view them in the debugger. + +WINBASEAPI HRESULT WINAPI SetThreadDescription( + IN HANDLE hThread, + IN LPCWSTR lpThreadDescription) +{ + ODS_ENTRY(); + return S_OK; +} + +WINBASEAPI HRESULT WINAPI GetThreadDescription( + IN HANDLE hThread, + OUT LPWSTR *ppszThreadDescription) +{ + // The caller is supposed to call LocalFree on *ppszThreadDescription + STATIC CONST WCHAR szNoDesc[] = L""; + ODS_ENTRY(); + *ppszThreadDescription = (PWSTR) LocalAlloc(0, sizeof(szNoDesc)); + RtlCopyMemory(ppszThreadDescription, szNoDesc, sizeof(szNoDesc)); + return S_OK; +} + +WINBASEAPI BOOL WINAPI GetProcessMitigationPolicy( + IN HANDLE hProcess, + IN PROCESS_MITIGATION_POLICY MitigationPolicy, + OUT LPVOID lpBuffer, + IN SIZE_T dwLength) +{ + ODS_ENTRY(); + + switch (MitigationPolicy) { + case ProcessDEPPolicy: { + PPROCESS_MITIGATION_DEP_POLICY lpPolicy = (PPROCESS_MITIGATION_DEP_POLICY) lpBuffer; + if (dwLength < sizeof(PROCESS_MITIGATION_DEP_POLICY)) { + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return FALSE; + } + + lpPolicy->Permanent = !!GetSystemDEPPolicy(); + } + break; + case ProcessASLRPolicy: + case ProcessDynamicCodePolicy: + case ProcessStrictHandleCheckPolicy: + case ProcessSystemCallDisablePolicy: + case ProcessMitigationOptionsMask: + case ProcessExtensionPointDisablePolicy: + case ProcessControlFlowGuardPolicy: + case ProcessSignaturePolicy: + case ProcessFontDisablePolicy: + case ProcessImageLoadPolicy: + case ProcessSystemCallFilterPolicy: + case ProcessPayloadRestrictionPolicy: + case ProcessChildProcessPolicy: + case ProcessSideChannelIsolationPolicy: + case ProcessUserShadowStackPolicy: + case ProcessRedirectionTrustPolicy: + ZeroMemory(lpBuffer, dwLength); + break; + default: + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + SetLastError(ERROR_SUCCESS); + return TRUE; +} + +WINBASEAPI BOOL WINAPI SetProcessMitigationPolicy( + IN PROCESS_MITIGATION_POLICY MitigationPolicy, + IN LPVOID lpBuffer, + IN SIZE_T dwLength) +{ + ODS_ENTRY(); + return TRUE; +} + +WINBASEAPI BOOL WINAPI PrefetchVirtualMemory( + IN HANDLE hProcess, + IN ULONG_PTR NumberOfEntries, + IN PWIN32_MEMORY_RANGE_ENTRY VirtualAddresses, + IN ULONG Flags) +{ + ODS_ENTRY(); + + // Since the PrefetchVirtualMemory function can never be necessary for correct operation + // of applications, it is treated as a strong hint by the system and is subject to usual + // physical memory constraints where it can completely or partially fail under + // low-memory conditions. + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + +WINBASEAPI BOOL GetOverlappedResultEx( + IN HANDLE hFile, + IN LPOVERLAPPED lpOverlapped, + OUT LPDWORD lpNumberOfBytesTransferred, + IN DWORD dwMilliseconds, + IN BOOL bAlertable) +{ + ODS_ENTRY(); + return GetOverlappedResult(hFile, lpOverlapped, lpNumberOfBytesTransferred, (dwMilliseconds == INFINITE)); +} \ No newline at end of file diff --git a/kernel33/kernel33.vcxproj b/kernel33/kernel33.vcxproj new file mode 100644 index 0000000..b40542c --- /dev/null +++ b/kernel33/kernel33.vcxproj @@ -0,0 +1,161 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3688EE16-AA48-414C-A8FA-6814C767CAEC} + Win32Proj + kernel33 + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;KERNEL33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + + + + + Level3 + Disabled + _WIN64;WIN32;_DEBUG;_WINDOWS;_USRDLL;KERNEL33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;KERNEL33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + + + Level3 + + + MaxSpeed + true + true + _WIN64;WIN32;NDEBUG;_WINDOWS;_USRDLL;KERNEL33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/kernel33/kernel33.vcxproj.filters b/kernel33/kernel33.vcxproj.filters new file mode 100644 index 0000000..4c077a2 --- /dev/null +++ b/kernel33/kernel33.vcxproj.filters @@ -0,0 +1,36 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/kernel33/kernel33.vcxproj.user b/kernel33/kernel33.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/kernel33/kernel33.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/kernel33/woa.c b/kernel33/woa.c new file mode 100644 index 0000000..edacd91 --- /dev/null +++ b/kernel33/woa.c @@ -0,0 +1,191 @@ +#include +#include + +#include "k32defs.h" + +// +// Contains the implementation for WaitOnAddress and related functions +// + +typedef struct _ACVAHASHTABLEADDRESSLISTENTRY { + LIST_ENTRY ListEntry; // MUST BE THE FIRST MEMBER OF THIS STRUCTURE + VOLATILE LPVOID lpAddr; + CONDITION_VARIABLE CVar; + DWORD dwWaiters; +} ACVAHASHTABLEADDRESSLISTENTRY, *PACVAHASHTABLEADDRESSLISTENTRY, *LPACVAHASHTABLEADDRESSLISTENTRY; + +typedef struct _ACVAHASHTABLEENTRY { + LIST_ENTRY Addresses; // list of ACVAHASHTABLEADDRESSLISTENTRY structures + CRITICAL_SECTION Lock; +} ACVAHASHTABLEENTRY, *PACVAHASHTABLEENTRY, *LPACVAHASHTABLEENTRY; + +ACVAHASHTABLEENTRY WaitOnAddressHashTable[256]; + +VOID DllMain_InitWoa( + VOID) +{ + INT i; + + for (i = 0; i < ARRAYSIZE(WaitOnAddressHashTable); ++i) { + LPACVAHASHTABLEENTRY lpHashTableEntry = &WaitOnAddressHashTable[i]; + InitializeCriticalSection(&lpHashTableEntry->Lock); + InitializeListHead(&lpHashTableEntry->Addresses); + } +} + +STATIC INLINE INT HashAddress( + IN LPVOID lpAddr) +{ + return (((ULONG_PTR) lpAddr) / 8) % ARRAYSIZE(WaitOnAddressHashTable); +} + +// Return TRUE if memory is the same. FALSE if memory is different. +#pragma warning(disable:4715) // not all control paths return a value +STATIC INLINE BOOL CompareVolatileMemory( + IN CONST VOLATILE LPVOID A1, + IN CONST LPVOID A2, + IN SIZE_T size) +{ + ASSUME(size == 1 || size == 2 || size == 4 || size == 8); + + switch (size) { + case 1: return (*(CONST LPBYTE)A1 == *(CONST LPBYTE)A2); + case 2: return (*(CONST LPWORD)A1 == *(CONST LPWORD)A2); + case 4: return (*(CONST LPDWORD)A1 == *(CONST LPDWORD)A2); + case 8: return (*(CONST LPQWORD)A1 == *(CONST LPQWORD)A2); + } +} +#pragma warning(default:4715) + +STATIC LPACVAHASHTABLEADDRESSLISTENTRY FindACVAListEntryForAddress( + IN LPACVAHASHTABLEENTRY lpHashTableEntry, + IN LPVOID lpAddr) +{ + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry; + + ForEachListEntry(&lpHashTableEntry->Addresses, lpListEntry) { + if (lpListEntry->lpAddr == lpAddr) { + return lpListEntry; + } + } + + return NULL; +} + +STATIC INLINE LPACVAHASHTABLEADDRESSLISTENTRY CreateACVAListEntryForAddress( + IN LPACVAHASHTABLEENTRY lpHashTableEntry, + IN LPVOID lpAddr) +{ + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry; + lpListEntry = (LPACVAHASHTABLEADDRESSLISTENTRY) HeapAlloc(GetProcessHeap(), 0, sizeof(ACVAHASHTABLEADDRESSLISTENTRY)); + + if (!lpListEntry) { + return NULL; + } + + lpListEntry->lpAddr = lpAddr; + lpListEntry->dwWaiters = 0; + InitializeConditionVariable(&lpListEntry->CVar); + InsertHeadList(&lpHashTableEntry->Addresses, (PLIST_ENTRY) lpListEntry); + + return lpListEntry; +} + +STATIC INLINE LPACVAHASHTABLEADDRESSLISTENTRY FindOrCreateACVAListEntryForAddress( + IN LPACVAHASHTABLEENTRY lpHashTableEntry, + IN LPVOID lpAddr) +{ + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry = FindACVAListEntryForAddress(lpHashTableEntry, lpAddr); + + if (!lpListEntry) { + lpListEntry = CreateACVAListEntryForAddress(lpHashTableEntry, lpAddr); + } + + return lpListEntry; +} + +STATIC INLINE VOID DeleteACVAListEntry( + IN LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry) +{ + RemoveEntryList((PLIST_ENTRY) lpListEntry); + HeapFree(GetProcessHeap(), 0, lpListEntry); +} + +WINBASEAPI BOOL WINAPI WaitOnAddress( + IN VOLATILE LPVOID lpAddr, // address to wait on + IN LPVOID lpCompare, // pointer to location of old value of lpAddr + IN SIZE_T cb, // number of bytes to compare + IN DWORD dwMilliseconds OPTIONAL)// maximum number of milliseconds to wait +{ + LPACVAHASHTABLEENTRY lpHashTableEntry = &WaitOnAddressHashTable[HashAddress(lpAddr)]; + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry; + DWORD dwLastError; + BOOL bSuccess; + + ODS_ENTRY(T("(%p, %p, %Iu, %I32u)"), lpAddr, lpCompare, cb, dwMilliseconds); + + if (!lpAddr || !lpCompare) { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } else if (!(cb == 1 || cb == 2 || cb == 4 || cb == 8)) { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + EnterCriticalSection(&lpHashTableEntry->Lock); + + if (!CompareVolatileMemory(lpAddr, lpCompare, cb)) { + LeaveCriticalSection(&lpHashTableEntry->Lock); + SetLastError(ERROR_SUCCESS); + return TRUE; + } + + lpListEntry = FindOrCreateACVAListEntryForAddress(lpHashTableEntry, lpAddr); + lpListEntry->dwWaiters++; + bSuccess = SleepConditionVariableCS(&lpListEntry->CVar, &lpHashTableEntry->Lock, dwMilliseconds); + dwLastError = GetLastError(); + + if (--lpListEntry->dwWaiters == 0) { + DeleteACVAListEntry(lpListEntry); + } + + LeaveCriticalSection(&lpHashTableEntry->Lock); + SetLastError(dwLastError); + return bSuccess; +} + +WINBASEAPI VOID WakeByAddressSingle( + IN LPVOID lpAddr) +{ + LPACVAHASHTABLEENTRY lpHashTableEntry = &WaitOnAddressHashTable[HashAddress(lpAddr)]; + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry; + + ODS_ENTRY(T("(%p)"), lpAddr); + + EnterCriticalSection(&lpHashTableEntry->Lock); + lpListEntry = FindACVAListEntryForAddress(lpHashTableEntry, lpAddr); + + if (lpListEntry) { + WakeConditionVariable(&lpListEntry->CVar); + } + + LeaveCriticalSection(&lpHashTableEntry->Lock); +} + +WINBASEAPI VOID WakeByAddressAll( + IN LPVOID lpAddr) +{ + LPACVAHASHTABLEENTRY lpHashTableEntry = &WaitOnAddressHashTable[HashAddress(lpAddr)]; + LPACVAHASHTABLEADDRESSLISTENTRY lpListEntry; + + ODS_ENTRY(T("(%p)"), lpAddr); + + EnterCriticalSection(&lpHashTableEntry->Lock); + lpListEntry = FindACVAListEntryForAddress(lpHashTableEntry, lpAddr); + + if (lpListEntry) { + WakeAllConditionVariable(&lpListEntry->CVar); + } + + LeaveCriticalSection(&lpHashTableEntry->Lock); +} \ No newline at end of file diff --git a/ntdll_x64.lib b/ntdll_x64.lib new file mode 100644 index 0000000000000000000000000000000000000000..288a0154e0dc5bde8f8deb42b642ca20e076b537 GIT binary patch literal 447634 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 z

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%0AnEjap8o81 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

SiJS61wk2m)|Eik{>xGZKjsuxcY-J{ z7Zf!V^Z7N!si)uR36yH)CwqX?b-r z&X+L)>v55%;`|xoWU=7(Jq1?$0vTbaO2@P_fbDcb#@H1y3MA7nm=R9VZ56HSjZWVi z`SelgMW77}=IKpLID0@Z&4cHq%@GZS=ihkd2NZhDLR{joF+GXu%mw+cp}tOb6Z zw>gR~QmJz{z1{u3O92s!Z6%;H@s5I^rpd}cXX2fXK}i`6xn->cG>Uf>go%yf-5FzI z+S+?E!o;+-_hy8NX>0E*2w^J${5gU41Of zqd-#dLxQ1}!%RUV`EX8A8@E=*M{izK~FA$lXPH`WKl(fl;9vn%4uJ@GrUF zkIQb=S{YwX7!&oSe2Q0vexM(%wvUC`wP*&v;h2Llv(P#&6es_tWQ3i5kh}k_gpvv}g|VL=+^piN|>Zw^%KER%VD1@upU3nDQe@^%J^B%P+Ql`K-$pH z1!Hov^^1(6x0ZP%Xm9;8WlYkp`c=x9q+Rvvl%Ws0`4ob?={Ff6$gV>7#&1)CF5 +#define DLLAPI __declspec(dllexport) +#define WINAPI __stdcall +DECLARE_HANDLE(CO_MTA_USAGE_COOKIE); + +DLLAPI HRESULT WINAPI CoIncrementMTAUsage( + OUT CO_MTA_USAGE_COOKIE *pCookie) +{ + *pCookie = NULL; + return E_NOTIMPL; +} \ No newline at end of file diff --git a/ole33/ole33.vcxproj b/ole33/ole33.vcxproj new file mode 100644 index 0000000..aa5e492 --- /dev/null +++ b/ole33/ole33.vcxproj @@ -0,0 +1,160 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {09F0931A-069E-4158-AE74-976DA2ED315C} + Win32Proj + ole33 + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;OLE33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + /ignore:4104 %(AdditionalOptions) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;OLE33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + /ignore:4104 %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;OLE33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + /ignore:4104 %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;OLE33_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + /ignore:4104 %(AdditionalOptions) + + + + + + + + + + \ No newline at end of file diff --git a/ole33/ole33.vcxproj.filters b/ole33/ole33.vcxproj.filters new file mode 100644 index 0000000..451924e --- /dev/null +++ b/ole33/ole33.vcxproj.filters @@ -0,0 +1,25 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/ole33/ole33.vcxproj.user b/ole33/ole33.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/ole33/ole33.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/shcore/shcore.c b/shcore/shcore.c new file mode 100644 index 0000000..5ec7105 --- /dev/null +++ b/shcore/shcore.c @@ -0,0 +1,162 @@ +#include +#define DLLAPI __declspec(dllexport) +#define WINAPI __stdcall + +typedef enum _MONITOR_DPI_TYPE { + MDT_EFFECTIVE_DPI, + MDT_ANGULAR_DPI, + MDT_RAW_DPI, + MDT_DEFAULT +} MONITOR_DPI_TYPE; + +typedef enum _SHELL_UI_COMPONENT { + SHELL_UI_COMPONENT_TASKBARS, + SHELL_UI_COMPONENT_NOTIFICATIONAREA, + SHELL_UI_COMPONENT_DESKBAND +} SHELL_UI_COMPONENT; + +typedef enum _PROCESS_DPI_AWARENESS { + PROCESS_DPI_UNAWARE, + PROCESS_SYSTEM_DPI_AWARE, + PROCESS_PER_MONITOR_DPI_AWARE +} PROCESS_DPI_AWARENESS; + +typedef enum _DEVICE_SCALE_FACTOR { + DEVICE_SCALE_FACTOR_INVALID, + SCALE_100_PERCENT, + SCALE_120_PERCENT, + SCALE_125_PERCENT, + SCALE_140_PERCENT, + SCALE_150_PERCENT, + SCALE_160_PERCENT, + SCALE_175_PERCENT, + SCALE_180_PERCENT, + SCALE_200_PERCENT, + SCALE_225_PERCENT, + SCALE_250_PERCENT, + SCALE_300_PERCENT, + SCALE_350_PERCENT, + SCALE_400_PERCENT, + SCALE_450_PERCENT, + SCALE_500_PERCENT +} DEVICE_SCALE_FACTOR; + +static UINT GetDpiForSystem( + VOID) +{ + HDC hdcScreen = GetDC(NULL); + UINT uDpi = GetDeviceCaps(hdcScreen, LOGPIXELSX); + ReleaseDC(NULL, hdcScreen); + return uDpi; +} + +DLLAPI HRESULT WINAPI GetDpiForMonitor( + IN HMONITOR hmonitor, + IN MONITOR_DPI_TYPE dpiType, + OUT LPUINT dpiX, + OUT LPUINT dpiY) +{ + HDC hdcScreen = GetDC(NULL); + *dpiX = GetDeviceCaps(hdcScreen, LOGPIXELSX); + *dpiY = GetDeviceCaps(hdcScreen, LOGPIXELSY); + ReleaseDC(NULL, hdcScreen); + return S_OK; +} + +DLLAPI UINT WINAPI GetDpiForShellUIComponent( + IN SHELL_UI_COMPONENT component) +{ + return GetDpiForSystem(); +} + +DLLAPI HRESULT WINAPI SetProcessDpiAwareness( + IN PROCESS_DPI_AWARENESS value) +{ + if (value != PROCESS_DPI_UNAWARE) { + SetProcessDPIAware(); + } + + return S_OK; +} + +DLLAPI HRESULT WINAPI GetProcessDpiAwareness( + IN HANDLE hprocess, + OUT PROCESS_DPI_AWARENESS *value) +{ + *value = PROCESS_DPI_UNAWARE; + return S_OK; +} + +DLLAPI HRESULT WINAPI GetScaleFactorForMonitor( + IN HMONITOR hMon, + OUT DEVICE_SCALE_FACTOR *pScale) +{ + *pScale = SCALE_100_PERCENT; + return S_OK; +} + +#pragma comment(linker, "/export:CommandLineToArgvW=shell32.CommandLineToArgvW") +#pragma comment(linker, "/export:GetCurrentProcessExplicitAppUserModelID=shell32.GetCurrentProcessExplicitAppUserModelID") +#pragma comment(linker, "/export:IStream_Copy=shlwapi.IStream_Copy") +#pragma comment(linker, "/export:IStream_Read=shlwapi.IStream_Read") +#pragma comment(linker, "/export:IStream_ReadStr=shlwapi.IStream_ReadStr") +#pragma comment(linker, "/export:IStream_Reset=shlwapi.IStream_Reset") +#pragma comment(linker, "/export:IStream_Size=shlwapi.IStream_Size") +#pragma comment(linker, "/export:IStream_Write=shlwapi.IStream_Write") +#pragma comment(linker, "/export:IStream_WriteStr=shlwapi.IStream_WriteStr") +#pragma comment(linker, "/export:IUnknown_AtomicRelease=shlwapi.IUnknown_AtomicRelease") +#pragma comment(linker, "/export:IUnknown_GetSite=shlwapi.IUnknown_GetSite") +#pragma comment(linker, "/export:IUnknown_QueryService=shlwapi.IUnknown_QueryService") +#pragma comment(linker, "/export:IUnknown_Set=shlwapi.IUnknown_Set") +#pragma comment(linker, "/export:IUnknown_SetSite=shlwapi.IUnknown_SetSite") +#pragma comment(linker, "/export:IsOS=shlwapi.IsOS") +#pragma comment(linker, "/export:SHAnsiToAnsi=shlwapi.SHAnsiToAnsi") +#pragma comment(linker, "/export:SHAnsiToUnicode=shlwapi.SHAnsiToUnicode") +#pragma comment(linker, "/export:SHCopyKeyA=shlwapi.SHCopyKeyA") +#pragma comment(linker, "/export:SHCopyKeyW=shlwapi.SHCopyKeyW") +#pragma comment(linker, "/export:SHCreateMemStream=shlwapi.SHCreateMemStream") +#pragma comment(linker, "/export:SHCreateStreamOnFileA=shlwapi.SHCreateStreamOnFileA") +#pragma comment(linker, "/export:SHCreateStreamOnFileEx=shlwapi.SHCreateStreamOnFileEx") +#pragma comment(linker, "/export:SHCreateStreamOnFileW=shlwapi.SHCreateStreamOnFileW") +#pragma comment(linker, "/export:SHCreateThread=shlwapi.SHCreateThread") +#pragma comment(linker, "/export:SHCreateThreadRef=shlwapi.SHCreateThreadRef") +#pragma comment(linker, "/export:SHCreateThreadWithHandle=shlwapi.SHCreateThreadWithHandle") +#pragma comment(linker, "/export:SHDeleteEmptyKeyA=shlwapi.SHDeleteEmptyKeyA") +#pragma comment(linker, "/export:SHDeleteEmptyKeyW=shlwapi.SHDeleteEmptyKeyW") +#pragma comment(linker, "/export:SHDeleteKeyA=shlwapi.SHDeleteKeyA") +#pragma comment(linker, "/export:SHDeleteKeyW=shlwapi.SHDeleteKeyW") +#pragma comment(linker, "/export:SHDeleteValueA=shlwapi.SHDeleteValueA") +#pragma comment(linker, "/export:SHDeleteValueW=shlwapi.SHDeleteValueW") +#pragma comment(linker, "/export:SHEnumKeyExA=shlwapi.SHEnumKeyExA") +#pragma comment(linker, "/export:SHEnumKeyExW=shlwapi.SHEnumKeyExW") +#pragma comment(linker, "/export:SHEnumValueA=shlwapi.SHEnumValueA") +#pragma comment(linker, "/export:SHEnumValueW=shlwapi.SHEnumValueW") +#pragma comment(linker, "/export:SHGetThreadRef=shlwapi.SHGetThreadRef") +#pragma comment(linker, "/export:SHGetValueA=shlwapi.SHGetValueA") +#pragma comment(linker, "/export:SHGetValueW=shlwapi.SHGetValueW") +#pragma comment(linker, "/export:SHOpenRegStream2A=shlwapi.SHOpenRegStream2A") +#pragma comment(linker, "/export:SHOpenRegStream2W=shlwapi.SHOpenRegStream2W") +#pragma comment(linker, "/export:SHOpenRegStreamA=shlwapi.SHOpenRegStreamA") +#pragma comment(linker, "/export:SHOpenRegStreamW=shlwapi.SHOpenRegStreamW") +#pragma comment(linker, "/export:SHQueryInfoKeyA=shlwapi.SHQueryInfoKeyA") +#pragma comment(linker, "/export:SHQueryInfoKeyW=shlwapi.SHQueryInfoKeyW") +#pragma comment(linker, "/export:SHQueryValueExA=shlwapi.SHQueryValueExA") +#pragma comment(linker, "/export:SHQueryValueExW=shlwapi.SHQueryValueExW") +#pragma comment(linker, "/export:SHRegDuplicateHKey=shlwapi.SHRegDuplicateHKey") +#pragma comment(linker, "/export:SHRegGetIntW=shlwapi.SHRegGetIntW") +#pragma comment(linker, "/export:SHRegGetPathA=shlwapi.SHRegGetPathA") +#pragma comment(linker, "/export:SHRegGetPathW=shlwapi.SHRegGetPathW") +#pragma comment(linker, "/export:SHRegGetValueA=shlwapi.SHRegGetValueA") +#pragma comment(linker, "/export:SHRegGetValueFromHKCUHKLM=shlwapi.SHRegGetValueFromHKCUHKLM") +#pragma comment(linker, "/export:SHRegGetValueW=shlwapi.SHRegGetValueW") +#pragma comment(linker, "/export:SHRegSetPathA=shlwapi.SHRegSetPathA") +#pragma comment(linker, "/export:SHRegSetPathW=shlwapi.SHRegSetPathW") +#pragma comment(linker, "/export:SHReleaseThreadRef=shlwapi.SHReleaseThreadRef") +#pragma comment(linker, "/export:SHSetThreadRef=shlwapi.SHSetThreadRef") +#pragma comment(linker, "/export:SHSetValueA=shlwapi.SHSetValueA") +#pragma comment(linker, "/export:SHSetValueW=shlwapi.SHSetValueW") +#pragma comment(linker, "/export:SHStrDupA=shlwapi.SHStrDupA") +#pragma comment(linker, "/export:SHStrDupW=shlwapi.SHStrDupW") +#pragma comment(linker, "/export:SHUnicodeToAnsi=shlwapi.SHUnicodeToAnsi") +#pragma comment(linker, "/export:SHUnicodeToUnicode=shlwapi.SHUnicodeToUnicode") +#pragma comment(linker, "/export:SetCurrentProcessExplicitAppUserModelID=shlwapi.SetCurrentProcessExplicitAppUserModelID") \ No newline at end of file diff --git a/shcore/shcore.vcxproj b/shcore/shcore.vcxproj new file mode 100644 index 0000000..e19e3a2 --- /dev/null +++ b/shcore/shcore.vcxproj @@ -0,0 +1,147 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {8FED5F6A-0C4A-479F-9C85-763C33621454} + Win32Proj + shcore + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SHCORE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SHCORE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SHCORE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SHCORE_EXPORTS;%(PreprocessorDefinitions) + $(SolutionDir) + + + Windows + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/shcore/shcore.vcxproj.filters b/shcore/shcore.vcxproj.filters new file mode 100644 index 0000000..27eaccf --- /dev/null +++ b/shcore/shcore.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + \ No newline at end of file diff --git a/shcore/shcore.vcxproj.user b/shcore/shcore.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/shcore/shcore.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/user33/forwarders.c b/user33/forwarders.c new file mode 100644 index 0000000..7a13787 --- /dev/null +++ b/user33/forwarders.c @@ -0,0 +1,847 @@ +// Generated by KexExprt (64 bit) from C:\Windows\system32\USER32.dll +#pragma comment(linker, "/export:ActivateKeyboardLayout=USER32.ActivateKeyboardLayout,@1502") +#pragma comment(linker, "/export:AddClipboardFormatListener=USER32.AddClipboardFormatListener,@1503") +#pragma comment(linker, "/export:AdjustWindowRect=USER32.AdjustWindowRect,@1504") +#pragma comment(linker, "/export:AdjustWindowRectEx=USER32.AdjustWindowRectEx,@1505") +#pragma comment(linker, "/export:AlignRects=USER32.AlignRects,@1506") +#pragma comment(linker, "/export:AllowForegroundActivation=USER32.AllowForegroundActivation,@1507") +#pragma comment(linker, "/export:AllowSetForegroundWindow=USER32.AllowSetForegroundWindow,@1508") +#pragma comment(linker, "/export:AnimateWindow=USER32.AnimateWindow,@1509") +#pragma comment(linker, "/export:AnyPopup=USER32.AnyPopup,@1510") +#pragma comment(linker, "/export:AppendMenuA=USER32.AppendMenuA,@1511") +#pragma comment(linker, "/export:AppendMenuW=USER32.AppendMenuW,@1512") +#pragma comment(linker, "/export:ArrangeIconicWindows=USER32.ArrangeIconicWindows,@1513") +#pragma comment(linker, "/export:AttachThreadInput=USER32.AttachThreadInput,@1514") +#pragma comment(linker, "/export:BeginDeferWindowPos=USER32.BeginDeferWindowPos,@1515") +#pragma comment(linker, "/export:BeginPaint=USER32.BeginPaint,@1516") +#pragma comment(linker, "/export:BlockInput=USER32.BlockInput,@1517") +#pragma comment(linker, "/export:BringWindowToTop=USER32.BringWindowToTop,@1518") +#pragma comment(linker, "/export:BroadcastSystemMessage=USER32.BroadcastSystemMessage,@1519") +#pragma comment(linker, "/export:BroadcastSystemMessageA=USER32.BroadcastSystemMessageA,@1520") +#pragma comment(linker, "/export:BroadcastSystemMessageExA=USER32.BroadcastSystemMessageExA,@1521") +#pragma comment(linker, "/export:BroadcastSystemMessageExW=USER32.BroadcastSystemMessageExW,@1522") +#pragma comment(linker, "/export:BroadcastSystemMessageW=USER32.BroadcastSystemMessageW,@1523") +#pragma comment(linker, "/export:BuildReasonArray=USER32.BuildReasonArray,@1524") +#pragma comment(linker, "/export:CalcMenuBar=USER32.CalcMenuBar,@1525") +#pragma comment(linker, "/export:CalculatePopupWindowPosition=USER32.CalculatePopupWindowPosition,@1526") +#pragma comment(linker, "/export:CallMsgFilter=USER32.CallMsgFilter,@1527") +#pragma comment(linker, "/export:CallMsgFilterA=USER32.CallMsgFilterA,@1528") +#pragma comment(linker, "/export:CallMsgFilterW=USER32.CallMsgFilterW,@1529") +#pragma comment(linker, "/export:CallNextHookEx=USER32.CallNextHookEx,@1530") +#pragma comment(linker, "/export:CallWindowProcA=USER32.CallWindowProcA,@1531") +#pragma comment(linker, "/export:CallWindowProcW=USER32.CallWindowProcW,@1532") +#pragma comment(linker, "/export:CancelShutdown=USER32.CancelShutdown,@1533") +#pragma comment(linker, "/export:CascadeChildWindows=USER32.CascadeChildWindows,@1534") +#pragma comment(linker, "/export:CascadeWindows=USER32.CascadeWindows,@1535") +#pragma comment(linker, "/export:ChangeClipboardChain=USER32.ChangeClipboardChain,@1536") +#pragma comment(linker, "/export:ChangeDisplaySettingsA=USER32.ChangeDisplaySettingsA,@1537") +#pragma comment(linker, "/export:ChangeDisplaySettingsExA=USER32.ChangeDisplaySettingsExA,@1538") +#pragma comment(linker, "/export:ChangeDisplaySettingsExW=USER32.ChangeDisplaySettingsExW,@1539") +#pragma comment(linker, "/export:ChangeDisplaySettingsW=USER32.ChangeDisplaySettingsW,@1540") +#pragma comment(linker, "/export:ChangeMenuA=USER32.ChangeMenuA,@1541") +#pragma comment(linker, "/export:ChangeMenuW=USER32.ChangeMenuW,@1542") +#pragma comment(linker, "/export:ChangeWindowMessageFilter=USER32.ChangeWindowMessageFilter,@1543") +#pragma comment(linker, "/export:ChangeWindowMessageFilterEx=USER32.ChangeWindowMessageFilterEx,@1544") +#pragma comment(linker, "/export:CharLowerA=USER32.CharLowerA,@1545") +#pragma comment(linker, "/export:CharLowerBuffA=USER32.CharLowerBuffA,@1546") +#pragma comment(linker, "/export:CharLowerBuffW=USER32.CharLowerBuffW,@1547") +#pragma comment(linker, "/export:CharLowerW=USER32.CharLowerW,@1548") +#pragma comment(linker, "/export:CharNextA=USER32.CharNextA,@1549") +#pragma comment(linker, "/export:CharNextExA=USER32.CharNextExA,@1557") +#pragma comment(linker, "/export:CharNextW=USER32.CharNextW,@1558") +#pragma comment(linker, "/export:CharPrevA=USER32.CharPrevA,@1559") +#pragma comment(linker, "/export:CharPrevExA=USER32.CharPrevExA,@1560") +#pragma comment(linker, "/export:CharPrevW=USER32.CharPrevW,@1561") +#pragma comment(linker, "/export:CharToOemA=USER32.CharToOemA,@1562") +#pragma comment(linker, "/export:CharToOemBuffA=USER32.CharToOemBuffA,@1563") +#pragma comment(linker, "/export:CharToOemBuffW=USER32.CharToOemBuffW,@1564") +#pragma comment(linker, "/export:CharToOemW=USER32.CharToOemW,@1565") +#pragma comment(linker, "/export:CharUpperA=USER32.CharUpperA,@1566") +#pragma comment(linker, "/export:CharUpperBuffA=USER32.CharUpperBuffA,@1567") +#pragma comment(linker, "/export:CharUpperBuffW=USER32.CharUpperBuffW,@1568") +#pragma comment(linker, "/export:CharUpperW=USER32.CharUpperW,@1569") +#pragma comment(linker, "/export:CheckDesktopByThreadId=USER32.CheckDesktopByThreadId,@1570") +#pragma comment(linker, "/export:CheckDlgButton=USER32.CheckDlgButton,@1571") +#pragma comment(linker, "/export:CheckMenuItem=USER32.CheckMenuItem,@1572") +#pragma comment(linker, "/export:CheckMenuRadioItem=USER32.CheckMenuRadioItem,@1573") +#pragma comment(linker, "/export:CheckRadioButton=USER32.CheckRadioButton,@1574") +#pragma comment(linker, "/export:CheckWindowThreadDesktop=USER32.CheckWindowThreadDesktop,@1575") +#pragma comment(linker, "/export:ChildWindowFromPoint=USER32.ChildWindowFromPoint,@1576") +#pragma comment(linker, "/export:ChildWindowFromPointEx=USER32.ChildWindowFromPointEx,@1577") +#pragma comment(linker, "/export:CliImmSetHotKey=USER32.CliImmSetHotKey,@1578") +#pragma comment(linker, "/export:ClientThreadSetup=USER32.ClientThreadSetup,@1579") +#pragma comment(linker, "/export:ClientToScreen=USER32.ClientToScreen,@1580") +#pragma comment(linker, "/export:ClipCursor=USER32.ClipCursor,@1581") +#pragma comment(linker, "/export:CloseClipboard=USER32.CloseClipboard,@1582") +#pragma comment(linker, "/export:CloseDesktop=USER32.CloseDesktop,@1583") +#pragma comment(linker, "/export:CloseGestureInfoHandle=USER32.CloseGestureInfoHandle,@1584") +#pragma comment(linker, "/export:CloseTouchInputHandle=USER32.CloseTouchInputHandle,@1585") +#pragma comment(linker, "/export:CloseWindow=USER32.CloseWindow,@1586") +#pragma comment(linker, "/export:CloseWindowStation=USER32.CloseWindowStation,@1587") +#pragma comment(linker, "/export:ConsoleControl=USER32.ConsoleControl,@1588") +#pragma comment(linker, "/export:ControlMagnification=USER32.ControlMagnification,@1589") +#pragma comment(linker, "/export:CopyAcceleratorTableA=USER32.CopyAcceleratorTableA,@1590") +#pragma comment(linker, "/export:CopyAcceleratorTableW=USER32.CopyAcceleratorTableW,@1591") +#pragma comment(linker, "/export:CopyIcon=USER32.CopyIcon,@1592") +#pragma comment(linker, "/export:CopyImage=USER32.CopyImage,@1593") +#pragma comment(linker, "/export:CopyRect=USER32.CopyRect,@1594") +#pragma comment(linker, "/export:CountClipboardFormats=USER32.CountClipboardFormats,@1595") +#pragma comment(linker, "/export:CreateAcceleratorTableA=USER32.CreateAcceleratorTableA,@1596") +#pragma comment(linker, "/export:CreateAcceleratorTableW=USER32.CreateAcceleratorTableW,@1597") +#pragma comment(linker, "/export:CreateCaret=USER32.CreateCaret,@1598") +#pragma comment(linker, "/export:CreateCursor=USER32.CreateCursor,@1599") +#pragma comment(linker, "/export:CreateDesktopA=USER32.CreateDesktopA,@1600") +#pragma comment(linker, "/export:CreateDesktopExA=USER32.CreateDesktopExA,@1601") +#pragma comment(linker, "/export:CreateDesktopExW=USER32.CreateDesktopExW,@1602") +#pragma comment(linker, "/export:CreateDesktopW=USER32.CreateDesktopW,@1603") +#pragma comment(linker, "/export:CreateDialogIndirectParamA=USER32.CreateDialogIndirectParamA,@1604") +#pragma comment(linker, "/export:CreateDialogIndirectParamAorW=USER32.CreateDialogIndirectParamAorW,@1605") +#pragma comment(linker, "/export:CreateDialogIndirectParamW=USER32.CreateDialogIndirectParamW,@1606") +#pragma comment(linker, "/export:CreateDialogParamA=USER32.CreateDialogParamA,@1607") +#pragma comment(linker, "/export:CreateDialogParamW=USER32.CreateDialogParamW,@1608") +#pragma comment(linker, "/export:CreateIcon=USER32.CreateIcon,@1609") +#pragma comment(linker, "/export:CreateIconFromResource=USER32.CreateIconFromResource,@1610") +#pragma comment(linker, "/export:CreateIconFromResourceEx=USER32.CreateIconFromResourceEx,@1611") +#pragma comment(linker, "/export:CreateIconIndirect=USER32.CreateIconIndirect,@1612") +#pragma comment(linker, "/export:CreateMDIWindowA=USER32.CreateMDIWindowA,@1613") +#pragma comment(linker, "/export:CreateMDIWindowW=USER32.CreateMDIWindowW,@1614") +#pragma comment(linker, "/export:CreateMenu=USER32.CreateMenu,@1615") +#pragma comment(linker, "/export:CreatePopupMenu=USER32.CreatePopupMenu,@1616") +#pragma comment(linker, "/export:CreateSystemThreads=USER32.CreateSystemThreads,@1617") +#pragma comment(linker, "/export:CreateWindowExA=USER32.CreateWindowExA,@1618") +#pragma comment(linker, "/export:CreateWindowExW=USER32.CreateWindowExW,@1619") +#pragma comment(linker, "/export:CreateWindowStationA=USER32.CreateWindowStationA,@1620") +#pragma comment(linker, "/export:CreateWindowStationW=USER32.CreateWindowStationW,@1621") +#pragma comment(linker, "/export:CsrBroadcastSystemMessageExW=USER32.CsrBroadcastSystemMessageExW,@1622") +#pragma comment(linker, "/export:CtxInitUser32=USER32.CtxInitUser32,@1623") +#pragma comment(linker, "/export:DdeAbandonTransaction=USER32.DdeAbandonTransaction,@1624") +#pragma comment(linker, "/export:DdeAccessData=USER32.DdeAccessData,@1625") +#pragma comment(linker, "/export:DdeAddData=USER32.DdeAddData,@1626") +#pragma comment(linker, "/export:DdeClientTransaction=USER32.DdeClientTransaction,@1627") +#pragma comment(linker, "/export:DdeCmpStringHandles=USER32.DdeCmpStringHandles,@1628") +#pragma comment(linker, "/export:DdeConnect=USER32.DdeConnect,@1629") +#pragma comment(linker, "/export:DdeConnectList=USER32.DdeConnectList,@1630") +#pragma comment(linker, "/export:DdeCreateDataHandle=USER32.DdeCreateDataHandle,@1631") +#pragma comment(linker, "/export:DdeCreateStringHandleA=USER32.DdeCreateStringHandleA,@1632") +#pragma comment(linker, "/export:DdeCreateStringHandleW=USER32.DdeCreateStringHandleW,@1633") +#pragma comment(linker, "/export:DdeDisconnect=USER32.DdeDisconnect,@1634") +#pragma comment(linker, "/export:DdeDisconnectList=USER32.DdeDisconnectList,@1635") +#pragma comment(linker, "/export:DdeEnableCallback=USER32.DdeEnableCallback,@1636") +#pragma comment(linker, "/export:DdeFreeDataHandle=USER32.DdeFreeDataHandle,@1637") +#pragma comment(linker, "/export:DdeFreeStringHandle=USER32.DdeFreeStringHandle,@1638") +#pragma comment(linker, "/export:DdeGetData=USER32.DdeGetData,@1639") +#pragma comment(linker, "/export:DdeGetLastError=USER32.DdeGetLastError,@1640") +#pragma comment(linker, "/export:DdeGetQualityOfService=USER32.DdeGetQualityOfService,@1641") +#pragma comment(linker, "/export:DdeImpersonateClient=USER32.DdeImpersonateClient,@1642") +#pragma comment(linker, "/export:DdeInitializeA=USER32.DdeInitializeA,@1643") +#pragma comment(linker, "/export:DdeInitializeW=USER32.DdeInitializeW,@1644") +#pragma comment(linker, "/export:DdeKeepStringHandle=USER32.DdeKeepStringHandle,@1645") +#pragma comment(linker, "/export:DdeNameService=USER32.DdeNameService,@1646") +#pragma comment(linker, "/export:DdePostAdvise=USER32.DdePostAdvise,@1647") +#pragma comment(linker, "/export:DdeQueryConvInfo=USER32.DdeQueryConvInfo,@1648") +#pragma comment(linker, "/export:DdeQueryNextServer=USER32.DdeQueryNextServer,@1649") +#pragma comment(linker, "/export:DdeQueryStringA=USER32.DdeQueryStringA,@1650") +#pragma comment(linker, "/export:DdeQueryStringW=USER32.DdeQueryStringW,@1651") +#pragma comment(linker, "/export:DdeReconnect=USER32.DdeReconnect,@1652") +#pragma comment(linker, "/export:DdeSetQualityOfService=USER32.DdeSetQualityOfService,@1653") +#pragma comment(linker, "/export:DdeSetUserHandle=USER32.DdeSetUserHandle,@1654") +#pragma comment(linker, "/export:DdeUnaccessData=USER32.DdeUnaccessData,@1655") +#pragma comment(linker, "/export:DdeUninitialize=USER32.DdeUninitialize,@1656") +#pragma comment(linker, "/export:DefDlgProcA=USER32.DefDlgProcA,@1657") +#pragma comment(linker, "/export:DefDlgProcW=USER32.DefDlgProcW,@1658") +#pragma comment(linker, "/export:DefFrameProcA=USER32.DefFrameProcA,@1659") +#pragma comment(linker, "/export:DefFrameProcW=USER32.DefFrameProcW,@1660") +#pragma comment(linker, "/export:DefMDIChildProcA=USER32.DefMDIChildProcA,@1661") +#pragma comment(linker, "/export:DefMDIChildProcW=USER32.DefMDIChildProcW,@1662") +#pragma comment(linker, "/export:DefRawInputProc=USER32.DefRawInputProc,@1663") +#pragma comment(linker, "/export:DefWindowProcA=USER32.DefWindowProcA,@1664") +#pragma comment(linker, "/export:DefWindowProcW=USER32.DefWindowProcW,@1665") +#pragma comment(linker, "/export:DeferWindowPos=USER32.DeferWindowPos,@1666") +#pragma comment(linker, "/export:DeleteMenu=USER32.DeleteMenu,@1667") +#pragma comment(linker, "/export:DeregisterShellHookWindow=USER32.DeregisterShellHookWindow,@1668") +#pragma comment(linker, "/export:DestroyAcceleratorTable=USER32.DestroyAcceleratorTable,@1669") +#pragma comment(linker, "/export:DestroyCaret=USER32.DestroyCaret,@1670") +#pragma comment(linker, "/export:DestroyCursor=USER32.DestroyCursor,@1671") +#pragma comment(linker, "/export:DestroyIcon=USER32.DestroyIcon,@1672") +#pragma comment(linker, "/export:DestroyMenu=USER32.DestroyMenu,@1673") +#pragma comment(linker, "/export:DestroyReasons=USER32.DestroyReasons,@1674") +#pragma comment(linker, "/export:DestroyWindow=USER32.DestroyWindow,@1675") +#pragma comment(linker, "/export:DeviceEventWorker=USER32.DeviceEventWorker,@1676") +#pragma comment(linker, "/export:DialogBoxIndirectParamA=USER32.DialogBoxIndirectParamA,@1677") +#pragma comment(linker, "/export:DialogBoxIndirectParamAorW=USER32.DialogBoxIndirectParamAorW,@1678") +#pragma comment(linker, "/export:DialogBoxIndirectParamW=USER32.DialogBoxIndirectParamW,@1679") +#pragma comment(linker, "/export:DialogBoxParamA=USER32.DialogBoxParamA,@1680") +#pragma comment(linker, "/export:DialogBoxParamW=USER32.DialogBoxParamW,@1681") +#pragma comment(linker, "/export:DisableProcessWindowsGhosting=USER32.DisableProcessWindowsGhosting,@1682") +#pragma comment(linker, "/export:DispatchMessageA=USER32.DispatchMessageA,@1683") +#pragma comment(linker, "/export:DispatchMessageW=USER32.DispatchMessageW,@1684") +#pragma comment(linker, "/export:DisplayConfigGetDeviceInfo=USER32.DisplayConfigGetDeviceInfo,@1685") +#pragma comment(linker, "/export:DisplayConfigSetDeviceInfo=USER32.DisplayConfigSetDeviceInfo,@1686") +#pragma comment(linker, "/export:DisplayExitWindowsWarnings=USER32.DisplayExitWindowsWarnings,@1687") +#pragma comment(linker, "/export:DlgDirListA=USER32.DlgDirListA,@1688") +#pragma comment(linker, "/export:DlgDirListComboBoxA=USER32.DlgDirListComboBoxA,@1689") +#pragma comment(linker, "/export:DlgDirListComboBoxW=USER32.DlgDirListComboBoxW,@1690") +#pragma comment(linker, "/export:DlgDirListW=USER32.DlgDirListW,@1691") +#pragma comment(linker, "/export:DlgDirSelectComboBoxExA=USER32.DlgDirSelectComboBoxExA,@1692") +#pragma comment(linker, "/export:DlgDirSelectComboBoxExW=USER32.DlgDirSelectComboBoxExW,@1693") +#pragma comment(linker, "/export:DlgDirSelectExA=USER32.DlgDirSelectExA,@1694") +#pragma comment(linker, "/export:DlgDirSelectExW=USER32.DlgDirSelectExW,@1695") +#pragma comment(linker, "/export:DoSoundConnect=USER32.DoSoundConnect,@1696") +#pragma comment(linker, "/export:DoSoundDisconnect=USER32.DoSoundDisconnect,@1697") +#pragma comment(linker, "/export:DragDetect=USER32.DragDetect,@1698") +#pragma comment(linker, "/export:DragObject=USER32.DragObject,@1699") +#pragma comment(linker, "/export:DrawAnimatedRects=USER32.DrawAnimatedRects,@1700") +#pragma comment(linker, "/export:DrawCaption=USER32.DrawCaption,@1701") +#pragma comment(linker, "/export:DrawCaptionTempA=USER32.DrawCaptionTempA,@1702") +#pragma comment(linker, "/export:DrawCaptionTempW=USER32.DrawCaptionTempW,@1703") +#pragma comment(linker, "/export:DrawEdge=USER32.DrawEdge,@1704") +#pragma comment(linker, "/export:DrawFocusRect=USER32.DrawFocusRect,@1705") +#pragma comment(linker, "/export:DrawFrame=USER32.DrawFrame,@1706") +#pragma comment(linker, "/export:DrawFrameControl=USER32.DrawFrameControl,@1707") +#pragma comment(linker, "/export:DrawIcon=USER32.DrawIcon,@1708") +#pragma comment(linker, "/export:DrawIconEx=USER32.DrawIconEx,@1709") +#pragma comment(linker, "/export:DrawMenuBar=USER32.DrawMenuBar,@1710") +#pragma comment(linker, "/export:DrawMenuBarTemp=USER32.DrawMenuBarTemp,@1711") +#pragma comment(linker, "/export:DrawStateA=USER32.DrawStateA,@1712") +#pragma comment(linker, "/export:DrawStateW=USER32.DrawStateW,@1713") +#pragma comment(linker, "/export:DrawTextA=USER32.DrawTextA,@1714") +#pragma comment(linker, "/export:DrawTextExA=USER32.DrawTextExA,@1715") +#pragma comment(linker, "/export:DrawTextExW=USER32.DrawTextExW,@1716") +#pragma comment(linker, "/export:DrawTextW=USER32.DrawTextW,@1717") +#pragma comment(linker, "/export:DwmGetDxSharedSurface=USER32.DwmGetDxSharedSurface,@1718") +#pragma comment(linker, "/export:DwmStartRedirection=USER32.DwmStartRedirection,@1719") +#pragma comment(linker, "/export:DwmStopRedirection=USER32.DwmStopRedirection,@1720") +#pragma comment(linker, "/export:EditWndProc=USER32.EditWndProc,@1721") +#pragma comment(linker, "/export:EmptyClipboard=USER32.EmptyClipboard,@1722") +#pragma comment(linker, "/export:EnableMenuItem=USER32.EnableMenuItem,@1723") +#pragma comment(linker, "/export:EnableScrollBar=USER32.EnableScrollBar,@1724") +#pragma comment(linker, "/export:EnableWindow=USER32.EnableWindow,@1725") +#pragma comment(linker, "/export:EndDeferWindowPos=USER32.EndDeferWindowPos,@1726") +#pragma comment(linker, "/export:EndDialog=USER32.EndDialog,@1727") +#pragma comment(linker, "/export:EndMenu=USER32.EndMenu,@1728") +#pragma comment(linker, "/export:EndPaint=USER32.EndPaint,@1729") +#pragma comment(linker, "/export:EndTask=USER32.EndTask,@1730") +#pragma comment(linker, "/export:EnterReaderModeHelper=USER32.EnterReaderModeHelper,@1731") +#pragma comment(linker, "/export:EnumChildWindows=USER32.EnumChildWindows,@1732") +#pragma comment(linker, "/export:EnumClipboardFormats=USER32.EnumClipboardFormats,@1733") +#pragma comment(linker, "/export:EnumDesktopWindows=USER32.EnumDesktopWindows,@1734") +#pragma comment(linker, "/export:EnumDesktopsA=USER32.EnumDesktopsA,@1735") +#pragma comment(linker, "/export:EnumDesktopsW=USER32.EnumDesktopsW,@1736") +#pragma comment(linker, "/export:EnumDisplayDevicesA=USER32.EnumDisplayDevicesA,@1737") +#pragma comment(linker, "/export:EnumDisplayDevicesW=USER32.EnumDisplayDevicesW,@1738") +#pragma comment(linker, "/export:EnumDisplayMonitors=USER32.EnumDisplayMonitors,@1739") +#pragma comment(linker, "/export:EnumDisplaySettingsA=USER32.EnumDisplaySettingsA,@1740") +#pragma comment(linker, "/export:EnumDisplaySettingsExA=USER32.EnumDisplaySettingsExA,@1741") +#pragma comment(linker, "/export:EnumDisplaySettingsExW=USER32.EnumDisplaySettingsExW,@1742") +#pragma comment(linker, "/export:EnumDisplaySettingsW=USER32.EnumDisplaySettingsW,@1743") +#pragma comment(linker, "/export:EnumPropsA=USER32.EnumPropsA,@1744") +#pragma comment(linker, "/export:EnumPropsExA=USER32.EnumPropsExA,@1745") +#pragma comment(linker, "/export:EnumPropsExW=USER32.EnumPropsExW,@1746") +#pragma comment(linker, "/export:EnumPropsW=USER32.EnumPropsW,@1747") +#pragma comment(linker, "/export:EnumThreadWindows=USER32.EnumThreadWindows,@1748") +#pragma comment(linker, "/export:EnumWindowStationsA=USER32.EnumWindowStationsA,@1749") +#pragma comment(linker, "/export:EnumWindowStationsW=USER32.EnumWindowStationsW,@1750") +#pragma comment(linker, "/export:EnumWindows=USER32.EnumWindows,@1751") +#pragma comment(linker, "/export:EqualRect=USER32.EqualRect,@1752") +#pragma comment(linker, "/export:ExcludeUpdateRgn=USER32.ExcludeUpdateRgn,@1753") +#pragma comment(linker, "/export:ExitWindowsEx=USER32.ExitWindowsEx,@1754") +#pragma comment(linker, "/export:FillRect=USER32.FillRect,@1755") +#pragma comment(linker, "/export:FindWindowA=USER32.FindWindowA,@1756") +#pragma comment(linker, "/export:FindWindowExA=USER32.FindWindowExA,@1757") +#pragma comment(linker, "/export:FindWindowExW=USER32.FindWindowExW,@1758") +#pragma comment(linker, "/export:FindWindowW=USER32.FindWindowW,@1759") +#pragma comment(linker, "/export:FlashWindow=USER32.FlashWindow,@1760") +#pragma comment(linker, "/export:FlashWindowEx=USER32.FlashWindowEx,@1761") +#pragma comment(linker, "/export:FrameRect=USER32.FrameRect,@1762") +#pragma comment(linker, "/export:FreeDDElParam=USER32.FreeDDElParam,@1763") +#pragma comment(linker, "/export:FrostCrashedWindow=USER32.FrostCrashedWindow,@1764") +#pragma comment(linker, "/export:GetActiveWindow=USER32.GetActiveWindow,@1765") +#pragma comment(linker, "/export:GetAltTabInfo=USER32.GetAltTabInfo,@1766") +#pragma comment(linker, "/export:GetAltTabInfoA=USER32.GetAltTabInfoA,@1767") +#pragma comment(linker, "/export:GetAltTabInfoW=USER32.GetAltTabInfoW,@1768") +#pragma comment(linker, "/export:GetAncestor=USER32.GetAncestor,@1769") +#pragma comment(linker, "/export:GetAppCompatFlags=USER32.GetAppCompatFlags,@1770") +#pragma comment(linker, "/export:GetAppCompatFlags2=USER32.GetAppCompatFlags2,@1771") +#pragma comment(linker, "/export:GetAsyncKeyState=USER32.GetAsyncKeyState,@1772") +#pragma comment(linker, "/export:GetCapture=USER32.GetCapture,@1773") +#pragma comment(linker, "/export:GetCaretBlinkTime=USER32.GetCaretBlinkTime,@1774") +#pragma comment(linker, "/export:GetCaretPos=USER32.GetCaretPos,@1775") +#pragma comment(linker, "/export:GetClassInfoA=USER32.GetClassInfoA,@1776") +#pragma comment(linker, "/export:GetClassInfoExA=USER32.GetClassInfoExA,@1777") +#pragma comment(linker, "/export:GetClassInfoExW=USER32.GetClassInfoExW,@1778") +#pragma comment(linker, "/export:GetClassInfoW=USER32.GetClassInfoW,@1779") +#pragma comment(linker, "/export:GetClassLongA=USER32.GetClassLongA,@1780") +#pragma comment(linker, "/export:GetClassLongPtrA=USER32.GetClassLongPtrA,@1781") +#pragma comment(linker, "/export:GetClassLongPtrW=USER32.GetClassLongPtrW,@1782") +#pragma comment(linker, "/export:GetClassLongW=USER32.GetClassLongW,@1783") +#pragma comment(linker, "/export:GetClassNameA=USER32.GetClassNameA,@1784") +#pragma comment(linker, "/export:GetClassNameW=USER32.GetClassNameW,@1785") +#pragma comment(linker, "/export:GetClassWord=USER32.GetClassWord,@1786") +#pragma comment(linker, "/export:GetClientRect=USER32.GetClientRect,@1787") +#pragma comment(linker, "/export:GetClipCursor=USER32.GetClipCursor,@1788") +#pragma comment(linker, "/export:GetClipboardData=USER32.GetClipboardData,@1789") +#pragma comment(linker, "/export:GetClipboardFormatNameA=USER32.GetClipboardFormatNameA,@1790") +#pragma comment(linker, "/export:GetClipboardFormatNameW=USER32.GetClipboardFormatNameW,@1791") +#pragma comment(linker, "/export:GetClipboardOwner=USER32.GetClipboardOwner,@1792") +#pragma comment(linker, "/export:GetClipboardSequenceNumber=USER32.GetClipboardSequenceNumber,@1793") +#pragma comment(linker, "/export:GetClipboardViewer=USER32.GetClipboardViewer,@1794") +#pragma comment(linker, "/export:GetComboBoxInfo=USER32.GetComboBoxInfo,@1795") +#pragma comment(linker, "/export:GetCursor=USER32.GetCursor,@1796") +#pragma comment(linker, "/export:GetCursorFrameInfo=USER32.GetCursorFrameInfo,@1797") +#pragma comment(linker, "/export:GetCursorInfo=USER32.GetCursorInfo,@1798") +#pragma comment(linker, "/export:GetCursorPos=USER32.GetCursorPos,@1799") +#pragma comment(linker, "/export:GetDC=USER32.GetDC,@1800") +#pragma comment(linker, "/export:GetDCEx=USER32.GetDCEx,@1801") +#pragma comment(linker, "/export:GetDesktopWindow=USER32.GetDesktopWindow,@1802") +#pragma comment(linker, "/export:GetDialogBaseUnits=USER32.GetDialogBaseUnits,@1803") +#pragma comment(linker, "/export:GetDisplayConfigBufferSizes=USER32.GetDisplayConfigBufferSizes,@1804") +#pragma comment(linker, "/export:GetDlgCtrlID=USER32.GetDlgCtrlID,@1805") +#pragma comment(linker, "/export:GetDlgItem=USER32.GetDlgItem,@1806") +#pragma comment(linker, "/export:GetDlgItemInt=USER32.GetDlgItemInt,@1807") +#pragma comment(linker, "/export:GetDlgItemTextA=USER32.GetDlgItemTextA,@1808") +#pragma comment(linker, "/export:GetDlgItemTextW=USER32.GetDlgItemTextW,@1809") +#pragma comment(linker, "/export:GetDoubleClickTime=USER32.GetDoubleClickTime,@1810") +#pragma comment(linker, "/export:GetFocus=USER32.GetFocus,@1811") +#pragma comment(linker, "/export:GetForegroundWindow=USER32.GetForegroundWindow,@1812") +#pragma comment(linker, "/export:GetGUIThreadInfo=USER32.GetGUIThreadInfo,@1813") +#pragma comment(linker, "/export:GetGestureConfig=USER32.GetGestureConfig,@1814") +#pragma comment(linker, "/export:GetGestureExtraArgs=USER32.GetGestureExtraArgs,@1815") +#pragma comment(linker, "/export:GetGestureInfo=USER32.GetGestureInfo,@1816") +#pragma comment(linker, "/export:GetGuiResources=USER32.GetGuiResources,@1817") +#pragma comment(linker, "/export:GetIconInfo=USER32.GetIconInfo,@1818") +#pragma comment(linker, "/export:GetIconInfoExA=USER32.GetIconInfoExA,@1819") +#pragma comment(linker, "/export:GetIconInfoExW=USER32.GetIconInfoExW,@1820") +#pragma comment(linker, "/export:GetInputDesktop=USER32.GetInputDesktop,@1821") +#pragma comment(linker, "/export:GetInputLocaleInfo=USER32.GetInputLocaleInfo,@1822") +#pragma comment(linker, "/export:GetInputState=USER32.GetInputState,@1823") +#pragma comment(linker, "/export:GetInternalWindowPos=USER32.GetInternalWindowPos,@1824") +#pragma comment(linker, "/export:GetKBCodePage=USER32.GetKBCodePage,@1825") +#pragma comment(linker, "/export:GetKeyNameTextA=USER32.GetKeyNameTextA,@1826") +#pragma comment(linker, "/export:GetKeyNameTextW=USER32.GetKeyNameTextW,@1827") +#pragma comment(linker, "/export:GetKeyState=USER32.GetKeyState,@1828") +#pragma comment(linker, "/export:GetKeyboardLayout=USER32.GetKeyboardLayout,@1829") +#pragma comment(linker, "/export:GetKeyboardLayoutList=USER32.GetKeyboardLayoutList,@1830") +#pragma comment(linker, "/export:GetKeyboardLayoutNameA=USER32.GetKeyboardLayoutNameA,@1831") +#pragma comment(linker, "/export:GetKeyboardLayoutNameW=USER32.GetKeyboardLayoutNameW,@1832") +#pragma comment(linker, "/export:GetKeyboardState=USER32.GetKeyboardState,@1833") +#pragma comment(linker, "/export:GetKeyboardType=USER32.GetKeyboardType,@1834") +#pragma comment(linker, "/export:GetLastActivePopup=USER32.GetLastActivePopup,@1835") +#pragma comment(linker, "/export:GetLastInputInfo=USER32.GetLastInputInfo,@1836") +#pragma comment(linker, "/export:GetLayeredWindowAttributes=USER32.GetLayeredWindowAttributes,@1837") +#pragma comment(linker, "/export:GetListBoxInfo=USER32.GetListBoxInfo,@1838") +#pragma comment(linker, "/export:GetMagnificationDesktopColorEffect=USER32.GetMagnificationDesktopColorEffect,@1839") +#pragma comment(linker, "/export:GetMagnificationDesktopMagnification=USER32.GetMagnificationDesktopMagnification,@1840") +#pragma comment(linker, "/export:GetMagnificationLensCtxInformation=USER32.GetMagnificationLensCtxInformation,@1841") +#pragma comment(linker, "/export:GetMenu=USER32.GetMenu,@1842") +#pragma comment(linker, "/export:GetMenuBarInfo=USER32.GetMenuBarInfo,@1843") +#pragma comment(linker, "/export:GetMenuCheckMarkDimensions=USER32.GetMenuCheckMarkDimensions,@1844") +#pragma comment(linker, "/export:GetMenuContextHelpId=USER32.GetMenuContextHelpId,@1845") +#pragma comment(linker, "/export:GetMenuDefaultItem=USER32.GetMenuDefaultItem,@1846") +#pragma comment(linker, "/export:GetMenuInfo=USER32.GetMenuInfo,@1847") +#pragma comment(linker, "/export:GetMenuItemCount=USER32.GetMenuItemCount,@1848") +#pragma comment(linker, "/export:GetMenuItemID=USER32.GetMenuItemID,@1849") +#pragma comment(linker, "/export:GetMenuItemInfoA=USER32.GetMenuItemInfoA,@1850") +#pragma comment(linker, "/export:GetMenuItemInfoW=USER32.GetMenuItemInfoW,@1851") +#pragma comment(linker, "/export:GetMenuItemRect=USER32.GetMenuItemRect,@1852") +#pragma comment(linker, "/export:GetMenuState=USER32.GetMenuState,@1853") +#pragma comment(linker, "/export:GetMenuStringA=USER32.GetMenuStringA,@1854") +#pragma comment(linker, "/export:GetMenuStringW=USER32.GetMenuStringW,@1855") +#pragma comment(linker, "/export:GetMessageA=USER32.GetMessageA,@1856") +#pragma comment(linker, "/export:GetMessageExtraInfo=USER32.GetMessageExtraInfo,@1857") +#pragma comment(linker, "/export:GetMessagePos=USER32.GetMessagePos,@1858") +#pragma comment(linker, "/export:GetMessageTime=USER32.GetMessageTime,@1859") +#pragma comment(linker, "/export:GetMessageW=USER32.GetMessageW,@1860") +#pragma comment(linker, "/export:GetMonitorInfoA=USER32.GetMonitorInfoA,@1861") +#pragma comment(linker, "/export:GetMonitorInfoW=USER32.GetMonitorInfoW,@1862") +#pragma comment(linker, "/export:GetMouseMovePointsEx=USER32.GetMouseMovePointsEx,@1863") +#pragma comment(linker, "/export:GetNextDlgGroupItem=USER32.GetNextDlgGroupItem,@1864") +#pragma comment(linker, "/export:GetNextDlgTabItem=USER32.GetNextDlgTabItem,@1865") +#pragma comment(linker, "/export:GetOpenClipboardWindow=USER32.GetOpenClipboardWindow,@1866") +#pragma comment(linker, "/export:GetParent=USER32.GetParent,@1867") +#pragma comment(linker, "/export:GetPhysicalCursorPos=USER32.GetPhysicalCursorPos,@1868") +#pragma comment(linker, "/export:GetPriorityClipboardFormat=USER32.GetPriorityClipboardFormat,@1869") +#pragma comment(linker, "/export:GetProcessDefaultLayout=USER32.GetProcessDefaultLayout,@1870") +#pragma comment(linker, "/export:GetProcessWindowStation=USER32.GetProcessWindowStation,@1871") +#pragma comment(linker, "/export:GetProgmanWindow=USER32.GetProgmanWindow,@1872") +#pragma comment(linker, "/export:GetPropA=USER32.GetPropA,@1873") +#pragma comment(linker, "/export:GetPropW=USER32.GetPropW,@1874") +#pragma comment(linker, "/export:GetQueueStatus=USER32.GetQueueStatus,@1875") +#pragma comment(linker, "/export:GetRawInputBuffer=USER32.GetRawInputBuffer,@1876") +#pragma comment(linker, "/export:GetRawInputData=USER32.GetRawInputData,@1877") +#pragma comment(linker, "/export:GetRawInputDeviceInfoA=USER32.GetRawInputDeviceInfoA,@1878") +#pragma comment(linker, "/export:GetRawInputDeviceInfoW=USER32.GetRawInputDeviceInfoW,@1879") +#pragma comment(linker, "/export:GetRawInputDeviceList=USER32.GetRawInputDeviceList,@1880") +#pragma comment(linker, "/export:GetReasonTitleFromReasonCode=USER32.GetReasonTitleFromReasonCode,@1881") +#pragma comment(linker, "/export:GetRegisteredRawInputDevices=USER32.GetRegisteredRawInputDevices,@1882") +#pragma comment(linker, "/export:GetScrollBarInfo=USER32.GetScrollBarInfo,@1883") +#pragma comment(linker, "/export:GetScrollInfo=USER32.GetScrollInfo,@1884") +#pragma comment(linker, "/export:GetScrollPos=USER32.GetScrollPos,@1885") +#pragma comment(linker, "/export:GetScrollRange=USER32.GetScrollRange,@1886") +#pragma comment(linker, "/export:GetSendMessageReceiver=USER32.GetSendMessageReceiver,@1887") +#pragma comment(linker, "/export:GetShellWindow=USER32.GetShellWindow,@1888") +#pragma comment(linker, "/export:GetSubMenu=USER32.GetSubMenu,@1889") +#pragma comment(linker, "/export:GetSysColor=USER32.GetSysColor,@1890") +#pragma comment(linker, "/export:GetSysColorBrush=USER32.GetSysColorBrush,@1891") +#pragma comment(linker, "/export:GetSystemMenu=USER32.GetSystemMenu,@1892") +#pragma comment(linker, "/export:GetSystemMetrics=USER32.GetSystemMetrics,@1893") +#pragma comment(linker, "/export:GetTabbedTextExtentA=USER32.GetTabbedTextExtentA,@1894") +#pragma comment(linker, "/export:GetTabbedTextExtentW=USER32.GetTabbedTextExtentW,@1895") +#pragma comment(linker, "/export:GetTaskmanWindow=USER32.GetTaskmanWindow,@1896") +#pragma comment(linker, "/export:GetThreadDesktop=USER32.GetThreadDesktop,@1897") +#pragma comment(linker, "/export:GetTitleBarInfo=USER32.GetTitleBarInfo,@1898") +#pragma comment(linker, "/export:GetTopLevelWindow=USER32.GetTopLevelWindow,@1899") +#pragma comment(linker, "/export:GetTopWindow=USER32.GetTopWindow,@1900") +#pragma comment(linker, "/export:GetTouchInputInfo=USER32.GetTouchInputInfo,@1901") +#pragma comment(linker, "/export:GetUpdateRect=USER32.GetUpdateRect,@1902") +#pragma comment(linker, "/export:GetUpdateRgn=USER32.GetUpdateRgn,@1903") +#pragma comment(linker, "/export:GetUpdatedClipboardFormats=USER32.GetUpdatedClipboardFormats,@1904") +#pragma comment(linker, "/export:GetUserObjectInformationA=USER32.GetUserObjectInformationA,@1905") +#pragma comment(linker, "/export:GetUserObjectInformationW=USER32.GetUserObjectInformationW,@1906") +#pragma comment(linker, "/export:GetUserObjectSecurity=USER32.GetUserObjectSecurity,@1907") +#pragma comment(linker, "/export:GetWinStationInfo=USER32.GetWinStationInfo,@1908") +#pragma comment(linker, "/export:GetWindow=USER32.GetWindow,@1909") +#pragma comment(linker, "/export:GetWindowCompositionAttribute=USER32.GetWindowCompositionAttribute,@1910") +#pragma comment(linker, "/export:GetWindowCompositionInfo=USER32.GetWindowCompositionInfo,@1911") +#pragma comment(linker, "/export:GetWindowContextHelpId=USER32.GetWindowContextHelpId,@1912") +#pragma comment(linker, "/export:GetWindowDC=USER32.GetWindowDC,@1913") +#pragma comment(linker, "/export:GetWindowDisplayAffinity=USER32.GetWindowDisplayAffinity,@1914") +#pragma comment(linker, "/export:GetWindowInfo=USER32.GetWindowInfo,@1915") +#pragma comment(linker, "/export:GetWindowLongA=USER32.GetWindowLongA,@1916") +#pragma comment(linker, "/export:GetWindowLongPtrA=USER32.GetWindowLongPtrA,@1917") +#pragma comment(linker, "/export:GetWindowLongPtrW=USER32.GetWindowLongPtrW,@1918") +#pragma comment(linker, "/export:GetWindowLongW=USER32.GetWindowLongW,@1919") +#pragma comment(linker, "/export:GetWindowMinimizeRect=USER32.GetWindowMinimizeRect,@1920") +#pragma comment(linker, "/export:GetWindowModuleFileName=USER32.GetWindowModuleFileName,@1921") +#pragma comment(linker, "/export:GetWindowModuleFileNameA=USER32.GetWindowModuleFileNameA,@1922") +#pragma comment(linker, "/export:GetWindowModuleFileNameW=USER32.GetWindowModuleFileNameW,@1923") +#pragma comment(linker, "/export:GetWindowPlacement=USER32.GetWindowPlacement,@1924") +#pragma comment(linker, "/export:GetWindowRect=USER32.GetWindowRect,@1925") +#pragma comment(linker, "/export:GetWindowRgn=USER32.GetWindowRgn,@1926") +#pragma comment(linker, "/export:GetWindowRgnBox=USER32.GetWindowRgnBox,@1927") +#pragma comment(linker, "/export:GetWindowRgnEx=USER32.GetWindowRgnEx,@1928") +#pragma comment(linker, "/export:GetWindowTextA=USER32.GetWindowTextA,@1929") +#pragma comment(linker, "/export:GetWindowTextLengthA=USER32.GetWindowTextLengthA,@1930") +#pragma comment(linker, "/export:GetWindowTextLengthW=USER32.GetWindowTextLengthW,@1931") +#pragma comment(linker, "/export:GetWindowTextW=USER32.GetWindowTextW,@1932") +#pragma comment(linker, "/export:GetWindowThreadProcessId=USER32.GetWindowThreadProcessId,@1933") +#pragma comment(linker, "/export:GetWindowWord=USER32.GetWindowWord,@1934") +#pragma comment(linker, "/export:GhostWindowFromHungWindow=USER32.GhostWindowFromHungWindow,@1935") +#pragma comment(linker, "/export:GrayStringA=USER32.GrayStringA,@1936") +#pragma comment(linker, "/export:GrayStringW=USER32.GrayStringW,@1937") +#pragma comment(linker, "/export:HideCaret=USER32.HideCaret,@1938") +#pragma comment(linker, "/export:HiliteMenuItem=USER32.HiliteMenuItem,@1939") +#pragma comment(linker, "/export:HungWindowFromGhostWindow=USER32.HungWindowFromGhostWindow,@1940") +#pragma comment(linker, "/export:IMPGetIMEA=USER32.IMPGetIMEA,@1941") +#pragma comment(linker, "/export:IMPGetIMEW=USER32.IMPGetIMEW,@1942") +#pragma comment(linker, "/export:IMPQueryIMEA=USER32.IMPQueryIMEA,@1943") +#pragma comment(linker, "/export:IMPQueryIMEW=USER32.IMPQueryIMEW,@1944") +#pragma comment(linker, "/export:IMPSetIMEA=USER32.IMPSetIMEA,@1945") +#pragma comment(linker, "/export:IMPSetIMEW=USER32.IMPSetIMEW,@1946") +#pragma comment(linker, "/export:ImpersonateDdeClientWindow=USER32.ImpersonateDdeClientWindow,@1947") +#pragma comment(linker, "/export:InSendMessage=USER32.InSendMessage,@1948") +#pragma comment(linker, "/export:InSendMessageEx=USER32.InSendMessageEx,@1949") +#pragma comment(linker, "/export:InflateRect=USER32.InflateRect,@1950") +#pragma comment(linker, "/export:InitializeLpkHooks=USER32.InitializeLpkHooks,@1951") +#pragma comment(linker, "/export:InsertMenuA=USER32.InsertMenuA,@1952") +#pragma comment(linker, "/export:InsertMenuItemA=USER32.InsertMenuItemA,@1953") +#pragma comment(linker, "/export:InsertMenuItemW=USER32.InsertMenuItemW,@1954") +#pragma comment(linker, "/export:InsertMenuW=USER32.InsertMenuW,@1955") +#pragma comment(linker, "/export:InternalGetWindowIcon=USER32.InternalGetWindowIcon,@1956") +#pragma comment(linker, "/export:InternalGetWindowText=USER32.InternalGetWindowText,@1957") +#pragma comment(linker, "/export:IntersectRect=USER32.IntersectRect,@1958") +#pragma comment(linker, "/export:InvalidateRect=USER32.InvalidateRect,@1959") +#pragma comment(linker, "/export:InvalidateRgn=USER32.InvalidateRgn,@1960") +#pragma comment(linker, "/export:InvertRect=USER32.InvertRect,@1961") +#pragma comment(linker, "/export:IsCharAlphaA=USER32.IsCharAlphaA,@1962") +#pragma comment(linker, "/export:IsCharAlphaNumericA=USER32.IsCharAlphaNumericA,@1963") +#pragma comment(linker, "/export:IsCharAlphaNumericW=USER32.IsCharAlphaNumericW,@1964") +#pragma comment(linker, "/export:IsCharAlphaW=USER32.IsCharAlphaW,@1965") +#pragma comment(linker, "/export:IsCharLowerA=USER32.IsCharLowerA,@1966") +#pragma comment(linker, "/export:IsCharLowerW=USER32.IsCharLowerW,@1967") +#pragma comment(linker, "/export:IsCharUpperA=USER32.IsCharUpperA,@1968") +#pragma comment(linker, "/export:IsCharUpperW=USER32.IsCharUpperW,@1969") +#pragma comment(linker, "/export:IsChild=USER32.IsChild,@1970") +#pragma comment(linker, "/export:IsClipboardFormatAvailable=USER32.IsClipboardFormatAvailable,@1971") +#pragma comment(linker, "/export:IsDialogMessage=USER32.IsDialogMessage,@1972") +#pragma comment(linker, "/export:IsDialogMessageA=USER32.IsDialogMessageA,@1973") +#pragma comment(linker, "/export:IsDialogMessageW=USER32.IsDialogMessageW,@1974") +#pragma comment(linker, "/export:IsDlgButtonChecked=USER32.IsDlgButtonChecked,@1975") +#pragma comment(linker, "/export:IsGUIThread=USER32.IsGUIThread,@1976") +#pragma comment(linker, "/export:IsHungAppWindow=USER32.IsHungAppWindow,@1977") +#pragma comment(linker, "/export:IsIconic=USER32.IsIconic,@1978") +#pragma comment(linker, "/export:IsMenu=USER32.IsMenu,@1979") +#pragma comment(linker, "/export:IsProcessDPIAware=USER32.IsProcessDPIAware,@1980") +#pragma comment(linker, "/export:IsRectEmpty=USER32.IsRectEmpty,@1981") +#pragma comment(linker, "/export:IsSETEnabled=USER32.IsSETEnabled,@1982") +#pragma comment(linker, "/export:IsServerSideWindow=USER32.IsServerSideWindow,@1983") +#pragma comment(linker, "/export:IsThreadDesktopComposited=USER32.IsThreadDesktopComposited,@1984") +#pragma comment(linker, "/export:IsTopLevelWindow=USER32.IsTopLevelWindow,@1985") +#pragma comment(linker, "/export:IsTouchWindow=USER32.IsTouchWindow,@1986") +#pragma comment(linker, "/export:IsWinEventHookInstalled=USER32.IsWinEventHookInstalled,@1987") +#pragma comment(linker, "/export:IsWindow=USER32.IsWindow,@1988") +#pragma comment(linker, "/export:IsWindowEnabled=USER32.IsWindowEnabled,@1989") +#pragma comment(linker, "/export:IsWindowInDestroy=USER32.IsWindowInDestroy,@1990") +#pragma comment(linker, "/export:IsWindowRedirectedForPrint=USER32.IsWindowRedirectedForPrint,@1991") +#pragma comment(linker, "/export:IsWindowUnicode=USER32.IsWindowUnicode,@1992") +#pragma comment(linker, "/export:IsWindowVisible=USER32.IsWindowVisible,@1993") +#pragma comment(linker, "/export:IsWow64Message=USER32.IsWow64Message,@1994") +#pragma comment(linker, "/export:IsZoomed=USER32.IsZoomed,@1995") +#pragma comment(linker, "/export:KillTimer=USER32.KillTimer,@1996") +#pragma comment(linker, "/export:LoadAcceleratorsA=USER32.LoadAcceleratorsA,@1997") +#pragma comment(linker, "/export:LoadAcceleratorsW=USER32.LoadAcceleratorsW,@1998") +#pragma comment(linker, "/export:LoadBitmapA=USER32.LoadBitmapA,@1999") +#pragma comment(linker, "/export:LoadBitmapW=USER32.LoadBitmapW,@2003") +#pragma comment(linker, "/export:LoadCursorA=USER32.LoadCursorA,@2004") +#pragma comment(linker, "/export:LoadCursorFromFileA=USER32.LoadCursorFromFileA,@2006") +#pragma comment(linker, "/export:LoadCursorFromFileW=USER32.LoadCursorFromFileW,@2007") +#pragma comment(linker, "/export:LoadCursorW=USER32.LoadCursorW,@2008") +#pragma comment(linker, "/export:LoadIconA=USER32.LoadIconA,@2009") +#pragma comment(linker, "/export:LoadIconW=USER32.LoadIconW,@2010") +#pragma comment(linker, "/export:LoadImageA=USER32.LoadImageA,@2011") +#pragma comment(linker, "/export:LoadImageW=USER32.LoadImageW,@2012") +#pragma comment(linker, "/export:LoadKeyboardLayoutA=USER32.LoadKeyboardLayoutA,@2013") +#pragma comment(linker, "/export:LoadKeyboardLayoutEx=USER32.LoadKeyboardLayoutEx,@2014") +#pragma comment(linker, "/export:LoadKeyboardLayoutW=USER32.LoadKeyboardLayoutW,@2015") +#pragma comment(linker, "/export:LoadLocalFonts=USER32.LoadLocalFonts,@2016") +#pragma comment(linker, "/export:LoadMenuA=USER32.LoadMenuA,@2017") +#pragma comment(linker, "/export:LoadMenuIndirectA=USER32.LoadMenuIndirectA,@2018") +#pragma comment(linker, "/export:LoadMenuIndirectW=USER32.LoadMenuIndirectW,@2019") +#pragma comment(linker, "/export:LoadMenuW=USER32.LoadMenuW,@2020") +#pragma comment(linker, "/export:LoadRemoteFonts=USER32.LoadRemoteFonts,@2021") +#pragma comment(linker, "/export:LoadStringA=USER32.LoadStringA,@2022") +#pragma comment(linker, "/export:LoadStringW=USER32.LoadStringW,@2023") +#pragma comment(linker, "/export:LockSetForegroundWindow=USER32.LockSetForegroundWindow,@2024") +#pragma comment(linker, "/export:LockWindowStation=USER32.LockWindowStation,@2025") +#pragma comment(linker, "/export:LockWindowUpdate=USER32.LockWindowUpdate,@2026") +#pragma comment(linker, "/export:LockWorkStation=USER32.LockWorkStation,@2027") +#pragma comment(linker, "/export:LogicalToPhysicalPoint=USER32.LogicalToPhysicalPoint,@2028") +#pragma comment(linker, "/export:LookupIconIdFromDirectory=USER32.LookupIconIdFromDirectory,@2029") +#pragma comment(linker, "/export:LookupIconIdFromDirectoryEx=USER32.LookupIconIdFromDirectoryEx,@2030") +#pragma comment(linker, "/export:MBToWCSEx=USER32.MBToWCSEx,@2031") +#pragma comment(linker, "/export:MB_GetString=USER32.MB_GetString,@2032") +#pragma comment(linker, "/export:MapDialogRect=USER32.MapDialogRect,@2033") +#pragma comment(linker, "/export:MapVirtualKeyA=USER32.MapVirtualKeyA,@2034") +#pragma comment(linker, "/export:MapVirtualKeyExA=USER32.MapVirtualKeyExA,@2035") +#pragma comment(linker, "/export:MapVirtualKeyExW=USER32.MapVirtualKeyExW,@2036") +#pragma comment(linker, "/export:MapVirtualKeyW=USER32.MapVirtualKeyW,@2037") +#pragma comment(linker, "/export:MapWindowPoints=USER32.MapWindowPoints,@2038") +#pragma comment(linker, "/export:MenuItemFromPoint=USER32.MenuItemFromPoint,@2039") +#pragma comment(linker, "/export:MenuWindowProcA=USER32.MenuWindowProcA,@2040") +#pragma comment(linker, "/export:MenuWindowProcW=USER32.MenuWindowProcW,@2041") +#pragma comment(linker, "/export:MessageBeep=USER32.MessageBeep,@2042") +#pragma comment(linker, "/export:MessageBoxA=USER32.MessageBoxA,@2043") +#pragma comment(linker, "/export:MessageBoxExA=USER32.MessageBoxExA,@2044") +#pragma comment(linker, "/export:MessageBoxExW=USER32.MessageBoxExW,@2045") +#pragma comment(linker, "/export:MessageBoxIndirectA=USER32.MessageBoxIndirectA,@2046") +#pragma comment(linker, "/export:MessageBoxIndirectW=USER32.MessageBoxIndirectW,@2047") +#pragma comment(linker, "/export:MessageBoxTimeoutA=USER32.MessageBoxTimeoutA,@2048") +#pragma comment(linker, "/export:MessageBoxTimeoutW=USER32.MessageBoxTimeoutW,@2049") +#pragma comment(linker, "/export:MessageBoxW=USER32.MessageBoxW,@2050") +#pragma comment(linker, "/export:ModifyMenuA=USER32.ModifyMenuA,@2051") +#pragma comment(linker, "/export:ModifyMenuW=USER32.ModifyMenuW,@2052") +#pragma comment(linker, "/export:MonitorFromPoint=USER32.MonitorFromPoint,@2053") +#pragma comment(linker, "/export:MonitorFromRect=USER32.MonitorFromRect,@2054") +#pragma comment(linker, "/export:MonitorFromWindow=USER32.MonitorFromWindow,@2055") +#pragma comment(linker, "/export:MoveWindow=USER32.MoveWindow,@2056") +#pragma comment(linker, "/export:MsgWaitForMultipleObjects=USER32.MsgWaitForMultipleObjects,@2057") +#pragma comment(linker, "/export:MsgWaitForMultipleObjectsEx=USER32.MsgWaitForMultipleObjectsEx,@2058") +#pragma comment(linker, "/export:NotifyOverlayWindow=USER32.NotifyOverlayWindow,@2059") +#pragma comment(linker, "/export:NotifyWinEvent=USER32.NotifyWinEvent,@2060") +#pragma comment(linker, "/export:OemKeyScan=USER32.OemKeyScan,@2061") +#pragma comment(linker, "/export:OemToCharA=USER32.OemToCharA,@2062") +#pragma comment(linker, "/export:OemToCharBuffA=USER32.OemToCharBuffA,@2063") +#pragma comment(linker, "/export:OemToCharBuffW=USER32.OemToCharBuffW,@2064") +#pragma comment(linker, "/export:OemToCharW=USER32.OemToCharW,@2065") +#pragma comment(linker, "/export:OffsetRect=USER32.OffsetRect,@2066") +#pragma comment(linker, "/export:OpenClipboard=USER32.OpenClipboard,@2067") +#pragma comment(linker, "/export:OpenDesktopA=USER32.OpenDesktopA,@2068") +#pragma comment(linker, "/export:OpenDesktopW=USER32.OpenDesktopW,@2069") +#pragma comment(linker, "/export:OpenIcon=USER32.OpenIcon,@2070") +#pragma comment(linker, "/export:OpenInputDesktop=USER32.OpenInputDesktop,@2071") +#pragma comment(linker, "/export:OpenThreadDesktop=USER32.OpenThreadDesktop,@2072") +#pragma comment(linker, "/export:OpenWindowStationA=USER32.OpenWindowStationA,@2073") +#pragma comment(linker, "/export:OpenWindowStationW=USER32.OpenWindowStationW,@2074") +#pragma comment(linker, "/export:PackDDElParam=USER32.PackDDElParam,@2075") +#pragma comment(linker, "/export:PaintDesktop=USER32.PaintDesktop,@2076") +#pragma comment(linker, "/export:PaintMenuBar=USER32.PaintMenuBar,@2077") +#pragma comment(linker, "/export:PaintMonitor=USER32.PaintMonitor,@2078") +#pragma comment(linker, "/export:PeekMessageA=USER32.PeekMessageA,@2079") +#pragma comment(linker, "/export:PeekMessageW=USER32.PeekMessageW,@2080") +#pragma comment(linker, "/export:PhysicalToLogicalPoint=USER32.PhysicalToLogicalPoint,@2081") +#pragma comment(linker, "/export:PostMessageA=USER32.PostMessageA,@2082") +#pragma comment(linker, "/export:PostMessageW=USER32.PostMessageW,@2083") +#pragma comment(linker, "/export:PostQuitMessage=USER32.PostQuitMessage,@2084") +#pragma comment(linker, "/export:PostThreadMessageA=USER32.PostThreadMessageA,@2085") +#pragma comment(linker, "/export:PostThreadMessageW=USER32.PostThreadMessageW,@2086") +#pragma comment(linker, "/export:PrintWindow=USER32.PrintWindow,@2087") +#pragma comment(linker, "/export:PrivateExtractIconExA=USER32.PrivateExtractIconExA,@2088") +#pragma comment(linker, "/export:PrivateExtractIconExW=USER32.PrivateExtractIconExW,@2089") +#pragma comment(linker, "/export:PrivateExtractIconsA=USER32.PrivateExtractIconsA,@2090") +#pragma comment(linker, "/export:PrivateExtractIconsW=USER32.PrivateExtractIconsW,@2091") +#pragma comment(linker, "/export:PrivateRegisterICSProc=USER32.PrivateRegisterICSProc,@2092") +#pragma comment(linker, "/export:PtInRect=USER32.PtInRect,@2093") +#pragma comment(linker, "/export:QueryDisplayConfig=USER32.QueryDisplayConfig,@2094") +#pragma comment(linker, "/export:QuerySendMessage=USER32.QuerySendMessage,@2095") +#pragma comment(linker, "/export:RealChildWindowFromPoint=USER32.RealChildWindowFromPoint,@2096") +#pragma comment(linker, "/export:RealGetWindowClass=USER32.RealGetWindowClass,@2097") +#pragma comment(linker, "/export:RealGetWindowClassA=USER32.RealGetWindowClassA,@2098") +#pragma comment(linker, "/export:RealGetWindowClassW=USER32.RealGetWindowClassW,@2099") +#pragma comment(linker, "/export:ReasonCodeNeedsBugID=USER32.ReasonCodeNeedsBugID,@2100") +#pragma comment(linker, "/export:ReasonCodeNeedsComment=USER32.ReasonCodeNeedsComment,@2101") +#pragma comment(linker, "/export:RecordShutdownReason=USER32.RecordShutdownReason,@2102") +#pragma comment(linker, "/export:RedrawWindow=USER32.RedrawWindow,@2103") +#pragma comment(linker, "/export:RegisterClassA=USER32.RegisterClassA,@2104") +#pragma comment(linker, "/export:RegisterClassExA=USER32.RegisterClassExA,@2105") +#pragma comment(linker, "/export:RegisterClassExW=USER32.RegisterClassExW,@2106") +#pragma comment(linker, "/export:RegisterClassW=USER32.RegisterClassW,@2107") +#pragma comment(linker, "/export:RegisterClipboardFormatA=USER32.RegisterClipboardFormatA,@2108") +#pragma comment(linker, "/export:RegisterClipboardFormatW=USER32.RegisterClipboardFormatW,@2109") +#pragma comment(linker, "/export:RegisterDeviceNotificationA=USER32.RegisterDeviceNotificationA,@2110") +#pragma comment(linker, "/export:RegisterDeviceNotificationW=USER32.RegisterDeviceNotificationW,@2111") +#pragma comment(linker, "/export:RegisterErrorReportingDialog=USER32.RegisterErrorReportingDialog,@2112") +#pragma comment(linker, "/export:RegisterFrostWindow=USER32.RegisterFrostWindow,@2113") +#pragma comment(linker, "/export:RegisterGhostWindow=USER32.RegisterGhostWindow,@2114") +#pragma comment(linker, "/export:RegisterHotKey=USER32.RegisterHotKey,@2115") +#pragma comment(linker, "/export:RegisterLogonProcess=USER32.RegisterLogonProcess,@2116") +#pragma comment(linker, "/export:RegisterMessagePumpHook=USER32.RegisterMessagePumpHook,@2117") +#pragma comment(linker, "/export:RegisterPowerSettingNotification=USER32.RegisterPowerSettingNotification,@2118") +#pragma comment(linker, "/export:RegisterRawInputDevices=USER32.RegisterRawInputDevices,@2119") +#pragma comment(linker, "/export:RegisterServicesProcess=USER32.RegisterServicesProcess,@2120") +#pragma comment(linker, "/export:RegisterSessionPort=USER32.RegisterSessionPort,@2121") +#pragma comment(linker, "/export:RegisterShellHookWindow=USER32.RegisterShellHookWindow,@2122") +#pragma comment(linker, "/export:RegisterSystemThread=USER32.RegisterSystemThread,@2123") +#pragma comment(linker, "/export:RegisterTasklist=USER32.RegisterTasklist,@2124") +#pragma comment(linker, "/export:RegisterTouchWindow=USER32.RegisterTouchWindow,@2125") +#pragma comment(linker, "/export:RegisterUserApiHook=USER32.RegisterUserApiHook,@2126") +#pragma comment(linker, "/export:RegisterWindowMessageA=USER32.RegisterWindowMessageA,@2127") +#pragma comment(linker, "/export:RegisterWindowMessageW=USER32.RegisterWindowMessageW,@2128") +#pragma comment(linker, "/export:ReleaseCapture=USER32.ReleaseCapture,@2129") +#pragma comment(linker, "/export:ReleaseDC=USER32.ReleaseDC,@2130") +#pragma comment(linker, "/export:RemoveClipboardFormatListener=USER32.RemoveClipboardFormatListener,@2131") +#pragma comment(linker, "/export:RemoveMenu=USER32.RemoveMenu,@2132") +#pragma comment(linker, "/export:RemovePropA=USER32.RemovePropA,@2133") +#pragma comment(linker, "/export:RemovePropW=USER32.RemovePropW,@2134") +#pragma comment(linker, "/export:ReplyMessage=USER32.ReplyMessage,@2135") +#pragma comment(linker, "/export:ResolveDesktopForWOW=USER32.ResolveDesktopForWOW,@2136") +#pragma comment(linker, "/export:ReuseDDElParam=USER32.ReuseDDElParam,@2137") +#pragma comment(linker, "/export:ScreenToClient=USER32.ScreenToClient,@2138") +#pragma comment(linker, "/export:ScrollChildren=USER32.ScrollChildren,@2139") +#pragma comment(linker, "/export:ScrollDC=USER32.ScrollDC,@2140") +#pragma comment(linker, "/export:ScrollWindow=USER32.ScrollWindow,@2141") +#pragma comment(linker, "/export:ScrollWindowEx=USER32.ScrollWindowEx,@2142") +#pragma comment(linker, "/export:SendDlgItemMessageA=USER32.SendDlgItemMessageA,@2143") +#pragma comment(linker, "/export:SendDlgItemMessageW=USER32.SendDlgItemMessageW,@2144") +#pragma comment(linker, "/export:SendIMEMessageExA=USER32.SendIMEMessageExA,@2145") +#pragma comment(linker, "/export:SendIMEMessageExW=USER32.SendIMEMessageExW,@2146") +#pragma comment(linker, "/export:SendInput=USER32.SendInput,@2147") +#pragma comment(linker, "/export:SendMessageA=USER32.SendMessageA,@2148") +#pragma comment(linker, "/export:SendMessageCallbackA=USER32.SendMessageCallbackA,@2149") +#pragma comment(linker, "/export:SendMessageCallbackW=USER32.SendMessageCallbackW,@2150") +#pragma comment(linker, "/export:SendMessageTimeoutA=USER32.SendMessageTimeoutA,@2151") +#pragma comment(linker, "/export:SendMessageTimeoutW=USER32.SendMessageTimeoutW,@2152") +#pragma comment(linker, "/export:SendMessageW=USER32.SendMessageW,@2153") +#pragma comment(linker, "/export:SendNotifyMessageA=USER32.SendNotifyMessageA,@2154") +#pragma comment(linker, "/export:SendNotifyMessageW=USER32.SendNotifyMessageW,@2155") +#pragma comment(linker, "/export:SetActiveWindow=USER32.SetActiveWindow,@2156") +#pragma comment(linker, "/export:SetCapture=USER32.SetCapture,@2157") +#pragma comment(linker, "/export:SetCaretBlinkTime=USER32.SetCaretBlinkTime,@2158") +#pragma comment(linker, "/export:SetCaretPos=USER32.SetCaretPos,@2159") +#pragma comment(linker, "/export:SetClassLongA=USER32.SetClassLongA,@2160") +#pragma comment(linker, "/export:SetClassLongPtrA=USER32.SetClassLongPtrA,@2161") +#pragma comment(linker, "/export:SetClassLongPtrW=USER32.SetClassLongPtrW,@2162") +#pragma comment(linker, "/export:SetClassLongW=USER32.SetClassLongW,@2163") +#pragma comment(linker, "/export:SetClassWord=USER32.SetClassWord,@2164") +#pragma comment(linker, "/export:SetClipboardData=USER32.SetClipboardData,@2165") +#pragma comment(linker, "/export:SetClipboardViewer=USER32.SetClipboardViewer,@2166") +#pragma comment(linker, "/export:SetCursor=USER32.SetCursor,@2167") +#pragma comment(linker, "/export:SetCursorContents=USER32.SetCursorContents,@2168") +#pragma comment(linker, "/export:SetCursorPos=USER32.SetCursorPos,@2169") +#pragma comment(linker, "/export:SetDebugErrorLevel=USER32.SetDebugErrorLevel,@2170") +#pragma comment(linker, "/export:SetDeskWallpaper=USER32.SetDeskWallpaper,@2171") +#pragma comment(linker, "/export:SetDisplayConfig=USER32.SetDisplayConfig,@2172") +#pragma comment(linker, "/export:SetDlgItemInt=USER32.SetDlgItemInt,@2173") +#pragma comment(linker, "/export:SetDlgItemTextA=USER32.SetDlgItemTextA,@2174") +#pragma comment(linker, "/export:SetDlgItemTextW=USER32.SetDlgItemTextW,@2175") +#pragma comment(linker, "/export:SetDoubleClickTime=USER32.SetDoubleClickTime,@2176") +#pragma comment(linker, "/export:SetFocus=USER32.SetFocus,@2177") +#pragma comment(linker, "/export:SetForegroundWindow=USER32.SetForegroundWindow,@2178") +#pragma comment(linker, "/export:SetGestureConfig=USER32.SetGestureConfig,@2179") +#pragma comment(linker, "/export:SetInternalWindowPos=USER32.SetInternalWindowPos,@2180") +#pragma comment(linker, "/export:SetKeyboardState=USER32.SetKeyboardState,@2181") +#pragma comment(linker, "/export:SetLastErrorEx=USER32.SetLastErrorEx,@2182") +#pragma comment(linker, "/export:SetLayeredWindowAttributes=USER32.SetLayeredWindowAttributes,@2183") +#pragma comment(linker, "/export:SetMagnificationDesktopColorEffect=USER32.SetMagnificationDesktopColorEffect,@2184") +#pragma comment(linker, "/export:SetMagnificationDesktopMagnification=USER32.SetMagnificationDesktopMagnification,@2185") +#pragma comment(linker, "/export:SetMagnificationLensCtxInformation=USER32.SetMagnificationLensCtxInformation,@2186") +#pragma comment(linker, "/export:SetMenu=USER32.SetMenu,@2187") +#pragma comment(linker, "/export:SetMenuContextHelpId=USER32.SetMenuContextHelpId,@2188") +#pragma comment(linker, "/export:SetMenuDefaultItem=USER32.SetMenuDefaultItem,@2189") +#pragma comment(linker, "/export:SetMenuInfo=USER32.SetMenuInfo,@2190") +#pragma comment(linker, "/export:SetMenuItemBitmaps=USER32.SetMenuItemBitmaps,@2191") +#pragma comment(linker, "/export:SetMenuItemInfoA=USER32.SetMenuItemInfoA,@2192") +#pragma comment(linker, "/export:SetMenuItemInfoW=USER32.SetMenuItemInfoW,@2193") +#pragma comment(linker, "/export:SetMessageExtraInfo=USER32.SetMessageExtraInfo,@2194") +#pragma comment(linker, "/export:SetMessageQueue=USER32.SetMessageQueue,@2195") +#pragma comment(linker, "/export:SetMirrorRendering=USER32.SetMirrorRendering,@2196") +#pragma comment(linker, "/export:SetParent=USER32.SetParent,@2197") +#pragma comment(linker, "/export:SetPhysicalCursorPos=USER32.SetPhysicalCursorPos,@2198") +#pragma comment(linker, "/export:SetProcessDPIAware=USER32.SetProcessDPIAware,@2199") +#pragma comment(linker, "/export:SetProcessDefaultLayout=USER32.SetProcessDefaultLayout,@2200") +#pragma comment(linker, "/export:SetProcessWindowStation=USER32.SetProcessWindowStation,@2201") +#pragma comment(linker, "/export:SetProgmanWindow=USER32.SetProgmanWindow,@2202") +#pragma comment(linker, "/export:SetPropA=USER32.SetPropA,@2203") +#pragma comment(linker, "/export:SetPropW=USER32.SetPropW,@2204") +#pragma comment(linker, "/export:SetRect=USER32.SetRect,@2205") +#pragma comment(linker, "/export:SetRectEmpty=USER32.SetRectEmpty,@2206") +#pragma comment(linker, "/export:SetScrollInfo=USER32.SetScrollInfo,@2207") +#pragma comment(linker, "/export:SetScrollPos=USER32.SetScrollPos,@2208") +#pragma comment(linker, "/export:SetScrollRange=USER32.SetScrollRange,@2209") +#pragma comment(linker, "/export:SetShellWindow=USER32.SetShellWindow,@2210") +#pragma comment(linker, "/export:SetShellWindowEx=USER32.SetShellWindowEx,@2211") +#pragma comment(linker, "/export:SetSysColors=USER32.SetSysColors,@2212") +#pragma comment(linker, "/export:SetSysColorsTemp=USER32.SetSysColorsTemp,@2213") +#pragma comment(linker, "/export:SetSystemCursor=USER32.SetSystemCursor,@2214") +#pragma comment(linker, "/export:SetSystemMenu=USER32.SetSystemMenu,@2215") +#pragma comment(linker, "/export:SetTaskmanWindow=USER32.SetTaskmanWindow,@2216") +#pragma comment(linker, "/export:SetThreadDesktop=USER32.SetThreadDesktop,@2217") +#pragma comment(linker, "/export:SetTimer=USER32.SetTimer,@2218") +#pragma comment(linker, "/export:SetUserObjectInformationA=USER32.SetUserObjectInformationA,@2219") +#pragma comment(linker, "/export:SetUserObjectInformationW=USER32.SetUserObjectInformationW,@2220") +#pragma comment(linker, "/export:SetUserObjectSecurity=USER32.SetUserObjectSecurity,@2221") +#pragma comment(linker, "/export:SetWinEventHook=USER32.SetWinEventHook,@2222") +#pragma comment(linker, "/export:SetWindowCompositionAttribute=USER32.SetWindowCompositionAttribute,@2223") +#pragma comment(linker, "/export:SetWindowContextHelpId=USER32.SetWindowContextHelpId,@2224") +#pragma comment(linker, "/export:SetWindowDisplayAffinity=USER32.SetWindowDisplayAffinity,@2225") +#pragma comment(linker, "/export:SetWindowLongA=USER32.SetWindowLongA,@2226") +#pragma comment(linker, "/export:SetWindowLongPtrA=USER32.SetWindowLongPtrA,@2227") +#pragma comment(linker, "/export:SetWindowLongPtrW=USER32.SetWindowLongPtrW,@2228") +#pragma comment(linker, "/export:SetWindowLongW=USER32.SetWindowLongW,@2229") +#pragma comment(linker, "/export:SetWindowPlacement=USER32.SetWindowPlacement,@2230") +#pragma comment(linker, "/export:SetWindowPos=USER32.SetWindowPos,@2231") +#pragma comment(linker, "/export:SetWindowRgn=USER32.SetWindowRgn,@2232") +#pragma comment(linker, "/export:SetWindowRgnEx=USER32.SetWindowRgnEx,@2233") +#pragma comment(linker, "/export:SetWindowStationUser=USER32.SetWindowStationUser,@2234") +#pragma comment(linker, "/export:SetWindowTextA=USER32.SetWindowTextA,@2235") +#pragma comment(linker, "/export:SetWindowTextW=USER32.SetWindowTextW,@2236") +#pragma comment(linker, "/export:SetWindowWord=USER32.SetWindowWord,@2237") +#pragma comment(linker, "/export:SetWindowsHookA=USER32.SetWindowsHookA,@2238") +#pragma comment(linker, "/export:SetWindowsHookExA=USER32.SetWindowsHookExA,@2239") +#pragma comment(linker, "/export:SetWindowsHookExW=USER32.SetWindowsHookExW,@2240") +#pragma comment(linker, "/export:SetWindowsHookW=USER32.SetWindowsHookW,@2241") +#pragma comment(linker, "/export:SfmDxBindSwapChain=USER32.SfmDxBindSwapChain,@2242") +#pragma comment(linker, "/export:SfmDxGetSwapChainStats=USER32.SfmDxGetSwapChainStats,@2243") +#pragma comment(linker, "/export:SfmDxOpenSwapChain=USER32.SfmDxOpenSwapChain,@2244") +#pragma comment(linker, "/export:SfmDxQuerySwapChainBindingStatus=USER32.SfmDxQuerySwapChainBindingStatus,@2245") +#pragma comment(linker, "/export:SfmDxReleaseSwapChain=USER32.SfmDxReleaseSwapChain,@2246") +#pragma comment(linker, "/export:SfmDxReportPendingBindingsToDwm=USER32.SfmDxReportPendingBindingsToDwm,@2247") +#pragma comment(linker, "/export:SfmDxSetSwapChainBindingStatus=USER32.SfmDxSetSwapChainBindingStatus,@2248") +#pragma comment(linker, "/export:SfmDxSetSwapChainStats=USER32.SfmDxSetSwapChainStats,@2249") +#pragma comment(linker, "/export:ShowCaret=USER32.ShowCaret,@2250") +#pragma comment(linker, "/export:ShowCursor=USER32.ShowCursor,@2251") +#pragma comment(linker, "/export:ShowOwnedPopups=USER32.ShowOwnedPopups,@2252") +#pragma comment(linker, "/export:ShowScrollBar=USER32.ShowScrollBar,@2253") +#pragma comment(linker, "/export:ShowStartGlass=USER32.ShowStartGlass,@2254") +#pragma comment(linker, "/export:ShowSystemCursor=USER32.ShowSystemCursor,@2255") +#pragma comment(linker, "/export:ShowWindow=USER32.ShowWindow,@2256") +#pragma comment(linker, "/export:ShowWindowAsync=USER32.ShowWindowAsync,@2257") +#pragma comment(linker, "/export:ShutdownBlockReasonCreate=USER32.ShutdownBlockReasonCreate,@2258") +#pragma comment(linker, "/export:ShutdownBlockReasonDestroy=USER32.ShutdownBlockReasonDestroy,@2259") +#pragma comment(linker, "/export:ShutdownBlockReasonQuery=USER32.ShutdownBlockReasonQuery,@2260") +#pragma comment(linker, "/export:SoftModalMessageBox=USER32.SoftModalMessageBox,@2261") +#pragma comment(linker, "/export:SoundSentry=USER32.SoundSentry,@2262") +#pragma comment(linker, "/export:SubtractRect=USER32.SubtractRect,@2263") +#pragma comment(linker, "/export:SwapMouseButton=USER32.SwapMouseButton,@2264") +#pragma comment(linker, "/export:SwitchDesktop=USER32.SwitchDesktop,@2265") +#pragma comment(linker, "/export:SwitchDesktopWithFade=USER32.SwitchDesktopWithFade,@2266") +#pragma comment(linker, "/export:SwitchToThisWindow=USER32.SwitchToThisWindow,@2267") +#pragma comment(linker, "/export:SystemParametersInfoA=USER32.SystemParametersInfoA,@2268") +#pragma comment(linker, "/export:SystemParametersInfoW=USER32.SystemParametersInfoW,@2269") +#pragma comment(linker, "/export:TabbedTextOutA=USER32.TabbedTextOutA,@2270") +#pragma comment(linker, "/export:TabbedTextOutW=USER32.TabbedTextOutW,@2271") +#pragma comment(linker, "/export:TileChildWindows=USER32.TileChildWindows,@2272") +#pragma comment(linker, "/export:TileWindows=USER32.TileWindows,@2273") +#pragma comment(linker, "/export:ToAscii=USER32.ToAscii,@2274") +#pragma comment(linker, "/export:ToAsciiEx=USER32.ToAsciiEx,@2275") +#pragma comment(linker, "/export:ToUnicode=USER32.ToUnicode,@2276") +#pragma comment(linker, "/export:ToUnicodeEx=USER32.ToUnicodeEx,@2277") +#pragma comment(linker, "/export:TrackMouseEvent=USER32.TrackMouseEvent,@2278") +#pragma comment(linker, "/export:TrackPopupMenu=USER32.TrackPopupMenu,@2279") +#pragma comment(linker, "/export:TrackPopupMenuEx=USER32.TrackPopupMenuEx,@2280") +#pragma comment(linker, "/export:TranslateAccelerator=USER32.TranslateAccelerator,@2281") +#pragma comment(linker, "/export:TranslateAcceleratorA=USER32.TranslateAcceleratorA,@2282") +#pragma comment(linker, "/export:TranslateAcceleratorW=USER32.TranslateAcceleratorW,@2283") +#pragma comment(linker, "/export:TranslateMDISysAccel=USER32.TranslateMDISysAccel,@2284") +#pragma comment(linker, "/export:TranslateMessage=USER32.TranslateMessage,@2285") +#pragma comment(linker, "/export:TranslateMessageEx=USER32.TranslateMessageEx,@2286") +#pragma comment(linker, "/export:UnhookWinEvent=USER32.UnhookWinEvent,@2287") +#pragma comment(linker, "/export:UnhookWindowsHook=USER32.UnhookWindowsHook,@2288") +#pragma comment(linker, "/export:UnhookWindowsHookEx=USER32.UnhookWindowsHookEx,@2289") +#pragma comment(linker, "/export:UnionRect=USER32.UnionRect,@2290") +#pragma comment(linker, "/export:UnloadKeyboardLayout=USER32.UnloadKeyboardLayout,@2291") +#pragma comment(linker, "/export:UnlockWindowStation=USER32.UnlockWindowStation,@2292") +#pragma comment(linker, "/export:UnpackDDElParam=USER32.UnpackDDElParam,@2293") +#pragma comment(linker, "/export:UnregisterClassA=USER32.UnregisterClassA,@2294") +#pragma comment(linker, "/export:UnregisterClassW=USER32.UnregisterClassW,@2295") +#pragma comment(linker, "/export:UnregisterDeviceNotification=USER32.UnregisterDeviceNotification,@2296") +#pragma comment(linker, "/export:UnregisterHotKey=USER32.UnregisterHotKey,@2297") +#pragma comment(linker, "/export:UnregisterMessagePumpHook=USER32.UnregisterMessagePumpHook,@2298") +#pragma comment(linker, "/export:UnregisterPowerSettingNotification=USER32.UnregisterPowerSettingNotification,@2299") +#pragma comment(linker, "/export:UnregisterSessionPort=USER32.UnregisterSessionPort,@2300") +#pragma comment(linker, "/export:UnregisterTouchWindow=USER32.UnregisterTouchWindow,@2301") +#pragma comment(linker, "/export:UnregisterUserApiHook=USER32.UnregisterUserApiHook,@2302") +#pragma comment(linker, "/export:UpdateLayeredWindow=USER32.UpdateLayeredWindow,@2303") +#pragma comment(linker, "/export:UpdateLayeredWindowIndirect=USER32.UpdateLayeredWindowIndirect,@2304") +#pragma comment(linker, "/export:UpdatePerUserSystemParameters=USER32.UpdatePerUserSystemParameters,@2305") +#pragma comment(linker, "/export:UpdateWindow=USER32.UpdateWindow,@2306") +#pragma comment(linker, "/export:UpdateWindowTransform=USER32.UpdateWindowTransform,@2307") +#pragma comment(linker, "/export:User32InitializeImmEntryTable=USER32.User32InitializeImmEntryTable,@2308") +#pragma comment(linker, "/export:UserClientDllInitialize=USER32.UserClientDllInitialize,@2309") +#pragma comment(linker, "/export:UserHandleGrantAccess=USER32.UserHandleGrantAccess,@2310") +#pragma comment(linker, "/export:UserLpkPSMTextOut=USER32.UserLpkPSMTextOut,@2311") +#pragma comment(linker, "/export:UserLpkTabbedTextOut=USER32.UserLpkTabbedTextOut,@2312") +#pragma comment(linker, "/export:UserRealizePalette=USER32.UserRealizePalette,@2313") +#pragma comment(linker, "/export:UserRegisterWowHandlers=USER32.UserRegisterWowHandlers,@2314") +#pragma comment(linker, "/export:VRipOutput=USER32.VRipOutput,@2315") +#pragma comment(linker, "/export:VTagOutput=USER32.VTagOutput,@2316") +#pragma comment(linker, "/export:ValidateRect=USER32.ValidateRect,@2317") +#pragma comment(linker, "/export:ValidateRgn=USER32.ValidateRgn,@2318") +#pragma comment(linker, "/export:VkKeyScanA=USER32.VkKeyScanA,@2319") +#pragma comment(linker, "/export:VkKeyScanExA=USER32.VkKeyScanExA,@2320") +#pragma comment(linker, "/export:VkKeyScanExW=USER32.VkKeyScanExW,@2321") +#pragma comment(linker, "/export:VkKeyScanW=USER32.VkKeyScanW,@2322") +#pragma comment(linker, "/export:WCSToMBEx=USER32.WCSToMBEx,@2323") +#pragma comment(linker, "/export:WINNLSEnableIME=USER32.WINNLSEnableIME,@2324") +#pragma comment(linker, "/export:WINNLSGetEnableStatus=USER32.WINNLSGetEnableStatus,@2325") +#pragma comment(linker, "/export:WINNLSGetIMEHotkey=USER32.WINNLSGetIMEHotkey,@2326") +#pragma comment(linker, "/export:WaitForInputIdle=USER32.WaitForInputIdle,@2327") +#pragma comment(linker, "/export:WaitMessage=USER32.WaitMessage,@2328") +#pragma comment(linker, "/export:WinHelpA=USER32.WinHelpA,@2329") +#pragma comment(linker, "/export:WinHelpW=USER32.WinHelpW,@2330") +#pragma comment(linker, "/export:WindowFromDC=USER32.WindowFromDC,@2331") +#pragma comment(linker, "/export:WindowFromPhysicalPoint=USER32.WindowFromPhysicalPoint,@2332") +#pragma comment(linker, "/export:WindowFromPoint=USER32.WindowFromPoint,@2333") +#pragma comment(linker, "/export:_UserTestTokenForInteractive=USER32._UserTestTokenForInteractive,@2334") +#pragma comment(linker, "/export:gSharedInfo=USER32.gSharedInfo,@2335") +#pragma comment(linker, "/export:gapfnScSendMessage=USER32.gapfnScSendMessage,@2336") +#pragma comment(linker, "/export:keybd_event=USER32.keybd_event,@2337") +#pragma comment(linker, "/export:mouse_event=USER32.mouse_event,@2338") +#pragma comment(linker, "/export:wsprintfA=USER32.wsprintfA,@2339") +#pragma comment(linker, "/export:wsprintfW=USER32.wsprintfW,@2340") +#pragma comment(linker, "/export:wvsprintfA=USER32.wvsprintfA,@2341") +#pragma comment(linker, "/export:wvsprintfW=USER32.wvsprintfW,@2342") +#pragma comment(linker, "/export:__OrdinalFunction5DC=USER32.#1500,@1500,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction5DD=USER32.#1501,@1501,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction60E=USER32.#1550,@1550,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction60F=USER32.#1551,@1551,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction610=USER32.#1552,@1552,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction611=USER32.#1553,@1553,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction612=USER32.#1554,@1554,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction613=USER32.#1555,@1555,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction614=USER32.#1556,@1556,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction7D0=USER32.#2000,@2000,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction7D1=USER32.#2001,@2001,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction7D2=USER32.#2002,@2002,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction7D5=USER32.#2005,@2005,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction9C4=USER32.#2500,@2500,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction9C5=USER32.#2501,@2501,NONAME") +#pragma comment(linker, "/export:__OrdinalFunction9C6=USER32.#2502,@2502,NONAME") \ No newline at end of file diff --git a/user33/user33.c b/user33/user33.c new file mode 100644 index 0000000..b8afbea --- /dev/null +++ b/user33/user33.c @@ -0,0 +1,315 @@ +#include +#undef WINUSERAPI +#define WINUSERAPI __declspec(dllexport) +DECLARE_HANDLE(DPI_AWARENESS_CONTEXT); + +WINUSERAPI BOOL WINAPI AdjustWindowRectExForDpi( + IN OUT LPRECT lpRect, + IN DWORD dwStyle, + IN BOOL bMenu, + IN DWORD dwExStyle, + IN UINT dpi) +{ + return AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle); +} + +WINUSERAPI INT WINAPI GetSystemMetricsForDpi( + IN INT nIndex, + IN UINT dpi) +{ + return GetSystemMetrics(nIndex); +} + +#define DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ((DPI_AWARENESS_CONTEXT) -2) + +WINUSERAPI BOOL WINAPI SetProcessDpiAwarenessContext( + IN DPI_AWARENESS_CONTEXT value) +{ + if (value == DPI_AWARENESS_CONTEXT_SYSTEM_AWARE) { + return SetProcessDPIAware(); + } + + return TRUE; +} + +WINUSERAPI DPI_AWARENESS_CONTEXT WINAPI SetThreadDpiAwarenessContext( + IN DPI_AWARENESS_CONTEXT value) +{ + return value; +} + +WINUSERAPI UINT WINAPI GetDpiForSystem( + VOID) +{ + HDC hdcScreen = GetDC(NULL); + UINT uDpi = GetDeviceCaps(hdcScreen, LOGPIXELSX); + ReleaseDC(NULL, hdcScreen); + return uDpi; +} + +WINUSERAPI UINT WINAPI GetDpiForWindow( + IN HWND hWnd) +{ + return GetDpiForSystem(); +} + +// Coalescable timers are a power-saving feature. They reduce the timer precision +// in exchange for greater energy efficiency, since timers can be "coalesced" and +// batches of timers can be handled at once. This also means that we can just proxy +// it directly to SetTimer() without causing any big problems. +WINUSERAPI UINT_PTR WINAPI SetCoalescableTimer( + IN HWND hwnd, + IN UINT_PTR nIdEvent, + IN UINT uElapse, + IN TIMERPROC lpTimerFunc, + IN ULONG uToleranceDelay) +{ + return SetTimer(hwnd, nIdEvent, uElapse, lpTimerFunc); +} + +WINUSERAPI BOOL WINAPI EnableNonClientDpiScaling( + IN HWND hWnd) +{ + return TRUE; +} + +WINUSERAPI BOOL WINAPI EnableMouseInPointer( + IN BOOL bEnable) +{ + return TRUE; +} + +typedef enum _ORIENTATION_PREFERENCE { + ORIENTATION_PREFERENCE_NONE, + ORIENTATION_PREFERENCE_LANDSCAPE, + ORIENTATION_PREFERENCE_PORTRAIT, + ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED, + ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED +} ORIENTATION_PREFERENCE; + +WINUSERAPI BOOL WINAPI GetDisplayAutoRotationPreferences( + OUT ORIENTATION_PREFERENCE *pOrientation) +{ + *pOrientation = ORIENTATION_PREFERENCE_NONE; + return TRUE; +} + +WINUSERAPI BOOL WINAPI SetDisplayAutoRotationPreferences( + IN ORIENTATION_PREFERENCE orientation) +{ + return TRUE; +} + +typedef enum _POINTER_INPUT_TYPE { + PT_POINTER, + PT_TOUCH, + PT_PEN, + PT_MOUSE, + PT_TOUCHPAD +} POINTER_INPUT_TYPE; + +typedef enum _POINTER_BUTTON_CHANGE_TYPE { + POINTER_CHANGE_NONE, + POINTER_CHANGE_FIRSTBUTTON_DOWN, + POINTER_CHANGE_FIRSTBUTTON_UP, + POINTER_CHANGE_SECONDBUTTON_DOWN, + POINTER_CHANGE_SECONDBUTTON_UP, + POINTER_CHANGE_THIRDBUTTON_DOWN, + POINTER_CHANGE_THIRDBUTTON_UP, + POINTER_CHANGE_FOURTHBUTTON_DOWN, + POINTER_CHANGE_FOURTHBUTTON_UP, + POINTER_CHANGE_FIFTHBUTTON_DOWN, + POINTER_CHANGE_FIFTHBUTTON_UP +} POINTER_BUTTON_CHANGE_TYPE; + +typedef UINT32 POINTER_FLAGS; +#define POINTER_FLAG_NONE 0x00000000 // Default +#define POINTER_FLAG_NEW 0x00000001 // New pointer +#define POINTER_FLAG_INRANGE 0x00000002 // Pointer has not departed +#define POINTER_FLAG_INCONTACT 0x00000004 // Pointer is in contact +#define POINTER_FLAG_FIRSTBUTTON 0x00000010 // Primary action +#define POINTER_FLAG_SECONDBUTTON 0x00000020 // Secondary action +#define POINTER_FLAG_THIRDBUTTON 0x00000040 // Third button +#define POINTER_FLAG_FOURTHBUTTON 0x00000080 // Fourth button +#define POINTER_FLAG_FIFTHBUTTON 0x00000100 // Fifth button +#define POINTER_FLAG_PRIMARY 0x00002000 // Pointer is primary for system +#define POINTER_FLAG_CONFIDENCE 0x00004000 // Pointer is considered unlikely to be accidental +#define POINTER_FLAG_CANCELED 0x00008000 // Pointer is departing in an abnormal manner +#define POINTER_FLAG_DOWN 0x00010000 // Pointer transitioned to down state (made contact) +#define POINTER_FLAG_UPDATE 0x00020000 // Pointer update +#define POINTER_FLAG_UP 0x00040000 // Pointer transitioned from down state (broke contact) +#define POINTER_FLAG_WHEEL 0x00080000 // Vertical wheel +#define POINTER_FLAG_HWHEEL 0x00100000 // Horizontal wheel +#define POINTER_FLAG_CAPTURECHANGED 0x00200000 // Lost capture +#define POINTER_FLAG_HASTRANSFORM 0x00400000 // Input has a transform associated with it + +typedef struct _POINTER_INFO { + POINTER_INPUT_TYPE pointerType; + UINT32 pointerId; + UINT32 frameId; + POINTER_FLAGS pointerFlags; + HANDLE sourceDevice; + HWND hwndTarget; + POINT ptPixelLocation; + POINT ptHimetricLocation; + POINT ptPixelLocationRaw; + POINT ptHimetricLocationRaw; + DWORD dwTime; + UINT32 historyCount; + INT32 InputData; + DWORD dwKeyStates; + UINT64 PerformanceCount; + POINTER_BUTTON_CHANGE_TYPE ButtonChangeType; +} POINTER_INFO; + +#define POINTER_DEVICE_PRODUCT_STRING_MAX 520 + +typedef enum tagPOINTER_DEVICE_TYPE { + POINTER_DEVICE_TYPE_INTEGRATED_PEN = 0x00000001, + POINTER_DEVICE_TYPE_EXTERNAL_PEN = 0x00000002, + POINTER_DEVICE_TYPE_TOUCH = 0x00000003, + POINTER_DEVICE_TYPE_TOUCH_PAD = 0x00000004, + POINTER_DEVICE_TYPE_MAX = 0xFFFFFFFF +} POINTER_DEVICE_TYPE; + +typedef struct tagPOINTER_DEVICE_INFO { + DWORD displayOrientation; + HANDLE device; + POINTER_DEVICE_TYPE pointerDeviceType; + HMONITOR monitor; + ULONG startingCursorId; + USHORT maxActiveContacts; + WCHAR productString[POINTER_DEVICE_PRODUCT_STRING_MAX]; +} POINTER_DEVICE_INFO; + +WINUSERAPI BOOL WINAPI GetPointerDevices( + IN OUT UINT32 *deviceCount, + OUT POINTER_DEVICE_INFO *pointerDevices) +{ + *deviceCount = 0; + return TRUE; +} + +WINUSERAPI BOOL WINAPI GetPointerType( + IN DWORD dwPointerId, + OUT POINTER_INPUT_TYPE *pointerType) +{ + *pointerType = PT_MOUSE; + return TRUE; +} + +WINUSERAPI BOOL WINAPI GetPointerInfo( + IN DWORD dwPointerId, + OUT POINTER_INFO *pointerInfo) +{ + pointerInfo->pointerType = PT_MOUSE; + pointerInfo->pointerId = dwPointerId; + pointerInfo->frameId = 0; + pointerInfo->pointerFlags = POINTER_FLAG_NONE; + pointerInfo->sourceDevice = NULL; + pointerInfo->hwndTarget = NULL; + GetCursorPos(&pointerInfo->ptPixelLocation); + GetCursorPos(&pointerInfo->ptHimetricLocation); + GetCursorPos(&pointerInfo->ptPixelLocationRaw); + GetCursorPos(&pointerInfo->ptHimetricLocationRaw); + pointerInfo->dwTime = 0; + pointerInfo->historyCount = 1; + pointerInfo->InputData = 0; + pointerInfo->dwKeyStates = 0; + pointerInfo->PerformanceCount = 0; + pointerInfo->ButtonChangeType = POINTER_CHANGE_NONE; + + return TRUE; +} + +WINUSERAPI BOOL WINAPI GetPointerDeviceRects( + IN HANDLE device, + OUT LPRECT lprcPointerDeviceRect, + OUT LPRECT lprcDisplayRect) +{ + lprcPointerDeviceRect->top = 0; + lprcPointerDeviceRect->left = 0; + lprcPointerDeviceRect->bottom = GetSystemMetrics(SM_CYVIRTUALSCREEN); + lprcPointerDeviceRect->right = GetSystemMetrics(SM_CXVIRTUALSCREEN); + + lprcDisplayRect->top = 0; + lprcDisplayRect->left = 0; + lprcDisplayRect->bottom = GetSystemMetrics(SM_CYVIRTUALSCREEN); + lprcDisplayRect->right = GetSystemMetrics(SM_CXVIRTUALSCREEN); + + return TRUE; +} + +WINUSERAPI BOOL WINAPI GetPointerTouchInfo( + IN DWORD dwPointerId, + OUT LPVOID lpTouchInfo) +{ + return FALSE; +} + +WINUSERAPI BOOL WINAPI GetPointerFrameTouchInfo( + IN DWORD dwPointerId, + IN OUT LPDWORD lpdwPointerCount, + OUT LPVOID lpTouchInfo) +{ + return FALSE; +} + +WINUSERAPI BOOL WINAPI GetPointerFrameTouchInfoHistory( + IN DWORD dwPointerId, + IN OUT DWORD dwEntriesCount, + IN OUT LPDWORD lpdwPointerCount, + OUT LPVOID lpTouchInfo) +{ + return FALSE; +} + +WINUSERAPI BOOL WINAPI GetPointerPenInfo( + IN DWORD dwPointerId, + OUT LPVOID lpPenInfo) +{ + return FALSE; +} + +WINUSERAPI BOOL WINAPI GetPointerPenInfoHistory( + IN DWORD dwPointerId, + IN OUT LPDWORD lpdwEntriesCount, + OUT LPVOID lpPenInfo) +{ + return FALSE; +} + +WINUSERAPI BOOL WINAPI SkipPointerFrameMessages( + IN DWORD dwPointerId) +{ + return TRUE; +} + +WINUSERAPI BOOL WINAPI LogicalToPhysicalPointForPerMonitorDPI( + IN HWND hWnd, + IN OUT LPPOINT lpPoint) +{ + return LogicalToPhysicalPoint(hWnd, lpPoint); +} + +WINUSERAPI BOOL WINAPI PhysicalToLogicalPointForPerMonitorDPI( + IN HWND hWnd, + IN OUT LPPOINT lpPoint) +{ + return PhysicalToLogicalPoint(hWnd, lpPoint); +} + +#ifdef SPECIFIC_HACK_KEYMOUSE +#pragma comment(linker, "/export:SetWindowsHookExW=P_SetWindowsHookExW") +WINUSERAPI +HHOOK +WINAPI +P_SetWindowsHookExW( + IN int idHook, + IN HOOKPROC lpfn, + IN HINSTANCE hmod, + IN DWORD dwThreadId) +{ + return NULL; +} +#endif // SPECIFIC_HACK_KEYMOUSE \ No newline at end of file diff --git a/user33/user33.vcxproj b/user33/user33.vcxproj new file mode 100644 index 0000000..e583a0e --- /dev/null +++ b/user33/user33.vcxproj @@ -0,0 +1,168 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {B66C9C69-C6C1-421C-97CB-5EA5BED49794} + Win32Proj + user33 + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;USER33_EXPORTS;%(PreprocessorDefinitions) + CompileAsC + $(SolutionDir) + + + Windows + true + + + + + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;USER33_EXPORTS;%(PreprocessorDefinitions) + CompileAsC + $(SolutionDir) + + + Windows + true + + + + + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;USER33_EXPORTS;%(PreprocessorDefinitions) + CompileAsC + $(SolutionDir) + + + Windows + true + true + true + + + + + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;USER33_EXPORTS;%(PreprocessorDefinitions) + CompileAsC + $(SolutionDir) + + + Windows + true + true + true + + + + + + + + + + + + + + \ No newline at end of file diff --git a/user33/user33.vcxproj.filters b/user33/user33.vcxproj.filters new file mode 100644 index 0000000..87d154c --- /dev/null +++ b/user33/user33.vcxproj.filters @@ -0,0 +1,25 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/user33/user33.vcxproj.user b/user33/user33.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/user33/user33.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file