repaired autoformatter

core/sys/windows/kernel32.odin

@@ -25,19 +25,36 @@ foreign kernel32 {
 	OutputDebugStringA :: proc(lpOutputString: LPCSTR) --- // The only A thing that is allowed
 	OutputDebugStringW :: proc(lpOutputString: LPCWSTR) ---
 
-	ReadConsoleW :: proc(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL ---
+	ReadConsoleW :: proc(hConsoleInput: HANDLE,
+	                     lpBuffer: LPVOID,
+	                     nNumberOfCharsToRead: DWORD,
+	                     lpNumberOfCharsRead: LPDWORD,
+	                     pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL ---
 
-	WriteConsoleW :: proc(hConsoleOutput: HANDLE, lpBuffer: LPCVOID, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID) -> BOOL ---
+	WriteConsoleW :: proc(hConsoleOutput: HANDLE,
+	                      lpBuffer: LPCVOID,
+	                      nNumberOfCharsToWrite: DWORD,
+	                      lpNumberOfCharsWritten: LPDWORD,
+	                      lpReserved: LPVOID) -> BOOL ---
 
-	GetConsoleMode :: proc(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL ---
+	GetConsoleMode :: proc(hConsoleHandle: HANDLE,
-	SetConsoleMode :: proc(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL ---
+	                       lpMode: LPDWORD) -> BOOL ---
-	SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE, dwCursorPosition: COORD) -> BOOL ---
+	SetConsoleMode :: proc(hConsoleHandle: HANDLE,
-	SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL ---
+	                       dwMode: DWORD) -> 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, dwMask: DWORD, dwFlags: DWORD) -> BOOL ---
+	SetHandleInformation :: proc(hObject: HANDLE,
-	SetFileInformationByHandle :: proc(hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL ---
+	                             dwMask: DWORD,
+	                             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 ---
@@ -47,9 +64,14 @@ foreign kernel32 {
 	RaiseException :: proc(dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
 
 
-	CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
+	CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR,
+	                        lpTargetFileName: LPCWSTR,
+	                        lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
 
-	GetFileInformationByHandleEx :: proc(hFile: HANDLE, fileInfoClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL ---
+	GetFileInformationByHandleEx :: proc(hFile: HANDLE,
+	                                     fileInfoClass: FILE_INFO_BY_HANDLE_CLASS,
+	                                     lpFileInformation: LPVOID,
+	                                     dwBufferSize: DWORD) -> BOOL ---
 
 	InitializeCriticalSection :: proc(CriticalSection: ^CRITICAL_SECTION) ---
 	InitializeCriticalSectionAndSpinCount :: proc(CriticalSection: ^CRITICAL_SECTION, dwSpinCount: DWORD) -> BOOL ---
@@ -67,12 +89,42 @@ foreign kernel32 {
 	GetCurrentProcessId :: proc() -> DWORD ---
 	GetCurrentThread :: proc() -> HANDLE ---
 	GetCurrentThreadId :: proc() -> DWORD ---
-	GetProcessTimes :: proc(hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME) -> BOOL ---
+	GetProcessTimes :: proc(
+		hProcess: HANDLE,
+		lpCreationTime: LPFILETIME,
+		lpExitTime: LPFILETIME,
+		lpKernelTime: LPFILETIME,
+		lpUserTime: LPFILETIME,
+	) -> BOOL ---
 	GetStdHandle :: proc(which: DWORD) -> HANDLE ---
 	ExitProcess :: proc(uExitCode: c_uint) -> ! ---
-	DeviceIoControl :: proc(hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
+	DeviceIoControl :: proc(
-	CreateThread :: proc(lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE ---
+		hDevice: HANDLE,
-	CreateRemoteThread :: proc(hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE ---
+		dwIoControlCode: DWORD,
+		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 ---
@@ -83,14 +135,46 @@ 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(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR) -> HANDLE ---
+	CreateWaitableTimerW :: proc(
-	CreateWaitableTimerExW :: proc(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD) -> HANDLE ---
+		lpTimerAttributes: LPSECURITY_ATTRIBUTES,
-	SetWaitableTimerEx :: proc(hTimer: HANDLE, lpDueTime: ^LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG) -> BOOL ---
+		bManualReset: 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(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD) -> BOOL ---
+	CopyFileExW :: proc(
-	FormatMessageW :: proc(flags: DWORD, lpSrc: LPVOID, msgId: DWORD, langId: DWORD, buf: LPWSTR, nsize: DWORD, args: rawptr) -> DWORD ---
+		lpExistingFileName: LPCWSTR,
+		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 ---
@@ -100,26 +184,89 @@ foreign kernel32 {
 	QueryPerformanceCounter :: proc(lpPerformanceCount: ^LARGE_INTEGER) -> BOOL ---
 	GetExitCodeProcess :: proc(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL ---
 	TerminateProcess :: proc(hProcess: HANDLE, uExitCode: UINT) -> BOOL ---
-	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 ---
+	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 ---
 	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(lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL ---
+	CreateDirectoryW :: proc(
+		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(CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: c_int, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL) -> c_int ---
+	WideCharToMultiByte :: proc(
-	MultiByteToWideChar :: proc(CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpWideCharStr: LPWSTR, cchWideChar: c_int) -> c_int ---
+		CodePage: UINT,
-	DuplicateHandle :: proc(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) -> BOOL ---
+		dwFlags: DWORD,
-	ReadFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
+		lpWideCharStr: LPCWSTR,
-	WriteFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL ---
+		cchWideChar: c_int,
+		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(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD) -> BOOL ---
+	SetFilePointerEx :: proc(
+		hFile: HANDLE,
+		liDistanceToMove: LARGE_INTEGER,
+		lpNewFilePointer: PLARGE_INTEGER,
+		dwMoveMethod: DWORD,
+	) -> BOOL ---
 	FlushFileBuffers :: proc(hFile: HANDLE) -> BOOL ---
-	CreateFileW :: proc(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE) -> HANDLE ---
+	CreateFileW :: proc(
+		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 ---
@@ -129,14 +276,45 @@ foreign kernel32 {
 	GetSystemTimeAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) ---
 	GetSystemTimePreciseAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) ---
 	FileTimeToSystemTime :: proc(lpFileTime: ^FILETIME, lpSystemTime: ^SYSTEMTIME) -> BOOL ---
-	SystemTimeToTzSpecificLocalTime :: proc(lpTimeZoneInformation: ^TIME_ZONE_INFORMATION, lpUniversalTime: ^SYSTEMTIME, lpLocalTime: ^SYSTEMTIME) -> BOOL ---
+	SystemTimeToTzSpecificLocalTime :: proc(
-	SystemTimeToFileTime :: proc(lpSystemTime: ^SYSTEMTIME, lpFileTime: LPFILETIME) -> BOOL ---
+		lpTimeZoneInformation: ^TIME_ZONE_INFORMATION,
-	CreateEventW :: proc(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE ---
+		lpUniversalTime: ^SYSTEMTIME,
+		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(nCount: DWORD, lpHandles: ^HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) -> DWORD ---
+	WaitForMultipleObjects :: proc(
-	CreateNamedPipeW :: proc(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> HANDLE ---
+		nCount: DWORD,
+		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(hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL) -> BOOL ---
+	GetOverlappedResult :: proc(
+		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 ---
@@ -147,8 +325,21 @@ foreign kernel32 {
 	LocalFree :: proc(mem: LPVOID) -> LPVOID ---
 
 
-	ReadDirectoryChangesW :: proc(hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) -> BOOL ---
+	ReadDirectoryChangesW :: proc(
-	FindFirstChangeNotificationW :: proc(lpPathName: LPWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD) -> HANDLE ---
+		hDirectory: 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 ---
 
@@ -191,9 +382,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 ---
@@ -205,7 +396,12 @@ foreign kernel32 {
 	GetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL ---
 	SetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL ---
 
-	GetDiskFreeSpaceExW :: proc(lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER) -> BOOL ---
+	GetDiskFreeSpaceExW :: proc(
+		lpDirectoryName: LPCWSTR,
+		lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
+		lpTotalNumberOfBytes: PULARGE_INTEGER,
+		lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
+	) -> BOOL ---
 
 	GetLogicalProcessorInformation :: proc(buffer: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION, returnedLength: PDWORD) -> BOOL ---
 
@@ -219,10 +415,6 @@ foreign kernel32 {
 	GetQueuedCompletionStatusEx :: proc(CompletionPort: HANDLE, lpCompletionPortEntries: ^OVERLAPPED_ENTRY, ulCount: c_ulong, ulNumEntriesRemoved: ^c_ulong, dwMilliseconds: DWORD, fAlertable: BOOL) -> BOOL ---
 	// [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-postqueuedcompletionstatus)
 	PostQueuedCompletionStatus :: proc(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: c_ulong, lpOverlapped: ^OVERLAPPED) -> BOOL ---
-	// [MS-Docs] (https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-gettickcount64)
-	GetTickCount64 :: proc() -> u64 ---
-	// [MS-Docs](https://github.com/mic101/windows/blob/master/WRK-v1.2/base/ntos/ex/keyedevent.c)
-	NtCreateKeyedEvent :: proc(KeyedEventHandle: ^HANDLE, DesiredAccess: ACCESS_MASK, ObjectAttributes: OBJECT_ATTRIBUTES, Flags: u32) -> NTSTATUS ---
 	// [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation)
 	GetHandleInformation :: proc(hObject: HANDLE, lpdwFlags: ^DWORD) -> BOOL ---
 }
@@ -233,13 +425,7 @@ SECTION_MAP_WRITE :: DWORD(0x0002)
 SECTION_MAP_READ             :: DWORD(0x0004)
 SECTION_MAP_EXECUTE          :: DWORD(0x0008)
 SECTION_EXTEND_SIZE          :: DWORD(0x0010)
-SECTION_ALL_ACCESS ::
+SECTION_ALL_ACCESS           :: STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE
-	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
@@ -290,29 +476,136 @@ MEM_4MB_PAGES :: 0x80000000
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	VirtualAlloc :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID ---
+	VirtualAlloc :: proc(
-	VirtualProtect :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL ---
+		lpAddress: LPVOID,
-	VirtualFree :: proc(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL ---
+		dwSize: SIZE_T,
-	VirtualQuery :: proc(lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T ---
+		flAllocationType: DWORD,
-	VirtualAllocEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID ---
+		flProtect: DWORD,
-	VirtualFreeEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL ---
+	) -> LPVOID ---
-	VirtualProtectEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL ---
+	VirtualProtect :: proc(
-	VirtualQueryEx :: proc(hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T ---
+		lpAddress: LPVOID,
-	ReadProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: ^SIZE_T) -> BOOL ---
+		dwSize: SIZE_T,
-	WriteProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: ^SIZE_T) -> BOOL ---
+		flNewProtect: DWORD,
-	CreateFileMappingW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR) -> HANDLE ---
+		lpflOldProtect: PDWORD,
-	OpenFileMappingW :: proc(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE ---
+	) -> BOOL ---
-	MapViewOfFile :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T) -> LPVOID ---
+	VirtualFree :: proc(
-	MapViewOfFileEx :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID) -> LPVOID ---
+		lpAddress: LPVOID,
-	FlushViewOfFile :: proc(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T) -> BOOL ---
+		dwSize: SIZE_T,
-	UnmapViewOfFile :: proc(lpBaseAddress: LPCVOID) -> BOOL ---
+		dwFreeType: DWORD,
+	) -> 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(hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD) -> BOOL ---
+	GetProcessWorkingSetSizeEx :: proc(
-	SetProcessWorkingSetSizeEx :: proc(hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD) -> BOOL ---
+		hProcess: HANDLE,
-	VirtualLock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL ---
+		lpMinimumWorkingSetSize: PSIZE_T,
-	VirtualUnlock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL ---
+		lpMaximumWorkingSetSize: PSIZE_T,
-	GetWriteWatch :: proc(dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: ^PVOID, lpdwCount: ^ULONG_PTR, lpdwGranularity: LPDWORD) -> UINT ---
+		Flags: PDWORD,
-	ResetWriteWatch :: proc(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T) -> UINT ---
+	) -> BOOL ---
+	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 ---
 }
 
 
@@ -326,8 +619,13 @@ HighMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.HighMemoryRe
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	CreateMemoryResourceNotification :: proc(NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE) -> HANDLE ---
+	CreateMemoryResourceNotification :: proc(
-	QueryMemoryResourceNotification :: proc(ResourceNotificationHandle: HANDLE, ResourceState: PBOOL) -> BOOL ---
+		NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE,
+	) -> HANDLE ---
+	QueryMemoryResourceNotification :: proc(
+		ResourceNotificationHandle: HANDLE,
+		ResourceState: PBOOL,
+	) -> BOOL ---
 }
 
 FILE_CACHE_MAX_HARD_ENABLE  :: DWORD(0x00000001)
@@ -337,9 +635,25 @@ FILE_CACHE_MIN_HARD_DISABLE :: DWORD(0x00000008)
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	GetSystemFileCacheSize :: proc(lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD) -> BOOL ---
+	GetSystemFileCacheSize :: proc(
-	SetSystemFileCacheSize :: proc(MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD) -> BOOL ---
+		lpMinimumFileCacheSize: PSIZE_T,
-	CreateFileMappingNumaW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD) -> HANDLE ---
+		lpMaximumFileCacheSize: PSIZE_T,
+		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 {
@@ -351,35 +665,86 @@ PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	PrefetchVirtualMemory :: proc(hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, Flags: ULONG) -> BOOL ---
+	PrefetchVirtualMemory :: proc(
-	CreateFileMappingFromApp :: proc(hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG, MaximumSize: ULONG64, Name: PCWSTR) -> HANDLE ---
+		hProcess: HANDLE,
-	MapViewOfFileFromApp :: proc(hFileMappingObject: HANDLE, DesiredAccess: ULONG, FileOffset: ULONG64, NumberOfBytesToMap: SIZE_T) -> PVOID ---
+		NumberOfEntries: ULONG_PTR,
-	UnmapViewOfFileEx :: proc(BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL ---
+		VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY,
-	AllocateUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
+		Flags: ULONG,
-	FreeUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
+	) -> BOOL ---
-	MapUserPhysicalPages :: proc(VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR) -> BOOL ---
+	CreateFileMappingFromApp :: proc(
-	AllocateUserPhysicalPagesNuma :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD) -> BOOL ---
+		hFile: HANDLE,
-	VirtualAllocExNuma :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD) -> LPVOID ---
+		SecurityAttributes: PSECURITY_ATTRIBUTES,
+		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(Capabilities: PULONG) -> BOOL ---
+	GetMemoryErrorHandlingCapabilities :: proc(
+		Capabilities: PULONG,
+	) -> BOOL ---
 }
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	GlobalMemoryStatusEx :: proc(lpBuffer: ^MEMORYSTATUSEX) -> BOOL ---
+	GlobalMemoryStatusEx :: proc(
+		lpBuffer: ^MEMORYSTATUSEX,
+	) -> BOOL ---
 }
 
 PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" ()
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	RegisterBadMemoryNotification :: proc(Callback: PBAD_MEMORY_CALLBACK_ROUTINE) -> PVOID ---
+	RegisterBadMemoryNotification :: proc(
-	UnregisterBadMemoryNotification :: proc(RegistrationHandle: PVOID) -> BOOL ---
+		Callback: PBAD_MEMORY_CALLBACK_ROUTINE,
+	) -> PVOID ---
+	UnregisterBadMemoryNotification :: proc(
+		RegistrationHandle: PVOID,
+	) -> BOOL ---
 }
 
 OFFER_PRIORITY :: enum c_int {
@@ -395,12 +760,36 @@ VmOfferPriorityNormal :: OFFER_PRIORITY.VmOfferPriorityNormal
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	OfferVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T, Priority: OFFER_PRIORITY) -> DWORD ---
+	OfferVirtualMemory :: proc(
-	ReclaimVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD ---
+		VirtualAddress: PVOID,
-	DiscardVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD ---
+		Size: SIZE_T,
-	VirtualAllocFromApp :: proc(BaseAddress: PVOID, Size: SIZE_T, AllocationType: ULONG, Protection: ULONG) -> PVOID ---
+		Priority: OFFER_PRIORITY,
-	VirtualProtectFromApp :: proc(Address: PVOID, Size: SIZE_T, NewProtection: ULONG, OldProtection: PULONG) -> BOOL ---
+	) -> DWORD ---
-	OpenFileMappingFromApp :: proc(DesiredAccess: ULONG, InheritHandle: BOOL, Name: PCWSTR) -> HANDLE ---
+	ReclaimVirtualMemory :: proc(
+		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 {
@@ -436,8 +825,24 @@ WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: distinct ULONG
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	QueryVirtualMemoryInformation :: proc(Process: HANDLE, VirtualAddress: PVOID, MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, MemoryInformation: PVOID, MemoryInformationSize: SIZE_T, ReturnSize: PSIZE_T) -> BOOL ---
+	QueryVirtualMemoryInformation :: proc(
-	MapViewOfFileNuma2 :: proc(FileMappingHandle: HANDLE, ProcessHandle: HANDLE, Offset: ULONG64, BaseAddress: PVOID, ViewSize: SIZE_T, AllocationType: ULONG, PageProtection: ULONG, PreferredNode: ULONG) -> PVOID ---
+		Process: HANDLE,
+		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 ---
 }
 
 
@@ -466,18 +871,30 @@ MapViewOfFile2 :: #force_inline proc "stdcall" (
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	UnmapViewOfFile2 :: proc(ProcessHandle: HANDLE, BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL ---
+	UnmapViewOfFile2 :: proc(
+		ProcessHandle: HANDLE,
+		BaseAddress: PVOID,
+		UnmapFlags: ULONG,
+	) -> BOOL ---
 }
 
 @(default_calling_convention="stdcall")
 foreign kernel32 {
-	GetProductInfo :: proc(OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, product_type: ^Windows_Product_Type) -> BOOL ---
+	GetProductInfo :: proc(
+		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,