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 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 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
);

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 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
);

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 GetThreadContext(
    __in    HANDLE hThread,
    __inout LPCONTEXT lpContext
);

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

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

BOOL 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
);

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

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

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

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
);

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

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 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
);

PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority (
    __in PSID pSid
    );

PDWORD WINAPI GetSidSubAuthority (
    __in PSID pSid,
    __in DWORD nSubAuthority
    );

PUCHAR WINAPI GetSidSubAuthorityCount (
    __in PSID pSid
    );


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
);


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
);



NTSTATUS WINAPI NtAlpcCreatePort(
    _Out_ PHANDLE PortHandle,
    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes
);


NTSTATUS WINAPI NtAlpcConnectPort(
    _Out_ PHANDLE PortHandle,
    _In_ PUNICODE_STRING PortName,
    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
    _In_ ULONG Flags,
    _In_opt_ PSID RequiredServerSid,
    _Inout_opt_ PPORT_MESSAGE ConnectionMessage,
    _Inout_opt_ PULONG BufferLength,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES OutMessageAttributes,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES InMessageAttributes,
    _In_opt_ PLARGE_INTEGER Timeout
);

NTSTATUS WINAPI NtAlpcConnectPortEx(
    _Out_ PHANDLE PortHandle,
    _In_ POBJECT_ATTRIBUTES ConnectionPortObjectAttributes,
    _In_opt_ POBJECT_ATTRIBUTES ClientPortObjectAttributes,
    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
    _In_ ULONG Flags,
    _In_opt_ PSECURITY_DESCRIPTOR ServerSecurityRequirements,
    _Inout_opt_ PPORT_MESSAGE ConnectionMessage,
    _Inout_opt_ PSIZE_T BufferLength,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES OutMessageAttributes,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES InMessageAttributes,
    _In_opt_ PLARGE_INTEGER Timeout
);


NTSTATUS WINAPI NtAlpcAcceptConnectPort(
    _Out_ PHANDLE PortHandle,
    _In_ HANDLE ConnectionPortHandle,
    _In_ ULONG Flags,
    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
    _In_opt_ PVOID PortContext,
    _In_ PPORT_MESSAGE ConnectionRequest,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES ConnectionMessageAttributes,
    _In_ BOOLEAN AcceptConnection
);

NTSTATUS WINAPI AlpcInitializeMessageAttribute(
    _In_ ULONG AttributeFlags,
    _Out_opt_ PALPC_MESSAGE_ATTRIBUTES Buffer,
    _In_ ULONG BufferSize,
    _Out_ PULONG RequiredBufferSize
);

PVOID WINAPI AlpcGetMessageAttribute(
    _In_ PALPC_MESSAGE_ATTRIBUTES Buffer,
    _In_ ULONG AttributeFlag
);

NTSTATUS WINAPI NtAlpcSendWaitReceivePort(
    _In_ HANDLE PortHandle,
    _In_ ULONG Flags,
    _In_opt_ PPORT_MESSAGE SendMessage,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES SendMessageAttributes,
    _Out_opt_ PPORT_MESSAGE ReceiveMessage,
    _Inout_opt_ PSIZE_T BufferLength,
    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES ReceiveMessageAttributes,
    _In_opt_ PLARGE_INTEGER Timeout
);


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 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 EnumWindows(
    __in WNDENUMPROC lpEnumFunc,
    __in LPARAM lParam
);


INT WINAPI GetWindowTextA(
    __in HWND hWnd,
    __out LPSTR lpString,
    __in INT nMaxCount
);

INT WINAPI GetWindowTextW(
    __in HWND hWnd,
    __out LPWSTR lpString,
    __in INT nMaxCount
);

UINT WINAPI GetWindowModuleFileNameA(
    __in HWND hwnd,
    __out LPSTR pszFileName,
    __in UINT cchFileNameMax);

UINT WINAPI GetWindowModuleFileNameW(
    __in HWND hwnd,
    __out LPWSTR pszFileName,
    __in UINT cchFileNameMax);


BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(
    __in HANDLE hFile,
    __inout DWORD *pcbHash,
    _Out_opt_ BYTE *pbHash,
    __in DWORD dwFlags);

HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(
    __in HCATADMIN hCatAdmin,
    __in BYTE *pbHash,
    __in DWORD cbHash,
    __in DWORD dwFlags,
    __inout HCATINFO *phPrevCatInfo);

BOOL WINAPI CryptCATAdminAcquireContext(
  _Out_       HCATADMIN *phCatAdmin,
  _In_        GUID      *pgSubsystem,
  _In_        DWORD     dwFlags
);

BOOL WINAPI CryptCATCatalogInfoFromContext(
  _In_    HCATINFO     hCatInfo,
  _Inout_ CATALOG_INFO *psCatInfo,
  _In_    DWORD        dwFlags
);


BOOL WINAPI CryptCATAdminReleaseCatalogContext(
  _In_ HCATADMIN hCatAdmin,
  _In_ HCATINFO  hCatInfo,
  _In_ DWORD     dwFlags
);

BOOL WINAPI CryptCATAdminReleaseContext(
  _In_ HCATADMIN hCatAdmin,
  _In_ DWORD     dwFlags
);

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
);

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
);

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
);

HRESULT WINAPI CoInitializeEx(
  _In_opt_ LPVOID pvReserved,
  _In_     DWORD  dwCoInit
);

HRESULT WINAPI CoInitializeSecurity(
  _In_opt_ PSECURITY_DESCRIPTOR        pSecDesc,
  _In_     LONG                        cAuthSvc,
  _In_opt_ SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
  _In_opt_ PVOID                        pReserved1,
  _In_     DWORD                       dwAuthnLevel,
  _In_     DWORD                       dwImpLevel,
  _In_opt_ PVOID                       pAuthList,
  _In_     DWORD                       dwCapabilities,
  _In_opt_ PVOID                       pReserved3
);

HRESULT WINAPI CoCreateInstance(
  _In_  REFCLSID  rclsid,
  _In_  LPUNKNOWN pUnkOuter,
  _In_  DWORD     dwClsContext,
  _In_  REFIID    riid,
  _Out_ LPVOID    *ppv
);

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
);
