diff --git a/ChangeLog.txt b/ChangeLog.txt new file mode 100644 index 0000000..1f31e58 Binary files /dev/null and b/ChangeLog.txt differ diff --git a/KexCfg/KexCfg.c b/KexCfg/KexCfg.c new file mode 100644 index 0000000..99c6173 --- /dev/null +++ b/KexCfg/KexCfg.c @@ -0,0 +1,161 @@ +#include +#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 0000000..b3ff7a2 Binary files /dev/null and b/KexExprt/KexExprt.rc differ diff --git a/KexExprt/KexExprt.vcxproj b/KexExprt/KexExprt.vcxproj new file mode 100644 index 0000000..e8c8e11 --- /dev/null +++ b/KexExprt/KexExprt.vcxproj @@ -0,0 +1,163 @@ + + + + + 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 0000000..9b94311 Binary files /dev/null and b/KexSetup/KexSetup.rc differ diff --git a/KexSetup/KexSetup.vcxproj b/KexSetup/KexSetup.vcxproj new file mode 100644 index 0000000..d9af9e2 --- /dev/null +++ b/KexSetup/KexSetup.vcxproj @@ -0,0 +1,177 @@ + + + + + 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 0000000..632518d Binary files /dev/null and b/KexSetup/disc1.ico differ 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 0000000..c1fbb2c Binary files /dev/null and b/KexShlEx/KexShlEx.rc differ 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 0000000..39f4973 Binary files /dev/null and b/VxKexLdr/VxKexLdr.aps differ diff --git a/VxKexLdr/VxKexLdr.c b/VxKexLdr/VxKexLdr.c new file mode 100644 index 0000000..43fc2c3 --- /dev/null +++ b/VxKexLdr/VxKexLdr.c @@ -0,0 +1,1026 @@ +#include +#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 0000000..0d58f8b Binary files /dev/null and b/VxKexLdr/VxKexLdr.rc differ diff --git a/VxKexLdr/resource.h b/VxKexLdr/resource.h new file mode 100644 index 0000000..d05a778 Binary files /dev/null and b/VxKexLdr/resource.h differ diff --git a/Vxkex.h b/Vxkex.h new file mode 100644 index 0000000..bc190e8 --- /dev/null +++ b/Vxkex.h @@ -0,0 +1,5 @@ +#pragma once + +#define KEX_VERSION_FV 0,0,0,1 +#define KEX_VERSION_PV 0,0,0,1 +#define KEX_VERSION_STR "0.0.0.1" diff --git a/combase/combase.c b/combase/combase.c new file mode 100644 index 0000000..eadcf70 --- /dev/null +++ b/combase/combase.c @@ -0,0 +1,143 @@ +#include +#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 0000000..288a015 Binary files /dev/null and b/ntdll_x64.lib differ diff --git a/ntdll_x86.lib b/ntdll_x86.lib new file mode 100644 index 0000000..35adce7 Binary files /dev/null and b/ntdll_x86.lib differ diff --git a/ole33/forwarders.c b/ole33/forwarders.c new file mode 100644 index 0000000..3c28485 --- /dev/null +++ b/ole33/forwarders.c @@ -0,0 +1,460 @@ +// Generated by KexExprt (64 bit) from C:\Windows\system32\ole32.dll +#pragma comment(linker, "/export:BindMoniker=ole32.BindMoniker,@10") +#pragma comment(linker, "/export:CLIPFORMAT_UserFree=ole32.CLIPFORMAT_UserFree,@11") +#pragma comment(linker, "/export:CLIPFORMAT_UserFree64=ole32.CLIPFORMAT_UserFree64,@12") +#pragma comment(linker, "/export:CLIPFORMAT_UserMarshal=ole32.CLIPFORMAT_UserMarshal,@13") +#pragma comment(linker, "/export:CLIPFORMAT_UserMarshal64=ole32.CLIPFORMAT_UserMarshal64,@14") +#pragma comment(linker, "/export:CLIPFORMAT_UserSize=ole32.CLIPFORMAT_UserSize,@15") +#pragma comment(linker, "/export:CLIPFORMAT_UserSize64=ole32.CLIPFORMAT_UserSize64,@16") +#pragma comment(linker, "/export:CLIPFORMAT_UserUnmarshal=ole32.CLIPFORMAT_UserUnmarshal,@17") +#pragma comment(linker, "/export:CLIPFORMAT_UserUnmarshal64=ole32.CLIPFORMAT_UserUnmarshal64,@18") +#pragma comment(linker, "/export:CLSIDFromOle1Class=ole32.CLSIDFromOle1Class,@19") +#pragma comment(linker, "/export:CLSIDFromProgID=ole32.CLSIDFromProgID,@20") +#pragma comment(linker, "/export:CLSIDFromProgIDEx=ole32.CLSIDFromProgIDEx,@21") +#pragma comment(linker, "/export:CLSIDFromString=ole32.CLSIDFromString,@22") +#pragma comment(linker, "/export:CoAddRefServerProcess=ole32.CoAddRefServerProcess,@23") +#pragma comment(linker, "/export:CoAllowSetForegroundWindow=ole32.CoAllowSetForegroundWindow,@24") +#pragma comment(linker, "/export:CoBuildVersion=ole32.CoBuildVersion,@25") +#pragma comment(linker, "/export:CoCancelCall=ole32.CoCancelCall,@26") +#pragma comment(linker, "/export:CoCopyProxy=ole32.CoCopyProxy,@27") +#pragma comment(linker, "/export:CoCreateFreeThreadedMarshaler=ole32.CoCreateFreeThreadedMarshaler,@28") +#pragma comment(linker, "/export:CoCreateGuid=ole32.CoCreateGuid,@29") +#pragma comment(linker, "/export:CoCreateInstance=ole32.CoCreateInstance,@30") +#pragma comment(linker, "/export:CoCreateInstanceEx=ole32.CoCreateInstanceEx,@31") +#pragma comment(linker, "/export:CoCreateObjectInContext=ole32.CoCreateObjectInContext,@32") +#pragma comment(linker, "/export:CoDeactivateObject=ole32.CoDeactivateObject,@33") +#pragma comment(linker, "/export:CoDisableCallCancellation=ole32.CoDisableCallCancellation,@34") +#pragma comment(linker, "/export:CoDisconnectContext=ole32.CoDisconnectContext,@35") +#pragma comment(linker, "/export:CoDisconnectObject=ole32.CoDisconnectObject,@36") +#pragma comment(linker, "/export:CoDosDateTimeToFileTime=ole32.CoDosDateTimeToFileTime,@37") +#pragma comment(linker, "/export:CoEnableCallCancellation=ole32.CoEnableCallCancellation,@38") +#pragma comment(linker, "/export:CoFileTimeNow=ole32.CoFileTimeNow,@39") +#pragma comment(linker, "/export:CoFileTimeToDosDateTime=ole32.CoFileTimeToDosDateTime,@40") +#pragma comment(linker, "/export:CoFreeAllLibraries=ole32.CoFreeAllLibraries,@41") +#pragma comment(linker, "/export:CoFreeLibrary=ole32.CoFreeLibrary,@42") +#pragma comment(linker, "/export:CoFreeUnusedLibraries=ole32.CoFreeUnusedLibraries,@43") +#pragma comment(linker, "/export:CoFreeUnusedLibrariesEx=ole32.CoFreeUnusedLibrariesEx,@44") +#pragma comment(linker, "/export:CoGetActivationState=ole32.CoGetActivationState,@45") +#pragma comment(linker, "/export:CoGetApartmentID=ole32.CoGetApartmentID,@46") +#pragma comment(linker, "/export:CoGetApartmentType=ole32.CoGetApartmentType,@47") +#pragma comment(linker, "/export:CoGetCallContext=ole32.CoGetCallContext,@48") +#pragma comment(linker, "/export:CoGetCallState=ole32.CoGetCallState,@49") +#pragma comment(linker, "/export:CoGetCallerTID=ole32.CoGetCallerTID,@50") +#pragma comment(linker, "/export:CoGetCancelObject=ole32.CoGetCancelObject,@51") +#pragma comment(linker, "/export:CoGetClassObject=ole32.CoGetClassObject,@52") +#pragma comment(linker, "/export:CoGetClassVersion=ole32.CoGetClassVersion,@53") +#pragma comment(linker, "/export:CoGetComCatalog=ole32.CoGetComCatalog,@54") +#pragma comment(linker, "/export:CoGetContextToken=ole32.CoGetContextToken,@55") +#pragma comment(linker, "/export:CoGetCurrentLogicalThreadId=ole32.CoGetCurrentLogicalThreadId,@56") +#pragma comment(linker, "/export:CoGetCurrentProcess=ole32.CoGetCurrentProcess,@57") +#pragma comment(linker, "/export:CoGetDefaultContext=ole32.CoGetDefaultContext,@58") +#pragma comment(linker, "/export:CoGetInstanceFromFile=ole32.CoGetInstanceFromFile,@59") +#pragma comment(linker, "/export:CoGetInstanceFromIStorage=ole32.CoGetInstanceFromIStorage,@60") +#pragma comment(linker, "/export:CoGetInterceptor=ole32.CoGetInterceptor,@61") +#pragma comment(linker, "/export:CoGetInterceptorFromTypeInfo=ole32.CoGetInterceptorFromTypeInfo,@62") +#pragma comment(linker, "/export:CoGetInterfaceAndReleaseStream=ole32.CoGetInterfaceAndReleaseStream,@63") +#pragma comment(linker, "/export:CoGetMalloc=ole32.CoGetMalloc,@64") +#pragma comment(linker, "/export:CoGetMarshalSizeMax=ole32.CoGetMarshalSizeMax,@65") +#pragma comment(linker, "/export:CoGetModuleType=ole32.CoGetModuleType,@66") +#pragma comment(linker, "/export:CoGetObject=ole32.CoGetObject,@67") +#pragma comment(linker, "/export:CoGetObjectContext=ole32.CoGetObjectContext,@68") +#pragma comment(linker, "/export:CoGetPSClsid=ole32.CoGetPSClsid,@69") +#pragma comment(linker, "/export:CoGetProcessIdentifier=ole32.CoGetProcessIdentifier,@70") +#pragma comment(linker, "/export:CoGetStandardMarshal=ole32.CoGetStandardMarshal,@71") +#pragma comment(linker, "/export:CoGetStdMarshalEx=ole32.CoGetStdMarshalEx,@72") +#pragma comment(linker, "/export:CoGetSystemSecurityPermissions=ole32.CoGetSystemSecurityPermissions,@73") +#pragma comment(linker, "/export:CoGetTreatAsClass=ole32.CoGetTreatAsClass,@74") +#pragma comment(linker, "/export:CoImpersonateClient=ole32.CoImpersonateClient,@75") +#pragma comment(linker, "/export:CoInitialize=ole32.CoInitialize,@76") +#pragma comment(linker, "/export:CoInitializeEx=ole32.CoInitializeEx,@77") +#pragma comment(linker, "/export:CoInitializeSecurity=ole32.CoInitializeSecurity,@78") +#pragma comment(linker, "/export:CoInitializeWOW=ole32.CoInitializeWOW,@79") +#pragma comment(linker, "/export:CoInstall=ole32.CoInstall,@80") +#pragma comment(linker, "/export:CoInvalidateRemoteMachineBindings=ole32.CoInvalidateRemoteMachineBindings,@81") +#pragma comment(linker, "/export:CoIsHandlerConnected=ole32.CoIsHandlerConnected,@82") +#pragma comment(linker, "/export:CoIsOle1Class=ole32.CoIsOle1Class,@83") +#pragma comment(linker, "/export:CoLoadLibrary=ole32.CoLoadLibrary,@84") +#pragma comment(linker, "/export:CoLockObjectExternal=ole32.CoLockObjectExternal,@85") +#pragma comment(linker, "/export:CoMarshalHresult=ole32.CoMarshalHresult,@86") +#pragma comment(linker, "/export:CoMarshalInterThreadInterfaceInStream=ole32.CoMarshalInterThreadInterfaceInStream,@87") +#pragma comment(linker, "/export:CoMarshalInterface=ole32.CoMarshalInterface,@88") +#pragma comment(linker, "/export:CoPopServiceDomain=ole32.CoPopServiceDomain,@89") +#pragma comment(linker, "/export:CoPushServiceDomain=ole32.CoPushServiceDomain,@90") +#pragma comment(linker, "/export:CoQueryAuthenticationServices=ole32.CoQueryAuthenticationServices,@91") +#pragma comment(linker, "/export:CoQueryClientBlanket=ole32.CoQueryClientBlanket,@92") +#pragma comment(linker, "/export:CoQueryProxyBlanket=ole32.CoQueryProxyBlanket,@93") +#pragma comment(linker, "/export:CoQueryReleaseObject=ole32.CoQueryReleaseObject,@94") +#pragma comment(linker, "/export:CoReactivateObject=ole32.CoReactivateObject,@95") +#pragma comment(linker, "/export:CoRegisterActivationFilter=ole32.CoRegisterActivationFilter,@96") +#pragma comment(linker, "/export:CoRegisterChannelHook=ole32.CoRegisterChannelHook,@97") +#pragma comment(linker, "/export:CoRegisterClassObject=ole32.CoRegisterClassObject,@98") +#pragma comment(linker, "/export:CoRegisterInitializeSpy=ole32.CoRegisterInitializeSpy,@99") +#pragma comment(linker, "/export:CoRegisterMallocSpy=ole32.CoRegisterMallocSpy,@100") +#pragma comment(linker, "/export:CoRegisterMessageFilter=ole32.CoRegisterMessageFilter,@101") +#pragma comment(linker, "/export:CoRegisterPSClsid=ole32.CoRegisterPSClsid,@102") +#pragma comment(linker, "/export:CoRegisterSurrogate=ole32.CoRegisterSurrogate,@103") +#pragma comment(linker, "/export:CoRegisterSurrogateEx=ole32.CoRegisterSurrogateEx,@104") +#pragma comment(linker, "/export:CoReleaseMarshalData=ole32.CoReleaseMarshalData,@105") +#pragma comment(linker, "/export:CoReleaseServerProcess=ole32.CoReleaseServerProcess,@106") +#pragma comment(linker, "/export:CoResumeClassObjects=ole32.CoResumeClassObjects,@107") +#pragma comment(linker, "/export:CoRetireServer=ole32.CoRetireServer,@108") +#pragma comment(linker, "/export:CoRevertToSelf=ole32.CoRevertToSelf,@109") +#pragma comment(linker, "/export:CoRevokeClassObject=ole32.CoRevokeClassObject,@110") +#pragma comment(linker, "/export:CoRevokeInitializeSpy=ole32.CoRevokeInitializeSpy,@111") +#pragma comment(linker, "/export:CoRevokeMallocSpy=ole32.CoRevokeMallocSpy,@112") +#pragma comment(linker, "/export:CoSetCancelObject=ole32.CoSetCancelObject,@113") +#pragma comment(linker, "/export:CoSetProxyBlanket=ole32.CoSetProxyBlanket,@114") +#pragma comment(linker, "/export:CoSetState=ole32.CoSetState,@115") +#pragma comment(linker, "/export:CoSuspendClassObjects=ole32.CoSuspendClassObjects,@116") +#pragma comment(linker, "/export:CoSwitchCallContext=ole32.CoSwitchCallContext,@117") +#pragma comment(linker, "/export:CoTaskMemAlloc=ole32.CoTaskMemAlloc,@118") +#pragma comment(linker, "/export:CoTaskMemFree=ole32.CoTaskMemFree,@119") +#pragma comment(linker, "/export:CoTaskMemRealloc=ole32.CoTaskMemRealloc,@120") +#pragma comment(linker, "/export:CoTestCancel=ole32.CoTestCancel,@121") +#pragma comment(linker, "/export:CoTreatAsClass=ole32.CoTreatAsClass,@122") +#pragma comment(linker, "/export:CoUninitialize=ole32.CoUninitialize,@123") +#pragma comment(linker, "/export:CoUnloadingWOW=ole32.CoUnloadingWOW,@124") +#pragma comment(linker, "/export:CoUnmarshalHresult=ole32.CoUnmarshalHresult,@125") +#pragma comment(linker, "/export:CoUnmarshalInterface=ole32.CoUnmarshalInterface,@126") +#pragma comment(linker, "/export:CoVrfCheckThreadState=ole32.CoVrfCheckThreadState,@1") +#pragma comment(linker, "/export:CoVrfGetThreadState=ole32.CoVrfGetThreadState,@2") +#pragma comment(linker, "/export:CoVrfReleaseThreadState=ole32.CoVrfReleaseThreadState,@3") +#pragma comment(linker, "/export:CoWaitForMultipleHandles=ole32.CoWaitForMultipleHandles,@127") +#pragma comment(linker, "/export:ComPs_NdrDllCanUnloadNow=ole32.ComPs_NdrDllCanUnloadNow,@128") +#pragma comment(linker, "/export:ComPs_NdrDllGetClassObject=ole32.ComPs_NdrDllGetClassObject,@129") +#pragma comment(linker, "/export:ComPs_NdrDllRegisterProxy=ole32.ComPs_NdrDllRegisterProxy,@130") +#pragma comment(linker, "/export:ComPs_NdrDllUnregisterProxy=ole32.ComPs_NdrDllUnregisterProxy,@131") +#pragma comment(linker, "/export:CreateAntiMoniker=ole32.CreateAntiMoniker,@132") +#pragma comment(linker, "/export:CreateBindCtx=ole32.CreateBindCtx,@133") +#pragma comment(linker, "/export:CreateClassMoniker=ole32.CreateClassMoniker,@134") +#pragma comment(linker, "/export:CreateDataAdviseHolder=ole32.CreateDataAdviseHolder,@135") +#pragma comment(linker, "/export:CreateDataCache=ole32.CreateDataCache,@136") +#pragma comment(linker, "/export:CreateErrorInfo=ole32.CreateErrorInfo,@137") +#pragma comment(linker, "/export:CreateFileMoniker=ole32.CreateFileMoniker,@138") +#pragma comment(linker, "/export:CreateGenericComposite=ole32.CreateGenericComposite,@139") +#pragma comment(linker, "/export:CreateILockBytesOnHGlobal=ole32.CreateILockBytesOnHGlobal,@140") +#pragma comment(linker, "/export:CreateItemMoniker=ole32.CreateItemMoniker,@141") +#pragma comment(linker, "/export:CreateObjrefMoniker=ole32.CreateObjrefMoniker,@142") +#pragma comment(linker, "/export:CreateOleAdviseHolder=ole32.CreateOleAdviseHolder,@143") +#pragma comment(linker, "/export:CreatePointerMoniker=ole32.CreatePointerMoniker,@144") +#pragma comment(linker, "/export:CreateStdProgressIndicator=ole32.CreateStdProgressIndicator,@145") +#pragma comment(linker, "/export:CreateStreamOnHGlobal=ole32.CreateStreamOnHGlobal,@146") +#pragma comment(linker, "/export:DcomChannelSetHResult=ole32.DcomChannelSetHResult,@147") +#pragma comment(linker, "/export:DllDebugObjectRPCHook=ole32.DllDebugObjectRPCHook,@148") +#pragma comment(linker, "/export:DllGetClassObject=ole32.DllGetClassObject,@149") +#pragma comment(linker, "/export:DllGetClassObjectWOW=ole32.DllGetClassObjectWOW,@150") +#pragma comment(linker, "/export:DllRegisterServer=ole32.DllRegisterServer,@151") +#pragma comment(linker, "/export:DoDragDrop=ole32.DoDragDrop,@152") +#pragma comment(linker, "/export:EnableHookObject=ole32.EnableHookObject,@153") +#pragma comment(linker, "/export:FmtIdToPropStgName=ole32.FmtIdToPropStgName,@154") +#pragma comment(linker, "/export:FreePropVariantArray=ole32.FreePropVariantArray,@155") +#pragma comment(linker, "/export:GetClassFile=ole32.GetClassFile,@156") +#pragma comment(linker, "/export:GetConvertStg=ole32.GetConvertStg,@157") +#pragma comment(linker, "/export:GetDocumentBitStg=ole32.GetDocumentBitStg,@158") +#pragma comment(linker, "/export:GetErrorInfo=ole32.GetErrorInfo,@159") +#pragma comment(linker, "/export:GetHGlobalFromILockBytes=ole32.GetHGlobalFromILockBytes,@160") +#pragma comment(linker, "/export:GetHGlobalFromStream=ole32.GetHGlobalFromStream,@161") +#pragma comment(linker, "/export:GetHookInterface=ole32.GetHookInterface,@162") +#pragma comment(linker, "/export:GetRunningObjectTable=ole32.GetRunningObjectTable,@163") +#pragma comment(linker, "/export:HACCEL_UserFree=ole32.HACCEL_UserFree,@164") +#pragma comment(linker, "/export:HACCEL_UserFree64=ole32.HACCEL_UserFree64,@165") +#pragma comment(linker, "/export:HACCEL_UserMarshal=ole32.HACCEL_UserMarshal,@166") +#pragma comment(linker, "/export:HACCEL_UserMarshal64=ole32.HACCEL_UserMarshal64,@167") +#pragma comment(linker, "/export:HACCEL_UserSize=ole32.HACCEL_UserSize,@168") +#pragma comment(linker, "/export:HACCEL_UserSize64=ole32.HACCEL_UserSize64,@169") +#pragma comment(linker, "/export:HACCEL_UserUnmarshal=ole32.HACCEL_UserUnmarshal,@170") +#pragma comment(linker, "/export:HACCEL_UserUnmarshal64=ole32.HACCEL_UserUnmarshal64,@171") +#pragma comment(linker, "/export:HBITMAP_UserFree=ole32.HBITMAP_UserFree,@172") +#pragma comment(linker, "/export:HBITMAP_UserFree64=ole32.HBITMAP_UserFree64,@173") +#pragma comment(linker, "/export:HBITMAP_UserMarshal=ole32.HBITMAP_UserMarshal,@174") +#pragma comment(linker, "/export:HBITMAP_UserMarshal64=ole32.HBITMAP_UserMarshal64,@175") +#pragma comment(linker, "/export:HBITMAP_UserSize=ole32.HBITMAP_UserSize,@176") +#pragma comment(linker, "/export:HBITMAP_UserSize64=ole32.HBITMAP_UserSize64,@177") +#pragma comment(linker, "/export:HBITMAP_UserUnmarshal=ole32.HBITMAP_UserUnmarshal,@178") +#pragma comment(linker, "/export:HBITMAP_UserUnmarshal64=ole32.HBITMAP_UserUnmarshal64,@179") +#pragma comment(linker, "/export:HBRUSH_UserFree=ole32.HBRUSH_UserFree,@180") +#pragma comment(linker, "/export:HBRUSH_UserFree64=ole32.HBRUSH_UserFree64,@181") +#pragma comment(linker, "/export:HBRUSH_UserMarshal=ole32.HBRUSH_UserMarshal,@182") +#pragma comment(linker, "/export:HBRUSH_UserMarshal64=ole32.HBRUSH_UserMarshal64,@183") +#pragma comment(linker, "/export:HBRUSH_UserSize=ole32.HBRUSH_UserSize,@184") +#pragma comment(linker, "/export:HBRUSH_UserSize64=ole32.HBRUSH_UserSize64,@185") +#pragma comment(linker, "/export:HBRUSH_UserUnmarshal=ole32.HBRUSH_UserUnmarshal,@186") +#pragma comment(linker, "/export:HBRUSH_UserUnmarshal64=ole32.HBRUSH_UserUnmarshal64,@187") +#pragma comment(linker, "/export:HDC_UserFree=ole32.HDC_UserFree,@188") +#pragma comment(linker, "/export:HDC_UserFree64=ole32.HDC_UserFree64,@189") +#pragma comment(linker, "/export:HDC_UserMarshal=ole32.HDC_UserMarshal,@190") +#pragma comment(linker, "/export:HDC_UserMarshal64=ole32.HDC_UserMarshal64,@191") +#pragma comment(linker, "/export:HDC_UserSize=ole32.HDC_UserSize,@192") +#pragma comment(linker, "/export:HDC_UserSize64=ole32.HDC_UserSize64,@193") +#pragma comment(linker, "/export:HDC_UserUnmarshal=ole32.HDC_UserUnmarshal,@194") +#pragma comment(linker, "/export:HDC_UserUnmarshal64=ole32.HDC_UserUnmarshal64,@195") +#pragma comment(linker, "/export:HENHMETAFILE_UserFree=ole32.HENHMETAFILE_UserFree,@196") +#pragma comment(linker, "/export:HENHMETAFILE_UserFree64=ole32.HENHMETAFILE_UserFree64,@197") +#pragma comment(linker, "/export:HENHMETAFILE_UserMarshal=ole32.HENHMETAFILE_UserMarshal,@198") +#pragma comment(linker, "/export:HENHMETAFILE_UserMarshal64=ole32.HENHMETAFILE_UserMarshal64,@199") +#pragma comment(linker, "/export:HENHMETAFILE_UserSize=ole32.HENHMETAFILE_UserSize,@200") +#pragma comment(linker, "/export:HENHMETAFILE_UserSize64=ole32.HENHMETAFILE_UserSize64,@201") +#pragma comment(linker, "/export:HENHMETAFILE_UserUnmarshal=ole32.HENHMETAFILE_UserUnmarshal,@202") +#pragma comment(linker, "/export:HENHMETAFILE_UserUnmarshal64=ole32.HENHMETAFILE_UserUnmarshal64,@203") +#pragma comment(linker, "/export:HGLOBAL_UserFree=ole32.HGLOBAL_UserFree,@204") +#pragma comment(linker, "/export:HGLOBAL_UserFree64=ole32.HGLOBAL_UserFree64,@205") +#pragma comment(linker, "/export:HGLOBAL_UserMarshal=ole32.HGLOBAL_UserMarshal,@206") +#pragma comment(linker, "/export:HGLOBAL_UserMarshal64=ole32.HGLOBAL_UserMarshal64,@207") +#pragma comment(linker, "/export:HGLOBAL_UserSize=ole32.HGLOBAL_UserSize,@208") +#pragma comment(linker, "/export:HGLOBAL_UserSize64=ole32.HGLOBAL_UserSize64,@209") +#pragma comment(linker, "/export:HGLOBAL_UserUnmarshal=ole32.HGLOBAL_UserUnmarshal,@210") +#pragma comment(linker, "/export:HGLOBAL_UserUnmarshal64=ole32.HGLOBAL_UserUnmarshal64,@211") +#pragma comment(linker, "/export:HICON_UserFree=ole32.HICON_UserFree,@212") +#pragma comment(linker, "/export:HICON_UserFree64=ole32.HICON_UserFree64,@213") +#pragma comment(linker, "/export:HICON_UserMarshal=ole32.HICON_UserMarshal,@214") +#pragma comment(linker, "/export:HICON_UserMarshal64=ole32.HICON_UserMarshal64,@215") +#pragma comment(linker, "/export:HICON_UserSize=ole32.HICON_UserSize,@216") +#pragma comment(linker, "/export:HICON_UserSize64=ole32.HICON_UserSize64,@217") +#pragma comment(linker, "/export:HICON_UserUnmarshal=ole32.HICON_UserUnmarshal,@218") +#pragma comment(linker, "/export:HICON_UserUnmarshal64=ole32.HICON_UserUnmarshal64,@219") +#pragma comment(linker, "/export:HMENU_UserFree=ole32.HMENU_UserFree,@220") +#pragma comment(linker, "/export:HMENU_UserFree64=ole32.HMENU_UserFree64,@221") +#pragma comment(linker, "/export:HMENU_UserMarshal=ole32.HMENU_UserMarshal,@222") +#pragma comment(linker, "/export:HMENU_UserMarshal64=ole32.HMENU_UserMarshal64,@223") +#pragma comment(linker, "/export:HMENU_UserSize=ole32.HMENU_UserSize,@224") +#pragma comment(linker, "/export:HMENU_UserSize64=ole32.HMENU_UserSize64,@225") +#pragma comment(linker, "/export:HMENU_UserUnmarshal=ole32.HMENU_UserUnmarshal,@226") +#pragma comment(linker, "/export:HMENU_UserUnmarshal64=ole32.HMENU_UserUnmarshal64,@227") +#pragma comment(linker, "/export:HMETAFILEPICT_UserFree=ole32.HMETAFILEPICT_UserFree,@228") +#pragma comment(linker, "/export:HMETAFILEPICT_UserFree64=ole32.HMETAFILEPICT_UserFree64,@229") +#pragma comment(linker, "/export:HMETAFILEPICT_UserMarshal=ole32.HMETAFILEPICT_UserMarshal,@230") +#pragma comment(linker, "/export:HMETAFILEPICT_UserMarshal64=ole32.HMETAFILEPICT_UserMarshal64,@231") +#pragma comment(linker, "/export:HMETAFILEPICT_UserSize=ole32.HMETAFILEPICT_UserSize,@232") +#pragma comment(linker, "/export:HMETAFILEPICT_UserSize64=ole32.HMETAFILEPICT_UserSize64,@233") +#pragma comment(linker, "/export:HMETAFILEPICT_UserUnmarshal=ole32.HMETAFILEPICT_UserUnmarshal,@234") +#pragma comment(linker, "/export:HMETAFILEPICT_UserUnmarshal64=ole32.HMETAFILEPICT_UserUnmarshal64,@235") +#pragma comment(linker, "/export:HMETAFILE_UserFree=ole32.HMETAFILE_UserFree,@236") +#pragma comment(linker, "/export:HMETAFILE_UserFree64=ole32.HMETAFILE_UserFree64,@237") +#pragma comment(linker, "/export:HMETAFILE_UserMarshal=ole32.HMETAFILE_UserMarshal,@238") +#pragma comment(linker, "/export:HMETAFILE_UserMarshal64=ole32.HMETAFILE_UserMarshal64,@239") +#pragma comment(linker, "/export:HMETAFILE_UserSize=ole32.HMETAFILE_UserSize,@240") +#pragma comment(linker, "/export:HMETAFILE_UserSize64=ole32.HMETAFILE_UserSize64,@241") +#pragma comment(linker, "/export:HMETAFILE_UserUnmarshal=ole32.HMETAFILE_UserUnmarshal,@242") +#pragma comment(linker, "/export:HMETAFILE_UserUnmarshal64=ole32.HMETAFILE_UserUnmarshal64,@243") +#pragma comment(linker, "/export:HPALETTE_UserFree=ole32.HPALETTE_UserFree,@244") +#pragma comment(linker, "/export:HPALETTE_UserFree64=ole32.HPALETTE_UserFree64,@245") +#pragma comment(linker, "/export:HPALETTE_UserMarshal=ole32.HPALETTE_UserMarshal,@246") +#pragma comment(linker, "/export:HPALETTE_UserMarshal64=ole32.HPALETTE_UserMarshal64,@247") +#pragma comment(linker, "/export:HPALETTE_UserSize=ole32.HPALETTE_UserSize,@248") +#pragma comment(linker, "/export:HPALETTE_UserSize64=ole32.HPALETTE_UserSize64,@249") +#pragma comment(linker, "/export:HPALETTE_UserUnmarshal=ole32.HPALETTE_UserUnmarshal,@250") +#pragma comment(linker, "/export:HPALETTE_UserUnmarshal64=ole32.HPALETTE_UserUnmarshal64,@251") +#pragma comment(linker, "/export:HRGN_UserFree=ole32.HRGN_UserFree,@4") +#pragma comment(linker, "/export:HRGN_UserMarshal=ole32.HRGN_UserMarshal,@5") +#pragma comment(linker, "/export:HRGN_UserSize=ole32.HRGN_UserSize,@6") +#pragma comment(linker, "/export:HRGN_UserUnmarshal=ole32.HRGN_UserUnmarshal,@7") +#pragma comment(linker, "/export:HWND_UserFree=ole32.HWND_UserFree,@252") +#pragma comment(linker, "/export:HWND_UserFree64=ole32.HWND_UserFree64,@253") +#pragma comment(linker, "/export:HWND_UserMarshal=ole32.HWND_UserMarshal,@254") +#pragma comment(linker, "/export:HWND_UserMarshal64=ole32.HWND_UserMarshal64,@255") +#pragma comment(linker, "/export:HWND_UserSize=ole32.HWND_UserSize,@256") +#pragma comment(linker, "/export:HWND_UserSize64=ole32.HWND_UserSize64,@257") +#pragma comment(linker, "/export:HWND_UserUnmarshal=ole32.HWND_UserUnmarshal,@258") +#pragma comment(linker, "/export:HWND_UserUnmarshal64=ole32.HWND_UserUnmarshal64,@259") +#pragma comment(linker, "/export:HkOleRegisterObject=ole32.HkOleRegisterObject,@260") +#pragma comment(linker, "/export:IIDFromString=ole32.IIDFromString,@261") +#pragma comment(linker, "/export:IsAccelerator=ole32.IsAccelerator,@262") +#pragma comment(linker, "/export:IsEqualGUID=ole32.IsEqualGUID,@263") +#pragma comment(linker, "/export:IsValidIid=ole32.IsValidIid,@264") +#pragma comment(linker, "/export:IsValidInterface=ole32.IsValidInterface,@265") +#pragma comment(linker, "/export:IsValidPtrIn=ole32.IsValidPtrIn,@266") +#pragma comment(linker, "/export:IsValidPtrOut=ole32.IsValidPtrOut,@267") +#pragma comment(linker, "/export:MkParseDisplayName=ole32.MkParseDisplayName,@268") +#pragma comment(linker, "/export:MonikerCommonPrefixWith=ole32.MonikerCommonPrefixWith,@269") +#pragma comment(linker, "/export:MonikerRelativePathTo=ole32.MonikerRelativePathTo,@270") +#pragma comment(linker, "/export:NdrOleInitializeExtension=ole32.NdrOleInitializeExtension,@8") +#pragma comment(linker, "/export:NdrProxyForwardingFunction10=ole32.NdrProxyForwardingFunction10,@271") +#pragma comment(linker, "/export:NdrProxyForwardingFunction11=ole32.NdrProxyForwardingFunction11,@272") +#pragma comment(linker, "/export:NdrProxyForwardingFunction12=ole32.NdrProxyForwardingFunction12,@273") +#pragma comment(linker, "/export:NdrProxyForwardingFunction13=ole32.NdrProxyForwardingFunction13,@274") +#pragma comment(linker, "/export:NdrProxyForwardingFunction14=ole32.NdrProxyForwardingFunction14,@275") +#pragma comment(linker, "/export:NdrProxyForwardingFunction15=ole32.NdrProxyForwardingFunction15,@276") +#pragma comment(linker, "/export:NdrProxyForwardingFunction16=ole32.NdrProxyForwardingFunction16,@277") +#pragma comment(linker, "/export:NdrProxyForwardingFunction17=ole32.NdrProxyForwardingFunction17,@278") +#pragma comment(linker, "/export:NdrProxyForwardingFunction18=ole32.NdrProxyForwardingFunction18,@279") +#pragma comment(linker, "/export:NdrProxyForwardingFunction19=ole32.NdrProxyForwardingFunction19,@280") +#pragma comment(linker, "/export:NdrProxyForwardingFunction20=ole32.NdrProxyForwardingFunction20,@281") +#pragma comment(linker, "/export:NdrProxyForwardingFunction21=ole32.NdrProxyForwardingFunction21,@282") +#pragma comment(linker, "/export:NdrProxyForwardingFunction22=ole32.NdrProxyForwardingFunction22,@283") +#pragma comment(linker, "/export:NdrProxyForwardingFunction23=ole32.NdrProxyForwardingFunction23,@284") +#pragma comment(linker, "/export:NdrProxyForwardingFunction24=ole32.NdrProxyForwardingFunction24,@285") +#pragma comment(linker, "/export:NdrProxyForwardingFunction25=ole32.NdrProxyForwardingFunction25,@286") +#pragma comment(linker, "/export:NdrProxyForwardingFunction26=ole32.NdrProxyForwardingFunction26,@287") +#pragma comment(linker, "/export:NdrProxyForwardingFunction27=ole32.NdrProxyForwardingFunction27,@288") +#pragma comment(linker, "/export:NdrProxyForwardingFunction28=ole32.NdrProxyForwardingFunction28,@289") +#pragma comment(linker, "/export:NdrProxyForwardingFunction29=ole32.NdrProxyForwardingFunction29,@290") +#pragma comment(linker, "/export:NdrProxyForwardingFunction3=ole32.NdrProxyForwardingFunction3,@291") +#pragma comment(linker, "/export:NdrProxyForwardingFunction30=ole32.NdrProxyForwardingFunction30,@292") +#pragma comment(linker, "/export:NdrProxyForwardingFunction31=ole32.NdrProxyForwardingFunction31,@293") +#pragma comment(linker, "/export:NdrProxyForwardingFunction32=ole32.NdrProxyForwardingFunction32,@294") +#pragma comment(linker, "/export:NdrProxyForwardingFunction4=ole32.NdrProxyForwardingFunction4,@295") +#pragma comment(linker, "/export:NdrProxyForwardingFunction5=ole32.NdrProxyForwardingFunction5,@296") +#pragma comment(linker, "/export:NdrProxyForwardingFunction6=ole32.NdrProxyForwardingFunction6,@297") +#pragma comment(linker, "/export:NdrProxyForwardingFunction7=ole32.NdrProxyForwardingFunction7,@298") +#pragma comment(linker, "/export:NdrProxyForwardingFunction8=ole32.NdrProxyForwardingFunction8,@299") +#pragma comment(linker, "/export:NdrProxyForwardingFunction9=ole32.NdrProxyForwardingFunction9,@300") +#pragma comment(linker, "/export:ObjectStublessClient10=ole32.ObjectStublessClient10,@301") +#pragma comment(linker, "/export:ObjectStublessClient11=ole32.ObjectStublessClient11,@302") +#pragma comment(linker, "/export:ObjectStublessClient12=ole32.ObjectStublessClient12,@303") +#pragma comment(linker, "/export:ObjectStublessClient13=ole32.ObjectStublessClient13,@304") +#pragma comment(linker, "/export:ObjectStublessClient14=ole32.ObjectStublessClient14,@305") +#pragma comment(linker, "/export:ObjectStublessClient15=ole32.ObjectStublessClient15,@306") +#pragma comment(linker, "/export:ObjectStublessClient16=ole32.ObjectStublessClient16,@307") +#pragma comment(linker, "/export:ObjectStublessClient17=ole32.ObjectStublessClient17,@308") +#pragma comment(linker, "/export:ObjectStublessClient18=ole32.ObjectStublessClient18,@309") +#pragma comment(linker, "/export:ObjectStublessClient19=ole32.ObjectStublessClient19,@310") +#pragma comment(linker, "/export:ObjectStublessClient20=ole32.ObjectStublessClient20,@311") +#pragma comment(linker, "/export:ObjectStublessClient21=ole32.ObjectStublessClient21,@312") +#pragma comment(linker, "/export:ObjectStublessClient22=ole32.ObjectStublessClient22,@313") +#pragma comment(linker, "/export:ObjectStublessClient23=ole32.ObjectStublessClient23,@314") +#pragma comment(linker, "/export:ObjectStublessClient24=ole32.ObjectStublessClient24,@315") +#pragma comment(linker, "/export:ObjectStublessClient25=ole32.ObjectStublessClient25,@316") +#pragma comment(linker, "/export:ObjectStublessClient26=ole32.ObjectStublessClient26,@317") +#pragma comment(linker, "/export:ObjectStublessClient27=ole32.ObjectStublessClient27,@318") +#pragma comment(linker, "/export:ObjectStublessClient28=ole32.ObjectStublessClient28,@319") +#pragma comment(linker, "/export:ObjectStublessClient29=ole32.ObjectStublessClient29,@320") +#pragma comment(linker, "/export:ObjectStublessClient3=ole32.ObjectStublessClient3,@321") +#pragma comment(linker, "/export:ObjectStublessClient30=ole32.ObjectStublessClient30,@322") +#pragma comment(linker, "/export:ObjectStublessClient31=ole32.ObjectStublessClient31,@323") +#pragma comment(linker, "/export:ObjectStublessClient32=ole32.ObjectStublessClient32,@324") +#pragma comment(linker, "/export:ObjectStublessClient4=ole32.ObjectStublessClient4,@325") +#pragma comment(linker, "/export:ObjectStublessClient5=ole32.ObjectStublessClient5,@326") +#pragma comment(linker, "/export:ObjectStublessClient6=ole32.ObjectStublessClient6,@327") +#pragma comment(linker, "/export:ObjectStublessClient7=ole32.ObjectStublessClient7,@328") +#pragma comment(linker, "/export:ObjectStublessClient8=ole32.ObjectStublessClient8,@329") +#pragma comment(linker, "/export:ObjectStublessClient9=ole32.ObjectStublessClient9,@330") +#pragma comment(linker, "/export:OleBuildVersion=ole32.OleBuildVersion,@331") +#pragma comment(linker, "/export:OleConvertIStorageToOLESTREAM=ole32.OleConvertIStorageToOLESTREAM,@332") +#pragma comment(linker, "/export:OleConvertIStorageToOLESTREAMEx=ole32.OleConvertIStorageToOLESTREAMEx,@333") +#pragma comment(linker, "/export:OleConvertOLESTREAMToIStorage=ole32.OleConvertOLESTREAMToIStorage,@334") +#pragma comment(linker, "/export:OleConvertOLESTREAMToIStorageEx=ole32.OleConvertOLESTREAMToIStorageEx,@335") +#pragma comment(linker, "/export:OleCreate=ole32.OleCreate,@336") +#pragma comment(linker, "/export:OleCreateDefaultHandler=ole32.OleCreateDefaultHandler,@337") +#pragma comment(linker, "/export:OleCreateEmbeddingHelper=ole32.OleCreateEmbeddingHelper,@338") +#pragma comment(linker, "/export:OleCreateEx=ole32.OleCreateEx,@339") +#pragma comment(linker, "/export:OleCreateFromData=ole32.OleCreateFromData,@340") +#pragma comment(linker, "/export:OleCreateFromDataEx=ole32.OleCreateFromDataEx,@341") +#pragma comment(linker, "/export:OleCreateFromFile=ole32.OleCreateFromFile,@342") +#pragma comment(linker, "/export:OleCreateFromFileEx=ole32.OleCreateFromFileEx,@343") +#pragma comment(linker, "/export:OleCreateLink=ole32.OleCreateLink,@344") +#pragma comment(linker, "/export:OleCreateLinkEx=ole32.OleCreateLinkEx,@345") +#pragma comment(linker, "/export:OleCreateLinkFromData=ole32.OleCreateLinkFromData,@346") +#pragma comment(linker, "/export:OleCreateLinkFromDataEx=ole32.OleCreateLinkFromDataEx,@347") +#pragma comment(linker, "/export:OleCreateLinkToFile=ole32.OleCreateLinkToFile,@348") +#pragma comment(linker, "/export:OleCreateLinkToFileEx=ole32.OleCreateLinkToFileEx,@349") +#pragma comment(linker, "/export:OleCreateMenuDescriptor=ole32.OleCreateMenuDescriptor,@350") +#pragma comment(linker, "/export:OleCreateStaticFromData=ole32.OleCreateStaticFromData,@351") +#pragma comment(linker, "/export:OleDestroyMenuDescriptor=ole32.OleDestroyMenuDescriptor,@352") +#pragma comment(linker, "/export:OleDoAutoConvert=ole32.OleDoAutoConvert,@353") +#pragma comment(linker, "/export:OleDraw=ole32.OleDraw,@354") +#pragma comment(linker, "/export:OleDuplicateData=ole32.OleDuplicateData,@355") +#pragma comment(linker, "/export:OleFlushClipboard=ole32.OleFlushClipboard,@356") +#pragma comment(linker, "/export:OleGetAutoConvert=ole32.OleGetAutoConvert,@357") +#pragma comment(linker, "/export:OleGetClipboard=ole32.OleGetClipboard,@358") +#pragma comment(linker, "/export:OleGetIconOfClass=ole32.OleGetIconOfClass,@359") +#pragma comment(linker, "/export:OleGetIconOfFile=ole32.OleGetIconOfFile,@360") +#pragma comment(linker, "/export:OleInitialize=ole32.OleInitialize,@361") +#pragma comment(linker, "/export:OleInitializeWOW=ole32.OleInitializeWOW,@362") +#pragma comment(linker, "/export:OleIsCurrentClipboard=ole32.OleIsCurrentClipboard,@363") +#pragma comment(linker, "/export:OleIsRunning=ole32.OleIsRunning,@364") +#pragma comment(linker, "/export:OleLoad=ole32.OleLoad,@365") +#pragma comment(linker, "/export:OleLoadFromStream=ole32.OleLoadFromStream,@366") +#pragma comment(linker, "/export:OleLockRunning=ole32.OleLockRunning,@367") +#pragma comment(linker, "/export:OleMetafilePictFromIconAndLabel=ole32.OleMetafilePictFromIconAndLabel,@368") +#pragma comment(linker, "/export:OleNoteObjectVisible=ole32.OleNoteObjectVisible,@369") +#pragma comment(linker, "/export:OleQueryCreateFromData=ole32.OleQueryCreateFromData,@370") +#pragma comment(linker, "/export:OleQueryLinkFromData=ole32.OleQueryLinkFromData,@371") +#pragma comment(linker, "/export:OleRegEnumFormatEtc=ole32.OleRegEnumFormatEtc,@372") +#pragma comment(linker, "/export:OleRegEnumVerbs=ole32.OleRegEnumVerbs,@373") +#pragma comment(linker, "/export:OleRegGetMiscStatus=ole32.OleRegGetMiscStatus,@374") +#pragma comment(linker, "/export:OleRegGetUserType=ole32.OleRegGetUserType,@375") +#pragma comment(linker, "/export:OleRun=ole32.OleRun,@376") +#pragma comment(linker, "/export:OleSave=ole32.OleSave,@377") +#pragma comment(linker, "/export:OleSaveToStream=ole32.OleSaveToStream,@378") +#pragma comment(linker, "/export:OleSetAutoConvert=ole32.OleSetAutoConvert,@379") +#pragma comment(linker, "/export:OleSetClipboard=ole32.OleSetClipboard,@380") +#pragma comment(linker, "/export:OleSetContainedObject=ole32.OleSetContainedObject,@381") +#pragma comment(linker, "/export:OleSetMenuDescriptor=ole32.OleSetMenuDescriptor,@382") +#pragma comment(linker, "/export:OleTranslateAccelerator=ole32.OleTranslateAccelerator,@383") +#pragma comment(linker, "/export:OleUninitialize=ole32.OleUninitialize,@384") +#pragma comment(linker, "/export:OpenOrCreateStream=ole32.OpenOrCreateStream,@385") +#pragma comment(linker, "/export:ProgIDFromCLSID=ole32.ProgIDFromCLSID,@386") +#pragma comment(linker, "/export:PropStgNameToFmtId=ole32.PropStgNameToFmtId,@387") +#pragma comment(linker, "/export:PropSysAllocString=ole32.PropSysAllocString,@388") +#pragma comment(linker, "/export:PropSysFreeString=ole32.PropSysFreeString,@389") +#pragma comment(linker, "/export:PropVariantChangeType=ole32.PropVariantChangeType,@9") +#pragma comment(linker, "/export:PropVariantClear=ole32.PropVariantClear,@390") +#pragma comment(linker, "/export:PropVariantCopy=ole32.PropVariantCopy,@391") +#pragma comment(linker, "/export:ReadClassStg=ole32.ReadClassStg,@392") +#pragma comment(linker, "/export:ReadClassStm=ole32.ReadClassStm,@393") +#pragma comment(linker, "/export:ReadFmtUserTypeStg=ole32.ReadFmtUserTypeStg,@394") +#pragma comment(linker, "/export:ReadOleStg=ole32.ReadOleStg,@395") +#pragma comment(linker, "/export:ReadStringStream=ole32.ReadStringStream,@396") +#pragma comment(linker, "/export:RegisterDragDrop=ole32.RegisterDragDrop,@397") +#pragma comment(linker, "/export:ReleaseStgMedium=ole32.ReleaseStgMedium,@398") +#pragma comment(linker, "/export:RevokeDragDrop=ole32.RevokeDragDrop,@399") +#pragma comment(linker, "/export:SNB_UserFree=ole32.SNB_UserFree,@400") +#pragma comment(linker, "/export:SNB_UserFree64=ole32.SNB_UserFree64,@401") +#pragma comment(linker, "/export:SNB_UserMarshal=ole32.SNB_UserMarshal,@402") +#pragma comment(linker, "/export:SNB_UserMarshal64=ole32.SNB_UserMarshal64,@403") +#pragma comment(linker, "/export:SNB_UserSize=ole32.SNB_UserSize,@404") +#pragma comment(linker, "/export:SNB_UserSize64=ole32.SNB_UserSize64,@405") +#pragma comment(linker, "/export:SNB_UserUnmarshal=ole32.SNB_UserUnmarshal,@406") +#pragma comment(linker, "/export:SNB_UserUnmarshal64=ole32.SNB_UserUnmarshal64,@407") +#pragma comment(linker, "/export:STGMEDIUM_UserFree=ole32.STGMEDIUM_UserFree,@408") +#pragma comment(linker, "/export:STGMEDIUM_UserFree64=ole32.STGMEDIUM_UserFree64,@409") +#pragma comment(linker, "/export:STGMEDIUM_UserMarshal=ole32.STGMEDIUM_UserMarshal,@410") +#pragma comment(linker, "/export:STGMEDIUM_UserMarshal64=ole32.STGMEDIUM_UserMarshal64,@411") +#pragma comment(linker, "/export:STGMEDIUM_UserSize=ole32.STGMEDIUM_UserSize,@412") +#pragma comment(linker, "/export:STGMEDIUM_UserSize64=ole32.STGMEDIUM_UserSize64,@413") +#pragma comment(linker, "/export:STGMEDIUM_UserUnmarshal=ole32.STGMEDIUM_UserUnmarshal,@414") +#pragma comment(linker, "/export:STGMEDIUM_UserUnmarshal64=ole32.STGMEDIUM_UserUnmarshal64,@415") +#pragma comment(linker, "/export:SetConvertStg=ole32.SetConvertStg,@416") +#pragma comment(linker, "/export:SetDocumentBitStg=ole32.SetDocumentBitStg,@417") +#pragma comment(linker, "/export:SetErrorInfo=ole32.SetErrorInfo,@418") +#pragma comment(linker, "/export:StgConvertPropertyToVariant=ole32.StgConvertPropertyToVariant,@419") +#pragma comment(linker, "/export:StgConvertVariantToProperty=ole32.StgConvertVariantToProperty,@420") +#pragma comment(linker, "/export:StgCreateDocfile=ole32.StgCreateDocfile,@421") +#pragma comment(linker, "/export:StgCreateDocfileOnILockBytes=ole32.StgCreateDocfileOnILockBytes,@422") +#pragma comment(linker, "/export:StgCreatePropSetStg=ole32.StgCreatePropSetStg,@423") +#pragma comment(linker, "/export:StgCreatePropStg=ole32.StgCreatePropStg,@424") +#pragma comment(linker, "/export:StgCreateStorageEx=ole32.StgCreateStorageEx,@425") +#pragma comment(linker, "/export:StgGetIFillLockBytesOnFile=ole32.StgGetIFillLockBytesOnFile,@426") +#pragma comment(linker, "/export:StgGetIFillLockBytesOnILockBytes=ole32.StgGetIFillLockBytesOnILockBytes,@427") +#pragma comment(linker, "/export:StgIsStorageFile=ole32.StgIsStorageFile,@428") +#pragma comment(linker, "/export:StgIsStorageILockBytes=ole32.StgIsStorageILockBytes,@429") +#pragma comment(linker, "/export:StgOpenAsyncDocfileOnIFillLockBytes=ole32.StgOpenAsyncDocfileOnIFillLockBytes,@430") +#pragma comment(linker, "/export:StgOpenPropStg=ole32.StgOpenPropStg,@431") +#pragma comment(linker, "/export:StgOpenStorage=ole32.StgOpenStorage,@432") +#pragma comment(linker, "/export:StgOpenStorageEx=ole32.StgOpenStorageEx,@433") +#pragma comment(linker, "/export:StgOpenStorageOnHandle=ole32.StgOpenStorageOnHandle,@434") +#pragma comment(linker, "/export:StgOpenStorageOnILockBytes=ole32.StgOpenStorageOnILockBytes,@435") +#pragma comment(linker, "/export:StgPropertyLengthAsVariant=ole32.StgPropertyLengthAsVariant,@436") +#pragma comment(linker, "/export:StgSetTimes=ole32.StgSetTimes,@437") +#pragma comment(linker, "/export:StringFromCLSID=ole32.StringFromCLSID,@438") +#pragma comment(linker, "/export:StringFromGUID2=ole32.StringFromGUID2,@439") +#pragma comment(linker, "/export:StringFromIID=ole32.StringFromIID,@440") +#pragma comment(linker, "/export:UpdateDCOMSettings=ole32.UpdateDCOMSettings,@441") +#pragma comment(linker, "/export:UpdateProcessTracing=ole32.UpdateProcessTracing,@442") +#pragma comment(linker, "/export:UtConvertDvtd16toDvtd32=ole32.UtConvertDvtd16toDvtd32,@443") +#pragma comment(linker, "/export:UtConvertDvtd32toDvtd16=ole32.UtConvertDvtd32toDvtd16,@444") +#pragma comment(linker, "/export:UtGetDvtd16Info=ole32.UtGetDvtd16Info,@445") +#pragma comment(linker, "/export:UtGetDvtd32Info=ole32.UtGetDvtd32Info,@446") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserFree=ole32.WdtpInterfacePointer_UserFree,@447") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserFree64=ole32.WdtpInterfacePointer_UserFree64,@448") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserMarshal=ole32.WdtpInterfacePointer_UserMarshal,@449") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserMarshal64=ole32.WdtpInterfacePointer_UserMarshal64,@450") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserSize=ole32.WdtpInterfacePointer_UserSize,@451") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserSize64=ole32.WdtpInterfacePointer_UserSize64,@452") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserUnmarshal=ole32.WdtpInterfacePointer_UserUnmarshal,@453") +#pragma comment(linker, "/export:WdtpInterfacePointer_UserUnmarshal64=ole32.WdtpInterfacePointer_UserUnmarshal64,@454") +#pragma comment(linker, "/export:WriteClassStg=ole32.WriteClassStg,@455") +#pragma comment(linker, "/export:WriteClassStm=ole32.WriteClassStm,@456") +#pragma comment(linker, "/export:WriteFmtUserTypeStg=ole32.WriteFmtUserTypeStg,@457") +#pragma comment(linker, "/export:WriteOleStg=ole32.WriteOleStg,@458") +#pragma comment(linker, "/export:WriteStringStream=ole32.WriteStringStream,@459") \ No newline at end of file diff --git a/ole33/ole33.c b/ole33/ole33.c new file mode 100644 index 0000000..afae884 --- /dev/null +++ b/ole33/ole33.c @@ -0,0 +1,11 @@ +#include +#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