VOID WINAPI ExitProcess(
  _In_  UINT uExitCode
);

BOOL WINAPI TerminateProcess(
  _In_ HANDLE hProcess,
  _In_ UINT   uExitCode
);

DWORD WINAPI GetLastError();

HANDLE WINAPI GetCurrentProcess();

HANDLE WINAPI CreateFileA(
    __in     LPCSTR lpFileName,
    __in     DWORD dwDesiredAccess,
    __in     DWORD dwShareMode,
    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    __in     DWORD dwCreationDisposition,
    __in     DWORD dwFlagsAndAttributes,
    __in_opt HANDLE hTemplateFile
    );

HANDLE WINAPI CreateFileW(
    __in     LPCWSTR lpFileName,
    __in     DWORD dwDesiredAccess,
    __in     DWORD dwShareMode,
    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
    __in     DWORD dwCreationDisposition,
    __in     DWORD dwFlagsAndAttributes,
    __in_opt HANDLE hTemplateFile
    );


NTSTATUS WINAPI NtCreateFile(
  _Out_    PHANDLE            FileHandle,
  _In_     ACCESS_MASK        DesiredAccess,
  _In_     POBJECT_ATTRIBUTES ObjectAttributes,
  _Out_    PIO_STATUS_BLOCK   IoStatusBlock,
  _In_opt_ PLARGE_INTEGER     AllocationSize,
  _In_     ULONG              FileAttributes,
  _In_     ULONG              ShareAccess,
  _In_     ULONG              CreateDisposition,
  _In_     ULONG              CreateOptions,
  _In_     PVOID              EaBuffer,
  _In_     ULONG              EaLength
);

NTSTATUS WINAPI LdrLoadDll(
  __in_opt LPCWSTR               PathToFile,
  __in_opt ULONG                Flags,
  _In_ PUNICODE_STRING      ModuleFileName,
  _Out_ PHANDLE             ModuleHandle
);

NTSTATUS WINAPI NtQuerySystemInformation(
  _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
  _Inout_    PVOID SystemInformation,
  _In_       ULONG SystemInformationLength,
  _Out_opt_  PULONG ReturnLength
);


NTSTATUS WINAPI NtQueryInformationProcess(
  _In_      HANDLE           ProcessHandle,
  _In_      PROCESSINFOCLASS ProcessInformationClass,
  _Out_     PVOID            ProcessInformation,
  _In_      ULONG            ProcessInformationLength,
  _Out_opt_ PULONG           ReturnLength
);

NTSTATUS WINAPI NtSetInformationProcess(
  _In_ HANDLE               ProcessHandle,
  _In_ PROCESS_INFORMATION_CLASS ProcessInformationClass,
  _In_ PVOID                ProcessInformation,
  _In_ ULONG                ProcessInformationLength
);

NTSTATUS WINAPI NtQueryVirtualMemory(
  _In_      HANDLE                   ProcessHandle,
  _In_opt_  PVOID                    BaseAddress,
  _In_      MEMORY_INFORMATION_CLASS MemoryInformationClass,
  _Out_     PVOID                    MemoryInformation,
  _In_      SIZE_T                   MemoryInformationLength,
  _Out_opt_ PSIZE_T                  ReturnLength
);

NTSTATUS WINAPI NtQueryVolumeInformationFile(
  _In_  HANDLE               FileHandle,
  _Out_ PIO_STATUS_BLOCK     IoStatusBlock,
  _Out_ PVOID                FsInformation,
  _In_  ULONG                Length,
  _In_  FS_INFORMATION_CLASS FsInformationClass
);

NTSTATUS NtCreateThreadEx(
        PHANDLE                 ThreadHandle,
        ACCESS_MASK             DesiredAccess,
        LPVOID                  ObjectAttributes,
        HANDLE                  ProcessHandle,
        LPTHREAD_START_ROUTINE  lpStartAddress,
        LPVOID                  lpParameter,
        BOOL                    CreateSuspended,
        DWORD                   dwStackSize,
        DWORD                   Unknown1,
        DWORD                   Unknown2,
        LPVOID                  Unknown3
);

NTSTATUS WINAPI NtQueryInformationThread (
    _In_ HANDLE ThreadHandle,
    _In_ THREAD_INFORMATION_CLASS ThreadInformationClass,
    _Out_ PVOID ThreadInformation,
    _In_ ULONG ThreadInformationLength,
    _Out_ PULONG ReturnLength
);

BOOL WINAPI GetExitCodeThread(
    _In_  HANDLE hThread,
    _Out_ LPDWORD lpExitCode
);

BOOL WINAPI GetExitCodeProcess(
    __in  HANDLE hProcess,
    __out LPDWORD lpExitCode
);


BOOL WINAPI SetPriorityClass(
  _In_ HANDLE hProcess,
  _In_ DWORD  dwPriorityClass
);

DWORD WINAPI GetPriorityClass(
  _In_ HANDLE hProcess
);

LPVOID WINAPI VirtualAlloc(
  _In_opt_  LPVOID lpAddress,
  _In_      SIZE_T dwSize,
  _In_      DWORD flAllocationType,
  _In_      DWORD flProtect
);

LPVOID WINAPI VirtualAllocEx(
  _In_      HANDLE hProcess,
  _In_opt_  LPVOID lpAddress,
  _In_      SIZE_T dwSize,
  _In_      DWORD flAllocationType,
  _In_      DWORD flProtect
);

NTSTATUS WINAPI NtAllocateVirtualMemory(
  _In_    HANDLE    ProcessHandle,
  _Inout_ PVOID     *BaseAddress,
  _In_    ULONG_PTR ZeroBits,
  _Inout_ PSIZE_T   RegionSize,
  _In_    ULONG     AllocationType,
  _In_    ULONG     Protect
);


NTSTATUS WINAPI NtProtectVirtualMemory(
  _In_ HANDLE               ProcessHandle,
  _Inout_ PVOID            *BaseAddress,
  _Inout_ PULONG           NumberOfBytesToProtect,
  _In_ ULONG                NewAccessProtection,
  _Out_ PULONG              OldAccessProtection
);


BOOL WINAPI VirtualFree(
  _In_ LPVOID lpAddress,
  _In_ SIZE_T dwSize,
  _In_ DWORD  dwFreeType
);

BOOL WINAPI VirtualFreeEx(
  _In_ HANDLE hProcess,
  _In_ LPVOID lpAddress,
  _In_ SIZE_T dwSize,
  _In_ DWORD  dwFreeType
);


NTSTATUS WINAPI NtFreeVirtualMemory(
  _In_    HANDLE  ProcessHandle,
  _Inout_ PVOID   *BaseAddress,
  _Inout_ PSIZE_T RegionSize,
  _In_    ULONG   FreeType
);

BOOL WINAPI VirtualProtect(
  _In_   LPVOID lpAddress,
  _In_   SIZE_T dwSize,
  _In_   DWORD flNewProtect,
  _Out_  PDWORD lpflOldProtect
);

BOOL WINAPI VirtualProtectEx(
  _In_  HANDLE hProcess,
  _In_  LPVOID lpAddress,
  _In_  SIZE_T dwSize,
  _In_  DWORD  flNewProtect,
  _Out_ PDWORD lpflOldProtect
);


DWORD VirtualQuery(
  LPCVOID lpAddress,
  PMEMORY_BASIC_INFORMATION lpBuffer,
  DWORD dwLength
);

SIZE_T WINAPI VirtualQueryEx(
    _In_     HANDLE hProcess,
    _In_opt_ LPCVOID lpAddress,
    _Out_ PMEMORY_BASIC_INFORMATION lpBuffer,
    _In_     SIZE_T dwLength
    );

BOOL WINAPI QueryWorkingSet(
  _In_  HANDLE hProcess,
  _Out_ PVOID  pv,
  _In_  DWORD  cb
);

BOOL WINAPI QueryWorkingSetEx(
  _In_    HANDLE hProcess,
  _Inout_ PVOID  pv,
  _In_    DWORD  cb
);


DWORD WINAPI GetModuleFileNameA(
  _In_opt_  HMODULE hModule,
  _Out_     LPSTR lpFilename,
  _In_      DWORD nSize
);

DWORD WINAPI GetModuleFileNameW(
  _In_opt_  HMODULE hModule,
  _Out_     LPWSTR lpFilename,
  _In_      DWORD nSize
);

HANDLE WINAPI CreateThread(
  _In_opt_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
  _In_       SIZE_T dwStackSize,
  _In_       LPTHREAD_START_ROUTINE lpStartAddress,
  _In_opt_   LPVOID lpParameter,
  _In_       DWORD dwCreationFlags,
  _Out_opt_  LPDWORD lpThreadId
);

HANDLE WINAPI CreateRemoteThread(
  _In_   HANDLE hProcess,
  _In_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
  _In_   SIZE_T dwStackSize,
  _In_   LPTHREAD_START_ROUTINE lpStartAddress,
  _In_   LPVOID lpParameter,
  _In_   DWORD dwCreationFlags,
  _Out_  LPDWORD lpThreadId
);

BOOL WINAPI VirtualProtect(
  _In_   LPVOID lpAddress,
  _In_   SIZE_T dwSize,
  _In_   DWORD flNewProtect,
  _Out_  PDWORD lpflOldProtect
);

BOOL WINAPI CreateProcessA(
    __in_opt    LPCSTR lpApplicationName,
    __inout_opt LPSTR lpCommandLine,
    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    __in        BOOL bInheritHandles,
    __in        DWORD dwCreationFlags,
    __in_opt    LPVOID lpEnvironment,
    __in_opt    LPCSTR lpCurrentDirectory,
    __in        LPSTARTUPINFOA lpStartupInfo,
    __out       LPPROCESS_INFORMATION lpProcessInformation
);

BOOL WINAPI CreateProcessW(
    __in_opt    LPCWSTR lpApplicationName,
    __inout_opt LPWSTR lpCommandLine,
    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    __in        BOOL bInheritHandles,
    __in        DWORD dwCreationFlags,
    __in_opt    LPVOID lpEnvironment,
    __in_opt    LPCWSTR lpCurrentDirectory,
    __in        LPSTARTUPINFOW lpStartupInfo,
    __out       LPPROCESS_INFORMATION lpProcessInformation
);

BOOL WINAPI CreateProcessAsUserA(
  _In_opt_    HANDLE                hToken,
  _In_opt_    LPSTR               lpApplicationName,
  _Inout_opt_ LPSTR                lpCommandLine,
  _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,
  _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,
  _In_        BOOL                  bInheritHandles,
  _In_        DWORD                 dwCreationFlags,
  _In_opt_    LPVOID                lpEnvironment,
  _In_opt_    LPSTR               lpCurrentDirectory,
  _In_        LPSTARTUPINFOA         lpStartupInfo,
  _Out_       LPPROCESS_INFORMATION lpProcessInformation
);


BOOL WINAPI CreateProcessAsUserW(
  _In_opt_    HANDLE                hToken,
  _In_opt_    LPWSTR               lpApplicationName,
  _Inout_opt_ LPWSTR                lpCommandLine,
  _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,
  _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,
  _In_        BOOL                  bInheritHandles,
  _In_        DWORD                 dwCreationFlags,
  _In_opt_    LPVOID                lpEnvironment,
  _In_opt_    LPWSTR               lpCurrentDirectory,
  _In_        LPSTARTUPINFOW         lpStartupInfo,
  _Out_       LPPROCESS_INFORMATION lpProcessInformation
);

BOOL WINAPI GetThreadContext(
    __in    HANDLE hThread,
    __inout LPCONTEXT lpContext
);

NTSTATUS WINAPI NtGetContextThread(
    __in    HANDLE hThread,
    __inout LPCONTEXT lpContext
);

BOOL WINAPI SetThreadContext(
    __in HANDLE hThread,
    __in CONST LPCONTEXT lpContext
);

NTSTATUS WINAPI NtSetContextThread(
    __in HANDLE hThread,
    __in CONST LPCONTEXT lpContext
);


HANDLE WINAPI OpenThread(
    __in DWORD dwDesiredAccess,
    __in BOOL bInheritHandle,
    __in DWORD dwThreadId
);

HANDLE WINAPI OpenProcess(
    __in DWORD dwDesiredAccess,
    __in BOOL bInheritHandle,
    __in DWORD dwProcessId
);

BOOL WINAPI CloseHandle(
    __in HANDLE hObject
);

BOOL WINAPI ReadProcessMemory(
  _In_   HANDLE     hProcess,
  _In_   LPCVOID    lpBaseAddress,
  _Out_  LPVOID     lpBuffer,
  _In_   SIZE_T     nSize,
  _Out_  SIZE_T     *lpNumberOfBytesRead
);

NTSTATUS WINAPI NtWow64ReadVirtualMemory64(
  _In_   HANDLE     hProcess,
  _In_   ULONG64    lpBaseAddress,
  _Out_  LPVOID     lpBuffer,
  _In_   ULONG64    nSize,
  _Out_  PULONG64   lpNumberOfBytesRead
);

NTSTATUS WINAPI NtReadVirtualMemory(
  _In_   HANDLE     hProcess,
  _In_   PVOID      lpBaseAddress,
  _Out_  LPVOID     lpBuffer,
  _In_   ULONG      nSize,
  _Out_  PULONG     lpNumberOfBytesRead
);


BOOL WINAPI WriteProcessMemory(
  _In_   HANDLE     hProcess,
  _In_   LPVOID     lpBaseAddress,
  _In_   LPCVOID    lpBuffer,
  _In_   SIZE_T     nSize,
  _Out_  SIZE_T     *lpNumberOfBytesWritten
);


NTSTATUS WINAPI NtWow64WriteVirtualMemory64(
  _In_   HANDLE     hProcess,
  _In_   ULONG64    lpBaseAddress,
  _Out_  LPVOID     lpBuffer,
  _In_   ULONG64    nSize,
  _Out_  PULONG64   lpNumberOfBytesWritten
);


NTSTATUS WINAPI NtWriteVirtualMemory(
  _In_ HANDLE               ProcessHandle,
  _In_ PVOID                BaseAddress,
  _In_ PVOID                Buffer,
  _In_ ULONG                NumberOfBytesToWrite,
  _Out_ PULONG              NumberOfBytesWritten
);


HANDLE WINAPI CreateToolhelp32Snapshot(
  _In_  DWORD dwFlags,
  _In_  DWORD th32ProcessID
);

BOOL WINAPI Thread32First(
  _In_     HANDLE hSnapshot,
  _Inout_  LPTHREADENTRY32 lpte
);

BOOL WINAPI Thread32Next(
  _In_   HANDLE hSnapshot,
  _Out_  LPTHREADENTRY32 lpte
);

BOOL WINAPI Process32First(
  _In_     HANDLE hSnapshot,
  _Inout_  LPPROCESSENTRY32 lppe
);

BOOL WINAPI Process32Next(
  _In_   HANDLE hSnapshot,
  _Out_  LPPROCESSENTRY32 lppe
);

BOOL Process32FirstW(
    HANDLE hSnapshot,
    LPPROCESSENTRY32W lppe
);

BOOL Process32NextW(
    HANDLE hSnapshot,
    LPPROCESSENTRY32W lppe
);

FARPROC WINAPI GetProcAddress(
  _In_  HMODULE hModule,
  _In_  LPCSTR lpProcName
);


HMODULE WINAPI LoadLibraryA(
    __in LPCSTR lpFileName
);

HMODULE WINAPI LoadLibraryW(
    __in LPCWSTR lpFileName
);

HMODULE LoadLibraryExA(
  LPCSTR lpLibFileName,
  HANDLE hFile,
  DWORD  dwFlags
);

HMODULE LoadLibraryExW(
  LPCWSTR lpLibFileName,
  HANDLE  hFile,
  DWORD   dwFlags
);

BOOL FreeLibrary(
  HMODULE hLibModule
);

BOOL WINAPI OpenProcessToken(
  _In_   HANDLE ProcessHandle,
  _In_   DWORD DesiredAccess,
  _Out_  PHANDLE TokenHandle
);

BOOL WINAPI DuplicateToken(
  _In_  HANDLE                       ExistingTokenHandle,
  _In_  SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
  _Out_ PHANDLE                      DuplicateTokenHandle
);


BOOL WINAPI DuplicateTokenEx(
  _In_     HANDLE                       hExistingToken,
  _In_     DWORD                        dwDesiredAccess,
  _In_opt_ LPSECURITY_ATTRIBUTES        lpTokenAttributes,
  _In_     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
  _In_     TOKEN_TYPE                   TokenType,
  _Out_    PHANDLE                      phNewToken
);


BOOL WINAPI OpenThreadToken(
  _In_  HANDLE  ThreadHandle,
  _In_  DWORD   DesiredAccess,
  _In_  BOOL    OpenAsSelf,
  _Out_ PHANDLE TokenHandle
);

BOOL WINAPI SetThreadToken(
  _In_opt_ PHANDLE Thread,
  _In_opt_ HANDLE  Token
);

BOOL WINAPI LookupPrivilegeValueA(
    __in_opt LPCSTR lpSystemName,
    __in     LPCSTR lpName,
    __out    PLUID   lpLuid
);

BOOL WINAPI LookupPrivilegeValueW(
    __in_opt LPCWSTR lpSystemName,
    __in     LPCWSTR lpName,
    __out    PLUID   lpLuid
);

BOOL WINAPI LookupPrivilegeNameA(
  _In_opt_  LPCSTR lpSystemName,
  _In_      PLUID   lpLuid,
  _Out_opt_ LPCSTR  lpName,
  _Inout_   LPDWORD cchName
);

BOOL WINAPI LookupPrivilegeNameW(
  _In_opt_  LPCWSTR lpSystemName,
  _In_      PLUID   lpLuid,
  _Out_opt_ LPCWSTR  lpName,
  _Inout_   LPDWORD cchName
);

BOOL WINAPI AdjustTokenPrivileges(
  _In_       HANDLE TokenHandle,
  _In_       BOOL DisableAllPrivileges,
  _In_opt_   PTOKEN_PRIVILEGES NewState,
  _In_       DWORD BufferLength,
  _Out_opt_  PTOKEN_PRIVILEGES PreviousState,
  _Out_opt_  PDWORD ReturnLength
);

HRSRC WINAPI FindResourceA(
    __in_opt HMODULE hModule,
    __in     LPCSTR lpName,
    __in     LPCSTR lpType
);

HRSRC WINAPI FindResourceW(
    __in_opt HMODULE hModule,
    __in     LPCWSTR lpName,
    __in     LPCWSTR lpType
);

DWORD WINAPI SizeofResource(
  _In_opt_  HMODULE hModule,
  _In_      HRSRC hResInfo
);

HGLOBAL WINAPI LoadResource(
  _In_opt_  HMODULE hModule,
  _In_      HRSRC hResInfo
);

LPVOID WINAPI LockResource(
  _In_  HGLOBAL hResData
);

BOOL WINAPI GetVersionExA(
    __inout LPOSVERSIONINFOA lpVersionInformation
);

BOOL WINAPI GetVersionExW(
    __inout LPOSVERSIONINFOW lpVersionInformation
);

DWORD GetVersion();

HANDLE GetCurrentThread();

DWORD GetCurrentThreadId();

DWORD GetCurrentProcessorNumber();

BOOL AllocConsole();

BOOL FreeConsole();

HANDLE WINAPI GetStdHandle(
  _In_  DWORD nStdHandle
);

BOOL WINAPI SetStdHandle(
  _In_  DWORD nStdHandle,
  _In_  HANDLE hHandle
);

DWORD WINAPI SetThreadAffinityMask(
  _In_  HANDLE hThread,
  _In_  DWORD dwThreadAffinityMask
);

BOOL WINAPI ReadFile(
  _In_        HANDLE       hFile,
  _Out_       LPVOID       lpBuffer,
  _In_        DWORD        nNumberOfBytesToRead,
  _Out_opt_   LPDWORD      lpNumberOfBytesRead,
  _Inout_opt_ LPOVERLAPPED lpOverlapped
);

BOOL WINAPI WriteFile(
  _In_         HANDLE hFile,
  _In_         LPCVOID lpBuffer,
  _In_         DWORD nNumberOfBytesToWrite,
  _Out_opt_    LPDWORD lpNumberOfBytesWritten,
  _Inout_opt_  LPOVERLAPPED lpOverlapped
);

DWORD WINAPI GetExtendedTcpTable(
  _Out_    PVOID pTcpTable,
  _Inout_  PDWORD pdwSize,
  _In_     BOOL bOrder,
  _In_     ULONG ulAf,
  _In_     TCP_TABLE_CLASS TableClass,
  _In_     ULONG Reserved
);

DWORD WINAPI GetExtendedUdpTable(
  _Out_    PVOID pUdpTable,
  _Inout_  PDWORD pdwSize,
  _In_     BOOL bOrder,
  _In_     ULONG ulAf,
  _In_     UDP_TABLE_CLASS TableClass,
  _In_     ULONG Reserved
);

DWORD WINAPI SetTcpEntry(
  _In_  PMIB_TCPROW pTcpRow
);

PVOID WINAPI AddVectoredContinueHandler(
  _In_  ULONG FirstHandler,
  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
);


PVOID WINAPI AddVectoredExceptionHandler(
  _In_  ULONG FirstHandler,
  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
);

BOOL WINAPI TerminateThread(
  _Inout_  HANDLE hThread,
  _In_     DWORD dwExitCode
);

VOID WINAPI ExitThread(
  _In_  DWORD dwExitCode
);

ULONG WINAPI RemoveVectoredExceptionHandler(
  _In_  PVOID Handler
);

DWORD WINAPI ResumeThread(
  _In_  HANDLE hThread
);

DWORD WINAPI SuspendThread(
  _In_  HANDLE hThread
);



DWORD WINAPI WaitForSingleObject(
  _In_  HANDLE hHandle,
  _In_  DWORD dwMilliseconds
);

DWORD WINAPI GetThreadId(
 _In_ HANDLE Thread
 );

HMODULE WINAPI LoadLibraryExA(
  _In_       LPCSTR lpFileName,
  _Reserved_ HANDLE  hFile,
  _In_       DWORD   dwFlags
);

HMODULE WINAPI LoadLibraryExW(
  _In_       LPCWSTR lpFileName,
  _Reserved_ HANDLE  hFile,
  _In_       DWORD   dwFlags
);

BOOL WINAPI SymInitialize(
  _In_     HANDLE hProcess,
  _In_opt_ LPCSTR UserSearchPath,
  _In_     BOOL   fInvadeProcess
);

BOOL WINAPI SymFromName(
  _In_    HANDLE       hProcess,
  _In_    LPCSTR       Name,
  _Inout_ PSYMBOL_INFO Symbol
);

DWORD64 WINAPI SymLoadModuleEx(
  _In_ HANDLE        hProcess,
  _In_ HANDLE        hFile,
  _In_ LPCSTR        ImageName,
  _In_ LPCSTR        ModuleName,
  _In_ DWORD64       BaseOfDll,
  _In_ DWORD         DllSize,
  _In_ PMODLOAD_DATA Data,
  _In_ DWORD         Flags
);

DWORD WINAPI SymSetOptions(
  _In_ DWORD SymOptions
);

BOOL WINAPI SymGetTypeInfo(
  _In_  HANDLE                    hProcess,
  _In_  DWORD64                   ModBase,
  _In_  ULONG                     TypeId,
  _In_  IMAGEHLP_SYMBOL_TYPE_INFO GetType,
  _Out_ PVOID                     pInfo
);

BOOL WINAPI DeviceIoControl(
  _In_        HANDLE       hDevice,
  _In_        DWORD        dwIoControlCode,
  _In_opt_    LPVOID       lpInBuffer,
  _In_        DWORD        nInBufferSize,
  _Out_opt_   LPVOID       lpOutBuffer,
  _In_        DWORD        nOutBufferSize,
  _Out_opt_   LPDWORD      lpBytesReturned,
  _Inout_opt_ LPOVERLAPPED lpOverlapped
);

BOOL WINAPI GetTokenInformation(
  _In_      HANDLE                  TokenHandle,
  _In_      TOKEN_INFORMATION_CLASS TokenInformationClass,
  _Out_opt_ LPVOID                  TokenInformation,
  _In_      DWORD                   TokenInformationLength,
  _Out_     PDWORD                  ReturnLength
);

LONG WINAPI RegOpenKeyExA(
  _In_     HKEY    hKey,
  _In_opt_ LPCSTR lpSubKey,
  _In_     DWORD   ulOptions,
  _In_     REGSAM  samDesired,
  _Out_    PHKEY   phkResult
);

LONG WINAPI RegOpenKeyExW(
  _In_     HKEY    hKey,
  _In_opt_ LPWSTR lpSubKey,
  _In_     DWORD   ulOptions,
  _In_     REGSAM  samDesired,
  _Out_    PHKEY   phkResult
);

LONG WINAPI RegGetValueA(
  _In_        HKEY    hkey,
  _In_opt_    LPCSTR lpSubKey,
  _In_opt_    LPCSTR lpValue,
  _In_opt_    DWORD   dwFlags,
  _Out_opt_   LPDWORD pdwType,
  _Out_opt_   PVOID   pvData,
  _Inout_opt_ LPDWORD pcbData
);

LONG WINAPI RegGetValueW(
  _In_        HKEY    hkey,
  _In_opt_    LPWSTR lpSubKey,
  _In_opt_    LPWSTR lpValue,
  _In_opt_    DWORD   dwFlags,
  _Out_opt_   LPDWORD pdwType,
  _Out_opt_   PVOID   pvData,
  _Inout_opt_ LPDWORD pcbData
);

LONG WINAPI RegCloseKey(
  _In_ HKEY hKey
);

BOOL WINAPI Wow64DisableWow64FsRedirection(
  _Out_ PVOID *OldValue
);

BOOL WINAPI Wow64RevertWow64FsRedirection(
  _In_ PVOID OldValue
);

BOOLEAN WINAPI Wow64EnableWow64FsRedirection(
  _In_ BOOLEAN Wow64FsEnableRedirection
);

BOOL WINAPI Wow64GetThreadContext(
    _In_    HANDLE hThread,
    _Inout_ PWOW64_CONTEXT lpContext
);

BOOL WINAPI SetConsoleCtrlHandler(
  _In_opt_ PHANDLER_ROUTINE HandlerRoutine,
  _In_     BOOL             Add
);

LONG WINAPI WinVerifyTrust(
    _In_opt_ HWND hwnd,
    _In_ GUID *pgActionID,
    _Inout_ LPVOID pWVTData
);

HGLOBAL WINAPI GlobalAlloc(
  _In_ UINT   uFlags,
  _In_ SIZE_T dwBytes
);

HGLOBAL WINAPI GlobalFree(
  _In_ HGLOBAL hMem
);

BOOL WINAPI GlobalUnlock(
  _In_ HGLOBAL hMem
);

LPVOID WINAPI GlobalLock(
  _In_ HGLOBAL hMem
);

BOOL WINAPI OpenClipboard(
  _In_opt_ HWND hWndNewOwner
);

BOOL WINAPI EmptyClipboard();

BOOL WINAPI CloseClipboard();

HANDLE WINAPI SetClipboardData(
  _In_     UINT   uFormat,
  _In_opt_ HANDLE hMem
);

HANDLE WINAPI GetClipboardData(
  _In_ UINT uFormat
);

UINT WINAPI EnumClipboardFormats(
  _In_ UINT format
);

INT WINAPI GetClipboardFormatNameA(
  _In_  UINT   format,
  _Out_ LPCSTR lpszFormatName,
  _In_  INT    cchMaxCount
);

INT WINAPI GetClipboardFormatNameW(
  _In_  UINT   format,
  _Out_ LPCWSTR lpszFormatName,
  _In_  INT    cchMaxCount
);

LONG WINAPI WinVerifyTrust(
  _In_ HWND   hWnd,
  _In_ GUID   *pgActionID,
  _In_ LPVOID pWVTData
);

BOOL WINAPI OpenProcessToken (
    __in        HANDLE ProcessHandle,
    __in        DWORD DesiredAccess,
    __deref_out PHANDLE TokenHandle
);

BOOL WINAPI OpenThreadToken (
    __in        HANDLE ThreadHandle,
    __in        DWORD DesiredAccess,
    __in        BOOL OpenAsSelf,
    __deref_out PHANDLE TokenHandle
);


BOOL WINAPI GetTokenInformation (
    __in      HANDLE TokenHandle,
    __in      TOKEN_INFORMATION_CLASS TokenInformationClass,
    __out     LPVOID TokenInformation,
    __in      DWORD TokenInformationLength,
    __out     PDWORD ReturnLength
);

BOOL WINAPI SetTokenInformation (
    __in HANDLE TokenHandle,
    __in TOKEN_INFORMATION_CLASS TokenInformationClass,
    __in LPVOID TokenInformation,
    __in DWORD TokenInformationLength
);




BOOL WINAPI CreateWellKnownSid(
  _In_      WELL_KNOWN_SID_TYPE WellKnownSidType,
  _In_opt_  PSID                DomainSid,
  _Out_opt_ PSID                pSid,
  _Inout_   DWORD               *cbSid
);


VOID DebugBreak();

BOOL WINAPI WaitForDebugEvent(
    __in LPDEBUG_EVENT lpDebugEvent,
    __in DWORD dwMilliseconds
    );

BOOL WINAPI ContinueDebugEvent(
    __in DWORD dwProcessId,
    __in DWORD dwThreadId,
    __in DWORD dwContinueStatus
    );

BOOL WINAPI DebugActiveProcess(
    __in DWORD dwProcessId
    );

BOOL WINAPI DebugActiveProcessStop(
    __in DWORD dwProcessId
    );

BOOL WINAPI DebugSetProcessKillOnExit(
    __in BOOL KillOnExit
    );

BOOL WINAPI DebugBreakProcess (
    __in HANDLE Process
    );

DWORD WINAPI GetProcessId(
  _In_ HANDLE Process
);

BOOL WINAPI Wow64SetThreadContext(
    __in HANDLE hThread,
    __in CONST WOW64_CONTEXT *lpContext
);

DWORD WINAPI GetMappedFileNameW (
    __in HANDLE hProcess,
    __in LPVOID lpv,
    __out PVOID lpFilename,
    __in DWORD nSize
);

DWORD WINAPI GetMappedFileNameA (
    __in HANDLE hProcess,
    __in LPVOID lpv,
    __out PVOID lpFilename,
    __in DWORD nSize
);

VOID RtlInitString (
    PSTRING DestinationString,
    LPCSTR SourceString
);


VOID RtlInitUnicodeString (
    PUNICODE_STRING DestinationString,
    LPCWSTR SourceString
);

NTSTATUS RtlAnsiStringToUnicodeString (
    PUNICODE_STRING DestinationString,
    PCANSI_STRING SourceString,
    BOOLEAN AllocateDestinationString
);

NTSTATUS RtlDecompressBuffer(
    USHORT CompressionFormat,
    PUCHAR UncompressedBuffer,
    ULONG  UncompressedBufferSize,
    PUCHAR CompressedBuffer,
    ULONG  CompressedBufferSize,
    PULONG FinalUncompressedSize
);

NTSTATUS RtlDecompressBufferEx(
   USHORT CompressionFormat,
   PUCHAR UncompressedBuffer,
   ULONG  UncompressedBufferSize,
   PUCHAR CompressedBuffer,
   ULONG  CompressedBufferSize,
   PULONG FinalUncompressedSize,
   PVOID  WorkSpace
);

NTSTATUS RtlGetCompressionWorkSpaceSize(
   USHORT CompressionFormatAndEngine,
   PULONG CompressBufferWorkSpaceSize,
   PULONG CompressFragmentWorkSpaceSize
);

NTSTATUS NtCreateSection(
    PHANDLE            SectionHandle,
    ACCESS_MASK        DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes,
    PLARGE_INTEGER     MaximumSize,
    ULONG              SectionPageProtection,
    ULONG              AllocationAttributes,
    HANDLE             FileHandle
);

NTSTATUS NtOpenSection(
    PHANDLE            SectionHandle,
    ACCESS_MASK        DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes
);

NTSTATUS NtMapViewOfSection(
    HANDLE          SectionHandle,
    HANDLE          ProcessHandle,
    PVOID           *BaseAddress,
    ULONG_PTR       ZeroBits,
    SIZE_T          CommitSize,
    PLARGE_INTEGER  SectionOffset,
    PSIZE_T         ViewSize,
    SECTION_INHERIT InheritDisposition,
    ULONG           AllocationType,
    ULONG           Win32Protect
);

NTSTATUS NtUnmapViewOfSection(
    HANDLE ProcessHandle,
    PVOID  BaseAddress
);

HANDLE WINAPI OpenEventA(
    __in DWORD dwDesiredAccess,
    __in BOOL bInheritHandle,
    __in LPCSTR lpName
);


HANDLE WINAPI OpenEventW(
    __in DWORD dwDesiredAccess,
    __in BOOL bInheritHandle,
    __in LPCWSTR lpName
);

NTSTATUS WINAPI NtOpenEvent(
    __out PHANDLE EventHandle,
    __in ACCESS_MASK DesiredAccess,
    __in POBJECT_ATTRIBUTES ObjectAttributes
);


INT WINAPI lstrcmpA(
    __in LPCSTR lpString1,
    __in LPCSTR lpString2
);

INT WINAPI lstrcmpW(
    __in LPCWSTR lpString1,
    __in LPCWSTR lpString2
);


HANDLE WINAPI CreateFileMappingA(
    __in     HANDLE hFile,
    __in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
    __in     DWORD flProtect,
    __in     DWORD dwMaximumSizeHigh,
    __in     DWORD dwMaximumSizeLow,
    __in_opt LPCSTR lpName
);

HANDLE WINAPI  CreateFileMappingW(
    __in     HANDLE hFile,
    __in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
    __in     DWORD flProtect,
    __in     DWORD dwMaximumSizeHigh,
    __in     DWORD dwMaximumSizeLow,
    __in_opt LPCWSTR lpName
);


LPVOID WINAPI MapViewOfFile(
    __in HANDLE hFileMappingObject,
    __in DWORD dwDesiredAccess,
    __in DWORD dwFileOffsetHigh,
    __in DWORD dwFileOffsetLow,
    __in SIZE_T dwNumberOfBytesToMap
);


SC_HANDLE WINAPI OpenSCManagerA(
    __in_opt        LPCSTR                lpMachineName,
    __in_opt        LPCSTR                lpDatabaseName,
    __in            DWORD                   dwDesiredAccess
);

SC_HANDLE WINAPI OpenSCManagerW(
    __in_opt        LPCWSTR                lpMachineName,
    __in_opt        LPCWSTR                lpDatabaseName,
    __in            DWORD                   dwDesiredAccess
);

BOOL WINAPI CloseServiceHandle(
  _In_ SC_HANDLE hSCObject
);

BOOL WINAPI EnumServicesStatusExA(
    __in            SC_HANDLE               hSCManager,
    __in            SC_ENUM_TYPE            InfoLevel,
    __in            DWORD                   dwServiceType,
    __in            DWORD                   dwServiceState,
    _Out_opt_       LPBYTE                  lpServices,
    __in            DWORD                   cbBufSize,
    __out           LPDWORD                 pcbBytesNeeded,
    __out           LPDWORD                 lpServicesReturned,
    __inout_opt     LPDWORD                 lpResumeHandle,
    __in_opt        LPCSTR                pszGroupName
);


BOOL WINAPI EnumServicesStatusExW(
    __in            SC_HANDLE               hSCManager,
    __in            SC_ENUM_TYPE            InfoLevel,
    __in            DWORD                   dwServiceType,
    __in            DWORD                   dwServiceState,
    _Out_opt_       LPBYTE                  lpServices,
    __in            DWORD                   cbBufSize,
    __out           LPDWORD                 pcbBytesNeeded,
    __out           LPDWORD                 lpServicesReturned,
    __inout_opt     LPDWORD                 lpResumeHandle,
    __in_opt        LPCWSTR                pszGroupName
    );


BOOL WINAPI StartServiceA(
  _In_     SC_HANDLE hService,
  _In_     DWORD     dwNumServiceArgs,
  _In_opt_ LPCSTR   *lpServiceArgVectors
);

BOOL WINAPI StartServiceW(
  _In_     SC_HANDLE hService,
  _In_     DWORD     dwNumServiceArgs,
  _In_opt_ LPCWSTR   *lpServiceArgVectors
);

SC_HANDLE WINAPI OpenServiceA(
  _In_ SC_HANDLE hSCManager,
  _In_ LPCSTR   lpServiceName,
  _In_ DWORD     dwDesiredAccess
);


SC_HANDLE WINAPI OpenServiceW(
  _In_ SC_HANDLE hSCManager,
  _In_ LPCWSTR   lpServiceName,
  _In_ DWORD     dwDesiredAccess
);


DWORD WINAPI GetLogicalDriveStringsA(
  _In_  DWORD  nBufferLength,
  _Out_ LPCSTR lpBuffer
);


DWORD WINAPI GetLogicalDriveStringsW(
  _In_  DWORD  nBufferLength,
  _Out_ LPWSTR lpBuffer
);



BOOL WINAPI GetVolumeInformationA(
  _In_opt_  LPCSTR lpRootPathName,
  _Out_opt_ LPSTR  lpVolumeNameBuffer,
  _In_      DWORD   nVolumeNameSize,
  _Out_opt_ LPDWORD lpVolumeSerialNumber,
  _Out_opt_ LPDWORD lpMaximumComponentLength,
  _Out_opt_ LPDWORD lpFileSystemFlags,
  _Out_opt_ LPSTR  lpFileSystemNameBuffer,
  _In_      DWORD   nFileSystemNameSize
);


BOOL WINAPI GetVolumeInformationW(
  _In_opt_  LPWSTR lpRootPathName,
  _Out_opt_ LPWSTR  lpVolumeNameBuffer,
  _In_      DWORD   nVolumeNameSize,
  _Out_opt_ LPDWORD lpVolumeSerialNumber,
  _Out_opt_ LPDWORD lpMaximumComponentLength,
  _Out_opt_ LPDWORD lpFileSystemFlags,
  _Out_opt_ LPWSTR  lpFileSystemNameBuffer,
  _In_      DWORD   nFileSystemNameSize
);


BOOL WINAPI GetVolumeNameForVolumeMountPointA(
  _In_  LPCSTR lpszVolumeMountPoint,
  _Out_ LPCSTR  lpszVolumeName,
  _In_  DWORD   cchBufferLength
);


BOOL WINAPI GetVolumeNameForVolumeMountPointW(
  _In_  LPWSTR lpszVolumeMountPoint,
  _Out_ LPWSTR  lpszVolumeName,
  _In_  DWORD   cchBufferLength
);

UINT WINAPI GetDriveTypeA(
  _In_opt_ LPCSTR lpRootPathName
);

UINT WINAPI GetDriveTypeW(
  _In_opt_ LPWSTR lpRootPathName
);

DWORD WINAPI QueryDosDeviceA(
  _In_opt_ LPCSTR lpDeviceName,
  _Out_    LPCSTR  lpTargetPath,
  _In_     DWORD   ucchMax
);

DWORD WINAPI QueryDosDeviceW(
  _In_opt_ LPWSTR lpDeviceName,
  _Out_    LPWSTR  lpTargetPath,
  _In_     DWORD   ucchMax
);


HANDLE WINAPI FindFirstVolumeA(
  _Out_ LPCSTR lpszVolumeName,
  _In_  DWORD  cchBufferLength
);

HANDLE WINAPI FindFirstVolumeW(
  _Out_ LPWSTR lpszVolumeName,
  _In_  DWORD  cchBufferLength
);

BOOL WINAPI FindNextVolumeA(
  _In_  HANDLE hFindVolume,
  _Out_ LPCSTR lpszVolumeName,
  _In_  DWORD  cchBufferLength
);

BOOL WINAPI FindNextVolumeW(
  _In_  HANDLE hFindVolume,
  _Out_ LPWSTR lpszVolumeName,
  _In_  DWORD  cchBufferLength
);

NTSTATUS WINAPI NtQueryObject(
  _In_opt_  HANDLE                   Handle,
  _In_      OBJECT_INFORMATION_CLASS ObjectInformationClass,
  _Out_opt_ PVOID                    ObjectInformation,
  _In_      ULONG                    ObjectInformationLength,
  _Out_opt_ PULONG                   ReturnLength
);

BOOL WINAPI DuplicateHandle(
  _In_  HANDLE   hSourceProcessHandle,
  _In_  HANDLE   hSourceHandle,
  _In_  HANDLE   hTargetProcessHandle,
  _Out_ LPHANDLE lpTargetHandle,
  _In_  DWORD    dwDesiredAccess,
  _In_  BOOL     bInheritHandle,
  _In_  DWORD    dwOptions
);

NTSTATUS WINAPI ZwDuplicateObject(
  _In_      HANDLE      SourceProcessHandle,
  _In_      HANDLE      SourceHandle,
  _In_opt_  HANDLE      TargetProcessHandle,
  _Out_opt_ PHANDLE     TargetHandle,
  _In_      ACCESS_MASK DesiredAccess,
  _In_      ULONG       HandleAttributes,
  _In_      ULONG       Options
);


DWORD WINAPI GetModuleBaseNameA(
  _In_     HANDLE  hProcess,
  _In_opt_ HMODULE hModule,
  _Out_    LPCSTR  lpBaseName,
  _In_     DWORD   nSize
);

DWORD WINAPI GetModuleBaseNameW(
  _In_     HANDLE  hProcess,
  _In_opt_ HMODULE hModule,
  _Out_    LPWSTR  lpBaseName,
  _In_     DWORD   nSize
);

DWORD WINAPI GetProcessImageFileNameA(
  _In_  HANDLE hProcess,
  _Out_ LPCSTR lpImageFileName,
  _In_  DWORD  nSize
);

DWORD WINAPI GetProcessImageFileNameW(
  _In_  HANDLE hProcess,
  _Out_ LPWSTR lpImageFileName,
  _In_  DWORD  nSize
);

BOOL WINAPI GetFileVersionInfoA(
  _In_       LPCSTR lptstrFilename,
  _Reserved_ DWORD   dwHandle,
  _In_       DWORD   dwLen,
  _Out_      LPVOID  lpData
);

BOOL WINAPI GetFileVersionInfoW(
  _In_       LPWSTR lptstrFilename,
  _Reserved_ DWORD   dwHandle,
  _In_       DWORD   dwLen,
  _Out_      LPVOID  lpData
);

DWORD WINAPI GetFileVersionInfoSizeA(
  _In_      LPCSTR lptstrFilename,
  _Out_opt_ LPDWORD lpdwHandle
);

DWORD WINAPI GetFileVersionInfoSizeW(
  _In_      LPWSTR lptstrFilename,
  _Out_opt_ LPDWORD lpdwHandle
);

BOOL WINAPI VerQueryValueA(
  _In_  LPCVOID pBlock,
  _In_  LPCSTR lpSubBlock,
  _Out_ LPVOID  *lplpBuffer,
  _Out_ PUINT   puLen
);

BOOL WINAPI VerQueryValueW(
  _In_  LPCVOID pBlock,
  _In_  LPWSTR lpSubBlock,
  _Out_ LPVOID  *lplpBuffer,
  _Out_ PUINT   puLen
);

INT WINAPI GetSystemMetrics(
  _In_ INT nIndex
);

BOOL WINAPI GetComputerNameA(
  _Out_   LPCSTR  lpBuffer,
  _Inout_ LPDWORD lpnSize
);

BOOL WINAPI GetComputerNameW(
  _Out_   LPWSTR  lpBuffer,
  _Inout_ LPDWORD lpnSize
);

BOOL WINAPI LookupAccountSidA(
  _In_opt_  LPCSTR        lpSystemName,
  _In_      PSID          lpSid,
  _Out_opt_ LPCSTR        lpName,
  _Inout_   LPDWORD       cchName,
  _Out_opt_ LPCSTR        lpReferencedDomainName,
  _Inout_   LPDWORD       cchReferencedDomainName,
  _Out_     PSID_NAME_USE peUse
);

BOOL WINAPI LookupAccountSidW(
  _In_opt_  LPWSTR       lpSystemName,
  _In_      PSID          lpSid,
  _Out_opt_ LPWSTR        lpName,
  _Inout_   LPDWORD       cchName,
  _Out_opt_ LPWSTR        lpReferencedDomainName,
  _Inout_   LPDWORD       cchReferencedDomainName,
  _Out_     PSID_NAME_USE peUse
);


DWORD WINAPI GetInterfaceInfo(
  _Out_   PIP_INTERFACE_INFO pIfTable,
  _Inout_ PULONG             dwOutBufLen
);

DWORD WINAPI GetIfTable(
  _Out_   PMIB_IFTABLE pIfTable,
  _Inout_ PULONG       pdwSize,
  _In_    BOOL         bOrder
);

DWORD WINAPI GetIpAddrTable(
  _Out_   PMIB_IPADDRTABLE pIpAddrTable,
  _Inout_ PULONG           pdwSize,
  _In_    BOOL             bOrder
);

NTSTATUS WINAPI NtOpenDirectoryObject(
    __out PHANDLE DirectoryHandle,
    __in ACCESS_MASK DesiredAccess,
    __in POBJECT_ATTRIBUTES ObjectAttributes
);


NTSTATUS WINAPI NtQueryDirectoryObject(
    __in HANDLE DirectoryHandle,
    __out PVOID Buffer,
    __in ULONG Length,
    __in BOOLEAN ReturnSingleEntry,
    __in BOOLEAN RestartScan,
    __inout PULONG Context,
    _Out_opt_ PULONG ReturnLength
    );

NTSTATUS WINAPI NtQuerySymbolicLinkObject(
  _In_      HANDLE          LinkHandle,
  _Inout_   PUNICODE_STRING LinkTarget,
  _Out_opt_ PULONG          ReturnedLength
);

NTSTATUS WINAPI NtOpenSymbolicLinkObject(
  _Out_ PHANDLE            LinkHandle,
  _In_  ACCESS_MASK        DesiredAccess,
  _In_  POBJECT_ATTRIBUTES ObjectAttributes
);

BOOL WINAPI GetProcessTimes(
  _In_  HANDLE     hProcess,
  _Out_ LPFILETIME lpCreationTime,
  _Out_ LPFILETIME lpExitTime,
  _Out_ LPFILETIME lpKernelTime,
  _Out_ LPFILETIME lpUserTime
);

DWORD WINAPI GetShortPathNameA(
  _In_  LPCSTR lpszLongPath,
  _Out_ LPCSTR  lpszShortPath,
  _In_  DWORD   cchBuffer
);

DWORD WINAPI GetShortPathNameW(
  _In_  LPWSTR lpszLongPath,
  _Out_ LPWSTR  lpszShortPath,
  _In_  DWORD   cchBuffer
);

DWORD WINAPI GetLongPathNameA(
  _In_  LPCSTR lpszShortPath,
  _Out_ LPCSTR  lpszLongPath,
  _In_  DWORD   cchBuffer
);

DWORD WINAPI GetLongPathNameW(
  _In_  LPWSTR lpszShortPath,
  _Out_ LPWSTR  lpszLongPath,
  _In_  DWORD   cchBuffer
);


BOOL WINAPI GetProcessDEPPolicy(
  _In_  HANDLE  hProcess,
  _Out_ LPDWORD lpFlags,
  _Out_ PBOOL   lpPermanent
);


DWORD WINAPI GetNamedSecurityInfoA(
  _In_      LPCSTR               pObjectName,
  _In_      SE_OBJECT_TYPE       ObjectType,
  _In_      SECURITY_INFORMATION SecurityInfo,
  _Out_opt_ PSID                 *ppsidOwner,
  _Out_opt_ PSID                 *ppsidGroup,
  _Out_opt_ PACL                 *ppDacl,
  _Out_opt_ PACL                 *ppSacl,
  _Out_opt_ PSECURITY_DESCRIPTOR *ppSecurityDescriptor
);


DWORD WINAPI GetNamedSecurityInfoW(
  _In_      LPWSTR               pObjectName,
  _In_      SE_OBJECT_TYPE       ObjectType,
  _In_      SECURITY_INFORMATION SecurityInfo,
  _Out_opt_ PSID                 *ppsidOwner,
  _Out_opt_ PSID                 *ppsidGroup,
  _Out_opt_ PACL                 *ppDacl,
  _Out_opt_ PACL                 *ppSacl,
  _Out_opt_ PSECURITY_DESCRIPTOR *ppSecurityDescriptor
);


DWORD WINAPI GetSecurityInfo(
  _In_      HANDLE               handle,
  _In_      SE_OBJECT_TYPE       ObjectType,
  _In_      SECURITY_INFORMATION SecurityInfo,
  _Out_opt_ PSID                 *ppsidOwner,
  _Out_opt_ PSID                 *ppsidGroup,
  _Out_opt_ PACL                 *ppDacl,
  _Out_opt_ PACL                 *ppSacl,
  _Out_opt_ PSECURITY_DESCRIPTOR *ppSecurityDescriptor
);


BOOL WINAPI ConvertStringSidToSidA(
  _In_  LPCSTR StringSid,
  _Out_ PSID    *Sid
);


BOOL WINAPI ConvertStringSidToSidW(
  _In_  LPWSTR StringSid,
  _Out_ PSID    *Sid
);


BOOL WINAPI ConvertSidToStringSidA(
  _In_  PSID   Sid,
  _Out_ LPCSTR *StringSid
);

BOOL WINAPI ConvertSidToStringSidW(
  _In_  PSID   Sid,
  _Out_ LPWSTR *StringSid
);

HLOCAL WINAPI LocalFree(
  _In_ HLOCAL hMem
);

LONG WINAPI RegQueryValueExA(
  _In_        HKEY    hKey,
  _In_opt_    LPCSTR lpValueName,
  _Reserved_  LPDWORD lpReserved,
  _Out_opt_   LPDWORD lpType,
  _Out_opt_   LPBYTE  lpData,
  _Inout_opt_ LPDWORD lpcbData
);


LONG WINAPI RegQueryValueExW(
  _In_        HKEY    hKey,
  _In_opt_    LPWSTR lpValueName,
  _Reserved_  LPDWORD lpReserved,
  _Out_opt_   LPDWORD lpType,
  _Out_opt_   LPBYTE  lpData,
  _Inout_opt_ LPDWORD lpcbData
);


BOOL WINAPI InitializeProcThreadAttributeList(
  _Out_opt_  LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
  _In_       DWORD                        dwAttributeCount,
  _Reserved_ DWORD                        dwFlags,
  _Inout_    PSIZE_T                      lpSize
);


BOOL WINAPI UpdateProcThreadAttribute(
  _Inout_   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
  _In_      DWORD                        dwFlags,
  _In_      DWORD_PTR                    Attribute,
  _In_      PVOID                        lpValue,
  _In_      SIZE_T                       cbSize,
  _Out_opt_ PVOID                        lpPreviousValue,
  _In_opt_  PSIZE_T                      lpReturnSize
);

VOID WINAPI DeleteProcThreadAttributeList(
  _Inout_ LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList
);


INT WINAPI MessageBoxA(
  _In_opt_ HWND    hWnd,
  _In_opt_ LPCSTR lpText,
  _In_opt_ LPCSTR lpCaption,
  _In_     UINT    uType
);


INT WINAPI MessageBoxW(
  _In_opt_ HWND    hWnd,
  _In_opt_ LPWSTR lpText,
  _In_opt_ LPWSTR lpCaption,
  _In_     UINT    uType
);

UINT WINAPI GetWindowsDirectoryA(
  _Out_ LPCSTR lpBuffer,
  _In_  UINT   uSize
);

UINT WINAPI GetWindowsDirectoryW(
  _Out_ LPWSTR lpBuffer,
  _In_  UINT   uSize
);

VOID WINAPI RtlGetUnloadEventTraceEx(
  _Out_ PULONG *ElementSize,
  _Out_ PULONG *ElementCount,
  _Out_ PVOID  *EventTrace
);


NTSTATUS WINAPI NtQueryInformationFile(
  _In_  HANDLE                 FileHandle,
  _Out_ PIO_STATUS_BLOCK       IoStatusBlock,
  _Out_ PVOID                  FileInformation,
  _In_  ULONG                  Length,
  _In_  FILE_INFORMATION_CLASS FileInformationClass
);

NTSTATUS WINAPI NtQueryDirectoryFile(
  _In_     HANDLE                 FileHandle,
  _In_opt_ HANDLE                 Event,
  _In_opt_ PIO_APC_ROUTINE        ApcRoutine,
  _In_opt_ PVOID                  ApcContext,
  _Out_    PIO_STATUS_BLOCK       IoStatusBlock,
  _Out_    PVOID                  FileInformation,
  _In_     ULONG                  Length,
  _In_     FILE_INFORMATION_CLASS FileInformationClass,
  _In_     BOOLEAN                ReturnSingleEntry,
  _In_opt_ PUNICODE_STRING        FileName,
  _In_     BOOLEAN                RestartScan
);


BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(
    _In_ PCWSTR DosName,
    _Out_ PUNICODE_STRING NtName,
    _Out_ PCWSTR *PartName,
    _Out_ PRTL_RELATIVE_NAME_U RelativeName
);

// NOT EXPORTED !!
NTSTATUS WINAPI ApiSetResolveToHost (
    _In_ PVOID Schema,
    _In_ PUNICODE_STRING FileNameIn,
    _In_opt_ PUNICODE_STRING ParentName,
    _Out_ PBOOLEAN Resolved,
    _Out_ PUNICODE_STRING HostBinary
    );


VOID WINAPI Sleep(
  _In_ DWORD dwMilliseconds
);

DWORD WINAPI SleepEx(
  _In_ DWORD dwMilliseconds,
  _In_ BOOL  bAlertable
);

BOOL WINAPI GetProcessMitigationPolicy(
  _In_  HANDLE                    hProcess,
  _In_  PROCESS_MITIGATION_POLICY MitigationPolicy,
  _Out_ PVOID                     lpBuffer,
  _In_  SIZE_T                    dwLength
);


BOOL WINAPI SetProcessMitigationPolicy(
  _In_ PROCESS_MITIGATION_POLICY MitigationPolicy,
  _In_ PVOID                     lpBuffer,
  _In_ SIZE_T                    dwLength
);


BOOL WINAPI GetProductInfo(
  _In_  DWORD  dwOSMajorVersion,
  _In_  DWORD  dwOSMinorVersion,
  _In_  DWORD  dwSpMajorVersion,
  _In_  DWORD  dwSpMinorVersion,
  _Out_ PDWORD pdwReturnedProductType
);


NTSTATUS NtSetInformationFile(
  HANDLE                 FileHandle,
  PIO_STATUS_BLOCK       IoStatusBlock,
  PVOID                  FileInformation,
  ULONG                  Length,
  FILE_INFORMATION_CLASS FileInformationClass
);


BOOL GetProcessMemoryInfo(
  HANDLE                   Process,
  PPROCESS_MEMORY_COUNTERS ppsmemCounters,
  DWORD                    cb
);


HMODULE WINAPI GetModuleHandleA(
  _In_opt_ LPCSTR lpModuleName
);

HMODULE WINAPI GetModuleHandleW(
  _In_opt_ LPWSTR lpModuleName
);


BOOLEAN RtlEqualUnicodeString(
  PUNICODE_STRING String1,
  PUNICODE_STRING String2,
  BOOLEAN          CaseInSensitive
);


DWORD WINAPI GetFirmwareEnvironmentVariableA(
  _In_ LPCSTR lpName,
  _In_ LPCSTR lpGuid,
  _Out_ PVOID pBuffer,
  _In_ DWORD    nSize
);

DWORD WINAPI GetFirmwareEnvironmentVariableW(
  _In_ LPCWSTR lpName,
  _In_ LPCWSTR lpGuid,
  _Out_ PVOID pBuffer,
  _In_ DWORD    nSize
);

DWORD WINAPI GetFirmwareEnvironmentVariableExA(
  _In_ LPCSTR lpName,
  _In_ LPCSTR lpGuid,
  _Out_ PVOID pBuffer,
  _In_ DWORD    nSize,
  _Out_ PDWORD pdwAttribubutes
);

DWORD WINAPI GetFirmwareEnvironmentVariableExW(
  _In_ LPCWSTR lpName,
  _In_ LPCWSTR lpGuid,
  _Out_ PVOID pBuffer,
  _In_ DWORD    nSize,
  _Out_ PDWORD pdwAttribubutes
);

NTSTATUS WINAPI NtEnumerateSystemEnvironmentValuesEx(
    _In_ ULONG InformationClass,
    _In_ PVOID Buffer,
    _In_ ULONG BufferLength
);


