module tango.sys.win32.UserGdi;

/*
 	Module:		Windows Functions
 	Author: 	Trevor Parscal
*/

/+ Imports +/
public
{
	import tango.sys.win32.Types;
}

/+ Functions +/
extern(Windows)
{
	BOOL GetWindowInfo(HWND, PWINDOWINFO);
	BOOL EnumDisplayMonitors(HDC, RECT*, MONITORENUMPROC, LPARAM);
	BOOL GetMonitorInfoA(HMONITOR, LPMONITORINFO);
	WINBOOL GetBinaryTypeA(LPCSTR, LPDWORD);
	DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD);
	LPSTR GetEnvironmentStringsA();
	WINBOOL FreeEnvironmentStringsA(LPSTR);
	DWORD FormatMessageA(DWORD, LPCVOID, DWORD, DWORD, LPSTR, DWORD, VA_LIST*);
	HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	int lstrcmpA(LPCSTR, LPCSTR);
	int lstrcmpiA(LPCSTR, LPCSTR);
	LPSTR lstrcpynA(LPSTR, LPCSTR, int);
	LPSTR lstrcpyA(LPSTR, LPCSTR);
	LPSTR lstrcatA(LPSTR, LPCSTR);
	int lstrlenA(LPCSTR);
	HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, WINBOOL, LPCSTR);
	HANDLE OpenMutexA(DWORD, WINBOOL, LPCSTR);
	HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCSTR);
	HANDLE OpenEventA(DWORD, WINBOOL, LPCSTR);
	HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR);
	HANDLE OpenSemaphoreA(DWORD, WINBOOL, LPCSTR);
	HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR);
	HANDLE OpenFileMappingA(DWORD, WINBOOL, LPCSTR);
	DWORD GetLogicalDriveStringsA(DWORD, LPSTR);
	HINST LoadLibraryA(LPCSTR);
	HINST LoadLibraryExA(LPCSTR, HANDLE, DWORD);
	DWORD GetModuleFileNameA(HINST, LPSTR, DWORD);
	HMODULE GetModuleHandleA(LPCSTR);
	void FatalAppExitA(UINT);
	LPSTR GetCommandLineA();
	DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD);
	WINBOOL SetEnvironmentVariableA(LPCSTR, LPCSTR);
	DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD);
	void OutputDebugStringA(LPCSTR);
	HRSRC FindResourceA(HINST, LPCSTR, LPCSTR);
	HRSRC FindResourceExA(HINST, LPCSTR, LPCSTR, ushort);
	WINBOOL EnumResourceTypesA(HINST, ENUMRESTYPEPROC, LONG);
	WINBOOL EnumResourceNamesA(HINST, LPCSTR, ENUMRESNAMEPROC, LONG);
	WINBOOL EnumResourceLanguagesA(HINST, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG);
	HANDLE BeginUpdateResourceA(LPCSTR, WINBOOL);
	WINBOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, ushort, LPVOID, DWORD);
	WINBOOL EndUpdateResourceA(HANDLE, WINBOOL);
	ATOM GlobalAddAtomA(LPCSTR);
	ATOM GlobalFindAtomA(LPCSTR);
	UINT GlobalGetAtomNameA(ATOM, LPSTR, int);
	ATOM AddAtomA(LPCSTR);
	ATOM FindAtomA(LPCSTR);
	UINT GetAtomNameA(ATOM, LPSTR, int);
	UINT GetProfileIntA(LPCSTR, LPCSTR, INT);
	DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD);
	WINBOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR);
	DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD);
	WINBOOL WriteProfileSectionA(LPCSTR, LPCSTR);
	UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR);
	DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
	WINBOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR);
	DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR);
	WINBOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR);
	UINT GetDriveTypeA(LPCSTR);
	UINT GetSystemDirectoryA(LPSTR, UINT);
	DWORD GetTempPathA(DWORD, LPSTR);
	UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR);
	UINT GetWindowsDirectoryA(LPSTR, UINT);
	WINBOOL SetCurrentDirectoryA(LPCSTR);
	DWORD GetCurrentDirectoryA(DWORD, LPSTR);
	WINBOOL GetDiskFreeSpaceA(LPCSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES);
	WINBOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
	WINBOOL RemoveDirectoryA(LPCSTR);
	DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*);
	WINBOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR);
	DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD);
	HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
	WINBOOL SetFileAttributesA(LPCSTR, DWORD);
	DWORD GetFileAttributesA(LPCSTR);
	BOOL GetFileAttributesExA(LPCSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*);
	DWORD GetCompressedFileSizeA(LPCSTR, LPDWORD);
	WINBOOL DeleteFileA(LPCSTR);
	DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR);
	WINBOOL CopyFileA(LPCSTR, LPCSTR, WINBOOL);
	WINBOOL MoveFileA(LPCSTR, LPCSTR);
	WINBOOL MoveFileExA(LPCSTR, LPCSTR, DWORD);
	HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	WINBOOL GetNamedPipeHandleStateA(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD);
	WINBOOL CallNamedPipeA(LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD);
	WINBOOL WaitNamedPipeA(LPCSTR, DWORD);
	WINBOOL SetVolumeLabelA(LPCSTR, LPCSTR);
	WINBOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD);
	WINBOOL ClearEventLogA(HANDLE, LPCSTR);
	WINBOOL BackupEventLogA(HANDLE, LPCSTR);
	HANDLE OpenEventLogA(LPCSTR, LPCSTR);
	HANDLE RegisterEventSourceA(LPCSTR, LPCSTR);
	HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR);
	WINBOOL ReadEventLogA(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD);
	WINBOOL ReportEventA(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCSTR*, LPVOID);
	WINBOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL);
	WINBOOL ObjectOpenAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL);
	WINBOOL ObjectPrivilegeAuditAlarmA(LPCSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL);
	WINBOOL ObjectCloseAuditAlarmA(LPCSTR, LPVOID, WINBOOL);
	WINBOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, WINBOOL);
	WINBOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	WINBOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	HANDLE FindFirstChangeNotificationA(LPCSTR, WINBOOL, DWORD);
	WINBOOL IsBadStringPtrA(LPCSTR, UINT);
	WINBOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE);
	WINBOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE);
	WINBOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID);
	WINBOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, LPDWORD);
	WINBOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, LPDWORD, LPDWORD);
	WINBOOL BuildCommDCBA(LPCSTR, LPDCB);
	WINBOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS);
	WINBOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG);
	WINBOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, LPDWORD);
	WINBOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD);
	WINBOOL GetComputerNameA(LPSTR, LPDWORD);
	WINBOOL SetComputerNameA(LPCSTR);
	WINBOOL GetUserNameA(LPSTR, LPDWORD);
	int wvsprintfA(LPSTR, LPCSTR, VA_LIST*);
	HKL LoadKeyboardLayoutA(LPCSTR, UINT);
	WINBOOL GetKeyboardLayoutNameA(LPSTR);
	HDESK CreateDesktopA(LPSTR, LPSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HDESK OpenDesktopA(LPSTR, DWORD, WINBOOL, DWORD);
	WINBOOL EnumDesktopsA(HWINSTA, DESKTOPENUMPROC, LPARAM);
	HWINSTA CreateWindowStationA(LPSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HWINSTA OpenWindowStationA(LPSTR, WINBOOL, DWORD);
	WINBOOL EnumWindowStationsA(ENUMWINDOWSTATIONPROC, LPARAM);
	WINBOOL GetUserObjectInformationA(HANDLE, int, PVOID, DWORD, LPDWORD);
	WINBOOL SetUserObjectInformationA(HANDLE, int, PVOID, DWORD);
	UINT RegisterWindowMessageA(LPCSTR);
	WINBOOL GetMessageA(LPMSG, HWND, UINT, UINT);
	LONG DispatchMessageA(LPMSG);
	WINBOOL PeekMessageA(LPMSG, HWND, UINT, UINT, UINT);
	LRESULT SendMessageA(HWND, UINT, WPARAM, LPARAM);
	LRESULT SendMessageTimeoutA(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD);
	WINBOOL SendNotifyMessageA(HWND, UINT, WPARAM, LPARAM);
	WINBOOL SendMessageCallbackA(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD);
	WINBOOL PostMessageA(HWND, UINT, WPARAM, LPARAM);
	WINBOOL PostThreadMessageA(DWORD, UINT, WPARAM, LPARAM);
	LRESULT DefWindowProcA(HWND, UINT, WPARAM, LPARAM);
	LRESULT CallWindowProcA(WNDPROC, HWND, UINT, WPARAM, LPARAM);
	ATOM RegisterClassA(LPWNDCLASS);
	WINBOOL UnregisterClassA(LPCSTR, HINST);
	WINBOOL GetClassInfoA(HINST, LPCSTR, LPWNDCLASS);
	ATOM RegisterClassExA(LPWNDCLASSEX);
	WINBOOL GetClassInfoExA(HINST, LPCSTR, LPWNDCLASSEX);
	HWND CreateWindowExA(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID);
	HWND CreateDialogParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM);
	HWND CreateDialogIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
	int DialogBoxParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM);
	int DialogBoxIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
	WINBOOL SetDlgItemTextA(HWND, int, LPCSTR);
	UINT GetDlgItemTextA(HWND, int, LPSTR, int);
	LONG SendDlgItemMessageA(HWND, int, UINT, WPARAM, LPARAM);
	LRESULT DefDlgProcA(HWND, UINT, WPARAM, LPARAM);
	WINBOOL CallMsgFilterA(LPMSG, int);
	UINT RegisterClipboardFormatA(LPCSTR);
	int GetClipboardFormatNameA(UINT, LPSTR, int);
	WINBOOL CharToOemA(LPCSTR, LPSTR);
	WINBOOL OemToCharA(LPCSTR, LPSTR);
	WINBOOL CharToOemBuffA(LPCSTR, LPSTR, DWORD);
	WINBOOL OemToCharBuffA(LPCSTR, LPSTR, DWORD);
	LPSTR CharUpperA(LPSTR);
	DWORD CharUpperBuffA(LPSTR, DWORD);
	LPSTR CharLowerA(LPSTR);
	DWORD CharLowerBuffA(LPSTR, DWORD);
	LPSTR CharNextA(LPCSTR);
	LPSTR CharPrevA(LPCSTR, LPCSTR);
	WINBOOL IsCharAlphaA(char);
	WINBOOL IsCharAlphaNumericA(char);
	WINBOOL IsCharUpperA(char);
	WINBOOL IsCharLowerA(char);
	int GetKeyNameTextA(LONG, LPSTR, int);
	SHORT VkKeyScanA(char);
	SHORT VkKeyScanExA(char, HKL);
	UINT MapVirtualKeyA(UINT, UINT);
	UINT MapVirtualKeyExA(UINT, UINT, HKL);
	HACCEL LoadAcceleratorsA(HINST, LPCSTR);
	HACCEL CreateAcceleratorTableA(LPACCEL, int);
	int CopyAcceleratorTableA(HACCEL, LPACCEL, int);
	int TranslateAcceleratorA(HWND, HACCEL, LPMSG);
	HMENU LoadMenuA(HINST, LPCSTR);
	HMENU LoadMenuIndirectA(LPMENUTEMPLATE);
	WINBOOL ChangeMenuA(HMENU, UINT, LPCSTR, UINT, UINT);
	int GetMenuStringA(HMENU, UINT, LPSTR, int, UINT);
	WINBOOL InsertMenuA(HMENU, UINT, UINT, UINT, LPCSTR);
	WINBOOL AppendMenuA(HMENU, UINT, UINT, LPCSTR);
	WINBOOL ModifyMenuA(HMENU, UINT, UINT, UINT, LPCSTR);
	WINBOOL InsertMenuItemA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
	WINBOOL GetMenuItemInfoA(HMENU, UINT, WINBOOL, LPMENUITEMINFO);
	WINBOOL SetMenuItemInfoA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
	int DrawTextA(HDC, LPCSTR, int, LPRECT, UINT);
	int DrawTextExA(HDC, LPSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS);
	WINBOOL GrayStringA(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int);
	WINBOOL DrawStateA(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT);
	LONG TabbedTextOutA(HDC, int, int, LPCSTR, int, int, LPINT, int);
	DWORD GetTabbedTextExtentA(HDC, LPCSTR, int, int, LPINT);
	WINBOOL SetPropA(HWND, LPCSTR, HANDLE);
	HANDLE GetPropA(HWND, LPCSTR);
	HANDLE RemovePropA(HWND, LPCSTR);
	int EnumPropsExA(HWND, PROPENUMPROCEX, LPARAM);
	int EnumPropsA(HWND, PROPENUMPROC);
	WINBOOL SetWindowTextA(HWND, LPCSTR);
	int GetWindowTextA(HWND, LPSTR, int);
	int GetWindowTextLengthA(HWND);
	int MessageBoxA(HWND, LPCSTR, LPCSTR, UINT);
	int MessageBoxExA(HWND, LPCSTR, LPCSTR, UINT, ushort);
	int MessageBoxIndirectA(LPMSGBOXPARAMS);
	LONG GetWindowLongA(HWND, int);
	LONG SetWindowLongA(HWND, int, LONG);
	DWORD GetClassLongA(HWND, int);
	DWORD SetClassLongA(HWND, int, LONG);
	HWND FindWindowA(LPCSTR, LPCSTR);
	HWND FindWindowExA(HWND, HWND, LPCSTR, LPCSTR);
	int GetClassNameA(HWND, LPSTR, int);
	HHOOK SetWindowsHookExA(int, HOOKPROC, HINST, DWORD);
	HBITMAP LoadBitmapA(HINST, LPCSTR);
	HCURSOR LoadCursorA(HINST, LPCSTR);
	HCURSOR LoadCursorFromFileA(LPCSTR);
	HICON LoadIconA(HINST, LPCSTR);
	HANDLE LoadImageA(HINST, LPCSTR, UINT, int, int, UINT);
	int LoadStringA(HINST, UINT, LPSTR, int);
	WINBOOL IsDialogMessageA(HWND, LPMSG);
	int DlgDirListA(HWND, LPSTR, int, int, UINT);
	WINBOOL DlgDirSelectExA(HWND, LPSTR, int, int);
	int DlgDirListComboBoxA(HWND, LPSTR, int, int, UINT);
	WINBOOL DlgDirSelectComboBoxExA(HWND, LPSTR, int, int);
	LRESULT DefFrameProcA(HWND, HWND, UINT, WPARAM, LPARAM);
	LRESULT DefMDIChildProcA(HWND, UINT, WPARAM, LPARAM);
	HWND CreateMDIWindowA(LPSTR, LPSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM);
	WINBOOL WinHelpA(HWND, LPCSTR, UINT, DWORD);
	LONG ChangeDisplaySettingsA(LPDEVMODE, DWORD);
	WINBOOL EnumDisplaySettingsA(LPCSTR, DWORD, LPDEVMODE);
	WINBOOL SystemParametersInfoA(UINT, UINT, PVOID, UINT);
	int AddFontResourceA(LPCSTR);
	HMETAFILE CopyMetaFileA(HMETAFILE, LPCSTR);
	HFONT CreateFontIndirectA(LPLOGFONT);
	HDC CreateICA(LPCSTR, LPCSTR, LPCSTR, LPDEVMODE);
	HDC CreateMetaFileA(LPCSTR);
	WINBOOL CreateScalableFontResourceA(DWORD, LPCSTR, LPCSTR, LPCSTR);
	int EnumFontFamiliesExA(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD);
	int EnumFontFamiliesA(HDC, LPCSTR, FONTENUMPROC, LPARAM);
	int EnumFontsA(HDC, LPCSTR, ENUMFONTSPROC, LPARAM);
	WINBOOL GetCharWidthA(HDC, UINT, UINT, LPINT);
	WINBOOL GetCharWidth32A(HDC, UINT, UINT, LPINT);
	WINBOOL GetCharWidthFloatA(HDC, UINT, UINT, PFLOAT);
	WINBOOL GetCharABCWidthsA(HDC, UINT, UINT, LPABC);
	WINBOOL GetCharABCWidthsFloatA(HDC, UINT, UINT, LPABCFLOAT);
	DWORD GetGlyphOutlineA(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2);
	HMETAFILE GetMetaFileA(LPCSTR);
	UINT GetOutlineTextMetricsA(HDC, UINT, LPOUTLINETEXTMETRIC);
	WINBOOL GetTextExtentPointA(HDC, LPCSTR, int, LPSIZE);
	WINBOOL GetTextExtentPoint32A(HDC, LPCSTR, int, LPSIZE);
	WINBOOL GetTextExtentExPointA(HDC, LPCSTR, int, int, LPINT, LPINT, LPSIZE);
	DWORD GetCharacterPlacementA(HDC, LPCSTR, int, int, LPGCP_RESULTS, DWORD);
	HDC ResetDCA(HDC, LPDEVMODE);
	WINBOOL RemoveFontResourceA(LPCSTR);
	HENHMETAFILE CopyEnhMetaFileA(HENHMETAFILE, LPCSTR);
	HDC CreateEnhMetaFileA(HDC, LPCSTR, LPRECT, LPCSTR);
	HENHMETAFILE GetEnhMetaFileA(LPCSTR);
	UINT GetEnhMetaFileDescriptionA(HENHMETAFILE, UINT, LPSTR);
	WINBOOL GetTextMetricsA(HDC, LPTEXTMETRIC);
	int StartDocA(HDC, PDOCINFO);
	int GetObjectA(HGDIOBJ, int, LPVOID);
	WINBOOL TextOutA(HDC, int, int, LPCSTR, int);
	WINBOOL ExtTextOutA(HDC, int, int, UINT, LPRECT, LPCSTR, UINT, LPINT);
	WINBOOL PolyTextOutA(HDC, PPOLYTEXT, int);
	int GetTextFaceA(HDC, int, LPSTR);
	DWORD GetKerningPairsA(HDC, DWORD, LPKERNINGPAIR);
	HCOLORSPACE CreateColorSpaceA(LPLOGCOLORSPACE);
	WINBOOL GetLogColorSpaceA(HCOLORSPACE, LPLOGCOLORSPACE, DWORD);
	WINBOOL GetICMProfileA(HDC, DWORD, LPSTR);
	WINBOOL SetICMProfileA(HDC, LPSTR);
	WINBOOL UpdateICMRegKeyA(DWORD, DWORD, LPSTR, UINT);
	int EnumICMProfilesA(HDC, ICMENUMPROC, LPARAM);
	int PropertySheetA(LPCPROPSHEETHEADER);
	HIMAGELIST ImageList_LoadImageA(HINST, LPCSTR, int, int, COLORREF, UINT, UINT);
	HWND CreateStatusWindowA(LONG, LPCSTR, HWND, UINT);
	void DrawStatusTextA(HDC, LPRECT, LPCSTR);
	WINBOOL GetOpenFileNameA(LPOPENFILENAME);
	WINBOOL GetSaveFileNameA(LPOPENFILENAME);
	int GetFileTitleA(LPCSTR, LPSTR, ushort);
	WINBOOL ChooseColorA(LPCHOOSECOLOR);
	HWND FindTextA(LPFINDREPLACE);
	HWND ReplaceTextA(LPFINDREPLACE);
	WINBOOL ChooseFontA(LPCHOOSEFONT);
	WINBOOL PrintDlgA(LPPRINTDLG);
	WINBOOL PageSetupDlgA(LPPAGESETUPDLG);
	WINBOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
	void GetStartupInfoA(LPSTARTUPINFO);
	HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATA);
	WINBOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATA);
	WINBOOL GetVersionExA(LPOSVERSIONINFO);
	HDC CreateDCA(LPCSTR, LPCSTR, LPCSTR, PDEVMODE);
	DWORD VerInstallFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, PUINT);
	DWORD GetFileVersionInfoSizeA(LPSTR, LPDWORD);
	WINBOOL GetFileVersionInfoA(LPSTR, DWORD, DWORD, LPVOID);
	DWORD VerLanguageNameA(DWORD, LPSTR, DWORD);
	WINBOOL VerQueryValueA(LPVOID, LPSTR, LPVOID, PUINT);
	DWORD VerFindFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, PUINT, LPSTR, PUINT);
	LONG RegConnectRegistryA(LPSTR, HKEY, PHKEY);
	LONG RegCreateKeyA(HKEY, LPCSTR, PHKEY);
	LONG RegCreateKeyExA(HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
	LONG RegDeleteKeyA(HKEY, LPCSTR);
	LONG RegDeleteValueA(HKEY, LPCSTR);
	LONG RegEnumKeyA(HKEY, DWORD, LPSTR, DWORD);
	LONG RegEnumKeyExA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPSTR, LPDWORD, PFILETIME);
	LONG RegEnumValueA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
	LONG RegLoadKeyA(HKEY, LPCSTR, LPCSTR);
	LONG RegOpenKeyA(HKEY, LPCSTR, PHKEY);
	LONG RegOpenKeyExA(HKEY, LPCSTR, DWORD, REGSAM, PHKEY);
	LONG RegQueryInfoKeyA(HKEY, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
	LONG RegQueryValueA(HKEY, LPCSTR, LPSTR, PLONG);
	LONG RegQueryMultipleValuesA(HKEY, PVALENT, DWORD, LPSTR, LPDWORD);
	LONG RegQueryValueExA(HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
	LONG RegReplaceKeyA(HKEY, LPCSTR, LPCSTR, LPCSTR);
	LONG RegRestoreKeyA(HKEY, LPCSTR, DWORD);
	LONG RegSaveKeyA(HKEY, LPCSTR, LPSECURITY_ATTRIBUTES);
	LONG RegSetValueA(HKEY, LPCSTR, DWORD, LPCSTR, DWORD);
	LONG RegSetValueExA(HKEY, LPCSTR, DWORD, DWORD, LPBYTE, DWORD);
	LONG RegUnLoadKeyA(HKEY, LPCSTR);
	WINBOOL InitiateSystemShutdownA(LPSTR, LPSTR, DWORD, WINBOOL, WINBOOL);
	WINBOOL AbortSystemShutdownA(LPSTR);
	int CompareStringA(LCID, DWORD, LPCSTR, int, LPCSTR, int);
	int LCMapStringA(LCID, DWORD, LPCSTR, int, LPSTR, int);
	int GetLocaleInfoA(LCID, LCTYPE, LPSTR, int);
	WINBOOL SetLocaleInfoA(LCID, LCTYPE, LPCSTR);
	int GetTimeFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int);
	int GetDateFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int);
	int GetNumberFormatA(LCID, DWORD, LPCSTR, PNUMBERFMT, LPSTR, int);
	int GetCurrencyFormatA(LCID, DWORD, LPCSTR, PCURRENCYFMT, LPSTR, int);
	WINBOOL EnumCalendarInfoA(CALINFO_ENUMPROC, LCID, CALID, CALTYPE);
	WINBOOL EnumTimeFormatsA(TIMEFMT_ENUMPROC, LCID, DWORD);
	WINBOOL EnumDateFormatsA(DATEFMT_ENUMPROC, LCID, DWORD);
	WINBOOL GetStringTypeExA(LCID, DWORD, LPCSTR, int, LPWORD);
	WINBOOL GetStringTypeA(LCID, DWORD, LPCSTR, int, LPWORD);
	int FoldStringA(DWORD, LPCSTR, int, LPSTR, int);
	WINBOOL EnumSystemLocalesA(LOCALE_ENUMPROC, DWORD);
	WINBOOL EnumSystemCodePagesA(CODEPAGE_ENUMPROC, DWORD);
	WINBOOL PeekConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL ReadConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL WriteConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL ReadConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
	WINBOOL WriteConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
	WINBOOL ReadConsoleOutputCharacterA(HANDLE, LPSTR, DWORD, COORD, LPDWORD);
	WINBOOL WriteConsoleOutputCharacterA(HANDLE, LPCSTR, DWORD, COORD, LPDWORD);
	WINBOOL FillConsoleOutputCharacterA(HANDLE, char, DWORD, COORD, LPDWORD);
	WINBOOL ScrollConsoleScreenBufferA(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO);
	DWORD GetConsoleTitleA(LPSTR, DWORD);
	WINBOOL SetConsoleTitleA(LPCSTR);
	WINBOOL ReadConsoleA(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID);
	WINBOOL WriteConsoleA(HANDLE, POINTER, DWORD, LPDWORD, LPVOID);
	DWORD WNetAddConnectionA(LPCSTR, LPCSTR, LPCSTR);
	DWORD WNetAddConnection2A(LPNETRESOURCE, LPCSTR, LPCSTR, DWORD);
	DWORD WNetAddConnection3A(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD);
	DWORD WNetCancelConnectionA(LPCSTR, WINBOOL);
	DWORD WNetCancelConnection2A(LPCSTR, DWORD, WINBOOL);
	DWORD WNetGetConnectionA(LPCSTR, LPSTR, LPDWORD);
	DWORD WNetUseConnectionA(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD, LPDWORD);
	DWORD WNetSetConnectionA(LPCSTR, DWORD, LPVOID);
	DWORD WNetConnectionDialog1A(LPCONNECTDLGSTRUCT);
	DWORD WNetDisconnectDialog1A(LPDISCDLGSTRUCT);
	DWORD WNetOpenEnumA(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE);
	DWORD WNetEnumResourceA(HANDLE, LPDWORD, LPVOID, LPDWORD);
	DWORD WNetGetUniversalNameA(LPCSTR, DWORD, LPVOID, LPDWORD);
	DWORD WNetGetUserA(LPCSTR, LPSTR, LPDWORD);
	DWORD WNetGetProviderNameA(DWORD, LPSTR, LPDWORD);
	DWORD WNetGetNetworkInformationA(LPCSTR, LPNETINFOSTRUCT);
	DWORD WNetGetLastErrorA(LPDWORD, LPSTR, DWORD, LPSTR, DWORD);
	DWORD MultinetGetConnectionPerformanceA(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT);
	WINBOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR);
	SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR);
	WINBOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD);
	WINBOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD);
	WINBOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD);
	SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD);
	SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD);
	WINBOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD);
	WINBOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR, LPHANDLER_FUNCTION);
	WINBOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY);
	WINBOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR);
	uint DragQueryFileA(HDROP, uint, PCHAR, uint);
	HICON ExtractAssociatedIconA(HINST, PCHAR, LPWORD);
	HICON ExtractIconA(HINST, PCHAR, uint);
	HINST FindExecutableA(PCHAR, PCHAR, PCHAR);
	int ShellAboutA(HWND, PCHAR, PCHAR, HICON);
	HINST ShellExecuteA(HWND, PCHAR, PCHAR, PCHAR, PCHAR, int);
	HSZ DdeCreateStringHandleA(DWORD, PCHAR, int);
	UINT DdeInitializeA(LPDWORD, PFNCALLBACK, DWORD, DWORD);
	DWORD DdeQueryStringA(DWORD, HSZ, PCHAR, DWORD, int);
	WINBOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE);
	WINBOOL CreateProcessAsUserA(HANDLE, LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCTSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
	WINBOOL GetBinaryTypeW(LPCWSTR, LPDWORD);
	DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD);
	LPWSTR GetEnvironmentStringsW();
	WINBOOL FreeEnvironmentStringsW(LPWSTR);
	DWORD FormatMessageW(DWORD, LPCVOID, DWORD, DWORD, LPWSTR, DWORD, VA_LIST*);
	HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	int lstrcmpW(LPCWSTR, LPCWSTR);
	int lstrcmpiW(LPCWSTR, LPCWSTR);
	LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int);
	LPWSTR lstrcpyW(LPWSTR, LPCWSTR);
	LPWSTR lstrcatW(LPWSTR, LPCWSTR);
	int lstrlenW(LPCWSTR);
	HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, WINBOOL, LPCWSTR);
	HANDLE OpenMutexW(DWORD, WINBOOL, LPCWSTR);
	HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCWSTR);
	HANDLE OpenEventW(DWORD, WINBOOL, LPCWSTR);
	HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR);
	HANDLE OpenSemaphoreW(DWORD, WINBOOL, LPCWSTR);
	HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR);
	HANDLE OpenFileMappingW(DWORD, WINBOOL, LPCWSTR);
	DWORD GetLogicalDriveStringsW(DWORD, LPWSTR);
	HINST LoadLibraryW(LPCWSTR);
	HINST LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
	DWORD GetModuleFileNameW(HINST, LPWSTR, DWORD);
	HMODULE GetModuleHandleW(LPCWSTR);
	void FatalAppExitW(UINT);
	LPWSTR GetCommandLineW();
	DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD);
	WINBOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR);
	DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD);
	void OutputDebugStringW(LPCWSTR);
	HRSRC FindResourceW(HINST, LPCWSTR, LPCWSTR);
	HRSRC FindResourceExW(HINST, LPCWSTR, LPCWSTR, ushort);
	WINBOOL EnumResourceTypesW(HINST, ENUMRESTYPEPROC, LONG);
	WINBOOL EnumResourceNamesW(HINST, LPCWSTR, ENUMRESNAMEPROC, LONG);
	WINBOOL EnumResourceLanguagesW(HINST, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG);
	HANDLE BeginUpdateResourceW(LPCWSTR, WINBOOL);
	WINBOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, ushort, LPVOID, DWORD);
	WINBOOL EndUpdateResourceW(HANDLE, WINBOOL);
	ATOM GlobalAddAtomW(LPCWSTR);
	ATOM GlobalFindAtomW(LPCWSTR);
	UINT GlobalGetAtomNameW(ATOM, LPWSTR, int);
	ATOM AddAtomW(LPCWSTR);
	ATOM FindAtomW(LPCWSTR);
	UINT GetAtomNameW(ATOM, LPWSTR, int);
	UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT);
	DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
	WINBOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR);
	DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD);
	WINBOOL WriteProfileSectionW(LPCWSTR, LPCWSTR);
	UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR);
	DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
	WINBOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
	DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR);
	WINBOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR);
	UINT GetDriveTypeW(LPCWSTR);
	UINT GetSystemDirectoryW(LPWSTR, UINT);
	DWORD GetTempPathW(DWORD, LPWSTR);
	UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR);
	UINT GetWindowsDirectoryW(LPWSTR, UINT);
	WINBOOL SetCurrentDirectoryW(LPCWSTR);
	DWORD GetCurrentDirectoryW(DWORD, LPWSTR);
	WINBOOL GetDiskFreeSpaceW(LPCWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES);
	WINBOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
	WINBOOL RemoveDirectoryW(LPCWSTR);
	DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*);
	WINBOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR);
	DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD);
	HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
	WINBOOL SetFileAttributesW(LPCWSTR, DWORD);
	DWORD GetFileAttributesW(LPCWSTR);
	BOOL GetFileAttributesExW(LPCWSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*);
	DWORD GetCompressedFileSizeW(LPCWSTR, LPDWORD);
	WINBOOL DeleteFileW(LPCWSTR);
	DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR);
	WINBOOL CopyFileW(LPCWSTR, LPCWSTR, WINBOOL);
	WINBOOL MoveFileW(LPCWSTR, LPCWSTR);
	WINBOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD);
	HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	WINBOOL GetNamedPipeHandleStateW(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD);
	WINBOOL CallNamedPipeW(LPCWSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD);
	WINBOOL WaitNamedPipeW(LPCWSTR, DWORD);
	WINBOOL SetVolumeLabelW(LPCWSTR, LPCWSTR);
	WINBOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD);
	WINBOOL ClearEventLogW(HANDLE, LPCWSTR);
	WINBOOL BackupEventLogW(HANDLE, LPCWSTR);
	HANDLE OpenEventLogW(LPCWSTR, LPCWSTR);
	HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR);
	HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR);
	WINBOOL ReadEventLogW(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD);
	WINBOOL ReportEventW(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCWSTR*, LPVOID);
	WINBOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL);
	WINBOOL ObjectOpenAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL);
	WINBOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL);
	WINBOOL ObjectCloseAuditAlarmW(LPCWSTR, LPVOID, WINBOOL);
	WINBOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, WINBOOL);
	WINBOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	WINBOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	HANDLE FindFirstChangeNotificationW(LPCWSTR, WINBOOL, DWORD);
	WINBOOL IsBadStringPtrW(LPCWSTR, UINT);
	WINBOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);
	WINBOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);
	WINBOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID);
	WINBOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, LPDWORD);
	WINBOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, LPDWORD);
	WINBOOL BuildCommDCBW(LPCWSTR, LPDCB);
	WINBOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS);
	WINBOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG);
	WINBOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, LPDWORD);
	WINBOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD);
	WINBOOL GetComputerNameW(LPWSTR, LPDWORD);
	WINBOOL SetComputerNameW(LPCWSTR);
	WINBOOL GetUserNameW(LPWSTR, LPDWORD);
	int wvsprintfW(LPWSTR, LPCWSTR, VA_LIST*);
	HKL LoadKeyboardLayoutW(LPCWSTR, UINT);
	WINBOOL GetKeyboardLayoutNameW(LPWSTR);
	HDESK CreateDesktopW(LPWSTR, LPWSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HDESK OpenDesktopW(LPWSTR, DWORD, WINBOOL, DWORD);
	WINBOOL EnumDesktopsW(HWINSTA, DESKTOPENUMPROC, LPARAM);
	HWINSTA CreateWindowStationW(LPWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HWINSTA OpenWindowStationW(LPWSTR, WINBOOL, DWORD);
	WINBOOL EnumWindowStationsW(ENUMWINDOWSTATIONPROC, LPARAM);
	WINBOOL GetUserObjectInformationW(HANDLE, int, PVOID, DWORD, LPDWORD);
	WINBOOL SetUserObjectInformationW(HANDLE, int, PVOID, DWORD);
	UINT RegisterWindowMessageW(LPCWSTR);
	WINBOOL GetMessageW(LPMSG, HWND, UINT, UINT);
	LONG DispatchMessageW(LPMSG);
	WINBOOL PeekMessageW(LPMSG, HWND, UINT, UINT, UINT);
	LRESULT SendMessageW(HWND, UINT, WPARAM, LPARAM);
	LRESULT SendMessageTimeoutW(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD);
	WINBOOL SendNotifyMessageW(HWND, UINT, WPARAM, LPARAM);
	WINBOOL SendMessageCallbackW(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD);
	WINBOOL PostMessageW(HWND, UINT, WPARAM, LPARAM);
	WINBOOL PostThreadMessageW(DWORD, UINT, WPARAM, LPARAM);
	LRESULT DefWindowProcW(HWND, UINT, WPARAM, LPARAM);
	LRESULT CallWindowProcW(WNDPROC, HWND, UINT, WPARAM, LPARAM);
	ATOM RegisterClassW(LPWNDCLASS);
	WINBOOL UnregisterClassW(LPCWSTR, HINST);
	WINBOOL GetClassInfoW(HINST, LPCWSTR, LPWNDCLASS);
	ATOM RegisterClassExW(LPWNDCLASSEX);
	WINBOOL GetClassInfoExW(HINST, LPCWSTR, LPWNDCLASSEX);
	HWND CreateWindowExW(DWORD, LPCWSTR, LPCWSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID);
	HWND CreateDialogParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM);
	HWND CreateDialogIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
	int DialogBoxParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM);
	int DialogBoxIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
	WINBOOL SetDlgItemTextW(HWND, int, LPCWSTR);
	UINT GetDlgItemTextW(HWND, int, LPWSTR, int);
	LONG SendDlgItemMessageW(HWND, int, UINT, WPARAM, LPARAM);
	LRESULT DefDlgProcW(HWND, UINT, WPARAM, LPARAM);
	WINBOOL CallMsgFilterW(LPMSG, int);
	UINT RegisterClipboardFormatW(LPCWSTR);
	int GetClipboardFormatNameW(UINT, LPWSTR, int);
	WINBOOL CharToOemW(LPCWSTR, LPSTR);
	WINBOOL OemToCharW(LPCSTR, LPWSTR);
	WINBOOL CharToOemBuffW(LPCWSTR, LPSTR, DWORD);
	WINBOOL OemToCharBuffW(LPCSTR, LPWSTR, DWORD);
	LPWSTR CharUpperW(LPWSTR);
	DWORD CharUpperBuffW(LPWSTR, DWORD);
	LPWSTR CharLowerW(LPWSTR);
	DWORD CharLowerBuffW(LPWSTR, DWORD);
	LPWSTR CharNextW(LPCWSTR);
	LPWSTR CharPrevW(LPCWSTR, LPCWSTR);
	WINBOOL IsCharAlphaW(WCHAR);
	WINBOOL IsCharAlphaNumericW(WCHAR);
	WINBOOL IsCharUpperW(WCHAR);
	WINBOOL IsCharLowerW(WCHAR);
	int GetKeyNameTextW(LONG, LPWSTR, int);
	SHORT VkKeyScanW(WCHAR);
	SHORT VkKeyScanExW(WCHAR, HKL);
	UINT MapVirtualKeyW(UINT, UINT);
	UINT MapVirtualKeyExW(UINT, UINT, HKL);
	HACCEL LoadAcceleratorsW(HINST, LPCWSTR);
	HACCEL CreateAcceleratorTableW(LPACCEL, int);
	int CopyAcceleratorTableW(HACCEL, LPACCEL, int);
	int TranslateAcceleratorW(HWND, HACCEL, LPMSG);
	HMENU LoadMenuW(HINST, LPCWSTR);
	HMENU LoadMenuIndirectW(LPMENUTEMPLATE);
	WINBOOL ChangeMenuW(HMENU, UINT, LPCWSTR, UINT, UINT);
	int GetMenuStringW(HMENU, UINT, LPWSTR, int, UINT);
	WINBOOL InsertMenuW(HMENU, UINT, UINT, UINT, LPCWSTR);
	WINBOOL AppendMenuW(HMENU, UINT, UINT, LPCWSTR);
	WINBOOL ModifyMenuW(HMENU, UINT, UINT, UINT, LPCWSTR);
	WINBOOL InsertMenuItemW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
	WINBOOL GetMenuItemInfoW(HMENU, UINT, WINBOOL, LPMENUITEMINFO);
	WINBOOL SetMenuItemInfoW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
	int DrawTextW(HDC, LPCWSTR, int, LPRECT, UINT);
	int DrawTextExW(HDC, LPWSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS);
	WINBOOL GrayStringW(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int);
	WINBOOL DrawStateW(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT);
	LONG TabbedTextOutW(HDC, int, int, LPCWSTR, int, int, LPINT, int);
	DWORD GetTabbedTextExtentW(HDC, LPCWSTR, int, int, LPINT);
	WINBOOL SetPropW(HWND, LPCWSTR, HANDLE);
	HANDLE GetPropW(HWND, LPCWSTR);
	HANDLE RemovePropW(HWND, LPCWSTR);
	int EnumPropsExW(HWND, PROPENUMPROCEX, LPARAM);
	int EnumPropsW(HWND, PROPENUMPROC);
	WINBOOL SetWindowTextW(HWND, LPCWSTR);
	int GetWindowTextW(HWND, LPWSTR, int);
	int GetWindowTextLengthW(HWND);
	int MessageBoxW(HWND, LPCWSTR, LPCWSTR, UINT);
	int MessageBoxExW(HWND, LPCWSTR, LPCWSTR, UINT, ushort);
	int MessageBoxIndirectW(LPMSGBOXPARAMS);
	LONG GetWindowLongW(HWND, int);
	LONG SetWindowLongW(HWND, int, LONG);
	DWORD GetClassLongW(HWND, int);
	DWORD SetClassLongW(HWND, int, LONG);
	HWND FindWindowW(LPCWSTR, LPCWSTR);
	HWND FindWindowExW(HWND, HWND, LPCWSTR, LPCWSTR);
	int GetClassNameW(HWND, LPWSTR, int);
	HHOOK SetWindowsHookExW(int, HOOKPROC, HINST, DWORD);
	HBITMAP LoadBitmapW(HINST, LPCWSTR);
	HCURSOR LoadCursorW(HINST, LPCWSTR);
	HCURSOR LoadCursorFromFileW(LPCWSTR);
	HICON LoadIconW(HINST, LPCWSTR);
	HANDLE LoadImageW(HINST, LPCWSTR, UINT, int, int, UINT);
	int LoadStringW(HINST, UINT, LPWSTR, int);
	WINBOOL IsDialogMessageW(HWND, LPMSG);
	int DlgDirListW(HWND, LPWSTR, int, int, UINT);
	WINBOOL DlgDirSelectExW(HWND, LPWSTR, int, int);
	int DlgDirListComboBoxW(HWND, LPWSTR, int, int, UINT);
	WINBOOL DlgDirSelectComboBoxExW(HWND, LPWSTR, int, int);
	LRESULT DefFrameProcW(HWND, HWND, UINT, WPARAM, LPARAM);
	LRESULT DefMDIChildProcW(HWND, UINT, WPARAM, LPARAM);
	HWND CreateMDIWindowW(LPWSTR, LPWSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM);
	WINBOOL WinHelpW(HWND, LPCWSTR, UINT, DWORD);
	LONG ChangeDisplaySettingsW(LPDEVMODE, DWORD);
	WINBOOL EnumDisplaySettingsW(LPCWSTR, DWORD, LPDEVMODE);
	WINBOOL SystemParametersInfoW(UINT, UINT, PVOID, UINT);
	int AddFontResourceW(LPCWSTR);
	HMETAFILE CopyMetaFileW(HMETAFILE, LPCWSTR);
	HFONT CreateFontIndirectW(PLOGFONT);
	HFONT CreateFontW(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCWSTR);
	HDC CreateICW(LPCWSTR, LPCWSTR, LPCWSTR, LPDEVMODE);
	HDC CreateMetaFileW(LPCWSTR);
	WINBOOL CreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);
	int EnumFontFamiliesExW(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD);
	int EnumFontFamiliesW(HDC, LPCWSTR, FONTENUMPROC, LPARAM);
	int EnumFontsW(HDC, LPCWSTR, ENUMFONTSPROC, LPARAM);
	WINBOOL GetCharWidthW(HDC, UINT, UINT, LPINT);
	WINBOOL GetCharWidth32W(HDC, UINT, UINT, LPINT);
	WINBOOL GetCharWidthFloatW(HDC, UINT, UINT, PFLOAT);
	WINBOOL GetCharABCWidthsW(HDC, UINT, UINT, LPABC);
	WINBOOL GetCharABCWidthsFloatW(HDC, UINT, UINT, LPABCFLOAT);
	DWORD GetGlyphOutlineW(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2);
	HMETAFILE GetMetaFileW(LPCWSTR);
	UINT GetOutlineTextMetricsW(HDC, UINT, LPOUTLINETEXTMETRIC);
	WINBOOL GetTextExtentPointW(HDC, LPCWSTR, int, LPSIZE);
	WINBOOL GetTextExtentPoint32W(HDC, LPCWSTR, int, LPSIZE);
	WINBOOL GetTextExtentExPointW(HDC, LPCWSTR, int, int, LPINT, LPINT, LPSIZE);
	DWORD GetCharacterPlacementW(HDC, LPCWSTR, int, int, LPGCP_RESULTS, DWORD);
	HDC ResetDCW(HDC, LPDEVMODE);
	WINBOOL RemoveFontResourceW(LPCWSTR);
	HENHMETAFILE CopyEnhMetaFileW(HENHMETAFILE, LPCWSTR);
	HDC CreateEnhMetaFileW(HDC, LPCWSTR, LPRECT, LPCWSTR);
	HENHMETAFILE GetEnhMetaFileW(LPCWSTR);
	UINT GetEnhMetaFileDescriptionW(HENHMETAFILE, UINT, LPWSTR);
	WINBOOL GetTextMetricsW(HDC, LPTEXTMETRIC);
	int StartDocW(HDC, PDOCINFO);
	int GetObjectW(HGDIOBJ, int, LPVOID);
	WINBOOL TextOutW(HDC, int, int, LPCWSTR, int);
	WINBOOL ExtTextOutW(HDC, int, int, UINT, LPRECT, LPCWSTR, UINT, LPINT);
	WINBOOL PolyTextOutW(HDC, PPOLYTEXT, int);
	int GetTextFaceW(HDC, int, LPWSTR);
	DWORD GetKerningPairsW(HDC, DWORD, LPKERNINGPAIR);
	WINBOOL GetLogColorSpaceW(HCOLORSPACE, LPLOGCOLORSPACE, DWORD);
	HCOLORSPACE CreateColorSpaceW(LPLOGCOLORSPACE);
	WINBOOL GetICMProfileW(HDC, DWORD, LPWSTR);
	WINBOOL SetICMProfileW(HDC, LPWSTR);
	WINBOOL UpdateICMRegKeyW(DWORD, DWORD, LPWSTR, UINT);
	int EnumICMProfilesW(HDC, ICMENUMPROC, LPARAM);
	HPROPSHEETPAGE CreatePropertySheetPageW(LPCPROPSHEETPAGE);
	int PropertySheetW(LPCPROPSHEETHEADER);
	HIMAGELIST ImageList_LoadImageW(HINST, LPCWSTR, int, int, COLORREF, UINT, UINT);
	HWND CreateStatusWindowW(LONG, LPCWSTR, HWND, UINT);
	void DrawStatusTextW(HDC, LPRECT, LPCWSTR);
	WINBOOL GetOpenFileNameW(LPOPENFILENAME);
	WINBOOL GetSaveFileNameW(LPOPENFILENAME);
	int GetFileTitleW(LPCWSTR, LPWSTR, ushort);
	WINBOOL ChooseColorW(LPCHOOSECOLOR);
	HWND ReplaceTextW(LPFINDREPLACE);
	WINBOOL ChooseFontW(LPCHOOSEFONT);
	HWND FindTextW(LPFINDREPLACE);
	WINBOOL PrintDlgW(LPPRINTDLG);
	WINBOOL PageSetupDlgW(LPPAGESETUPDLG);
	WINBOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
	void GetStartupInfoW(LPSTARTUPINFO);
	HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW);
	WINBOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW);
	WINBOOL GetVersionExW(LPOSVERSIONINFO);
	HDC CreateDCW(LPCWSTR, LPCWSTR, LPCWSTR, PDEVMODE);
	HFONT CreateFontA(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCSTR);
	DWORD VerInstallFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT);
	DWORD GetFileVersionInfoSizeW(LPWSTR, LPDWORD);
	WINBOOL GetFileVersionInfoW(LPWSTR, DWORD, DWORD, LPVOID);
	DWORD VerLanguageNameW(DWORD, LPWSTR, DWORD);
	WINBOOL VerQueryValueW(LPVOID, LPWSTR, LPVOID, PUINT);
	DWORD VerFindFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT, LPWSTR, PUINT);
	LONG RegSetValueExW(HKEY, LPCWSTR, DWORD, DWORD, LPBYTE, DWORD);
	LONG RegUnLoadKeyW(HKEY, LPCWSTR);
	WINBOOL InitiateSystemShutdownW(LPWSTR, LPWSTR, DWORD, WINBOOL, WINBOOL);
	WINBOOL AbortSystemShutdownW(LPWSTR);
	LONG RegRestoreKeyW(HKEY, LPCWSTR, DWORD);
	LONG RegSaveKeyW(HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES);
	LONG RegSetValueW(HKEY, LPCWSTR, DWORD, LPCWSTR, DWORD);
	LONG RegQueryValueW(HKEY, LPCWSTR, LPWSTR, PLONG);
	LONG RegQueryMultipleValuesW(HKEY, PVALENT, DWORD, LPWSTR, LPDWORD);
	LONG RegQueryValueExW(HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
	LONG RegReplaceKeyW(HKEY, LPCWSTR, LPCWSTR, LPCWSTR);
	LONG RegConnectRegistryW(LPWSTR, HKEY, PHKEY);
	LONG RegCreateKeyW(HKEY, LPCWSTR, PHKEY);
	LONG RegCreateKeyExW(HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
	LONG RegDeleteKeyW(HKEY, LPCWSTR);
	LONG RegDeleteValueW(HKEY, LPCWSTR);
	LONG RegEnumKeyW(HKEY, DWORD, LPWSTR, DWORD);
	LONG RegEnumKeyExW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPWSTR, LPDWORD, PFILETIME);
	LONG RegEnumValueW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
	LONG RegLoadKeyW(HKEY, LPCWSTR, LPCWSTR);
	LONG RegOpenKeyW(HKEY, LPCWSTR, PHKEY);
	LONG RegOpenKeyExW(HKEY, LPCWSTR, DWORD, REGSAM, PHKEY);
	LONG RegQueryInfoKeyW(HKEY, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
	int CompareStringW(LCID, DWORD, LPCWSTR, int, LPCWSTR, int);
	int LCMapStringW(LCID, DWORD, LPCWSTR, int, LPWSTR, int);
	int GetLocaleInfoW(LCID, LCTYPE, LPWSTR, int);
	WINBOOL SetLocaleInfoW(LCID, LCTYPE, LPCWSTR);
	int GetTimeFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int);
	int GetDateFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int);
	int GetNumberFormatW(LCID, DWORD, LPCWSTR, PNUMBERFMT, LPWSTR, int);
	int GetCurrencyFormatW(LCID, DWORD, LPCWSTR, PCURRENCYFMT, LPWSTR, int);
	WINBOOL EnumCalendarInfoW(CALINFO_ENUMPROC, LCID, CALID, CALTYPE);
	WINBOOL EnumTimeFormatsW(TIMEFMT_ENUMPROC, LCID, DWORD);
	WINBOOL EnumDateFormatsW(DATEFMT_ENUMPROC, LCID, DWORD);
	WINBOOL GetStringTypeExW(LCID, DWORD, LPCWSTR, int, LPWORD);
	WINBOOL GetStringTypeW(DWORD, LPCWSTR, int, LPWORD);
	int FoldStringW(DWORD, LPCWSTR, int, LPWSTR, int);
	WINBOOL EnumSystemLocalesW(LOCALE_ENUMPROC, DWORD);
	WINBOOL EnumSystemCodePagesW(CODEPAGE_ENUMPROC, DWORD);
	WINBOOL PeekConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL ReadConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL WriteConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
	WINBOOL ReadConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
	WINBOOL WriteConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
	WINBOOL ReadConsoleOutputCharacterW(HANDLE, LPWSTR, DWORD, COORD, LPDWORD);
	WINBOOL WriteConsoleOutputCharacterW(HANDLE, LPCWSTR, DWORD, COORD, LPDWORD);
	WINBOOL FillConsoleOutputCharacterW(HANDLE, WCHAR, DWORD, COORD, LPDWORD);
	WINBOOL ScrollConsoleScreenBufferW(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO);
	DWORD GetConsoleTitleW(LPWSTR, DWORD);
	WINBOOL SetConsoleTitleW(LPCWSTR);
	WINBOOL ReadConsoleW(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID);
	WINBOOL WriteConsoleW(HANDLE, POINTER, DWORD, LPDWORD, LPVOID);
	DWORD WNetAddConnectionW(LPCWSTR, LPCWSTR, LPCWSTR);
	DWORD WNetAddConnection2W(LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD);
	DWORD WNetAddConnection3W(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD);
	DWORD WNetCancelConnectionW(LPCWSTR, WINBOOL);
	DWORD WNetCancelConnection2W(LPCWSTR, DWORD, WINBOOL);
	DWORD WNetGetConnectionW(LPCWSTR, LPWSTR, LPDWORD);
	DWORD WNetUseConnectionW(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPDWORD, LPDWORD);
	DWORD WNetSetConnectionW(LPCWSTR, DWORD, LPVOID);
	DWORD WNetConnectionDialog1W(LPCONNECTDLGSTRUCT);
	DWORD WNetDisconnectDialog1W(LPDISCDLGSTRUCT);
	DWORD WNetOpenEnumW(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE);
	DWORD WNetEnumResourceW(HANDLE, LPDWORD, LPVOID, LPDWORD);
	DWORD WNetGetUniversalNameW(LPCWSTR, DWORD, LPVOID, LPDWORD);
	DWORD WNetGetUserW(LPCWSTR, LPWSTR, LPDWORD);
	DWORD WNetGetProviderNameW(DWORD, LPWSTR, LPDWORD);
	DWORD WNetGetNetworkInformationW(LPCWSTR, LPNETINFOSTRUCT);
	DWORD WNetGetLastErrorW(LPDWORD, LPWSTR, DWORD, LPWSTR, DWORD);
	DWORD MultinetGetConnectionPerformanceW(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT);
	WINBOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
	SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR);
	WINBOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD);
	WINBOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD);
	WINBOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD);
	SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD);
	SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD);
	WINBOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD);
	WINBOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR, LPHANDLER_FUNCTION);
	WINBOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY);
	WINBOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR);
	uint DragQueryFileW(HDROP, uint, LPCWSTR, uint);
	HICON ExtractAssociatedIconW(HINST, LPCWSTR, LPWORD);
	HICON ExtractIconW(HINST, LPCWSTR, uint);
	HINST FindExecutableW(LPCWSTR, LPCWSTR, LPCWSTR);
	int ShellAboutW(HWND, LPCWSTR, LPCWSTR, HICON);
	HINST ShellExecuteW(HWND, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, int);
	HSZ DdeCreateStringHandleW(DWORD, LPCWSTR, int);
	UINT DdeInitializeW(LPDWORD, PFNCALLBACK, DWORD, DWORD);
	DWORD DdeQueryStringW(DWORD, HSZ, LPCWSTR, DWORD, int);
	WINBOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE);
	WINBOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
	WINBOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, LPDWORD, LPDWORD, LPBOOL);
	LONG InterlockedIncrement(LPLONG);
	LONG InterlockedDecrement(LPLONG);
	LONG InterlockedExchange(LPLONG, LONG);
	WINBOOL FreeResource(HGLOBAL);
	LPVOID LockResource(HGLOBAL);
	WINBOOL FreeLibrary(HINST);
	void FreeLibraryAndExitThread(HMODULE, DWORD);
	WINBOOL DisableThreadLibraryCalls(HMODULE);
	FARPROC GetProcAddress(HINST, LPCSTR);
	DWORD GetVersion();
	HGLOBAL GlobalAlloc(UINT, DWORD);
	HGLOBAL GlobalReAlloc(HGLOBAL, DWORD, UINT);
	DWORD GlobalSize(HGLOBAL);
	UINT GlobalFlags(HGLOBAL);
	LPVOID GlobalLock(HGLOBAL);
	HGLOBAL GlobalHandle(LPCVOID);
	WINBOOL GlobalUnlock(HGLOBAL);
	HGLOBAL GlobalFree(HGLOBAL);
	UINT GlobalCompact(DWORD);
	void GlobalFix(HGLOBAL);
	void GlobalUnfix(HGLOBAL);
	LPVOID GlobalWire(HGLOBAL);
	WINBOOL GlobalUnWire(HGLOBAL);
	void GlobalMemoryStatus(LPMEMORYSTATUS);
	HLOCAL LocalAlloc(UINT, UINT);
	HLOCAL LocalReAlloc(HLOCAL, UINT, UINT);
	LPVOID LocalLock(HLOCAL);
	HLOCAL LocalHandle(LPCVOID);
	WINBOOL LocalUnlock(HLOCAL);
	UINT LocalSize(HLOCAL);
	UINT LocalFlags(HLOCAL);
	HLOCAL LocalFree(HLOCAL);
	UINT LocalShrink(HLOCAL, UINT);
	UINT LocalCompact(UINT);
	WINBOOL FlushInstructionCache(HANDLE, LPCVOID, DWORD);
	LPVOID VirtualAlloc(LPVOID, DWORD, DWORD, DWORD);
	WINBOOL VirtualFree(LPVOID, DWORD, DWORD);
	WINBOOL VirtualProtect(LPVOID, DWORD, DWORD, PDWORD);
	DWORD VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
	WINBOOL VirtualProtectEx(HANDLE, LPVOID, DWORD, DWORD, PDWORD);
	DWORD VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
	HANDLE HeapCreate(DWORD, DWORD, DWORD);
	WINBOOL HeapDestroy(HANDLE);
	LPVOID HeapAlloc(HANDLE, DWORD, DWORD);
	LPVOID HeapReAlloc(HANDLE, DWORD, LPVOID, DWORD);
	WINBOOL HeapFree(HANDLE, DWORD, LPVOID);
	DWORD HeapSize(HANDLE, DWORD, LPCVOID);
	WINBOOL HeapValidate(HANDLE, DWORD, LPCVOID);
	UINT HeapCompact(HANDLE, DWORD);
	HANDLE GetProcessHeap();
	DWORD GetProcessHeaps(DWORD, PHANDLE);
	WINBOOL HeapLock(HANDLE);
	WINBOOL HeapUnlock(HANDLE);
	WINBOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY);
	WINBOOL GetProcessAffinityMask(HANDLE, LPDWORD, LPDWORD);
	WINBOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
	WINBOOL GetProcessWorkingSetSize(HANDLE, LPDWORD, LPDWORD);
	WINBOOL SetProcessWorkingSetSize(HANDLE, DWORD, DWORD);
	HANDLE OpenProcess(DWORD, WINBOOL, DWORD);
	HANDLE GetCurrentProcess();
	DWORD GetCurrentProcessId();
	void ExitProcess(UINT);
	WINBOOL TerminateProcess(HANDLE, UINT);
	WINBOOL GetExitCodeProcess(HANDLE, LPDWORD);
	void FatalExit(int);
	void RaiseException(DWORD, DWORD, DWORD);
	LONG UnhandledExceptionFilter(EMPTYRECORD*);
	HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
	HANDLE GetCurrentThread();
	DWORD GetCurrentThreadId();
	DWORD SetThreadAffinityMask(HANDLE, DWORD);
	WINBOOL SetThreadPriority(HANDLE, int);
	int GetThreadPriority(HANDLE);
	WINBOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
	void ExitThread(DWORD);
	WINBOOL TerminateThread(HANDLE, DWORD);
	WINBOOL GetExitCodeThread(HANDLE, LPDWORD);
	WINBOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY);
	DWORD GetLastError();
	void SetLastError(DWORD);
	HANDLE CreateIoCompletionPort(HANDLE, HANDLE, DWORD, DWORD);
	UINT SetErrorMode(UINT);
	WINBOOL ReadProcessMemory(HANDLE, LPCVOID, LPVOID, DWORD, LPDWORD);
	WINBOOL WriteProcessMemory(HANDLE, LPVOID, LPVOID, DWORD, LPDWORD);
	WINBOOL GetThreadContext(HANDLE, LPCONTEXT);
	DWORD SuspendThread(HANDLE);
	DWORD ResumeThread(HANDLE);
	void DebugBreak();
	WINBOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD);
	WINBOOL ContinueDebugEvent(DWORD, DWORD, DWORD);
	WINBOOL DebugActiveProcess(DWORD);
	void InitializeCriticalSection(LPCRITICAL_SECTION);
	void EnterCriticalSection(LPCRITICAL_SECTION);
	WINBOOL TryEnterCriticalSection(LPCRITICAL_SECTION);
	void LeaveCriticalSection(LPCRITICAL_SECTION);
	void DeleteCriticalSection(LPCRITICAL_SECTION);
	WINBOOL SetEvent(HANDLE);
	WINBOOL ResetEvent(HANDLE);
	WINBOOL PulseEvent(HANDLE);
	WINBOOL ReleaseSemaphore(HANDLE, LONG, LPLONG);
	WINBOOL ReleaseMutex(HANDLE);
	DWORD WaitForSingleObject(HANDLE, DWORD);
	DWORD WaitForMultipleObjects(DWORD, HANDLE*, WINBOOL, DWORD);
	void Sleep(DWORD);
	HGLOBAL LoadResource(HINST, HRSRC);
	DWORD SizeofResource(HINST, HRSRC);
	ATOM GlobalDeleteAtom(ATOM);
	WINBOOL InitAtomTable(DWORD);
	ATOM DeleteAtom(ATOM);
	UINT SetHandleCount(UINT);
	DWORD GetLogicalDrives();
	WINBOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
	WINBOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
	WINBOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
	WINBOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED);
	WINBOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION);
	DWORD GetFileType(HANDLE);
	DWORD GetFileSize(HANDLE, LPDWORD);
	HANDLE GetStdHandle(DWORD);
	WINBOOL SetStdHandle(DWORD, HANDLE);
	WINBOOL FlushFileBuffers(HANDLE);
	WINBOOL DeviceIoControl(HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
	WINBOOL SetEndOfFile(HANDLE);
	DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD);
	WINBOOL FindClose(HANDLE);
	WINBOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME);
	WINBOOL SetFileTime(HANDLE, FILETIME*, FILETIME*, FILETIME*);
	WINBOOL CloseHandle(HANDLE);
	WINBOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, LPHANDLE, DWORD, WINBOOL, DWORD);
	WINBOOL GetHandleInformation(HANDLE, LPDWORD);
	WINBOOL SetHandleInformation(HANDLE, DWORD, DWORD);
	DWORD LoadModule(LPCSTR, LPVOID);
	UINT WinExec(LPCSTR, UINT);
	WINBOOL ClearCommBreak(HANDLE);
	WINBOOL ClearCommError(HANDLE, LPDWORD, LPCOMSTAT);
	WINBOOL SetupComm(HANDLE, DWORD, DWORD);
	WINBOOL EscapeCommFunction(HANDLE, DWORD);
	WINBOOL GetCommConfig(HANDLE, LPCOMMCONFIG, LPDWORD);
	WINBOOL GetCommProperties(HANDLE, LPCOMMPROP);
	WINBOOL GetCommModemStatus(HANDLE, PDWORD);
	WINBOOL GetCommState(HANDLE, PDCB);
	WINBOOL GetCommTimeouts(HANDLE, PCOMMTIMEOUTS);
	WINBOOL PurgeComm(HANDLE, DWORD);
	WINBOOL SetCommBreak(HANDLE);
	WINBOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD);
	WINBOOL SetCommMask(HANDLE, DWORD);
	WINBOOL SetCommState(HANDLE, TDCB*);
	WINBOOL SetCommTimeouts(HANDLE, TCOMMTIMEOUTS*);
	WINBOOL TransmitCommChar(HANDLE, char);
	WINBOOL WaitCommEvent(HANDLE, LPDWORD, LPOVERLAPPED);
	DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, WINBOOL);
	DWORD GetTapePosition(HANDLE, DWORD, LPDWORD, LPDWORD, LPDWORD);
	DWORD PrepareTape(HANDLE, DWORD, WINBOOL);
	DWORD EraseTape(HANDLE, DWORD, WINBOOL);
	DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD);
	DWORD WriteTapemark(HANDLE, DWORD, DWORD, WINBOOL);
	DWORD GetTapeStatus(HANDLE);
	DWORD GetTapeParameters(HANDLE, DWORD, LPDWORD, LPVOID);
	DWORD SetTapeParameters(HANDLE, DWORD, LPVOID);
	WINBOOL Beep(DWORD, DWORD);
	int MulDiv(int, int, int);
	void GetSystemTime(LPSYSTEMTIME);
        void GetSystemTimeAsFileTime(FILETIME*);
	WINBOOL SetSystemTime(SYSTEMTIME*);
	void GetLocalTime(LPSYSTEMTIME);
	WINBOOL SetLocalTime(SYSTEMTIME*);
	void GetSystemInfo(LPSYSTEM_INFO);
	WINBOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
	DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
	WINBOOL SetTimeZoneInformation(TIME_ZONE_INFORMATION*);
	WINBOOL SystemTimeToFileTime(SYSTEMTIME*, LPFILETIME);
	WINBOOL FileTimeToLocalFileTime(FILETIME*, LPFILETIME);
	WINBOOL LocalFileTimeToFileTime(FILETIME*, LPFILETIME);
	WINBOOL FileTimeToSystemTime(FILETIME*, LPSYSTEMTIME);
	LONG CompareFileTime(FILETIME*, FILETIME*);
	WINBOOL FileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD);
	WINBOOL DosDateTimeToFileTime(ushort, ushort, LPFILETIME);
	DWORD GetTickCount();
	WINBOOL SetSystemTimeAdjustment(DWORD, WINBOOL);
	WINBOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PWINBOOL);
	WINBOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
	WINBOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED);
	WINBOOL DisconnectNamedPipe(HANDLE);
	WINBOOL SetNamedPipeHandleState(HANDLE, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL GetNamedPipeInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL PeekNamedPipe(HANDLE, LPVOID, DWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL TransactNamedPipe(HANDLE, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
	WINBOOL GetMailslotInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
	WINBOOL SetMailslotInfo(HANDLE, DWORD);
	LPVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
	WINBOOL FlushViewOfFile(LPCVOID, DWORD);
	WINBOOL UnmapViewOfFile(LPVOID);
	HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT);
	HFILE _lopen(LPCSTR, int);
	HFILE _lcreat(LPCSTR, int);
	UINT _lread(HFILE, LPVOID, UINT);
	UINT _lwrite(HFILE, LPCSTR, UINT);
	int _hread(HFILE, LPVOID, int);
	int _hwrite(HFILE, LPCSTR, int);
	HFILE _lclose(HFILE);
	LONG _llseek(HFILE, LONG, int);
	WINBOOL IsTextUnicode(LPVOID, int, LPINT);
	DWORD TlsAlloc();
	LPVOID TlsGetValue(DWORD);
	WINBOOL TlsSetValue(DWORD, LPVOID);
	WINBOOL TlsFree(DWORD);
	DWORD SleepEx(DWORD, WINBOOL);
	DWORD WaitForSingleObjectEx(HANDLE, DWORD, WINBOOL);
	DWORD WaitForMultipleObjectsEx(DWORD, HANDLE*, WINBOOL, DWORD, WINBOOL);
	WINBOOL ReadFileEx(HANDLE, LPVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
	WINBOOL WriteFileEx(HANDLE, LPCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
	WINBOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*);
	WINBOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*);
	WINBOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*);
	WINBOOL SetProcessShutdownParameters(DWORD, DWORD);
	WINBOOL GetProcessShutdownParameters(LPDWORD, LPDWORD);
	void SetFileApisToOEM();
	void SetFileApisToANSI();
	WINBOOL AreFileApisANSI();
	WINBOOL CloseEventLog(HANDLE);
	WINBOOL DeregisterEventSource(HANDLE);
	WINBOOL NotifyChangeEventLog(HANDLE, HANDLE);
	WINBOOL GetNumberOfEventLogRecords(HANDLE, PDWORD);
	WINBOOL GetOldestEventLogRecord(HANDLE, PDWORD);
	WINBOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE);
	WINBOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	WINBOOL ImpersonateNamedPipeClient(HANDLE);
	WINBOOL ImpersonateLoggedOnUser(HANDLE);
	WINBOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
	WINBOOL RevertToSelf();
	WINBOOL SetThreadToken(PHANDLE, HANDLE);
	WINBOOL OpenProcessToken(HANDLE, DWORD, PHANDLE);
	WINBOOL OpenThreadToken(HANDLE, DWORD, WINBOOL, PHANDLE);
	WINBOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD, PDWORD);
	WINBOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD);
	WINBOOL AdjustTokenPrivileges(HANDLE, WINBOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
	WINBOOL AdjustTokenGroups(HANDLE, WINBOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD);
	WINBOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, LPBOOL);
	WINBOOL IsValidSid(PSID);
	WINBOOL EqualSid(PSID, PSID);
	WINBOOL EqualPrefixSid(PSID, PSID);
	DWORD GetSidLengthRequired(UCHAR);
	WINBOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, ubyte, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
	PVOID FreeSid(PSID);
	WINBOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, ubyte);
	PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID);
	PDWORD GetSidSubAuthority(PSID, DWORD);
	PUCHAR GetSidSubAuthorityCount(PSID);
	DWORD GetLengthSid(PSID);
	WINBOOL CopySid(DWORD, PSID, PSID);
	WINBOOL AreAllAccessesGranted(DWORD, DWORD);
	WINBOOL AreAnyAccessesGranted(DWORD, DWORD);
	void MapGenericMask(PDWORD);
	WINBOOL IsValidAcl(PACL);
	WINBOOL InitializeAcl(PACL, DWORD, DWORD);
	WINBOOL GetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS);
	WINBOOL SetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS);
	WINBOOL AddAce(PACL, DWORD, DWORD, LPVOID, DWORD);
	WINBOOL DeleteAce(PACL, DWORD);
	WINBOOL GetAce(PACL, DWORD, LPVOID*);
	WINBOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID);
	WINBOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID);
	WINBOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, WINBOOL, WINBOOL);
	WINBOOL FindFirstFreeAce(PACL, LPVOID*);
	WINBOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD);
	WINBOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
	DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
	WINBOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, LPDWORD);
	WINBOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL);
	WINBOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
	WINBOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL);
	WINBOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
	WINBOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, WINBOOL);
	WINBOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
	WINBOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, WINBOOL);
	WINBOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
	WINBOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, WINBOOL, HANDLE, PGENERIC_MAPPING);
	WINBOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE);
	WINBOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
	WINBOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR);
	WINBOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD);
	WINBOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD, PACL, LPDWORD, PACL, LPDWORD, PSID, LPDWORD, PSID, LPDWORD);
	WINBOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	WINBOOL FindNextChangeNotification(HANDLE);
	WINBOOL FindCloseChangeNotification(HANDLE);
	WINBOOL VirtualLock(LPVOID, DWORD);
	WINBOOL VirtualUnlock(LPVOID, DWORD);
	LPVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPVOID);
	WINBOOL SetPriorityClass(HANDLE, DWORD);
	DWORD GetPriorityClass(HANDLE);
	WINBOOL IsBadReadPtr(POINTER, UINT);
	WINBOOL IsBadWritePtr(LPVOID, UINT);
	WINBOOL IsBadHugeReadPtr(POINTER, UINT);
	WINBOOL IsBadHugeWritePtr(LPVOID, UINT);
	WINBOOL IsBadCodePtr(FARPROC);
	WINBOOL AllocateLocallyUniqueId(PLUID);
	WINBOOL QueryPerformanceCounter(PLARGE_INTEGER);
	WINBOOL QueryPerformanceFrequency(PLARGE_INTEGER);
	WINBOOL ActivateKeyboardLayout(HKL, UINT);
	WINBOOL UnloadKeyboardLayout(HKL);
	int GetKeyboardLayoutList(int, HKL*);
	HKL GetKeyboardLayout(DWORD);
	HDESK OpenInputDesktop(DWORD, WINBOOL, DWORD);
	WINBOOL EnumDesktopWindows(HDESK, ENUMWINDOWSPROC, LPARAM);
	WINBOOL SwitchDesktop(HDESK);
	WINBOOL SetThreadDesktop(HDESK);
	WINBOOL CloseDesktop(HDESK);
	HDESK GetThreadDesktop(DWORD);
	WINBOOL CloseWindowStation(HWINSTA);
	WINBOOL SetProcessWindowStation(HWINSTA);
	HWINSTA GetProcessWindowStation();
	WINBOOL SetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	WINBOOL GetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	WINBOOL TranslateMessage(LPMSG);
	WINBOOL SetMessageQueue(int);
	WINBOOL RegisterHotKey(HWND, int, UINT, UINT);
	WINBOOL UnregisterHotKey(HWND, int);
	WINBOOL ExitWindowsEx(UINT, DWORD);
	WINBOOL SwapMouseButton(WINBOOL);
	DWORD GetMessagePos();
	LONG GetMessageTime();
	LONG GetMessageExtraInfo();
	LPARAM SetMessageExtraInfo(LPARAM);
	int BroadcastSystemMessage(DWORD, LPDWORD, UINT, WPARAM, LPARAM);
	WINBOOL AttachThreadInput(DWORD, DWORD, WINBOOL);
	WINBOOL ReplyMessage(LRESULT);
	WINBOOL WaitMessage();
	DWORD WaitForInputIdle(HANDLE, DWORD);
	void PostQuitMessage(int);
	WINBOOL InSendMessage();
	UINT GetDoubleClickTime();
	WINBOOL SetDoubleClickTime(UINT);
	WINBOOL IsWindow(HWND);
	WINBOOL IsMenu(HMENU);
	WINBOOL IsChild(HWND, HWND);
	WINBOOL DestroyWindow(HWND);
	WINBOOL ShowWindow(HWND, int);
	WINBOOL ShowWindowAsync(HWND, int);
	WINBOOL FlashWindow(HWND, WINBOOL);
	WINBOOL ShowOwnedPopups(HWND, WINBOOL);
	WINBOOL OpenIcon(HWND);
	WINBOOL CloseWindow(HWND);
	WINBOOL MoveWindow(HWND, int, int, int, int, WINBOOL);
	WINBOOL SetWindowPos(HWND, HWND, int, int, int, int, UINT);
	WINBOOL GetWindowPlacement(HWND, WINDOWPLACEMENT*);
	WINBOOL SetWindowPlacement(HWND, WINDOWPLACEMENT*);
	HDWP BeginDeferWindowPos(int);
	HDWP DeferWindowPos(HDWP, HWND, HWND, int, int, int, int, UINT);
	WINBOOL EndDeferWindowPos(HDWP);
	WINBOOL IsWindowVisible(HWND);
	WINBOOL IsIconic(HWND);
	WINBOOL AnyPopup();
	WINBOOL BringWindowToTop(HWND);
	WINBOOL IsZoomed(HWND);
	WINBOOL EndDialog(HWND, int);
	HWND GetDlgItem(HWND, int);
	WINBOOL SetDlgItemInt(HWND, int, UINT, WINBOOL);
	UINT GetDlgItemInt(HWND, int, WINBOOL*, WINBOOL);
	WINBOOL CheckDlgButton(HWND, int, UINT);
	WINBOOL CheckRadioButton(HWND, int, int, int);
	UINT IsDlgButtonChecked(HWND, int);
	HWND GetNextDlgGroupItem(HWND, HWND, WINBOOL);
	HWND GetNextDlgTabItem(HWND, HWND, WINBOOL);
	int GetDlgCtrlID(HWND);
	int GetDialogBaseUnits();
	WINBOOL OpenClipboard(HWND);
	WINBOOL CloseClipboard();
	HWND GetClipboardOwner();
	HWND SetClipboardViewer(HWND);
	HWND GetClipboardViewer();
	WINBOOL ChangeClipboardChain(HWND, HWND);
	HANDLE SetClipboardData(UINT, HANDLE);
	HANDLE GetClipboardData(UINT);
	int CountClipboardFormats();
	UINT EnumClipboardFormats(UINT);
	WINBOOL EmptyClipboard();
	WINBOOL IsClipboardFormatAvailable(UINT);
	int GetPriorityClipboardFormat(UINT*, int);
	HWND GetOpenClipboardWindow();
	LPSTR CharNextExA(ushort, LPCSTR, DWORD);
	LPSTR CharPrevExA(ushort, LPCSTR, LPCSTR, DWORD);
	HWND SetFocus(HWND);
	HWND GetActiveWindow();
	HWND GetFocus();
	UINT GetKBCodePage();
	SHORT GetKeyState(int);
	SHORT GetAsyncKeyState(int);
	WINBOOL GetKeyboardState(PBYTE);
	WINBOOL SetKeyboardState(LPBYTE);
	int GetKeyboardType(int);
	int ToAscii(UINT, UINT, PBYTE, LPWORD, UINT);
	int ToAsciiEx(UINT, UINT, PBYTE, LPWORD, UINT, HKL);
	int ToUnicode(UINT, UINT, PBYTE, LPWSTR, int, UINT);
	DWORD OemKeyScan(ushort);
	void keybd_event(ubyte, ubyte, DWORD);
	void mouse_event(DWORD, DWORD, DWORD, DWORD);
	WINBOOL GetInputState();
	DWORD GetQueueStatus(UINT);
	HWND GetCapture();
	HWND SetCapture(HWND);
	WINBOOL ReleaseCapture();
	DWORD MsgWaitForMultipleObjects(DWORD, LPHANDLE, WINBOOL, DWORD, DWORD);
	UINT SetTimer(HWND, UINT, UINT, TIMERPROC);
	WINBOOL KillTimer(HWND, UINT);
	WINBOOL IsWindowUnicode(HWND);
	WINBOOL EnableWindow(HWND, WINBOOL);
	WINBOOL IsWindowEnabled(HWND);
	WINBOOL DestroyAcceleratorTable(HACCEL);
	int GetSystemMetrics(int);
	HMENU GetMenu(HWND);
	WINBOOL SetMenu(HWND, HMENU);
	WINBOOL HiliteMenuItem(HWND, HMENU, UINT, UINT);
	UINT GetMenuState(HMENU, UINT, UINT);
	WINBOOL DrawMenuBar(HWND);
	HMENU GetSystemMenu(HWND, WINBOOL);
	HMENU CreateMenu();
	HMENU CreatePopupMenu();
	WINBOOL DestroyMenu(HMENU);
	DWORD CheckMenuItem(HMENU, UINT, UINT);
	WINBOOL EnableMenuItem(HMENU, UINT, UINT);
	HMENU GetSubMenu(HMENU, int);
	UINT GetMenuItemID(HMENU, int);
	int GetMenuItemCount(HMENU);
	WINBOOL RemoveMenu(HMENU, UINT, UINT);
	WINBOOL DeleteMenu(HMENU, UINT, UINT);
	WINBOOL SetMenuItemBitmaps(HMENU, UINT, UINT, HBITMAP, HBITMAP);
	LONG GetMenuCheckMarkDimensions();
	WINBOOL TrackPopupMenu(HMENU, UINT, int, int, int, HWND, RECT*);
	UINT GetMenuDefaultItem(HMENU, UINT, UINT);
	WINBOOL SetMenuDefaultItem(HMENU, UINT, UINT);
	WINBOOL GetMenuItemRect(HWND, HMENU, UINT, LPRECT);
	int MenuItemFromPoint(HWND, HMENU, POINT);
	DWORD DragObject(HWND, HWND, UINT, DWORD, HCURSOR);
	WINBOOL DragDetect(HWND, POINT);
	WINBOOL DrawIcon(HDC, int, int, HICON);
	WINBOOL UpdateWindow(HWND);
	HWND SetActiveWindow(HWND);
	HWND GetForegroundWindow();
	WINBOOL PaintDesktop(HDC);
	WINBOOL SetForegroundWindow(HWND);
	HWND WindowFromDC(HDC);
	HDC GetDC(HWND);
	HDC GetDCEx(HWND, HRGN, DWORD);
	HDC GetWindowDC(HWND);
	int ReleaseDC(HWND, HDC);
	HDC BeginPaint(HWND, LPPAINTSTRUCT);
	WINBOOL EndPaint(HWND, LPPAINTSTRUCT);
	WINBOOL GetUpdateRect(HWND, LPRECT, WINBOOL);
	int GetUpdateRgn(HWND, HRGN, WINBOOL);
	int SetWindowRgn(HWND, HRGN, WINBOOL);
	int GetWindowRgn(HWND, HRGN);
	int ExcludeUpdateRgn(HDC, HWND);
	WINBOOL InvalidateRect(HWND, RECT*, WINBOOL);
	WINBOOL ValidateRect(HWND, RECT*);
	WINBOOL InvalidateRgn(HWND, HRGN, WINBOOL);
	WINBOOL ValidateRgn(HWND, HRGN);
	WINBOOL RedrawWindow(HWND, RECT*, HRGN, UINT);
	WINBOOL LockWindowUpdate(HWND);
	WINBOOL ScrollWindow(HWND, int, int, RECT*, RECT*);
	WINBOOL ScrollDC(HDC, int, int, RECT*, RECT*, HRGN, LPRECT);
	int ScrollWindowEx(HWND, int, int, RECT*, RECT*, HRGN, LPRECT, UINT);
	int SetScrollPos(HWND, int, int, WINBOOL);
	int GetScrollPos(HWND, int);
	WINBOOL SetScrollRange(HWND, int, int, int, WINBOOL);
	WINBOOL GetScrollRange(HWND, int, LPINT, LPINT);
	WINBOOL ShowScrollBar(HWND, int, WINBOOL);
	WINBOOL EnableScrollBar(HWND, UINT, UINT);
	WINBOOL GetClientRect(HWND, LPRECT);
	WINBOOL GetWindowRect(HWND, LPRECT);
	WINBOOL AdjustWindowRect(LPRECT, DWORD, WINBOOL);
	WINBOOL AdjustWindowRectEx(LPRECT, DWORD, WINBOOL, DWORD);
	WINBOOL SetWindowContextHelpId(HWND, DWORD);
	DWORD GetWindowContextHelpId(HWND);
	WINBOOL SetMenuContextHelpId(HMENU, DWORD);
	DWORD GetMenuContextHelpId(HMENU);
	WINBOOL MessageBeep(UINT);
	int ShowCursor(WINBOOL);
	WINBOOL SetCursorPos(int, int);
	HCURSOR SetCursor(HCURSOR);
	WINBOOL GetCursorPos(LPPOINT);
	WINBOOL ClipCursor(RECT*);
	WINBOOL GetClipCursor(LPRECT);
	HCURSOR GetCursor();
	WINBOOL CreateCaret(HWND, HBITMAP, int, int);
	UINT GetCaretBlinkTime();
	WINBOOL SetCaretBlinkTime(UINT);
	WINBOOL DestroyCaret();
	WINBOOL HideCaret(HWND);
	WINBOOL ShowCaret(HWND);
	WINBOOL SetCaretPos(int, int);
	WINBOOL GetCaretPos(LPPOINT);
	WINBOOL ClientToScreen(HWND, LPPOINT);
	WINBOOL ScreenToClient(HWND, LPPOINT);
	int MapWindowPoints(HWND, HWND, LPPOINT, UINT);
	HWND WindowFromPoint(POINT);
	HWND ChildWindowFromPoint(HWND, POINT);
	DWORD GetSysColor(int);
	HBRUSH GetSysColorBrush(int);
	WINBOOL SetSysColors(int, WINT*, COLORREF*);
	WINBOOL DrawFocusRect(HDC, RECT*);
	int FillRect(HDC, RECT*, HBRUSH);
	int FrameRect(HDC, RECT*, HBRUSH);
	WINBOOL InvertRect(HDC, RECT*);
	WINBOOL SetRect(LPRECT, int, int, int, int);
	WINBOOL SetRectEmpty(LPRECT);
	WINBOOL CopyRect(LPRECT, RECT*);
	WINBOOL InflateRect(LPRECT, int, int);
	WINBOOL IntersectRect(LPRECT, RECT*, RECT*);
	WINBOOL UnionRect(LPRECT, RECT*, RECT*);
	WINBOOL SubtractRect(LPRECT, RECT*, RECT*);
	WINBOOL OffsetRect(LPRECT, int, int);
	WINBOOL IsRectEmpty(RECT*);
	WINBOOL EqualRect(RECT*, RECT*);
	WINBOOL PtInRect(RECT*, POINT);
	ushort GetWindowWord(HWND, int);
	ushort SetWindowWord(HWND, int, ushort);
	ushort GetClassWord(HWND, int);
	ushort SetClassWord(HWND, int, ushort);
	HWND GetDesktopWindow();
	HWND GetParent(HWND);
	HWND SetParent(HWND, HWND);
	WINBOOL EnumChildWindows(HWND, ENUMWINDOWSPROC, LPARAM);
	WINBOOL EnumWindows(ENUMWINDOWSPROC, LPARAM);
	WINBOOL EnumThreadWindows(DWORD, ENUMWINDOWSPROC, LPARAM);
	HWND GetTopWindow(HWND);
	DWORD GetWindowThreadProcessId(HWND, LPDWORD);
	HWND GetLastActivePopup(HWND);
	HWND GetWindow(HWND, UINT);
	WINBOOL UnhookWindowsHook(int, HOOKPROC);
	WINBOOL UnhookWindowsHookEx(HHOOK);
	LRESULT CallNextHookEx(HHOOK, int, WPARAM, LPARAM);
	WINBOOL CheckMenuRadioItem(HMENU, UINT, UINT, UINT, UINT);
	HCURSOR CreateCursor(HINST, int, int, int, int, POINTER, POINTER);
	WINBOOL DestroyCursor(HCURSOR);
	WINBOOL SetSystemCursor(HCURSOR, DWORD);
	HICON CreateIcon(HINST, int, int, ubyte, ubyte, ubyte*, ubyte*);
	WINBOOL DestroyIcon(HICON);
	int LookupIconIdFromDirectory(PBYTE, WINBOOL);
	int LookupIconIdFromDirectoryEx(PBYTE, WINBOOL, int, int, UINT);
	HICON CreateIconFromResource(PBYTE, DWORD, WINBOOL, DWORD);
	HICON CreateIconFromResourceEx(PBYTE, DWORD, WINBOOL, DWORD, int, int, UINT);
	HICON CopyImage(HANDLE, UINT, int, int, UINT);
	HICON CreateIconIndirect(PICONINFO);
	HICON CopyIcon(HICON);
	WINBOOL GetIconInfo(HICON, PICONINFO);
	WINBOOL MapDialogRect(HWND, LPRECT);
	int SetScrollInfo(HWND, int, LPCSCROLLINFO, WINBOOL);
	WINBOOL GetScrollInfo(HWND, int, LPSCROLLINFO);
	WINBOOL TranslateMDISysAccel(HWND, LPMSG);
	UINT ArrangeIconicWindows(HWND);
	ushort TileWindows(HWND, UINT, RECT*, UINT, HWND*);
	ushort CascadeWindows(HWND, UINT, RECT*, UINT, HWND*);
	void SetLastErrorEx(DWORD);
	void SetDebugErrorLevel(DWORD);
	WINBOOL DrawEdge(HDC, LPRECT, UINT, UINT);
	WINBOOL DrawFrameControl(HDC, LPRECT, UINT, UINT);
	WINBOOL DrawCaption(HWND, HDC, RECT*, UINT);
	WINBOOL DrawAnimatedRects(HWND, int, RECT*, RECT*);
	WINBOOL TrackPopupMenuEx(HMENU, UINT, int, int, HWND, LPTPMPARAMS);
	HWND ChildWindowFromPointEx(HWND, POINT, UINT);
	WINBOOL DrawIconEx(HDC, int, int, HICON, int, int, UINT, HBRUSH, UINT);
	WINBOOL AnimatePalette(HPALETTE, UINT, UINT, PALETTEENTRY*);
	WINBOOL Arc(HDC, int, int, int, int, int, int, int, int);
	WINBOOL BitBlt(HDC, int, int, int, int, HDC, int, int, DWORD);
	WINBOOL CancelDC(HDC);
	WINBOOL Chord(HDC, int, int, int, int, int, int, int, int);
	HMETAFILE CloseMetaFile(HDC);
	int CombineRgn(HRGN, HRGN, HRGN, int);
	HBITMAP CreateBitmap(int, int, UINT, UINT, POINTER);
	HBITMAP CreateBitmapIndirect(BITMAP*);
	HBRUSH CreateBrushIndirect(LOGBRUSH*);
	HBITMAP CreateCompatibleBitmap(HDC, int, int);
	HBITMAP CreateDiscardableBitmap(HDC, int, int);
	HDC CreateCompatibleDC(HDC);
	HBITMAP CreateDIBitmap(HDC, BITMAPINFOHEADER*, DWORD, POINTER, BITMAPINFO*, UINT);
	HBRUSH CreateDIBPatternBrush(HGLOBAL, UINT);
	HBRUSH CreateDIBPatternBrushPt(POINTER, UINT);
	HRGN CreateEllipticRgn(int, int, int, int);
	HRGN CreateEllipticRgnIndirect(RECT*);
	HBRUSH CreateHatchBrush(int, COLORREF);
	HPALETTE CreatePalette(LOGPALETTE*);
	HPEN CreatePen(int, int, COLORREF);
	HPEN CreatePenIndirect(LOGPEN*);
	HRGN CreatePolyPolygonRgn(POINT*, WINT*, int, int);
	HBRUSH CreatePatternBrush(HBITMAP);
	HRGN CreateRectRgn(int, int, int, int);
	HRGN CreateRectRgnIndirect(RECT*);
	HRGN CreateRoundRectRgn(int, int, int, int, int, int);
	HBRUSH CreateSolidBrush(COLORREF);
	WINBOOL DeleteDC(HDC);
	WINBOOL DeleteMetaFile(HMETAFILE);
	WINBOOL DeleteObject(HGDIOBJ);
	int DrawEscape(HDC, int, int, LPCSTR);
	WINBOOL Ellipse(HDC, int, int, int, int);
	int EnumObjects(HDC, int, ENUMOBJECTSPROC, LPARAM);
	WINBOOL EqualRgn(HRGN, HRGN);
	int Escape(HDC, int, int, LPCSTR, LPVOID);
	int ExtEscape(HDC, int, int, LPCSTR, int, LPSTR);
	int ExcludeClipRect(HDC, int, int, int, int);
	HRGN ExtCreateRegion(XFORM*, DWORD, RGNDATA*);
	WINBOOL ExtFloodFill(HDC, int, int, COLORREF, UINT);
	WINBOOL FillRgn(HDC, HRGN, HBRUSH);
	WINBOOL FloodFill(HDC, int, int, COLORREF);
	WINBOOL FrameRgn(HDC, HRGN, HBRUSH, int, int);
	int GetROP2(HDC);
	WINBOOL GetAspectRatioFilterEx(HDC, LPSIZE);
	COLORREF GetBkColor(HDC);
	int GetBkMode(HDC);
	LONG GetBitmapBits(HBITMAP, LONG, LPVOID);
	WINBOOL GetBitmapDimensionEx(HBITMAP, LPSIZE);
	UINT GetBoundsRect(HDC, LPRECT, UINT);
	WINBOOL GetBrushOrgEx(HDC, LPPOINT);
	int GetClipBox(HDC, LPRECT);
	int GetClipRgn(HDC, HRGN);
	int GetMetaRgn(HDC, HRGN);
	HGDIOBJ GetCurrentObject(HDC, UINT);
	WINBOOL GetCurrentPositionEx(HDC, LPPOINT);
	int GetDeviceCaps(HDC, int);
	int GetDIBits(HDC, HBITMAP, UINT, UINT, LPVOID, LPBITMAPINFO, UINT);
	DWORD GetFontData(HDC, DWORD, DWORD, LPVOID, DWORD);
	int GetGraphicsMode(HDC);
	int GetMapMode(HDC);
	UINT GetMetaFileBitsEx(HMETAFILE, UINT, LPVOID);
	COLORREF GetNearestColor(HDC, COLORREF);
	UINT GetNearestPaletteIndex(HPALETTE, COLORREF);
	DWORD GetObjectType(HGDIOBJ);
	UINT GetPaletteEntries(HPALETTE, UINT, UINT, LPPALETTEENTRY);
	COLORREF GetPixel(HDC, int, int);
	int GetPixelFormat(HDC);
	int GetPolyFillMode(HDC);
	WINBOOL GetRasterizerCaps(LPRASTERIZER_STATUS, UINT);
	DWORD GetRegionData(HRGN, DWORD, LPRGNDATA);
	int GetRgnBox(HRGN, LPRECT);
	HGDIOBJ GetStockObject(int);
	int GetStretchBltMode(HDC);
	UINT GetSystemPaletteEntries(HDC, UINT, UINT, LPPALETTEENTRY);
	UINT GetSystemPaletteUse(HDC);
	int GetTextCharacterExtra(HDC);
	UINT GetTextAlign(HDC);
	COLORREF GetTextColor(HDC);
	int GetTextCharset(HDC);
	int GetTextCharsetInfo(HDC, LPFONTSIGNATURE, DWORD);
	WINBOOL TranslateCharsetInfo(DWORD*, LPCHARSETINFO, DWORD);
	DWORD GetFontLanguageInfo(HDC);
	WINBOOL GetViewportExtEx(HDC, LPSIZE);
	WINBOOL GetViewportOrgEx(HDC, LPPOINT);
	WINBOOL GetWindowExtEx(HDC, LPSIZE);
	WINBOOL GetWindowOrgEx(HDC, LPPOINT);
	int IntersectClipRect(HDC, int, int, int, int);
	WINBOOL InvertRgn(HDC, HRGN);
	WINBOOL LineDDA(int, int, int, int, LINEDDAPROC, LPARAM);
	WINBOOL LineTo(HDC, int, int);
	WINBOOL MaskBlt(HDC, int, int, int, int, HDC, int, int, HBITMAP, int, int, DWORD);
	WINBOOL PlgBlt(HDC, POINT*, HDC, int, int, int, int, HBITMAP, int, int);
	int OffsetClipRgn(HDC, int, int);
	int OffsetRgn(HRGN, int, int);
	WINBOOL PatBlt(HDC, int, int, int, int, DWORD);
	WINBOOL Pie(HDC, int, int, int, int, int, int, int, int);
	WINBOOL PlayMetaFile(HDC, HMETAFILE);
	WINBOOL PaintRgn(HDC, HRGN);
	WINBOOL PolyPolygon(HDC, POINT*, WINT*, int);
	WINBOOL PtInRegion(HRGN, int, int);
	WINBOOL PtVisible(HDC, int, int);
	WINBOOL RectInRegion(HRGN, RECT*);
	WINBOOL RectVisible(HDC, RECT*);
	WINBOOL Rectangle(HDC, int, int, int, int);
	WINBOOL RestoreDC(HDC, int);
	UINT RealizePalette(HDC);
	WINBOOL RoundRect(HDC, int, int, int, int, int, int);
	WINBOOL ResizePalette(HPALETTE, UINT);
	int SaveDC(HDC);
	int SelectClipRgn(HDC, HRGN);
	int ExtSelectClipRgn(HDC, HRGN, int);
	int SetMetaRgn(HDC);
	HGDIOBJ SelectObject(HDC, HGDIOBJ);
	HPALETTE SelectPalette(HDC, HPALETTE, WINBOOL);
	COLORREF SetBkColor(HDC, COLORREF);
	int SetBkMode(HDC, int);
	LONG SetBitmapBits(HBITMAP, DWORD, POINTER);
	UINT SetBoundsRect(HDC, RECT*, UINT);
	int SetDIBits(HDC, HBITMAP, UINT, UINT, POINTER, PBITMAPINFO, UINT);
	int SetDIBitsToDevice(HDC, int, int, DWORD, DWORD, int, int, UINT, UINT, POINTER, BITMAPINFO*, UINT);
	DWORD SetMapperFlags(HDC, DWORD);
	int SetGraphicsMode(HDC, int);
	int SetMapMode(HDC, int);
	HMETAFILE SetMetaFileBitsEx(UINT, ubyte*);
	UINT SetPaletteEntries(HPALETTE, UINT, UINT, PALETTEENTRY*);
	COLORREF SetPixel(HDC, int, int, COLORREF);
	WINBOOL SetPixelV(HDC, int, int, COLORREF);
	int SetPolyFillMode(HDC, int);
	WINBOOL StretchBlt(HDC, int, int, int, int, HDC, int, int, int, int, DWORD);
	WINBOOL SetRectRgn(HRGN, int, int, int, int);
	int StretchDIBits(HDC, int, int, int, int, int, int, int, int, POINTER, BITMAPINFO*, UINT, DWORD);
	int SetROP2(HDC, int);
	int SetStretchBltMode(HDC, int);
	UINT SetSystemPaletteUse(HDC, UINT);
	int SetTextCharacterExtra(HDC, int);
	COLORREF SetTextColor(HDC, COLORREF);
	UINT SetTextAlign(HDC, UINT);
	WINBOOL SetTextJustification(HDC, int, int);
	WINBOOL UpdateColors(HDC);
	WINBOOL PlayMetaFileRecord(HDC, LPHANDLETABLE, LPMETARECORD, UINT);
	WINBOOL EnumMetaFile(HDC, HMETAFILE, ENUMMETAFILEPROC, LPARAM);
	HENHMETAFILE CloseEnhMetaFile(HDC);
	WINBOOL DeleteEnhMetaFile(HENHMETAFILE);
	WINBOOL EnumEnhMetaFile(HDC, HENHMETAFILE, ENHMETAFILEPROC, LPVOID, RECT*);
	UINT GetEnhMetaFileHeader(HENHMETAFILE, UINT, LPENHMETAHEADER);
	UINT GetEnhMetaFilePaletteEntries(HENHMETAFILE, UINT, LPPALETTEENTRY);
	UINT GetWinMetaFileBits(HENHMETAFILE, UINT, LPBYTE, WINT, HDC);
	WINBOOL PlayEnhMetaFile(HDC, HENHMETAFILE, RECT*);
	WINBOOL PlayEnhMetaFileRecord(HDC, LPHANDLETABLE, ENHMETARECORD*, UINT);
	HENHMETAFILE SetEnhMetaFileBits(UINT, ubyte*);
	HENHMETAFILE SetWinMetaFileBits(UINT, ubyte*, HDC, METAFILEPICT*);
	WINBOOL GdiComment(HDC, UINT, ubyte*);
	WINBOOL AngleArc(HDC, int, int, DWORD, FLOAT, FLOAT);
	WINBOOL PolyPolyline(HDC, POINT*, DWORD*, DWORD);
	WINBOOL GetWorldTransform(HDC, LPXFORM);
	WINBOOL SetWorldTransform(HDC, XFORM*);
	WINBOOL ModifyWorldTransform(HDC, XFORM*, DWORD);
	WINBOOL CombineTransform(LPXFORM, XFORM*, XFORM*);
	HBITMAP CreateDIBSection(HDC, BITMAPINFO*, UINT, POINTER*, HANDLE, DWORD);
	UINT GetDIBColorTable(HDC, UINT, UINT, RGBQUAD*);
	UINT SetDIBColorTable(HDC, UINT, UINT, RGBQUAD*);
	WINBOOL SetColorAdjustment(HDC, COLORADJUSTMENT*);
	WINBOOL GetColorAdjustment(HDC, LPCOLORADJUSTMENT);
	HPALETTE CreateHalftonePalette(HDC);
	int EndDoc(HDC);
	int StartPage(HDC);
	int EndPage(HDC);
	int AbortDoc(HDC);
	int SetAbortProc(HDC, TABORTPROC);
	WINBOOL ArcTo(HDC, int, int, int, int, int, int, int, int);
	WINBOOL BeginPath(HDC);
	WINBOOL CloseFigure(HDC);
	WINBOOL EndPath(HDC);
	WINBOOL FillPath(HDC);
	WINBOOL FlattenPath(HDC);
	int GetPath(HDC, LPPOINT, LPBYTE, int);
	HRGN PathToRegion(HDC);
	WINBOOL PolyDraw(HDC, POINT*, ubyte*, int);
	WINBOOL SelectClipPath(HDC, int);
	int SetArcDirection(HDC, int);
	WINBOOL SetMiterLimit(HDC, FLOAT, PFLOAT);
	WINBOOL StrokeAndFillPath(HDC);
	WINBOOL StrokePath(HDC);
	WINBOOL WidenPath(HDC);
	HPEN ExtCreatePen(DWORD, DWORD, LOGBRUSH*, DWORD, DWORD*);
	WINBOOL GetMiterLimit(HDC, PFLOAT);
	int GetArcDirection(HDC);
	WINBOOL MoveToEx(HDC, int, int, LPPOINT);
	HRGN CreatePolygonRgn(POINT*, int, int);
	WINBOOL DPtoLP(HDC, LPPOINT, int);
	WINBOOL LPtoDP(HDC, LPPOINT, int);
	WINBOOL Polygon(HDC, POINT*, int);
	WINBOOL Polyline(HDC, POINT*, int);
	WINBOOL PolyBezier(HDC, POINT*, DWORD);
	WINBOOL PolyBezierTo(HDC, POINT*, DWORD);
	WINBOOL PolylineTo(HDC, POINT*, DWORD);
	WINBOOL SetViewportExtEx(HDC, int, int, LPSIZE);
	WINBOOL SetViewportOrgEx(HDC, int, int, LPPOINT);
	WINBOOL SetWindowExtEx(HDC, int, int, LPSIZE);
	WINBOOL SetWindowOrgEx(HDC, int, int, LPPOINT);
	WINBOOL OffsetViewportOrgEx(HDC, int, int, LPPOINT);
	WINBOOL OffsetWindowOrgEx(HDC, int, int, LPPOINT);
	WINBOOL ScaleViewportExtEx(HDC, int, int, int, int, LPSIZE);
	WINBOOL ScaleWindowExtEx(HDC, int, int, int, int, LPSIZE);
	WINBOOL SetBitmapDimensionEx(HBITMAP, int, int, LPSIZE);
	WINBOOL SetBrushOrgEx(HDC, int, int, LPPOINT);
	WINBOOL GetDCOrgEx(HDC, LPPOINT);
	WINBOOL FixBrushOrgEx(HDC, int, int, LPPOINT);
	WINBOOL UnrealizeObject(HGDIOBJ);
	WINBOOL GdiFlush();
	DWORD GdiSetBatchLimit(DWORD);
	DWORD GdiGetBatchLimit();
	int SetICMMode(HDC, int);
	WINBOOL CheckColorsInGamut(HDC, LPVOID, LPVOID, DWORD);
	HANDLE GetColorSpace(HDC);
	WINBOOL SetColorSpace(HDC, HCOLORSPACE);
	WINBOOL DeleteColorSpace(HCOLORSPACE);
	WINBOOL GetDeviceGammaRamp(HDC, LPVOID);
	WINBOOL SetDeviceGammaRamp(HDC, LPVOID);
	WINBOOL ColorMatchToTarget(HDC, HDC, DWORD);
	HPROPSHEETPAGE CreatePropertySheetPageA(LPCPROPSHEETPAGE);
	WINBOOL DestroyPropertySheetPage(HPROPSHEETPAGE);
	void InitCommonControls();
	HIMAGELIST ImageList_Create(int, int, UINT, int, int);
	WINBOOL ImageList_Destroy(HIMAGELIST);
	int ImageList_GetImageCount(HIMAGELIST);
	int ImageList_Add(HIMAGELIST, HBITMAP, HBITMAP);
	int ImageList_ReplaceIcon(HIMAGELIST, int, HICON);
	COLORREF ImageList_SetBkColor(HIMAGELIST, COLORREF);
	COLORREF ImageList_GetBkColor(HIMAGELIST);
	WINBOOL ImageList_SetOverlayImage(HIMAGELIST, int, int);
	WINBOOL ImageList_Draw(HIMAGELIST, int, HDC, int, int, UINT);
	WINBOOL ImageList_Replace(HIMAGELIST, int, HBITMAP, HBITMAP);
	int ImageList_AddMasked(HIMAGELIST, HBITMAP, COLORREF);
	WINBOOL ImageList_DrawEx(HIMAGELIST, int, HDC, int, int, int, int, COLORREF, COLORREF, UINT);
	WINBOOL ImageList_Remove(HIMAGELIST, int);
	HICON ImageList_GetIcon(HIMAGELIST, int, UINT);
	WINBOOL ImageList_BeginDrag(HIMAGELIST, int, int, int);
	void ImageList_EndDrag();
	WINBOOL ImageList_DragEnter(HWND, int, int);
	WINBOOL ImageList_DragLeave(HWND);
	WINBOOL ImageList_DragMove(int, int);
	WINBOOL ImageList_SetDragCursorImage(HIMAGELIST, int, int, int);
	WINBOOL ImageList_DragShowNolock(WINBOOL);
	HIMAGELIST ImageList_GetDragImage(POINT*, POINT*);
	WINBOOL ImageList_GetIconSize(HIMAGELIST, int*, int*);
	WINBOOL ImageList_SetIconSize(HIMAGELIST, int, int);
	WINBOOL ImageList_GetImageInfo(HIMAGELIST, int, IMAGEINFO*);
	HIMAGELIST ImageList_Merge(HIMAGELIST, int, HIMAGELIST, int, int, int);
	HWND CreateToolbarEx(HWND, DWORD, UINT, int, HINST, UINT, LPCTBBUTTON, int, int, int, int, int, UINT);
	HBITMAP CreateMappedBitmap(HINST, int, UINT, LPCOLORMAP, int);
	void MenuHelp(UINT, WPARAM, LPARAM, HMENU, HINST, HWND);
	WINBOOL ShowHideMenuCtl(HWND, UINT, LPINT);
	void GetEffectiveClientRect(HWND, LPRECT);
	WINBOOL MakeDragList(HWND);
	void DrawInsert(HWND, HWND);
	int LBItemFromPt(HWND, POINT, WINBOOL);
	HWND CreateUpDownControl(DWORD, int, int, int, int, HWND, int, HINST, HWND, int, int, int);
	LONG RegCloseKey(HKEY);
	LONG RegSetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	LONG RegFlushKey(HKEY);
	LONG RegGetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, LPDWORD);
	LONG RegNotifyChangeKeyValue(HKEY, WINBOOL, DWORD, HANDLE, WINBOOL);
	WINBOOL IsValidCodePage(UINT);
	UINT GetACP();
	UINT GetOEMCP();
	WINBOOL GetCPInfo(UINT, LPCPINFO);
	WINBOOL IsDBCSLeadByte(ubyte);
	WINBOOL IsDBCSLeadByteEx(UINT, ubyte);
	int MultiByteToWideChar(UINT, DWORD, LPCSTR, int, LPWSTR, int);
	int WideCharToMultiByte(UINT, DWORD, LPCWSTR, int, LPSTR, int, LPCSTR, LPBOOL);
	WINBOOL IsValidLocale(LCID, DWORD);
	LCID ConvertDefaultLocale(LCID);
	LCID GetThreadLocale();
	WINBOOL SetThreadLocale(LCID);
	LANGID GetSystemDefaultLangID();
	LANGID GetUserDefaultLangID();
	LCID GetSystemDefaultLCID();
	LCID GetUserDefaultLCID();
	WINBOOL ReadConsoleOutputAttribute(HANDLE, LPWORD, DWORD, COORD, LPDWORD);
	WINBOOL WriteConsoleOutputAttribute(HANDLE, ushort*, DWORD, COORD, LPDWORD);
	WINBOOL FillConsoleOutputAttribute(HANDLE, ushort, DWORD, COORD, LPDWORD);
	WINBOOL GetConsoleMode(HANDLE, LPDWORD);
	WINBOOL GetNumberOfConsoleInputEvents(HANDLE, PDWORD);
	WINBOOL GetConsoleScreenBufferInfo(HANDLE, PCONSOLE_SCREEN_BUFFER_INFO);
	COORD GetLargestConsoleWindowSize(HANDLE);
	WINBOOL GetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO);
	WINBOOL GetNumberOfConsoleMouseButtons(LPDWORD);
	WINBOOL SetConsoleMode(HANDLE, DWORD);
	WINBOOL SetConsoleActiveScreenBuffer(HANDLE);
	WINBOOL FlushConsoleInputBuffer(HANDLE);
	WINBOOL SetConsoleScreenBufferSize(HANDLE, COORD);
	WINBOOL SetConsoleCursorPosition(HANDLE, COORD);
	WINBOOL SetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO);
	WINBOOL SetConsoleWindowInfo(HANDLE, WINBOOL, SMALL_RECT*);
	WINBOOL SetConsoleTextAttribute(HANDLE, ushort);
	WINBOOL SetConsoleCtrlHandler(PHANDLER_ROUTINE, WINBOOL);
	WINBOOL GenerateConsoleCtrlEvent(DWORD, DWORD);
	WINBOOL AllocConsole();
	WINBOOL FreeConsole();
	HANDLE CreateConsoleScreenBuffer(DWORD, DWORD, SECURITY_ATTRIBUTES*, DWORD, LPVOID);
	UINT GetConsoleCP();
	WINBOOL SetConsoleCP(UINT);
	UINT GetConsoleOutputCP();
	WINBOOL SetConsoleOutputCP(UINT);
	DWORD WNetConnectionDialog(HWND, DWORD);
	DWORD WNetDisconnectDialog(HWND, DWORD);
	DWORD WNetCloseEnum(HANDLE);
	WINBOOL CloseServiceHandle(SC_HANDLE);
	WINBOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS);
	WINBOOL DeleteService(SC_HANDLE);
	SC_LOCK LockServiceDatabase(SC_HANDLE);
	WINBOOL NotifyBootConfigStatus(WINBOOL);
	WINBOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	WINBOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS);
	WINBOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
	WINBOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS);
	WINBOOL UnlockServiceDatabase(SC_LOCK);
	int ChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR*);
	int DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
	WINBOOL SetPixelFormat(HDC, int, PPIXELFORMATDESCRIPTOR);
	WINBOOL SwapBuffers(HDC);
	WINBOOL DragQueryPoint(HDROP, LPPOINT);
	void DragFinish(HDROP);
	void DragAcceptFiles(HWND, BOOL);
	HICON DuplicateIcon(HINST, HICON);
	BOOL DdeAbandonTransaction(DWORD, HCONV, DWORD);
	PBYTE DdeAccessData(HDDEDATA, PDWORD);
	HDDEDATA DdeAddData(HDDEDATA, PBYTE, DWORD, DWORD);
	HDDEDATA DdeClientTransaction(PBYTE, DWORD, HCONV, HSZ, UINT, UINT, DWORD, PDWORD);
	int DdeCmpStringHandles(HSZ, HSZ);
	HCONV DdeConnect(DWORD, HSZ, HSZ, CONVCONTEXT*);
	HCONVLIST DdeConnectList(DWORD, HSZ, HSZ, HCONVLIST, PCONVCONTEXT);
	HDDEDATA DdeCreateDataHandle(DWORD, LPBYTE, DWORD, DWORD, HSZ, UINT, UINT);
	WINBOOL DdeDisconnect(HCONV);
	BOOL DdeDisconnectList(HCONVLIST);
	BOOL DdeEnableCallback(DWORD, HCONV, UINT);
	WINBOOL DdeFreeDataHandle(HDDEDATA);
	WINBOOL DdeFreeStringHandle(DWORD, HSZ);
	DWORD DdeGetData(HDDEDATA, ubyte*, DWORD, DWORD);
	UINT DdeGetLastError(DWORD);
	BOOL DdeImpersonateClient(HCONV);
	BOOL DdeKeepStringHandle(DWORD, HSZ);
	HDDEDATA DdeNameService(DWORD, HSZ, HSZ, UINT);
	WINBOOL DdePostAdvise(DWORD, HSZ, HSZ);
	UINT DdeQueryConvInfo(HCONV, DWORD, PCONVINFO);
	HCONV DdeQueryNextServer(HCONVLIST, HCONV);
	HCONV DdeReconnect(HCONV);
	BOOL DdeSetUserHandle(HCONV, DWORD, DWORD);
	BOOL DdeUnaccessData(HDDEDATA);
	WINBOOL DdeUninitialize(DWORD);
	void SHAddToRecentDocs(UINT);
	LPITEMIDLIST SHBrowseForFolder(LPBROWSEINFO);
	void SHChangeNotify(LONG, UINT, LPCVOID);
	int SHFileOperation(LPSHFILEOPSTRUCT);
	void SHFreeNameMappings(HANDLE);
	DWORD SHGetFileInfo(LPCTSTR, DWORD, SHFILEINFO*, UINT, UINT);
	WINBOOL SHGetPathFromIDList(LPCITEMIDLIST, LPTSTR);
	HRESULT SHGetSpecialFolderLocation(HWND, int, LPITEMIDLIST*);
	THANDLE CreateThread(POINTER, DWORD, TFNTHREADSTARTROUTINE, POINTER, DWORD, DWORD*);
	BOOL DdeSetQualityOfService(HWND, TSECURITYQUALITYOFSERVICE*, PSECURITYQUALITYOFSERVICE);
	BOOL GetCommMask(THANDLE, DWORD*);
	BOOL GetDiskFreeSpaceExA(LPCSTR, void*, void*, PLARGEINTEGER);
	BOOL GetDiskFreeSpaceExW(LPWSTR, void*, void*, PLARGEINTEGER);
	DWORD GetKerningPairs(HDC, DWORD, void*);
	BOOL GetOverlappedResult(THANDLE, TOVERLAPPED*, DWORD*, BOOL);
	BOOL GetQueuedCompletionStatus(THANDLE, DWORD*, DWORD*, POVERLAPPED*, DWORD);
	BOOL GetSystemPowerStatus(TSYSTEMPOWERSTATUS*);
	BOOL ReadFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED);
	BOOL SetThreadContext(THANDLE, TCONTEXT*);
	BOOL wglDescribeLayerPlane(HDC, int, int, uint, TLAYERPLANEDESCRIPTOR*);
	int wglGetLayerPaletteEntries(HDC, int, int, int, void*);
	int wglSetLayerPaletteEntries(HDC, int, int, int, void*);
	DWORD WNetGetResourceParentA(PNETRESOURCEA, POINTER, DWORD*);
	BOOL WriteFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED);

        BOOL CancelWaitableTimer(HANDLE hTimer);
        HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName);
        HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName);
        HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName);
        HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName);
        BOOL SetWaitableTimer(HANDLE hTimer, LARGE_INTEGER* pDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume);
}