/***********************************************************************\
*                               winbase.d                               *
*                                                                       *
*                       Windows API header module                       *
*                                                                       *
*             Translated from MinGW API for MS-Windows 3.10             *
*                                                                       *
*                       Placed into public domain                       *
\***********************************************************************/
module win32.winbase;
pragma(lib, "kernel32.lib");

/**
Translation Notes:
The following macros are obsolete, and have no effect.

LockSegment(w), MakeProcInstance(p, i), UnlockResource(h), UnlockSegment(w)
FreeModule(m), FreeProcInstance(p), GetFreeSpace(w), DefineHandleTable(w)
SetSwapAreaSize(w), LimitEmsPages(n), Yield()

// The following Win16 functions are obselete in Win32.

 int _hread(HFILE, LPVOID, int);
 int _hwrite(HFILE, LPCSTR, int);
 HFILE _lclose(HFILE);
 HFILE _lcreat(LPCSTR, int);
 LONG _llseek(HFILE, LONG, int);
 HFILE _lopen(LPCSTR, int);
 UINT _lread(HFILE, LPVOID, UINT);
 UINT _lwrite(HFILE, LPCSTR, UINT);
 SIZE_T GlobalCompact(DWORD);
 VOID GlobalFix(HGLOBAL);
* MSDN contradicts itself on GlobalFlags:
* "This function is provided only for compatibility with 16-bit versions of Windows."
* but also requires Windows 2000 or above
 UINT GlobalFlags(HGLOBAL);
 VOID GlobalUnfix(HGLOBAL);
 BOOL GlobalUnWire(HGLOBAL);
 PVOID GlobalWire(HGLOBAL);
 SIZE_T LocalCompact(UINT);
 UINT LocalFlags(HLOCAL);
 SIZE_T LocalShrink(HLOCAL, UINT);

// These are not required for DMD.

//FIXME:
// #ifndef UNDER_CE
	int WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
#else
	int WinMain(HINSTANCE, HINSTANCE, LPWSTR, int);
#endif
int wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int);

*/

import win32.windef, win32.winver;
private import win32.basetyps, win32.w32api, win32.winnt;

// FIXME:
alias void va_list;


/+
//--------------------------------------
// These functions are problematic

version(UseNtoSKernel) {}else {
	/* CAREFUL: These are exported from ntoskrnl.exe and declared in winddk.h
	   as __fastcall functions, but are  exported from kernel32.dll as __stdcall */
	static if (_WIN32_WINNT >= 0x0501) {
	 VOID InitializeSListHead(PSLIST_HEADER);
	}
	LONG InterlockedCompareExchange(LPLONG, LONG, LONG);
	// PVOID WINAPI InterlockedCompareExchangePointer(PVOID*, PVOID, PVOID);
	(PVOID)InterlockedCompareExchange((LPLONG)(d)    (PVOID)InterlockedCompareExchange((LPLONG)(d), (LONG)(e), (LONG)(c))
	LONG InterlockedDecrement(LPLONG);
	LONG InterlockedExchange(LPLONG, LONG);
	// PVOID WINAPI InterlockedExchangePointer(PVOID*, PVOID);
	(PVOID)InterlockedExchange((LPLONG)((PVOID)InterlockedExchange((LPLONG)(t), (LONG)(v))
	LONG InterlockedExchangeAdd(LPLONG, LONG);

	static if (_WIN32_WINNT >= 0x0501) {
	PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER);
	}
	LONG InterlockedIncrement(LPLONG);
	static if (_WIN32_WINNT >= 0x0501) {
	PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER);
	PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER, PSLIST_ENTRY);
	}
} // #endif //  __USE_NTOSKRNL__
//--------------------------------------
+/

// COMMPROP structure, used by GetCommProperties()
// -----------------------------------------------

// Communications provider type
enum : DWORD {
	PST_UNSPECIFIED,
	PST_RS232,
	PST_PARALLELPORT,
	PST_RS422,
	PST_RS423,
	PST_RS449,
	PST_MODEM,      // =      6
	PST_FAX            = 0x0021,
	PST_SCANNER        = 0x0022,
	PST_NETWORK_BRIDGE = 0x0100,
	PST_LAT            = 0x0101,
	PST_TCPIP_TELNET   = 0x0102,
	PST_X25            = 0x0103
}

// Max baud rate
enum : DWORD {
	BAUD_075    = 0x00000001,
	BAUD_110    = 0x00000002,
	BAUD_134_5  = 0x00000004,
	BAUD_150    = 0x00000008,
	BAUD_300    = 0x00000010,
	BAUD_600    = 0x00000020,
	BAUD_1200   = 0x00000040,
	BAUD_1800   = 0x00000080,
	BAUD_2400   = 0x00000100,
	BAUD_4800   = 0x00000200,
	BAUD_7200   = 0x00000400,
	BAUD_9600   = 0x00000800,
	BAUD_14400  = 0x00001000,
	BAUD_19200  = 0x00002000,
	BAUD_38400  = 0x00004000,
	BAUD_56K    = 0x00008000,
	BAUD_128K   = 0x00010000,
	BAUD_115200 = 0x00020000,
	BAUD_57600  = 0x00040000,
	BAUD_USER   = 0x10000000
}

// Comm capabilities
enum : DWORD {
	PCF_DTRDSR        = 0x0001,
	PCF_RTSCTS        = 0x0002,
	PCF_RLSD          = 0x0004,
	PCF_PARITY_CHECK  = 0x0008,
	PCF_XONXOFF       = 0x0010,
	PCF_SETXCHAR      = 0x0020,
	PCF_TOTALTIMEOUTS = 0x0040,
	PCF_INTTIMEOUTS   = 0x0080,
	PCF_SPECIALCHARS  = 0x0100,
	PCF_16BITMODE     = 0x0200
}

enum  : DWORD {
	SP_PARITY       = 1,
	SP_BAUD         = 2,
	SP_DATABITS     = 4,
	SP_STOPBITS     = 8,
	SP_HANDSHAKING  = 16,
	SP_PARITY_CHECK = 32,
	SP_RLSD         = 64
}

enum : DWORD {
	DATABITS_5   = 1,
	DATABITS_6   = 2,
	DATABITS_7   = 4,
	DATABITS_8   = 8,
	DATABITS_16  = 16,
	DATABITS_16X = 32
}

enum : WORD {
	STOPBITS_10  = 0x0001,
	STOPBITS_15  = 0x0002,
	STOPBITS_20  = 0x0004,
	PARITY_NONE  = 0x0100,
	PARITY_ODD   = 0x0200,
	PARITY_EVEN  = 0x0400,
	PARITY_MARK  = 0x0800,
	PARITY_SPACE = 0x1000
}

// used by dwServiceMask
const SP_SERIALCOMM = 1;

struct COMMPROP {
	WORD  wPacketLength;
	WORD  wPacketVersion;
	DWORD dwServiceMask;
	DWORD dwReserved1;
	DWORD dwMaxTxQueue;
	DWORD dwMaxRxQueue;
	DWORD dwMaxBaud;
	DWORD dwProvSubType;
	DWORD dwProvCapabilities;
	DWORD dwSettableParams;
	DWORD dwSettableBaud;
	WORD  wSettableData;
	WORD  wSettableStopParity;
	DWORD dwCurrentTxQueue;
	DWORD dwCurrentRxQueue;
	DWORD dwProvSpec1;
	DWORD dwProvSpec2;
	WCHAR _wcProvChar;

	WCHAR* wcProvChar() { return &_wcProvChar; }
}
alias COMMPROP* LPCOMMPROP;

// ----------

// for DEBUG_EVENT
enum : DWORD {
	EXCEPTION_DEBUG_EVENT = 1,
	CREATE_THREAD_DEBUG_EVENT,
	CREATE_PROCESS_DEBUG_EVENT,
	EXIT_THREAD_DEBUG_EVENT,
	EXIT_PROCESS_DEBUG_EVENT,
	LOAD_DLL_DEBUG_EVENT,
	UNLOAD_DLL_DEBUG_EVENT,
	OUTPUT_DEBUG_STRING_EVENT,
	RIP_EVENT
}

const HFILE HFILE_ERROR = cast(HFILE) (-1);

// for SetFilePointer()
enum : DWORD {
	FILE_BEGIN   = 0,
	FILE_CURRENT = 1,
	FILE_END     = 2
}
const DWORD INVALID_SET_FILE_POINTER = -1;


// for OpenFile()
deprecated enum : UINT {
	OF_READ             = 0,
	OF_WRITE            = 0x0001,
	OF_READWRITE        = 0x0002,
	OF_SHARE_COMPAT     = 0,
	OF_SHARE_EXCLUSIVE  = 0x0010,
	OF_SHARE_DENY_WRITE = 0x0020,
	OF_SHARE_DENY_READ  = 0x0030,
	OF_SHARE_DENY_NONE  = 0x0040,
	OF_PARSE            = 0x0100,
	OF_DELETE           = 0x0200,
	OF_VERIFY           = 0x0400,
	OF_CANCEL           = 0x0800,
	OF_CREATE           = 0x1000,
	OF_PROMPT           = 0x2000,
	OF_EXIST            = 0x4000,
	OF_REOPEN           = 0x8000
}

enum : DWORD {
	NMPWAIT_NOWAIT           =  1,
	NMPWAIT_WAIT_FOREVER     = -1,
	NMPWAIT_USE_DEFAULT_WAIT =  0
}

// for ClearCommError()
const DWORD
	CE_RXOVER   = 0x0001,
	CE_OVERRUN  = 0x0002,
	CE_RXPARITY = 0x0004,
	CE_FRAME    = 0x0008,
	CE_BREAK    = 0x0010,
	CE_TXFULL   = 0x0100,
	CE_PTO      = 0x0200,
	CE_IOE      = 0x0400,
	CE_DNS      = 0x0800,
	CE_OOP      = 0x1000,
	CE_MODE     = 0x8000;

// for CopyProgressRoutine callback.
enum : DWORD {
	PROGRESS_CONTINUE = 0,
	PROGRESS_CANCEL   = 1,
	PROGRESS_STOP     = 2,
	PROGRESS_QUIET    = 3
}

enum : DWORD {
	CALLBACK_CHUNK_FINISHED = 0,
	CALLBACK_STREAM_SWITCH  = 1
}

// CopyFileEx()
enum : DWORD {
	COPY_FILE_FAIL_IF_EXISTS = 1,
	COPY_FILE_RESTARTABLE    = 2
}

enum : DWORD {
	FILE_MAP_COPY       = 1,
	FILE_MAP_WRITE      = 2,
	FILE_MAP_READ       = 4,
	FILE_MAP_ALL_ACCESS = 0x000F001F
}

enum : DWORD {
	MUTEX_ALL_ACCESS       = 0x001f0001,
	MUTEX_MODIFY_STATE     = 0x00000001,
	SEMAPHORE_ALL_ACCESS   = 0x001f0003,
	SEMAPHORE_MODIFY_STATE = 0x00000002,
	EVENT_ALL_ACCESS       = 0x001f0003,
	EVENT_MODIFY_STATE     = 0x00000002
}

// CreateNamedPipe()
enum : DWORD {
	PIPE_ACCESS_INBOUND  = 1,
	PIPE_ACCESS_OUTBOUND = 2,
	PIPE_ACCESS_DUPLEX   = 3
}

const DWORD
	PIPE_TYPE_BYTE        = 0,
	PIPE_TYPE_MESSAGE     = 4,
	PIPE_READMODE_BYTE    = 0,
	PIPE_READMODE_MESSAGE = 2,
	PIPE_WAIT             = 0,
	PIPE_NOWAIT           = 1;

// GetNamedPipeInfo()
const DWORD
	PIPE_CLIENT_END  = 0,
	PIPE_SERVER_END  = 1;

const DWORD PIPE_UNLIMITED_INSTANCES = 255;

// dwCreationFlags for CreateProcess() and CreateProcessAsUser()
enum : DWORD {
	DEBUG_PROCESS               = 0x00000001,
	DEBUG_ONLY_THIS_PROCESS     = 0x00000002,
	CREATE_SUSPENDED            = 0x00000004,
	DETACHED_PROCESS            = 0x00000008,
	CREATE_NEW_CONSOLE          = 0x00000010,
	NORMAL_PRIORITY_CLASS       = 0x00000020,
	IDLE_PRIORITY_CLASS         = 0x00000040,
	HIGH_PRIORITY_CLASS         = 0x00000080,
	REALTIME_PRIORITY_CLASS     = 0x00000100,
	CREATE_NEW_PROCESS_GROUP    = 0x00000200,
	CREATE_UNICODE_ENVIRONMENT  = 0x00000400,
	CREATE_SEPARATE_WOW_VDM     = 0x00000800,
	CREATE_SHARED_WOW_VDM       = 0x00001000,
	CREATE_FORCEDOS             = 0x00002000,
	BELOW_NORMAL_PRIORITY_CLASS = 0x00004000,
	ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000,
	CREATE_BREAKAWAY_FROM_JOB   = 0x01000000,
	CREATE_WITH_USERPROFILE     = 0x02000000,
	CREATE_DEFAULT_ERROR_MODE   = 0x04000000,
	CREATE_NO_WINDOW            = 0x08000000,
	PROFILE_USER                = 0x10000000,
	PROFILE_KERNEL              = 0x20000000,
	PROFILE_SERVER              = 0x40000000
}

const DWORD CONSOLE_TEXTMODE_BUFFER = 1;

// CreateFile()
enum : DWORD {
	CREATE_NEW = 1,
	CREATE_ALWAYS,
	OPEN_EXISTING,
	OPEN_ALWAYS,
	TRUNCATE_EXISTING
}

// CreateFile()
const DWORD
	FILE_FLAG_WRITE_THROUGH      = 0x80000000,
	FILE_FLAG_OVERLAPPED         = 0x40000000,
	FILE_FLAG_NO_BUFFERING       = 0x20000000,
	FILE_FLAG_RANDOM_ACCESS      = 0x10000000,
	FILE_FLAG_SEQUENTIAL_SCAN    = 0x08000000,
	FILE_FLAG_DELETE_ON_CLOSE    = 0x04000000,
	FILE_FLAG_BACKUP_SEMANTICS   = 0x02000000,
	FILE_FLAG_POSIX_SEMANTICS    = 0x01000000,
	FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000,
	FILE_FLAG_OPEN_NO_RECALL     = 0x00100000;

static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) {
	const DWORD FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;
}

// for CreateFile()
const DWORD
	SECURITY_ANONYMOUS        = SECURITY_IMPERSONATION_LEVEL.SecurityAnonymous<<16,
	SECURITY_IDENTIFICATION   = SECURITY_IMPERSONATION_LEVEL.SecurityIdentification<<16,
	SECURITY_IMPERSONATION    = SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation<<16,
	SECURITY_DELEGATION       = SECURITY_IMPERSONATION_LEVEL.SecurityDelegation<<16,
	SECURITY_CONTEXT_TRACKING = 0x00040000,
	SECURITY_EFFECTIVE_ONLY   = 0x00080000,
	SECURITY_SQOS_PRESENT     = 0x00100000,
	SECURITY_VALID_SQOS_FLAGS = 0x001F0000;


// Thread exit code
const DWORD STILL_ACTIVE = 0x103;

/*	??? The only documentation of this seems to be about Windows CE and to
 *	state what _doesn't_ support it.
 */
const DWORD FIND_FIRST_EX_CASE_SENSITIVE = 1;

// GetBinaryType()
enum : DWORD {
	SCS_32BIT_BINARY = 0,
	SCS_DOS_BINARY,
	SCS_WOW_BINARY,
	SCS_PIF_BINARY,
	SCS_POSIX_BINARY,
	SCS_OS216_BINARY
}

const size_t
	MAX_COMPUTERNAME_LENGTH = 15,
	HW_PROFILE_GUIDLEN      = 39,
	MAX_PROFILE_LEN         = 80;

// HW_PROFILE_INFO
const DWORD
	DOCKINFO_UNDOCKED      = 1,
	DOCKINFO_DOCKED        = 2,
	DOCKINFO_USER_SUPPLIED = 4,
	DOCKINFO_USER_UNDOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED,
	DOCKINFO_USER_DOCKED   = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;

// DriveType(), RealDriveType()
enum : int {
	DRIVE_UNKNOWN = 0,
	DRIVE_NO_ROOT_DIR,
	DRIVE_REMOVABLE,
	DRIVE_FIXED,
	DRIVE_REMOTE,
	DRIVE_CDROM,
	DRIVE_RAMDISK
}

// GetFileType()
enum : DWORD {
	FILE_TYPE_UNKNOWN = 0,
	FILE_TYPE_DISK,
	FILE_TYPE_CHAR,
	FILE_TYPE_PIPE,
	FILE_TYPE_REMOTE = 0x8000
}

// Get/SetHandleInformation()
const DWORD
	HANDLE_FLAG_INHERIT            = 0x01,
	HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x02;

enum : DWORD {
	STD_INPUT_HANDLE  = 0xFFFFFFF6,
	STD_OUTPUT_HANDLE = 0xFFFFFFF5,
	STD_ERROR_HANDLE  = 0xFFFFFFF4
}

const HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1);

enum : DWORD {
	GET_TAPE_MEDIA_INFORMATION = 0,
	GET_TAPE_DRIVE_INFORMATION = 1
}

enum : DWORD {
	SET_TAPE_MEDIA_INFORMATION = 0,
	SET_TAPE_DRIVE_INFORMATION = 1
}

// SetThreadPriority()/GetThreadPriority()
enum : int {
	THREAD_PRIORITY_IDLE          = -15,
	THREAD_PRIORITY_LOWEST        =  -2,
	THREAD_PRIORITY_BELOW_NORMAL  =  -1,
	THREAD_PRIORITY_NORMAL        =   0,
	THREAD_PRIORITY_ABOVE_NORMAL  =   1,
	THREAD_PRIORITY_HIGHEST       =   2,
	THREAD_PRIORITY_TIME_CRITICAL =  15,
	THREAD_PRIORITY_ERROR_RETURN  = 2147483647
}

enum : DWORD {
	TIME_ZONE_ID_UNKNOWN,
	TIME_ZONE_ID_STANDARD,
	TIME_ZONE_ID_DAYLIGHT,
	TIME_ZONE_ID_INVALID = 0xFFFFFFFF
}

const DWORD
	FS_CASE_SENSITIVE         =     1,
	FS_CASE_IS_PRESERVED      =     2,
	FS_UNICODE_STORED_ON_DISK =     4,
	FS_PERSISTENT_ACLS        =     8,
	FS_FILE_COMPRESSION       =    16,
	FS_VOL_IS_COMPRESSED      = 32768;

// Flags for GlobalAlloc
const UINT
	GMEM_FIXED       = 0,
	GMEM_MOVEABLE    = 0x0002,
	GMEM_ZEROINIT    = 0x0040,
	GPTR             = 0x0040,
	GHND             = 0x0042,
	GMEM_MODIFY      = 0x0080,  // used only for GlobalRealloc
	GMEM_VALID_FLAGS = 0x7F72;

/+  // Obselete flags (Win16 only)
	GMEM_NOCOMPACT=16;
	GMEM_NODISCARD=32;
	GMEM_DISCARDABLE=256;
	GMEM_NOT_BANKED=4096;
	GMEM_LOWER=4096;
	GMEM_SHARE=8192;
	GMEM_DDESHARE=8192;

	GMEM_LOCKCOUNT=255;

// for GlobalFlags()
	GMEM_DISCARDED      = 16384;
	GMEM_INVALID_HANDLE = 32768;

	GMEM_NOTIFY         = 16384;
+/

const UINT
	LMEM_FIXED          = 0,
	LMEM_MOVEABLE       = 0x0002,
	LMEM_NONZEROLPTR    = 0,
	NONZEROLPTR         = 0,
	LMEM_NONZEROLHND    = 0x0002,
	NONZEROLHND         = 0x0002,
	LMEM_DISCARDABLE    = 0x0F00,
	LMEM_NOCOMPACT      = 0x0010,
	LMEM_NODISCARD      = 0x0020,
	LMEM_ZEROINIT       = 0x0040,
	LPTR                = 0x0040,
	LHND                = 0x0042,
	LMEM_MODIFY         = 0x0080,
	LMEM_LOCKCOUNT      = 0x00FF,
	LMEM_DISCARDED      = 0x4000,
	LMEM_INVALID_HANDLE = 0x8000;



// used in EXCEPTION_RECORD
enum : DWORD {
	STATUS_WAIT_0                      = 0,
	STATUS_ABANDONED_WAIT_0            = 0x00000080,
	STATUS_USER_APC                    = 0x000000C0,
	STATUS_TIMEOUT                     = 0x00000102,
	STATUS_PENDING                     = 0x00000103,

	STATUS_SEGMENT_NOTIFICATION        = 0x40000005,
	STATUS_GUARD_PAGE_VIOLATION        = 0x80000001,
	STATUS_DATATYPE_MISALIGNMENT       = 0x80000002,
	STATUS_BREAKPOINT                  = 0x80000003,
	STATUS_SINGLE_STEP                 = 0x80000004,

	STATUS_ACCESS_VIOLATION            = 0xC0000005,
	STATUS_IN_PAGE_ERROR               = 0xC0000006,
	STATUS_INVALID_HANDLE              = 0xC0000008,

	STATUS_NO_MEMORY                   = 0xC0000017,
	STATUS_ILLEGAL_INSTRUCTION         = 0xC000001D,
	STATUS_NONCONTINUABLE_EXCEPTION    = 0xC0000025,
	STATUS_INVALID_DISPOSITION         = 0xC0000026,
	STATUS_ARRAY_BOUNDS_EXCEEDED       = 0xC000008C,
	STATUS_FLOAT_DENORMAL_OPERAND      = 0xC000008D,
	STATUS_FLOAT_DIVIDE_BY_ZERO        = 0xC000008E,
	STATUS_FLOAT_INEXACT_RESULT        = 0xC000008F,
	STATUS_FLOAT_INVALID_OPERATION     = 0xC0000090,
	STATUS_FLOAT_OVERFLOW              = 0xC0000091,
	STATUS_FLOAT_STACK_CHECK           = 0xC0000092,
	STATUS_FLOAT_UNDERFLOW             = 0xC0000093,
	STATUS_INTEGER_DIVIDE_BY_ZERO      = 0xC0000094,
	STATUS_INTEGER_OVERFLOW            = 0xC0000095,
	STATUS_PRIVILEGED_INSTRUCTION      = 0xC0000096,
	STATUS_STACK_OVERFLOW              = 0xC00000FD,
	STATUS_CONTROL_C_EXIT              = 0xC000013A,
	STATUS_DLL_INIT_FAILED             = 0xC0000142,
	STATUS_DLL_INIT_FAILED_LOGOFF      = 0xC000026B,

	CONTROL_C_EXIT                     = STATUS_CONTROL_C_EXIT,

	EXCEPTION_ACCESS_VIOLATION         = STATUS_ACCESS_VIOLATION,
	EXCEPTION_DATATYPE_MISALIGNMENT    = STATUS_DATATYPE_MISALIGNMENT,
	EXCEPTION_BREAKPOINT               = STATUS_BREAKPOINT,
	EXCEPTION_SINGLE_STEP              = STATUS_SINGLE_STEP,
	EXCEPTION_ARRAY_BOUNDS_EXCEEDED    = STATUS_ARRAY_BOUNDS_EXCEEDED,
	EXCEPTION_FLT_DENORMAL_OPERAND     = STATUS_FLOAT_DENORMAL_OPERAND,
	EXCEPTION_FLT_DIVIDE_BY_ZERO       = STATUS_FLOAT_DIVIDE_BY_ZERO,
	EXCEPTION_FLT_INEXACT_RESULT       = STATUS_FLOAT_INEXACT_RESULT,
	EXCEPTION_FLT_INVALID_OPERATION    = STATUS_FLOAT_INVALID_OPERATION,
	EXCEPTION_FLT_OVERFLOW             = STATUS_FLOAT_OVERFLOW,
	EXCEPTION_FLT_STACK_CHECK          = STATUS_FLOAT_STACK_CHECK,
	EXCEPTION_FLT_UNDERFLOW            = STATUS_FLOAT_UNDERFLOW,
	EXCEPTION_INT_DIVIDE_BY_ZERO       = STATUS_INTEGER_DIVIDE_BY_ZERO,
	EXCEPTION_INT_OVERFLOW             = STATUS_INTEGER_OVERFLOW,
	EXCEPTION_PRIV_INSTRUCTION         = STATUS_PRIVILEGED_INSTRUCTION,
	EXCEPTION_IN_PAGE_ERROR            = STATUS_IN_PAGE_ERROR,
	EXCEPTION_ILLEGAL_INSTRUCTION      = STATUS_ILLEGAL_INSTRUCTION,
	EXCEPTION_NONCONTINUABLE_EXCEPTION = STATUS_NONCONTINUABLE_EXCEPTION,
	EXCEPTION_STACK_OVERFLOW           = STATUS_STACK_OVERFLOW,
	EXCEPTION_INVALID_DISPOSITION      = STATUS_INVALID_DISPOSITION,
	EXCEPTION_GUARD_PAGE               = STATUS_GUARD_PAGE_VIOLATION,
	EXCEPTION_INVALID_HANDLE           = STATUS_INVALID_HANDLE
}

// for PROCESS_HEAP_ENTRY
const WORD
	PROCESS_HEAP_REGION            =  1,
	PROCESS_HEAP_UNCOMMITTED_RANGE =  2,
	PROCESS_HEAP_ENTRY_BUSY        =  4,
	PROCESS_HEAP_ENTRY_MOVEABLE    = 16,
	PROCESS_HEAP_ENTRY_DDESHARE    = 32;

// for LoadLibraryEx()
const DWORD
	DONT_RESOLVE_DLL_REFERENCES   = 0x01, // not for WinME and earlier
	LOAD_LIBRARY_AS_DATAFILE      = 0x02,
	LOAD_WITH_ALTERED_SEARCH_PATH = 0x08,
	LOAD_IGNORE_CODE_AUTHZ_LEVEL  = 0x10; // only for XP and later

// for LockFile()
const DWORD
	LOCKFILE_FAIL_IMMEDIATELY = 1,
	LOCKFILE_EXCLUSIVE_LOCK   = 2;

const MAXIMUM_WAIT_OBJECTS  = 64;
const MAXIMUM_SUSPEND_COUNT = 0x7F;

const WAIT_OBJECT_0    = 0;
const WAIT_ABANDONED_0 = 128;

//const WAIT_TIMEOUT=258;  // also in winerror.h

enum : DWORD {
	WAIT_IO_COMPLETION = 0x000000C0,
	WAIT_ABANDONED     = 0x00000080,
	WAIT_FAILED        = 0xFFFFFFFF
}

// PurgeComm()
const DWORD
	PURGE_TXABORT = 1,
	PURGE_RXABORT = 2,
	PURGE_TXCLEAR = 4,
	PURGE_RXCLEAR = 8;

// ReadEventLog()
const DWORD
	EVENTLOG_SEQUENTIAL_READ = 1,
	EVENTLOG_SEEK_READ       = 2,
	EVENTLOG_FORWARDS_READ   = 4,
	EVENTLOG_BACKWARDS_READ  = 8;

// ReportEvent()
enum : WORD {
	EVENTLOG_SUCCESS          = 0,
	EVENTLOG_ERROR_TYPE       = 1,
	EVENTLOG_WARNING_TYPE     = 2,
	EVENTLOG_INFORMATION_TYPE = 4,
	EVENTLOG_AUDIT_SUCCESS    = 8,
	EVENTLOG_AUDIT_FAILURE    = 16
}

// FormatMessage()
const DWORD
	FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x0100,
	FORMAT_MESSAGE_IGNORE_INSERTS  = 0x0200,
	FORMAT_MESSAGE_FROM_STRING     = 0x0400,
	FORMAT_MESSAGE_FROM_HMODULE    = 0x0800,
	FORMAT_MESSAGE_FROM_SYSTEM     = 0x1000,
	FORMAT_MESSAGE_ARGUMENT_ARRAY  = 0x2000;

const DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK = 255;

// also in ddk/ntapi.h
// To restore default error mode, call SetErrorMode(0)
enum {
	SEM_FAILCRITICALERRORS     = 0x0001,
	SEM_NOGPFAULTERRORBOX      = 0x0002,
	SEM_NOALIGNMENTFAULTEXCEPT = 0x0004,
	SEM_NOOPENFILEERRORBOX     = 0x8000
}
// end ntapi.h

enum {
	SLE_ERROR = 1,
	SLE_MINORERROR,
	SLE_WARNING
}

const SHUTDOWN_NORETRY = 1;

// Return type for exception filters.
enum : LONG {
	EXCEPTION_EXECUTE_HANDLER    =  1,
	EXCEPTION_CONTINUE_EXECUTION = -1,
	EXCEPTION_CONTINUE_SEARCH    =  0
}

enum  : ATOM {
	MAXINTATOM   = 0xC000,
	INVALID_ATOM = 0
}

const IGNORE   = 0;
const INFINITE = 0xFFFFFFFF;

// EscapeCommFunction()
enum {
	SETXOFF    = 1,
	SETXON,
	SETRTS,
	CLRRTS,
	SETDTR,
	CLRDTR, // = 6
	SETBREAK   = 8,
	CLRBREAK   = 9
}


// for SetCommMask()
const DWORD
	EV_RXCHAR   = 0x0001,
	EV_RXFLAG   = 0x0002,
	EV_TXEMPTY  = 0x0004,
	EV_CTS      = 0x0008,
	EV_DSR      = 0x0010,
	EV_RLSD     = 0x0020,
	EV_BREAK    = 0x0040,
	EV_ERR      = 0x0080,
	EV_RING     = 0x0100,
	EV_PERR     = 0x0200,
	EV_RX80FULL = 0x0400,
	EV_EVENT1   = 0x0800,
	EV_EVENT2   = 0x1000;

// GetCommModemStatus()
const DWORD
	MS_CTS_ON  = 0x0010,
	MS_DSR_ON  = 0x0020,
	MS_RING_ON = 0x0040,
	MS_RLSD_ON = 0x0080;


// DCB
enum : BYTE {
	NOPARITY = 0,
	ODDPARITY,
	EVENPARITY,
	MARKPARITY,
	SPACEPARITY
}
// DCB
enum : BYTE {
	ONESTOPBIT = 0,
	ONE5STOPBITS,
	TWOSTOPBITS
}
// DCB
enum : DWORD {
	CBR_110    =    110,
	CBR_300    =    300,
	CBR_600    =    600,
	CBR_1200   =   1200,
	CBR_2400   =   2400,
	CBR_4800   =   4800,
	CBR_9600   =   9600,
	CBR_14400  =  14400,
	CBR_19200  =  19200,
	CBR_38400  =  38400,
	CBR_56000  =  56000,
	CBR_57600  =  57600,
	CBR_115200 = 115200,
	CBR_128000 = 128000,
	CBR_256000 = 256000
}
// DCB, 2-bit bitfield
enum {
	DTR_CONTROL_DISABLE = 0,
	DTR_CONTROL_ENABLE,
	DTR_CONTROL_HANDSHAKE
}

// DCB, 2-bit bitfield
enum {
	RTS_CONTROL_DISABLE = 0,
	RTS_CONTROL_ENABLE,
	RTS_CONTROL_HANDSHAKE,
	RTS_CONTROL_TOGGLE,
}

// WIN32_STREAM_ID
enum : DWORD {
	BACKUP_INVALID = 0,
	BACKUP_DATA,
	BACKUP_EA_DATA,
	BACKUP_SECURITY_DATA,
	BACKUP_ALTERNATE_DATA,
	BACKUP_LINK,
	BACKUP_PROPERTY_DATA,
	BACKUP_OBJECT_ID,
	BACKUP_REPARSE_DATA,
	BACKUP_SPARSE_BLOCK
}

// WIN32_STREAM_ID
enum : DWORD {
	STREAM_NORMAL_ATTRIBUTE    = 0,
	STREAM_MODIFIED_WHEN_READ  = 1,
	STREAM_CONTAINS_SECURITY   = 2,
	STREAM_CONTAINS_PROPERTIES = 4
}

// STARTUPINFO
const DWORD
	STARTF_USESHOWWINDOW    = 0x0001,
	STARTF_USESIZE          = 0x0002,
	STARTF_USEPOSITION      = 0x0004,
	STARTF_USECOUNTCHARS    = 0x0008,
	STARTF_USEFILLATTRIBUTE = 0x0010,
	STARTF_RUNFULLSCREEN    = 0x0020,
	STARTF_FORCEONFEEDBACK  = 0x0040,
	STARTF_FORCEOFFFEEDBACK = 0x0080,
	STARTF_USESTDHANDLES    = 0x0100,
	STARTF_USEHOTKEY        = 0x0200;

// ???
enum {
	TC_NORMAL  = 0,
	TC_HARDERR = 1,
	TC_GP_TRAP = 2,
	TC_SIGNAL  = 3
}

/+ These seem to be Windows CE-specific
enum {
	AC_LINE_OFFLINE      = 0,
	AC_LINE_ONLINE       = 1,
	AC_LINE_BACKUP_POWER = 2,
	AC_LINE_UNKNOWN      = 255
}

enum {
	BATTERY_FLAG_HIGH          = 1,
	BATTERY_FLAG_LOW           = 2,
	BATTERY_FLAG_CRITICAL      = 4,
	BATTERY_FLAG_CHARGING      = 8,
	BATTERY_FLAG_NO_BATTERY    = 128,
	BATTERY_FLAG_UNKNOWN       = 255,
	BATTERY_PERCENTAGE_UNKNOWN = 255,
	BATTERY_LIFE_UNKNOWN       = 0xFFFFFFFF
}
+/

// ???
const HINSTANCE_ERROR = 32;

// returned from GetFileSize()
const DWORD INVALID_FILE_SIZE = 0xFFFFFFFF;

const DWORD TLS_OUT_OF_INDEXES = 0xFFFFFFFF;

// GetWriteWatch()
const DWORD WRITE_WATCH_FLAG_RESET = 1;

static if (_WIN32_WINNT_ONLY) {
	// for LogonUser()
	enum : DWORD {
		LOGON32_LOGON_INTERACTIVE = 2,
		LOGON32_LOGON_NETWORK     = 3,
		LOGON32_LOGON_BATCH       = 4,
		LOGON32_LOGON_SERVICE     = 5,
		LOGON32_LOGON_UNLOCK      = 7
	}

	// for LogonUser()
	enum : DWORD {
		LOGON32_PROVIDER_DEFAULT,
		LOGON32_PROVIDER_WINNT35,
		LOGON32_PROVIDER_WINNT40,
		LOGON32_PROVIDER_WINNT50
	}

	// for MoveFileEx()
	const DWORD
		MOVEFILE_REPLACE_EXISTING   = 1,
		MOVEFILE_COPY_ALLOWED       = 2,
		MOVEFILE_DELAY_UNTIL_REBOOT = 4,
		MOVEFILE_WRITE_THROUGH      = 8;

	// DefineDosDevice()
	const DWORD
		DDD_RAW_TARGET_PATH       = 1,
		DDD_REMOVE_DEFINITION     = 2,
		DDD_EXACT_MATCH_ON_REMOVE = 4;

	static if (_WIN32_WINNT >= 0x500) {
		enum : DWORD {
			LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
			LOGON32_LOGON_NEW_CREDENTIALS   = 9
		}

		// ReplaceFile()
		const DWORD
			REPLACEFILE_WRITE_THROUGH       = 1,
			REPLACEFILE_IGNORE_MERGE_ERRORS = 2;
	}

	static if (_WIN32_WINNT >= 0x501) {
		const DWORD
			GET_MODULE_HANDLE_EX_FLAG_PIN                = 1,
			GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2,
			GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS       = 4;

		// for ACTCTX
		const DWORD
			ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01,
			ACTCTX_FLAG_LANGID_VALID                 = 0x02,
			ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID     = 0x04,
			ACTCTX_FLAG_RESOURCE_NAME_VALID          = 0x08,
			ACTCTX_FLAG_SET_PROCESS_DEFAULT          = 0x10,
			ACTCTX_FLAG_APPLICATION_NAME_VALID       = 0x20,
			ACTCTX_FLAG_HMODULE_VALID                = 0x80;

		// DeactivateActCtx()
		const DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1;
		// FindActCtxSectionString()
		const DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX          = 1;
		// QueryActCtxW()
		const DWORD
			QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX             = 0x04,
			QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE             = 0x08,
			QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS             = 0x10;

		enum {
			LOGON_WITH_PROFILE        = 1,
			LOGON_NETCREDENTIALS_ONLY
		}
	}
}

// ----

struct FILETIME {
	DWORD dwLowDateTime;
	DWORD dwHighDateTime;
}
alias FILETIME* PFILETIME, LPFILETIME;

struct BY_HANDLE_FILE_INFORMATION {
	DWORD    dwFileAttributes;
	FILETIME ftCreationTime;
	FILETIME ftLastAccessTime;
	FILETIME ftLastWriteTime;
	DWORD    dwVolumeSerialNumber;
	DWORD    nFileSizeHigh;
	DWORD    nFileSizeLow;
	DWORD    nNumberOfLinks;
	DWORD    nFileIndexHigh;
	DWORD    nFileIndexLow;
}
alias BY_HANDLE_FILE_INFORMATION* LPBY_HANDLE_FILE_INFORMATION;

struct DCB {
	DWORD DCBlength = DCB.sizeof;
	DWORD BaudRate;
/+
	DWORD fBinary:1;              // Binary Mode (skip EOF check)
	DWORD fParity:1;              // Enable parity checking
	DWORD fOutxCtsFlow:1;         // CTS handshaking on output
	DWORD fOutxDsrFlow:1;         // DSR handshaking on output
	DWORD fDtrControl:2;          // DTR Flow control
	DWORD fDsrSensitivity:1;      // DSR Sensitivity
	DWORD fTXContinueOnXoff:1;    // Continue TX when Xoff sent
	DWORD fOutX:1;                // Enable output X-ON/X-OFF
	DWORD fInX:1;                 // Enable input X-ON/X-OFF
	DWORD fErrorChar:1;           // Enable Err Replacement
	DWORD fNull:1;                // Enable Null stripping
	DWORD fRtsControl:2;          // Rts Flow control
	DWORD fAbortOnError:1;        // Abort all reads and writes on Error
	DWORD fDummy2:17;             // Reserved
+/
	uint _bf;
	bool fBinary(bool f)           { _bf = (_bf & ~0x0001) | f; return f; }
	bool fParity(bool f)           { _bf = (_bf & ~0x0002) | (f<<1); return f; }
	bool fOutxCtsFlow(bool f)      { _bf = (_bf & ~0x0004) | (f<<2); return f; }
	bool fOutxDsrFlow(bool f)      { _bf = (_bf & ~0x0008) | (f<<3); return f; }
	byte fDtrControl(byte x)       { _bf = (_bf & ~0x0030) | (x<<4); return cast(byte)(x & 3); }
	bool fDsrSensitivity(bool f)   { _bf = (_bf & ~0x0040) | (f<<6); return f; }
	bool fTXContinueOnXoff(bool f) { _bf = (_bf & ~0x0080) | (f<<7); return f; }
	bool fOutX(bool f)             { _bf = (_bf & ~0x0100) | (f<<8); return f; }
	bool fInX(bool f)              { _bf = (_bf & ~0x0200) | (f<<9); return f; }
	bool fErrorChar(bool f)        { _bf = (_bf & ~0x0400) | (f<<10); return f; }
	bool fNull(bool f)             { _bf = (_bf & ~0x0800) | (f<<11); return f; }
	byte fRtsControl(byte x)       { _bf = (_bf & ~0x3000) | (x<<12); return cast(byte)(x & 3); }
	bool fAbortOnError(bool f)     { _bf = (_bf & ~0x4000) | (f<<14); return f; }

	bool fBinary()           { return cast(bool) (_bf & 1); }
	bool fParity()           { return cast(bool) (_bf & 2); }
	bool fOutxCtsFlow()      { return cast(bool) (_bf & 4); }
	bool fOutxDsrFlow()      { return cast(bool) (_bf & 8); }
	byte fDtrControl()       { return cast(byte) ((_bf & (32+16))>>4); }
	bool fDsrSensitivity()   { return cast(bool) (_bf & 64); }
	bool fTXContinueOnXoff() { return cast(bool) (_bf & 128); }
	bool fOutX()             { return cast(bool) (_bf & 256); }
	bool fInX()              { return cast(bool) (_bf & 512); }
	bool fErrorChar()        { return cast(bool) (_bf & 1024); }
	bool fNull()             { return cast(bool) (_bf & 2048); }
	byte fRtsControl()       { return cast(byte) ((_bf & (4096+8192))>>12); }
	bool fAbortOnError()     { return cast(bool) (_bf & 16384); }

	WORD wReserved;
	WORD XonLim;
	WORD XoffLim;
	BYTE ByteSize;
	BYTE Parity;
	BYTE StopBits;
	char XonChar;
	char XoffChar;
	char ErrorChar;
	char EofChar;
	char EvtChar;
	WORD wReserved1;
}
alias DCB* LPDCB;

struct COMMCONFIG {
	DWORD dwSize = COMMCONFIG.sizeof;
	WORD  wVersion;
	WORD  wReserved;
	DCB   dcb;
	DWORD dwProviderSubType;
	DWORD dwProviderOffset;
	DWORD dwProviderSize;
	WCHAR _wcProviderData;

	WCHAR* wcProviderData() { return &_wcProviderData; }
}
alias COMMCONFIG* LPCOMMCONFIG;

struct COMMTIMEOUTS {
	DWORD ReadIntervalTimeout;
	DWORD ReadTotalTimeoutMultiplier;
	DWORD ReadTotalTimeoutConstant;
	DWORD WriteTotalTimeoutMultiplier;
	DWORD WriteTotalTimeoutConstant;
}
alias COMMTIMEOUTS* LPCOMMTIMEOUTS;

struct COMSTAT {
/+
	DWORD fCtsHold:1;
	DWORD fDsrHold:1;
	DWORD fRlsdHold:1;
	DWORD fXoffHold:1;
	DWORD fXoffSent:1;
	DWORD fEof:1;
	DWORD fTxim:1;
	DWORD fReserved:25;
+/
	DWORD _bf;
    bool fCtsHold(bool f)  { _bf = (_bf & ~1) | f; return f; }
	bool fDsrHold(bool f)  { _bf = (_bf & ~2) | (f<<1); return f; }
	bool fRlsdHold(bool f) { _bf = (_bf & ~4) | (f<<2); return f; }
	bool fXoffHold(bool f) { _bf = (_bf & ~8) | (f<<3); return f; }
	bool fXoffSent(bool f) { _bf = (_bf & ~16) | (f<<4); return f; }
	bool fEof(bool f)      { _bf = (_bf & ~32) | (f<<5); return f; }
	bool fTxim(bool f)     { _bf = (_bf & ~64) | (f<<6); return f; }

    bool fCtsHold()  { return cast(bool) (_bf & 1); }
	bool fDsrHold()  { return cast(bool) (_bf & 2); }
	bool fRlsdHold() { return cast(bool) (_bf & 4); }
	bool fXoffHold() { return cast(bool) (_bf & 8); }
	bool fXoffSent() { return cast(bool) (_bf & 16); }
	bool fEof()      { return cast(bool) (_bf & 32); }
	bool fTxim()     { return cast(bool) (_bf & 64); }

	DWORD cbInQue;
	DWORD cbOutQue;
}
alias COMSTAT* LPCOMSTAT;

struct CREATE_PROCESS_DEBUG_INFO {
	HANDLE hFile;
	HANDLE hProcess;
	HANDLE hThread;
	LPVOID lpBaseOfImage;
	DWORD  dwDebugInfoFileOffset;
	DWORD  nDebugInfoSize;
	LPVOID lpThreadLocalBase;
	LPTHREAD_START_ROUTINE lpStartAddress;
	LPVOID lpImageName;
	WORD   fUnicode;
}
alias CREATE_PROCESS_DEBUG_INFO* LPCREATE_PROCESS_DEBUG_INFO;

struct CREATE_THREAD_DEBUG_INFO {
	HANDLE hThread;
	LPVOID lpThreadLocalBase;
	LPTHREAD_START_ROUTINE lpStartAddress;
}
alias CREATE_THREAD_DEBUG_INFO* LPCREATE_THREAD_DEBUG_INFO;

struct EXCEPTION_DEBUG_INFO {
	EXCEPTION_RECORD ExceptionRecord;
	DWORD            dwFirstChance;
}
alias EXCEPTION_DEBUG_INFO* LPEXCEPTION_DEBUG_INFO;

struct EXIT_THREAD_DEBUG_INFO {
	DWORD dwExitCode;
}
alias EXIT_THREAD_DEBUG_INFO* LPEXIT_THREAD_DEBUG_INFO;

struct EXIT_PROCESS_DEBUG_INFO {
	DWORD dwExitCode;
}
alias EXIT_PROCESS_DEBUG_INFO* LPEXIT_PROCESS_DEBUG_INFO;

struct LOAD_DLL_DEBUG_INFO {
	HANDLE hFile;
	LPVOID lpBaseOfDll;
	DWORD  dwDebugInfoFileOffset;
	DWORD  nDebugInfoSize;
	LPVOID lpImageName;
	WORD   fUnicode;
}
alias LOAD_DLL_DEBUG_INFO* LPLOAD_DLL_DEBUG_INFO;

struct UNLOAD_DLL_DEBUG_INFO {
	LPVOID lpBaseOfDll;
}
alias UNLOAD_DLL_DEBUG_INFO* LPUNLOAD_DLL_DEBUG_INFO;

struct OUTPUT_DEBUG_STRING_INFO {
	LPSTR lpDebugStringData;
	WORD  fUnicode;
	WORD  nDebugStringLength;
}
alias OUTPUT_DEBUG_STRING_INFO* LPOUTPUT_DEBUG_STRING_INFO;

struct RIP_INFO {
	DWORD dwError;
	DWORD dwType;
}
alias RIP_INFO* LPRIP_INFO;

struct DEBUG_EVENT {
	DWORD dwDebugEventCode;
	DWORD dwProcessId;
	DWORD dwThreadId;
	union {
		EXCEPTION_DEBUG_INFO      Exception;
		CREATE_THREAD_DEBUG_INFO  CreateThread;
		CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
		EXIT_THREAD_DEBUG_INFO    ExitThread;
		EXIT_PROCESS_DEBUG_INFO   ExitProcess;
		LOAD_DLL_DEBUG_INFO       LoadDll;
		UNLOAD_DLL_DEBUG_INFO     UnloadDll;
		OUTPUT_DEBUG_STRING_INFO  DebugString;
		RIP_INFO                  RipInfo;
	}
}
alias DEBUG_EVENT* LPDEBUG_EVENT;

struct OVERLAPPED {
	ULONG_PTR Internal;
	ULONG_PTR InternalHigh;
	union {
		struct {
			DWORD     Offset;
			DWORD     OffsetHigh;
		}
		PVOID     Pointer;
	}
	HANDLE    hEvent;
}
alias OVERLAPPED* POVERLAPPED, LPOVERLAPPED;

struct STARTUPINFOA {
	DWORD  cb = STARTUPINFOA.sizeof;
	LPSTR  lpReserved;
	LPSTR  lpDesktop;
	LPSTR  lpTitle;
	DWORD  dwX;
	DWORD  dwY;
	DWORD  dwXSize;
	DWORD  dwYSize;
	DWORD  dwXCountChars;
	DWORD  dwYCountChars;
	DWORD  dwFillAttribute;
	DWORD  dwFlags;
	WORD   wShowWindow;
	WORD   cbReserved2;
	PBYTE  lpReserved2;
	HANDLE hStdInput;
	HANDLE hStdOutput;
	HANDLE hStdError;
}
alias STARTUPINFOA* LPSTARTUPINFOA;

struct STARTUPINFOW {
	DWORD  cb = STARTUPINFOW.sizeof;
	LPWSTR lpReserved;
	LPWSTR lpDesktop;
	LPWSTR lpTitle;
	DWORD  dwX;
	DWORD  dwY;
	DWORD  dwXSize;
	DWORD  dwYSize;
	DWORD  dwXCountChars;
	DWORD  dwYCountChars;
	DWORD  dwFillAttribute;
	DWORD  dwFlags;
	WORD   wShowWindow;
	WORD   cbReserved2;
	PBYTE  lpReserved2;
	HANDLE hStdInput;
	HANDLE hStdOutput;
	HANDLE hStdError;
}
alias STARTUPINFOW* LPSTARTUPINFOW;

struct PROCESS_INFORMATION {
	HANDLE hProcess;
	HANDLE hThread;
	DWORD  dwProcessId;
	DWORD  dwThreadId;
}
alias PROCESS_INFORMATION* PPROCESS_INFORMATION, LPPROCESS_INFORMATION;

struct CRITICAL_SECTION_DEBUG {
	WORD              Type;
	WORD              CreatorBackTraceIndex;
	CRITICAL_SECTION* CriticalSection;
	LIST_ENTRY        ProcessLocksList;
	DWORD             EntryCount;
	DWORD             ContentionCount;
	DWORD[2]          Spare;
}
alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG;

struct CRITICAL_SECTION {
	PCRITICAL_SECTION_DEBUG DebugInfo;
	LONG   LockCount;
	LONG   RecursionCount;
	HANDLE OwningThread;
	HANDLE LockSemaphore;
	DWORD  SpinCount;
}
alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION;

struct SYSTEMTIME {
	WORD wYear;
	WORD wMonth;
	WORD wDayOfWeek;
	WORD wDay;
	WORD wHour;
	WORD wMinute;
	WORD wSecond;
	WORD wMilliseconds;
}
alias SYSTEMTIME* LPSYSTEMTIME;

static if (_WIN32_WINDOWS >= 0x410) {
	struct WIN32_FILE_ATTRIBUTE_DATA {
		DWORD    dwFileAttributes;
		FILETIME ftCreationTime;
		FILETIME ftLastAccessTime;
		FILETIME ftLastWriteTime;
		DWORD    nFileSizeHigh;
		DWORD    nFileSizeLow;
	}
	alias WIN32_FILE_ATTRIBUTE_DATA* LPWIN32_FILE_ATTRIBUTE_DATA;
}

struct WIN32_FIND_DATAA {
	DWORD          dwFileAttributes;
	FILETIME       ftCreationTime;
	FILETIME       ftLastAccessTime;
	FILETIME       ftLastWriteTime;
	DWORD          nFileSizeHigh;
	DWORD          nFileSizeLow;
// #ifdef _WIN32_WCE
//	DWORD dwOID;
// #else
	DWORD          dwReserved0;
	DWORD          dwReserved1;
// #endif
	CHAR[MAX_PATH] cFileName;
// #ifndef _WIN32_WCE
	CHAR[14]       cAlternateFileName;
// #endif
}
alias WIN32_FIND_DATAA* PWIN32_FIND_DATAA, LPWIN32_FIND_DATAA;

struct WIN32_FIND_DATAW {
	DWORD           dwFileAttributes;
	FILETIME        ftCreationTime;
	FILETIME        ftLastAccessTime;
	FILETIME        ftLastWriteTime;
	DWORD           nFileSizeHigh;
	DWORD           nFileSizeLow;
// #ifdef _WIN32_WCE
// 	DWORD dwOID;
// #else
	DWORD           dwReserved0;
	DWORD           dwReserved1;
// #endif
	WCHAR[MAX_PATH] cFileName;
// #ifndef _WIN32_WCE
	WCHAR[14]       cAlternateFileName;
// #endif
}
alias WIN32_FIND_DATAW* PWIN32_FIND_DATAW, LPWIN32_FIND_DATAW;

static if (_WIN32_WINNT_ONLY) {
	struct WIN32_STREAM_ID {
		DWORD         dwStreamId;
		DWORD         dwStreamAttributes;
		LARGE_INTEGER Size;
		DWORD         dwStreamNameSize;
		WCHAR         _cStreamName;

		WCHAR* cStreamName() { return &_cStreamName; }
	}
	alias WIN32_STREAM_ID* LPWIN32_STREAM_ID;

	enum FINDEX_INFO_LEVELS {
		FindExInfoStandard,
		FindExInfoMaxInfoLevel
	}

	enum FINDEX_SEARCH_OPS {
		FindExSearchNameMatch,
		FindExSearchLimitToDirectories,
		FindExSearchLimitToDevices,
		FindExSearchMaxSearchOp
	}

	enum ACL_INFORMATION_CLASS {
		AclRevisionInformation = 1,
		AclSizeInformation
	}

	struct HW_PROFILE_INFOA {
		DWORD dwDockInfo;
		CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid;
		CHAR[MAX_PROFILE_LEN]    szHwProfileName;
	}
	alias HW_PROFILE_INFOA* LPHW_PROFILE_INFOA;

	struct HW_PROFILE_INFOW {
		DWORD dwDockInfo;
		WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid;
		WCHAR[MAX_PROFILE_LEN]    szHwProfileName;
	}
	alias HW_PROFILE_INFOW* LPHW_PROFILE_INFOW;
}

/*	??? MSDN documents this only for Windows CE/Mobile, but it's used by
 *	GetFileAttributesEx, which is in desktop Windows.
 */
enum GET_FILEEX_INFO_LEVELS {
	GetFileExInfoStandard,
	GetFileExMaxInfoLevel
}

struct SYSTEM_INFO {
	union {
		DWORD dwOemId;
		struct {
			WORD wProcessorArchitecture;
			WORD wReserved;
		}
	}
	DWORD dwPageSize;
	PVOID lpMinimumApplicationAddress;
	PVOID lpMaximumApplicationAddress;
	DWORD dwActiveProcessorMask;
	DWORD dwNumberOfProcessors;
	DWORD dwProcessorType;
	DWORD dwAllocationGranularity;
	WORD  wProcessorLevel;
	WORD  wProcessorRevision;
}
alias SYSTEM_INFO* LPSYSTEM_INFO;

static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) {
	struct SYSTEM_POWER_STATUS {
		BYTE ACLineStatus;
		BYTE BatteryFlag;
		BYTE BatteryLifePercent;
		BYTE Reserved1;
		DWORD BatteryLifeTime;
		DWORD BatteryFullLifeTime;
	}
	alias SYSTEM_POWER_STATUS* LPSYSTEM_POWER_STATUS;
}

struct TIME_ZONE_INFORMATION {
	LONG       Bias;
	WCHAR[32]  StandardName;
	SYSTEMTIME StandardDate;
	LONG       StandardBias;
	WCHAR[32]  DaylightName;
	SYSTEMTIME DaylightDate;
	LONG       DaylightBias;
}
alias TIME_ZONE_INFORMATION* LPTIME_ZONE_INFORMATION;

// MSDN documents this, possibly erroneously, as Win2000+.
struct MEMORYSTATUS {
	DWORD dwLength;
	DWORD dwMemoryLoad;
	DWORD dwTotalPhys;
	DWORD dwAvailPhys;
	DWORD dwTotalPageFile;
	DWORD dwAvailPageFile;
	DWORD dwTotalVirtual;
	DWORD dwAvailVirtual;
}
alias MEMORYSTATUS* LPMEMORYSTATUS;

static if (_WIN32_WINNT >= 0x500) {
	struct MEMORYSTATUSEX {
		DWORD     dwLength;
		DWORD     dwMemoryLoad;
		DWORDLONG ullTotalPhys;
		DWORDLONG ullAvailPhys;
		DWORDLONG ullTotalPageFile;
		DWORDLONG ullAvailPageFile;
		DWORDLONG ullTotalVirtual;
		DWORDLONG ullAvailVirtual;
		DWORDLONG ullAvailExtendedVirtual;
	}
	alias MEMORYSTATUSEX* LPMEMORYSTATUSEX;
}

struct LDT_ENTRY {
	WORD LimitLow;
	WORD BaseLow;
	struct {
		BYTE BaseMid;
		BYTE Flags1;
		BYTE Flags2;
		BYTE BaseHi;

		byte Type(byte f)        { Flags1 = cast(BYTE) ((Flags1 & 0xE0) | f); return cast(byte)(f & 0x1F); }
		byte Dpl(byte f)         { Flags1 = cast(BYTE) ((Flags1 & 0x9F) | (f<<5)); return cast(byte)(f & 3); }
		bool Pres(bool f)        { Flags1 = cast(BYTE) ((Flags1 & 0x7F) | (f<<7)); return f; }

		byte LimitHi(byte f)     { Flags2 = cast(BYTE) ((Flags2 & 0xF0) | (f&0x0F)); return cast(byte)(f & 0x0F); }
		bool Sys(bool f)         { Flags2 = cast(BYTE) ((Flags2 & 0xEF) | (f<<4)); return f; }
		// Next bit is reserved
		bool Default_Big(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xBF) | (f<<6)); return f; }
		bool Granularity(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0x7F) | (f<<7)); return f; }

		byte Type()        { return cast(byte) (Flags1 & 0x1F); }
		byte Dpl()         { return cast(byte) ((Flags1 & 0x60)>>5); }
		bool Pres()        { return cast(bool) (Flags1 & 0x80); }

		byte LimitHi()     { return cast(byte) (Flags2 & 0x0F); }
		bool Sys()         { return cast(bool) (Flags2 & 0x10); }
		bool Default_Big() { return cast(bool) (Flags2 & 0x40); }
		bool Granularity() { return cast(bool) (Flags2 & 0x80); }
	}
/+
	union  HighWord {
		struct Bytes {
			BYTE BaseMid;
			BYTE Flags1;
			BYTE Flags2;
			BYTE BaseHi;
		}
	struct Bits {
		DWORD BaseMid:8;
		DWORD Type:5;
		DWORD Dpl:2;
		DWORD Pres:1;
		DWORD LimitHi:4;
		DWORD Sys:1;
		DWORD Reserved_0:1;
		DWORD Default_Big:1;
		DWORD Granularity:1;
		DWORD BaseHi:8;
	}
	}
+/
}
alias LDT_ENTRY* PLDT_ENTRY, LPLDT_ENTRY;

/*	As with the other memory management functions and structures, MSDN's
 *	Windows version info shall be taken with a cup of salt.
 */
struct PROCESS_HEAP_ENTRY {
	PVOID lpData;
	DWORD cbData;
	BYTE  cbOverhead;
	BYTE  iRegionIndex;
	WORD  wFlags;
	union {
		struct Block {
			HANDLE   hMem;
			DWORD[3] dwReserved;
		}
		struct Region {
			DWORD    dwCommittedSize;
			DWORD    dwUnCommittedSize;
			LPVOID   lpFirstBlock;
			LPVOID   lpLastBlock;
		}
	}
}
alias PROCESS_HEAP_ENTRY* LPPROCESS_HEAP_ENTRY;

struct OFSTRUCT {
	BYTE      cBytes = OFSTRUCT.sizeof;
	BYTE      fFixedDisk;
	WORD      nErrCode;
	WORD      Reserved1;
	WORD      Reserved2;
	CHAR[128] szPathName; // const OFS_MAXPATHNAME = 128;
}
alias OFSTRUCT* LPOFSTRUCT, POFSTRUCT;

/*	??? MSDN documents this only for Windows CE, but it's used by
 *	ImageGetCertificateData, which is in desktop Windows.
 */
struct WIN_CERTIFICATE {
	DWORD dwLength;
	WORD  wRevision;
	WORD  wCertificateType;
	BYTE  _bCertificate;

	BYTE* bCertificate() { return &_bCertificate; }
}
alias WIN_CERTIFICATE* LPWIN_CERTIFICATE;

static if (_WIN32_WINNT >= 0x500) {
	enum COMPUTER_NAME_FORMAT {
		ComputerNameNetBIOS,
		ComputerNameDnsHostname,
		ComputerNameDnsDomain,
		ComputerNameDnsFullyQualified,
		ComputerNamePhysicalNetBIOS,
		ComputerNamePhysicalDnsHostname,
		ComputerNamePhysicalDnsDomain,
		ComputerNamePhysicalDnsFullyQualified,
		ComputerNameMax
	}
}

static if (_WIN32_WINNT >= 0x501) {
	struct ACTCTXA {
		ULONG cbSize = this.sizeof;
		DWORD dwFlags;
		LPCSTR lpSource;
		USHORT wProcessorArchitecture;
		LANGID wLangId;
		LPCSTR lpAssemblyDirectory;
		LPCSTR lpResourceName;
		LPCSTR lpApplicationName;
		HMODULE hModule;
	}
	alias ACTCTXA* PACTCTXA, PCACTCTXA;

	struct ACTCTXW {
		ULONG cbSize = this.sizeof;
		DWORD dwFlags;
		LPCWSTR lpSource;
		USHORT wProcessorArchitecture;
		LANGID wLangId;
		LPCWSTR lpAssemblyDirectory;
		LPCWSTR lpResourceName;
		LPCWSTR lpApplicationName;
		HMODULE hModule;
	}
	alias ACTCTXW* PACTCTXW, PCACTCTXW;

	struct ACTCTX_SECTION_KEYED_DATA {
		ULONG cbSize = this.sizeof;
		ULONG ulDataFormatVersion;
		PVOID lpData;
		ULONG ulLength;
		PVOID lpSectionGlobalData;
		ULONG ulSectionGlobalDataLength;
		PVOID lpSectionBase;
		ULONG ulSectionTotalLength;
		HANDLE hActCtx;
		HANDLE ulAssemblyRosterIndex;
	}
	alias ACTCTX_SECTION_KEYED_DATA* PACTCTX_SECTION_KEYED_DATA, PCACTCTX_SECTION_KEYED_DATA;

	enum MEMORY_RESOURCE_NOTIFICATION_TYPE {
		LowMemoryResourceNotification,
		HighMemoryResourceNotification
	}

} // (_WIN32_WINNT >= 0x0501)

static if (WINVER >= 0x410) {
	/*	apparently used only by SetThreadExecutionState (Win2000+)
	 *	and DDK functions (version compatibility not established)
	 */
	alias DWORD EXECUTION_STATE;
}

// Callbacks
extern (Windows) {
	alias DWORD function(LPVOID) LPTHREAD_START_ROUTINE;
	alias DWORD function(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
		DWORD, DWORD, HANDLE, HANDLE, LPVOID)  LPPROGRESS_ROUTINE;
	alias void function(PVOID) LPFIBER_START_ROUTINE;

	alias BOOL function(HMODULE, LPCSTR, LPCSTR, WORD, LONG) ENUMRESLANGPROCA;
	alias BOOL function(HMODULE, LPCWSTR, LPCWSTR, WORD, LONG) ENUMRESLANGPROCW;
	alias BOOL function(HMODULE, LPCSTR, LPSTR, LONG) ENUMRESNAMEPROCA;
	alias BOOL function(HMODULE, LPCWSTR, LPWSTR, LONG) ENUMRESNAMEPROCW;
	alias BOOL function(HMODULE, LPSTR, LONG) ENUMRESTYPEPROCA;
	alias BOOL function(HMODULE, LPWSTR, LONG) ENUMRESTYPEPROCW;
	alias void function(DWORD, DWORD, LPOVERLAPPED) LPOVERLAPPED_COMPLETION_ROUTINE;
	alias LONG function(LPEXCEPTION_POINTERS) PTOP_LEVEL_EXCEPTION_FILTER;
	alias PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;

	alias void function(ULONG_PTR) PAPCFUNC;
	alias void function(PVOID, DWORD, DWORD) PTIMERAPCROUTINE;

	static if (_WIN32_WINNT_ONLY && _WIN32_WINNT >= 0x500) {
		alias void function(PVOID, BOOLEAN) WAITORTIMERCALLBACK;
	}
}

LPTSTR MAKEINTATOM(short i) {
	return cast(LPTSTR) i;
}

extern (Windows) {
	ATOM AddAtomA(LPCSTR);
	ATOM AddAtomW(LPCWSTR);
	BOOL AreFileApisANSI();
	BOOL Beep(DWORD, DWORD);
	HANDLE BeginUpdateResourceA(LPCSTR, BOOL);
	HANDLE BeginUpdateResourceW(LPCWSTR, BOOL);
	BOOL BuildCommDCBA(LPCSTR, LPDCB);
	BOOL BuildCommDCBW(LPCWSTR, LPDCB);
	BOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS);
	BOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS);
	BOOL CallNamedPipeA(LPCSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
	BOOL CallNamedPipeW(LPCWSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
	BOOL CancelDeviceWakeupRequest(HANDLE);
	BOOL CheckTokenMembership(HANDLE, PSID, PBOOL);
	BOOL ClearCommBreak(HANDLE);
	BOOL ClearCommError(HANDLE, PDWORD, LPCOMSTAT);
	BOOL CloseHandle(HANDLE);
	BOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG);
	BOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG);
	LONG CompareFileTime(FILETIME*, FILETIME*);
	BOOL ContinueDebugEvent(DWORD, DWORD, DWORD);
	BOOL CopyFileA(LPCSTR, LPCSTR, BOOL);
	BOOL CopyFileW(LPCWSTR, LPCWSTR, BOOL);
	BOOL CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
	BOOL CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);

	/+ FIXME
	alias memmove RtlMoveMemory;
	alias memcpy RtlCopyMemory;

	void RtlFillMemory(PVOID dest, SIZE_T len, BYTE fill) {
		memset(dest, fill, len);
	}

	void RtlZeroMemory(PVOID dest, SIZE_T len) {
		RtlFillMemory(dest, len , 0);
	}

	alias RtlMoveMemory MoveMemory;
	alias RtlCopyMemory CopyMemory;
	alias RtlFillMemory FillMemory;
	alias RtlZeroMemory ZeroMemory;
	+/
	BOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES);
	BOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES);
	BOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
	BOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
	HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR);
	HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR);
	HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
	HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
	HANDLE CreateIoCompletionPort(HANDLE, HANDLE, ULONG_PTR, DWORD);
	HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
	HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
	HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
	BOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
	BOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
	BOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
	HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR);
	HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR);
	HANDLE CreateThread(LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, PVOID, DWORD, PDWORD);
	BOOL DebugActiveProcess(DWORD);
	void DebugBreak();
	ATOM DeleteAtom(ATOM);
	void DeleteCriticalSection(PCRITICAL_SECTION);
	BOOL DeleteFileA(LPCSTR);
	BOOL DeleteFileW(LPCWSTR);
	BOOL DisableThreadLibraryCalls(HMODULE);
	BOOL DosDateTimeToFileTime(WORD, WORD, LPFILETIME);
	BOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, PHANDLE, DWORD, BOOL, DWORD);
	BOOL EndUpdateResourceA(HANDLE, BOOL);
	BOOL EndUpdateResourceW(HANDLE, BOOL);
	void EnterCriticalSection(LPCRITICAL_SECTION);
	BOOL EnumResourceLanguagesA(HMODULE, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG_PTR);
	BOOL EnumResourceLanguagesW(HMODULE, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG_PTR);
	BOOL EnumResourceNamesA(HMODULE, LPCSTR, ENUMRESNAMEPROC, LONG_PTR);
	BOOL EnumResourceNamesW(HMODULE, LPCWSTR, ENUMRESNAMEPROC, LONG_PTR);
	BOOL EnumResourceTypesA(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
	BOOL EnumResourceTypesW(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
	BOOL EscapeCommFunction(HANDLE, DWORD);
	void ExitProcess(UINT); // Never returns
	void ExitThread(DWORD); // Never returns
	DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD);
	DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD);
	void FatalAppExitA(UINT, LPCSTR);
	void FatalAppExitW(UINT, LPCWSTR);
	void FatalExit(int);
	BOOL FileTimeToDosDateTime(FILETIME* , LPWORD, LPWORD);
	BOOL FileTimeToLocalFileTime(FILETIME* , LPFILETIME);
	BOOL FileTimeToSystemTime(FILETIME* , LPSYSTEMTIME);
	ATOM FindAtomA(LPCSTR);
	ATOM FindAtomW(LPCWSTR);
	BOOL FindClose(HANDLE);
	BOOL FindCloseChangeNotification(HANDLE);
	HANDLE FindFirstChangeNotificationA(LPCSTR, BOOL, DWORD);
	HANDLE FindFirstChangeNotificationW(LPCWSTR, BOOL, DWORD);
	HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATAA);
	HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW);
	BOOL FindNextChangeNotification(HANDLE);
	BOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATAA);
	BOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW);
	HRSRC FindResourceA(HMODULE, LPCSTR, LPCSTR);
	HRSRC FindResourceW(HINSTANCE, LPCWSTR, LPCWSTR);
	HRSRC FindResourceExA(HINSTANCE, LPCSTR, LPCSTR, WORD);
	HRSRC FindResourceExW(HINSTANCE, LPCWSTR, LPCWSTR, WORD);
	BOOL FlushFileBuffers(HANDLE);
	BOOL FlushInstructionCache(HANDLE, PCVOID, DWORD);
	DWORD FormatMessageA(DWORD, PCVOID, DWORD, DWORD, LPSTR, DWORD, va_list*);
	DWORD FormatMessageW(DWORD, PCVOID, DWORD, DWORD, LPWSTR, DWORD, va_list*);
	BOOL FreeEnvironmentStringsA(LPSTR);
	BOOL FreeEnvironmentStringsW(LPWSTR);
	BOOL FreeLibrary(HMODULE);
	void FreeLibraryAndExitThread(HMODULE, DWORD); // never returns
	BOOL FreeResource(HGLOBAL);
	UINT GetAtomNameA(ATOM, LPSTR, int);
	UINT GetAtomNameW(ATOM, LPWSTR, int);
	LPSTR GetCommandLineA();
	LPWSTR GetCommandLineW();
	BOOL GetCommConfig(HANDLE, LPCOMMCONFIG, PDWORD);
	BOOL GetCommMask(HANDLE, PDWORD);
	BOOL GetCommModemStatus(HANDLE, PDWORD);
	BOOL GetCommProperties(HANDLE, LPCOMMPROP);
	BOOL GetCommState(HANDLE, LPDCB);
	BOOL GetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
	BOOL GetComputerNameA(LPSTR, PDWORD);
	BOOL GetComputerNameW(LPWSTR, PDWORD);
	DWORD GetCurrentDirectoryA(DWORD, LPSTR);
	DWORD GetCurrentDirectoryW(DWORD, LPWSTR);
	HANDLE GetCurrentProcess();
	DWORD GetCurrentProcessId();
	HANDLE GetCurrentThread();
/* In MinGW:
#ifdef _WIN32_WCE
extern DWORD GetCurrentThreadId(void);
#else
WINBASEAPI DWORD WINAPI GetCurrentThreadId(void);
#endif
*/
	DWORD GetCurrentThreadId();

	alias GetTickCount GetCurrentTime;

	BOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, PDWORD);
	BOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, PDWORD);
	BOOL GetDiskFreeSpaceA(LPCSTR, PDWORD, PDWORD, PDWORD, PDWORD);
	BOOL GetDiskFreeSpaceW(LPCWSTR, PDWORD, PDWORD, PDWORD, PDWORD);
	BOOL GetDiskFreeSpaceExA(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
	BOOL GetDiskFreeSpaceExW(LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
	UINT GetDriveTypeA(LPCSTR);
	UINT GetDriveTypeW(LPCWSTR);
	LPSTR GetEnvironmentStrings(); // ???
	LPSTR GetEnvironmentStringsA();
	LPWSTR GetEnvironmentStringsW();
	DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD);
	DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD);
	BOOL GetExitCodeProcess(HANDLE, PDWORD);
	BOOL GetExitCodeThread(HANDLE, PDWORD);
	DWORD GetFileAttributesA(LPCSTR);
	DWORD GetFileAttributesW(LPCWSTR);
	BOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION);
	DWORD GetFileSize(HANDLE, PDWORD);
	BOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME);
	DWORD GetFileType(HANDLE);
	DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*);
	DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*);
	DWORD GetLastError();
	void GetLocalTime(LPSYSTEMTIME);
	DWORD GetLogicalDrives();
	DWORD GetLogicalDriveStringsA(DWORD, LPSTR);
	DWORD GetLogicalDriveStringsW(DWORD, LPWSTR);
	BOOL GetMailslotInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
	DWORD GetModuleFileNameA(HINSTANCE, LPSTR, DWORD);
	DWORD GetModuleFileNameW(HINSTANCE, LPWSTR, DWORD);
	HMODULE GetModuleHandleA(LPCSTR);
	HMODULE GetModuleHandleW(LPCWSTR);
	BOOL GetNamedPipeHandleStateA(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
	BOOL GetNamedPipeHandleStateW(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
	BOOL GetNamedPipeInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
	BOOL GetOverlappedResult(HANDLE, LPOVERLAPPED, PDWORD, BOOL);
	DWORD GetPriorityClass(HANDLE);
	UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR);
	UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR);
	DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR);
	DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR);
	DWORD GetPrivateProfileSectionNamesA(LPSTR, DWORD, LPCSTR);
	DWORD GetPrivateProfileSectionNamesW(LPWSTR, DWORD, LPCWSTR);
	DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
	DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
	BOOL GetPrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
	BOOL GetPrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
	FARPROC GetProcAddress(HINSTANCE, LPCSTR);
	BOOL GetProcessAffinityMask(HANDLE, PDWORD, PDWORD);
	DWORD GetProcessVersion(DWORD);
	UINT GetProfileIntA(LPCSTR, LPCSTR, INT);
	UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT);
	DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD);
	DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD);
	DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD);
	DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
	DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD);
	DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD);
	VOID GetStartupInfoA(LPSTARTUPINFOA);
	VOID GetStartupInfoW(LPSTARTUPINFOW);
	HANDLE GetStdHandle(DWORD);
	UINT GetSystemDirectoryA(LPSTR, UINT);
	UINT GetSystemDirectoryW(LPWSTR, UINT);
	VOID GetSystemInfo(LPSYSTEM_INFO);
	VOID GetSystemTime(LPSYSTEMTIME);
	BOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PBOOL);
	void GetSystemTimeAsFileTime(LPFILETIME);
	UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR);
	UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR);
	DWORD GetTempPathA(DWORD, LPSTR);
	DWORD GetTempPathW(DWORD, LPWSTR);
	BOOL GetThreadContext(HANDLE, LPCONTEXT);
	int GetThreadPriority(HANDLE);
	BOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY);
	DWORD GetTickCount();
	DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
	BOOL GetUserNameA (LPSTR, PDWORD);
	BOOL GetUserNameW(LPWSTR, PDWORD);
	DWORD GetVersion();
	BOOL GetVersionExA(LPOSVERSIONINFOA);
	BOOL GetVersionExW(LPOSVERSIONINFOW);
	BOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
	BOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
	UINT GetWindowsDirectoryA(LPSTR, UINT);
	UINT GetWindowsDirectoryW(LPWSTR, UINT);
	DWORD GetWindowThreadProcessId(HWND, PDWORD);
	ATOM GlobalAddAtomA(LPCSTR);
	ATOM GlobalAddAtomW(LPCWSTR);
	ATOM GlobalDeleteAtom(ATOM);
	ATOM GlobalFindAtomA(LPCSTR);
	ATOM GlobalFindAtomW(LPCWSTR);
	UINT GlobalGetAtomNameA(ATOM, LPSTR, int);
	UINT GlobalGetAtomNameW(ATOM, LPWSTR, int);

	bool HasOverlappedIoCompleted(LPOVERLAPPED lpOverlapped) {
		return lpOverlapped.Internal != STATUS_PENDING;
	}

	BOOL InitAtomTable(DWORD);
	VOID InitializeCriticalSection(LPCRITICAL_SECTION);
	/*	??? The next two are allegedly obsolete and "supported only for
	 *	backward compatibility with the 16-bit Windows API".  Yet the
	 *	replacements IsBadReadPtr and IsBadWritePtr are apparently Win2000+
	 *	only.  Where's the mistake?
	 */
	BOOL IsBadHugeReadPtr(PCVOID, UINT);
	BOOL IsBadHugeWritePtr(PVOID, UINT);
	BOOL IsBadReadPtr(PCVOID, UINT);
	BOOL IsBadStringPtrA(LPCSTR, UINT);
	BOOL IsBadStringPtrW(LPCWSTR, UINT);
	BOOL IsBadWritePtr(PVOID, UINT);
	void LeaveCriticalSection(LPCRITICAL_SECTION);
	HINSTANCE LoadLibraryA(LPCSTR);
	HINSTANCE LoadLibraryW(LPCWSTR);
	HINSTANCE LoadLibraryExA(LPCSTR, HANDLE, DWORD);
	HINSTANCE LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
	DWORD LoadModule(LPCSTR, PVOID);
	HGLOBAL LoadResource(HINSTANCE, HRSRC);
	BOOL LocalFileTimeToFileTime(FILETIME* , LPFILETIME);
	BOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
	PVOID LockResource(HGLOBAL);

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

	BOOL MoveFileA(LPCSTR, LPCSTR);
	BOOL MoveFileW(LPCWSTR, LPCWSTR);
	int MulDiv(int, int, int);
	HANDLE OpenEventA(DWORD, BOOL, LPCSTR);
	HANDLE OpenEventW(DWORD, BOOL, LPCWSTR);
	deprecated HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT);
	HANDLE OpenMutexA(DWORD, BOOL, LPCSTR);
	HANDLE OpenMutexW(DWORD, BOOL, LPCWSTR);
	HANDLE OpenProcess(DWORD, BOOL, DWORD);
	HANDLE OpenSemaphoreA(DWORD, BOOL, LPCSTR);
	HANDLE OpenSemaphoreW(DWORD, BOOL, LPCWSTR);
	void OutputDebugStringA(LPCSTR);
	void OutputDebugStringW(LPCWSTR);
	BOOL PeekNamedPipe(HANDLE, PVOID, DWORD, PDWORD, PDWORD, PDWORD);
	BOOL PulseEvent(HANDLE);
	BOOL PurgeComm(HANDLE, DWORD);
	BOOL QueryPerformanceCounter(PLARGE_INTEGER);
	BOOL QueryPerformanceFrequency(PLARGE_INTEGER);
	DWORD QueueUserAPC(PAPCFUNC, HANDLE, ULONG_PTR);
	void RaiseException(DWORD, DWORD, DWORD, DWORD*);
	BOOL ReadFile(HANDLE, PVOID, DWORD, PDWORD, LPOVERLAPPED);
	BOOL ReadFileEx(HANDLE, PVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
	BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, DWORD, PDWORD);
	BOOL ReleaseMutex(HANDLE);
	BOOL ReleaseSemaphore(HANDLE, LONG, LPLONG);
	BOOL RemoveDirectoryA(LPCSTR);
	BOOL RemoveDirectoryW(LPCWSTR);
/* In MinGW:
#ifdef _WIN32_WCE
extern BOOL ResetEvent(HANDLE);
#else
WINBASEAPI BOOL WINAPI ResetEvent(HANDLE);
#endif
*/
	BOOL ResetEvent(HANDLE);
	DWORD ResumeThread(HANDLE);
	DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR*);
	DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR*);
	BOOL SetCommBreak(HANDLE);
	BOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD);
	BOOL SetCommMask(HANDLE, DWORD);
	BOOL SetCommState(HANDLE, LPDCB);
	BOOL SetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
	BOOL SetComputerNameA(LPCSTR);
	BOOL SetComputerNameW(LPCWSTR);
	BOOL SetCurrentDirectoryA(LPCSTR);
	BOOL SetCurrentDirectoryW(LPCWSTR);
	BOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD);
	BOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD);
	BOOL SetEndOfFile(HANDLE);
	BOOL SetEnvironmentVariableA(LPCSTR, LPCSTR);
	BOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR);
	UINT SetErrorMode(UINT);
/* In MinGW:
#ifdef _WIN32_WCE
extern BOOL SetEvent(HANDLE);
#else
WINBASEAPI BOOL WINAPI SetEvent(HANDLE);
#endif
*/
	BOOL SetEvent(HANDLE);
	VOID SetFileApisToANSI();
	VOID SetFileApisToOEM();
	BOOL SetFileAttributesA(LPCSTR, DWORD);
	BOOL SetFileAttributesW(LPCWSTR, DWORD);
	DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD);
	BOOL SetFileTime(HANDLE, FILETIME*, FILETIME*, FILETIME*);
	deprecated UINT SetHandleCount(UINT);
	void SetLastError(DWORD);
	void SetLastErrorEx(DWORD, DWORD);
	BOOL SetLocalTime(SYSTEMTIME*);
	BOOL SetMailslotInfo(HANDLE, DWORD);
	BOOL SetNamedPipeHandleState(HANDLE, PDWORD, PDWORD, PDWORD);
	BOOL SetPriorityClass(HANDLE, DWORD);
	BOOL SetStdHandle(DWORD, HANDLE);
	BOOL SetSystemTime(SYSTEMTIME*);
	DWORD SetThreadAffinityMask(HANDLE, DWORD);
	BOOL SetThreadContext(HANDLE, CONTEXT*);
	BOOL SetThreadPriority(HANDLE, int);
	BOOL SetTimeZoneInformation(TIME_ZONE_INFORMATION*);
	LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
	BOOL SetupComm(HANDLE, DWORD, DWORD);
	BOOL SetVolumeLabelA(LPCSTR, LPCSTR);
	BOOL SetVolumeLabelW(LPCWSTR, LPCWSTR);

	DWORD SizeofResource(HINSTANCE, HRSRC);
	void Sleep(DWORD);
	DWORD SleepEx(DWORD, BOOL);
	DWORD SuspendThread(HANDLE);
	BOOL SystemTimeToFileTime(SYSTEMTIME*, LPFILETIME);
	BOOL TerminateProcess(HANDLE, UINT);
	BOOL TerminateThread(HANDLE, DWORD);
	DWORD TlsAlloc();
	BOOL TlsFree(DWORD);
	PVOID TlsGetValue(DWORD);
	BOOL TlsSetValue(DWORD, PVOID);
	BOOL TransactNamedPipe(HANDLE, PVOID, DWORD, PVOID, DWORD, PDWORD, LPOVERLAPPED);
	BOOL TransmitCommChar(HANDLE, char);
	LONG UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
	BOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
	BOOL WaitCommEvent(HANDLE, PDWORD, LPOVERLAPPED);
	BOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD);
	DWORD WaitForMultipleObjects(DWORD, HANDLE*, BOOL, DWORD);
	DWORD WaitForMultipleObjectsEx(DWORD, HANDLE*, BOOL, DWORD, BOOL);
	DWORD WaitForSingleObject(HANDLE, DWORD);
	DWORD WaitForSingleObjectEx(HANDLE, DWORD, BOOL);
	BOOL WaitNamedPipeA(LPCSTR, DWORD);
	BOOL WaitNamedPipeW(LPCWSTR, DWORD);
	// undocumented on MSDN
	BOOL WinLoadTrustProvider(GUID*);
	BOOL WriteFile(HANDLE, PCVOID, DWORD, PDWORD, LPOVERLAPPED);
	BOOL WriteFileEx(HANDLE, PCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
	BOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR);
	BOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR);
	BOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR);
	BOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
	BOOL WritePrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
	BOOL WritePrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
	BOOL WriteProcessMemory(HANDLE, LPVOID, LPCVOID, SIZE_T, SIZE_T*);
	BOOL WriteProfileSectionA(LPCSTR, LPCSTR);
	BOOL WriteProfileSectionW(LPCWSTR, LPCWSTR);
	BOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR);
	BOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR);

	/*	Memory allocation functions.
	 *	MSDN documents these erroneously as Win2000+; thus it is uncertain what
	 *	version compatibility they really have.
	 */
	HGLOBAL GlobalAlloc(UINT, DWORD);
	HGLOBAL GlobalDiscard(HGLOBAL);
	HGLOBAL GlobalFree(HGLOBAL);
	HGLOBAL GlobalHandle(PCVOID);
	LPVOID GlobalLock(HGLOBAL);
	VOID GlobalMemoryStatus(LPMEMORYSTATUS);
	HGLOBAL GlobalReAlloc(HGLOBAL, DWORD, UINT);
	DWORD GlobalSize(HGLOBAL);
	BOOL GlobalUnlock(HGLOBAL);
	PVOID HeapAlloc(HANDLE, DWORD, DWORD);
	SIZE_T HeapCompact(HANDLE, DWORD);
	HANDLE HeapCreate(DWORD, DWORD, DWORD);
	BOOL HeapDestroy(HANDLE);
	BOOL HeapFree(HANDLE, DWORD, PVOID);
	BOOL HeapLock(HANDLE);
	PVOID HeapReAlloc(HANDLE, DWORD, PVOID, DWORD);
	DWORD HeapSize(HANDLE, DWORD, PCVOID);
	BOOL HeapUnlock(HANDLE);
	BOOL HeapValidate(HANDLE, DWORD, PCVOID);
	BOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY);
	HLOCAL LocalAlloc(UINT, SIZE_T);
	HLOCAL LocalDiscard(HLOCAL);
	HLOCAL LocalFree(HLOCAL);
	HLOCAL LocalHandle(LPCVOID);
	PVOID LocalLock(HLOCAL);
	HLOCAL LocalReAlloc(HLOCAL, SIZE_T, UINT);
	UINT LocalSize(HLOCAL);
	BOOL LocalUnlock(HLOCAL);
	PVOID VirtualAlloc(PVOID, DWORD, DWORD, DWORD);
	PVOID VirtualAllocEx(HANDLE, PVOID, DWORD, DWORD, DWORD);
	BOOL VirtualFree(PVOID, DWORD, DWORD);
	BOOL VirtualFreeEx(HANDLE, PVOID, DWORD, DWORD);
	BOOL VirtualLock(PVOID, DWORD);
	BOOL VirtualProtect(PVOID, DWORD, DWORD, PDWORD);
	BOOL VirtualProtectEx(HANDLE, PVOID, DWORD, DWORD, PDWORD);
	DWORD VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
	DWORD VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
	BOOL VirtualUnlock(PVOID, DWORD);

	static if (_WIN32_WINDOWS >= 0x600) {
		BOOL CancelIoEx(HANDLE, LPOVERLAPPED);
	}

	static if (_WIN32_WINDOWS >= 0x410) {
		BOOL CancelIo(HANDLE);
		BOOL CancelWaitableTimer(HANDLE);
		PVOID ConvertThreadToFiber(PVOID);
		LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID);
		HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
		HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
		void DeleteFiber(PVOID);
		BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID);
		BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID);
		DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD);
		DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD);
		BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD);
		BOOL IsDebuggerPresent();
		HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR);
		HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR);
		DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD);
		DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD);
		BOOL SetWaitableTimer(HANDLE, LARGE_INTEGER*, LONG, PTIMERAPCROUTINE, PVOID, BOOL);
		void SwitchToFiber(PVOID);
	}

	static if (WINVER >= 0x500) {
		HANDLE OpenThread(DWORD, BOOL, DWORD);
	}

	static if (_WIN32_WINNT_ONLY) {
		BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL);
		BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
		BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
		BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID);
		BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID);
		BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD);
		BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL);
		BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD);
		BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
		BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
		BOOL AllocateLocallyUniqueId(PLUID);
		BOOL AreAllAccessesGranted(DWORD, DWORD);
		BOOL AreAnyAccessesGranted(DWORD, DWORD);
		BOOL BackupEventLogA(HANDLE, LPCSTR);
		BOOL BackupEventLogW(HANDLE, LPCWSTR);
		BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
		BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*);
		BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
		BOOL ClearEventLogA(HANDLE, LPCSTR);
		BOOL ClearEventLogW(HANDLE, LPCWSTR);
		BOOL CloseEventLog(HANDLE);
		BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED);
		BOOL CopySid(DWORD, PSID, PSID);
		HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
		HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
		BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING);
		BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
		BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
		HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
		DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD);
		BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR);
		BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR);
		BOOL DeleteAce(PACL, DWORD);
		BOOL DeregisterEventSource(HANDLE);
		BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
		BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED);
		BOOL DisconnectNamedPipe(HANDLE);
		BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE);
		BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE);
		BOOL EqualPrefixSid(PSID, PSID);
		BOOL EqualSid(PSID, PSID);
		DWORD EraseTape(HANDLE, DWORD, BOOL);
		HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
		HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
		BOOL FindFirstFreeAce(PACL, PVOID*);
		PVOID FreeSid(PSID);
		BOOL GetAce(PACL, DWORD, LPVOID*);
		BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
		BOOL GetBinaryTypeA(LPCSTR, PDWORD);
		BOOL GetBinaryTypeW(LPCWSTR, PDWORD);
		DWORD GetCompressedFileSizeA(LPCSTR, PDWORD);
		DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD);
		BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
		BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
		BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
		BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
		BOOL GetHandleInformation(HANDLE, PDWORD);
		BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
		DWORD GetLengthSid(PSID);
		BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD);
		BOOL GetOldestEventLogRecord(HANDLE, PDWORD);
		BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
		BOOL GetProcessPriorityBoost(HANDLE, PBOOL);
		BOOL GetProcessShutdownParameters(PDWORD, PDWORD);
		BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
		HWINSTA GetProcessWindowStation();
		BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T);
		BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD);
		BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD);
		BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
		BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
		DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
		BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
		BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
		PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID);
		DWORD GetSidLengthRequired(UCHAR);
		PDWORD GetSidSubAuthority(PSID, DWORD);
		PUCHAR GetSidSubAuthorityCount(PSID);
		DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID);
		DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD);
		DWORD GetTapeStatus(HANDLE);
		BOOL GetThreadPriorityBoost(HANDLE, PBOOL);
		BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
		BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD);
		BOOL ImpersonateLoggedOnUser(HANDLE);
		BOOL ImpersonateNamedPipeClient(HANDLE);
		BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
		BOOL InitializeAcl(PACL, DWORD, DWORD);
		DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD);
		BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD);
		BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE);
		BOOL IsProcessorFeaturePresent(DWORD);
		BOOL IsTextUnicode(PCVOID, int, LPINT);
		BOOL IsValidAcl(PACL);
		BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
		BOOL IsValidSid(PSID);
		BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
		BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE);
		BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE);
		BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
		BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
		BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
		BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
		BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD);
		BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD);
		BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD);
		BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD);
		BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID);
		BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID);
		BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD);
		BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD);
		VOID MapGenericMask(PDWORD, PGENERIC_MAPPING);
		BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD);
		BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD);
		BOOL NotifyChangeEventLog(HANDLE, HANDLE);
		BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL);
		BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL);
		BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL);
		BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL);
		BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
		BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
		BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
		BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
		HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR);
		HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR);
		HANDLE OpenEventLogA(LPCSTR, LPCSTR);
		HANDLE OpenEventLogW(LPCWSTR, LPCWSTR);
		BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE);
		BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE);
		BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED);
		DWORD PrepareTape(HANDLE, DWORD, BOOL);
		BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL);
		BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL);
		BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL);
		BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
		BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
		BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
		BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
		HANDLE RegisterEventSourceA (LPCSTR, LPCSTR);
		HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR);
		BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID);
		BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID);
		BOOL RevertToSelf();
		BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
		BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
		BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
		BOOL SetHandleInformation(HANDLE, DWORD, DWORD);
		BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
		BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR* , PGENERIC_MAPPING, HANDLE);
		BOOL SetProcessAffinityMask(HANDLE, DWORD);
		BOOL SetProcessPriorityBoost(HANDLE, BOOL);
		BOOL SetProcessShutdownParameters(DWORD, DWORD);
		BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T);
		BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
		BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL);
		BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL);
		BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
		BOOL SetSystemTimeAdjustment(DWORD, BOOL);
		DWORD SetTapeParameters(HANDLE, DWORD, PVOID);
		DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL);
		BOOL SetThreadPriorityBoost(HANDLE, BOOL);
		BOOL SetThreadToken(PHANDLE, HANDLE);
		BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD);
		DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL);
		BOOL SwitchToThread();
		BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
		BOOL TryEnterCriticalSection(LPCRITICAL_SECTION);
		BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED);
		BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD);
		BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD);
		BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
		DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL);

		static if (_WIN32_WINNT >= 0x500) {
			BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
			BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
			PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER);
			BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
			BOOL AssignProcessToJobObject(HANDLE, HANDLE);
			BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG);
			LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID);
			HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR);
			HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR);
			BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
			BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
			HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR);
			HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR);
			BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
			HANDLE CreateTimerQueue();
			BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG);
			BOOL DeleteTimerQueue(HANDLE);
			BOOL DeleteTimerQueueEx(HANDLE, HANDLE);
			BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE);
			BOOL DeleteVolumeMountPointA(LPCSTR);
			BOOL DeleteVolumeMountPointW(LPCWSTR);
			BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD);
			BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD);
			BOOL EncryptFileA(LPCSTR);
			BOOL EncryptFileW(LPCWSTR);
			BOOL FileEncryptionStatusA(LPCSTR, LPDWORD);
			BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD);
			HANDLE FindFirstVolumeA(LPCSTR, DWORD);
			HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD);
			HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD);
			HANDLE FindFirstVolumeW(LPCWSTR, DWORD);
			BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD);
			BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD);
			BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD);
			BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD);
			BOOL FindVolumeClose(HANDLE);
			BOOL FindVolumeMountPointClose(HANDLE);
			BOOL FlushViewOfFile(PCVOID, DWORD);
			BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
			BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD);
			BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD);
			BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER);
			BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*);
			BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*);
			HANDLE GetProcessHeap();
			DWORD GetProcessHeaps(DWORD, PHANDLE);
			BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS);
			BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
			UINT GetSystemWindowsDirectoryA(LPSTR, UINT);
			UINT GetSystemWindowsDirectoryW(LPWSTR, UINT);
			BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD);
			BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD);
			BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD);
			BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD);
			BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
			BOOL IsBadCodePtr(FARPROC);
			BOOL IsSystemResumeAutomatic();
			BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR);
			BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR);
			PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
			PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, PVOID);
			HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR);
			HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR);
			BOOL ProcessIdToSessionId(DWORD, DWORD*);
			BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
			ULONG RemoveVectoredExceptionHandler(PVOID);
			BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
			BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
			BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR);
			BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR);
			BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD);
			BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
			BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL);
			BOOL SetSystemPowerState(BOOL, BOOL);
			EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE);
			DWORD SetThreadIdealProcessor(HANDLE, DWORD);
			BOOL SetVolumeMountPointA(LPCSTR, LPCSTR);
			BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR);
			BOOL TerminateJobObject(HANDLE, UINT);
			BOOL UnmapViewOfFile(PVOID);
			BOOL UnregisterWait(HANDLE);
			BOOL UnregisterWaitEx(HANDLE, HANDLE);
			BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG);
			BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG);
		}

		static if (_WIN32_WINNT >= 0x501) {
			BOOL ActivateActCtx(HANDLE, ULONG_PTR*);
			void AddRefActCtx(HANDLE);
			BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL);
			BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL);
			BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL);
			BOOL ConvertFiberToThread();
			HANDLE CreateActCtxA(PCACTCTXA);
			HANDLE CreateActCtxW(PCACTCTXW);
			HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE);
			BOOL DeactivateActCtx(DWORD, ULONG_PTR);
			BOOL DebugActiveProcessStop(DWORD);
			BOOL DebugBreakProcess(HANDLE);
			BOOL DebugSetProcessKillOnExit(BOOL);
			BOOL FindActCtxSectionGuid(DWORD, GUID*, ULONG, GUID*,
			  PACTCTX_SECTION_KEYED_DATA);
			BOOL FindActCtxSectionStringA(DWORD, GUID*, ULONG, LPCSTR,
			  PACTCTX_SECTION_KEYED_DATA);
			BOOL FindActCtxSectionStringW(DWORD, GUID*, ULONG, LPCWSTR,
			  PACTCTX_SECTION_KEYED_DATA);
			BOOL GetCurrentActCtx(HANDLE*);
			VOID GetNativeSystemInfo(LPSYSTEM_INFO);
			BOOL GetProcessHandleCount(HANDLE, PDWORD);
			BOOL GetSystemRegistryQuota(PDWORD, PDWORD);
			BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME);
			UINT GetSystemWow64DirectoryA(LPSTR, UINT);
			UINT GetSystemWow64DirectoryW(LPWSTR, UINT);
			BOOL GetThreadIOPendingFlag(HANDLE, PBOOL);
			BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD);
			BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD);
			UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG);
			BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T);
			BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
			BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL);
			BOOL IsWow64Process(HANDLE, PBOOL);
			BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*);
			BOOL QueryMemoryResourceNotification(HANDLE, PBOOL);
			void ReleaseActCtx(HANDLE);
			UINT ResetWriteWatch(LPVOID, SIZE_T);
			BOOL SetFileShortNameA(HANDLE, LPCSTR);
			BOOL SetFileShortNameW(HANDLE, LPCWSTR);
			BOOL SetFileValidData(HANDLE, LONGLONG);
			BOOL ZombifyActCtx(HANDLE);
		}

		static if (_WIN32_WINNT >= 0x502) {
			DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
			DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
			DWORD GetDllDirectoryA(DWORD, LPSTR);
			DWORD GetDllDirectoryW(DWORD, LPWSTR);
			DWORD GetProcessId(HANDLE);
			HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD);
			BOOL SetDllDirectoryA(LPCSTR);
			BOOL SetDllDirectoryW(LPCWSTR);
			BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
			BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
		}
	}

	// ???
	static if (_WIN32_WINNT >= 0x510) {
		VOID RestoreLastError(DWORD);
	}
}


version (Unicode) {
	alias STARTUPINFOW STARTUPINFO;
	alias WIN32_FIND_DATAW WIN32_FIND_DATA;
	alias ENUMRESLANGPROCW ENUMRESLANGPROC;
	alias ENUMRESNAMEPROCW ENUMRESNAMEPROC;
	alias ENUMRESTYPEPROCW ENUMRESTYPEPROC;
	alias AddAtomW AddAtom;
	alias BeginUpdateResourceW BeginUpdateResource;
	alias BuildCommDCBW BuildCommDCB;
	alias BuildCommDCBAndTimeoutsW BuildCommDCBAndTimeouts;
	alias CallNamedPipeW CallNamedPipe;
	alias CommConfigDialogW CommConfigDialog;
	alias CopyFileW CopyFile;
	alias CopyFileExW CopyFileEx;
	alias CreateDirectoryW CreateDirectory;
	alias CreateDirectoryExW CreateDirectoryEx;
	alias CreateEventW CreateEvent;
	alias CreateFileW CreateFile;
	alias CreateMailslotW CreateMailslot;
	alias CreateMutexW CreateMutex;
	alias CreateProcessW CreateProcess;
	alias CreateSemaphoreW CreateSemaphore;
	alias DeleteFileW DeleteFile;
	alias EndUpdateResourceW EndUpdateResource;
	alias EnumResourceLanguagesW EnumResourceLanguages;
	alias EnumResourceNamesW EnumResourceNames;
	alias EnumResourceTypesW EnumResourceTypes;
	alias ExpandEnvironmentStringsW ExpandEnvironmentStrings;
	alias FatalAppExitW FatalAppExit;
	alias FindAtomW FindAtom;
	alias FindFirstChangeNotificationW FindFirstChangeNotification;
	alias FindFirstFileW FindFirstFile;
	alias FindNextFileW FindNextFile;
	alias FindResourceW FindResource;
	alias FindResourceExW FindResourceEx;
	alias FormatMessageW FormatMessage;
	alias FreeEnvironmentStringsW FreeEnvironmentStrings;
	alias GetAtomNameW GetAtomName;
	alias GetCommandLineW GetCommandLine;
	alias GetComputerNameW GetComputerName;
	alias GetCurrentDirectoryW GetCurrentDirectory;
	alias GetDefaultCommConfigW GetDefaultCommConfig;
	alias GetDiskFreeSpaceW GetDiskFreeSpace;
	alias GetDiskFreeSpaceExW GetDiskFreeSpaceEx;
	alias GetDriveTypeW GetDriveType;
	alias GetEnvironmentStringsW GetEnvironmentStrings;
	alias GetEnvironmentVariableW GetEnvironmentVariable;
	alias GetFileAttributesW GetFileAttributes;
	alias GetFullPathNameW GetFullPathName;
	alias GetLogicalDriveStringsW GetLogicalDriveStrings;
	alias GetModuleFileNameW GetModuleFileName;
	alias GetModuleHandleW GetModuleHandle;
	alias GetNamedPipeHandleStateW GetNamedPipeHandleState;
	alias GetPrivateProfileIntW GetPrivateProfileInt;
	alias GetPrivateProfileSectionW GetPrivateProfileSection;
	alias GetPrivateProfileSectionNamesW GetPrivateProfileSectionNames;
	alias GetPrivateProfileStringW GetPrivateProfileString;
	alias GetPrivateProfileStructW GetPrivateProfileStruct;
	alias GetProfileIntW GetProfileInt;
	alias GetProfileSectionW GetProfileSection;
	alias GetProfileStringW GetProfileString;
	alias GetShortPathNameW GetShortPathName;
	alias GetStartupInfoW GetStartupInfo;
	alias GetSystemDirectoryW GetSystemDirectory;
	alias GetTempFileNameW GetTempFileName;
	alias GetTempPathW GetTempPath;
	alias GetUserNameW GetUserName;
	alias GetVersionExW GetVersionEx;
	alias GetVolumeInformationW GetVolumeInformation;
	alias GetWindowsDirectoryW GetWindowsDirectory;
	alias GlobalAddAtomW GlobalAddAtom;
	alias GlobalFindAtomW GlobalFindAtom;
	alias GlobalGetAtomNameW GlobalGetAtomName;
	alias IsBadStringPtrW IsBadStringPtr;
	alias LoadLibraryW LoadLibrary;
	alias LoadLibraryExW LoadLibraryEx;
	alias lstrcatW lstrcat;
	alias lstrcmpW lstrcmp;
	alias lstrcmpiW lstrcmpi;
	alias lstrcpyW lstrcpy;
	alias lstrcpynW lstrcpyn;
	alias lstrlenW lstrlen;
	alias MoveFileW MoveFile;
	alias OpenEventW OpenEvent;
	alias OpenMutexW OpenMutex;
	alias OpenSemaphoreW OpenSemaphore;
	alias OutputDebugStringW OutputDebugString;
	alias RemoveDirectoryW RemoveDirectory;
	alias SearchPathW SearchPath;
	alias SetComputerNameW SetComputerName;
	alias SetCurrentDirectoryW SetCurrentDirectory;
	alias SetDefaultCommConfigW SetDefaultCommConfig;
	alias SetEnvironmentVariableW SetEnvironmentVariable;
	alias SetFileAttributesW SetFileAttributes;
	alias SetVolumeLabelW SetVolumeLabel;
	alias WaitNamedPipeW WaitNamedPipe;
	alias WritePrivateProfileSectionW WritePrivateProfileSection;
	alias WritePrivateProfileStringW WritePrivateProfileString;
	alias WritePrivateProfileStructW WritePrivateProfileStruct;
	alias WriteProfileSectionW WriteProfileSection;
	alias WriteProfileStringW WriteProfileString;

	static if (_WIN32_WINDOWS >= 0x410) {
		alias CreateWaitableTimerW CreateWaitableTimer;
		alias GetFileAttributesExW GetFileAttributesEx;
		alias GetLongPathNameW GetLongPathName;
		alias QueryDosDeviceW QueryDosDevice;
	}

	static if (_WIN32_WINNT_ONLY) {
		alias HW_PROFILE_INFOW HW_PROFILE_INFO;
		alias AccessCheckAndAuditAlarmW AccessCheckAndAuditAlarm;
		alias BackupEventLogW BackupEventLog;
		alias ClearEventLogW ClearEventLog;
		alias CreateNamedPipeW CreateNamedPipe;
		alias CreateProcessAsUserW CreateProcessAsUser;
		alias DefineDosDeviceW DefineDosDevice;
		alias FindFirstFileExW FindFirstFileEx;
		alias GetBinaryTypeW GetBinaryType;
		alias GetCompressedFileSizeW GetCompressedFileSize;
		alias GetFileSecurityW GetFileSecurity;
		alias LogonUserW LogonUser;
		alias LookupAccountNameW LookupAccountName;
		alias LookupAccountSidW LookupAccountSid;
		alias LookupPrivilegeDisplayNameW LookupPrivilegeDisplayName;
		alias LookupPrivilegeNameW LookupPrivilegeName;
		alias LookupPrivilegeValueW LookupPrivilegeValue;
		alias MoveFileExW MoveFileEx;
		alias ObjectCloseAuditAlarmW ObjectCloseAuditAlarm;
		alias ObjectDeleteAuditAlarmW ObjectDeleteAuditAlarm;
		alias ObjectOpenAuditAlarmW ObjectOpenAuditAlarm;
		alias ObjectPrivilegeAuditAlarmW ObjectPrivilegeAuditAlarm;
		alias OpenBackupEventLogW OpenBackupEventLog;
		alias OpenEventLogW OpenEventLog;
		alias PrivilegedServiceAuditAlarmW PrivilegedServiceAuditAlarm;
		alias ReadEventLogW ReadEventLog;
		alias RegisterEventSourceW RegisterEventSource;
		alias ReportEventW ReportEvent;
		alias SetFileSecurityW SetFileSecurity;
		alias UpdateResourceW UpdateResource;

		static if (_WIN32_WINNT >= 0x500) {
			alias CreateFileMappingW CreateFileMapping;
			alias CreateHardLinkW CreateHardLink;
			alias CreateJobObjectW CreateJobObject;
			alias DeleteVolumeMountPointW DeleteVolumeMountPoint;
			alias DnsHostnameToComputerNameW DnsHostnameToComputerName;
			alias EncryptFileW EncryptFile;
			alias FileEncryptionStatusW FileEncryptionStatus;
			alias FindFirstVolumeW FindFirstVolume;
			alias FindFirstVolumeMountPointW FindFirstVolumeMountPoint;
			alias FindNextVolumeW FindNextVolume;
			alias FindNextVolumeMountPointW FindNextVolumeMountPoint;
			alias GetModuleHandleExW GetModuleHandleEx;
			alias GetSystemWindowsDirectoryW GetSystemWindowsDirectory;
			alias GetVolumeNameForVolumeMountPointW GetVolumeNameForVolumeMountPoint;
			alias GetVolumePathNameW GetVolumePathName;
			alias OpenFileMappingW OpenFileMapping;
			alias ReplaceFileW ReplaceFile;
			alias SetVolumeMountPointW SetVolumeMountPoint;
			alias VerifyVersionInfoW VerifyVersionInfo;
		}

		static if (_WIN32_WINNT >= 0x501) {
			alias ACTCTXW ACTCTX;
			alias CheckNameLegalDOS8Dot3W CheckNameLegalDOS8Dot3;
			alias CreateActCtxW CreateActCtx;
			alias FindActCtxSectionStringW FindActCtxSectionString;
			alias GetSystemWow64DirectoryW GetSystemWow64Directory;
			alias GetVolumePathNamesForVolumeNameW GetVolumePathNamesForVolumeName;
			alias SetFileShortNameW SetFileShortName;
		}

		static if (_WIN32_WINNT >= 0x502) {
			alias SetFirmwareEnvironmentVariableW SetFirmwareEnvironmentVariable;
			alias SetDllDirectoryW SetDllDirectory;
			alias GetDllDirectoryW GetDllDirectory;
		}
	}

} else {
	alias STARTUPINFOA STARTUPINFO;
	alias WIN32_FIND_DATAA WIN32_FIND_DATA;
	alias ENUMRESLANGPROCW ENUMRESLANGPROC;
	alias ENUMRESNAMEPROCW ENUMRESNAMEPROC;
	alias ENUMRESTYPEPROCW ENUMRESTYPEPROC;
	alias AddAtomA AddAtom;
	alias BeginUpdateResourceA BeginUpdateResource;
	alias BuildCommDCBA BuildCommDCB;
	alias BuildCommDCBAndTimeoutsA BuildCommDCBAndTimeouts;
	alias CallNamedPipeA CallNamedPipe;
	alias CommConfigDialogA CommConfigDialog;
	alias CopyFileA CopyFile;
	alias CopyFileExA CopyFileEx;
	alias CreateDirectoryA CreateDirectory;
	alias CreateDirectoryExA CreateDirectoryEx;
	alias CreateEventA CreateEvent;
	alias CreateFileA CreateFile;
	alias CreateMailslotA CreateMailslot;
	alias CreateMutexA CreateMutex;
	alias CreateProcessA CreateProcess;
	alias CreateSemaphoreA CreateSemaphore;
	alias DeleteFileA DeleteFile;
	alias EndUpdateResourceA EndUpdateResource;
	alias EnumResourceLanguagesA EnumResourceLanguages;
	alias EnumResourceNamesA EnumResourceNames;
	alias EnumResourceTypesA EnumResourceTypes;
	alias ExpandEnvironmentStringsA ExpandEnvironmentStrings;
	alias FatalAppExitA FatalAppExit;
	alias FindAtomA FindAtom;
	alias FindFirstChangeNotificationA FindFirstChangeNotification;
	alias FindFirstFileA FindFirstFile;
	alias FindNextFileA FindNextFile;
	alias FindResourceA FindResource;
	alias FindResourceExA FindResourceEx;
	alias FormatMessageA FormatMessage;
	alias FreeEnvironmentStringsA FreeEnvironmentStrings;
	alias GetAtomNameA GetAtomName;
	alias GetCommandLineA GetCommandLine;
	alias GetComputerNameA GetComputerName;
	alias GetCurrentDirectoryA GetCurrentDirectory;
	alias GetDefaultCommConfigA GetDefaultCommConfig;
	alias GetDiskFreeSpaceA GetDiskFreeSpace;
	alias GetDiskFreeSpaceExA GetDiskFreeSpaceEx;
	alias GetDriveTypeA GetDriveType;
	alias GetEnvironmentVariableA GetEnvironmentVariable;
	alias GetFileAttributesA GetFileAttributes;
	alias GetFullPathNameA GetFullPathName;
	alias GetLogicalDriveStringsA GetLogicalDriveStrings;
	alias GetNamedPipeHandleStateA GetNamedPipeHandleState;
	alias GetModuleHandleA GetModuleHandle;
	alias GetModuleFileNameA GetModuleFileName;
	alias GetPrivateProfileIntA GetPrivateProfileInt;
	alias GetPrivateProfileSectionA GetPrivateProfileSection;
	alias GetPrivateProfileSectionNamesA GetPrivateProfileSectionNames;
	alias GetPrivateProfileStringA GetPrivateProfileString;
	alias GetPrivateProfileStructA GetPrivateProfileStruct;
	alias GetProfileIntA GetProfileInt;
	alias GetProfileSectionA GetProfileSection;
	alias GetProfileStringA GetProfileString;
	alias GetShortPathNameA GetShortPathName;
	alias GetStartupInfoA GetStartupInfo;
	alias GetSystemDirectoryA GetSystemDirectory;
	alias GetTempFileNameA GetTempFileName;
	alias GetTempPathA GetTempPath;
	alias GetUserNameA GetUserName;
	alias GetVersionExA GetVersionEx;
	alias GetVolumeInformationA GetVolumeInformation;
	alias GetWindowsDirectoryA GetWindowsDirectory;
	alias GlobalAddAtomA GlobalAddAtom;
	alias GlobalFindAtomA GlobalFindAtom;
	alias GlobalGetAtomNameA GlobalGetAtomName;
	alias IsBadStringPtrA IsBadStringPtr;
	alias LoadLibraryA LoadLibrary;
	alias LoadLibraryExA LoadLibraryEx;
	alias lstrcatA lstrcat;
	alias lstrcmpA lstrcmp;
	alias lstrcmpiA lstrcmpi;
	alias lstrcpyA lstrcpy;
	alias lstrcpynA lstrcpyn;
	alias lstrlenA lstrlen;
	alias MoveFileA MoveFile;
	alias OpenEventA OpenEvent;
	alias OpenMutexA OpenMutex;
	alias OpenSemaphoreA OpenSemaphore;
	alias OutputDebugStringA OutputDebugString;
	alias RemoveDirectoryA RemoveDirectory;
	alias SearchPathA SearchPath;
	alias SetComputerNameA SetComputerName;
	alias SetCurrentDirectoryA SetCurrentDirectory;
	alias SetDefaultCommConfigA SetDefaultCommConfig;
	alias SetEnvironmentVariableA SetEnvironmentVariable;
	alias SetFileAttributesA SetFileAttributes;
	alias SetVolumeLabelA SetVolumeLabel;
	alias WaitNamedPipeA WaitNamedPipe;
	alias WritePrivateProfileSectionA WritePrivateProfileSection;
	alias WritePrivateProfileStringA WritePrivateProfileString;
	alias WritePrivateProfileStructA WritePrivateProfileStruct;
	alias WriteProfileSectionA WriteProfileSection;
	alias WriteProfileStringA WriteProfileString;

	static if (_WIN32_WINDOWS >= 0x410) {
		alias CreateWaitableTimerA CreateWaitableTimer;
		alias GetFileAttributesExA GetFileAttributesEx;
		alias GetLongPathNameA GetLongPathName;
		alias QueryDosDeviceA QueryDosDevice;
	}

	static if (_WIN32_WINNT_ONLY) {
		alias HW_PROFILE_INFOA HW_PROFILE_INFO;
		alias AccessCheckAndAuditAlarmA AccessCheckAndAuditAlarm;
		alias BackupEventLogA BackupEventLog;
		alias ClearEventLogA ClearEventLog;
		alias CreateNamedPipeA CreateNamedPipe;
		alias CreateProcessAsUserA CreateProcessAsUser;
		alias DefineDosDeviceA DefineDosDevice;
		alias FindFirstFileExA FindFirstFileEx;
		alias GetBinaryTypeA GetBinaryType;
		alias GetCompressedFileSizeA GetCompressedFileSize;
		alias GetFileSecurityA GetFileSecurity;
		alias LogonUserA LogonUser;
		alias LookupAccountNameA LookupAccountName;
		alias LookupAccountSidA LookupAccountSid;
		alias LookupPrivilegeDisplayNameA LookupPrivilegeDisplayName;
		alias LookupPrivilegeNameA LookupPrivilegeName;
		alias LookupPrivilegeValueA LookupPrivilegeValue;
		alias MoveFileExA MoveFileEx;
		alias ObjectCloseAuditAlarmA ObjectCloseAuditAlarm;
		alias ObjectDeleteAuditAlarmA ObjectDeleteAuditAlarm;
		alias ObjectOpenAuditAlarmA ObjectOpenAuditAlarm;
		alias ObjectPrivilegeAuditAlarmA ObjectPrivilegeAuditAlarm;
		alias OpenBackupEventLogA OpenBackupEventLog;
		alias OpenEventLogA OpenEventLog;
		alias PrivilegedServiceAuditAlarmA PrivilegedServiceAuditAlarm;
		alias ReadEventLogA ReadEventLog;
		alias RegisterEventSourceA RegisterEventSource;
		alias ReportEventA ReportEvent;
		alias SetFileSecurityA SetFileSecurity;
		alias UpdateResourceA UpdateResource;

		static if (_WIN32_WINNT >= 0x500) {
			alias CreateFileMappingA CreateFileMapping;
			alias CreateHardLinkA CreateHardLink;
			alias CreateJobObjectA CreateJobObject;
			alias DeleteVolumeMountPointA DeleteVolumeMountPoint;
			alias DnsHostnameToComputerNameA DnsHostnameToComputerName;
			alias EncryptFileA EncryptFile;
			alias FileEncryptionStatusA FileEncryptionStatus;
			alias FindFirstVolumeA FindFirstVolume;
			alias FindFirstVolumeMountPointA FindFirstVolumeMountPoint;
			alias FindNextVolumeA FindNextVolume;
			alias FindNextVolumeMountPointA FindNextVolumeMountPoint;
			alias GetModuleHandleExA GetModuleHandleEx;
			alias GetSystemWindowsDirectoryA GetSystemWindowsDirectory;
			alias GetVolumeNameForVolumeMountPointA GetVolumeNameForVolumeMountPoint;
			alias GetVolumePathNameA GetVolumePathName;
			alias OpenFileMappingA OpenFileMapping;
			alias ReplaceFileA ReplaceFile;
			alias SetVolumeMountPointA SetVolumeMountPoint;
			alias VerifyVersionInfoA VerifyVersionInfo;
		}

		static if (_WIN32_WINNT >= 0x501) {
			alias ACTCTXA ACTCTX;
			alias CheckNameLegalDOS8Dot3A CheckNameLegalDOS8Dot3;
			alias CreateActCtxA CreateActCtx;
			alias FindActCtxSectionStringA FindActCtxSectionString;
			alias GetSystemWow64DirectoryA GetSystemWow64Directory;
			alias GetVolumePathNamesForVolumeNameA GetVolumePathNamesForVolumeName;
			alias SetFileShortNameA SetFileShortName;
		}

		static if (_WIN32_WINNT >= 0x502) {
			alias GetDllDirectoryA GetDllDirectory;
			alias SetDllDirectoryA SetDllDirectory;
			alias SetFirmwareEnvironmentVariableA SetFirmwareEnvironmentVariable;
		}
	}
}

alias STARTUPINFO* LPSTARTUPINFO;
alias WIN32_FIND_DATA* LPWIN32_FIND_DATA;

static if (_WIN32_WINNT_ONLY) {
	alias HW_PROFILE_INFO* LPHW_PROFILE_INFO;

	static if (_WIN32_WINNT >= 0x501) {
		alias ACTCTX* PACTCTX, PCACTCTX;
	}
}