winbase.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! This module defines the 32-Bit Windows Base APIs
use ctypes::{c_char, c_int, c_long, c_void};
use shared::basetsd::{
    DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR,
    ULONG_PTR,
};
use shared::guiddef::GUID;
use shared::minwindef::{
    ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL,
    LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT,
    UCHAR, UINT, ULONG, USHORT, WORD,
};
use shared::windef::HWND;
use um::cfgmgr32::MAX_PROFILE_LEN;
use um::fileapi::STREAM_INFO_LEVELS;
use um::libloaderapi::{
    ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW,
};
use um::minwinbase::{
    FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS,
    LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT,
};
use um::processthreadsapi::{
    LPPROCESS_INFORMATION, LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, LPSTARTUPINFOW,
    STARTUPINFOA, STARTUPINFOW,
};
use um::winnt::{
    BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID,
    LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA,
    LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE,
    PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA,
    PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT,
    PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT,
    PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC,
    STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification,
    SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT,
    THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK,
    WCHAR, WOW64_CONTEXT,
};
#[cfg(target_arch = "x86")]
use um::winnt::PLDT_ENTRY;
use vc::vadefs::va_list;
pub const FILE_BEGIN: DWORD = 0;
pub const FILE_CURRENT: DWORD = 1;
pub const FILE_END: DWORD = 2;
pub const WAIT_FAILED: DWORD = 0xFFFFFFFF;
pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32;
pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32;
pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000;
pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000;
pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000;
pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000;
pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000;
pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000;
pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000;
pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000;
pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000;
pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000;
pub const PROGRESS_CONTINUE: DWORD = 0;
pub const PROGRESS_CANCEL: DWORD = 1;
pub const PROGRESS_STOP: DWORD = 2;
pub const PROGRESS_QUIET: DWORD = 3;
pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000;
pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001;
pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001;
pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002;
pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004;
pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008;
pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800;
pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000;
pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000;
pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000;
pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000;
pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000;
pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000;
pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001;
pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002;
pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004;
pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001;
pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002;
pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003;
pub const PIPE_CLIENT_END: DWORD = 0x00000000;
pub const PIPE_SERVER_END: DWORD = 0x00000001;
pub const PIPE_WAIT: DWORD = 0x00000000;
pub const PIPE_NOWAIT: DWORD = 0x00000001;
pub const PIPE_READMODE_BYTE: DWORD = 0x00000000;
pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002;
pub const PIPE_TYPE_BYTE: DWORD = 0x00000000;
pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004;
pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000;
pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008;
pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255;
pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16;
pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16;
pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16;
pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16;
pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000;
pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000;
pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000;
FN!{stdcall PFIBER_START_ROUTINE(
    lpFiberParameter: LPVOID,
) -> ()}
pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE;
FN!{stdcall PFIBER_CALLOUT_ROUTINE(
    lpParameter: LPVOID,
) -> LPVOID}
// FAIL_FAST_*
#[cfg(target_arch = "x86")]
pub type LPLDT_ENTRY = PLDT_ENTRY;
#[cfg(not(target_arch = "x86"))]
pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit
//SP_SERIALCOMM
//PST_*
// PCF_*
// SP_*
// BAUD_*
// DATABITS_*
// STOPBITS_*
// PARITY_*
STRUCT!{struct COMMPROP {
    wPacketLength: WORD,
    wPacketVersion: WORD,
    dwServiceMask: DWORD,
    dwReserved1: DWORD,
    dwMaxTxQueue: DWORD,
    dwMaxRxQueue: DWORD,
    dwMaxBaud: DWORD,
    dwProvSubType: DWORD,
    dwProvCapabilities: DWORD,
    dwSettableParams: DWORD,
    dwSettableBaud: DWORD,
    wSettableData: WORD,
    wSettableStopParity: WORD,
    dwCurrentTxQueue: DWORD,
    dwCurrentRxQueue: DWORD,
    dwProvSpec1: DWORD,
    dwProvSpec2: DWORD,
    wcProvChar: [WCHAR; 1],
}}
pub type LPCOMMPROP = *mut COMMPROP;
STRUCT!{struct COMSTAT {
    BitFields: DWORD,
    cbInQue: DWORD,
    cbOutQue: DWORD,
}}
BITFIELD!{COMSTAT BitFields: DWORD [
    fCtsHold set_fCtsHold[0..1],
    fDsrHold set_fDsrHold[1..2],
    fRlsdHold set_fRlsdHold[2..3],
    fXoffHold set_fXoffHold[3..4],
    fXoffSent set_fXoffSent[4..5],
    fEof set_fEof[5..6],
    fTxim set_fTxim[6..7],
    fReserved set_fReserved[7..32],
]}
pub type LPCOMSTAT = *mut COMSTAT;
pub const DTR_CONTROL_DISABLE: DWORD = 0x00;
pub const DTR_CONTROL_ENABLE: DWORD = 0x01;
pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02;
pub const RTS_CONTROL_DISABLE: DWORD = 0x00;
pub const RTS_CONTROL_ENABLE: DWORD = 0x01;
pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02;
pub const RTS_CONTROL_TOGGLE: DWORD = 0x03;
STRUCT!{struct DCB {
    DCBlength: DWORD,
    BaudRate: DWORD,
    BitFields: DWORD,
    wReserved: WORD,
    XonLim: WORD,
    XoffLim: WORD,
    ByteSize: BYTE,
    Parity: BYTE,
    StopBits: BYTE,
    XonChar: c_char,
    XoffChar: c_char,
    ErrorChar: c_char,
    EofChar: c_char,
    EvtChar: c_char,
    wReserved1: WORD,
}}
BITFIELD!{DCB BitFields: DWORD [
    fBinary set_fBinary[0..1],
    fParity set_fParity[1..2],
    fOutxCtsFlow set_fOutxCtsFlow[2..3],
    fOutxDsrFlow set_fOutxDsrFlow[3..4],
    fDtrControl set_fDtrControl[4..6],
    fDsrSensitivity set_fDsrSensitivity[6..7],
    fTXContinueOnXoff set_fTXContinueOnXoff[7..8],
    fOutX set_fOutX[8..9],
    fInX set_fInX[9..10],
    fErrorChar set_fErrorChar[10..11],
    fNull set_fNull[11..12],
    fRtsControl set_fRtsControl[12..14],
    fAbortOnError set_fAbortOnError[14..15],
    fDummy2 set_fDummy2[15..32],
]}
pub type LPDCB = *mut DCB;
STRUCT!{struct COMMTIMEOUTS {
    ReadIntervalTimeout: DWORD,
    ReadTotalTimeoutMultiplier: DWORD,
    ReadTotalTimeoutConstant: DWORD,
    WriteTotalTimeoutMultiplier: DWORD,
    WriteTotalTimeoutConstant: DWORD,
}}
pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS;
STRUCT!{struct COMMCONFIG {
    dwSize: DWORD,
    wVersion: WORD,
    wReserved: WORD,
    dcb: DCB,
    dwProviderSubType: DWORD,
    dwProviderOffset: DWORD,
    dwProviderSize: DWORD,
    wcProviderData: [WCHAR; 1],
}}
pub type LPCOMMCONFIG = *mut COMMCONFIG;
pub const GMEM_FIXED: UINT = 0x0000;
pub const GMEM_MOVEABLE: UINT = 0x0002;
pub const GMEM_NOCOMPACT: UINT = 0x0010;
pub const GMEM_NODISCARD: UINT = 0x0020;
pub const GMEM_ZEROINIT: UINT = 0x0040;
pub const GMEM_MODIFY: UINT = 0x0080;
pub const GMEM_DISCARDABLE: UINT = 0x0100;
pub const GMEM_NOT_BANKED: UINT = 0x1000;
pub const GMEM_SHARE: UINT = 0x2000;
pub const GMEM_DDESHARE: UINT = 0x2000;
pub const GMEM_NOTIFY: UINT = 0x4000;
pub const GMEM_LOWER: UINT = GMEM_NOT_BANKED;
pub const GMEM_VALID_FLAGS: UINT = 0x7F72;
pub const GMEM_INVALID_HANDLE: UINT = 0x8000;
pub const GHND: UINT = GMEM_MOVEABLE | GMEM_ZEROINIT;
pub const GPTR: UINT = GMEM_FIXED | GMEM_ZEROINIT;
pub const GMEM_DISCARDED: UINT = 0x4000;
pub const GMEM_LOCKCOUNT: UINT = 0x00FF;
STRUCT!{struct MEMORYSTATUS {
    dwLength: DWORD,
    dwMemoryLoad: DWORD,
    dwTotalPhys: SIZE_T,
    dwAvailPhys: SIZE_T,
    dwTotalPageFile: SIZE_T,
    dwAvailPageFile: SIZE_T,
    dwTotalVirtual: SIZE_T,
    dwAvailVirtual: SIZE_T,
}}
pub type LPMEMORYSTATUS = *mut MEMORYSTATUS;
// NUMA_NO_PREFERRED_NODE
pub const DEBUG_PROCESS: DWORD = 0x00000001;
pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002;
pub const CREATE_SUSPENDED: DWORD = 0x00000004;
pub const DETACHED_PROCESS: DWORD = 0x00000008;
pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010;
pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020;
pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040;
pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080;
pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100;
pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200;
pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800;
pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000;
pub const CREATE_FORCEDOS: DWORD = 0x00002000;
pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000;
pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000;
pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000;
pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000;
pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000;
pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000;
pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000;
pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000;
pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000;
pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000;
pub const CREATE_NO_WINDOW: DWORD = 0x08000000;
pub const PROFILE_USER: DWORD = 0x10000000;
pub const PROFILE_KERNEL: DWORD = 0x20000000;
pub const PROFILE_SERVER: DWORD = 0x40000000;
pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000;
// STACK_SIZE_PARAM_IS_A_RESERVATION
pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN;
pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1;
pub const THREAD_PRIORITY_NORMAL: DWORD = 0;
pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX;
pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1;
pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32;
pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT;
pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE;
pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000;
pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000;
pub const VOLUME_NAME_DOS: DWORD = 0x0;
// VOLUME_NAME_*
// FILE_NAME_*
// JIT_DEBUG_*
pub const DRIVE_UNKNOWN: DWORD = 0;
pub const DRIVE_NO_ROOT_DIR: DWORD = 1;
pub const DRIVE_REMOVABLE: DWORD = 2;
pub const DRIVE_FIXED: DWORD = 3;
pub const DRIVE_REMOTE: DWORD = 4;
pub const DRIVE_CDROM: DWORD = 5;
pub const DRIVE_RAMDISK: DWORD = 6;
// pub fn GetFreeSpace();
pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000;
pub const FILE_TYPE_DISK: DWORD = 0x0001;
pub const FILE_TYPE_CHAR: DWORD = 0x0002;
pub const FILE_TYPE_PIPE: DWORD = 0x0003;
pub const FILE_TYPE_REMOTE: DWORD = 0x8000;
pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32;
pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32;
pub const NOPARITY: BYTE = 0;
pub const ODDPARITY: BYTE = 1;
pub const EVENPARITY: BYTE = 2;
pub const MARKPARITY: BYTE = 3;
pub const SPACEPARITY: BYTE = 4;
pub const ONESTOPBIT: BYTE = 0;
pub const ONE5STOPBITS: BYTE = 1;
pub const TWOSTOPBITS: BYTE = 2;
pub const IGNORE: DWORD = 0;
pub const INFINITE: DWORD = 0xFFFFFFFF;
pub const CBR_110: DWORD = 110;
pub const CBR_300: DWORD = 300;
pub const CBR_600: DWORD = 600;
pub const CBR_1200: DWORD = 1200;
pub const CBR_2400: DWORD = 2400;
pub const CBR_4800: DWORD = 4800;
pub const CBR_9600: DWORD = 9600;
pub const CBR_14400: DWORD = 14400;
pub const CBR_19200: DWORD = 19200;
pub const CBR_38400: DWORD = 38400;
pub const CBR_56000: DWORD = 56000;
pub const CBR_57600: DWORD = 57600;
pub const CBR_115200: DWORD = 115200;
pub const CBR_128000: DWORD = 128000;
pub const CBR_256000: DWORD = 256000;
// CE_*
// IE_*
// EV_*
pub const SETXOFF: DWORD = 1;
pub const SETXON: DWORD = 2;
pub const SETRTS: DWORD = 3;
pub const CLRRTS: DWORD = 4;
pub const SETDTR: DWORD = 5;
pub const CLRDTR: DWORD = 6;
pub const RESETDEV: DWORD = 7;
pub const SETBREAK: DWORD = 8;
pub const CLRBREAK: DWORD = 9;
pub const PURGE_TXABORT: DWORD = 0x0001;
pub const PURGE_RXABORT: DWORD = 0x0002;
pub const PURGE_TXCLEAR: DWORD = 0x0004;
pub const PURGE_RXCLEAR: DWORD = 0x0008;
pub const MS_CTS_ON: DWORD = 0x0010;
pub const MS_DSR_ON: DWORD = 0x0020;
pub const MS_RING_ON: DWORD = 0x0040;
pub const MS_RLSD_ON: DWORD = 0x0080;
// S_*
// NMPWAIT_*
// FS_*
// OF_*
pub const OFS_MAXPATHNAME: usize = 128;
STRUCT!{struct OFSTRUCT {
    cBytes: BYTE,
    fFixedDisk: BYTE,
    nErrCode: WORD,
    Reserved1: WORD,
    Reserved2: WORD,
    szPathName: [CHAR; OFS_MAXPATHNAME],
}}
pub type POFSTRUCT = *mut OFSTRUCT;
pub type LPOFSTRUCT = *mut OFSTRUCT;
extern "system" {
    pub fn GlobalAlloc(
        uFlags: UINT,
        dwBytes: SIZE_T,
    ) -> HGLOBAL;
    pub fn GlobalReAlloc(
        hMem: HGLOBAL,
        dwBytes: SIZE_T,
        uFlags: UINT,
    ) -> HGLOBAL;
    pub fn GlobalSize(
        hMem: HGLOBAL,
    ) -> SIZE_T;
    pub fn GlobalFlags(
        hMem: HGLOBAL,
    ) -> UINT;
    pub fn GlobalLock(
        hMem: HGLOBAL,
    ) -> LPVOID;
    pub fn GlobalHandle(
        pMem: LPCVOID,
    ) -> HGLOBAL;
    pub fn GlobalUnlock(
        hMem: HGLOBAL,
    ) -> BOOL;
    pub fn GlobalFree(
        hMem: HGLOBAL,
    ) -> HGLOBAL;
    pub fn GlobalCompact(
        dwMinFree: DWORD,
    ) -> SIZE_T;
    pub fn GlobalFix(
        hMem: HGLOBAL,
    );
    pub fn GlobalUnfix(
        hMem: HGLOBAL,
    );
    pub fn GlobalWire(
        hMem: HGLOBAL,
    ) -> LPVOID;
    pub fn GlobalUnWire(
        hMem: HGLOBAL,
    ) -> BOOL;
    pub fn GlobalMemoryStatus(
        lpBuffer: LPMEMORYSTATUS,
    );
    pub fn LocalAlloc(
        uFlags: UINT,
        uBytes: SIZE_T,
    ) -> HLOCAL;
    pub fn LocalReAlloc(
        hMem: HLOCAL,
        uBytes: SIZE_T,
        uFlags: UINT,
    ) -> HLOCAL;
    pub fn LocalLock(
        hMem: HLOCAL,
    ) -> LPVOID;
    pub fn LocalHandle(
        pMem: LPCVOID,
    ) -> HLOCAL;
    pub fn LocalUnlock(
        hMem: HLOCAL,
    ) -> BOOL;
    pub fn LocalSize(
        hMem: HLOCAL,
    ) -> SIZE_T;
    pub fn LocalFlags(
        hMem: HLOCAL,
    ) -> UINT;
    pub fn LocalFree(
        hMem: HLOCAL,
    ) -> HLOCAL;
    pub fn LocalShrink(
        hMem: HLOCAL,
        cbNewSize: UINT,
    ) -> SIZE_T;
    pub fn LocalCompact(
        uMinFree: UINT,
    ) -> SIZE_T;
}
// SCS_*
extern "system" {
    pub fn GetBinaryTypeA(
        lpApplicationName: LPCSTR,
        lpBinaryType: LPDWORD,
    ) -> BOOL;
    pub fn GetBinaryTypeW(
        lpApplicationName: LPCWSTR,
        lpBinaryType: LPDWORD,
    ) -> BOOL;
    pub fn GetShortPathNameA(
        lpszLongPath: LPCSTR,
        lpszShortPath: LPSTR,
        cchBuffer: DWORD,
    ) -> DWORD;
    pub fn GetLongPathNameTransactedA(
        lpszShortPath: LPCSTR,
        lpszLongPath: LPSTR,
        cchBuffer: DWORD,
        hTransaction: HANDLE,
    ) -> DWORD;
    pub fn GetLongPathNameTransactedW(
        lpszShortPath: LPCWSTR,
        lpszLongPath: LPWSTR,
        cchBuffer: DWORD,
        hTransaction: HANDLE,
    ) -> DWORD;
    pub fn GetProcessAffinityMask(
        hProcess: HANDLE,
        lpProcessAffinityMask: PDWORD_PTR,
        lpSystemAffinityMask: PDWORD_PTR,
    ) -> BOOL;
    pub fn SetProcessAffinityMask(
        hProcess: HANDLE,
        dwProcessAffinityMask: DWORD,
    ) -> BOOL;
    pub fn GetProcessIoCounters(
        hProcess: HANDLE,
        lpIoCounters: PIO_COUNTERS,
    ) -> BOOL;
    pub fn GetProcessWorkingSetSize(
        hProcess: HANDLE,
        lpMinimumWorkingSetSize: PSIZE_T,
        lpMaximumWorkingSetSize: PSIZE_T,
    ) -> BOOL;
    pub fn SetProcessWorkingSetSize(
        hProcess: HANDLE,
        dwMinimumWorkingSetSize: SIZE_T,
        dwMaximumWorkingSetSize: SIZE_T,
    ) -> BOOL;
    pub fn FatalExit(
        ExitCode: c_int,
    );
    pub fn SetEnvironmentStringsA(
        NewEnvironment: LPCH,
    ) -> BOOL;
    pub fn SwitchToFiber(
        lpFiber: LPVOID,
    );
    pub fn DeleteFiber(
        lpFiber: LPVOID,
    );
    pub fn ConvertFiberToThread() -> BOOL;
    pub fn CreateFiberEx(
        dwStackCommitSize: SIZE_T,
        dwStackReserveSize: SIZE_T,
        dwFlags: DWORD,
        lpStartAddress: LPFIBER_START_ROUTINE,
        lpParameter: LPVOID,
    ) -> LPVOID;
    pub fn ConvertThreadToFiberEx(
        lpParameter: LPVOID,
        dwFlags: DWORD,
    ) -> LPVOID;
    pub fn CreateFiber(
        dwStackSize: SIZE_T,
        lpStartAddress: LPFIBER_START_ROUTINE,
        lpParameter: LPVOID,
    ) -> LPVOID;
    pub fn ConvertThreadToFiber(
        lpParameter: LPVOID,
    ) -> LPVOID;
}
pub type PUMS_CONTEXT = *mut c_void;
pub type PUMS_COMPLETION_LIST = *mut c_void;
pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS;
pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS;
pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT;
STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO {
    UmsVersion: ULONG,
    CompletionList: PUMS_COMPLETION_LIST,
    SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT,
    SchedulerParam: PVOID,
}}
pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO;
STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION {
    UmsVersion: ULONG,
    ThreadUmsFlags: ULONG,
}}
BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [
    IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1],
    IsUmsWorkerThread set_IsUmsWorkerThread[1..2],
]}
pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION;
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn CreateUmsCompletionList(
        UmsCompletionList: *mut PUMS_COMPLETION_LIST,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn DequeueUmsCompletionListItems(
        UmsCompletionList: PUMS_COMPLETION_LIST,
        WaitTimeOut: DWORD,
        UmsThreadList: *mut PUMS_CONTEXT,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn GetUmsCompletionListEvent(
        UmsCompletionList: PUMS_COMPLETION_LIST,
        UmsCompletionEvent: PHANDLE,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn ExecuteUmsThread(
        UmsThread: PUMS_CONTEXT,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn UmsThreadYield(
        SchedulerParam: PVOID,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn DeleteUmsCompletionList(
        UmsCompletionList: PUMS_COMPLETION_LIST,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn GetCurrentUmsThread() -> PUMS_CONTEXT;
    #[cfg(target_pointer_width = "64")]
    pub fn GetNextUmsListItem(
        UmsContext: PUMS_CONTEXT,
    ) -> PUMS_CONTEXT;
    #[cfg(target_pointer_width = "64")]
    pub fn QueryUmsThreadInformation(
        UmsThread: PUMS_CONTEXT,
        UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
        UmsThreadInformation: PVOID,
        UmsThreadInformationLength: ULONG,
        ReturnLength: PULONG,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn SetUmsThreadInformation(
        UmsThread: PUMS_CONTEXT,
        UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
        UmsThreadInformation: PVOID,
        UmsThreadInformationLength: ULONG,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn DeleteUmsThreadContext(
        UmsThread: PUMS_CONTEXT,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn CreateUmsThreadContext(
        lpUmsThread: *mut PUMS_CONTEXT,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn EnterUmsSchedulingMode(
        SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO,
    ) -> BOOL;
    #[cfg(target_pointer_width = "64")]
    pub fn GetUmsSystemThreadInformation(
        ThreadHandle: HANDLE,
        SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION,
    ) -> BOOL;
    pub fn SetThreadAffinityMask(
        hThread: HANDLE,
        dwThreadAffinityMask: DWORD_PTR,
    ) -> DWORD_PTR;
    pub fn SetProcessDEPPolicy(
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn GetProcessDEPPolicy(
        hProcess: HANDLE,
        lpFlags: LPDWORD,
        lpPermanent: PBOOL,
    ) -> BOOL;
    pub fn RequestWakeupLatency(
        latency: LATENCY_TIME,
    ) -> BOOL;
    pub fn IsSystemResumeAutomatic() -> BOOL;
    pub fn GetThreadSelectorEntry(
        hThread: HANDLE,
        dwSelector: DWORD,
        lpSelectorEntry: LPLDT_ENTRY,
    ) -> BOOL;
    pub fn SetThreadExecutionState(
        esFlags: EXECUTION_STATE,
    ) -> EXECUTION_STATE;
    pub fn PowerCreateRequest(
        Context: PREASON_CONTEXT,
    ) -> HANDLE;
    pub fn PowerSetRequest(
        PowerRequest: HANDLE,
        RequestType: POWER_REQUEST_TYPE,
    ) -> BOOL;
    pub fn PowerClearRequest(
        PowerRequest: HANDLE,
        RequestType: POWER_REQUEST_TYPE,
    ) -> BOOL;
    pub fn RestoreLastError(
        dwErrCode: DWORD,
    );
}
pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: UCHAR = 0x1;
pub const FILE_SKIP_SET_EVENT_ON_HANDLE: UCHAR = 0x2;
extern "system" {
    pub fn SetFileCompletionNotificationModes(
        FileHandle: HANDLE,
        Flags: UCHAR,
    ) -> BOOL;
}
pub const SEM_FAILCRITICALERRORS: UINT = 0x0001;
pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004;
pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000;
extern "system" {
    pub fn Wow64GetThreadContext(
        hThread: HANDLE,
        lpContext: PWOW64_CONTEXT,
    ) -> BOOL;
    pub fn Wow64SetThreadContext(
        hThread: HANDLE,
        lpContext: *const WOW64_CONTEXT,
    ) -> BOOL;
    pub fn Wow64GetThreadSelectorEntry(
        hThread: HANDLE,
        dwSelector: DWORD,
        lpSelectorEntry: PWOW64_LDT_ENTRY,
    ) -> BOOL;
    pub fn Wow64SuspendThread(
        hThread: HANDLE,
    ) -> DWORD;
    pub fn DebugSetProcessKillOnExit(
        KillOnExit: BOOL,
    ) -> BOOL;
    pub fn DebugBreakProcess(
        Process: HANDLE,
    ) -> BOOL;
    pub fn PulseEvent(
        hEvent: HANDLE,
    ) -> BOOL;
    pub fn GlobalDeleteAtom(
        nAtom: ATOM,
    ) -> ATOM;
    pub fn InitAtomTable(
        nSize: DWORD,
    ) -> BOOL;
    pub fn DeleteAtom(
        nAtom: ATOM,
    ) -> ATOM;
    pub fn SetHandleCount(
        uNumber: UINT,
    ) -> UINT;
    pub fn RequestDeviceWakeup(
        hDevice: HANDLE,
    ) -> BOOL;
    pub fn CancelDeviceWakeupRequest(
        hDevice: HANDLE,
    ) -> BOOL;
    pub fn GetDevicePowerState(
        hDevice: HANDLE,
        pfOn: *mut BOOL,
    ) -> BOOL;
    pub fn SetMessageWaitingIndicator(
        hMsgIndicator: HANDLE,
        ulMsgCount: ULONG,
    ) -> BOOL;
    pub fn SetFileShortNameA(
        hFile: HANDLE,
        lpShortName: LPCSTR,
    ) -> BOOL;
    pub fn SetFileShortNameW(
        hFile: HANDLE,
        lpShortName: LPCWSTR,
    ) -> BOOL;
}
pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002;
extern "system" {
    pub fn LoadModule(
        lpModuleName: LPCSTR,
        lpParameterBlock: LPVOID,
    ) -> DWORD;
    pub fn WinExec(
        lpCmdLine: LPCSTR,
        uCmdShow: UINT,
    ) -> UINT;
    // ClearCommBreak
    // ClearCommError
    // SetupComm
    // EscapeCommFunction
    // GetCommConfig
    // GetCommMask
    // GetCommProperties
    // GetCommModemStatus
    // GetCommState
    // GetCommTimeouts
    // PurgeComm
    // SetCommBreak
    // SetCommConfig
    // SetCommMask
    // SetCommState
    // SetCommTimeouts
    // TransmitCommChar
    // WaitCommEvent
    pub fn SetTapePosition(
        hDevice: HANDLE,
        dwPositionMethod: DWORD,
        dwPartition: DWORD,
        dwOffsetLow: DWORD,
        dwOffsetHigh: DWORD,
        bImmediate: BOOL,
    ) -> DWORD;
    pub fn GetTapePosition(
        hDevice: HANDLE,
        dwPositionType: DWORD,
        lpdwPartition: LPDWORD,
        lpdwOffsetLow: LPDWORD,
        lpdwOffsetHigh: LPDWORD,
    ) -> DWORD;
    pub fn PrepareTape(
        hDevice: HANDLE,
        dwOperation: DWORD,
        bImmediate: BOOL,
    ) -> DWORD;
    pub fn EraseTape(
        hDevice: HANDLE,
        dwEraseType: DWORD,
        bImmediate: BOOL,
    ) -> DWORD;
    pub fn CreateTapePartition(
        hDevice: HANDLE,
        dwPartitionMethod: DWORD,
        dwCount: DWORD,
        dwSize: DWORD,
    ) -> DWORD;
    pub fn WriteTapemark(
        hDevice: HANDLE,
        dwTapemarkType: DWORD,
        dwTapemarkCount: DWORD,
        bImmediate: BOOL,
    ) -> DWORD;
    pub fn GetTapeStatus(
        hDevice: HANDLE,
    ) -> DWORD;
    pub fn GetTapeParameters(
        hDevice: HANDLE,
        dwOperation: DWORD,
        lpdwSize: LPDWORD,
        lpTapeInformation: LPVOID,
    ) -> DWORD;
    pub fn SetTapeParameters(
        hDevice: HANDLE,
        dwOperation: DWORD,
        lpTapeInformation: LPVOID,
    ) -> DWORD;
    pub fn MulDiv(
        nNumber: c_int,
        nNumerator: c_int,
        nDenominator: c_int,
    ) -> c_int;
}
ENUM!{enum DEP_SYSTEM_POLICY_TYPE {
    DEPPolicyAlwaysOff = 0,
    DEPPolicyAlwaysOn,
    DEPPolicyOptIn,
    DEPPolicyOptOut,
    DEPTotalPolicyCount,
}}
extern "system" {
    pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE;
    pub fn GetSystemRegistryQuota(
        pdwQuotaAllowed: PDWORD,
        pdwQuotaUsed: PDWORD,
    ) -> BOOL;
    pub fn FileTimeToDosDateTime(
        lpFileTime: *const FILETIME,
        lpFatDate: LPWORD,
        lpFatTime: LPWORD,
    ) -> BOOL;
    pub fn DosDateTimeToFileTime(
        wFatDate: WORD,
        wFatTime: WORD,
        lpFileTime: LPFILETIME,
    ) -> BOOL;
    pub fn FormatMessageA(
        dwFlags: DWORD,
        lpSource: LPCVOID,
        dwMessageId: DWORD,
        dwLanguageId: DWORD,
        lpBuffer: LPSTR,
        nSize: DWORD,
        Arguments: *mut va_list,
    ) -> DWORD;
    pub fn FormatMessageW(
        dwFlags: DWORD,
        lpSource: LPCVOID,
        dwMessageId: DWORD,
        dwLanguageId: DWORD,
        lpBuffer: LPWSTR,
        nSize: DWORD,
        Arguments: *mut va_list,
    ) -> DWORD;
}
pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400;
pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800;
pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000;
pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF;
pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100;
extern "system" {
    pub fn CreateMailslotA(
        lpName: LPCSTR,
        nMaxMessageSize: DWORD,
        lReadTimeout: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> HANDLE;
    pub fn CreateMailslotW(
        lpName: LPCWSTR,
        nMaxMessageSize: DWORD,
        lReadTimeout: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> HANDLE;
    pub fn GetMailslotInfo(
        hMailslot: HANDLE,
        lpMaxMessageSize: LPDWORD,
        lpNextSize: LPDWORD,
        lpMessageCount: LPDWORD,
        lpReadTimeout: LPDWORD,
    ) -> BOOL;
    pub fn SetMailslotInfo(
        hMailslot: HANDLE,
        lReadTimeout: DWORD,
    ) -> BOOL;
    // pub fn EncryptFileA();
    // pub fn EncryptFileW();
    // pub fn DecryptFileA();
    // pub fn DecryptFileW();
    // pub fn FileEncryptionStatusA();
    // pub fn FileEncryptionStatusW();
    // pub fn OpenEncryptedFileRawA();
    // pub fn OpenEncryptedFileRawW();
    // pub fn ReadEncryptedFileRaw();
    // pub fn WriteEncryptedFileRaw();
    // pub fn CloseEncryptedFileRaw();
    pub fn lstrcmpA(
        lpString1: LPCSTR,
        lpString2: LPCSTR,
    ) -> c_int;
    pub fn lstrcmpW(
        lpString1: LPCWSTR,
        lpString2: LPCWSTR,
    ) -> c_int;
    pub fn lstrcmpiA(
        lpString1: LPCSTR,
        lpString2: LPCSTR,
    ) -> c_int;
    pub fn lstrcmpiW(
        lpString1: LPCWSTR,
        lpString2: LPCWSTR,
    ) -> c_int;
    pub fn lstrcpynA(
        lpString1: LPSTR,
        lpString2: LPCSTR,
        iMaxLength: c_int,
    ) -> LPSTR;
    pub fn lstrcpynW(
        lpString1: LPWSTR,
        lpString2: LPCWSTR,
        iMaxLength: c_int,
    ) -> LPWSTR;
    pub fn lstrcpyA(
        lpString1: LPSTR,
        lpString2: LPCSTR,
    ) -> LPSTR;
    pub fn lstrcpyW(
        lpString1: LPWSTR,
        lpString2: LPCWSTR,
    ) -> LPWSTR;
    pub fn lstrcatA(
        lpString1: LPSTR,
        lpString2: LPCSTR,
    ) -> LPSTR;
    pub fn lstrcatW(
        lpString1: LPWSTR,
        lpString2: LPCWSTR,
    ) -> LPWSTR;
    pub fn lstrlenA(
        lpString: LPCSTR,
    ) -> c_int;
    pub fn lstrlenW(
        lpString: LPCWSTR,
    ) -> c_int;
    pub fn OpenFile(
        lpFileName: LPCSTR,
        lpReOpenBuff: LPOFSTRUCT,
        uStyle: UINT,
    ) -> HFILE;
    pub fn _lopen(
        lpPathName: LPCSTR,
        iReadWrite: c_int,
    ) -> HFILE;
    pub fn _lcreat(
        lpPathName: LPCSTR,
        iAttrubute: c_int,
    ) -> HFILE;
    pub fn _lread(
        hFile: HFILE,
        lpBuffer: LPVOID,
        uBytes: UINT,
    ) -> UINT;
    pub fn _lwrite(
        hFile: HFILE,
        lpBuffer: LPCCH,
        uBytes: UINT,
    ) -> UINT;
    pub fn _hread(
        hFile: HFILE,
        lpBuffer: LPVOID,
        lBytes: c_long,
    ) -> c_long;
    pub fn _hwrite(
        hFile: HFILE,
        lpBuffer: LPCCH,
        lBytes: c_long,
    ) -> c_long;
    pub fn _lclose(
        hFile: HFILE,
    ) -> HFILE;
    pub fn _llseek(
        hFile: HFILE,
        lOffset: LONG,
        iOrigin: c_int,
    ) -> LONG;
    // pub fn IsTextUnicode();
    // pub fn SignalObjectAndWait();
    pub fn BackupRead(
        hFile: HANDLE,
        lpBuffer: LPBYTE,
        nNumberOfBytesToRead: DWORD,
        lpNumberOfBytesRead: LPDWORD,
        bAbort: BOOL,
        bProcessSecurity: BOOL,
        lpContext: *mut LPVOID,
    ) -> BOOL;
    pub fn BackupSeek(
        hFile: HANDLE,
        dwLowBytesToSeek: DWORD,
        dwHighBytesToSeek: DWORD,
        lpdwLowByteSeeked: LPDWORD,
        lpdwHighByteSeeked: LPDWORD,
        lpContext: *mut LPVOID,
    ) -> BOOL;
    pub fn BackupWrite(
        hFile: HANDLE,
        lpBuffer: LPBYTE,
        nNumberOfBytesToWrite: DWORD,
        lpNumberOfBytesWritten: LPDWORD,
        bAbort: BOOL,
        bProcessSecurity: BOOL,
        lpContext: *mut LPVOID,
    ) -> BOOL;
}
//2886
pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001;
pub const STARTF_USESIZE: DWORD = 0x00000002;
pub const STARTF_USEPOSITION: DWORD = 0x00000004;
pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008;
pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010;
pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020;
pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040;
pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080;
pub const STARTF_USESTDHANDLES: DWORD = 0x00000100;
pub const STARTF_USEHOTKEY: DWORD = 0x00000200;
pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800;
pub const STARTF_TITLEISAPPID: DWORD = 0x00001000;
pub const STARTF_PREVENTPINNING: DWORD = 0x00002000;
pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000;
STRUCT!{struct STARTUPINFOEXA {
    StartupInfo: STARTUPINFOA,
    lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
}}
pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA;
STRUCT!{struct STARTUPINFOEXW {
    StartupInfo: STARTUPINFOW,
    lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
}}
pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW;
extern "system" {
    pub fn OpenMutexA(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateSemaphoreA(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
        lInitialCount: LONG,
        lMaximumCount: LONG,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn OpenSemaphoreA(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateWaitableTimerA(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
        bManualReset: BOOL,
        lpTimerName: LPCSTR,
    ) -> HANDLE;
    pub fn OpenWaitableTimerA(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        lpTimerName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateSemaphoreExA(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
        lInitialCount: LONG,
        lMaximumCount: LONG,
        lpName: LPCSTR,
        dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateWaitableTimerExA(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
        lpTimerName: LPCSTR,
        dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateFileMappingA(
        hFile: HANDLE,
        lpAttributes: LPSECURITY_ATTRIBUTES,
        flProtect: DWORD,
        dwMaximumSizeHigh: DWORD,
        dwMaximumSizeLow: DWORD,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateFileMappingNumaA(
        hFile: HANDLE,
        lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
        flProtect: DWORD,
        dwMaximumSizeHigh: DWORD,
        dwMaximumSizeLow: DWORD,
        lpName: LPCSTR,
        nndPreferred: DWORD,
    ) -> HANDLE;
    pub fn OpenFileMappingA(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn GetLogicalDriveStringsA(
        nBufferLength: DWORD,
        lpBuffer: LPSTR,
    ) -> DWORD;
    pub fn LoadPackagedLibrary(
        lpwLibFileName: LPCWSTR,
        Reserved: DWORD,
    ) -> HMODULE;
    pub fn QueryFullProcessImageNameA(
        hProcess: HANDLE,
        dwFlags: DWORD,
        lpExeName: LPSTR,
        lpdwSize: PDWORD,
    ) -> BOOL;
    pub fn QueryFullProcessImageNameW(
        hProcess: HANDLE,
        dwFlags: DWORD,
        lpExeName: LPWSTR,
        lpdwSize: PDWORD,
    ) -> BOOL;
}
//3233
extern "system" {
    pub fn GetStartupInfoA(
        lpStartupInfo: LPSTARTUPINFOA,
    );
    pub fn GetFirmwareEnvironmentVariableA(
        lpName: LPCSTR,
        lpGuid: LPCSTR,
        pBuffer: PVOID,
        nSize: DWORD,
    ) -> DWORD;
    pub fn GetFirmwareEnvironmentVariableW(
        lpName: LPCWSTR,
        lpGuid: LPCWSTR,
        pBuffer: PVOID,
        nSize: DWORD,
    ) -> DWORD;
    pub fn GetFirmwareEnvironmentVariableExA(
        lpName: LPCSTR,
        lpGuid: LPCSTR,
        pBuffer: PVOID,
        nSize: DWORD,
        pdwAttribubutes: PDWORD,
    ) -> DWORD;
    pub fn GetFirmwareEnvironmentVariableExW(
        lpName: LPCWSTR,
        lpGuid: LPCWSTR,
        pBuffer: PVOID,
        nSize: DWORD,
        pdwAttribubutes: PDWORD,
    ) -> DWORD;
    pub fn SetFirmwareEnvironmentVariableA(
        lpName: LPCSTR,
        lpGuid: LPCSTR,
        pValue: PVOID,
        nSize: DWORD,
    ) -> BOOL;
    pub fn SetFirmwareEnvironmentVariableW(
        lpName: LPCWSTR,
        lpGuid: LPCWSTR,
        pValue: PVOID,
        nSize: DWORD,
    ) -> BOOL;
    pub fn SetFirmwareEnvironmentVariableExA(
        lpName: LPCSTR,
        lpGuid: LPCSTR,
        pValue: PVOID,
        nSize: DWORD,
        dwAttributes: DWORD,
    ) -> BOOL;
    pub fn SetFirmwareEnvironmentVariableExW(
        lpName: LPCWSTR,
        lpGuid: LPCWSTR,
        pValue: PVOID,
        nSize: DWORD,
        dwAttributes: DWORD,
    ) -> BOOL;
    pub fn GetFirmwareType(
        FirmwareType: PFIRMWARE_TYPE,
    ) -> BOOL;
    pub fn IsNativeVhdBoot(
        NativeVhdBoot: PBOOL,
    ) -> BOOL;
    pub fn FindResourceA(
        hModule: HMODULE,
        lpName: LPCSTR,
        lpType: LPCSTR,
    ) -> HRSRC;
    pub fn FindResourceExA(
        hModule: HMODULE,
        lpName: LPCSTR,
        lpType: LPCSTR,
        wLanguage: WORD,
    ) -> HRSRC;
    pub fn EnumResourceTypesA(
        hModule: HMODULE,
        lpEnumFunc: ENUMRESTYPEPROCA,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceTypesW(
        hModule: HMODULE,
        lpEnumFunc: ENUMRESTYPEPROCW,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceNamesA(
        hModule: HMODULE,
        lpType: LPCSTR,
        lpEnumFunc: ENUMRESNAMEPROCA,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceLanguagesA(
        hModule: HMODULE,
        lpType: LPCSTR,
        lpName: LPCSTR,
        lpEnumFunc: ENUMRESLANGPROCA,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceLanguagesW(
        hModule: HMODULE,
        lpType: LPCWSTR,
        lpName: LPCWSTR,
        lpEnumFunc: ENUMRESLANGPROCW,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn BeginUpdateResourceA(
        pFileName: LPCSTR,
        bDeleteExistingResources: BOOL,
    ) -> HANDLE;
    pub fn BeginUpdateResourceW(
        pFileName: LPCWSTR,
        bDeleteExistingResources: BOOL,
    ) -> HANDLE;
    pub fn UpdateResourceA(
        hUpdate: HANDLE,
        lpType: LPCSTR,
        lpName: LPCSTR,
        wLanguage: WORD,
        lpData: LPVOID,
        cb: DWORD,
    ) -> BOOL;
    pub fn UpdateResourceW(
        hUpdate: HANDLE,
        lpType: LPCWSTR,
        lpName: LPCWSTR,
        wLanguage: WORD,
        lpData: LPVOID,
        cb: DWORD,
    ) -> BOOL;
    pub fn EndUpdateResourceA(
        hUpdate: HANDLE,
        fDiscard: BOOL,
    ) -> BOOL;
    pub fn EndUpdateResourceW(
        hUpdate: HANDLE,
        fDiscard: BOOL,
    ) -> BOOL;
    pub fn GlobalAddAtomA(
        lpString: LPCSTR,
    ) -> ATOM;
    pub fn GlobalAddAtomW(
        lpString: LPCWSTR,
    ) -> ATOM;
    pub fn GlobalAddAtomExA(
        lpString: LPCSTR,
        Flags: DWORD,
    ) -> ATOM;
    pub fn GlobalAddAtomExW(
        lpString: LPCWSTR,
        Flags: DWORD,
    ) -> ATOM;
    pub fn GlobalFindAtomA(
        lpString: LPCSTR,
    ) -> ATOM;
    pub fn GlobalFindAtomW(
        lpString: LPCWSTR,
    ) -> ATOM;
    pub fn GlobalGetAtomNameA(
        nAtom: ATOM,
        lpBuffer: LPSTR,
        nSize: c_int,
    ) -> UINT;
    pub fn GlobalGetAtomNameW(
        nAtom: ATOM,
        lpBuffer: LPWSTR,
        nSize: c_int,
    ) -> UINT;
    pub fn AddAtomA(
        lpString: LPCSTR,
    ) -> ATOM;
    pub fn AddAtomW(
        lpString: LPCWSTR,
    ) -> ATOM;
    pub fn FindAtomA(
        lpString: LPCSTR,
    ) -> ATOM;
    pub fn FindAtomW(
        lpString: LPCWSTR,
    ) -> ATOM;
    pub fn GetAtomNameA(
        nAtom: ATOM,
        lpBuffer: LPSTR,
        nSize: c_int,
    ) -> UINT;
    pub fn GetAtomNameW(
        nAtom: ATOM,
        lpBuffer: LPWSTR,
        nSize: c_int,
    ) -> UINT;
    pub fn GetProfileIntA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        nDefault: INT,
    ) -> UINT;
    pub fn GetProfileIntW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        nDefault: INT,
    ) -> UINT;
    pub fn GetProfileStringA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        lpDefault: LPCSTR,
        lpReturnedString: LPSTR,
        nSize: DWORD,
    ) -> DWORD;
    pub fn GetProfileStringW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        lpDefault: LPCWSTR,
        lpReturnedString: LPWSTR,
        nSize: DWORD,
    ) -> DWORD;
    pub fn WriteProfileStringA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        lpString: LPCSTR,
    ) -> BOOL;
    pub fn WriteProfileStringW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        lpString: LPCWSTR,
    ) -> BOOL;
    pub fn GetProfileSectionA(
        lpAppName: LPCSTR,
        lpReturnedString: LPSTR,
        nSize: DWORD,
    ) -> DWORD;
    pub fn GetProfileSectionW(
        lpAppName: LPCWSTR,
        lpReturnedString: LPWSTR,
        nSize: DWORD,
    ) -> DWORD;
    pub fn WriteProfileSectionA(
        lpAppName: LPCSTR,
        lpString: LPCSTR,
    ) -> BOOL;
    pub fn WriteProfileSectionW(
        lpAppName: LPCWSTR,
        lpString: LPCWSTR,
    ) -> BOOL;
    pub fn GetPrivateProfileIntA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        nDefault: INT,
        lpFileName: LPCSTR,
    ) -> UINT;
    pub fn GetPrivateProfileIntW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        nDefault: INT,
        lpFileName: LPCWSTR,
    ) -> UINT;
    pub fn GetPrivateProfileStringA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        lpDefault: LPCSTR,
        lpReturnedString: LPSTR,
        nSize: DWORD,
        lpFileName: LPCSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileStringW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        lpDefault: LPCWSTR,
        lpReturnedString: LPWSTR,
        nSize: DWORD,
        lpFileName: LPCWSTR,
    ) -> DWORD;
    pub fn WritePrivateProfileStringA(
        lpAppName: LPCSTR,
        lpKeyName: LPCSTR,
        lpString: LPCSTR,
        lpFileName: LPCSTR,
    ) -> BOOL;
    pub fn WritePrivateProfileStringW(
        lpAppName: LPCWSTR,
        lpKeyName: LPCWSTR,
        lpString: LPCWSTR,
        lpFileName: LPCWSTR,
    ) -> BOOL;
    pub fn GetPrivateProfileSectionA(
        lpAppName: LPCSTR,
        lpReturnedString: LPSTR,
        nSize: DWORD,
        lpFileName: LPCSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileSectionW(
        lpAppName: LPCWSTR,
        lpReturnedString: LPWSTR,
        nSize: DWORD,
        lpFileName: LPCWSTR,
    ) -> DWORD;
    pub fn WritePrivateProfileSectionA(
        lpAppName: LPCSTR,
        lpString: LPCSTR,
        lpFileName: LPCSTR,
    ) -> BOOL;
    pub fn WritePrivateProfileSectionW(
        lpAppName: LPCWSTR,
        lpString: LPCWSTR,
        lpFileName: LPCWSTR,
    ) -> BOOL;
    pub fn GetPrivateProfileSectionNamesA(
        lpszReturnBuffer: LPSTR,
        nSize: DWORD,
        lpFileName: LPCSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileSectionNamesW(
        lpszReturnBuffer: LPWSTR,
        nSize: DWORD,
        lpFileName: LPCWSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileStructA(
        lpszSection: LPCSTR,
        lpszKey: LPCSTR,
        lpStruct: LPVOID,
        uSizeStruct: UINT,
        szFile: LPCSTR,
    ) -> BOOL;
    pub fn GetPrivateProfileStructW(
        lpszSection: LPCWSTR,
        lpszKey: LPCWSTR,
        lpStruct: LPVOID,
        uSizeStruct: UINT,
        szFile: LPCWSTR,
    ) -> BOOL;
    pub fn WritePrivateProfileStructA(
        lpszSection: LPCSTR,
        lpszKey: LPCSTR,
        lpStruct: LPVOID,
        uSizeStruct: UINT,
        szFile: LPCSTR,
    ) -> BOOL;
    pub fn WritePrivateProfileStructW(
        lpszSection: LPCWSTR,
        lpszKey: LPCWSTR,
        lpStruct: LPVOID,
        uSizeStruct: UINT,
        szFile: LPCWSTR,
    ) -> BOOL;
    pub fn Wow64EnableWow64FsRedirection(
        Wow64FsEnableRedirection: BOOLEAN,
    ) -> BOOLEAN;
    pub fn SetDllDirectoryA(
        lpPathName: LPCSTR,
    ) -> BOOL;
    pub fn SetDllDirectoryW(
        lpPathName: LPCWSTR,
    ) -> BOOL;
    pub fn GetDllDirectoryA(
        nBufferLength: DWORD,
        lpBuffer: LPSTR,
    ) -> DWORD;
    pub fn GetDllDirectoryW(
        nBufferLength: DWORD,
        lpBuffer: LPWSTR,
    ) -> DWORD;
    pub fn SetSearchPathMode(
        Flags: DWORD,
    ) -> BOOL;
    pub fn CreateDirectoryExA(
        lpTemplateDirectory: LPCSTR,
        lpNewDirectory: LPCSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateDirectoryExW(
        lpTemplateDirectory: LPCWSTR,
        lpNewDirectory: LPCWSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateDirectoryTransactedA(
        lpTemplateDirectory: LPCSTR,
        lpNewDirectory: LPCSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn CreateDirectoryTransactedW(
        lpTemplateDirectory: LPCWSTR,
        lpNewDirectory: LPCWSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn RemoveDirectoryTransactedA(
        lpPathName: LPCSTR,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn RemoveDirectoryTransactedW(
        lpPathName: LPCWSTR,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn GetFullPathNameTransactedA(
        lpFileName: LPCSTR,
        nBufferLength: DWORD,
        lpBuffer: LPSTR,
        lpFilePart: *mut LPSTR,
        hTransaction: HANDLE,
    ) -> DWORD;
    pub fn GetFullPathNameTransactedW(
        lpFileName: LPCWSTR,
        nBufferLength: DWORD,
        lpBuffer: LPWSTR,
        lpFilePart: *mut LPWSTR,
        hTransaction: HANDLE,
    );
    pub fn DefineDosDeviceA(
        dwFlags: DWORD,
        lpDeviceName: LPCSTR,
        lpTargetPath: LPCSTR,
    ) -> BOOL;
    pub fn QueryDosDeviceA(
        lpDeviceName: LPCSTR,
        lpTargetPath: LPSTR,
        ucchMax: DWORD,
    ) -> DWORD;
    pub fn CreateFileTransactedA(
        lpFileName: LPCSTR,
        dwDesiredAccess: DWORD,
        dwShareMode: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        dwCreationDisposition: DWORD,
        dwFlagsAndAttributes: DWORD,
        hTemplateFile: HANDLE,
        hTransaction: HANDLE,
        pusMiniVersion: PUSHORT,
        lpExtendedParameter: PVOID,
    ) -> HANDLE;
    pub fn CreateFileTransactedW(
        lpFileName: LPCWSTR,
        dwDesiredAccess: DWORD,
        dwShareMode: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        dwCreationDisposition: DWORD,
        dwFlagsAndAttributes: DWORD,
        hTemplateFile: HANDLE,
        hTransaction: HANDLE,
        pusMiniVersion: PUSHORT,
        lpExtendedParameter: PVOID,
    ) -> HANDLE;
    pub fn ReOpenFile(
        hOriginalFile: HANDLE,
        dwDesiredAccess: DWORD,
        dwShareMode: DWORD,
        dwFlags: DWORD,
    ) -> HANDLE;
    pub fn SetFileAttributesTransactedA(
        lpFileName: LPCSTR,
        dwFileAttributes: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn SetFileAttributesTransactedW(
        lpFileName: LPCWSTR,
        dwFileAttributes: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn GetFileAttributesTransactedA(
        lpFileName: LPCSTR,
        fInfoLevelId: GET_FILEEX_INFO_LEVELS,
        lpFileInformation: LPVOID,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn GetFileAttributesTransactedW(
        lpFileName: LPCWSTR,
        fInfoLevelId: GET_FILEEX_INFO_LEVELS,
        lpFileInformation: LPVOID,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn GetCompressedFileSizeTransactedA(
        lpFileName: LPCSTR,
        lpFileSizeHigh: LPDWORD,
        hTransaction: HANDLE,
    ) -> DWORD;
    pub fn GetCompressedFileSizeTransactedW(
        lpFileName: LPCWSTR,
        lpFileSizeHigh: LPDWORD,
        hTransaction: HANDLE,
    );
    pub fn DeleteFileTransactedA(
        lpFileName: LPCSTR,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn DeleteFileTransactedW(
        lpFileName: LPCWSTR,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn CheckNameLegalDOS8Dot3A(
        lpName: LPCSTR,
        lpOemName: LPSTR,
        OemNameSize: DWORD,
        pbNameContainsSpaces: PBOOL,
        pbNameLegal: PBOOL,
    ) -> BOOL;
    pub fn CheckNameLegalDOS8Dot3W(
        lpName: LPCWSTR,
        lpOemName: LPSTR,
        OemNameSize: DWORD,
        pbNameContainsSpaces: PBOOL,
        pbNameLegal: PBOOL,
    ) -> BOOL;
    pub fn FindFirstFileTransactedA(
        lpFileName: LPCSTR,
        fInfoLevelId: FINDEX_INFO_LEVELS,
        lpFindFileData: LPVOID,
        fSearchOp: FINDEX_SEARCH_OPS,
        lpSearchFilter: LPVOID,
        dwAdditionalFlags: DWORD,
        hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn FindFirstFileTransactedW(
        lpFileName: LPCWSTR,
        fInfoLevelId: FINDEX_INFO_LEVELS,
        lpFindFileData: LPVOID,
        fSearchOp: FINDEX_SEARCH_OPS,
        lpSearchFilter: LPVOID,
        dwAdditionalFlags: DWORD,
        hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn CopyFileA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
        bFailIfExists: BOOL,
    ) -> BOOL;
    pub fn CopyFileW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        bFailIfExists: BOOL,
    ) -> BOOL;
}
FN!{stdcall LPPROGRESS_ROUTINE(
    TotalFileSize: LARGE_INTEGER,
    TotalBytesTransferred: LARGE_INTEGER,
    StreamSize: LARGE_INTEGER,
    StreamBytesTransferred: LARGE_INTEGER,
    dwStreamNumber: DWORD,
    dwCallbackReason: DWORD,
    hSourceFile: HANDLE,
    hDestinationFile: HANDLE,
    lpData: LPVOID,
) -> DWORD}
extern "system" {
    pub fn CopyFileExA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        pbCancel: LPBOOL,
        dwCopyFlags: DWORD,
    ) -> BOOL;
    pub fn CopyFileExW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        pbCancel: LPBOOL,
        dwCopyFlags: DWORD,
    ) -> BOOL;
    pub fn CopyFileTransactedA(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        pbCancel: LPBOOL,
        dwCopyFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn CopyFileTransactedW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        pbCancel: LPBOOL,
        dwCopyFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
}
ENUM!{enum COPYFILE2_MESSAGE_TYPE {
    COPYFILE2_CALLBACK_NONE = 0,
    COPYFILE2_CALLBACK_CHUNK_STARTED,
    COPYFILE2_CALLBACK_CHUNK_FINISHED,
    COPYFILE2_CALLBACK_STREAM_STARTED,
    COPYFILE2_CALLBACK_STREAM_FINISHED,
    COPYFILE2_CALLBACK_POLL_CONTINUE,
    COPYFILE2_CALLBACK_ERROR,
    COPYFILE2_CALLBACK_MAX,
}}
ENUM!{enum COPYFILE2_MESSAGE_ACTION {
    COPYFILE2_PROGRESS_CONTINUE = 0,
    COPYFILE2_PROGRESS_CANCEL,
    COPYFILE2_PROGRESS_STOP,
    COPYFILE2_PROGRESS_QUIET,
    COPYFILE2_PROGRESS_PAUSE,
}}
ENUM!{enum COPYFILE2_COPY_PHASE {
    COPYFILE2_PHASE_NONE = 0,
    COPYFILE2_PHASE_PREPARE_SOURCE,
    COPYFILE2_PHASE_PREPARE_DEST,
    COPYFILE2_PHASE_READ_SOURCE,
    COPYFILE2_PHASE_WRITE_DESTINATION,
    COPYFILE2_PHASE_SERVER_COPY,
    COPYFILE2_PHASE_NAMEGRAFT_COPY,
    COPYFILE2_PHASE_MAX,
}}
STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted {
    dwStreamNumber: DWORD,
    dwReserved: DWORD,
    hSourceFile: HANDLE,
    hDestinationFile: HANDLE,
    uliChunkNumber: ULARGE_INTEGER,
    uliChunkSize: ULARGE_INTEGER,
    uliStreamSize: ULARGE_INTEGER,
    uliTotalFileSize: ULARGE_INTEGER,
}}
STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished {
    dwStreamNumber: DWORD,
    dwFlags: DWORD,
    hSourceFile: HANDLE,
    hDestinationFile: HANDLE,
    uliChunkNumber: ULARGE_INTEGER,
    uliChunkSize: ULARGE_INTEGER,
    uliStreamSize: ULARGE_INTEGER,
    uliStreamBytesTransferred: ULARGE_INTEGER,
    uliTotalFileSize: ULARGE_INTEGER,
    uliTotalBytesTransferred: ULARGE_INTEGER,
}}
STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted {
    dwStreamNumber: DWORD,
    dwReserved: DWORD,
    hSourceFile: HANDLE,
    hDestinationFile: HANDLE,
    uliStreamSize: ULARGE_INTEGER,
    uliTotalFileSize: ULARGE_INTEGER,
}}
STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished {
    dwStreamNumber: DWORD,
    dwReserved: DWORD,
    hSourceFile: HANDLE,
    hDestinationFile: HANDLE,
    uliStreamSize: ULARGE_INTEGER,
    uliStreamBytesTransferred: ULARGE_INTEGER,
    uliTotalFileSize: ULARGE_INTEGER,
    uliTotalBytesTransferred: ULARGE_INTEGER,
}}
STRUCT!{struct COPYFILE2_MESSAGE_PollContinue {
    dwReserved: DWORD,
}}
STRUCT!{struct COPYFILE2_MESSAGE_Error {
    CopyPhase: COPYFILE2_COPY_PHASE,
    dwStreamNumber: DWORD,
    hrFailure: HRESULT,
    dwReserved: DWORD,
    uliChunkNumber: ULARGE_INTEGER,
    uliStreamSize: ULARGE_INTEGER,
    uliStreamBytesTransferred: ULARGE_INTEGER,
    uliTotalFileSize: ULARGE_INTEGER,
    uliTotalBytesTransferred: ULARGE_INTEGER,
}}
UNION!{union COPYFILE2_MESSAGE_Info {
    [u64; 8] [u64; 9],
    ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted,
    ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished,
    StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted,
    StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished,
    PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue,
    Error Error_mut: COPYFILE2_MESSAGE_Error,
}}
STRUCT!{struct COPYFILE2_MESSAGE {
    Type: COPYFILE2_MESSAGE_TYPE,
    dwPadding: DWORD,
    Info: COPYFILE2_MESSAGE_Info,
}}
FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE(
    pMessage: *const COPYFILE2_MESSAGE,
    pvCallbackContext: PVOID,
) -> COPYFILE2_MESSAGE_ACTION}
STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS {
    dwSize: DWORD,
    dwCopyFlags: DWORD,
    pfCancel: *mut BOOL,
    pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE,
    pvCallbackContext: PVOID,
}}
extern "system" {
    pub fn CopyFile2(
        pwszExistingFileName: PCWSTR,
        pwszNewFileName: PCWSTR,
        pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS,
    ) -> HRESULT;
    pub fn MoveFileA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
    ) -> BOOL;
    pub fn MoveFileW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
    ) -> BOOL;
    pub fn MoveFileExA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn MoveFileExW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn MoveFileWithProgressA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn MoveFileWithProgressW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        dwFlags: DWORD,
    ) -> BOOL;
    pub fn MoveFileTransactedA(
        lpExistingFileName: LPCSTR,
        lpNewFileName: LPCSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        dwFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn MoveFileTransactedW(
        lpExistingFileName: LPCWSTR,
        lpNewFileName: LPCWSTR,
        lpProgressRoutine: LPPROGRESS_ROUTINE,
        lpData: LPVOID,
        dwFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOL;
}
pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001;
pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002;
pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004;
pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008;
pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010;
pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020;
extern "system" {
    pub fn ReplaceFileA(
        lpReplacedFileName: LPCSTR,
        lpReplacementFileName: LPCSTR,
        lpBackupFileName: LPCSTR,
        dwReplaceFlags: DWORD,
        lpExclude: LPVOID,
        lpReserved: LPVOID,
    );
    pub fn ReplaceFileW(
        lpReplacedFileName: LPCWSTR,
        lpReplacementFileName: LPCWSTR,
        lpBackupFileName: LPCWSTR,
        dwReplaceFlags: DWORD,
        lpExclude: LPVOID,
        lpReserved: LPVOID,
    );
    pub fn CreateHardLinkA(
        lpFileName: LPCSTR,
        lpExistingFileName: LPCSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateHardLinkW(
        lpFileName: LPCWSTR,
        lpExistingFileName: LPCWSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateHardLinkTransactedA(
        lpFileName: LPCSTR,
        lpExistingFileName: LPCSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        hTransaction: HANDLE,
    ) -> BOOL;
    pub fn CreateHardLinkTransactedW(
        lpFileName: LPCWSTR,
        lpExistingFileName: LPCWSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        hTransaction: HANDLE,
    );
    pub fn FindFirstStreamTransactedW(
        lpFileName: LPCWSTR,
        InfoLevel: STREAM_INFO_LEVELS,
        lpFindStreamData: LPVOID,
        dwFlags: DWORD,
        hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn FindFirstFileNameTransactedW(
        lpFileName: LPCWSTR,
        dwFlags: DWORD,
        StringLength: LPDWORD,
        LinkName: PWSTR,
        hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn CreateNamedPipeA(
        lpName: LPCSTR,
        dwOpenMode: DWORD,
        dwPipeMode: DWORD,
        nMaxInstances: DWORD,
        nOutBufferSize: DWORD,
        nInBufferSize: DWORD,
        nDefaultTimeOut: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> HANDLE;
    pub fn GetNamedPipeHandleStateA(
        hNamedPipe: HANDLE,
        lpState: LPDWORD,
        lpCurInstances: LPDWORD,
        lpMaxCollectionCount: LPDWORD,
        lpCollectDataTimeout: LPDWORD,
        lpUserName: LPSTR,
        nMaxUserNameSize: DWORD,
    ) -> BOOL;
    pub fn CallNamedPipeA(
        lpNamedPipeName: LPCSTR,
        lpInBuffer: LPVOID,
        nInBufferSize: DWORD,
        lpOutBuffer: LPVOID,
        nOutBufferSize: DWORD,
        lpBytesRead: LPDWORD,
        nTimeOut: DWORD,
    ) -> BOOL;
    pub fn WaitNamedPipeA(
        lpNamedPipeName: LPCSTR,
        nTimeOut: DWORD,
    ) -> BOOL;
    pub fn GetNamedPipeClientComputerNameA(
        Pipe: HANDLE,
        ClientComputerName: LPSTR,
        ClientComputerNameLength: ULONG,
    ) -> BOOL;
    pub fn GetNamedPipeClientProcessId(
        Pipe: HANDLE,
        ClientProcessId: PULONG,
    ) -> BOOL;
    pub fn GetNamedPipeClientSessionId(
        Pipe: HANDLE,
        ClientSessionId: PULONG,
    ) -> BOOL;
    pub fn GetNamedPipeServerProcessId(
        Pipe: HANDLE,
        ServerProcessId: PULONG,
    ) -> BOOL;
    pub fn GetNamedPipeServerSessionId(
        Pipe: HANDLE,
        ServerSessionId: PULONG,
    ) -> BOOL;
    pub fn SetVolumeLabelA(
        lpRootPathName: LPCSTR,
        lpVolumeName: LPCSTR,
    ) -> BOOL;
    pub fn SetVolumeLabelW(
        lpRootPathName: LPCWSTR,
        lpVolumeName: LPCWSTR,
    ) -> BOOL;
    pub fn SetFileBandwidthReservation(
        hFile: HANDLE,
        nPeriodMilliseconds: DWORD,
        nBytesPerPeriod: DWORD,
        bDiscardable: BOOL,
        lpTransferSize: LPDWORD,
        lpNumOutstandingRequests: LPDWORD,
    ) -> BOOL;
    pub fn GetFileBandwidthReservation(
        hFile: HANDLE,
        lpPeriodMilliseconds: LPDWORD,
        lpBytesPerPeriod: LPDWORD,
        pDiscardable: LPBOOL,
        lpTransferSize: LPDWORD,
        lpNumOutstandingRequests: LPDWORD,
    ) -> BOOL;
    // pub fn ClearEventLogA();
    // pub fn ClearEventLogW();
    // pub fn BackupEventLogA();
    // pub fn BackupEventLogW();
    // pub fn CloseEventLog();
    pub fn DeregisterEventSource(
        hEventLog: HANDLE,
    ) -> BOOL;
    // pub fn NotifyChangeEventLog();
    // pub fn GetNumberOfEventLogRecords();
    // pub fn GetOldestEventLogRecord();
    // pub fn OpenEventLogA();
    // pub fn OpenEventLogW();
    pub fn RegisterEventSourceA(
        lpUNCServerName: LPCSTR,
        lpSourceName: LPCSTR,
    ) -> HANDLE;
    pub fn RegisterEventSourceW(
        lpUNCServerName: LPCWSTR,
        lpSourceName: LPCWSTR,
    ) -> HANDLE;
    // pub fn OpenBackupEventLogA();
    // pub fn OpenBackupEventLogW();
    // pub fn ReadEventLogA();
    // pub fn ReadEventLogW();
    pub fn ReportEventA(
        hEventLog: HANDLE,
        wType: WORD,
        wCategory: WORD,
        dwEventID: DWORD,
        lpUserSid: PSID,
        wNumStrings: WORD,
        dwDataSize: DWORD,
        lpStrings: *mut LPCSTR,
        lpRawData: LPVOID,
    ) -> BOOL;
    pub fn ReportEventW(
        hEventLog: HANDLE,
        wType: WORD,
        wCategory: WORD,
        dwEventID: DWORD,
        lpUserSid: PSID,
        wNumStrings: WORD,
        dwDataSize: DWORD,
        lpStrings: *mut LPCWSTR,
        lpRawData: LPVOID,
    ) -> BOOL;
    // pub fn GetEventLogInformation();
    // pub fn OperationStart();
    // pub fn OperationEnd();
    // pub fn AccessCheckAndAuditAlarmA();
    // pub fn AccessCheckByTypeAndAuditAlarmA();
    // pub fn AccessCheckByTypeResultListAndAuditAlarmA();
    // pub fn AccessCheckByTypeResultListAndAuditAlarmByHandleA();
    // pub fn ObjectOpenAuditAlarmA();
    // pub fn ObjectPrivilegeAuditAlarmA();
    // pub fn ObjectCloseAuditAlarmA();
    // pub fn ObjectDeleteAuditAlarmA();
    // pub fn PrivilegedServiceAuditAlarmA();
    // pub fn AddConditionalAce();
    // pub fn SetFileSecurityA();
    // pub fn GetFileSecurityA();
    pub fn ReadDirectoryChangesW(
        hDirectory: HANDLE,
        lpBuffer: LPVOID,
        nBufferLength: DWORD,
        bWatchSubtree: BOOL,
        dwNotifyFilter: DWORD,
        lpBytesReturned: LPDWORD,
        lpOverlapped: LPOVERLAPPED,
        lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
    ) -> BOOL;
    pub fn MapViewOfFileExNuma(
        hFileMappingObject: HANDLE,
        dwDesiredAccess: DWORD,
        dwFileOffsetHigh: DWORD,
        dwFileOffsetLow: DWORD,
        dwNumberOfBytesToMap: SIZE_T,
        lpBaseAddress: LPVOID,
        nndPreferred: DWORD,
    ) -> LPVOID;
    pub fn IsBadReadPtr(
        lp: *const VOID,
        ucb: UINT_PTR,
    ) -> BOOL;
    pub fn IsBadWritePtr(
        lp: LPVOID,
        ucb: UINT_PTR,
    ) -> BOOL;
    pub fn IsBadHugeReadPtr(
        lp: *const VOID,
        ucb: UINT_PTR,
    ) -> BOOL;
    pub fn IsBadHugeWritePtr(
        lp: LPVOID,
        ucb: UINT_PTR,
    ) -> BOOL;
    pub fn IsBadCodePtr(
        lpfn: FARPROC,
    ) -> BOOL;
    pub fn IsBadStringPtrA(
        lpsz: LPCSTR,
        ucchMax: UINT_PTR,
    ) -> BOOL;
    pub fn IsBadStringPtrW(
        lpsz: LPCWSTR,
        ucchMax: UINT_PTR,
    ) -> BOOL;
    pub fn LookupAccountSidA(
        lpSystemName: LPCSTR,
        Sid: PSID,
        Name: LPSTR,
        cchName: LPDWORD,
        ReferencedDomainName: LPSTR,
        cchReferencedDomainName: LPDWORD,
        peUse: PSID_NAME_USE,
    ) -> BOOL;
    pub fn LookupAccountSidW(
        lpSystemName: LPCWSTR,
        Sid: PSID,
        Name: LPWSTR,
        cchName: LPDWORD,
        ReferencedDomainName: LPWSTR,
        cchReferencedDomainName: LPDWORD,
        peUse: PSID_NAME_USE,
    ) -> BOOL;
    pub fn LookupAccountNameA(
        lpSystemName: LPCSTR,
        lpAccountName: LPCSTR,
        Sid: PSID,
        cbSid: LPDWORD,
        ReferencedDomainName: LPCSTR,
        cchReferencedDomainName: LPDWORD,
        peUse: PSID_NAME_USE,
    ) -> BOOL;
    pub fn LookupAccountNameW(
        lpSystemName: LPCWSTR,
        lpAccountName: LPCWSTR,
        Sid: PSID,
        cbSid: LPDWORD,
        ReferencedDomainName: LPCWSTR,
        cchReferencedDomainName: LPDWORD,
        peUse: PSID_NAME_USE,
    ) -> BOOL;
    // pub fn LookupAccountNameLocalA();
    // pub fn LookupAccountNameLocalW();
    // pub fn LookupAccountSidLocalA();
    // pub fn LookupAccountSidLocalW();
    pub fn LookupPrivilegeValueA(
        lpSystemName: LPCSTR,
        lpName: LPCSTR,
        lpLuid: PLUID,
    ) -> BOOL;
    pub fn LookupPrivilegeValueW(
        lpSystemName: LPCWSTR,
        lpName: LPCWSTR,
        lpLuid: PLUID,
    ) -> BOOL;
    pub fn LookupPrivilegeNameA(
        lpSystemName: LPCSTR,
        lpLuid: PLUID,
        lpName: LPSTR,
        cchName: LPDWORD,
    ) -> BOOL;
    pub fn LookupPrivilegeNameW(
        lpSystemName: LPCWSTR,
        lpLuid: PLUID,
        lpName: LPWSTR,
        cchName: LPDWORD,
    ) -> BOOL;
    pub fn LookupPrivilegeDisplayNameA(
        lpSystemName: LPCSTR,
        lpName: LPCSTR,
        lpDisplayName: LPSTR,
        cchDisplayName: LPDWORD,
        lpLanguageId: LPDWORD,
    ) -> BOOL;
    pub fn LookupPrivilegeDisplayNameW(
        lpSystemName: LPCWSTR,
        lpName: LPCWSTR,
        lpDisplayName: LPWSTR,
        cchDisplayName: LPDWORD,
        lpLanguageId: LPDWORD,
    ) -> BOOL;
    pub fn BuildCommDCBA(
        lpDef: LPCSTR,
        lpDCB: LPDCB,
    ) -> BOOL;
    pub fn BuildCommDCBW(
        lpDef: LPCWSTR,
        lpDCB: LPDCB,
    ) -> BOOL;
    pub fn BuildCommDCBAndTimeoutsA(
        lpDef: LPCSTR,
        lpDCB: LPDCB,
        lpCommTimeouts: LPCOMMTIMEOUTS,
    ) -> BOOL;
    pub fn BuildCommDCBAndTimeoutsW(
        lpDef: LPCWSTR,
        lpDCB: LPDCB,
        lpCommTimeouts: LPCOMMTIMEOUTS,
    ) -> BOOL;
    pub fn CommConfigDialogA(
        lpszName: LPCSTR,
        hWnd: HWND,
        lpCC: LPCOMMCONFIG,
    ) -> BOOL;
    pub fn CommConfigDialogW(
        lpszName: LPCWSTR,
        hWnd: HWND,
        lpCC: LPCOMMCONFIG,
    ) -> BOOL;
    pub fn GetDefaultCommConfigA(
        lpszName: LPCSTR,
        lpCC: LPCOMMCONFIG,
        lpdwSize: LPDWORD,
    ) -> BOOL;
    pub fn GetDefaultCommConfigW(
        lpszName: LPCWSTR,
        lpCC: LPCOMMCONFIG,
        lpdwSize: LPDWORD,
    ) -> BOOL;
    pub fn SetDefaultCommConfigA(
        lpszName: LPCSTR,
        lpCC: LPCOMMCONFIG,
        dwSize: DWORD,
    ) -> BOOL;
    pub fn SetDefaultCommConfigW(
        lpszName: LPCWSTR,
        lpCC: LPCOMMCONFIG,
        dwSize: DWORD,
    ) -> BOOL;
    pub fn GetComputerNameA(
        lpBuffer: LPSTR,
        nSize: LPDWORD,
    ) -> BOOL;
    pub fn GetComputerNameW(
        lpBuffer: LPWSTR,
        nSize: LPDWORD,
    ) -> BOOL;
    pub fn DnsHostnameToComputerNameA(
        Hostname: LPCSTR,
        ComputerName: LPCSTR,
        nSize: LPDWORD,
    ) -> BOOL;
    pub fn DnsHostnameToComputerNameW(
        Hostname: LPCWSTR,
        ComputerName: LPWSTR,
        nSize: LPDWORD,
    ) -> BOOL;
    pub fn GetUserNameA(
        lpBuffer: LPSTR,
        pcbBuffer: LPDWORD,
    ) -> BOOL;
    pub fn GetUserNameW(
        lpBuffer: LPWSTR,
        pcbBuffer: LPDWORD,
    ) -> BOOL;
}
pub const LOGON32_LOGON_INTERACTIVE: DWORD = 2;
pub const LOGON32_LOGON_NETWORK: DWORD = 3;
pub const LOGON32_LOGON_BATCH: DWORD = 4;
pub const LOGON32_LOGON_SERVICE: DWORD = 5;
pub const LOGON32_LOGON_UNLOCK: DWORD = 7;
pub const LOGON32_LOGON_NETWORK_CLEARTEXT: DWORD = 8;
pub const LOGON32_LOGON_NEW_CREDENTIALS: DWORD = 9;
pub const LOGON32_PROVIDER_DEFAULT: DWORD = 0;
pub const LOGON32_PROVIDER_WINNT35: DWORD = 1;
pub const LOGON32_PROVIDER_WINNT40: DWORD = 2;
pub const LOGON32_PROVIDER_WINNT50: DWORD = 3;
pub const LOGON32_PROVIDER_VIRTUAL: DWORD = 4;
extern "system" {
    pub fn LogonUserA(
        lpUsername: LPCSTR,
        lpDomain: LPCSTR,
        lpPassword: LPCSTR,
        dwLogonType: DWORD,
        dwLogonProvider: DWORD,
        phToken: PHANDLE,
    ) -> BOOL;
    pub fn LogonUserW(
        lpUsername: LPCWSTR,
        lpDomain: LPCWSTR,
        lpPassword: LPCWSTR,
        dwLogonType: DWORD,
        dwLogonProvider: DWORD,
        phToken: PHANDLE,
    ) -> BOOL;
    pub fn LogonUserExA(
        lpUsername: LPCSTR,
        lpDomain: LPCSTR,
        lpPassword: LPCSTR,
        dwLogonType: DWORD,
        dwLogonProvider: DWORD,
        phToken: PHANDLE,
        ppLogonSid: *mut PSID,
        ppProfileBuffer: *mut PVOID,
        pdwProfileLength: LPDWORD,
        pQuotaLimits: PQUOTA_LIMITS,
    ) -> BOOL;
    pub fn LogonUserExW(
        lpUsername: LPCWSTR,
        lpDomain: LPCWSTR,
        lpPassword: LPCWSTR,
        dwLogonType: DWORD,
        dwLogonProvider: DWORD,
        phToken: PHANDLE,
        ppLogonSid: *mut PSID,
        ppProfileBuffer: *mut PVOID,
        pdwProfileLength: LPDWORD,
        pQuotaLimits: PQUOTA_LIMITS,
    ) -> BOOL;
}
pub const LOGON_WITH_PROFILE: DWORD = 0x00000001;
pub const LOGON_NETCREDENTIALS_ONLY: DWORD = 0x00000002;
extern "system" {
    pub fn CreateProcessWithLogonW(
        lpUsername: LPCWSTR,
        lpDomain: LPCWSTR,
        lpPassword: LPCWSTR,
        dwLogonFlags: DWORD,
        lpApplicationName: LPCWSTR,
        lpCommandLine: LPWSTR,
        dwCreationFlags: DWORD,
        lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCWSTR,
        lpStartupInfo: LPSTARTUPINFOW,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn CreateProcessWithTokenW(
        hToken: HANDLE,
        dwLogonFlags: DWORD,
        lpApplicationName: LPCWSTR,
        lpCommandLine: LPWSTR,
        dwCreationFlags: DWORD,
        lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCWSTR,
        lpStartupInfo: LPSTARTUPINFOW,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn IsTokenUntrusted(
        TokenHandle: HANDLE,
    ) -> BOOL;
    pub fn RegisterWaitForSingleObject(
        phNewWaitObject: PHANDLE,
        hObject: HANDLE,
        Callback: WAITORTIMERCALLBACK,
        Context: PVOID,
        dwMilliseconds: ULONG,
        dwFlags: ULONG,
    ) -> BOOL;
    pub fn UnregisterWait(
        WaitHandle: HANDLE,
    ) -> BOOL;
    pub fn BindIoCompletionCallback(
        FileHandle: HANDLE,
        Function: LPOVERLAPPED_COMPLETION_ROUTINE,
        Flags: ULONG,
    ) -> BOOL;
    pub fn SetTimerQueueTimer(
        TimerQueue: HANDLE,
        Callback: WAITORTIMERCALLBACK,
        Parameter: PVOID,
        DueTime: DWORD,
        Period: DWORD,
        PreferIo: BOOL,
    ) -> HANDLE;
    pub fn CancelTimerQueueTimer(
        TimerQueue: HANDLE,
        Timer: HANDLE,
    ) -> BOOL;
    pub fn DeleteTimerQueue(
        TimerQueue: HANDLE,
    ) -> BOOL;
    // pub fn InitializeThreadpoolEnvironment();
    // pub fn SetThreadpoolCallbackPool();
    // pub fn SetThreadpoolCallbackCleanupGroup();
    // pub fn SetThreadpoolCallbackRunsLong();
    // pub fn SetThreadpoolCallbackLibrary();
    // pub fn SetThreadpoolCallbackPriority();
    // pub fn DestroyThreadpoolEnvironment();
    // pub fn SetThreadpoolCallbackPersistent();
    pub fn CreatePrivateNamespaceA(
        lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES,
        lpBoundaryDescriptor: LPVOID,
        lpAliasPrefix: LPCSTR,
    ) -> HANDLE;
    pub fn OpenPrivateNamespaceA(
        lpBoundaryDescriptor: LPVOID,
        lpAliasPrefix: LPCSTR,
    ) -> HANDLE;
    pub fn CreateBoundaryDescriptorA(
        Name: LPCSTR,
        Flags: ULONG,
    ) -> HANDLE;
    pub fn AddIntegrityLabelToBoundaryDescriptor(
        BoundaryDescriptor: *mut HANDLE,
        IntegrityLabel: PSID,
    ) -> BOOL;
}
pub const HW_PROFILE_GUIDLEN: usize = 39;
// MAX_PROFILE_LEN
pub const DOCKINFO_UNDOCKED: DWORD = 0x1;
pub const DOCKINFO_DOCKED: DWORD = 0x2;
pub const DOCKINFO_USER_SUPPLIED: DWORD = 0x4;
pub const DOCKINFO_USER_UNDOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED;
pub const DOCKINFO_USER_DOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;
STRUCT!{struct HW_PROFILE_INFOA {
    dwDockInfo: DWORD,
    szHwProfileGuid: [CHAR; HW_PROFILE_GUIDLEN],
    szHwProfileName: [CHAR; MAX_PROFILE_LEN],
}}
pub type LPHW_PROFILE_INFOA = *mut HW_PROFILE_INFOA;
STRUCT!{struct HW_PROFILE_INFOW {
    dwDockInfo: DWORD,
    szHwProfileGuid: [WCHAR; HW_PROFILE_GUIDLEN],
    szHwProfileName: [WCHAR; MAX_PROFILE_LEN],
}}
pub type LPHW_PROFILE_INFOW = *mut HW_PROFILE_INFOW;
extern "system" {
    pub fn GetCurrentHwProfileA(
        lpHwProfileInfo: LPHW_PROFILE_INFOA,
    ) -> BOOL;
    pub fn GetCurrentHwProfileW(
        lpHwProfileInfo: LPHW_PROFILE_INFOW,
    ) -> BOOL;
    pub fn VerifyVersionInfoA(
        lpVersionInformation: LPOSVERSIONINFOEXA,
        dwTypeMask: DWORD,
        dwlConditionMask: DWORDLONG,
    ) -> BOOL;
    pub fn VerifyVersionInfoW(
        lpVersionInformation: LPOSVERSIONINFOEXW,
        dwTypeMask: DWORD,
        dwlConditionMask: DWORDLONG,
    ) -> BOOL;
}
STRUCT!{struct SYSTEM_POWER_STATUS {
    ACLineStatus: BYTE,
    BatteryFlag: BYTE,
    BatteryLifePercent: BYTE,
    Reserved1: BYTE,
    BatteryLifeTime: DWORD,
    BatteryFullLifeTime: DWORD,
}}
pub type LPSYSTEM_POWER_STATUS = *mut SYSTEM_POWER_STATUS;
extern "system" {
    pub fn GetSystemPowerStatus(
        lpSystemPowerStatus: LPSYSTEM_POWER_STATUS,
    ) -> BOOL;
    pub fn SetSystemPowerState(
        fSuspend: BOOL,
        fForce: BOOL,
    ) -> BOOL;
    pub fn MapUserPhysicalPagesScatter(
        VirtualAddresses: *mut PVOID,
        NumberOfPages: ULONG_PTR,
        PageArray: PULONG_PTR,
    ) -> BOOL;
    pub fn CreateJobObjectA(
        lpJobAttributes: LPSECURITY_ATTRIBUTES,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn OpenJobObjectA(
        dwDesiredAccess: DWORD,
        bInheritHandle: BOOL,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateJobSet(
        NumJob: ULONG,
        UserJobSet: PJOB_SET_ARRAY,
        Flags: ULONG,
    ) -> BOOL;
    pub fn FindFirstVolumeA(
        lpszVolumeName: LPSTR,
        cchBufferLength: DWORD,
    ) -> HANDLE;
    pub fn FindNextVolumeA(
        hFindVolume: HANDLE,
        lpszVolumeName: LPSTR,
        cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindFirstVolumeMountPointA(
        lpszRootPathName: LPCSTR,
        lpszVolumeMountPoint: LPSTR,
        cchBufferLength: DWORD,
    ) -> HANDLE;
    pub fn FindFirstVolumeMountPointW(
        lpszRootPathName: LPCWSTR,
        lpszVolumeMountPoint: LPWSTR,
        cchBufferLength: DWORD,
    ) -> HANDLE;
    pub fn FindNextVolumeMountPointA(
        hFindVolumeMountPoint: HANDLE,
        lpszVolumeMountPoint: LPSTR,
        cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindNextVolumeMountPointW(
        hFindVolumeMountPoint: HANDLE,
        lpszVolumeMountPoint: LPWSTR,
        cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindVolumeMountPointClose(
        hFindVolumeMountPoint: HANDLE,
    ) -> BOOL;
    pub fn SetVolumeMountPointA(
        lpszVolumeMountPoint: LPCSTR,
        lpszVolumeName: LPCSTR,
    ) -> BOOL;
    pub fn SetVolumeMountPointW(
        lpszVolumeMountPoint: LPCWSTR,
        lpszVolumeName: LPCWSTR,
    ) -> BOOL;
    pub fn DeleteVolumeMountPointA(
        lpszVolumeMountPoint: LPCSTR,
    ) -> BOOL;
    pub fn GetVolumeNameForVolumeMountPointA(
        lpszVolumeMountPoint: LPCSTR,
        lpszVolumeName: LPSTR,
        cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumePathNameA(
        lpszFileName: LPCSTR,
        lpszVolumePathName: LPSTR,
        cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumePathNamesForVolumeNameA(
        lpszVolumeName: LPCSTR,
        lpszVolumePathNames: LPCH,
        cchBufferLength: DWORD,
        lpcchReturnLength: PDWORD,
    ) -> BOOL;
}
// ACTCTX_FLAG_*
STRUCT!{struct ACTCTXA {
    cbSize: ULONG,
    dwFlags: DWORD,
    lpSource: LPCSTR,
    wProcessorArchitecture: USHORT,
    wLangId: LANGID,
    lpAssemblyDirectory: LPCSTR,
    lpResourceName: LPCSTR,
    lpApplicationName: LPCSTR,
    hModule: HMODULE,
}}
pub type PACTCTXA = *mut ACTCTXA;
STRUCT!{struct ACTCTXW {
    cbSize: ULONG,
    dwFlags: DWORD,
    lpSource: LPCWSTR,
    wProcessorArchitecture: USHORT,
    wLangId: LANGID,
    lpAssemblyDirectory: LPCWSTR,
    lpResourceName: LPCWSTR,
    lpApplicationName: LPCWSTR,
    hModule: HMODULE,
}}
pub type PACTCTXW = *mut ACTCTXW;
pub type PCACTCTXA = *const ACTCTXA;
pub type PCACTCTXW = *const ACTCTXW;
extern "system" {
    pub fn CreateActCtxA(
        pActCtx: PCACTCTXA,
    ) -> HANDLE;
    pub fn CreateActCtxW(
        pActCtx: PCACTCTXW,
    ) -> HANDLE;
    pub fn AddRefActCtx(
        hActCtx: HANDLE,
    );
    pub fn ReleaseActCtx(
        hActCtx: HANDLE,
    );
    pub fn ZombifyActCtx(
        hActCtx: HANDLE,
    ) -> BOOL;
    pub fn ActivateActCtx(
        hActCtx: HANDLE,
        lpCookie: *mut ULONG_PTR,
    ) -> BOOL;
    pub fn DeactivateActCtx(
        dwFlags: DWORD,
        ulCookie: ULONG_PTR,
    ) -> BOOL;
    pub fn GetCurrentActCtx(
        lphActCtx: *mut HANDLE,
    ) -> BOOL;
}
STRUCT!{struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
    lpInformation: PVOID,
    lpSectionBase: PVOID,
    ulSectionLength: ULONG,
    lpSectionGlobalDataBase: PVOID,
    ulSectionGlobalDataLength: ULONG,
}}
pub type PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
    *mut ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
pub type PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
    *const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
STRUCT!{struct ACTCTX_SECTION_KEYED_DATA {
    cbSize: ULONG,
    ulDataFormatVersion: ULONG,
    lpData: PVOID,
    ulLength: ULONG,
    lpSectionGlobalData: PVOID,
    ulSectionGlobalDataLength: ULONG,
    lpSectionBase: PVOID,
    ulSectionTotalLength: ULONG,
    hActCtx: HANDLE,
    ulAssemblyRosterIndex: ULONG,
    ulFlags: ULONG,
    AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
}}
pub type PACTCTX_SECTION_KEYED_DATA = *mut ACTCTX_SECTION_KEYED_DATA;
pub type PCACTCTX_SECTION_KEYED_DATA = *const ACTCTX_SECTION_KEYED_DATA;
extern "system" {
    pub fn FindActCtxSectionStringA(
        dwFlags: DWORD,
        lpExtensionGuid: *const GUID,
        ulSectionId: ULONG,
        lpStringToFind: LPCSTR,
        ReturnedData: PACTCTX_SECTION_KEYED_DATA,
    ) -> BOOL;
    pub fn FindActCtxSectionStringW(
        dwFlags: DWORD,
        lpExtensionGuid: *const GUID,
        ulSectionId: ULONG,
        lpStringToFind: LPCWSTR,
        ReturnedData: PACTCTX_SECTION_KEYED_DATA,
    ) -> BOOL;
    pub fn FindActCtxSectionGuid(
        dwFlags: DWORD,
        lpExtensionGuid: *const GUID,
        ulSectionId: ULONG,
        lpGuidToFind: *const GUID,
        ReturnedData: PACTCTX_SECTION_KEYED_DATA,
    ) -> BOOL;
    pub fn QueryActCtxW(
        dwFlags: DWORD,
        hActCtx: HANDLE,
        pvSubInstance: PVOID,
        ulInfoClass: ULONG,
        pvBuffer: PVOID,
        cbBuffer: SIZE_T,
        pcbWrittenOrRequired: *mut SIZE_T,
    ) -> BOOL;
    pub fn WTSGetActiveConsoleSessionId() -> DWORD;
    // pub fn WTSGetServiceSessionId();
    // pub fn WTSIsServerContainer();
    pub fn GetActiveProcessorGroupCount() -> WORD;
    pub fn GetMaximumProcessorGroupCount() -> WORD;
    pub fn GetActiveProcessorCount(
        GroupNumber: WORD,
    ) -> DWORD;
    pub fn GetMaximumProcessorCount(
        GroupNumber: WORD,
    ) -> DWORD;
    pub fn GetNumaProcessorNode(
        Processor: UCHAR,
        NodeNumber: PUCHAR,
    ) -> BOOL;
    pub fn GetNumaNodeNumberFromHandle(
        hFile: HANDLE,
        NodeNumber: PUSHORT,
    ) -> BOOL;
    pub fn GetNumaProcessorNodeEx(
        Processor: PPROCESSOR_NUMBER,
        NodeNumber: PUSHORT,
    ) -> BOOL;
    pub fn GetNumaNodeProcessorMask(
        Node: UCHAR,
        ProcessorMask: PULONGLONG,
    ) -> BOOL;
    pub fn GetNumaAvailableMemoryNode(
        Node: UCHAR,
        AvailableBytes: PULONGLONG,
    ) -> BOOL;
    pub fn GetNumaAvailableMemoryNodeEx(
        Node: USHORT,
        AvailableBytes: PULONGLONG,
    ) -> BOOL;
    pub fn GetNumaProximityNode(
        ProximityId: ULONG,
        NodeNumber: PUCHAR,
    ) -> BOOL;
}
FN!{stdcall APPLICATION_RECOVERY_CALLBACK(
    pvParameter: PVOID,
) -> DWORD}
// RESTART_*
// RECOVERY_*
extern "system" {
    pub fn RegisterApplicationRecoveryCallback(
        pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK,
        pvParameter: PVOID,
        dwPingInterval: DWORD,
        dwFlags: DWORD,
    ) -> HRESULT;
    pub fn UnregisterApplicationRecoveryCallback() -> HRESULT;
    pub fn RegisterApplicationRestart(
        pwzCommandline: PCWSTR,
        dwFlags: DWORD,
    ) -> HRESULT;
    pub fn UnregisterApplicationRestart() -> HRESULT;
    pub fn GetApplicationRecoveryCallback(
        hProcess: HANDLE,
        pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK,
        ppvParameter: *mut PVOID,
        pdwPingInterval: PDWORD,
        pdwFlags: PDWORD,
    ) -> HRESULT;
    pub fn GetApplicationRestartSettings(
        hProcess: HANDLE,
        pwzCommandline: PWSTR,
        pcchSize: PDWORD,
        pdwFlags: PDWORD,
    ) -> HRESULT;
    pub fn ApplicationRecoveryInProgress(
        pbCancelled: PBOOL,
    ) -> HRESULT;
    pub fn ApplicationRecoveryFinished(
        bSuccess: BOOL,
    );
}
// FILE_BASIC_INFO, etc.
extern "system" {
    pub fn GetFileInformationByHandleEx(
        hFile: HANDLE,
        FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
        lpFileInformation: LPVOID,
        dwBufferSize: DWORD,
    ) -> BOOL;
}
ENUM!{enum FILE_ID_TYPE {
    FileIdType,
    ObjectIdType,
    ExtendedFileIdType,
    MaximumFileIdType,
}}
UNION!{union FILE_ID_DESCRIPTOR_u {
    [u64; 2],
    FileId FileId_mut: LARGE_INTEGER,
    ObjectId ObjectId_mut: GUID,
    ExtendedFileId ExtendedFileId_mut: FILE_ID_128,
}}
STRUCT!{struct FILE_ID_DESCRIPTOR {
    dwSize: DWORD,
    Type: FILE_ID_TYPE,
    u: FILE_ID_DESCRIPTOR_u,
}}
pub type LPFILE_ID_DESCRIPTOR = *mut FILE_ID_DESCRIPTOR;
extern "system" {
    pub fn OpenFileById(
        hVolumeHint: HANDLE,
        lpFileId: LPFILE_ID_DESCRIPTOR,
        dwDesiredAccess: DWORD,
        dwShareMode: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        dwFlagsAndAttributes: DWORD,
    ) -> HANDLE;
    pub fn CreateSymbolicLinkA(
        lpSymlinkFileName: LPCSTR,
        lpTargetFileName: LPCSTR,
        dwFlags: DWORD,
    ) -> BOOLEAN;
    pub fn CreateSymbolicLinkW(
        lpSymlinkFileName: LPCWSTR,
        lpTargetFileName: LPCWSTR,
        dwFlags: DWORD,
    ) -> BOOLEAN;
    pub fn QueryActCtxSettingsW(
        dwFlags: DWORD,
        hActCtx: HANDLE,
        settingsNameSpace: PCWSTR,
        settingName: PCWSTR,
        pvBuffer: PWSTR,
        dwBuffer: SIZE_T,
        pdwWrittenOrRequired: *mut SIZE_T,
    ) -> BOOL;
    pub fn CreateSymbolicLinkTransactedA(
        lpSymlinkFileName: LPCSTR,
        lpTargetFileName: LPCSTR,
        dwFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOLEAN;
    pub fn CreateSymbolicLinkTransactedW(
        lpSymlinkFileName: LPCWSTR,
        lpTargetFileName: LPCWSTR,
        dwFlags: DWORD,
        hTransaction: HANDLE,
    ) -> BOOLEAN;
    pub fn ReplacePartitionUnit(
        TargetPartition: PWSTR,
        SparePartition: PWSTR,
        Flags: ULONG,
    ) -> BOOL;
    pub fn AddSecureMemoryCacheCallback(
        pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK,
    ) -> BOOL;
    pub fn RemoveSecureMemoryCacheCallback(
        pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK,
    ) -> BOOL;
    pub fn CopyContext(
        Destination: PCONTEXT,
        ContextFlags: DWORD,
        Source: PCONTEXT,
    ) -> BOOL;
    pub fn InitializeContext(
        Buffer: PVOID,
        ContextFlags: DWORD,
        Context: *mut PCONTEXT,
        ContextLength: PDWORD,
    ) -> BOOL;
    pub fn GetEnabledXStateFeatures() -> DWORD64;
    pub fn GetXStateFeaturesMask(
        Context: PCONTEXT,
        FeatureMask: PDWORD64,
    ) -> BOOL;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn LocateXStateFeature(
        Context: PCONTEXT,
        FeatureId: DWORD,
        Length: PDWORD,
    ) -> PVOID;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn SetXStateFeaturesMask(
        Context: PCONTEXT,
        FeatureMask: DWORD64,
    ) -> BOOL;
    pub fn EnableThreadProfiling(
        ThreadHandle: HANDLE,
        Flags: DWORD,
        HardwareCounters: DWORD64,
        PerformanceDataHandle: *mut HANDLE,
    ) -> BOOL;
    pub fn DisableThreadProfiling(
        PerformanceDataHandle: HANDLE,
    ) -> DWORD;
    pub fn QueryThreadProfiling(
        ThreadHandle: HANDLE,
        Enabled: PBOOLEAN,
    ) -> DWORD;
    pub fn ReadThreadProfilingData(
        PerformanceDataHandle: HANDLE,
        Flags: DWORD,
        PerformanceData: PPERFORMANCE_DATA,
    ) -> DWORD;
    // intrinsic InterlockedIncrement
    // intrinsic InterlockedDecrement
    // intrinsic InterlockedExchange
    // intrinsic InterlockedExchangeAdd
    // intrinsic InterlockedExchangeSubtract
    // intrinsic InterlockedCompareExchange
    // intrinsic InterlockedAnd
    // intrinsic InterlockedOr
    // intrinsic InterlockedXor
}