[ros-diffs] [akhaldi] 55158: [PSDK] * Update winbase.h annotations.

Author: akhaldi
Date: Tue Jan 24 23:11:46 2012
New Revision: 55158

URL: http://svn.reactos.org/svn/reactos?rev=55158&view=rev
Log:
[PSDK]
* Update winbase.h annotations.

Modified:
    trunk/reactos/include/psdk/winbase.h

Modified: trunk/reactos/include/psdk/winbase.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/include/psdk/winbase.h?rev…
==============================================================================
--- trunk/reactos/include/psdk/winbase.h [iso-8859-1] (original)
+++ trunk/reactos/include/psdk/winbase.h [iso-8859-1] Tue Jan 24 23:11:46 2012
@@ -1152,7 +1152,15 @@
 } ACTIVATION_CONTEXT_BASIC_INFORMATION, *PACTIVATION_CONTEXT_BASIC_INFORMATION;
 typedef const struct _ACTIVATION_CONTEXT_BASIC_INFORMATION
*PCACTIVATION_CONTEXT_BASIC_INFORMATION;
 
-typedef BOOL (WINAPI *PQUERYACTCTXW_FUNC)(DWORD,HANDLE,PVOID,ULONG,PVOID,SIZE_T,SIZE_T
*);
+typedef BOOL
+(WINAPI *PQUERYACTCTXW_FUNC)(
+  _In_ DWORD dwFlags,
+  _In_ HANDLE hActCtx,
+  _In_opt_ PVOID pvSubInstance,
+  _In_ ULONG ulInfoClass,
+  _Out_writes_bytes_to_opt_(cbBuffer, *pcbWrittenOrRequired) PVOID pvBuffer,
+  _In_ SIZE_T cbBuffer,
+  _Out_opt_ SIZE_T *pcbWrittenOrRequired);
 
 typedef enum {
 	LowMemoryResourceNotification ,
@@ -1179,7 +1187,7 @@
 typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE;
 #endif
 
-typedef DWORD(WINAPI
*LPPROGRESS_ROUTINE)(LARGE_INTEGER,LARGE_INTEGER,LARGE_INTEGER,LARGE_INTEGER,DWORD,DWORD,HANDLE,HANDLE,LPVOID);
+typedef DWORD(WINAPI *LPPROGRESS_ROUTINE)(_In_ LARGE_INTEGER, _In_ LARGE_INTEGER, _In_
LARGE_INTEGER, _In_ LARGE_INTEGER, _In_ DWORD, _In_ DWORD, _In_ HANDLE, _In_ HANDLE,
_In_opt_ LPVOID);
 
 typedef VOID (WINAPI *PFIBER_START_ROUTINE)( LPVOID lpFiberParameter );
 typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE;
@@ -1208,28 +1216,69 @@
 
 /* Functions */
 #ifndef UNDER_CE
-int APIENTRY WinMain(HINSTANCE,HINSTANCE,LPSTR,int);
+int APIENTRY WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPSTR, _In_ int);
 #else
-int APIENTRY WinMain(HINSTANCE,HINSTANCE,LPWSTR,int);
-#endif
-int APIENTRY wWinMain(HINSTANCE,HINSTANCE,LPWSTR,int);
-long WINAPI _hread(HFILE,LPVOID,long);
-long WINAPI _hwrite(HFILE,LPCSTR,long);
-HFILE WINAPI _lclose(HFILE);
-HFILE WINAPI _lcreat(LPCSTR,int);
-LONG WINAPI _llseek(HFILE,LONG,int);
-HFILE WINAPI _lopen(LPCSTR,int);
-UINT WINAPI _lread(HFILE,LPVOID,UINT);
-UINT WINAPI _lwrite(HFILE,LPCSTR,UINT);
+int APIENTRY WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPWSTR, _In_ int);
+#endif
+int APIENTRY wWinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPWSTR, _In_ int);
+
+long
+WINAPI
+_hread(
+  _In_ HFILE hFile,
+  _Out_writes_bytes_to_(lBytes, return) LPVOID lpBuffer,
+  _In_ long lBytes);
+
+long
+WINAPI
+_hwrite(
+  _In_ HFILE hFile,
+  _In_reads_bytes_(lBytes) LPCCH lpBuffer,
+  _In_ long lBytes);
+
+HFILE WINAPI _lclose(_In_ HFILE);
+HFILE WINAPI _lcreat(_In_ LPCSTR, _In_ int);
+LONG WINAPI _llseek(_In_ HFILE, _In_ LONG, _In_ int);
+HFILE WINAPI _lopen(_In_ LPCSTR, _In_ int);
+
+UINT
+WINAPI
+_lread(
+  _In_ HFILE hFile,
+  _Out_writes_bytes_to_(uBytes, return) LPVOID lpBuffer,
+  _In_ UINT uBytes);
+
+UINT
+WINAPI
+_lwrite(
+  _In_ HFILE hFile,
+  _In_reads_bytes_(uBytes) LPCCH lpBuffer,
+  _In_ UINT uBytes);
+
 BOOL WINAPI
AccessCheck(PSECURITY_DESCRIPTOR,HANDLE,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,PDWORD,PDWORD,PBOOL);
-BOOL WINAPI
AccessCheckAndAuditAlarmA(LPCSTR,LPVOID,LPSTR,LPSTR,PSECURITY_DESCRIPTOR,DWORD,PGENERIC_MAPPING,BOOL,PDWORD,PBOOL,PBOOL);
+
+BOOL
+WINAPI
+AccessCheckAndAuditAlarmA(
+  _In_ LPCSTR SubsystemName,
+  _In_opt_ LPVOID HandleId,
+  _In_ LPSTR ObjectTypeName,
+  _In_opt_ LPSTR ObjectName,
+  _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
+  _In_ DWORD DesiredAccess,
+  _In_ PGENERIC_MAPPING GenericMapping,
+  _In_ BOOL ObjectCreation,
+  _Out_ LPDWORD GrantedAccess,
+  _Out_ LPBOOL AccessStatus,
+  _Out_ LPBOOL pfGenerateOnClose);
+
 BOOL WINAPI
AccessCheckAndAuditAlarmW(LPCWSTR,LPVOID,LPWSTR,LPWSTR,PSECURITY_DESCRIPTOR,DWORD,PGENERIC_MAPPING,BOOL,PDWORD,PBOOL,PBOOL);
 #if (_WIN32_WINNT >= 0x0600)
 VOID WINAPI AcquireSRWLockExclusive(PSRWLOCK);
 VOID WINAPI AcquireSRWLockShared(PSRWLOCK);
 #endif
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI ActivateActCtx(HANDLE,ULONG_PTR*);
+BOOL WINAPI ActivateActCtx(_Inout_opt_ HANDLE, _Out_ ULONG_PTR*);
 #endif
 BOOL WINAPI AddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
 BOOL WINAPI AddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
@@ -1240,17 +1289,17 @@
 BOOL WINAPI AddAccessDeniedObjectAce(PACL,DWORD,DWORD,DWORD,GUID*,GUID*,PSID);
 #endif
 BOOL WINAPI AddAce(PACL,DWORD,DWORD,PVOID,DWORD);
-ATOM WINAPI AddAtomA(LPCSTR);
-ATOM WINAPI AddAtomW(LPCWSTR);
+ATOM WINAPI AddAtomA(_In_opt_ LPCSTR);
+ATOM WINAPI AddAtomW(_In_opt_ LPCWSTR);
 BOOL WINAPI AddAuditAccessAce(PACL,DWORD,DWORD,PSID,BOOL,BOOL);
 #if (_WIN32_WINNT >= 0x0500)
 BOOL WINAPI AddAuditAccessObjectAce(PACL,DWORD,DWORD,DWORD,GUID*,GUID*,PSID,BOOL,BOOL);
 #endif
 #if (_WIN32_WINNT >= 0x0501)
-void WINAPI AddRefActCtx(HANDLE);
-#endif
-#if (_WIN32_WINNT >= 0x0500)
-PVOID WINAPI AddVectoredExceptionHandler(ULONG,PVECTORED_EXCEPTION_HANDLER);
+void WINAPI AddRefActCtx(_Inout_ HANDLE);
+#endif
+#if (_WIN32_WINNT >= 0x0500)
+_Ret_maybenull_ PVOID WINAPI AddVectoredExceptionHandler(_In_ ULONG, _In_
PVECTORED_EXCEPTION_HANDLER);
 #endif
 BOOL WINAPI
AccessCheckByType(PSECURITY_DESCRIPTOR,PSID,HANDLE,DWORD,POBJECT_TYPE_LIST,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,LPDWORD,LPDWORD,LPBOOL);
 BOOL WINAPI AdjustTokenGroups(HANDLE,BOOL,PTOKEN_GROUPS,DWORD,PTOKEN_GROUPS,PDWORD);
@@ -1261,54 +1310,116 @@
 BOOL WINAPI AreAllAccessesGranted(DWORD,DWORD);
 BOOL WINAPI AreAnyAccessesGranted(DWORD,DWORD);
 BOOL WINAPI AreFileApisANSI(void);
-BOOL WINAPI BackupEventLogA(HANDLE,LPCSTR);
-BOOL WINAPI BackupEventLogW(HANDLE,LPCWSTR);
-BOOL WINAPI BackupRead(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
-BOOL WINAPI BackupSeek(HANDLE,DWORD,DWORD,LPDWORD,LPDWORD,LPVOID*);
-BOOL WINAPI BackupWrite(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
+BOOL WINAPI BackupEventLogA(_In_ HANDLE, _In_ LPCSTR);
+BOOL WINAPI BackupEventLogW(_In_ HANDLE, _In_ LPCWSTR);
+
+BOOL
+WINAPI
+BackupRead(
+  _In_ HANDLE hFile,
+  _Out_writes_bytes_to_(nNumberOfBytesToRead, *lpNumberOfBytesRead) LPBYTE lpBuffer,
+  _In_ DWORD nNumberOfBytesToRead,
+  _Out_ LPDWORD lpNumberOfBytesRead,
+  _In_ BOOL bAbort,
+  _In_ BOOL bProcessSecurity,
+  _Inout_ LPVOID *lpContext);
+
+BOOL WINAPI BackupSeek(_In_ HANDLE, _In_ DWORD, _In_ DWORD, _Out_ LPDWORD, _Out_ LPDWORD,
_Inout_ LPVOID*);
+
+BOOL
+WINAPI
+BackupWrite(
+  _In_ HANDLE hFile,
+  _In_reads_bytes_(nNumberOfBytesToWrite) LPBYTE lpBuffer,
+  _In_ DWORD nNumberOfBytesToWrite,
+  _Out_ LPDWORD lpNumberOfBytesWritten,
+  _In_ BOOL bAbort,
+  _In_ BOOL bProcessSecurity,
+  _Inout_ LPVOID *lpContext);
+
 BOOL WINAPI Beep(DWORD,DWORD);
-HANDLE WINAPI BeginUpdateResourceA(LPCSTR,BOOL);
-HANDLE WINAPI BeginUpdateResourceW(LPCWSTR,BOOL);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI BindIoCompletionCallback(HANDLE,LPOVERLAPPED_COMPLETION_ROUTINE,ULONG);
-#endif
-BOOL WINAPI BuildCommDCBA(LPCSTR,LPDCB);
-BOOL WINAPI BuildCommDCBW(LPCWSTR,LPDCB);
-BOOL WINAPI BuildCommDCBAndTimeoutsA(LPCSTR,LPDCB,LPCOMMTIMEOUTS);
-BOOL WINAPI BuildCommDCBAndTimeoutsW(LPCWSTR,LPDCB,LPCOMMTIMEOUTS);
-BOOL WINAPI CallNamedPipeA(LPCSTR,PVOID,DWORD,PVOID,DWORD,PDWORD,DWORD);
-BOOL WINAPI CallNamedPipeW(LPCWSTR,PVOID,DWORD,PVOID,DWORD,PDWORD,DWORD);
-BOOL WINAPI CancelDeviceWakeupRequest(HANDLE);
+HANDLE WINAPI BeginUpdateResourceA(_In_ LPCSTR, _In_ BOOL);
+HANDLE WINAPI BeginUpdateResourceW(_In_ LPCWSTR, _In_ BOOL);
+#if (_WIN32_WINNT >= 0x0500)
+BOOL WINAPI BindIoCompletionCallback(_In_ HANDLE, _In_ LPOVERLAPPED_COMPLETION_ROUTINE,
_In_ ULONG);
+#endif
+BOOL WINAPI BuildCommDCBA(_In_ LPCSTR, _Out_ LPDCB);
+BOOL WINAPI BuildCommDCBW(_In_ LPCWSTR, _Out_ LPDCB);
+BOOL WINAPI BuildCommDCBAndTimeoutsA(_In_ LPCSTR, _Out_ LPDCB, _Out_ LPCOMMTIMEOUTS);
+BOOL WINAPI BuildCommDCBAndTimeoutsW(_In_ LPCWSTR, _Out_ LPDCB, _Out_ LPCOMMTIMEOUTS);
+
+BOOL
+WINAPI
+CallNamedPipeA(
+  _In_ LPCSTR lpNamedPipeName,
+  _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
+  _In_ DWORD nInBufferSize,
+  _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesRead) LPVOID lpOutBuffer,
+  _In_ DWORD nOutBufferSize,
+  _Out_ LPDWORD lpBytesRead,
+  _In_ DWORD nTimeOut);
+
+BOOL
+WINAPI
+CallNamedPipeW(
+  _In_ LPCWSTR lpNamedPipeName,
+  _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
+  _In_ DWORD nInBufferSize,
+  _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesRead) LPVOID lpOutBuffer,
+  _In_ DWORD nOutBufferSize,
+  _Out_ LPDWORD lpBytesRead,
+  _In_ DWORD nTimeOut);
+
+BOOL WINAPI CancelDeviceWakeupRequest(_In_ HANDLE);
 BOOL WINAPI CancelIo(HANDLE);
 #if (_WIN32_WINNT >= 0x0600)
 BOOL WINAPI CancelIoEx(HANDLE,LPOVERLAPPED);
 BOOL WINAPI CancelSynchronousIo(HANDLE);
 #endif
 BOOL WINAPI CancelWaitableTimer(HANDLE);
-#if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI CheckNameLegalDOS8Dot3A(LPCSTR,LPSTR,DWORD,PBOOL,PBOOL);
-BOOL WINAPI CheckNameLegalDOS8Dot3W(LPCWSTR,LPSTR,DWORD,PBOOL,PBOOL);
-BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE,PBOOL);
-#endif
-BOOL WINAPI ClearCommBreak(HANDLE);
-BOOL WINAPI ClearCommError(HANDLE,PDWORD,LPCOMSTAT);
-BOOL WINAPI ClearEventLogA(HANDLE,LPCSTR);
-BOOL WINAPI ClearEventLogW(HANDLE,LPCWSTR);
-BOOL WINAPI CloseEventLog(HANDLE);
+
+#if (_WIN32_WINNT >= 0x0501)
+
+BOOL
+WINAPI
+CheckNameLegalDOS8Dot3A(
+  _In_ LPCSTR lpName,
+  _Out_writes_opt_(OemNameSize) LPSTR lpOemName,
+  _In_ DWORD OemNameSize,
+  _Out_opt_ PBOOL pbNameContainsSpaces,
+  _Out_ PBOOL pbNameLegal);
+
+BOOL
+WINAPI
+CheckNameLegalDOS8Dot3W(
+  _In_ LPCWSTR lpName,
+  _Out_writes_opt_(OemNameSize) LPSTR lpOemName,
+  _In_ DWORD OemNameSize,
+  _Out_opt_ PBOOL pbNameContainsSpaces,
+  _Out_ PBOOL pbNameLegal);
+
+BOOL WINAPI CheckRemoteDebuggerPresent(_In_ HANDLE, _Out_ PBOOL);
+#endif
+
+BOOL WINAPI ClearCommBreak(_In_ HANDLE);
+BOOL WINAPI ClearCommError(_In_ HANDLE, _Out_opt_ PDWORD, _Out_opt_ LPCOMSTAT);
+BOOL WINAPI ClearEventLogA(_In_ HANDLE, _In_opt_ LPCSTR);
+BOOL WINAPI ClearEventLogW(_In_ HANDLE, _In_opt_ LPCWSTR);
+BOOL WINAPI CloseEventLog(_In_ HANDLE);
 BOOL WINAPI CloseHandle(HANDLE);
-BOOL WINAPI CommConfigDialogA(LPCSTR,HWND,LPCOMMCONFIG);
-BOOL WINAPI CommConfigDialogW(LPCWSTR,HWND,LPCOMMCONFIG);
+BOOL WINAPI CommConfigDialogA(_In_ LPCSTR, _In_opt_ HWND, _Inout_ LPCOMMCONFIG);
+BOOL WINAPI CommConfigDialogW(_In_ LPCWSTR, _In_opt_ HWND, _Inout_ LPCOMMCONFIG);
 LONG WINAPI CompareFileTime(CONST FILETIME*,CONST FILETIME*);
 BOOL WINAPI ConnectNamedPipe(HANDLE,LPOVERLAPPED);
 BOOL WINAPI ContinueDebugEvent(DWORD,DWORD,DWORD);
 #if (_WIN32_WINNT >= 0x0400)
 BOOL WINAPI ConvertFiberToThread(void);
 #endif
-PVOID WINAPI ConvertThreadToFiber(PVOID);
-BOOL WINAPI CopyFileA(LPCSTR,LPCSTR,BOOL);
-BOOL WINAPI CopyFileW(LPCWSTR,LPCWSTR,BOOL);
-BOOL WINAPI CopyFileExA(LPCSTR,LPCSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD);
-BOOL WINAPI CopyFileExW(LPCWSTR,LPCWSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD);
+_Ret_maybenull_ PVOID WINAPI ConvertThreadToFiber(_In_opt_ PVOID);
+BOOL WINAPI CopyFileA(_In_ LPCSTR, _In_ LPCSTR, _In_ BOOL);
+BOOL WINAPI CopyFileW(_In_ LPCWSTR, _In_ LPCWSTR, _In_ BOOL);
+BOOL WINAPI CopyFileExA(_In_ LPCSTR, _In_ LPCSTR, _In_opt_ LPPROGRESS_ROUTINE, _In_opt_
LPVOID, _In_opt_ LPBOOL, _In_ DWORD);
+BOOL WINAPI CopyFileExW(_In_ LPCWSTR, _In_ LPCWSTR, _In_opt_ LPPROGRESS_ROUTINE, _In_opt_
LPVOID, _In_opt_ LPBOOL, _In_ DWORD);
 #define MoveMemory RtlMoveMemory
 #define CopyMemory RtlCopyMemory
 #define FillMemory RtlFillMemory
@@ -1316,40 +1427,40 @@
 #define SecureZeroMemory RtlSecureZeroMemory
 BOOL WINAPI CopySid(DWORD,PSID,PSID);
 #if (_WIN32_WINNT >= 0x0501)
-HANDLE WINAPI CreateActCtxA(PCACTCTXA);
-HANDLE WINAPI CreateActCtxW(PCACTCTXW);
+HANDLE WINAPI CreateActCtxA(_In_ PCACTCTXA);
+HANDLE WINAPI CreateActCtxW(_In_ PCACTCTXW);
 #endif
 BOOL WINAPI CreateDirectoryA(LPCSTR,LPSECURITY_ATTRIBUTES);
 BOOL WINAPI CreateDirectoryW(LPCWSTR,LPSECURITY_ATTRIBUTES);
-BOOL WINAPI CreateDirectoryExA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
-BOOL WINAPI CreateDirectoryExW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
+BOOL WINAPI CreateDirectoryExA(_In_ LPCSTR, _In_ LPCSTR, _In_opt_
LPSECURITY_ATTRIBUTES);
+BOOL WINAPI CreateDirectoryExW(_In_ LPCWSTR, _In_ LPCWSTR, _In_opt_
LPSECURITY_ATTRIBUTES);
 HANDLE WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
 HANDLE WINAPI CreateEventW(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCWSTR);
 #if (_WIN32_WINNT >= 0x0600)
 HANDLE WINAPI CreateEventExA(LPSECURITY_ATTRIBUTES,LPCSTR,DWORD,DWORD);
 HANDLE WINAPI CreateEventExW(LPSECURITY_ATTRIBUTES,LPCWSTR,DWORD,DWORD);
 #endif
-LPVOID WINAPI CreateFiber(SIZE_T,LPFIBER_START_ROUTINE,LPVOID);
+_Ret_maybenull_ LPVOID WINAPI CreateFiber(_In_ SIZE_T, _In_ LPFIBER_START_ROUTINE,
_In_opt_ LPVOID);
 #if (_WIN32_WINNT >= 0x0400)
-LPVOID WINAPI CreateFiberEx(SIZE_T,SIZE_T,DWORD,LPFIBER_START_ROUTINE,LPVOID);
+_Ret_maybenull_ LPVOID WINAPI CreateFiberEx(_In_ SIZE_T, _In_ SIZE_T, _In_ DWORD, _In_
LPFIBER_START_ROUTINE, _In_opt_ LPVOID);
 #endif
 HANDLE WINAPI CreateFileA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
 HANDLE WINAPI CreateFileW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
-HANDLE WINAPI CreateFileMappingA(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateFileMappingA(_In_ HANDLE, _In_opt_
LPSECURITY_ATTRIBUTES, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_opt_ LPCSTR);
 HANDLE WINAPI
CreateFileMappingW(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCWSTR);
 #if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI CreateHardLinkA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
-BOOL WINAPI CreateHardLinkW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
+BOOL WINAPI CreateHardLinkA(_In_ LPCSTR, _In_ LPCSTR, _Reserved_ LPSECURITY_ATTRIBUTES);
+BOOL WINAPI CreateHardLinkW(_In_ LPCWSTR, _In_ LPCWSTR, _Reserved_
LPSECURITY_ATTRIBUTES);
 #endif
 HANDLE WINAPI CreateIoCompletionPort(HANDLE,HANDLE,ULONG_PTR,DWORD);
 #if (_WIN32_WINNT >= 0x0500)
-HANDLE WINAPI CreateJobObjectA(LPSECURITY_ATTRIBUTES,LPCSTR);
-HANDLE WINAPI CreateJobObjectW(LPSECURITY_ATTRIBUTES,LPCWSTR);
-BOOL WINAPI TerminateJobObject(HANDLE,UINT);
-BOOL WINAPI AssignProcessToJobObject(HANDLE,HANDLE);
-#endif
-HANDLE WINAPI CreateMailslotA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
-HANDLE WINAPI CreateMailslotW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
+_Ret_maybenull_ HANDLE WINAPI CreateJobObjectA(_In_opt_ LPSECURITY_ATTRIBUTES, _In_opt_
LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateJobObjectW(_In_opt_ LPSECURITY_ATTRIBUTES, _In_opt_
LPCWSTR);
+BOOL WINAPI TerminateJobObject(_In_ HANDLE, _In_ UINT);
+BOOL WINAPI AssignProcessToJobObject(_In_ HANDLE, _In_ HANDLE);
+#endif
+HANDLE WINAPI CreateMailslotA(_In_ LPCSTR, _In_ DWORD, _In_ DWORD, _In_opt_
LPSECURITY_ATTRIBUTES);
+HANDLE WINAPI CreateMailslotW(_In_ LPCWSTR, _In_ DWORD, _In_ DWORD, _In_opt_
LPSECURITY_ATTRIBUTES);
 #if (_WIN32_WINNT >= 0x0501)
 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE);
 #endif
@@ -1359,36 +1470,51 @@
 HANDLE WINAPI CreateMutexExA(LPSECURITY_ATTRIBUTES,LPCSTR,DWORD,DWORD);
 HANDLE WINAPI CreateMutexExW(LPSECURITY_ATTRIBUTES,LPCWSTR,DWORD,DWORD);
 #endif
-HANDLE WINAPI
CreateNamedPipeA(LPCSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
-HANDLE WINAPI
CreateNamedPipeW(LPCWSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
+HANDLE WINAPI CreateNamedPipeA(_In_ LPCSTR, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_
DWORD, _In_ DWORD, _In_ DWORD, _In_opt_ LPSECURITY_ATTRIBUTES);
+HANDLE WINAPI CreateNamedPipeW(_In_ LPCWSTR, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_
DWORD, _In_ DWORD, _In_ DWORD, _In_opt_ LPSECURITY_ATTRIBUTES);
 BOOL WINAPI CreatePipe(PHANDLE,PHANDLE,LPSECURITY_ATTRIBUTES,DWORD);
 BOOL WINAPI
CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR*,BOOL,HANDLE,PGENERIC_MAPPING);
 BOOL WINAPI
CreateProcessA(LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCSTR,LPSTARTUPINFOA,LPPROCESS_INFORMATION);
 BOOL WINAPI
CreateProcessW(LPCWSTR,LPWSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCWSTR,LPSTARTUPINFOW,LPPROCESS_INFORMATION);
-BOOL WINAPI
CreateProcessAsUserA(HANDLE,LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCSTR,LPSTARTUPINFOA,LPPROCESS_INFORMATION);
+
+BOOL
+WINAPI
+CreateProcessAsUserA(
+  _In_opt_ HANDLE,
+  _In_opt_ LPCSTR,
+  _Inout_opt_ LPSTR,
+  _In_opt_ LPSECURITY_ATTRIBUTES,
+  _In_opt_ LPSECURITY_ATTRIBUTES,
+  _In_ BOOL,
+  _In_ DWORD,
+  _In_opt_ PVOID,
+  _In_opt_ LPCSTR,
+  _In_ LPSTARTUPINFOA,
+  _Out_ LPPROCESS_INFORMATION);
+
 BOOL WINAPI
CreateProcessAsUserW(HANDLE,LPCWSTR,LPWSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCWSTR,LPSTARTUPINFOW,LPPROCESS_INFORMATION);
 HANDLE WINAPI
CreateRemoteThread(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
-HANDLE WINAPI CreateSemaphoreA(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCSTR);
-HANDLE WINAPI CreateSemaphoreW(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCWSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateSemaphoreA(_In_opt_ LPSECURITY_ATTRIBUTES, _In_ LONG,
_In_ LONG, _In_opt_ LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateSemaphoreW(_In_opt_ LPSECURITY_ATTRIBUTES, _In_ LONG,
_In_ LONG, _In_opt_ LPCWSTR);
 #if (_WIN32_WINNT >= 0x0600)
-HANDLE WINAPI CreateSemaphoreExA(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCSTR,DWORD,DWORD);
+_Ret_maybenull_ HANDLE WINAPI CreateSemaphoreExA(_In_opt_ LPSECURITY_ATTRIBUTES, _In_
LONG, _In_ LONG, _In_opt_ LPCSTR, _Reserved_ DWORD, _In_ DWORD);
 HANDLE WINAPI CreateSemaphoreExW(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCWSTR,DWORD,DWORD);
 #endif
-DWORD WINAPI CreateTapePartition(HANDLE,DWORD,DWORD,DWORD);
+DWORD WINAPI CreateTapePartition(_In_ HANDLE, _In_ DWORD, _In_ DWORD, _In_ DWORD);
 #if (_WIN32_WINNT >= 0x0500)
 HANDLE WINAPI CreateTimerQueue(void);
 BOOL WINAPI
CreateTimerQueueTimer(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,DWORD,DWORD,ULONG);
 #endif
 HANDLE WINAPI
CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,PVOID,DWORD,PDWORD);
-HANDLE WINAPI CreateWaitableTimerA(LPSECURITY_ATTRIBUTES,BOOL,LPCSTR);
-HANDLE WINAPI CreateWaitableTimerW(LPSECURITY_ATTRIBUTES,BOOL,LPCWSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateWaitableTimerA(_In_opt_ LPSECURITY_ATTRIBUTES, _In_
BOOL, _In_opt_ LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI CreateWaitableTimerW(_In_opt_ LPSECURITY_ATTRIBUTES, _In_
BOOL, _In_opt_ LPCWSTR);
 #if (_WIN32_WINNT >= 0x0600)
-HANDLE WINAPI CreateWaitableTimerExA(LPSECURITY_ATTRIBUTES,LPCSTR,DWORD,DWORD);
+_Ret_maybenull_ HANDLE WINAPI CreateWaitableTimerExA(_In_opt_ LPSECURITY_ATTRIBUTES,
_In_opt_ LPCSTR, _In_ DWORD, _In_ DWORD);
 HANDLE WINAPI CreateWaitableTimerExW(LPSECURITY_ATTRIBUTES,LPCWSTR,DWORD,DWORD);
 #endif
 #if (_WIN32_WINNT >= 0x0501)
 BOOL WINAPI CreateWellKnownSid(WELL_KNOWN_SID_TYPE,PSID,PSID,DWORD*);
-BOOL WINAPI DeactivateActCtx(DWORD,ULONG_PTR);
+BOOL WINAPI DeactivateActCtx(_In_ DWORD, _In_ ULONG_PTR);
 #endif
 BOOL WINAPI DebugActiveProcess(DWORD);
 #if (_WIN32_WINNT >= 0x0501)
@@ -1396,78 +1522,95 @@
 #endif
 void WINAPI DebugBreak(void);
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI DebugBreakProcess(HANDLE);
-BOOL WINAPI DebugSetProcessKillOnExit(BOOL);
+BOOL WINAPI DebugBreakProcess(_In_ HANDLE);
+BOOL WINAPI DebugSetProcessKillOnExit(_In_ BOOL);
 #endif
 PVOID WINAPI DecodePointer(PVOID);
 PVOID WINAPI DecodeSystemPointer(PVOID);
-BOOL WINAPI DecryptFileA(LPCSTR,DWORD);
-BOOL WINAPI DecryptFileW(LPCWSTR,DWORD);
-BOOL WINAPI DefineDosDeviceA(DWORD,LPCSTR,LPCSTR);
+BOOL WINAPI DecryptFileA(_In_ LPCSTR, _Reserved_ DWORD);
+BOOL WINAPI DecryptFileW(_In_ LPCWSTR, _Reserved_ DWORD);
+BOOL WINAPI DefineDosDeviceA(_In_ DWORD, _In_ LPCSTR, _In_opt_ LPCSTR);
 BOOL WINAPI DefineDosDeviceW(DWORD,LPCWSTR,LPCWSTR);
 #define DefineHandleTable(w) ((w),TRUE)
 BOOL WINAPI DeleteAce(PACL,DWORD);
-ATOM WINAPI DeleteAtom(ATOM);
+ATOM WINAPI DeleteAtom(_In_ ATOM);
 void WINAPI DeleteCriticalSection(PCRITICAL_SECTION);
-void WINAPI DeleteFiber(PVOID);
+void WINAPI DeleteFiber(_In_ PVOID);
 BOOL WINAPI DeleteFileA(LPCSTR);
 BOOL WINAPI DeleteFileW(LPCWSTR);
 #if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI DeleteTimerQueue(HANDLE);
+_Must_inspect_result_ BOOL WINAPI DeleteTimerQueue(_In_ HANDLE);
 BOOL WINAPI DeleteTimerQueueEx(HANDLE,HANDLE);
 BOOL WINAPI DeleteTimerQueueTimer(HANDLE,HANDLE,HANDLE);
-BOOL WINAPI DeleteVolumeMountPointA(LPCSTR);
+BOOL WINAPI DeleteVolumeMountPointA(_In_ LPCSTR);
 BOOL WINAPI DeleteVolumeMountPointW(LPCWSTR);
 #endif
-BOOL WINAPI DeregisterEventSource(HANDLE);
+BOOL WINAPI DeregisterEventSource(_In_ HANDLE);
 BOOL WINAPI DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
 BOOL WINAPI DeviceIoControl(HANDLE,DWORD,PVOID,DWORD,PVOID,DWORD,PDWORD,POVERLAPPED);
 BOOL WINAPI DisableThreadLibraryCalls(HMODULE);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR,LPSTR,LPDWORD);
-BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR,LPWSTR,LPDWORD);
-#endif
+
+#if (_WIN32_WINNT >= 0x0500)
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+DnsHostnameToComputerNameA(
+  _In_ LPCSTR Hostname,
+  _Out_writes_to_opt_(*nSize, *nSize + 1) LPSTR ComputerName,
+  _Inout_ LPDWORD nSize);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+DnsHostnameToComputerNameW(
+  _In_ LPCWSTR Hostname,
+  _Out_writes_to_opt_(*nSize, *nSize + 1) LPWSTR ComputerName,
+  _Inout_ LPDWORD nSize);
+
+#endif
+
 BOOL WINAPI DisconnectNamedPipe(HANDLE);
-BOOL WINAPI DosDateTimeToFileTime(WORD,WORD,LPFILETIME);
+BOOL WINAPI DosDateTimeToFileTime(_In_ WORD, _In_ WORD, _Out_ LPFILETIME);
 BOOL WINAPI DuplicateHandle(HANDLE,HANDLE,HANDLE,PHANDLE,DWORD,BOOL,DWORD);
 BOOL WINAPI DuplicateToken(HANDLE,SECURITY_IMPERSONATION_LEVEL,PHANDLE);
 BOOL WINAPI
DuplicateTokenEx(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
 PVOID WINAPI EncodePointer(PVOID);
 PVOID WINAPI EncodeSystemPointer(PVOID);
-BOOL WINAPI EncryptFileA(LPCSTR);
-BOOL WINAPI EncryptFileW(LPCWSTR);
-BOOL WINAPI EndUpdateResourceA(HANDLE,BOOL);
-BOOL WINAPI EndUpdateResourceW(HANDLE,BOOL);
+BOOL WINAPI EncryptFileA(_In_ LPCSTR);
+BOOL WINAPI EncryptFileW(_In_ LPCWSTR);
+BOOL WINAPI EndUpdateResourceA(_In_ HANDLE, _In_ BOOL);
+BOOL WINAPI EndUpdateResourceW(_In_ HANDLE, _In_ BOOL);
 void WINAPI EnterCriticalSection(LPCRITICAL_SECTION);
-BOOL WINAPI EnumResourceLanguagesA(HMODULE,LPCSTR,LPCSTR,ENUMRESLANGPROCA,LONG_PTR);
-BOOL WINAPI EnumResourceLanguagesW(HMODULE,LPCWSTR,LPCWSTR,ENUMRESLANGPROCW,LONG_PTR);
-BOOL WINAPI EnumResourceNamesA(HMODULE,LPCSTR,ENUMRESNAMEPROCA,LONG_PTR);
-BOOL WINAPI EnumResourceNamesW(HMODULE,LPCWSTR,ENUMRESNAMEPROCW,LONG_PTR);
-BOOL WINAPI EnumResourceTypesA(HMODULE,ENUMRESTYPEPROCA,LONG_PTR);
-BOOL WINAPI EnumResourceTypesW(HMODULE,ENUMRESTYPEPROCW,LONG_PTR);
+BOOL WINAPI EnumResourceLanguagesA(_In_opt_ HMODULE, _In_ LPCSTR, _In_ LPCSTR, _In_
ENUMRESLANGPROCA, _In_ LONG_PTR);
+BOOL WINAPI EnumResourceLanguagesW(_In_opt_ HMODULE, _In_ LPCWSTR, _In_ LPCWSTR, _In_
ENUMRESLANGPROCW, _In_ LONG_PTR);
+BOOL WINAPI EnumResourceNamesA(_In_opt_ HMODULE, _In_ LPCSTR, _In_ ENUMRESNAMEPROCA, _In_
LONG_PTR);
+BOOL WINAPI EnumResourceNamesW(_In_opt_ HMODULE, _In_ LPCWSTR, _In_ ENUMRESNAMEPROCW,
_In_ LONG_PTR);
+BOOL WINAPI EnumResourceTypesA(_In_opt_ HMODULE, _In_ ENUMRESTYPEPROCA, _In_ LONG_PTR);
+BOOL WINAPI EnumResourceTypesW(_In_opt_ HMODULE, _In_ ENUMRESTYPEPROCW, _In_ LONG_PTR);
 BOOL WINAPI EqualPrefixSid(PSID,PSID);
 BOOL WINAPI EqualSid(PSID,PSID);
-DWORD WINAPI EraseTape(HANDLE,DWORD,BOOL);
-BOOL WINAPI EscapeCommFunction(HANDLE,DWORD);
+DWORD WINAPI EraseTape(_In_ HANDLE, _In_ DWORD, _In_ BOOL);
+BOOL WINAPI EscapeCommFunction(_In_ HANDLE, _In_ DWORD);
 DECLSPEC_NORETURN void WINAPI ExitProcess(UINT);
 DECLSPEC_NORETURN void WINAPI ExitThread(DWORD);
 DWORD WINAPI ExpandEnvironmentStringsA(LPCSTR,LPSTR,DWORD);
 DWORD WINAPI ExpandEnvironmentStringsW(LPCWSTR,LPWSTR,DWORD);
 void WINAPI FatalAppExitA(UINT,LPCSTR);
 void WINAPI FatalAppExitW(UINT,LPCWSTR);
-void WINAPI FatalExit(int);
-BOOL WINAPI FileEncryptionStatusA(LPCSTR,LPDWORD);
-BOOL WINAPI FileEncryptionStatusW(LPCWSTR,LPDWORD);
-BOOL WINAPI FileTimeToDosDateTime(CONST FILETIME *,LPWORD,LPWORD);
+__analysis_noreturn void WINAPI FatalExit(_In_ int);
+BOOL WINAPI FileEncryptionStatusA(_In_ LPCSTR, _Out_ LPDWORD);
+BOOL WINAPI FileEncryptionStatusW(_In_ LPCWSTR, _Out_ LPDWORD);
+BOOL WINAPI FileTimeToDosDateTime(_In_ CONST FILETIME *, _Out_ LPWORD, _Out_ LPWORD);
 BOOL WINAPI FileTimeToLocalFileTime(CONST FILETIME *,LPFILETIME);
 BOOL WINAPI FileTimeToSystemTime(CONST FILETIME *,LPSYSTEMTIME);
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI FindActCtxSectionGuid(DWORD,const GUID*,ULONG,const
GUID*,PACTCTX_SECTION_KEYED_DATA);
-BOOL WINAPI FindActCtxSectionStringA(DWORD,const
GUID*,ULONG,LPCSTR,PACTCTX_SECTION_KEYED_DATA);
-BOOL WINAPI FindActCtxSectionStringW(DWORD,const
GUID*,ULONG,LPCWSTR,PACTCTX_SECTION_KEYED_DATA);
-#endif
-ATOM WINAPI FindAtomA(LPCSTR);
-ATOM WINAPI FindAtomW(LPCWSTR);
+BOOL WINAPI FindActCtxSectionGuid(_In_ DWORD, _Reserved_ const GUID*, _In_ ULONG,
_In_opt_ const GUID*, _Out_ PACTCTX_SECTION_KEYED_DATA);
+BOOL WINAPI FindActCtxSectionStringA(_In_ DWORD, _Reserved_ const GUID*, _In_ ULONG, _In_
LPCSTR, _Out_ PACTCTX_SECTION_KEYED_DATA);
+BOOL WINAPI FindActCtxSectionStringW(_In_ DWORD, _Reserved_ const GUID*, _In_ ULONG, _In_
LPCWSTR, _Out_ PACTCTX_SECTION_KEYED_DATA);
+#endif
+ATOM WINAPI FindAtomA(_In_opt_ LPCSTR);
+ATOM WINAPI FindAtomW(_In_opt_ LPCWSTR);
 BOOL WINAPI FindClose(HANDLE);
 BOOL WINAPI FindCloseChangeNotification(HANDLE);
 HANDLE WINAPI FindFirstChangeNotificationA(LPCSTR,BOOL,DWORD);
@@ -1477,36 +1620,95 @@
 HANDLE WINAPI
FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
 HANDLE WINAPI
FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
 #if (_WIN32_WINNT >= 0x0501)
-HANDLE WINAPI FindFirstStreamW(LPCWSTR,STREAM_INFO_LEVELS,LPVOID,DWORD);
+HANDLE WINAPI FindFirstStreamW(_In_ LPCWSTR, _In_ STREAM_INFO_LEVELS, _Out_ LPVOID,
_Reserved_ DWORD);
 #endif
 BOOL WINAPI FindFirstFreeAce(PACL,PVOID*);
-#if (_WIN32_WINNT >= 0x0500)
-HANDLE WINAPI FindFirstVolumeA(LPSTR,DWORD);
+
+#if (_WIN32_WINNT >= 0x0500)
+
+HANDLE
+WINAPI
+FindFirstVolumeA(
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumeName,
+  _In_ DWORD cchBufferLength);
+
 HANDLE WINAPI FindFirstVolumeW(LPWSTR,DWORD);
-HANDLE WINAPI FindFirstVolumeMountPointA(LPCSTR,LPSTR,DWORD);
-HANDLE WINAPI FindFirstVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
-#endif
+
+HANDLE
+WINAPI
+FindFirstVolumeMountPointA(
+  _In_ LPCSTR lpszRootPathName,
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumeMountPoint,
+  _In_ DWORD cchBufferLength);
+
+HANDLE
+WINAPI
+FindFirstVolumeMountPointW(
+  _In_ LPCWSTR lpszRootPathName,
+  _Out_writes_(cchBufferLength) LPWSTR lpszVolumeMountPoint,
+  _In_ DWORD cchBufferLength);
+
+#endif
+
 BOOL WINAPI FindNextChangeNotification(HANDLE);
 BOOL WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
 BOOL WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI FindNextStreamW(HANDLE,LPVOID);
-#endif
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI FindNextVolumeA(HANDLE,LPSTR,DWORD);
+BOOL WINAPI FindNextStreamW(_In_ HANDLE, _Out_ LPVOID);
+#endif
+
+#if (_WIN32_WINNT >= 0x0500)
+
+BOOL
+WINAPI
+FindNextVolumeA(
+  _Inout_ HANDLE hFindVolume,
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumeName,
+  _In_ DWORD cchBufferLength);
+
 BOOL WINAPI FindNextVolumeW(HANDLE,LPWSTR,DWORD);
-BOOL WINAPI FindNextVolumeMountPointA(HANDLE,LPSTR,DWORD);
-BOOL WINAPI FindNextVolumeMountPointW(HANDLE,LPWSTR,DWORD);
+
+BOOL
+WINAPI
+FindNextVolumeMountPointA(
+  _In_ HANDLE hFindVolumeMountPoint,
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumeMountPoint,
+  _In_ DWORD cchBufferLength);
+
+BOOL
+WINAPI
+FindNextVolumeMountPointW(
+  _In_ HANDLE hFindVolumeMountPoint,
+  _Out_writes_(cchBufferLength) LPWSTR lpszVolumeMountPoint,
+  _In_ DWORD cchBufferLength);
+
 BOOL WINAPI FindVolumeClose(HANDLE);
-BOOL WINAPI FindVolumeMountPointClose(HANDLE);
-#endif
-HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
-HRSRC WINAPI FindResourceW(HINSTANCE,LPCWSTR,LPCWSTR);
-HRSRC WINAPI FindResourceExA(HINSTANCE,LPCSTR,LPCSTR,WORD);
+BOOL WINAPI FindVolumeMountPointClose(_In_ HANDLE);
+
+#endif
+
+_Ret_maybenull_ HRSRC WINAPI FindResourceA(_In_opt_ HMODULE,_In_ LPCSTR, _In_ LPCSTR);
+_Ret_maybenull_ HRSRC WINAPI FindResourceW(_In_opt_ HMODULE,_In_ LPCWSTR, _In_ LPCWSTR);
+_Ret_maybenull_ HRSRC WINAPI FindResourceExA(_In_opt_ HMODULE, _In_ LPCSTR, _In_ LPCSTR,
_In_ WORD);
 HRSRC WINAPI FindResourceExW(HINSTANCE,LPCWSTR,LPCWSTR,WORD);
 #if (_WIN32_WINNT >= 0x0502)
-DWORD WINAPI GetFirmwareEnvironmentVariableA(LPCSTR,LPCSTR,PVOID,DWORD);
-DWORD WINAPI GetFirmwareEnvironmentVariableW(LPCWSTR,LPCWSTR,PVOID,DWORD);
+
+DWORD
+WINAPI
+GetFirmwareEnvironmentVariableA(
+  _In_ LPCSTR lpName,
+  _In_ LPCSTR lpGuid,
+  _Out_writes_bytes_to_opt_(nSize, return) PVOID pBuffer,
+  _In_ DWORD nSize);
+
+DWORD
+WINAPI
+GetFirmwareEnvironmentVariableW(
+  _In_ LPCWSTR lpName,
+  _In_ LPCWSTR lpGuid,
+  _Out_writes_bytes_to_opt_(nSize, return) PVOID pBuffer,
+  _In_ DWORD nSize);
+
 #endif
 BOOL WINAPI FlushFileBuffers(HANDLE);
 BOOL WINAPI FlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
@@ -1530,51 +1732,113 @@
 BOOL WINAPI GetAce(PACL,DWORD,LPVOID*);
 BOOL WINAPI GetAclInformation(PACL,PVOID,DWORD,ACL_INFORMATION_CLASS);
 #if (_WIN32_WINNT >= 0x0600)
-HRESULT WINAPI
GetApplicationRecoveryCallback(HANDLE,APPLICATION_RECOVERY_CALLBACK*,PVOID*, DWORD*,
DWORD*);
+HRESULT WINAPI GetApplicationRecoveryCallback(_In_ HANDLE, _Out_
APPLICATION_RECOVERY_CALLBACK*, _Outptr_opt_result_maybenull_ PVOID*, _Out_opt_ DWORD*,
_Out_opt_ DWORD*);
 HRESULT WINAPI GetApplicationRestart(HANDLE,PWSTR,PDWORD,PDWORD);
 #endif
-UINT WINAPI GetAtomNameA(ATOM,LPSTR,int);
-UINT WINAPI GetAtomNameW(ATOM,LPWSTR,int);
-BOOL WINAPI GetBinaryTypeA(LPCSTR,PDWORD);
-BOOL WINAPI GetBinaryTypeW(LPCWSTR,PDWORD);
+
+UINT
+WINAPI
+GetAtomNameA(
+  _In_ ATOM nAtom,
+  _Out_writes_to_(nSize, return + 1) LPSTR lpBuffer,
+  _In_ int nSize);
+
+UINT
+WINAPI
+GetAtomNameW(
+  _In_ ATOM nAtom,
+  _Out_writes_to_(nSize, return + 1) LPWSTR lpBuffer,
+  _In_ int nSize);
+
+BOOL WINAPI GetBinaryTypeA(_In_ LPCSTR, _Out_ PDWORD);
+BOOL WINAPI GetBinaryTypeW(_In_ LPCWSTR, _Out_ PDWORD);
 LPSTR WINAPI GetCommandLineA(VOID);
 LPWSTR WINAPI GetCommandLineW(VOID);
-BOOL WINAPI GetCommConfig(HANDLE,LPCOMMCONFIG,PDWORD);
-BOOL WINAPI GetCommMask(HANDLE,PDWORD);
-BOOL WINAPI GetCommModemStatus(HANDLE,PDWORD);
-BOOL WINAPI GetCommProperties(HANDLE,LPCOMMPROP);
-BOOL WINAPI GetCommState(HANDLE,LPDCB);
-BOOL WINAPI GetCommTimeouts(HANDLE,LPCOMMTIMEOUTS);
-DWORD WINAPI GetCompressedFileSizeA(LPCSTR,PDWORD);
-DWORD WINAPI GetCompressedFileSizeW(LPCWSTR,PDWORD);
-BOOL WINAPI GetComputerNameA(LPSTR,PDWORD);
-BOOL WINAPI GetComputerNameW(LPWSTR,PDWORD);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+GetCommConfig(
+  _In_ HANDLE hCommDev,
+  _Out_writes_bytes_opt_(*lpdwSize) LPCOMMCONFIG lpCC,
+  _Inout_ LPDWORD lpdwSize);
+
+BOOL WINAPI GetCommMask(_In_ HANDLE, _Out_ PDWORD);
+BOOL WINAPI GetCommModemStatus(_In_ HANDLE, _Out_ PDWORD);
+BOOL WINAPI GetCommProperties(_In_ HANDLE, _Inout_ LPCOMMPROP);
+BOOL WINAPI GetCommState(_In_ HANDLE, _Out_ LPDCB);
+BOOL WINAPI GetCommTimeouts(_In_ HANDLE, _Out_ LPCOMMTIMEOUTS);
+DWORD WINAPI GetCompressedFileSizeA(_In_ LPCSTR, _Out_opt_ PDWORD);
+DWORD WINAPI GetCompressedFileSizeW(_In_ LPCWSTR, _Out_opt_ PDWORD);
+
+_Success_(return != 0)
+BOOL
+WINAPI
+GetComputerNameA(
+  _Out_writes_to_opt_(*nSize, *nSize + 1) LPSTR lpBuffer,
+  _Inout_ LPDWORD nSize);
+
+_Success_(return != 0)
+BOOL
+WINAPI
+GetComputerNameW(
+  _Out_writes_to_opt_(*nSize, *nSize + 1) LPWSTR lpBuffer,
+  _Inout_ LPDWORD nSize);
+
 #if (_WIN32_WINNT >= 0x0500)
 BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT,LPSTR,LPDWORD);
 BOOL WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT,LPWSTR,LPDWORD);
 #endif
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI GetCurrentActCtx(HANDLE*);
+BOOL WINAPI GetCurrentActCtx( _Outptr_ HANDLE*);
 #endif
 DWORD WINAPI GetCurrentDirectoryA(DWORD,LPSTR);
 DWORD WINAPI GetCurrentDirectoryW(DWORD,LPWSTR);
-BOOL WINAPI GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
-BOOL WINAPI GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
+BOOL WINAPI GetCurrentHwProfileA(_Out_ LPHW_PROFILE_INFOA);
+BOOL WINAPI GetCurrentHwProfileW(_Out_ LPHW_PROFILE_INFOW);
 HANDLE WINAPI GetCurrentProcess(void);
 DWORD WINAPI GetCurrentProcessId(void);
 HANDLE WINAPI GetCurrentThread(void);
 DWORD WINAPI GetCurrentThreadId(void);
 #define GetCurrentTime GetTickCount
-BOOL WINAPI GetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,PDWORD);
-BOOL WINAPI GetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,PDWORD);
+
+BOOL
+WINAPI
+GetDefaultCommConfigA(
+  _In_ LPCSTR lpszName,
+  _Out_writes_bytes_to_(*lpdwSize, *lpdwSize) LPCOMMCONFIG lpCC,
+  _Inout_ LPDWORD lpdwSize);
+
+BOOL
+WINAPI
+GetDefaultCommConfigW(
+  _In_ LPCWSTR lpszName,
+  _Out_writes_bytes_to_(*lpdwSize, *lpdwSize) LPCOMMCONFIG lpCC,
+  _Inout_ LPDWORD lpdwSize);
+
 BOOL WINAPI GetDiskFreeSpaceA(LPCSTR,PDWORD,PDWORD,PDWORD,PDWORD);
 BOOL WINAPI GetDiskFreeSpaceW(LPCWSTR,PDWORD,PDWORD,PDWORD,PDWORD);
 BOOL WINAPI GetDiskFreeSpaceExA(LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
 BOOL WINAPI
GetDiskFreeSpaceExW(LPCWSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+
 #if (_WIN32_WINNT >= 0x0502)
-DWORD WINAPI GetDllDirectoryA(DWORD,LPSTR);
-DWORD WINAPI GetDllDirectoryW(DWORD,LPWSTR);
-#endif
+
+_Success_(return != 0 && return < nBufferLength)
+DWORD
+WINAPI
+GetDllDirectoryA(
+  _In_ DWORD nBufferLength,
+  _Out_writes_to_opt_(nBufferLength, return + 1) LPSTR lpBuffer);
+
+_Success_(return != 0 && return < nBufferLength)
+DWORD
+WINAPI
+GetDllDirectoryW(
+  _In_ DWORD nBufferLength,
+  _Out_writes_to_opt_(nBufferLength, return + 1) LPWSTR lpBuffer);
+
+#endif
+
 UINT WINAPI GetDriveTypeA(LPCSTR);
 UINT WINAPI GetDriveTypeW(LPCWSTR);
 LPSTR WINAPI GetEnvironmentStrings(void);
@@ -1593,10 +1857,19 @@
 BOOL WINAPI GetFileAttributesExA(LPCSTR,GET_FILEEX_INFO_LEVELS,PVOID);
 BOOL WINAPI GetFileAttributesExW(LPCWSTR,GET_FILEEX_INFO_LEVELS,PVOID);
 #if (_WIN32_WINNT >= 0x0600)
-BOOL WINAPI GetFileBandwidthReservation(HANDLE,LPDWORD,LPDWORD,LPBOOL,LPDWORD,LPDWORD);
+BOOL WINAPI GetFileBandwidthReservation(_In_ HANDLE, _Out_ LPDWORD, _Out_ LPDWORD, _Out_
LPBOOL, _Out_ LPDWORD, _Out_ LPDWORD);
 #endif
 BOOL WINAPI GetFileInformationByHandle(HANDLE,LPBY_HANDLE_FILE_INFORMATION);
-BOOL WINAPI
GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
+
+BOOL
+WINAPI
+GetFileSecurityA(
+  _In_ LPCSTR lpFileName,
+  _In_ SECURITY_INFORMATION RequestedInformation,
+  _Out_writes_bytes_to_opt_(nLength, *lpnLengthNeeded) PSECURITY_DESCRIPTOR
pSecurityDescriptor,
+  _In_ DWORD nLength,
+  _Out_ LPDWORD lpnLengthNeeded);
+
 BOOL WINAPI
GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
 DWORD WINAPI GetFileSize(HANDLE,PDWORD);
 BOOL WINAPI GetFileSizeEx(HANDLE,PLARGE_INTEGER);
@@ -1611,13 +1884,20 @@
 DWORD WINAPI GetLengthSid(PSID);
 void WINAPI GetLocalTime(LPSYSTEMTIME);
 DWORD WINAPI GetLogicalDrives(void);
-DWORD WINAPI GetLogicalDriveStringsA(DWORD,LPSTR);
+
+_Success_(return != 0 && return <= nBufferLength)
+DWORD
+WINAPI
+GetLogicalDriveStringsA(
+  _In_ DWORD nBufferLength,
+  _Out_writes_to_opt_(nBufferLength, return + 1) LPSTR lpBuffer);
+
 DWORD WINAPI GetLogicalDriveStringsW(DWORD,LPWSTR);
 #if (_WIN32_WINNT >= 0x0500 || _WIN32_WINDOWS >= 0x0410)
 DWORD WINAPI GetLongPathNameA(LPCSTR,LPSTR,DWORD);
 DWORD WINAPI GetLongPathNameW(LPCWSTR,LPWSTR,DWORD);
 #endif
-BOOL WINAPI GetMailslotInfo(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD);
+BOOL WINAPI GetMailslotInfo(_In_ HANDLE, _Out_opt_ PDWORD, _Out_opt_ PDWORD, _Out_opt_
PDWORD, _Out_opt_ PDWORD);
 DWORD WINAPI GetModuleFileNameA(HINSTANCE,LPSTR,DWORD);
 DWORD WINAPI GetModuleFileNameW(HINSTANCE,LPWSTR,DWORD);
 HMODULE WINAPI GetModuleHandleA(LPCSTR);
@@ -1632,32 +1912,122 @@
 WINBASEAPI WINBOOL WINAPI NeedCurrentDirectoryForExePathW(LPCWSTR ExeName);
 #endif
 
-BOOL WINAPI GetNamedPipeHandleStateA(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD,LPSTR,DWORD);
-BOOL WINAPI GetNamedPipeHandleStateW(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD,LPWSTR,DWORD);
-BOOL WINAPI GetNamedPipeInfo(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD);
+BOOL
+WINAPI
+GetNamedPipeHandleStateA(
+  _In_ HANDLE hNamedPipe,
+  _Out_opt_ LPDWORD lpState,
+  _Out_opt_ LPDWORD lpCurInstances,
+  _Out_opt_ LPDWORD lpMaxCollectionCount,
+  _Out_opt_ LPDWORD lpCollectDataTimeout,
+  _Out_writes_opt_(nMaxUserNameSize) LPSTR lpUserName,
+  _In_ DWORD nMaxUserNameSize);
+
+BOOL
+WINAPI
+GetNamedPipeHandleStateW(
+  _In_ HANDLE hNamedPipe,
+  _Out_opt_ LPDWORD lpState,
+  _Out_opt_ LPDWORD lpCurInstances,
+  _Out_opt_ LPDWORD lpMaxCollectionCount,
+  _Out_opt_ LPDWORD lpCollectDataTimeout,
+  _Out_writes_opt_(nMaxUserNameSize) LPWSTR lpUserName,
+  _In_ DWORD nMaxUserNameSize);
+
+BOOL WINAPI GetNamedPipeInfo(_In_ HANDLE, _Out_opt_ PDWORD, _Out_opt_ PDWORD, _Out_opt_
PDWORD, _Out_opt_ PDWORD);
 #if (_WIN32_WINNT >= 0x0501)
 VOID WINAPI GetNativeSystemInfo(LPSYSTEM_INFO);
 #endif
-BOOL WINAPI GetEventLogInformation(HANDLE,DWORD,LPVOID,DWORD,LPDWORD);
-BOOL WINAPI GetNumberOfEventLogRecords(HANDLE,PDWORD);
-BOOL WINAPI GetOldestEventLogRecord(HANDLE,PDWORD);
+
+BOOL
+WINAPI
+GetEventLogInformation(
+  _In_ HANDLE hEventLog,
+  _In_ DWORD dwInfoLevel,
+  _Out_writes_bytes_to_(cbBufSize, *pcbBytesNeeded) LPVOID lpBuffer,
+  _In_ DWORD cbBufSize,
+  _Out_ LPDWORD pcbBytesNeeded);
+
+BOOL WINAPI GetNumberOfEventLogRecords(_In_ HANDLE, _Out_ PDWORD);
+BOOL WINAPI GetOldestEventLogRecord(_In_ HANDLE, _Out_ PDWORD);
 BOOL WINAPI GetOverlappedResult(HANDLE,LPOVERLAPPED,PDWORD,BOOL);
 DWORD WINAPI GetPriorityClass(HANDLE);
 BOOL WINAPI
GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
-UINT WINAPI GetPrivateProfileIntA(LPCSTR,LPCSTR,INT,LPCSTR);
-UINT WINAPI GetPrivateProfileIntW(LPCWSTR,LPCWSTR,INT,LPCWSTR);
-DWORD WINAPI GetPrivateProfileSectionA(LPCSTR,LPSTR,DWORD,LPCSTR);
-DWORD WINAPI GetPrivateProfileSectionW(LPCWSTR,LPWSTR,DWORD,LPCWSTR);
-DWORD WINAPI GetPrivateProfileSectionNamesA(LPSTR,DWORD,LPCSTR);
-DWORD WINAPI GetPrivateProfileSectionNamesW(LPWSTR,DWORD,LPCWSTR);
-DWORD WINAPI GetPrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,DWORD,LPCSTR);
-DWORD WINAPI GetPrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,DWORD,LPCWSTR);
-BOOL WINAPI GetPrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
-BOOL WINAPI GetPrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
+UINT WINAPI GetPrivateProfileIntA(_In_ LPCSTR, _In_ LPCSTR, _In_ INT, _In_opt_ LPCSTR);
+UINT WINAPI GetPrivateProfileIntW(_In_ LPCWSTR, _In_ LPCWSTR, _In_ INT, _In_opt_
LPCWSTR);
+
+DWORD
+WINAPI
+GetPrivateProfileSectionA(
+  _In_ LPCSTR lpAppName,
+  _Out_writes_to_opt_(nSize, return + 1) LPSTR lpReturnedString,
+  _In_ DWORD nSize,
+  _In_opt_ LPCSTR lpFileName);
+
+DWORD
+WINAPI
+GetPrivateProfileSectionW(
+  _In_ LPCWSTR lpAppName,
+  _Out_writes_to_opt_(nSize, return + 1) LPWSTR lpReturnedString,
+  _In_ DWORD nSize,
+  _In_opt_ LPCWSTR lpFileName);
+
+DWORD
+WINAPI
+GetPrivateProfileSectionNamesA(
+  _Out_writes_to_opt_(nSize, return + 1) LPSTR lpszReturnBuffer,
+  _In_ DWORD nSize,
+  _In_opt_ LPCSTR lpFileName);
+
+DWORD
+WINAPI
+GetPrivateProfileSectionNamesW(
+  _Out_writes_to_opt_(nSize, return + 1) LPWSTR lpszReturnBuffer,
+  _In_ DWORD nSize,
+  _In_opt_ LPCWSTR lpFileName);
+
+DWORD
+WINAPI
+GetPrivateProfileStringA(
+  _In_opt_ LPCSTR lpAppName,
+  _In_opt_ LPCSTR lpKeyName,
+  _In_opt_ LPCSTR lpDefault,
+  _Out_writes_to_opt_(nSize, return + 1) LPSTR lpReturnedString,
+  _In_ DWORD nSize,
+  _In_opt_ LPCSTR lpFileName);
+
+DWORD
+WINAPI
+GetPrivateProfileStringW(
+  _In_opt_ LPCWSTR lpAppName,
+  _In_opt_ LPCWSTR lpKeyName,
+  _In_opt_ LPCWSTR lpDefault,
+  _Out_writes_to_opt_(nSize, return + 1) LPWSTR lpReturnedString,
+  _In_ DWORD nSize,
+  _In_opt_ LPCWSTR lpFileName);
+
+BOOL
+WINAPI
+GetPrivateProfileStructA(
+  _In_ LPCSTR lpszSection,
+  _In_ LPCSTR lpszKey,
+  _Out_writes_bytes_opt_(uSizeStruct) LPVOID lpStruct,
+  _In_ UINT uSizeStruct,
+  _In_opt_ LPCSTR szFile);
+
+BOOL
+WINAPI
+GetPrivateProfileStructW(
+  _In_ LPCWSTR lpszSection,
+  _In_ LPCWSTR lpszKey,
+  _Out_writes_bytes_opt_(uSizeStruct) LPVOID lpStruct,
+  _In_ UINT uSizeStruct,
+  _In_opt_ LPCWSTR szFile);
+
 FARPROC WINAPI GetProcAddress(HINSTANCE,LPCSTR);
-BOOL WINAPI GetProcessAffinityMask(HANDLE,PDWORD_PTR,PDWORD_PTR);
+BOOL WINAPI GetProcessAffinityMask(_In_ HANDLE, _Out_ PDWORD_PTR, _Out_ PDWORD_PTR);
 #if (_WIN32_WINNT >= 0x0502)
-BOOL WINAPI GetProcessHandleCount(HANDLE,PDWORD);
+BOOL WINAPI GetProcessHandleCount(_In_ HANDLE, _Out_ PDWORD);
 #endif
 HANDLE WINAPI GetProcessHeap(VOID);
 DWORD WINAPI GetProcessHeaps(DWORD,PHANDLE);
@@ -1665,20 +2035,49 @@
 DWORD WINAPI GetProcessId(HANDLE);
 #endif
 #if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI GetProcessIoCounters(HANDLE,PIO_COUNTERS);
-#endif
-BOOL WINAPI GetProcessPriorityBoost(HANDLE,PBOOL);
-BOOL WINAPI GetProcessShutdownParameters(PDWORD,PDWORD);
+BOOL WINAPI GetProcessIoCounters(_In_ HANDLE, _Out_ PIO_COUNTERS);
+#endif
+BOOL WINAPI GetProcessPriorityBoost(_In_ HANDLE, _Out_ PBOOL);
+BOOL WINAPI GetProcessShutdownParameters(_Out_ PDWORD, _Out_ PDWORD);
 BOOL WINAPI GetProcessTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
 DWORD WINAPI GetProcessVersion(DWORD);
 HWINSTA WINAPI GetProcessWindowStation(void);
-BOOL WINAPI GetProcessWorkingSetSize(HANDLE,PSIZE_T,PSIZE_T);
-UINT WINAPI GetProfileIntA(LPCSTR,LPCSTR,INT);
-UINT WINAPI GetProfileIntW(LPCWSTR,LPCWSTR,INT);
-DWORD WINAPI GetProfileSectionA(LPCSTR,LPSTR,DWORD);
-DWORD WINAPI GetProfileSectionW(LPCWSTR,LPWSTR,DWORD);
-DWORD WINAPI GetProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,DWORD);
-DWORD WINAPI GetProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,DWORD);
+BOOL WINAPI GetProcessWorkingSetSize(_In_ HANDLE, _Out_ PSIZE_T, _Out_ PSIZE_T);
+UINT WINAPI GetProfileIntA(_In_ LPCSTR, _In_ LPCSTR, _In_ INT);
+UINT WINAPI GetProfileIntW(_In_ LPCWSTR, _In_ LPCWSTR, _In_ INT);
+
+DWORD
+WINAPI
+GetProfileSectionA(
+  _In_ LPCSTR lpAppName,
+  _Out_writes_to_opt_(nSize, return + 1) LPSTR lpReturnedString,
+  _In_ DWORD nSize);
+
+DWORD
+WINAPI
+GetProfileSectionW(
+  _In_ LPCWSTR lpAppName,
+  _Out_writes_to_opt_(nSize, return + 1) LPWSTR lpReturnedString,
+  _In_ DWORD nSize);
+
+DWORD
+WINAPI
+GetProfileStringA(
+  _In_opt_ LPCSTR lpAppName,
+  _In_opt_ LPCSTR lpKeyName,
+  _In_opt_ LPCSTR lpDefault,
+  _Out_writes_to_opt_(nSize, return + 1) LPSTR lpReturnedString,
+  _In_ DWORD nSize);
+
+DWORD
+WINAPI
+GetProfileStringW(
+  _In_opt_ LPCWSTR lpAppName,
+  _In_opt_ LPCWSTR lpKeyName,
+  _In_opt_ LPCWSTR lpDefault,
+  _Out_writes_to_opt_(nSize, return + 1) LPWSTR lpReturnedString,
+  _In_ DWORD nSize);
+
 BOOL WINAPI GetQueuedCompletionStatus(HANDLE,PDWORD,PULONG_PTR,LPOVERLAPPED*,DWORD);
 BOOL WINAPI
GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR_CONTROL,PDWORD);
 BOOL WINAPI GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL*,LPBOOL);
@@ -1687,25 +2086,33 @@
 BOOL WINAPI GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID*,LPBOOL);
 DWORD WINAPI GetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR,PUCHAR);
 BOOL WINAPI GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL*,LPBOOL);
-DWORD WINAPI GetShortPathNameA(LPCSTR,LPSTR,DWORD);
+
+_Success_(return != 0 && return < cchBuffer)
+DWORD
+WINAPI
+GetShortPathNameA(
+  _In_ LPCSTR lpszLongPath,
+  _Out_writes_to_opt_(cchBuffer, return + 1) LPSTR  lpszShortPath,
+  _In_ DWORD cchBuffer);
+
 DWORD WINAPI GetShortPathNameW(LPCWSTR,LPWSTR,DWORD);
 PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
 DWORD WINAPI GetSidLengthRequired(UCHAR);
 PDWORD WINAPI GetSidSubAuthority(PSID,DWORD);
 PUCHAR WINAPI GetSidSubAuthorityCount(PSID);
-VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA);
+VOID WINAPI GetStartupInfoA(_Out_ LPSTARTUPINFOA);
 VOID WINAPI GetStartupInfoW(LPSTARTUPINFOW);
 HANDLE WINAPI GetStdHandle(DWORD);
 UINT WINAPI GetSystemDirectoryA(LPSTR,UINT);
 UINT WINAPI GetSystemDirectoryW(LPWSTR,UINT);
 VOID WINAPI GetSystemInfo(LPSYSTEM_INFO);
-BOOL WINAPI GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
+BOOL WINAPI GetSystemPowerStatus(_Out_ LPSYSTEM_POWER_STATUS);
 #if (_WIN32_WINNT >= 0x0502)
-BOOL WINAPI GetSystemRegistryQuota(PDWORD,PDWORD);
+BOOL WINAPI GetSystemRegistryQuota(_Out_opt_ PDWORD, _Out_opt_ PDWORD);
 #endif
 VOID WINAPI GetSystemTime(LPSYSTEMTIME);
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI GetSystemTimes(LPFILETIME,LPFILETIME,LPFILETIME);
+BOOL WINAPI GetSystemTimes(_Out_opt_ LPFILETIME, _Out_opt_ LPFILETIME, _Out_opt_
LPFILETIME);
 #endif
 BOOL WINAPI GetSystemTimeAdjustment(PDWORD,PDWORD,PBOOL);
 void WINAPI GetSystemTimeAsFileTime(LPFILETIME);
@@ -1713,24 +2120,60 @@
 UINT WINAPI GetSystemWindowsDirectoryA(LPSTR,UINT);
 UINT WINAPI GetSystemWindowsDirectoryW(LPWSTR,UINT);
 #endif
-#if (_WIN32_WINNT >= 0x0501)
-UINT WINAPI GetSystemWow64DirectoryA(LPSTR,UINT);
-UINT WINAPI GetSystemWow64DirectoryW(LPWSTR,UINT);
-#endif
-DWORD WINAPI GetTapeParameters(HANDLE,DWORD,PDWORD,PVOID);
-DWORD WINAPI GetTapePosition(HANDLE,DWORD,PDWORD,PDWORD,PDWORD);
-DWORD WINAPI GetTapeStatus(HANDLE);
-UINT WINAPI GetTempFileNameA(LPCSTR,LPCSTR,UINT,LPSTR);
+
+#if (_WIN32_WINNT >= 0x0501)
+
+_Success_(return != 0 && return < uSize)
+UINT
+WINAPI
+GetSystemWow64DirectoryA(
+  _Out_writes_to_opt_(uSize, return + 1) LPSTR lpBuffer,
+  _In_ UINT uSize);
+
+_Success_(return != 0 && return < uSize)
+UINT
+WINAPI
+GetSystemWow64DirectoryW(
+  _Out_writes_to_opt_(uSize, return + 1) LPWSTR lpBuffer,
+  _In_ UINT uSize);
+
+#endif
+
+DWORD
+WINAPI
+GetTapeParameters(
+  _In_ HANDLE hDevice,
+  _In_ DWORD dwOperation,
+  _Inout_ LPDWORD lpdwSize,
+  _Out_writes_bytes_(*lpdwSize) LPVOID lpTapeInformation);
+
+DWORD WINAPI GetTapePosition(_In_ HANDLE, _In_ DWORD, _Out_ PDWORD, _Out_ PDWORD, _Out_
PDWORD);
+DWORD WINAPI GetTapeStatus(_In_ HANDLE);
+
+UINT
+WINAPI
+GetTempFileNameA(
+  _In_ LPCSTR lpPathName,
+  _In_ LPCSTR lpPrefixString,
+  _In_ UINT uUnique,
+  _Out_writes_(MAX_PATH) LPSTR lpTempFileName);
+
 UINT WINAPI GetTempFileNameW(LPCWSTR,LPCWSTR,UINT,LPWSTR);
-DWORD WINAPI GetTempPathA(DWORD,LPSTR);
+
+DWORD
+WINAPI
+GetTempPathA(
+  _In_ DWORD nBufferLength,
+  _Out_writes_to_opt_(nBufferLength, return + 1) LPSTR lpBuffer);
+
 DWORD WINAPI GetTempPathW(DWORD,LPWSTR);
 BOOL WINAPI GetThreadContext(HANDLE,LPCONTEXT);
 #if (_WIN32_WINNT >= 0x0502)
-BOOL WINAPI GetThreadIOPendingFlag(HANDLE,PBOOL);
+BOOL WINAPI GetThreadIOPendingFlag(_In_ HANDLE, _Out_ PBOOL);
 #endif
 int WINAPI GetThreadPriority(HANDLE);
 BOOL WINAPI GetThreadPriorityBoost(HANDLE,PBOOL);
-BOOL WINAPI GetThreadSelectorEntry(HANDLE,DWORD,LPLDT_ENTRY);
+BOOL WINAPI GetThreadSelectorEntry(_In_ HANDLE, _In_ DWORD, _Out_ LPLDT_ENTRY);
 BOOL WINAPI GetThreadTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
 DWORD WINAPI GetTickCount(VOID);
 #if (_WIN32_WINNT >= 0x0600)
@@ -1739,52 +2182,115 @@
 DWORD WINAPI GetThreadId(HANDLE);
 DWORD WINAPI GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
 BOOL WINAPI GetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,PVOID,DWORD,PDWORD);
-BOOL WINAPI GetUserNameA (LPSTR,PDWORD);
-BOOL WINAPI GetUserNameW(LPWSTR,PDWORD);
+
+BOOL
+WINAPI
+GetUserNameA(
+  _Out_writes_to_opt_(*pcbBuffer, *pcbBuffer) LPSTR lpBuffer,
+  _Inout_ LPDWORD pcbBuffer);
+
+BOOL
+WINAPI
+GetUserNameW(
+  _Out_writes_to_opt_(*pcbBuffer, *pcbBuffer) LPWSTR lpBuffer,
+  _Inout_ LPDWORD pcbBuffer);
+
 DWORD WINAPI GetVersion(void);
 BOOL WINAPI GetVersionExA(LPOSVERSIONINFOA);
 BOOL WINAPI GetVersionExW(LPOSVERSIONINFOW);
-BOOL WINAPI GetVolumeInformationA(LPCSTR,LPSTR,DWORD,PDWORD,PDWORD,PDWORD,LPSTR,DWORD);
+
+BOOL
+WINAPI
+GetVolumeInformationA(
+  _In_opt_ LPCSTR lpRootPathName,
+  _Out_writes_opt_(nVolumeNameSize) LPSTR lpVolumeNameBuffer,
+  _In_ DWORD nVolumeNameSize,
+  _Out_opt_ LPDWORD lpVolumeSerialNumber,
+  _Out_opt_ LPDWORD lpMaximumComponentLength,
+  _Out_opt_ LPDWORD lpFileSystemFlags,
+  _Out_writes_opt_(nFileSystemNameSize) LPSTR lpFileSystemNameBuffer,
+  _In_ DWORD nFileSystemNameSize);
+
 BOOL WINAPI
GetVolumeInformationW(LPCWSTR,LPWSTR,DWORD,PDWORD,PDWORD,PDWORD,LPWSTR,DWORD);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI GetVolumeNameForVolumeMountPointA(LPCSTR,LPSTR,DWORD);
+
+#if (_WIN32_WINNT >= 0x0500)
+
+BOOL
+WINAPI
+GetVolumeNameForVolumeMountPointA(
+  _In_ LPCSTR lpszVolumeMountPoint,
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumeName,
+  _In_ DWORD cchBufferLength);
+
 BOOL WINAPI GetVolumeNameForVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
-BOOL WINAPI GetVolumePathNameA(LPCSTR,LPSTR,DWORD);
+
+BOOL
+WINAPI
+GetVolumePathNameA(
+  _In_ LPCSTR lpszFileName,
+  _Out_writes_(cchBufferLength) LPSTR lpszVolumePathName,
+  _In_ DWORD cchBufferLength);
+
 BOOL WINAPI GetVolumePathNameW(LPCWSTR,LPWSTR,DWORD);
-#endif
-#if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI GetVolumePathNamesForVolumeNameA(LPCSTR,LPSTR,DWORD,PDWORD);
+
+#endif
+
+#if (_WIN32_WINNT >= 0x0501)
+
+BOOL
+WINAPI
+GetVolumePathNamesForVolumeNameA(
+  _In_ LPCSTR lpszVolumeName,
+  _Out_writes_to_opt_(cchBufferLength, *lpcchReturnLength) _Post_ _NullNull_terminated_
LPCH lpszVolumePathNames,
+  _In_ DWORD cchBufferLength,
+  _Out_ PDWORD lpcchReturnLength);
+
 BOOL WINAPI GetVolumePathNamesForVolumeNameW(LPCWSTR,LPWSTR,DWORD,PDWORD);
-#endif
+
+#endif
+
 UINT WINAPI GetWindowsDirectoryA(LPSTR,UINT);
 UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
 DWORD WINAPI GetWindowThreadProcessId(HWND,PDWORD);
 UINT WINAPI GetWriteWatch(DWORD,PVOID,SIZE_T,PVOID*,PULONG_PTR,PULONG);
-ATOM WINAPI GlobalAddAtomA(LPCSTR);
-ATOM WINAPI GlobalAddAtomW( LPCWSTR);
+ATOM WINAPI GlobalAddAtomA(_In_opt_ LPCSTR);
+ATOM WINAPI GlobalAddAtomW(_In_opt_ LPCWSTR);
 HGLOBAL WINAPI GlobalAlloc(UINT,SIZE_T);
-SIZE_T WINAPI GlobalCompact(DWORD); /* Obsolete: Has no effect. */
-ATOM WINAPI GlobalDeleteAtom(ATOM);
+SIZE_T WINAPI GlobalCompact(_In_ DWORD); /* Obsolete: Has no effect. */
+ATOM WINAPI GlobalDeleteAtom(_In_ ATOM);
 #define GlobalDiscard(m) GlobalReAlloc((m),0,GMEM_MOVEABLE)
-ATOM WINAPI GlobalFindAtomA(LPCSTR);
-ATOM WINAPI GlobalFindAtomW(LPCWSTR);
-VOID WINAPI GlobalFix(HGLOBAL); /* Obsolete: Has no effect. */
-UINT WINAPI GlobalFlags(HGLOBAL); /* Obsolete: Has no effect. */
+ATOM WINAPI GlobalFindAtomA(_In_opt_ LPCSTR);
+ATOM WINAPI GlobalFindAtomW(_In_opt_ LPCWSTR);
+VOID WINAPI GlobalFix(_In_ HGLOBAL); /* Obsolete: Has no effect. */
+UINT WINAPI GlobalFlags(_In_ HGLOBAL); /* Obsolete: Has no effect. */
 HGLOBAL WINAPI GlobalFree(HGLOBAL);
-UINT WINAPI GlobalGetAtomNameA(ATOM,LPSTR,int);
-UINT WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,int);
-HGLOBAL WINAPI GlobalHandle(LPCVOID);
-LPVOID WINAPI GlobalLock(HGLOBAL);
-VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
+
+UINT
+WINAPI
+GlobalGetAtomNameA(
+  _In_ ATOM nAtom,
+  _Out_writes_to_(nSize, return + 1) LPSTR lpBuffer,
+  _In_ int nSize);
+
+UINT
+WINAPI
+GlobalGetAtomNameW(
+  _In_ ATOM nAtom,
+  _Out_writes_to_(nSize, return + 1) LPWSTR lpBuffer,
+  _In_ int nSize);
+
+_Ret_maybenull_ HGLOBAL WINAPI GlobalHandle(_In_ LPCVOID);
+_Ret_maybenull_ LPVOID WINAPI GlobalLock(_In_ HGLOBAL);
+VOID WINAPI GlobalMemoryStatus(_Out_ LPMEMORYSTATUS);
 #if (_WIN32_WINNT >= 0x0500)
 BOOL WINAPI GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
 #endif
 HGLOBAL WINAPI GlobalReAlloc(HGLOBAL,SIZE_T,UINT);
-SIZE_T WINAPI GlobalSize(HGLOBAL);
-VOID WINAPI GlobalUnfix(HGLOBAL); /* Obsolete: Has no effect. */
-BOOL WINAPI GlobalUnlock(HGLOBAL);
-BOOL WINAPI GlobalUnWire(HGLOBAL); /* Obsolete: Has no effect. */
-PVOID WINAPI GlobalWire(HGLOBAL); /* Obsolete: Has no effect. */
+SIZE_T WINAPI GlobalSize(_In_ HGLOBAL);
+VOID WINAPI GlobalUnfix(_In_ HGLOBAL); /* Obsolete: Has no effect. */
+BOOL WINAPI GlobalUnlock(_In_ HGLOBAL);
+BOOL WINAPI GlobalUnWire(_In_ HGLOBAL); /* Obsolete: Has no effect. */
+PVOID WINAPI GlobalWire(_In_ HGLOBAL); /* Obsolete: Has no effect. */
 #define HasOverlappedIoCompleted(lpOverlapped)  ((lpOverlapped)->Internal !=
STATUS_PENDING)
 PVOID WINAPI HeapAlloc(HANDLE,DWORD,SIZE_T);
 SIZE_T WINAPI HeapCompact(HANDLE,DWORD);
@@ -1807,7 +2313,7 @@
 BOOL WINAPI ImpersonateLoggedOnUser(HANDLE);
 BOOL WINAPI ImpersonateNamedPipeClient(HANDLE);
 BOOL WINAPI ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
-BOOL WINAPI InitAtomTable(DWORD);
+BOOL WINAPI InitAtomTable(_In_ DWORD);
 BOOL WINAPI InitializeAcl(PACL,DWORD,DWORD);
 #if (_WIN32_WINNT >= 0x0600)
 VOID WINAPI InitializeConditionVariable(PCONDITION_VARIABLE);
@@ -1957,20 +2463,27 @@
 
 #endif /* __INTERLOCKED_DECLARED */
 
-BOOL WINAPI IsBadCodePtr(FARPROC);
-BOOL WINAPI IsBadHugeReadPtr(CONST VOID*,UINT_PTR);
-BOOL WINAPI IsBadHugeWritePtr(PVOID,UINT_PTR);
-BOOL WINAPI IsBadReadPtr(CONST VOID*,UINT_PTR);
-BOOL WINAPI IsBadStringPtrA(LPCSTR,UINT_PTR);
-BOOL WINAPI IsBadStringPtrW(LPCWSTR,UINT_PTR);
-BOOL WINAPI IsBadWritePtr(PVOID,UINT_PTR);
+BOOL WINAPI IsBadCodePtr(_In_opt_ FARPROC);
+BOOL WINAPI IsBadHugeReadPtr(_In_opt_ CONST VOID*, _In_ UINT_PTR);
+BOOL WINAPI IsBadHugeWritePtr(_In_opt_ PVOID, _In_ UINT_PTR);
+BOOL WINAPI IsBadReadPtr(_In_opt_ CONST VOID*, _In_ UINT_PTR);
+BOOL WINAPI IsBadStringPtrA(_In_opt_ LPCSTR, _In_ UINT_PTR);
+BOOL WINAPI IsBadStringPtrW(_In_opt_ LPCWSTR, _In_ UINT_PTR);
+BOOL WINAPI IsBadWritePtr(_In_opt_ PVOID, _In_ UINT_PTR);
 BOOL WINAPI IsDebuggerPresent(void);
 #if (_WIN32_WINNT >= 0x0501)
 BOOL WINAPI IsProcessInJob(HANDLE,HANDLE,PBOOL);
 #endif
 BOOL WINAPI IsProcessorFeaturePresent(DWORD);
 BOOL WINAPI IsSystemResumeAutomatic(void);
-BOOL WINAPI IsTextUnicode(CONST VOID*,int,LPINT);
+
+BOOL
+WINAPI
+IsTextUnicode(
+  _In_reads_bytes_(iSize) CONST VOID *lpv,
+  _In_ int iSize,
+  _Inout_opt_ LPINT lpiResult);
+
 #if (_WIN32_WINNT >= 0x0600)
 BOOL WINAPI IsThreadAFiber(VOID);
 #endif
@@ -1983,50 +2496,151 @@
 #endif
 void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION);
 #define LimitEmsPages(n)
-HINSTANCE WINAPI LoadLibraryA(LPCSTR);
+_Ret_maybenull_ HINSTANCE WINAPI LoadLibraryA(_In_ LPCSTR);
+_Ret_maybenull_ HINSTANCE WINAPI LoadLibraryW(_In_ LPCWSTR);
 HINSTANCE WINAPI LoadLibraryExA(LPCSTR,HANDLE,DWORD);
 HINSTANCE WINAPI LoadLibraryExW(LPCWSTR,HANDLE,DWORD);
-HINSTANCE WINAPI LoadLibraryW(LPCWSTR);
-DWORD WINAPI LoadModule(LPCSTR,PVOID);
+DWORD WINAPI LoadModule(_In_ LPCSTR, _In_ PVOID);
 HGLOBAL WINAPI LoadResource(HINSTANCE,HRSRC);
 HLOCAL WINAPI LocalAlloc(UINT,SIZE_T);
-SIZE_T WINAPI LocalCompact(UINT); /* Obsolete: Has no effect. */
+SIZE_T WINAPI LocalCompact(_In_ UINT); /* Obsolete: Has no effect. */
 #define LocalDiscard(m) (LocalReAlloc((m),0,LMEM_MOVEABLE))
 BOOL WINAPI LocalFileTimeToFileTime(CONST FILETIME *,LPFILETIME);
-UINT WINAPI LocalFlags(HLOCAL); /* Obsolete: Has no effect. */
+UINT WINAPI LocalFlags(_In_ HLOCAL); /* Obsolete: Has no effect. */
 HLOCAL WINAPI LocalFree(HLOCAL);
-HLOCAL WINAPI LocalHandle(LPCVOID);
+_Ret_maybenull_ HLOCAL WINAPI LocalHandle(_In_ LPCVOID);
 PVOID WINAPI LocalLock(HLOCAL);
 HLOCAL WINAPI LocalReAlloc(HLOCAL,SIZE_T,UINT);
-SIZE_T WINAPI LocalShrink(HLOCAL,UINT);  /* Obsolete: Has no effect. */
-SIZE_T WINAPI LocalSize(HLOCAL);
+SIZE_T WINAPI LocalShrink(_In_ HLOCAL, _In_ UINT);  /* Obsolete: Has no effect. */
+SIZE_T WINAPI LocalSize(_In_ HLOCAL);
 BOOL WINAPI LocalUnlock(HLOCAL);
 BOOL WINAPI LockFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
 BOOL WINAPI LockFileEx(HANDLE,DWORD,DWORD,DWORD,DWORD,LPOVERLAPPED);
 PVOID WINAPI LockResource(HGLOBAL);
 #define LockSegment(w) GlobalFix((HANDLE)(w)) /* Obsolete: Has no effect. */
-BOOL WINAPI LogonUserA(LPSTR,LPSTR,LPSTR,DWORD,DWORD,PHANDLE);
-BOOL WINAPI LogonUserW(LPWSTR,LPWSTR,LPWSTR,DWORD,DWORD,PHANDLE);
-BOOL WINAPI LookupAccountNameA(LPCSTR,LPCSTR,PSID,PDWORD,LPSTR,PDWORD,PSID_NAME_USE);
-BOOL WINAPI LookupAccountNameW(LPCWSTR,LPCWSTR,PSID,PDWORD,LPWSTR,PDWORD,PSID_NAME_USE);
-BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPSTR,PDWORD,LPSTR,PDWORD,PSID_NAME_USE);
-BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPWSTR,PDWORD,LPWSTR,PDWORD,PSID_NAME_USE);
-BOOL WINAPI LookupPrivilegeDisplayNameA(LPCSTR,LPCSTR,LPSTR,PDWORD,PDWORD);
-BOOL WINAPI LookupPrivilegeDisplayNameW(LPCWSTR,LPCWSTR,LPWSTR,PDWORD,PDWORD);
-BOOL WINAPI LookupPrivilegeNameA(LPCSTR,PLUID,LPSTR,PDWORD);
-BOOL WINAPI LookupPrivilegeNameW(LPCWSTR,PLUID,LPWSTR,PDWORD);
-BOOL WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,PLUID);
-BOOL WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,PLUID);
-LPSTR WINAPI lstrcatA(LPSTR,LPCSTR);
-LPWSTR WINAPI lstrcatW(LPWSTR,LPCWSTR);
+BOOL WINAPI LogonUserA(_In_ LPSTR, _In_opt_ LPSTR, _In_opt_ LPSTR, _In_ DWORD, _In_
DWORD, _Outptr_ PHANDLE);
+BOOL WINAPI LogonUserW(_In_ LPWSTR, _In_opt_ LPWSTR, _In_opt_ LPWSTR, _In_ DWORD, _In_
DWORD, _Outptr_ PHANDLE);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupAccountNameA(
+  _In_opt_ LPCSTR lpSystemName,
+  _In_ LPCSTR lpAccountName,
+  _Out_writes_bytes_to_opt_(*cbSid, *cbSid) PSID Sid,
+  _Inout_ LPDWORD cbSid,
+  _Out_writes_to_opt_(*cchReferencedDomainName, *cchReferencedDomainName + 1) LPSTR
ReferencedDomainName,
+  _Inout_ LPDWORD cchReferencedDomainName,
+  _Out_ PSID_NAME_USE peUse);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupAccountNameW(
+  _In_opt_ LPCWSTR lpSystemName,
+  _In_ LPCWSTR lpAccountName,
+  _Out_writes_bytes_to_opt_(*cbSid, *cbSid) PSID Sid,
+  _Inout_ LPDWORD cbSid,
+  _Out_writes_to_opt_(*cchReferencedDomainName, *cchReferencedDomainName + 1) LPWSTR
ReferencedDomainName,
+  _Inout_ LPDWORD cchReferencedDomainName,
+  _Out_ PSID_NAME_USE peUse);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupAccountSidA(
+  _In_opt_ LPCSTR lpSystemName,
+  _In_ PSID Sid,
+  _Out_writes_to_opt_(*cchName, *cchName + 1) LPSTR Name,
+  _Inout_ LPDWORD cchName,
+  _Out_writes_to_opt_(*cchReferencedDomainName, *cchReferencedDomainName + 1) LPSTR
ReferencedDomainName,
+  _Inout_ LPDWORD cchReferencedDomainName,
+  _Out_ PSID_NAME_USE peUse);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupAccountSidW(
+  _In_opt_ LPCWSTR lpSystemName,
+  _In_ PSID Sid,
+  _Out_writes_to_opt_(*cchName, *cchName + 1) LPWSTR Name,
+  _Inout_  LPDWORD cchName,
+  _Out_writes_to_opt_(*cchReferencedDomainName, *cchReferencedDomainName + 1) LPWSTR
ReferencedDomainName,
+  _Inout_ LPDWORD cchReferencedDomainName,
+  _Out_ PSID_NAME_USE peUse);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupPrivilegeDisplayNameA(
+  _In_opt_ LPCSTR lpSystemName,
+  _In_ LPCSTR lpName,
+  _Out_writes_to_opt_(*cchDisplayName, *cchDisplayName + 1) LPSTR lpDisplayName,
+  _Inout_ LPDWORD cchDisplayName,
+  _Out_ LPDWORD lpLanguageId);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupPrivilegeDisplayNameW(
+  _In_opt_ LPCWSTR lpSystemName,
+  _In_ LPCWSTR lpName,
+  _Out_writes_to_opt_(*cchDisplayName, *cchDisplayName + 1) LPWSTR lpDisplayName,
+  _Inout_ LPDWORD cchDisplayName,
+  _Out_ LPDWORD lpLanguageId);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupPrivilegeNameA(
+  _In_opt_ LPCSTR lpSystemName,
+  _In_ PLUID lpLuid,
+  _Out_writes_to_opt_(*cchName, *cchName + 1) LPSTR lpName,
+  _Inout_ LPDWORD cchName);
+
+_Success_(return != FALSE)
+BOOL
+WINAPI
+LookupPrivilegeNameW(
+  _In_opt_ LPCWSTR lpSystemName,
+  _In_ PLUID lpLuid,
+  _Out_writes_to_opt_(*cchName, *cchName + 1) LPWSTR lpName,
+  _Inout_ LPDWORD cchName);
+
+BOOL WINAPI LookupPrivilegeValueA(_In_opt_ LPCSTR, _In_ LPCSTR, _Out_ PLUID);
+BOOL WINAPI LookupPrivilegeValueW(_In_opt_ LPCWSTR, _In_ LPCWSTR, _Out_ PLUID);
+
+LPSTR
+WINAPI
+lstrcatA(
+  _Inout_updates_z_(_String_length_(lpString1) + _String_length_(lpString2) + 1) LPSTR
lpString1,
+  _In_ LPCSTR lpString2);
+
+LPWSTR
+WINAPI
+lstrcatW(
+  _Inout_updates_z_(_String_length_(lpString1) + _String_length_(lpString2) + 1) LPWSTR
lpString1,
+  _In_ LPCWSTR lpString2);
+
 int WINAPI lstrcmpA(LPCSTR,LPCSTR);
 int WINAPI lstrcmpiA(LPCSTR,LPCSTR);
 int WINAPI lstrcmpiW( LPCWSTR,LPCWSTR);
 int WINAPI lstrcmpW(LPCWSTR,LPCWSTR);
-LPSTR WINAPI lstrcpyA(LPSTR,LPCSTR);
+
+LPSTR
+WINAPI
+lstrcpyA(
+  _Out_writes_(_String_length_(lpString2) + 1) LPSTR lpString1,
+  _In_ LPCSTR lpString2);
+
+LPWSTR
+WINAPI
+lstrcpyW(
+  _Out_writes_(_String_length_(lpString2) + 1) LPWSTR lpString1,
+  _In_ LPCWSTR lpString2);
+
 LPSTR WINAPI lstrcpynA(LPSTR,LPCSTR,int);
 LPWSTR WINAPI lstrcpynW(LPWSTR,LPCWSTR,int);
-LPWSTR WINAPI lstrcpyW(LPWSTR,LPCWSTR);
 int WINAPI lstrlenA(LPCSTR);
 int WINAPI lstrlenW(LPCWSTR);
 BOOL WINAPI
MakeAbsoluteSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,PDWORD,PACL,PDWORD,PACL,PDWORD,PSID,PDWORD,PSID,PDWORD);
@@ -2035,61 +2649,78 @@
 VOID WINAPI MapGenericMask(PDWORD,PGENERIC_MAPPING);
 PVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,SIZE_T);
 PVOID WINAPI MapViewOfFileEx(HANDLE,DWORD,DWORD,DWORD,SIZE_T,PVOID);
-BOOL WINAPI MoveFileA(LPCSTR,LPCSTR);
-BOOL WINAPI MoveFileExA(LPCSTR,LPCSTR,DWORD);
-BOOL WINAPI MoveFileExW(LPCWSTR,LPCWSTR,DWORD);
-BOOL WINAPI MoveFileW(LPCWSTR,LPCWSTR);
-int WINAPI MulDiv(int,int,int);
-BOOL WINAPI NotifyChangeEventLog(HANDLE,HANDLE);
-BOOL WINAPI ObjectCloseAuditAlarmA(LPCSTR,PVOID,BOOL);
+BOOL WINAPI MoveFileA(_In_ LPCSTR, _In_ LPCSTR);
+BOOL WINAPI MoveFileW(_In_ LPCWSTR, _In_ LPCWSTR);
+BOOL WINAPI MoveFileExA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD);
+BOOL WINAPI MoveFileExW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ DWORD);
+int WINAPI MulDiv(_In_ int, _In_ int, _In_ int);
+BOOL WINAPI NotifyChangeEventLog(_In_ HANDLE, _In_ HANDLE);
+BOOL WINAPI ObjectCloseAuditAlarmA(_In_ LPCSTR, _In_ PVOID, _In_ BOOL);
 BOOL WINAPI ObjectCloseAuditAlarmW(LPCWSTR,PVOID,BOOL);
-BOOL WINAPI ObjectDeleteAuditAlarmA(LPCSTR,PVOID,BOOL);
+BOOL WINAPI ObjectDeleteAuditAlarmA(_In_ LPCSTR, _In_ PVOID, _In_ BOOL);
 BOOL WINAPI ObjectDeleteAuditAlarmW(LPCWSTR,PVOID,BOOL);
-BOOL WINAPI
ObjectOpenAuditAlarmA(LPCSTR,PVOID,LPSTR,LPSTR,PSECURITY_DESCRIPTOR,HANDLE,DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,PBOOL);
+BOOL WINAPI ObjectOpenAuditAlarmA(_In_ LPCSTR, _In_ PVOID, _In_ LPSTR, _In_opt_ LPSTR,
_In_ PSECURITY_DESCRIPTOR, _In_ HANDLE, _In_ DWORD, _In_ DWORD, _In_opt_ PPRIVILEGE_SET,
_In_ BOOL, _In_ BOOL, _Out_ PBOOL);
 BOOL WINAPI
ObjectOpenAuditAlarmW(LPCWSTR,PVOID,LPWSTR,LPWSTR,PSECURITY_DESCRIPTOR,HANDLE,DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,PBOOL);
-BOOL WINAPI ObjectPrivilegeAuditAlarmA(LPCSTR,PVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
+BOOL WINAPI ObjectPrivilegeAuditAlarmA(_In_ LPCSTR, _In_ PVOID, _In_ HANDLE, _In_ DWORD,
_In_ PPRIVILEGE_SET, _In_ BOOL);
 BOOL WINAPI ObjectPrivilegeAuditAlarmW(LPCWSTR,PVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
-HANDLE WINAPI OpenBackupEventLogA(LPCSTR,LPCSTR);
-HANDLE WINAPI OpenBackupEventLogW(LPCWSTR,LPCWSTR);
+HANDLE WINAPI OpenBackupEventLogA(_In_opt_ LPCSTR, _In_ LPCSTR);
+HANDLE WINAPI OpenBackupEventLogW(_In_opt_ LPCWSTR, _In_ LPCWSTR);
 HANDLE WINAPI OpenEventA(DWORD,BOOL,LPCSTR);
-HANDLE WINAPI OpenEventLogA (LPCSTR,LPCSTR);
-HANDLE WINAPI OpenEventLogW(LPCWSTR,LPCWSTR);
+HANDLE WINAPI OpenEventLogA(_In_opt_ LPCSTR, _In_ LPCSTR);
+HANDLE WINAPI OpenEventLogW(_In_opt_ LPCWSTR, _In_ LPCWSTR);
 HANDLE WINAPI OpenEventW(DWORD,BOOL,LPCWSTR);
-HFILE WINAPI OpenFile(LPCSTR,LPOFSTRUCT,UINT);
+HFILE WINAPI OpenFile(_In_ LPCSTR, _Inout_ LPOFSTRUCT, _In_ UINT);
 #if (_WIN32_WINNT >= 0x0600)
-HANDLE WINAPI
OpenFileById(HANDLE,LPFILE_ID_DESCRIPTOR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD);
-#endif
-HANDLE WINAPI OpenFileMappingA(DWORD,BOOL,LPCSTR);
+HANDLE WINAPI OpenFileById(_In_ HANDLE, _In_ LPFILE_ID_DESCRIPTOR, _In_ DWORD, _In_
DWORD, _In_opt_ LPSECURITY_ATTRIBUTES, _In_ DWORD);
+#endif
+HANDLE WINAPI OpenFileMappingA(_In_ DWORD, _In_ BOOL, _In_ LPCSTR);
 HANDLE WINAPI OpenFileMappingW(DWORD,BOOL,LPCWSTR);
-HANDLE WINAPI OpenMutexA(DWORD,BOOL,LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI OpenMutexA(_In_ DWORD, _In_ BOOL, _In_ LPCSTR);
 HANDLE WINAPI OpenMutexW(DWORD,BOOL,LPCWSTR);
 HANDLE WINAPI OpenProcess(DWORD,BOOL,DWORD);
 BOOL WINAPI OpenProcessToken(HANDLE,DWORD,PHANDLE);
-HANDLE WINAPI OpenSemaphoreA(DWORD,BOOL,LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI OpenSemaphoreA(_In_ DWORD, _In_ BOOL, _In_ LPCSTR);
 HANDLE WINAPI OpenSemaphoreW(DWORD,BOOL,LPCWSTR);
 #if (_WIN32_WINNT >= 0x0500) || (_WIN32_WINDOWS >= 0x0490)
 HANDLE WINAPI OpenThread(DWORD,BOOL,DWORD);
 #endif
 BOOL WINAPI OpenThreadToken(HANDLE,DWORD,BOOL,PHANDLE);
-HANDLE WINAPI OpenWaitableTimerA(DWORD,BOOL,LPCSTR);
+_Ret_maybenull_ HANDLE WINAPI OpenWaitableTimerA(_In_ DWORD, _In_ BOOL, _In_ LPCSTR);
 HANDLE WINAPI OpenWaitableTimerW(DWORD,BOOL,LPCWSTR);
 WINBASEAPI void WINAPI OutputDebugStringA(LPCSTR);
 WINBASEAPI void WINAPI OutputDebugStringW(LPCWSTR);
 BOOL WINAPI PeekNamedPipe(HANDLE,PVOID,DWORD,PDWORD,PDWORD,PDWORD);
 BOOL WINAPI PostQueuedCompletionStatus(HANDLE,DWORD,ULONG_PTR,LPOVERLAPPED);
-DWORD WINAPI PrepareTape(HANDLE,DWORD,BOOL);
+DWORD WINAPI PrepareTape(_In_ HANDLE, _In_ DWORD, _In_ BOOL);
 BOOL WINAPI PrivilegeCheck (HANDLE,PPRIVILEGE_SET,PBOOL);
-BOOL WINAPI PrivilegedServiceAuditAlarmA(LPCSTR,LPCSTR,HANDLE,PPRIVILEGE_SET,BOOL);
+BOOL WINAPI PrivilegedServiceAuditAlarmA(_In_ LPCSTR, _In_ LPCSTR, _In_ HANDLE, _In_
PPRIVILEGE_SET, _In_ BOOL);
 BOOL WINAPI PrivilegedServiceAuditAlarmW(LPCWSTR,LPCWSTR,HANDLE,PPRIVILEGE_SET,BOOL);
 #if (_WIN32_WINNT >= 0x0500)
 BOOL WINAPI ProcessIdToSessionId(DWORD,DWORD*);
 #endif
 BOOL WINAPI PulseEvent(HANDLE);
-BOOL WINAPI PurgeComm(HANDLE,DWORD);
-#if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI QueryActCtxW(DWORD,HANDLE,PVOID,ULONG,PVOID,SIZE_T,SIZE_T*);
-#endif
-DWORD WINAPI QueryDosDeviceA(LPCSTR,LPSTR,DWORD);
+BOOL WINAPI PurgeComm(_In_ HANDLE, _In_ DWORD);
+
+#if (_WIN32_WINNT >= 0x0501)
+BOOL
+WINAPI
+QueryActCtxW(
+  _In_ DWORD dwFlags,
+  _In_ HANDLE hActCtx,
+  _In_opt_ PVOID pvSubInstance,
+  _In_ ULONG ulInfoClass,
+  _Out_writes_bytes_to_opt_(cbBuffer, *pcbWrittenOrRequired) PVOID pvBuffer,
+  _In_ SIZE_T cbBuffer,
+  _Out_opt_ SIZE_T *pcbWrittenOrRequired);
+#endif
+
+DWORD
+WINAPI
+QueryDosDeviceA(
+  _In_opt_ LPCSTR lpDeviceName,
+  _Out_writes_to_opt_(ucchMax, return) LPSTR lpTargetPath,
+  _In_ DWORD ucchMax);
+
 DWORD WINAPI QueryDosDeviceW(LPCWSTR,LPWSTR,DWORD);
 #if (_WIN32_WINNT >= 0x0501)
 BOOL WINAPI QueryMemoryResourceNotification(HANDLE,PBOOL);
@@ -2104,9 +2735,41 @@
 BOOL WINAPI QueueUserWorkItem(LPTHREAD_START_ROUTINE,PVOID,ULONG);
 #endif
 void WINAPI RaiseException(DWORD,DWORD,DWORD,const ULONG_PTR*);
-BOOL WINAPI
ReadDirectoryChangesW(HANDLE,PVOID,DWORD,BOOL,DWORD,PDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
-BOOL WINAPI ReadEventLogA(HANDLE,DWORD,DWORD,PVOID,DWORD,DWORD *,DWORD *);
-BOOL WINAPI ReadEventLogW(HANDLE,DWORD,DWORD,PVOID,DWORD,DWORD *,DWORD *);
+
+BOOL
+WINAPI
+ReadDirectoryChangesW(
+  _In_ HANDLE hDirectory,
+  _Out_writes_bytes_to_(nBufferLength, *lpBytesReturned) LPVOID lpBuffer,
+  _In_ DWORD nBufferLength,
+  _In_ BOOL bWatchSubtree,
+  _In_ DWORD dwNotifyFilter,
+  _Out_opt_ LPDWORD lpBytesReturned,
+  _Inout_opt_ LPOVERLAPPED lpOverlapped,
+  _In_opt_ LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
+
+BOOL
+WINAPI
+ReadEventLogA(
+  _In_ HANDLE hEventLog,
+  _In_ DWORD dwReadFlags,
+  _In_ DWORD dwRecordOffset,
+  _Out_writes_bytes_to_(nNumberOfBytesToRead, *pnBytesRead) LPVOID lpBuffer,
+  _In_ DWORD nNumberOfBytesToRead,
+  _Out_ DWORD *pnBytesRead,
+  _Out_ DWORD *pnMinNumberOfBytesNeeded);
+
+BOOL
+WINAPI
+ReadEventLogW(
+  _In_ HANDLE hEventLog,
+  _In_ DWORD dwReadFlags,
+  _In_ DWORD dwRecordOffset,
+  _Out_writes_bytes_to_(nNumberOfBytesToRead, *pnBytesRead) LPVOID lpBuffer,
+  _In_ DWORD nNumberOfBytesToRead,
+  _Out_ DWORD *pnBytesRead,
+  _Out_ DWORD *pnMinNumberOfBytesNeeded);
+
 BOOL WINAPI ReadFile(HANDLE,PVOID,DWORD,PDWORD,LPOVERLAPPED);
 BOOL WINAPI ReadFileEx(HANDLE,PVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
 BOOL WINAPI ReadFileScatter(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
@@ -2114,17 +2777,17 @@
 #if (_WIN32_WINNT >= 0x0600)
 VOID WINAPI RecoveryFinished(BOOL);
 HRESULT WINAPI RecoveryInProgress(OUT PBOOL);
-HRESULT WINAPI RegisterApplicationRecoveryCallback(APPLICATION_RECOVERY_CALLBACK,PVOID,
DWORD, DWORD);
-HRESULT WINAPI RegisterApplicationRestart(PCWSTR,DWORD);
-#endif
-HANDLE WINAPI RegisterEventSourceA (LPCSTR,LPCSTR);
-HANDLE WINAPI RegisterEventSourceW(LPCWSTR,LPCWSTR);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI
RegisterWaitForSingleObject(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
+HRESULT WINAPI RegisterApplicationRecoveryCallback(_In_ APPLICATION_RECOVERY_CALLBACK,
_In_opt_ PVOID, _In_ DWORD, _In_ DWORD);
+HRESULT WINAPI RegisterApplicationRestart(_In_opt_ PCWSTR, _In_ DWORD);
+#endif
+HANDLE WINAPI RegisterEventSourceA(_In_opt_ LPCSTR, _In_ LPCSTR);
+HANDLE WINAPI RegisterEventSourceW(_In_opt_ LPCWSTR, _In_ LPCWSTR);
+#if (_WIN32_WINNT >= 0x0500)
+BOOL WINAPI RegisterWaitForSingleObject(_Outptr_ PHANDLE, _In_ HANDLE, _In_
WAITORTIMERCALLBACK, _In_opt_ PVOID, _In_ ULONG, _In_ ULONG);
 HANDLE WINAPI
RegisterWaitForSingleObjectEx(HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
 #endif
 #if (_WIN32_WINNT >= 0x0501)
-void WINAPI ReleaseActCtx(HANDLE);
+void WINAPI ReleaseActCtx(_Inout_ HANDLE);
 #endif
 BOOL WINAPI ReleaseMutex(HANDLE);
 BOOL WINAPI ReleaseSemaphore(HANDLE,LONG,LPLONG);
@@ -2135,42 +2798,98 @@
 BOOL WINAPI RemoveDirectoryA(LPCSTR);
 BOOL WINAPI RemoveDirectoryW(LPCWSTR);
 #if (_WIN32_WINNT >= 0x0500)
-ULONG WINAPI RemoveVectoredExceptionHandler(PVOID);
-#endif
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI ReplaceFileA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPVOID,LPVOID);
-BOOL WINAPI ReplaceFileW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPVOID,LPVOID);
-#endif
-BOOL WINAPI ReportEventA(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCSTR*,PVOID);
-BOOL WINAPI ReportEventW(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCWSTR*,PVOID);
+ULONG WINAPI RemoveVectoredExceptionHandler(_In_ PVOID);
+#endif
+#if (_WIN32_WINNT >= 0x0500)
+BOOL WINAPI ReplaceFileA(_In_ LPCSTR, _In_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD,
_Reserved_ LPVOID, _Reserved_ LPVOID);
+BOOL WINAPI ReplaceFileW(_In_ LPCWSTR, _In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ DWORD,
_Reserved_ LPVOID, _Reserved_ LPVOID);
+#endif
+
+BOOL
+WINAPI
+ReportEventA(
+  _In_ HANDLE hEventLog,
+  _In_ WORD wType,
+  _In_ WORD wCategory,
+  _In_ DWORD dwEventID,
+  _In_opt_ PSID lpUserSid,
+  _In_ WORD wNumStrings,
+  _In_ DWORD dwDataSize,
+  _In_reads_opt_(wNumStrings) LPCSTR *lpStrings,
+  _In_reads_bytes_opt_(dwDataSize) LPVOID lpRawData);
+
+BOOL
+WINAPI
+ReportEventW(
+  _In_ HANDLE hEventLog,
+  _In_ WORD wType,
+  _In_ WORD wCategory,
+  _In_ DWORD dwEventID,
+  _In_opt_ PSID lpUserSid,
+  _In_ WORD wNumStrings,
+  _In_ DWORD dwDataSize,
+  _In_reads_opt_(wNumStrings) LPCWSTR *lpStrings,
+  _In_reads_bytes_opt_(dwDataSize) LPVOID lpRawData);
+
 BOOL WINAPI ResetEvent(HANDLE);
 UINT WINAPI ResetWriteWatch(LPVOID,SIZE_T);
 #if (_WIN32_WINNT >= 0x0510)
-VOID WINAPI RestoreLastError(DWORD);
+VOID WINAPI RestoreLastError(_In_ DWORD);
 #endif
 DWORD WINAPI ResumeThread(HANDLE);
 BOOL WINAPI RevertToSelf(void);
-DWORD WINAPI SearchPathA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPSTR,LPSTR*);
+
+_Success_(return != 0 && return < nBufferLength)
+DWORD
+WINAPI
+SearchPathA(
+  _In_opt_ LPCSTR lpPath,
+  _In_ LPCSTR lpFileName,
+  _In_opt_ LPCSTR lpExtension,
+  _In_ DWORD nBufferLength,
+  _Out_writes_to_opt_(nBufferLength, return + 1) LPSTR lpBuffer,
+  _Out_opt_ LPSTR *lpFilePart);
+
 DWORD WINAPI SearchPathW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPWSTR,LPWSTR*);
 BOOL WINAPI SetAclInformation(PACL,PVOID,DWORD,ACL_INFORMATION_CLASS);
-BOOL WINAPI SetCommBreak(HANDLE);
-BOOL WINAPI SetCommConfig(HANDLE,LPCOMMCONFIG,DWORD);
-BOOL WINAPI SetCommMask(HANDLE,DWORD);
-BOOL WINAPI SetCommState(HANDLE,LPDCB);
-BOOL WINAPI SetCommTimeouts(HANDLE,LPCOMMTIMEOUTS);
-BOOL WINAPI SetComputerNameA(LPCSTR);
-BOOL WINAPI SetComputerNameW(LPCWSTR);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT,LPCSTR);
+BOOL WINAPI SetCommBreak(_In_ HANDLE);
+
+BOOL
+WINAPI
+SetCommConfig(
+  _In_ HANDLE hCommDev,
+  _In_reads_bytes_(dwSize) LPCOMMCONFIG lpCC,
+  _In_ DWORD dwSize);
+
+BOOL WINAPI SetCommMask(_In_ HANDLE, _In_ DWORD);
+BOOL WINAPI SetCommState(_In_ HANDLE, _In_ LPDCB);
+BOOL WINAPI SetCommTimeouts(_In_ HANDLE, _In_ LPCOMMTIMEOUTS);
+BOOL WINAPI SetComputerNameA(_In_ LPCSTR);
+BOOL WINAPI SetComputerNameW(_In_ LPCWSTR);
+#if (_WIN32_WINNT >= 0x0500)
+BOOL WINAPI SetComputerNameExA(_In_ COMPUTER_NAME_FORMAT, _In_ LPCSTR);
 BOOL WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT,LPCWSTR);
 #endif
 BOOL WINAPI SetCurrentDirectoryA(LPCSTR);
 BOOL WINAPI SetCurrentDirectoryW(LPCWSTR);
-BOOL WINAPI SetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,DWORD);
-BOOL WINAPI SetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,DWORD);
+
+BOOL
+WINAPI
+SetDefaultCommConfigA(
+  _In_ LPCSTR lpszName,
+  _In_reads_bytes_(dwSize) LPCOMMCONFIG lpCC,
+  _In_ DWORD dwSize);
+
+BOOL
+WINAPI
+SetDefaultCommConfigW(
+  _In_ LPCWSTR lpszName,
+  _In_reads_bytes_(dwSize) LPCOMMCONFIG lpCC,
+  _In_ DWORD dwSize);
+
 #if (_WIN32_WINNT >= 0x0502)
-BOOL WINAPI SetDllDirectoryA(LPCSTR);
-BOOL WINAPI SetDllDirectoryW(LPCWSTR);
+BOOL WINAPI SetDllDirectoryA(_In_opt_ LPCSTR);
+BOOL WINAPI SetDllDirectoryW(_In_opt_ LPCWSTR);
 #endif
 BOOL WINAPI SetEndOfFile(HANDLE);
 BOOL WINAPI SetEnvironmentVariableA(LPCSTR,LPCSTR);
@@ -2185,39 +2904,56 @@
 #endif
 BOOL WINAPI SetFileAttributesW(LPCWSTR,DWORD);
 #if (_WIN32_WINNT >= 0x0600)
-BOOL WINAPI SetFileBandwidthReservation(HANDLE,DWORD,DWORD,BOOL,LPDWORD,LPDWORD);
-BOOL WINAPI SetFileCompletionNotificationModes(HANDLE,UCHAR);
+BOOL WINAPI SetFileBandwidthReservation(_In_ HANDLE, _In_ DWORD, _In_ DWORD, _In_ BOOL,
_Out_ LPDWORD, _Out_ LPDWORD);
+BOOL WINAPI SetFileCompletionNotificationModes(_In_ HANDLE, _In_ UCHAR);
 #endif
 DWORD WINAPI SetFilePointer(HANDLE,LONG,PLONG,DWORD);
 BOOL WINAPI SetFilePointerEx(HANDLE,LARGE_INTEGER,PLARGE_INTEGER,DWORD);
-BOOL WINAPI SetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
+BOOL WINAPI SetFileSecurityA(_In_ LPCSTR, _In_ SECURITY_INFORMATION, _In_
PSECURITY_DESCRIPTOR);
 BOOL WINAPI SetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI SetFileShortNameA(HANDLE,LPCSTR);
-BOOL WINAPI SetFileShortNameW(HANDLE,LPCWSTR);
+BOOL WINAPI SetFileShortNameA(_In_ HANDLE, _In_ LPCSTR);
+BOOL WINAPI SetFileShortNameW(_In_ HANDLE, _In_ LPCWSTR);
 #endif
 BOOL WINAPI SetFileTime(HANDLE,const FILETIME*,const FILETIME*,const FILETIME*);
 #if (_WIN32_WINNT >= 0x0501)
 BOOL WINAPI SetFileValidData(HANDLE,LONGLONG);
 #endif
+
 #if (_WIN32_WINNT >= 0x0502)
-BOOL WINAPI SetFirmwareEnvironmentVariableA(LPCSTR,LPCSTR,PVOID,DWORD);
-BOOL WINAPI SetFirmwareEnvironmentVariableW(LPCWSTR,LPCWSTR,PVOID,DWORD);
-#endif
+
+BOOL
+WINAPI
+SetFirmwareEnvironmentVariableA(
+  _In_ LPCSTR lpName,
+  _In_ LPCSTR lpGuid,
+  _In_reads_bytes_opt_(nSize) PVOID pValue,
+  _In_ DWORD nSize);
+
+BOOL
+WINAPI
+SetFirmwareEnvironmentVariableW(
+  _In_ LPCWSTR lpName,
+  _In_ LPCWSTR lpGuid,
+  _In_reads_bytes_opt_(nSize) PVOID pValue,
+  _In_ DWORD nSize);
+
+#endif
+
 UINT WINAPI SetHandleCount(UINT);
 BOOL WINAPI SetHandleInformation(HANDLE,DWORD,DWORD);
 BOOL WINAPI SetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 void WINAPI SetLastError(DWORD);
 void WINAPI SetLastErrorEx(DWORD,DWORD);
 BOOL WINAPI SetLocalTime(const SYSTEMTIME*);
-BOOL WINAPI SetMailslotInfo(HANDLE,DWORD);
+BOOL WINAPI SetMailslotInfo(_In_ HANDLE, _In_ DWORD);
 BOOL WINAPI SetNamedPipeHandleState(HANDLE,PDWORD,PDWORD,PDWORD);
 BOOL WINAPI SetPriorityClass(HANDLE,DWORD);
 BOOL WINAPI
SetPrivateObjectSecurity(SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR
*,PGENERIC_MAPPING,HANDLE);
-BOOL WINAPI SetProcessAffinityMask(HANDLE,DWORD_PTR);
-BOOL WINAPI SetProcessPriorityBoost(HANDLE,BOOL);
+BOOL WINAPI SetProcessAffinityMask(_In_ HANDLE, _In_ DWORD_PTR);
+BOOL WINAPI SetProcessPriorityBoost(_In_ HANDLE, _In_ BOOL);
 BOOL WINAPI SetProcessShutdownParameters(DWORD,DWORD);
-BOOL WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
+BOOL WINAPI SetProcessWorkingSetSize(_In_ HANDLE, _In_ SIZE_T, _In_ SIZE_T);
 #if (_WIN32_WINNT >= 0x0600)
 VOID WINAPI SetSecurityAccessMask(SECURITY_INFORMATION,LPDWORD);
 #endif
@@ -2229,29 +2965,29 @@
 BOOL WINAPI SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
 BOOL WINAPI SetStdHandle(DWORD,HANDLE);
 #define SetSwapAreaSize(w) (w)
-BOOL WINAPI SetSystemPowerState(BOOL,BOOL);
+BOOL WINAPI SetSystemPowerState(_In_ BOOL, _In_ BOOL);
 BOOL WINAPI SetSystemTime(const SYSTEMTIME*);
-BOOL WINAPI SetSystemTimeAdjustment(DWORD,BOOL);
-DWORD WINAPI SetTapeParameters(HANDLE,DWORD,PVOID);
-DWORD WINAPI SetTapePosition(HANDLE,DWORD,DWORD,DWORD,DWORD,BOOL);
-DWORD_PTR WINAPI SetThreadAffinityMask(HANDLE,DWORD_PTR);
+BOOL WINAPI SetSystemTimeAdjustment(_In_ DWORD, _In_ BOOL);
+DWORD WINAPI SetTapeParameters(_In_ HANDLE, _In_ DWORD, _In_ PVOID);
+DWORD WINAPI SetTapePosition(_In_ HANDLE, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD,
_In_ BOOL);
+DWORD_PTR WINAPI SetThreadAffinityMask(_In_ HANDLE, _In_ DWORD_PTR);
 BOOL WINAPI SetThreadContext(HANDLE,const CONTEXT*);
-DWORD WINAPI SetThreadIdealProcessor(HANDLE,DWORD);
+DWORD WINAPI SetThreadIdealProcessor(_In_ HANDLE, _In_ DWORD);
 BOOL WINAPI SetThreadPriority(HANDLE,int);
 BOOL WINAPI SetThreadPriorityBoost(HANDLE,BOOL);
 BOOL WINAPI SetThreadToken (PHANDLE,HANDLE);
 BOOL WINAPI SetTimeZoneInformation(const TIME_ZONE_INFORMATION *);
 BOOL WINAPI SetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,PVOID,DWORD);
 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
-BOOL WINAPI SetupComm(HANDLE,DWORD,DWORD);
-BOOL WINAPI SetVolumeLabelA(LPCSTR,LPCSTR);
-BOOL WINAPI SetVolumeLabelW(LPCWSTR,LPCWSTR);
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI SetVolumeMountPointA(LPCSTR,LPCSTR);
-BOOL WINAPI SetVolumeMountPointW(LPCWSTR,LPCWSTR);
+BOOL WINAPI SetupComm(_In_ HANDLE, _In_ DWORD, _In_ DWORD);
+BOOL WINAPI SetVolumeLabelA(_In_opt_ LPCSTR, _In_opt_ LPCSTR);
+BOOL WINAPI SetVolumeLabelW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR);
+#if (_WIN32_WINNT >= 0x0500)
+BOOL WINAPI SetVolumeMountPointA(_In_ LPCSTR, _In_ LPCSTR);
+BOOL WINAPI SetVolumeMountPointW(_In_ LPCWSTR, _In_ LPCWSTR);
 #endif
 BOOL WINAPI SetWaitableTimer(HANDLE,const
LARGE_INTEGER*,LONG,PTIMERAPCROUTINE,PVOID,BOOL);
-DWORD WINAPI SignalObjectAndWait(HANDLE,HANDLE,DWORD,BOOL);
+DWORD WINAPI SignalObjectAndWait(_In_ HANDLE, _In_ HANDLE, _In_ DWORD, _In_ BOOL);
 DWORD WINAPI SizeofResource(HINSTANCE,HRSRC);
 WINBASEAPI void WINAPI Sleep(DWORD);
 #if (_WIN32_WINNT >= 0x0600)
@@ -2260,7 +2996,7 @@
 #endif
 DWORD WINAPI SleepEx(DWORD,BOOL);
 DWORD WINAPI SuspendThread(HANDLE);
-void WINAPI SwitchToFiber(PVOID);
+void WINAPI SwitchToFiber(_In_ PVOID);
 BOOL WINAPI SwitchToThread(void);
 BOOL WINAPI SystemTimeToFileTime(const SYSTEMTIME*,LPFILETIME);
 BOOL WINAPI SystemTimeToTzSpecificLocalTime(CONST TIME_ZONE_INFORMATION*,CONST
SYSTEMTIME*,LPSYSTEMTIME);
@@ -2271,7 +3007,7 @@
 PVOID WINAPI TlsGetValue(DWORD);
 BOOL WINAPI TlsSetValue(DWORD,PVOID);
 BOOL WINAPI TransactNamedPipe(HANDLE,PVOID,DWORD,PVOID,DWORD,PDWORD,LPOVERLAPPED);
-BOOL WINAPI TransmitCommChar(HANDLE,char);
+BOOL WINAPI TransmitCommChar(_In_ HANDLE, _In_ char);
 BOOL WINAPI TryEnterCriticalSection(LPCRITICAL_SECTION);
 BOOL WINAPI
TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION,LPSYSTEMTIME,LPSYSTEMTIME);
 LONG WINAPI UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
@@ -2281,13 +3017,32 @@
 #define UnlockSegment(w) GlobalUnfix((HANDLE)(w)) /* Obsolete: Has no effect. */
 BOOL WINAPI UnmapViewOfFile(LPCVOID);
 #if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI UnregisterWait(HANDLE);
+_Must_inspect_result_ BOOL WINAPI UnregisterWait(_In_ HANDLE);
 BOOL WINAPI UnregisterWaitEx(HANDLE,HANDLE);
 #endif
-BOOL WINAPI UpdateResourceA(HANDLE,LPCSTR,LPCSTR,WORD,PVOID,DWORD);
-BOOL WINAPI UpdateResourceW(HANDLE,LPCWSTR,LPCWSTR,WORD,PVOID,DWORD);
-BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA,DWORD,DWORDLONG);
-BOOL WINAPI VerifyVersionInfoW(LPOSVERSIONINFOEXW,DWORD,DWORDLONG);
+
+BOOL
+WINAPI
+UpdateResourceA(
+  _In_ HANDLE hUpdate,
+  _In_ LPCSTR lpType,
+  _In_ LPCSTR lpName,
+  _In_ WORD wLanguage,
+  _In_reads_bytes_opt_(cb) LPVOID lpData,
+  _In_ DWORD cb);
+
+BOOL
+WINAPI
+UpdateResourceW(
+  _In_ HANDLE hUpdate,
+  _In_ LPCWSTR lpType,
+  _In_ LPCWSTR lpName,
+  _In_ WORD wLanguage,
+  _In_reads_bytes_opt_(cb) LPVOID lpData,
+  _In_ DWORD cb);
+
+BOOL WINAPI VerifyVersionInfoA(_Inout_ LPOSVERSIONINFOEXA, _In_ DWORD, _In_ DWORDLONG);
+BOOL WINAPI VerifyVersionInfoW(_Inout_ LPOSVERSIONINFOEXW, _In_ DWORD, _In_ DWORDLONG);
 PVOID WINAPI VirtualAlloc(PVOID,SIZE_T,DWORD,DWORD);
 PVOID WINAPI VirtualAllocEx(HANDLE,PVOID,SIZE_T,DWORD,DWORD);
 BOOL WINAPI VirtualFree(PVOID,SIZE_T,DWORD);
@@ -2298,46 +3053,97 @@
 SIZE_T WINAPI VirtualQuery(LPCVOID,PMEMORY_BASIC_INFORMATION,SIZE_T);
 SIZE_T WINAPI VirtualQueryEx(HANDLE,LPCVOID,PMEMORY_BASIC_INFORMATION,SIZE_T);
 BOOL WINAPI VirtualUnlock(PVOID,SIZE_T);
-BOOL WINAPI WaitCommEvent(HANDLE,PDWORD,LPOVERLAPPED);
+BOOL WINAPI WaitCommEvent(_In_ HANDLE, _Inout_ PDWORD, _Inout_opt_ LPOVERLAPPED);
 BOOL WINAPI WaitForDebugEvent(LPDEBUG_EVENT,DWORD);
-DWORD WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
+
+DWORD
+WINAPI
+WaitForMultipleObjects(
+  _In_ DWORD nCount,
+  _In_reads_(nCount) CONST HANDLE *lpHandles,
+  _In_ BOOL bWaitAll,
+  _In_ DWORD dwMilliseconds);
+
 DWORD WINAPI WaitForMultipleObjectsEx(DWORD,const HANDLE*,BOOL,DWORD,BOOL);
 DWORD WINAPI WaitForSingleObject(HANDLE,DWORD);
 DWORD WINAPI WaitForSingleObjectEx(HANDLE,DWORD,BOOL);
-BOOL WINAPI WaitNamedPipeA(LPCSTR,DWORD);
-BOOL WINAPI WaitNamedPipeW(LPCWSTR,DWORD);
+BOOL WINAPI WaitNamedPipeA(_In_ LPCSTR, _In_ DWORD);
+BOOL WINAPI WaitNamedPipeW(_In_ LPCWSTR, _In_ DWORD);
 #if (_WIN32_WINNT >= 0x0600)
 VOID WINAPI WakeConditionVariable(PCONDITION_VARIABLE);
 VOID WINAPI WakeAllConditionVariable(PCONDITION_VARIABLE);
 #endif
 BOOL WINAPI WinLoadTrustProvider(GUID*);
 BOOL WINAPI Wow64DisableWow64FsRedirection(PVOID*);
-BOOLEAN WINAPI Wow64EnableWow64FsRedirection(BOOLEAN);
+BOOLEAN WINAPI Wow64EnableWow64FsRedirection(_In_ BOOLEAN);
 BOOL WINAPI Wow64RevertWow64FsRedirection(PVOID);
 BOOL WINAPI WriteFile(HANDLE,LPCVOID,DWORD,LPDWORD,LPOVERLAPPED);
 BOOL WINAPI
WriteFileEx(HANDLE,LPCVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
 BOOL WINAPI WriteFileGather(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
-BOOL WINAPI WritePrivateProfileSectionA(LPCSTR,LPCSTR,LPCSTR);
-BOOL WINAPI WritePrivateProfileSectionW(LPCWSTR,LPCWSTR,LPCWSTR);
-BOOL WINAPI WritePrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
-BOOL WINAPI WritePrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR);
-BOOL WINAPI WritePrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
-BOOL WINAPI WritePrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
+BOOL WINAPI WritePrivateProfileSectionA(_In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_opt_
LPCSTR);
+BOOL WINAPI WritePrivateProfileSectionW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_opt_
LPCWSTR);
+BOOL WINAPI WritePrivateProfileStringA(_In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_opt_ LPCSTR,
_In_opt_ LPCSTR);
+BOOL WINAPI WritePrivateProfileStringW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_opt_
LPCWSTR, _In_opt_ LPCWSTR);
+
+BOOL
+WINAPI
+WritePrivateProfileStructA(
+  _In_ LPCSTR lpszSection,
+  _In_ LPCSTR lpszKey,
+  _In_reads_bytes_opt_(uSizeStruct) LPVOID lpStruct,
+  _In_ UINT uSizeStruct,
+  _In_opt_ LPCSTR szFile);
+
+BOOL
+WINAPI
+WritePrivateProfileStructW(
+  _In_ LPCWSTR lpszSection,
+  _In_ LPCWSTR lpszKey,
+  _In_reads_bytes_opt_(uSizeStruct) LPVOID lpStruct,
+  _In_ UINT uSizeStruct,
+  _In_opt_ LPCWSTR szFile);
+
 BOOL WINAPI WriteProcessMemory(HANDLE,LPVOID,LPCVOID,SIZE_T,SIZE_T*);
-BOOL WINAPI WriteProfileSectionA(LPCSTR,LPCSTR);
-BOOL WINAPI WriteProfileSectionW(LPCWSTR,LPCWSTR);
-BOOL WINAPI WriteProfileStringA(LPCSTR,LPCSTR,LPCSTR);
-BOOL WINAPI WriteProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR);
-DWORD WINAPI WriteTapemark(HANDLE,DWORD,DWORD,BOOL);
+BOOL WINAPI WriteProfileSectionA(_In_ LPCSTR, _In_ LPCSTR);
+BOOL WINAPI WriteProfileSectionW(_In_ LPCWSTR, _In_ LPCWSTR);
+BOOL WINAPI WriteProfileStringA(_In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_opt_ LPCSTR);
+BOOL WINAPI WriteProfileStringW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR);
+DWORD WINAPI WriteTapemark(_In_ HANDLE, _In_ DWORD, _In_ DWORD, _In_ BOOL);
 #define Yield()
 #if (_WIN32_WINNT >= 0x0501)
-BOOL WINAPI ZombifyActCtx(HANDLE);
-#endif
-#if (_WIN32_WINNT >= 0x0500)
-BOOL WINAPI AllocateUserPhysicalPages(HANDLE,PULONG_PTR,PULONG_PTR);
-BOOL WINAPI FreeUserPhysicalPages(HANDLE,PULONG_PTR,PULONG_PTR);
-BOOL WINAPI MapUserPhysicalPages(PVOID,ULONG_PTR,PULONG_PTR);
-BOOL WINAPI MapUserPhysicalPagesScatter(PVOID*,ULONG_PTR,PULONG_PTR);
+BOOL WINAPI ZombifyActCtx(_Inout_ HANDLE);
+#endif
+
+#if (_WIN32_WINNT >= 0x0500)
+
+BOOL
+WINAPI
+AllocateUserPhysicalPages(
+  _In_ HANDLE hProcess,
+  _Inout_ PULONG_PTR NumberOfPages,
+  _Out_writes_to_(*NumberOfPages, *NumberOfPages) PULONG_PTR PageArray);
+
+BOOL
+WINAPI
+FreeUserPhysicalPages(
+  _In_ HANDLE hProcess,
+  _Inout_ PULONG_PTR NumberOfPages,
+  _In_reads_(*NumberOfPages) PULONG_PTR PageArray);
+
+BOOL
+WINAPI
+MapUserPhysicalPages(
+  _In_ PVOID VirtualAddress,
+  _In_ ULONG_PTR NumberOfPages,
+  _In_reads_opt_(NumberOfPages) PULONG_PTR PageArray);
+
+BOOL
+WINAPI
+MapUserPhysicalPagesScatter(
+  _In_reads_(NumberOfPages) PVOID *VirtualAddresses,
+  _In_ ULONG_PTR NumberOfPages,
+  _In_reads_opt_(NumberOfPages) PULONG_PTR PageArray);
+
 #endif
 
 #ifdef UNICODE