minor fixes, winsvc api

[ia32rtools.git] / win32.hlist

WINBASEAPI BOOL WINAPI AddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
WINBASEAPI BOOL WINAPI AddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
WINBASEAPI BOOL WINAPI AddAccessDeniedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
WINBASEAPI BOOL WINAPI AddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
WINBASEAPI BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID*);
WINBASEAPI BOOL WINAPI AllocateLocallyUniqueId(PLUID);
WINBASEAPI BOOL WINAPI AreAllAccessesGranted(DWORD,DWORD);
WINBASEAPI BOOL WINAPI AreAnyAccessesGranted(DWORD,DWORD);
WINBASEAPI BOOL WINAPI AreFileApisANSI(void);
WINBASEAPI BOOL WINAPI BackupEventLogA(HANDLE,LPCSTR);
WINBASEAPI BOOL WINAPI BackupEventLogW(HANDLE,LPCWSTR);
WINBASEAPI BOOL WINAPI BackupRead(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
WINBASEAPI BOOL WINAPI BackupSeek(HANDLE,DWORD,DWORD,LPDWORD,LPDWORD,LPVOID*);
WINBASEAPI BOOL WINAPI BackupWrite(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
WINBASEAPI BOOL WINAPI Beep(DWORD,DWORD);
WINBASEAPI HANDLE WINAPI BeginUpdateResourceA(LPCSTR,BOOL);
WINBASEAPI HANDLE WINAPI BeginUpdateResourceW(LPCWSTR,BOOL);
WINBASEAPI BOOL WINAPI BuildCommDCBA(LPCSTR,LPDCB);
WINBASEAPI BOOL WINAPI BuildCommDCBW(LPCWSTR,LPDCB);
WINBASEAPI BOOL WINAPI BuildCommDCBAndTimeoutsA(LPCSTR,LPDCB,LPCOMMTIMEOUTS);
WINBASEAPI BOOL WINAPI BuildCommDCBAndTimeoutsW(LPCWSTR,LPDCB,LPCOMMTIMEOUTS);
WINBASEAPI BOOL WINAPI CallNamedPipeA(LPCSTR,PVOID,DWORD,PVOID,DWORD,PDWORD,DWORD);
WINBASEAPI BOOL WINAPI CallNamedPipeW(LPCWSTR,PVOID,DWORD,PVOID,DWORD,PDWORD,DWORD);
WINBASEAPI BOOL WINAPI CancelDeviceWakeupRequest(HANDLE);
WINBASEAPI BOOL WINAPI CancelIo(HANDLE);
WINBASEAPI BOOL WINAPI CancelWaitableTimer(HANDLE);
WINBASEAPI BOOL WINAPI ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG);
WINBASEAPI BOOL WINAPI CheckNameLegalDOS8Dot3A(LPCSTR,LPSTR,DWORD,PBOOL,PBOOL);
WINBASEAPI BOOL WINAPI CheckNameLegalDOS8Dot3W(LPCWSTR,LPSTR,DWORD,PBOOL,PBOOL);
WINBASEAPI BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE,PBOOL);
WINBASEAPI BOOL WINAPI CheckTokenMembership(HANDLE,PSID,PBOOL);
WINBASEAPI BOOL WINAPI ClearCommBreak(HANDLE);
WINBASEAPI BOOL WINAPI ClearCommError(HANDLE,PDWORD,LPCOMSTAT);
WINBASEAPI BOOL WINAPI ClearEventLogA(HANDLE,LPCSTR);
WINBASEAPI BOOL WINAPI ClearEventLogW(HANDLE,LPCWSTR);
WINBASEAPI BOOL WINAPI CloseEventLog(HANDLE);
WINBASEAPI BOOL WINAPI CloseHandle(HANDLE);
WINBASEAPI BOOL WINAPI CommConfigDialogA(LPCSTR,HWND,LPCOMMCONFIG);
WINBASEAPI BOOL WINAPI CommConfigDialogW(LPCWSTR,HWND,LPCOMMCONFIG);
WINBASEAPI LONG WINAPI CompareFileTime(CONST FILETIME*,CONST FILETIME*);
WINBASEAPI BOOL WINAPI ConnectNamedPipe(HANDLE,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI ContinueDebugEvent(DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI ConvertFiberToThread(void);
WINBASEAPI PVOID WINAPI ConvertThreadToFiber(PVOID);
WINBASEAPI BOOL WINAPI CopyFileA(LPCSTR,LPCSTR,BOOL);
WINBASEAPI BOOL WINAPI CopyFileW(LPCWSTR,LPCWSTR,BOOL);
WINBASEAPI BOOL WINAPI CopyFileExA(LPCSTR,LPCSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD);
WINBASEAPI BOOL WINAPI CopyFileExW(LPCWSTR,LPCWSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD);
WINBASEAPI BOOL WINAPI CopySid(DWORD,PSID,PSID);
WINBASEAPI HANDLE WINAPI CreateActCtxA(PCACTCTXA);
WINBASEAPI HANDLE WINAPI CreateActCtxW(PCACTCTXW);
WINBASEAPI BOOL WINAPI CreateDirectoryA(LPCSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI BOOL WINAPI CreateDirectoryW(LPCWSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI BOOL WINAPI CreateDirectoryExA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI BOOL WINAPI CreateDirectoryExW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI HANDLE WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI CreateEventW(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCWSTR);
WINBASEAPI LPVOID WINAPI CreateFiber(SIZE_T,LPFIBER_START_ROUTINE,LPVOID);
WINBASEAPI LPVOID WINAPI CreateFiberEx(SIZE_T,SIZE_T,DWORD,LPFIBER_START_ROUTINE,LPVOID);
WINBASEAPI HANDLE WINAPI CreateFileA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
WINBASEAPI HANDLE WINAPI CreateFileW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCSTR);
WINBASEAPI HANDLE WINAPI CreateFileMappingW(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCWSTR);
WINBASEAPI BOOL WINAPI CreateHardLinkA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI BOOL WINAPI CreateHardLinkW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
WINBASEAPI HANDLE WINAPI CreateIoCompletionPort(HANDLE,HANDLE,ULONG_PTR,DWORD);
WINBASEAPI HANDLE WINAPI CreateJobObjectA(LPSECURITY_ATTRIBUTES,LPCSTR);
WINBASEAPI HANDLE WINAPI CreateJobObjectW(LPSECURITY_ATTRIBUTES,LPCWSTR);
WINBASEAPI BOOL WINAPI TerminateJobObject(HANDLE,UINT);
WINBASEAPI BOOL WINAPI AssignProcessToJobObject(HANDLE,HANDLE);
WINBASEAPI BOOL WINAPI SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
WINBASEAPI BOOL WINAPI QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
WINBASEAPI HANDLE WINAPI CreateMailslotA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINBASEAPI HANDLE WINAPI CreateMailslotW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINBASEAPI HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE);
WINBASEAPI HANDLE WINAPI CreateMutexA(LPSECURITY_ATTRIBUTES,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI CreateMutexW(LPSECURITY_ATTRIBUTES,BOOL,LPCWSTR);
WINBASEAPI HANDLE WINAPI CreateNamedPipeA(LPCSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINBASEAPI HANDLE WINAPI CreateNamedPipeW(LPCWSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINBASEAPI BOOL WINAPI CreatePipe(PHANDLE,PHANDLE,LPSECURITY_ATTRIBUTES,DWORD);
WINBASEAPI BOOL WINAPI CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR*,BOOL,HANDLE,PGENERIC_MAPPING);

WINBASEAPI BOOL WINAPI CreateProcessA(LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCSTR,LPSTARTUPINFOA,LPPROCESS_INFORMATION);
WINBASEAPI HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,PVOID,DWORD,PDWORD);
WINBASEAPI void WINAPI DeleteCriticalSection(PCRITICAL_SECTION);
WINBASEAPI void WINAPI DeleteFiber(PVOID);
WINBASEAPI BOOL WINAPI DeleteFileA(LPCSTR);
WINBASEAPI BOOL WINAPI DeleteFileW(LPCWSTR);
WINBASEAPI BOOL WINAPI DeleteTimerQueue(HANDLE);
WINBASEAPI BOOL WINAPI DeleteTimerQueueEx(HANDLE,HANDLE);
WINBASEAPI BOOL WINAPI DeleteTimerQueueTimer(HANDLE,HANDLE,HANDLE);
WINBASEAPI BOOL WINAPI DeleteVolumeMountPointA(LPCSTR);
WINBASEAPI BOOL WINAPI DeleteVolumeMountPointW(LPCWSTR);
WINBASEAPI BOOL WINAPI DeregisterEventSource(HANDLE);
WINBASEAPI BOOL WINAPI DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
WINBASEAPI BOOL WINAPI DeviceIoControl(HANDLE,DWORD,PVOID,DWORD,PVOID,DWORD,PDWORD,POVERLAPPED);
WINBASEAPI BOOL WINAPI DisableThreadLibraryCalls(HMODULE);
WINBASEAPI BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR,LPSTR,LPDWORD);
WINBASEAPI BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR,LPWSTR,LPDWORD);
WINBASEAPI BOOL WINAPI DisconnectNamedPipe(HANDLE);
WINBASEAPI BOOL WINAPI DosDateTimeToFileTime(WORD,WORD,LPFILETIME);
WINBASEAPI BOOL WINAPI DuplicateHandle(HANDLE,HANDLE,HANDLE,PHANDLE,DWORD,BOOL,DWORD);
WINBASEAPI BOOL WINAPI DuplicateToken(HANDLE,SECURITY_IMPERSONATION_LEVEL,PHANDLE);
WINBASEAPI BOOL WINAPI DuplicateTokenEx(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
WINBASEAPI BOOL WINAPI EncryptFileA(LPCSTR);
WINBASEAPI BOOL WINAPI EncryptFileW(LPCWSTR);
WINBASEAPI BOOL WINAPI EndUpdateResourceA(HANDLE,BOOL);
WINBASEAPI BOOL WINAPI EndUpdateResourceW(HANDLE,BOOL);
WINBASEAPI void WINAPI EnterCriticalSection(LPCRITICAL_SECTION);
DECLSPEC_NORETURN WINBASEAPI void WINAPI ExitProcess(UINT);
DECLSPEC_NORETURN WINBASEAPI void WINAPI ExitThread(DWORD);
WINBASEAPI BOOL WINAPI FileTimeToDosDateTime(CONST FILETIME *,LPWORD,LPWORD);
WINBASEAPI BOOL WINAPI FileTimeToLocalFileTime(CONST FILETIME *,LPFILETIME);
WINBASEAPI BOOL WINAPI FileTimeToSystemTime(CONST FILETIME *,LPSYSTEMTIME);
WINBASEAPI BOOL WINAPI FindClose(HANDLE);
WINBASEAPI BOOL WINAPI FindCloseChangeNotification(HANDLE);
WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationA(LPCSTR,BOOL,DWORD);
WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationW(LPCWSTR,BOOL,DWORD);
WINBASEAPI HANDLE WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
WINBASEAPI HANDLE WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
WINBASEAPI HANDLE WINAPI FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
WINBASEAPI HANDLE WINAPI FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
WINBASEAPI BOOL WINAPI FindNextChangeNotification(HANDLE);
WINBASEAPI BOOL WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
WINBASEAPI BOOL WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
WINBASEAPI HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
WINBASEAPI HRSRC WINAPI FindResourceW(HINSTANCE,LPCWSTR,LPCWSTR);
WINBASEAPI HRSRC WINAPI FindResourceExA(HINSTANCE,LPCSTR,LPCSTR,WORD);
WINBASEAPI HRSRC WINAPI FindResourceExW(HINSTANCE,LPCWSTR,LPCWSTR,WORD);
WINBASEAPI BOOL WINAPI FlushFileBuffers(HANDLE);
WINBASEAPI BOOL WINAPI FlushInstructionCache(HANDLE,LPCVOID,DWORD);
WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID,DWORD);
WINBASEAPI DWORD WINAPI FormatMessageA(DWORD,LPCVOID,DWORD,DWORD,LPSTR,DWORD,va_list*);
WINBASEAPI DWORD WINAPI FormatMessageW(DWORD,LPCVOID,DWORD,DWORD,LPWSTR,DWORD,va_list*);
WINBASEAPI BOOL WINAPI FreeEnvironmentStringsA(LPSTR);
WINBASEAPI BOOL WINAPI FreeEnvironmentStringsW(LPWSTR);
WINBASEAPI BOOL WINAPI FreeLibrary(HMODULE);
DECLSPEC_NORETURN WINBASEAPI void WINAPI FreeLibraryAndExitThread(HMODULE,DWORD);
WINBASEAPI BOOL WINAPI FreeResource(HGLOBAL);
WINBASEAPI PVOID WINAPI FreeSid(PSID);
WINBASEAPI BOOL WINAPI GetAce(PACL,DWORD,LPVOID*);
WINBASEAPI BOOL WINAPI GetAclInformation(PACL,PVOID,DWORD,ACL_INFORMATION_CLASS);
WINBASEAPI UINT WINAPI GetAtomNameA(ATOM,LPSTR,int);
WINBASEAPI UINT WINAPI GetAtomNameW(ATOM,LPWSTR,int);
WINBASEAPI BOOL WINAPI GetBinaryTypeA(LPCSTR,PDWORD);
WINBASEAPI BOOL WINAPI GetBinaryTypeW(LPCWSTR,PDWORD);
WINBASEAPI LPSTR WINAPI GetCommandLineA(VOID);
WINBASEAPI LPWSTR WINAPI GetCommandLineW(VOID);
WINBASEAPI BOOL WINAPI GetCommConfig(HANDLE,LPCOMMCONFIG,PDWORD);
WINBASEAPI BOOL WINAPI GetCommMask(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetCommModemStatus(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetCommProperties(HANDLE,LPCOMMPROP);
WINBASEAPI BOOL WINAPI GetCommState(HANDLE,LPDCB);
WINBASEAPI BOOL WINAPI GetCommTimeouts(HANDLE,LPCOMMTIMEOUTS);
WINBASEAPI DWORD WINAPI GetCompressedFileSizeA(LPCSTR,PDWORD);
WINBASEAPI DWORD WINAPI GetCompressedFileSizeW(LPCWSTR,PDWORD);
WINBASEAPI BOOL WINAPI GetComputerNameA(LPSTR,PDWORD);
WINBASEAPI BOOL WINAPI GetComputerNameW(LPWSTR,PDWORD);
WINBASEAPI BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT,LPSTR,LPDWORD);
WINBASEAPI BOOL WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT,LPWSTR,LPDWORD);
WINBASEAPI BOOL WINAPI GetCurrentActCtx(HANDLE*);
WINBASEAPI DWORD WINAPI GetCurrentDirectoryA(DWORD,LPSTR);
WINBASEAPI DWORD WINAPI GetCurrentDirectoryW(DWORD,LPWSTR);
WINBASEAPI BOOL WINAPI GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
WINBASEAPI BOOL WINAPI GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
WINBASEAPI HANDLE WINAPI GetCurrentProcess(void);
WINBASEAPI DWORD WINAPI GetCurrentProcessId(void);
WINBASEAPI HANDLE WINAPI GetCurrentThread(void);
WINBASEAPI DWORD WINAPI GetCurrentThreadId(void);
WINBASEAPI BOOL WINAPI GetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,PDWORD);
WINBASEAPI BOOL WINAPI GetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,PDWORD);
WINBASEAPI BOOL WINAPI GetDevicePowerState(HANDLE, BOOL*);
WINBASEAPI BOOL WINAPI GetDiskFreeSpaceA(LPCSTR,PDWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetDiskFreeSpaceW(LPCWSTR,PDWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExA(LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExW(LPCWSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
WINBASEAPI DWORD WINAPI GetDllDirectoryA(DWORD,LPSTR);
WINBASEAPI DWORD WINAPI GetDllDirectoryW(DWORD,LPWSTR);
WINBASEAPI UINT WINAPI GetDriveTypeA(LPCSTR);
WINBASEAPI UINT WINAPI GetDriveTypeW(LPCWSTR);
WINBASEAPI LPSTR WINAPI GetEnvironmentStrings(void);
WINBASEAPI LPSTR WINAPI GetEnvironmentStringsA(void);
WINBASEAPI LPWSTR WINAPI GetEnvironmentStringsW(void);
WINBASEAPI DWORD WINAPI GetEnvironmentVariableA(LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetEnvironmentVariableW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetExitCodeProcess(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetExitCodeThread(HANDLE,PDWORD);
WINBASEAPI DWORD WINAPI GetFileAttributesA(LPCSTR);
WINBASEAPI DWORD WINAPI GetFileAttributesW(LPCWSTR);
WINBASEAPI BOOL WINAPI GetFileAttributesExA(LPCSTR,GET_FILEEX_INFO_LEVELS,PVOID);
WINBASEAPI BOOL WINAPI GetFileAttributesExW(LPCWSTR,GET_FILEEX_INFO_LEVELS,PVOID);
WINBASEAPI BOOL WINAPI GetFileInformationByHandle(HANDLE,LPBY_HANDLE_FILE_INFORMATION);
WINBASEAPI BOOL WINAPI GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
WINBASEAPI DWORD WINAPI GetFileSize(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetFileSizeEx(HANDLE,PLARGE_INTEGER);
WINBASEAPI BOOL WINAPI GetFileTime(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME);
WINBASEAPI DWORD WINAPI GetFileType(HANDLE);
WINBASEAPI DWORD WINAPI GetFullPathNameA(LPCSTR,DWORD,LPSTR,LPSTR*);
WINBASEAPI DWORD WINAPI GetFullPathNameW(LPCWSTR,DWORD,LPWSTR,LPWSTR*);
WINBASEAPI BOOL WINAPI GetHandleInformation(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
WINBASEAPI DWORD WINAPI GetLastError(void);
WINBASEAPI DWORD WINAPI GetLengthSid(PSID);
WINBASEAPI void WINAPI GetLocalTime(LPSYSTEMTIME);
WINBASEAPI DWORD WINAPI GetLogicalDrives(void);
WINBASEAPI DWORD WINAPI GetLogicalDriveStringsA(DWORD,LPSTR);
WINBASEAPI DWORD WINAPI GetLogicalDriveStringsW(DWORD,LPWSTR);
WINBASEAPI DWORD WINAPI GetLongPathNameA(LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetLongPathNameW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetMailslotInfo(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI DWORD WINAPI GetModuleFileNameA(HINSTANCE,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetModuleFileNameW(HINSTANCE,LPWSTR,DWORD);
WINBASEAPI HMODULE WINAPI GetModuleHandleA(LPCSTR);
WINBASEAPI HMODULE WINAPI GetModuleHandleW(LPCWSTR);
WINBASEAPI BOOL WINAPI GetModuleHandleExA(DWORD,LPCSTR,HMODULE*);
WINBASEAPI BOOL WINAPI GetModuleHandleExW(DWORD,LPCWSTR,HMODULE*);
WINBASEAPI BOOL WINAPI GetNamedPipeHandleStateA(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD,LPSTR,DWORD);
WINBASEAPI BOOL WINAPI GetNamedPipeHandleStateW(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetNamedPipeInfo(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI VOID WINAPI GetNativeSystemInfo(LPSYSTEM_INFO);
WINBASEAPI BOOL WINAPI GetNumberOfEventLogRecords(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetOldestEventLogRecord(HANDLE,PDWORD);
WINBASEAPI BOOL WINAPI GetOverlappedResult(HANDLE,LPOVERLAPPED,PDWORD,BOOL);
WINBASEAPI DWORD WINAPI GetPriorityClass(HANDLE);
WINBASEAPI BOOL WINAPI GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
WINBASEAPI UINT WINAPI GetPrivateProfileIntA(LPCSTR,LPCSTR,INT,LPCSTR);
WINBASEAPI UINT WINAPI GetPrivateProfileIntW(LPCWSTR,LPCWSTR,INT,LPCWSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileSectionA(LPCSTR,LPSTR,DWORD,LPCSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileSectionW(LPCWSTR,LPWSTR,DWORD,LPCWSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileSectionNamesA(LPSTR,DWORD,LPCSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileSectionNamesW(LPWSTR,DWORD,LPCWSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,DWORD,LPCSTR);
WINBASEAPI DWORD WINAPI GetPrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,DWORD,LPCWSTR);
WINBASEAPI BOOL WINAPI GetPrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
WINBASEAPI BOOL WINAPI GetPrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
WINBASEAPI FARPROC WINAPI GetProcAddress(HINSTANCE,LPCSTR);
WINBASEAPI BOOL WINAPI GetProcessAffinityMask(HANDLE,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetProcessDEPPolicy (HANDLE, LPDWORD, PBOOL);
WINBASEAPI BOOL WINAPI GetProcessHandleCount(HANDLE,PDWORD);
WINBASEAPI HANDLE WINAPI GetProcessHeap(VOID);
WINBASEAPI DWORD WINAPI GetProcessHeaps(DWORD,PHANDLE);
WINBASEAPI DWORD WINAPI GetProcessId(HANDLE);
WINBASEAPI BOOL WINAPI GetProcessIoCounters(HANDLE,PIO_COUNTERS);
WINBASEAPI BOOL WINAPI GetProcessPriorityBoost(HANDLE,PBOOL);
WINBASEAPI BOOL WINAPI GetProcessShutdownParameters(PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetProcessTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
WINBASEAPI DWORD WINAPI GetProcessVersion(DWORD);
WINBASEAPI HWINSTA WINAPI GetProcessWindowStation(void);
WINBASEAPI BOOL WINAPI GetProcessWorkingSetSize(HANDLE,PSIZE_T,PSIZE_T);
WINBASEAPI UINT WINAPI GetProfileIntA(LPCSTR,LPCSTR,INT);
WINBASEAPI UINT WINAPI GetProfileIntW(LPCWSTR,LPCWSTR,INT);
WINBASEAPI DWORD WINAPI GetProfileSectionA(LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetProfileSectionW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI DWORD WINAPI GetProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetQueuedCompletionStatus(HANDLE,PDWORD,PULONG_PTR,LPOVERLAPPED*,DWORD);
WINBASEAPI BOOL WINAPI GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR_CONTROL,PDWORD);
WINBASEAPI BOOL WINAPI GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL*,LPBOOL);
WINBASEAPI BOOL WINAPI GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID*,LPBOOL);
WINBASEAPI DWORD WINAPI GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
WINBASEAPI BOOL WINAPI GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID*,LPBOOL);
WINBASEAPI BOOL WINAPI GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL*,LPBOOL);
WINBASEAPI DWORD WINAPI GetShortPathNameA(LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI GetShortPathNameW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
WINBASEAPI DWORD WINAPI GetSidLengthRequired(UCHAR);
WINBASEAPI PDWORD WINAPI GetSidSubAuthority(PSID,DWORD);
WINBASEAPI PUCHAR WINAPI GetSidSubAuthorityCount(PSID);
WINBASEAPI VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA);
WINBASEAPI VOID WINAPI GetStartupInfoW(LPSTARTUPINFOW);
WINBASEAPI HANDLE WINAPI GetStdHandle(DWORD);
WINBASEAPI UINT WINAPI GetSystemDirectoryA(LPSTR,UINT);
WINBASEAPI UINT WINAPI GetSystemDirectoryW(LPWSTR,UINT);
WINBASEAPI VOID WINAPI GetSystemInfo(LPSYSTEM_INFO);
WINBASEAPI BOOL WINAPI GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
WINBASEAPI VOID WINAPI GetSystemTime(LPSYSTEMTIME);
WINBASEAPI BOOL WINAPI GetSystemTimes(LPFILETIME,LPFILETIME,LPFILETIME);
WINBASEAPI BOOL WINAPI GetSystemTimeAdjustment(PDWORD,PDWORD,PBOOL);
WINBASEAPI void WINAPI GetSystemTimeAsFileTime(LPFILETIME);
WINBASEAPI UINT WINAPI GetSystemWindowsDirectoryA(LPSTR,UINT);
WINBASEAPI UINT WINAPI GetSystemWindowsDirectoryW(LPWSTR,UINT);
WINBASEAPI UINT WINAPI GetSystemWow64DirectoryA(LPSTR,UINT);
WINBASEAPI UINT WINAPI GetSystemWow64DirectoryW(LPWSTR,UINT);
WINBASEAPI DWORD WINAPI GetTapeParameters(HANDLE,DWORD,PDWORD,PVOID);
WINBASEAPI DWORD WINAPI GetTapePosition(HANDLE,DWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI DWORD WINAPI GetTapeStatus(HANDLE);
WINBASEAPI UINT WINAPI GetTempFileNameA(LPCSTR,LPCSTR,UINT,LPSTR);
WINBASEAPI UINT WINAPI GetTempFileNameW(LPCWSTR,LPCWSTR,UINT,LPWSTR);
WINBASEAPI DWORD WINAPI GetTempPathA(DWORD,LPSTR);
WINBASEAPI DWORD WINAPI GetTempPathW(DWORD,LPWSTR);
WINBASEAPI BOOL WINAPI GetThreadContext(HANDLE,LPCONTEXT);
WINBASEAPI BOOL WINAPI GetThreadIOPendingFlag(HANDLE,PBOOL);
WINBASEAPI int WINAPI GetThreadPriority(HANDLE);
WINBASEAPI BOOL WINAPI GetThreadPriorityBoost(HANDLE,PBOOL);
WINBASEAPI BOOL WINAPI GetThreadSelectorEntry(HANDLE,DWORD,LPLDT_ENTRY);
WINBASEAPI BOOL WINAPI GetThreadTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
WINBASEAPI DWORD WINAPI GetTickCount(VOID);
WINBASEAPI DWORD WINAPI GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
WINBASEAPI BOOL WINAPI GetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,PVOID,DWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetUserNameA (LPSTR,PDWORD);
WINBASEAPI BOOL WINAPI GetUserNameW(LPWSTR,PDWORD);
WINBASEAPI DWORD WINAPI GetVersion(void);
WINBASEAPI BOOL WINAPI GetVersionExA(LPOSVERSIONINFOA);
WINBASEAPI BOOL WINAPI GetVersionExW(LPOSVERSIONINFOW);
WINBASEAPI BOOL WINAPI GetVolumeInformationA(LPCSTR,LPSTR,DWORD,PDWORD,PDWORD,PDWORD,LPSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumeInformationW(LPCWSTR,LPWSTR,DWORD,PDWORD,PDWORD,PDWORD,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumeNameForVolumeMountPointA(LPCSTR,LPSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumeNameForVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumePathNameA(LPCSTR,LPSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumePathNameW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI GetVolumePathNamesForVolumeNameA(LPCSTR,LPSTR,DWORD,PDWORD);
WINBASEAPI BOOL WINAPI GetVolumePathNamesForVolumeNameW(LPCWSTR,LPWSTR,DWORD,PDWORD);
WINBASEAPI UINT WINAPI GetWindowsDirectoryA(LPSTR,UINT);
WINBASEAPI UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
WINBASEAPI DWORD WINAPI GetWindowThreadProcessId(HWND,PDWORD);
WINBASEAPI UINT WINAPI GetWriteWatch(DWORD,PVOID,SIZE_T,PVOID*,PULONG_PTR,PULONG);
WINBASEAPI ATOM WINAPI GlobalAddAtomA(LPCSTR);
WINBASEAPI ATOM WINAPI GlobalAddAtomW( LPCWSTR);
WINBASEAPI HGLOBAL WINAPI GlobalAlloc(UINT,DWORD);
WINBASEAPI SIZE_T WINAPI GlobalCompact(DWORD);
WINBASEAPI ATOM WINAPI GlobalDeleteAtom(ATOM);
WINBASEAPI ATOM WINAPI GlobalFindAtomA(LPCSTR);
WINBASEAPI ATOM WINAPI GlobalFindAtomW(LPCWSTR);
WINBASEAPI VOID WINAPI GlobalFix(HGLOBAL);
WINBASEAPI UINT WINAPI GlobalFlags(HGLOBAL);
WINBASEAPI HGLOBAL WINAPI GlobalFree(HGLOBAL);
WINBASEAPI UINT WINAPI GlobalGetAtomNameA(ATOM,LPSTR,int);
WINBASEAPI UINT WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,int);
WINBASEAPI HGLOBAL WINAPI GlobalHandle(PCVOID);
WINBASEAPI LPVOID WINAPI GlobalLock(HGLOBAL);
WINBASEAPI VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);

WINBASEAPI BOOL WINAPI GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
WINBASEAPI HGLOBAL WINAPI GlobalReAlloc(HGLOBAL,DWORD,UINT);
WINBASEAPI DWORD WINAPI GlobalSize(HGLOBAL);
WINBASEAPI VOID WINAPI GlobalUnfix(HGLOBAL); /* Obsolete: Has no effect. */
WINBASEAPI BOOL WINAPI GlobalUnlock(HGLOBAL);
WINBASEAPI BOOL WINAPI GlobalUnWire(HGLOBAL); /* Obsolete: Has no effect. */
WINBASEAPI PVOID WINAPI GlobalWire(HGLOBAL); /* Obsolete: Has no effect. */
WINBASEAPI PVOID WINAPI HeapAlloc(HANDLE,DWORD,DWORD);
SIZE_T WINAPI HeapCompact(HANDLE,DWORD);
WINBASEAPI HANDLE WINAPI HeapCreate(DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI HeapDestroy(HANDLE);
WINBASEAPI BOOL WINAPI HeapFree(HANDLE,DWORD,PVOID);
WINBASEAPI BOOL WINAPI HeapLock(HANDLE);
WINBASEAPI BOOL WINAPI HeapQueryInformation(HANDLE,HEAP_INFORMATION_CLASS,PVOID,SIZE_T,PSIZE_T);
WINBASEAPI PVOID WINAPI HeapReAlloc(HANDLE,DWORD,PVOID,DWORD);
WINBASEAPI BOOL WINAPI HeapSetInformation(HANDLE,HEAP_INFORMATION_CLASS,PVOID,SIZE_T);
WINBASEAPI DWORD WINAPI HeapSize(HANDLE,DWORD,PCVOID);
WINBASEAPI BOOL WINAPI HeapUnlock(HANDLE);
WINBASEAPI BOOL WINAPI HeapValidate(HANDLE,DWORD,PCVOID);
WINBASEAPI BOOL WINAPI HeapWalk(HANDLE,LPPROCESS_HEAP_ENTRY);
WINBASEAPI BOOL WINAPI ImpersonateLoggedOnUser(HANDLE);
WINBASEAPI BOOL WINAPI ImpersonateNamedPipeClient(HANDLE);
WINBASEAPI BOOL WINAPI ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
WINBASEAPI BOOL WINAPI InitAtomTable(DWORD);
WINBASEAPI BOOL WINAPI InitializeAcl(PACL,DWORD,DWORD);
WINBASEAPI VOID WINAPI InitializeCriticalSection(LPCRITICAL_SECTION);
WINBASEAPI BOOL WINAPI InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION,DWORD);
WINBASEAPI DWORD WINAPI SetCriticalSectionSpinCount(LPCRITICAL_SECTION,DWORD);
WINBASEAPI BOOL WINAPI InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
WINBASEAPI BOOL WINAPI InitializeSid (PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
WINBASEAPI VOID WINAPI InitializeSListHead(PSLIST_HEADER);

LONG WINAPI InterlockedCompareExchange(volatile LONG *,LONG,LONG);
LONG WINAPI InterlockedDecrement(volatile LONG *);
LONG WINAPI InterlockedExchange(volatile LONG *,LONG);
LONG WINAPI InterlockedExchangeAdd(volatile LONG *,LONG);
PSLIST_ENTRY WINAPI InterlockedFlushSList(PSLIST_HEADER);
LONG WINAPI InterlockedIncrement(volatile LONG *);
PSLIST_ENTRY WINAPI InterlockedPopEntrySList(PSLIST_HEADER);
PSLIST_ENTRY WINAPI InterlockedPushEntrySList(PSLIST_HEADER,PSLIST_ENTRY);
WINBASEAPI BOOL WINAPI IsBadCodePtr(FARPROC);
WINBASEAPI BOOL WINAPI IsBadHugeReadPtr(LPCVOID,UINT);
WINBASEAPI BOOL WINAPI IsBadHugeWritePtr(PVOID,UINT);
WINBASEAPI BOOL WINAPI IsBadReadPtr(LPCVOID,UINT);
WINBASEAPI BOOL WINAPI IsBadStringPtrA(LPCSTR,UINT);
WINBASEAPI BOOL WINAPI IsBadStringPtrW(LPCWSTR,UINT);
WINBASEAPI BOOL WINAPI IsBadWritePtr(PVOID,UINT);
WINBASEAPI BOOL WINAPI IsDebuggerPresent(void);
//WINBASEAPI BOOL IsProcessInJob(HANDLE,HANDLE,PBOOL);
WINBASEAPI BOOL WINAPI IsProcessorFeaturePresent(DWORD);
WINBASEAPI BOOL WINAPI IsSystemResumeAutomatic(void);
WINBASEAPI BOOL WINAPI IsTextUnicode(LPCVOID,int,LPINT);
WINBASEAPI BOOL WINAPI IsValidAcl(PACL);
WINBASEAPI BOOL WINAPI IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
WINBASEAPI BOOL WINAPI IsValidSid(PSID);
WINBASEAPI BOOL WINAPI IsWow64Process(HANDLE,PBOOL);
WINBASEAPI void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION);
WINBASEAPI HINSTANCE WINAPI LoadLibraryA(LPCSTR);
WINBASEAPI HINSTANCE WINAPI LoadLibraryExA(LPCSTR,HANDLE,DWORD);
WINBASEAPI HINSTANCE WINAPI LoadLibraryExW(LPCWSTR,HANDLE,DWORD);
WINBASEAPI HINSTANCE WINAPI LoadLibraryW(LPCWSTR);
WINBASEAPI DWORD WINAPI LoadModule(LPCSTR,PVOID);
WINBASEAPI HGLOBAL WINAPI LoadResource(HINSTANCE,HRSRC);
WINBASEAPI HLOCAL WINAPI LocalAlloc(UINT,SIZE_T);
WINBASEAPI SIZE_T WINAPI LocalCompact(UINT); /* Obsolete: Has no effect. */
//WINBASEAPI HLOCAL LocalDiscard(HLOCAL);
WINBASEAPI BOOL WINAPI LocalFileTimeToFileTime(CONST FILETIME *,LPFILETIME);
WINBASEAPI UINT WINAPI LocalFlags(HLOCAL); /* Obsolete: Has no effect. */
WINBASEAPI HLOCAL WINAPI LocalFree(HLOCAL);
WINBASEAPI HLOCAL WINAPI LocalHandle(LPCVOID);
WINBASEAPI PVOID WINAPI LocalLock(HLOCAL);
WINBASEAPI HLOCAL WINAPI LocalReAlloc(HLOCAL,SIZE_T,UINT);
WINBASEAPI SIZE_T WINAPI LocalShrink(HLOCAL,UINT);  /* Obsolete: Has no effect. */
WINBASEAPI UINT WINAPI LocalSize(HLOCAL);
WINBASEAPI BOOL WINAPI LocalUnlock(HLOCAL);
WINBASEAPI BOOL WINAPI LockFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI LockFileEx(HANDLE,DWORD,DWORD,DWORD,DWORD,LPOVERLAPPED);
WINBASEAPI PVOID WINAPI LockResource(HGLOBAL);
WINBASEAPI BOOL WINAPI LogonUserA(LPSTR,LPSTR,LPSTR,DWORD,DWORD,PHANDLE);
WINBASEAPI BOOL WINAPI LogonUserW(LPWSTR,LPWSTR,LPWSTR,DWORD,DWORD,PHANDLE);
WINBASEAPI BOOL WINAPI LookupAccountNameA(LPCSTR,LPCSTR,PSID,PDWORD,LPSTR,PDWORD,PSID_NAME_USE);
WINBASEAPI BOOL WINAPI LookupAccountNameW(LPCWSTR,LPCWSTR,PSID,PDWORD,LPWSTR,PDWORD,PSID_NAME_USE);
WINBASEAPI BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPSTR,PDWORD,LPSTR,PDWORD,PSID_NAME_USE);
WINBASEAPI BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPWSTR,PDWORD,LPWSTR,PDWORD,PSID_NAME_USE);
WINBASEAPI BOOL WINAPI LookupPrivilegeDisplayNameA(LPCSTR,LPCSTR,LPSTR,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI LookupPrivilegeDisplayNameW(LPCWSTR,LPCWSTR,LPWSTR,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI LookupPrivilegeNameA(LPCSTR,PLUID,LPSTR,PDWORD);
WINBASEAPI BOOL WINAPI LookupPrivilegeNameW(LPCWSTR,PLUID,LPWSTR,PDWORD);
WINBASEAPI BOOL WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,PLUID);
WINBASEAPI BOOL WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,PLUID);
WINBASEAPI LPSTR WINAPI lstrcatA(LPSTR,LPCSTR);
WINBASEAPI LPWSTR WINAPI lstrcatW(LPWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrcmpA(LPCSTR,LPCSTR);
WINBASEAPI int WINAPI lstrcmpiA(LPCSTR,LPCSTR);
WINBASEAPI int WINAPI lstrcmpiW( LPCWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrcmpW(LPCWSTR,LPCWSTR);
WINBASEAPI LPSTR WINAPI lstrcpyA(LPSTR,LPCSTR);
WINBASEAPI LPSTR WINAPI lstrcpynA(LPSTR,LPCSTR,int);
WINBASEAPI LPWSTR WINAPI lstrcpynW(LPWSTR,LPCWSTR,int);
WINBASEAPI LPWSTR WINAPI lstrcpyW(LPWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrlenA(LPCSTR);
WINBASEAPI int WINAPI lstrlenW(LPCWSTR);
WINBASEAPI BOOL WINAPI MakeAbsoluteSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,PDWORD,PACL,PDWORD,PACL,PDWORD,PSID,PDWORD,PSID,PDWORD);
WINBASEAPI BOOL WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,PDWORD);
WINBASEAPI VOID WINAPI MapGenericMask(PDWORD,PGENERIC_MAPPING);
WINBASEAPI PVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
WINBASEAPI PVOID WINAPI MapViewOfFileEx(HANDLE,DWORD,DWORD,DWORD,DWORD,PVOID);
WINBASEAPI BOOL WINAPI MoveFileA(LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI MoveFileExA(LPCSTR,LPCSTR,DWORD);
WINBASEAPI BOOL WINAPI MoveFileExW(LPCWSTR,LPCWSTR,DWORD);
WINBASEAPI BOOL WINAPI MoveFileW(LPCWSTR,LPCWSTR);
WINBASEAPI int WINAPI MulDiv(int,int,int);
WINBASEAPI BOOL WINAPI NotifyChangeEventLog(HANDLE,HANDLE);
WINBASEAPI BOOL WINAPI ObjectCloseAuditAlarmA(LPCSTR,PVOID,BOOL);
WINBASEAPI BOOL WINAPI ObjectCloseAuditAlarmW(LPCWSTR,PVOID,BOOL);
WINBASEAPI BOOL WINAPI ObjectDeleteAuditAlarmA(LPCSTR,PVOID,BOOL);
WINBASEAPI BOOL WINAPI ObjectDeleteAuditAlarmW(LPCWSTR,PVOID,BOOL);
WINBASEAPI BOOL WINAPI ObjectOpenAuditAlarmA(LPCSTR,PVOID,LPSTR,LPSTR,PSECURITY_DESCRIPTOR,HANDLE,DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,PBOOL);
WINBASEAPI BOOL WINAPI ObjectOpenAuditAlarmW(LPCWSTR,PVOID,LPWSTR,LPWSTR,PSECURITY_DESCRIPTOR,HANDLE,DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,PBOOL);
WINBASEAPI BOOL WINAPI ObjectPrivilegeAuditAlarmA(LPCSTR,PVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
WINBASEAPI BOOL WINAPI ObjectPrivilegeAuditAlarmW(LPCWSTR,PVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
WINBASEAPI HANDLE WINAPI OpenBackupEventLogA(LPCSTR,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenBackupEventLogW(LPCWSTR,LPCWSTR);
WINBASEAPI HANDLE WINAPI OpenEventA(DWORD,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenEventLogA (LPCSTR,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenEventLogW(LPCWSTR,LPCWSTR);
WINBASEAPI HANDLE WINAPI OpenEventW(DWORD,BOOL,LPCWSTR);
WINBASEAPI HFILE WINAPI OpenFile(LPCSTR,LPOFSTRUCT,UINT);
WINBASEAPI HANDLE WINAPI OpenFileMappingA(DWORD,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenFileMappingW(DWORD,BOOL,LPCWSTR);
WINBASEAPI HANDLE WINAPI OpenMutexA(DWORD,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenMutexW(DWORD,BOOL,LPCWSTR);
WINBASEAPI HANDLE WINAPI OpenProcess(DWORD,BOOL,DWORD);
WINBASEAPI BOOL WINAPI OpenProcessToken(HANDLE,DWORD,PHANDLE);
WINBASEAPI HANDLE WINAPI OpenSemaphoreA(DWORD,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenSemaphoreW(DWORD,BOOL,LPCWSTR);
WINBASEAPI HANDLE WINAPI OpenThread(DWORD,BOOL,DWORD);
WINBASEAPI BOOL WINAPI OpenThreadToken(HANDLE,DWORD,BOOL,PHANDLE);
WINBASEAPI HANDLE WINAPI OpenWaitableTimerA(DWORD,BOOL,LPCSTR);
WINBASEAPI HANDLE WINAPI OpenWaitableTimerW(DWORD,BOOL,LPCWSTR);
WINBASEAPI void WINAPI OutputDebugStringA(LPCSTR);
WINBASEAPI void WINAPI OutputDebugStringW(LPCWSTR);
WINBASEAPI BOOL WINAPI PeekNamedPipe(HANDLE,PVOID,DWORD,PDWORD,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI PostQueuedCompletionStatus(HANDLE,DWORD,ULONG_PTR,LPOVERLAPPED);
WINBASEAPI DWORD WINAPI PrepareTape(HANDLE,DWORD,BOOL);
WINBASEAPI BOOL WINAPI PrivilegeCheck (HANDLE,PPRIVILEGE_SET,PBOOL);
WINBASEAPI BOOL WINAPI PrivilegedServiceAuditAlarmA(LPCSTR,LPCSTR,HANDLE,PPRIVILEGE_SET,BOOL);
WINBASEAPI BOOL WINAPI PrivilegedServiceAuditAlarmW(LPCWSTR,LPCWSTR,HANDLE,PPRIVILEGE_SET,BOOL);
WINBASEAPI BOOL WINAPI ProcessIdToSessionId(DWORD,DWORD*);
WINBASEAPI BOOL WINAPI PulseEvent(HANDLE);
WINBASEAPI BOOL WINAPI PurgeComm(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI QueryActCtxW(DWORD,HANDLE,PVOID,ULONG,PVOID,SIZE_T,SIZE_T*);
WINBASEAPI DWORD WINAPI QueryDosDeviceA(LPCSTR,LPSTR,DWORD);
WINBASEAPI DWORD WINAPI QueryDosDeviceW(LPCWSTR,LPWSTR,DWORD);
WINBASEAPI BOOL WINAPI QueryMemoryResourceNotification(HANDLE,PBOOL);
WINBASEAPI BOOL WINAPI QueryPerformanceCounter(PLARGE_INTEGER);
WINBASEAPI BOOL WINAPI QueryPerformanceFrequency(PLARGE_INTEGER);
WINBASEAPI DWORD WINAPI QueueUserAPC(PAPCFUNC,HANDLE,ULONG_PTR);
WINBASEAPI BOOL WINAPI QueueUserWorkItem(LPTHREAD_START_ROUTINE,PVOID,ULONG);
WINBASEAPI void WINAPI RaiseException(DWORD,DWORD,DWORD,const DWORD*);
WINBASEAPI BOOL WINAPI ReadDirectoryChangesW(HANDLE,PVOID,DWORD,BOOL,DWORD,PDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
WINBASEAPI BOOL WINAPI ReadEventLogA(HANDLE,DWORD,DWORD,PVOID,DWORD,DWORD *,DWORD *);
WINBASEAPI BOOL WINAPI ReadEventLogW(HANDLE,DWORD,DWORD,PVOID,DWORD,DWORD *,DWORD *);
WINBASEAPI BOOL WINAPI ReadFile(HANDLE,PVOID,DWORD,PDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI ReadFileEx(HANDLE,PVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
WINBASEAPI BOOL WINAPI ReadFileScatter(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI ReadProcessMemory(HANDLE,LPCVOID,PVOID,DWORD,PDWORD);
WINBASEAPI HANDLE WINAPI RegisterEventSourceA (LPCSTR,LPCSTR);
WINBASEAPI HANDLE WINAPI RegisterEventSourceW(LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI RegisterWaitForSingleObject(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
WINBASEAPI HANDLE WINAPI RegisterWaitForSingleObjectEx(HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
WINBASEAPI void WINAPI ReleaseActCtx(HANDLE);
WINBASEAPI BOOL WINAPI ReleaseMutex(HANDLE);
WINBASEAPI BOOL WINAPI ReleaseSemaphore(HANDLE,LONG,LPLONG);
WINBASEAPI BOOL WINAPI RemoveDirectoryA(LPCSTR);
WINBASEAPI BOOL WINAPI RemoveDirectoryW(LPCWSTR);
WINBASEAPI ULONG WINAPI RemoveVectoredExceptionHandler(PVOID);
WINBASEAPI HANDLE WINAPI ReOpenFile(HANDLE,DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI ReplaceFileA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPVOID,LPVOID);
WINBASEAPI BOOL WINAPI ReplaceFileW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPVOID,LPVOID);
WINBASEAPI BOOL WINAPI ReportEventA(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCSTR*,PVOID);
WINBASEAPI BOOL WINAPI ReportEventW(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCWSTR*,PVOID);
WINBASEAPI BOOL WINAPI ResetEvent(HANDLE);
WINBASEAPI UINT WINAPI ResetWriteWatch(LPVOID,SIZE_T);
WINBASEAPI VOID WINAPI RestoreLastError(DWORD);
WINBASEAPI DWORD WINAPI ResumeThread(HANDLE);
WINBASEAPI BOOL WINAPI RevertToSelf(void);
WINBASEAPI DWORD WINAPI SearchPathA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPSTR,LPSTR*);
WINBASEAPI DWORD WINAPI SearchPathW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPWSTR,LPWSTR*);
WINBASEAPI BOOL WINAPI SetAclInformation(PACL,PVOID,DWORD,ACL_INFORMATION_CLASS);
WINBASEAPI BOOL WINAPI SetCommBreak(HANDLE);
WINBASEAPI BOOL WINAPI SetCommConfig(HANDLE,LPCOMMCONFIG,DWORD);
WINBASEAPI BOOL WINAPI SetCommMask(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetCommState(HANDLE,LPDCB);
WINBASEAPI BOOL WINAPI SetCommTimeouts(HANDLE,LPCOMMTIMEOUTS);
WINBASEAPI BOOL WINAPI SetComputerNameA(LPCSTR);
WINBASEAPI BOOL WINAPI SetComputerNameW(LPCWSTR);
WINBASEAPI BOOL WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT,LPCSTR);
WINBASEAPI BOOL WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT,LPCWSTR);
WINBASEAPI BOOL WINAPI SetCurrentDirectoryA(LPCSTR);
WINBASEAPI BOOL WINAPI SetCurrentDirectoryW(LPCWSTR);
WINBASEAPI BOOL WINAPI SetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,DWORD);
WINBASEAPI BOOL WINAPI SetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,DWORD);
WINBASEAPI BOOL WINAPI SetDllDirectoryA(LPCSTR);
WINBASEAPI BOOL WINAPI SetDllDirectoryW(LPCWSTR);
WINBASEAPI BOOL WINAPI SetEndOfFile(HANDLE);
WINBASEAPI BOOL WINAPI SetEnvironmentVariableA(LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI SetEnvironmentVariableW(LPCWSTR,LPCWSTR);
WINBASEAPI UINT WINAPI SetErrorMode(UINT);
WINBASEAPI BOOL WINAPI SetEvent(HANDLE);
WINBASEAPI VOID WINAPI SetFileApisToANSI(void);
WINBASEAPI VOID WINAPI SetFileApisToOEM(void);
WINBASEAPI BOOL WINAPI SetFileAttributesA(LPCSTR,DWORD);
WINBASEAPI BOOL WINAPI SetFileAttributesW(LPCWSTR,DWORD);
WINBASEAPI DWORD WINAPI SetFilePointer(HANDLE,LONG,PLONG,DWORD);
WINBASEAPI BOOL WINAPI SetFilePointerEx(HANDLE,LARGE_INTEGER,PLARGE_INTEGER,DWORD);
WINBASEAPI BOOL WINAPI SetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINBASEAPI BOOL WINAPI SetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINBASEAPI BOOL WINAPI SetFileTime(HANDLE,const FILETIME*,const FILETIME*,const FILETIME*);
WINBASEAPI BOOL WINAPI SetFileValidData(HANDLE,LONGLONG);
WINBASEAPI BOOL WINAPI SetFirmwareEnvironmentVariableA(LPCSTR,LPCSTR,PVOID,DWORD);
WINBASEAPI BOOL WINAPI SetFirmwareEnvironmentVariableW(LPCWSTR,LPCWSTR,PVOID,DWORD);
WINBASEAPI UINT WINAPI SetHandleCount(UINT);
WINBASEAPI BOOL WINAPI SetHandleInformation(HANDLE,DWORD,DWORD);
WINBASEAPI BOOL WINAPI SetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINBASEAPI void WINAPI SetLastError(DWORD);
WINBASEAPI void WINAPI SetLastErrorEx(DWORD,DWORD);
WINBASEAPI BOOL WINAPI SetLocalTime(const SYSTEMTIME*);
WINBASEAPI BOOL WINAPI SetMailslotInfo(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetNamedPipeHandleState(HANDLE,PDWORD,PDWORD,PDWORD);
WINBASEAPI BOOL WINAPI SetPriorityClass(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetPrivateObjectSecurity(SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR *,PGENERIC_MAPPING,HANDLE);
WINBASEAPI BOOL WINAPI SetProcessAffinityMask(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetProcessDEPPolicy (DWORD);
WINBASEAPI BOOL WINAPI SetProcessPriorityBoost(HANDLE,BOOL);
WINBASEAPI BOOL WINAPI SetProcessShutdownParameters(DWORD,DWORD);
WINBASEAPI BOOL WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
WINBASEAPI BOOL WINAPI SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,SECURITY_DESCRIPTOR_CONTROL,SECURITY_DESCRIPTOR_CONTROL);
WINBASEAPI BOOL WINAPI SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
WINBASEAPI BOOL WINAPI SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID,BOOL);
WINBASEAPI BOOL WINAPI SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID,BOOL);
WINBASEAPI BOOL WINAPI SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
WINBASEAPI BOOL WINAPI SetStdHandle(DWORD,HANDLE);
WINBASEAPI BOOL WINAPI SetSystemPowerState(BOOL,BOOL);
WINBASEAPI BOOL WINAPI SetSystemTime(const SYSTEMTIME*);
WINBASEAPI BOOL WINAPI SetSystemTimeAdjustment(DWORD,BOOL);
WINBASEAPI DWORD WINAPI SetTapeParameters(HANDLE,DWORD,PVOID);
WINBASEAPI DWORD WINAPI SetTapePosition(HANDLE,DWORD,DWORD,DWORD,DWORD,BOOL);
WINBASEAPI DWORD WINAPI SetThreadAffinityMask(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetThreadContext(HANDLE,const CONTEXT*);
WINBASEAPI EXECUTION_STATE WINAPI SetThreadExecutionState(EXECUTION_STATE);
WINBASEAPI DWORD WINAPI SetThreadIdealProcessor(HANDLE,DWORD);
WINBASEAPI BOOL WINAPI SetThreadPriority(HANDLE,int);
WINBASEAPI BOOL WINAPI SetThreadPriorityBoost(HANDLE,BOOL);
WINBASEAPI BOOL WINAPI SetThreadToken (PHANDLE,HANDLE);
WINBASEAPI BOOL WINAPI SetTimeZoneInformation(const TIME_ZONE_INFORMATION *);
WINBASEAPI BOOL WINAPI SetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,PVOID,DWORD);
WINBASEAPI LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
WINBASEAPI BOOL WINAPI SetupComm(HANDLE,DWORD,DWORD);
WINBASEAPI BOOL WINAPI SetVolumeLabelA(LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI SetVolumeLabelW(LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI SetVolumeMountPointA(LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI SetVolumeMountPointW(LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI SetWaitableTimer(HANDLE,const LARGE_INTEGER*,LONG,PTIMERAPCROUTINE,PVOID,BOOL);
WINBASEAPI DWORD WINAPI SignalObjectAndWait(HANDLE,HANDLE,DWORD,BOOL);
WINBASEAPI DWORD WINAPI SizeofResource(HINSTANCE,HRSRC);
WINBASEAPI void WINAPI Sleep(DWORD);
WINBASEAPI DWORD WINAPI SleepEx(DWORD,BOOL);
WINBASEAPI DWORD WINAPI SuspendThread(HANDLE);
WINBASEAPI void WINAPI SwitchToFiber(PVOID);
WINBASEAPI BOOL WINAPI SwitchToThread(void);
WINBASEAPI BOOL WINAPI SystemTimeToFileTime(const SYSTEMTIME*,LPFILETIME);
WINBASEAPI BOOL WINAPI SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION,LPSYSTEMTIME,LPSYSTEMTIME);
WINBASEAPI BOOL WINAPI TerminateProcess(HANDLE,UINT);
WINBASEAPI BOOL WINAPI TerminateThread(HANDLE,DWORD);
WINBASEAPI DWORD WINAPI TlsAlloc(VOID);
WINBASEAPI BOOL WINAPI TlsFree(DWORD);
WINBASEAPI PVOID WINAPI TlsGetValue(DWORD);
WINBASEAPI BOOL WINAPI TlsSetValue(DWORD,PVOID);
WINBASEAPI BOOL WINAPI TransactNamedPipe(HANDLE,PVOID,DWORD,PVOID,DWORD,PDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI TransmitCommChar(HANDLE,char);
WINBASEAPI BOOL WINAPI TryEnterCriticalSection(LPCRITICAL_SECTION);
WINBASEAPI LONG WINAPI UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
WINBASEAPI BOOL WINAPI UnlockFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI UnlockFileEx(HANDLE,DWORD,DWORD,DWORD,LPOVERLAPPED);

WINBASEAPI BOOL WINAPI UnmapViewOfFile(PVOID);
WINBASEAPI BOOL WINAPI UnregisterWait(HANDLE);
WINBASEAPI BOOL WINAPI UnregisterWaitEx(HANDLE,HANDLE);
WINBASEAPI BOOL WINAPI UpdateResourceA(HANDLE,LPCSTR,LPCSTR,WORD,PVOID,DWORD);
WINBASEAPI BOOL WINAPI UpdateResourceW(HANDLE,LPCWSTR,LPCWSTR,WORD,PVOID,DWORD);
WINBASEAPI BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA,DWORD,DWORDLONG);
WINBASEAPI BOOL WINAPI VerifyVersionInfoW(LPOSVERSIONINFOEXW,DWORD,DWORDLONG);
WINBASEAPI PVOID WINAPI VirtualAlloc(PVOID,DWORD,DWORD,DWORD);
WINBASEAPI PVOID WINAPI VirtualAllocEx(HANDLE,PVOID,DWORD,DWORD,DWORD);
WINBASEAPI BOOL WINAPI VirtualFree(PVOID,DWORD,DWORD);
WINBASEAPI BOOL WINAPI VirtualFreeEx(HANDLE,PVOID,DWORD,DWORD);
WINBASEAPI BOOL WINAPI VirtualLock(PVOID,DWORD);
WINBASEAPI BOOL WINAPI VirtualProtect(PVOID,DWORD,DWORD,PDWORD);
WINBASEAPI BOOL WINAPI VirtualProtectEx(HANDLE,PVOID,DWORD,DWORD,PDWORD);
WINBASEAPI DWORD WINAPI VirtualQuery(LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
WINBASEAPI DWORD WINAPI VirtualQueryEx(HANDLE,LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
WINBASEAPI BOOL WINAPI VirtualUnlock(PVOID,DWORD);
WINBASEAPI BOOL WINAPI WaitCommEvent(HANDLE,PDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI WaitForDebugEvent(LPDEBUG_EVENT,DWORD);
WINBASEAPI DWORD WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
WINBASEAPI DWORD WINAPI WaitForMultipleObjectsEx(DWORD,const HANDLE*,BOOL,DWORD,BOOL);
WINBASEAPI DWORD WINAPI WaitForSingleObject(HANDLE,DWORD);
WINBASEAPI DWORD WINAPI WaitForSingleObjectEx(HANDLE,DWORD,BOOL);
WINBASEAPI BOOL WINAPI WaitNamedPipeA(LPCSTR,DWORD);
WINBASEAPI BOOL WINAPI WaitNamedPipeW(LPCWSTR,DWORD);
WINBASEAPI BOOL WINAPI WinLoadTrustProvider(GUID*);
WINBASEAPI BOOL WINAPI WriteFile(HANDLE,LPCVOID,DWORD,PDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI WriteFileEx(HANDLE,LPCVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
WINBASEAPI BOOL WINAPI WriteFileGather(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
WINBASEAPI BOOL WINAPI WritePrivateProfileSectionA(LPCSTR,LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI WritePrivateProfileSectionW(LPCWSTR,LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI WritePrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI WritePrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI WritePrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
WINBASEAPI BOOL WINAPI WritePrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
WINBASEAPI BOOL WINAPI WriteProcessMemory(HANDLE,LPVOID,LPCVOID,SIZE_T,SIZE_T*);
WINBASEAPI BOOL WINAPI WriteProfileSectionA(LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI WriteProfileSectionW(LPCWSTR,LPCWSTR);
WINBASEAPI BOOL WINAPI WriteProfileStringA(LPCSTR,LPCSTR,LPCSTR);
WINBASEAPI BOOL WINAPI WriteProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR);
WINBASEAPI DWORD WINAPI WriteTapemark(HANDLE,DWORD,DWORD,BOOL);
WINBASEAPI BOOL WINAPI ZombifyActCtx(HANDLE);
WINBASEAPI BOOL WINAPI AllocateUserPhysicalPages(HANDLE,PULONG_PTR,PULONG_PTR);
WINBASEAPI BOOL WINAPI FreeUserPhysicalPages(HANDLE,PULONG_PTR,PULONG_PTR);
WINBASEAPI BOOL WINAPI MapUserPhysicalPages(PVOID,ULONG_PTR,PULONG_PTR);
WINBASEAPI BOOL WINAPI MapUserPhysicalPagesScatter(PVOID*,ULONG_PTR,PULONG_PTR);
WINBASEAPI void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION);

WINBASEAPI BOOL WINAPI GetCPInfoExA(UINT,DWORD,LPCPINFOEXA);
WINBASEAPI BOOL WINAPI GetCPInfoExW(UINT,DWORD,LPCPINFOEXW);
WINBASEAPI BOOL WINAPI GetCPInfo(UINT,LPCPINFO);
WINBASEAPI BOOL WINAPI GetStringTypeA(LCID,DWORD,LPCSTR,int,LPWORD);
WINBASEAPI BOOL WINAPI GetStringTypeW(DWORD,LPCWSTR,int,LPWORD);
WINBASEAPI BOOL WINAPI IsDBCSLeadByte(BYTE);
WINBASEAPI BOOL WINAPI IsDBCSLeadByteEx(UINT,BYTE);
WINBASEAPI int WINAPI CompareStringA(LCID,DWORD,LPCSTR,int,LPCSTR,int);
WINBASEAPI int WINAPI CompareStringW(LCID,DWORD,LPCWSTR,int,LPCWSTR,int);
WINBASEAPI int WINAPI GetDateFormatA(LCID,DWORD,const SYSTEMTIME*,LPCSTR,LPSTR,int);
WINBASEAPI int WINAPI GetLocaleInfoA(LCID,LCTYPE,LPSTR,int);
WINBASEAPI int WINAPI GetTimeFormatA(LCID,DWORD,const SYSTEMTIME*,LPCSTR,LPSTR,int);
WINBASEAPI int WINAPI LCMapStringA(LCID,DWORD,LPCSTR,int,LPSTR,int);
WINBASEAPI int WINAPI LCMapStringW(LCID,DWORD,LPCWSTR,int,LPWSTR,int);
WINBASEAPI int WINAPI MultiByteToWideChar(UINT,DWORD,LPCSTR,int,LPWSTR,int);
WINBASEAPI int WINAPI WideCharToMultiByte(UINT,DWORD,LPCWSTR,int,LPSTR,int,LPCSTR,LPBOOL);
WINBASEAPI LANGID WINAPI GetUserDefaultLangID(void);
WINBASEAPI UINT WINAPI GetACP(void);
WINBASEAPI UINT WINAPI GetOEMCP(void);
WINADVAPI LONG WINAPI RegDeleteValueA(HKEY,LPCSTR);
WINADVAPI LONG WINAPI RegOpenKeyExA(HKEY,LPCSTR,DWORD,REGSAM,PHKEY);

WINUSERAPI HKL WINAPI ActivateKeyboardLayout(HKL,UINT);
WINUSERAPI BOOL WINAPI AdjustWindowRect(LPRECT,DWORD,BOOL);
WINUSERAPI BOOL WINAPI AdjustWindowRectEx(LPRECT,DWORD,BOOL,DWORD);
WINUSERAPI BOOL WINAPI AnimateWindow(HWND,DWORD,DWORD);
WINUSERAPI BOOL WINAPI AnyPopup(void);
WINUSERAPI BOOL WINAPI AppendMenuA(HMENU,UINT,UINT_PTR,LPCSTR);
WINUSERAPI BOOL WINAPI AppendMenuW(HMENU,UINT,UINT_PTR,LPCWSTR);
WINUSERAPI UINT WINAPI ArrangeIconicWindows(HWND);
WINUSERAPI BOOL WINAPI AttachThreadInput(DWORD,DWORD,BOOL);
WINUSERAPI HDWP WINAPI BeginDeferWindowPos(int);
WINUSERAPI HDC WINAPI BeginPaint(HWND,LPPAINTSTRUCT);
WINUSERAPI BOOL WINAPI BringWindowToTop(HWND);
WINUSERAPI long WINAPI BroadcastSystemMessage(DWORD,LPDWORD,UINT,WPARAM,LPARAM);
WINUSERAPI long WINAPI BroadcastSystemMessageA(DWORD,LPDWORD,UINT,WPARAM,LPARAM);
WINUSERAPI long WINAPI BroadcastSystemMessageW(DWORD,LPDWORD,UINT,WPARAM,LPARAM);
WINUSERAPI long WINAPI BroadcastSystemMessageExA(DWORD,LPDWORD,UINT,WPARAM,LPARAM,PBSMINFO);
WINUSERAPI long WINAPI BroadcastSystemMessageExW(DWORD,LPDWORD,UINT,WPARAM,LPARAM,PBSMINFO);
WINUSERAPI BOOL WINAPI CallMsgFilterA(LPMSG,INT);
WINUSERAPI BOOL WINAPI CallMsgFilterW(LPMSG,INT);
WINUSERAPI LRESULT WINAPI CallNextHookEx(HHOOK,int,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI CallWindowProcA(WNDPROC,HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI CallWindowProcW(WNDPROC,HWND,UINT,WPARAM,LPARAM);
WINUSERAPI WORD WINAPI CascadeWindows(HWND,UINT,LPCRECT,UINT,const HWND*);
WINUSERAPI BOOL WINAPI ChangeClipboardChain(HWND,HWND);
WINUSERAPI LONG WINAPI ChangeDisplaySettingsA(PDEVMODEA,DWORD);
WINUSERAPI LONG WINAPI ChangeDisplaySettingsW(PDEVMODEW,DWORD);
WINUSERAPI LONG WINAPI ChangeDisplaySettingsExA(LPCSTR,LPDEVMODEA,HWND,DWORD,LPVOID);
WINUSERAPI LONG WINAPI ChangeDisplaySettingsExW(LPCWSTR,LPDEVMODEW,HWND,DWORD,LPVOID);
WINUSERAPI BOOL WINAPI ChangeMenuA(HMENU,UINT,LPCSTR,UINT,UINT);
WINUSERAPI BOOL WINAPI ChangeMenuW(HMENU,UINT,LPCWSTR,UINT,UINT);

WINUSERAPI LPSTR WINAPI CharLowerA(LPSTR);
WINUSERAPI LPWSTR WINAPI CharLowerW(LPWSTR);
WINUSERAPI DWORD WINAPI CharLowerBuffA(LPSTR,DWORD);
WINUSERAPI DWORD WINAPI CharLowerBuffW(LPWSTR,DWORD);
WINUSERAPI LPSTR WINAPI CharNextA(LPCSTR);
WINUSERAPI LPWSTR WINAPI CharNextW(LPCWSTR);
WINUSERAPI LPSTR WINAPI CharNextExA(WORD,LPCSTR,DWORD);
WINUSERAPI LPSTR WINAPI CharPrevA(LPCSTR,LPCSTR);
WINUSERAPI LPWSTR WINAPI CharPrevW(LPCWSTR,LPCWSTR);
WINUSERAPI LPSTR WINAPI CharPrevExA(WORD,LPCSTR,LPCSTR,DWORD);
WINUSERAPI BOOL WINAPI CharToOemA(LPCSTR,LPSTR);
WINUSERAPI BOOL WINAPI CharToOemW(LPCWSTR,LPSTR);
WINUSERAPI BOOL WINAPI CharToOemBuffA(LPCSTR,LPSTR,DWORD);
WINUSERAPI BOOL WINAPI CharToOemBuffW(LPCWSTR,LPSTR,DWORD);
WINUSERAPI LPSTR WINAPI CharUpperA(LPSTR);
WINUSERAPI LPWSTR WINAPI CharUpperW(LPWSTR);
WINUSERAPI DWORD WINAPI CharUpperBuffA(LPSTR,DWORD);
WINUSERAPI DWORD WINAPI CharUpperBuffW(LPWSTR,DWORD);
WINUSERAPI BOOL WINAPI CheckDlgButton(HWND,int,UINT);
WINUSERAPI DWORD WINAPI CheckMenuItem(HMENU,UINT,UINT);
WINUSERAPI BOOL WINAPI CheckMenuRadioItem(HMENU,UINT,UINT,UINT,UINT);
WINUSERAPI BOOL WINAPI CheckRadioButton(HWND,int,int,int);
WINUSERAPI HWND WINAPI ChildWindowFromPoint(HWND,POINT);
WINUSERAPI HWND WINAPI ChildWindowFromPointEx(HWND,POINT,UINT);
WINUSERAPI BOOL WINAPI ClientToScreen(HWND,LPPOINT);
WINUSERAPI BOOL WINAPI ClipCursor(LPCRECT);
WINUSERAPI BOOL WINAPI CloseClipboard(void);
WINUSERAPI BOOL WINAPI CloseDesktop(HDESK);
WINUSERAPI BOOL WINAPI CloseWindow(HWND);
WINUSERAPI BOOL WINAPI CloseWindowStation(HWINSTA);
WINUSERAPI int WINAPI CopyAcceleratorTableA(HACCEL,LPACCEL,int);
WINUSERAPI int WINAPI CopyAcceleratorTableW(HACCEL,LPACCEL,int);
WINUSERAPI HICON WINAPI CopyIcon(HICON);
WINUSERAPI HANDLE WINAPI CopyImage(HANDLE,UINT,int,int,UINT);
WINUSERAPI BOOL WINAPI CopyRect(LPRECT,LPCRECT);
WINUSERAPI int WINAPI CountClipboardFormats(void);
WINUSERAPI HACCEL WINAPI CreateAcceleratorTableA(LPACCEL,int);
WINUSERAPI HACCEL WINAPI CreateAcceleratorTableW(LPACCEL,int);
WINUSERAPI BOOL WINAPI CreateCaret(HWND,HBITMAP,int,int);
WINUSERAPI HCURSOR WINAPI CreateCursor(HINSTANCE,int,int,int,int,LPCVOID,LPCVOID);
WINUSERAPI HDESK WINAPI CreateDesktopA(LPCSTR,LPCSTR,LPDEVMODEA,DWORD,ACCESS_MASK,LPSECURITY_ATTRIBUTES);
WINUSERAPI HDESK WINAPI CreateDesktopW(LPCWSTR,LPCWSTR,LPDEVMODEW,DWORD,ACCESS_MASK,LPSECURITY_ATTRIBUTES);
WINUSERAPI HWND WINAPI CreateDialogIndirectParamA(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
WINUSERAPI HWND WINAPI CreateDialogIndirectParamW(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
WINUSERAPI HWND WINAPI CreateDialogParamA(HINSTANCE,LPCSTR,HWND,DLGPROC,LPARAM);
WINUSERAPI HWND WINAPI CreateDialogParamW(HINSTANCE,LPCWSTR,HWND,DLGPROC,LPARAM);
WINUSERAPI HICON WINAPI CreateIcon(HINSTANCE,int,int,BYTE,BYTE,const BYTE*,const BYTE*);
WINUSERAPI HICON WINAPI CreateIconFromResource(PBYTE,DWORD,BOOL,DWORD);
WINUSERAPI HICON WINAPI CreateIconFromResourceEx(PBYTE,DWORD,BOOL,DWORD,int,int,UINT);
WINUSERAPI HICON WINAPI CreateIconIndirect(PICONINFO);
WINUSERAPI HWND WINAPI CreateMDIWindowA(LPCSTR,LPCSTR,DWORD,int,int,int,int,HWND,HINSTANCE,LPARAM);
WINUSERAPI HWND WINAPI CreateMDIWindowW(LPCWSTR,LPCWSTR,DWORD,int,int,int,int,HWND,HINSTANCE,LPARAM);
WINUSERAPI HMENU WINAPI CreateMenu(void);
WINUSERAPI HMENU WINAPI CreatePopupMenu(void);
WINUSERAPI HWND WINAPI CreateWindowExA(DWORD,LPCSTR,LPCSTR,DWORD,int,int,int,int,HWND,HMENU,HINSTANCE,LPVOID);
WINUSERAPI HWND WINAPI CreateWindowExW(DWORD,LPCWSTR,LPCWSTR,DWORD,int,int,int,int,HWND,HMENU,HINSTANCE,LPVOID);
WINUSERAPI HWINSTA WINAPI CreateWindowStationA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINUSERAPI HWINSTA WINAPI CreateWindowStationW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
WINUSERAPI LRESULT WINAPI DefDlgProcA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefDlgProcW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI HDWP WINAPI DeferWindowPos(HDWP,HWND,HWND,int,int,int,int,UINT);
WINUSERAPI LRESULT WINAPI DefFrameProcA(HWND,HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefFrameProcW(HWND,HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefMDIChildProcA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefMDIChildProcW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefRawInputProc(PRAWINPUT*,INT,UINT);
WINUSERAPI LRESULT WINAPI DefWindowProcA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI LRESULT WINAPI DefWindowProcW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI DeleteMenu(HMENU,UINT,UINT);
WINUSERAPI BOOL WINAPI DeregisterShellHookWindow(HWND);
WINUSERAPI BOOL WINAPI DestroyAcceleratorTable(HACCEL);
WINUSERAPI BOOL WINAPI DestroyCaret(void);
WINUSERAPI BOOL WINAPI DestroyCursor(HCURSOR);
WINUSERAPI BOOL WINAPI DestroyIcon(HICON);
WINUSERAPI BOOL WINAPI DestroyMenu(HMENU);
WINUSERAPI BOOL WINAPI DestroyWindow(HWND);
WINUSERAPI int WINAPI DialogBoxIndirectParamA(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
WINUSERAPI int WINAPI DialogBoxIndirectParamW(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
WINUSERAPI int WINAPI DialogBoxParamA(HINSTANCE,LPCSTR,HWND,DLGPROC,LPARAM);
WINUSERAPI int WINAPI DialogBoxParamW(HINSTANCE,LPCWSTR,HWND,DLGPROC,LPARAM);
WINUSERAPI LONG WINAPI DispatchMessageA(const MSG*);
WINUSERAPI LONG WINAPI DispatchMessageW(const MSG*);
WINUSERAPI int WINAPI DlgDirListA(HWND,LPSTR,int,int,UINT);
WINUSERAPI int WINAPI DlgDirListW(HWND,LPWSTR,int,int,UINT);
WINUSERAPI int WINAPI DlgDirListComboBoxA(HWND,LPSTR,int,int,UINT);
WINUSERAPI int WINAPI DlgDirListComboBoxW(HWND,LPWSTR,int,int,UINT);
WINUSERAPI BOOL WINAPI DlgDirSelectComboBoxExA(HWND,LPSTR,int,int);
WINUSERAPI BOOL WINAPI DlgDirSelectComboBoxExW(HWND,LPWSTR,int,int);
WINUSERAPI BOOL WINAPI DlgDirSelectExA(HWND,LPSTR,int,int);
WINUSERAPI BOOL WINAPI DlgDirSelectExW(HWND,LPWSTR,int,int);
WINUSERAPI BOOL WINAPI DragDetect(HWND,POINT);
WINUSERAPI DWORD WINAPI DragObject(HWND,HWND,UINT,DWORD,HCURSOR);
WINUSERAPI BOOL WINAPI DrawAnimatedRects(HWND,int,LPCRECT,LPCRECT);
WINUSERAPI BOOL WINAPI DrawCaption(HWND,HDC,LPCRECT,UINT);
WINUSERAPI BOOL WINAPI DrawEdge(HDC,LPRECT,UINT,UINT);
WINUSERAPI BOOL WINAPI DrawFocusRect(HDC,LPCRECT);
WINUSERAPI BOOL WINAPI DrawFrameControl(HDC,LPRECT,UINT,UINT);
WINUSERAPI BOOL WINAPI DrawIcon(HDC,int,int,HICON);
WINUSERAPI BOOL WINAPI DrawIconEx(HDC,int,int,HICON,int,int,UINT,HBRUSH,UINT);
WINUSERAPI BOOL WINAPI DrawMenuBar(HWND);
WINUSERAPI BOOL WINAPI DrawStateA(HDC,HBRUSH,DRAWSTATEPROC,LPARAM,WPARAM,int,int,int,int,UINT);
WINUSERAPI BOOL WINAPI DrawStateW(HDC,HBRUSH,DRAWSTATEPROC,LPARAM,WPARAM,int,int,int,int,UINT);
WINUSERAPI int WINAPI DrawTextA(HDC,LPCSTR,int,LPRECT,UINT);
WINUSERAPI int WINAPI DrawTextW(HDC,LPCWSTR,int,LPRECT,UINT);
WINUSERAPI int WINAPI DrawTextExA(HDC,LPSTR,int,LPRECT,UINT,LPDRAWTEXTPARAMS);
WINUSERAPI int WINAPI DrawTextExW(HDC,LPWSTR,int,LPRECT,UINT,LPDRAWTEXTPARAMS);
WINUSERAPI BOOL WINAPI EmptyClipboard(void);
WINUSERAPI BOOL WINAPI EnableMenuItem(HMENU,UINT,UINT);
WINUSERAPI BOOL WINAPI EnableScrollBar(HWND,UINT,UINT);
WINUSERAPI BOOL WINAPI EnableWindow(HWND,BOOL);
WINUSERAPI BOOL WINAPI EndDeferWindowPos(HDWP);
WINUSERAPI BOOL WINAPI EndDialog(HWND,int);
WINUSERAPI BOOL WINAPI EndMenu(void);
WINUSERAPI BOOL WINAPI EndPaint(HWND,const PAINTSTRUCT*);
WINUSERAPI BOOL WINAPI EndTask(HWND,BOOL,BOOL);
WINUSERAPI BOOL WINAPI EnumChildWindows(HWND,ENUMWINDOWSPROC,LPARAM);
WINUSERAPI UINT WINAPI EnumClipboardFormats(UINT);
WINUSERAPI BOOL WINAPI EnumDesktopsA(HWINSTA,DESKTOPENUMPROCA,LPARAM);
WINUSERAPI BOOL WINAPI EnumDesktopsW(HWINSTA,DESKTOPENUMPROCW,LPARAM);
WINUSERAPI BOOL WINAPI EnumDesktopWindows(HDESK,ENUMWINDOWSPROC,LPARAM);
WINUSERAPI BOOL WINAPI EnumDisplayMonitors(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
WINUSERAPI BOOL WINAPI EnumDisplaySettingsA(LPCSTR,DWORD,PDEVMODEA);
WINUSERAPI BOOL WINAPI EnumDisplaySettingsW(LPCWSTR,DWORD,PDEVMODEW);
WINUSERAPI BOOL WINAPI EnumDisplaySettingsExA(LPCSTR,DWORD,LPDEVMODEA,DWORD);
WINUSERAPI BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR,DWORD,LPDEVMODEW,DWORD);
WINUSERAPI BOOL WINAPI EnumDisplayDevicesA(LPCSTR,DWORD,PDISPLAY_DEVICEA,DWORD);
WINUSERAPI BOOL WINAPI EnumDisplayDevicesW(LPCWSTR,DWORD,PDISPLAY_DEVICEW,DWORD);
WINUSERAPI int WINAPI EnumPropsA(HWND,PROPENUMPROCA);
WINUSERAPI int WINAPI EnumPropsW(HWND,PROPENUMPROCW);
WINUSERAPI int WINAPI EnumPropsExA(HWND,PROPENUMPROCEXA,LPARAM);
WINUSERAPI int WINAPI EnumPropsExW(HWND,PROPENUMPROCEXW,LPARAM);
WINUSERAPI BOOL WINAPI EnumThreadWindows(DWORD,WNDENUMPROC,LPARAM);
WINUSERAPI BOOL WINAPI EnumWindows(WNDENUMPROC,LPARAM);
WINUSERAPI BOOL WINAPI EnumWindowStationsA(WINSTAENUMPROCA,LPARAM);
WINUSERAPI BOOL WINAPI EnumWindowStationsW(WINSTAENUMPROCW,LPARAM);
WINUSERAPI BOOL WINAPI EqualRect(LPCRECT,LPCRECT);
WINUSERAPI BOOL WINAPI ExitWindowsEx(UINT,DWORD);
WINUSERAPI HWND WINAPI FindWindowA(LPCSTR,LPCSTR);
WINUSERAPI HWND WINAPI FindWindowExA(HWND,HWND,LPCSTR,LPCSTR);
WINUSERAPI HWND WINAPI FindWindowExW(HWND,HWND,LPCWSTR,LPCWSTR);
WINUSERAPI HWND WINAPI FindWindowW(LPCWSTR,LPCWSTR);
WINUSERAPI BOOL WINAPI FlashWindow(HWND,BOOL);
WINUSERAPI BOOL WINAPI FlashWindowEx(PFLASHWINFO);
int WINAPI FrameRect(HDC,LPCRECT,HBRUSH);
WINUSERAPI BOOL WINAPI FrameRgn(HDC,HRGN,HBRUSH,int,int);
WINUSERAPI HWND WINAPI GetActiveWindow(void);
WINUSERAPI HWND WINAPI GetAncestor(HWND,UINT);
WINUSERAPI SHORT WINAPI GetAsyncKeyState(int);
WINUSERAPI HWND WINAPI GetCapture(void);
WINUSERAPI UINT WINAPI GetCaretBlinkTime(void);
WINUSERAPI BOOL WINAPI GetCaretPos(LPPOINT);
WINUSERAPI BOOL WINAPI GetClassInfoA(HINSTANCE,LPCSTR,LPWNDCLASSA);
WINUSERAPI BOOL WINAPI GetClassInfoExA(HINSTANCE,LPCSTR,LPWNDCLASSEXA);
WINUSERAPI BOOL WINAPI GetClassInfoW(HINSTANCE,LPCWSTR,LPWNDCLASSW);
WINUSERAPI BOOL WINAPI GetClassInfoExW(HINSTANCE,LPCWSTR,LPWNDCLASSEXW);
WINUSERAPI DWORD WINAPI GetClassLongA(HWND,int);
WINUSERAPI DWORD WINAPI GetClassLongW(HWND,int);
WINUSERAPI int WINAPI GetClassNameA(HWND,LPSTR,int);
WINUSERAPI int WINAPI GetClassNameW(HWND,LPWSTR,int);
WINUSERAPI WORD WINAPI GetClassWord(HWND,int);
WINUSERAPI BOOL WINAPI GetClientRect(HWND,LPRECT);
WINUSERAPI HANDLE WINAPI GetClipboardData(UINT);
WINUSERAPI int WINAPI GetClipboardFormatNameA(UINT,LPSTR,int);
WINUSERAPI int WINAPI GetClipboardFormatNameW(UINT,LPWSTR,int);
WINUSERAPI HWND WINAPI GetClipboardOwner(void);
WINUSERAPI DWORD WINAPI GetClipboardSequenceNumber(void);
HWND WINAPI GetClipboardViewer(void);
WINUSERAPI BOOL WINAPI GetClipCursor(LPRECT);
WINUSERAPI BOOL WINAPI GetCursorPos(LPPOINT);
WINUSERAPI HDC WINAPI GetDC(HWND);
WINUSERAPI HDC WINAPI GetDCEx(HWND,HRGN,DWORD);
WINUSERAPI HWND WINAPI GetDesktopWindow(void);
WINUSERAPI long WINAPI GetDialogBaseUnits(void);
WINUSERAPI int WINAPI GetDlgCtrlID(HWND);
WINUSERAPI HWND WINAPI GetDlgItem(HWND,int);
WINUSERAPI UINT WINAPI GetDlgItemInt(HWND,int,PBOOL,BOOL);
WINUSERAPI UINT WINAPI GetDlgItemTextA(HWND,int,LPSTR,int);
WINUSERAPI UINT WINAPI GetDlgItemTextW(HWND,int,LPWSTR,int);
WINUSERAPI UINT WINAPI GetDoubleClickTime(void);
WINUSERAPI HWND WINAPI GetFocus(void);
WINUSERAPI HWND WINAPI GetForegroundWindow(void);
WINUSERAPI DWORD WINAPI GetGuiResources(HANDLE,DWORD);
WINUSERAPI BOOL WINAPI GetIconInfo(HICON,PICONINFO);
WINUSERAPI BOOL WINAPI GetInputState(void);
WINUSERAPI UINT WINAPI GetKBCodePage(void);
WINUSERAPI HKL WINAPI GetKeyboardLayout(DWORD);
WINUSERAPI UINT WINAPI GetKeyboardLayoutList(int,HKL*);
WINUSERAPI BOOL WINAPI GetKeyboardLayoutNameA(LPSTR);
WINUSERAPI BOOL WINAPI GetKeyboardLayoutNameW(LPWSTR);
WINUSERAPI BOOL WINAPI GetKeyboardState(PBYTE);
WINUSERAPI int WINAPI GetKeyboardType(int);
WINUSERAPI int WINAPI GetKeyNameTextA(LONG,LPSTR,int);
WINUSERAPI int WINAPI GetKeyNameTextW(LONG,LPWSTR,int);
WINUSERAPI SHORT WINAPI GetKeyState(int);
WINUSERAPI HWND WINAPI GetLastActivePopup(HWND);
WINUSERAPI HMENU WINAPI GetMenu(HWND);
WINUSERAPI LONG WINAPI GetMenuCheckMarkDimensions(void);
WINUSERAPI DWORD WINAPI GetMenuContextHelpId(HMENU);
WINUSERAPI UINT WINAPI GetMenuDefaultItem(HMENU,UINT,UINT);
WINUSERAPI int WINAPI GetMenuItemCount(HMENU);
WINUSERAPI UINT WINAPI GetMenuItemID(HMENU,int);
WINUSERAPI BOOL WINAPI GetMenuItemInfoA(HMENU,UINT,BOOL,LPMENUITEMINFOA);
WINUSERAPI BOOL WINAPI GetMenuItemInfoW(HMENU,UINT,BOOL,LPMENUITEMINFOW);
WINUSERAPI BOOL WINAPI GetMenuItemRect(HWND,HMENU,UINT,LPRECT);
WINUSERAPI UINT WINAPI GetMenuState(HMENU,UINT,UINT);
WINUSERAPI int WINAPI GetMenuStringA(HMENU,UINT,LPSTR,int,UINT);
WINUSERAPI int WINAPI GetMenuStringW(HMENU,UINT,LPWSTR,int,UINT);
WINUSERAPI BOOL WINAPI GetMessageA(LPMSG,HWND,UINT,UINT);
WINUSERAPI BOOL WINAPI GetMessageW(LPMSG,HWND,UINT,UINT);
WINUSERAPI LONG WINAPI GetMessageExtraInfo(void);
WINUSERAPI DWORD WINAPI GetMessagePos(void);
WINUSERAPI LONG WINAPI GetMessageTime(void);
WINUSERAPI int WINAPI GetMouseMovePointsEx(UINT,LPMOUSEMOVEPOINT,LPMOUSEMOVEPOINT,int,DWORD);
WINUSERAPI HWND WINAPI GetNextDlgGroupItem(HWND,HWND,BOOL);
WINUSERAPI HWND WINAPI GetNextDlgTabItem(HWND,HWND,BOOL);
WINUSERAPI HWND WINAPI GetOpenClipboardWindow(void);
WINUSERAPI HWND WINAPI GetParent(HWND);
WINUSERAPI int WINAPI GetPriorityClipboardFormat(UINT*,int);
WINUSERAPI HANDLE WINAPI GetPropA(HWND,LPCSTR);
WINUSERAPI HANDLE WINAPI GetPropW(HWND,LPCWSTR);
WINUSERAPI UINT WINAPI GetRawInputBuffer(PRAWINPUT,PUINT,UINT);
WINUSERAPI UINT WINAPI GetRawInputData(HRAWINPUT,UINT,LPVOID,PUINT,UINT);
WINUSERAPI UINT WINAPI GetRawInputDeviceInfoA(HANDLE,UINT,LPVOID,PUINT);
WINUSERAPI UINT WINAPI GetRawInputDeviceInfoW(HANDLE,UINT,LPVOID,PUINT);
WINUSERAPI UINT WINAPI GetRawInputDeviceList(PRAWINPUTDEVICELIST,PUINT,UINT);
WINUSERAPI UINT WINAPI GetRegisteredRawInputDevices(PRAWINPUTDEVICE,PUINT,UINT);
WINUSERAPI DWORD WINAPI GetQueueStatus(UINT);
WINUSERAPI BOOL WINAPI GetScrollInfo(HWND,int,LPSCROLLINFO);
WINUSERAPI int WINAPI GetScrollPos(HWND,int);
WINUSERAPI BOOL WINAPI GetScrollRange(HWND,int,LPINT,LPINT);
WINUSERAPI HWND WINAPI GetShellWindow(void);
WINUSERAPI HMENU WINAPI GetSubMenu(HMENU,int);
WINUSERAPI DWORD WINAPI GetSysColor(int);
WINUSERAPI HBRUSH WINAPI GetSysColorBrush(int);
WINUSERAPI HMENU WINAPI GetSystemMenu(HWND,BOOL);
WINUSERAPI int WINAPI GetSystemMetrics(int);
WINUSERAPI DWORD WINAPI GetTabbedTextExtentA(HDC,LPCSTR,int,int,LPINT);
WINUSERAPI DWORD WINAPI GetTabbedTextExtentW(HDC,LPCWSTR,int,int,LPINT);
WINUSERAPI LONG WINAPI GetWindowLongA(HWND,int);
WINUSERAPI LONG WINAPI GetWindowLongW(HWND,int);
WINUSERAPI HDESK WINAPI GetThreadDesktop(DWORD);
WINUSERAPI HWND WINAPI GetTopWindow(HWND);
WINUSERAPI BOOL WINAPI GetUpdateRect(HWND,LPRECT,BOOL);
WINUSERAPI int WINAPI GetUpdateRgn(HWND,HRGN,BOOL);
WINUSERAPI BOOL WINAPI GetUserObjectInformationA(HANDLE,int,PVOID,DWORD,PDWORD);
WINUSERAPI BOOL WINAPI GetUserObjectInformationW(HANDLE,int,PVOID,DWORD,PDWORD);
WINUSERAPI BOOL WINAPI GetUserObjectSecurity(HANDLE,PSECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
WINUSERAPI HWND WINAPI GetWindow(HWND,UINT);
WINUSERAPI DWORD WINAPI GetWindowContextHelpId(HWND);
WINUSERAPI HDC WINAPI GetWindowDC(HWND);
WINUSERAPI BOOL WINAPI GetWindowPlacement(HWND,WINDOWPLACEMENT*);
WINUSERAPI BOOL WINAPI GetWindowRect(HWND,LPRECT);
WINUSERAPI int WINAPI GetWindowRgn(HWND,HRGN);
WINUSERAPI int WINAPI GetWindowTextA(HWND,LPSTR,int);
WINUSERAPI int WINAPI GetWindowTextLengthA(HWND);
WINUSERAPI int WINAPI GetWindowTextLengthW(HWND);
WINUSERAPI int WINAPI GetWindowTextW(HWND,LPWSTR,int);
WINUSERAPI WORD WINAPI GetWindowWord(HWND,int);
WINUSERAPI BOOL WINAPI GetAltTabInfoA(HWND,int,PALTTABINFO,LPSTR,UINT);
WINUSERAPI BOOL WINAPI GetAltTabInfoW(HWND,int,PALTTABINFO,LPWSTR,UINT);
WINUSERAPI BOOL WINAPI GetComboBoxInfo(HWND,PCOMBOBOXINFO);
WINUSERAPI BOOL WINAPI GetCursorInfo(PCURSORINFO);
WINUSERAPI BOOL WINAPI GetGUIThreadInfo(DWORD,LPGUITHREADINFO);
WINUSERAPI BOOL WINAPI GetLastInputInfo(PLASTINPUTINFO);
WINUSERAPI DWORD WINAPI GetListBoxInfo(HWND);
WINUSERAPI BOOL WINAPI GetMenuBarInfo(HWND,LONG,LONG,PMENUBARINFO);
WINUSERAPI BOOL WINAPI GetMenuInfo(HMENU,LPMENUINFO);
WINUSERAPI BOOL WINAPI GetProcessDefaultLayout(DWORD*);
WINUSERAPI BOOL WINAPI GetScrollBarInfo(HWND,LONG,PSCROLLBARINFO);
WINUSERAPI BOOL WINAPI GetTitleBarInfo(HWND,PTITLEBARINFO);
WINUSERAPI BOOL WINAPI GetWindowInfo(HWND,PWINDOWINFO);
WINUSERAPI BOOL WINAPI GetMonitorInfoA(HMONITOR,LPMONITORINFO);
WINUSERAPI BOOL WINAPI GetMonitorInfoW(HMONITOR,LPMONITORINFO);
WINUSERAPI UINT WINAPI GetWindowModuleFileNameA(HWND,LPSTR,UINT);
WINUSERAPI UINT WINAPI GetWindowModuleFileNameW(HWND,LPWSTR,UINT);
WINUSERAPI BOOL WINAPI GrayStringA(HDC,HBRUSH,GRAYSTRINGPROC,LPARAM,int,int,int,int,int);
WINUSERAPI BOOL WINAPI GrayStringW(HDC,HBRUSH,GRAYSTRINGPROC,LPARAM,int,int,int,int,int);
WINUSERAPI BOOL WINAPI HideCaret(HWND);
WINUSERAPI BOOL WINAPI HiliteMenuItem(HWND,HMENU,UINT,UINT);
WINUSERAPI BOOL WINAPI InflateRect(LPRECT,int,int);
WINUSERAPI BOOL WINAPI InSendMessage(void);
WINUSERAPI DWORD WINAPI InSendMessageEx(LPVOID);
WINUSERAPI BOOL WINAPI InsertMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
WINUSERAPI BOOL WINAPI InsertMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
WINUSERAPI BOOL WINAPI InsertMenuItemA(HMENU,UINT,BOOL,LPCMENUITEMINFOA);
WINUSERAPI BOOL WINAPI InsertMenuItemW(HMENU,UINT,BOOL,LPCMENUITEMINFOW);
WINUSERAPI INT WINAPI InternalGetWindowText(HWND,LPWSTR,INT);
WINUSERAPI BOOL WINAPI IntersectRect(LPRECT,LPCRECT,LPCRECT);
WINUSERAPI BOOL WINAPI InvalidateRect(HWND,LPCRECT,BOOL);
WINUSERAPI BOOL WINAPI InvalidateRgn(HWND,HRGN,BOOL);
WINUSERAPI BOOL WINAPI InvertRect(HDC,LPCRECT);
WINUSERAPI BOOL WINAPI IsCharAlphaA(CHAR ch);
WINUSERAPI BOOL WINAPI IsCharAlphaNumericA(CHAR);
WINUSERAPI BOOL WINAPI IsCharAlphaNumericW(WCHAR);
WINUSERAPI BOOL WINAPI IsCharAlphaW(WCHAR);
WINUSERAPI BOOL WINAPI IsCharLowerA(CHAR);
WINUSERAPI BOOL WINAPI IsCharLowerW(WCHAR);
WINUSERAPI BOOL WINAPI IsCharUpperA(CHAR);
WINUSERAPI BOOL WINAPI IsCharUpperW(WCHAR);
WINUSERAPI BOOL WINAPI IsChild(HWND,HWND);
WINUSERAPI BOOL WINAPI IsClipboardFormatAvailable(UINT);
WINUSERAPI BOOL WINAPI IsDialogMessageA(HWND,LPMSG);
WINUSERAPI BOOL WINAPI IsDialogMessageW(HWND,LPMSG);
WINUSERAPI UINT WINAPI IsDlgButtonChecked(HWND,int);
WINUSERAPI BOOL WINAPI IsGUIThread(BOOL);
WINUSERAPI BOOL WINAPI IsHungAppWindow(HWND);
WINUSERAPI BOOL WINAPI IsIconic(HWND);
WINUSERAPI BOOL WINAPI IsMenu(HMENU);
WINUSERAPI BOOL WINAPI IsRectEmpty(LPCRECT);
WINUSERAPI BOOL WINAPI IsWindow(HWND);
WINUSERAPI BOOL WINAPI IsWindowEnabled(HWND);
WINUSERAPI BOOL WINAPI IsWindowUnicode(HWND);
WINUSERAPI BOOL WINAPI IsWindowVisible(HWND);
WINUSERAPI BOOL WINAPI IsWinEventHookInstalled(DWORD);
WINUSERAPI BOOL WINAPI IsZoomed(HWND);
WINUSERAPI VOID WINAPI keybd_event(BYTE,BYTE,DWORD,DWORD);
WINUSERAPI BOOL WINAPI KillTimer(HWND,UINT);
WINUSERAPI HACCEL WINAPI LoadAcceleratorsA(HINSTANCE,LPCSTR);
WINUSERAPI HACCEL WINAPI LoadAcceleratorsW(HINSTANCE,LPCWSTR);
WINUSERAPI HBITMAP WINAPI LoadBitmapA(HINSTANCE,LPCSTR);
WINUSERAPI HBITMAP WINAPI LoadBitmapW(HINSTANCE,LPCWSTR);
WINUSERAPI HCURSOR WINAPI LoadCursorA(HINSTANCE,LPCSTR);
WINUSERAPI HCURSOR WINAPI LoadCursorFromFileA(LPCSTR);
WINUSERAPI HCURSOR WINAPI LoadCursorFromFileW(LPCWSTR);
WINUSERAPI HCURSOR WINAPI LoadCursorW(HINSTANCE,LPCWSTR);
WINUSERAPI HICON WINAPI LoadIconA(HINSTANCE,LPCSTR);
WINUSERAPI HICON WINAPI LoadIconW(HINSTANCE,LPCWSTR);
WINUSERAPI HANDLE WINAPI LoadImageA(HINSTANCE,LPCSTR,UINT,int,int,UINT);
WINUSERAPI HANDLE WINAPI LoadImageW(HINSTANCE,LPCWSTR,UINT,int,int,UINT);
WINUSERAPI HKL WINAPI LoadKeyboardLayoutA(LPCSTR,UINT);
WINUSERAPI HKL WINAPI LoadKeyboardLayoutW(LPCWSTR,UINT);
WINUSERAPI HMENU WINAPI LoadMenuA(HINSTANCE,LPCSTR);
WINUSERAPI HMENU WINAPI LoadMenuIndirectA(const MENUTEMPLATE*);
WINUSERAPI HMENU WINAPI LoadMenuIndirectW(const MENUTEMPLATE*);
WINUSERAPI HMENU WINAPI LoadMenuW(HINSTANCE,LPCWSTR);
WINUSERAPI int WINAPI LoadStringA(HINSTANCE,UINT,LPSTR,int);
WINUSERAPI int WINAPI LoadStringW(HINSTANCE,UINT,LPWSTR,int);
WINUSERAPI BOOL WINAPI LockWindowUpdate(HWND);
WINUSERAPI BOOL WINAPI LockWorkStation(void);
WINUSERAPI int WINAPI LookupIconIdFromDirectory(PBYTE,BOOL);
WINUSERAPI int WINAPI LookupIconIdFromDirectoryEx(PBYTE,BOOL,int,int,UINT);
WINUSERAPI BOOL WINAPI MapDialogRect(HWND,LPRECT);
WINUSERAPI UINT WINAPI MapVirtualKeyA(UINT,UINT);
WINUSERAPI UINT WINAPI MapVirtualKeyExA(UINT,UINT,HKL);
WINUSERAPI UINT WINAPI MapVirtualKeyExW(UINT,UINT,HKL);
WINUSERAPI UINT WINAPI MapVirtualKeyW(UINT,UINT);
WINUSERAPI int WINAPI MapWindowPoints(HWND,HWND,LPPOINT,UINT);
WINUSERAPI int WINAPI MenuItemFromPoint(HWND,HMENU,POINT);
WINUSERAPI BOOL WINAPI MessageBeep(UINT);
WINUSERAPI int WINAPI MessageBoxA(HWND,LPCSTR,LPCSTR,UINT);
WINUSERAPI int WINAPI MessageBoxW(HWND,LPCWSTR,LPCWSTR,UINT);
WINUSERAPI int WINAPI MessageBoxExA(HWND,LPCSTR,LPCSTR,UINT,WORD);
WINUSERAPI int WINAPI MessageBoxExW(HWND,LPCWSTR,LPCWSTR,UINT,WORD);
WINUSERAPI int WINAPI MessageBoxIndirectA(CONST MSGBOXPARAMSA*);
WINUSERAPI int WINAPI MessageBoxIndirectW(CONST MSGBOXPARAMSW*);
WINUSERAPI BOOL WINAPI ModifyMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
WINUSERAPI BOOL WINAPI ModifyMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
WINUSERAPI HMONITOR WINAPI MonitorFromPoint(POINT,DWORD);
WINUSERAPI HMONITOR WINAPI MonitorFromRect(LPCRECT,DWORD);
WINUSERAPI HMONITOR WINAPI MonitorFromWindow(HWND,DWORD);
WINUSERAPI void WINAPI mouse_event(DWORD,DWORD,DWORD,DWORD,ULONG_PTR);
WINUSERAPI BOOL WINAPI MoveWindow(HWND,int,int,int,int,BOOL);
WINUSERAPI DWORD WINAPI MsgWaitForMultipleObjects(DWORD,CONST HANDLE*,BOOL,DWORD,DWORD);
WINUSERAPI DWORD WINAPI MsgWaitForMultipleObjectsEx(DWORD,CONST HANDLE*,DWORD,DWORD,DWORD);
WINUSERAPI void WINAPI NotifyWinEvent(DWORD,HWND,LONG,LONG);
WINUSERAPI DWORD WINAPI OemKeyScan(WORD);
WINUSERAPI BOOL WINAPI OemToCharA(LPCSTR,LPSTR);
WINUSERAPI BOOL WINAPI OemToCharBuffA(LPCSTR,LPSTR,DWORD);
WINUSERAPI BOOL WINAPI OemToCharBuffW(LPCSTR,LPWSTR,DWORD);
WINUSERAPI BOOL WINAPI OemToCharW(LPCSTR,LPWSTR);
WINUSERAPI BOOL WINAPI OffsetRect(LPRECT,int,int);
WINUSERAPI BOOL WINAPI OpenClipboard(HWND);
WINUSERAPI HDESK WINAPI OpenDesktopA(LPSTR,DWORD,BOOL,DWORD);
WINUSERAPI HDESK WINAPI OpenDesktopW(LPWSTR,DWORD,BOOL,DWORD);
WINUSERAPI BOOL WINAPI OpenIcon(HWND);
WINUSERAPI HDESK WINAPI OpenInputDesktop(DWORD,BOOL,DWORD);
WINUSERAPI HWINSTA WINAPI OpenWindowStationA(LPSTR,BOOL,DWORD);
WINUSERAPI HWINSTA WINAPI OpenWindowStationW(LPWSTR,BOOL,DWORD);
WINUSERAPI BOOL WINAPI PaintDesktop(HDC);
WINUSERAPI BOOL WINAPI PeekMessageA(LPMSG,HWND,UINT,UINT,UINT);
WINUSERAPI BOOL WINAPI PeekMessageW(LPMSG,HWND,UINT,UINT,UINT);
WINUSERAPI BOOL WINAPI PostMessageA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI PostMessageW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI void WINAPI PostQuitMessage(int);
WINUSERAPI BOOL WINAPI PostThreadMessageA(DWORD,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI PostThreadMessageW(DWORD,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI PrintWindow(HWND,HDC,UINT);
WINUSERAPI BOOL WINAPI PtInRect(LPCRECT,POINT);
WINUSERAPI HWND WINAPI RealChildWindowFromPoint(HWND,POINT);
WINUSERAPI UINT WINAPI RealGetWindowClassA(HWND,LPSTR,UINT);
WINUSERAPI UINT WINAPI RealGetWindowClassW(HWND,LPWSTR,UINT);
WINUSERAPI BOOL WINAPI RedrawWindow(HWND,LPCRECT,HRGN,UINT);
WINUSERAPI ATOM WINAPI RegisterClassA(CONST WNDCLASSA*);
WINUSERAPI ATOM WINAPI RegisterClassW(CONST WNDCLASSW*);
WINUSERAPI ATOM WINAPI RegisterClassExA(CONST WNDCLASSEXA*);
WINUSERAPI ATOM WINAPI RegisterClassExW(CONST WNDCLASSEXW*);
WINUSERAPI UINT WINAPI RegisterClipboardFormatA(LPCSTR);
WINUSERAPI UINT WINAPI RegisterClipboardFormatW(LPCWSTR);
WINUSERAPI HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE,LPVOID,DWORD);
WINUSERAPI HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE,LPVOID,DWORD);
WINUSERAPI HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(HANDLE,LPCGUID,DWORD);
WINUSERAPI BOOL WINAPI RegisterHotKey(HWND,int,UINT,UINT);
WINUSERAPI BOOL WINAPI RegisterRawInputDevices(PCRAWINPUTDEVICE,UINT,UINT);
WINUSERAPI UINT WINAPI RegisterWindowMessageA(LPCSTR);
WINUSERAPI UINT WINAPI RegisterWindowMessageW(LPCWSTR);
WINUSERAPI BOOL WINAPI ReleaseCapture(void);
WINUSERAPI int WINAPI ReleaseDC(HWND,HDC);
WINUSERAPI BOOL WINAPI RemoveMenu(HMENU,UINT,UINT);
WINUSERAPI HANDLE WINAPI RemovePropA(HWND,LPCSTR);
WINUSERAPI HANDLE WINAPI RemovePropW(HWND,LPCWSTR);
WINUSERAPI BOOL WINAPI ReplyMessage(LRESULT);
WINUSERAPI BOOL WINAPI ScreenToClient(HWND,LPPOINT);
WINUSERAPI BOOL WINAPI ScrollDC(HDC,int,int,LPCRECT,LPCRECT,HRGN,LPRECT);
WINUSERAPI BOOL WINAPI ScrollWindow(HWND,int,int,LPCRECT,LPCRECT);
WINUSERAPI int WINAPI ScrollWindowEx(HWND,int,int,LPCRECT,LPCRECT,HRGN,LPRECT,UINT);
WINUSERAPI LONG WINAPI SendDlgItemMessageA(HWND,int,UINT,WPARAM,LPARAM);
WINUSERAPI LONG WINAPI SendDlgItemMessageW(HWND,int,UINT,WPARAM,LPARAM);
WINUSERAPI UINT WINAPI SendInput(UINT,LPINPUT,int);
WINUSERAPI LRESULT WINAPI SendMessageA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI SendMessageCallbackA(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,DWORD);
WINUSERAPI BOOL WINAPI SendMessageCallbackW(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,DWORD);
WINUSERAPI LRESULT WINAPI SendMessageTimeoutA(HWND,UINT,WPARAM,LPARAM,UINT,UINT,PDWORD);
WINUSERAPI LRESULT WINAPI SendMessageTimeoutW(HWND,UINT,WPARAM,LPARAM,UINT,UINT,PDWORD);
WINUSERAPI LRESULT WINAPI SendMessageW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI SendNotifyMessageA(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI BOOL WINAPI SendNotifyMessageW(HWND,UINT,WPARAM,LPARAM);
WINUSERAPI HWND WINAPI SetActiveWindow(HWND);
WINUSERAPI HWND WINAPI SetCapture(HWND hWnd);
WINUSERAPI BOOL WINAPI SetCaretBlinkTime(UINT);
WINUSERAPI BOOL WINAPI SetCaretPos(int,int);
WINUSERAPI DWORD WINAPI SetClassLongA(HWND,int,LONG);
WINUSERAPI DWORD WINAPI SetClassLongW(HWND,int,LONG);
WINUSERAPI WORD WINAPI SetClassWord(HWND,int,WORD);
WINUSERAPI HANDLE WINAPI SetClipboardData(UINT,HANDLE);
WINUSERAPI HWND WINAPI SetClipboardViewer(HWND);
WINUSERAPI HCURSOR WINAPI SetCursor(HCURSOR);
WINUSERAPI BOOL WINAPI SetCursorPos(int,int);
WINUSERAPI VOID WINAPI SetDebugErrorLevel(DWORD);
WINUSERAPI BOOL WINAPI SetDlgItemInt(HWND,int,UINT,BOOL);
WINUSERAPI BOOL WINAPI SetDlgItemTextA(HWND,int,LPCSTR);
WINUSERAPI BOOL WINAPI SetDlgItemTextW(HWND,int,LPCWSTR);
WINUSERAPI BOOL WINAPI SetDoubleClickTime(UINT);
WINUSERAPI HWND WINAPI SetFocus(HWND);
WINUSERAPI BOOL WINAPI SetForegroundWindow(HWND);
WINUSERAPI BOOL WINAPI SetKeyboardState(PBYTE);
WINUSERAPI BOOL WINAPI SetMenu(HWND,HMENU);
WINUSERAPI BOOL WINAPI SetMenuContextHelpId(HMENU,DWORD);
WINUSERAPI BOOL WINAPI SetMenuDefaultItem(HMENU,UINT,UINT);
WINUSERAPI BOOL WINAPI SetMenuInfo(HMENU,LPCMENUINFO);
WINUSERAPI BOOL WINAPI SetMenuItemBitmaps(HMENU,UINT,UINT,HBITMAP,HBITMAP);
WINUSERAPI BOOL WINAPI SetMenuItemInfoA(HMENU,UINT,BOOL,LPCMENUITEMINFOA);
WINUSERAPI BOOL WINAPI SetMenuItemInfoW( HMENU,UINT,BOOL,LPCMENUITEMINFOW);
WINUSERAPI LPARAM WINAPI SetMessageExtraInfo(LPARAM);
WINUSERAPI BOOL WINAPI SetMessageQueue(int);
WINUSERAPI HWND WINAPI SetParent(HWND,HWND);
WINUSERAPI BOOL WINAPI SetProcessDefaultLayout(DWORD);
WINUSERAPI BOOL WINAPI SetProcessWindowStation(HWINSTA);
WINUSERAPI BOOL WINAPI SetPropA(HWND,LPCSTR,HANDLE);
WINUSERAPI BOOL WINAPI SetPropW(HWND,LPCWSTR,HANDLE);
WINUSERAPI BOOL WINAPI SetRect(LPRECT,int,int,int,int);
WINUSERAPI BOOL WINAPI SetRectEmpty(LPRECT);
WINUSERAPI int WINAPI SetScrollInfo(HWND,int,LPCSCROLLINFO,BOOL);
WINUSERAPI int WINAPI SetScrollPos(HWND,int,int,BOOL);
WINUSERAPI BOOL WINAPI SetScrollRange(HWND,int,int,int,BOOL);
WINUSERAPI BOOL WINAPI SetSysColors(int,const INT *,const COLORREF *);
WINUSERAPI BOOL WINAPI SetSystemCursor(HCURSOR,DWORD);
WINUSERAPI BOOL WINAPI SetThreadDesktop(HDESK);
WINUSERAPI UINT WINAPI SetTimer(HWND,UINT,UINT,TIMERPROC);
WINUSERAPI BOOL WINAPI SetUserObjectInformationA(HANDLE,int,PVOID,DWORD);
WINUSERAPI BOOL WINAPI SetUserObjectInformationW(HANDLE,int,PVOID,DWORD);
WINUSERAPI BOOL WINAPI SetUserObjectSecurity(HANDLE,PSECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINUSERAPI HWINEVENTHOOK WINAPI SetWinEventHook(UINT,UINT,HMODULE,WINEVENTPROC,DWORD,DWORD,UINT);
WINUSERAPI BOOL WINAPI SetWindowContextHelpId(HWND,DWORD);
WINUSERAPI LONG WINAPI SetWindowLongA(HWND,int,LONG);
WINUSERAPI LONG WINAPI SetWindowLongW(HWND,int,LONG);
WINUSERAPI BOOL WINAPI SetWindowPlacement(HWND hWnd,const WINDOWPLACEMENT*);
WINUSERAPI BOOL WINAPI SetWindowPos(HWND,HWND,int,int,int,int,UINT);
WINUSERAPI int WINAPI SetWindowRgn(HWND,HRGN,BOOL);
WINUSERAPI HHOOK WINAPI SetWindowsHookA(int,HOOKPROC);
WINUSERAPI HHOOK WINAPI SetWindowsHookW(int,HOOKPROC);
WINUSERAPI HHOOK WINAPI SetWindowsHookExA(int,HOOKPROC,HINSTANCE,DWORD);
WINUSERAPI HHOOK WINAPI SetWindowsHookExW(int,HOOKPROC,HINSTANCE,DWORD);
WINUSERAPI BOOL WINAPI SetWindowTextA(HWND,LPCSTR);
WINUSERAPI BOOL WINAPI SetWindowTextW(HWND,LPCWSTR);
WINUSERAPI WORD WINAPI SetWindowWord(HWND,int,WORD);
WINUSERAPI BOOL WINAPI ShowCaret(HWND);
WINUSERAPI int WINAPI ShowCursor(BOOL);
WINUSERAPI BOOL WINAPI ShowOwnedPopups(HWND,BOOL);
WINUSERAPI BOOL WINAPI ShowScrollBar(HWND,int,BOOL);
WINUSERAPI BOOL WINAPI ShowWindow(HWND,int);
WINUSERAPI BOOL WINAPI ShowWindowAsync(HWND,int);
WINUSERAPI BOOL WINAPI SubtractRect(LPRECT,LPCRECT,LPCRECT);
WINUSERAPI BOOL WINAPI SwapMouseButton(BOOL);
WINUSERAPI BOOL WINAPI SwitchDesktop(HDESK);
WINUSERAPI VOID WINAPI SwitchToThisWindow(HWND,BOOL);
WINUSERAPI BOOL WINAPI SystemParametersInfoA(UINT,UINT,PVOID,UINT);
WINUSERAPI BOOL WINAPI SystemParametersInfoW(UINT,UINT,PVOID,UINT);
WINUSERAPI LONG WINAPI TabbedTextOutA(HDC,int,int,LPCSTR,int,int,LPINT,int);
WINUSERAPI LONG WINAPI TabbedTextOutW(HDC,int,int,LPCWSTR,int,int,LPINT,int);
WINUSERAPI WORD WINAPI TileWindows(HWND,UINT,LPCRECT,UINT,const HWND *);
WINUSERAPI int WINAPI ToAscii(UINT,UINT,PBYTE,LPWORD,UINT);
WINUSERAPI int WINAPI ToAsciiEx(UINT,UINT,PBYTE,LPWORD,UINT,HKL);
WINUSERAPI int WINAPI ToUnicode(UINT,UINT,PBYTE,LPWSTR,int,UINT);
WINUSERAPI int WINAPI ToUnicodeEx(UINT,UINT,PBYTE,LPWSTR,int,UINT,HKL);
WINUSERAPI BOOL WINAPI TrackMouseEvent(LPTRACKMOUSEEVENT);
WINUSERAPI BOOL WINAPI TrackPopupMenu(HMENU,UINT,int,int,int,HWND,LPCRECT);
WINUSERAPI BOOL WINAPI TrackPopupMenuEx(HMENU,UINT,int,int,HWND,LPTPMPARAMS);
WINUSERAPI int WINAPI TranslateAcceleratorA(HWND,HACCEL,LPMSG);
WINUSERAPI int WINAPI TranslateAcceleratorW(HWND,HACCEL,LPMSG);
WINUSERAPI BOOL WINAPI TranslateMDISysAccel(HWND,LPMSG);
WINUSERAPI BOOL WINAPI TranslateMessage(const MSG*);
WINUSERAPI BOOL WINAPI UnhookWindowsHook(int,HOOKPROC);
WINUSERAPI BOOL WINAPI UnhookWindowsHookEx(HHOOK);
WINUSERAPI BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK);
WINUSERAPI BOOL WINAPI UnionRect(LPRECT,LPCRECT,LPCRECT);
WINUSERAPI BOOL WINAPI UnloadKeyboardLayout(HKL);
WINUSERAPI BOOL WINAPI UnregisterClassA(LPCSTR,HINSTANCE);
WINUSERAPI BOOL WINAPI UnregisterClassW(LPCWSTR,HINSTANCE);
WINUSERAPI BOOL WINAPI UnregisterDeviceNotification(HANDLE);
WINUSERAPI BOOL WINAPI UnregisterPowerSettingNotification(HPOWERNOTIFY);
WINUSERAPI BOOL WINAPI UnregisterHotKey(HWND,int);
WINUSERAPI BOOL WINAPI UpdateWindow(HWND);
WINUSERAPI BOOL WINAPI UserHandleGrantAccess(HANDLE,HANDLE,BOOL);
WINUSERAPI BOOL WINAPI ValidateRect(HWND,LPCRECT);
WINUSERAPI BOOL WINAPI ValidateRgn(HWND,HRGN);
WINUSERAPI SHORT WINAPI VkKeyScanA(CHAR);
WINUSERAPI SHORT WINAPI VkKeyScanExA(CHAR,HKL);
WINUSERAPI SHORT WINAPI VkKeyScanExW(WCHAR,HKL);
WINUSERAPI SHORT WINAPI VkKeyScanW(WCHAR);
WINUSERAPI DWORD WINAPI WaitForInputIdle(HANDLE,DWORD);
WINUSERAPI BOOL WINAPI WaitMessage(void);
WINUSERAPI HWND WINAPI WindowFromDC(HDC hDC);
WINUSERAPI HWND WINAPI WindowFromPoint(POINT);
WINUSERAPI UINT WINAPI WinExec(LPCSTR,UINT);
WINUSERAPI BOOL WINAPI WinHelpA(HWND,LPCSTR,UINT,DWORD);
WINUSERAPI BOOL WINAPI WinHelpW(HWND,LPCWSTR,UINT,DWORD);
WINUSERAPI int __cdecl wsprintfA(LPSTR,LPCSTR,...);
WINUSERAPI int __cdecl wsprintfW(LPWSTR,LPCWSTR,...);
WINUSERAPI int WINAPI wvsprintfA(LPSTR,LPCSTR,va_list arglist);
WINUSERAPI int WINAPI wvsprintfW(LPWSTR,LPCWSTR,va_list arglist);

WINUSERAPI BOOL WINAPI AllowSetForegroundWindow(DWORD);
WINUSERAPI BOOL WINAPI LockSetForegroundWindow(UINT);

DWORD WINAPI GetFileVersionInfoSizeA(LPCSTR,PDWORD);
DWORD WINAPI GetFileVersionInfoSizeW(LPCWSTR,PDWORD);
BOOL WINAPI GetFileVersionInfoA(LPCSTR,DWORD,DWORD,PVOID);
BOOL WINAPI GetFileVersionInfoW(LPCWSTR,DWORD,DWORD,PVOID);
DWORD WINAPI VerLanguageNameA(DWORD,LPSTR,DWORD);
DWORD WINAPI VerLanguageNameW(DWORD,LPWSTR,DWORD);
BOOL WINAPI VerQueryValueA(const LPVOID,LPSTR,LPVOID*,PUINT);
BOOL WINAPI VerQueryValueW(const LPVOID,LPWSTR,LPVOID*,PUINT);

LPWSTR * WINAPI CommandLineToArgvW(LPCWSTR,int*);
void WINAPI DragAcceptFiles(HWND,BOOL);
void WINAPI DragFinish(HDROP);
UINT WINAPI DragQueryFileA(HDROP,UINT,LPSTR,UINT);
UINT WINAPI DragQueryFileW(HDROP,UINT,LPWSTR,UINT);
BOOL WINAPI DragQueryPoint(HDROP,LPPOINT);
HICON WINAPI DuplicateIcon(HINSTANCE,HICON);
HICON WINAPI ExtractAssociatedIconA(HINSTANCE,LPCSTR,PWORD);
HICON WINAPI ExtractAssociatedIconW(HINSTANCE,LPCWSTR,PWORD);
HICON WINAPI ExtractIconA(HINSTANCE,LPCSTR,UINT);
HICON WINAPI ExtractIconW(HINSTANCE,LPCWSTR,UINT);
UINT WINAPI ExtractIconExA(LPCSTR,int,HICON*,HICON*,UINT);
UINT WINAPI ExtractIconExW(LPCWSTR,int,HICON*,HICON*,UINT);
HINSTANCE WINAPI FindExecutableA(LPCSTR,LPCSTR,LPSTR);
HINSTANCE WINAPI FindExecutableW(LPCWSTR,LPCWSTR,LPWSTR);
UINT WINAPI SHAppBarMessage(DWORD,PAPPBARDATA);
BOOL WINAPI Shell_NotifyIconA(DWORD,PNOTIFYICONDATAA);
BOOL WINAPI Shell_NotifyIconW(DWORD,PNOTIFYICONDATAW);
int WINAPI ShellAboutA(HWND,LPCSTR,LPCSTR,HICON);
int WINAPI ShellAboutW(HWND,LPCWSTR,LPCWSTR,HICON);
HINSTANCE WINAPI ShellExecuteA(HWND,LPCSTR,LPCSTR,LPCSTR,LPCSTR,INT);
HINSTANCE WINAPI ShellExecuteW(HWND,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,INT);
BOOL WINAPI ShellExecuteExA(LPSHELLEXECUTEINFOA);
BOOL WINAPI ShellExecuteExW(LPSHELLEXECUTEINFOW);
int WINAPI SHFileOperationA(LPSHFILEOPSTRUCTA);
int WINAPI SHFileOperationW(LPSHFILEOPSTRUCTW);
void WINAPI SHFreeNameMappings(HANDLE);
DWORD WINAPI SHGetFileInfoA(LPCSTR,DWORD,SHFILEINFOA*,UINT,UINT);
DWORD WINAPI SHGetFileInfoW(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT);
HRESULT WINAPI SHQueryRecycleBinA(LPCSTR, LPSHQUERYRBINFO);
HRESULT WINAPI SHQueryRecycleBinW(LPCWSTR, LPSHQUERYRBINFO);
HRESULT WINAPI SHEmptyRecycleBinA(HWND,LPCSTR,DWORD);
HRESULT WINAPI SHEmptyRecycleBinW(HWND,LPCWSTR,DWORD);

HRESULT WINAPI SHGetSpecialFolderLocation(HWND,int,LPITEMIDLIST*);
HRESULT WINAPI SHGetFolderPathA(HWND,int,HANDLE,DWORD,LPSTR);
HRESULT WINAPI SHGetFolderPathW(HWND,int,HANDLE,DWORD,LPWSTR);
BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST,LPSTR);
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST,LPWSTR);

WINBASEAPI LPSTR WINAPI lstrcatA(LPSTR,LPCSTR);
WINBASEAPI LPWSTR WINAPI lstrcatW(LPWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrcmpA(LPCSTR,LPCSTR);
WINBASEAPI int WINAPI lstrcmpiA(LPCSTR,LPCSTR);
WINBASEAPI int WINAPI lstrcmpiW( LPCWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrcmpW(LPCWSTR,LPCWSTR);
WINBASEAPI LPSTR WINAPI lstrcpyA(LPSTR,LPCSTR);
WINBASEAPI LPSTR WINAPI lstrcpynA(LPSTR,LPCSTR,int);
WINBASEAPI LPWSTR WINAPI lstrcpynW(LPWSTR,LPCWSTR,int);
WINBASEAPI LPWSTR WINAPI lstrcpyW(LPWSTR,LPCWSTR);
WINBASEAPI int WINAPI lstrlenA(LPCSTR);
WINBASEAPI int WINAPI lstrlenW(LPCWSTR);

// wingdi.h
WINGDIAPI int WINAPI AbortDoc(HDC);
WINGDIAPI BOOL WINAPI AbortPath(HDC);
WINGDIAPI int WINAPI AddFontResourceA(LPCSTR);
WINGDIAPI int WINAPI AddFontResourceW(LPCWSTR);
WINGDIAPI HANDLE WINAPI AddFontMemResourceEx(PVOID,DWORD,PVOID,DWORD *);
WINGDIAPI int WINAPI AddFontResourceExA(LPCSTR,DWORD,PVOID);
WINGDIAPI int WINAPI AddFontResourceExW(LPCWSTR,DWORD,PVOID);
WINGDIAPI BOOL WINAPI AngleArc(HDC,int,int,DWORD,FLOAT,FLOAT);
WINGDIAPI BOOL WINAPI AnimatePalette(HPALETTE,UINT,UINT,const PALETTEENTRY*);
WINGDIAPI BOOL WINAPI Arc(HDC,int,int,int,int,int,int,int,int);
WINGDIAPI BOOL WINAPI ArcTo(HDC,int,int,int,int,int,int,int,int);
WINGDIAPI BOOL WINAPI BeginPath(HDC);
WINGDIAPI BOOL WINAPI BitBlt(HDC,int,int,int,int,HDC,int,int,DWORD);
WINGDIAPI BOOL WINAPI CancelDC(HDC);
WINGDIAPI BOOL WINAPI CheckColorsInGamut(HDC,PVOID,PVOID,DWORD);
WINGDIAPI BOOL WINAPI Chord(HDC,int,int,int,int,int,int,int,int);
WINGDIAPI int WINAPI ChoosePixelFormat(HDC,CONST PIXELFORMATDESCRIPTOR*);
WINGDIAPI HENHMETAFILE WINAPI CloseEnhMetaFile(HDC);
WINGDIAPI BOOL WINAPI CloseFigure(HDC);
WINGDIAPI HMETAFILE WINAPI CloseMetaFile(HDC);
WINGDIAPI BOOL WINAPI ColorCorrectPalette(HDC,HPALETTE,DWORD,DWORD);
WINGDIAPI BOOL WINAPI ColorMatchToTarget(HDC,HDC,DWORD);
WINGDIAPI int WINAPI CombineRgn(HRGN,HRGN,HRGN,int);
WINGDIAPI BOOL WINAPI CombineTransform(LPXFORM,const XFORM*,const XFORM*);
WINGDIAPI HENHMETAFILE WINAPI CopyEnhMetaFileA(HENHMETAFILE,LPCSTR);
WINGDIAPI HENHMETAFILE WINAPI CopyEnhMetaFileW(HENHMETAFILE,LPCWSTR);
WINGDIAPI HMETAFILE WINAPI CopyMetaFileA(HMETAFILE,LPCSTR);
WINGDIAPI HMETAFILE WINAPI CopyMetaFileW(HMETAFILE,LPCWSTR);
WINGDIAPI HBITMAP WINAPI CreateBitmap(int,int,UINT,UINT,LPCVOID);
WINGDIAPI HBITMAP WINAPI CreateBitmapIndirect(const BITMAP*);
WINGDIAPI HBRUSH WINAPI CreateBrushIndirect(const LOGBRUSH*);
WINGDIAPI HCOLORSPACE WINAPI CreateColorSpaceA(LPLOGCOLORSPACEA);
WINGDIAPI HCOLORSPACE WINAPI CreateColorSpaceW(LPLOGCOLORSPACEW);
WINGDIAPI HBITMAP WINAPI CreateCompatibleBitmap(HDC,int,int);
WINGDIAPI HDC WINAPI CreateCompatibleDC(HDC);
WINGDIAPI HDC WINAPI CreateDCA(LPCSTR,LPCSTR,LPCSTR,const DEVMODEA*);
WINGDIAPI HDC WINAPI CreateDCW(LPCWSTR,LPCWSTR,LPCWSTR,const DEVMODEW*);
WINGDIAPI HBITMAP WINAPI CreateDIBitmap(HDC,const BITMAPINFOHEADER*,DWORD,LPCVOID,const BITMAPINFO*,UINT);
WINGDIAPI HBRUSH WINAPI CreateDIBPatternBrush(HGLOBAL,UINT);
WINGDIAPI HBRUSH WINAPI CreateDIBPatternBrushPt(LPCVOID,UINT);
WINGDIAPI HBITMAP WINAPI CreateDIBSection(HDC,const BITMAPINFO*,UINT,void**,HANDLE,DWORD);
WINGDIAPI HBITMAP WINAPI CreateDiscardableBitmap(HDC,int,int);
WINGDIAPI HRGN WINAPI CreateEllipticRgn(int,int,int,int);
WINGDIAPI HRGN WINAPI CreateEllipticRgnIndirect(LPCRECT);
WINGDIAPI HDC WINAPI CreateEnhMetaFileA(HDC,LPCSTR,LPCRECT,LPCSTR);
WINGDIAPI HDC WINAPI CreateEnhMetaFileW(HDC,LPCWSTR,LPCRECT,LPCWSTR);
WINGDIAPI HFONT WINAPI CreateFontA(int,int,int,int,int,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPCSTR);
WINGDIAPI HFONT WINAPI CreateFontW(int,int,int,int,int,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPCWSTR);
WINGDIAPI HFONT WINAPI CreateFontIndirectA(const LOGFONTA*);
WINGDIAPI HFONT WINAPI CreateFontIndirectW(const LOGFONTW*);
WINGDIAPI HPALETTE WINAPI CreateHalftonePalette(HDC);
WINGDIAPI HBRUSH WINAPI CreateHatchBrush(int,COLORREF);
WINGDIAPI HDC WINAPI CreateICA(LPCSTR,LPCSTR,LPCSTR,const DEVMODEA*);
WINGDIAPI HDC WINAPI CreateICW(LPCWSTR,LPCWSTR,LPCWSTR,const DEVMODEW*);
WINGDIAPI HDC WINAPI CreateMetaFileA(LPCSTR);
WINGDIAPI HDC WINAPI CreateMetaFileW(LPCWSTR);
WINGDIAPI HPALETTE WINAPI CreatePalette(const LOGPALETTE*);
WINGDIAPI HBRUSH WINAPI CreatePatternBrush(HBITMAP);
WINGDIAPI HPEN WINAPI CreatePen(int,int,COLORREF);
WINGDIAPI HPEN WINAPI CreatePenIndirect(const LOGPEN*);
WINGDIAPI HRGN WINAPI CreatePolygonRgn(const POINT*,int,int);
WINGDIAPI HRGN WINAPI CreatePolyPolygonRgn(const POINT*,const INT*,int,int);
WINGDIAPI HRGN WINAPI CreateRectRgn(int,int,int,int);
WINGDIAPI HRGN WINAPI CreateRectRgnIndirect(LPCRECT);
WINGDIAPI HRGN WINAPI CreateRoundRectRgn(int,int,int,int,int,int);
WINGDIAPI BOOL WINAPI CreateScalableFontResourceA(DWORD,LPCSTR,LPCSTR,LPCSTR);
WINGDIAPI BOOL WINAPI CreateScalableFontResourceW(DWORD,LPCWSTR,LPCWSTR,LPCWSTR);
WINGDIAPI HBRUSH WINAPI CreateSolidBrush(COLORREF);
WINGDIAPI BOOL WINAPI DeleteColorSpace(HCOLORSPACE);
WINGDIAPI BOOL WINAPI DeleteDC(HDC);
WINGDIAPI BOOL WINAPI DeleteEnhMetaFile(HENHMETAFILE);
WINGDIAPI BOOL WINAPI DeleteMetaFile(HMETAFILE);
WINGDIAPI BOOL WINAPI DeleteObject(HGDIOBJ);
WINGDIAPI int WINAPI DescribePixelFormat(HDC,int,UINT,LPPIXELFORMATDESCRIPTOR);
WINGDIAPI DWORD WINAPI DeviceCapabilitiesA(LPCSTR,LPCSTR,WORD,LPSTR,const DEVMODEA*);
WINGDIAPI DWORD WINAPI DeviceCapabilitiesW(LPCWSTR,LPCWSTR,WORD,LPWSTR,const DEVMODEW*);
WINGDIAPI BOOL WINAPI DPtoLP(HDC,LPPOINT,int);
WINGDIAPI int WINAPI DrawEscape(HDC,int,int,LPCSTR);
WINGDIAPI BOOL WINAPI Ellipse(HDC,int,int,int,int);
WINGDIAPI int WINAPI EndDoc(HDC);
WINGDIAPI int WINAPI EndPage(HDC);
WINGDIAPI BOOL WINAPI EndPath(HDC);
WINGDIAPI BOOL WINAPI EnumEnhMetaFile(HDC,HENHMETAFILE,ENHMFENUMPROC,PVOID,LPCRECT);
WINGDIAPI int WINAPI EnumFontFamiliesA(HDC,LPCSTR,FONTENUMPROCA,LPARAM);
WINGDIAPI int WINAPI EnumFontFamiliesW(HDC,LPCWSTR,FONTENUMPROCW,LPARAM);
WINGDIAPI int WINAPI EnumFontFamiliesExA(HDC,PLOGFONTA,FONTENUMPROCA,LPARAM,DWORD);
WINGDIAPI int WINAPI EnumFontFamiliesExW(HDC,PLOGFONTW,FONTENUMPROCW,LPARAM,DWORD);
WINGDIAPI int WINAPI EnumFontsA(HDC,LPCSTR,FONTENUMPROCA,LPARAM);
WINGDIAPI int WINAPI EnumFontsW(HDC,LPCWSTR,FONTENUMPROCW,LPARAM);
WINGDIAPI int WINAPI EnumICMProfilesA(HDC,ICMENUMPROCA,LPARAM);
WINGDIAPI int WINAPI EnumICMProfilesW(HDC,ICMENUMPROCW,LPARAM);
WINGDIAPI BOOL WINAPI EnumMetaFile(HDC,HMETAFILE,MFENUMPROC,LPARAM);
WINGDIAPI int WINAPI EnumObjects(HDC,int,GOBJENUMPROC,LPARAM);
WINGDIAPI BOOL WINAPI EqualRgn(HRGN,HRGN);
WINGDIAPI int WINAPI Escape(HDC,int,int,LPCSTR,PVOID);
WINGDIAPI int WINAPI ExcludeClipRect(HDC,int,int,int,int);
WINGDIAPI int WINAPI ExcludeUpdateRgn(HDC,HWND);
WINGDIAPI HPEN WINAPI ExtCreatePen(DWORD,DWORD,const LOGBRUSH*,DWORD,const DWORD*);
WINGDIAPI HRGN WINAPI ExtCreateRegion(const XFORM*,DWORD,const RGNDATA*);
WINGDIAPI int WINAPI ExtEscape(HDC,int,int,LPCSTR,int,LPSTR);
WINGDIAPI BOOL WINAPI ExtFloodFill(HDC,int,int,COLORREF,UINT);
WINGDIAPI int WINAPI ExtSelectClipRgn(HDC,HRGN,int);
WINGDIAPI BOOL WINAPI ExtTextOutW(HDC,int,int,UINT,LPCRECT,LPCWSTR,UINT,const INT*);

WINGDIAPI BOOL WINAPI ExtTextOutA(HDC,int,int,UINT,LPCRECT,LPCSTR,UINT,const INT*);
WINGDIAPI BOOL WINAPI FillPath(HDC);
WINGDIAPI int WINAPI FillRect(HDC,LPCRECT,HBRUSH);
WINGDIAPI int WINAPI FillRgn(HDC,HRGN,HBRUSH);
WINGDIAPI BOOL WINAPI FixBrushOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI BOOL WINAPI FlattenPath(HDC);
WINGDIAPI BOOL WINAPI FloodFill(HDC,int,int,COLORREF);

WINGDIAPI UINT WINAPI SetTextAlign(HDC,UINT);
WINGDIAPI BOOL WINAPI GetTextMetricsA(HDC,LPTEXTMETRICA);
WINGDIAPI BOOL WINAPI GetTextMetricsW(HDC,LPTEXTMETRICW);
WINGDIAPI BOOL WINAPI GetViewportExtEx(HDC,LPSIZE);
WINGDIAPI BOOL WINAPI GetViewportOrgEx(HDC,LPPOINT);
WINGDIAPI BOOL WINAPI GetWindowExtEx(HDC,LPSIZE);
WINGDIAPI BOOL WINAPI GetWindowOrgEx(HDC,LPPOINT);
WINGDIAPI UINT WINAPI GetWinMetaFileBits(HENHMETAFILE,UINT,LPBYTE,INT,HDC);
WINGDIAPI BOOL WINAPI GetWorldTransform(HDC,LPXFORM);
WINGDIAPI BOOL WINAPI GdiComment(HDC,UINT,const BYTE*);
WINGDIAPI BOOL WINAPI GdiFlush(void);
WINGDIAPI DWORD WINAPI GdiGetBatchLimit(void);
WINGDIAPI DWORD WINAPI GdiSetBatchLimit(DWORD);
WINGDIAPI int WINAPI GetArcDirection(HDC);
WINGDIAPI BOOL WINAPI GetAspectRatioFilterEx(HDC,LPSIZE);
WINGDIAPI LONG WINAPI GetBitmapBits(HBITMAP,LONG,PVOID);
WINGDIAPI BOOL WINAPI GetBitmapDimensionEx(HBITMAP,LPSIZE);
WINGDIAPI COLORREF WINAPI GetBkColor(HDC);
WINGDIAPI int WINAPI GetBkMode(HDC);
WINGDIAPI UINT WINAPI GetBoundsRect(HDC,LPRECT,UINT);
WINGDIAPI BOOL WINAPI GetBrushOrgEx(HDC,LPPOINT);
WINGDIAPI BOOL WINAPI GetCharABCWidthsA(HDC,UINT,UINT,LPABC);
WINGDIAPI BOOL WINAPI GetCharABCWidthsW(HDC,UINT,UINT,LPABC);
WINGDIAPI BOOL WINAPI GetCharABCWidthsFloatA(HDC,UINT,UINT,LPABCFLOAT);
WINGDIAPI BOOL WINAPI GetCharABCWidthsFloatW(HDC,UINT,UINT,LPABCFLOAT);
WINGDIAPI DWORD WINAPI GetCharacterPlacementA(HDC,LPCSTR,int,int,LPGCP_RESULTSA,DWORD);
WINGDIAPI DWORD WINAPI GetCharacterPlacementW(HDC,LPCWSTR,int,int,LPGCP_RESULTSW,DWORD);
WINGDIAPI BOOL WINAPI GetCharWidth32A(HDC,UINT,UINT,LPINT);
WINGDIAPI BOOL WINAPI GetCharWidth32W(HDC,UINT,UINT,LPINT);
WINGDIAPI BOOL WINAPI GetCharWidthA(HDC,UINT,UINT,LPINT);
WINGDIAPI BOOL WINAPI GetCharWidthW(HDC,UINT,UINT,LPINT);
WINGDIAPI BOOL WINAPI GetCharWidthFloatA(HDC,UINT,UINT,PFLOAT);
WINGDIAPI BOOL WINAPI GetCharWidthFloatW(HDC,UINT,UINT,PFLOAT);
WINGDIAPI int WINAPI GetClipBox(HDC,LPRECT);
WINGDIAPI int WINAPI GetClipRgn(HDC,HRGN);
WINGDIAPI BOOL WINAPI GetColorAdjustment(HDC,LPCOLORADJUSTMENT);
WINGDIAPI HANDLE WINAPI GetColorSpace(HDC);
WINGDIAPI HGDIOBJ WINAPI GetCurrentObject(HDC,UINT);
WINGDIAPI BOOL WINAPI GetCurrentPositionEx(HDC,LPPOINT);
WINGDIAPI HCURSOR WINAPI GetCursor(void);
WINGDIAPI COLORREF WINAPI GetDCBrushColor(HDC);
WINGDIAPI COLORREF WINAPI GetDCPenColor(HDC);
WINGDIAPI BOOL WINAPI GetDCOrgEx(HDC,LPPOINT);
WINGDIAPI int WINAPI GetDeviceCaps(HDC,int);
WINGDIAPI BOOL WINAPI GetDeviceGammaRamp(HDC,PVOID);
WINGDIAPI UINT WINAPI GetDIBColorTable(HDC,UINT,UINT,RGBQUAD*);
WINGDIAPI int WINAPI GetDIBits(HDC,HBITMAP,UINT,UINT,PVOID,LPBITMAPINFO,UINT);
WINGDIAPI HENHMETAFILE WINAPI GetEnhMetaFileA(LPCSTR);
WINGDIAPI HENHMETAFILE WINAPI GetEnhMetaFileW(LPCWSTR);
WINGDIAPI UINT WINAPI GetEnhMetaFileBits(HENHMETAFILE,UINT,LPBYTE);
WINGDIAPI UINT WINAPI GetEnhMetaFileDescriptionA(HENHMETAFILE,UINT,LPSTR);
WINGDIAPI UINT WINAPI GetEnhMetaFileDescriptionW(HENHMETAFILE,UINT,LPWSTR);
WINGDIAPI UINT WINAPI GetEnhMetaFileHeader(HENHMETAFILE,UINT,LPENHMETAHEADER);
WINGDIAPI UINT WINAPI GetEnhMetaFilePaletteEntries(HENHMETAFILE,UINT,LPPALETTEENTRY);
WINGDIAPI UINT WINAPI GetEnhMetaFilePixelFormat(HENHMETAFILE,DWORD,CONST PIXELFORMATDESCRIPTOR*);
WINGDIAPI DWORD WINAPI GetFontData(HDC,DWORD,DWORD,PVOID,DWORD);
WINGDIAPI DWORD WINAPI GetFontLanguageInfo(HDC);
WINGDIAPI DWORD WINAPI GetGlyphOutlineA(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,PVOID,const MAT2*);
WINGDIAPI DWORD WINAPI GetGlyphOutlineW(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,PVOID,const MAT2*);
WINGDIAPI int WINAPI GetGraphicsMode(HDC);
WINGDIAPI BOOL WINAPI GetICMProfileA(HDC,LPDWORD,LPSTR);
WINGDIAPI BOOL WINAPI GetICMProfileW(HDC,LPDWORD,LPWSTR);
WINGDIAPI DWORD WINAPI GetKerningPairsA(HDC,DWORD,LPKERNINGPAIR);
WINGDIAPI DWORD WINAPI GetKerningPairsW(HDC,DWORD,LPKERNINGPAIR);
WINGDIAPI BOOL WINAPI GetLogColorSpaceA(HCOLORSPACE,LPLOGCOLORSPACEA,DWORD);
WINGDIAPI BOOL WINAPI GetLogColorSpaceW(HCOLORSPACE,LPLOGCOLORSPACEW,DWORD);
WINGDIAPI int WINAPI GetMapMode(HDC);
WINGDIAPI HMETAFILE WINAPI GetMetaFileA(LPCSTR);
WINGDIAPI HMETAFILE WINAPI GetMetaFileW(LPCWSTR);
WINGDIAPI UINT WINAPI GetMetaFileBitsEx(HMETAFILE,UINT,PVOID);
WINGDIAPI int WINAPI GetMetaRgn(HDC,HRGN);
WINGDIAPI BOOL WINAPI GetMiterLimit(HDC,PFLOAT);
WINGDIAPI COLORREF WINAPI GetNearestColor(HDC,COLORREF);
WINGDIAPI UINT WINAPI GetNearestPaletteIndex(HPALETTE,COLORREF);
WINGDIAPI int WINAPI GetObjectA(HGDIOBJ,int,PVOID);
WINGDIAPI int WINAPI GetObjectW(HGDIOBJ,int,PVOID);
WINGDIAPI DWORD WINAPI GetObjectType(HGDIOBJ);
WINGDIAPI UINT WINAPI GetOutlineTextMetricsA(HDC,UINT,LPOUTLINETEXTMETRICA);
WINGDIAPI UINT WINAPI GetOutlineTextMetricsW(HDC,UINT,LPOUTLINETEXTMETRICW);
WINGDIAPI UINT WINAPI GetPaletteEntries(HPALETTE,UINT,UINT,LPPALETTEENTRY);
WINGDIAPI int WINAPI GetPath(HDC,LPPOINT,PBYTE,int);
WINGDIAPI COLORREF WINAPI GetPixel(HDC,int,int);
WINGDIAPI int WINAPI GetPixelFormat(HDC);
WINGDIAPI int WINAPI GetPolyFillMode(HDC);
WINGDIAPI BOOL WINAPI GetRasterizerCaps(LPRASTERIZER_STATUS,UINT);
WINGDIAPI int WINAPI GetRandomRgn (HDC,HRGN,INT);
WINGDIAPI DWORD WINAPI GetRegionData(HRGN,DWORD,LPRGNDATA);
WINGDIAPI int WINAPI GetRgnBox(HRGN,LPRECT);
WINGDIAPI int WINAPI GetROP2(HDC);
WINGDIAPI HGDIOBJ WINAPI GetStockObject(int);
WINGDIAPI int WINAPI GetStretchBltMode(HDC);
WINGDIAPI UINT WINAPI GetSystemPaletteEntries(HDC,UINT,UINT,LPPALETTEENTRY);
WINGDIAPI UINT WINAPI GetSystemPaletteUse(HDC);
WINGDIAPI UINT WINAPI GetTextAlign(HDC);
WINGDIAPI int WINAPI GetTextCharacterExtra(HDC);
WINGDIAPI int WINAPI GetTextCharset(HDC);
WINGDIAPI int WINAPI GetTextCharsetInfo(HDC,LPFONTSIGNATURE,DWORD);
WINGDIAPI COLORREF WINAPI GetTextColor(HDC);
WINGDIAPI BOOL WINAPI GetTextExtentExPointA(HDC,LPCSTR,int,int,LPINT,LPINT,LPSIZE);
WINGDIAPI BOOL WINAPI GetTextExtentExPointW( HDC,LPCWSTR,int,int,LPINT,LPINT,LPSIZE );
WINGDIAPI BOOL WINAPI GetTextExtentPointA(HDC,LPCSTR,int,LPSIZE);
WINGDIAPI BOOL WINAPI GetTextExtentPointW(HDC,LPCWSTR,int,LPSIZE);
WINGDIAPI BOOL WINAPI GetTextExtentExPointI(HDC, LPWORD, int, int, LPINT, LPINT, LPSIZE);
WINGDIAPI BOOL WINAPI GetTextExtentPoint32A(HDC,LPCSTR,int,LPSIZE);
WINGDIAPI BOOL WINAPI GetTextExtentPoint32W( HDC,LPCWSTR,int,LPSIZE);
WINGDIAPI int WINAPI GetTextFaceA(HDC,int,LPSTR);
WINGDIAPI int WINAPI GetTextFaceW(HDC,int,LPWSTR);
WINGDIAPI int WINAPI IntersectClipRect(HDC,int,int,int,int);
WINGDIAPI BOOL WINAPI InvertRgn(HDC,HRGN);
WINGDIAPI BOOL WINAPI LineDDA(int,int,int,int,LINEDDAPROC,LPARAM);
WINGDIAPI BOOL WINAPI LineTo(HDC,int,int);
WINGDIAPI BOOL WINAPI LPtoDP(HDC,LPPOINT,int);
WINGDIAPI BOOL WINAPI MaskBlt(HDC,int,int,int,int,HDC,int,int,HBITMAP,int,int,DWORD);
WINGDIAPI BOOL WINAPI ModifyWorldTransform(HDC,const XFORM*,DWORD);
WINGDIAPI BOOL WINAPI MoveToEx(HDC,int,int,LPPOINT);
WINGDIAPI int WINAPI OffsetClipRgn(HDC,int,int);
WINGDIAPI int WINAPI OffsetRgn(HRGN,int,int);
WINGDIAPI BOOL WINAPI OffsetViewportOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI BOOL WINAPI OffsetWindowOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI BOOL WINAPI PaintRgn(HDC,HRGN);
WINGDIAPI BOOL WINAPI PatBlt(HDC,int,int,int,int,DWORD);
WINGDIAPI HRGN WINAPI PathToRegion(HDC);
WINGDIAPI BOOL WINAPI Pie(HDC,int,int,int,int,int,int,int,int);
WINGDIAPI BOOL WINAPI PlayEnhMetaFile(HDC,HENHMETAFILE,LPCRECT);
WINGDIAPI BOOL WINAPI PlayEnhMetaFileRecord(HDC,LPHANDLETABLE,const ENHMETARECORD*,UINT);
WINGDIAPI BOOL WINAPI PlayMetaFile(HDC,HMETAFILE);
WINGDIAPI BOOL WINAPI PlayMetaFileRecord(HDC,LPHANDLETABLE,LPMETARECORD,UINT);
WINGDIAPI BOOL WINAPI PlgBlt(HDC,const POINT*,HDC,int,int,int,int,HBITMAP,int,int);
WINGDIAPI BOOL WINAPI PolyBezier(HDC,const POINT*,DWORD);
WINGDIAPI BOOL WINAPI PolyBezierTo(HDC,const POINT*,DWORD);
WINGDIAPI BOOL WINAPI PolyDraw(HDC,const POINT*,const BYTE*,int);
WINGDIAPI BOOL WINAPI Polygon(HDC,const POINT*,int);
WINGDIAPI BOOL WINAPI Polyline(HDC,const POINT*,int);
WINGDIAPI BOOL WINAPI PolylineTo(HDC,const POINT*,DWORD);
WINGDIAPI BOOL WINAPI PolyPolygon(HDC,const POINT*,const INT*,int);
WINGDIAPI BOOL WINAPI PolyPolyline(HDC,const POINT*,const DWORD*,DWORD);
WINGDIAPI BOOL WINAPI PolyTextOutA(HDC,const POLYTEXTA*,int);
WINGDIAPI BOOL WINAPI PolyTextOutW(HDC,const POLYTEXTW*,int);
WINGDIAPI BOOL WINAPI PtInRegion(HRGN,int,int);
WINGDIAPI BOOL WINAPI PtVisible(HDC,int,int);
WINGDIAPI UINT WINAPI RealizePalette(HDC);
WINGDIAPI BOOL WINAPI Rectangle(HDC,int,int,int,int);
WINGDIAPI BOOL WINAPI RectInRegion(HRGN,LPCRECT);
WINGDIAPI BOOL WINAPI RectVisible(HDC,LPCRECT);
WINGDIAPI BOOL WINAPI RemoveFontResourceA(LPCSTR);
WINGDIAPI BOOL WINAPI RemoveFontResourceW(LPCWSTR);
WINGDIAPI BOOL WINAPI RemoveFontMemResourceEx(HANDLE);
WINGDIAPI BOOL WINAPI RemoveFontResourceExA(LPCSTR,DWORD,PVOID);
WINGDIAPI BOOL WINAPI RemoveFontResourceExW(LPCWSTR,DWORD,PVOID);
WINGDIAPI HDC WINAPI ResetDCA(HDC,const DEVMODEA*);
WINGDIAPI HDC WINAPI ResetDCW(HDC,const DEVMODEW*);
WINGDIAPI BOOL WINAPI ResizePalette(HPALETTE,UINT);
WINGDIAPI BOOL WINAPI RestoreDC(HDC,int);
WINGDIAPI BOOL WINAPI RoundRect(HDC,int,int,int,int,int,int);
WINGDIAPI int WINAPI SaveDC(HDC);
WINGDIAPI BOOL WINAPI ScaleViewportExtEx(HDC,int,int,int,int,LPSIZE);
WINGDIAPI BOOL WINAPI ScaleWindowExtEx(HDC,int,int,int,int,LPSIZE);
WINGDIAPI BOOL WINAPI SelectClipPath(HDC,int);
WINGDIAPI int WINAPI SelectClipRgn(HDC,HRGN);
WINGDIAPI HGDIOBJ WINAPI SelectObject(HDC,HGDIOBJ);
WINGDIAPI HPALETTE WINAPI SelectPalette(HDC,HPALETTE,BOOL);
WINGDIAPI int WINAPI SetAbortProc(HDC,ABORTPROC);
WINGDIAPI int WINAPI SetArcDirection(HDC,int);
WINGDIAPI LONG WINAPI SetBitmapBits(HBITMAP,DWORD,LPCVOID);
WINGDIAPI BOOL WINAPI SetBitmapDimensionEx(HBITMAP,int,int,LPSIZE);
WINGDIAPI COLORREF WINAPI SetBkColor(HDC,COLORREF);
WINGDIAPI int WINAPI SetBkMode(HDC,int);
WINGDIAPI UINT WINAPI SetBoundsRect(HDC,LPCRECT,UINT);
WINGDIAPI BOOL WINAPI SetBrushOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI BOOL WINAPI SetColorAdjustment(HDC,const COLORADJUSTMENT*);
WINGDIAPI BOOL WINAPI SetColorSpace(HDC,HCOLORSPACE);
WINGDIAPI COLORREF WINAPI SetDCBrushColor(HDC,COLORREF);
WINGDIAPI COLORREF WINAPI SetDCPenColor(HDC,COLORREF);
WINGDIAPI BOOL WINAPI SetDeviceGammaRamp(HDC,PVOID);
WINGDIAPI UINT WINAPI SetDIBColorTable(HDC,UINT,UINT,const RGBQUAD*);
WINGDIAPI int WINAPI SetDIBits(HDC,HBITMAP,UINT,UINT,LPCVOID,const BITMAPINFO*,UINT);
WINGDIAPI int WINAPI SetDIBitsToDevice(HDC,int,int,DWORD,DWORD,int,int,UINT,UINT,LPCVOID,const BITMAPINFO*,UINT);
WINGDIAPI HENHMETAFILE WINAPI SetEnhMetaFileBits(UINT,const BYTE*);
WINGDIAPI int WINAPI SetGraphicsMode(HDC,int);
WINGDIAPI int WINAPI SetICMMode(HDC,int);
WINGDIAPI BOOL WINAPI SetICMProfileA(HDC,LPSTR);
WINGDIAPI BOOL WINAPI SetICMProfileW(HDC,LPWSTR);
WINGDIAPI int WINAPI SetMapMode(HDC,int);
WINGDIAPI DWORD WINAPI SetMapperFlags(HDC,DWORD);
WINGDIAPI HMETAFILE WINAPI SetMetaFileBitsEx(UINT,const BYTE *);
WINGDIAPI int WINAPI SetMetaRgn(HDC);
WINGDIAPI BOOL WINAPI SetMiterLimit(HDC,FLOAT,PFLOAT);
WINGDIAPI UINT WINAPI SetPaletteEntries(HPALETTE,UINT,UINT,const PALETTEENTRY*);
WINGDIAPI COLORREF WINAPI SetPixel(HDC,int,int,COLORREF);
WINGDIAPI BOOL WINAPI SetPixelFormat(HDC,int,const PIXELFORMATDESCRIPTOR*);
WINGDIAPI BOOL WINAPI SetPixelV(HDC,int,int,COLORREF);
WINGDIAPI int WINAPI SetPolyFillMode(HDC,int);
WINGDIAPI BOOL WINAPI SetRectRgn(HRGN,int,int,int,int);
WINGDIAPI int WINAPI SetROP2(HDC,int);
WINGDIAPI int WINAPI SetStretchBltMode(HDC,int);
WINGDIAPI UINT WINAPI SetSystemPaletteUse(HDC,UINT);
WINGDIAPI UINT WINAPI SetTextAlign(HDC,UINT);
WINGDIAPI int WINAPI SetTextCharacterExtra(HDC,int);
WINGDIAPI COLORREF WINAPI SetTextColor(HDC,COLORREF);
WINGDIAPI BOOL WINAPI SetTextJustification(HDC,int,int);
WINGDIAPI BOOL WINAPI SetViewportExtEx(HDC,int,int,LPSIZE);
WINGDIAPI BOOL WINAPI SetViewportOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI BOOL WINAPI SetWindowExtEx(HDC,int,int,LPSIZE);
WINGDIAPI BOOL WINAPI SetWindowOrgEx(HDC,int,int,LPPOINT);
WINGDIAPI HENHMETAFILE WINAPI SetWinMetaFileBits(UINT,const BYTE*,HDC,const METAFILEPICT*);
WINGDIAPI BOOL WINAPI SetWorldTransform(HDC,const XFORM *);
WINGDIAPI int WINAPI StartDocA(HDC,const DOCINFOA*);
WINGDIAPI int WINAPI StartDocW(HDC,const DOCINFOW*);
WINGDIAPI int WINAPI StartPage(HDC);
WINGDIAPI BOOL WINAPI StretchBlt(HDC,int,int,int,int,HDC,int,int,int,int,DWORD);
WINGDIAPI int WINAPI StretchDIBits(HDC,int,int,int,int,int,int,int,int,const VOID *,const BITMAPINFO *,UINT,DWORD);
WINGDIAPI BOOL WINAPI StrokeAndFillPath(HDC);
WINGDIAPI BOOL WINAPI StrokePath(HDC);
WINGDIAPI BOOL WINAPI SwapBuffers(HDC);
WINGDIAPI BOOL WINAPI TextOutA(HDC,int,int,LPCSTR,int);
WINGDIAPI BOOL WINAPI TextOutW(HDC,int,int,LPCWSTR,int);
WINGDIAPI BOOL WINAPI TranslateCharsetInfo(PDWORD,LPCHARSETINFO,DWORD);
WINGDIAPI BOOL WINAPI UnrealizeObject(HGDIOBJ);
WINGDIAPI BOOL WINAPI UpdateColors(HDC);
WINGDIAPI BOOL WINAPI UpdateICMRegKeyA(DWORD,DWORD,LPSTR,UINT);
WINGDIAPI BOOL WINAPI UpdateICMRegKeyW(DWORD,DWORD,LPWSTR,UINT);
WINGDIAPI BOOL WINAPI WidenPath(HDC);
WINGDIAPI BOOL WINAPI wglCopyContext(HGLRC,HGLRC,UINT);
WINGDIAPI HGLRC WINAPI wglCreateContext(HDC);
WINGDIAPI HGLRC WINAPI wglCreateLayerContext(HDC,int);
WINGDIAPI BOOL WINAPI wglDeleteContext(HGLRC);
WINGDIAPI BOOL WINAPI wglDescribeLayerPlane(HDC,int,int,UINT,LPLAYERPLANEDESCRIPTOR);
WINGDIAPI HGLRC WINAPI wglGetCurrentContext(void);
WINGDIAPI HDC WINAPI wglGetCurrentDC(void);
WINGDIAPI int WINAPI wglGetLayerPaletteEntries(HDC,int,int,int,COLORREF*);
WINGDIAPI PROC WINAPI wglGetProcAddress(LPCSTR);
WINGDIAPI BOOL WINAPI wglMakeCurrent(HDC,HGLRC);
WINGDIAPI BOOL WINAPI wglRealizeLayerPalette(HDC,int,BOOL);
WINGDIAPI int WINAPI wglSetLayerPaletteEntries(HDC,int,int,int,const COLORREF*);
WINGDIAPI BOOL WINAPI wglShareLists(HGLRC,HGLRC);
WINGDIAPI BOOL WINAPI wglSwapLayerBuffers(HDC,UINT);
WINGDIAPI BOOL WINAPI wglUseFontBitmapsA(HDC,DWORD,DWORD,DWORD);
WINGDIAPI BOOL WINAPI wglUseFontBitmapsW(HDC,DWORD,DWORD,DWORD);
WINGDIAPI BOOL WINAPI wglUseFontOutlinesA(HDC,DWORD,DWORD,DWORD,FLOAT,FLOAT,int,LPGLYPHMETRICSFLOAT);
WINGDIAPI BOOL WINAPI wglUseFontOutlinesW(HDC,DWORD,DWORD,DWORD,FLOAT,FLOAT,int,LPGLYPHMETRICSFLOAT);

HIMC WINAPI ImmAssociateContext(HWND,HIMC);
LONG WINAPI ImmGetCompositionStringA(HIMC,DWORD,PVOID,DWORD);
HIMC WINAPI ImmGetContext(HWND);
BOOL WINAPI ImmSetCompositionStringA(HIMC,DWORD,LPCVOID,DWORD,LPCVOID,DWORD);
BOOL WINAPI ImmReleaseContext(HWND,HIMC);

WINADVAPI BOOL WINAPI AbortSystemShutdownA(LPCSTR);
WINADVAPI BOOL WINAPI AbortSystemShutdownW(LPCWSTR);
WINADVAPI BOOL WINAPI InitiateSystemShutdownA(LPSTR,LPSTR,DWORD,BOOL,BOOL);
WINADVAPI BOOL WINAPI InitiateSystemShutdownW(LPWSTR,LPWSTR,DWORD,BOOL,BOOL);

// advapi32 winreg.h
WINADVAPI LONG WINAPI RegCloseKey(HKEY);
WINADVAPI LONG WINAPI RegConnectRegistryA(LPCSTR,HKEY,PHKEY);
WINADVAPI LONG WINAPI RegConnectRegistryW(LPCWSTR,HKEY,PHKEY);
WINADVAPI LONG WINAPI RegCreateKeyA(HKEY,LPCSTR,PHKEY);
WINADVAPI LONG WINAPI RegCreateKeyExA(HKEY,LPCSTR,DWORD,LPSTR,DWORD,REGSAM,LPSECURITY_ATTRIBUTES,PHKEY,PDWORD);
WINADVAPI LONG WINAPI RegCreateKeyExW(HKEY,LPCWSTR,DWORD,LPWSTR,DWORD,REGSAM,LPSECURITY_ATTRIBUTES,PHKEY,PDWORD);
WINADVAPI LONG WINAPI RegCreateKeyW(HKEY,LPCWSTR,PHKEY);
WINADVAPI LONG WINAPI RegDeleteKeyA(HKEY,LPCSTR);
WINADVAPI LONG WINAPI RegDeleteKeyW(HKEY,LPCWSTR);
WINADVAPI LONG WINAPI RegDeleteKeyExA(HKEY,LPCSTR,REGSAM,DWORD);
WINADVAPI LONG WINAPI RegDeleteKeyExW(HKEY,LPCWSTR,REGSAM,DWORD);
WINADVAPI LONG WINAPI RegDeleteValueA(HKEY,LPCSTR);
WINADVAPI LONG WINAPI RegDeleteValueW(HKEY,LPCWSTR);
WINADVAPI LONG WINAPI RegEnumKeyA(HKEY,DWORD,LPSTR,DWORD);
WINADVAPI LONG WINAPI RegEnumKeyW(HKEY,DWORD,LPWSTR,DWORD);
WINADVAPI LONG WINAPI RegEnumKeyExA(HKEY,DWORD,LPSTR,PDWORD,PDWORD,LPSTR,PDWORD,PFILETIME);
WINADVAPI LONG WINAPI RegEnumKeyExW(HKEY,DWORD,LPWSTR,PDWORD,PDWORD,LPWSTR,PDWORD,PFILETIME);
WINADVAPI LONG WINAPI RegEnumValueA(HKEY,DWORD,LPSTR,PDWORD,PDWORD,PDWORD,LPBYTE,PDWORD);
WINADVAPI LONG WINAPI RegEnumValueW(HKEY,DWORD,LPWSTR,PDWORD,PDWORD,PDWORD,LPBYTE,PDWORD);
WINADVAPI LONG WINAPI RegFlushKey(HKEY);
WINADVAPI LONG WINAPI RegGetKeySecurity(HKEY,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,PDWORD);
WINADVAPI LONG WINAPI RegLoadKeyA(HKEY,LPCSTR,LPCSTR);
WINADVAPI LONG WINAPI RegLoadKeyW(HKEY,LPCWSTR,LPCWSTR);
WINADVAPI LONG WINAPI RegNotifyChangeKeyValue(HKEY,BOOL,DWORD,HANDLE,BOOL);
WINADVAPI LONG WINAPI RegOpenKeyA(HKEY,LPCSTR,PHKEY);
WINADVAPI LONG WINAPI RegOpenKeyExA(HKEY,LPCSTR,DWORD,REGSAM,PHKEY);
WINADVAPI LONG WINAPI RegOpenKeyExW(HKEY,LPCWSTR,DWORD,REGSAM,PHKEY);
WINADVAPI LONG WINAPI RegOpenKeyW(HKEY,LPCWSTR,PHKEY);
WINADVAPI LONG WINAPI RegQueryInfoKeyA(HKEY,LPSTR,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PFILETIME);
WINADVAPI LONG WINAPI RegQueryInfoKeyW(HKEY,LPWSTR,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PFILETIME);
WINADVAPI LONG WINAPI RegQueryMultipleValuesA(HKEY,PVALENTA,DWORD,LPSTR,LPDWORD);
WINADVAPI LONG WINAPI RegQueryMultipleValuesW(HKEY,PVALENTW,DWORD,LPWSTR,LPDWORD);
WINADVAPI LONG WINAPI RegQueryValueA(HKEY,LPCSTR,LPSTR,PLONG);
WINADVAPI LONG WINAPI RegQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
WINADVAPI LONG WINAPI RegQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
WINADVAPI LONG WINAPI RegQueryValueW(HKEY,LPCWSTR,LPWSTR,PLONG);
WINADVAPI LONG WINAPI RegReplaceKeyA(HKEY,LPCSTR,LPCSTR,LPCSTR);
WINADVAPI LONG WINAPI RegReplaceKeyW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR);
WINADVAPI LONG WINAPI RegRestoreKeyA(HKEY,LPCSTR,DWORD);
WINADVAPI LONG WINAPI RegRestoreKeyW(HKEY,LPCWSTR,DWORD);
WINADVAPI LONG WINAPI RegSaveKeyA(HKEY,LPCSTR,LPSECURITY_ATTRIBUTES);
WINADVAPI LONG WINAPI RegSaveKeyW(HKEY,LPCWSTR,LPSECURITY_ATTRIBUTES);
WINADVAPI LONG WINAPI RegSetKeySecurity(HKEY,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINADVAPI LONG WINAPI RegSetValueA(HKEY,LPCSTR,DWORD,LPCSTR,DWORD);
WINADVAPI LONG WINAPI RegSetValueExA(HKEY,LPCSTR,DWORD,DWORD,const BYTE*,DWORD);
WINADVAPI LONG WINAPI RegSetValueExW(HKEY,LPCWSTR,DWORD,DWORD,const BYTE*,DWORD);
WINADVAPI LONG WINAPI RegSetValueW(HKEY,LPCWSTR,DWORD,LPCWSTR,DWORD);
WINADVAPI LONG WINAPI RegUnLoadKeyA(HKEY,LPCSTR);
WINADVAPI LONG WINAPI RegUnLoadKeyW(HKEY,LPCWSTR);

// commctrl.h
void WINAPI InitCommonControls(void);
BOOL WINAPI InitCommonControlsEx(LPINITCOMMONCONTROLSEX);

// commdlg.h
BOOL WINAPI ChooseColorA(LPCHOOSECOLORA);
BOOL WINAPI ChooseColorW(LPCHOOSECOLORW);
BOOL WINAPI ChooseFontA(LPCHOOSEFONTA);
BOOL WINAPI ChooseFontW(LPCHOOSEFONTW);
DWORD WINAPI CommDlgExtendedError(void);
HWND WINAPI FindTextA(LPFINDREPLACEA);
HWND WINAPI FindTextW(LPFINDREPLACEW);
short WINAPI GetFileTitleA(LPCSTR,LPSTR,WORD);
short WINAPI GetFileTitleW(LPCWSTR,LPWSTR,WORD);
BOOL WINAPI GetOpenFileNameA(LPOPENFILENAMEA);
BOOL WINAPI GetOpenFileNameW(LPOPENFILENAMEW);
BOOL WINAPI GetSaveFileNameA(LPOPENFILENAMEA);
BOOL WINAPI GetSaveFileNameW(LPOPENFILENAMEW);
BOOL WINAPI PageSetupDlgA(LPPAGESETUPDLGA);
BOOL WINAPI PageSetupDlgW(LPPAGESETUPDLGW);
BOOL WINAPI PrintDlgA(LPPRINTDLGA);
BOOL WINAPI PrintDlgW(LPPRINTDLGW);
HWND WINAPI ReplaceTextA(LPFINDREPLACEA);
HWND WINAPI ReplaceTextW(LPFINDREPLACEW);
HRESULT WINAPI PrintDlgExA(LPPRINTDLGEXA);
HRESULT WINAPI PrintDlgExW(LPPRINTDLGEXW);

// mmsystem.h
LRESULT WINAPI CloseDriver(HDRVR,LONG,LONG);
HDRVR WINAPI OpenDriver(LPCWSTR,LPCWSTR,LONG);
LRESULT WINAPI SendDriverMessage(HDRVR,UINT,LONG,LONG);
HMODULE WINAPI DrvGetModuleHandle(HDRVR);
HMODULE WINAPI GetDriverModuleHandle(HDRVR);
LRESULT WINAPI DefDriverProc(DWORD,HDRVR,UINT,LPARAM,LPARAM);
UINT WINAPI mmsystemGetVersion(void);
BOOL WINAPI sndPlaySoundA(LPCSTR,UINT);
BOOL WINAPI sndPlaySoundW(LPCWSTR,UINT);
BOOL WINAPI PlaySoundA(LPCSTR,HMODULE,DWORD);
BOOL WINAPI PlaySoundW(LPCWSTR,HMODULE,DWORD);
UINT WINAPI waveOutGetNumDevs(void);
MMRESULT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
MMRESULT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
MMRESULT WINAPI waveOutGetVolume(HWAVEOUT,PDWORD);
MMRESULT WINAPI waveOutSetVolume(HWAVEOUT,DWORD);
MMRESULT WINAPI waveOutGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI waveOutGetErrorTextW(MMRESULT,LPWSTR,UINT);
MMRESULT WINAPI waveOutOpen(LPHWAVEOUT,UINT,LPCWAVEFORMATEX,DWORD,DWORD,DWORD);
MMRESULT WINAPI waveOutClose(HWAVEOUT);
MMRESULT WINAPI waveOutPrepareHeader(HWAVEOUT,LPWAVEHDR,UINT);
MMRESULT WINAPI waveOutUnprepareHeader(HWAVEOUT,LPWAVEHDR,UINT);
MMRESULT WINAPI waveOutWrite(HWAVEOUT,LPWAVEHDR,UINT);
MMRESULT WINAPI waveOutPause(HWAVEOUT);
MMRESULT WINAPI waveOutRestart(HWAVEOUT);
MMRESULT WINAPI waveOutReset(HWAVEOUT);
MMRESULT WINAPI waveOutBreakLoop(HWAVEOUT);
MMRESULT WINAPI waveOutGetPosition(HWAVEOUT,LPMMTIME,UINT);
MMRESULT WINAPI waveOutGetPitch(HWAVEOUT,PDWORD);
MMRESULT WINAPI waveOutSetPitch(HWAVEOUT,DWORD);
MMRESULT WINAPI waveOutGetPlaybackRate(HWAVEOUT,PDWORD);
MMRESULT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
MMRESULT WINAPI waveOutGetID(HWAVEOUT,LPUINT);
MMRESULT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
UINT WINAPI waveInGetNumDevs(void);
MMRESULT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
MMRESULT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
MMRESULT WINAPI waveInGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI waveInGetErrorTextW(MMRESULT,LPWSTR,UINT);
MMRESULT WINAPI waveInOpen(LPHWAVEIN,UINT,LPCWAVEFORMATEX,DWORD,DWORD,DWORD);
MMRESULT WINAPI waveInClose(HWAVEIN);
MMRESULT WINAPI waveInPrepareHeader(HWAVEIN,LPWAVEHDR,UINT);
MMRESULT WINAPI waveInUnprepareHeader(HWAVEIN,LPWAVEHDR,UINT);
MMRESULT WINAPI waveInAddBuffer(HWAVEIN,LPWAVEHDR,UINT);
MMRESULT WINAPI waveInStart(HWAVEIN);
MMRESULT WINAPI waveInStop(HWAVEIN);
MMRESULT WINAPI waveInReset(HWAVEIN);
MMRESULT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
MMRESULT WINAPI waveInGetID(HWAVEIN,LPUINT);
MMRESULT WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
UINT WINAPI mixerGetNumDevs(void);
MMRESULT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
MMRESULT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
MMRESULT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
MMRESULT WINAPI mixerClose(HMIXER);
DWORD WINAPI mixerMessage(HMIXER,UINT,DWORD,DWORD);
MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
MMRESULT WINAPI mixerGetID(HMIXEROBJ,PUINT,DWORD);
MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ,LPMIXERLINECONTROLSA,DWORD);
MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ,LPMIXERLINECONTROLSW,DWORD);
MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
MMRESULT WINAPI mixerGetControlDetailsW(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
DWORD WINAPI timeGetTime(void);
MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
MMRESULT WINAPI timeKillEvent(UINT);
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
MMRESULT WINAPI timeBeginPeriod(UINT);
MMRESULT WINAPI timeEndPeriod(UINT);
UINT WINAPI joyGetNumDevs(void);
MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
MMRESULT WINAPI joyGetPosEx(UINT,LPJOYINFOEX);
MMRESULT WINAPI joyGetThreshold(UINT,LPUINT);
MMRESULT WINAPI joyReleaseCapture(UINT);
MMRESULT WINAPI joySetCapture(HWND,UINT,UINT,BOOL);
MMRESULT WINAPI joySetThreshold(UINT,UINT);

// winsock2.h
SOCKET PASCAL accept(SOCKET,struct sockaddr*,int*);
int PASCAL bind(SOCKET,const struct sockaddr*,int);
int PASCAL closesocket(SOCKET);
int PASCAL connect(SOCKET,const struct sockaddr*,int);
int PASCAL ioctlsocket(SOCKET,long,u_long *);
int PASCAL getpeername(SOCKET,struct sockaddr*,int*);
int PASCAL getsockname(SOCKET,struct sockaddr*,int*);
int PASCAL getsockopt(SOCKET,int,int,char*,int*);
unsigned long PASCAL inet_addr(const char*);
// char * __stdcall inet_ntoa(struct in_addr);
// hack: for now this will need a wrapper
char * __stdcall inet_ntoa(int in_addr);
int PASCAL listen(SOCKET,int);
int PASCAL recv(SOCKET,char*,int,int);
int PASCAL recvfrom(SOCKET,char*,int,int,struct sockaddr*,int*);
int PASCAL send(SOCKET,const char*,int,int);
int PASCAL sendto(SOCKET,const char*,int,int,const struct sockaddr*,int);
int PASCAL setsockopt(SOCKET,int,int,const char*,int);
int PASCAL shutdown(SOCKET,int);
SOCKET PASCAL socket(int,int,int);
struct hostent * PASCAL gethostbyaddr(const char*,int,int);
struct hostent * PASCAL gethostbyname(const char*);
struct servent * PASCAL getservbyport(int,const char*);
struct servent * PASCAL getservbyname(const char*,const char*);
struct protoent * PASCAL getprotobynumber(int);
struct protoent * PASCAL getprotobyname(const char*);
u_long PASCAL htonl(u_long);
u_long PASCAL ntohl(u_long);
u_short PASCAL htons(u_short);
u_short PASCAL ntohs(u_short);
int PASCAL select(int nfds,fd_set*,fd_set*,fd_set*,const struct timeval*);
int PASCAL gethostname(char*,int);
int PASCAL WSAStartup(WORD,LPWSADATA);
int PASCAL WSACleanup(void);
void PASCAL WSASetLastError(int);
int PASCAL WSAGetLastError(void);
HANDLE PASCAL WSAAsyncGetServByName(HWND,u_int,const char*,const char*,char*,int);
HANDLE PASCAL WSAAsyncGetServByPort(HWND,u_int,int,const char*,char*,int);
HANDLE PASCAL WSAAsyncGetProtoByName(HWND,u_int,const char*,char*,int);
HANDLE PASCAL WSAAsyncGetProtoByNumber(HWND,u_int,int,char*,int);
HANDLE PASCAL WSAAsyncGetHostByName(HWND,u_int,const char*,char*,int);
HANDLE PASCAL WSAAsyncGetHostByAddr(HWND,u_int,const char*,int,int,char*,int);
int PASCAL WSACancelAsyncRequest(HANDLE);
int PASCAL WSAAsyncSelect(SOCKET,HWND,u_int,long);
int PASCAL __WSAFDIsSet(SOCKET,fd_set*);

// ole32 objbase.h
DWORD __stdcall CoBuildVersion(void);
HRESULT __stdcall CoInitialize(PVOID);
HRESULT __stdcall CoInitializeEx(LPVOID,DWORD);
void __stdcall CoUninitialize(void);
HRESULT __stdcall CoCreateInstance(REFCLSID,LPUNKNOWN,DWORD,REFIID,PVOID*);
HRESULT __stdcall CoCreateInstanceEx(REFCLSID,IUnknown*,DWORD,COSERVERINFO*,DWORD,MULTI_QI*);

// tapi.h
DWORD WINAPI lineAccept(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineAddProvider(LPCSTR,HWND,LPDWORD);
DWORD WINAPI lineAddProviderA(LPCSTR,HWND,LPDWORD);
DWORD WINAPI lineAddProviderW(LPCWSTR,HWND,LPDWORD);
DWORD WINAPI lineAddToConference(HCALL,HCALL);
DWORD WINAPI lineAnswer(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineBlindTransfer(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineClose(HLINE);
DWORD WINAPI lineCompleteCall(HCALL,LPDWORD,DWORD,DWORD);
DWORD WINAPI lineCompleteTransfer(HCALL,HCALL,LPHCALL,DWORD);
DWORD WINAPI lineConfigDialog(DWORD,HWND,LPCSTR);
DWORD WINAPI lineConfigDialogEdit(DWORD,HWND,LPCSTR,LPVOID const,DWORD,LPVARSTRING);
DWORD WINAPI lineConfigProvider(HWND,DWORD);
DWORD WINAPI lineDeallocateCall(HCALL);
DWORD WINAPI lineDevSpecific(HLINE,DWORD,HCALL,LPVOID,DWORD);
DWORD WINAPI lineDevSpecificFeature(HLINE,DWORD,LPVOID,DWORD);
DWORD WINAPI lineDial(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineDrop(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineForward(HLINE,DWORD,DWORD,LPLINEFORWARDLIST,DWORD,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineGatherDigits(HCALL,DWORD,LPSTR,DWORD,LPCSTR,DWORD,DWORD);
DWORD WINAPI lineGenerateDigits(HCALL,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineGenerateTone(HCALL,DWORD,DWORD,DWORD,LPLINEGENERATETONE);
DWORD WINAPI lineGetAddressCaps(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPLINEADDRESSCAPS);
DWORD WINAPI lineGetAddressID(HLINE,LPDWORD,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineGetAddressStatus(HLINE,DWORD,LPLINEADDRESSSTATUS);
DWORD WINAPI lineGetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPVARSTRING,LPDWORD);
DWORD WINAPI lineGetCallInfo(HCALL,LPLINECALLINFO);
DWORD WINAPI lineGetCallStatus(HCALL,LPLINECALLSTATUS);
DWORD WINAPI lineGetConfRelatedCalls(HCALL,LPLINECALLLIST);
DWORD WINAPI lineGetCountry(DWORD,DWORD,LPLINECOUNTRYLIST);
DWORD WINAPI lineGetDevCaps(HLINEAPP,DWORD,DWORD,DWORD,LPLINEDEVCAPS);
DWORD WINAPI lineGetDevCapsA(HLINEAPP,DWORD,DWORD,DWORD,LPLINEDEVCAPS);
DWORD WINAPI lineGetDevCapsW(HLINEAPP,DWORD,DWORD,DWORD,LPLINEDEVCAPS);
DWORD WINAPI lineGetDevConfig(DWORD,LPVARSTRING,LPCSTR);
DWORD WINAPI lineGetID(HLINE,DWORD,HCALL,DWORD,LPVARSTRING,LPCSTR);
DWORD WINAPI lineGetIDA(HLINE,DWORD,HCALL,DWORD,LPVARSTRING,LPCSTR);
DWORD WINAPI lineGetIDW(HLINE,DWORD,HCALL,DWORD,LPVARSTRING,LPCWSTR);
DWORD WINAPI lineGetIcon(DWORD,LPCSTR,HICON *);
DWORD WINAPI lineGetLineDevStatus(HLINE,LPLINEDEVSTATUS);
DWORD WINAPI lineGetNewCalls(HLINE,DWORD,DWORD,LPLINECALLLIST);
DWORD WINAPI lineGetNumRings(HLINE,DWORD,LPDWORD);
DWORD WINAPI lineGetProviderList(DWORD,LPLINEPROVIDERLIST);
DWORD WINAPI lineGetProviderListA(DWORD,LPLINEPROVIDERLIST);
DWORD WINAPI lineGetProviderListW(DWORD,LPLINEPROVIDERLIST);
DWORD WINAPI lineGetRequest(HLINEAPP,DWORD,LPVOID);
DWORD WINAPI lineGetStatusMessages(HLINE,LPDWORD,LPDWORD);
DWORD WINAPI lineGetTranslateCaps(HLINEAPP,DWORD,LPLINETRANSLATECAPS);
DWORD WINAPI lineHandoff(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineHold(HCALL);
DWORD WINAPI lineInitialize(LPHLINEAPP,HINSTANCE,LINECALLBACK,LPCSTR,LPDWORD);
LONG  WINAPI lineInitializeExA(LPHLINEAPP,HINSTANCE,LINECALLBACK,LPCSTR,LPDWORD,LPDWORD,LPLINEINITIALIZEEXPARAMS);
LONG  WINAPI lineInitializeExW(LPHLINEAPP,HINSTANCE,LINECALLBACK,LPCWSTR,LPDWORD,LPDWORD,LPLINEINITIALIZEEXPARAMS);
DWORD WINAPI lineMakeCall(HLINE,LPHCALL,LPCSTR,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineMakeCallA(HLINE,LPHCALL,LPCSTR,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineMakeCallW(HLINE,LPHCALL,LPCWSTR,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineMonitorDigits(HCALL,DWORD);
DWORD WINAPI lineMonitorMedia(HCALL,DWORD);
DWORD WINAPI lineMonitorTones(HCALL,LPLINEMONITORTONE,DWORD);
DWORD WINAPI lineNegotiateAPIVersion(HLINEAPP,DWORD,DWORD,DWORD,LPDWORD,LPLINEEXTENSIONID);
DWORD WINAPI lineNegotiateExtVersion(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPDWORD);
DWORD WINAPI lineOpen(HLINEAPP,DWORD,LPHLINE,DWORD,DWORD,DWORD,DWORD,DWORD,LPLINECALLPARAMS);
DWORD WINAPI linePark(HCALL,DWORD,LPCSTR,LPVARSTRING);
DWORD WINAPI linePickup(HLINE,DWORD,LPHCALL,LPCSTR,LPCSTR);
DWORD WINAPI linePrepareAddToConference(HCALL,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineRedirect(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP,DWORD,DWORD,DWORD);
DWORD WINAPI lineReleaseUserUserInfo(HCALL);
DWORD WINAPI lineRemoveFromConference(HCALL);
DWORD WINAPI lineRemoveProvider(DWORD,HWND);
DWORD WINAPI lineSecureCall(HCALL);
DWORD WINAPI lineSendUserUserInfo(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineSetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineSetAppSpecific(HCALL,DWORD);
DWORD WINAPI lineSetCallParams(HCALL,DWORD,DWORD,DWORD,LPLINEDIALPARAMS);
DWORD WINAPI lineSetCallPrivilege(HCALL,DWORD);
DWORD WINAPI lineSetCurrentLocation(HLINEAPP,DWORD);
DWORD WINAPI lineSetDevConfig(DWORD,LPVOID,DWORD,LPCSTR);
DWORD WINAPI lineSetMediaControl(HLINE,DWORD,HCALL,DWORD,LPLINEMEDIACONTROLDIGIT,DWORD,LPLINEMEDIACONTROLMEDIA,DWORD,LPLINEMEDIACONTROLTONE,DWORD,LPLINEMEDIACONTROLCALLSTATE,DWORD);
DWORD WINAPI lineSetMediaMode(HCALL,DWORD);
DWORD WINAPI lineSetNumRings(HLINE,DWORD,DWORD);
DWORD WINAPI lineSetStatusMessages(HLINE,DWORD,DWORD);
DWORD WINAPI lineSetTerminal(HLINE,DWORD,HCALL,DWORD,DWORD,DWORD,DWORD);
DWORD WINAPI lineSetTollList(HLINEAPP,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineSetupConference(HCALL,HLINE,LPHCALL,LPHCALL,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineSetupTransfer(HCALL,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineShutdown(HLINEAPP);
DWORD WINAPI lineSwapHold(HCALL,HCALL);
DWORD WINAPI lineTranslateAddress(HLINEAPP,DWORD,DWORD,LPCSTR,DWORD,DWORD,LPLINETRANSLATEOUTPUT);
DWORD WINAPI lineTranslateDialog(HLINEAPP,DWORD,DWORD,HWND,LPCSTR);
DWORD WINAPI lineUncompleteCall(HLINE,DWORD);
DWORD WINAPI lineUnHold(HCALL);
DWORD WINAPI lineUnpark(HLINE,DWORD,LPHCALL,LPCSTR);

DWORD WINAPI lineBlindTransferA(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineConfigDialogA(DWORD,HWND,LPCSTR);
DWORD WINAPI lineConfigDialogEditA(DWORD,HWND,LPCSTR,LPVOID const,DWORD,LPVARSTRING);
DWORD WINAPI lineDialA(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineForwardA(HLINE,DWORD,DWORD,LPLINEFORWARDLIST,DWORD,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineGatherDigitsA(HCALL,DWORD,LPSTR,DWORD,LPCSTR,DWORD,DWORD);
DWORD WINAPI lineGenerateDigitsA(HCALL,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineGetAddressCapsA(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPLINEADDRESSCAPS);
DWORD WINAPI lineGetAddressIDA(HLINE,LPDWORD,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineGetAddressStatusA(HLINE,DWORD,LPLINEADDRESSSTATUS);
DWORD WINAPI lineGetAppPriorityA(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPVARSTRING,LPDWORD);
DWORD WINAPI lineGetCallInfoA(HCALL,LPLINECALLINFO);
DWORD WINAPI lineGetCountryA(DWORD,DWORD,LPLINECOUNTRYLIST);
DWORD WINAPI lineGetDevConfigA(DWORD,LPVARSTRING,LPCSTR);
DWORD WINAPI lineGetIconA(DWORD,LPCSTR,HICON *);
DWORD WINAPI lineGetLineDevStatusA(HLINE,LPLINEDEVSTATUS);
DWORD WINAPI lineGetRequestA(HLINEAPP,DWORD,LPVOID);
DWORD WINAPI lineGetTranslateCapsA(HLINEAPP,DWORD,LPLINETRANSLATECAPS);
DWORD WINAPI lineHandoffA(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineOpenA(HLINEAPP,DWORD,LPHLINE,DWORD,DWORD,DWORD,DWORD,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineParkA(HCALL,DWORD,LPCSTR,LPVARSTRING);
DWORD WINAPI linePickupA(HLINE,DWORD,LPHCALL,LPCSTR,LPCSTR);
DWORD WINAPI linePrepareAddToConferenceA(HCALL,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineRedirectA(HCALL,LPCSTR,DWORD);
DWORD WINAPI lineSetAppPriorityA(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineSetDevConfigA(DWORD,LPVOID,DWORD,LPCSTR);
DWORD WINAPI lineSetTollListA(HLINEAPP,DWORD,LPCSTR,DWORD);
DWORD WINAPI lineSetupConferenceA(HCALL,HLINE,LPHCALL,LPHCALL,DWORD,LPLINECALLPARAMS);
DWORD WINAPI lineSetupTransferA(HCALL,LPHCALL,LPLINECALLPARAMS);
DWORD WINAPI lineTranslateAddressA(HLINEAPP,DWORD,DWORD,LPCSTR,DWORD,DWORD,LPLINETRANSLATEOUTPUT);
DWORD WINAPI lineTranslateDialogA(HLINEAPP,DWORD,DWORD,HWND,LPCSTR);
DWORD WINAPI lineUnhold(HCALL);
DWORD WINAPI lineUnparkA(HLINE,DWORD,LPHCALL,LPCSTR);

// winsvc.h
WINADVAPI BOOL WINAPI ChangeServiceConfigA(SC_HANDLE,DWORD,DWORD,DWORD,LPCSTR,LPCSTR,LPDWORD,LPCSTR,LPCSTR,LPCSTR,LPCSTR);
WINADVAPI BOOL WINAPI ChangeServiceConfigW(SC_HANDLE,DWORD,DWORD,DWORD,LPCWSTR,LPCWSTR,LPDWORD,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR);
WINADVAPI BOOL WINAPI ChangeServiceConfig2A(SC_HANDLE,DWORD,LPVOID);
WINADVAPI BOOL WINAPI ChangeServiceConfig2W(SC_HANDLE,DWORD,LPVOID);
WINADVAPI BOOL WINAPI CloseServiceHandle(SC_HANDLE);
WINADVAPI BOOL WINAPI ControlService(SC_HANDLE,DWORD,LPSERVICE_STATUS);
WINADVAPI SC_HANDLE WINAPI CreateServiceA(SC_HANDLE,LPCSTR,LPCSTR,DWORD,DWORD,DWORD,DWORD,LPCSTR,LPCSTR,PDWORD,LPCSTR,LPCSTR,LPCSTR);
WINADVAPI SC_HANDLE WINAPI CreateServiceW(SC_HANDLE,LPCWSTR,LPCWSTR,DWORD,DWORD,DWORD,DWORD,LPCWSTR,LPCWSTR,PDWORD,LPCWSTR,LPCWSTR,LPCWSTR);
WINADVAPI BOOL WINAPI DeleteService(SC_HANDLE);
WINADVAPI BOOL WINAPI EnumDependentServicesA(SC_HANDLE,DWORD,LPENUM_SERVICE_STATUSA,DWORD,PDWORD,PDWORD);
WINADVAPI BOOL WINAPI EnumDependentServicesW(SC_HANDLE,DWORD,LPENUM_SERVICE_STATUSW,DWORD,PDWORD,PDWORD);
WINADVAPI BOOL WINAPI EnumServicesStatusA(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSA,DWORD,PDWORD,PDWORD,PDWORD);
WINADVAPI BOOL WINAPI EnumServicesStatusW(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSW,DWORD,PDWORD,PDWORD,PDWORD);
WINADVAPI BOOL WINAPI EnumServicesStatusExA(SC_HANDLE,SC_ENUM_TYPE,DWORD,DWORD,LPBYTE,DWORD,LPDWORD,LPDWORD,LPDWORD,LPCSTR);
WINADVAPI BOOL WINAPI EnumServicesStatusExW(SC_HANDLE,SC_ENUM_TYPE,DWORD,DWORD,LPBYTE,DWORD,LPDWORD,LPDWORD,LPDWORD,LPCWSTR);
WINADVAPI BOOL WINAPI GetServiceDisplayNameA(SC_HANDLE,LPCSTR,LPSTR,PDWORD);
WINADVAPI BOOL WINAPI GetServiceDisplayNameW(SC_HANDLE,LPCWSTR,LPWSTR,PDWORD);
WINADVAPI BOOL WINAPI GetServiceKeyNameA(SC_HANDLE,LPCSTR,LPSTR,PDWORD);
WINADVAPI BOOL WINAPI GetServiceKeyNameW(SC_HANDLE,LPCWSTR,LPWSTR,PDWORD);
WINADVAPI SC_LOCK WINAPI LockServiceDatabase(SC_HANDLE);
WINADVAPI BOOL WINAPI NotifyBootConfigStatus(BOOL);
WINADVAPI SC_HANDLE WINAPI OpenSCManagerA(LPCSTR,LPCSTR,DWORD);
WINADVAPI SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR,LPCWSTR,DWORD);
WINADVAPI SC_HANDLE WINAPI OpenServiceA(SC_HANDLE,LPCSTR,DWORD);
WINADVAPI SC_HANDLE WINAPI OpenServiceW(SC_HANDLE,LPCWSTR,DWORD);
WINADVAPI BOOL WINAPI QueryServiceConfigA(SC_HANDLE,LPQUERY_SERVICE_CONFIGA,DWORD,PDWORD);
WINADVAPI BOOL WINAPI QueryServiceConfigW(SC_HANDLE,LPQUERY_SERVICE_CONFIGW,DWORD,PDWORD);
WINADVAPI BOOL WINAPI QueryServiceConfig2A(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD);
WINADVAPI BOOL WINAPI QueryServiceConfig2W(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD);
WINADVAPI BOOL WINAPI QueryServiceLockStatusA(SC_HANDLE,LPQUERY_SERVICE_LOCK_STATUSA,DWORD,PDWORD);
WINADVAPI BOOL WINAPI QueryServiceLockStatusW(SC_HANDLE,LPQUERY_SERVICE_LOCK_STATUSW,DWORD,PDWORD);
WINADVAPI BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
WINADVAPI BOOL WINAPI QueryServiceStatus(SC_HANDLE,LPSERVICE_STATUS);
WINADVAPI BOOL WINAPI QueryServiceStatusEx(SC_HANDLE,SC_STATUS_TYPE,LPBYTE,DWORD,LPDWORD);
WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA(LPCSTR,LPHANDLER_FUNCTION);
WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW(LPCWSTR,LPHANDLER_FUNCTION);
WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA(LPCSTR,LPHANDLER_FUNCTION_EX,LPVOID);
WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW(LPCWSTR,LPHANDLER_FUNCTION_EX,LPVOID);
WINADVAPI BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
WINADVAPI BOOL WINAPI SetServiceStatus(SERVICE_STATUS_HANDLE,LPSERVICE_STATUS);
WINADVAPI BOOL WINAPI StartServiceA(SC_HANDLE,DWORD,LPCSTR*);
WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA);
WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW);
WINADVAPI BOOL WINAPI StartServiceW(SC_HANDLE,DWORD,LPCWSTR*);
WINADVAPI BOOL WINAPI UnlockServiceDatabase(SC_LOCK);

// ddraw.h dsound.h
HRESULT WINAPI DirectDrawCreate(GUID *driver_guid, IDirectDraw **ddraw, IUnknown *outer);
HRESULT WINAPI DirectDrawCreateEx(GUID *driver_guid, void **ddraw, REFIID interface_iid, IUnknown *outer);
HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer);

HRESULT WINAPI DirectSoundCreate(LPCGUID lpGUID,LPDIRECTSOUND *ppDS,LPUNKNOWN pUnkOuter);
HRESULT WINAPI DirectSoundEnumerateA(LPDSENUMCALLBACKA, LPVOID);
HRESULT WINAPI DirectSoundEnumerateW(LPDSENUMCALLBACKW, LPVOID);
HRESULT WINAPI DirectSoundCreate8(LPCGUID lpGUID,LPDIRECTSOUND8 *ppDS8,LPUNKNOWN pUnkOuter);
HRESULT WINAPI GetDeviceID(LPCGUID lpGuidSrc, LPGUID lpGuidDest);

struct IUnknown {
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
};

struct IDirectDraw {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectDraw methods
/*0c*/    int (WINAPI *Compact)(void *this);
/*10*/    int (WINAPI *CreateClipper)(void *this, DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, IUnknown *pUnkOuter);
/*14*/    int (WINAPI *CreatePalette)(void *this, DWORD dwFlags, LPPALETTEENTRY lpColorTable, LPDIRECTDRAWPALETTE *lplpDDPalette, IUnknown *pUnkOuter); // 14
/*18*/    int (WINAPI *CreateSurface)(void *this, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE *lplpDDSurface, IUnknown *pUnkOuter);
/*1c*/    int (WINAPI *DuplicateSurface)(void *this, LPDIRECTDRAWSURFACE lpDDSurface, LPDIRECTDRAWSURFACE *lplpDupDDSurface);
/*20*/    int (WINAPI *EnumDisplayModes)(void *this, DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback);
/*24*/    int (WINAPI *EnumSurfaces)(void *this, DWORD dwFlags, LPDDSURFACEDESC lpDDSD, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback);
/*28*/    int (WINAPI *FlipToGDISurface)(void *this);
/*2c*/    int (WINAPI *GetCaps_dd)(void *this, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps);
/*30*/    int (WINAPI *GetDisplayMode)(void *this, LPDDSURFACEDESC lpDDSurfaceDesc);
/*34*/    int (WINAPI *GetFourCCCodes)(void *this, LPDWORD lpNumCodes, LPDWORD lpCodes);
/*38*/    int (WINAPI *GetGDISurface)(void *this, LPDIRECTDRAWSURFACE *lplpGDIDDSurface);
/*3c*/    int (WINAPI *GetMonitorFrequency)(void *this, LPDWORD lpdwFrequency);
/*40*/    int (WINAPI *GetScanLine)(void *this, LPDWORD lpdwScanLine);
/*44*/    int (WINAPI *GetVerticalBlankStatus)(void *this, BOOL *lpbIsInVB);
/*48*/    int (WINAPI *Initialize)(void *this, GUID *lpGUID);
/*4c*/    int (WINAPI *RestoreDisplayMode)(void *this);
/*50*/    int (WINAPI *SetCooperativeLevel)(void *this, HWND hWnd, DWORD dwFlags);
/*54*/    int (WINAPI *SetDisplayMode)(void *this, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP);
/*58*/    int (WINAPI *WaitForVerticalBlank)(void *this, DWORD dwFlags, HANDLE hEvent);
};

struct IDirectDraw2 {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectDraw2 methods
/*0c*/    int (WINAPI *Compact)(void *this);
/*10*/    int (WINAPI *CreateClipper)(void *this, DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, IUnknown *pUnkOuter);
/*14*/    int (WINAPI *CreatePalette)(void *this, DWORD dwFlags, LPPALETTEENTRY lpColorTable, LPDIRECTDRAWPALETTE *lplpDDPalette, IUnknown *pUnkOuter);
/*18*/    int (WINAPI *CreateSurface)(void *this, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE *lplpDDSurface, IUnknown *pUnkOuter);
/*1c*/    int (WINAPI *DuplicateSurface)(void *this, LPDIRECTDRAWSURFACE lpDDSurface, LPDIRECTDRAWSURFACE *lplpDupDDSurface);
/*20*/    int (WINAPI *EnumDisplayModes)(void *this, DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback);
/*24*/    int (WINAPI *EnumSurfaces)(void *this, DWORD dwFlags, LPDDSURFACEDESC lpDDSD, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback);
/*28*/    int (WINAPI *FlipToGDISurface)(void *this);
/*2c*/    int (WINAPI *GetCaps_dd)(void *this, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps);
/*30*/    int (WINAPI *GetDisplayMode)(void *this, LPDDSURFACEDESC lpDDSurfaceDesc);
/*34*/    int (WINAPI *GetFourCCCodes)(void *this, LPDWORD lpNumCodes, LPDWORD lpCodes);
/*38*/    int (WINAPI *GetGDISurface)(void *this, LPDIRECTDRAWSURFACE *lplpGDIDDSurface);
/*3c*/    int (WINAPI *GetMonitorFrequency)(void *this, LPDWORD lpdwFrequency);
/*40*/    int (WINAPI *GetScanLine)(void *this, LPDWORD lpdwScanLine);
/*44*/    int (WINAPI *GetVerticalBlankStatus)(void *this, BOOL *lpbIsInVB);
/*48*/    int (WINAPI *Initialize)(void *this, GUID *lpGUID);
/*4c*/    int (WINAPI *RestoreDisplayMode)(void *this);
/*50*/    int (WINAPI *SetCooperativeLevel)(void *this, HWND hWnd, DWORD dwFlags);
/*54*/    int (WINAPI *SetDisplayMode)(void *this, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags);
/*58*/    int (WINAPI *WaitForVerticalBlank)(void *this, DWORD dwFlags, HANDLE hEvent);
          // added in v2
/*5c*/    int (WINAPI *GetAvailableVidMem)(void *this, LPDDSCAPS lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree);
};

// LPDIRECTDRAWPALETTE
struct IDirectDrawPalette {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectDrawPalette methods
/*0c*/    int (WINAPI *GetCaps_ddp)(void *this, LPDWORD lpdwCaps);
/*10*/    int (WINAPI *GetEntries)(void *this, DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries);
/*14*/    int (WINAPI *Initialize)(void *this, LPDIRECTDRAW lpDD, DWORD dwFlags, LPPALETTEENTRY lpDDColorTable);
/*18*/    int (WINAPI *SetEntries)(void *this, DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries);
};

// LPDIRECTDRAWSURFACE
struct IDirectDrawSurface {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectDrawSurface methods
/*0c*/    int (WINAPI *AddAttachedSurface)(void *this, LPDIRECTDRAWSURFACE lpDDSAttachedSurface);
/*10*/    int (WINAPI *AddOverlayDirtyRect)(void *this, LPRECT lpRect);
/*14*/    int (WINAPI *Blt)(void *this, LPRECT lpDestRect, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx);
/*18*/    int (WINAPI *BltBatch)(void *this, LPDDBLTBATCH lpDDBltBatch, DWORD dwCount, DWORD dwFlags);
/*1c*/    int (WINAPI *BltFast)(void *this, DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwTrans);
/*20*/    int (WINAPI *DeleteAttachedSurface)(void *this, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface);
/*24*/    int (WINAPI *EnumAttachedSurfaces)(void *this, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback);
/*28*/    int (WINAPI *EnumOverlayZOrders)(void *this, DWORD dwFlags, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpfnCallback);
/*2c*/    int (WINAPI *Flip)(void *this, LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags);
/*30*/    int (WINAPI *GetAttachedSurface)(void *this, LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE *lplpDDAttachedSurface);
/*34*/    int (WINAPI *GetBltStatus)(void *this, DWORD dwFlags);
/*38*/    int (WINAPI *GetCaps_dds)(void *this, LPDDSCAPS lpDDSCaps);
/*3c*/    int (WINAPI *GetClipper)(void *this, LPDIRECTDRAWCLIPPER *lplpDDClipper);
/*40*/    int (WINAPI *GetColorKey)(void *this, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey);
/*44*/    int (WINAPI *GetDC)(void *this, HDC *lphDC);
/*48*/    int (WINAPI *GetFlipStatus)(void *this, DWORD dwFlags);
/*4c*/    int (WINAPI *GetOverlayPosition)(void *this, LPLONG lplX, LPLONG lplY);
/*50*/    int (WINAPI *GetPalette)(void *this, LPDIRECTDRAWPALETTE *lplpDDPalette);
/*54*/    int (WINAPI *GetPixelFormat)(void *this, LPDDPIXELFORMAT lpDDPixelFormat);
/*58*/    int (WINAPI *GetSurfaceDesc)(void *this, LPDDSURFACEDESC lpDDSurfaceDesc);
/*5c*/    int (WINAPI *Initialize)(void *this, LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc);
/*60*/    int (WINAPI *IsLost)(void *this);
/*64*/    int (WINAPI *Lock)(void *this, LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent);
/*68*/    int (WINAPI *ReleaseDC)(void *this, HDC hDC);
/*6c*/    int (WINAPI *Restore)(void *this);
/*70*/    int (WINAPI *SetClipper)(void *this, LPDIRECTDRAWCLIPPER lpDDClipper);
/*74*/    int (WINAPI *SetColorKey)(void *this, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey);
/*78*/    int (WINAPI *SetOverlayPosition)(void *this, LONG lX, LONG lY);
/*7c*/    int (WINAPI *SetPalette)(void *this, LPDIRECTDRAWPALETTE lpDDPalette);
/*80*/    int (WINAPI *Unlock)(void *this, LPVOID lpSurfaceData);
/*84*/    int (WINAPI *UpdateOverlay)(void *this, LPRECT lpSrcRect, LPDIRECTDRAWSURFACE lpDDDestSurface, LPRECT lpDestRect, DWORD dwFlags, LPDDOVERLAYFX lpDDOverlayFx);
/*88*/    int (WINAPI *UpdateOverlayDisplay)(void *this, DWORD dwFlags);
/*8c*/    int (WINAPI *UpdateOverlayZOrder)(void *this, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSReference);
};

struct IDirectSound {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectSound methods
/*0c*/    int (WINAPI *CreateSoundBuffer)(void *this, LPCDSBUFFERDESC lpcDSBufferDesc, LPLPDIRECTSOUNDBUFFER lplpDirectSoundBuffer, IUnknown *pUnkOuter);
/*10*/    int (WINAPI *GetCaps_ds)(void *this, LPDSCAPS lpDSCaps);
/*14*/    int (WINAPI *DuplicateSoundBuffer)(void *this, LPDIRECTSOUNDBUFFER lpDsbOriginal, LPLPDIRECTSOUNDBUFFER lplpDsbDuplicate);
/*18*/    int (WINAPI *SetCooperativeLevel)(void *this, HWND hwnd, DWORD dwLevel);
/*1c*/    int (WINAPI *Compact)(void *this);
/*20*/    int (WINAPI *GetSpeakerConfig)(void *this, LPDWORD lpdwSpeakerConfig);
/*24*/    int (WINAPI *SetSpeakerConfig)(void *this, DWORD dwSpeakerConfig);
/*28*/    int (WINAPI *Initialize)(void *this, LPCGUID lpcGuid);
};

// LPLPDIRECTSOUNDBUFFER
struct IDirectSoundBuffer {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectSoundBuffer methods
/*0c*/    int (WINAPI *GetCaps_dsb)(void *this, LPDSBCAPS lpDSBufferCaps);
/*10*/    int (WINAPI *GetCurrentPosition)(void *this, LPDWORD lpdwCurrentPlayCursor, LPDWORD lpdwCurrentWriteCursor);
/*14*/    int (WINAPI *GetFormat)(void *this, LPWAVEFORMATEX lpwfxFormat, DWORD dwSizeAllocated, LPDWORD lpdwSizeWritten);
/*18*/    int (WINAPI *GetVolume)(void *this, LPLONG lplVolume);
/*1c*/    int (WINAPI *GetPan)(void *this, LPLONG lplpan);
/*20*/    int (WINAPI *GetFrequency)(void *this, LPDWORD lpdwFrequency);
/*24*/    int (WINAPI *GetStatus)(void *this, LPDWORD lpdwStatus);
/*28*/    int (WINAPI *Initialize)(void *this, LPDIRECTSOUND lpDirectSound, LPCDSBUFFERDESC lpcDSBufferDesc);
/*2c*/    int (WINAPI *Lock)(void *this, DWORD dwOffset, DWORD dwBytes, LPVOID *ppvAudioPtr1, LPDWORD pdwAudioBytes1, LPVOID *ppvAudioPtr2, LPDWORD pdwAudioBytes2, DWORD dwFlags);
/*30*/    int (WINAPI *Play)(void *this, DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags);
/*34*/    int (WINAPI *SetCurrentPosition)(void *this, DWORD dwNewPosition);
/*38*/    int (WINAPI *SetFormat)(void *this, LPCWAVEFORMATEX lpcfxFormat);
/*3c*/    int (WINAPI *SetVolume)(void *this, LONG lVolume);
/*40*/    int (WINAPI *SetPan)(void *this, LONG lPan);
/*44*/    int (WINAPI *SetFrequency)(void *this, DWORD dwFrequency);
/*48*/    int (WINAPI *Stop)(void *this);
/*4c*/    int (WINAPI *Unlock)(void *this, LPVOID pvAudioPtr1, DWORD dwAudioBytes1, LPVOID pvAudioPtr2, DWORD dwAudioPtr2);
/*50*/    int (WINAPI *Restore)(void *this);
};

// 0x279AFA86,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60
struct IDirectSound3DBuffer {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IDirectSound3DBuffer methods
/*0c*/    int (WINAPI *GetAllParameters)(void *this, LPDS3DBUFFER lpDs3dBuffer);
/*10*/    int (WINAPI *GetConeAngles)(void *this, LPDWORD lpdwInsideConeAngle, LPDWORD lpdwOutsideConeAngle);
/*14*/    int (WINAPI *GetConeOrientation)(void *this, LPD3DVECTOR lpvOrientation);
/*18*/    int (WINAPI *GetConeOutsideVolume)(void *this, LPLONG lplConeOutsideVolume);
/*1c*/    int (WINAPI *GetMaxDistance)(void *this, LPD3DVALUE lpflMaxDistance);
/*20*/    int (WINAPI *GetMinDistance)(void *this, LPD3DVALUE lpflMinDistance);
/*24*/    int (WINAPI *GetMode)(void *this, LPDWORD lpwdMode);
/*28*/    int (WINAPI *GetPosition)(void *this, LPD3DVECTOR lpvPosition);
/*2c*/    int (WINAPI *GetVelocity)(void *this, LPD3DVECTOR lpvVelocity);
/*30*/    int (WINAPI *SetAllParameters)(void *this, LPCDS3DBUFFER lpcDs3dBuffer, DWORD dwApply);
/*34*/    int (WINAPI *SetConeAngles)(void *this, DWORD dwInsideConeAngle, DWORD dwOutsideConeAngle, DWORD dwApply);
/*38*/    int (WINAPI *SetConeOrientation)(void *this, float x, float y, float z, DWORD dwApply);
/*3c*/    int (WINAPI *SetConeOutsideVolume)(void *this, LONG lConeOutsideVolume, DWORD dwApply);
/*40*/    int (WINAPI *SetMaxDistance)(void *this, float flMaxDistance, DWORD dwApply);
/*44*/    int (WINAPI *SetMinDistance)(void *this, float flMinDistance, DWORD dwApply);
/*48*/    int (WINAPI *SetMode)(void *this, DWORD dwMode, DWORD dwApply);
/*4c*/    int (WINAPI *SetPosition)(void *this, float x, float y, float z, DWORD dwApply);
/*50*/    int (WINAPI *SetVelocity)(void *this, float x, float y, float z, DWORD dwApply);
};

// 0x31EFAC30,0x515C,0x11D0,0xA9,0xAA,0x00,0xAA,0x00,0x61,0xBE,0x93
struct IKsPropertySet {
          // IUnknown methods
/*00*/    HRESULT (WINAPI *QueryInterface)(void *this, REFIID riid, void** ppvObject);
/*04*/    ULONG (WINAPI *AddRef)(void *this);
/*08*/    ULONG (WINAPI *Release)(void *this);
          // IKsPropertySet methods
/*0c*/    int (WINAPI *Get_iks)(void *this, REFGUID rgid,ULONG x1,LPVOID p1,ULONG x2,LPVOID p2,ULONG x3,ULONG *px4);
/*10*/    int (WINAPI *Set_iks)(void *this, REFGUID rgid,ULONG x1,LPVOID p1,ULONG x2,LPVOID p2,ULONG x3);
/*14*/    int (WINAPI *QuerySupport_iks)(void *this, REFGUID rgid,ULONG x1,ULONG *px2);
};

// %s/ PURE;/;/
// %s/STDMETHOD(\(.*\))(THIS_ /int (WINAPI *\1)(void *this, /
// %s/\<D3DVALUE\>/float/g