remove duplicate

core/sys/windows/kernel32.odin

@@ -25,36 +25,19 @@ foreign kernel32 {
 	OutputDebugStringA :: proc(lpOutputString: LPCSTR) --- // The only A thing that is allowed
 	OutputDebugStringW :: proc(lpOutputString: LPCWSTR) ---
 
-	ReadConsoleW :: proc(hConsoleInput: HANDLE,
+	ReadConsoleW :: proc(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL ---
-	                     lpBuffer: LPVOID,
-	                     nNumberOfCharsToRead: DWORD,
-	                     lpNumberOfCharsRead: LPDWORD,
-	                     pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL ---
 
-	WriteConsoleW :: proc(hConsoleOutput: HANDLE,
+	WriteConsoleW :: proc(hConsoleOutput: HANDLE, lpBuffer: LPCVOID, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID) -> BOOL ---
-	                      lpBuffer: LPCVOID,
-	                      nNumberOfCharsToWrite: DWORD,
-	                      lpNumberOfCharsWritten: LPDWORD,
-	                      lpReserved: LPVOID) -> BOOL ---
 
-	GetConsoleMode :: proc(hConsoleHandle: HANDLE,
+	GetConsoleMode :: proc(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL ---
-	                       lpMode: LPDWORD) -> BOOL ---
+	SetConsoleMode :: proc(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL ---
-	SetConsoleMode :: proc(hConsoleHandle: HANDLE,
+	SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE, dwCursorPosition: COORD) -> BOOL ---
-	                       dwMode: DWORD) -> BOOL ---
+	SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL ---
-	SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE,
-						   dwCursorPosition: COORD) -> BOOL ---
-	SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE,
-									wAttributes: WORD) -> BOOL ---
 	SetConsoleOutputCP :: proc(wCodePageID: UINT) -> BOOL ---
 
 	GetFileInformationByHandle :: proc(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) -> BOOL ---
-	SetHandleInformation :: proc(hObject: HANDLE,
+	SetHandleInformation :: proc(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL ---
-	                             dwMask: DWORD,
+	SetFileInformationByHandle :: proc(hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL ---
-	                             dwFlags: DWORD) -> BOOL ---
-	SetFileInformationByHandle :: proc(hFile:                HANDLE,
-	                                   FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
-	                                   lpFileInformation:    LPVOID,
-	                                   dwBufferSize:         DWORD) -> BOOL ---
 
 
 	AddVectoredExceptionHandler :: proc(FirstHandler: ULONG, VectoredHandler: PVECTORED_EXCEPTION_HANDLER) -> LPVOID ---
@@ -64,14 +47,9 @@ foreign kernel32 {
 	RaiseException :: proc(dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
 
 
-	CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR,
+	CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
-	                        lpTargetFileName: LPCWSTR,
-	                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
 
-	GetFileInformationByHandleEx :: proc(hFile: HANDLE,
+	GetFileInformationByHandleEx :: proc(hFile: HANDLE, fileInfoClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL ---
-	                                     fileInfoClass: FILE_INFO_BY_HANDLE_CLASS,
-	                                     lpFileInformation: LPVOID,
-	                                     dwBufferSize: DWORD) -> BOOL ---
 
 	InitializeCriticalSection :: proc(CriticalSection: ^CRITICAL_SECTION) ---
 	InitializeCriticalSectionAndSpinCount :: proc(CriticalSection: ^CRITICAL_SECTION, dwSpinCount: DWORD) -> BOOL ---
@@ -89,42 +67,12 @@ foreign kernel32 {
 	GetCurrentProcessId :: proc() -> DWORD ---
 	GetCurrentThread :: proc() -> HANDLE ---
 	GetCurrentThreadId :: proc() -> DWORD ---
-	GetProcessTimes :: proc(
+	GetProcessTimes :: proc(hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME) -> BOOL ---
-		hProcess: HANDLE,
-		lpCreationTime: LPFILETIME,
-		lpExitTime: LPFILETIME,
-		lpKernelTime: LPFILETIME,
-		lpUserTime: LPFILETIME,
-	) -> BOOL ---
 	GetStdHandle :: proc(which: DWORD) -> HANDLE ---
 	ExitProcess :: proc(uExitCode: c_uint) -> ! ---
-	DeviceIoControl :: proc(
+	DeviceIoControl :: proc(hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
-		hDevice: HANDLE,
+	CreateThread :: proc(lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE ---
-		dwIoControlCode: DWORD,
+	CreateRemoteThread :: proc(hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE ---
-		lpInBuffer: LPVOID,
-		nInBufferSize: DWORD,
-		lpOutBuffer: LPVOID,
-		nOutBufferSize: DWORD,
-		lpBytesReturned: LPDWORD,
-		lpOverlapped: LPOVERLAPPED,
-	) -> BOOL ---
-	CreateThread :: proc(
-		lpThreadAttributes: LPSECURITY_ATTRIBUTES,
-		dwStackSize: SIZE_T,
-		lpStartAddress: proc "stdcall" (rawptr) -> DWORD,
-		lpParameter: LPVOID,
-		dwCreationFlags: DWORD,
-		lpThreadId: LPDWORD,
-	) -> HANDLE ---
-	CreateRemoteThread :: proc(
-		hProcess: HANDLE,
-		lpThreadAttributes: LPSECURITY_ATTRIBUTES,
-		dwStackSize: SIZE_T,
-		lpStartAddress: proc "stdcall" (rawptr) -> DWORD,
-		lpParameter: LPVOID,
-		dwCreationFlags: DWORD,
-		lpThreadId: LPDWORD,
-	) -> HANDLE ---
 	SwitchToThread :: proc() -> BOOL ---
 	ResumeThread :: proc(thread: HANDLE) -> DWORD ---
 	GetThreadPriority :: proc(thread: HANDLE) -> c_int ---
@@ -135,46 +83,14 @@ foreign kernel32 {
 	CreateSemaphoreW :: proc(attributes: LPSECURITY_ATTRIBUTES, initial_count, maximum_count: LONG, name: LPCWSTR) -> HANDLE ---
 	ReleaseSemaphore :: proc(semaphore: HANDLE, release_count: LONG, previous_count: ^LONG) -> BOOL ---
 
-	CreateWaitableTimerW :: proc(
+	CreateWaitableTimerW :: proc(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR) -> HANDLE ---
-		lpTimerAttributes: LPSECURITY_ATTRIBUTES,
+	CreateWaitableTimerExW :: proc(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD) -> HANDLE ---
-		bManualReset: BOOL,
+	SetWaitableTimerEx :: proc(hTimer: HANDLE, lpDueTime: ^LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG) -> BOOL ---
-		lpTimerName: LPCWSTR,
-	) -> HANDLE ---
-	CreateWaitableTimerExW :: proc(
-		lpTimerAttributes: LPSECURITY_ATTRIBUTES,
-		lpTimerName: LPCWSTR,
-		dwFlags: DWORD,
-		dwDesiredAccess: DWORD,
-	) -> HANDLE ---
-	SetWaitableTimerEx :: proc(
-		hTimer: HANDLE,
-		lpDueTime: ^LARGE_INTEGER,
-		lPeriod: LONG,
-		pfnCompletionRoutine: PTIMERAPCROUTINE,
-		lpArgToCompletionRoutine: LPVOID,
-		WakeContext: PREASON_CONTEXT,
-		TolerableDelay: ULONG,
-	) -> BOOL ---
 	WaitForSingleObject :: proc(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD ---
 	Sleep :: proc(dwMilliseconds: DWORD) ---
 	GetProcessId :: proc(handle: HANDLE) -> DWORD ---
-	CopyFileExW :: proc(
+	CopyFileExW :: proc(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD) -> BOOL ---
-		lpExistingFileName: LPCWSTR,
+	FormatMessageW :: proc(flags: DWORD, lpSrc: LPVOID, msgId: DWORD, langId: DWORD, buf: LPWSTR, nsize: DWORD, args: rawptr) -> DWORD ---
-		lpNewFileName: LPCWSTR,
-		lpProgressRoutine: LPPROGRESS_ROUTINE,
-		lpData: LPVOID,
-		pbCancel: LPBOOL,
-		dwCopyFlags: DWORD,
-	) -> BOOL ---
-	FormatMessageW :: proc(
-		flags: DWORD,
-		lpSrc: LPVOID,
-		msgId: DWORD,
-		langId: DWORD,
-		buf: LPWSTR,
-		nsize: DWORD,
-		args: rawptr,
-	) -> DWORD ---
 	TlsAlloc :: proc() -> DWORD ---
 	TlsFree :: proc(dwTlsIndex: DWORD) -> BOOL ---
 	TlsGetValue :: proc(dwTlsIndex: DWORD) -> LPVOID ---
@@ -184,89 +100,26 @@ foreign kernel32 {
 	QueryPerformanceCounter :: proc(lpPerformanceCount: ^LARGE_INTEGER) -> BOOL ---
 	GetExitCodeProcess :: proc(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL ---
 	TerminateProcess :: proc(hProcess: HANDLE, uExitCode: UINT) -> BOOL ---
-	CreateProcessW :: proc(
+	CreateProcessW :: proc(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFO, lpProcessInformation: LPPROCESS_INFORMATION) -> BOOL ---
-		lpApplicationName: LPCWSTR,
-		lpCommandLine: LPWSTR,
-		lpProcessAttributes: LPSECURITY_ATTRIBUTES,
-		lpThreadAttributes: LPSECURITY_ATTRIBUTES,
-		bInheritHandles: BOOL,
-		dwCreationFlags: DWORD,
-		lpEnvironment: LPVOID,
-		lpCurrentDirectory: LPCWSTR,
-		lpStartupInfo: LPSTARTUPINFO,
-		lpProcessInformation: LPPROCESS_INFORMATION,
-	) -> BOOL ---
 	GetEnvironmentVariableW :: proc(n: LPCWSTR, v: LPWSTR, nsize: DWORD) -> DWORD ---
 	SetEnvironmentVariableW :: proc(n: LPCWSTR, v: LPCWSTR) -> BOOL ---
 	GetEnvironmentStringsW :: proc() -> LPWCH ---
 	FreeEnvironmentStringsW :: proc(env_ptr: LPWCH) -> BOOL ---
 	GetModuleFileNameW :: proc(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD) -> DWORD ---
-	CreateDirectoryW :: proc(
+	CreateDirectoryW :: proc(lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
-		lpPathName: LPCWSTR,
-		lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
-	) -> BOOL ---
 	DeleteFileW :: proc(lpPathName: LPCWSTR) -> BOOL ---
 	GetCurrentDirectoryW :: proc(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD ---
 	SetCurrentDirectoryW :: proc(lpPathName: LPCWSTR) -> BOOL ---
-	WideCharToMultiByte :: proc(
+	WideCharToMultiByte :: proc(CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: c_int, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL) -> c_int ---
-		CodePage: UINT,
+	MultiByteToWideChar :: proc(CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpWideCharStr: LPWSTR, cchWideChar: c_int) -> c_int ---
-		dwFlags: DWORD,
+	DuplicateHandle :: proc(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) -> BOOL ---
-		lpWideCharStr: LPCWSTR,
+	ReadFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
-		cchWideChar: c_int,
+	WriteFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
-		lpMultiByteStr: LPSTR,
-		cbMultiByte: c_int,
-		lpDefaultChar: LPCSTR,
-		lpUsedDefaultChar: LPBOOL,
-	) -> c_int ---
-	MultiByteToWideChar :: proc(
-		CodePage: UINT,
-		dwFlags: DWORD,
-		lpMultiByteStr: LPSTR,
-		cbMultiByte: c_int,
-		lpWideCharStr: LPWSTR,
-		cchWideChar: c_int,
-	) -> c_int ---
-	DuplicateHandle :: proc(
-		hSourceProcessHandle: HANDLE,
-		hSourceHandle: HANDLE,
-		hTargetProcessHandle: HANDLE,
-		lpTargetHandle: LPHANDLE,
-		dwDesiredAccess: DWORD,
-		bInheritHandle: BOOL,
-		dwOptions: DWORD,
-	) -> BOOL ---
-	ReadFile :: proc(
-		hFile: HANDLE,
-		lpBuffer: LPVOID,
-		nNumberOfBytesToRead: DWORD,
-		lpNumberOfBytesRead: LPDWORD,
-		lpOverlapped: LPOVERLAPPED,
-	) -> BOOL ---
-	WriteFile :: proc(
-		hFile: HANDLE,
-		lpBuffer: LPVOID,
-		nNumberOfBytesToWrite: DWORD,
-		lpNumberOfBytesWritten: LPDWORD,
-		lpOverlapped: LPOVERLAPPED,
-	) -> BOOL ---
 	CloseHandle :: proc(hObject: HANDLE) -> BOOL ---
 	MoveFileExW :: proc(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD) -> BOOL ---
-	SetFilePointerEx :: proc(
+	SetFilePointerEx :: proc(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD) -> BOOL ---
-		hFile: HANDLE,
-		liDistanceToMove: LARGE_INTEGER,
-		lpNewFilePointer: PLARGE_INTEGER,
-		dwMoveMethod: DWORD,
-	) -> BOOL ---
 	FlushFileBuffers :: proc(hFile: HANDLE) -> BOOL ---
-	CreateFileW :: proc(
+	CreateFileW :: proc(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE) -> HANDLE ---
-		lpFileName: LPCWSTR,
-		dwDesiredAccess: DWORD,
-		dwShareMode: DWORD,
-		lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
-		dwCreationDisposition: DWORD,
-		dwFlagsAndAttributes: DWORD,
-		hTemplateFile: HANDLE,
-	) -> HANDLE ---
 
 	FindFirstFileW :: proc(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW) -> HANDLE ---
 	FindNextFileW :: proc(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW) -> BOOL ---
@@ -276,45 +129,14 @@ foreign kernel32 {
 	GetSystemTimeAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) ---
 	GetSystemTimePreciseAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) ---
 	FileTimeToSystemTime :: proc(lpFileTime: ^FILETIME, lpSystemTime: ^SYSTEMTIME) -> BOOL ---
-	SystemTimeToTzSpecificLocalTime :: proc(
+	SystemTimeToTzSpecificLocalTime :: proc(lpTimeZoneInformation: ^TIME_ZONE_INFORMATION, lpUniversalTime: ^SYSTEMTIME, lpLocalTime: ^SYSTEMTIME) -> BOOL ---
-		lpTimeZoneInformation: ^TIME_ZONE_INFORMATION,
+	SystemTimeToFileTime :: proc(lpSystemTime: ^SYSTEMTIME, lpFileTime: LPFILETIME) -> BOOL ---
-		lpUniversalTime: ^SYSTEMTIME,
+	CreateEventW :: proc(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE ---
-		lpLocalTime: ^SYSTEMTIME,
-	) -> BOOL ---
-	SystemTimeToFileTime :: proc(
-		lpSystemTime: ^SYSTEMTIME,
-		lpFileTime: LPFILETIME,
-	) -> BOOL ---
-	CreateEventW :: proc(
-		lpEventAttributes: LPSECURITY_ATTRIBUTES,
-		bManualReset: BOOL,
-		bInitialState: BOOL,
-		lpName: LPCWSTR,
-	) -> HANDLE ---
 	ResetEvent :: proc(hEvent: HANDLE) -> BOOL ---
-	WaitForMultipleObjects :: proc(
+	WaitForMultipleObjects :: proc(nCount: DWORD, lpHandles: ^HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) -> DWORD ---
-		nCount: DWORD,
+	CreateNamedPipeW :: proc(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> HANDLE ---
-		lpHandles: ^HANDLE,
-		bWaitAll: BOOL,
-		dwMilliseconds: DWORD,
-	) -> DWORD ---
-	CreateNamedPipeW :: proc(
-		lpName: LPCWSTR,
-		dwOpenMode: DWORD,
-		dwPipeMode: DWORD,
-		nMaxInstances: DWORD,
-		nOutBufferSize: DWORD,
-		nInBufferSize: DWORD,
-		nDefaultTimeOut: DWORD,
-		lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
-	) -> HANDLE ---
 	CancelIo :: proc(handle: HANDLE) -> BOOL ---
-	GetOverlappedResult :: proc(
+	GetOverlappedResult :: proc(hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL) -> BOOL ---
-		hFile: HANDLE,
-		lpOverlapped: LPOVERLAPPED,
-		lpNumberOfBytesTransferred: LPDWORD,
-		bWait: BOOL,
-	) -> BOOL ---
 	GetProcessHeap :: proc() -> HANDLE ---
 	HeapAlloc :: proc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID ---
 	HeapReAlloc :: proc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID ---
@@ -325,21 +147,8 @@ foreign kernel32 {
 	LocalFree :: proc(mem: LPVOID) -> LPVOID ---
 
 
-	ReadDirectoryChangesW :: proc(
+	ReadDirectoryChangesW :: proc(hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) -> BOOL ---
-		hDirectory: HANDLE,
+	FindFirstChangeNotificationW :: proc(lpPathName: LPWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD) -> HANDLE ---
-		lpBuffer: LPVOID,
-		nBufferLength: DWORD,
-		bWatchSubtree: BOOL,
-		dwNotifyFilter: DWORD,
-		lpBytesReturned: LPDWORD,
-		lpOverlapped: LPOVERLAPPED,
-		lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
-	) -> BOOL ---
-	FindFirstChangeNotificationW :: proc(
-		lpPathName: LPWSTR,
-		bWatchSubtree: BOOL,
-		dwNotifyFilter: DWORD,
-	) -> HANDLE ---
 	FindNextChangeNotification :: proc(hChangeHandle: HANDLE) -> BOOL ---
 	FindCloseChangeNotification :: proc(hChangeHandle: HANDLE) -> BOOL ---
 
@@ -382,9 +191,9 @@ foreign kernel32 {
 
 	CreatePipe :: proc(hReadPipe, hWritePipe: ^HANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD) -> BOOL ---
 
-	ConnectNamedPipe :: proc(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED,) -> BOOL ---
+	ConnectNamedPipe :: proc(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL ---
-	DisconnectNamedPipe :: proc(hNamedPipe: HANDLE,) -> BOOL ---
+	DisconnectNamedPipe :: proc(hNamedPipe: HANDLE) -> BOOL ---
-	WaitNamedPipeW :: proc(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD,) -> BOOL ---
+	WaitNamedPipeW :: proc(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD) -> BOOL ---
 
 	SetConsoleCtrlHandler :: proc(HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL) -> BOOL ---
 	GenerateConsoleCtrlEvent :: proc(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD) -> BOOL ---
@@ -396,12 +205,7 @@ foreign kernel32 {
 	GetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL ---
 	SetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL ---
 
-	GetDiskFreeSpaceExW :: proc(
+	GetDiskFreeSpaceExW :: proc(lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER) -> BOOL ---
-		lpDirectoryName: LPCWSTR,
-		lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
-		lpTotalNumberOfBytes: PULARGE_INTEGER,
-		lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
-	) -> BOOL ---
 
 	GetLogicalProcessorInformation :: proc(buffer: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION, returnedLength: PDWORD) -> BOOL ---
 
@@ -419,8 +223,6 @@ foreign kernel32 {
 	GetTickCount64 :: proc() -> u64 ---
 	// [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation)
 	GetHandleInformation :: proc(hObject: HANDLE, lpdwFlags: ^DWORD) -> BOOL ---
-	//[MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-getqueuedcompletionstatus)
-	GetQueuedCompletionStatus :: proc(CompletionPort: HANDLE, lpNumberOfBytesTransferred: ^DWORD, lpCompletionKey: uintptr, lpOverlapped: ^^OVERLAPPED, dwMilliseconds: DWORD) -> BOOL ---
 }
 
 
@@ -429,7 +231,13 @@ SECTION_MAP_WRITE            :: DWORD(0x0002)
 SECTION_MAP_READ :: DWORD(0x0004)
 SECTION_MAP_EXECUTE :: DWORD(0x0008)
 SECTION_EXTEND_SIZE :: DWORD(0x0010)
-SECTION_ALL_ACCESS           :: STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE
+SECTION_ALL_ACCESS ::
+	STANDARD_RIGHTS_REQUIRED |
+	SECTION_QUERY |
+	SECTION_MAP_WRITE |
+	SECTION_MAP_READ |
+	SECTION_MAP_EXECUTE |
+	SECTION_EXTEND_SIZE
 SECTION_MAP_EXECUTE_EXPLICIT :: DWORD(0x0020)
 
 FILE_MAP_WRITE :: SECTION_MAP_WRITE
@@ -480,136 +288,29 @@ MEM_4MB_PAGES   :: 0x80000000
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	VirtualAlloc :: proc(
+	VirtualAlloc :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID ---
-		lpAddress: LPVOID,
+	VirtualProtect :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL ---
-		dwSize: SIZE_T,
+	VirtualFree :: proc(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL ---
-		flAllocationType: DWORD,
+	VirtualQuery :: proc(lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T ---
-		flProtect: DWORD,
+	VirtualAllocEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID ---
-	) -> LPVOID ---
+	VirtualFreeEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL ---
-	VirtualProtect :: proc(
+	VirtualProtectEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL ---
-		lpAddress: LPVOID,
+	VirtualQueryEx :: proc(hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T ---
-		dwSize: SIZE_T,
+	ReadProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: ^SIZE_T) -> BOOL ---
-		flNewProtect: DWORD,
+	WriteProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: ^SIZE_T) -> BOOL ---
-		lpflOldProtect: PDWORD,
+	CreateFileMappingW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR) -> HANDLE ---
-	) -> BOOL ---
+	OpenFileMappingW :: proc(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE ---
-	VirtualFree :: proc(
+	MapViewOfFile :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T) -> LPVOID ---
-		lpAddress: LPVOID,
+	MapViewOfFileEx :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID) -> LPVOID ---
-		dwSize: SIZE_T,
+	FlushViewOfFile :: proc(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T) -> BOOL ---
-		dwFreeType: DWORD,
+	UnmapViewOfFile :: proc(lpBaseAddress: LPCVOID) -> BOOL ---
-	) -> BOOL ---
-	VirtualQuery :: proc(
-		lpAddress: LPCVOID,
-		lpBuffer: PMEMORY_BASIC_INFORMATION,
-		dwLength: SIZE_T,
-	) -> SIZE_T ---
-	VirtualAllocEx :: proc(
-		hProcess: HANDLE,
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-		flAllocationType: DWORD,
-		flProtect: DWORD,
-	) -> LPVOID ---
-	VirtualFreeEx :: proc(
-		hProcess: HANDLE,
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-		dwFreeType: DWORD,
-	) -> BOOL ---
-	VirtualProtectEx :: proc(
-		hProcess: HANDLE,
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-		flNewProtect: DWORD,
-		lpflOldProtect: PDWORD,
-	) -> BOOL ---
-	VirtualQueryEx :: proc(
-		hProcess: HANDLE,
-		lpAddress: LPCVOID,
-		lpBuffer: PMEMORY_BASIC_INFORMATION,
-		dwLength: SIZE_T,
-	) -> SIZE_T ---
-	ReadProcessMemory :: proc(
-		hProcess: HANDLE,
-		lpBaseAddress: LPCVOID,
-		lpBuffer: LPVOID,
-		nSize: SIZE_T,
-		lpNumberOfBytesRead: ^SIZE_T,
-	) -> BOOL ---
-	WriteProcessMemory :: proc(
-		hProcess: HANDLE,
-		lpBaseAddress: LPVOID,
-		lpBuffer: LPCVOID,
-		nSize: SIZE_T,
-		lpNumberOfBytesWritten: ^SIZE_T,
-	) -> BOOL ---
-	CreateFileMappingW :: proc(
-		hFile: HANDLE,
-		lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
-		flProtect: DWORD,
-		dwMaximumSizeHigh: DWORD,
-		dwMaximumSizeLow: DWORD,
-		lpName: LPCWSTR,
-	) -> HANDLE ---
-	OpenFileMappingW :: proc(
-		dwDesiredAccess: DWORD,
-		bInheritHandle: BOOL,
-		lpName: LPCWSTR,
-	) -> HANDLE ---
-	MapViewOfFile :: proc(
-		hFileMappingObject: HANDLE,
-		dwDesiredAccess: DWORD,
-		dwFileOffsetHigh: DWORD,
-		dwFileOffsetLow: DWORD,
-		dwNumberOfBytesToMap: SIZE_T,
-	) -> LPVOID ---
-	MapViewOfFileEx :: proc(
-		hFileMappingObject: HANDLE,
-		dwDesiredAccess: DWORD,
-		dwFileOffsetHigh: DWORD,
-		dwFileOffsetLow: DWORD,
-		dwNumberOfBytesToMap: SIZE_T,
-		lpBaseAddress: LPVOID,
-	) -> LPVOID ---
-	FlushViewOfFile :: proc(
-		lpBaseAddress: LPCVOID,
-		dwNumberOfBytesToFlush: SIZE_T,
-	) -> BOOL ---
-	UnmapViewOfFile :: proc(
-		lpBaseAddress: LPCVOID,
-	) -> BOOL ---
 	GetLargePageMinimum :: proc() -> SIZE_T ---
-	GetProcessWorkingSetSizeEx :: proc(
+	GetProcessWorkingSetSizeEx :: proc(hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD) -> BOOL ---
-		hProcess: HANDLE,
+	SetProcessWorkingSetSizeEx :: proc(hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD) -> BOOL ---
-		lpMinimumWorkingSetSize: PSIZE_T,
+	VirtualLock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL ---
-		lpMaximumWorkingSetSize: PSIZE_T,
+	VirtualUnlock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL ---
-		Flags: PDWORD,
+	GetWriteWatch :: proc(dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: ^PVOID, lpdwCount: ^ULONG_PTR, lpdwGranularity: LPDWORD) -> UINT ---
-	) -> BOOL ---
+	ResetWriteWatch :: proc(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T) -> UINT ---
-	SetProcessWorkingSetSizeEx :: proc(
-		hProcess: HANDLE,
-		dwMinimumWorkingSetSize: SIZE_T,
-		dwMaximumWorkingSetSize: SIZE_T,
-		Flags: DWORD,
-	) -> BOOL ---
-	VirtualLock :: proc(
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-	) -> BOOL ---
-	VirtualUnlock :: proc(
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-	) -> BOOL ---
-	GetWriteWatch :: proc(
-		dwFlags: DWORD,
-		lpBaseAddress: PVOID,
-		dwRegionSize: SIZE_T,
-		lpAddresses: ^PVOID,
-		lpdwCount: ^ULONG_PTR,
-		lpdwGranularity: LPDWORD,
-	) -> UINT ---
-	ResetWriteWatch :: proc(
-		lpBaseAddress: LPVOID,
-		dwRegionSize: SIZE_T,
-	) -> UINT ---
 }
 
 
@@ -623,13 +324,8 @@ HighMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.HighMemoryRe
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	CreateMemoryResourceNotification :: proc(
+	CreateMemoryResourceNotification :: proc(NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE) -> HANDLE ---
-		NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE,
+	QueryMemoryResourceNotification :: proc(ResourceNotificationHandle: HANDLE, ResourceState: PBOOL) -> BOOL ---
-	) -> HANDLE ---
-	QueryMemoryResourceNotification :: proc(
-		ResourceNotificationHandle: HANDLE,
-		ResourceState: PBOOL,
-	) -> BOOL ---
 }
 
 FILE_CACHE_MAX_HARD_ENABLE :: DWORD(0x00000001)
@@ -639,25 +335,9 @@ FILE_CACHE_MIN_HARD_DISABLE :: DWORD(0x00000008)
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	GetSystemFileCacheSize :: proc(
+	GetSystemFileCacheSize :: proc(lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD) -> BOOL ---
-		lpMinimumFileCacheSize: PSIZE_T,
+	SetSystemFileCacheSize :: proc(MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD) -> BOOL ---
-		lpMaximumFileCacheSize: PSIZE_T,
+	CreateFileMappingNumaW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD) -> HANDLE ---
-		lpFlags: PDWORD,
-	) -> BOOL ---
-	SetSystemFileCacheSize :: proc(
-		MinimumFileCacheSize: SIZE_T,
-		MaximumFileCacheSize: SIZE_T,
-		Flags: DWORD,
-	) -> BOOL ---
-	CreateFileMappingNumaW :: proc(
-		hFile: HANDLE,
-		lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
-		flProtect: DWORD,
-		dwMaximumSizeHigh: DWORD,
-		dwMaximumSizeLow: DWORD,
-		lpName: LPCWSTR,
-		nndPreferred: DWORD,
-	) -> HANDLE ---
 }
 
 WIN32_MEMORY_RANGE_ENTRY :: struct {
@@ -669,86 +349,35 @@ PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	PrefetchVirtualMemory :: proc(
+	PrefetchVirtualMemory :: proc(hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, Flags: ULONG) -> BOOL ---
-		hProcess: HANDLE,
+	CreateFileMappingFromApp :: proc(hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG, MaximumSize: ULONG64, Name: PCWSTR) -> HANDLE ---
-		NumberOfEntries: ULONG_PTR,
+	MapViewOfFileFromApp :: proc(hFileMappingObject: HANDLE, DesiredAccess: ULONG, FileOffset: ULONG64, NumberOfBytesToMap: SIZE_T) -> PVOID ---
-		VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY,
+	UnmapViewOfFileEx :: proc(BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL ---
-		Flags: ULONG,
+	AllocateUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
-	) -> BOOL ---
+	FreeUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
-	CreateFileMappingFromApp :: proc(
+	MapUserPhysicalPages :: proc(VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
-		hFile: HANDLE,
+	AllocateUserPhysicalPagesNuma :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD) -> BOOL ---
-		SecurityAttributes: PSECURITY_ATTRIBUTES,
+	VirtualAllocExNuma :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD) -> LPVOID ---
-		PageProtection: ULONG,
-		MaximumSize: ULONG64,
-		Name: PCWSTR,
-	) -> HANDLE ---
-	MapViewOfFileFromApp :: proc(
-		hFileMappingObject: HANDLE,
-		DesiredAccess: ULONG,
-		FileOffset: ULONG64,
-		NumberOfBytesToMap: SIZE_T,
-	) -> PVOID ---
-	UnmapViewOfFileEx :: proc(
-		BaseAddress: PVOID,
-		UnmapFlags: ULONG,
-	) -> BOOL ---
-	AllocateUserPhysicalPages :: proc(
-		hProcess: HANDLE,
-		NumberOfPages: PULONG_PTR,
-		PageArray: PULONG_PTR,
-	) -> BOOL ---
-	FreeUserPhysicalPages :: proc(
-		hProcess: HANDLE,
-		NumberOfPages: PULONG_PTR,
-		PageArray: PULONG_PTR,
-	) -> BOOL ---
-	MapUserPhysicalPages :: proc(
-		VirtualAddress: PVOID,
-		NumberOfPages: ULONG_PTR,
-		PageArray: PULONG_PTR,
-	) -> BOOL ---
-	AllocateUserPhysicalPagesNuma :: proc(
-		hProcess: HANDLE,
-		NumberOfPages: PULONG_PTR,
-		PageArray: PULONG_PTR,
-		nndPreferred: DWORD,
-	) -> BOOL ---
-	VirtualAllocExNuma :: proc(
-		hProcess: HANDLE,
-		lpAddress: LPVOID,
-		dwSize: SIZE_T,
-		flAllocationType: DWORD,
-		flProtect: DWORD,
-		nndPreferred: DWORD,
-	) -> LPVOID ---
 }
 
 MEHC_PATROL_SCRUBBER_PRESENT :: ULONG(0x1)
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	GetMemoryErrorHandlingCapabilities :: proc(
+	GetMemoryErrorHandlingCapabilities :: proc(Capabilities: PULONG) -> BOOL ---
-		Capabilities: PULONG,
-	) -> BOOL ---
 }
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	GlobalMemoryStatusEx :: proc(
+	GlobalMemoryStatusEx :: proc(lpBuffer: ^MEMORYSTATUSEX) -> BOOL ---
-		lpBuffer: ^MEMORYSTATUSEX,
-	) -> BOOL ---
 }
 
 PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" ()
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	RegisterBadMemoryNotification :: proc(
+	RegisterBadMemoryNotification :: proc(Callback: PBAD_MEMORY_CALLBACK_ROUTINE) -> PVOID ---
-		Callback: PBAD_MEMORY_CALLBACK_ROUTINE,
+	UnregisterBadMemoryNotification :: proc(RegistrationHandle: PVOID) -> BOOL ---
-	) -> PVOID ---
-	UnregisterBadMemoryNotification :: proc(
-		RegistrationHandle: PVOID,
-	) -> BOOL ---
 }
 
 OFFER_PRIORITY :: enum c_int {
@@ -764,36 +393,12 @@ VmOfferPriorityNormal      :: OFFER_PRIORITY.VmOfferPriorityNormal
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	OfferVirtualMemory :: proc(
+	OfferVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T, Priority: OFFER_PRIORITY) -> DWORD ---
-		VirtualAddress: PVOID,
+	ReclaimVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD ---
-		Size: SIZE_T,
+	DiscardVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD ---
-		Priority: OFFER_PRIORITY,
+	VirtualAllocFromApp :: proc(BaseAddress: PVOID, Size: SIZE_T, AllocationType: ULONG, Protection: ULONG) -> PVOID ---
-	) -> DWORD ---
+	VirtualProtectFromApp :: proc(Address: PVOID, Size: SIZE_T, NewProtection: ULONG, OldProtection: PULONG) -> BOOL ---
-	ReclaimVirtualMemory :: proc(
+	OpenFileMappingFromApp :: proc(DesiredAccess: ULONG, InheritHandle: BOOL, Name: PCWSTR) -> HANDLE ---
-		VirtualAddress: PVOID,
-		Size: SIZE_T,
-	) -> DWORD ---
-	DiscardVirtualMemory :: proc(
-		VirtualAddress: PVOID,
-		Size: SIZE_T,
-	) -> DWORD ---
-	VirtualAllocFromApp :: proc(
-		BaseAddress: PVOID,
-		Size: SIZE_T,
-		AllocationType: ULONG,
-		Protection: ULONG,
-	) -> PVOID ---
-	VirtualProtectFromApp :: proc(
-		Address: PVOID,
-		Size: SIZE_T,
-		NewProtection: ULONG,
-		OldProtection: PULONG,
-	) -> BOOL ---
-	OpenFileMappingFromApp :: proc(
-		DesiredAccess: ULONG,
-		InheritHandle: BOOL,
-		Name: PCWSTR,
-	) -> HANDLE ---
 }
 
 WIN32_MEMORY_INFORMATION_CLASS :: enum c_int {
@@ -829,24 +434,8 @@ WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: distinct ULONG
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	QueryVirtualMemoryInformation :: proc(
+	QueryVirtualMemoryInformation :: proc(Process: HANDLE, VirtualAddress: PVOID, MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, MemoryInformation: PVOID, MemoryInformationSize: SIZE_T, ReturnSize: PSIZE_T) -> BOOL ---
-		Process: HANDLE,
+	MapViewOfFileNuma2 :: proc(FileMappingHandle: HANDLE, ProcessHandle: HANDLE, Offset: ULONG64, BaseAddress: PVOID, ViewSize: SIZE_T, AllocationType: ULONG, PageProtection: ULONG, PreferredNode: ULONG) -> PVOID ---
-		VirtualAddress: PVOID,
-		MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS,
-		MemoryInformation: PVOID,
-		MemoryInformationSize: SIZE_T,
-		ReturnSize: PSIZE_T,
-	) -> BOOL ---
-	MapViewOfFileNuma2 :: proc(
-		FileMappingHandle: HANDLE,
-		ProcessHandle: HANDLE,
-		Offset: ULONG64,
-		BaseAddress: PVOID,
-		ViewSize: SIZE_T,
-		AllocationType: ULONG,
-		PageProtection: ULONG,
-		PreferredNode: ULONG,
-	) -> PVOID ---
 }
 
 
@@ -875,30 +464,18 @@ MapViewOfFile2 :: #force_inline proc "stdcall" (
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	UnmapViewOfFile2 :: proc(
+	UnmapViewOfFile2 :: proc(ProcessHandle: HANDLE, BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL ---
-		ProcessHandle: HANDLE,
-		BaseAddress: PVOID,
-		UnmapFlags: ULONG,
-	) -> BOOL ---
 }
 
 @(default_calling_convention = "stdcall")
 foreign kernel32 {
-	GetProductInfo :: proc(
+	GetProductInfo :: proc(OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, product_type: ^Windows_Product_Type) -> BOOL ---
-		OSMajorVersion: DWORD,
-		OSMinorVersion: DWORD,
-		SpMajorVersion: DWORD,
-		SpMinorVersion: DWORD,
-		product_type: ^Windows_Product_Type,
-	) -> BOOL ---
 }
 
 HandlerRoutine :: proc "stdcall" (dwCtrlType: DWORD) -> BOOL
 PHANDLER_ROUTINE :: HandlerRoutine
 
 
-
-
 DCB_Config :: struct {
 	fParity:           bool,
 	fOutxCtsFlow:      bool,