kernel32-sys-0.2.2/src/lib.rs

// Copyright © 2015, Peter Atashian
// Licensed under the MIT License <LICENSE.md>
//! FFI bindings to kernel32.
#![cfg(windows)]
extern crate winapi;
use winapi::*;
extern "system" {
    pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK);
    pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK);
    pub fn ActivateActCtx(hActCtx: HANDLE, lpCookie: *mut ULONG_PTR) -> BOOL;
    pub fn AddAtomA(lpString: LPCSTR) -> ATOM;
    pub fn AddAtomW(lpString: LPCWSTR) -> ATOM;
    pub fn AddConsoleAliasA(Source: LPSTR, Target: LPSTR, ExeName: LPSTR) -> BOOL;
    pub fn AddConsoleAliasW(Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR) -> BOOL;
    pub fn AddDllDirectory(NewDirectory: PCWSTR) -> DLL_DIRECTORY_COOKIE;
    pub fn AddIntegrityLabelToBoundaryDescriptor(
        BoundaryDescriptor: *mut HANDLE, IntegrityLabel: PSID,
    ) -> BOOL;
    // pub fn AddLocalAlternateComputerNameA();
    // pub fn AddLocalAlternateComputerNameW();
    pub fn AddRefActCtx(hActCtx: HANDLE);
    pub fn AddResourceAttributeAce(
        pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID,
        pAttributeInfo: PCLAIM_SECURITY_ATTRIBUTES_INFORMATION, pReturnLength: PDWORD,
    ) -> BOOL;
    pub fn AddSIDToBoundaryDescriptor(BoundaryDescriptor: *mut HANDLE, RequiredSid: PSID) -> BOOL;
    pub fn AddScopedPolicyIDAce(
        pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID,
    ) -> BOOL;
    pub fn AddSecureMemoryCacheCallback(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK) -> BOOL;
    pub fn AddVectoredContinueHandler(First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER) -> PVOID;
    pub fn AddVectoredExceptionHandler(
        First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER,
    ) -> PVOID;
    pub fn AllocConsole() -> BOOL;
    pub fn AllocateUserPhysicalPages(
        hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR,
    ) -> BOOL;
    pub fn AllocateUserPhysicalPagesNuma(
        hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD,
    ) -> BOOL;
    // pub fn AppXGetOSMaxVersionTested();
    pub fn ApplicationRecoveryFinished(bSuccess: BOOL);
    pub fn ApplicationRecoveryInProgress(pbCancelled: PBOOL) -> HRESULT;
    pub fn AreFileApisANSI() -> BOOL;
    pub fn AssignProcessToJobObject(hJob: HANDLE, hProcess: HANDLE) -> BOOL;
    pub fn AttachConsole(dwProcessId: DWORD) -> BOOL;
    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;
    // pub fn BaseSetLastNTError();
    pub fn Beep(dwFreq: DWORD, dwDuration: DWORD) -> BOOL;
    pub fn BeginUpdateResourceA(pFileName: LPCSTR, bDeleteExistingResources: BOOL) -> HANDLE;
    pub fn BeginUpdateResourceW(pFileName: LPCWSTR, bDeleteExistingResources: BOOL) -> HANDLE;
    pub fn BindIoCompletionCallback(
        FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG,
    ) -> BOOL;
    pub fn BuildCommDCBA(lpDef: LPCSTR, 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 BuildCommDCBW(lpDef: LPCWSTR, lpDCB: LPDCB) -> BOOL;
    pub fn CallNamedPipeA(
        lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
        nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD,
    ) -> BOOL;
    pub fn CallNamedPipeW(
        lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
        nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD,
    ) -> BOOL;
    pub fn CallbackMayRunLong(pci: PTP_CALLBACK_INSTANCE) -> BOOL;
    pub fn CalloutOnFiberStack(
        lpFiber: PVOID, lpStartAddress: PFIBER_CALLOUT_ROUTINE, lpParameter: PVOID,
    ) -> PVOID;
    pub fn CancelDeviceWakeupRequest(hDevice: HANDLE) -> BOOL;
    pub fn CancelIo(hFile: HANDLE) -> BOOL;
    pub fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL;
    pub fn CancelSynchronousIo(hThread: HANDLE) -> BOOL;
    pub fn CancelThreadpoolIo(pio: PTP_IO);
    pub fn CancelTimerQueueTimer(TimerQueue: HANDLE, Timer: HANDLE) -> BOOL;
    pub fn CancelWaitableTimer(hTimer: HANDLE) -> BOOL;
    pub fn CeipIsOptedIn() -> BOOL;
    pub fn ChangeTimerQueueTimer(
        TimerQueue: HANDLE, Timer: HANDLE, DueTime: ULONG, Period: ULONG,
    ) -> BOOL;
    // pub fn CheckElevation();
    // pub fn CheckElevationEnabled();
    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 CheckRemoteDebuggerPresent(hProcess: HANDLE, pbDebuggerPresent: PBOOL) -> BOOL;
    pub fn CheckTokenCapability(
        TokenHandle: HANDLE, CapabilitySidToCheck: PSID, HasCapability: PBOOL,
    ) -> BOOL;
    pub fn CheckTokenMembershipEx(
        TokenHandle: HANDLE, SidToCheck: PSID, Flags: DWORD, IsMember: PBOOL,
    ) -> BOOL;
    pub fn ClearCommBreak(hFile: HANDLE) -> BOOL;
    pub fn ClearCommError(hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT) -> BOOL;
    pub fn CloseHandle(hObject: HANDLE) -> BOOL;
    // pub fn ClosePackageInfo();
    pub fn ClosePrivateNamespace(Handle: HANDLE, Flags: ULONG) -> BOOLEAN;
    // pub fn CloseState();
    pub fn CloseThreadpool(ptpp: PTP_POOL);
    pub fn CloseThreadpoolCleanupGroup(ptpcg: PTP_CLEANUP_GROUP);
    pub fn CloseThreadpoolCleanupGroupMembers(
        ptpcg: PTP_CLEANUP_GROUP, fCancelPendingCallbacks: BOOL, pvCleanupContext: PVOID,
    );
    pub fn CloseThreadpoolIo(pio: PTP_IO);
    pub fn CloseThreadpoolTimer(pti: PTP_TIMER);
    pub fn CloseThreadpoolWait(pwa: PTP_WAIT);
    pub fn CloseThreadpoolWork(pwk: PTP_WORK);
    pub fn CommConfigDialogA(lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG) -> BOOL;
    pub fn CommConfigDialogW(lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG) -> BOOL;
    pub fn CompareFileTime(lpFileTime1: *const FILETIME, lpFileTime2: *const FILETIME) -> LONG;
    pub fn CompareStringA(
        Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: c_int, lpString2: PCNZCH,
        cchCount2: c_int,
    ) -> c_int;
    pub fn CompareStringEx(
        lpLocaleName: LPCWSTR, dwCmpFlags: DWORD, lpString1: LPCWCH, cchCount1: c_int,
        lpString2: LPCWCH, cchCount2: c_int, lpVersionInformation: LPNLSVERSIONINFO,
        lpReserved: LPVOID, lParam: LPARAM,
    ) -> c_int;
    pub fn CompareStringOrdinal(
        lpString1: LPCWCH, cchCount1: c_int, lpString2: LPCWCH, cchCount2: c_int, bIgnoreCase: BOOL,
    ) -> c_int;
    pub fn CompareStringW(
        Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: c_int, lpString2: PCNZWCH,
        cchCount2: c_int,
    ) -> c_int;
    pub fn ConnectNamedPipe(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL;
    pub fn ContinueDebugEvent(
        dwProcessId: DWORD, dwThreadId: DWORD, dwContinueStatus: DWORD,
    ) -> BOOL;
    pub fn ConvertDefaultLocale(Locale: LCID) -> LCID;
    pub fn ConvertFiberToThread() -> BOOL;
    pub fn ConvertThreadToFiber(lpParameter: LPVOID) -> LPVOID;
    pub fn ConvertThreadToFiberEx(lpParameter: LPVOID, dwFlags: DWORD) -> LPVOID;
    pub fn CopyContext(Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT) -> BOOL;
    pub fn CopyFile2(
        pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR,
        pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS,
    ) -> HRESULT;
    pub fn CopyFileA(
        lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL
    ) -> BOOL;
    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;
    pub fn CopyFileW(
        lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL
    ) -> BOOL;
    pub fn CreateActCtxA(pActCtx: PCACTCTXA) -> HANDLE;
    pub fn CreateActCtxW(pActCtx: PCACTCTXW) -> HANDLE;
    pub fn CreateBoundaryDescriptorA(Name: LPCSTR, Flags: ULONG) -> HANDLE;
    pub fn CreateBoundaryDescriptorW(Name: LPCWSTR, Flags: ULONG) -> HANDLE;
    pub fn CreateConsoleScreenBuffer(
        dwDesiredAccess: DWORD, dwShareMode: DWORD,
        lpSecurityAttributes: *const SECURITY_ATTRIBUTES, dwFlags: DWORD,
        lpScreenBufferData: LPVOID,
    ) -> HANDLE;
    pub fn CreateDirectoryA(
        lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> 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 CreateDirectoryW(
        lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateEventA(
        lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateEventW(
        lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL,
        lpName: LPCWSTR,
    ) -> HANDLE;
    pub fn CreateEventExA(
        lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateEventExW(
        lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateFiber(
        dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID,
    ) -> LPVOID;
    pub fn CreateFiberEx(
        dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD,
        lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID,
    ) -> LPVOID;
    pub fn CreateFile2(
        lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
        dwCreationDisposition: DWORD, pCreateExParams: LPCREATEFILE2_EXTENDED_PARAMETERS,
    ) -> HANDLE;
    pub fn CreateFileA(
        lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
        dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE,
    ) -> HANDLE;
    pub fn CreateFileMappingA(
        hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
        dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateFileMappingFromApp(
        hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG,
        MaximumSize: ULONG64, Name: PCWSTR,
    ) -> HANDLE;
    pub fn CreateFileMappingNumaA(
        hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
        dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD,
    ) -> HANDLE;
    pub fn CreateFileMappingNumaW(
        hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
        dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD,
    ) -> HANDLE;
    pub fn CreateFileMappingW(
        hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
        dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR,
    ) -> HANDLE;
    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 CreateFileW(
        lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
        dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE,
    ) -> HANDLE;
    pub fn CreateHardLinkA(
        lpFileName: LPCSTR, lpExistingFileName: LPCSTR, 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 CreateHardLinkW(
        lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> BOOL;
    pub fn CreateIoCompletionPort(
        FileHandle: HANDLE, ExistingCompletionPort: HANDLE, CompletionKey: ULONG_PTR,
        NumberOfConcurrentThreads: DWORD,
    ) -> HANDLE;
    pub fn CreateJobObjectA(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR) -> HANDLE;
    pub fn CreateJobObjectW(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR) -> HANDLE;
    pub fn CreateJobSet(NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG) -> BOOL;
    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 CreateMemoryResourceNotification(
        NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE,
    ) -> HANDLE;
    pub fn CreateMutexA(
        lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateMutexExA(
        lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateMutexExW(
        lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateMutexW(
        lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCWSTR,
    ) -> HANDLE;
    pub fn CreateNamedPipeA(
        lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD,
        nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> HANDLE;
    pub fn CreateNamedPipeW(
        lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD,
        nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
    ) -> HANDLE;
    pub fn CreatePipe(
        hReadPipe: PHANDLE, hWritePipe: PHANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES,
        nSize: DWORD,
    ) -> BOOL;
    pub fn CreatePrivateNamespaceA(
        lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID,
        lpAliasPrefix: LPCSTR,
    ) -> HANDLE;
    pub fn CreatePrivateNamespaceW(
        lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID,
        lpAliasPrefix: LPCWSTR,
    ) -> HANDLE;
    pub fn CreateProcessA(
        lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES,
        lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD,
        lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn CreateProcessW(
        lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR,
        lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES,
        bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID,
        lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW,
        lpProcessInformation: LPPROCESS_INFORMATION,
    ) -> BOOL;
    pub fn CreateRemoteThread(
        hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
        lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn CreateRemoteThreadEx(
        hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn CreateSemaphoreA(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
        lpName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateSemaphoreExA(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
        lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateSemaphoreExW(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
        lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateSemaphoreW(
        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
        lpName: LPCWSTR,
    ) -> HANDLE;
    pub fn CreateSymbolicLinkA(
        lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD,
    ) -> BOOLEAN;
    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 CreateSymbolicLinkW(
        lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD,
    ) -> BOOLEAN;
    pub fn CreateTapePartition(
        hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD,
    ) -> DWORD;
    pub fn CreateThread(
        lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
        lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
        lpThreadId: LPDWORD,
    ) -> HANDLE;
    pub fn CreateThreadpool(reserved: PVOID) -> PTP_POOL;
    pub fn CreateThreadpoolCleanupGroup() -> PTP_CLEANUP_GROUP;
    pub fn CreateThreadpoolIo(
        fl: HANDLE, pfnio: PTP_WIN32_IO_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
    ) -> PTP_IO;
    pub fn CreateThreadpoolTimer(
        pfnti: PTP_TIMER_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
    ) -> PTP_TIMER;
    pub fn CreateThreadpoolWait(
        pfnwa: PTP_WAIT_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
    ) -> PTP_WAIT;
    pub fn CreateThreadpoolWork(
        pfnwk: PTP_WORK_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
    ) -> PTP_WORK;
    pub fn CreateTimerQueue() -> HANDLE;
    pub fn CreateTimerQueueTimer(
        phNewTimer: PHANDLE, TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID,
        DueTime: DWORD, Period: DWORD, Flags: ULONG,
    ) -> BOOL;
    pub fn CreateToolhelp32Snapshot(dwFlags: DWORD, th32ProcessID: DWORD) -> HANDLE;
    #[cfg(target_arch = "x86_64")]
    pub fn CreateUmsCompletionList(UmsCompletionList: *mut PUMS_COMPLETION_LIST) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn CreateUmsThreadContext(lpUmsThread: *mut PUMS_CONTEXT) -> BOOL;
    pub fn CreateWaitableTimerA(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR,
    ) -> HANDLE;
    pub fn CreateWaitableTimerExA(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateWaitableTimerExW(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD,
        dwDesiredAccess: DWORD,
    ) -> HANDLE;
    pub fn CreateWaitableTimerW(
        lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR,
    ) -> HANDLE;
    // pub fn CtrlRoutine();
    pub fn DeactivateActCtx(dwFlags: DWORD, ulCookie: ULONG_PTR) -> BOOL;
    pub fn DebugActiveProcess(dwProcessId: DWORD) -> BOOL;
    pub fn DebugActiveProcessStop(dwProcessId: DWORD) -> BOOL;
    pub fn DebugBreak();
    pub fn DebugBreakProcess(Process: HANDLE) -> BOOL;
    pub fn DebugSetProcessKillOnExit(KillOnExit: BOOL) -> BOOL;
    pub fn DecodePointer(Ptr: PVOID) -> PVOID;
    pub fn DecodeSystemPointer(Ptr: PVOID) -> PVOID;
    pub fn DefineDosDeviceA(dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR) -> BOOL;
    pub fn DefineDosDeviceW(dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR) -> BOOL;
    pub fn DelayLoadFailureHook(pszDllName: LPCSTR, pszProcName: LPCSTR) -> FARPROC;
    pub fn DeleteAtom(nAtom: ATOM) -> ATOM;
    pub fn DeleteBoundaryDescriptor(BoundaryDescriptor: HANDLE);
    pub fn DeleteCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
    pub fn DeleteFiber(lpFiber: LPVOID);
    pub fn DeleteFileA(lpFileName: LPCSTR) -> BOOL;
    pub fn DeleteFileTransactedA(lpFileName: LPCSTR, hTransaction: HANDLE) -> BOOL;
    pub fn DeleteFileTransactedW(lpFileName: LPCWSTR, hTransaction: HANDLE) -> BOOL;
    pub fn DeleteFileW(lpFileName: LPCWSTR) -> BOOL;
    pub fn DeleteProcThreadAttributeList(lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST);
    pub fn DeleteSynchronizationBarrier(lpBarrier: LPSYNCHRONIZATION_BARRIER) -> BOOL;
    pub fn DeleteTimerQueue(TimerQueue: HANDLE) -> BOOL;
    pub fn DeleteTimerQueueEx(TimerQueue: HANDLE, CompletionEvent: HANDLE) -> BOOL;
    pub fn DeleteTimerQueueTimer(
        TimerQueue: HANDLE, Timer: HANDLE, CompletionEvent: HANDLE,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn DeleteUmsCompletionList(UmsCompletionList: PUMS_COMPLETION_LIST) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn DeleteUmsThreadContext(UmsThread: PUMS_CONTEXT) -> BOOL;
    pub fn DeleteVolumeMountPointA(lpszVolumeMountPoint: LPCSTR) -> BOOL;
    pub fn DeleteVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn DequeueUmsCompletionListItems(
        UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD,
        UmsThreadList: *mut PUMS_CONTEXT,
    ) -> BOOL;
    pub fn DeviceIoControl(
        hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD,
        lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD,
        lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn DisableThreadLibraryCalls(hLibModule: HMODULE) -> BOOL;
    pub fn DisableThreadProfiling(PerformanceDataHandle: HANDLE) -> DWORD;
    pub fn DisassociateCurrentThreadFromCallback(pci: PTP_CALLBACK_INSTANCE);
    pub fn DisconnectNamedPipe(hNamedPipe: HANDLE) -> BOOL;
    pub fn DnsHostnameToComputerNameA(
        Hostname: LPCSTR, ComputerName: LPCSTR, nSize: LPDWORD,
    ) -> BOOL;
    pub fn DnsHostnameToComputerNameExW(
        Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD,
    ) -> BOOL;
    pub fn DnsHostnameToComputerNameW(
        Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD,
    ) -> BOOL;
    pub fn DosDateTimeToFileTime(wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME) -> BOOL;
    // pub fn DosPathToSessionPathW();
    pub fn DuplicateHandle(
        hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE,
        lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD,
    ) -> BOOL;
    pub fn EnableThreadProfiling(
        ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64,
        PerformanceDataHandle: *mut HANDLE,
    ) -> BOOL;
    pub fn EncodePointer(Ptr: PVOID) -> PVOID;
    pub fn EncodeSystemPointer(Ptr: PVOID) -> PVOID;
    pub fn EndUpdateResourceA(hUpdate: HANDLE, fDiscard: BOOL) -> BOOL;
    pub fn EndUpdateResourceW(hUpdate: HANDLE, fDiscard: BOOL) -> BOOL;
    pub fn EnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
    pub fn EnterSynchronizationBarrier(
        lpBarrier: LPSYNCHRONIZATION_BARRIER, dwFlags: DWORD,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn EnterUmsSchedulingMode(SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO) -> BOOL;
    pub fn EnumCalendarInfoA(
        lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
    ) -> BOOL;
    pub fn EnumCalendarInfoExA(
        lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
    ) -> BOOL;
    pub fn EnumCalendarInfoExEx(
        pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX, lpLocaleName: LPCWSTR, Calendar: CALID,
        lpReserved: LPCWSTR, CalType: CALTYPE, lParam: LPARAM,
    ) -> BOOL;
    pub fn EnumCalendarInfoExW(
        lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
    ) -> BOOL;
    pub fn EnumCalendarInfoW(
        lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
    ) -> BOOL;
    pub fn EnumDateFormatsA(
        lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumDateFormatsExA(
        lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumDateFormatsExEx(
        lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX, lpLocaleName: LPCWSTR, dwFlags: DWORD,
        lParam: LPARAM,
    ) -> BOOL;
    pub fn EnumDateFormatsExW(
        lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumDateFormatsW(
        lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumLanguageGroupLocalesA(
        lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumLanguageGroupLocalesW(
        lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceLanguagesA(
        hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceLanguagesExA(
        hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA,
        lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceLanguagesExW(
        hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW,
        lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceLanguagesW(
        hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW,
        lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceNamesA(
        hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceNamesExA(
        hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR,
        dwFlags: DWORD, LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceNamesExW(
        hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR,
        dwFlags: DWORD, LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceNamesW(
        hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceTypesA(
        hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumResourceTypesExA(
        hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD,
        LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceTypesExW(
        hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD,
        LangId: LANGID,
    ) -> BOOL;
    pub fn EnumResourceTypesW(
        hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumSystemCodePagesA(lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD) -> BOOL;
    pub fn EnumSystemCodePagesW(lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD) -> BOOL;
    pub fn EnumSystemFirmwareTables(
        FirmwareTableProviderSignature: DWORD, pFirmwareTableEnumBuffer: PVOID, BufferSize: DWORD,
    ) -> UINT;
    pub fn EnumSystemGeoID(
        GeoClass: GEOCLASS, ParentGeoId: GEOID, lpGeoEnumProc: GEO_ENUMPROC,
    ) -> BOOL;
    pub fn EnumSystemLanguageGroupsA(
        lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumSystemLanguageGroupsW(
        lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumSystemLocalesA(lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD) -> BOOL;
    pub fn EnumSystemLocalesEx(
        lpLocaleEnumProcEx: LOCALE_ENUMPROCEX, dwFlags: DWORD, lParam: LPARAM, lpReserved: LPVOID,
    ) -> BOOL;
    pub fn EnumSystemLocalesW(lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD) -> BOOL;
    pub fn EnumTimeFormatsA(
        lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumTimeFormatsEx(
        lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX, lpLocaleName: LPCWSTR, dwFlags: DWORD,
        lParam: LPARAM,
    ) -> BOOL;
    pub fn EnumTimeFormatsW(
        lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD,
    ) -> BOOL;
    pub fn EnumUILanguagesA(
        lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR,
    ) -> BOOL;
    pub fn EnumUILanguagesW(
        lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR,
    ) -> BOOL;
    // pub fn EnumerateLocalComputerNamesA();
    // pub fn EnumerateLocalComputerNamesW();
    pub fn EraseTape(hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL) -> DWORD;
    pub fn EscapeCommFunction(hFile: HANDLE, dwFunc: DWORD) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn ExecuteUmsThread(UmsThread: PUMS_CONTEXT) -> BOOL;
    pub fn ExitProcess(uExitCode: UINT);
    pub fn ExitThread(dwExitCode: DWORD);
    pub fn ExpandEnvironmentStringsA(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD) -> DWORD;
    pub fn ExpandEnvironmentStringsW(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD) -> DWORD;
    pub fn FatalAppExitA(uAction: UINT, lpMessageText: LPCSTR);
    pub fn FatalAppExitW(uAction: UINT, lpMessageText: LPCWSTR);
    pub fn FatalExit(ExitCode: c_int);
    pub fn FileTimeToDosDateTime(
        lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD,
    ) -> BOOL;
    pub fn FileTimeToLocalFileTime(
        lpFileTime: *const FILETIME, lpLocalFileTime: LPFILETIME,
    ) -> BOOL;
    pub fn FileTimeToSystemTime(
        lpFileTime: *const FILETIME, lpSystemTime: LPSYSTEMTIME,
    ) -> BOOL;
    pub fn FillConsoleOutputAttribute(
        hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfAttrsWritten: LPDWORD,
    ) -> BOOL;
    pub fn FillConsoleOutputCharacterA(
        hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfCharsWritten: LPDWORD,
    ) -> BOOL;
    pub fn FillConsoleOutputCharacterW(
        hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfCharsWritten: LPDWORD,
    ) -> BOOL;
    pub fn FindActCtxSectionGuid(
        dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpGuidToFind: *const GUID,
        ReturnedData: PACTCTX_SECTION_KEYED_DATA,
    ) -> BOOL;
    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 FindAtomA(lpString: LPCSTR) -> ATOM;
    pub fn FindAtomW(lpString: LPCWSTR) -> ATOM;
    pub fn FindClose(hFindFile: HANDLE) -> BOOL;
    pub fn FindCloseChangeNotification(hChangeHandle: HANDLE) -> BOOL;
    pub fn FindFirstChangeNotificationA(
        lpPathName: LPCSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD,
    ) -> HANDLE;
    pub fn FindFirstChangeNotificationW(
        lpPathName: LPCWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD,
    ) -> HANDLE;
    pub fn FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA) -> HANDLE;
    pub fn FindFirstFileExA(
        lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
        fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
    ) -> HANDLE;
    pub fn FindFirstFileExW(
        lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
        fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
    ) -> HANDLE;
    pub fn FindFirstFileNameTransactedW(
        lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR,
        hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn FindFirstFileNameW(
        lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR,
    ) -> HANDLE;
    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 FindFirstFileW(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW) -> HANDLE;
    pub fn FindFirstStreamTransactedW(
        lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID,
        dwFlags: DWORD, hTransaction: HANDLE,
    ) -> HANDLE;
    pub fn FindFirstStreamW(
        lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID,
        dwFlags: DWORD,
    ) -> HANDLE;
    pub fn FindFirstVolumeA(lpszVolumeName: LPSTR, cchBufferLength: DWORD) -> HANDLE;
    pub fn FindFirstVolumeMountPointA(
        lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD,
    ) -> HANDLE;
    pub fn FindFirstVolumeMountPointW(
        lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD,
    ) -> HANDLE;
    pub fn FindFirstVolumeW(lpszVolumeName: LPWSTR, cchBufferLength: DWORD) -> HANDLE;
    pub fn FindNLSString(
        Locale: LCID, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: c_int,
        lpStringValue: LPCWSTR, cchValue: c_int, pcchFound: LPINT,
    ) -> c_int;
    pub fn FindNLSStringEx(
        lpLocaleName: LPCWSTR, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR,
        cchSource: c_int, lpStringValue: LPCWSTR, cchValue: c_int, pcchFound: LPINT,
        lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, sortHandle: LPARAM,
    ) -> c_int;
    pub fn FindNextChangeNotification(hChangeHandle: HANDLE) -> BOOL;
    pub fn FindNextFileA(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA) -> BOOL;
    pub fn FindNextFileNameW(hFindStream: HANDLE, StringLength: LPDWORD, LinkName: PWSTR) -> BOOL;
    pub fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW) -> BOOL;
    pub fn FindNextStreamW(hFindStream: HANDLE, lpFindStreamData: LPVOID) -> BOOL;
    pub fn FindNextVolumeA(
        hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindNextVolumeMountPointA(
        hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindNextVolumeMountPointW(
        hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn FindNextVolumeW(
        hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    // pub fn FindPackagesByPackageFamily();
    pub fn FindResourceA(hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR) -> HRSRC;
    pub fn FindResourceExA(
        hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD,
    ) -> HRSRC;
    pub fn FindResourceExW(
        hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR, wLanguage: WORD,
    ) -> HRSRC;
    pub fn FindResourceW(hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR) -> HRSRC;
    pub fn FindStringOrdinal(
        dwFindStringOrdinalFlags: DWORD, lpStringSource: LPCWSTR, cchSource: c_int,
        lpStringValue: LPCWSTR, cchValue: c_int, bIgnoreCase: BOOL,
    ) -> c_int;
    pub fn FindVolumeClose(hFindVolume: HANDLE) -> BOOL;
    pub fn FindVolumeMountPointClose(hFindVolumeMountPoint: HANDLE) -> BOOL;
    pub fn FlsAlloc(lpCallback: PFLS_CALLBACK_FUNCTION) -> DWORD;
    pub fn FlsFree(dwFlsIndex: DWORD) -> BOOL;
    pub fn FlsGetValue(dwFlsIndex: DWORD) -> PVOID;
    pub fn FlsSetValue(dwFlsIndex: DWORD, lpFlsData: PVOID) -> BOOL;
    pub fn FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL;
    pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL;
    pub fn FlushInstructionCache(hProcess: HANDLE, lpBaseAddress: LPCVOID, dwSize: SIZE_T) -> BOOL;
    pub fn FlushProcessWriteBuffers();
    pub fn FlushViewOfFile(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T) -> BOOL;
    pub fn FoldStringA(
        dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpDestStr: LPSTR, cchDest: c_int,
    ) -> c_int;
    pub fn FoldStringW(
        dwMapFlags: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpDestStr: LPWSTR, cchDest: c_int,
    ) -> c_int;
    // pub fn FormatApplicationUserModelId();
    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 fn FreeConsole() -> BOOL;
    pub fn FreeEnvironmentStringsA(penv: LPCH) -> BOOL;
    pub fn FreeEnvironmentStringsW(penv: LPWCH) -> BOOL;
    pub fn FreeLibrary(hLibModule: HMODULE) -> BOOL;
    pub fn FreeLibraryAndExitThread(hLibModule: HMODULE, dwExitCode: DWORD);
    pub fn FreeLibraryWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, module: HMODULE);
    pub fn FreeResource(hResData: HGLOBAL) -> BOOL;
    pub fn FreeUserPhysicalPages(
        hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR,
    ) -> BOOL;
    pub fn GenerateConsoleCtrlEvent(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD) -> BOOL;
    pub fn GetACP() -> UINT;
    pub fn GetActiveProcessorCount(GroupNumber: WORD) -> DWORD;
    pub fn GetActiveProcessorGroupCount() -> WORD;
    pub fn GetAppContainerAce(
        Acl: PACL, StartingAceIndex: DWORD, AppContainerAce: *mut PVOID,
        AppContainerAceIndex: *mut DWORD,
    ) -> BOOL;
    pub fn GetAppContainerNamedObjectPath(
        Token: HANDLE, AppContainerSid: PSID, ObjectPathLength: ULONG, ObjectPath: LPWSTR,
        ReturnLength: PULONG,
    ) -> BOOL;
    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 GetApplicationUserModelId();
    pub fn GetAtomNameA(nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int) -> UINT;
    pub fn GetAtomNameW(nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int) -> UINT;
    pub fn GetBinaryTypeA(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD) -> BOOL;
    pub fn GetBinaryTypeW(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD) -> BOOL;
    pub fn GetCPInfo(CodePage: UINT, lpCPInfo: LPCPINFO) -> BOOL;
    pub fn GetCPInfoExA(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA) -> BOOL;
    pub fn GetCPInfoExW(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW) -> BOOL;
    pub fn GetCachedSigningLevel(
        File: HANDLE, Flags: PULONG, SigningLevel: PULONG, Thumbprint: PUCHAR,
        ThumbprintSize: PULONG, ThumbprintAlgorithm: PULONG,
    ) -> BOOL;
    pub fn GetCalendarInfoA(
        Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: c_int,
        lpValue: LPDWORD,
    ) -> c_int;
    pub fn GetCalendarInfoEx(
        lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE,
        lpCalData: LPWSTR, cchData: c_int, lpValue: LPDWORD,
    ) -> c_int;
    pub fn GetCalendarInfoW(
        Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: c_int,
        lpValue: LPDWORD,
    ) -> c_int;
    pub fn GetCommConfig(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
    pub fn GetCommMask(hFile: HANDLE, lpEvtMask: LPDWORD) -> BOOL;
    pub fn GetCommModemStatus(hFile: HANDLE, lpModemStat: LPDWORD) -> BOOL;
    pub fn GetCommProperties(hFile: HANDLE, lpCommProp: LPCOMMPROP) -> BOOL;
    pub fn GetCommState(hFile: HANDLE, lpDCB: LPDCB) -> BOOL;
    pub fn GetCommTimeouts(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS) -> BOOL;
    pub fn GetCommandLineA() -> LPSTR;
    pub fn GetCommandLineW() -> LPWSTR;
    pub fn GetCompressedFileSizeA(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD) -> DWORD;
    pub fn GetCompressedFileSizeTransactedA(
        lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE,
    ) -> DWORD;
    pub fn GetCompressedFileSizeTransactedW(
        lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE,
    );
    pub fn GetCompressedFileSizeW(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD) -> DWORD;
    pub fn GetComputerNameA(lpBuffer: LPSTR, nSize: LPDWORD) -> BOOL;
    pub fn GetComputerNameExA(
        NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD,
    ) -> BOOL;
    pub fn GetComputerNameExW(
        NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD,
    ) -> BOOL;
    pub fn GetComputerNameW(lpBuffer: LPWSTR, nSize: LPDWORD) -> BOOL;
    pub fn GetConsoleAliasA(
        Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR,
    ) -> DWORD;
    pub fn GetConsoleAliasExesA(ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD) -> DWORD;
    pub fn GetConsoleAliasExesLengthA() -> DWORD;
    pub fn GetConsoleAliasExesLengthW() -> DWORD;
    pub fn GetConsoleAliasExesW(ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD) -> DWORD;
    pub fn GetConsoleAliasW(
        Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR,
    ) -> DWORD;
    pub fn GetConsoleAliasesA(
        AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR,
    ) -> DWORD;
    pub fn GetConsoleAliasesLengthA(ExeName: LPSTR) -> DWORD;
    pub fn GetConsoleAliasesLengthW(ExeName: LPWSTR) -> DWORD;
    pub fn GetConsoleAliasesW(
        AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR,
    ) -> DWORD;
    pub fn GetConsoleCP() -> UINT;
    pub fn GetConsoleCursorInfo(
        hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO,
    ) -> BOOL;
    pub fn GetConsoleDisplayMode(lpModeFlags: LPDWORD) -> BOOL;
    pub fn GetConsoleFontSize(hConsoleOutput: HANDLE, nFont: DWORD) -> COORD;
    pub fn GetConsoleHistoryInfo(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO) -> BOOL;
    pub fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL;
    pub fn GetConsoleOriginalTitleA(lpConsoleTitle: LPSTR, nSize: DWORD) -> DWORD;
    pub fn GetConsoleOriginalTitleW(lpConsoleTitle: LPWSTR, nSize: DWORD) -> DWORD;
    pub fn GetConsoleOutputCP() -> UINT;
    pub fn GetConsoleProcessList(lpdwProcessList: LPDWORD, dwProcessCount: DWORD) -> DWORD;
    pub fn GetConsoleScreenBufferInfo(
        hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO,
    ) -> BOOL;
    pub fn GetConsoleScreenBufferInfoEx(
        hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX,
    ) -> BOOL;
    pub fn GetConsoleSelectionInfo(lpConsoleSelectionInfo: PCONSOLE_SELECTION_INFO) -> BOOL;
    pub fn GetConsoleTitleA(lpConsoleTitle: LPSTR, nSize: DWORD) -> DWORD;
    pub fn GetConsoleTitleW(lpConsoleTitle: LPWSTR, nSize: DWORD) -> DWORD;
    pub fn GetConsoleWindow() -> HWND;
    pub fn GetCurrencyFormatA(
        Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: *const CURRENCYFMTA,
        lpCurrencyStr: LPSTR, cchCurrency: c_int,
    ) -> c_int;
    pub fn GetCurrencyFormatEx(
        lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const CURRENCYFMTW,
        lpCurrencyStr: LPWSTR, cchCurrency: c_int,
    ) -> c_int;
    pub fn GetCurrencyFormatW(
        Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const CURRENCYFMTW,
        lpCurrencyStr: LPWSTR, cchCurrency: c_int,
    ) -> c_int;
    pub fn GetCurrentActCtx(lphActCtx: *mut HANDLE) -> BOOL;
    // pub fn GetCurrentApplicationUserModelId();
    pub fn GetCurrentConsoleFont(
        hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFont: PCONSOLE_FONT_INFO,
    ) -> BOOL;
    pub fn GetCurrentConsoleFontEx(
        hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX,
    ) -> BOOL;
    pub fn GetCurrentDirectoryA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
    pub fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
    // pub fn GetCurrentPackageFamilyName();
    // pub fn GetCurrentPackageFullName();
    // pub fn GetCurrentPackageId();
    // pub fn GetCurrentPackageInfo();
    // pub fn GetCurrentPackagePath();
    pub fn GetCurrentProcess() -> HANDLE;
    pub fn GetCurrentProcessId() -> DWORD;
    pub fn GetCurrentProcessorNumber() -> DWORD;
    pub fn GetCurrentProcessorNumberEx(ProcNumber: PPROCESSOR_NUMBER);
    pub fn GetCurrentThread() -> HANDLE;
    pub fn GetCurrentThreadId() -> DWORD;
    pub fn GetCurrentThreadStackLimits(LowLimit: PULONG_PTR, HighLimit: PULONG_PTR);
    #[cfg(target_arch = "x86_64")]
    pub fn GetCurrentUmsThread() -> PUMS_CONTEXT;
    pub fn GetDateFormatA(
        Locale: LCID, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCSTR, lpDateStr: LPSTR,
        cchDate: c_int,
    ) -> c_int;
    pub fn GetDateFormatEx(
        lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCWSTR,
        lpDateStr: LPWSTR, cchDate: c_int, lpCalendar: LPCWSTR,
    ) -> c_int;
    pub fn GetDateFormatW(
        Locale: LCID, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCWSTR,
        lpDateStr: LPWSTR, cchDate: c_int,
    ) -> c_int;
    pub fn GetDefaultCommConfigA(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
    pub fn GetDefaultCommConfigW(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
    pub fn GetDevicePowerState(hDevice: HANDLE, pfOn: *mut BOOL) -> BOOL;
    pub fn GetDiskFreeSpaceA(
        lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD,
        lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD,
    ) -> BOOL;
    pub fn GetDiskFreeSpaceExA(
        lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
        lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
    ) -> BOOL;
    pub fn GetDiskFreeSpaceExW(
        lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
        lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
    ) -> BOOL;
    pub fn GetDiskFreeSpaceW(
        lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD,
        lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD,
    ) -> BOOL;
    pub fn GetDllDirectoryA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
    pub fn GetDllDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
    pub fn GetDriveTypeA(lpRootPathName: LPCSTR) -> UINT;
    pub fn GetDriveTypeW(lpRootPathName: LPCWSTR) -> UINT;
    pub fn GetDurationFormat(
        Locale: LCID, dwFlags: DWORD, lpDuration: *const SYSTEMTIME, ullDuration: ULONGLONG,
        lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: c_int,
    ) -> c_int;
    pub fn GetDurationFormatEx(
        lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDuration: *const SYSTEMTIME,
        ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: c_int,
    ) -> c_int;
    pub fn GetDynamicTimeZoneInformation(
        pTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION,
    ) -> DWORD;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn GetEnabledXStateFeatures() -> DWORD64;
    pub fn GetEnvironmentStrings() -> LPCH;
    pub fn GetEnvironmentStringsW() -> LPWCH;
    pub fn GetEnvironmentVariableA(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD) -> DWORD;
    pub fn GetEnvironmentVariableW(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD) -> DWORD;
    // pub fn GetEraNameCountedString();
    pub fn GetErrorMode() -> UINT;
    pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
    pub fn GetExitCodeThread(hThread: HANDLE, lpExitCode: LPDWORD) -> BOOL;
    pub fn GetFileAttributesA(lpFileName: LPCSTR) -> DWORD;
    pub fn GetFileAttributesExA(
        lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
    ) -> BOOL;
    pub fn GetFileAttributesExW(
        lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
    ) -> 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 GetFileAttributesW(lpFileName: LPCWSTR) -> DWORD;
    pub fn GetFileBandwidthReservation(
        hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD,
        pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD,
    ) -> BOOL;
    pub fn GetFileInformationByHandle(
        hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION,
    ) -> BOOL;
    pub fn GetFileInformationByHandleEx(
        hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID,
        dwBufferSize: DWORD,
    ) -> BOOL;
    pub fn GetFileMUIInfo(
        dwFlags: DWORD, pcwszFilePath: PCWSTR, pFileMUIInfo: PFILEMUIINFO,
        pcbFileMUIInfo: *mut DWORD,
    ) -> BOOL;
    pub fn GetFileMUIPath(
        dwFlags: DWORD, pcwszFilePath: PCWSTR, pwszLanguage: PWSTR, pcchLanguage: PULONG,
        pwszFileMUIPath: PWSTR, pcchFileMUIPath: PULONG, pululEnumerator: PULONGLONG,
    ) -> BOOL;
    pub fn GetFileSize(hFile: HANDLE, lpFileSizeHigh: LPDWORD) -> DWORD;
    pub fn GetFileSizeEx(hFile: HANDLE, lpFileSize: PLARGE_INTEGER) -> BOOL;
    pub fn GetFileTime(
        hFile: HANDLE, lpCreationTime: LPFILETIME, lpLastAccessTime: LPFILETIME,
        lpLastWriteTime: LPFILETIME,
    ) -> BOOL;
    pub fn GetFileType(hFile: HANDLE) -> DWORD;
    pub fn GetFinalPathNameByHandleA(
        hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD,
    ) -> DWORD;
    pub fn GetFinalPathNameByHandleW(
        hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD,
    ) -> DWORD;
    pub fn GetFirmwareEnvironmentVariableA(
        lpName: LPCSTR, lpGuid: LPCSTR, 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 GetFirmwareEnvironmentVariableW(
        lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD,
    ) -> DWORD;
    pub fn GetFirmwareType(FirmwareType: PFIRMWARE_TYPE) -> BOOL;
    pub fn GetFullPathNameA(
        lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR,
    ) -> DWORD;
    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 GetFullPathNameW(
        lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR,
    ) -> DWORD;
    pub fn GetGeoInfoA(
        Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: c_int, LangId: LANGID,
    ) -> c_int;
    pub fn GetGeoInfoW(
        Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: c_int, LangId: LANGID,
    ) -> c_int;
    pub fn GetHandleInformation(hObject: HANDLE, lpdwFlags: LPDWORD) -> BOOL;
    pub fn GetLargePageMinimum() -> SIZE_T;
    pub fn GetLargestConsoleWindowSize(hConsoleOutput: HANDLE) -> COORD;
    pub fn GetLastError() -> DWORD;
    pub fn GetLocalTime(lpSystemTime: LPSYSTEMTIME);
    pub fn GetLocaleInfoA(
        Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: c_int,
    ) -> c_int;
    pub fn GetLocaleInfoEx(
        lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: c_int,
    ) -> c_int;
    pub fn GetLocaleInfoW(
        Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: c_int,
    ) -> c_int;
    pub fn GetLogicalDriveStringsA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
    pub fn GetLogicalDriveStringsW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
    pub fn GetLogicalDrives() -> DWORD;
    pub fn GetLogicalProcessorInformation(
        Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, ReturnedLength: PDWORD,
    ) -> BOOL;
    pub fn GetLogicalProcessorInformationEx(
        RelationshipType: LOGICAL_PROCESSOR_RELATIONSHIP,
        Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
        ReturnedLength: PDWORD,
    ) -> BOOL;
    pub fn GetLongPathNameA(lpszShortPath: LPCSTR, lpszLongPath: 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 GetLongPathNameW(
        lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD,
    ) -> DWORD;
    pub fn GetMailslotInfo(
        hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD,
        lpReadTimeout: LPDWORD,
    ) -> BOOL;
    pub fn GetMaximumProcessorCount(GroupNumber: WORD) -> DWORD;
    pub fn GetMaximumProcessorGroupCount() -> WORD;
    pub fn GetMemoryErrorHandlingCapabilities(Capabilities: PULONG) -> BOOL;
    pub fn GetModuleFileNameA(
        hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn GetModuleFileNameW(
        hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn GetModuleHandleA(lpModuleName: LPCSTR) -> HMODULE;
    pub fn GetModuleHandleExA(
        dwFlags: DWORD, lpModuleName: LPCSTR, phModule: *mut HMODULE,
    ) -> BOOL;
    pub fn GetModuleHandleExW(
        dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: *mut HMODULE,
    ) -> BOOL;
    pub fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE;
    pub fn GetNLSVersion(
        Function: NLS_FUNCTION, Locale: LCID, lpVersionInformation: LPNLSVERSIONINFO,
    ) -> BOOL;
    pub fn GetNLSVersionEx(
        function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX,
    ) -> BOOL;
    // pub fn GetNamedPipeAttribute();
    pub fn GetNamedPipeClientComputerNameA(
        Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG,
    ) -> BOOL;
    pub fn GetNamedPipeClientComputerNameW(
        Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG,
    ) -> BOOL;
    pub fn GetNamedPipeClientProcessId(Pipe: HANDLE, ClientProcessId: PULONG) -> BOOL;
    pub fn GetNamedPipeClientSessionId(Pipe: HANDLE, ClientSessionId: PULONG) -> BOOL;
    pub fn GetNamedPipeHandleStateA(
        hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD,
        lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR,
        nMaxUserNameSize: DWORD,
    ) -> BOOL;
    pub fn GetNamedPipeHandleStateW(
        hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD,
        lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR,
        nMaxUserNameSize: DWORD,
    ) -> BOOL;
    pub fn GetNamedPipeInfo(
        hNamedPipe: HANDLE, lpFlags: LPDWORD, lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD,
        lpMaxInstances: LPDWORD,
    ) -> BOOL;
    pub fn GetNamedPipeServerProcessId(Pipe: HANDLE, ServerProcessId: PULONG) -> BOOL;
    pub fn GetNamedPipeServerSessionId(Pipe: HANDLE, ServerSessionId: PULONG) -> BOOL;
    pub fn GetNativeSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
    #[cfg(target_arch = "x86_64")]
    pub fn GetNextUmsListItem(UmsContext: PUMS_CONTEXT) -> PUMS_CONTEXT;
    pub fn GetNumaAvailableMemoryNode(Node: UCHAR, AvailableBytes: PULONGLONG) -> BOOL;
    pub fn GetNumaAvailableMemoryNodeEx(Node: USHORT, AvailableBytes: PULONGLONG) -> BOOL;
    pub fn GetNumaHighestNodeNumber(HighestNodeNumber: PULONG) -> BOOL;
    pub fn GetNumaNodeNumberFromHandle(hFile: HANDLE, NodeNumber: PUSHORT) -> BOOL;
    pub fn GetNumaNodeProcessorMask(Node: UCHAR, ProcessorMask: PULONGLONG) -> BOOL;
    pub fn GetNumaNodeProcessorMaskEx(Node: USHORT, ProcessorMask: PGROUP_AFFINITY) -> BOOL;
    pub fn GetNumaProcessorNode(Processor: UCHAR, NodeNumber: PUCHAR) -> BOOL;
    pub fn GetNumaProcessorNodeEx(Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT) -> BOOL;
    pub fn GetNumaProximityNode(ProximityId: ULONG, NodeNumber: PUCHAR) -> BOOL;
    pub fn GetNumaProximityNodeEx(ProximityId: ULONG, NodeNumber: PUSHORT) -> BOOL;
    pub fn GetNumberFormatA(
        Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: *const NUMBERFMTA,
        lpNumberStr: LPSTR, cchNumber: c_int,
    ) -> c_int;
    pub fn GetNumberFormatEx(
        lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const NUMBERFMTW,
        lpNumberStr: LPWSTR, cchNumber: c_int,
    ) -> c_int;
    pub fn GetNumberFormatW(
        Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const NUMBERFMTW,
        lpNumberStr: LPWSTR, cchNumber: c_int,
    ) -> c_int;
    pub fn GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: LPDWORD) -> BOOL;
    pub fn GetNumberOfConsoleMouseButtons(lpNumberOfMouseButtons: LPDWORD) -> BOOL;
    pub fn GetOEMCP() -> UINT;
    pub fn GetOverlappedResult(
        hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL,
    ) -> BOOL;
    pub fn GetOverlappedResultEx(
        hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD,
        dwMilliseconds: DWORD, bAlertable: BOOL,
    ) -> BOOL;
    // pub fn GetPackageApplicationIds();
    // pub fn GetPackageFamilyName();
    // pub fn GetPackageFullName();
    // pub fn GetPackageId();
    // pub fn GetPackageInfo();
    // pub fn GetPackagePath();
    // pub fn GetPackagePathByFullName();
    // pub fn GetPackagesByPackageFamily();
    pub fn GetPhysicallyInstalledSystemMemory(TotalMemoryInKilobytes: PULONGLONG) -> BOOL;
    pub fn GetPriorityClass(hProcess: HANDLE) -> DWORD;
    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 GetPrivateProfileSectionA(
        lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileSectionNamesA(
        lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileSectionNamesW(
        lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR,
    ) -> DWORD;
    pub fn GetPrivateProfileSectionW(
        lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR,
    ) -> DWORD;
    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 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 GetProcAddress(hModule: HMODULE, lpProcName: LPCSTR) -> FARPROC;
    pub fn GetProcessAffinityMask(
        hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR,
    ) -> BOOL;
    pub fn GetProcessDEPPolicy(hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL) -> BOOL;
    pub fn GetProcessGroupAffinity(
        hProcess: HANDLE, GroupCount: PUSHORT, GroupArray: PUSHORT,
    ) -> BOOL;
    pub fn GetProcessHandleCount(hProcess: HANDLE, pdwHandleCount: PDWORD) -> BOOL;
    pub fn GetProcessHeap() -> HANDLE;
    pub fn GetProcessHeaps(NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE) -> DWORD;
    pub fn GetProcessId(Process: HANDLE) -> DWORD;
    pub fn GetProcessIdOfThread(Thread: HANDLE) -> DWORD;
    pub fn GetProcessInformation(
        hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS,
        ProcessInformation: LPVOID, ProcessInformationSize: DWORD,
    ) -> BOOL;
    pub fn GetProcessIoCounters(hProcess: HANDLE, lpIoCounters: PIO_COUNTERS) -> BOOL;
    pub fn GetProcessMitigationPolicy(
        hProcess: HANDLE, MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: PVOID,
        dwLength: SIZE_T,
    ) -> BOOL;
    pub fn GetProcessPreferredUILanguages(
        dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
        pcchLanguagesBuffer: PULONG,
    ) -> BOOL;
    pub fn GetProcessPriorityBoost(hProcess: HANDLE, pDisablePriorityBoost: PBOOL) -> BOOL;
    pub fn GetProcessShutdownParameters(lpdwLevel: LPDWORD, lpdwFlags: LPDWORD) -> BOOL;
    pub fn GetProcessTimes(
        hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME,
        lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME,
    ) -> BOOL;
    pub fn GetProcessVersion(ProcessId: DWORD) -> DWORD;
    pub fn GetProcessWorkingSetSize(
        hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T,
    ) -> BOOL;
    pub fn GetProcessWorkingSetSizeEx(
        hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T,
        Flags: PDWORD,
    ) -> BOOL;
    pub fn GetProcessorSystemCycleTime(
        Group: USHORT, Buffer: PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, ReturnedLength: PDWORD,
    ) -> BOOL;
    pub fn GetProductInfo(
        dwOSMajorVersion: DWORD, dwOSMinorVersion: DWORD, dwSpMajorVersion: DWORD,
        dwSpMinorVersion: DWORD, pdwReturnedProductType: PDWORD,
    ) -> BOOL;
    pub fn GetProfileIntA(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT) -> UINT;
    pub fn GetProfileIntW(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT) -> UINT;
    pub fn GetProfileSectionA(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD) -> DWORD;
    pub fn GetProfileSectionW(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD) -> DWORD;
    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 GetQueuedCompletionStatus(
        CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: PULONG_PTR,
        lpOverlapped: *mut LPOVERLAPPED, dwMilliseconds: DWORD,
    ) -> BOOL;
    pub fn GetQueuedCompletionStatusEx(
        CompletionPort: HANDLE, lpCompletionPortEntries: LPOVERLAPPED_ENTRY, ulCount: ULONG,
        ulNumEntriesRemoved: PULONG, dwMilliseconds: DWORD, fAlertable: BOOL,
    ) -> BOOL;
    pub fn GetShortPathNameA(
        lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD,
    ) -> DWORD;
    pub fn GetShortPathNameW(
        lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD,
    ) -> DWORD;
    // pub fn GetStagedPackagePathByFullName();
    pub fn GetStartupInfoA(lpStartupInfo: LPSTARTUPINFOA);
    pub fn GetStartupInfoW(lpStartupInfo: LPSTARTUPINFOW);
    // pub fn GetStateFolder();
    pub fn GetStdHandle(nStdHandle: DWORD) -> HANDLE;
    pub fn GetStringScripts(
        dwFlags: DWORD, lpString: LPCWSTR, cchString: c_int, lpScripts: LPWSTR, cchScripts: c_int,
    ) -> c_int;
    pub fn GetStringTypeA(
        Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpCharType: LPWORD,
    ) -> BOOL;
    pub fn GetStringTypeExA(
        Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpCharType: LPWORD,
    ) -> BOOL;
    pub fn GetStringTypeExW(
        Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpCharType: LPWORD,
    ) -> BOOL;
    pub fn GetStringTypeW(
        dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpCharType: LPWORD,
    ) -> BOOL;
    // pub fn GetSystemAppDataKey();
    pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE;
    pub fn GetSystemDefaultLCID() -> LCID;
    pub fn GetSystemDefaultLangID() -> LANGID;
    pub fn GetSystemDefaultLocaleName(lpLocaleName: LPWSTR, cchLocaleName: c_int) -> c_int;
    pub fn GetSystemDefaultUILanguage() -> LANGID;
    pub fn GetSystemDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
    pub fn GetSystemDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
    pub fn GetSystemFileCacheSize(
        lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD,
    ) -> BOOL;
    pub fn GetSystemFirmwareTable(
        FirmwareTableProviderSignature: DWORD, FirmwareTableID: DWORD, pFirmwareTableBuffer: PVOID,
        BufferSize: DWORD,
    ) -> UINT;
    pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
    pub fn GetSystemPowerStatus(lpSystemPowerStatus: LPSYSTEM_POWER_STATUS) -> BOOL;
    pub fn GetSystemPreferredUILanguages(
        dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
        pcchLanguagesBuffer: PULONG,
    ) -> BOOL;
    pub fn GetSystemRegistryQuota(pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD) -> BOOL;
    pub fn GetSystemTime(lpSystemTime: LPSYSTEMTIME);
    pub fn GetSystemTimeAdjustment(
        lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD, lpTimeAdjustmentDisabled: PBOOL,
    ) -> BOOL;
    pub fn GetSystemTimeAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
    pub fn GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
    pub fn GetSystemTimes(
        lpIdleTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME,
    ) -> BOOL;
    pub fn GetSystemWindowsDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
    pub fn GetSystemWindowsDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
    pub fn GetSystemWow64DirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
    pub fn GetSystemWow64DirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
    pub fn GetTapeParameters(
        hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID
    ) -> DWORD;
    pub fn GetTapePosition(
        hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD,
        lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD
    ) -> DWORD;
    pub fn GetTapeStatus(hDevice: HANDLE) -> DWORD;
    pub fn GetTempFileNameA(
        lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR,
    ) -> UINT;
    pub fn GetTempFileNameW(
        lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR,
    ) -> UINT;
    pub fn GetTempPathA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
    pub fn GetTempPathW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
    pub fn GetThreadContext(hThread: HANDLE, lpContext: LPCONTEXT) -> BOOL;
    pub fn GetThreadErrorMode() -> DWORD;
    pub fn GetThreadGroupAffinity(hThread: HANDLE, GroupAffinity: PGROUP_AFFINITY) -> BOOL;
    pub fn GetThreadIOPendingFlag(hThread: HANDLE, lpIOIsPending: PBOOL) -> BOOL;
    pub fn GetThreadId(Thread: HANDLE) -> DWORD;
    pub fn GetThreadIdealProcessorEx(hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER) -> BOOL;
    pub fn GetThreadInformation(
        hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS,
        ThreadInformation: LPVOID, ThreadInformationSize: DWORD,
    ) -> BOOL;
    pub fn GetThreadLocale() -> LCID;
    pub fn GetThreadPreferredUILanguages(
        dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
        pcchLanguagesBuffer: PULONG,
    ) -> BOOL;
    pub fn GetThreadPriority(hThread: HANDLE) -> c_int;
    pub fn GetThreadPriorityBoost(hThread: HANDLE, pDisablePriorityBoost: PBOOL) -> BOOL;
    pub fn GetThreadSelectorEntry(
        hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY,
    ) -> BOOL;
    pub fn GetThreadTimes(
        hThread: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME,
        lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME,
    ) -> BOOL;
    pub fn GetThreadUILanguage() -> LANGID;
    pub fn GetTickCount() -> DWORD;
    pub fn GetTickCount64() -> ULONGLONG;
    pub fn GetTimeFormatA(
        Locale: LCID, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCSTR,
        lpTimeStr: LPSTR, cchTime: c_int,
    ) -> c_int;
    pub fn GetTimeFormatEx(
        lpLocaleName: LPCWSTR, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCWSTR,
        lpTimeStr: LPWSTR, cchTime: c_int,
    ) -> c_int;
    pub fn GetTimeFormatW(
        Locale: LCID, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCWSTR,
        lpTimeStr: LPWSTR, cchTime: c_int,
    ) -> c_int;
    pub fn GetTimeZoneInformation(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION) -> DWORD;
    pub fn GetTimeZoneInformationForYear(
        wYear: USHORT, pdtzi: PDYNAMIC_TIME_ZONE_INFORMATION, ptzi: LPTIME_ZONE_INFORMATION,
    ) -> BOOL;
    pub fn GetUILanguageInfo(
        dwFlags: DWORD, pwmszLanguage: PCZZWSTR, pwszFallbackLanguages: PZZWSTR,
        pcchFallbackLanguages: PDWORD, pAttributes: PDWORD,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn GetUmsCompletionListEvent(
        UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn GetUmsSystemThreadInformation(
        ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION,
    ) -> BOOL;
    pub fn GetUserDefaultLCID() -> LCID;
    pub fn GetUserDefaultLangID() -> LANGID;
    pub fn GetUserDefaultLocaleName(lpLocaleName: LPWSTR, cchLocaleName: c_int) -> c_int;
    pub fn GetUserDefaultUILanguage() -> LANGID;
    pub fn GetUserGeoID(GeoClass: GEOCLASS) -> GEOID;
    pub fn GetUserPreferredUILanguages(
        dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
        pcchLanguagesBuffer: PULONG,
    ) -> BOOL;
    pub fn GetVersion() -> DWORD;
    pub fn GetVersionExA(lpVersionInformation: LPOSVERSIONINFOA) -> BOOL;
    pub fn GetVersionExW(lpVersionInformation: LPOSVERSIONINFOW) -> BOOL;
    pub fn GetVolumeInformationA(
        lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD,
        lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
        lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD,
    ) -> BOOL;
    pub fn GetVolumeInformationByHandleW(
        hFile: HANDLE, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD,
        lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
        lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD,
    ) -> BOOL;
    pub fn GetVolumeInformationW(
        lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD,
        lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
        lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD,
    ) -> BOOL;
    pub fn GetVolumeNameForVolumeMountPointA(
        lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumeNameForVolumeMountPointW(
        lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumePathNameA(
        lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumePathNameW(
        lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD,
    ) -> BOOL;
    pub fn GetVolumePathNamesForVolumeNameA(
        lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD,
        lpcchReturnLength: PDWORD,
    ) -> BOOL;
    pub fn GetVolumePathNamesForVolumeNameW(
        lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD,
        lpcchReturnLength: PDWORD,
    ) -> BOOL;
    pub fn GetWindowsDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
    pub fn GetWindowsDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
    pub fn GetWriteWatch(
        dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: *mut PVOID,
        lpdwCount: *mut ULONG_PTR, lpdwGranularity: LPDWORD,
    ) -> UINT;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn GetXStateFeaturesMask(Context: PCONTEXT, FeatureMask: PDWORD64) -> BOOL;
    pub fn GlobalAddAtomA(lpString: LPCSTR) -> ATOM;
    pub fn GlobalAddAtomExA(lpString: LPCSTR, Flags: DWORD) -> ATOM;
    pub fn GlobalAddAtomExW(lpString: LPCWSTR, Flags: DWORD) -> ATOM;
    pub fn GlobalAddAtomW(lpString: LPCWSTR) -> ATOM;
    pub fn GlobalAlloc(uFlags: UINT, dwBytes: SIZE_T) -> HGLOBAL;
    pub fn GlobalCompact(dwMinFree: DWORD) -> SIZE_T;
    pub fn GlobalDeleteAtom(nAtom: ATOM) -> ATOM;
    pub fn GlobalFindAtomA(lpString: LPCSTR) -> ATOM;
    pub fn GlobalFindAtomW(lpString: LPCWSTR) -> ATOM;
    pub fn GlobalFix(hMem: HGLOBAL);
    pub fn GlobalFlags(hMem: HGLOBAL) -> UINT;
    pub fn GlobalFree(hMem: HGLOBAL) -> HGLOBAL;
    pub fn GlobalGetAtomNameA(nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int) -> UINT;
    pub fn GlobalGetAtomNameW(nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int) -> UINT;
    pub fn GlobalHandle(pMem: LPCVOID) -> HGLOBAL;
    pub fn GlobalLock(hMem: HGLOBAL) -> LPVOID;
    pub fn GlobalMemoryStatus(lpBuffer: LPMEMORYSTATUS);
    pub fn GlobalMemoryStatusEx(lpBuffer: LPMEMORYSTATUSEX) -> BOOL;
    pub fn GlobalReAlloc(hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT) -> HGLOBAL;
    pub fn GlobalSize(hMem: HGLOBAL) -> SIZE_T;
    pub fn GlobalUnWire(hMem: HGLOBAL) -> BOOL;
    pub fn GlobalUnfix(hMem: HGLOBAL);
    pub fn GlobalUnlock(hMem: HGLOBAL) -> BOOL;
    pub fn GlobalWire(hMem: HGLOBAL) -> LPVOID;
    pub fn Heap32First(lphe: LPHEAPENTRY32, th32ProcessID: DWORD, th32HeapID: ULONG_PTR) -> BOOL;
    pub fn Heap32ListFirst(hSnapshot: HANDLE, lphl: LPHEAPLIST32) -> BOOL;
    pub fn Heap32ListNext(hSnapshot: HANDLE, lphl: LPHEAPLIST32) -> BOOL;
    pub fn Heap32Next(lphe: LPHEAPENTRY32) -> BOOL;
    pub fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
    pub fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) -> SIZE_T;
    pub fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) -> HANDLE;
    pub fn HeapDestroy(hHeap: HANDLE) -> BOOL;
    pub fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
    pub fn HeapLock(hHeap: HANDLE) -> BOOL;
    pub fn HeapQueryInformation(
        HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID,
        HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T,
    ) -> BOOL;
    pub fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
    pub fn HeapSetInformation(
        HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID,
        HeapInformationLength: SIZE_T,
    ) -> BOOL;
    pub fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID) -> SIZE_T;
    pub fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) -> BOOL;
    pub fn HeapUnlock(hHeap: HANDLE) -> BOOL;
    pub fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID) -> BOOL;
    pub fn HeapWalk(hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY) -> BOOL;
    pub fn InitAtomTable(nSize: DWORD) -> BOOL;
    pub fn InitOnceBeginInitialize(
        lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: *mut LPVOID,
    ) -> BOOL;
    pub fn InitOnceComplete(
        lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID,
    ) -> BOOL;
    pub fn InitOnceExecuteOnce(
        InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: *mut LPVOID,
    ) -> BOOL;
    pub fn InitOnceInitialize(InitOnce: PINIT_ONCE);
    pub fn InitializeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
    pub fn InitializeContext(
        Buffer: PVOID, ContextFlags: DWORD, Context: *mut PCONTEXT, ContextLength: PDWORD,
    ) -> BOOL;
    pub fn InitializeCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
    pub fn InitializeCriticalSectionAndSpinCount(
        lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD,
    ) -> BOOL;
    pub fn InitializeCriticalSectionEx(
        lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD,
    ) -> BOOL;
    pub fn InitializeProcThreadAttributeList(
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount: DWORD, dwFlags: DWORD,
        lpSize: PSIZE_T,
    ) -> BOOL;
    pub fn InitializeSListHead(ListHead: PSLIST_HEADER);
    pub fn InitializeSRWLock(SRWLock: PSRWLOCK);
    pub fn InitializeSynchronizationBarrier(
        lpBarrier: LPSYNCHRONIZATION_BARRIER, lTotalThreads: LONG, lSpinCount: LONG,
    ) -> BOOL;
    pub fn InstallELAMCertificateInfo(ELAMFile: HANDLE) -> BOOL;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedCompareExchange(
        Destination: *mut LONG, ExChange: LONG, Comperand: LONG,
    ) -> LONG;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedCompareExchange64(
        Destination: *mut LONG64, ExChange: LONG64, Comperand: LONG64,
    ) -> LONG64;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedDecrement(Addend: *mut LONG) -> LONG;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedExchange(Target: *mut LONG, Value: LONG) -> LONG;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedExchangeAdd(Addend: *mut LONG, Value: LONG) -> LONG;
    pub fn InterlockedFlushSList(ListHead: PSLIST_HEADER) -> PSLIST_ENTRY;
    #[cfg(target_arch = "x86")]
    pub fn InterlockedIncrement(Addend: *mut LONG) -> LONG;
    pub fn InterlockedPopEntrySList(ListHead: PSLIST_HEADER) -> PSLIST_ENTRY;
    pub fn InterlockedPushEntrySList(
        ListHead: PSLIST_HEADER, ListEntry: PSLIST_ENTRY,
    ) -> PSLIST_ENTRY;
    pub fn InterlockedPushListSListEx(
        ListHead: PSLIST_HEADER, List: PSLIST_ENTRY, ListEnd: PSLIST_ENTRY, Count: ULONG,
    ) -> PSLIST_ENTRY;
    pub fn IsBadCodePtr(lpfn: FARPROC) -> BOOL;
    pub fn IsBadHugeReadPtr(lp: *const VOID, ucb: UINT_PTR) -> BOOL;
    pub fn IsBadHugeWritePtr(lp: LPVOID, ucb: UINT_PTR) -> BOOL;
    pub fn IsBadReadPtr(lp: *const VOID, ucb: UINT_PTR) -> BOOL;
    pub fn IsBadStringPtrA(lpsz: LPCSTR, ucchMax: UINT_PTR) -> BOOL;
    pub fn IsBadStringPtrW(lpsz: LPCWSTR, ucchMax: UINT_PTR) -> BOOL;
    pub fn IsBadWritePtr(lp: LPVOID, ucb: UINT_PTR) -> BOOL;
    pub fn IsDBCSLeadByte(TestChar: BYTE) -> BOOL;
    pub fn IsDBCSLeadByteEx(CodePage: UINT, TestChar: BYTE) -> BOOL;
    pub fn IsDebuggerPresent() -> BOOL;
    pub fn IsNLSDefinedString(
        Function: NLS_FUNCTION, dwFlags: DWORD, lpVersionInformation: LPNLSVERSIONINFO,
        lpString: LPCWSTR, cchStr: INT,
    ) -> BOOL;
    pub fn IsNativeVhdBoot(NativeVhdBoot: PBOOL) -> BOOL;
    pub fn IsNormalizedString(NormForm: NORM_FORM, lpString: LPCWSTR, cwLength: c_int) -> BOOL;
    pub fn IsProcessCritical(hProcess: HANDLE, Critical: PBOOL) -> BOOL;
    pub fn IsProcessInJob(ProcessHandle: HANDLE, JobHandle: HANDLE, Result: PBOOL) -> BOOL;
    pub fn IsProcessorFeaturePresent(ProcessorFeature: DWORD) -> BOOL;
    pub fn IsSystemResumeAutomatic() -> BOOL;
    pub fn IsThreadAFiber() -> BOOL;
    pub fn IsThreadpoolTimerSet(pti: PTP_TIMER) -> BOOL;
    pub fn IsValidCodePage(CodePage: UINT) -> BOOL;
    pub fn IsValidLanguageGroup(LanguageGroup: LGRPID, dwFlags: DWORD) -> BOOL;
    pub fn IsValidLocale(Locale: LCID, dwFlags: DWORD) -> BOOL;
    pub fn IsValidLocaleName(lpLocaleName: LPCWSTR) -> BOOL;
    pub fn IsValidNLSVersion(
        function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX,
    ) -> BOOL;
    pub fn IsWow64Process(hProcess: HANDLE, Wow64Process: PBOOL) -> BOOL;
    pub fn K32EmptyWorkingSet(hProcess: HANDLE) -> BOOL;
    pub fn K32EnumDeviceDrivers(lpImageBase: *mut LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) -> BOOL;
    pub fn K32EnumPageFilesA(
        pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID,
    ) -> BOOL;
    pub fn K32EnumPageFilesW(
        pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID,
    ) -> BOOL;
    pub fn K32EnumProcessModules(
        hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD,
    ) -> BOOL;
    pub fn K32EnumProcessModulesEx(
        hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD,
        dwFilterFlag: DWORD,
    ) -> BOOL;
    pub fn K32EnumProcesses(
        lpidProcess: *mut DWORD, cb: DWORD, lpcbNeeded: LPDWORD,
    ) -> BOOL;
    pub fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) -> DWORD;
    pub fn K32GetDeviceDriverBaseNameW(
        ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) -> DWORD;
    pub fn K32GetDeviceDriverFileNameW(
        ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetMappedFileNameA(
        hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetMappedFileNameW(
        hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetModuleBaseNameA(
        hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetModuleBaseNameW(
        hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetModuleFileNameExA(
        hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetModuleFileNameExW(
        hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetModuleInformation(
        hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD,
    ) -> BOOL;
    pub fn K32GetPerformanceInfo(
        pPerformanceInformation: PPERFORMANCE_INFORMATION, cb: DWORD,
    ) -> BOOL;
    pub fn K32GetProcessImageFileNameA(
        hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetProcessImageFileNameW(
        hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD,
    ) -> DWORD;
    pub fn K32GetProcessMemoryInfo(
        Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD,
    ) -> BOOL;
    pub fn K32GetWsChanges(
        hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD,
    ) -> BOOL;
    pub fn K32GetWsChangesEx(
        hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: PDWORD,
    ) -> BOOL;
    pub fn K32InitializeProcessForWsWatch(hProcess: HANDLE) -> BOOL;
    pub fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) -> BOOL;
    pub fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) -> BOOL;
    pub fn LCIDToLocaleName(Locale: LCID, lpName: LPWSTR, cchName: c_int, dwFlags: DWORD) -> c_int;
    pub fn LCMapStringA(
        Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpDestStr: LPSTR,
        cchDest: c_int,
    ) -> c_int;
    pub fn LCMapStringEx(
        lpLocaleName: LPCWSTR, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: c_int,
        lpDestStr: LPWSTR, cchDest: c_int, lpVersionInformation: LPNLSVERSIONINFO,
        lpReserved: LPVOID, sortHandle: LPARAM,
    ) -> c_int;
    pub fn LCMapStringW(
        Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: c_int, lpDestStr: LPWSTR,
        cchDest: c_int,
    ) -> c_int;
    pub fn LeaveCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
    pub fn LeaveCriticalSectionWhenCallbackReturns(
        pci: PTP_CALLBACK_INSTANCE, pcs: PCRITICAL_SECTION,
    );
    // pub fn LoadAppInitDlls();
    pub fn LoadLibraryA(lpFileName: LPCSTR) -> HMODULE;
    pub fn LoadLibraryExA(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD) -> HMODULE;
    pub fn LoadLibraryExW(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD) -> HMODULE;
    pub fn LoadLibraryW(lpFileName: LPCWSTR) -> HMODULE;
    pub fn LoadModule(lpModuleName: LPCSTR, lpParameterBlock: LPVOID) -> DWORD;
    pub fn LoadPackagedLibrary(lpwLibFileName: LPCWSTR, Reserved: DWORD) -> HMODULE;
    pub fn LoadResource(hModule: HMODULE, hResInfo: HRSRC) -> HGLOBAL;
    // pub fn LoadStringBaseExW();
    // pub fn LoadStringBaseW();
    pub fn LocalAlloc(uFlags: UINT, uBytes: SIZE_T) -> HLOCAL;
    pub fn LocalCompact(uMinFree: UINT) -> SIZE_T;
    pub fn LocalFileTimeToFileTime(
        lpLocalFileTime: *const FILETIME, lpFileTime: LPFILETIME,
    ) -> BOOL;
    pub fn LocalFlags(hMem: HLOCAL) -> UINT;
    pub fn LocalFree(hMem: HLOCAL) -> HLOCAL;
    pub fn LocalHandle(pMem: LPCVOID) -> HLOCAL;
    pub fn LocalLock(hMem: HLOCAL) -> LPVOID;
    pub fn LocalReAlloc(hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT) -> HLOCAL;
    pub fn LocalShrink(hMem: HLOCAL, cbNewSize: UINT) -> SIZE_T;
    pub fn LocalSize(hMem: HLOCAL) -> SIZE_T;
    pub fn LocalUnlock(hMem: HLOCAL) -> BOOL;
    pub fn LocaleNameToLCID(lpName: LPCWSTR, dwFlags: DWORD) -> LCID;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn LocateXStateFeature(Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD) -> PVOID;
    pub fn LockFile(
        hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
        nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD,
    ) -> BOOL;
    pub fn LockFileEx(
        hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD, nNumberOfBytesToLockLow: DWORD,
        nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn LockResource(hResData: HGLOBAL) -> LPVOID;
    pub fn MapUserPhysicalPages(
        VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR,
    ) -> BOOL;
    pub fn MapUserPhysicalPagesScatter(
        VirtualAddresses: *mut PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR,
    ) -> BOOL;
    pub fn MapViewOfFile(
        hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
        dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T,
    ) -> LPVOID;
    pub fn MapViewOfFileEx(
        hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
        dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID,
    ) -> LPVOID;
    pub fn MapViewOfFileExNuma(
        hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
        dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID,
        nndPreferred: DWORD,
    ) -> LPVOID;
    pub fn MapViewOfFileFromApp(
        hFileMappingObject: HANDLE, DesiredAccess: ULONG, FileOffset: ULONG64,
        NumberOfBytesToMap: SIZE_T,
    ) -> PVOID;
    pub fn Module32First(hSnapshot: HANDLE, lpme: LPMODULEENTRY32) -> BOOL;
    pub fn Module32FirstW(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W) -> BOOL;
    pub fn Module32Next(hSnapshot: HANDLE, lpme: LPMODULEENTRY32) -> BOOL;
    pub fn Module32NextW(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W) -> BOOL;
    pub fn MoveFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR) -> BOOL;
    pub fn MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD) -> BOOL;
    pub fn MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, 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 fn MoveFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR) -> 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 MulDiv(nNumber: c_int, nNumerator: c_int, nDenominator: c_int) -> c_int;
    pub fn MultiByteToWideChar(
        CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCSTR, cbMultiByte: c_int,
        lpWideCharStr: LPWSTR, cchWideChar: c_int,
    ) -> c_int;
    pub fn NeedCurrentDirectoryForExePathA(ExeName: LPCSTR) -> BOOL;
    pub fn NeedCurrentDirectoryForExePathW(ExeName: LPCWSTR) -> BOOL;
    pub fn NormalizeString(
        NormForm: NORM_FORM, lpSrcString: LPCWSTR, cwSrcLength: c_int, lpDstString: LPWSTR,
        cwDstLength: c_int,
    ) -> c_int;
    // pub fn NotifyMountMgr();
    pub fn NotifyUILanguageChange(
        dwFlags: DWORD, pcwstrNewLanguage: PCWSTR, pcwstrPreviousLanguage: PCWSTR,
        dwReserved: DWORD, pdwStatusRtrn: PDWORD,
    ) -> BOOL;
    // pub fn OOBEComplete();
    pub fn OpenEventA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
    pub fn OpenEventW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
    pub fn OpenFile(lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT) -> HFILE;
    pub fn OpenFileById(
        hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD,
        dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
        dwFlagsAndAttributes: DWORD,
    ) -> HANDLE;
    pub fn OpenFileMappingA(
        dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR,
    ) -> HANDLE;
    pub fn OpenFileMappingW(
        dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR,
    ) -> HANDLE;
    pub fn OpenJobObjectA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
    pub fn OpenJobObjectW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
    pub fn OpenMutexA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
    pub fn OpenMutexW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
    // pub fn OpenPackageInfoByFullName();
    pub fn OpenPrivateNamespaceA(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR) -> HANDLE;
    pub fn OpenPrivateNamespaceW(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR) -> HANDLE;
    pub fn OpenProcess(dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwProcessId: DWORD) -> HANDLE;
    pub fn OpenSemaphoreA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
    pub fn OpenSemaphoreW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
    // pub fn OpenState();
    // pub fn OpenStateExplicit();
    pub fn OpenThread(dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwThreadId: DWORD) -> HANDLE;
    pub fn OpenWaitableTimerA(
        dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR,
    ) -> HANDLE;
    pub fn OpenWaitableTimerW(
        dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCWSTR,
    ) -> HANDLE;
    pub fn OutputDebugStringA(lpOutputString: LPCSTR);
    pub fn OutputDebugStringW(lpOutputString: LPCWSTR);
    // pub fn PackageFamilyNameFromFullName();
    // pub fn PackageFamilyNameFromId();
    // pub fn PackageFullNameFromId();
    // pub fn PackageIdFromFullName();
    // pub fn PackageNameAndPublisherIdFromFamilyName();
    // pub fn ParseApplicationUserModelId();
    pub fn PeekConsoleInputA(
        hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsRead: LPDWORD,
    ) -> BOOL;
    pub fn PeekConsoleInputW(
        hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsRead: LPDWORD,
    ) -> BOOL;
    pub fn PeekNamedPipe(
        hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD, lpBytesRead: LPDWORD,
        lpTotalBytesAvail: LPDWORD, lpBytesLeftThisMessage: LPDWORD,
    ) -> BOOL;
    pub fn PostQueuedCompletionStatus(
        CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR,
        lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn PowerClearRequest(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE) -> BOOL;
    pub fn PowerCreateRequest(Context: PREASON_CONTEXT) -> HANDLE;
    pub fn PowerSetRequest(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE) -> BOOL;
    pub fn PrefetchVirtualMemory(
        hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY,
        Flags: ULONG,
    ) -> BOOL;
    pub fn PrepareTape(hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL) -> DWORD;
    pub fn Process32First(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32) -> BOOL;
    pub fn Process32FirstW(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W) -> BOOL;
    pub fn Process32Next(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32) -> BOOL;
    pub fn Process32NextW(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W) -> BOOL;
    pub fn ProcessIdToSessionId(dwProcessId: DWORD, pSessionId: *mut DWORD) -> BOOL;
    pub fn PssCaptureSnapshot(
        ProcessHandle: HANDLE, CaptureFlags: PSS_CAPTURE_FLAGS, ThreadContextFlags: DWORD,
        SnapshotHandle: *mut HPSS,
    ) -> DWORD;
    pub fn PssDuplicateSnapshot(
        SourceProcessHandle: HANDLE, SnapshotHandle: HPSS, TargetProcessHandle: HANDLE,
        TargetSnapshotHandle: *mut HPSS, Flags: PSS_DUPLICATE_FLAGS,
    ) -> DWORD;
    pub fn PssFreeSnapshot(ProcessHandle: HANDLE, SnapshotHandle: HPSS) -> DWORD;
    pub fn PssQuerySnapshot(
        SnapshotHandle: HPSS, InformationClass: PSS_QUERY_INFORMATION_CLASS, Buffer: *mut c_void,
        BufferLength: DWORD,
    ) -> DWORD;
    pub fn PssWalkMarkerCreate(
        Allocator: *const PSS_ALLOCATOR, WalkMarkerHandle: *mut HPSSWALK,
    ) -> DWORD;
    pub fn PssWalkMarkerFree(WalkMarkerHandle: HPSSWALK) -> DWORD;
    pub fn PssWalkMarkerGetPosition(WalkMarkerHandle: HPSSWALK, Position: *mut ULONG_PTR) -> DWORD;
    // pub fn PssWalkMarkerRewind();
    // pub fn PssWalkMarkerSeek();
    pub fn PssWalkMarkerSeekToBeginning(WalkMarkerHandle: HPSS) -> DWORD;
    pub fn PssWalkMarkerSetPosition(WalkMarkerHandle: HPSSWALK, Position: ULONG_PTR) -> DWORD;
    // pub fn PssWalkMarkerTell();
    pub fn PssWalkSnapshot(
        SnapshotHandle: HPSS, InformationClass: PSS_WALK_INFORMATION_CLASS,
        WalkMarkerHandle: HPSSWALK, Buffer: *mut c_void, BufferLength: DWORD,
    ) -> DWORD;
    pub fn PulseEvent(hEvent: HANDLE) -> BOOL;
    pub fn PurgeComm(hFile: HANDLE, dwFlags: DWORD) -> BOOL;
    pub fn QueryActCtxSettingsW(
        dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR,
        pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: *mut SIZE_T,
    ) -> BOOL;
    pub fn QueryActCtxW(
        dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID,
        cbBuffer: SIZE_T, pcbWrittenOrRequired: *mut SIZE_T,
    ) -> BOOL;
    pub fn QueryDepthSList(ListHead: PSLIST_HEADER) -> USHORT;
    pub fn QueryDosDeviceA(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD) -> DWORD;
    pub fn QueryDosDeviceW(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD) -> DWORD;
    pub fn QueryFullProcessImageNameA(
        hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD,
    ) -> BOOL;
    pub fn QueryFullProcessImageNameW(
        hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD,
    ) -> BOOL;
    pub fn QueryIdleProcessorCycleTime(
        BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64,
    ) -> BOOL;
    pub fn QueryIdleProcessorCycleTimeEx(
        Group: USHORT, BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64,
    ) -> BOOL;
    pub fn QueryInformationJobObject(
        hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS,
        lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD,
        lpReturnLength: LPDWORD,
    ) -> BOOL;
    pub fn QueryMemoryResourceNotification(
        ResourceNotificationHandle: HANDLE, ResourceState: PBOOL,
    ) -> BOOL;
    pub fn QueryPerformanceCounter(lpPerformanceCount: *mut LARGE_INTEGER) -> BOOL;
    pub fn QueryPerformanceFrequency(lpFrequency: *mut LARGE_INTEGER) -> BOOL;
    pub fn QueryProcessAffinityUpdateMode(hProcess: HANDLE, lpdwFlags: LPDWORD) -> BOOL;
    pub fn QueryProcessCycleTime(ProcessHandle: HANDLE, CycleTime: PULONG64) -> BOOL;
    pub fn QueryProtectedPolicy(PolicyGuid: LPCGUID, PolicyValue: PULONG_PTR) -> BOOL;
    pub fn QueryThreadCycleTime(ThreadHandle: HANDLE, CycleTime: PULONG64) -> BOOL;
    pub fn QueryThreadProfiling(ThreadHandle: HANDLE, Enabled: PBOOLEAN) -> DWORD;
    pub fn QueryThreadpoolStackInformation(
        ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn QueryUmsThreadInformation(
        UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
        UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG,
    ) -> BOOL;
    pub fn QueryUnbiasedInterruptTime(UnbiasedTime: PULONGLONG) -> BOOL;
    pub fn QueueUserAPC(pfnAPC: PAPCFUNC, hThread: HANDLE, dwData: ULONG_PTR) -> DWORD;
    pub fn QueueUserWorkItem(
        Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG,
    ) -> BOOL;
    pub fn RaiseException(
        dwExceptionCode: DWORD, dwExceptionFlags: DWORD, nNumberOfArguments: DWORD,
        lpArguments: *const ULONG_PTR,
    );
    pub fn RaiseFailFastException(
        pExceptionRecord: PEXCEPTION_RECORD, pContextRecord: PCONTEXT, dwFlags: DWORD,
    );
    pub fn ReOpenFile(
        hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD,
    ) -> HANDLE;
    pub fn ReadConsoleA(
        hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD,
        lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL,
    ) -> BOOL;
    pub fn ReadConsoleInputA(
        hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsRead: LPDWORD,
    ) -> BOOL;
    pub fn ReadConsoleInputW(
        hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsRead: LPDWORD,
    ) -> BOOL;
    pub fn ReadConsoleOutputA(
        hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD,
        lpReadRegion: PSMALL_RECT,
    ) -> BOOL;
    pub fn ReadConsoleOutputAttribute(
        hConsoleOutput: HANDLE, lpAttribute: LPWORD, nLength: DWORD, dwReadCoord: COORD,
        lpNumberOfAttrsRead: LPDWORD,
    ) -> BOOL;
    pub fn ReadConsoleOutputCharacterA(
        hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD,
        lpNumberOfCharsRead: LPDWORD,
    ) -> BOOL;
    pub fn ReadConsoleOutputCharacterW(
        hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD,
        lpNumberOfCharsRead: LPDWORD,
    ) -> BOOL;
    pub fn ReadConsoleOutputW(
        hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD,
        lpReadRegion: PSMALL_RECT,
    ) -> BOOL;
    pub fn ReadConsoleW(
        hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD,
        lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL,
    ) -> BOOL;
    pub fn ReadDirectoryChangesW(
        hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL,
        dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED,
        lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
    ) -> BOOL;
    pub fn ReadFile(
        hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD,
        lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn ReadFileEx(
        hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpOverlapped: LPOVERLAPPED,
        lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
    ) -> BOOL;
    pub fn ReadFileScatter(
        hFile: HANDLE, aSegmentArray: *mut FILE_SEGMENT_ELEMENT, nNumberOfBytesToRead: DWORD,
        lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn ReadProcessMemory(
        hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T,
        lpNumberOfBytesRead: *mut SIZE_T,
    ) -> BOOL;
    pub fn ReadThreadProfilingData(
        PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA,
    ) -> DWORD;
    pub fn RegisterApplicationRecoveryCallback(
        pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD,
        dwFlags: DWORD,
    ) -> HRESULT;
    pub fn RegisterApplicationRestart(pwzCommandline: PCWSTR, dwFlags: DWORD) -> HRESULT;
    pub fn RegisterBadMemoryNotification(Callback: PBAD_MEMORY_CALLBACK_ROUTINE) -> PVOID;
    // pub fn RegisterWaitForInputIdle();
    pub fn RegisterWaitForSingleObject(
        phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID,
        dwMilliseconds: ULONG, dwFlags: ULONG,
    ) -> BOOL;
    pub fn RegisterWaitForSingleObjectEx(
        hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG,
        dwFlags: ULONG,
    ) -> HANDLE;
    // pub fn RegisterWaitUntilOOBECompleted();
    pub fn ReleaseActCtx(hActCtx: HANDLE);
    pub fn ReleaseMutex(hMutex: HANDLE) -> BOOL;
    pub fn ReleaseMutexWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, mutex: HANDLE);
    pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK);
    pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK);
    pub fn ReleaseSemaphore(
        hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG,
    ) -> BOOL;
    pub fn ReleaseSemaphoreWhenCallbackReturns(
        pci: PTP_CALLBACK_INSTANCE, sem: HANDLE, crel: DWORD,
    );
    pub fn RemoveDirectoryA(lpPathName: LPCSTR) -> BOOL;
    pub fn RemoveDirectoryTransactedA(lpPathName: LPCSTR, hTransaction: HANDLE) -> BOOL;
    pub fn RemoveDirectoryTransactedW(lpPathName: LPCWSTR, hTransaction: HANDLE) -> BOOL;
    pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
    pub fn RemoveDllDirectory(Cookie: DLL_DIRECTORY_COOKIE) -> BOOL;
    // pub fn RemoveLocalAlternateComputerNameA();
    // pub fn RemoveLocalAlternateComputerNameW();
    pub fn RemoveSecureMemoryCacheCallback(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK) -> BOOL;
    pub fn RemoveVectoredContinueHandler(Handle: PVOID) -> ULONG;
    pub fn RemoveVectoredExceptionHandler(Handle: PVOID) -> ULONG;
    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 ReplacePartitionUnit(
        TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG,
    ) -> BOOL;
    pub fn RequestDeviceWakeup(hDevice: HANDLE) -> BOOL;
    pub fn RequestWakeupLatency(latency: LATENCY_TIME) -> BOOL;
    pub fn ResetEvent(hEvent: HANDLE) -> BOOL;
    pub fn ResetWriteWatch(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T) -> UINT;
    // pub fn ResolveDelayLoadedAPI();
    // pub fn ResolveDelayLoadsFromDll();
    pub fn ResolveLocaleName(
        lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: c_int,
    ) -> c_int;
    pub fn RestoreLastError(dwErrCode: DWORD);
    pub fn ResumeThread(hThread: HANDLE) -> DWORD;
    #[cfg(target_arch = "arm")]
    pub fn RtlAddFunctionTable(
        FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, BaseAddress: DWORD,
    ) -> BOOLEAN;
    #[cfg(target_arch = "x86_64")]
    pub fn RtlAddFunctionTable(
        FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, BaseAddress: DWORD64,
    ) -> BOOLEAN;
    pub fn RtlCaptureContext(ContextRecord: PCONTEXT);
    pub fn RtlCaptureStackBackTrace(
        FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: *mut PVOID, BackTraceHash: PDWORD,
    ) -> WORD;
    // #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlCompareMemory(Source1: *const VOID, Source2: *const VOID, Length: SIZE_T) -> SIZE_T;
    // #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlCopyMemory(Destination: PVOID, Source: *const VOID, Length: SIZE_T);
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlDeleteFunctionTable(FunctionTable: PRUNTIME_FUNCTION) -> BOOLEAN;
    // pub fn RtlFillMemory();
    #[cfg(target_arch = "arm")]
    pub fn RtlInstallFunctionTableCallback(
        TableIdentifier: DWORD, BaseAddress: DWORD, Length: DWORD,
        Callback: PGET_RUNTIME_FUNCTION_CALLBACK, Context: PVOID, OutOfProcessCallbackDll: PCWSTR,
    ) -> BOOLEAN;
    #[cfg(target_arch = "x86_64")]
    pub fn RtlInstallFunctionTableCallback(
        TableIdentifier: DWORD64, BaseAddress: DWORD64, Length: DWORD,
        Callback: PGET_RUNTIME_FUNCTION_CALLBACK, Context: PVOID, OutOfProcessCallbackDll: PCWSTR,
    ) -> BOOLEAN;
    #[cfg(target_arch = "arm")]
    pub fn RtlLookupFunctionEntry(
        ControlPc: ULONG_PTR, ImageBase: PDWORD, HistoryTable: PUNWIND_HISTORY_TABLE,
    ) -> PRUNTIME_FUNCTION;
    #[cfg(target_arch = "x86_64")]
    pub fn RtlLookupFunctionEntry(
        ControlPc: DWORD64, ImageBase: PDWORD64, HistoryTable: PUNWIND_HISTORY_TABLE,
    ) -> PRUNTIME_FUNCTION;
    // pub fn RtlMoveMemory();
    // #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlPcToFileHeader(PcValue: PVOID, BaseOfImage: *mut PVOID) -> PVOID;
    // #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    // pub fn RtlRaiseException();
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlRestoreContext(ContextRecord: PCONTEXT, ExceptionRecord: *mut EXCEPTION_RECORD);
    pub fn RtlUnwind(
        TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID,
    );
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn RtlUnwindEx(
        TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID,
        ContextRecord: PCONTEXT, HistoryTable: PUNWIND_HISTORY_TABLE,
    );
    #[cfg(target_arch = "arm")]
    pub fn RtlVirtualUnwind(
        HandlerType: DWORD, ImageBase: DWORD, ControlPc: DWORD, FunctionEntry: PRUNTIME_FUNCTION,
        ContextRecord: PCONTEXT, HandlerData: *mut PVOID, EstablisherFrame: PDWORD,
        ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS,
    ) -> PEXCEPTION_ROUTINE;
    #[cfg(target_arch = "x86_64")]
    pub fn RtlVirtualUnwind(
        HandlerType: DWORD, ImageBase: DWORD64, ControlPc: DWORD64,
        FunctionEntry: PRUNTIME_FUNCTION, ContextRecord: PCONTEXT, HandlerData: *mut PVOID,
        EstablisherFrame: PDWORD64, ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS,
    ) -> PEXCEPTION_ROUTINE;
    // pub fn RtlZeroMemory();
    pub fn ScrollConsoleScreenBufferA(
        hConsoleOutput: HANDLE, lpScrollRectangle: *const SMALL_RECT,
        lpClipRectangle: *const SMALL_RECT, dwDestinationOrigin: COORD, lpFill: *const CHAR_INFO,
    ) -> BOOL;
    pub fn ScrollConsoleScreenBufferW(
        hConsoleOutput: HANDLE, lpScrollRectangle: *const SMALL_RECT,
        lpClipRectangle: *const SMALL_RECT, dwDestinationOrigin: COORD, lpFill: *const CHAR_INFO,
    ) -> BOOL;
    pub fn SearchPathA(
        lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD,
        lpBuffer: LPSTR, lpFilePart: *mut LPSTR,
    ) -> DWORD;
    pub fn SearchPathW(
        lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD,
        lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR,
    ) -> DWORD;
    pub fn SetCachedSigningLevel(
        SourceFiles: PHANDLE, SourceFileCount: ULONG, Flags: ULONG, TargetFile: HANDLE,
    ) -> BOOL;
    pub fn SetCalendarInfoA(
        Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR,
    ) -> BOOL;
    pub fn SetCalendarInfoW(
        Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR,
    ) -> BOOL;
    pub fn SetCommBreak(hFile: HANDLE) -> BOOL;
    pub fn SetCommConfig(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
    pub fn SetCommMask(hFile: HANDLE, dwEvtMask: DWORD) -> BOOL;
    pub fn SetCommState(hFile: HANDLE, lpDCB: LPDCB) -> BOOL;
    pub fn SetCommTimeouts(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS) -> BOOL;
    pub fn SetComputerNameA(lpComputerName: LPCSTR) -> BOOL;
    pub fn SetComputerNameEx2W(
        NameType: COMPUTER_NAME_FORMAT, Flags: DWORD, lpBuffer: LPCWSTR,
    ) -> BOOL;
    pub fn SetComputerNameExA(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCSTR) -> BOOL;
    pub fn SetComputerNameExW(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR) -> BOOL;
    pub fn SetComputerNameW(lpComputerName: LPCWSTR) -> BOOL;
    pub fn SetConsoleActiveScreenBuffer(hConsoleOutput: HANDLE) -> BOOL;
    pub fn SetConsoleCP(wCodePageID: UINT) -> BOOL;
    pub fn SetConsoleCtrlHandler(HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL) -> BOOL;
    // pub fn SetConsoleCursor();
    pub fn SetConsoleCursorInfo(
        hConsoleOutput: HANDLE, lpConsoleCursorInfo: *const CONSOLE_CURSOR_INFO,
    ) -> BOOL;
    pub fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL;
    pub fn SetConsoleDisplayMode(
        hConsoleOutput: HANDLE, dwFlags: DWORD, lpNewScreenBufferDimensions: PCOORD,
    ) -> BOOL;
    pub fn SetConsoleHistoryInfo(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO) -> BOOL;
    pub fn SetConsoleMode(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL;
    pub fn SetConsoleOutputCP(wCodePageID: UINT) -> BOOL;
    pub fn SetConsoleScreenBufferInfoEx(
        hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX,
    ) -> BOOL;
    pub fn SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL;
    pub fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL;
    pub fn SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL;
    pub fn SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL;
    pub fn SetConsoleWindowInfo(
        hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: *const SMALL_RECT,
    ) -> BOOL;
    pub fn SetCriticalSectionSpinCount(
        lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD,
    ) -> DWORD;
    pub fn SetCurrentConsoleFontEx(
        hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX,
    ) -> BOOL;
    pub fn SetCurrentDirectoryA(lpPathName: LPCSTR) -> BOOL;
    pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
    pub fn SetDefaultCommConfigA(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
    pub fn SetDefaultCommConfigW(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
    pub fn SetDefaultDllDirectories(DirectoryFlags: DWORD) -> BOOL;
    pub fn SetDllDirectoryA(lpPathName: LPCSTR) -> BOOL;
    pub fn SetDllDirectoryW(lpPathName: LPCWSTR) -> BOOL;
    pub fn SetDynamicTimeZoneInformation(
        lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
    ) -> BOOL;
    pub fn SetEndOfFile(hFile: HANDLE) -> BOOL;
    pub fn SetEnvironmentStringsA(NewEnvironment: LPCH) -> BOOL;
    pub fn SetEnvironmentStringsW(NewEnvironment: LPWCH) -> BOOL;
    pub fn SetEnvironmentVariableA(lpName: LPCSTR, lpValue: LPCSTR) -> BOOL;
    pub fn SetEnvironmentVariableW(lpName: LPCWSTR, lpValue: LPCWSTR) -> BOOL;
    pub fn SetErrorMode(uMode: UINT) -> UINT;
    pub fn SetEvent(hEvent: HANDLE) -> BOOL;
    pub fn SetEventWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, evt: HANDLE);
    pub fn SetFileApisToANSI();
    pub fn SetFileApisToOEM();
    pub fn SetFileAttributesA(lpFileName: LPCSTR, dwFileAttributes: DWORD) -> BOOL;
    pub fn SetFileAttributesTransactedA(
        lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE,
    ) -> BOOL;
    pub fn SetFileAttributesTransactedW(
        lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE,
    ) -> BOOL;
    pub fn SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: DWORD) -> BOOL;
    pub fn SetFileBandwidthReservation(
        hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL,
        lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD,
    ) -> BOOL;
    pub fn SetFileCompletionNotificationModes(FileHandle: HANDLE, Flags: UCHAR) -> BOOL;
    pub fn SetFileInformationByHandle(
        hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID,
        dwBufferSize: DWORD,
    ) -> BOOL;
    pub fn SetFileIoOverlappedRange(
        FileHandle: HANDLE, OverlappedRangeStart: PUCHAR, Length: ULONG,
    ) -> BOOL;
    pub fn SetFilePointer(
        hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD,
    ) -> DWORD;
    pub fn SetFilePointerEx(
        hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER,
        dwMoveMethod: DWORD,
    ) -> BOOL;
    pub fn SetFileShortNameA(hFile: HANDLE, lpShortName: LPCSTR) -> BOOL;
    pub fn SetFileShortNameW(hFile: HANDLE, lpShortName: LPCWSTR) -> BOOL;
    pub fn SetFileTime(
        hFile: HANDLE, lpCreationTime: *const FILETIME, lpLastAccessTime: *const FILETIME,
        lpLastWriteTime: *const FILETIME,
    ) -> BOOL;
    pub fn SetFileValidData(hFile: HANDLE, ValidDataLength: LONGLONG) -> BOOL;
    pub fn SetFirmwareEnvironmentVariableA(
        lpName: LPCSTR, lpGuid: LPCSTR, 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 SetFirmwareEnvironmentVariableW(
        lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD,
    ) -> BOOL;
    pub fn SetHandleCount(uNumber: UINT) -> UINT;
    pub fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL;
    pub fn SetInformationJobObject(
        hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS,
        lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD,
    ) -> BOOL;
    pub fn SetLastError(dwErrCode: DWORD);
    // pub fn SetLocalPrimaryComputerNameA();
    // pub fn SetLocalPrimaryComputerNameW();
    pub fn SetLocalTime(lpSystemTime: *const SYSTEMTIME) -> BOOL;
    pub fn SetLocaleInfoA(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR) -> BOOL;
    pub fn SetLocaleInfoW(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR) -> BOOL;
    pub fn SetMailslotInfo(hMailslot: HANDLE, lReadTimeout: DWORD) -> BOOL;
    pub fn SetMessageWaitingIndicator(hMsgIndicator: HANDLE, ulMsgCount: ULONG) -> BOOL;
    pub fn SetNamedPipeAttribute(
        Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR,
        AttributeValue: PVOID, AttributeValueLength: SIZE_T,
    ) -> BOOL;
    pub fn SetNamedPipeHandleState(
        hNamedPipe: HANDLE, lpMode: LPDWORD, lpMaxCollectionCount: LPDWORD,
        lpCollectDataTimeout: LPDWORD,
    ) -> BOOL;
    pub fn SetPriorityClass(hProcess: HANDLE, dwPriorityClass: DWORD) -> BOOL;
    pub fn SetProcessAffinityMask(hProcess: HANDLE, dwProcessAffinityMask: DWORD) -> BOOL;
    pub fn SetProcessAffinityUpdateMode(hProcess: HANDLE, dwFlags: DWORD) -> BOOL;
    pub fn SetProcessDEPPolicy(dwFlags: DWORD) -> BOOL;
    pub fn SetProcessInformation(
        hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS,
        ProcessInformation: LPVOID, ProcessInformationSize: DWORD,
    ) -> BOOL;
    pub fn SetProcessMitigationPolicy(
        MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: PVOID, dwLength: SIZE_T,
    ) -> BOOL;
    pub fn SetProcessPreferredUILanguages(
        dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG,
    ) -> BOOL;
    pub fn SetProcessPriorityBoost(hProcess: HANDLE, bDisablePriorityBoost: BOOL) -> BOOL;
    pub fn SetProcessShutdownParameters(dwLevel: DWORD, dwFlags: DWORD) -> BOOL;
    pub fn SetProcessWorkingSetSize(
        hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T,
    ) -> BOOL;
    pub fn SetProcessWorkingSetSizeEx(
        hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T,
        Flags: DWORD,
    ) -> BOOL;
    pub fn SetProtectedPolicy(
        PolicyGuid: LPCGUID, PolicyValue: ULONG_PTR, OldPolicyValue: PULONG_PTR,
    ) -> BOOL;
    pub fn SetSearchPathMode(Flags: DWORD) -> BOOL;
    pub fn SetStdHandle(nStdHandle: DWORD, hHandle: HANDLE) -> BOOL;
    pub fn SetStdHandleEx(nStdHandle: DWORD, hHandle: HANDLE, phPrevValue: PHANDLE) -> BOOL;
    pub fn SetSystemFileCacheSize(
        MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD,
    ) -> BOOL;
    pub fn SetSystemPowerState(fSuspend: BOOL, fForce: BOOL) -> BOOL;
    pub fn SetSystemTime(lpSystemTime: *const SYSTEMTIME) -> BOOL;
    pub fn SetSystemTimeAdjustment(dwTimeAdjustment: DWORD, bTimeAdjustmentDisabled: BOOL) -> BOOL;
    pub fn SetTapeParameters(
        hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID,
    ) -> DWORD;
    pub fn SetTapePosition(
        hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD,
        dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL
    ) -> DWORD;
    pub fn SetThreadAffinityMask(hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR) -> DWORD_PTR;
    pub fn SetThreadContext(hThread: HANDLE, lpContext: *const CONTEXT) -> BOOL;
    pub fn SetThreadErrorMode(dwNewMode: DWORD, lpOldMode: LPDWORD) -> BOOL;
    pub fn SetThreadExecutionState(esFlags: EXECUTION_STATE) -> EXECUTION_STATE;
    pub fn SetThreadGroupAffinity(
        hThread: HANDLE, GroupAffinity: *const GROUP_AFFINITY,
        PreviousGroupAffinity: PGROUP_AFFINITY,
    ) -> BOOL;
    pub fn SetThreadIdealProcessor(hThread: HANDLE, dwIdealProcessor: DWORD) -> DWORD;
    pub fn SetThreadIdealProcessorEx(
        hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER,
        lpPreviousIdealProcessor: PPROCESSOR_NUMBER,
    ) -> BOOL;
    pub fn SetThreadInformation(
        hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS,
        ThreadInformation: LPVOID, ThreadInformationSize: DWORD,
    );
    pub fn SetThreadLocale(Locale: LCID) -> BOOL;
    pub fn SetThreadPreferredUILanguages(
        dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG,
    ) -> BOOL;
    pub fn SetThreadPriority(hThread: HANDLE, nPriority: c_int) -> BOOL;
    pub fn SetThreadPriorityBoost(hThread: HANDLE, bDisablePriorityBoost: BOOL) -> BOOL;
    pub fn SetThreadStackGuarantee(StackSizeInBytes: PULONG) -> BOOL;
    pub fn SetThreadUILanguage(LangId: LANGID) -> LANGID;
    pub fn SetThreadpoolStackInformation(
        ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION,
    ) -> BOOL;
    pub fn SetThreadpoolThreadMaximum(ptpp: PTP_POOL, cthrdMost: DWORD);
    pub fn SetThreadpoolThreadMinimum(ptpp: PTP_POOL, cthrdMic: DWORD) -> BOOL;
    pub fn SetThreadpoolTimer(
        pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD,
    );
    pub fn SetThreadpoolTimerEx(
        pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD,
    ) -> BOOL;
    pub fn SetThreadpoolWait(pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME);
    pub fn SetThreadpoolWaitEx(
        pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME, Reserved: PVOID,
    ) -> BOOL;
    pub fn SetTimeZoneInformation(lpTimeZoneInformation: *const TIME_ZONE_INFORMATION) -> BOOL;
    pub fn SetTimerQueueTimer(
        TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD,
        Period: DWORD, PreferIo: BOOL,
    ) -> HANDLE;
    #[cfg(target_arch = "x86_64")]
    pub fn SetUmsThreadInformation(
        UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
        UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG,
    ) -> BOOL;
    pub fn SetUnhandledExceptionFilter(
        lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER,
    ) -> LPTOP_LEVEL_EXCEPTION_FILTER;
    pub fn SetUserGeoID(GeoId: GEOID) -> BOOL;
    pub fn SetVolumeLabelA(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR) -> BOOL;
    pub fn SetVolumeLabelW(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR) -> BOOL;
    pub fn SetVolumeMountPointA(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR) -> BOOL;
    pub fn SetVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR) -> BOOL;
    pub fn SetWaitableTimer(
        hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG,
        pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: BOOL,
    ) -> BOOL;
    pub fn SetWaitableTimerEx(
        hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG,
        pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID,
        WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG,
    ) -> BOOL;
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    pub fn SetXStateFeaturesMask(Context: PCONTEXT, FeatureMask: DWORD64) -> BOOL;
    pub fn SetupComm(hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD) -> BOOL;
    pub fn SignalObjectAndWait(
        hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL,
    ) -> DWORD;
    pub fn SizeofResource(hModule: HMODULE, hResInfo: HRSRC) -> DWORD;
    pub fn Sleep(dwMilliseconds: DWORD);
    pub fn SleepConditionVariableCS(
        ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION,
        dwMilliseconds: DWORD,
    ) -> BOOL;
    pub fn SleepConditionVariableSRW(
        ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD,
        Flags: ULONG,
    ) -> BOOL;
    pub fn SleepEx(dwMilliseconds: DWORD, bAlertable: BOOL) -> DWORD;
    pub fn StartThreadpoolIo(pio: PTP_IO);
    pub fn SubmitThreadpoolWork(pwk: PTP_WORK);
    pub fn SuspendThread(hThread: HANDLE) -> DWORD;
    pub fn SwitchToFiber(lpFiber: LPVOID);
    pub fn SwitchToThread() -> BOOL;
    pub fn SystemTimeToFileTime(lpSystemTime: *const SYSTEMTIME, lpFileTime: LPFILETIME) -> BOOL;
    pub fn SystemTimeToTzSpecificLocalTime(
        lpTimeZoneInformation: *const TIME_ZONE_INFORMATION, lpUniversalTime: *const SYSTEMTIME,
        lpLocalTime: LPSYSTEMTIME,
    ) -> BOOL;
    pub fn SystemTimeToTzSpecificLocalTimeEx(
        lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
        lpUniversalTime: *const SYSTEMTIME, lpLocalTime: LPSYSTEMTIME,
    ) -> BOOL;
    pub fn TerminateJobObject(hJob: HANDLE, uExitCode: UINT) -> BOOL;
    pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL;
    pub fn TerminateThread(hThread: HANDLE, dwExitCode: DWORD) -> BOOL;
    pub fn Thread32First(hSnapshot: HANDLE, lpte: LPTHREADENTRY32) -> BOOL;
    pub fn Thread32Next(hSnapshot: HANDLE, lpte: LPTHREADENTRY32) -> BOOL;
    pub fn TlsAlloc() -> DWORD;
    pub fn TlsFree(dwTlsIndex: DWORD) -> BOOL;
    pub fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID;
    pub fn TlsSetValue(dwTlsIndex: DWORD, lpTlsValue: LPVOID) -> BOOL;
    pub fn Toolhelp32ReadProcessMemory(th32ProcessID: DWORD, lpBaseAddress: LPCVOID,
        lpBuffer: LPVOID, cbRead: SIZE_T, lpNumberOfBytesRead: *mut SIZE_T
    ) -> BOOL;
    pub fn TransactNamedPipe(
        hNamedPipe: HANDLE, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
        nOutBufferSize: DWORD, lpBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn TransmitCommChar(hFile: HANDLE, cChar: c_char) -> BOOL;
    pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN;
    pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN;
    pub fn TryEnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION) -> BOOL;
    pub fn TrySubmitThreadpoolCallback(
        pfns: PTP_SIMPLE_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
    ) -> BOOL;
    pub fn TzSpecificLocalTimeToSystemTime(
        lpTimeZoneInformation: *const TIME_ZONE_INFORMATION, lpLocalTime: *const SYSTEMTIME,
        lpUniversalTime: LPSYSTEMTIME,
    ) -> BOOL;
    pub fn TzSpecificLocalTimeToSystemTimeEx(
        lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
        lpLocalTime: *const SYSTEMTIME, lpUniversalTime: LPSYSTEMTIME,
    ) -> BOOL;
    #[cfg(target_arch = "x86_64")]
    pub fn UmsThreadYield(SchedulerParam: PVOID) -> BOOL;
    pub fn UnhandledExceptionFilter(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG;
    pub fn UnlockFile(
        hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
        nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD,
    ) -> BOOL;
    pub fn UnlockFileEx(
        hFile: HANDLE, dwReserved: DWORD, nNumberOfBytesToUnlockLow: DWORD,
        nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
    pub fn UnregisterApplicationRecoveryCallback() -> HRESULT;
    pub fn UnregisterApplicationRestart() -> HRESULT;
    pub fn UnregisterBadMemoryNotification(RegistrationHandle: PVOID) -> BOOL;
    pub fn UnregisterWait(WaitHandle: HANDLE) -> BOOL;
    pub fn UnregisterWaitEx(WaitHandle: HANDLE, CompletionEvent: HANDLE) -> BOOL;
    // pub fn UnregisterWaitUntilOOBECompleted();
    pub fn UpdateProcThreadAttribute(
        lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags: DWORD, Attribute: DWORD_PTR,
        lpValue: PVOID, cbSize: SIZE_T, lpPreviousValue: PVOID, lpReturnSize: PSIZE_T,
    ) -> BOOL;
    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 VerLanguageNameA(wLang: DWORD, szLang: LPSTR, cchLang: DWORD) -> DWORD;
    pub fn VerLanguageNameW(wLang: DWORD, szLang: LPWSTR, cchLang: DWORD) -> DWORD;
    pub fn VerSetConditionMask(
        ConditionMask: ULONGLONG, TypeMask: DWORD, Condition: BYTE,
    ) -> ULONGLONG;
    pub fn VerifyScripts(
        dwFlags: DWORD, lpLocaleScripts: LPCWSTR, cchLocaleScripts: c_int, lpTestScripts: LPCWSTR,
        cchTestScripts: c_int,
    ) -> BOOL;
    pub fn VerifyVersionInfoA(
        lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG,
    ) -> BOOL;
    pub fn VerifyVersionInfoW(
        lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG,
    ) -> BOOL;
    pub fn VirtualAlloc(
        lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD,
    ) -> LPVOID;
    pub fn VirtualAllocEx(
        hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD,
        flProtect: DWORD,
    ) -> LPVOID;
    pub fn VirtualAllocExNuma(
        hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD,
        flProtect: DWORD, nndPreferred: DWORD,
    ) -> LPVOID;
    pub fn VirtualFree(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL;
    pub fn VirtualFreeEx(
        hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD,
    ) -> BOOL;
    pub fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
    pub fn VirtualProtect(
        lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD,
    ) -> BOOL;
    pub fn VirtualProtectEx(
        hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD,
        lpflOldProtect: DWORD,
    ) -> BOOL;
    pub fn VirtualQuery(
        lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T,
    ) -> SIZE_T;
    pub fn VirtualQueryEx(
        hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T,
    ) -> SIZE_T;
    pub fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
    pub fn WTSGetActiveConsoleSessionId() -> DWORD;
    pub fn WaitCommEvent(hFile: HANDLE, lpEvtMask: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL;
    pub fn WaitForDebugEvent(lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD) -> BOOL;
    pub fn WaitForMultipleObjects(
        nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD,
    ) -> DWORD;
    pub fn WaitForMultipleObjectsEx(
        nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD,
        bAlertable: BOOL,
    ) -> DWORD;
    pub fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
    pub fn WaitForSingleObjectEx(
        hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL,
    ) -> DWORD;
    pub fn WaitForThreadpoolIoCallbacks(pio: PTP_IO, fCancelPendingCallbacks: BOOL);
    pub fn WaitForThreadpoolTimerCallbacks(pti: PTP_TIMER, fCancelPendingCallbacks: BOOL);
    pub fn WaitForThreadpoolWaitCallbacks(pwa: PTP_WAIT, fCancelPendingCallbacks: BOOL);
    pub fn WaitForThreadpoolWorkCallbacks(pwk: PTP_WORK, fCancelPendingCallbacks: BOOL);
    pub fn WaitNamedPipeA(lpNamedPipeName: LPCSTR, nTimeOut: DWORD) -> BOOL;
    pub fn WaitNamedPipeW(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD) -> BOOL;
    pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
    pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
    pub fn WerGetFlags(hProcess: HANDLE, pdwFlags: PDWORD) -> HRESULT;
    pub fn WerRegisterFile(
        pwzFile: PCWSTR, regFileType: WER_REGISTER_FILE_TYPE, dwFlags: DWORD,
    ) -> HRESULT;
    pub fn WerRegisterMemoryBlock(pvAddress: PVOID, dwSize: DWORD) -> HRESULT;
    pub fn WerRegisterRuntimeExceptionModule(
        pwszOutOfProcessCallbackDll: PCWSTR, pContext: PVOID,
    ) -> HRESULT;
    pub fn WerSetFlags(dwFlags: DWORD) -> HRESULT;
    pub fn WerUnregisterFile(pwzFilePath: PCWSTR) -> HRESULT;
    pub fn WerUnregisterMemoryBlock(pvAddress: PVOID) -> HRESULT;
    pub fn WerUnregisterRuntimeExceptionModule(
        pwszOutOfProcessCallbackDll: PCWSTR, pContext: PVOID,
    ) -> HRESULT;
    // pub fn WerpInitiateRemoteRecovery();
    pub fn WideCharToMultiByte(
      CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: c_int,
      lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL,
    ) -> c_int;
    pub fn WinExec(lpCmdLine: LPCSTR, uCmdShow: UINT) -> UINT;
    pub fn Wow64DisableWow64FsRedirection(OldValue: *mut PVOID) -> BOOL;
    pub fn Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: BOOLEAN) -> BOOLEAN;
    pub fn Wow64GetThreadContext(hThread: HANDLE, lpContext: PWOW64_CONTEXT) -> BOOL;
    pub fn Wow64GetThreadSelectorEntry(
        hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY,
    ) -> BOOL;
    pub fn Wow64RevertWow64FsRedirection(OlValue: PVOID) -> BOOL;
    pub fn Wow64SetThreadContext(hThread: HANDLE, lpContext: *const WOW64_CONTEXT) -> BOOL;
    pub fn Wow64SuspendThread(hThread: HANDLE) -> DWORD;
    pub fn WriteConsoleA(
        hConsoleOutput: HANDLE, lpBuffer: *const VOID, nNumberOfCharsToWrite: DWORD,
        lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID,
    ) -> BOOL;
    pub fn WriteConsoleInputA(
        hConsoleInput: HANDLE, lpBuffer: *const INPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsWritten: LPDWORD,
    ) -> BOOL;
    pub fn WriteConsoleInputW(
        hConsoleInput: HANDLE, lpBuffer: *const INPUT_RECORD, nLength: DWORD,
        lpNumberOfEventsWritten: LPDWORD,
    ) -> BOOL;
    pub fn WriteConsoleOutputA(
        hConsoleOutput: HANDLE, lpBuffer: *const CHAR_INFO, dwBufferSize: COORD,
        dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT,
    ) -> BOOL;
    pub fn WriteConsoleOutputAttribute(
        hConsoleOutput: HANDLE, lpAttribute: *const WORD, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfAttrsWritten: LPDWORD,
    ) -> BOOL;
    pub fn WriteConsoleOutputCharacterA(
        hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfCharsWritten: LPDWORD,
    ) -> BOOL;
    pub fn WriteConsoleOutputCharacterW(
        hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD,
        lpNumberOfCharsWritten: LPDWORD,
    ) -> BOOL;
    pub fn WriteConsoleOutputW(
        hConsoleOutput: HANDLE, lpBuffer: *const CHAR_INFO, dwBufferSize: COORD,
        dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT,
    ) -> BOOL;
    pub fn WriteConsoleW(
        hConsoleOutput: HANDLE, lpBuffer: *const VOID, nNumberOfCharsToWrite: DWORD,
        lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID,
    ) -> BOOL;
    pub fn WriteFile(
        hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD,
        lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn WriteFileEx(
        hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED,
        lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
    ) -> BOOL;
    pub fn WriteFileGather(
        hFile: HANDLE, aSegmentArray: *mut FILE_SEGMENT_ELEMENT, nNumberOfBytesToWrite: DWORD,
        lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED,
    ) -> BOOL;
    pub fn WritePrivateProfileSectionA(
        lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR,
    ) -> BOOL;
    pub fn WritePrivateProfileSectionW(
        lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR,
    ) -> BOOL;
    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 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 WriteProcessMemory(
        hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T,
        lpNumberOfBytesWritten: *mut SIZE_T,
    ) -> BOOL;
    pub fn WriteProfileSectionA(lpAppName: LPCSTR, lpString: LPCSTR) -> BOOL;
    pub fn WriteProfileSectionW(lpAppName: LPCWSTR, lpString: LPCWSTR) -> BOOL;
    pub fn WriteProfileStringA(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR) -> BOOL;
    pub fn WriteProfileStringW(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR) -> BOOL;
    pub fn WriteTapemark(
        hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL,
    ) -> DWORD;
    pub fn ZombifyActCtx(hActCtx: HANDLE) -> BOOL;
    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 _lcreat(lpPathName: LPCSTR, iAttrubute: c_int) -> HFILE;
    pub fn _llseek(hFile: HFILE, lOffset: LONG, iOrigin: c_int) -> LONG;
    pub fn _lopen(lpPathName: LPCSTR, iReadWrite: 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 lstrcat(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
    pub fn lstrcatA(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
    pub fn lstrcatW(lpString1: LPWSTR, lpString2: LPCWSTR) -> LPSTR;
    pub fn lstrcmp(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
    pub fn lstrcmpA(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
    pub fn lstrcmpW(lpString1: LPCWSTR, lpString2: LPCWSTR) -> c_int;
    pub fn lstrcmpi(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
    pub fn lstrcmpiA(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
    pub fn lstrcmpiW(lpString1: LPCWSTR, lpString2: LPCWSTR) -> c_int;
    pub fn lstrcpy(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
    pub fn lstrcpyA(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
    pub fn lstrcpyW(lpString1: LPWSTR, lpString2: LPCWSTR) -> LPSTR;
    pub fn lstrcpyn(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int) -> LPSTR;
    pub fn lstrcpynA(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int) -> LPSTR;
    pub fn lstrcpynW(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int) -> LPSTR;
    pub fn lstrlen(lpString: LPCSTR) -> c_int;
    pub fn lstrlenA(lpString: LPCSTR) -> c_int;
    pub fn lstrlenW(lpString: LPCWSTR) -> c_int;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_lstrcmpW(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_lstrcmpiW(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_lstrlenW(String: LPCUWSTR) -> c_int;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_wcschr(String: PCUWSTR, Character: WCHAR) -> PUWSTR;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_wcscpy(Destination: PUWSTR, Source: PCUWSTR) -> PUWSTR;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_wcsicmp(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_wcslen(String: PCUWSTR) -> size_t;
    #[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
    pub fn uaw_wcsrchr(String: PCUWSTR, Character: WCHAR) -> PUWSTR;
}