;----------------------------------------------;
;           Coder plugin syntax file           ;
;----------------------------------------------;

;Colors
; Color need to be in #RRGGBB or #RGB format.
; If color equal to zero, then color ignored.
;
;Font styles
; 0  ignored.
; 1  normal.
; 2  bold.
; 3  italic.
; 4  bold italic.
;
;For comfort file viewing/editing set tab size to 8.


Files:
;==========
;File types
;==========
*.cpp
*.cxx
*.c
*.h
*.hh
*.hpp
*.hxx
*.c++
*.cc
*.cp
*.cu
*.i
*.ii
*.java
*.idl
*.tlh
*.tli


;----------------------------------------------;
;                  HighLight                   ;
;----------------------------------------------;

;Flags (sum of the members)
;     1  case sensitive.
;     2  word is a composition of characters ("Words:" section only). Example: "0123456789" - highlight words that contain only digits.
;     4  quote end required ("Quotes:" section only).
;     8  quote start string is ignored and last meet delimiter used as quote start ("Quotes:" section only).
;    16  quote end string is ignored and first meet delimiter used as quote end ("Quotes:" section only).
;    32  don't highlight quote start ("Quotes:" section only).
;    64  don't highlight quote end ("Quotes:" section only).
;   128  don't catch and don't highlight quote start ("Quotes:" section only).
;   256  don't catch and don't highlight quote end ("Quotes:" section only).
;   512  quote start, delimiter or word located at line start.
;  1024  quote end, delimiter or word located at line end.
;  2048  quote start is surrounded with delimiters ("Quotes:" section only).
;  4096  quote end is surrounded with delimiters ("Quotes:" section only).
;  8192  quote doesn't contain delimiters ("Quotes:" section only).
; 16384  only quote start string is catched ("Quotes:" section only).
; 32768  quote doesn't contain any character ("Quotes:" section only).


Font:
;=================================================================
;FontStyle             FontSize              FaceName
;=================================================================
${HighLight_FontStyle} ${HighLight_FontSize} ${HighLight_FaceName}


Colors:
;=============================================================================================================================================================================================================================================================================================================================================================================================================================
;BasicTextColor             BasicBkColor              SelTextColor              SelBkColor              LineTextColor              LineBkColor              LineBorderColor              AltTextColor              AltBkColor              AltBorderColor              ColumnColor              MarkerColor              CaretColor              UrlColor              ActiveUrlColor              VisitUrlColor
;=============================================================================================================================================================================================================================================================================================================================================================================================================================
${HighLight_BasicTextColor} ${HighLight_BasicBkColor} ${HighLight_SelTextColor} ${HighLight_SelBkColor} ${HighLight_LineTextColor} ${HighLight_LineBkColor} ${HighLight_LineBorderColor} ${HighLight_AltTextColor} ${HighLight_AltBkColor} ${HighLight_AltBorderColor} ${HighLight_ColumnColor} ${HighLight_MarkerColor} ${HighLight_CaretColor} ${HighLight_UrlColor} ${HighLight_ActiveUrlColor} ${HighLight_VisitUrlColor}


BkImage:
;==================================================
;BkImageFile              BkImageAlpha
;==================================================
${HighLight_BkImageFile}  ${HighLight_BkImageAlpha}


AutoMark:
;====================================================================================================================
;AutoMarkFlags             AutoMarkFontStyle              AutoMarkTextColor              AutoMarkBkColor
;====================================================================================================================
${HighLight_AutoMarkFlags} ${HighLight_AutoMarkFontStyle} ${HighLight_AutoMarkTextColor} ${HighLight_AutoMarkBkColor}


Quotes:
;===================================================================================
;Flags  Font    Color   Color   Quote   Quote   Escape  Quote   Quote   Parent  Rule
;       style   text    bkgrnd  start   end     char    include exclude ID      ID
;===================================================================================
;5=1+4
5	3	${STR}	0	`"`	`"`	"\"	""	""	0	0
;5=1+4
5	3	${STR}	0	"'"	"'"	"\"	""	""	0	0
;1=1
1	3	${COMM}	0	"//"	""	":"	""	""	0	0
;5=1+4
5	3	${COMM}	0	"/*"	"*/"	""	""	""	0	0


QuotesRE:
;==========================================================================================================
;Flags  Pattern                        \BackRef=(FontStyle,ColorText,ColorBk) \BackRef=...  ParentID RuleID
;==========================================================================================================
;0	`(")([^"\\]*(\\.[^"\\]*)*)(")` `\1=(0,${DEL1},0) \2=(3,${STR},0) \4=(0,${DEL1},0)`  0        0


Delimiters:
;===============================================
;Flags  Font    Color   Color   Char(s)   Parent
;       style   text    bkgrnd            ID
;===============================================
1	0	0	0	" "
1	0	0	0	"	"
1	0	${DEL1}	0	(
1	0	${DEL1}	0	)
1	0	${DEL2}	0	{
1	0	${DEL2}	0	}
1	0	${DEL2}	0	.
1	0	${DEL2}	0	,
1	0	${DEL2}	0	:
1	0	${DEL2}	0	;
1	0	${DEL2}	0	!
1	0	${DEL2}	0	~
1	0	${DEL2}	0	|
1	0	${DEL2}	0	=
1	0	${DEL2}	0	-
1	0	${DEL2}	0	*
1	0	${DEL2}	0	+
1	0	${DEL2}	0	/
1	0	${DEL2}	0	<
1	0	${DEL2}	0	>
1	0	${DEL2}	0	&
1	0	${DEL2}	0	^
1	0	${DEL2}	0	%
1	0	${DEL2}	0	?
1	0	${DEL2}	0	[
1	0	${DEL2}	0	]


Words:
;===========================================
;Flags  Font    Color   Color   Word  Parent
;       style   text    bkgrnd        ID
;===========================================
;--Types--
1	0	${TYPE}	0	bool
1	0	${TYPE}	0	char
1	0	${TYPE}	0	wchar_t
1	0	${TYPE}	0	void
1	0	${TYPE}	0	double
1	0	${TYPE}	0	float
1	0	${TYPE}	0	int
1	0	${TYPE}	0	long
1	0	${TYPE}	0	short
1	0	${TYPE}	0	signed
1	0	${TYPE}	0	unsigned
;1	0	${TYPE}	0	BOOL
;1	0	${TYPE}	0	BYTE
;1	0	${TYPE}	0	CHAR
;1	0	${TYPE}	0	DOUBLE
;1	0	${TYPE}	0	DWORD
;1	0	${TYPE}	0	FILE
;1	0	${TYPE}	0	FLOAT
;1	0	${TYPE}	0	INT
;1	0	${TYPE}	0	LONG
;1	0	${TYPE}	0	SHORT
;1	0	${TYPE}	0	TCHAR
;1	0	${TYPE}	0	VOID
;1	0	${TYPE}	0	WCHAR
;1	0	${TYPE}	0	WORD
;1	0	${TYPE}	0	size_t
;1	0	${TYPE}	0	NULL
;1	0	${TYPE}	0	true
;1	0	${TYPE}	0	false
;1	0	${TYPE}	0	TRUE
;1	0	${TYPE}	0	FALSE
;--Preprocessor--
1	0	${OP}	0	defined
1	0	${OP}	0	#define
1	0	${OP}	0	#elif
1	0	${OP}	0	#else
1	0	${OP}	0	#endif
1	0	${OP}	0	#error
1	0	${OP}	0	#if
1	0	${OP}	0	#ifdef
1	0	${OP}	0	#ifndef
1	0	${OP}	0	#import
1	0	${OP}	0	#include
1	0	${OP}	0	#line
1	0	${OP}	0	#pragma
1	0	${OP}	0	#undef
1	0	${OP}	0	#using
;--Type qualifiers--
1	0	${OP}	0	const
1	0	${OP}	0	restrict
1	0	${OP}	0	volatile
;--Storage-class specifiers--
1	0	${OP}	0	typedef
1	0	${OP}	0	extern
1	0	${OP}	0	static
1	0	${OP}	0	auto
1	0	${OP}	0	register
;--Class members--
1	0	${OP}	0	private
1	0	${OP}	0	protected
1	0	${OP}	0	public
1	0	${OP}	0	friend
1	0	${OP}	0	mutable
1	0	${OP}	0	explicit
;--Keywords--
1	0	${OP}	0	const_cast
1	0	${OP}	0	dynamic_cast
1	0	${OP}	0	reinterpret_cast
1	0	${OP}	0	static_cast
1	0	${OP}	0	class
1	0	${OP}	0	enum
1	0	${OP}	0	struct
1	0	${OP}	0	namespace
1	0	${OP}	0	operator
1	0	${OP}	0	template
1	0	${OP}	0	this
1	0	${OP}	0	typeid
1	0	${OP}	0	typename
1	0	${OP}	0	union
1	0	${OP}	0	using
1	0	${OP}	0	virtual
1	0	${OP}	0	sizeof
1	0	${OP}	0	delete
1	0	${OP}	0	new
1	0	${OP}	0	__declspec
1	0	${OP}	0	__cdecl
1	0	${OP}	0	__fastcall
;--Conditional--
1	0	${IF}	0	break
1	0	${IF}	0	continue
1	0	${IF}	0	do
1	0	${IF}	0	else
1	0	${IF}	0	for
1	0	${IF}	0	goto
1	0	${IF}	0	if
1	0	${IF}	0	while
1	0	${IF}	0	return
1	0	${IF}	0	case
1	0	${IF}	0	default
1	0	${IF}	0	switch
1	0	${IF}	0	try
1	0	${IF}	0	catch
1	0	${IF}	0	throw
1	0	${IF}	0	__asm
1	0	${IF}	0	_asm
1	0	${IF}	0	__inline
1	0	${IF}	0	__forceinline
1	0	${IF}	0	__try
1	0	${IF}	0	__except
1	0	${IF}	0	__finally
1	0	${IF}	0	__leave
;1	0	${IF}	0	asm
;1	0	${IF}	0	except
;1	0	${IF}	0	finally
;1	0	${IF}	0	inline
;1	0	${IF}	0	leave



;----------------------------------------------;
;                   CodeFold                   ;
;----------------------------------------------;

;Flags (sum of the members)
;       1  case sensitive.
;       2  force get fold name for function list from left at the fold start ("Folds:" section only).
;       4  force get fold name for function list from right at the fold start, including fold start ("Folds:" section only).
;       8  fold start ("Folds:" section) or skip start ("Skips:" section) located at line start.
;      16  fold start ("Folds:" section) or skip start ("Skips:" section) located at line end.
;      32  fold end ("Folds:" section) or skip end ("Skips:" section) located at line start.
;      64  fold end ("Folds:" section) or skip end ("Skips:" section) located at line end.
;     128  don't catch fold end ("Folds:" section) or skip end ("Skips:" section).
;     256  additional to 128 flag - more priority is given to sibling level instead of parent level ("Folds:" section only).
;     512  comment fold - fold ignore any other folds and skips inside ("Folds:" section only).
;    1024  reserved.
;    2048  deny fold - founded fold will be ignored ("Folds:" section only).
;    4096  xml fold - "<tag" and "</tag>", "<single" and "/>", "<single" and ">" ("Folds:" section only).
;    8192  don't check delimiters from left of fold start ("Folds:" section only).
;   16384  don't check delimiters from right of fold start ("Folds:" section only).
;   32768  don't check delimiters from left of fold end ("Folds:" section only).
;   65536  don't check delimiters from right of fold end ("Folds:" section only).
;  131072  deny delimiters ("Folds:" section only).
;  262144  don't show fold in list ("Folds:" section only).
; 1048576  regular expression in fold start ("Folds:" section) or skip start ("Skips:" section).
; 2097152  regular expression in fold end ("Folds:" section) or skip end ("Skips:" section). Backreference \101 matches \1 in fold start, \102 matches \2 and so on.


FoldPanel:
;=================================================================================================================================================================================================================================================================================================================================================================================================================================================================
;PanelFirstBkColor            PanelSecondBkColor             PanelNormalFoldColor             PanelActiveFoldColor             PanelNormalNodeOpenBkColor             PanelNormalNodeCloseBkColor             PanelActiveNodeOpenBkColor             PanelActiveNodeCloseBkColor             PanelNormalNodeOpenSignColor             PanelNormalNodeCloseSignColor             PanelActiveNodeOpenSignColor             PanelActiveNodeCloseSignColor
;=================================================================================================================================================================================================================================================================================================================================================================================================================================================================
${CodeFold_PanelFirstBkColor} ${CodeFold_PanelSecondBkColor} ${CodeFold_PanelNormalFoldColor} ${CodeFold_PanelActiveFoldColor} ${CodeFold_PanelNormalNodeOpenBkColor} ${CodeFold_PanelNormalNodeCloseBkColor} ${CodeFold_PanelActiveNodeOpenBkColor} ${CodeFold_PanelActiveNodeCloseBkColor} ${CodeFold_PanelNormalNodeOpenSignColor} ${CodeFold_PanelNormalNodeCloseSignColor} ${CodeFold_PanelActiveNodeOpenSignColor} ${CodeFold_PanelActiveNodeCloseSignColor}


FoldList:
;================================================
;ListTextColor            ListBkColor
;================================================
${CodeFold_ListTextColor} ${CodeFold_ListBkColor}


TagMark:
;============================================================================================================
;TagMarkFlags            TagMarkFontStyle             TagMarkTextColor             TagMarkBkColor
;============================================================================================================
${CodeFold_TagMarkFlags} ${CodeFold_TagMarkFontStyle} ${CodeFold_TagMarkTextColor} ${CodeFold_TagMarkBkColor}


Skips:
;=============================
;Flags  Skip    Skip    Escape
;       start   end     char
;=============================
1	`"`	`"`	"\"
1	`'`	`'`	"\"
1	"//"	""	":"


Folds:
;===================================================================================
;Flags  Font    Color   Color   Fold      Fold      Deli        Parent  Rule    Rule
;       style   text    bkgrnd  start     end       miters      ID      ID      file
;===================================================================================
1	0	0	0	"{"       "}"       ""          0	0
;513=1+512
513	3	${COMM}	0	"/*"      "*/"      ""          0	0
;--switch...case...default--
;169=1+8+32+128
169	0	0	0	"case"    "case"    " 	"       0	0
;169=1+8+32+128
169	0	0	0	"case"    "default" " 	:"      0	0
;169=1+8+32+128
169	0	0	0	"default" "case"    " 	:"      0	0
;98441=1+8+128+32768+65536
98441	0	0	0	"case"    "}"       " 	:"      0	0
;98441=1+8+128+32768+65536
98441	0	0	0	"default" "}"       " 	:"      0	0
;--Preprocessor directives--
;41=1+8+32
41	0	0	0	"#ifdef"  "#endif"  " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#ifdef"  "#elif"   " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#ifdef"  "#else"   " 	"       0	0
;41=1+8+32
41	0	0	0	"#ifndef" "#endif"  " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#ifndef" "#elif"   " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#ifndef" "#else"   " 	"       0	0
;41=1+8+32
41	0	0	0	"#if"     "#endif"  " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#if"     "#elif"   " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#if"     "#else"   " 	"       0	0
;41=1+8+32
41	0	0	0	"#elif"   "#endif"  " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#elif"   "#elif"   " 	"       0	0
;425=1+8+32+128+256
425	0	0	0	"#elif"   "#else"   " 	"       0	0
;41=1+8+32
41	0	0	0	"#else"   "#endif"  " 	"       0	0


;----------------------------------------------;
;                 AutoComplete                 ;
;----------------------------------------------;

;Flags (sum of the members)
;  1  force case sensitive.
;  2  force case insensitive.
;  4  regular expression (only for "$="). Scan starts from caret line beginning and metacharacters \a or \z specified caret position.
;  8  Don't show in listbox.


CompleteList:
;=====================================================================================================================================================================================================================================================================================================================================================================================================================================================================
;ListFontStyle                ListFontSize                 ListFaceName                 ListLineGap                 ListBlockIcon `"C:\1.dll", 0` ListBlockIconMargins "left;right"    ListHlBaseIcon `"C:\1.dll", 0` ListHlBaseIconMargins "left;right"    ListDocWordIcon `"C:\1.dll", 0` ListDocWordIconMargins "left;right"    ListBasicTextColor                 ListBasicBkColor                 ListSelTextColor                 ListSelBkColor
;=====================================================================================================================================================================================================================================================================================================================================================================================================================================================================
${AutoComplete_ListFontStyle} ${AutoComplete_ListFontSize} ${AutoComplete_ListFaceName} ${AutoComplete_ListLineGap} ${AutoComplete_ListBlockIcon} ${AutoComplete_ListBlockIconMargins} ${AutoComplete_ListHlBaseIcon} ${AutoComplete_ListHlBaseIconMargins} ${AutoComplete_ListDocWordIcon} ${AutoComplete_ListDocWordIconMargins} ${AutoComplete_ListBasicTextColor} ${AutoComplete_ListBasicBkColor} ${AutoComplete_ListSelTextColor} ${AutoComplete_ListSelBkColor}


Blocks:
;=============================================================================
;Abbreviations and blocks
;
; $~abbr         normal abbreviation.
; $(flags)~abbr  normal abbreviation with flags.
; $=abbr         exact abbreviation. May contain delimiters.
; $(flags)=abbr  exact abbreviation with flags. May contain delimiters.
; $[]            set caret to this position. Can be multiple (hot spots).
; $[text]        select text. Can be multiple (hot spots).
; $$             symbol $.
; $\]            escape symbol ]. Can be used in $[text] block: $[One [1$\] ].
; ${VAR}         variable assigned from Coder::Settings.
; $;             comment line.
;=============================================================================
$~class
class $[]
{
${AutoComplete_Indent}$[]
};

$~do
do
{
${AutoComplete_Indent}$[]
}
while ($[]);

$~for
for ($[]; $[]; $[])
{
${AutoComplete_Indent}$[]
}

$~if
if ($[])
{
${AutoComplete_Indent}$[]
}

$~struct
typedef struct {
${AutoComplete_Indent}$[]
} $[];

$~switch
switch ($[])
{
${AutoComplete_Indent}case $[]:
${AutoComplete_Indent}${AutoComplete_Indent}$[]
${AutoComplete_Indent}${AutoComplete_Indent}break;
${AutoComplete_Indent}case $[]:
${AutoComplete_Indent}${AutoComplete_Indent}$[]
${AutoComplete_Indent}${AutoComplete_Indent}break;
${AutoComplete_Indent}default:
${AutoComplete_Indent}${AutoComplete_Indent}$[]
${AutoComplete_Indent}${AutoComplete_Indent}break;
}

$~try
try
{
${AutoComplete_Indent}$[]
}
catch ($[])
{
${AutoComplete_Indent}$[]
}

$~while
while ($[])
{
${AutoComplete_Indent}$[]
}

$~MessageBox
MessageBox(NULL, "$[]", NULL, 0);

$~msgA
{
  char buf[MAX_PATH];

  wsprintfA(buf, "GetTickCount=%d\n", $[GetTickCount()]);
  MessageBoxA(NULL, buf, NULL, 0);
}

$~msgW
{
  wchar_t buf[MAX_PATH];

  wsprintfW(buf, L"GetTickCount=%d\n", $[GetTickCount()]);
  MessageBoxW(NULL, buf, NULL, 0);
}

$~SendMessage
SendMessage($[hWnd], $[WM_COMMAND], $[0], $[0]);

$~PostMessage
PostMessage($[hWnd], $[WM_COMMAND], $[0], $[0]);

$~WideCharToMultiByte
WideCharToMultiByte(CP_ACP, 0, $[wszString], -1, $[szString], $[MAX_PATH], NULL, NULL);

$~MultiByteToWideChar
MultiByteToWideChar(CP_ACP, 0, $[szString], -1, $[wszString], $[MAX_PATH]);

$~OldWindows
if (bOldWindows)
else

$; advapi32.dll
$; ------------
$~AbortSystemShutdownA
$[BOOL ]AbortSystemShutdownA($[LPSTR lpMachineName], $[LPSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown])

$~AbortSystemShutdownW
$[BOOL ]AbortSystemShutdownW($[LPWSTR lpMachineName], $[LPWSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown])

$~AccessCheck
$[BOOL ]AccessCheck($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[PGENERIC_MAPPING GenericMapping], $[PPRIVILEGE_SET PrivilegeSet], $[LPDWORD PrivilegeSetLength], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus])

$~AccessCheckAndAuditAlarmA
$[BOOL ]AccessCheckAndAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[LPSTR ObjectTypeName], $[LPSTR ObjectName], $[PSECURITY_DESCRIPTOR SecurityDescriptor], $[DWORD DesiredAccess], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus], $[LPBOOL pfGenerateOnClose])

$~AccessCheckAndAuditAlarmW
$[BOOL ]AccessCheckAndAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[LPWSTR ObjectTypeName], $[LPWSTR ObjectName], $[PSECURITY_DESCRIPTOR SecurityDescriptor], $[DWORD DesiredAccess], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByType
$[BOOL ]AccessCheckByType($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[PPRIVILEGE_SET PrivilegeSet], $[LPDWORD PrivilegeSetLength], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus])

$~AccessCheckByTypeAndAuditAlarmA
$[BOOL ]AccessCheckByTypeAndAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[LPCSTR ObjectTypeName], $[LPCSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByTypeAndAuditAlarmW
$[BOOL ]AccessCheckByTypeAndAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[LPCWSTR ObjectTypeName], $[LPCWSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPBOOL AccessStatus], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByTypeResultList
$[BOOL ]AccessCheckByTypeResultList($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[PPRIVILEGE_SET PrivilegeSet], $[LPDWORD PrivilegeSetLength], $[LPDWORD GrantedAccessList], $[LPDWORD AccessStatusList])

$~AccessCheckByTypeResultListAndAuditAlarmA
$[BOOL ]AccessCheckByTypeResultListAndAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[LPCSTR ObjectTypeName], $[LPCSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPDWORD AccessStatusList], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByTypeResultListAndAuditAlarmByHandleA
$[BOOL ]AccessCheckByTypeResultListAndAuditAlarmByHandleA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[HANDLE ClientToken], $[LPCSTR ObjectTypeName], $[LPCSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPDWORD AccessStatusList], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByTypeResultListAndAuditAlarmByHandleW
$[BOOL ]AccessCheckByTypeResultListAndAuditAlarmByHandleW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[HANDLE ClientToken], $[LPCWSTR ObjectTypeName], $[LPCWSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPDWORD AccessStatusList], $[LPBOOL pfGenerateOnClose])

$~AccessCheckByTypeResultListAndAuditAlarmW
$[BOOL ]AccessCheckByTypeResultListAndAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[LPCWSTR ObjectTypeName], $[LPCWSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID PrincipalSelfSid], $[DWORD DesiredAccess], $[AUDIT_EVENT_TYPE AuditType], $[DWORD Flags], $[POBJECT_TYPE_LIST ObjectTypeList], $[DWORD ObjectTypeListLength], $[PGENERIC_MAPPING GenericMapping], $[BOOL ObjectCreation], $[LPDWORD GrantedAccess], $[LPDWORD AccessStatusList], $[LPBOOL pfGenerateOnClose])

$~AddAccessAllowedAce
$[BOOL ]AddAccessAllowedAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AccessMask], $[PSID pSid])

$~AddAccessAllowedAceEx
$[BOOL ]AddAccessAllowedAceEx($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD AccessMask], $[PSID pSid])

$~AddAccessAllowedObjectAce
$[BOOL ]AddAccessAllowedObjectAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD AccessMask], $[GUID* ObjectTypeGuid], $[GUID* InheritedObjectTypeGuid], $[PSID pSid])

$~AddAccessDeniedAce
$[BOOL ]AddAccessDeniedAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AccessMask], $[PSID pSid])

$~AddAccessDeniedAceEx
$[BOOL ]AddAccessDeniedAceEx($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD AccessMask], $[PSID pSid])

$~AddAccessDeniedObjectAce
$[BOOL ]AddAccessDeniedObjectAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD AccessMask], $[GUID* ObjectTypeGuid], $[GUID* InheritedObjectTypeGuid], $[PSID pSid])

$~AddAce
$[BOOL ]AddAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD dwStartingAceIndex], $[LPVOID pAceList], $[DWORD nAceListLength])

$~AddAuditAccessAce
$[BOOL ]AddAuditAccessAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD dwAccessMask], $[PSID pSid], $[BOOL bAuditSuccess], $[BOOL bAuditFailure])

$~AddAuditAccessAceEx
$[BOOL ]AddAuditAccessAceEx($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD dwAccessMask], $[PSID pSid], $[BOOL bAuditSuccess], $[BOOL bAuditFailure])

$~AddAuditAccessObjectAce
$[BOOL ]AddAuditAccessObjectAce($[PACL pAcl], $[DWORD dwAceRevision], $[DWORD AceFlags], $[DWORD AccessMask], $[GUID* ObjectTypeGuid], $[GUID* InheritedObjectTypeGuid], $[PSID pSid], $[BOOL bAuditSuccess], $[BOOL bAuditFailure])

$~AdjustTokenGroups
$[BOOL ]AdjustTokenGroups($[HANDLE TokenHandle], $[BOOL ResetToDefault], $[PTOKEN_GROUPS NewState], $[DWORD BufferLength], $[PTOKEN_GROUPS PreviousState], $[PDWORD ReturnLength])

$~AdjustTokenPrivileges
$[BOOL ]AdjustTokenPrivileges($[HANDLE TokenHandle], $[BOOL DisableAllPrivileges], $[PTOKEN_PRIVILEGES NewState], $[DWORD BufferLength], $[PTOKEN_PRIVILEGES PreviousState], $[PDWORD ReturnLength])

$~AllocateAndInitializeSid
$[BOOL ]AllocateAndInitializeSid($[PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority], $[BYTE nSubAuthorityCount], $[DWORD dwSubAuthority0], $[DWORD dwSubAuthority1], $[DWORD dwSubAuthority2], $[DWORD dwSubAuthority3], $[DWORD dwSubAuthority4], $[DWORD dwSubAuthority5], $[DWORD dwSubAuthority6], $[DWORD dwSubAuthority7], $[PSID* pSid])

$~AllocateLocallyUniqueId
$[BOOL ]AllocateLocallyUniqueId($[PLUID Luid])

$~AreAllAccessesGranted
$[BOOL ]AreAllAccessesGranted($[DWORD GrantedAccess], $[DWORD DesiredAccess])

$~AreAnyAccessesGranted
$[BOOL ]AreAnyAccessesGranted($[DWORD GrantedAccess], $[DWORD DesiredAccess])

$~BackupEventLogA
$[BOOL ]BackupEventLogA($[HANDLE hEventLog], $[LPCSTR lpBackupFileName])

$~BackupEventLogW
$[BOOL ]BackupEventLogW($[HANDLE hEventLog], $[LPCWSTR lpBackupFileName])

$~ChangeServiceConfig2A
$[BOOL ]ChangeServiceConfig2A($[SC_HANDLE hService], $[DWORD dwInfoLevel], $[LPVOID lpInfo])

$~ChangeServiceConfig2W
$[BOOL ]ChangeServiceConfig2W($[SC_HANDLE hService], $[DWORD dwInfoLevel], $[LPVOID lpInfo])

$~ChangeServiceConfigA
$[BOOL ]ChangeServiceConfigA($[SC_HANDLE hService], $[DWORD dwServiceType], $[DWORD dwStartType], $[DWORD dwErrorControl], $[LPCSTR lpBinaryPathName], $[LPCSTR lpLoadOrderGroup], $[LPDWORD lpdwTagId], $[LPCSTR lpDependencies], $[LPCSTR lpServiceStartName], $[LPCSTR lpPassword], $[LPCSTR lpDisplayName])

$~ChangeServiceConfigW
$[BOOL ]ChangeServiceConfigW($[SC_HANDLE hService], $[DWORD dwServiceType], $[DWORD dwStartType], $[DWORD dwErrorControl], $[LPCWSTR lpBinaryPathName], $[LPCWSTR lpLoadOrderGroup], $[LPDWORD lpdwTagId], $[LPCWSTR lpDependencies], $[LPCWSTR lpServiceStartName], $[LPCWSTR lpPassword], $[LPCWSTR lpDisplayName])

$~CheckTokenMembership
$[BOOL ]CheckTokenMembership($[HANDLE TokenHandle], $[PSID SidToCheck], $[PBOOL IsMember])

$~ClearEventLogA
$[BOOL ]ClearEventLogA($[HANDLE hEventLog], $[LPCSTR lpBackupFileName])

$~ClearEventLogW
$[BOOL ]ClearEventLogW($[HANDLE hEventLog], $[LPCWSTR lpBackupFileName])

$~CloseEventLog
$[BOOL ]CloseEventLog($[HANDLE hEventLog])

$~CloseServiceHandle
$[BOOL ]CloseServiceHandle($[SC_HANDLE hSCObject])

$~ControlService
$[BOOL ]ControlService($[SC_HANDLE hService], $[DWORD dwControl], $[LPSERVICE_STATUS lpServiceStatus])

$~ConvertSecurityDescriptorToStringSecurityDescriptorA
$[BOOL ]ConvertSecurityDescriptorToStringSecurityDescriptorA($[PSECURITY_DESCRIPTOR SecurityDescriptor], $[DWORD RequestedStringSDRevision], $[SECURITY_INFORMATION SecurityInformation], $[LPTSTR* StringSecurityDescriptor], $[PULONG StringSecurityDescriptorLen])

$~ConvertSecurityDescriptorToStringSecurityDescriptorW
$[BOOL ]ConvertSecurityDescriptorToStringSecurityDescriptorW($[PSECURITY_DESCRIPTOR SecurityDescriptor], $[DWORD RequestedStringSDRevision], $[SECURITY_INFORMATION SecurityInformation], $[LPTSTR* StringSecurityDescriptor], $[PULONG StringSecurityDescriptorLen])

$~ConvertSidToStringSidA
$[BOOL ]ConvertSidToStringSidA($[PSID Sid], $[LPTSTR* StringSid])

$~ConvertSidToStringSidW
$[BOOL ]ConvertSidToStringSidW($[PSID Sid], $[LPTSTR* StringSid])

$~ConvertStringSDToSDDomainA
$[BOOL ]ConvertStringSDToSDDomainA($[PSID DomainSid], $[PSID RootDomainSid], $[LPCSTR StringSecurityDescriptor], $[DWORD StringSDRevision], $[PSECURITY_DESCRIPTOR* SecurityDescriptor], $[PULONG SecurityDescriptorSize])

$~ConvertStringSDToSDDomainW
$[BOOL ]ConvertStringSDToSDDomainW($[PSID DomainSid], $[PSID RootDomainSid], $[LPCWSTR StringSecurityDescriptor], $[DWORD StringSDRevision], $[PSECURITY_DESCRIPTOR* SecurityDescriptor], $[PULONG SecurityDescriptorSize])

$~ConvertStringSecurityDescriptorToSecurityDescriptorA
$[BOOL ]ConvertStringSecurityDescriptorToSecurityDescriptorA($[LPCSTR StringSecurityDescriptor], $[DWORD StringSDRevision], $[PSECURITY_DESCRIPTOR* SecurityDescriptor], $[PULONG SecurityDescriptorSize])

$~ConvertStringSecurityDescriptorToSecurityDescriptorW
$[BOOL ]ConvertStringSecurityDescriptorToSecurityDescriptorW($[LPCWSTR StringSecurityDescriptor], $[DWORD StringSDRevision], $[PSECURITY_DESCRIPTOR* SecurityDescriptor], $[PULONG SecurityDescriptorSize])

$~ConvertStringSidToSidA
$[BOOL ]ConvertStringSidToSidA($[LPCSTR StringSid], $[PSID* Sid])

$~ConvertStringSidToSidW
$[BOOL ]ConvertStringSidToSidW($[LPCWSTR StringSid], $[PSID* Sid])

$~ConvertToAutoInheritPrivateObjectSecurity
$[BOOL ]ConvertToAutoInheritPrivateObjectSecurity($[PSECURITY_DESCRIPTOR ParentDescriptor], $[PSECURITY_DESCRIPTOR CurrentSecurityDescriptor], $[PSECURITY_DESCRIPTOR* NewSecurityDescriptor], $[GUID* ObjectType], $[BOOLEAN IsDirectoryObject], $[PGENERIC_MAPPING GenericMapping])

$~CopySid
$[BOOL ]CopySid($[DWORD nDestinationSidLength], $[PSID pDestinationSid], $[PSID pSourceSid])

$~CreatePrivateObjectSecurity
$[BOOL ]CreatePrivateObjectSecurity($[PSECURITY_DESCRIPTOR ParentDescriptor], $[PSECURITY_DESCRIPTOR CreatorDescriptor], $[PSECURITY_DESCRIPTOR* NewDescriptor], $[BOOL IsDirectoryObject], $[HANDLE Token], $[PGENERIC_MAPPING GenericMapping])

$~CreatePrivateObjectSecurityEx
$[BOOL ]CreatePrivateObjectSecurityEx($[PSECURITY_DESCRIPTOR ParentDescriptor], $[PSECURITY_DESCRIPTOR CreatorDescriptor], $[PSECURITY_DESCRIPTOR* NewDescriptor], $[GUID* ObjectType], $[BOOL IsContainerObject], $[ULONG AutoInheritFlags], $[HANDLE Token], $[PGENERIC_MAPPING GenericMapping])

$~CreatePrivateObjectSecurityWithMultipleInheritance
$[BOOL ]CreatePrivateObjectSecurityWithMultipleInheritance($[PSECURITY_DESCRIPTOR ParentDescriptor], $[PSECURITY_DESCRIPTOR CreatorDescriptor], $[PSECURITY_DESCRIPTOR* NewDescriptor], $[GUID** ObjectTypes], $[ULONG GuidCount], $[BOOL IsContainerObject], $[ULONG AutoInheritFlags], $[HANDLE Token], $[PGENERIC_MAPPING GenericMapping])

$~CreateProcessAsUserA
$[BOOL ]CreateProcessAsUserA($[HANDLE hToken], $[LPCSTR lpApplicationName], $[LPSTR lpCommandLine], $[LPSECURITY_ATTRIBUTES lpProcessAttributes], $[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[BOOL bInheritHandles], $[DWORD dwCreationFlags], $[LPVOID lpEnvironment], $[LPCSTR lpCurrentDirectory], $[LPSTARTUPINFO lpStartupInfo], $[LPPROCESS_INFORMATION lpProcessInformation])

$~CreateProcessAsUserW
$[BOOL ]CreateProcessAsUserW($[HANDLE hToken], $[LPCWSTR lpApplicationName], $[LPWSTR lpCommandLine], $[LPSECURITY_ATTRIBUTES lpProcessAttributes], $[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[BOOL bInheritHandles], $[DWORD dwCreationFlags], $[LPVOID lpEnvironment], $[LPCWSTR lpCurrentDirectory], $[LPSTARTUPINFO lpStartupInfo], $[LPPROCESS_INFORMATION lpProcessInformation])

$~CreateProcessWithLogonW
$[BOOL ]CreateProcessWithLogonW($[LPCWSTR lpUsername], $[LPCWSTR lpDomain], $[LPCWSTR lpPassword], $[DWORD dwLogonFlags], $[LPCWSTR lpApplicationName], $[LPWSTR lpCommandLine], $[DWORD dwCreationFlags], $[LPVOID lpEnvironment], $[LPCWSTR lpCurrentDirectory], $[LPSTARTUPINFOW lpStartupInfo], $[LPPROCESS_INFORMATION lpProcessInfo])

$~CreateRestrictedToken
$[BOOL ]CreateRestrictedToken($[HANDLE ExistingTokenHandle], $[DWORD Flags], $[DWORD DisableSidCount], $[PSID_AND_ATTRIBUTES SidsToDisable], $[DWORD DeletePrivilegeCount], $[PLUID_AND_ATTRIBUTES PrivilegesToDelete], $[DWORD RestrictedSidCount], $[PSID_AND_ATTRIBUTES SidsToRestrict], $[PHANDLE NewTokenHandle])

$~CreateWellKnownSid
$[BOOL ]CreateWellKnownSid($[WELL_KNOWN_SID_TYPE WellKnownSidType], $[PSID DomainSid], $[PSID pSid], $[DWORD* cbSid])

$~CredDeleteA
$[BOOL ]CredDeleteA($[LPCSTR TargetName], $[DWORD Type], $[DWORD Flags])

$~CredDeleteW
$[BOOL ]CredDeleteW($[LPCWSTR TargetName], $[DWORD Type], $[DWORD Flags])

$~CredEnumerateA
$[BOOL ]CredEnumerateA($[LPCSTR Filter], $[DWORD Flags], $[DWORD* Count], $[PCREDENTIAL** Credentials])

$~CredEnumerateW
$[BOOL ]CredEnumerateW($[LPCWSTR Filter], $[DWORD Flags], $[DWORD* Count], $[PCREDENTIAL** Credentials])

$~CredGetSessionTypes
$[BOOL ]CredGetSessionTypes($[DWORD MaximumPersistCount], $[LPDWORD MaximumPersist])

$~CredGetTargetInfoA
$[BOOL ]CredGetTargetInfoA($[LPCSTR TargetName], $[DWORD Flags], $[PCREDENTIAL_TARGET_INFORMATION* TargetInfo])

$~CredGetTargetInfoW
$[BOOL ]CredGetTargetInfoW($[LPCWSTR TargetName], $[DWORD Flags], $[PCREDENTIAL_TARGET_INFORMATION* TargetInfo])

$~CredIsMarshaledCredentialA
$[BOOL ]CredIsMarshaledCredentialA($[LPCSTR MarshaledCredential])

$~CredIsMarshaledCredentialW
$[BOOL ]CredIsMarshaledCredentialW($[LPCWSTR MarshaledCredential])

$~CredMarshalCredentialA
$[BOOL ]CredMarshalCredentialA($[CRED_MARSHAL_TYPE CredType], $[PVOID Credential], $[LPTSTR* MarshaledCredential])

$~CredMarshalCredentialW
$[BOOL ]CredMarshalCredentialW($[CRED_MARSHAL_TYPE CredType], $[PVOID Credential], $[LPTSTR* MarshaledCredential])

$~CredReadA
$[BOOL ]CredReadA($[LPCSTR TargetName], $[DWORD Type], $[DWORD Flags], $[PCREDENTIAL* Credential])

$~CredReadDomainCredentialsA
$[BOOL ]CredReadDomainCredentialsA($[PCREDENTIAL_TARGET_INFORMATION TargetInfo], $[DWORD Flags], $[DWORD* Count], $[PCREDENTIAL** Credentials])

$~CredReadDomainCredentialsW
$[BOOL ]CredReadDomainCredentialsW($[PCREDENTIAL_TARGET_INFORMATION TargetInfo], $[DWORD Flags], $[DWORD* Count], $[PCREDENTIAL** Credentials])

$~CredReadW
$[BOOL ]CredReadW($[LPCWSTR TargetName], $[DWORD Type], $[DWORD Flags], $[PCREDENTIAL* Credential])

$~CredRenameA
$[BOOL ]CredRenameA($[LPCSTR OldTargetName], $[LPCSTR NewTargetName], $[DWORD Type], $[DWORD Flags])

$~CredRenameW
$[BOOL ]CredRenameW($[LPCWSTR OldTargetName], $[LPCWSTR NewTargetName], $[DWORD Type], $[DWORD Flags])

$~CredUnmarshalCredentialA
$[BOOL ]CredUnmarshalCredentialA($[LPCSTR MarshaledCredential], $[PCRED_MARSHAL_TYPE CredType], $[PVOID* Credential])

$~CredUnmarshalCredentialW
$[BOOL ]CredUnmarshalCredentialW($[LPCWSTR MarshaledCredential], $[PCRED_MARSHAL_TYPE CredType], $[PVOID* Credential])

$~CredWriteA
$[BOOL ]CredWriteA($[PCREDENTIAL Credential], $[DWORD Flags])

$~CredWriteDomainCredentialsA
$[BOOL ]CredWriteDomainCredentialsA($[PCREDENTIAL_TARGET_INFORMATION TargetInfo], $[PCREDENTIAL Credential], $[DWORD Flags])

$~CredWriteDomainCredentialsW
$[BOOL ]CredWriteDomainCredentialsW($[PCREDENTIAL_TARGET_INFORMATION TargetInfo], $[PCREDENTIAL Credential], $[DWORD Flags])

$~CredWriteW
$[BOOL ]CredWriteW($[PCREDENTIAL Credential], $[DWORD Flags])

$~CryptAcquireContextA
$[BOOL ]CryptAcquireContextA($[HCRYPTPROV* phProv], $[LPCSTR pszContainer], $[LPCSTR pszProvider], $[DWORD dwProvType], $[DWORD dwFlags])

$~CryptAcquireContextW
$[BOOL ]CryptAcquireContextW($[HCRYPTPROV* phProv], $[LPCWSTR pszContainer], $[LPCWSTR pszProvider], $[DWORD dwProvType], $[DWORD dwFlags])

$~CryptContextAddRef
$[BOOL ]CryptContextAddRef($[HCRYPTPROV hProv], $[DWORD* pdwReserved], $[DWORD dwFlags])

$~CryptCreateHash
$[BOOL ]CryptCreateHash($[HCRYPTPROV hProv], $[ALG_ID Algid], $[HCRYPTKEY hKey], $[DWORD dwFlags], $[HCRYPTHASH* phHash])

$~CryptDecrypt
$[BOOL ]CryptDecrypt($[HCRYPTKEY hKey], $[HCRYPTHASH hHash], $[BOOL Final], $[DWORD dwFlags], $[BYTE* pbData], $[DWORD* pdwDataLen])

$~CryptDeriveKey
$[BOOL ]CryptDeriveKey($[HCRYPTPROV hProv], $[ALG_ID Algid], $[HCRYPTHASH hBaseData], $[DWORD dwFlags], $[HCRYPTKEY* phKey])

$~CryptDestroyHash
$[BOOL ]CryptDestroyHash($[HCRYPTHASH hHash])

$~CryptDestroyKey
$[BOOL ]CryptDestroyKey($[HCRYPTKEY hKey])

$~CryptDuplicateHash
$[BOOL ]CryptDuplicateHash($[HCRYPTHASH hHash], $[DWORD* pdwReserved], $[DWORD dwFlags], $[HCRYPTHASH* phHash])

$~CryptDuplicateKey
$[BOOL ]CryptDuplicateKey($[HCRYPTKEY hKey], $[DWORD* pdwReserved], $[DWORD dwFlags], $[HCRYPTKEY* phKey])

$~CryptEncrypt
$[BOOL ]CryptEncrypt($[HCRYPTKEY hKey], $[HCRYPTHASH hHash], $[BOOL Final], $[DWORD dwFlags], $[BYTE* pbData], $[DWORD* pdwDataLen], $[DWORD dwBufLen])

$~CryptEnumProvidersA
$[BOOL ]CryptEnumProvidersA($[DWORD dwIndex], $[DWORD* pdwReserved], $[DWORD dwFlags], $[DWORD* pdwProvType], $[LPSTR pszProvName], $[DWORD* pcbProvName])

$~CryptEnumProvidersW
$[BOOL ]CryptEnumProvidersW($[DWORD dwIndex], $[DWORD* pdwReserved], $[DWORD dwFlags], $[DWORD* pdwProvType], $[LPWSTR pszProvName], $[DWORD* pcbProvName])

$~CryptEnumProviderTypesA
$[BOOL ]CryptEnumProviderTypesA($[DWORD dwIndex], $[DWORD* pdwReserved], $[DWORD dwFlags], $[DWORD* pdwProvType], $[LPSTR pszTypeName], $[DWORD* pcbTypeName])

$~CryptEnumProviderTypesW
$[BOOL ]CryptEnumProviderTypesW($[DWORD dwIndex], $[DWORD* pdwReserved], $[DWORD dwFlags], $[DWORD* pdwProvType], $[LPWSTR pszTypeName], $[DWORD* pcbTypeName])

$~CryptExportKey
$[BOOL ]CryptExportKey($[HCRYPTKEY hKey], $[HCRYPTKEY hExpKey], $[DWORD dwBlobType], $[DWORD dwFlags], $[BYTE* pbData], $[DWORD* pdwDataLen])

$~CryptGenKey
$[BOOL ]CryptGenKey($[HCRYPTPROV hProv], $[ALG_ID Algid], $[DWORD dwFlags], $[HCRYPTKEY* phKey])

$~CryptGenRandom
$[BOOL ]CryptGenRandom($[HCRYPTPROV hProv], $[DWORD dwLen], $[BYTE* pbBuffer])

$~CryptGetDefaultProviderA
$[BOOL ]CryptGetDefaultProviderA($[DWORD dwProvType], $[DWORD* pdwReserved], $[DWORD dwFlags], $[LPSTR pszProvName], $[DWORD* pcbProvName])

$~CryptGetDefaultProviderW
$[BOOL ]CryptGetDefaultProviderW($[DWORD dwProvType], $[DWORD* pdwReserved], $[DWORD dwFlags], $[LPWSTR pszProvName], $[DWORD* pcbProvName])

$~CryptGetHashParam
$[BOOL ]CryptGetHashParam($[HCRYPTHASH hHash], $[DWORD dwParam], $[BYTE* pbData], $[DWORD* pdwDataLen], $[DWORD dwFlags])

$~CryptGetKeyParam
$[BOOL ]CryptGetKeyParam($[HCRYPTKEY hKey], $[DWORD dwParam], $[BYTE* pbData], $[DWORD* pdwDataLen], $[DWORD dwFlags])

$~CryptGetProvParam
$[BOOL ]CryptGetProvParam($[HCRYPTPROV hProv], $[DWORD dwParam], $[BYTE* pbData], $[DWORD* pdwDataLen], $[DWORD dwFlags])

$~CryptGetUserKey
$[BOOL ]CryptGetUserKey($[HCRYPTPROV hProv], $[DWORD dwKeySpec], $[HCRYPTKEY* phUserKey])

$~CryptHashData
$[BOOL ]CryptHashData($[HCRYPTHASH hHash], $[BYTE* pbData], $[DWORD dwDataLen], $[DWORD dwFlags])

$~CryptHashSessionKey
$[BOOL ]CryptHashSessionKey($[HCRYPTHASH hHash], $[HCRYPTKEY hKey], $[DWORD dwFlags])

$~CryptImportKey
$[BOOL ]CryptImportKey($[HCRYPTPROV hProv], $[BYTE* pbData], $[DWORD dwDataLen], $[HCRYPTKEY hPubKey], $[DWORD dwFlags], $[HCRYPTKEY* phKey])

$~CryptReleaseContext
$[BOOL ]CryptReleaseContext($[HCRYPTPROV hProv], $[DWORD dwFlags])

$~CryptSetHashParam
$[BOOL ]CryptSetHashParam($[HCRYPTHASH hHash], $[DWORD dwParam], $[const BYTE* pbData], $[DWORD dwFlags])

$~CryptSetKeyParam
$[BOOL ]CryptSetKeyParam($[HCRYPTKEY hKey], $[DWORD dwParam], $[const BYTE* pbData], $[DWORD dwFlags])

$~CryptSetProviderA
$[BOOL ]CryptSetProviderA($[LPCSTR pszProvName], $[DWORD dwProvType])

$~CryptSetProviderExA
$[BOOL ]CryptSetProviderExA($[LPCSTR pszProvName], $[DWORD dwProvType], $[DWORD* pdwReserved], $[DWORD dwFlags])

$~CryptSetProviderExW
$[BOOL ]CryptSetProviderExW($[LPCWSTR pszProvName], $[DWORD dwProvType], $[DWORD* pdwReserved], $[DWORD dwFlags])

$~CryptSetProviderW
$[BOOL ]CryptSetProviderW($[LPCWSTR pszProvName], $[DWORD dwProvType])

$~CryptSetProvParam
$[BOOL ]CryptSetProvParam($[HCRYPTPROV hProv], $[DWORD dwParam], $[const BYTE* pbData], $[DWORD dwFlags])

$~CryptSignHashA
$[BOOL ]CryptSignHashA($[HCRYPTHASH hHash], $[DWORD dwKeySpec], $[LPCSTR sDescription], $[DWORD dwFlags], $[BYTE* pbSignature], $[DWORD* pdwSigLen])

$~CryptSignHashW
$[BOOL ]CryptSignHashW($[HCRYPTHASH hHash], $[DWORD dwKeySpec], $[LPCWSTR sDescription], $[DWORD dwFlags], $[BYTE* pbSignature], $[DWORD* pdwSigLen])

$~CryptVerifySignatureA
$[BOOL ]CryptVerifySignatureA($[HCRYPTHASH hHash], $[BYTE* pbSignature], $[DWORD dwSigLen], $[HCRYPTKEY hPubKey], $[LPCSTR sDescription], $[DWORD dwFlags])

$~CryptVerifySignatureW
$[BOOL ]CryptVerifySignatureW($[HCRYPTHASH hHash], $[BYTE* pbSignature], $[DWORD dwSigLen], $[HCRYPTKEY hPubKey], $[LPCWSTR sDescription], $[DWORD dwFlags])

$~DecryptFileA
$[BOOL ]DecryptFileA($[LPCSTR lpFileName], $[DWORD dwReserved])

$~DecryptFileW
$[BOOL ]DecryptFileW($[LPCWSTR lpFileName], $[DWORD dwReserved])

$~DeleteAce
$[BOOL ]DeleteAce($[PACL pAcl], $[DWORD dwAceIndex])

$~DeleteService
$[BOOL ]DeleteService($[SC_HANDLE hService])

$~DeregisterEventSource
$[BOOL ]DeregisterEventSource($[HANDLE hEventLog])

$~DestroyPrivateObjectSecurity
$[BOOL ]DestroyPrivateObjectSecurity($[PSECURITY_DESCRIPTOR* ObjectDescriptor])

$~DuplicateToken
$[BOOL ]DuplicateToken($[HANDLE ExistingTokenHandle], $[SECURITY_IMPERSONATION_LEVEL ImpersonationLevel], $[PHANDLE DuplicateTokenHandle])

$~DuplicateTokenEx
$[BOOL ]DuplicateTokenEx($[HANDLE hExistingToken], $[DWORD dwDesiredAccess], $[LPSECURITY_ATTRIBUTES lpTokenAttributes], $[SECURITY_IMPERSONATION_LEVEL ImpersonationLevel], $[TOKEN_TYPE TokenType], $[PHANDLE phNewToken])

$~EncryptFileA
$[BOOL ]EncryptFileA($[LPCSTR lpFileName])

$~EncryptFileW
$[BOOL ]EncryptFileW($[LPCWSTR lpFileName])

$~EncryptionDisable
$[BOOL ]EncryptionDisable($[LPCWSTR DirPath], $[BOOL Disable])

$~EnumDependentServicesA
$[BOOL ]EnumDependentServicesA($[SC_HANDLE hService], $[DWORD dwServiceState], $[LPENUM_SERVICE_STATUS lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned])

$~EnumDependentServicesW
$[BOOL ]EnumDependentServicesW($[SC_HANDLE hService], $[DWORD dwServiceState], $[LPENUM_SERVICE_STATUS lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned])

$~EnumServicesStatusA
$[BOOL ]EnumServicesStatusA($[SC_HANDLE hSCManager], $[DWORD dwServiceType], $[DWORD dwServiceState], $[LPENUM_SERVICE_STATUS lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned], $[LPDWORD lpResumeHandle])

$~EnumServicesStatusExA
$[BOOL ]EnumServicesStatusExA($[SC_HANDLE hSCManager], $[SC_ENUM_TYPE InfoLevel], $[DWORD dwServiceType], $[DWORD dwServiceState], $[LPBYTE lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned], $[LPDWORD lpResumeHandle], $[LPCSTR pszGroupName])

$~EnumServicesStatusExW
$[BOOL ]EnumServicesStatusExW($[SC_HANDLE hSCManager], $[SC_ENUM_TYPE InfoLevel], $[DWORD dwServiceType], $[DWORD dwServiceState], $[LPBYTE lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned], $[LPDWORD lpResumeHandle], $[LPCWSTR pszGroupName])

$~EnumServicesStatusW
$[BOOL ]EnumServicesStatusW($[SC_HANDLE hSCManager], $[DWORD dwServiceType], $[DWORD dwServiceState], $[LPENUM_SERVICE_STATUS lpServices], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded], $[LPDWORD lpServicesReturned], $[LPDWORD lpResumeHandle])

$~EqualDomainSid
$[BOOL ]EqualDomainSid($[PSID pSid1], $[PSID pSid2], $[BOOL* pfEqual])

$~EqualPrefixSid
$[BOOL ]EqualPrefixSid($[PSID pSid1], $[PSID pSid2])

$~EqualSid
$[BOOL ]EqualSid($[PSID pSid1], $[PSID pSid2])

$~FileEncryptionStatusA
$[BOOL ]FileEncryptionStatusA($[LPCSTR lpFileName], $[LPDWORD lpStatus])

$~FileEncryptionStatusW
$[BOOL ]FileEncryptionStatusW($[LPCWSTR lpFileName], $[LPDWORD lpStatus])

$~FindFirstFreeAce
$[BOOL ]FindFirstFreeAce($[PACL pAcl], $[LPVOID* pAce])

$~GetAce
$[BOOL ]GetAce($[PACL pAcl], $[DWORD dwAceIndex], $[LPVOID* pAce])

$~GetAclInformation
$[BOOL ]GetAclInformation($[PACL pAcl], $[LPVOID pAclInformation], $[DWORD nAclInformationLength], $[ACL_INFORMATION_CLASS dwAclInformationClass])

$~GetCurrentHwProfileA
$[BOOL ]GetCurrentHwProfileA($[LPHW_PROFILE_INFO lpHwProfileInfo])

$~GetCurrentHwProfileW
$[BOOL ]GetCurrentHwProfileW($[LPHW_PROFILE_INFO lpHwProfileInfo])

$~GetEventLogInformation
$[BOOL ]GetEventLogInformation($[HANDLE hEventLog], $[DWORD dwInfoLevel], $[LPVOID lpBuffer], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~GetFileSecurityA
$[BOOL ]GetFileSecurityA($[LPCSTR lpFileName], $[SECURITY_INFORMATION RequestedInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetFileSecurityW
$[BOOL ]GetFileSecurityW($[LPCWSTR lpFileName], $[SECURITY_INFORMATION RequestedInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetKernelObjectSecurity
$[BOOL ]GetKernelObjectSecurity($[HANDLE Handle], $[SECURITY_INFORMATION RequestedInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetNumberOfEventLogRecords
$[BOOL ]GetNumberOfEventLogRecords($[HANDLE hEventLog], $[PDWORD NumberOfRecords])

$~GetOldestEventLogRecord
$[BOOL ]GetOldestEventLogRecord($[HANDLE hEventLog], $[PDWORD OldestRecord])

$~GetPrivateObjectSecurity
$[BOOL ]GetPrivateObjectSecurity($[PSECURITY_DESCRIPTOR ObjectDescriptor], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR ResultantDescriptor], $[DWORD DescriptorLength], $[PDWORD ReturnLength])

$~GetSecurityDescriptorControl
$[BOOL ]GetSecurityDescriptorControl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSECURITY_DESCRIPTOR_CONTROL pControl], $[LPDWORD lpdwRevision])

$~GetSecurityDescriptorDacl
$[BOOL ]GetSecurityDescriptorDacl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[LPBOOL lpbDaclPresent], $[PACL* pDacl], $[LPBOOL lpbDaclDefaulted])

$~GetSecurityDescriptorGroup
$[BOOL ]GetSecurityDescriptorGroup($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID* pGroup], $[LPBOOL lpbGroupDefaulted])

$~GetSecurityDescriptorOwner
$[BOOL ]GetSecurityDescriptorOwner($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID* pOwner], $[LPBOOL lpbOwnerDefaulted])

$~GetSecurityDescriptorSacl
$[BOOL ]GetSecurityDescriptorSacl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[LPBOOL lpbSaclPresent], $[PACL* pSacl], $[LPBOOL lpbSaclDefaulted])

$~GetServiceDisplayNameA
$[BOOL ]GetServiceDisplayNameA($[SC_HANDLE hSCManager], $[LPCSTR lpServiceName], $[LPSTR lpDisplayName], $[LPDWORD lpcchBuffer])

$~GetServiceDisplayNameW
$[BOOL ]GetServiceDisplayNameW($[SC_HANDLE hSCManager], $[LPCWSTR lpServiceName], $[LPWSTR lpDisplayName], $[LPDWORD lpcchBuffer])

$~GetServiceKeyNameA
$[BOOL ]GetServiceKeyNameA($[SC_HANDLE hSCManager], $[LPCSTR lpDisplayName], $[LPSTR lpServiceName], $[LPDWORD lpcchBuffer])

$~GetServiceKeyNameW
$[BOOL ]GetServiceKeyNameW($[SC_HANDLE hSCManager], $[LPCWSTR lpDisplayName], $[LPWSTR lpServiceName], $[LPDWORD lpcchBuffer])

$~GetTokenInformation
$[BOOL ]GetTokenInformation($[HANDLE TokenHandle], $[TOKEN_INFORMATION_CLASS TokenInformationClass], $[LPVOID TokenInformation], $[DWORD TokenInformationLength], $[PDWORD ReturnLength])

$~GetUserNameA
$[BOOL ]GetUserNameA($[LPSTR lpBuffer], $[LPDWORD lpnSize])

$~GetUserNameW
$[BOOL ]GetUserNameW($[LPWSTR lpBuffer], $[LPDWORD lpnSize])

$~GetWindowsAccountDomainSid
$[BOOL ]GetWindowsAccountDomainSid($[PSID pSid], $[PSID ppDomainSid], $[DWORD* cbSid])

$~ImpersonateAnonymousToken
$[BOOL ]ImpersonateAnonymousToken($[HANDLE ThreadHandle])

$~ImpersonateLoggedOnUser
$[BOOL ]ImpersonateLoggedOnUser($[HANDLE hToken])

$~ImpersonateNamedPipeClient
$[BOOL ]ImpersonateNamedPipeClient($[HANDLE hNamedPipe])

$~ImpersonateSelf
$[BOOL ]ImpersonateSelf($[SECURITY_IMPERSONATION_LEVEL ImpersonationLevel])

$~InitializeAcl
$[BOOL ]InitializeAcl($[PACL pAcl], $[DWORD nAclLength], $[DWORD dwAclRevision])

$~InitializeSecurityDescriptor
$[BOOL ]InitializeSecurityDescriptor($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[DWORD dwRevision])

$~InitializeSid
$[BOOL ]InitializeSid($[PSID Sid], $[PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority], $[BYTE nSubAuthorityCount])

$~InitiateSystemShutdownA
$[BOOL ]InitiateSystemShutdownA($[LPSTR lpMachineName], $[LPSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown])

$~InitiateSystemShutdownExA
$[BOOL ]InitiateSystemShutdownExA($[LPSTR lpMachineName], $[LPSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown], $[DWORD dwReason])

$~InitiateSystemShutdownExW
$[BOOL ]InitiateSystemShutdownExW($[LPWSTR lpMachineName], $[LPWSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown], $[DWORD dwReason])

$~InitiateSystemShutdownW
$[BOOL ]InitiateSystemShutdownW($[LPWSTR lpMachineName], $[LPWSTR lpMessage], $[DWORD dwTimeout], $[BOOL bForceAppsClosed], $[BOOL bRebootAfterShutdown])

$~IsTextUnicode
$[BOOL ]IsTextUnicode($[CONST VOID* pBuffer], $[int cb], $[LPINT lpi])

$~IsTokenRestricted
$[BOOL ]IsTokenRestricted($[HANDLE TokenHandle])

$~IsValidAcl
$[BOOL ]IsValidAcl($[PACL pAcl])

$~IsValidSecurityDescriptor
$[BOOL ]IsValidSecurityDescriptor($[PSECURITY_DESCRIPTOR pSecurityDescriptor])

$~IsValidSid
$[BOOL ]IsValidSid($[PSID pSid])

$~IsWellKnownSid
$[BOOL ]IsWellKnownSid($[PSID pSid], $[WELL_KNOWN_SID_TYPE WellKnownSidType])

$~LogonUserA
$[BOOL ]LogonUserA($[LPSTR lpszUsername], $[LPSTR lpszDomain], $[LPSTR lpszPassword], $[DWORD dwLogonType], $[DWORD dwLogonProvider], $[PHANDLE phToken])

$~LogonUserExA
$[BOOL ]LogonUserExA($[LPSTR lpszUsername], $[LPSTR lpszDomain], $[LPSTR lpszPassword], $[DWORD dwLogonType], $[DWORD dwLogonProvider], $[PHANDLE phToken], $[PSID* ppLogonSid], $[PVOID* ppProfileBuffer], $[LPDWORD pdwProfileLength], $[PQUOTA_LIMITS pQuotaLimits])

$~LogonUserExW
$[BOOL ]LogonUserExW($[LPWSTR lpszUsername], $[LPWSTR lpszDomain], $[LPWSTR lpszPassword], $[DWORD dwLogonType], $[DWORD dwLogonProvider], $[PHANDLE phToken], $[PSID* ppLogonSid], $[PVOID* ppProfileBuffer], $[LPDWORD pdwProfileLength], $[PQUOTA_LIMITS pQuotaLimits])

$~LogonUserW
$[BOOL ]LogonUserW($[LPWSTR lpszUsername], $[LPWSTR lpszDomain], $[LPWSTR lpszPassword], $[DWORD dwLogonType], $[DWORD dwLogonProvider], $[PHANDLE phToken])

$~LookupAccountNameA
$[BOOL ]LookupAccountNameA($[LPCSTR lpSystemName], $[LPCSTR lpAccountName], $[PSID Sid], $[LPDWORD cbSid], $[LPSTR ReferencedDomainName], $[LPDWORD cchReferencedDomainName], $[PSID_NAME_USE peUse])

$~LookupAccountNameW
$[BOOL ]LookupAccountNameW($[LPCWSTR lpSystemName], $[LPCWSTR lpAccountName], $[PSID Sid], $[LPDWORD cbSid], $[LPWSTR ReferencedDomainName], $[LPDWORD cchReferencedDomainName], $[PSID_NAME_USE peUse])

$~LookupAccountSidA
$[BOOL ]LookupAccountSidA($[LPCSTR lpSystemName], $[PSID lpSid], $[LPSTR lpName], $[LPDWORD cchName], $[LPSTR lpReferencedDomainName], $[LPDWORD cchReferencedDomainName], $[PSID_NAME_USE peUse])

$~LookupAccountSidW
$[BOOL ]LookupAccountSidW($[LPCWSTR lpSystemName], $[PSID lpSid], $[LPWSTR lpName], $[LPDWORD cchName], $[LPWSTR lpReferencedDomainName], $[LPDWORD cchReferencedDomainName], $[PSID_NAME_USE peUse])

$~LookupPrivilegeDisplayNameA
$[BOOL ]LookupPrivilegeDisplayNameA($[LPCSTR lpSystemName], $[LPCSTR lpName], $[LPSTR lpDisplayName], $[LPDWORD cchDisplayName], $[LPDWORD lpLanguageId])

$~LookupPrivilegeDisplayNameW
$[BOOL ]LookupPrivilegeDisplayNameW($[LPCWSTR lpSystemName], $[LPCWSTR lpName], $[LPWSTR lpDisplayName], $[LPDWORD cchDisplayName], $[LPDWORD lpLanguageId])

$~LookupPrivilegeNameA
$[BOOL ]LookupPrivilegeNameA($[LPCSTR lpSystemName], $[PLUID lpLuid], $[LPSTR lpName], $[LPDWORD cchName])

$~LookupPrivilegeNameW
$[BOOL ]LookupPrivilegeNameW($[LPCWSTR lpSystemName], $[PLUID lpLuid], $[LPWSTR lpName], $[LPDWORD cchName])

$~LookupPrivilegeValueA
$[BOOL ]LookupPrivilegeValueA($[LPCSTR lpSystemName], $[LPCSTR lpName], $[PLUID lpLuid])

$~LookupPrivilegeValueW
$[BOOL ]LookupPrivilegeValueW($[LPCWSTR lpSystemName], $[LPCWSTR lpName], $[PLUID lpLuid])

$~MakeAbsoluteSD
$[BOOL ]MakeAbsoluteSD($[PSECURITY_DESCRIPTOR pSelfRelativeSD], $[PSECURITY_DESCRIPTOR pAbsoluteSD], $[LPDWORD lpdwAbsoluteSDSize], $[PACL pDacl], $[LPDWORD lpdwDaclSize], $[PACL pSacl], $[LPDWORD lpdwSaclSize], $[PSID pOwner], $[LPDWORD lpdwOwnerSize], $[PSID pPrimaryGroup], $[LPDWORD lpdwPrimaryGroupSize])

$~MakeSelfRelativeSD
$[BOOL ]MakeSelfRelativeSD($[PSECURITY_DESCRIPTOR pAbsoluteSD], $[PSECURITY_DESCRIPTOR pSelfRelativeSD], $[LPDWORD lpdwBufferLength])

$~NotifyBootConfigStatus
$[BOOL ]NotifyBootConfigStatus($[BOOL BootAcceptable])

$~NotifyChangeEventLog
$[BOOL ]NotifyChangeEventLog($[HANDLE hEventLog], $[HANDLE hEvent])

$~ObjectCloseAuditAlarmA
$[BOOL ]ObjectCloseAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[BOOL GenerateOnClose])

$~ObjectCloseAuditAlarmW
$[BOOL ]ObjectCloseAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[BOOL GenerateOnClose])

$~ObjectDeleteAuditAlarmA
$[BOOL ]ObjectDeleteAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[BOOL GenerateOnClose])

$~ObjectDeleteAuditAlarmW
$[BOOL ]ObjectDeleteAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[BOOL GenerateOnClose])

$~ObjectOpenAuditAlarmA
$[BOOL ]ObjectOpenAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[LPSTR ObjectTypeName], $[LPSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[DWORD GrantedAccess], $[PPRIVILEGE_SET Privileges], $[BOOL ObjectCreation], $[BOOL AccessGranted], $[LPBOOL GenerateOnClose])

$~ObjectOpenAuditAlarmW
$[BOOL ]ObjectOpenAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[LPWSTR ObjectTypeName], $[LPWSTR ObjectName], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[DWORD GrantedAccess], $[PPRIVILEGE_SET Privileges], $[BOOL ObjectCreation], $[BOOL AccessGranted], $[LPBOOL GenerateOnClose])

$~ObjectPrivilegeAuditAlarmA
$[BOOL ]ObjectPrivilegeAuditAlarmA($[LPCSTR SubsystemName], $[LPVOID HandleId], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[PPRIVILEGE_SET Privileges], $[BOOL AccessGranted])

$~ObjectPrivilegeAuditAlarmW
$[BOOL ]ObjectPrivilegeAuditAlarmW($[LPCWSTR SubsystemName], $[LPVOID HandleId], $[HANDLE ClientToken], $[DWORD DesiredAccess], $[PPRIVILEGE_SET Privileges], $[BOOL AccessGranted])

$~OpenProcessToken
$[BOOL ]OpenProcessToken($[HANDLE ProcessHandle], $[DWORD DesiredAccess], $[PHANDLE TokenHandle])

$~OpenThreadToken
$[BOOL ]OpenThreadToken($[HANDLE ThreadHandle], $[DWORD DesiredAccess], $[BOOL OpenAsSelf], $[PHANDLE TokenHandle])

$~PrivilegeCheck
$[BOOL ]PrivilegeCheck($[HANDLE ClientToken], $[PPRIVILEGE_SET RequiredPrivileges], $[LPBOOL pfResult])

$~PrivilegedServiceAuditAlarmA
$[BOOL ]PrivilegedServiceAuditAlarmA($[LPCSTR SubsystemName], $[LPCSTR ServiceName], $[HANDLE ClientToken], $[PPRIVILEGE_SET Privileges], $[BOOL AccessGranted])

$~PrivilegedServiceAuditAlarmW
$[BOOL ]PrivilegedServiceAuditAlarmW($[LPCWSTR SubsystemName], $[LPCWSTR ServiceName], $[HANDLE ClientToken], $[PPRIVILEGE_SET Privileges], $[BOOL AccessGranted])

$~QueryServiceConfig2A
$[BOOL ]QueryServiceConfig2A($[SC_HANDLE hService], $[DWORD dwInfoLevel], $[LPBYTE lpBuffer], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceConfig2W
$[BOOL ]QueryServiceConfig2W($[SC_HANDLE hService], $[DWORD dwInfoLevel], $[LPBYTE lpBuffer], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceConfigA
$[BOOL ]QueryServiceConfigA($[SC_HANDLE hService], $[LPQUERY_SERVICE_CONFIG lpServiceConfig], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceConfigW
$[BOOL ]QueryServiceConfigW($[SC_HANDLE hService], $[LPQUERY_SERVICE_CONFIG lpServiceConfig], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceLockStatusA
$[BOOL ]QueryServiceLockStatusA($[SC_HANDLE hSCManager], $[LPQUERY_SERVICE_LOCK_STATUS lpLockStatus], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceLockStatusW
$[BOOL ]QueryServiceLockStatusW($[SC_HANDLE hSCManager], $[LPQUERY_SERVICE_LOCK_STATUS lpLockStatus], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceObjectSecurity
$[BOOL ]QueryServiceObjectSecurity($[SC_HANDLE hService], $[SECURITY_INFORMATION dwSecurityInformation], $[PSECURITY_DESCRIPTOR lpSecurityDescriptor], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~QueryServiceStatus
$[BOOL ]QueryServiceStatus($[SC_HANDLE hService], $[LPSERVICE_STATUS lpServiceStatus])

$~QueryServiceStatusEx
$[BOOL ]QueryServiceStatusEx($[SC_HANDLE hService], $[SC_STATUS_TYPE InfoLevel], $[LPBYTE lpBuffer], $[DWORD cbBufSize], $[LPDWORD pcbBytesNeeded])

$~ReadEventLogA
$[BOOL ]ReadEventLogA($[HANDLE hEventLog], $[DWORD dwReadFlags], $[DWORD dwRecordOffset], $[LPVOID lpBuffer], $[DWORD nNumberOfBytesToRead], $[DWORD* pnBytesRead], $[DWORD* pnMinNumberOfBytesNeeded])

$~ReadEventLogW
$[BOOL ]ReadEventLogW($[HANDLE hEventLog], $[DWORD dwReadFlags], $[DWORD dwRecordOffset], $[LPVOID lpBuffer], $[DWORD nNumberOfBytesToRead], $[DWORD* pnBytesRead], $[DWORD* pnMinNumberOfBytesNeeded])

$~ReportEventA
$[BOOL ]ReportEventA($[HANDLE hEventLog], $[WORD wType], $[WORD wCategory], $[DWORD dwEventID], $[PSID lpUserSid], $[WORD wNumStrings], $[DWORD dwDataSize], $[LPCTSTR* lpStrings], $[LPVOID lpRawData])

$~ReportEventW
$[BOOL ]ReportEventW($[HANDLE hEventLog], $[WORD wType], $[WORD wCategory], $[DWORD dwEventID], $[PSID lpUserSid], $[WORD wNumStrings], $[DWORD dwDataSize], $[LPCTSTR* lpStrings], $[LPVOID lpRawData])

$~RevertToSelf
$[BOOL ]RevertToSelf($[])

$~SaferCloseLevel
$[BOOL ]SaferCloseLevel($[SAFER_LEVEL_HANDLE hLevelHandle])

$~SaferComputeTokenFromLevel
$[BOOL ]SaferComputeTokenFromLevel($[SAFER_LEVEL_HANDLE LevelHandle], $[HANDLE InAccessToken], $[PHANDLE OutAccessToken], $[DWORD dwFlags], $[LPVOID lpReserved])

$~SaferCreateLevel
$[BOOL ]SaferCreateLevel($[DWORD dwScopeId], $[DWORD dwLevelId], $[DWORD OpenFlags], $[SAFER_LEVEL_HANDLE* pLevelHandle], $[LPVOID lpReserved])

$~SaferGetLevelInformation
$[BOOL ]SaferGetLevelInformation($[SAFER_LEVEL_HANDLE LevelHandle], $[SAFER_OBJECT_INFO_CLASS dwInfoType], $[LPVOID lpQueryBuffer], $[DWORD dwInBufferSize], $[LPDWORD lpdwOutBufferSize])

$~SaferGetPolicyInformation
$[BOOL ]SaferGetPolicyInformation($[DWORD dwScopeId], $[SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass], $[DWORD InfoBufferSize], $[PVOID InfoBuffer], $[PDWORD InfoBufferRetSize], $[LPVOID lpReserved])

$~SaferIdentifyLevel
$[BOOL ]SaferIdentifyLevel($[DWORD dwNumProperties], $[PSAFER_CODE_PROPERTIES pCodeProperties], $[SAFER_LEVEL_HANDLE* pLevelHandle], $[LPVOID lpReserved])

$~SaferiIsExecutableFileType
$[BOOL ]SaferiIsExecutableFileType($[LPCWSTR szFullPathname], $[BOOLEAN bFromShellExecute])

$~SaferRecordEventLogEntry
$[BOOL ]SaferRecordEventLogEntry($[SAFER_LEVEL_HANDLE hLevel], $[LPCWSTR szTargetPath], $[LPVOID lpReserved])

$~SetAclInformation
$[BOOL ]SetAclInformation($[PACL pAcl], $[LPVOID pAclInformation], $[DWORD nAclInformationLength], $[ACL_INFORMATION_CLASS dwAclInformationClass])

$~SetFileSecurityA
$[BOOL ]SetFileSecurityA($[LPCSTR lpFileName], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor])

$~SetFileSecurityW
$[BOOL ]SetFileSecurityW($[LPCWSTR lpFileName], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor])

$~SetKernelObjectSecurity
$[BOOL ]SetKernelObjectSecurity($[HANDLE Handle], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR SecurityDescriptor])

$~SetPrivateObjectSecurity
$[BOOL ]SetPrivateObjectSecurity($[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR ModificationDescriptor], $[PSECURITY_DESCRIPTOR* ObjectsSecurityDescriptor], $[PGENERIC_MAPPING GenericMapping], $[HANDLE Token])

$~SetPrivateObjectSecurityEx
$[BOOL ]SetPrivateObjectSecurityEx($[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR ModificationDescriptor], $[PSECURITY_DESCRIPTOR* SecurityDescriptor], $[ULONG AutoInheritFlags], $[PGENERIC_MAPPING GenericMapping], $[HANDLE Token])

$~SetSecurityDescriptorControl
$[BOOL ]SetSecurityDescriptorControl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest], $[SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet])

$~SetSecurityDescriptorDacl
$[BOOL ]SetSecurityDescriptorDacl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[BOOL bDaclPresent], $[PACL pDacl], $[BOOL bDaclDefaulted])

$~SetSecurityDescriptorGroup
$[BOOL ]SetSecurityDescriptorGroup($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID pGroup], $[BOOL bGroupDefaulted])

$~SetSecurityDescriptorOwner
$[BOOL ]SetSecurityDescriptorOwner($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[PSID pOwner], $[BOOL bOwnerDefaulted])

$~SetSecurityDescriptorSacl
$[BOOL ]SetSecurityDescriptorSacl($[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[BOOL bSaclPresent], $[PACL pSacl], $[BOOL bSaclDefaulted])

$~SetServiceBits
$[BOOL ]SetServiceBits($[SERVICE_STATUS_HANDLE hServiceStatus], $[DWORD dwServiceBits], $[BOOL bSetBitsOn], $[BOOL bUpdateImmediately])

$~SetServiceObjectSecurity
$[BOOL ]SetServiceObjectSecurity($[SC_HANDLE hService], $[SECURITY_INFORMATION dwSecurityInformation], $[PSECURITY_DESCRIPTOR lpSecurityDescriptor])

$~SetServiceStatus
$[BOOL ]SetServiceStatus($[SERVICE_STATUS_HANDLE hServiceStatus], $[LPSERVICE_STATUS lpServiceStatus])

$~SetThreadToken
$[BOOL ]SetThreadToken($[PHANDLE Thread], $[HANDLE Token])

$~SetTokenInformation
$[BOOL ]SetTokenInformation($[HANDLE TokenHandle], $[TOKEN_INFORMATION_CLASS TokenInformationClass], $[LPVOID TokenInformation], $[DWORD TokenInformationLength])

$~StartServiceA
$[BOOL ]StartServiceA($[SC_HANDLE hService], $[DWORD dwNumServiceArgs], $[LPCTSTR* lpServiceArgVectors])

$~StartServiceCtrlDispatcherA
$[BOOL ]StartServiceCtrlDispatcherA($[const SERVICE_TABLE_ENTRY* lpServiceTable])

$~StartServiceCtrlDispatcherW
$[BOOL ]StartServiceCtrlDispatcherW($[const SERVICE_TABLE_ENTRY* lpServiceTable])

$~StartServiceW
$[BOOL ]StartServiceW($[SC_HANDLE hService], $[DWORD dwNumServiceArgs], $[LPCTSTR* lpServiceArgVectors])

$~UnlockServiceDatabase
$[BOOL ]UnlockServiceDatabase($[SC_LOCK ScLock])

$~AddUsersToEncryptedFile
$[DWORD ]AddUsersToEncryptedFile($[LPCWSTR lpFileName], $[PENCRYPTION_CERTIFICATE_LIST pUsers])

$~BuildSecurityDescriptorA
$[DWORD ]BuildSecurityDescriptorA($[PTRUSTEE pOwner], $[PTRUSTEE pGroup], $[ULONG cCountOfAccessEntries], $[PEXPLICIT_ACCESS pListOfAccessEntries], $[ULONG cCountOfAuditEntries], $[PEXPLICIT_ACCESS pListOfAuditEntries], $[PSECURITY_DESCRIPTOR pOldSD], $[PULONG pSizeNewSD], $[PSECURITY_DESCRIPTOR* pNewSD])

$~BuildSecurityDescriptorW
$[DWORD ]BuildSecurityDescriptorW($[PTRUSTEE pOwner], $[PTRUSTEE pGroup], $[ULONG cCountOfAccessEntries], $[PEXPLICIT_ACCESS pListOfAccessEntries], $[ULONG cCountOfAuditEntries], $[PEXPLICIT_ACCESS pListOfAuditEntries], $[PSECURITY_DESCRIPTOR pOldSD], $[PULONG pSizeNewSD], $[PSECURITY_DESCRIPTOR* pNewSD])

$~DuplicateEncryptionInfoFile
$[DWORD ]DuplicateEncryptionInfoFile($[LPCSTR SrcFileName], $[LPCSTR DstFileName], $[DWORD dwCreationDistribution], $[DWORD dwAttributes], $[const LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~FreeInheritedFromArray
$[DWORD ]FreeInheritedFromArray($[PINHERITED_FROM pInheritArray], $[USHORT AceCnt], $[PFN_OBJECT_MGR_FUNCTS pfnArray])

$~GetAuditedPermissionsFromAclA
$[DWORD ]GetAuditedPermissionsFromAclA($[PACL pacl], $[PTRUSTEE pTrustee], $[PACCESS_MASK pSuccessfulAuditedRights], $[PACCESS_MASK pFailedAuditRights])

$~GetAuditedPermissionsFromAclW
$[DWORD ]GetAuditedPermissionsFromAclW($[PACL pacl], $[PTRUSTEE pTrustee], $[PACCESS_MASK pSuccessfulAuditedRights], $[PACCESS_MASK pFailedAuditRights])

$~GetEffectiveRightsFromAclA
$[DWORD ]GetEffectiveRightsFromAclA($[PACL pacl], $[PTRUSTEE pTrustee], $[PACCESS_MASK pAccessRights])

$~GetEffectiveRightsFromAclW
$[DWORD ]GetEffectiveRightsFromAclW($[PACL pacl], $[PTRUSTEE pTrustee], $[PACCESS_MASK pAccessRights])

$~GetExplicitEntriesFromAclA
$[DWORD ]GetExplicitEntriesFromAclA($[PACL pacl], $[PULONG pcCountOfExplicitEntries], $[PEXPLICIT_ACCESS* pListOfExplicitEntries])

$~GetExplicitEntriesFromAclW
$[DWORD ]GetExplicitEntriesFromAclW($[PACL pacl], $[PULONG pcCountOfExplicitEntries], $[PEXPLICIT_ACCESS* pListOfExplicitEntries])

$~GetInheritanceSourceA
$[DWORD ]GetInheritanceSourceA($[LPSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[BOOL Container], $[GUID** pObjectClassGuids], $[DWORD GuidCount], $[PACL pAcl], $[PFN_OBJECT_MGR_FUNCTS pfnArray], $[PGENERIC_MAPPING pGenericMapping], $[PINHERITED_FROM pInheritArray])

$~GetInheritanceSourceW
$[DWORD ]GetInheritanceSourceW($[LPWSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[BOOL Container], $[GUID** pObjectClassGuids], $[DWORD GuidCount], $[PACL pAcl], $[PFN_OBJECT_MGR_FUNCTS pfnArray], $[PGENERIC_MAPPING pGenericMapping], $[PINHERITED_FROM pInheritArray])

$~GetLengthSid
$[DWORD ]GetLengthSid($[PSID pSid])

$~GetLocalManagedApplications
$[DWORD ]GetLocalManagedApplications($[BOOL bUserApps], $[LPDWORD pdwApps], $[PLOCALMANAGEDAPPLICATION* prgLocalApps])

$~GetManagedApplicationCategories
$[DWORD ]GetManagedApplicationCategories($[DWORD dwReserved], $[APPCATEGORYINFOLIST* pAppCategory])

$~GetManagedApplications
$[DWORD ]GetManagedApplications($[GUID* pCategory], $[DWORD dwQueryFlags], $[DWORD dwInfoLevel], $[LPDWORD pdwApps], $[PMANAGEDAPPLICATION* prgManagedApps])

$~GetNamedSecurityInfoA
$[DWORD ]GetNamedSecurityInfoA($[LPSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID* ppsidOwner], $[PSID* ppsidGroup], $[PACL* ppDacl], $[PACL* ppSacl], $[PSECURITY_DESCRIPTOR* ppSecurityDescriptor])

$~GetNamedSecurityInfoW
$[DWORD ]GetNamedSecurityInfoW($[LPWSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID* ppsidOwner], $[PSID* ppsidGroup], $[PACL* ppDacl], $[PACL* ppSacl], $[PSECURITY_DESCRIPTOR* ppSecurityDescriptor])

$~GetSecurityDescriptorLength
$[DWORD ]GetSecurityDescriptorLength($[PSECURITY_DESCRIPTOR pSecurityDescriptor])

$~GetSecurityDescriptorRMControl
$[DWORD ]GetSecurityDescriptorRMControl($[PSECURITY_DESCRIPTOR SecurityDescriptor], $[PUCHAR RMControl])

$~GetSecurityInfo
$[DWORD ]GetSecurityInfo($[HANDLE handle], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID* ppsidOwner], $[PSID* ppsidGroup], $[PACL* ppDacl], $[PACL* ppSacl], $[PSECURITY_DESCRIPTOR* ppSecurityDescriptor])

$~GetSidLengthRequired
$[DWORD ]GetSidLengthRequired($[UCHAR nSubAuthorityCount])

$~InstallApplication
$[DWORD ]InstallApplication($[PINSTALLDATA* pInstallInfo])

$~LookupSecurityDescriptorPartsA
$[DWORD ]LookupSecurityDescriptorPartsA($[PTRUSTEE* pOwner], $[PTRUSTEE* pGroup], $[PULONG cCountOfAccessEntries], $[PEXPLICIT_ACCESS* pListOfAccessEntries], $[PULONG cCountOfAuditEntries], $[PEXPLICIT_ACCESS* pListOfAuditEntries], $[PSECURITY_DESCRIPTOR pSD])

$~LookupSecurityDescriptorPartsW
$[DWORD ]LookupSecurityDescriptorPartsW($[PTRUSTEE* pOwner], $[PTRUSTEE* pGroup], $[PULONG cCountOfAccessEntries], $[PEXPLICIT_ACCESS* pListOfAccessEntries], $[PULONG cCountOfAuditEntries], $[PEXPLICIT_ACCESS* pListOfAuditEntries], $[PSECURITY_DESCRIPTOR pSD])

$~MSChapSrvChangePassword
$[DWORD ]MSChapSrvChangePassword($[LPWSTR ServerName], $[LPWSTR UserName], $[BOOLEAN LmOldPresent], $[PLM_OWF_PASSWORD LmOldOwfPassword], $[PLM_OWF_PASSWORD LmNewOwfPassword], $[PNT_OWF_PASSWORD NtOldOwfPassword], $[PNT_OWF_PASSWORD NtNewOwfPassword])

$~MSChapSrvChangePassword2
$[DWORD ]MSChapSrvChangePassword2($[LPWSTR ServerName], $[LPWSTR UserName], $[PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldNt], $[PENCRYPTED_NT_OWF_PASSWORD OldNtOwfPasswordEncryptedWithNewNt], $[BOOLEAN LmPresent], $[PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm], $[PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewLmOrNt])

$~OpenEncryptedFileRawA
$[DWORD ]OpenEncryptedFileRawA($[LPCSTR lpFileName], $[ULONG ulFlags], $[PVOID* pvContext])

$~OpenEncryptedFileRawW
$[DWORD ]OpenEncryptedFileRawW($[LPCWSTR lpFileName], $[ULONG ulFlags], $[PVOID* pvContext])

$~QueryRecoveryAgentsOnEncryptedFile
$[DWORD ]QueryRecoveryAgentsOnEncryptedFile($[LPCWSTR lpFileName], $[PENCRYPTION_CERTIFICATE_HASH_LIST* pRecoveryAgents])

$~QueryUsersOnEncryptedFile
$[DWORD ]QueryUsersOnEncryptedFile($[LPCWSTR lpFileName], $[PENCRYPTION_CERTIFICATE_HASH_LIST* pUsers])

$~ReadEncryptedFileRaw
$[DWORD ]ReadEncryptedFileRaw($[PFE_EXPORT_FUNC pfExportCallback], $[PVOID pvCallbackContext], $[PVOID pvContext])

$~RemoveUsersFromEncryptedFile
$[DWORD ]RemoveUsersFromEncryptedFile($[LPCWSTR lpFileName], $[PENCRYPTION_CERTIFICATE_HASH_LIST pHashes])

$~SetEntriesInAclA
$[DWORD ]SetEntriesInAclA($[ULONG cCountOfExplicitEntries], $[PEXPLICIT_ACCESS pListOfExplicitEntries], $[PACL OldAcl], $[PACL* NewAcl])

$~SetEntriesInAclW
$[DWORD ]SetEntriesInAclW($[ULONG cCountOfExplicitEntries], $[PEXPLICIT_ACCESS pListOfExplicitEntries], $[PACL OldAcl], $[PACL* NewAcl])

$~SetNamedSecurityInfoA
$[DWORD ]SetNamedSecurityInfoA($[LPSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID psidOwner], $[PSID psidGroup], $[PACL pDacl], $[PACL pSacl])

$~SetNamedSecurityInfoW
$[DWORD ]SetNamedSecurityInfoW($[LPWSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID psidOwner], $[PSID psidGroup], $[PACL pDacl], $[PACL pSacl])

$~SetSecurityDescriptorRMControl
$[DWORD ]SetSecurityDescriptorRMControl($[PSECURITY DESCRIPTOR SecurityDescriptor], $[PUCHAR RMControl])

$~SetSecurityInfo
$[DWORD ]SetSecurityInfo($[HANDLE handle], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID psidOwner], $[PSID psidGroup], $[PACL pDacl], $[PACL pSacl])

$~SetUserFileEncryptionKey
$[DWORD ]SetUserFileEncryptionKey($[PENCRYPTION_CERTIFICATE pEncryptionCertificate])

$~TreeResetNamedSecurityInfoA
$[DWORD ]TreeResetNamedSecurityInfoA($[LPSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID pOwner], $[PSID pGroup], $[PACL pDacl], $[PACL pSacl], $[BOOL KeepExplicit], $[FN_PROGRESS fnProgress], $[PROG_INVOKE_SETTING ProgressInvokeSetting], $[PVOID Args])

$~TreeResetNamedSecurityInfoW
$[DWORD ]TreeResetNamedSecurityInfoW($[LPWSTR pObjectName], $[SE_OBJECT_TYPE ObjectType], $[SECURITY_INFORMATION SecurityInfo], $[PSID pOwner], $[PSID pGroup], $[PACL pDacl], $[PACL pSacl], $[BOOL KeepExplicit], $[FN_PROGRESS fnProgress], $[PROG_INVOKE_SETTING ProgressInvokeSetting], $[PVOID Args])

$~UninstallApplication
$[DWORD ]UninstallApplication($[WCHAR* ProductCode], $[DWORD dwStatus])

$~WriteEncryptedFileRaw
$[DWORD ]WriteEncryptedFileRaw($[PFE_IMPORT_FUNC pfImportCallback], $[PVOID pvCallbackContext], $[PVOID pvContext])

$~OpenBackupEventLogA
$[HANDLE ]OpenBackupEventLogA($[LPCSTR lpUNCServerName], $[LPCSTR lpFileName])

$~OpenBackupEventLogW
$[HANDLE ]OpenBackupEventLogW($[LPCWSTR lpUNCServerName], $[LPCWSTR lpFileName])

$~OpenEventLogA
$[HANDLE ]OpenEventLogA($[LPCSTR lpUNCServerName], $[LPCSTR lpSourceName])

$~OpenEventLogW
$[HANDLE ]OpenEventLogW($[LPCWSTR lpUNCServerName], $[LPCWSTR lpSourceName])

$~RegisterEventSourceA
$[HANDLE ]RegisterEventSourceA($[LPCSTR lpUNCServerName], $[LPCSTR lpSourceName])

$~RegisterEventSourceW
$[HANDLE ]RegisterEventSourceW($[LPCWSTR lpUNCServerName], $[LPCWSTR lpSourceName])

$~RegCloseKey
$[LONG ]RegCloseKey($[HKEY hKey])

$~RegConnectRegistryA
$[LONG ]RegConnectRegistryA($[LPCSTR lpMachineName], $[HKEY hKey], $[PHKEY phkResult])

$~RegConnectRegistryW
$[LONG ]RegConnectRegistryW($[LPCWSTR lpMachineName], $[HKEY hKey], $[PHKEY phkResult])

$~RegCreateKeyA
$[LONG ]RegCreateKeyA($[HKEY hKey], $[LPCSTR lpSubKey], $[PHKEY phkResult])

$~RegCreateKeyExA
$[LONG ]RegCreateKeyExA($[HKEY hKey], $[LPCSTR lpSubKey], $[DWORD Reserved], $[LPSTR lpClass], $[DWORD dwOptions], $[REGSAM samDesired], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[PHKEY phkResult], $[LPDWORD lpdwDisposition])

$~RegCreateKeyExW
$[LONG ]RegCreateKeyExW($[HKEY hKey], $[LPCWSTR lpSubKey], $[DWORD Reserved], $[LPWSTR lpClass], $[DWORD dwOptions], $[REGSAM samDesired], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[PHKEY phkResult], $[LPDWORD lpdwDisposition])

$~RegCreateKeyW
$[LONG ]RegCreateKeyW($[HKEY hKey], $[LPCWSTR lpSubKey], $[PHKEY phkResult])

$~RegDeleteKeyA
$[LONG ]RegDeleteKeyA($[HKEY hKey], $[LPCSTR lpSubKey])

$~RegDeleteKeyW
$[LONG ]RegDeleteKeyW($[HKEY hKey], $[LPCWSTR lpSubKey])

$~RegDeleteValueA
$[LONG ]RegDeleteValueA($[HKEY hKey], $[LPCSTR lpValueName])

$~RegDeleteValueW
$[LONG ]RegDeleteValueW($[HKEY hKey], $[LPCWSTR lpValueName])

$~RegDisablePredefinedCache
$[LONG ]RegDisablePredefinedCache($[])

$~RegEnumKeyA
$[LONG ]RegEnumKeyA($[HKEY hKey], $[DWORD dwIndex], $[LPSTR lpName], $[DWORD cchName])

$~RegEnumKeyExA
$[LONG ]RegEnumKeyExA($[HKEY hKey], $[DWORD dwIndex], $[LPSTR lpName], $[LPDWORD lpcName], $[LPDWORD lpReserved], $[LPSTR lpClass], $[LPDWORD lpcClass], $[PFILETIME lpftLastWriteTime])

$~RegEnumKeyExW
$[LONG ]RegEnumKeyExW($[HKEY hKey], $[DWORD dwIndex], $[LPWSTR lpName], $[LPDWORD lpcName], $[LPDWORD lpReserved], $[LPWSTR lpClass], $[LPDWORD lpcClass], $[PFILETIME lpftLastWriteTime])

$~RegEnumKeyW
$[LONG ]RegEnumKeyW($[HKEY hKey], $[DWORD dwIndex], $[LPWSTR lpName], $[DWORD cchName])

$~RegEnumValueA
$[LONG ]RegEnumValueA($[HKEY hKey], $[DWORD dwIndex], $[LPSTR lpValueName], $[LPDWORD lpcValueName], $[LPDWORD lpReserved], $[LPDWORD lpType], $[LPBYTE lpData], $[LPDWORD lpcbData])

$~RegEnumValueW
$[LONG ]RegEnumValueW($[HKEY hKey], $[DWORD dwIndex], $[LPWSTR lpValueName], $[LPDWORD lpcValueName], $[LPDWORD lpReserved], $[LPDWORD lpType], $[LPBYTE lpData], $[LPDWORD lpcbData])

$~RegFlushKey
$[LONG ]RegFlushKey($[HKEY hKey])

$~RegGetKeySecurity
$[LONG ]RegGetKeySecurity($[HKEY hKey], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor], $[LPDWORD lpcbSecurityDescriptor])

$~RegLoadKeyA
$[LONG ]RegLoadKeyA($[HKEY hKey], $[LPCSTR lpSubKey], $[LPCSTR lpFile])

$~RegLoadKeyW
$[LONG ]RegLoadKeyW($[HKEY hKey], $[LPCWSTR lpSubKey], $[LPCWSTR lpFile])

$~RegNotifyChangeKeyValue
$[LONG ]RegNotifyChangeKeyValue($[HKEY hKey], $[BOOL bWatchSubtree], $[DWORD dwNotifyFilter], $[HANDLE hEvent], $[BOOL fAsynchronous])

$~RegOpenCurrentUser
$[LONG ]RegOpenCurrentUser($[REGSAM samDesired], $[PHKEY phkResult])

$~RegOpenKeyA
$[LONG ]RegOpenKeyA($[HKEY hKey], $[LPCSTR lpSubKey], $[PHKEY phkResult])

$~RegOpenKeyExA
$[LONG ]RegOpenKeyExA($[HKEY hKey], $[LPCSTR lpSubKey], $[DWORD ulOptions], $[REGSAM samDesired], $[PHKEY phkResult])

$~RegOpenKeyExW
$[LONG ]RegOpenKeyExW($[HKEY hKey], $[LPCWSTR lpSubKey], $[DWORD ulOptions], $[REGSAM samDesired], $[PHKEY phkResult])

$~RegOpenKeyW
$[LONG ]RegOpenKeyW($[HKEY hKey], $[LPCWSTR lpSubKey], $[PHKEY phkResult])

$~RegOpenUserClassesRoot
$[LONG ]RegOpenUserClassesRoot($[HANDLE hToken], $[DWORD dwOptions], $[REGSAM samDesired], $[PHKEY phkResult])

$~RegOverridePredefKey
$[LONG ]RegOverridePredefKey($[HKEY hKey], $[HKEY hNewHKey])

$~RegQueryInfoKeyA
$[LONG ]RegQueryInfoKeyA($[HKEY hKey], $[LPSTR lpClass], $[LPDWORD lpcClass], $[LPDWORD lpReserved], $[LPDWORD lpcSubKeys], $[LPDWORD lpcMaxSubKeyLen], $[LPDWORD lpcMaxClassLen], $[LPDWORD lpcValues], $[LPDWORD lpcMaxValueNameLen], $[LPDWORD lpcMaxValueLen], $[LPDWORD lpcbSecurityDescriptor], $[PFILETIME lpftLastWriteTime])

$~RegQueryInfoKeyW
$[LONG ]RegQueryInfoKeyW($[HKEY hKey], $[LPWSTR lpClass], $[LPDWORD lpcClass], $[LPDWORD lpReserved], $[LPDWORD lpcSubKeys], $[LPDWORD lpcMaxSubKeyLen], $[LPDWORD lpcMaxClassLen], $[LPDWORD lpcValues], $[LPDWORD lpcMaxValueNameLen], $[LPDWORD lpcMaxValueLen], $[LPDWORD lpcbSecurityDescriptor], $[PFILETIME lpftLastWriteTime])

$~RegQueryMultipleValuesA
$[LONG ]RegQueryMultipleValuesA($[HKEY hKey], $[PVALENT val_list], $[DWORD num_vals], $[LPSTR lpValueBuf], $[LPDWORD ldwTotsize])

$~RegQueryMultipleValuesW
$[LONG ]RegQueryMultipleValuesW($[HKEY hKey], $[PVALENT val_list], $[DWORD num_vals], $[LPWSTR lpValueBuf], $[LPDWORD ldwTotsize])

$~RegQueryValueA
$[LONG ]RegQueryValueA($[HKEY hKey], $[LPCSTR lpSubKey], $[LPSTR lpValue], $[PLONG lpcbValue])

$~RegQueryValueExA
$[LONG ]RegQueryValueExA($[HKEY hKey], $[LPCSTR lpValueName], $[LPDWORD lpReserved], $[LPDWORD lpType], $[LPBYTE lpData], $[LPDWORD lpcbData])

$~RegQueryValueExW
$[LONG ]RegQueryValueExW($[HKEY hKey], $[LPCWSTR lpValueName], $[LPDWORD lpReserved], $[LPDWORD lpType], $[LPBYTE lpData], $[LPDWORD lpcbData])

$~RegQueryValueW
$[LONG ]RegQueryValueW($[HKEY hKey], $[LPCWSTR lpSubKey], $[LPWSTR lpValue], $[PLONG lpcbValue])

$~RegReplaceKeyA
$[LONG ]RegReplaceKeyA($[HKEY hKey], $[LPCSTR lpSubKey], $[LPCSTR lpNewFile], $[LPCSTR lpOldFile])

$~RegReplaceKeyW
$[LONG ]RegReplaceKeyW($[HKEY hKey], $[LPCWSTR lpSubKey], $[LPCWSTR lpNewFile], $[LPCWSTR lpOldFile])

$~RegRestoreKeyA
$[LONG ]RegRestoreKeyA($[HKEY hKey], $[LPCSTR lpFile], $[DWORD dwFlags])

$~RegRestoreKeyW
$[LONG ]RegRestoreKeyW($[HKEY hKey], $[LPCWSTR lpFile], $[DWORD dwFlags])

$~RegSaveKeyA
$[LONG ]RegSaveKeyA($[HKEY hKey], $[LPCSTR lpFile], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~RegSaveKeyExA
$[LONG ]RegSaveKeyExA($[HKEY hKey], $[LPCSTR lpFile], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[DWORD Flags])

$~RegSaveKeyExW
$[LONG ]RegSaveKeyExW($[HKEY hKey], $[LPCWSTR lpFile], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[DWORD Flags])

$~RegSaveKeyW
$[LONG ]RegSaveKeyW($[HKEY hKey], $[LPCWSTR lpFile], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~RegSetKeySecurity
$[LONG ]RegSetKeySecurity($[HKEY hKey], $[SECURITY_INFORMATION SecurityInformation], $[PSECURITY_DESCRIPTOR pSecurityDescriptor])

$~RegSetValueA
$[LONG ]RegSetValueA($[HKEY hKey], $[LPCSTR lpSubKey], $[DWORD dwType], $[LPCSTR lpData], $[DWORD cbData])

$~RegSetValueExA
$[LONG ]RegSetValueExA($[HKEY hKey], $[LPCSTR lpValueName], $[DWORD Reserved], $[DWORD dwType], $[const BYTE* lpData], $[DWORD cbData])

$~RegSetValueExW
$[LONG ]RegSetValueExW($[HKEY hKey], $[LPCWSTR lpValueName], $[DWORD Reserved], $[DWORD dwType], $[const BYTE* lpData], $[DWORD cbData])

$~RegSetValueW
$[LONG ]RegSetValueW($[HKEY hKey], $[LPCWSTR lpSubKey], $[DWORD dwType], $[LPCWSTR lpData], $[DWORD cbData])

$~RegUnLoadKeyA
$[LONG ]RegUnLoadKeyA($[HKEY hKey], $[LPCSTR lpSubKey])

$~RegUnLoadKeyW
$[LONG ]RegUnLoadKeyW($[HKEY hKey], $[LPCWSTR lpSubKey])

$~GetTrusteeNameA
$[LPSTR ]GetTrusteeNameA($[PTRUSTEE pTrustee])

$~GetTrusteeNameW
$[LPWSTR ]GetTrusteeNameW($[PTRUSTEE pTrustee])

$~LsaAddAccountRights
$[NTSTATUS ]LsaAddAccountRights($[LSA_HANDLE PolicyHandle], $[PSID AccountSid], $[PLSA_UNICODE_STRING UserRights], $[ULONG CountOfRights])

$~LsaClose
$[NTSTATUS ]LsaClose($[LSA_HANDLE ObjectHandle])

$~LsaCreateTrustedDomainEx
$[NTSTATUS ]LsaCreateTrustedDomainEx($[LSA_HANDLE PolicyHandle], $[PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation], $[PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation], $[ACCESS_MASK DesiredAccess], $[PLSA_HANDLE TrustedDomainHandle])

$~LsaDeleteTrustedDomain
$[NTSTATUS ]LsaDeleteTrustedDomain($[LSA_HANDLE PolicyHandle], $[PSID TrustedDomainSid])

$~LsaEnumerateAccountRights
$[NTSTATUS ]LsaEnumerateAccountRights($[LSA_HANDLE PolicyHandle], $[PSID AccountSid], $[PLSA_UNICODE_STRING* UserRights], $[PULONG CountOfRights])

$~LsaEnumerateAccountsWithUserRight
$[NTSTATUS ]LsaEnumerateAccountsWithUserRight($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING UserRights], $[PVOID* EnumerationBuffer], $[PULONG CountReturned])

$~LsaEnumerateTrustedDomains
$[NTSTATUS ]LsaEnumerateTrustedDomains($[LSA_HANDLE PolicyHandle], $[PLSA_ENUMERATION_HANDLE EnumerationContext], $[PVOID* Buffer], $[ULONG PreferedMaximumLength], $[PULONG CountReturned])

$~LsaEnumerateTrustedDomainsEx
$[NTSTATUS ]LsaEnumerateTrustedDomainsEx($[LSA_HANDLE PolicyHandle], $[PLSA_ENUMERATION_HANDLE EnumerationContext], $[PVOID* Buffer], $[ULONG PreferredMaximumLength], $[PULONG CountReturned])

$~LsaFreeMemory
$[NTSTATUS ]LsaFreeMemory($[PVOID Buffer])

$~LsaLookupNames
$[NTSTATUS ]LsaLookupNames($[LSA_HANDLE PolicyHandle], $[ULONG Count], $[PLSA_UNICODE_STRING Names], $[PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains], $[PLSA_TRANSLATED_SID* Sids])

$~LsaLookupNames2
$[NTSTATUS ]LsaLookupNames2($[LSA_HANDLE PolicyHandle], $[ULONG Flags], $[ULONG Count], $[PLSA_UNICODE_STRING Names], $[PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains], $[PLSA_TRANSLATED_SID2* Sids])

$~LsaLookupSids
$[NTSTATUS ]LsaLookupSids($[LSA_HANDLE PolicyHandle], $[ULONG Count], $[PSID* Sids], $[PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains], $[PLSA_TRANSLATED_NAME* Names])

$~LsaOpenPolicy
$[NTSTATUS ]LsaOpenPolicy($[PLSA_UNICODE_STRING SystemName], $[PLSA_OBJECT_ATTRIBUTES ObjectAttributes], $[ACCESS_MASK DesiredAccess], $[PLSA_HANDLE PolicyHandle])

$~LsaOpenTrustedDomainByName
$[NTSTATUS ]LsaOpenTrustedDomainByName($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING TrustedDomainName], $[ACCESS_MASK DesiredAccess], $[PLSA_HANDLE TrustedDomainHandle])

$~LsaQueryInformationPolicy
$[NTSTATUS ]LsaQueryInformationPolicy($[LSA_HANDLE PolicyHandle], $[POLICY_INFORMATION_CLASS InformationClass], $[PVOID* Buffer])

$~LsaQueryTrustedDomainInfo
$[NTSTATUS ]LsaQueryTrustedDomainInfo($[LSA_HANDLE PolicyHandle], $[PSID TrustedDomainSid], $[TRUSTED_INFORMATION_CLASS InformationClass], $[PVOID* Buffer])

$~LsaQueryTrustedDomainInfoByName
$[NTSTATUS ]LsaQueryTrustedDomainInfoByName($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING TrustedDomainName], $[TRUSTED_INFORMATION_CLASS InformationClass], $[PVOID* Buffer])

$~LsaRemoveAccountRights
$[NTSTATUS ]LsaRemoveAccountRights($[LSA_HANDLE PolicyHandle], $[PSID AccountSid], $[BOOLEAN AllRights], $[PLSA_UNICODE_STRING UserRights], $[ULONG CountOfRights])

$~LsaRetrievePrivateData
$[NTSTATUS ]LsaRetrievePrivateData($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING KeyName], $[PLSA_UNICODE_STRING* PrivateData])

$~LsaSetInformationPolicy
$[NTSTATUS ]LsaSetInformationPolicy($[LSA_HANDLE PolicyHandle], $[POLICY_INFORMATION_CLASS InformationClass], $[PVOID Buffer])

$~LsaSetTrustedDomainInfoByName
$[NTSTATUS ]LsaSetTrustedDomainInfoByName($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING TrustedDomainName], $[TRUSTED_INFORMATION_CLASS InformationClass], $[PVOID Buffer])

$~LsaSetTrustedDomainInformation
$[NTSTATUS ]LsaSetTrustedDomainInformation($[LSA_HANDLE PolicyHandle], $[PSID TrustedDomainSid], $[TRUSTED_INFORMATION_CLASS InformationClass], $[PVOID Buffer])

$~LsaStorePrivateData
$[NTSTATUS ]LsaStorePrivateData($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING KeyName], $[PLSA_UNICODE_STRING PrivateData])

$~LsaQueryDomainInformationPolicy
$[NTSTATUS NTAPI ]LsaQueryDomainInformationPolicy($[LSA_HANDLE PolicyHandle], $[POLICY_DOMAIN_INFORMATION_CLASS InformationClass], $[PVOID* Buffer])

$~LsaQueryForestTrustInformation
$[NTSTATUS NTAPI ]LsaQueryForestTrustInformation($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING TrustedDomainName], $[PLSA_FOREST_TRUST_INFORMATION* ForestTrustInfo])

$~LsaSetDomainInformationPolicy
$[NTSTATUS NTAPI ]LsaSetDomainInformationPolicy($[LSA_HANDLE PolicyHandle], $[POLICY_DOMAIN_INFORMATION_CLASS InformationClass], $[PVOID Buffer])

$~LsaSetForestTrustInformation
$[NTSTATUS NTAPI ]LsaSetForestTrustInformation($[LSA_HANDLE PolicyHandle], $[PLSA_UNICODE_STRING TrustedDomainName], $[PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo], $[BOOLEAN CheckOnly], $[PLSA_FOREST_TRUST_COLLISION_INFORMATION* CollisionInfo])

$~GetSidSubAuthority
$[PDWORD ]GetSidSubAuthority($[PSID pSid], $[DWORD nSubAuthority])

$~GetSidIdentifierAuthority
$[PSID_IDENTIFIER_AUTHORITY ]GetSidIdentifierAuthority($[PSID pSid])

$~GetSidSubAuthorityCount
$[PUCHAR ]GetSidSubAuthorityCount($[PSID pSid])

$~FreeSid
$[PVOID ]FreeSid($[PSID pSid])

$~CreateServiceA
$[SC_HANDLE ]CreateServiceA($[SC_HANDLE hSCManager], $[LPCSTR lpServiceName], $[LPCSTR lpDisplayName], $[DWORD dwDesiredAccess], $[DWORD dwServiceType], $[DWORD dwStartType], $[DWORD dwErrorControl], $[LPCSTR lpBinaryPathName], $[LPCSTR lpLoadOrderGroup], $[LPDWORD lpdwTagId], $[LPCSTR lpDependencies], $[LPCSTR lpServiceStartName], $[LPCSTR lpPassword])

$~CreateServiceW
$[SC_HANDLE ]CreateServiceW($[SC_HANDLE hSCManager], $[LPCWSTR lpServiceName], $[LPCWSTR lpDisplayName], $[DWORD dwDesiredAccess], $[DWORD dwServiceType], $[DWORD dwStartType], $[DWORD dwErrorControl], $[LPCWSTR lpBinaryPathName], $[LPCWSTR lpLoadOrderGroup], $[LPDWORD lpdwTagId], $[LPCSTR lpDependencies], $[LPCWSTR lpServiceStartName], $[LPCWSTR lpPassword])

$~OpenSCManagerA
$[SC_HANDLE ]OpenSCManagerA($[LPCSTR lpMachineName], $[LPCSTR lpDatabaseName], $[DWORD dwDesiredAccess])

$~OpenSCManagerW
$[SC_HANDLE ]OpenSCManagerW($[LPCWSTR lpMachineName], $[LPCWSTR lpDatabaseName], $[DWORD dwDesiredAccess])

$~OpenServiceA
$[SC_HANDLE ]OpenServiceA($[SC_HANDLE hSCManager], $[LPCSTR lpServiceName], $[DWORD dwDesiredAccess])

$~OpenServiceW
$[SC_HANDLE ]OpenServiceW($[SC_HANDLE hSCManager], $[LPCWSTR lpServiceName], $[DWORD dwDesiredAccess])

$~LockServiceDatabase
$[SC_LOCK ]LockServiceDatabase($[SC_HANDLE hSCManager])

$~RegisterServiceCtrlHandlerA
$[SERVICE_STATUS_HANDLE ]RegisterServiceCtrlHandlerA($[LPCSTR lpServiceName], $[LPHANDLER_FUNCTION lpHandlerProc])

$~RegisterServiceCtrlHandlerExA
$[SERVICE_STATUS_HANDLE ]RegisterServiceCtrlHandlerExA($[LPCSTR lpServiceName], $[LPHANDLER_FUNCTION_EX lpHandlerProc], $[LPVOID lpContext])

$~RegisterServiceCtrlHandlerExW
$[SERVICE_STATUS_HANDLE ]RegisterServiceCtrlHandlerExW($[LPCWSTR lpServiceName], $[LPHANDLER_FUNCTION_EX lpHandlerProc], $[LPVOID lpContext])

$~RegisterServiceCtrlHandlerW
$[SERVICE_STATUS_HANDLE ]RegisterServiceCtrlHandlerW($[LPCWSTR lpServiceName], $[LPHANDLER_FUNCTION lpHandlerProc])

$~GetTraceLoggerHandle
$[TRACEHANDLE ]GetTraceLoggerHandle($[PVOID Buffer])

$~OpenTraceA
$[TRACEHANDLE ]OpenTraceA($[PEVENT_TRACE_LOGFILE Logfile])

$~OpenTraceW
$[TRACEHANDLE ]OpenTraceW($[PEVENT_TRACE_LOGFILE Logfile])

$~GetTrusteeFormA
$[TRUSTEE_FORM ]GetTrusteeFormA($[PTRUSTEE pTrustee])

$~GetTrusteeFormW
$[TRUSTEE_FORM ]GetTrusteeFormW($[PTRUSTEE pTrustee])

$~GetTrusteeTypeA
$[TRUSTEE_TYPE ]GetTrusteeTypeA($[PTRUSTEE pTrustee])

$~GetTrusteeTypeW
$[TRUSTEE_TYPE ]GetTrusteeTypeW($[PTRUSTEE pTrustee])

$~GetTraceEnableLevel
$[UCHAR ]GetTraceEnableLevel($[TRACEHANDLE SessionHandle])

$~CloseTrace
$[ULONG ]CloseTrace($[TRACEHANDLE TraceHandle])

$~ControlTraceA
$[ULONG ]ControlTraceA($[TRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties], $[ULONG ControlCode])

$~ControlTraceW
$[ULONG ]ControlTraceW($[TRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties], $[ULONG ControlCode])

$~CreateTraceInstanceId
$[ULONG ]CreateTraceInstanceId($[HANDLE RegHandle], $[PEVENT_INSTANCE_INFO pInstInfo])

$~EnableTrace
$[ULONG ]EnableTrace($[ULONG Enable], $[ULONG EnableFlag], $[ULONG EnableLevel], $[LPCGUID ControlGuid], $[TRACEHANDLE SessionHandle])

$~EnumerateTraceGuids
$[ULONG ]EnumerateTraceGuids($[PTRACE_GUID_PROPERTIES* GuidPropertiesArray], $[ULONG PropertyArrayCount], $[PULONG GuidCount])

$~FlushTraceA
$[ULONG ]FlushTraceA($[TRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~FlushTraceW
$[ULONG ]FlushTraceW($[TRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~GetTraceEnableFlags
$[ULONG ]GetTraceEnableFlags($[TRACEHANDLE SessionHandle])

$~LsaNtStatusToWinError
$[ULONG ]LsaNtStatusToWinError($[NTSTATUS Status])

$~QueryAllTracesA
$[ULONG ]QueryAllTracesA($[PEVENT_TRACE_PROPERTIES* PropertyArray], $[ULONG PropertyArrayCount], $[PULONG SessionCount])

$~QueryAllTracesW
$[ULONG ]QueryAllTracesW($[PEVENT_TRACE_PROPERTIES* PropertyArray], $[ULONG PropertyArrayCount], $[PULONG SessionCount])

$~QueryTraceA
$[ULONG ]QueryTraceA($[TRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~QueryTraceW
$[ULONG ]QueryTraceW($[TRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~RemoveTraceCallback
$[ULONG ]RemoveTraceCallback($[LPCGUID pGuid])

$~SetTraceCallback
$[ULONG ]SetTraceCallback($[LPCGUID pGuid], $[PEVENT_CALLBACK EventCallback])

$~StartTraceA
$[ULONG ]StartTraceA($[PTRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~StartTraceW
$[ULONG ]StartTraceW($[PTRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~StopTraceA
$[ULONG ]StopTraceA($[TRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~StopTraceW
$[ULONG ]StopTraceW($[TRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~TraceEvent
$[ULONG ]TraceEvent($[TRACEHANDLE SessionHandle], $[PEVENT_TRACE_HEADER EventTrace])

$~TraceEventInstance
$[ULONG ]TraceEventInstance($[TRACEHANDLE SessionHandle], $[PEVENT_INSTANCE_HEADER EventTrace], $[PEVENT_INSTANCE_INFO pInstInfo], $[PEVENT_INSTANCE_INFO pParentInstInfo])

$~TraceMessage
$[ULONG ]TraceMessage($[TRACEHANDLE SessionHandle], $[ULONG MessageFlags], $[LPGUID MessageGuid], $[USHORT MessageNumber])

$~TraceMessageVa
$[ULONG ]TraceMessageVa($[TRACEHANDLE SessionHandle], $[ULONG MessageFlags], $[LPGUID MessageGuid], $[USHORT MessageNumber], $[va_list MessageArgList])

$~UnregisterTraceGuids
$[ULONG ]UnregisterTraceGuids($[TRACEHANDLE RegistrationHandle])

$~UpdateTraceA
$[ULONG ]UpdateTraceA($[TRACEHANDLE SessionHandle], $[LPCSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~UpdateTraceW
$[ULONG ]UpdateTraceW($[TRACEHANDLE SessionHandle], $[LPCWSTR SessionName], $[PEVENT_TRACE_PROPERTIES Properties])

$~BuildExplicitAccessWithNameA
$[VOID ]BuildExplicitAccessWithNameA($[PEXPLICIT_ACCESS pExplicitAccess], $[LPSTR pTrusteeName], $[DWORD AccessPermissions], $[ACCESS_MODE AccessMode], $[DWORD Inheritance])

$~BuildExplicitAccessWithNameW
$[VOID ]BuildExplicitAccessWithNameW($[PEXPLICIT_ACCESS pExplicitAccess], $[LPWSTR pTrusteeName], $[DWORD AccessPermissions], $[ACCESS_MODE AccessMode], $[DWORD Inheritance])

$~BuildTrusteeWithNameA
$[void ]BuildTrusteeWithNameA($[PTRUSTEE pTrustee], $[LPSTR pName])

$~BuildTrusteeWithNameW
$[void ]BuildTrusteeWithNameW($[PTRUSTEE pTrustee], $[LPWSTR pName])

$~BuildTrusteeWithObjectsAndNameA
$[void ]BuildTrusteeWithObjectsAndNameA($[PTRUSTEE pTrustee], $[POBJECTS_AND_NAME pObjName], $[SE_OBJECT_TYPE ObjectType], $[LPSTR ObjectTypeName], $[LPSTR InheritedObjectTypeName], $[LPSTR Name])

$~BuildTrusteeWithObjectsAndNameW
$[void ]BuildTrusteeWithObjectsAndNameW($[PTRUSTEE pTrustee], $[POBJECTS_AND_NAME pObjName], $[SE_OBJECT_TYPE ObjectType], $[LPSTR ObjectTypeName], $[LPSTR InheritedObjectTypeName], $[LPSTR Name])

$~BuildTrusteeWithObjectsAndSidA
$[void ]BuildTrusteeWithObjectsAndSidA($[PTRUSTEE pTrustee], $[POBJECTS_AND_SID pObjSid], $[GUID* pObjectGuid], $[GUID* pInheritedObjectGuid], $[PSID pSid])

$~BuildTrusteeWithObjectsAndSidW
$[void ]BuildTrusteeWithObjectsAndSidW($[PTRUSTEE pTrustee], $[POBJECTS_AND_SID pObjSid], $[GUID* pObjectGuid], $[GUID* pInheritedObjectGuid], $[PSID pSid])

$~BuildTrusteeWithSidA
$[VOID ]BuildTrusteeWithSidA($[PTRUSTEE pTrustee], $[PSID pSid])

$~BuildTrusteeWithSidW
$[VOID ]BuildTrusteeWithSidW($[PTRUSTEE pTrustee], $[PSID pSid])

$~CloseEncryptedFileRaw
$[void ]CloseEncryptedFileRaw($[PVOID pvContext])

$~CredFree
$[VOID ]CredFree($[PVOID Buffer])

$~FreeEncryptionCertificateHashList
$[VOID ]FreeEncryptionCertificateHashList($[PENCRYPTION_CERTIFICATE_HASH_LIST pHashes])

$~MapGenericMask
$[VOID ]MapGenericMask($[PDWORD AccessMask], $[PGENERIC_MAPPING GenericMapping])

$~MD5Final
$[void ]MD5Final($[MD5_CTX* context])

$~MD5Init
$[void ]MD5Init($[MD5_CTX* context])

$~MD5Update
$[void ]MD5Update($[MD5_CTX* context], $[const unsigned char* input], $[unsigned int inlen])

$; comctl32.dll
$; ------------
$~DestroyPropertySheetPage
$[BOOL ]DestroyPropertySheetPage($[HPROPSHEETPAGE hPSPage])

$~DPA_DeleteAllPtrs
$[BOOL ]DPA_DeleteAllPtrs($[HDPA pdpa])

$~DPA_Destroy
$[BOOL ]DPA_Destroy($[HDPA pdpa])

$~DPA_SetPtr
$[BOOL ]DPA_SetPtr($[HDPA pdpa], $[int index], $[void *p])

$~DPA_Sort
$[BOOL ]DPA_Sort($[HDPA pdpa], $[PFNDPACOMPARE pfnCmp], $[LPARAM lParam])

$~DSA_DeleteAllItems
$[BOOL ]DSA_DeleteAllItems($[HDSA hdsa])

$~DSA_Destroy
$[BOOL ]DSA_Destroy($[HDSA pdsa])

$~FlatSB_EnableScrollBar
$[BOOL ]FlatSB_EnableScrollBar($[HWND hwnd], $[int wSBflags], $[UINT wArrows])

$~FlatSB_GetScrollInfo
$[BOOL ]FlatSB_GetScrollInfo($[HWND hwnd], $[int fnBar], $[LPSCROLLINFO lpsi])

$~FlatSB_GetScrollProp
$[BOOL ]FlatSB_GetScrollProp($[HWND hwnd], $[UINT index], $[LPINT pValue])

$~FlatSB_GetScrollRange
$[BOOL ]FlatSB_GetScrollRange($[HWND hwnd], $[int code], $[LPINT lpMinPos], $[LPINT lpMaxPos])

$~FlatSB_SetScrollProp
$[BOOL ]FlatSB_SetScrollProp($[HWND hwnd], $[UINT index], $[INT_PTR newValue], $[BOOL fRedraw])

$~FlatSB_ShowScrollBar
$[BOOL ]FlatSB_ShowScrollBar($[HWND hwnd], $[int code], $[BOOL fShow])

$~ImageList_BeginDrag
$[BOOL ]ImageList_BeginDrag($[HIMAGELIST himlTrack], $[int iTrack], $[int dxHotspot], $[int dyHotspot])

$~ImageList_Copy
$[BOOL ]ImageList_Copy($[HIMAGELIST himlDst], $[HIMAGELIST himlSrc], $[int iDst], $[int iSrc], $[UINT uFlags])

$~ImageList_Destroy
$[BOOL ]ImageList_Destroy($[HIMAGELIST himl])

$~ImageList_DragEnter
$[BOOL ]ImageList_DragEnter($[HWND hwndLock], $[int x], $[int y])

$~ImageList_DragLeave
$[BOOL ]ImageList_DragLeave($[HWND hwndLock])

$~ImageList_DragMove
$[BOOL ]ImageList_DragMove($[int x], $[int y])

$~ImageList_DragShowNolock
$[BOOL ]ImageList_DragShowNolock($[BOOL fShow])

$~ImageList_Draw
$[BOOL ]ImageList_Draw($[HIMAGELIST himl], $[int i], $[HDC hdcDst], $[int x], $[int y], $[UINT fStyle])

$~ImageList_DrawEx
$[BOOL ]ImageList_DrawEx($[HIMAGELIST himl], $[int i], $[HDC hdcDst], $[int x], $[int y], $[int dx], $[int dy], $[COLORREF rgbBk], $[COLORREF rgbFg], $[UINT fStyle])

$~ImageList_DrawIndirect
$[BOOL ]ImageList_DrawIndirect($[IMAGELISTDRAWPARAMS *pimldp])

$~ImageList_GetIconSize
$[BOOL ]ImageList_GetIconSize($[HIMAGELIST himl], $[int *cx], $[int *cy])

$~ImageList_GetImageInfo
$[BOOL ]ImageList_GetImageInfo($[HIMAGELIST himl], $[int i], $[IMAGEINFO FAR* pImageInfo])

$~ImageList_Remove
$[BOOL ]ImageList_Remove($[HIMAGELIST himl], $[int i])

$~ImageList_Replace
$[BOOL ]ImageList_Replace($[HIMAGELIST himl], $[int i], $[HBITMAP hbmImage], $[HBITMAP hbmMask])

$~ImageList_SetDragCursorImage
$[BOOL ]ImageList_SetDragCursorImage($[HIMAGELIST himlDrag], $[int iDrag], $[int dxHotspot], $[int dyHotspot])

$~ImageList_SetIconSize
$[BOOL ]ImageList_SetIconSize($[HIMAGELIST himl], $[int cx], $[int cy])

$~ImageList_SetImageCount
$[BOOL ]ImageList_SetImageCount($[HIMAGELIST himl], $[UINT uNewCount])

$~ImageList_SetOverlayImage
$[BOOL ]ImageList_SetOverlayImage($[HIMAGELIST himl], $[int iImage], $[int iOverlay])

$~ImageList_Write
$[BOOL ]ImageList_Write($[HIMAGELIST himl], $[LPSTREAM pstm])

$~InitCommonControlsEx
$[BOOL ]InitCommonControlsEx($[LPINITCOMMONCONTROLSEX lpInitCtrls])

$~InitializeFlatSB
$[BOOL ]InitializeFlatSB($[HWND hwnd])

$~MakeDragList
$[BOOL ]MakeDragList($[HWND hLB])

$~RemoveWindowSubclass
$[BOOL ]RemoveWindowSubclass($[HWND hWnd], $[SUBCLASSPROC pfnSubclass], $[UINT_PTR uIdSubclass])

$~SetWindowSubclass
$[BOOL ]SetWindowSubclass($[HWND hWnd], $[SUBCLASSPROC pfnSubclass], $[UINT_PTR uIdSubclass], $[DWORD_PTR dwRefData])

$~ShowHideMenuCtl
$[BOOL ]ShowHideMenuCtl($[HWND hWnd], $[UINT_PTR uFlags], $[LPINT lpInfo])

$~Str_SetPtrW
$[BOOL ]Str_SetPtrW($[LPWSTR *ppszCurrent], $[LPCWSTR pszNew])

$~_TrackMouseEvent
$[BOOL ]_TrackMouseEvent($[LPTRACKMOUSEEVENT lpEventTrack])

$~ImageList_GetBkColor
$[COLORREF ]ImageList_GetBkColor($[HIMAGELIST himl])

$~ImageList_SetBkColor
$[COLORREF ]ImageList_SetBkColor($[HIMAGELIST himl], $[COLORREF clrBk])

$~CreateMappedBitmap
$[HBITMAP ]CreateMappedBitmap($[HINSTANCE hInstance], $[INT_PTR idBitmap], $[UINT wFlags], $[LPCOLORMAP lpColorMap], $[int iNumMaps])

$~DPA_Create
$[HDPA ]DPA_Create($[int cpGrow])

$~DSA_Create
$[HDSA ]DSA_Create($[int cbItem], $[int cbItemGrow])

$~ImageList_GetIcon
$[HICON ]ImageList_GetIcon($[HIMAGELIST himl], $[int i], $[UINT flags])

$~ImageList_Create
$[HIMAGELIST ]ImageList_Create($[int cx], $[int cy], $[UINT flags], $[int cInitial], $[int cGrow])

$~ImageList_Duplicate
$[HIMAGELIST ]ImageList_Duplicate($[HIMAGELIST himl])

$~ImageList_GetDragImage
$[HIMAGELIST ]ImageList_GetDragImage($[POINT *ppt], $[POINT *pptHotspot])

$~ImageList_LoadImage
$[HIMAGELIST ]ImageList_LoadImage($[HINSTANCE hi], $[LPCSTR lpbmp], $[int cx], $[int cGrow], $[COLORREF crMask], $[UINT uType], $[UINT uFlags])

$~ImageList_LoadImageA
$[HIMAGELIST ]ImageList_LoadImageA($[HINSTANCE hi], $[LPCSTR lpbmp], $[int cx], $[int cGrow], $[COLORREF crMask], $[UINT uType], $[UINT uFlags])

$~ImageList_LoadImageW
$[HIMAGELIST ]ImageList_LoadImageW($[HINSTANCE hi], $[LPCSTR lpbmp], $[int cx], $[int cGrow], $[COLORREF crMask], $[UINT uType], $[UINT uFlags])

$~ImageList_Merge
$[HIMAGELIST ]ImageList_Merge($[HIMAGELIST himl1], $[int i1], $[HIMAGELIST himl2], $[int i2], $[int dx], $[int dy])

$~ImageList_Read
$[HIMAGELIST ]ImageList_Read($[LPSTREAM pstm])

$~CreatePropertySheetPage
$[HPROPSHEETPAGE ]CreatePropertySheetPage($[LPCPROPSHEETPAGE lppsp])

$~CreatePropertySheetPageA
$[HPROPSHEETPAGE ]CreatePropertySheetPageA($[LPCPROPSHEETPAGE lppsp])

$~CreatePropertySheetPageW
$[HPROPSHEETPAGE ]CreatePropertySheetPageW($[LPCPROPSHEETPAGE lppsp])

$~UninitializeFlatSB
$[HRESULT ]UninitializeFlatSB($[HWND hwnd])

$~CreateStatusWindow
$[HWND ]CreateStatusWindow($[LONG style], $[LPCSTR lpszText], $[HWND hwndParent], $[UINT wID])

$~CreateStatusWindowA
$[HWND ]CreateStatusWindowA($[LONG style], $[LPCSTR lpszText], $[HWND hwndParent], $[UINT wID])

$~CreateStatusWindowW
$[HWND ]CreateStatusWindowW($[LONG style], $[LPCSTR lpszText], $[HWND hwndParent], $[UINT wID])

$~CreateToolbarEx
$[HWND ]CreateToolbarEx($[HWND hwnd], $[DWORD ws], $[UINT wID], $[int nBitmaps], $[HINSTANCE hBMInst], $[UINT_PTR wBMID], $[LPCTBBUTTON lpButtons], $[int iNumButtons], $[int dxButton], $[int dyButton], $[int dxBitmap], $[int dyBitmap], $[UINT uStructSize])

$~CreateUpDownControl
$[HWND ]CreateUpDownControl($[DWORD dwStyle], $[int x], $[int y], $[int cx], $[int cy], $[HWND hParent], $[int nID], $[HINSTANCE hInst], $[HWND hBuddy], $[int nUpper], $[int nLower], $[int nPos])

$~DPA_InsertPtr
$[int ]DPA_InsertPtr($[HDPA pdpa], $[int index], $[void *p])

$~DPA_Search
$[int ]DPA_Search($[HDPA pdpa], $[void *pFind], $[int iStart], $[PFNDPACOMPARE pfnCmp], $[LPARAM lParam], $[UINT options])

$~DSA_InsertItem
$[int ]DSA_InsertItem($[HDSA pdsa], $[int index], $[void *pItem])

$~EnumMRUListW
$[int ]EnumMRUListW($[HANDLE hMRU], $[int nItem], $[void *lpData], $[UINT uLen])

$~FlatSB_GetScrollPos
$[int ]FlatSB_GetScrollPos($[HWND hwnd], $[int code])

$~FlatSB_SetScrollInfo
$[int ]FlatSB_SetScrollInfo($[HWND hwnd], $[int fnBar], $[LPSCROLLINFO lpsi], $[BOOL fRedraw])

$~FlatSB_SetScrollPos
$[int ]FlatSB_SetScrollPos($[HWND hwnd], $[int code], $[int nPos], $[BOOL fRedraw])

$~FlatSB_SetScrollRange
$[int ]FlatSB_SetScrollRange($[HWND hwnd], $[int code], $[int nMinPos], $[int nMaxPos], $[BOOL fRedraw])

$~FreeMRUList
$[int ]FreeMRUList($[HANDLE hMRU])

$~ImageList_Add
$[int ]ImageList_Add($[HIMAGELIST himl], $[HBITMAP hbmImage], $[HBITMAP hbmMask])

$~ImageList_AddIcon
$[int ]ImageList_AddIcon($[HIMAGELIST himl], $[HICON hicon])

$~ImageList_AddMasked
$[int ]ImageList_AddMasked($[HIMAGELIST himl], $[HBITMAP hbmImage], $[COLORREF crMask])

$~ImageList_GetImageCount
$[int ]ImageList_GetImageCount($[HIMAGELIST himl])

$~ImageList_ReplaceIcon
$[int ]ImageList_ReplaceIcon($[HIMAGELIST himl], $[int i], $[HICON hicon])

$~LBItemFromPt
$[int ]LBItemFromPt($[HWND hLB], $[POINT pt], $[BOOL bAutoScroll])

$~PropertySheet
$[int ]PropertySheet($[LPCPROPSHEETHEADER lppsph])

$~PropertySheetA
$[int ]PropertySheetA($[LPCPROPSHEETHEADER lppsph])

$~PropertySheetW
$[int ]PropertySheetW($[LPCPROPSHEETHEADER lppsph])

$~GetMUILanguage
$[LANGID ]GetMUILanguage($[])

$~DefSubclassProc
$[LRESULT ]DefSubclassProc($[HWND hWnd], $[UINT uMsg], $[WPARAM WPARAM], $[LPARAM LPARAM])

$~DSA_GetItemPtr
$[void *WINAPI ]DSA_GetItemPtr($[HDSA pdsa], $[int index])

$~DPA_DestroyCallback
$[void ]DPA_DestroyCallback($[HDPA pdpa], $[PFNDPAENUMCALLBACK pfnCB], $[void *pData])

$~DPA_EnumCallback
$[void ]DPA_EnumCallback($[HDPA pdpa], $[PFNDPAENUMCALLBACK pfnCB], $[void *pData])

$~DrawInsert
$[void ]DrawInsert($[HWND handParent], $[HWND hLB], $[int nItem])

$~DrawStatusText
$[void ]DrawStatusText($[HDC hdc], $[LPRECT lprc], $[LPCSTR pszText], $[UINT uFlags])

$~DrawStatusTextA
$[void ]DrawStatusTextA($[HDC hdc], $[LPRECT lprc], $[LPCSTR pszText], $[UINT uFlags])

$~DrawStatusTextW
$[void ]DrawStatusTextW($[HDC hdc], $[LPRECT lprc], $[LPCSTR pszText], $[UINT uFlags])

$~DSA_DestroyCallback
$[void ]DSA_DestroyCallback($[HDSA pdsa], $[PFNDSAENUMCALLBACK pfnCB], $[void *pData])

$~GetEffectiveClientRect
$[void ]GetEffectiveClientRect($[HWND hWnd], $[LPRECT lprc], $[const INT *lpInfo])

$~ImageList_EndDrag
$[VOID ]ImageList_EndDrag($[])

$~InitCommonControls
$[void ]InitCommonControls($[])

$~InitMUILanguage
$[VOID ]InitMUILanguage($[LANGID uiLang])

$~MenuHelp
$[void ]MenuHelp($[UINT uMsg], $[WPARAM wParam], $[LPARAM lParam], $[HMENU hMainMenu], $[HINSTANCE hInst], $[HWND hwndStatus], $[LPUINT lpwIDs])

$~DPA_DeletePtr
$[void* ]DPA_DeletePtr($[HDPA pdpa], $[int index])

$~DPA_GetPtr
$[void* ]DPA_GetPtr($[HDPA pdpa], $[int index])

$; comdlg32.dll
$; ------------
$~ChooseColorA
$[BOOL ]ChooseColorA($[LPCHOOSECOLOR lpcc])

$~ChooseColorW
$[BOOL ]ChooseColorW($[LPCHOOSECOLOR lpcc])

$~ChooseFontA
$[BOOL ]ChooseFontA($[LPCHOOSEFONT lpcf])

$~ChooseFontW
$[BOOL ]ChooseFontW($[LPCHOOSEFONT lpcf])

$~GetOpenFileNameA
$[BOOL ]GetOpenFileNameA($[LPOPENFILENAME lpofn])

$~GetOpenFileNameW
$[BOOL ]GetOpenFileNameW($[LPOPENFILENAME lpofn])

$~GetSaveFileNameA
$[BOOL ]GetSaveFileNameA($[LPOPENFILENAME lpofn])

$~GetSaveFileNameW
$[BOOL ]GetSaveFileNameW($[LPOPENFILENAME lpofn])

$~PageSetupDlgA
$[BOOL ]PageSetupDlgA($[LPPAGESETUPDLG lppsd])

$~PageSetupDlgW
$[BOOL ]PageSetupDlgW($[LPPAGESETUPDLG lppsd])

$~PrintDlgA
$[BOOL ]PrintDlgA($[LPPRINTDLG lppd])

$~PrintDlgW
$[BOOL ]PrintDlgW($[LPPRINTDLG lppd])

$~CommDlgExtendedError
$[DWORD ]CommDlgExtendedError($[])

$~PrintDlgExA
$[HRESULT ]PrintDlgExA($[LPPRINTDLGEX lppd])

$~PrintDlgExW
$[HRESULT ]PrintDlgExW($[LPPRINTDLGEX lppd])

$~FindTextA
$[HWND ]FindTextA($[LPFINDREPLACEA])

$~FindTextW
$[HWND ]FindTextW($[LPFINDREPLACEW])

$~ReplaceTextA
$[HWND ]ReplaceTextA($[LPFINDREPLACE lpfr])

$~ReplaceTextW
$[HWND ]ReplaceTextW($[LPFINDREPLACE lpfr])

$~GetFileTitleA
$[short ]GetFileTitleA($[LPCSTR lpszFile], $[LPSTR lpszTitle], $[WORD cbBuf])

$~GetFileTitleW
$[short ]GetFileTitleW($[LPCWSTR lpszFile], $[LPWSTR lpszTitle], $[WORD cbBuf])

$; crypt32.dll
$; ------------
$~CertAddCertificateContextToStore
$[BOOL ]CertAddCertificateContextToStore($[HCERTSTORE hCertStore], $[PCCERT_CONTEXT pCertContext], $[DWORD dwAddDisposition], $[PCCERT_CONTEXT* ppStoreContext])

$~CertAddCertificateLinkToStore
$[BOOL ]CertAddCertificateLinkToStore($[HCERTSTORE hCertStore], $[PCCERT_CONTEXT pCertContext], $[DWORD dwAddDisposition], $[PCCERT_CONTEXT* ppStoreContext])

$~CertAddCRLContextToStore
$[BOOL ]CertAddCRLContextToStore($[HCERTSTORE hCertStore], $[PCCRL_CONTEXT pCrlContext], $[DWORD dwAddDisposition], $[PCCRL_CONTEXT* ppStoreContext])

$~CertAddCRLLinkToStore
$[BOOL ]CertAddCRLLinkToStore($[HCERTSTORE hCertStore], $[PCCRL_CONTEXT pCrlContext], $[DWORD dwAddDisposition], $[PCCRL_CONTEXT* ppStoreContext])

$~CertAddCTLContextToStore
$[BOOL ]CertAddCTLContextToStore($[HCERTSTORE hCertStore], $[PCCTL_CONTEXT pCtlContext], $[DWORD dwAddDisposition], $[PCCTL_CONTEXT* ppStoreContext])

$~CertAddCTLLinkToStore
$[BOOL ]CertAddCTLLinkToStore($[HCERTSTORE hCertStore], $[PCCTL_CONTEXT pCtlContext], $[DWORD dwAddDisposition], $[PCCTL_CONTEXT* ppStoreContext])

$~CertAddEncodedCertificateToStore
$[BOOL ]CertAddEncodedCertificateToStore($[HCERTSTORE hCertStore], $[DWORD dwCertEncodingType], $[const BYTE* pbCertEncoded], $[DWORD cbCertEncoded], $[DWORD dwAddDisposition], $[PCCERT_CONTEXT* ppCertContext])

$~CertAddEncodedCRLToStore
$[BOOL ]CertAddEncodedCRLToStore($[HCERTSTORE hCertStore], $[DWORD dwCertEncodingType], $[const BYTE* pbCrlEncoded], $[DWORD cbCrlEncoded], $[DWORD dwAddDisposition], $[PCCRL_CONTEXT* ppCrlContext])

$~CertAddEncodedCTLToStore
$[BOOL ]CertAddEncodedCTLToStore($[HCERTSTORE hCertStore], $[DWORD dwMsgAndCertEncodingType], $[const BYTE* pbCtlEncoded], $[DWORD cbCtlEncoded], $[DWORD dwAddDisposition], $[PCCTL_CONTEXT* ppCtlContext])

$~CertAddEnhancedKeyUsageIdentifier
$[BOOL ]CertAddEnhancedKeyUsageIdentifier($[PCCERT_CONTEXT pCertContext], $[LPCSTR pszUsageIdentifier])

$~CertAddSerializedElementToStore
$[BOOL ]CertAddSerializedElementToStore($[HCERTSTORE hCertStore], $[const BYTE* pbElement], $[DWORD cbElement], $[DWORD dwAddDisposition], $[DWORD dwFlags], $[DWORD dwContextTypeFlags], $[DWORD* pdwContextType], $[const void** ppvContext])

$~CertAddStoreToCollection
$[BOOL ]CertAddStoreToCollection($[HCERTSTORE hCollectionStore], $[HCERTSTORE hSiblingStore], $[DWORD dwUpdateFlag], $[DWORD dwPriority])

$~CertCloseStore
$[BOOL ]CertCloseStore($[HCERTSTORE hCertStore], $[DWORD dwFlags])

$~CertCompareCertificate
$[BOOL ]CertCompareCertificate($[DWORD dwCertEncodingType], $[PCERT_INFO pCertId1], $[PCERT_INFO pCertId2])

$~CertCompareCertificateName
$[BOOL ]CertCompareCertificateName($[DWORD dwCertEncodingType], $[PCERT_NAME_BLOB pCertName1], $[PCERT_NAME_BLOB pCertName2])

$~CertCompareIntegerBlob
$[BOOL ]CertCompareIntegerBlob($[PCRYPT_INTEGER_BLOB pInt1], $[PCRYPT_INTEGER_BLOB pInt2])

$~CertComparePublicKeyInfo
$[BOOL ]CertComparePublicKeyInfo($[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pPublicKey1], $[PCERT_PUBLIC_KEY_INFO pPublicKey2])

$~CertControlStore
$[BOOL ]CertControlStore($[HCERTSTORE hCertStore], $[DWORD dwFlags], $[DWORD dwCtrlType], $[const void* pvCtrlPara])

$~CertCreateCertificateChainEngine
$[BOOL ]CertCreateCertificateChainEngine($[PCERT_CHAIN_ENGINE_CONFIG pConfig], $[HCERTCHAINENGINE* phChainEngine])

$~CertCreateCTLEntryFromCertificateContextProperties
$[BOOL ]CertCreateCTLEntryFromCertificateContextProperties($[PCCERT_CONTEXT pCertContext], $[DWORD cOptAttr], $[PCRYPT_ATTRIBUTE rgOptAttr], $[DWORD dwFlags], $[void* pvReserved], $[PCTL_ENTRY pCtlEntry], $[DWORD* pcbCtlEntry])

$~CertDeleteCertificateFromStore
$[BOOL ]CertDeleteCertificateFromStore($[PCCERT_CONTEXT pCertContext])

$~CertDeleteCRLFromStore
$[BOOL ]CertDeleteCRLFromStore($[PCCRL_CONTEXT pCrlContext])

$~CertDeleteCTLFromStore
$[BOOL ]CertDeleteCTLFromStore($[PCCTL_CONTEXT pCtlContext])

$~CertEnumPhysicalStore
$[BOOL ]CertEnumPhysicalStore($[const void* pvSystemStore], $[DWORD dwFlags], $[void* pvArg], $[PFN_CERT_ENUM_PHYSICAL_STORE pfnEnum])

$~CertEnumSubjectInSortedCTL
$[BOOL ]CertEnumSubjectInSortedCTL($[PCCTL_CONTEXT pCtlContext], $[void** ppvNextSubject], $[PCRYPT_DER_BLOB pSubjectIdentifier], $[PCRYPT_DER_BLOB pEncodedAttributes])

$~CertEnumSystemStore
$[BOOL ]CertEnumSystemStore($[DWORD dwFlags], $[void* pvSystemStoreLocationPara], $[void* pvArg], $[PFN_CERT_ENUM_SYSTEM_STORE pfnEnum])

$~CertEnumSystemStoreLocation
$[BOOL ]CertEnumSystemStoreLocation($[DWORD dwFlags], $[void* pvArg], $[PFN_CERT_ENUM_SYSTEM_STORE_LOCATION pfnEnum])

$~CertFindCertificateInCRL
$[BOOL ]CertFindCertificateInCRL($[PCCERT_CONTEXT pCert], $[PCCRL_CONTEXT pCrlContext], $[DWORD dwFlags], $[void* pvReserved], $[PCRL_ENTRY* ppCrlEntry])

$~CertFindSubjectInSortedCTL
$[BOOL ]CertFindSubjectInSortedCTL($[PCRYPT_DATA_BLOB pSubjectIdentifier], $[PCCTL_CONTEXT pCtlContext], $[DWORD dwFlags], $[void* pvReserved], $[PCRYPT_DER_BLOB pEncodedAttributes])

$~CertFreeCertificateContext
$[BOOL ]CertFreeCertificateContext($[PCCERT_CONTEXT pCertContext])

$~CertFreeCRLContext
$[BOOL ]CertFreeCRLContext($[PCCRL_CONTEXT pCrlContext])

$~CertFreeCTLContext
$[BOOL ]CertFreeCTLContext($[PCCTL_CONTEXT pCtlContext])

$~CertGetCertificateChain
$[BOOL ]CertGetCertificateChain($[HCERTCHAINENGINE hChainEngine], $[PCCERT_CONTEXT pCertContext], $[LPFILETIME pTime], $[HCERTSTORE hAdditionalStore], $[PCERT_CHAIN_PARA pChainPara], $[DWORD dwFlags], $[LPVOID pvReserved], $[PCCERT_CHAIN_CONTEXT* ppChainContext])

$~CertGetCertificateContextProperty
$[BOOL ]CertGetCertificateContextProperty($[PCCERT_CONTEXT pCertContext], $[DWORD dwPropId], $[void* pvData], $[DWORD* pcbData])

$~CertGetCRLContextProperty
$[BOOL ]CertGetCRLContextProperty($[PCCRL_CONTEXT pCrlContext], $[DWORD dwPropId], $[void* pvData], $[DWORD* pcbData])

$~CertGetCTLContextProperty
$[BOOL ]CertGetCTLContextProperty($[PCCTL_CONTEXT pCtlContext], $[DWORD dwPropId], $[void* pvData], $[DWORD* pcbData])

$~CertGetEnhancedKeyUsage
$[BOOL ]CertGetEnhancedKeyUsage($[PCCERT_CONTEXT pCertContext], $[DWORD dwFlags], $[PCERT_ENHKEY_USAGE pUsage], $[DWORD* pcbUsage])

$~CertGetIntendedKeyUsage
$[BOOL ]CertGetIntendedKeyUsage($[DWORD dwCertEncodingType], $[PCERT_INFO pCertInfo], $[BYTE* pbKeyUsage], $[DWORD cbKeyUsage])

$~CertGetStoreProperty
$[BOOL ]CertGetStoreProperty($[HCERTSTORE hCertStore], $[DWORD dwPropId], $[void* pvData], $[DWORD* pcbData])

$~CertGetValidUsages
$[BOOL ]CertGetValidUsages($[DWORD cCerts], $[PCCERT_CONTEXT* rghCerts], $[int* cNumOIDs], $[LPSTR* rghOIDs], $[DWORD* pcbOIDs])

$~CertIsRDNAttrsInCertificateName
$[BOOL ]CertIsRDNAttrsInCertificateName($[DWORD dwCertEncodingType], $[DWORD dwFlags], $[PCERT_NAME_BLOB pCertName], $[PCERT_RDN pRDN])

$~CertIsValidCRLForCertificate
$[BOOL ]CertIsValidCRLForCertificate($[PCCERT_CONTEXT pCert], $[PCCRL_CONTEXT pCRL], $[DWORD dwFlags], $[void* pvReserved])

$~CertRegisterPhysicalStore
$[BOOL ]CertRegisterPhysicalStore($[const void* pvSystemStore], $[DWORD dwFlags], $[LPCWSTR pwszStoreName], $[PCERT_PHYSICAL_STORE_INFO pStoreInfo], $[void* pvReserved])

$~CertRegisterSystemStore
$[BOOL ]CertRegisterSystemStore($[const void* pvSystemStore], $[DWORD dwFlags], $[PCERT_SYSTEM_STORE_INFO pStoreInfo], $[void* pvReserved])

$~CertRemoveEnhancedKeyUsageIdentifier
$[BOOL ]CertRemoveEnhancedKeyUsageIdentifier($[PCCERT_CONTEXT pCertContext], $[LPCSTR pszUsageIdentifier])

$~CertSaveStore
$[BOOL ]CertSaveStore($[HCERTSTORE hCertStore], $[DWORD dwMsgAndCertEncodingType], $[DWORD dwSaveAs], $[DWORD dwSaveTo], $[void* pvSaveToPara], $[DWORD dwFlags])

$~CertSerializeCertificateStoreElement
$[BOOL ]CertSerializeCertificateStoreElement($[PCCERT_CONTEXT pCertContext], $[DWORD dwFlags], $[BYTE* pbElement], $[DWORD* pcbElement])

$~CertSerializeCRLStoreElement
$[BOOL ]CertSerializeCRLStoreElement($[PCCRL_CONTEXT pCrlContext], $[DWORD dwFlags], $[BYTE* pbElement], $[DWORD* pcbElement])

$~CertSerializeCTLStoreElement
$[BOOL ]CertSerializeCTLStoreElement($[PCCTL_CONTEXT pCtlContext], $[DWORD dwFlags], $[BYTE* pbElement], $[DWORD* pcbElement])

$~CertSetCertificateContextPropertiesFromCTLEntry
$[BOOL ]CertSetCertificateContextPropertiesFromCTLEntry($[PCCERT_CONTEXT pCertContext], $[PCTL_ENTRY pCtlEntry], $[DWORD dwFlags])

$~CertSetCertificateContextProperty
$[BOOL ]CertSetCertificateContextProperty($[PCCERT_CONTEXT pCertContext], $[DWORD dwPropId], $[DWORD dwFlags], $[const void* pvData])

$~CertSetCRLContextProperty
$[BOOL ]CertSetCRLContextProperty($[PCCRL_CONTEXT pCrlContext], $[DWORD dwPropId], $[DWORD dwFlags], $[const void* pvData])

$~CertSetCTLContextProperty
$[BOOL ]CertSetCTLContextProperty($[PCCTL_CONTEXT pCtlContext], $[DWORD dwPropId], $[DWORD dwFlags], $[const void* pvData])

$~CertSetEnhancedKeyUsage
$[BOOL ]CertSetEnhancedKeyUsage($[PCCERT_CONTEXT pCertContext], $[PCERT_ENHKEY_USAGE pUsage])

$~CertSetStoreProperty
$[BOOL ]CertSetStoreProperty($[HCERTSTORE hCertStore], $[DWORD dwPropId], $[DWORD dwFlags], $[const void* pvData])

$~CertStrToNameA
$[BOOL ]CertStrToNameA($[DWORD dwCertEncodingType], $[LPCSTR pszX500], $[DWORD dwStrType], $[void* pvReserved], $[BYTE* pbEncoded], $[DWORD* pcbEncoded], $[LPCTSTR* ppszError])

$~CertStrToNameW
$[BOOL ]CertStrToNameW($[DWORD dwCertEncodingType], $[LPCWSTR pszX500], $[DWORD dwStrType], $[void* pvReserved], $[BYTE* pbEncoded], $[DWORD* pcbEncoded], $[LPCTSTR* ppszError])

$~CertUnregisterPhysicalStore
$[BOOL ]CertUnregisterPhysicalStore($[const void* pvSystemStore], $[DWORD dwFlags], $[LPCWSTR pwszStoreName])

$~CertUnregisterSystemStore
$[BOOL ]CertUnregisterSystemStore($[const void* pvSystemStore], $[DWORD dwFlags])

$~CertVerifyCertificateChainPolicy
$[BOOL ]CertVerifyCertificateChainPolicy($[LPCSTR pszPolicyOID], $[PCCERT_CHAIN_CONTEXT pChainContext], $[PCERT_CHAIN_POLICY_PARA pPolicyPara], $[PCERT_CHAIN_POLICY_STATUS pPolicyStatus])

$~CertVerifyCRLRevocation
$[BOOL ]CertVerifyCRLRevocation($[DWORD dwCertEncodingType], $[PCERT_INFO pCertId], $[DWORD cCrlInfo], $[PCRL_INFO* rgpCrlInfo])

$~CertVerifyCTLUsage
$[BOOL ]CertVerifyCTLUsage($[DWORD dwEncodingType], $[DWORD dwSubjectType], $[void* pvSubject], $[PCTL_USAGE pSubjectUsage], $[DWORD dwFlags], $[PCTL_VERIFY_USAGE_PARA pVerifyUsagePara], $[PCTL_VERIFY_USAGE_STATUS pVerifyUsageStatus])

$~CertVerifyRevocation
$[BOOL ]CertVerifyRevocation($[DWORD dwEncodingType], $[DWORD dwRevType], $[DWORD cContext], $[PVOID* rgpvContext], $[DWORD dwFlags], $[PCERT_REVOCATION_PARA pRevPara], $[PCERT_REVOCATION_STATUS pRevStatus])

$~CertVerifySubjectCertificateContext
$[BOOL ]CertVerifySubjectCertificateContext($[PCCERT_CONTEXT pSubject], $[PCCERT_CONTEXT pIssuer], $[DWORD* pdwFlags])

$~CertVerifyValidityNesting
$[BOOL ]CertVerifyValidityNesting($[PCERT_INFO pSubjectInfo], $[PCERT_INFO pIssuerInfo])

$~CryptAcquireCertificatePrivateKey
$[BOOL ]CryptAcquireCertificatePrivateKey($[PCCERT_CONTEXT pCert], $[DWORD dwFlags], $[void* pvReserved], $[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE* phCryptProvOrNCryptKey], $[DWORD* pdwKeySpec], $[BOOL* pfCallerFreeProvOrNCryptKey])

$~CryptBinaryToStringA
$[BOOL ]CryptBinaryToStringA($[const BYTE* pbBinary], $[DWORD cbBinary], $[DWORD dwFlags], $[LPSTR pszString], $[DWORD* pcchString])

$~CryptBinaryToStringW
$[BOOL ]CryptBinaryToStringW($[const BYTE* pbBinary], $[DWORD cbBinary], $[DWORD dwFlags], $[LPWSTR pszString], $[DWORD* pcchString])

$~CryptCreateKeyIdentifierFromCSP
$[BOOL ]CryptCreateKeyIdentifierFromCSP($[DWORD dwCertEncodingType], $[LPCSTR pszPubKeyOID], $[const PUBLICKEYSTRUC* pPubKeyStruc], $[DWORD cbPubKeyStruc], $[DWORD dwFlags], $[void* pvReserved], $[BYTE* pbHash], $[DWORD* pcbHash])

$~CryptDecodeMessage
$[BOOL ]CryptDecodeMessage($[DWORD dwMsgTypeFlags], $[PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara], $[PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara], $[DWORD dwSignerIndex], $[const BYTE* pbEncodedBlob], $[DWORD cbEncodedBlob], $[DWORD dwPrevInnerContentType], $[DWORD* pdwMsgType], $[DWORD* pdwInnerContentType], $[BYTE* pbDecoded], $[DWORD* pcbDecoded], $[PCCERT_CONTEXT* ppXchgCert], $[PCCERT_CONTEXT* ppSignerCert])

$~CryptDecodeObject
$[BOOL ]CryptDecodeObject($[DWORD dwCertEncodingType], $[LPCSTR lpszStructType], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[DWORD dwFlags], $[void* pvStructInfo], $[DWORD* pcbStructInfo])

$~CryptDecodeObjectEx
$[BOOL ]CryptDecodeObjectEx($[DWORD dwCertEncodingType], $[LPCSTR lpszStructType], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[DWORD dwFlags], $[PCRYPT_DECODE_PARA pDecodePara], $[void* pvStructInfo], $[DWORD* pcbStructInfo])

$~CryptDecryptAndVerifyMessageSignature
$[BOOL ]CryptDecryptAndVerifyMessageSignature($[PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara], $[PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara], $[DWORD dwSignerIndex], $[const BYTE* pbEncryptedBlob], $[DWORD cbEncryptedBlob], $[BYTE* pbDecrypted], $[DWORD* pcbDecrypted], $[PCCERT_CONTEXT* ppXchgCert], $[PCCERT_CONTEXT* ppSignerCert])

$~CryptDecryptMessage
$[BOOL ]CryptDecryptMessage($[PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara], $[const BYTE* pbEncryptedBlob], $[DWORD cbEncryptedBlob], $[BYTE* pbDecrypted], $[DWORD* pcbDecrypted], $[PCCERT_CONTEXT* ppXchgCert])

$~CryptEncodeObject
$[BOOL ]CryptEncodeObject($[DWORD dwCertEncodingType], $[LPCSTR lpszStructType], $[const void* pvStructInfo], $[BYTE* pbEncoded], $[DWORD* pcbEncoded])

$~CryptEncodeObjectEx
$[BOOL ]CryptEncodeObjectEx($[DWORD dwCertEncodingType], $[LPCSTR lpszStructType], $[const void* pvStructInfo], $[DWORD dwFlags], $[PCRYPT_ENCODE_PARA pEncodePara], $[void* pvEncoded], $[DWORD* pcbEncoded])

$~CryptEncryptMessage
$[BOOL ]CryptEncryptMessage($[PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara], $[DWORD cRecipientCert], $[PCCERT_CONTEXT* rgpRecipientCert], $[const BYTE* pbToBeEncrypted], $[DWORD cbToBeEncrypted], $[BYTE* pbEncryptedBlob], $[DWORD* pcbEncryptedBlob])

$~CryptEnumKeyIdentifierProperties
$[BOOL ]CryptEnumKeyIdentifierProperties($[const CRYPT_HASH_BLOB* pKeyIdentifier], $[DWORD dwPropId], $[DWORD dwFlags], $[LPCWSTR pwszComputerName], $[void* pvReserved], $[void* pvArg], $[PFN_CRYPT_ENUM_KEYID_PROP pfnEnum])

$~CryptEnumOIDFunction
$[BOOL ]CryptEnumOIDFunction($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCSTR pszOID], $[DWORD dwFlags], $[void* pvArg], $[PFN_CRYPT_ENUM_OID_FUNC pfnEnumOIDFunc])

$~CryptEnumOIDInfo
$[BOOL ]CryptEnumOIDInfo($[DWORD dwGroupId], $[DWORD dwFlags], $[void* pvArg], $[PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo])

$~CryptExportPKCS8
$[BOOL ]CryptExportPKCS8($[HCRYPTPROV hCryptProv], $[DWORD dwKeySpec], $[LPSTR pszPrivateKeyObjId], $[DWORD dwFlags], $[void* pvAuxInfo], $[BYTE* pbPrivateKeyBlob], $[DWORD* pcbPrivateKeyBlob])

$~CryptExportPublicKeyInfo
$[BOOL ]CryptExportPublicKeyInfo($[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey], $[DWORD dwKeySpec], $[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pInfo], $[DWORD* pcbInfo])

$~CryptExportPublicKeyInfoEx
$[BOOL ]CryptExportPublicKeyInfoEx($[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey], $[DWORD dwKeySpec], $[DWORD dwCertEncodingType], $[LPSTR pszPublicKeyObjId], $[DWORD dwFlags], $[void* pvAuxInfo], $[PCERT_PUBLIC_KEY_INFO pInfo], $[DWORD* pcbInfo])

$~CryptFindCertificateKeyProvInfo
$[BOOL ]CryptFindCertificateKeyProvInfo($[PCCERT_CONTEXT pCert], $[DWORD dwFlags], $[void* pvReserved])

$~CryptFormatObject
$[BOOL ]CryptFormatObject($[DWORD dwCertEncodingType], $[DWORD dwFormatType], $[DWORD dwFormatStrType], $[void* pFormatStruct], $[LPCSTR lpszStructType], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[void* pbFormat], $[DWORD* pcbFormat])

$~CryptFreeOIDFunctionAddress
$[BOOL ]CryptFreeOIDFunctionAddress($[HCRYPTOIDFUNCADDR hFuncAddr], $[DWORD dwFlags])

$~CryptGetDefaultOIDDllList
$[BOOL ]CryptGetDefaultOIDDllList($[HCRYPTOIDFUNCSET hFuncSet], $[DWORD dwEncodingType], $[LPWSTR pwszDllList], $[DWORD* pcchDllList])

$~CryptGetDefaultOIDFunctionAddress
$[BOOL ]CryptGetDefaultOIDFunctionAddress($[HCRYPTOIDFUNCSET hFuncSet], $[DWORD dwEncodingType], $[LPCWSTR pwszDll], $[DWORD dwFlags], $[void** ppvFuncAddr], $[HCRYPTOIDFUNCADDR* phFuncAddr])

$~CryptGetKeyIdentifierProperty
$[BOOL ]CryptGetKeyIdentifierProperty($[const CRYPT_HASH_BLOB* pKeyIdentifier], $[DWORD dwPropId], $[DWORD dwFlags], $[LPCWSTR pwszComputerName], $[void* pvReserved], $[void* pvData], $[DWORD* pcbData])

$~CryptGetOIDFunctionAddress
$[BOOL ]CryptGetOIDFunctionAddress($[HCRYPTOIDFUNCSET hFuncSet], $[DWORD dwEncodingType], $[LPCSTR pszOID], $[DWORD dwFlags], $[void** ppvFuncAddr], $[HCRYPTOIDFUNCADDR* phFuncAddr])

$~CryptGetOIDFunctionValue
$[BOOL ]CryptGetOIDFunctionValue($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCSTR pszOID], $[LPCWSTR pwszValueName], $[DWORD* pdwValueType], $[BYTE* pbValueData], $[DWORD* pcbValueData])

$~CryptHashCertificate
$[BOOL ]CryptHashCertificate($[HCRYPTPROV_LEGACY hCryptProv], $[ALG_ID Algid], $[DWORD dwFlags], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptHashMessage
$[BOOL ]CryptHashMessage($[PCRYPT_HASH_MESSAGE_PARA pHashPara], $[BOOL fDetachedHash], $[DWORD cToBeHashed], $[const BYTE** rgpbToBeHashed], $[DWORD* rgcbToBeHashed], $[BYTE* pbHashedBlob], $[DWORD* pcbHashedBlob], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptHashPublicKeyInfo
$[BOOL ]CryptHashPublicKeyInfo($[HCRYPTPROV_LEGACY hCryptProv], $[ALG_ID Algid], $[DWORD dwFlags], $[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pInfo], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptHashToBeSigned
$[BOOL ]CryptHashToBeSigned($[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwCertEncodingType], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptImportPKCS8
$[BOOL ]CryptImportPKCS8($[CRYPT_PKCS8_IMPORT_PARAMS sImportParams], $[DWORD dwFlags], $[HCRYPTPROV* phCryptProv], $[void* pvAuxInfo])

$~CryptImportPublicKeyInfo
$[BOOL ]CryptImportPublicKeyInfo($[HCRYPTPROV hCryptProv], $[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pInfo], $[HCRYPTKEY* phKey])

$~CryptImportPublicKeyInfoEx
$[BOOL ]CryptImportPublicKeyInfoEx($[HCRYPTPROV hCryptProv], $[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pInfo], $[ALG_ID aiKeyAlg], $[DWORD dwFlags], $[void* pvAuxInfo], $[HCRYPTKEY* phKey])

$~CryptInstallDefaultContext
$[BOOL ]CryptInstallDefaultContext($[HCRYPTPROV hCryptProv], $[DWORD dwDefaultType], $[const void* pvDefaultPara], $[DWORD dwFlags], $[void* pvReserved], $[HCRYPTDEFAULTCONTEXT* phDefaultContext])

$~CryptInstallOIDFunctionAddress
$[BOOL ]CryptInstallOIDFunctionAddress($[HMODULE hModule], $[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[DWORD cFuncEntry], $[CRYPT_OID_FUNC_ENTRY rgFuncEntry*], $[DWORD dwFlags])

$~CryptMsgClose
$[BOOL ]CryptMsgClose($[HCRYPTMSG hCryptMsg])

$~CryptMsgControl
$[BOOL ]CryptMsgControl($[HCRYPTMSG hCryptMsg], $[DWORD dwFlags], $[DWORD dwCtrlType], $[const void* pvCtrlPara])

$~CryptMsgCountersign
$[BOOL ]CryptMsgCountersign($[HCRYPTMSG hCryptMsg], $[DWORD dwIndex], $[DWORD cCountersigners], $[PCMSG_SIGNER_ENCODE_INFO rgCountersigners])

$~CryptMsgCountersignEncoded
$[BOOL ]CryptMsgCountersignEncoded($[DWORD dwEncodingType], $[PBYTE pbSignerInfo], $[DWORD cbSignerInfo], $[DWORD cCountersigners], $[PCMSG_SIGNER_ENCODE_INFO rgCountersigners], $[PBYTE pbCountersignature], $[PDWORD pcbCountersignature])

$~CryptMsgEncodeAndSignCTL
$[BOOL ]CryptMsgEncodeAndSignCTL($[DWORD dwMsgEncodingType], $[PCTL_INFO pCtlInfo], $[PCMSG_SIGNED_ENCODE_INFO pSignInfo], $[DWORD dwFlags], $[BYTE* pbEncoded], $[DWORD* pcbEncoded])

$~CryptMsgGetAndVerifySigner
$[BOOL ]CryptMsgGetAndVerifySigner($[HCRYPTMSG hCryptMsg], $[DWORD cSignerStore], $[HCERTSTORE* rghSignerStore], $[DWORD dwFlags], $[PCCERT_CONTEXT* ppSigner], $[DWORD* pdwSignerIndex])

$~CryptMsgGetParam
$[BOOL ]CryptMsgGetParam($[HCRYPTMSG hCryptMsg], $[DWORD dwParamType], $[DWORD dwIndex], $[void* pvData], $[DWORD* pcbData])

$~CryptMsgSignCTL
$[BOOL ]CryptMsgSignCTL($[DWORD dwMsgEncodingType], $[BYTE* pbCtlContent], $[DWORD cbCtlContent], $[PCMSG_SIGNED_ENCODE_INFO pSignInfo], $[DWORD dwFlags], $[BYTE* pbEncoded], $[DWORD* pcbEncoded])

$~CryptMsgUpdate
$[BOOL ]CryptMsgUpdate($[HCRYPTMSG hCryptMsg], $[const BYTE* pbData], $[DWORD cbData], $[BOOL fFinal])

$~CryptMsgVerifyCountersignatureEncoded
$[BOOL ]CryptMsgVerifyCountersignatureEncoded($[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwEncodingType], $[PBYTE pbSignerInfo], $[DWORD cbSignerInfo], $[PBYTE pbSignerInfoCountersignature], $[DWORD cbSignerInfoCountersignature], $[PCERT_INFO pciCountersigner])

$~CryptMsgVerifyCountersignatureEncodedEx
$[BOOL ]CryptMsgVerifyCountersignatureEncodedEx($[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwEncodingType], $[PBYTE pbSignerInfo], $[DWORD cbSignerInfo], $[PBYTE pbSignerInfoCountersignature], $[DWORD cbSignerInfoCountersignature], $[DWORD dwSignerType], $[Void * pvSigner], $[DWORD dwFlags], $[Void * pvReserved])

$~CryptProtectData
$[BOOL ]CryptProtectData($[DATA_BLOB* pDataIn], $[LPCWSTR szDataDescr], $[DATA_BLOB* pOptionalEntropy], $[PVOID pvReserved], $[CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct], $[DWORD dwFlags], $[DATA_BLOB* pDataOut])

$~CryptQueryObject
$[BOOL ]CryptQueryObject($[DWORD dwObjectType], $[const void* pvObject], $[DWORD dwExpectedContentTypeFlags], $[DWORD dwExpectedFormatTypeFlags], $[DWORD dwFlags], $[DWORD* pdwMsgAndCertEncodingType], $[DWORD* pdwContentType], $[DWORD* pdwFormatType], $[HCERTSTORE* phCertStore], $[HCRYPTMSG* phMsg], $[const void** ppvContext])

$~CryptRegisterDefaultOIDFunction
$[BOOL ]CryptRegisterDefaultOIDFunction($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[DWORD dwIndex], $[LPCWSTR pwszDll])

$~CryptRegisterOIDFunction
$[BOOL ]CryptRegisterOIDFunction($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCSTR pszOID], $[LPCWSTR pwszDll], $[LPCSTR pszOverrideFuncName])

$~CryptRegisterOIDInfo
$[BOOL ]CryptRegisterOIDInfo($[PCCRYPT_OID_INFO pInfo], $[DWORD dwFlags])

$~CryptSetKeyIdentifierProperty
$[BOOL ]CryptSetKeyIdentifierProperty($[const CRYPT_HASH_BLOB* pKeyIdentifier], $[DWORD dwPropId], $[DWORD dwFlags], $[LPCWSTR pwszComputerName], $[void* pvReserved], $[const void* pvData])

$~CryptSetOIDFunctionValue
$[BOOL ]CryptSetOIDFunctionValue($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCSTR pszOID], $[LPCWSTR pwszValueName], $[DWORD dwValueType], $[const BYTE* pbValueData], $[DWORD cbValueData])

$~CryptSignAndEncodeCertificate
$[BOOL ]CryptSignAndEncodeCertificate($[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey], $[DWORD dwKeySpec], $[DWORD dwCertEncodingType], $[LPCSTR lpszStructType], $[const void* pvStructInfo], $[PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm], $[const void* pvHashAuxInfo], $[PBYTE pbEncoded], $[DWORD* pcbEncoded])

$~CryptSignAndEncryptMessage
$[BOOL ]CryptSignAndEncryptMessage($[PCRYPT_SIGN_MESSAGE_PARA pSignPara], $[PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara], $[DWORD cRecipientCert], $[PCCERT_CONTEXT* rgpRecipientCert], $[const BYTE* pbToBeSignedAndEncrypted], $[DWORD cbToBeSignedAndEncrypted], $[BYTE* pbSignedAndEncryptedBlob], $[DWORD* pcbSignedAndEncryptedBlob])

$~CryptSignCertificate
$[BOOL ]CryptSignCertificate($[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey], $[DWORD dwKeySpec], $[DWORD dwCertEncodingType], $[const BYTE* pbEncodedToBeSigned], $[DWORD cbEncodedToBeSigned], $[PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm], $[const void* pvHashAuxInfo], $[BYTE* pbSignature], $[DWORD* pcbSignature])

$~CryptSignMessage
$[BOOL ]CryptSignMessage($[PCRYPT_SIGN_MESSAGE_PARA pSignPara], $[BOOL fDetachedSignature], $[DWORD cToBeSigned], $[const BYTE** rgpbToBeSigned], $[DWORD* rgcbToBeSigned], $[BYTE* pbSignedBlob], $[DWORD* pcbSignedBlob])

$~CryptSignMessageWithKey
$[BOOL ]CryptSignMessageWithKey($[PCRYPT_KEY_SIGN_MESSAGE_PARA pSignPara], $[const BYTE* pbToBeSigned], $[DWORD cToBeSigned], $[BYTE* pbSignedBlob], $[DWORD* pcbSignedBlob])

$~CryptSIPAddProvider
$[BOOL ]CryptSIPAddProvider($[SIP_ADD_NEWPROVIDER* psNewProv])

$~CryptSIPRemoveProvider
$[BOOL ]CryptSIPRemoveProvider($[GUID* pgProv])

$~CryptStringToBinaryA
$[BOOL ]CryptStringToBinaryA($[LPCSTR pszString], $[DWORD cchString], $[DWORD dwFlags], $[BYTE* pbBinary], $[DWORD* pcbBinary], $[DWORD* pdwSkip], $[DWORD* pdwFlags])

$~CryptStringToBinaryW
$[BOOL ]CryptStringToBinaryW($[LPCWSTR pszString], $[DWORD cchString], $[DWORD dwFlags], $[BYTE* pbBinary], $[DWORD* pcbBinary], $[DWORD* pdwSkip], $[DWORD* pdwFlags])

$~CryptUninstallDefaultContext
$[BOOL ]CryptUninstallDefaultContext($[HCRYPTDEFAULTCONTEXT hDefaultContext], $[DWORD dwFlags], $[void* pvReserved])

$~CryptUnprotectData
$[BOOL ]CryptUnprotectData($[DATA_BLOB* pDataIn], $[LPWSTR* ppszDataDescr], $[DATA_BLOB* pOptionalEntropy], $[PVOID pvReserved], $[CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct], $[DWORD dwFlags], $[DATA_BLOB* pDataOut])

$~CryptUnregisterDefaultOIDFunction
$[BOOL ]CryptUnregisterDefaultOIDFunction($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCWSTR pwszDll])

$~CryptUnregisterOIDFunction
$[BOOL ]CryptUnregisterOIDFunction($[DWORD dwEncodingType], $[LPCSTR pszFuncName], $[LPCSTR pszOID])

$~CryptUnregisterOIDInfo
$[BOOL ]CryptUnregisterOIDInfo($[PCCRYPT_OID_INFO pInfo])

$~CryptVerifyCertificateSignature
$[BOOL ]CryptVerifyCertificateSignature($[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwCertEncodingType], $[BYTE* pbEncoded], $[DWORD cbEncoded], $[PCERT_PUBLIC_KEY_INFO pPublicKey])

$~CryptVerifyCertificateSignatureEx
$[BOOL ]CryptVerifyCertificateSignatureEx($[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwCertEncodingType], $[DWORD dwSubjectType], $[void* pvSubject], $[DWORD dwIssuerType], $[void* pvIssuer], $[DWORD dwFlags], $[void* pvReserved])

$~CryptVerifyDetachedMessageHash
$[BOOL ]CryptVerifyDetachedMessageHash($[PCRYPT_HASH_MESSAGE_PARA pHashPara], $[BYTE* pbDetachedHashBlob], $[DWORD cbDetachedHashBlob], $[DWORD cToBeHashed], $[const BYTE** rgpbToBeHashed], $[DWORD* rgcbToBeHashed], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptVerifyDetachedMessageSignature
$[BOOL ]CryptVerifyDetachedMessageSignature($[PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara], $[DWORD dwSignerIndex], $[const BYTE* pbDetachedSignBlob], $[DWORD cbDetachedSignBlob], $[DWORD cToBeSigned], $[const BYTE** rgpbToBeSigned], $[DWORD* rgcbToBeSigned], $[PCCERT_CONTEXT* ppSignerCert])

$~CryptVerifyMessageHash
$[BOOL ]CryptVerifyMessageHash($[PCRYPT_HASH_MESSAGE_PARA pHashPara], $[BYTE* pbHashedBlob], $[DWORD cbHashedBlob], $[BYTE* pbToBeHashed], $[DWORD* pcbToBeHashed], $[BYTE* pbComputedHash], $[DWORD* pcbComputedHash])

$~CryptVerifyMessageSignature
$[BOOL ]CryptVerifyMessageSignature($[PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara], $[DWORD dwSignerIndex], $[const BYTE* pbSignedBlob], $[DWORD cbSignedBlob], $[BYTE* pbDecoded], $[DWORD* pcbDecoded], $[PCCERT_CONTEXT* ppSignerCert])

$~CryptVerifyMessageSignatureWithKey
$[BOOL ]CryptVerifyMessageSignatureWithKey($[PCRYPT_KEY_VERIFY_MESSAGE_PARA pVerifyPara], $[PCERT_PUBLIC_KEY_INFO pPublicKeyInfo], $[const BYTE* pbSignedBlob], $[DWORD cbSignedBlob], $[BYTE* pbDecoded], $[DWORD* pcbDecoded])

$~PFXExportCertStore
$[BOOL ]PFXExportCertStore($[HCERTSTORE hStore], $[CRYPT_DATA_BLOB* pPFX], $[LPCWSTR szPassword], $[DWORD dwFlags])

$~PFXExportCertStoreEx
$[BOOL ]PFXExportCertStoreEx($[HCERTSTORE hStore], $[CRYPT_DATA_BLOB* pPFX], $[LPCWSTR szPassword], $[void* pvReserved], $[DWORD dwFlags])

$~PFXIsPFXBlob
$[BOOL ]PFXIsPFXBlob($[CRYPT_DATA_BLOB* pPFX])

$~PFXVerifyPassword
$[BOOL ]PFXVerifyPassword($[CRYPT_DATA_BLOB* pPFX], $[LPCWSTR szPassword], $[DWORD dwFlags])

$~CertEnumCertificateContextProperties
$[DWORD ]CertEnumCertificateContextProperties($[PCCERT_CONTEXT pCertContext], $[DWORD dwPropId])

$~CertEnumCRLContextProperties
$[DWORD ]CertEnumCRLContextProperties($[PCCRL_CONTEXT pCrlContext], $[DWORD dwPropId])

$~CertEnumCTLContextProperties
$[DWORD ]CertEnumCTLContextProperties($[PCCTL_CONTEXT pCtlContext], $[DWORD dwPropId])

$~CertGetNameStringA
$[DWORD ]CertGetNameStringA($[PCCERT_CONTEXT pCertContext], $[DWORD dwType], $[DWORD dwFlags], $[void* pvTypePara], $[LPSTR pszNameString], $[DWORD cchNameString])

$~CertGetNameStringW
$[DWORD ]CertGetNameStringW($[PCCERT_CONTEXT pCertContext], $[DWORD dwType], $[DWORD dwFlags], $[void* pvTypePara], $[LPWSTR pszNameString], $[DWORD cchNameString])

$~CertGetPublicKeyLength
$[DWORD ]CertGetPublicKeyLength($[DWORD dwCertEncodingType], $[PCERT_PUBLIC_KEY_INFO pPublicKey])

$~CertNameToStrA
$[DWORD ]CertNameToStrA($[DWORD dwCertEncodingType], $[PCERT_NAME_BLOB pName], $[DWORD dwStrType], $[LPSTR psz], $[DWORD csz])

$~CertNameToStrW
$[DWORD ]CertNameToStrW($[DWORD dwCertEncodingType], $[PCERT_NAME_BLOB pName], $[DWORD dwStrType], $[LPWSTR psz], $[DWORD csz])

$~CertOIDToAlgId
$[DWORD ]CertOIDToAlgId($[LPCSTR pszObjId])

$~CertRDNValueToStrA
$[DWORD ]CertRDNValueToStrA($[DWORD dwValueType], $[PCERT_RDN_VALUE_BLOB pValue], $[LPSTR psz], $[DWORD csz])

$~CertRDNValueToStrW
$[DWORD ]CertRDNValueToStrW($[DWORD dwValueType], $[PCERT_RDN_VALUE_BLOB pValue], $[LPWSTR psz], $[DWORD csz])

$~CryptMsgCalculateEncodedLength
$[DWORD ]CryptMsgCalculateEncodedLength($[DWORD dwMsgEncodingType], $[DWORD dwFlags], $[DWORD dwMsgType], $[const void* pvMsgEncodeInfo], $[LPSTR pszInnerContentObjID], $[DWORD cbData])

$~CertDuplicateStore
$[HCERTSTORE ]CertDuplicateStore($[HCERTSTORE hCertStore])

$~CertOpenStore
$[HCERTSTORE ]CertOpenStore($[LPCSTR lpszStoreProvider], $[DWORD dwMsgAndCertEncodingType], $[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwFlags], $[const void* pvPara])

$~CertOpenSystemStoreA
$[HCERTSTORE ]CertOpenSystemStoreA($[HCRYPTPROV_LEGACY hprov], $[LPTCSTR szSubsystemProtocol])

$~CertOpenSystemStoreW
$[HCERTSTORE ]CertOpenSystemStoreW($[HCRYPTPROV_LEGACY hprov], $[LPTCSTR szSubsystemProtocol])

$~CryptGetMessageCertificates
$[HCERTSTORE ]CryptGetMessageCertificates($[DWORD dwMsgAndCertEncodingType], $[HCRYPTPROV_LEGACY hCryptProv], $[DWORD dwFlags], $[const BYTE* pbSignedBlob], $[DWORD cbSignedBlob])

$~PFXImportCertStore
$[HCERTSTORE ]PFXImportCertStore($[CRYPT_DATA_BLOB* pPFX], $[LPCWSTR szPassword], $[DWORD dwFlags])

$~CryptMsgDuplicate
$[HCRYPTMSG ]CryptMsgDuplicate($[HCRYPTMSG hCryptMsg])

$~CryptMsgOpenToDecode
$[HCRYPTMSG ]CryptMsgOpenToDecode($[DWORD dwMsgEncodingType], $[DWORD dwFlags], $[DWORD dwMsgType], $[HCRYPTPROV_LEGACY hCryptProv], $[PCERT_INFO pRecipientInfo], $[PCMSG_STREAM_INFO pStreamInfo])

$~CryptMsgOpenToEncode
$[HCRYPTMSG ]CryptMsgOpenToEncode($[DWORD dwMsgEncodingType], $[DWORD dwFlags], $[DWORD dwMsgType], $[const void* pvMsgEncodeInfo], $[LPSTR pszInnerContentObjID], $[PCMSG_STREAM_INFO pStreamInfo])

$~CryptInitOIDFunctionSet
$[HCRYPTOIDFUNCSET ]CryptInitOIDFunctionSet($[LPCSTR pszFuncName], $[DWORD dwFlags])

$~CertVerifyCRLTimeValidity
$[LONG ]CertVerifyCRLTimeValidity($[LPFILETIME pTimeToVerify], $[PCRL_INFO pCrlInfo])

$~CertVerifyTimeValidity
$[LONG ]CertVerifyTimeValidity($[LPFILETIME pTimeToVerify], $[PCERT_INFO pCertInfo])

$~CryptGetMessageSignerCount
$[LONG ]CryptGetMessageSignerCount($[DWORD dwMsgEncodingType], $[const BYTE* pbSignedBlob], $[DWORD cbSignedBlob])

$~CertAlgIdToOID
$[LPCSTR ]CertAlgIdToOID($[DWORD dwAlgId])

$~CryptFindLocalizedName
$[LPCWSTR ]CryptFindLocalizedName($[LPCWSTR pwszCryptName])

$~CryptMemAlloc
$[LPVOID ]CryptMemAlloc($[ULONG cbSize])

$~CryptMemRealloc
$[LPVOID ]CryptMemRealloc($[LPVOID pv], $[ULONG cbSize])

$~CertDuplicateCertificateChain
$[PCCERT_CHAIN_CONTEXT ]CertDuplicateCertificateChain($[PCCERT_CHAIN_CONTEXT pChainContext])

$~CertFindChainInStore
$[PCCERT_CHAIN_CONTEXT ]CertFindChainInStore($[HCERTSTORE hCertStore], $[DWORD dwCertEncodingType], $[DWORD dwFindFlags], $[DWORD dwFindType], $[const void* pvFindPara], $[PCCERT_CHAIN_CONTEXT pPrevChainContext])

$~CertCreateCertificateContext
$[PCCERT_CONTEXT ]CertCreateCertificateContext($[DWORD dwCertEncodingType], $[const BYTE* pbCertEncoded], $[DWORD cbCertEncoded])

$~CertCreateSelfSignCertificate
$[PCCERT_CONTEXT ]CertCreateSelfSignCertificate($[HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey], $[PCERT_NAME_BLOB pSubjectIssuerBlob], $[DWORD dwFlags], $[PCRYPT_KEY_PROV_INFO pKeyProvInfo], $[PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm], $[PSYSTEMTIME pStartTime], $[PSYSTEMTIME pEndTime], $[PCERT_EXTENSIONS pExtensions])

$~CertDuplicateCertificateContext
$[PCCERT_CONTEXT ]CertDuplicateCertificateContext($[PCCERT_CONTEXT pCertContext])

$~CertEnumCertificatesInStore
$[PCCERT_CONTEXT ]CertEnumCertificatesInStore($[HCERTSTORE hCertStore], $[PCCERT_CONTEXT pPrevCertContext])

$~CertFindCertificateInStore
$[PCCERT_CONTEXT ]CertFindCertificateInStore($[HCERTSTORE hCertStore], $[DWORD dwCertEncodingType], $[DWORD dwFindFlags], $[DWORD dwFindType], $[const void* pvFindPara], $[PCCERT_CONTEXT pPrevCertContext])

$~CertGetIssuerCertificateFromStore
$[PCCERT_CONTEXT ]CertGetIssuerCertificateFromStore($[HCERTSTORE hCertStore], $[PCCERT_CONTEXT pSubjectContext], $[PCCERT_CONTEXT pPrevIssuerContext], $[DWORD* pdwFlags])

$~CertGetSubjectCertificateFromStore
$[PCCERT_CONTEXT ]CertGetSubjectCertificateFromStore($[HCERTSTORE hCertStore], $[DWORD dwCertEncodingType], $[PCERT_INFO pCertId])

$~CertCreateCRLContext
$[PCCRL_CONTEXT ]CertCreateCRLContext($[DWORD dwCertEncodingType], $[const BYTE* pbCrlEncoded], $[DWORD cbCrlEncoded])

$~CertDuplicateCRLContext
$[PCCRL_CONTEXT ]CertDuplicateCRLContext($[PCCRL_CONTEXT pCrlContext])

$~CertEnumCRLsInStore
$[PCCRL_CONTEXT ]CertEnumCRLsInStore($[HCERTSTORE hCertStore], $[PCCRL_CONTEXT pPrevCrlContext])

$~CertFindCRLInStore
$[PCCRL_CONTEXT ]CertFindCRLInStore($[HCERTSTORE hCertStore], $[DWORD dwEncodingType], $[DWORD dwFindFlags], $[DWORD dwFindType], $[const void* pvFindPara], $[PCCRL_CONTEXT pPrevCrlContext])

$~CertGetCRLFromStore
$[PCCRL_CONTEXT ]CertGetCRLFromStore($[HCERTSTORE hCertStore], $[PCCERT_CONTEXT pIssuerContext], $[PCCRL_CONTEXT pPrevCrlContext], $[DWORD* pdwFlags])

$~CryptFindOIDInfo
$[PCCRYPT_OID_INFO ]CryptFindOIDInfo($[DWORD dwKeyType], $[void* pvKey], $[DWORD dwGroupId])

$~CertCreateCTLContext
$[PCCTL_CONTEXT ]CertCreateCTLContext($[DWORD dwMsgAndCertEncodingType], $[const BYTE* pbCtlEncoded], $[DWORD cbCtlEncoded])

$~CertDuplicateCTLContext
$[PCCTL_CONTEXT ]CertDuplicateCTLContext($[PCCTL_CONTEXT pCtlContext])

$~CertEnumCTLsInStore
$[PCCTL_CONTEXT ]CertEnumCTLsInStore($[HCERTSTORE hCertStore], $[PCCTL_CONTEXT pPrevCtlContext])

$~CertFindCTLInStore
$[PCCTL_CONTEXT ]CertFindCTLInStore($[HCERTSTORE hCertStore], $[DWORD dwMsgAndCertEncodingType], $[DWORD dwFindFlags], $[DWORD dwFindType], $[const void* pvFindPara], $[PCCTL_CONTEXT pPrevCtlContext])

$~CertFindExtension
$[PCERT_EXTENSION ]CertFindExtension($[LPCSTR pszObjId], $[DWORD cExtensions], $[CERT_EXTENSION* rgExtensions])

$~CertFindRDNAttr
$[PCERT_RDN_ATTR ]CertFindRDNAttr($[LPCSTR pszObjId], $[PCERT_NAME_INFO pName])

$~CertFindAttribute
$[PCRYPT_ATTRIBUTE ]CertFindAttribute($[LPCSTR pszObjId], $[DWORD cAttr], $[CRYPT_ATTRIBUTE* rgAttr])

$~CertFindSubjectInCTL
$[PCTL_ENTRY ]CertFindSubjectInCTL($[DWORD dwEncodingType], $[DWORD dwSubjectType], $[void* pvSubject], $[PCCTL_CONTEXT pCtlContext], $[DWORD dwFlags])

$~CertFreeCertificateChain
$[VOID ]CertFreeCertificateChain($[PCCERT_CHAIN_CONTEXT pChainContext])

$~CertFreeCertificateChainEngine
$[void ]CertFreeCertificateChainEngine($[HCERTCHAINENGINE hChainEngine])

$~CertRemoveStoreFromCollection
$[void ]CertRemoveStoreFromCollection($[HCERTSTORE hCollectionStore], $[HCERTSTORE hSiblingStore])

$~CryptMemFree
$[void ]CryptMemFree($[LPVOID pv])

$~CertCreateContext
$[void* ]CertCreateContext($[DWORD dwContextType], $[DWORD dwEncodingType], $[const BYTE* pbEncoded], $[DWORD cbEncoded], $[DWORD dwFlags], $[PCERT_CREATE_CONTEXT_PARA pCreatePara])

$; dbghelp.dll
$; ------------
$~DbgHelpCreateUserDump
$[BOOL ]DbgHelpCreateUserDump($[LPSTR FileName], $[PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback], $[PVOID UserData])

$~DbgHelpCreateUserDumpW
$[BOOL ]DbgHelpCreateUserDumpW($[LPWSTR FileName], $[PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback], $[PVOID UserData])

$~EnumerateLoadedModules
$[BOOL ]EnumerateLoadedModules($[HANDLE hProcess], $[PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback], $[PVOID UserContext])

$~EnumerateLoadedModules64
$[BOOL ]EnumerateLoadedModules64($[HANDLE hProcess], $[PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback], $[PVOID UserContext])

$~FindFileInPath
$[BOOL ]FindFileInPath($[HANDLE hprocess], $[LPSTR SearchPath], $[LPSTR FileName], $[PVOID id], $[DWORD two], $[DWORD three], $[DWORD flags], $[LPSTR FilePath])

$~FindFileInSearchPath
$[BOOL ]FindFileInSearchPath($[HANDLE hprocess], $[LPSTR SearchPath], $[LPSTR FileName], $[DWORD one], $[DWORD two], $[DWORD three], $[LPSTR FilePath])

$~MakeSureDirectoryPathExists
$[BOOL ]MakeSureDirectoryPathExists($[PCSTR DirPath])

$~MiniDumpReadDumpStream
$[BOOL ]MiniDumpReadDumpStream($[PVOID BaseOfDump], $[ULONG StreamNumber], $[PMINIDUMP_DIRECTORY* Dir], $[PVOID* StreamPointer], $[ULONG* StreamSize])

$~MiniDumpWriteDump
$[BOOL ]MiniDumpWriteDump($[HANDLE hProcess], $[DWORD ProcessId], $[HANDLE hFile], $[MINIDUMP_TYPE DumpType], $[PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam], $[PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam], $[PMINIDUMP_CALLBACK_INFORMATION CallbackParam])

$~SearchTreeForFile
$[BOOL ]SearchTreeForFile($[PCSTR RootPath], $[PCSTR InputPathName], $[PSTR OutputPathBuffer])

$~StackWalk
$[BOOL ]StackWalk($[DWORD MachineType], $[HANDLE hProcess], $[HANDLE hThread], $[LPSTACKFRAME StackFrame], $[PVOID ContextRecord], $[PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine], $[PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine], $[PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine], $[PTRANSLATE_ADDRESS_ROUTINE TranslateAddress])

$~StackWalk64
$[BOOL ]StackWalk64($[DWORD MachineType], $[HANDLE hProcess], $[HANDLE hThread], $[LPSTACKFRAME64 StackFrame], $[PVOID ContextRecord], $[PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine], $[PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine], $[PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine], $[PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress])

$~SymCleanup
$[BOOL ]SymCleanup($[HANDLE hProcess])

$~SymEnumerateModules
$[BOOL ]SymEnumerateModules($[HANDLE hProcess], $[PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback], $[PVOID UserContext])

$~SymEnumerateModules64
$[BOOL ]SymEnumerateModules64($[HANDLE hProcess], $[PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback], $[PVOID UserContext])

$~SymEnumerateSymbols
$[BOOL ]SymEnumerateSymbols($[HANDLE hProcess], $[DWORD64 BaseOfDll], $[PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback], $[PVOID UserContext])

$~SymEnumerateSymbols64
$[BOOL ]SymEnumerateSymbols64($[HANDLE hProcess], $[DWORD64 BaseOfDll], $[PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback], $[PVOID UserContext])

$~SymEnumSourceFiles
$[BOOL ]SymEnumSourceFiles($[HANDLE hProcess], $[ULONG64 ModBase], $[PCSTR Mask], $[PSYM_ENUMSOURCEFILES_CALLBACK EnumSymbolsCallback], $[PVOID UserContext])

$~SymEnumSym
$[BOOL ]SymEnumSym($[HANDLE hProcess], $[ULONG64 BaseOfDll], $[PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback], $[PVOID UserContext])

$~SymEnumSymbols
$[BOOL ]SymEnumSymbols($[HANDLE hProcess], $[ULONG64 BaseOfDll], $[PCSTR Mask], $[PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback], $[PVOID UserContext])

$~SymEnumTypes
$[BOOL ]SymEnumTypes($[HANDLE hProcess], $[ULONG64 BaseOfDll], $[PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback], $[PVOID UserContext])

$~SymFindFileInPath
$[BOOL ]SymFindFileInPath($[HANDLE hProcess], $[PCSTR SearchPath], $[PCSTR FileName], $[PVOID id], $[DWORD two], $[DWORD three], $[DWORD flags], $[PSTR FilePath], $[PFINDFILEINPATHCALLBACK callback], $[PVOID context])

$~SymFromAddr
$[BOOL ]SymFromAddr($[HANDLE hProcess], $[DWORD64 Address], $[PDWORD64 Displacement], $[PSYMBOL_INFO Symbol])

$~SymFromName
$[BOOL ]SymFromName($[HANDLE hProcess], $[PCSTR Name], $[PSYMBOL_INFO Symbol])

$~SymGetFileLineOffsets64
$[BOOL ]SymGetFileLineOffsets64($[HANDLE hProcess], $[PCSTR ModuleName], $[PCSTR FileName], $[PDWORD64 Buffer], $[ULONG BufferLines])

$~SymGetLineFromAddr
$[BOOL ]SymGetLineFromAddr($[HANDLE hProcess], $[DWORD dwAddr], $[PDWORD pdwDisplacement], $[PIMAGEHLP_LINE Line])

$~SymGetLineFromAddr64
$[BOOL ]SymGetLineFromAddr64($[HANDLE hProcess], $[DWORD64 dwAddr], $[PDWORD pdwDisplacement], $[PIMAGEHLP_LINE64 Line])

$~SymGetLineFromName
$[BOOL ]SymGetLineFromName($[HANDLE hProcess], $[LPSTR ModuleName], $[LPSTR FileName], $[DWORD dwLineNumber], $[PLONG lpDisplacement], $[PIMAGEHLP_LINE Line])

$~SymGetLineFromName64
$[BOOL ]SymGetLineFromName64($[HANDLE hProcess], $[PCSTR ModuleName], $[PCSTR FileName], $[DWORD dwLineNumber], $[PLONG lpDisplacement], $[PIMAGEHLP_LINE64 Line])

$~SymGetLineNext
$[BOOL ]SymGetLineNext($[HANDLE hProcess], $[PIMAGEHLP_LINE Line])

$~SymGetLineNext64
$[BOOL ]SymGetLineNext64($[HANDLE hProcess], $[PIMAGEHLP_LINE64 Line])

$~SymGetLinePrev
$[BOOL ]SymGetLinePrev($[HANDLE hProcess], $[PIMAGEHLP_LINE Line])

$~SymGetLinePrev64
$[BOOL ]SymGetLinePrev64($[HANDLE hProcess], $[PIMAGEHLP_LINE64 Line])

$~SymGetModuleInfo
$[BOOL ]SymGetModuleInfo($[HANDLE hProcess], $[DWORD dwAddr], $[PIMAGEHLP_MODULE ModuleInfo])

$~SymGetModuleInfo64
$[BOOL ]SymGetModuleInfo64($[HANDLE hProcess], $[DWORD64 dwAddr], $[PIMAGEHLP_MODULE64 ModuleInfo])

$~SymGetModuleInfoW
$[BOOL ]SymGetModuleInfoW($[HANDLE hProcess], $[DWORD dwAddr], $[PIMAGEHLP_MODULE ModuleInfo])

$~SymGetModuleInfoW64
$[BOOL ]SymGetModuleInfoW64($[HANDLE hProcess], $[DWORD64 qwAddr], $[PIMAGEHLP_MODULEW64 ModuleInfo])

$~SymGetSearchPath
$[BOOL ]SymGetSearchPath($[HANDLE hProcess], $[PSTR SearchPath], $[DWORD SearchPathLength])

$~SymGetSymFromAddr
$[BOOL ]SymGetSymFromAddr($[HANDLE hProcess], $[DWORD Address], $[PDWORD Displacement], $[PIMAGEHLP_SYMBOL Symbol])

$~SymGetSymFromAddr64
$[BOOL ]SymGetSymFromAddr64($[HANDLE hProcess], $[DWORD64 Address], $[PDWORD64 Displacement], $[PIMAGEHLP_SYMBOL64 Symbol])

$~SymGetSymFromName
$[BOOL ]SymGetSymFromName($[HANDLE hProcess], $[LPSTR Name], $[PIMAGEHLP_SYMBOL Symbol])

$~SymGetSymFromName64
$[BOOL ]SymGetSymFromName64($[HANDLE hProcess], $[PCSTR Name], $[PIMAGEHLP_SYMBOL64 Symbol])

$~SymGetSymNext
$[BOOL ]SymGetSymNext($[HANDLE hProcess], $[PIMAGEHLP_SYMBOL Symbol])

$~SymGetSymNext64
$[BOOL ]SymGetSymNext64($[HANDLE hProcess], $[PIMAGEHLP_SYMBOL64 Symbol])

$~SymGetSymPrev
$[BOOL ]SymGetSymPrev($[HANDLE hProcess], $[PIMAGEHLP_SYMBOL Symbol])

$~SymGetSymPrev64
$[BOOL ]SymGetSymPrev64($[HANDLE hProcess], $[PIMAGEHLP_SYMBOL64 Symbol])

$~SymGetTypeFromName
$[BOOL ]SymGetTypeFromName($[HANDLE hProcess], $[ULONG64 BaseOfDll], $[PCSTR Name], $[PSYMBOL_INFO Symbol])

$~SymGetTypeInfo
$[BOOL ]SymGetTypeInfo($[HANDLE hProcess], $[DWORD64 ModBase], $[ULONG TypeId], $[IMAGEHLP_SYMBOL_TYPE_INFO GetType], $[PVOID pInfo])

$~SymInitialize
$[BOOL ]SymInitialize($[HANDLE hProcess], $[PCSTR UserSearchPath], $[BOOL fInvadeProcess])

$~SymMatchFileName
$[BOOL ]SymMatchFileName($[PSTR FileName], $[PSTR Match], $[PTSTR* FileNameStop], $[PTSTR* MatchStop])

$~SymMatchString
$[BOOL ]SymMatchString($[PCSTR string], $[PCSTR expression], $[BOOL fCase])

$~SymRegisterCallback
$[BOOL ]SymRegisterCallback($[HANDLE hProcess], $[PSYMBOL_REGISTERED_CALLBACK CallbackFunction], $[PVOID UserContext])

$~SymRegisterCallback64
$[BOOL ]SymRegisterCallback64($[HANDLE hProcess], $[PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction], $[ULONG64 UserContext])

$~SymRegisterFunctionEntryCallback
$[BOOL ]SymRegisterFunctionEntryCallback($[HANDLE hProcess], $[PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction], $[PVOID UserContext])

$~SymRegisterFunctionEntryCallback64
$[BOOL ]SymRegisterFunctionEntryCallback64($[HANDLE hProcess], $[PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction], $[ULONG64 UserContext])

$~SymSetSearchPath
$[BOOL ]SymSetSearchPath($[HANDLE hProcess], $[PCSTR SearchPath])

$~SymUnDName
$[BOOL ]SymUnDName($[PIMAGEHLP_SYMBOL Symbol], $[PSTR UnDecName], $[DWORD UnDecNameLength])

$~SymUnDName64
$[BOOL ]SymUnDName64($[PIMAGEHLP_SYMBOL64 sym], $[PSTR UnDecName], $[DWORD UnDecNameLength])

$~SymUnloadModule
$[BOOL ]SymUnloadModule($[HANDLE hProcess], $[DWORD BaseOfDll])

$~SymUnloadModule64
$[BOOL ]SymUnloadModule64($[HANDLE hProcess], $[DWORD64 BaseOfDll])

$~UnmapDebugInformation
$[BOOL ]UnmapDebugInformation($[PIMAGE_DEBUG_INFORMATION DebugInfo])

$~GetTimestampForLoadedLibrary
$[DWORD ]GetTimestampForLoadedLibrary($[HMODULE ImageBase])

$~SymGetModuleBase
$[DWORD ]SymGetModuleBase($[HANDLE hProcess], $[DWORD dwAddr])

$~SymGetOptions
$[DWORD ]SymGetOptions($[])

$~SymLoadModule
$[DWORD ]SymLoadModule($[HANDLE hProcess], $[HANDLE hFile], $[PSTR ImageName], $[PSTR ModuleName], $[DWORD BaseOfDll], $[DWORD SizeOfDll])

$~SymSetOptions
$[DWORD ]SymSetOptions($[DWORD SymOptions])

$~UnDecorateSymbolName
$[DWORD ]UnDecorateSymbolName($[PCSTR DecoratedName], $[PSTR UnDecoratedName], $[DWORD UndecoratedLength], $[DWORD Flags])

$~SymGetModuleBase64
$[DWORD64 ]SymGetModuleBase64($[HANDLE hProcess], $[DWORD64 dwAddr])

$~SymLoadModule64
$[DWORD64 ]SymLoadModule64($[HANDLE hProcess], $[HANDLE hFile], $[PCSTR ImageName], $[PCSTR ModuleName], $[DWORD64 BaseOfDll], $[DWORD SizeOfDll])

$~SymLoadModuleEx
$[DWORD64 ]SymLoadModuleEx($[HANDLE hProcess], $[HANDLE hFile], $[PCSTR ImageName], $[PCSTR ModuleName], $[DWORD64 BaseOfDll], $[DWORD DllSize], $[PMODLOAD_DATA Data], $[DWORD Flags])

$~FindDebugInfoFile
$[HANDLE ]FindDebugInfoFile($[PCSTR FileName], $[PCSTR SymbolPath], $[PSTR DebugFilePath])

$~FindDebugInfoFileEx
$[HANDLE ]FindDebugInfoFileEx($[PCSTR FileName], $[PCSTR SymbolPath], $[PSTR DebugFilePath], $[PFIND_DEBUG_FILE_CALLBACK Callback], $[PVOID CallerData])

$~FindExecutableImage
$[HANDLE ]FindExecutableImage($[PCSTR FileName], $[PCSTR SymbolPath], $[PSTR ImageFilePath])

$~FindExecutableImageEx
$[HANDLE ]FindExecutableImageEx($[PCSTR FileName], $[PCSTR SymbolPath], $[PSTR ImageFilePath], $[PFIND_EXE_FILE_CALLBACK Callback], $[PVOID CallerData])

$~ImagehlpApiVersion
$[LPAPI_VERSION ]ImagehlpApiVersion($[])

$~ImagehlpApiVersionEx
$[LPAPI_VERSION ]ImagehlpApiVersionEx($[LPAPI_VERSION AppVersion])

$~MapDebugInformation
$[PIMAGE_DEBUG_INFORMATION ]MapDebugInformation($[HANDLE FileHandle], $[PSTR FileName], $[PSTR SymbolPath], $[DWORD ImageBase])

$~ImageNtHeader
$[PIMAGE_NT_HEADERS ]ImageNtHeader($[PVOID ImageBase])

$~ImageRvaToSection
$[PIMAGE_SECTION_HEADER ]ImageRvaToSection($[PIMAGE_NT_HEADERS NtHeaders], $[PVOID Base], $[ULONG Rva])

$~ImageDirectoryEntryToData
$[PVOID ]ImageDirectoryEntryToData($[PVOID Base], $[BOOLEAN MappedAsImage], $[USHORT DirectoryEntry], $[PULONG Size])

$~ImageDirectoryEntryToDataEx
$[PVOID ]ImageDirectoryEntryToDataEx($[PVOID Base], $[BOOLEAN MappedAsImage], $[USHORT DirectoryEntry], $[PULONG Size], $[PIMAGE_SECTION_HEADER* FoundHeader])

$~ImageRvaToVa
$[PVOID ]ImageRvaToVa($[PIMAGE_NT_HEADERS NtHeaders], $[PVOID Base], $[ULONG Rva], $[PIMAGE_SECTION_HEADER* LastRvaSection])

$~SymFunctionTableAccess
$[PVOID ]SymFunctionTableAccess($[HANDLE hProcess], $[DWORD AddrBase])

$~SymFunctionTableAccess64
$[PVOID ]SymFunctionTableAccess64($[HANDLE hProcess], $[DWORD64 AddrBase])

$~SymSetContext
$[ULONG ]SymSetContext($[HANDLE hProcess], $[PIMAGEHLP_STACK_FRAME StackFrame], $[PIMAGEHLP_CONTEXT Context])

$; gdi32.dll
$; ---------
$~AbortPath
$[BOOL ]AbortPath($[HDC hdc])

$~AngleArc
$[BOOL ]AngleArc($[HDC hdc], $[int X], $[int Y], $[DWORD dwRadius], $[FLOAT eStartAngle], $[FLOAT eSweepAngle])

$~AnimatePalette
$[BOOL ]AnimatePalette($[HPALETTE hpal], $[UINT iStartIndex], $[UINT cEntries], $[CONST PALETTEENTRY *ppe])

$~ArcTo
$[BOOL ]ArcTo($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect], $[int nXRadial1], $[int nYRadial1], $[int nXRadial2], $[int nYRadial2])

$~BeginPath
$[BOOL ]BeginPath($[HDC hdc])

$~BitBlt
$[BOOL ]BitBlt($[HDC hdcDest], $[int nXDest], $[int nYDest], $[int nWidth], $[int nHeight], $[HDC hdcSrc], $[int nXSrc], $[int nYSrc], $[DWORD dwRop])

$~CancelDC
$[BOOL ]CancelDC($[HDC hdc])

$~CheckColorsInGamut
$[BOOL ]CheckColorsInGamut($[HDC hDC], $[LPVOID lpRGBTriples], $[LPVOID lpBuffer], $[UINT nCount])

$~Chord
$[BOOL ]Chord($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect], $[int nXRadial1], $[int nYRadial1], $[int nXRadial2], $[int nYRadial2])

$~CLIPOBJ_bEnum
$[BOOL ]CLIPOBJ_bEnum($[IN CLIPOBJ *pco], $[IN ULONG cj], $[OUT ULONG *pv])

$~CloseFigure
$[BOOL ]CloseFigure($[HDC])

$~ColorCorrectPalette
$[BOOL ]ColorCorrectPalette($[HDC hDC], $[HPALETTE hPalette], $[DWORD dwFirstEntry], $[DWORD dwNumOfEntries])

$~ColorMatchToTarget
$[BOOL ]ColorMatchToTarget($[HDC hDC], $[HDC hdcTarget], $[DWORD uiAction])

$~CombineTransform
$[BOOL ]CombineTransform($[LPXFORM lpxformResult], $[CONST XFORM *lpxform1], $[CONST XFORM *lpxform2])

$~CreateScalableFontResourceA
$[BOOL ]CreateScalableFontResourceA($[DWORD fdwHidden], $[LPCSTR lpszFontRes], $[LPCSTR lpszFontFile], $[LPCSTR lpszCurrentPath])

$~CreateScalableFontResourceW
$[BOOL ]CreateScalableFontResourceW($[DWORD fdwHidden], $[LPCWSTR lpszFontRes], $[LPCWSTR lpszFontFile], $[LPCWSTR lpszCurrentPath])

$~DeleteColorSpace
$[BOOL ]DeleteColorSpace($[HCOLORSPACE hColorSpace])

$~DeleteDC
$[BOOL ]DeleteDC($[HDC hdc])

$~DeleteEnhMetaFile
$[BOOL ]DeleteEnhMetaFile($[HENHMETAFILE hemf])

$~DeleteMetaFile
$[BOOL ]DeleteMetaFile($[HMETAFILE hmf])

$~DeleteObject
$[BOOL ]DeleteObject($[HGDIOBJ hObject])

$~DPtoLP
$[BOOL ]DPtoLP($[HDC hdc], $[LPPOINT lpPoints], $[int nCount])

$~EnableEUDC
$[BOOL ]EnableEUDC($[BOOL fEnableEUDC])

$~EndPath
$[BOOL ]EndPath($[HDC hdc])

$~EngAssociateSurface
$[BOOL ]EngAssociateSurface($[IN HSURF hsurf], $[IN HDEV hdev], $[IN FLONG flHooks])

$~EngBitBlt
$[BOOL ]EngBitBlt($[IN SURFOBJ *psoTrg], $[IN SURFOBJ *psoSrc], $[IN SURFOBJ *psoMask], $[IN CLIPOBJ *pco], $[IN XLATEOBJ *pxlo], $[IN RECTL *prclTrg], $[IN POINTL *pptlSrc], $[IN POINTL *pptlMask], $[IN BRUSHOBJ *pbo], $[IN POINTL *pptlBrush], $[IN ROP4 rop4])

$~EngCheckAbort
$[BOOL ]EngCheckAbort($[IN SURFOBJ *pso])

$~EngCopyBits
$[BOOL ]EngCopyBits($[OUT SURFOBJ *psoDest], $[IN SURFOBJ *psoSrc], $[IN CLIPOBJ *pco], $[IN XLATEOBJ *pxlo], $[IN RECTL *prclDest], $[IN POINTL *pptlSrc])

$~EngDeletePalette
$[BOOL ]EngDeletePalette($[IN HPALETTE hpal])

$~EngEraseSurface
$[BOOL ]EngEraseSurface($[IN SURFOBJ *pso], $[IN RECTL *prcl], $[IN ULONG iColor])

$~EngFillPath
$[BOOL ]EngFillPath($[IN SURFOBJ *pso], $[IN PATHOBJ *ppo], $[IN CLIPOBJ *pco], $[IN BRUSHOBJ *pbo], $[IN POINTL *pptlBrushOrg], $[IN MIX mix], $[IN FLONG flOptions])

$~EngGradientFill
$[BOOL ]EngGradientFill($[IN SURFOBJ *psoDest], $[IN CLIPOBJ *pco], $[IN XLATEOBJ *pxlo], $[IN TRIVERTEX *pVertex], $[IN ULONG nVertex], $[IN PVOID pMesh], $[IN ULONG nMesh], $[IN RECTL *prclExtents], $[IN POINTL *pptlDitherOrg], $[IN ULONG ulMode])

$~EngLineTo
$[BOOL ]EngLineTo($[SURFOBJ *pso], $[CLIPOBJ *pco], $[BRUSHOBJ *pbo], $[LONG x1], $[LONG y1], $[LONG x2], $[LONG y2], $[RECTL *prclBounds], $[MIX mix])

$~EngMarkBandingSurface
$[BOOL ]EngMarkBandingSurface($[IN HSURF hsurf])

$~EngPaint
$[BOOL ]EngPaint($[IN SURFOBJ *pso], $[IN CLIPOBJ *pco], $[IN BRUSHOBJ *pbo], $[IN POINTL *pptlBrushOrg], $[IN MIX mix])

$~EngStretchBlt
$[BOOL ]EngStretchBlt($[IN SURFOBJ *psoDest], $[IN SURFOBJ *psoSrc], $[IN SURFOBJ *psoMask], $[IN CLIPOBJ *pco], $[IN XLATEOBJ *pxlo], $[IN COLORADJUSTMENT *pca], $[IN POINTL *pptlHTOrg], $[IN RECTL *prclDest], $[IN RECTL *prclSrc], $[IN POINTL *pptlMask], $[IN ULONG iMode])

$~EngStrokeAndFillPath
$[BOOL ]EngStrokeAndFillPath($[IN SURFOBJ *pso], $[IN PATHOBJ *ppo], $[IN CLIPOBJ *pco], $[IN XFORMOBJ *pxo], $[IN BRUSHOBJ *pboStroke], $[IN LINEATTRS *plineattrs], $[IN BRUSHOBJ *pboFill], $[IN POINTL *pptlBrushOrg], $[IN MIX mixFill], $[IN FLONG flOptions])

$~EngStrokePath
$[BOOL ]EngStrokePath($[IN SURFOBJ *pso], $[IN PATHOBJ *ppo], $[IN CLIPOBJ *pco], $[IN XFORMOBJ *pxo], $[IN BRUSHOBJ *pbo], $[IN POINTL *pptlBrushOrg], $[IN LINEATTRS *plineattrs], $[IN MIX mix])

$~EngTextOut
$[BOOL ]EngTextOut($[IN SURFOBJ *pso], $[IN STROBJ *pstro], $[IN FONTOBJ *pfo], $[IN CLIPOBJ *pco], $[IN RECTL *prclExtra], $[IN RECTL *prclOpaque], $[IN BRUSHOBJ *pboFore], $[IN BRUSHOBJ *pboOpaque], $[IN POINTL pptlOrg], $[IN MIX mix])

$~EnumEnhMetaFile
$[BOOL ]EnumEnhMetaFile($[HDC hdc], $[HENHMETAFILE hemf], $[ENHMFENUMPROC lpEnhMetaFunc], $[LPVOID lpData], $[CONST RECT *lpRect])

$~EnumMetaFile
$[BOOL ]EnumMetaFile($[HDC hdc], $[HMETAFILE hmf], $[MFENUMPROC lpMetaFunc], $[LPARAM lParam])

$~EqualRgn
$[BOOL ]EqualRgn($[HRGN hSrcRgn1], $[HRGN hSrcRgn2])

$~ExtFloodFill
$[BOOL ]ExtFloodFill($[HDC hdc], $[int nXStart], $[int nYStart], $[COLORREF crColor], $[UINT fuFillType])

$~ExtTextOutA
$[BOOL ]ExtTextOutA($[HDC hdc], $[int X], $[int Y], $[UINT fuOptions], $[CONST RECT* lprc], $[LPCSTR lpString], $[UINT cbCount], $[CONST INT* lpDx])

$~ExtTextOutW
$[BOOL ]ExtTextOutW($[HDC hdc], $[int X], $[int Y], $[UINT fuOptions], $[CONST RECT* lprc], $[LPCWSTR lpString], $[UINT cbCount], $[CONST INT* lpDx])

$~FillRgn
$[BOOL ]FillRgn($[HDC hdc], $[HRGN hrgn], $[HBRUSH hbr])

$~FlattenPath
$[BOOL ]FlattenPath($[HDC hdc])

$~FloodFill
$[BOOL ]FloodFill($[HDC hdc], $[int nXStart], $[int nYStart], $[COLORREF crFill])

$~FrameRgn
$[BOOL ]FrameRgn($[HDC hdc], $[HRGN hrgn], $[HBRUSH hbr], $[int nWidth], $[int nHeight])

$~GdiComment
$[BOOL ]GdiComment($[HDC hdc], $[UINT cbSize], $[CONST BYTE *lpData])

$~GdiDeleteSpoolFileHandle
$[BOOL ]GdiDeleteSpoolFileHandle($[HANDLE SpoolFileHandle])

$~GdiFlush
$[BOOL ]GdiFlush($[])

$~GdiGetDevmodeForPage
$[BOOL ]GdiGetDevmodeForPage($[HANDLE SpoolFileHandle], $[DWORD dwPageNumber], $[PDEVMODEW *pCurrDM], $[PDEVMODEW *pLastDM])

$~GdiPlayPageEMF
$[BOOL ]GdiPlayPageEMF($[HANDLE SpoolFileHandle], $[HANDLE hemf], $[RECT *prectDocument], $[RECT *prectBorder], $[RECT *prectClip])

$~GdiResetDCEMF
$[BOOL ]GdiResetDCEMF($[HANDLE SpoolFileHandle], $[PDEVMODEW pCurrDM])

$~GdiStartDocEMF
$[BOOL ]GdiStartDocEMF($[HANDLE SpoolFileHandle], $[DOCINFOW *pDocInfo])

$~GetAspectRatioFilterEx
$[BOOL ]GetAspectRatioFilterEx($[HDC hdc], $[LPSIZE lpAspectRatio])

$~GetBitmapDimensionEx
$[BOOL ]GetBitmapDimensionEx($[HBITMAP hBitmap], $[LPSIZE lpDimension])

$~GetBrushOrgEx
$[BOOL ]GetBrushOrgEx($[HDC hdc], $[LPPOINT lppt])

$~GetCharABCWidthsA
$[BOOL ]GetCharABCWidthsA($[HDC hdc], $[UINT uFirstChar], $[UINT uLastChar], $[LPABC lpabc])

$~GetCharABCWidthsFloatA
$[BOOL ]GetCharABCWidthsFloatA($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[LPABCFLOAT lpABCF])

$~GetCharABCWidthsFloatW
$[BOOL ]GetCharABCWidthsFloatW($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[LPABCFLOAT lpABCF])

$~GetCharABCWidthsI
$[BOOL ]GetCharABCWidthsI($[HDC hdc], $[UINT giFirst], $[UINT cgi], $[LPWORD pgi], $[LPABC lpabc])

$~GetCharABCWidthsW
$[BOOL ]GetCharABCWidthsW($[HDC hdc], $[UINT uFirstChar], $[UINT uLastChar], $[LPABC lpabc])

$~GetCharWidthA
$[BOOL ]GetCharWidthA($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[LPINT lpBuffer])

$~GetCharWidthFloatA
$[BOOL ]GetCharWidthFloatA($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[PFLOAT pxBuffer])

$~GetCharWidthFloatW
$[BOOL ]GetCharWidthFloatW($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[PFLOAT pxBuffer])

$~GetCharWidthI
$[BOOL ]GetCharWidthI($[HDC hdc], $[UINT giFirst], $[UINT cgi], $[LPWORD pgi], $[LPINT lpBuffer])

$~GetCharWidthW
$[BOOL ]GetCharWidthW($[HDC hdc], $[UINT iFirstChar], $[UINT iLastChar], $[LPINT lpBuffer])

$~GetColorAdjustment
$[BOOL ]GetColorAdjustment($[HDC hdc], $[LPCOLORADJUSTMENT lpca])

$~GetCurrentPositionEx
$[BOOL ]GetCurrentPositionEx($[HDC hdc], $[LPPOINT lpPoint])

$~GetDCOrgEx
$[BOOL ]GetDCOrgEx($[HDC hdc], $[LPPOINT lpPoint])

$~GetDeviceGammaRamp
$[BOOL ]GetDeviceGammaRamp($[HDC hDC], $[LPVOID lpRamp])

$~GetICMProfileA
$[BOOL ]GetICMProfileA($[HDC hDC], $[LPDWORD lpcbName], $[LPSTR lpszFilename])

$~GetICMProfileW
$[BOOL ]GetICMProfileW($[HDC hDC], $[LPDWORD lpcbName], $[LPWSTR lpszFilename])

$~GetLogColorSpaceA
$[BOOL ]GetLogColorSpaceA($[HCOLORSPACE hColorSpace], $[LPLOGCOLORSPACE lpBuffer], $[DWORD nSize])

$~GetLogColorSpaceW
$[BOOL ]GetLogColorSpaceW($[HCOLORSPACE hColorSpace], $[LPLOGCOLORSPACE lpBuffer], $[DWORD nSize])

$~GetRasterizerCaps
$[BOOL ]GetRasterizerCaps($[LPRASTERIZER_STATUS lprs], $[UINT cb])

$~GetTextExtentExPointA
$[BOOL ]GetTextExtentExPointA($[HDC hdc], $[LPCSTR lpszStr], $[int cchString], $[int nMaxExtent], $[LPINT lpnFit], $[LPINT alpDx], $[LPSIZE lpSize])

$~GetTextExtentExPointI
$[BOOL ]GetTextExtentExPointI($[HDC hdc], $[LPWORD pgiIn], $[int cgi], $[int nMaxExtent], $[LPINT lpnFit], $[LPINT alpDx], $[LPSIZE lpSize])

$~GetTextExtentExPointW
$[BOOL ]GetTextExtentExPointW($[HDC hdc], $[LPCWSTR lpszStr], $[int cchString], $[int nMaxExtent], $[LPINT lpnFit], $[LPINT alpDx], $[LPSIZE lpSize])

$~GetTextExtentPoint32A
$[BOOL ]GetTextExtentPoint32A($[HDC hdc], $[LPCWSTR lpString], $[int cbString], $[LPSIZE lpSize])

$~GetTextExtentPoint32W
$[BOOL ]GetTextExtentPoint32W($[HDC hdc], $[LPCSTR lpString], $[int cbString], $[LPSIZE lpSize])

$~GetTextExtentPointA
$[BOOL ]GetTextExtentPointA($[HDC hdc], $[LPCSTR lpString], $[int cbString], $[LPSIZE lpSize])

$~GetTextExtentPointI
$[BOOL ]GetTextExtentPointI($[HDC hdc], $[LPWORD pgiIn], $[int cgi], $[LPSIZE lpSize])

$~GetTextExtentPointW
$[BOOL ]GetTextExtentPointW($[HDC hdc], $[LPCWSTR lpString], $[int cbString], $[LPSIZE lpSize])

$~GetTextMetricsA
$[BOOL ]GetTextMetricsA($[HDC hdc], $[LPTEXTMETRIC lptm])

$~GetTextMetricsW
$[BOOL ]GetTextMetricsW($[HDC hdc], $[LPTEXTMETRIC lptm])

$~GetViewportExtEx
$[BOOL ]GetViewportExtEx($[HDC hdc], $[LPSIZE lpSize])

$~GetViewportOrgEx
$[BOOL ]GetViewportOrgEx($[HDC hdc], $[LPPOINT lpPoint])

$~GetWindowExtEx
$[BOOL ]GetWindowExtEx($[HDC hdc], $[LPSIZE lpSize])

$~GetWindowOrgEx
$[BOOL ]GetWindowOrgEx($[HDC hdc], $[LPPOINT lpPoint])

$~GetWorldTransform
$[BOOL ]GetWorldTransform($[HDC hdc], $[LPXFORM lpXform])

$~InvertRgn
$[BOOL ]InvertRgn($[HDC hdc], $[HRGN hrgn])

$~LineDDA
$[BOOL ]LineDDA($[int nXStart], $[int nYStart], $[int nXEnd], $[int nYEnd], $[LINEDDAPROC lpLineFunc], $[LPARAM lpData])

$~LineTo
$[BOOL ]LineTo($[HDC hdc], $[int nXEnd], $[int nYEnd])

$~LPtoDP
$[BOOL ]LPtoDP($[HDC hdc], $[LPPOINT lpPoints], $[int nCount])

$~MaskBlt
$[BOOL ]MaskBlt($[HDC hdcDest], $[int nXDest], $[int nYDest], $[int nWidth], $[int nHeight], $[HDC hdcSrc], $[int nXSrc], $[int nYSrc], $[HBITMAP hbmMask], $[int xMask], $[int yMask], $[DWORD dwRop])

$~ModifyWorldTransform
$[BOOL ]ModifyWorldTransform($[HDC hdc], $[CONST XFORM *lpXform], $[DWORD iMode])

$~MoveToEx
$[BOOL ]MoveToEx($[HDC hdc], $[int X], $[int Y], $[LPPOINT lpPoint])

$~OffsetViewportOrgEx
$[BOOL ]OffsetViewportOrgEx($[HDC hdc], $[int nXOffset], $[int nYOffset], $[LPPOINT lpPoint])

$~OffsetWindowOrgEx
$[BOOL ]OffsetWindowOrgEx($[HDC hdc], $[int nXOffset], $[int nYOffset], $[LPPOINT lpPoint])

$~PaintRgn
$[BOOL ]PaintRgn($[HDC hdc], $[HRGN hrgn])

$~PatBlt
$[BOOL ]PatBlt($[HDC hdc], $[int nXLeft], $[int nYLeft], $[int nWidth], $[int nHeight], $[DWORD dwRop])

$~PATHOBJ_bEnum
$[BOOL ]PATHOBJ_bEnum($[IN PATHOBJ *ppo], $[OUT PATHDATA *ppd])

$~PATHOBJ_bEnumClipLines
$[BOOL ]PATHOBJ_bEnumClipLines($[IN PATHOBJ *ppo], $[IN ULONG cb], $[OUT CLIPLINE *pcl])

$~Pie
$[BOOL ]Pie($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect], $[int nXRadial1], $[int nYRadial1], $[int nXRadial2], $[int nYRadial2])

$~PlayEnhMetaFile
$[BOOL ]PlayEnhMetaFile($[HDC hdc], $[HENHMETAFILE hemf], $[CONST RECT *lpRect])

$~PlayEnhMetaFileRecord
$[BOOL ]PlayEnhMetaFileRecord($[HDC hdc], $[LPHANDLETABLE lpHandletable], $[CONST ENHMETARECORD *lpEnhMetaRecord], $[UINT nHandles])

$~PlayMetaFile
$[BOOL ]PlayMetaFile($[HDC hdc], $[HMETAFILE hmf])

$~PlayMetaFileRecord
$[BOOL ]PlayMetaFileRecord($[HDC hdc], $[LPHANDLETABLE lpHandletable], $[LPMETARECORD lpMetaRecord], $[UINT nHandles])

$~PlgBlt
$[BOOL ]PlgBlt($[HDC hdcDest], $[CONST POINT *lpPoint], $[HDC hdcSrc], $[int nXSrc], $[int nYSrc], $[int nWidth], $[int nHeight], $[HBITMAP hbmMask], $[int xMask], $[int yMask])

$~PolyBezier
$[BOOL ]PolyBezier($[HDC hdc], $[CONST POINT* lppt], $[DWORD cPoints])

$~PolyBezierTo
$[BOOL ]PolyBezierTo($[HDC hdc], $[CONST POINT *lppt], $[DWORD cCount])

$~PolyDraw
$[BOOL ]PolyDraw($[HDC hdc], $[CONST POINT *lppt], $[CONST BYTE *lpbTypes], $[int cCount])

$~PolylineTo
$[BOOL ]PolylineTo($[HDC hdc], $[CONST POINT *lppt], $[DWORD cCount])

$~PolyPolygon
$[BOOL ]PolyPolygon($[HDC hdc], $[CONST POINT *lpPoints], $[CONST INT *lpPolyCounts], $[int nCount])

$~PolyPolyline
$[BOOL ]PolyPolyline($[HDC hdc], $[CONST POINT *lppt], $[CONST DWORD *lpdwPolyPoints], $[DWORD cCount])

$~PolyTextOutA
$[BOOL ]PolyTextOutA($[HDC hdc], $[CONST POLYTEXT *pptxt], $[int cStrings])

$~PolyTextOutW
$[BOOL ]PolyTextOutW($[HDC hdc], $[CONST POLYTEXT *pptxt], $[int cStrings])

$~PtInRegion
$[BOOL ]PtInRegion($[HRGN hrgn], $[int X], $[int Y])

$~PtVisible
$[BOOL ]PtVisible($[int x], $[int y])

$~RectInRegion
$[BOOL ]RectInRegion($[HRGN hrgn], $[CONST RECT *lprc])

$~RectVisible
$[BOOL ]RectVisible($[HDC hdc], $[CONST RECT* lprc])

$~RemoveFontMemResourceEx
$[BOOL ]RemoveFontMemResourceEx($[HANDLE fh])

$~RemoveFontResourceA
$[BOOL ]RemoveFontResourceA($[LPCSTR lpFileName])

$~RemoveFontResourceExA
$[BOOL ]RemoveFontResourceExA($[LPCSTR lpFileName], $[DWORD fl], $[PVOID pdv])

$~RemoveFontResourceExW
$[BOOL ]RemoveFontResourceExW($[LPCWSTR lpFileName], $[DWORD fl], $[PVOID pdv])

$~RemoveFontResourceW
$[BOOL ]RemoveFontResourceW($[LPCWSTR lpFileName])

$~ResizePalette
$[BOOL ]ResizePalette($[HPALETTE hpal], $[UINT nEntries])

$~RestoreDC
$[BOOL ]RestoreDC($[HDC hdc], $[int nSavedDC])

$~RoundRect
$[BOOL ]RoundRect($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect], $[int nWidth], $[int nHeight])

$~ScaleViewportExtEx
$[BOOL ]ScaleViewportExtEx($[HDC hdc], $[int Xnum], $[int Xdenom], $[int Ynum], $[int Ydenom], $[LPSIZE lpSize])

$~ScaleWindowExtEx
$[BOOL ]ScaleWindowExtEx($[HDC hdc], $[int Xnum], $[int Xdenom], $[int Ynum], $[int Ydenom], $[LPSIZE lpSize])

$~SelectClipPath
$[BOOL ]SelectClipPath($[HDC hdc], $[int iMode])

$~SetBitmapDimensionEx
$[BOOL ]SetBitmapDimensionEx($[HBITMAP hBitmap], $[int nWidth], $[int nHeight], $[LPSIZE lpSize])

$~SetBrushOrgEx
$[BOOL ]SetBrushOrgEx($[HDC hdc], $[int nXOrg], $[int nYOrg], $[LPPOINT lppt])

$~SetColorAdjustment
$[BOOL ]SetColorAdjustment($[HDC hdc], $[CONST COLORADJUSTMENT *lpca])

$~SetDeviceGammaRamp
$[BOOL ]SetDeviceGammaRamp($[HDC hDC], $[LPVOID lpRamp])

$~SetICMProfileA
$[BOOL ]SetICMProfileA($[HDC hDC], $[LPSTR lpFileName])

$~SetICMProfileW
$[BOOL ]SetICMProfileW($[HDC hDC], $[LPWSTR lpFileName])

$~SetMiterLimit
$[BOOL ]SetMiterLimit($[HDC hdc], $[FLOAT eNewLimit], $[PFLOAT peOldLimit])

$~SetPixelFormat
$[BOOL ]SetPixelFormat($[HDC hdc], $[int iPixelFormat], $[CONST PIXELFORMATDESCRIPTOR * ppfd])

$~SetPixelV
$[BOOL ]SetPixelV($[HDC hdc], $[int X], $[int Y], $[COLORREF crColor])

$~SetRectRgn
$[BOOL ]SetRectRgn($[HRGN hrgn], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect])

$~SetTextJustification
$[BOOL ]SetTextJustification($[HDC hdc], $[int nBreakExtra], $[int nBreakCount])

$~SetViewportExtEx
$[BOOL ]SetViewportExtEx($[HDC hdc], $[int nXExtent], $[int nYExtent], $[LPSIZE lpSize])

$~SetViewportOrgEx
$[BOOL ]SetViewportOrgEx($[HDC hdc], $[int X], $[int Y], $[LPPOINT lpPoint])

$~SetWindowExtEx
$[BOOL ]SetWindowExtEx($[HDC hdc], $[int nXExtent], $[int nYExtent], $[LPSIZE lpSize])

$~SetWindowOrgEx
$[BOOL ]SetWindowOrgEx($[HDC hdc], $[int X], $[int Y], $[LPPOINT lpPoint])

$~SetWorldTransform
$[BOOL ]SetWorldTransform($[HDC hdc], $[CONST XFORM *lpXform])

$~StretchBlt
$[BOOL ]StretchBlt($[HDC hdcDest], $[int nXOriginDest], $[int nYOriginDest], $[int nWidthDest], $[int nHeightDest], $[HDC hdcSrc], $[int nXOriginSrc], $[int nYOriginSrc], $[int nWidthSrc], $[int nHeightSrc], $[DWORD dwRop])

$~STROBJ_bEnum
$[BOOL ]STROBJ_bEnum($[IN STROBJ *pstro], $[OUT ULONG *pc], $[OUT PGLYPHPOS *ppgpos])

$~STROBJ_bEnumPositionsOnly
$[BOOL ]STROBJ_bEnumPositionsOnly($[IN STROBJ *pstro], $[OUT ULONG *pc], $[OUT PGLYPHOS **ppgpos])

$~STROBJ_bGetAdvanceWidths
$[BOOL ]STROBJ_bGetAdvanceWidths($[IN STROBJ *pso], $[IN ULONG iFirst], $[IN ULONG c], $[OUT POINTQF *pptqD])

$~StrokeAndFillPath
$[BOOL ]StrokeAndFillPath($[HDC hdc])

$~StrokePath
$[BOOL ]StrokePath($[HDC hdc])

$~SwapBuffers
$[BOOL ]SwapBuffers($[HDC hdc])

$~TextOutA
$[BOOL ]TextOutA($[HDC hdc], $[int nXStart], $[int nYStart], $[LPCSTR lpString], $[int cbString])

$~TextOutW
$[BOOL ]TextOutW($[HDC hdc], $[int nXStart], $[int nYStart], $[LPCWSTR lpString], $[int cbString])

$~TranslateCharsetInfo
$[BOOL ]TranslateCharsetInfo($[DWORD* pSrc], $[LPCHARSETINFO lpCs], $[DWORD dwFlags])

$~UnrealizeObject
$[BOOL ]UnrealizeObject($[HGDIOBJ hgdiobj])

$~UpdateColors
$[BOOL ]UpdateColors($[HDC hdc])

$~UpdateICMRegKeyA
$[BOOL ]UpdateICMRegKeyA($[DWORD dwReserved], $[LPSTR lpszCMID], $[LPSTR lpszFileName], $[UINT nCommand])

$~UpdateICMRegKeyW
$[BOOL ]UpdateICMRegKeyW($[DWORD dwReserved], $[LPWSTR lpszCMID], $[LPWSTR lpszFileName], $[UINT nCommand])

$~WidenPath
$[BOOL ]WidenPath($[HDC hdc])

$~XFORMOBJ_bApplyXform
$[BOOL ]XFORMOBJ_bApplyXform($[IN XFORMOBJ *pxo], $[IN ULONG iMode], $[IN ULONG cPoints], $[IN PVOID pvIn], $[OUT PVOID pvOut])

$~EngCreateClip
$[CLIPOBJ* ]EngCreateClip($[VOID])

$~GetBkColor
$[COLORREF ]GetBkColor($[HDC hdc])

$~GetDCBrushColor
$[COLORREF ]GetDCBrushColor($[HDC hdc])

$~GetDCPenColor
$[COLORREF ]GetDCPenColor($[HDC hdc])

$~GetNearestColor
$[COLORREF ]GetNearestColor($[HDC hdc], $[COLORREF crColor])

$~GetPixel
$[COLORREF ]GetPixel($[HDC hdc], $[int nXPos], $[int nYPos])

$~GetTextColor
$[COLORREF ]GetTextColor($[HDC hdc])

$~SetBkColor
$[COLORREF ]SetBkColor($[HDC hdc], $[COLORREF crColor])

$~SetDCBrushColor
$[COLORREF ]SetDCBrushColor($[HDC hdc], $[COLORREF crColor])

$~SetDCPenColor
$[COLORREF ]SetDCPenColor($[HDC hdc], $[COLORREF crColor])

$~SetPixel
$[COLORREF ]SetPixel($[HDC hdc], $[int X], $[int Y], $[COLORREF crColor])

$~SetTextColor
$[COLORREF ]SetTextColor($[HDC hdc], $[COLORREF crColor])

$~GdiGetBatchLimit
$[DWORD ]GdiGetBatchLimit($[])

$~GdiGetPageCount
$[DWORD ]GdiGetPageCount($[HANDLE SpoolFileHandle])

$~GdiSetBatchLimit
$[DWORD ]GdiSetBatchLimit($[DWORD dwLimit])

$~GetCharacterPlacementA
$[DWORD ]GetCharacterPlacementA($[HDC hdc], $[LPCSTR lpString], $[int nCount], $[int nMaxExtent], $[LPGCP_RESULTS lpResults], $[DWORD dwFlags])

$~GetCharacterPlacementW
$[DWORD ]GetCharacterPlacementW($[HDC hdc], $[LPCWSTR lpString], $[int nCount], $[int nMaxExtent], $[LPGCP_RESULTS lpResults], $[DWORD dwFlags])

$~GetFontData
$[DWORD ]GetFontData($[HDC hdc], $[DWORD dwTable], $[DWORD dwOffset], $[LPVOID lpvBuffer], $[DWORD cbData])

$~GetFontLanguageInfo
$[DWORD ]GetFontLanguageInfo($[HDC hdc])

$~GetFontUnicodeRanges
$[DWORD ]GetFontUnicodeRanges($[HDC hdc], $[LPGLYPHSET lpgs])

$~GetGlyphIndicesA
$[DWORD ]GetGlyphIndicesA($[HDC hdc], $[LPCSTR lpstr], $[int c], $[LPWORD pgi], $[DWORD fl])

$~GetGlyphIndicesW
$[DWORD ]GetGlyphIndicesW($[HDC hdc], $[LPCWSTR lpstr], $[int c], $[LPWORD pgi], $[DWORD fl])

$~GetGlyphOutline
$[DWORD ]GetGlyphOutline($[HDC hdc], $[UINT uChar], $[UINT uFormat], $[LPGLYPHMETRICS lpgm], $[DWORD cbBuffer], $[LPVOID lpvBuffer], $[CONST MAT2 *lpmat2])

$~GetGlyphOutlineA
$[DWORD ]GetGlyphOutlineA($[HDC hdc], $[UINT uChar], $[UINT uFormat], $[LPGLYPHMETRICS lpgm], $[DWORD cbBuffer], $[LPVOID lpvBuffer], $[CONST MAT2 *lpmat2])

$~GetGlyphOutlineW
$[DWORD ]GetGlyphOutlineW($[HDC hdc], $[UINT uChar], $[UINT uFormat], $[LPGLYPHMETRICS lpgm], $[DWORD cbBuffer], $[LPVOID lpvBuffer], $[CONST MAT2 *lpmat2])

$~GetKerningPairs
$[DWORD ]GetKerningPairs($[HDC hdc], $[DWORD nNumPairs], $[LPKERNINGPAIR lpkrnpair])

$~GetKerningPairsA
$[DWORD ]GetKerningPairsA($[HDC hdc], $[DWORD nNumPairs], $[LPKERNINGPAIR lpkrnpair])

$~GetKerningPairsW
$[DWORD ]GetKerningPairsW($[HDC hdc], $[DWORD nNumPairs], $[LPKERNINGPAIR lpkrnpair])

$~GetLayout
$[DWORD ]GetLayout($[HDC hdc])

$~GetObjectType
$[DWORD ]GetObjectType($[HGDIOBJ h])

$~GetRegionData
$[DWORD ]GetRegionData($[HRGN hRgn], $[DWORD dwCount], $[LPRGNDATA lpRgnData])

$~SetLayout
$[DWORD ]SetLayout($[HDC hdc], $[DWORD dwLayout])

$~SetMapperFlags
$[DWORD ]SetMapperFlags($[HDC hdc], $[DWORD dwFlag])

$~STROBJ_dwGetCodePage
$[DWORD ]STROBJ_dwGetCodePage($[IN STROBJ *pstro])

$~EngComputeGlyphSet
$[FD_GLYPHSET* ]EngComputeGlyphSet($[IN INT nCodePage], $[IN INT nFirstChar], $[IN INT cChars])

$~FONTOBJ_pfdg
$[FD_GLYPHSET* ]FONTOBJ_pfdg($[IN FONTOBJ *pfo])

$~AddFontMemResourceEx
$[HANDLE ]AddFontMemResourceEx($[PVOID pbFont], $[DWORD cbFont], $[PVOID pdv], $[DWORD *pcFonts])

$~BRUSHOBJ_hGetColorTransform
$[HANDLE ]BRUSHOBJ_hGetColorTransform($[IN BRUSHOBJ *pbo])

$~GdiGetPageHandle
$[HANDLE ]GdiGetPageHandle($[HANDLE SpoolFileHandle], $[DWORD Page], $[LPDWORD pdwPageType])

$~GdiGetSpoolFileHandle
$[HANDLE ]GdiGetSpoolFileHandle($[LPWSTR pwszPrinterName], $[LPDEVMODEW pDevmode], $[LPWSTR pwszDocName])

$~XLATEOBJ_hGetColorTransform
$[HANDLE ]XLATEOBJ_hGetColorTransform($[IN XLATEOBJ *pxlo])

$~CreateBitmap
$[HBITMAP ]CreateBitmap($[int nWidth], $[int nHeight], $[UINT cPlanes], $[UINT cBitsPerPel], $[CONST VOID *lpvBits])

$~CreateBitmapIndirect
$[HBITMAP ]CreateBitmapIndirect($[CONST BITMAP *lpbm])

$~CreateCompatibleBitmap
$[HBITMAP ]CreateCompatibleBitmap($[HDC hdc], $[int nWidth], $[int nHeight])

$~CreateDIBitmap
$[HBITMAP ]CreateDIBitmap($[HDC hdc], $[CONST BITMAPINFOHEADER *lpbmih], $[DWORD fdwInit], $[CONST VOID *lpbInit], $[CONST BITMAPINFO *lpbmi], $[UINT fuUsage])

$~CreateDIBSection
$[HBITMAP ]CreateDIBSection($[HDC hdc], $[CONST BITMAPINFO *pbmi], $[UINT iUsage], $[VOID **ppvBits], $[HANDLE hSection], $[DWORD dwOffset])

$~CreateDiscardableBitmap
$[HBITMAP ]CreateDiscardableBitmap($[HDC hdc], $[int nWidth], $[int nHeight])

$~EngCreateBitmap
$[HBITMAP ]EngCreateBitmap($[IN SIZEL sizl], $[IN LONG lWidth], $[IN ULONG iFormat], $[IN FLONG fl], $[IN PVOID pvBits])

$~EngCreateDeviceBitmap
$[HBITMAP ]EngCreateDeviceBitmap($[IN DHSURF dhsurf], $[IN SIZEL sizl], $[IN ULONG iFormatCompat])

$~CreateBrushIndirect
$[HBRUSH ]CreateBrushIndirect($[CONST LOGBRUSH *lplb])

$~CreateDIBPatternBrush
$[HBRUSH ]CreateDIBPatternBrush($[HGLOBAL hglbDIBPacked], $[UINT fuColorSpec])

$~CreateDIBPatternBrushPt
$[HBRUSH ]CreateDIBPatternBrushPt($[CONST VOID *lpPackedDIB], $[UINT iUsage])

$~CreateHatchBrush
$[HBRUSH ]CreateHatchBrush($[int fnStyle], $[COLORREF clrref])

$~CreatePatternBrush
$[HBRUSH ]CreatePatternBrush($[HBITMAP hbmp])

$~CreateSolidBrush
$[HBRUSH ]CreateSolidBrush($[COLORREF crColor])

$~CreateColorSpaceA
$[HCOLORSPACE ]CreateColorSpaceA($[LPLOGCOLORSPACE lpLogColorSpace])

$~CreateColorSpaceW
$[HCOLORSPACE ]CreateColorSpaceW($[LPLOGCOLORSPACE lpLogColorSpace])

$~GetColorSpace
$[HCOLORSPACE ]GetColorSpace($[HDC hDC])

$~SetColorSpace
$[HCOLORSPACE ]SetColorSpace($[HCD hDC], $[HCOLORSPACE hColorSpace])

$~CreateCompatibleDC
$[HDC ]CreateCompatibleDC($[HDC hdc])

$~CreateEnhMetaFileA
$[HDC ]CreateEnhMetaFileA($[HDC hdcRef], $[LPCSTR lpFilename], $[CONST RECT* lpRect], $[LPCSTR lpDescription])

$~CreateEnhMetaFileW
$[HDC ]CreateEnhMetaFileW($[HDC hdcRef], $[LPCWSTR lpFilename], $[CONST RECT* lpRect], $[LPCWSTR lpDescription])

$~CreateMetaFileA
$[HDC ]CreateMetaFileA($[LPCSTR lpszFile])

$~CreateMetaFileW
$[HDC ]CreateMetaFileW($[LPCWSTR lpszFile])

$~GdiGetDC
$[HDC ]GdiGetDC($[HANDLE SpoolFileHandle])

$~CloseEnhMetaFile
$[HENHMETAFILE ]CloseEnhMetaFile($[HDC hdc])

$~CopyEnhMetaFileA
$[HENHMETAFILE ]CopyEnhMetaFileA($[HENHMETAFILE hemfSrc], $[LPCSTR lpszFile])

$~CopyEnhMetaFileW
$[HENHMETAFILE ]CopyEnhMetaFileW($[HENHMETAFILE hemfSrc], $[LPCWSTR lpszFile])

$~GetEnhMetaFileA
$[HENHMETAFILE ]GetEnhMetaFileA($[LPCSTR lpszMetaFile])

$~GetEnhMetaFileW
$[HENHMETAFILE ]GetEnhMetaFileW($[LPCWSTR lpszMetaFile])

$~SetEnhMetaFileBits
$[HENHMETAFILE ]SetEnhMetaFileBits($[UINT cbBuffer], $[CONST BYTE *lpData])

$~SetWinMetaFileBits
$[HENHMETAFILE ]SetWinMetaFileBits($[UINT cbBuffer], $[CONST BYTE *lpbBuffer], $[HDC hdcRef], $[CONST METAFILEPICT *lpmfp])

$~CreateFontA
$[HFONT ]CreateFontA($[int nHeight], $[int nWidth], $[int nEscapement], $[int nOrientation], $[int fnWeight], $[DWORD fdwItalic], $[DWORD fdwUnderline], $[DWORD fdwStrikeOut], $[DWORD fdwCharSet], $[DWORD fdwOutputPrecision], $[DWORD fdwClipPrecision], $[DWORD fdwQuality], $[DWORD fdwPitchAndFamily], $[LPCSTR lpszFace])

$~CreateFontIndirectA
$[HFONT ]CreateFontIndirectA($[CONST LOGFONTA* lplf])

$~CreateFontIndirectExA
$[HFONT ]CreateFontIndirectExA($[CONST ENUMLOGFONTEXDV *penumlfex])

$~CreateFontIndirectExW
$[HFONT ]CreateFontIndirectExW($[CONST ENUMLOGFONTEXDV *penumlfex])

$~CreateFontIndirectW
$[HFONT ]CreateFontIndirectW($[CONST LOGFONTW* lplf])

$~CreateFontW
$[HFONT ]CreateFontW($[int nHeight], $[int nWidth], $[int nEscapement], $[int nOrientation], $[int fnWeight], $[DWORD fdwItalic], $[DWORD fdwUnderline], $[DWORD fdwStrikeOut], $[DWORD fdwCharSet], $[DWORD fdwOutputPrecision], $[DWORD fdwClipPrecision], $[DWORD fdwQuality], $[DWORD fdwPitchAndFamily], $[LPCWSTR lpszFace])

$~GetCurrentObject
$[HGDIOBJ ]GetCurrentObject($[HDC hdc], $[UINT uObjectType])

$~GetStockObject
$[HGDIOBJ ]GetStockObject($[int fnObject])

$~SelectObject
$[HGDIOBJ ]SelectObject($[HDC hdc], $[HGDIOBJ hgdiobj])

$~CloseMetaFile
$[HMETAFILE ]CloseMetaFile($[HDC hdc])

$~CopyMetaFileA
$[HMETAFILE ]CopyMetaFileA($[HMETAFILE hmfSrc], $[LPCSTR lpszFile])

$~CopyMetaFileW
$[HMETAFILE ]CopyMetaFileW($[HMETAFILE hmfSrc], $[LPCWSTR lpszFile])

$~SetMetaFileBitsEx
$[HMETAFILE ]SetMetaFileBitsEx($[UINT nSize], $[CONST BYTE *lpData])

$~CreateHalftonePalette
$[HPALETTE ]CreateHalftonePalette($[HDC hdc])

$~CreatePalette
$[HPALETTE ]CreatePalette($[CONST LOGPALETTE *lplgpl])

$~EngCreatePalette
$[HPALETTE ]EngCreatePalette($[IN ULONG iMode], $[IN ULONG cColors], $[IN ULONG *pulColors], $[IN FLONG flRed], $[IN FLONG flGreen], $[IN FLONG flBlue])

$~SelectPalette
$[HPALETTE ]SelectPalette($[HDC hdc], $[HPALETTE hpal], $[BOOL bForceBackground])

$~CreatePen
$[HPEN ]CreatePen($[int fnPenStyle], $[int nWidth], $[COLORREF crColor])

$~CreatePenIndirect
$[HPEN ]CreatePenIndirect($[CONST LOGPEN *lplgpn])

$~ExtCreatePen
$[HPEN ]ExtCreatePen($[DWORD dwPenStyle], $[DWORD dwWidth], $[CONST LOGBRUSH *lplb], $[DWORD dwStyleCount], $[CONST DWORD *lpStyle])

$~EnumObjects
$[HRESULT ]EnumObjects($[HWND hwndOwner], $[SHCONTF grfFlags], $[IEnumIDList **ppenumIDList])

$~CreateEllipticRgn
$[HRGN ]CreateEllipticRgn($[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect])

$~CreateEllipticRgnIndirect
$[HRGN ]CreateEllipticRgnIndirect($[CONST RECT *lprc])

$~CreatePolygonRgn
$[HRGN ]CreatePolygonRgn($[CONST POINT *lppt], $[int cPoints], $[int fnPolyFillMode])

$~CreatePolyPolygonRgn
$[HRGN ]CreatePolyPolygonRgn($[CONST POINT *lppt], $[CONST INT *lpPolyCounts], $[int nCount], $[int fnPolyFillMode])

$~CreateRectRgn
$[HRGN ]CreateRectRgn($[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect])

$~CreateRectRgnIndirect
$[HRGN ]CreateRectRgnIndirect($[CONST RECT *lprc])

$~CreateRoundRectRgn
$[HRGN ]CreateRoundRectRgn($[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect], $[int nWidthEllipse], $[int nHeightEllipse])

$~ExtCreateRegion
$[HRGN ]ExtCreateRegion($[CONST XFORM *lpXform], $[DWORD nCount], $[CONST RGNDATA *lpRgnData])

$~PathToRegion
$[HRGN ]PathToRegion($[HDC hdc])

$~EngCreateSemaphore
$[HSEMAPHORE ]EngCreateSemaphore($[VOID])

$~EngCreateDeviceSurface
$[HSURF ]EngCreateDeviceSurface($[DHSURF dhsurf], $[SIZEL sizl], $[ULONG iFormatCompat])

$~FONTOBJ_pifi
$[IFIMETRICS* ]FONTOBJ_pifi($[IN FONTOBJ *pfo])

$~AbortDoc
$[int ]AbortDoc($[HDC hdc])

$~AddFontResourceA
$[int ]AddFontResourceA($[LPCSTR lpszFilename])

$~AddFontResourceExA
$[int ]AddFontResourceExA($[LPCSTR lpszFilename], $[DWORD fl], $[PVOID pdv])

$~AddFontResourceExW
$[int ]AddFontResourceExW($[LPCWSTR lpszFilename], $[DWORD fl], $[PVOID pdv])

$~AddFontResourceW
$[int ]AddFontResourceW($[LPCWSTR lpszFilename])

$~ChoosePixelFormat
$[int ]ChoosePixelFormat($[HDC hdc], $[CONST PIXELFORMATDESCRIPTOR * ppfd])

$~CombineRgn
$[int ]CombineRgn($[HRGN hrgnDest], $[HRGN hrgnSrc1], $[HRGN hrgnSrc2], $[int fnCombineMode])

$~DescribePixelFormat
$[int ]DescribePixelFormat($[HDC hdc], $[int iPixelFormat], $[UINT nBytes], $[LPPIXELFORMATDESCRIPTOR ppfd])

$~DrawEscape
$[int ]DrawEscape($[HDC hdc], $[int nEscape], $[int cbInput], $[LPCSTR lpszInData])

$~EndDoc
$[int ]EndDoc($[HDC hdc])

$~EndPage
$[int ]EndPage($[HDC hdc])

$~EngMultiByteToWideChar
$[INT ]EngMultiByteToWideChar($[IN UINT CodePage], $[OUT LPWSTR WideCharString], $[IN INT BytesInWideCharString], $[IN LPSTR MultiByteString], $[IN INT BytesInMultiByteString])

$~EngWideCharToMultiByte
$[INT ]EngWideCharToMultiByte($[IN UINT CodePage], $[IN LPWSTR WideCharString], $[IN INT BytesInWideCharString], $[OUT LPSTR MultiByteString], $[IN INT BytesInMultiByteString])

$~EnumFontFamiliesA
$[int ]EnumFontFamiliesA($[HDC hdc], $[LPCSTR lpszFamily], $[FONTENUMPROC lpEnumFontFamProc], $[LPARAM lParam])

$~EnumFontFamiliesExA
$[int ]EnumFontFamiliesExA($[HDC hdc], $[LPLOGFONTA lpLogfont], $[FONTENUMPROC lpEnumFontFamExProc], $[LPARAM lParam], $[DWORD dwFlags])

$~EnumFontFamiliesExW
$[int ]EnumFontFamiliesExW($[HDC hdc], $[LPLOGFONTW lpLogfont], $[FONTENUMPROC lpEnumFontFamExProc], $[LPARAM lParam], $[DWORD dwFlags])

$~EnumFontFamiliesW
$[int ]EnumFontFamiliesW($[HDC hdc], $[LPCWSTR lpszFamily], $[FONTENUMPROC lpEnumFontFamProc], $[LPARAM lParam])

$~EnumFontsA
$[int ]EnumFontsA($[HDC hdc], $[LPCSTR lpFaceName], $[FONTENUMPROC lpFontFunc], $[LPARAM lParam])

$~EnumFontsW
$[int ]EnumFontsW($[HDC hdc], $[LPCWSTR lpFaceName], $[FONTENUMPROC lpFontFunc], $[LPARAM lParam])

$~EnumICMProfilesA
$[int ]EnumICMProfilesA($[HDC hDC], $[ICMENUMPROC lpEnumICMProfilesFunc], $[LPARAM lParam])

$~EnumICMProfilesW
$[int ]EnumICMProfilesW($[HDC hDC], $[ICMENUMPROC lpEnumICMProfilesFunc], $[LPARAM lParam])

$~ExcludeClipRect
$[int ]ExcludeClipRect($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect])

$~ExtEscape
$[int ]ExtEscape($[HDC hdc], $[int nEscape], $[int cbInput], $[LPCSTR lpszInData], $[int cbOutput], $[LPSTR lpszOutData])

$~ExtSelectClipRgn
$[int ]ExtSelectClipRgn($[HDC hdc], $[HRGN hrgn], $[int fnMode])

$~GetArcDirection
$[int ]GetArcDirection($[HDC hdc])

$~GetBkMode
$[int ]GetBkMode($[HDC hdc])

$~GetClipBox
$[int ]GetClipBox($[HDC hdc], $[LPRECT lprc])

$~GetClipRgn
$[int ]GetClipRgn($[HDC hdc], $[HRGN hrgn])

$~GetDeviceCaps
$[int ]GetDeviceCaps($[HDC hdc], $[int nIndex])

$~GetDIBits
$[int ]GetDIBits($[HDC hdc], $[HBITMAP hbmp], $[UINT uStartScan], $[UINT cScanLines], $[LPVOID lpvBits], $[LPBITMAPINFO lpbi], $[UINT uUsage])

$~GetGraphicsMode
$[int ]GetGraphicsMode($[HDC hdc])

$~GetMapMode
$[int ]GetMapMode($[HDC hdc])

$~GetMetaRgn
$[int ]GetMetaRgn($[HDC hdc], $[HRGN hrgn])

$~GetPixelFormat
$[int ]GetPixelFormat($[HDC hdc])

$~GetPolyFillMode
$[int ]GetPolyFillMode($[HDC hdc])

$~GetRandomRgn
$[int ]GetRandomRgn($[HDC hdc], $[HRGN hrgn], $[INT iNum])

$~GetRgnBox
$[int ]GetRgnBox($[HRGN hrgn], $[LPRECT lprc])

$~GetROP2
$[int ]GetROP2($[HDC hdc])

$~GetStretchBltMode
$[int ]GetStretchBltMode($[HDC hdc])

$~GetTextCharacterExtra
$[int ]GetTextCharacterExtra($[HDC hdc])

$~GetTextCharset
$[int ]GetTextCharset($[HDC hdc])

$~GetTextCharsetInfo
$[int ]GetTextCharsetInfo($[HDC hdc], $[LPFONTSIGNATURE lpSig], $[DWORD dwFlags])

$~GetTextFaceA
$[int ]GetTextFaceA($[HDC hdc], $[int nCount], $[LPSTR lpFaceName])

$~GetTextFaceW
$[int ]GetTextFaceW($[HDC hdc], $[int nCount], $[LPWSTR lpFaceName])

$~IntersectClipRect
$[int ]IntersectClipRect($[HDC hdc], $[int nLeftRect], $[int nTopRect], $[int nRightRect], $[int nBottomRect])

$~OffsetClipRgn
$[int ]OffsetClipRgn($[HDC hdc], $[int nXOffset], $[int nYOffset])

$~OffsetRgn
$[int ]OffsetRgn($[HRGN hrgn], $[int nXOffset], $[int nYOffset])

$~SaveDC
$[int ]SaveDC($[HDC hdc])

$~SelectClipRgn
$[int ]SelectClipRgn($[HDC hdc], $[HRGN hrgn])

$~SetAbortProc
$[int ]SetAbortProc($[HDC hdc], $[ABORTPROC lpAbortProc])

$~SetArcDirection
$[int ]SetArcDirection($[HDC hdc], $[int ArcDirection])

$~SetBkMode
$[int ]SetBkMode($[HDC hdc], $[int iBkMode])

$~SetDIBits
$[int ]SetDIBits($[HDC hdc], $[HBITMAP hbmp], $[UINT uStartScan], $[UINT cScanLines], $[CONST VOID *lpvBits], $[CONST BITMAPINFO *lpbmi], $[UINT fuColorUse])

$~SetDIBitsToDevice
$[int ]SetDIBitsToDevice($[HDC hdc], $[int XDest], $[int YDest], $[DWORD dwWidth], $[DWORD dwHeight], $[int XSrc], $[int YSrc], $[UINT uStartScan], $[UINT cScanLines], $[CONST VOID *lpvBits], $[CONST BITMAPINFO *lpbmi], $[UINT fuColorUse])

$~SetGraphicsMode
$[int ]SetGraphicsMode($[HDC hdc], $[int iMode])

$~SetICMMode
$[int ]SetICMMode($[HDC hDC], $[int iEnableICM])

$~SetMapMode
$[int ]SetMapMode($[HDC hdc], $[int fnMapMode])

$~SetMetaRgn
$[int ]SetMetaRgn($[HDC hdc])

$~SetPolyFillMode
$[int ]SetPolyFillMode($[HDC hdc], $[int iPolyFillMode])

$~SetROP2
$[int ]SetROP2($[HDC hdc], $[int fnDrawMode])

$~SetStretchBltMode
$[int ]SetStretchBltMode($[HDC hdc], $[int iStretchMode])

$~SetTextCharacterExtra
$[int ]SetTextCharacterExtra($[HDC hdc], $[int nCharExtra])

$~StartDocA
$[int ]StartDocA($[HDC hdc], $[CONST DOCINFO* lpdi])

$~StartDocW
$[int ]StartDocW($[HDC hdc], $[CONST DOCINFO* lpdi])

$~StartPage
$[int ]StartPage($[HDC hDC])

$~StretchDIBits
$[int ]StretchDIBits($[HDC hdc], $[int XDest], $[int YDest], $[int nDestWidth], $[int nDestHeight], $[int XSrc], $[int YSrc], $[int nSrcWidth], $[int nSrcHeight], $[CONST VOID *lpBits], $[CONST BITMAPINFO *lpBitsInfo], $[UINT iUsage], $[DWORD dwRop])

$~GetBitmapBits
$[LONG ]GetBitmapBits($[HBITMAP hbmp], $[LONG cbBuffer], $[LPVOID lpvBits])

$~HT_Get8BPPFormatPalette
$[LONG ]HT_Get8BPPFormatPalette($[OUT LPPALETTEENTRY pPaletteEntry], $[IN USHORT RedGamma], $[IN USHORT GreenGamma], $[IN USHORT BlueGamma])

$~HT_Get8BPPMaskPalette
$[LONG ]HT_Get8BPPMaskPalette($[IN OUT LPPALETTEENTRY pPaletteEntry], $[IN BOOL Use8BPPMaskPal], $[IN BYTE CMYMask], $[IN USHORT RedGamma], $[IN USHORT GreenGamma], $[IN USHORT BlueGamma])

$~SetBitmapBits
$[LONG ]SetBitmapBits($[HBITMAP hbmp], $[DWORD cBytes], $[CONST VOID *lpBits])

$~EngGetDriverName
$[LPWSTR ]EngGetDriverName($[IN HDEV hdev])

$~EngGetPrinterDataFileName
$[LPWSTR ]EngGetPrinterDataFileName($[IN HDEV hdev])

$~CLIPOBJ_ppoGetPath
$[PATHOBJ* ]CLIPOBJ_ppoGetPath($[IN CLIPOBJ *pco])

$~FONTOBJ_pQueryGlyphAttrs
$[PFD_GLYPHATTR APIENTRY ]FONTOBJ_pQueryGlyphAttrs($[IN FONTOBJ *pfo], $[IN ULONG iMode])

$~BRUSHOBJ_pvAllocRbrush
$[PVOID ]BRUSHOBJ_pvAllocRbrush($[BRUSHOBJ* pbo], $[ULONG cj])

$~BRUSHOBJ_pvGetRbrush
$[PVOID ]BRUSHOBJ_pvGetRbrush($[BRUSHOBJ* pbo], )

$~EngFindResource
$[PVOID ]EngFindResource($[IN HANDLE h], $[IN int iName], $[IN int iType], $[OUT PULONG pulSize])

$~FONTOBJ_pvTrueTypeFontFile
$[PVOID ]FONTOBJ_pvTrueTypeFontFile($[IN FONTOBJ *pfo], $[OUT ULONG *pcjFile])

$~GetMiterLimit
$[REAL ]GetMiterLimit($[])

$~FillPath
$[Status ]FillPath($[const Brush *brush], $[const GraphicsPath *path])

$~GetTransform
$[Status ]GetTransform($[Matrix *matrix])

$~EngLockSurface
$[SURFOBJ* ]EngLockSurface($[IN HSURF hsurf])

$~GetBoundsRect
$[UINT ]GetBoundsRect($[HDC hdc], $[LPRECT lprcBounds], $[UINT flags])

$~GetDIBColorTable
$[UINT ]GetDIBColorTable($[HDC hdc], $[UINT uStartIndex], $[UINT cEntries], $[RGBQUAD *pColors])

$~GetEnhMetaFileBits
$[UINT ]GetEnhMetaFileBits($[HENHMETAFILE hemf], $[UINT cbBuffer], $[LPBYTE lpbBuffer])

$~GetEnhMetaFileDescriptionA
$[UINT ]GetEnhMetaFileDescriptionA($[HENHMETAFILE hemf], $[UINT cchBuffer], $[LPSTR lpszDescription])

$~GetEnhMetaFileDescriptionW
$[UINT ]GetEnhMetaFileDescriptionW($[HENHMETAFILE hemf], $[UINT cchBuffer], $[LPWSTR lpszDescription])

$~GetEnhMetaFileHeader
$[UINT ]GetEnhMetaFileHeader($[HENHMETAFILE hemf], $[UINT cbBuffer], $[LPENHMETAHEADER lpemh])

$~GetEnhMetaFilePaletteEntries
$[UINT ]GetEnhMetaFilePaletteEntries($[HENHMETAFILE hemf], $[UINT cEntries], $[LPPALETTEENTRY lppe])

$~GetMetaFileBitsEx
$[UINT ]GetMetaFileBitsEx($[HMETAFILE hmf], $[UINT nSize], $[LPVOID lpvData])

$~GetNearestPaletteIndex
$[UINT ]GetNearestPaletteIndex($[HPALETTE hpal], $[COLORREF crColor])

$~GetOutlineTextMetricsA
$[UINT ]GetOutlineTextMetricsA($[HDC hdc], $[UINT cbData], $[LPOUTLINETEXTMETRIC lpOTM])

$~GetOutlineTextMetricsW
$[UINT ]GetOutlineTextMetricsW($[HDC hdc], $[UINT cbData], $[LPOUTLINETEXTMETRIC lpOTM])

$~GetPaletteEntries
$[UINT ]GetPaletteEntries($[HPALETTE hpal], $[UINT iStartIndex], $[UINT nEntries], $[LPPALETTEENTRY lppe])

$~GetSystemPaletteEntries
$[UINT ]GetSystemPaletteEntries($[HDC hdc], $[UINT iStartIndex], $[UINT nEntries], $[LPPALETTEENTRY lppe])

$~GetSystemPaletteUse
$[UINT ]GetSystemPaletteUse($[HDC hdc])

$~GetTextAlign
$[UINT ]GetTextAlign($[HDC hdc])

$~GetWinMetaFileBits
$[UINT ]GetWinMetaFileBits($[HENHMETAFILE hemf], $[UINT cbBuffer], $[LPBYTE lpbBuffer], $[INT fnMapMode], $[HDC hdcRef])

$~RealizePalette
$[UINT ]RealizePalette($[HDC hdc])

$~SetBoundsRect
$[UINT ]SetBoundsRect($[HDC hdc], $[CONST RECT *lprcBounds], $[UINT flags])

$~SetDIBColorTable
$[UINT ]SetDIBColorTable($[HDC hdc], $[UINT uStartIndex], $[UINT cEntries], $[CONST RGBQUAD *pColors])

$~SetPaletteEntries
$[UINT ]SetPaletteEntries($[HPALETTE hpal], $[UINT iStart], $[UINT cEntries], $[CONST PALETTEENTRY *lppe])

$~SetSystemPaletteUse
$[UINT ]SetSystemPaletteUse($[HDC hdc], $[UINT uUsage])

$~SetTextAlign
$[UINT ]SetTextAlign($[HDC hdc], $[UINT fMode])

$~XLATEOBJ_piVector
$[ULONG* ]XLATEOBJ_piVector($[IN XLATEOBJ *pxlo])

$~BRUSHOBJ_ulGetBrushColor
$[ULONG ]BRUSHOBJ_ulGetBrushColor($[IN BRUSHOBJ *pbo])

$~CLIPOBJ_cEnumStart
$[ULONG ]CLIPOBJ_cEnumStart($[IN CLIPOBJ *pco], $[IN BOOL bAll], $[IN ULONG iType], $[IN ULONG iDirection], $[IN ULONG cLimit])

$~FONTOBJ_cGetAllGlyphHandles
$[ULONG ]FONTOBJ_cGetAllGlyphHandles($[IN FONTOBJ *pfo], $[OUT HGLYPH *phg])

$~FONTOBJ_cGetGlyphs
$[ULONG ]FONTOBJ_cGetGlyphs($[IN FONTOBJ *pfo], $[IN ULONG iMode], $[IN ULONG cGlyph], $[IN HGLYPH *phg], $[OUT PVOID *ppvGlyph])

$~XFORMOBJ_iGetXform
$[ULONG ]XFORMOBJ_iGetXform($[IN XFORMOBJ *pxo], $[OUT XFORML *pxform])

$~XLATEOBJ_cGetPalette
$[ULONG ]XLATEOBJ_cGetPalette($[IN XLATEOBJ *pxlo], $[IN ULONG iPal], $[IN ULONG cPal], $[OUT ULONG *pPal])

$~XLATEOBJ_iXlate
$[ULONG ]XLATEOBJ_iXlate($[IN XLATEOBJ *pxlo], $[IN ULONG iColor])

$~GetEnhMetaFilePixelFormat
$[UNIT ]GetEnhMetaFilePixelFormat($[HENHMETAFILE hemf], $[DWORD cbBuffer], $[CONST PIXELFORMATDESCRIPTOR * ppfd])

$~EngAcquireSemaphore
$[VOID ]EngAcquireSemaphore($[IN HSEMAPHORE hsem])

$~EngDeleteClip
$[VOID ]EngDeleteClip($[IN CLIPOBJ *pco])

$~EngDeletePath
$[VOID ]EngDeletePath($[IN PATHOBJ *ppo])

$~EngDeleteSemaphore
$[VOID ]EngDeleteSemaphore($[IN OUT HSEMAPHORE hsem])

$~EngFreeModule
$[VOID ]EngFreeModule($[IN HANDLE h])

$~EngGetCurrentCodePage
$[VOID ]EngGetCurrentCodePage($[OUT PUSHORT OemCodePage], $[OUT PUSHORT AnsiCodePage])

$~EngMultiByteToUnicodeN
$[VOID ]EngMultiByteToUnicodeN($[OUT LPWSTR UnicodeString], $[IN ULONG MaxBytesInUnicodeString], $[OUT PULONG BytesInUnicodeString], $[IN PCHAR MultiByteString], $[IN ULONG BytesInMultiByteString])

$~EngQueryLocalTime
$[VOID ]EngQueryLocalTime($[OUT PENG_TIME_FIELDS ptf])

$~EngReleaseSemaphore
$[VOID ]EngReleaseSemaphore($[IN HSEMAPHORE hsem])

$~EngUnicodeToMultiByteN
$[VOID ]EngUnicodeToMultiByteN($[OUT PCHAR MultiByteString], $[IN ULONG MaxBytesInMultiByteString], $[OUT PULONG BytesInMultiByteString], $[IN PWSTR UnicodeString], $[IN ULONG BytesInUnicodeString])

$~EngUnlockSurface
$[VOID ]EngUnlockSurface($[IN SURFOBJ *pso])

$~FONTOBJ_vGetInfo
$[VOID ]FONTOBJ_vGetInfo($[IN FONTOBJ *pfo], $[IN ULONG cjSize], $[OUT FONTINFO *pfi])

$~PATHOBJ_vEnumStart
$[VOID ]PATHOBJ_vEnumStart($[IN PATHOBJ *ppo])

$~PATHOBJ_vEnumStartClipLines
$[VOID ]PATHOBJ_vEnumStartClipLines($[IN PATHOBJ *ppo], $[IN CLIPOBJ *pco], $[IN SURFOBJ *pso], $[IN LINEATTRS *pla])

$~PATHOBJ_vGetBounds
$[VOID ]PATHOBJ_vGetBounds($[IN PATHOBJ *ppo], $[OUT PRECTFX prectfx])

$~STROBJ_vEnumStart
$[VOID ]STROBJ_vEnumStart($[IN STROBJ *pstro])

$~FONTOBJ_pxoGetXform
$[XFORMOBJ ]FONTOBJ_pxoGetXform($[IN FONTOBJ *pfo])

$; kernel32.dll
$; ------------
$~AddAtomA
$[ATOM ]AddAtomA($[LPCSTR lpString])

$~AddAtomW
$[ATOM ]AddAtomW($[LPCWSTR lpString])

$~DeleteAtom
$[ATOM ]DeleteAtom($[ATOM nAtom])

$~FindAtomA
$[ATOM ]FindAtomA($[LPCSTR lpString])

$~FindAtomW
$[ATOM ]FindAtomW($[LPCWSTR lpString])

$~GlobalAddAtomA
$[ATOM ]GlobalAddAtomA($[LPCSTR lpString])

$~GlobalAddAtomW
$[ATOM ]GlobalAddAtomW($[LPCWSTR lpString])

$~GlobalDeleteAtom
$[ATOM ]GlobalDeleteAtom($[ATOM nAtom])

$~GlobalFindAtomA
$[ATOM ]GlobalFindAtomA($[LPCSTR lpString])

$~GlobalFindAtomW
$[ATOM ]GlobalFindAtomW($[LPCWSTR lpString])

$~ActivateActCtx
$[BOOL ]ActivateActCtx($[HACTCTX hActCtx], $[ULONG_PTR* lpCookie])

$~AddConsoleAliasA
$[BOOL ]AddConsoleAliasA($[LPCSTR Source], $[LPCSTR Target], $[LPCSTR ExeName])

$~AddConsoleAliasW
$[BOOL ]AddConsoleAliasW($[LPCWSTR Source], $[LPCWSTR Target], $[LPCWSTR ExeName])

$~AllocateUserPhysicalPages
$[BOOL ]AllocateUserPhysicalPages($[HANDLE hProcess], $[PULONG_PTR NumberOfPages], $[PULONG_PTR UserPfnArray])

$~AllocConsole
$[BOOL ]AllocConsole($[])

$~AreFileApisANSI
$[BOOL ]AreFileApisANSI($[])

$~AssignProcessToJobObject
$[BOOL ]AssignProcessToJobObject($[HANDLE hJob], $[HANDLE hProcess])

$~AttachConsole
$[BOOL ]AttachConsole($[DWORD dwProcessId])

$~BackupRead
$[BOOL ]BackupRead($[HANDLE hFile], $[LPBYTE lpBuffer], $[DWORD nNumberOfBytesToRead], $[LPDWORD lpNumberOfBytesRead], $[BOOL bAbort], $[BOOL bProcessSecurity], $[LPVOID* lpContext])

$~BackupSeek
$[BOOL ]BackupSeek($[HANDLE hFile], $[DWORD dwLowBytesToSeek], $[DWORD dwHighBytesToSeek], $[LPDWORD lpdwLowByteSeeked], $[LPDWORD lpdwHighByteSeeked], $[LPVOID* lpContext])

$~BackupWrite
$[BOOL ]BackupWrite($[HANDLE hFile], $[LPBYTE lpBuffer], $[DWORD nNumberOfBytesToWrite], $[LPDWORD lpNumberOfBytesWritten], $[BOOL bAbort], $[BOOL bProcessSecurity], $[LPVOID* lpContext])

$~Beep
$[BOOL ]Beep($[DWORD dwFreq], $[DWORD dwDuration])

$~BindIoCompletionCallback
$[BOOL ]BindIoCompletionCallback($[HANDLE FileHandle], $[LPOVERLAPPED_COMPLETION_ROUTINE Function], $[ULONG Flags])

$~BuildCommDCBAndTimeoutsA
$[BOOL ]BuildCommDCBAndTimeoutsA($[LPCSTR lpDef], $[LPDCB lpDCB], $[LPCOMMTIMEOUTS lpCommTimeouts])

$~BuildCommDCBAndTimeoutsW
$[BOOL ]BuildCommDCBAndTimeoutsW($[LPCWSTR lpDef], $[LPDCB lpDCB], $[LPCOMMTIMEOUTS lpCommTimeouts])

$~CallNamedPipeA
$[BOOL ]CallNamedPipeA($[LPCSTR lpNamedPipeName], $[LPVOID lpInBuffer], $[DWORD nInBufferSize], $[LPVOID lpOutBuffer], $[DWORD nOutBufferSize], $[LPDWORD lpBytesRead], $[DWORD nTimeOut])

$~CallNamedPipeW
$[BOOL ]CallNamedPipeW($[LPCWSTR lpNamedPipeName], $[LPVOID lpInBuffer], $[DWORD nInBufferSize], $[LPVOID lpOutBuffer], $[DWORD nOutBufferSize], $[LPDWORD lpBytesRead], $[DWORD nTimeOut])

$~CancelDeviceWakeupRequest
$[BOOL ]CancelDeviceWakeupRequest ($[HANDLE hDevice])

$~CancelIo
$[BOOL ]CancelIo($[HANDLE hFile])

$~CancelWaitableTimer
$[BOOL ]CancelWaitableTimer($[HANDLE hTimer])

$~ChangeTimerQueueTimer
$[BOOL ]ChangeTimerQueueTimer($[HANDLE TimerQueue], $[HANDLE Timer], $[ULONG DueTime], $[ULONG Period])

$~CheckNameLegalDOS8Dot3A
$[BOOL ]CheckNameLegalDOS8Dot3A($[LPCSTR lpName], $[LPSTR lpOemName], $[DWORD OemNameSize], $[PBOOL pbNameContainsSpaces], $[PBOOL pbNameLegal])

$~CheckNameLegalDOS8Dot3W
$[BOOL ]CheckNameLegalDOS8Dot3W($[LPCWSTR lpName], $[LPSTR lpOemName], $[DWORD OemNameSize], $[PBOOL pbNameContainsSpaces], $[PBOOL pbNameLegal])

$~CheckRemoteDebuggerPresent
$[BOOL ]CheckRemoteDebuggerPresent($[HANDLE hProcess], $[PBOOL pbDebuggerPresent])

$~ClearCommBreak
$[BOOL ]ClearCommBreak($[HANDLE hFile])

$~ClearCommError
$[BOOL ]ClearCommError($[HANDLE hFile], $[LPDWORD lpErrors], $[LPCOMSTAT lpStat])

$~CloseHandle
$[BOOL ]CloseHandle($[HANDLE hObject])

$~CommConfigDialogA
$[BOOL ]CommConfigDialogA($[LPCSTR lpszName], $[HWND hWnd], $[LPCOMMCONFIG lpCC])

$~CommConfigDialogW
$[BOOL ]CommConfigDialogW($[LPCWSTR lpszName], $[HWND hWnd], $[LPCOMMCONFIG lpCC])

$~ConnectNamedPipe
$[BOOL ]ConnectNamedPipe($[HANDLE hNamedPipe], $[LPOVERLAPPED lpOverlapped])

$~ContinueDebugEvent
$[BOOL ]ContinueDebugEvent($[DWORD dwProcessId], $[DWORD dwThreadId], $[DWORD dwContinueStatus])

$~ConvertFiberToThread
$[BOOL ]ConvertFiberToThread($[])

$~CopyFileA
$[BOOL ]CopyFileA($[LPCSTR lpExistingFileName], $[LPCSTR lpNewFileName], $[BOOL bFailIfExists])

$~CopyFileExA
$[BOOL ]CopyFileExA($[LPCSTR lpExistingFileName], $[LPCSTR lpNewFileName], $[LPPROGRESS_ROUTINE lpProgressRoutine], $[LPVOID lpData], $[LPBOOL pbCancel], $[DWORD dwCopyFlags])

$~CopyFileExW
$[BOOL ]CopyFileExW($[LPCWSTR lpExistingFileName], $[LPCWSTR lpNewFileName], $[LPPROGRESS_ROUTINE lpProgressRoutine], $[LPVOID lpData], $[LPBOOL pbCancel], $[DWORD dwCopyFlags])

$~CopyFileW
$[BOOL ]CopyFileW($[LPCWSTR lpExistingFileName], $[LPCWSTR lpNewFileName], $[BOOL bFailIfExists])

$~CreateDirectoryA
$[BOOL ]CreateDirectoryA($[LPCSTR lpPathName], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateDirectoryExA
$[BOOL ]CreateDirectoryExA($[LPCSTR lpTemplateDirectory], $[LPCSTR lpNewDirectory], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateDirectoryExW
$[BOOL ]CreateDirectoryExW($[LPCWSTR lpTemplateDirectory], $[LPCWSTR lpNewDirectory], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateDirectoryW
$[BOOL ]CreateDirectoryW($[LPCWSTR lpPathName], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateHardLinkA
$[BOOL ]CreateHardLinkA($[LPCSTR lpFileName], $[LPCSTR lpExistingFileName], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateHardLinkW
$[BOOL ]CreateHardLinkW($[LPCWSTR lpFileName], $[LPCWSTR lpExistingFileName], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreatePipe
$[BOOL ]CreatePipe($[PHANDLE hReadPipe], $[PHANDLE hWritePipe], $[LPSECURITY_ATTRIBUTES lpPipeAttributes], $[DWORD nSize])

$~CreateProcessA
$[BOOL ]CreateProcessA($[LPCSTR lpApplicationName], $[LPSTR lpCommandLine], $[LPSECURITY_ATTRIBUTES lpProcessAttributes], $[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[BOOL bInheritHandles], $[DWORD dwCreationFlags], $[LPVOID lpEnvironment], $[LPCSTR lpCurrentDirectory], $[LPSTARTUPINFO lpStartupInfo], $[LPPROCESS_INFORMATION lpProcessInformation])

$~CreateProcessW
$[BOOL ]CreateProcessW($[LPCWSTR lpApplicationName], $[LPWSTR lpCommandLine], $[LPSECURITY_ATTRIBUTES lpProcessAttributes], $[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[BOOL bInheritHandles], $[DWORD dwCreationFlags], $[LPVOID lpEnvironment], $[LPCWSTR lpCurrentDirectory], $[LPSTARTUPINFO lpStartupInfo], $[LPPROCESS_INFORMATION lpProcessInformation])

$~CreateTimerQueueTimer
$[BOOL ]CreateTimerQueueTimer($[PHANDLE phNewTimer], $[HANDLE TimerQueue], $[WAITORTIMERCALLBACK Callback], $[PVOID Parameter], $[DWORD DueTime], $[DWORD Period], $[ULONG Flags])

$~DeactivateActCtx
$[BOOL ]DeactivateActCtx($[DWORD dwFlags], $[ULONG_PTR ulCookie])

$~DebugActiveProcess
$[BOOL ]DebugActiveProcess($[DWORD dwProcessId])

$~DebugActiveProcessStop
$[BOOL ]DebugActiveProcessStop($[DWORD dwProcessId])

$~DebugBreakProcess
$[BOOL ]DebugBreakProcess($[HANDLE Process])

$~DebugSetProcessKillOnExit
$[BOOL ]DebugSetProcessKillOnExit($[BOOL KillOnExit])

$~DefineDosDeviceA
$[BOOL ]DefineDosDeviceA($[DWORD dwFlags], $[LPCSTR lpDeviceName], $[LPCSTR lpTargetPath])

$~DefineDosDeviceW
$[BOOL ]DefineDosDeviceW($[DWORD dwFlags], $[LPCWSTR lpDeviceName], $[LPCWSTR lpTargetPath])

$~DeleteFileA
$[BOOL ]DeleteFileA($[LPCSTR lpFileName])

$~DeleteFileW
$[BOOL ]DeleteFileW($[LPCWSTR lpFileName])

$~DeleteTimerQueue
$[BOOL ]DeleteTimerQueue($[HANDLE TimerQueue])

$~DeleteTimerQueueEx
$[BOOL ]DeleteTimerQueueEx($[HANDLE TimerQueue], $[HANDLE CompletionEvent])

$~DeleteTimerQueueTimer
$[BOOL ]DeleteTimerQueueTimer($[HANDLE TimerQueue], $[HANDLE Timer], $[HANDLE CompletionEvent])

$~DeleteVolumeMountPointA
$[BOOL ]DeleteVolumeMountPointA($[LPCSTR lpszVolumeMountPoint])

$~DeleteVolumeMountPointW
$[BOOL ]DeleteVolumeMountPointW($[LPCWSTR lpszVolumeMountPoint])

$~DeviceIoControl
$[BOOL ]DeviceIoControl($[HANDLE hDevice], $[DWORD dwIoControlCode], $[LPVOID lpInBuffer], $[DWORD nInBufferSize], $[LPVOID lpOutBuffer], $[DWORD nOutBufferSize], $[LPDWORD lpBytesReturned], $[LPOVERLAPPED lpOverlapped])

$~DisableThreadLibraryCalls
$[BOOL ]DisableThreadLibraryCalls($[HMODULE hModule])

$~DisconnectNamedPipe
$[BOOL ]DisconnectNamedPipe($[HANDLE hNamedPipe])

$~DnsHostnameToComputerNameA
$[BOOL ]DnsHostnameToComputerNameA($[LPCSTR Hostname], $[LPSTR ComputerName], $[LPDWORD nSize])

$~DnsHostnameToComputerNameW
$[BOOL ]DnsHostnameToComputerNameW($[LPCWSTR Hostname], $[LPWSTR ComputerName], $[LPDWORD nSize])

$~DosDateTimeToFileTime
$[BOOL ]DosDateTimeToFileTime($[WORD wFatDate], $[WORD wFatTime], $[LPFILETIME lpFileTime])

$~DuplicateHandle
$[BOOL ]DuplicateHandle($[HANDLE hSourceProcessHandle], $[HANDLE hSourceHandle], $[HANDLE hTargetProcessHandle], $[LPHANDLE lpTargetHandle], $[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[DWORD dwOptions])

$~EndUpdateResourceA
$[BOOL ]EndUpdateResourceA($[HANDLE hUpdate], $[BOOL fDiscard])

$~EndUpdateResourceW
$[BOOL ]EndUpdateResourceW($[HANDLE hUpdate], $[BOOL fDiscard])

$~EnumCalendarInfoA
$[BOOL ]EnumCalendarInfoA($[CALINFO_ENUMPROC pCalInfoEnumProc], $[LCID Locale], $[CALID Calendar], $[CALTYPE CalType])

$~EnumCalendarInfoExA
$[BOOL ]EnumCalendarInfoExA($[CALINFO_ENUMPROCEX pCalInfoEnumProcEx], $[LCID Locale], $[CALID Calendar], $[CALTYPE CalType])

$~EnumCalendarInfoExW
$[BOOL ]EnumCalendarInfoExW($[CALINFO_ENUMPROCEX pCalInfoEnumProcEx], $[LCID Locale], $[CALID Calendar], $[CALTYPE CalType])

$~EnumCalendarInfoW
$[BOOL ]EnumCalendarInfoW($[CALINFO_ENUMPROC pCalInfoEnumProc], $[LCID Locale], $[CALID Calendar], $[CALTYPE CalType])

$~EnumDateFormatsA
$[BOOL ]EnumDateFormatsA($[DATEFMT_ENUMPROC lpDateFmtEnumProc], $[LCID Locale], $[DWORD dwFlags])

$~EnumDateFormatsExA
$[BOOL ]EnumDateFormatsExA($[DATEFMT_ENUMPROCEX lpDateFmtEnumProcEx], $[LCID Locale], $[DWORD dwFlags])

$~EnumDateFormatsExW
$[BOOL ]EnumDateFormatsExW($[DATEFMT_ENUMPROCEX lpDateFmtEnumProcEx], $[LCID Locale], $[DWORD dwFlags])

$~EnumDateFormatsW
$[BOOL ]EnumDateFormatsW($[DATEFMT_ENUMPROC lpDateFmtEnumProc], $[LCID Locale], $[DWORD dwFlags])

$~EnumLanguageGroupLocalesA
$[BOOL ]EnumLanguageGroupLocalesA($[LANGGROUPLOCALE_ENUMPROC pLangGroupLocaleEnumProc], $[LGRPID LanguageGroup], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EnumLanguageGroupLocalesW
$[BOOL ]EnumLanguageGroupLocalesW($[LANGGROUPLOCALE_ENUMPROC pLangGroupLocaleEnumProc], $[LGRPID LanguageGroup], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EnumResourceLanguagesA
$[BOOL ]EnumResourceLanguagesA($[HMODULE hModule], $[LPCSTR lpType], $[LPCSTR lpName], $[ENUMRESLANGPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumResourceLanguagesW
$[BOOL ]EnumResourceLanguagesW($[HMODULE hModule], $[LPCWSTR lpType], $[LPCWSTR lpName], $[ENUMRESLANGPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumResourceNamesA
$[BOOL ]EnumResourceNamesA($[HMODULE hModule], $[LPCSTR lpszType], $[ENUMRESNAMEPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumResourceNamesW
$[BOOL ]EnumResourceNamesW($[HMODULE hModule], $[LPCWSTR lpszType], $[ENUMRESNAMEPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumResourceTypesA
$[BOOL ]EnumResourceTypesA($[HMODULE hModule], $[ENUMRESTYPEPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumResourceTypesW
$[BOOL ]EnumResourceTypesW($[HMODULE hModule], $[ENUMRESTYPEPROC lpEnumFunc], $[LONG_PTR lParam])

$~EnumSystemCodePagesA
$[BOOL ]EnumSystemCodePagesA($[CODEPAGE_ENUMPROC lpCodePageEnumProc], $[DWORD dwFlags])

$~EnumSystemCodePagesW
$[BOOL ]EnumSystemCodePagesW($[CODEPAGE_ENUMPROC lpCodePageEnumProc], $[DWORD dwFlags])

$~EnumSystemGeoID
$[BOOL ]EnumSystemGeoID($[GEOCLASS GeoClass], $[GEOID ParentGeoId], $[GEO_ENUMPROC lpGeoEnumProc])

$~EnumSystemLanguageGroupsA
$[BOOL ]EnumSystemLanguageGroupsA($[LANGUAGEGROUP_ENUMPROC pLangGroupEnumProc], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EnumSystemLanguageGroupsW
$[BOOL ]EnumSystemLanguageGroupsW($[LANGUAGEGROUP_ENUMPROC pLangGroupEnumProc], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EnumSystemLocalesA
$[BOOL ]EnumSystemLocalesA($[LOCALE_ENUMPROC lpLocaleEnumProc], $[DWORD dwFlags])

$~EnumSystemLocalesW
$[BOOL ]EnumSystemLocalesW($[LOCALE_ENUMPROC lpLocaleEnumProc], $[DWORD dwFlags])

$~EnumTimeFormatsA
$[BOOL ]EnumTimeFormatsA($[TIMEFMT_ENUMPROC lpTimeFmtEnumProc], $[LCID Locale], $[DWORD dwFlags])

$~EnumTimeFormatsW
$[BOOL ]EnumTimeFormatsW($[TIMEFMT_ENUMPROC lpTimeFmtEnumProc], $[LCID Locale], $[DWORD dwFlags])

$~EnumUILanguagesA
$[BOOL ]EnumUILanguagesA($[UILANGUAGE_ENUMPROC lpUILanguageEnumProc], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EnumUILanguagesW
$[BOOL ]EnumUILanguagesW($[UILANGUAGE_ENUMPROC lpUILanguageEnumProc], $[DWORD dwFlags], $[LONG_PTR lParam])

$~EscapeCommFunction
$[BOOL ]EscapeCommFunction($[HANDLE hFile], $[DWORD dwFunc])

$~FileTimeToDosDateTime
$[BOOL ]FileTimeToDosDateTime($[const FILETIME* lpFileTime], $[LPWORD lpFatDate], $[LPWORD lpFatTime])

$~FileTimeToLocalFileTime
$[BOOL ]FileTimeToLocalFileTime($[const FILETIME* lpFileTime], $[LPFILETIME lpLocalFileTime])

$~FileTimeToSystemTime
$[BOOL ]FileTimeToSystemTime($[const FILETIME* lpFileTime], $[LPSYSTEMTIME lpSystemTime])

$~FillConsoleOutputAttribute
$[BOOL ]FillConsoleOutputAttribute($[HANDLE hConsoleOutput], $[WORD wAttribute], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfAttrsWritten])

$~FillConsoleOutputCharacterA
$[BOOL ]FillConsoleOutputCharacterA($[HANDLE hConsoleOutput], $[T HAR cCharacter], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfCharsWritten])

$~FillConsoleOutputCharacterW
$[BOOL ]FillConsoleOutputCharacterW($[HANDLE hConsoleOutput], $[TWHAR cCharacter], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfCharsWritten])

$~FindActCtxSectionGuid
$[BOOL ]FindActCtxSectionGuid($[DWORD dwFlags], $[const GUID* lpExtensionGuid], $[ULONG ulSectionId], $[const GUID* lpGuidToFind], $[PACTCTX_SECTION_KEYED_DATA ReturnedData])

$~FindActCtxSectionStringA
$[BOOL ]FindActCtxSectionStringA($[DWORD dwFlags], $[const GUID* lpExtensionGuid], $[ULONG ulSectionId], $[LPCSTR lpStringToFind], $[PACTCTX_SECTION_KEYED_DATA ReturnedData])

$~FindActCtxSectionStringW
$[BOOL ]FindActCtxSectionStringW($[DWORD dwFlags], $[const GUID* lpExtensionGuid], $[ULONG ulSectionId], $[LPCWSTR lpStringToFind], $[PACTCTX_SECTION_KEYED_DATA ReturnedData])

$~FindClose
$[BOOL ]FindClose($[HANDLE hFindFile])

$~FindCloseChangeNotification
$[BOOL ]FindCloseChangeNotification($[HANDLE hChangeHandle])

$~FindNextChangeNotification
$[BOOL ]FindNextChangeNotification($[HANDLE hChangeHandle])

$~FindNextFileA
$[BOOL ]FindNextFileA($[HANDLE hFindFile], $[LPWIN32_FIND_DATA lpFindFileData])

$~FindNextFileW
$[BOOL ]FindNextFileW($[HANDLE hFindFile], $[LPWIN32_FIND_DATAW lpFindFileData])

$~FindNextVolumeA
$[BOOL ]FindNextVolumeA($[HANDLE hFindVolume], $[LPSTR lpszVolumeName], $[DWORD cchBufferLength])

$~FindNextVolumeMountPointA
$[BOOL ]FindNextVolumeMountPointA($[HANDLE hFindVolumeMountPoint], $[LPSTR lpszVolumeMountPoint], $[DWORD cchBufferLength])

$~FindNextVolumeMountPointW
$[BOOL ]FindNextVolumeMountPointW($[HANDLE hFindVolumeMountPoint], $[LPWSTR lpszVolumeMountPoint], $[DWORD cchBufferLength])

$~FindNextVolumeW
$[BOOL ]FindNextVolumeW($[HANDLE hFindVolume], $[LPWSTR lpszVolumeName], $[DWORD cchBufferLength])

$~FindVolumeClose
$[BOOL ]FindVolumeClose($[HANDLE hFindVolume])

$~FindVolumeMountPointClose
$[BOOL ]FindVolumeMountPointClose($[HANDLE hFindVolumeMountPoint])

$~FlushConsoleInputBuffer
$[BOOL ]FlushConsoleInputBuffer($[HANDLE hConsoleInput])

$~FlushFileBuffers
$[BOOL ]FlushFileBuffers($[HANDLE hFile])

$~FlushInstructionCache
$[BOOL ]FlushInstructionCache($[HANDLE hProcess], $[LPCVOID lpBaseAddress], $[SIZE_T dwSize])

$~FlushViewOfFile
$[BOOL ]FlushViewOfFile($[LPCVOID lpBaseAddress], $[SIZE_T dwNumberOfBytesToFlush])

$~FreeConsole
$[BOOL ]FreeConsole($[])

$~FreeEnvironmentStringsA
$[BOOL ]FreeEnvironmentStringsA($[LPTCH lpszEnvironmentBlock])

$~FreeEnvironmentStringsW
$[BOOL ]FreeEnvironmentStringsW($[LPTCH lpszEnvironmentBlock])

$~FreeLibrary
$[BOOL ]FreeLibrary($[HMODULE hModule])

$~FreeResource
$[BOOL ]FreeResource($[HGLOBAL hglbResource])

$~FreeUserPhysicalPages
$[BOOL ]FreeUserPhysicalPages($[HANDLE hProcess], $[PULONG_PTR NumberOfPages], $[PULONG_PTR UserPfnArray])

$~GenerateConsoleCtrlEvent
$[BOOL ]GenerateConsoleCtrlEvent($[DWORD dwCtrlEvent], $[DWORD dwProcessGroupId])

$~GetBinaryType
$[BOOL ]GetBinaryType($[LPCSTR lpApplicationName], $[LPDWORD lpBinaryType])

$~GetBinaryTypeA
$[BOOL ]GetBinaryTypeA($[LPCSTR lpApplicationName], $[LPDWORD lpBinaryType])

$~GetBinaryTypeW
$[BOOL ]GetBinaryTypeW($[LPCSTR lpApplicationName], $[LPDWORD lpBinaryType])

$~GetCommConfig
$[BOOL ]GetCommConfig($[HANDLE hCommDev], $[LPCOMMCONFIG lpCC], $[LPDWORD lpdwSize])

$~GetCommMask
$[BOOL ]GetCommMask($[HANDLE hFile], $[LPDWORD lpEvtMask])

$~GetCommModemStatus
$[BOOL ]GetCommModemStatus($[HANDLE hFile], $[LPDWORD lpModemStat])

$~GetCommProperties
$[BOOL ]GetCommProperties($[HANDLE hFile], $[LPCOMMPROP lpCommProp])

$~GetCommState
$[BOOL ]GetCommState($[HANDLE hFile], $[LPDCB lpDCB])

$~GetCommTimeouts
$[BOOL ]GetCommTimeouts($[HANDLE hFile], $[LPCOMMTIMEOUTS lpCommTimeouts])

$~GetComputerNameA
$[BOOL ]GetComputerNameA($[LPSTR lpBuffer], $[LPDWORD lpnSize])

$~GetComputerNameExA
$[BOOL ]GetComputerNameExA($[COMPUTER_NAME_FORMAT NameType], $[LPSTR lpBuffer], $[LPDWORD lpnSize])

$~GetComputerNameExW
$[BOOL ]GetComputerNameExW($[COMPUTER_NAME_FORMAT NameType], $[LPWSTR lpBuffer], $[LPDWORD lpnSize])

$~GetComputerNameW
$[BOOL ]GetComputerNameW($[LPWSTR lpBuffer], $[LPDWORD lpnSize])

$~GetConsoleCursorInfo
$[BOOL ]GetConsoleCursorInfo($[HANDLE hConsoleOutput], $[PCONSOLE_CURSOR_INFO lpConsoleCursorInfo])

$~GetConsoleDisplayMode
$[BOOL ]GetConsoleDisplayMode($[LPDWORD lpModeFlags])

$~GetConsoleMode
$[BOOL ]GetConsoleMode($[HANDLE hConsoleHandle], $[LPDWORD lpMode])

$~GetConsoleScreenBufferInfo
$[BOOL ]GetConsoleScreenBufferInfo($[HANDLE hConsoleOutput], $[PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo])

$~GetConsoleSelectionInfo
$[BOOL ]GetConsoleSelectionInfo($[PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo])

$~GetCPInfo
$[BOOL ]GetCPInfo($[UINT CodePage], $[LPCPINFO lpCPInfo])

$~GetCPInfoExA
$[BOOL ]GetCPInfoExA($[UINT CodePage], $[DWORD dwFlags], $[LPCPINFOEX lpCPInfoEx])

$~GetCPInfoExW
$[BOOL ]GetCPInfoExW($[UINT CodePage], $[DWORD dwFlags], $[LPCPINFOEX lpCPInfoEx])

$~GetCurrentActCtx
$[BOOL ]GetCurrentActCtx($[HANDLE* lphActCtx])

$~GetCurrentConsoleFont
$[BOOL ]GetCurrentConsoleFont($[HANDLE hConsoleOutput], $[BOOL bMaximumWindow], $[PCONSOLE_FONT_INFO lpConsoleCurrentFont])

$~GetDefaultCommConfigA
$[BOOL ]GetDefaultCommConfigA($[LPCSTR lpszName], $[LPCOMMCONFIG lpCC], $[LPDWORD lpdwSize])

$~GetDefaultCommConfigW
$[BOOL ]GetDefaultCommConfigW($[LPCWSTR lpszName], $[LPCOMMCONFIG lpCC], $[LPDWORD lpdwSize])

$~GetDevicePowerState
$[BOOL ]GetDevicePowerState($[HANDLE hDevice], $[BOOL* pfOn])

$~GetDiskFreeSpaceA
$[BOOL ]GetDiskFreeSpaceA($[LPCSTR lpRootPathName], $[LPDWORD lpSectorsPerCluster], $[LPDWORD lpBytesPerSector], $[LPDWORD lpNumberOfFreeClusters], $[LPDWORD lpTotalNumberOfClusters])

$~GetDiskFreeSpaceExA
$[BOOL ]GetDiskFreeSpaceExA($[LPCSTR lpDirectoryName], $[PULARGE_INTEGER lpFreeBytesAvailable], $[PULARGE_INTEGER lpTotalNumberOfBytes], $[PULARGE_INTEGER lpTotalNumberOfFreeBytes])

$~GetDiskFreeSpaceExW
$[BOOL ]GetDiskFreeSpaceExW($[LPCWSTR lpDirectoryName], $[PULARGE_INTEGER lpFreeBytesAvailable], $[PULARGE_INTEGER lpTotalNumberOfBytes], $[PULARGE_INTEGER lpTotalNumberOfFreeBytes])

$~GetDiskFreeSpaceW
$[BOOL ]GetDiskFreeSpaceW($[LPCWSTR lpRootPathName], $[LPDWORD lpSectorsPerCluster], $[LPDWORD lpBytesPerSector], $[LPDWORD lpNumberOfFreeClusters], $[LPDWORD lpTotalNumberOfClusters])

$~GetExitCodeProcess
$[BOOL ]GetExitCodeProcess($[HANDLE hProcess], $[LPDWORD lpExitCode])

$~GetExitCodeThread
$[BOOL ]GetExitCodeThread($[HANDLE hThread], $[LPDWORD lpExitCode])

$~GetFileAttributesExA
$[BOOL ]GetFileAttributesExA($[LPCSTR lpFileName], $[GET_FILEEX_INFO_LEVELS fInfoLevelId], $[LPVOID lpFileInformation])

$~GetFileAttributesExW
$[BOOL ]GetFileAttributesExW($[LPCWSTR lpFileName], $[GET_FILEEX_INFO_LEVELS fInfoLevelId], $[LPVOID lpFileInformation])

$~GetFileInformationByHandle
$[BOOL ]GetFileInformationByHandle($[HANDLE hFile], $[LPBY_HANDLE_FILE_INFORMATION lpFileInformation])

$~GetFileSizeEx
$[BOOL ]GetFileSizeEx($[HANDLE hFile], $[PLARGE_INTEGER lpFileSize])

$~GetFileTime
$[BOOL ]GetFileTime($[HANDLE hFile], $[LPFILETIME lpCreationTime], $[LPFILETIME lpLastAccessTime], $[LPFILETIME lpLastWriteTime])

$~GetHandleInformation
$[BOOL ]GetHandleInformation($[HANDLE hObject], $[LPDWORD lpdwFlags])

$~GetMailslotInfo
$[BOOL ]GetMailslotInfo($[HANDLE hMailslot], $[LPDWORD lpMaxMessageSize], $[LPDWORD lpNextSize], $[LPDWORD lpMessageCount], $[LPDWORD lpReadTimeout])

$~GetModuleHandleExA
$[BOOL ]GetModuleHandleExA($[DWORD dwFlags], $[LPCSTR lpModuleName], $[HMODULE* phModule])

$~GetModuleHandleExW
$[BOOL ]GetModuleHandleExW($[DWORD dwFlags], $[LPCWSTR lpModuleName], $[HMODULE* phModule])

$~GetNamedPipeHandleStateA
$[BOOL ]GetNamedPipeHandleStateA($[HANDLE hNamedPipe], $[LPDWORD lpState], $[LPDWORD lpCurInstances], $[LPDWORD lpMaxCollectionCount], $[LPDWORD lpCollectDataTimeout], $[LPSTR lpUserName], $[DWORD nMaxUserNameSize])

$~GetNamedPipeHandleStateW
$[BOOL ]GetNamedPipeHandleStateW($[HANDLE hNamedPipe], $[LPDWORD lpState], $[LPDWORD lpCurInstances], $[LPDWORD lpMaxCollectionCount], $[LPDWORD lpCollectDataTimeout], $[LPWSTR lpUserName], $[DWORD nMaxUserNameSize])

$~GetNamedPipeInfo
$[BOOL ]GetNamedPipeInfo($[HANDLE hNamedPipe], $[LPDWORD lpFlags], $[LPDWORD lpOutBufferSize], $[LPDWORD lpInBufferSize], $[LPDWORD lpMaxInstances])

$~GetNumaAvailableMemoryNode
$[BOOL ]GetNumaAvailableMemoryNode($[UCHAR Node], $[PULONGLONG AvailableBytes])

$~GetNumaHighestNodeNumber
$[BOOL ]GetNumaHighestNodeNumber($[PULONG HighestNodeNumber])

$~GetNumaNodeProcessorMask
$[BOOL ]GetNumaNodeProcessorMask($[UCHAR Node], $[PULONGLONG ProcessorMask])

$~GetNumaProcessorNode
$[BOOL ]GetNumaProcessorNode($[UCHAR Processor], $[PUCHAR NodeNumber])

$~GetNumberOfConsoleInputEvents
$[BOOL ]GetNumberOfConsoleInputEvents($[HANDLE hConsoleInput], $[LPDWORD lpcNumberOfEvents])

$~GetNumberOfConsoleMouseButtons
$[BOOL ]GetNumberOfConsoleMouseButtons($[LPDWORD lpNumberOfMouseButtons])

$~GetOverlappedResult
$[BOOL ]GetOverlappedResult($[HANDLE hFile], $[LPOVERLAPPED lpOverlapped], $[LPDWORD lpNumberOfBytesTransferred], $[BOOL bWait])

$~GetPrivateProfileStructA
$[BOOL ]GetPrivateProfileStructA($[LPCSTR lpszSection], $[LPCSTR lpszKey], $[LPVOID lpStruct], $[UINT uSizeStruct], $[LPCSTR szFile])

$~GetPrivateProfileStructW
$[BOOL ]GetPrivateProfileStructW($[LPCWSTR lpszSection], $[LPCWSTR lpszKey], $[LPVOID lpStruct], $[UINT uSizeStruct], $[LPCWSTR szFile])

$~GetProcessAffinityMask
$[BOOL ]GetProcessAffinityMask($[HANDLE hProcess], $[PDWORD_PTR lpProcessAffinityMask], $[PDWORD_PTR lpSystemAffinityMask])

$~GetProcessHandleCount
$[BOOL ]GetProcessHandleCount($[HANDLE hProcess], $[PDWORD pdwHandleCount])

$~GetProcessIoCounters
$[BOOL ]GetProcessIoCounters($[HANDLE hProcess], $[PIO_COUNTERS lpIoCounters])

$~GetProcessPriorityBoost
$[BOOL ]GetProcessPriorityBoost($[HANDLE hProcess], $[PBOOL pDisablePriorityBoost])

$~GetProcessShutdownParameters
$[BOOL ]GetProcessShutdownParameters($[LPDWORD lpdwLevel], $[LPDWORD lpdwFlags])

$~GetProcessTimes
$[BOOL ]GetProcessTimes($[HANDLE hProcess], $[LPFILETIME lpCreationTime], $[LPFILETIME lpExitTime], $[LPFILETIME lpKernelTime], $[LPFILETIME lpUserTime])

$~GetProcessWorkingSetSize
$[BOOL ]GetProcessWorkingSetSize($[HANDLE hProcess], $[PSIZE_T lpMinimumWorkingSetSize], $[PSIZE_T lpMaximumWorkingSetSize])

$~GetQueuedCompletionStatus
$[BOOL ]GetQueuedCompletionStatus($[HANDLE CompletionPort], $[LPDWORD lpNumberOfBytes], $[PULONG_PTR lpCompletionKey], $[LPOVERLAPPED* lpOverlapped], $[DWORD dwMilliseconds])

$~GetStringTypeExA
$[BOOL ]GetStringTypeExA($[LCID Locale], $[DWORD dwInfoType], $[LPCSTR lpSrcStr], $[int cchSrc], $[LPWORD lpCharType])

$~GetStringTypeExW
$[BOOL ]GetStringTypeExW($[LCID Locale], $[DWORD dwInfoType], $[LPCWSTR lpSrcStr], $[int cchSrc], $[LPWORD lpCharType])

$~GetSystemPowerStatus
$[BOOL ]GetSystemPowerStatus($[LPSYSTEM_POWER_STATUS lpSystemPowerStatus])

$~GetSystemRegistryQuota
$[BOOL ]GetSystemRegistryQuota($[PDWORD pdwQuotaAllowed], $[PDWORD pdwQuotaUsed])

$~GetSystemTimeAdjustment
$[BOOL ]GetSystemTimeAdjustment($[PDWORD lpTimeAdjustment], $[PDWORD lpTimeIncrement], $[PBOOL lpTimeAdjustmentDisabled])

$~GetSystemTimes
$[BOOL ]GetSystemTimes($[LPFILETIME lpIdleTime], $[LPFILETIME lpKernelTime], $[LPFILETIME lpUserTime])

$~GetThreadContext
$[BOOL ]GetThreadContext($[HANDLE hThread], $[LPCONTEXT lpContext])

$~GetThreadIOPendingFlag
$[BOOL ]GetThreadIOPendingFlag($[HANDLE hThread], $[PBOOL lpIOIsPending])

$~GetThreadPriorityBoost
$[BOOL ]GetThreadPriorityBoost($[HANDLE hThread], $[PBOOL pDisablePriorityBoost])

$~GetThreadSelectorEntry
$[BOOL ]GetThreadSelectorEntry($[HANDLE hThread], $[DWORD dwSelector], $[LPLDT_ENTRY lpSelectorEntry])

$~GetThreadTimes
$[BOOL ]GetThreadTimes($[HANDLE hThread], $[LPFILETIME lpCreationTime], $[LPFILETIME lpExitTime], $[LPFILETIME lpKernelTime], $[LPFILETIME lpUserTime])

$~GetVersionExA
$[BOOL ]GetVersionExA($[LPOSVERSIONINFOA lpVersionInfo])

$~GetVersionExW
$[BOOL ]GetVersionExW($[LPOSVERSIONINFOW lpVersionInfo])

$~GetVolumeInformationA
$[BOOL ]GetVolumeInformationA($[LPCSTR lpRootPathName], $[LPSTR lpVolumeNameBuffer], $[DWORD nVolumeNameSize], $[LPDWORD lpVolumeSerialNumber], $[LPDWORD lpMaximumComponentLength], $[LPDWORD lpFileSystemFlags], $[LPSTR lpFileSystemNameBuffer], $[DWORD nFileSystemNameSize])

$~GetVolumeInformationW
$[BOOL ]GetVolumeInformationW($[LPCWSTR lpRootPathName], $[LPWSTR lpVolumeNameBuffer], $[DWORD nVolumeNameSize], $[LPDWORD lpVolumeSerialNumber], $[LPDWORD lpMaximumComponentLength], $[LPDWORD lpFileSystemFlags], $[LPWSTR lpFileSystemNameBuffer], $[DWORD nFileSystemNameSize])

$~GetVolumeNameForVolumeMountPointA
$[BOOL ]GetVolumeNameForVolumeMountPointA($[LPCSTR lpszVolumeMountPoint], $[LPSTR lpszVolumeName], $[DWORD cchBufferLength])

$~GetVolumeNameForVolumeMountPointW
$[BOOL ]GetVolumeNameForVolumeMountPointW($[LPCWSTR lpszVolumeMountPoint], $[LPWSTR lpszVolumeName], $[DWORD cchBufferLength])

$~GetVolumePathNameA
$[BOOL ]GetVolumePathNameA($[LPCSTR lpszFileName], $[LPSTR lpszVolumePathName], $[DWORD cchBufferLength])

$~GetVolumePathNamesForVolumeNameA
$[BOOL ]GetVolumePathNamesForVolumeNameA($[LPCSTR lpszVolumeName], $[LPSTR lpszVolumePathNames], $[DWORD cchBufferLength], $[PDWORD lpcchReturnLength])

$~GetVolumePathNamesForVolumeNameW
$[BOOL ]GetVolumePathNamesForVolumeNameW($[LPCWSTR lpszVolumeName], $[LPWSTR lpszVolumePathNames], $[DWORD cchBufferLength], $[PDWORD lpcchReturnLength])

$~GetVolumePathNameW
$[BOOL ]GetVolumePathNameW($[LPCWSTR lpszFileName], $[LPWSTR lpszVolumePathName], $[DWORD cchBufferLength])

$~GlobalMemoryStatusEx
$[BOOL ]GlobalMemoryStatusEx($[LPMEMORYSTATUSEX lpBuffer])

$~GlobalUnlock
$[BOOL ]GlobalUnlock($[HGLOBAL hMem])

$~Heap32First
$[BOOL ]Heap32First($[LPHEAPENTRY32 lphe], $[DWORD th32ProcessID], $[ULONG_PTR th32HeapID])

$~Heap32ListFirst
$[BOOL ]Heap32ListFirst($[HANDLE hSnapshot], $[LPHEAPLIST32 lphl])

$~Heap32ListNext
$[BOOL ]Heap32ListNext($[HANDLE hSnapshot], $[LPHEAPLIST32 lphl])

$~Heap32Next
$[BOOL ]Heap32Next($[LPHEAPENTRY32 lphe])

$~HeapDestroy
$[BOOL ]HeapDestroy($[HANDLE hHeap])

$~HeapFree
$[BOOL ]HeapFree($[HANDLE hHeap], $[DWORD dwFlags], $[LPVOID lpMem])

$~HeapLock
$[BOOL ]HeapLock($[HANDLE hHeap])

$~HeapQueryInformation
$[BOOL ]HeapQueryInformation($[HANDLE HeapHandle], $[HEAP_INFORMATION_CLASS HeapInformationClass], $[PVOID HeapInformation], $[SIZE_T HeapInformationLength], $[PSIZE_T ReturnLength])

$~HeapSetInformation
$[BOOL ]HeapSetInformation($[HANDLE HeapHandle], $[HEAP_INFORMATION_CLASS HeapInformationClass], $[PVOID HeapInformation], $[SIZE_T HeapInformationLength])

$~HeapUnlock
$[BOOL ]HeapUnlock($[HANDLE hHeap])

$~HeapValidate
$[BOOL ]HeapValidate($[HANDLE hHeap], $[DWORD dwFlags], $[LPCVOID lpMem])

$~HeapWalk
$[BOOL ]HeapWalk($[HANDLE hHeap], $[LPPROCESS_HEAP_ENTRY lpEntry])

$~InitAtomTable
$[BOOL ]InitAtomTable($[DWORD nSize])

$~InitializeCriticalSectionAndSpinCount
$[BOOL ]InitializeCriticalSectionAndSpinCount($[LPCRITICAL_SECTION lpCriticalSection], $[DWORD dwSpinCount])

$~IsBadCodePtr
$[BOOL ]IsBadCodePtr($[FARPROC lpfn])

$~IsBadHugeReadPtr
$[BOOL ]IsBadHugeReadPtr($[const VOID* lp], $[UINT_PTR ucb])

$~IsBadHugeWritePtr
$[BOOL ]IsBadHugeWritePtr($[LPVOID lp], $[UINT_PTR ucb])

$~IsBadReadPtr
$[BOOL ]IsBadReadPtr($[const VOID* lp], $[UINT_PTR ucb])

$~IsBadStringPtrA
$[BOOL ]IsBadStringPtrA($[LPCSTR lpsz], $[UINT_PTR ucchMax])

$~IsBadStringPtrW
$[BOOL ]IsBadStringPtrW($[LPCWSTR lpsz], $[UINT_PTR ucchMax])

$~IsBadWritePtr
$[BOOL ]IsBadWritePtr($[LPVOID lp], $[UINT_PTR ucb])

$~IsDBCSLeadByte
$[BOOL ]IsDBCSLeadByte($[BYTE TestChar])

$~IsDBCSLeadByteEx
$[BOOL ]IsDBCSLeadByteEx($[UINT CodePage], $[BYTE TestChar])

$~IsDebuggerPresent
$[BOOL ]IsDebuggerPresent($[])

$~IsProcessInJob
$[BOOL ]IsProcessInJob($[HANDLE ProcessHandle], $[HANDLE JobHandle], $[PBOOL Result])

$~IsProcessorFeaturePresent
$[BOOL ]IsProcessorFeaturePresent($[DWORD ProcessorFeature])

$~IsSystemResumeAutomatic
$[BOOL ]IsSystemResumeAutomatic($[])

$~IsValidCodePage
$[BOOL ]IsValidCodePage($[UINT CodePage])

$~IsValidLanguageGroup
$[BOOL ]IsValidLanguageGroup($[LGRPID LanguageGroup], $[DWORD dwFlags])

$~IsValidLocale
$[BOOL ]IsValidLocale($[LCID Locale], $[DWORD dwFlags])

$~IsWow64Process
$[BOOL ]IsWow64Process($[HANDLE hProcess], $[PBOOL Wow64Process])

$~LocalFileTimeToFileTime
$[BOOL ]LocalFileTimeToFileTime($[const FILETIME* lpLocalFileTime], $[LPFILETIME lpFileTime])

$~LocalUnlock
$[BOOL ]LocalUnlock($[HLOCAL hMem])

$~LockFile
$[BOOL ]LockFile($[HANDLE hFile], $[DWORD dwFileOffsetLow], $[DWORD dwFileOffsetHigh], $[DWORD nNumberOfBytesToLockLow], $[DWORD nNumberOfBytesToLockHigh])

$~LockFileEx
$[BOOL ]LockFileEx($[HANDLE hFile], $[DWORD dwFlags], $[DWORD dwReserved], $[DWORD nNumberOfBytesToLockLow], $[DWORD nNumberOfBytesToLockHigh], $[LPOVERLAPPED lpOverlapped])

$~MapUserPhysicalPages
$[BOOL ]MapUserPhysicalPages($[PVOID lpAddress], $[ULONG_PTR NumberOfPages], $[PULONG_PTR UserPfnArray])

$~MapUserPhysicalPagesScatter
$[BOOL ]MapUserPhysicalPagesScatter($[PVOID* VirtualAddresses], $[ULONG_PTR NumberOfPages], $[PULONG_PTR PageArray])

$~Module32First
$[BOOL ]Module32First($[HANDLE hSnapshot], $[LPMODULEENTRY32 lpme])

$~Module32FirstW
$[BOOL ]Module32FirstW($[HANDLE hSnapshot], $[LPMODULEENTRY32W lpme])

$~Module32Next
$[BOOL ]Module32Next($[HANDLE hSnapshot], $[LPMODULEENTRY32 lpme])

$~Module32NextW
$[BOOL ]Module32NextW($[HANDLE hSnapshot], $[LPMODULEENTRY32W lpme])

$~MoveFileA
$[BOOL ]MoveFileA($[LPCSTR lpExistingFileName], $[LPCSTR lpNewFileName])

$~MoveFileExA
$[BOOL ]MoveFileExA($[LPCSTR lpExistingFileName], $[LPCSTR lpNewFileName], $[DWORD dwFlags])

$~MoveFileExW
$[BOOL ]MoveFileExW($[LPCWSTR lpExistingFileName], $[LPCWSTR lpNewFileName], $[DWORD dwFlags])

$~MoveFileW
$[BOOL ]MoveFileW($[LPCWSTR lpExistingFileName], $[LPCWSTR lpNewFileName])

$~MoveFileWithProgressA
$[BOOL ]MoveFileWithProgressA($[LPCSTR lpExistingFileName], $[LPCSTR lpNewFileName], $[LPPROGRESS_ROUTINE lpProgressRoutine], $[LPVOID lpData], $[DWORD dwFlags])

$~MoveFileWithProgressW
$[BOOL ]MoveFileWithProgressW($[LPCWSTR lpExistingFileName], $[LPCWSTR lpNewFileName], $[LPPROGRESS_ROUTINE lpProgressRoutine], $[LPVOID lpData], $[DWORD dwFlags])

$~PeekConsoleInputA
$[BOOL ]PeekConsoleInputA($[HANDLE hConsoleInput], $[PINPUT_RECORD lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsRead])

$~PeekConsoleInputW
$[BOOL ]PeekConsoleInputW($[HANDLE hConsoleInput], $[PINPUT_RECORD lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsRead])

$~PeekNamedPipe
$[BOOL ]PeekNamedPipe($[HANDLE hNamedPipe], $[LPVOID lpBuffer], $[DWORD nBufferSize], $[LPDWORD lpBytesRead], $[LPDWORD lpTotalBytesAvail], $[LPDWORD lpBytesLeftThisMessage])

$~PostQueuedCompletionStatus
$[BOOL ]PostQueuedCompletionStatus($[HANDLE CompletionPort], $[DWORD dwNumberOfBytesTransferred], $[ULONG_PTR dwCompletionKey], $[LPOVERLAPPED lpOverlapped])

$~Process32First
$[BOOL ]Process32First($[HANDLE hSnapshot], $[LPPROCESSENTRY32 lppe])

$~Process32FirstW
$[BOOL ]Process32FirstW($[HANDLE hSnapshot], $[LPPROCESSENTRY32W lppe])

$~Process32Next
$[BOOL ]Process32Next($[HANDLE hSnapshot], $[LPPROCESSENTRY32 lppe])

$~Process32NextW
$[BOOL ]Process32NextW($[HANDLE hSnapshot], $[LPPROCESSENTRY32W lppe])

$~ProcessIdToSessionId
$[BOOL ]ProcessIdToSessionId($[DWORD dwProcessId], $[DWORD* pSessionId])

$~PulseEvent
$[BOOL ]PulseEvent($[HANDLE hEvent])

$~PurgeComm
$[BOOL ]PurgeComm($[HANDLE hFile], $[DWORD dwFlags])

$~QueryInformationJobObject
$[BOOL ]QueryInformationJobObject($[HANDLE hJob], $[JOBOBJECTINFOCLASS JobObjectInfoClass], $[LPVOID lpJobObjectInfo], $[DWORD cbJobObjectInfoLength], $[LPDWORD lpReturnLength])

$~QueryMemoryResourceNotification
$[BOOL ]QueryMemoryResourceNotification($[HANDLE ResourceNotificationHandle], $[PBOOL ResourceState])

$~QueryPerformanceCounter
$[BOOL ]QueryPerformanceCounter($[LARGE_INTEGER *lpPerformanceCount])

$~QueryPerformanceFrequency
$[BOOL ]QueryPerformanceFrequency($[LARGE_INTEGER *lpFrequency])

$~QueueUserWorkItem
$[BOOL ]QueueUserWorkItem($[LPTHREAD_START_ROUTINE Function], $[PVOID Context], $[ULONG Flags])

$~ReadConsoleA
$[BOOL ]ReadConsoleA($[HANDLE hConsoleInput], $[LPVOID lpBuffer], $[DWORD nNumberOfCharsToRead], $[LPDWORD lpNumberOfCharsRead], $[LPVOID pInputControl])

$~ReadConsoleInputA
$[BOOL ]ReadConsoleInputA($[HANDLE hConsoleInput], $[PINPUT_RECORD lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsRead])

$~ReadConsoleInputW
$[BOOL ]ReadConsoleInputW($[HANDLE hConsoleInput], $[PINPUT_RECORD lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsRead])

$~ReadConsoleOutputA
$[BOOL ]ReadConsoleOutputA($[HANDLE hConsoleOutput], $[PCHAR_INFO lpBuffer], $[COORD dwBufferSize], $[COORD dwBufferCoord], $[PSMALL_RECT lpReadRegion])

$~ReadConsoleOutputAttribute
$[BOOL ]ReadConsoleOutputAttribute($[HANDLE hConsoleOutput], $[LPWORD lpAttribute], $[DWORD nLength], $[COORD dwReadCoord], $[LPDWORD lpNumberOfAttrsRead])

$~ReadConsoleOutputCharacterA
$[BOOL ]ReadConsoleOutputCharacterA($[HANDLE hConsoleOutput], $[LPSTR lpCharacter], $[DWORD nLength], $[COORD dwReadCoord], $[LPDWORD lpNumberOfCharsRead])

$~ReadConsoleOutputCharacterW
$[BOOL ]ReadConsoleOutputCharacterW($[HANDLE hConsoleOutput], $[LPWSTR lpCharacter], $[DWORD nLength], $[COORD dwReadCoord], $[LPDWORD lpNumberOfCharsRead])

$~ReadConsoleOutputW
$[BOOL ]ReadConsoleOutputW($[HANDLE hConsoleOutput], $[PCHAR_INFO lpBuffer], $[COORD dwBufferSize], $[COORD dwBufferCoord], $[PSMALL_RECT lpReadRegion])

$~ReadConsoleW
$[BOOL ]ReadConsoleW($[HANDLE hConsoleInput], $[LPVOID lpBuffer], $[DWORD nNumberOfCharsToRead], $[LPDWORD lpNumberOfCharsRead], $[LPVOID pInputControl])

$~ReadDirectoryChangesW
$[BOOL ]ReadDirectoryChangesW($[HANDLE hDirectory], $[LPVOID lpBuffer], $[DWORD nBufferLength], $[BOOL bWatchSubtree], $[DWORD dwNotifyFilter], $[LPDWORD lpBytesReturned], $[LPOVERLAPPED lpOverlapped], $[LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~ReadFile
$[BOOL ]ReadFile($[HANDLE hFile], $[LPVOID lpBuffer], $[DWORD nNumberOfBytesToRead], $[LPDWORD lpNumberOfBytesRead], $[LPOVERLAPPED lpOverlapped])

$~ReadFileEx
$[BOOL ]ReadFileEx($[HANDLE hFile], $[LPVOID lpBuffer], $[DWORD nNumberOfBytesToRead], $[LPOVERLAPPED lpOverlapped], $[LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~ReadFileScatter
$[BOOL ]ReadFileScatter($[HANDLE hFile], $[FILE_SEGMENT_ELEMENT* aSegmentArray], $[DWORD nNumberOfBytesToRead], $[LPDWORD lpReserved], $[LPOVERLAPPED lpOverlapped])

$~ReadProcessMemory
$[BOOL ]ReadProcessMemory($[HANDLE hProcess], $[LPCVOID lpBaseAddress], $[LPVOID lpBuffer], $[DWORD nSize], $[LPDWORD lpNumberOfBytesRead])

$~RegisterWaitForSingleObject
$[BOOL ]RegisterWaitForSingleObject($[PHANDLE phNewWaitObject], $[HANDLE hObject], $[WAITORTIMERCALLBACK Callback], $[PVOID Context], $[ULONG dwMilliseconds], $[ULONG dwFlags])

$~ReleaseMutex
$[BOOL ]ReleaseMutex($[HANDLE hMutex])

$~ReleaseSemaphore
$[BOOL ]ReleaseSemaphore($[HANDLE hSemaphore], $[LONG lReleaseCount], $[LPLONG lpPreviousCount])

$~RemoveDirectoryA
$[BOOL ]RemoveDirectoryA($[LPCSTR lpPathName])

$~RemoveDirectoryW
$[BOOL ]RemoveDirectoryW($[LPCWSTR lpPathName])

$~ReplaceFile
$[BOOL ]ReplaceFile($[LPCSTR lpReplacedFileName], $[LPCSTR lpReplacementFileName], $[LPCSTR lpBackupFileName], $[DWORD dwReplaceFlags], $[LPVOID lpExclude], $[LPVOID lpReserved])

$~ReplaceFileA
$[BOOL ]ReplaceFileA($[LPCSTR lpReplacedFileName], $[LPCSTR lpReplacementFileName], $[LPCSTR lpBackupFileName], $[DWORD dwReplaceFlags], $[LPVOID lpExclude], $[LPVOID lpReserved])

$~ReplaceFileW
$[BOOL ]ReplaceFileW($[LPCSTR lpReplacedFileName], $[LPCSTR lpReplacementFileName], $[LPCSTR lpBackupFileName], $[DWORD dwReplaceFlags], $[LPVOID lpExclude], $[LPVOID lpReserved])

$~RequestDeviceWakeup
$[BOOL ]RequestDeviceWakeup($[HANDLE hDevice])

$~RequestWakeupLatency
$[BOOL ]RequestWakeupLatency($[LATENCY_TIME latency])

$~ResetEvent
$[BOOL ]ResetEvent($[HANDLE hEvent])

$~ScrollConsoleScreenBufferA
$[BOOL ]ScrollConsoleScreenBufferA($[HANDLE hConsoleOutput], $[const SMALL_RECT* lpScrollRectangle], $[const SMALL_RECT* lpClipRectangle], $[COORD dwDestinationOrigin], $[const CHAR_INFO* lpFill])

$~ScrollConsoleScreenBufferW
$[BOOL ]ScrollConsoleScreenBufferW($[HANDLE hConsoleOutput], $[const SMALL_RECT* lpScrollRectangle], $[const SMALL_RECT* lpClipRectangle], $[COORD dwDestinationOrigin], $[const CHAR_INFO* lpFill])

$~SetCommBreak
$[BOOL ]SetCommBreak($[HANDLE hFile])

$~SetCommConfig
$[BOOL ]SetCommConfig($[HANDLE hCommDev], $[LPCOMMCONFIG lpCC], $[DWORD dwSize])

$~SetCommMask
$[BOOL ]SetCommMask($[HANDLE hFile], $[DWORD dwEvtMask])

$~SetCommState
$[BOOL ]SetCommState($[HANDLE hFile], $[LPDCB lpDCB])

$~SetCommTimeouts
$[BOOL ]SetCommTimeouts($[HANDLE hFile], $[LPCOMMTIMEOUTS lpCommTimeouts])

$~SetComputerNameA
$[BOOL ]SetComputerNameA($[LPCSTR lpComputerName])

$~SetComputerNameExA
$[BOOL ]SetComputerNameExA($[COMPUTER_NAME_FORMAT NameType], $[LPCSTR lpBuffer])

$~SetComputerNameExW
$[BOOL ]SetComputerNameExW($[COMPUTER_NAME_FORMAT NameType], $[LPCWSTR lpBuffer])

$~SetComputerNameW
$[BOOL ]SetComputerNameW($[LPCWSTR lpComputerName])

$~SetConsoleActiveScreenBuffer
$[BOOL ]SetConsoleActiveScreenBuffer($[HANDLE hConsoleOutput])

$~SetConsoleCP
$[BOOL ]SetConsoleCP($[UINT wCodePageID])

$~SetConsoleCtrlHandler
$[BOOL ]SetConsoleCtrlHandler($[PHANDLER_ROUTINE HandlerRoutine], $[BOOL Add])

$~SetConsoleCursorInfo
$[BOOL ]SetConsoleCursorInfo($[HANDLE hConsoleOutput], $[const CONSOLE_CURSOR_INFO* lpConsoleCursorInfo])

$~SetConsoleCursorPosition
$[BOOL ]SetConsoleCursorPosition($[HANDLE hConsoleOutput], $[COORD dwCursorPosition])

$~SetConsoleDisplayMode
$[BOOL ]SetConsoleDisplayMode($[HANDLE hConsoleOutput], $[DWORD dwFlags], $[PCOORD lpNewScreenBufferDimensions])

$~SetConsoleMode
$[BOOL ]SetConsoleMode($[HANDLE hConsoleHandle], $[DWORD dwMode])

$~SetConsoleOutputCP
$[BOOL ]SetConsoleOutputCP($[UINT wCodePageID])

$~SetConsoleScreenBufferSize
$[BOOL ]SetConsoleScreenBufferSize($[HANDLE hConsoleOutput], $[COORD dwSize])

$~SetConsoleTextAttribute
$[BOOL ]SetConsoleTextAttribute($[HANDLE hConsoleOutput], $[WORD wAttributes])

$~SetConsoleTitleA
$[BOOL ]SetConsoleTitleA($[LPCSTR lpConsoleTitle])

$~SetConsoleTitleW
$[BOOL ]SetConsoleTitleW($[LPCWSTR lpConsoleTitle])

$~SetConsoleWindowInfo
$[BOOL ]SetConsoleWindowInfo($[HANDLE hConsoleOutput], $[BOOL bAbsolute], $[const SMALL_RECT* lpConsoleWindow])

$~SetCurrentDirectoryA
$[BOOL ]SetCurrentDirectoryA($[LPCSTR lpPathName])

$~SetCurrentDirectoryW
$[BOOL ]SetCurrentDirectoryW($[LPCWSTR lpPathName])

$~SetDefaultCommConfigA
$[BOOL ]SetDefaultCommConfigA($[LPCSTR lpszName], $[LPCOMMCONFIG lpCC], $[DWORD dwSize])

$~SetDefaultCommConfigW
$[BOOL ]SetDefaultCommConfigW($[LPCWSTR lpszName], $[LPCOMMCONFIG lpCC], $[DWORD dwSize])

$~SetDllDirectoryA
$[BOOL ]SetDllDirectoryA($[LPCSTR lpPathName])

$~SetDllDirectoryW
$[BOOL ]SetDllDirectoryW($[LPCWSTR lpPathName])

$~SetEndOfFile
$[BOOL ]SetEndOfFile($[HANDLE hFile])

$~SetEnvironmentVariableA
$[BOOL ]SetEnvironmentVariableA($[LPCSTR lpName], $[LPCSTR lpValue])

$~SetEnvironmentVariableW
$[BOOL ]SetEnvironmentVariableW($[LPCWSTR lpName], $[LPCWSTR lpValue])

$~SetEvent
$[BOOL ]SetEvent($[HANDLE hEvent])

$~SetFileAttributesA
$[BOOL ]SetFileAttributesA($[LPCSTR lpFileName], $[DWORD dwFileAttributes])

$~SetFileAttributesW
$[BOOL ]SetFileAttributesW($[LPCWSTR lpFileName], $[DWORD dwFileAttributes])

$~SetFilePointerEx
$[BOOL ]SetFilePointerEx($[HANDLE hFile], $[LARGE_INTEGER liDistanceToMove], $[PLARGE_INTEGER lpNewFilePointer], $[DWORD dwMoveMethod])

$~SetFileShortNameA
$[BOOL ]SetFileShortNameA($[HANDLE hFile], $[LPCSTR lpShortName])

$~SetFileShortNameW
$[BOOL ]SetFileShortNameW($[HANDLE hFile], $[LPCWSTR lpShortName])

$~SetFileTime
$[BOOL ]SetFileTime($[HANDLE hFile], $[const FILETIME* lpCreationTime], $[const FILETIME* lpLastAccessTime], $[const FILETIME* lpLastWriteTime])

$~SetFileValidData
$[BOOL ]SetFileValidData($[HANDLE hFile], $[LONGLONG ValidDataLength])

$~SetFirmwareEnvironmentVariableA
$[BOOL ]SetFirmwareEnvironmentVariableA($[LPCSTR lpName], $[LPCSTR lpGuid], $[PVOID pBuffer], $[DWORD nSize])

$~SetFirmwareEnvironmentVariableW
$[BOOL ]SetFirmwareEnvironmentVariableW($[LPCWSTR lpName], $[LPCWSTR lpGuid], $[PVOID pBuffer], $[DWORD nSize])

$~SetHandleInformation
$[BOOL ]SetHandleInformation($[HANDLE hObject], $[DWORD dwMask], $[DWORD dwFlags])

$~SetInformationJobObject
$[BOOL ]SetInformationJobObject($[HANDLE hJob], $[JOBOBJECTINFOCLASS JobObjectInfoClass], $[LPVOID lpJobObjectInfo], $[DWORD cbJobObjectInfoLength])

$~SetLocaleInfoA
$[BOOL ]SetLocaleInfoA($[LCID Locale], $[LCTYPE LCType], $[LPCSTR lpLCData])

$~SetLocaleInfoW
$[BOOL ]SetLocaleInfoW($[LCID Locale], $[LCTYPE LCType], $[LPCWSTR lpLCData])

$~SetLocalTime
$[BOOL ]SetLocalTime($[const SYSTEMTIME* lpSystemTime])

$~SetMailslotInfo
$[BOOL ]SetMailslotInfo($[HANDLE hMailslot], $[DWORD lReadTimeout])

$~SetMessageWaitingIndicator
$[BOOL ]SetMessageWaitingIndicator($[IN HANDLE hIndicator], $[IN ULONG cmsg])

$~SetNamedPipeHandleState
$[BOOL ]SetNamedPipeHandleState($[HANDLE hNamedPipe], $[LPDWORD lpMode], $[LPDWORD lpMaxCollectionCount], $[LPDWORD lpCollectDataTimeout])

$~SetPriorityClass
$[BOOL ]SetPriorityClass($[HANDLE hProcess], $[DWORD dwPriorityClass])

$~SetProcessAffinityMask
$[BOOL ]SetProcessAffinityMask($[HANDLE hProcess], $[DWORD_PTR dwProcessAffinityMask])

$~SetProcessPriorityBoost
$[BOOL ]SetProcessPriorityBoost($[HANDLE hProcess], $[BOOL DisablePriorityBoost])

$~SetProcessShutdownParameters
$[BOOL ]SetProcessShutdownParameters($[DWORD dwLevel], $[DWORD dwFlags])

$~SetProcessWorkingSetSize
$[BOOL ]SetProcessWorkingSetSize($[HANDLE hProcess], $[SIZE_T dwMinimumWorkingSetSize], $[SIZE_T dwMaximumWorkingSetSize])

$~SetStdHandle
$[BOOL ]SetStdHandle($[DWORD nStdHandle], $[HANDLE hHandle])

$~SetSystemPowerState
$[BOOL ]SetSystemPowerState($[BOOL fSuspend], $[BOOL fForce])

$~SetSystemTime
$[BOOL ]SetSystemTime($[const SYSTEMTIME* lpSystemTime])

$~SetSystemTimeAdjustment
$[BOOL ]SetSystemTimeAdjustment($[DWORD dwTimeAdjustment], $[BOOL bTimeAdjustmentDisabled])

$~SetThreadContext
$[BOOL ]SetThreadContext($[HANDLE hThread], $[const CONTEXT* lpContext])

$~SetThreadLocale
$[BOOL ]SetThreadLocale($[LCID Locale])

$~SetThreadPriority
$[BOOL ]SetThreadPriority($[HANDLE hThread], $[int nPriority])

$~SetThreadPriorityBoost
$[BOOL ]SetThreadPriorityBoost($[HANDLE hThread], $[BOOL DisablePriorityBoost])

$~SetTimeZoneInformation
$[BOOL ]SetTimeZoneInformation($[const TIME_ZONE_INFORMATION* lpTimeZoneInformation])

$~SetupComm
$[BOOL ]SetupComm($[HANDLE hFile], $[DWORD dwInQueue], $[DWORD dwOutQueue])

$~SetUserGeoID
$[BOOL ]SetUserGeoID($[GEOID GeoID])

$~SetVolumeLabelA
$[BOOL ]SetVolumeLabelA($[LPCSTR lpRootPathName], $[LPCSTR lpVolumeName])

$~SetVolumeLabelW
$[BOOL ]SetVolumeLabelW($[LPCWSTR lpRootPathName], $[LPCWSTR lpVolumeName])

$~SetVolumeMountPointA
$[BOOL ]SetVolumeMountPointA($[LPCSTR lpszVolumeMountPoint], $[LPCSTR lpszVolumeName])

$~SetVolumeMountPointW
$[BOOL ]SetVolumeMountPointW($[LPCWSTR lpszVolumeMountPoint], $[LPCWSTR lpszVolumeName])

$~SetWaitableTimer
$[BOOL ]SetWaitableTimer($[HANDLE hTimer], $[const LARGE_INTEGER* pDueTime], $[LONG lPeriod], $[PTIMERAPCROUTINE pfnCompletionRoutine], $[LPVOID lpArgToCompletionRoutine], $[BOOL fResume])

$~SwitchToThread
$[BOOL ]SwitchToThread($[])

$~SystemTimeToFileTime
$[BOOL ]SystemTimeToFileTime($[const SYSTEMTIME* lpSystemTime], $[LPFILETIME lpFileTime])

$~SystemTimeToTzSpecificLocalTime
$[BOOL ]SystemTimeToTzSpecificLocalTime($[LPTIME_ZONE_INFORMATION lpTimeZone], $[LPSYSTEMTIME lpUniversalTime], $[LPSYSTEMTIME lpLocalTime])

$~TerminateJobObject
$[BOOL ]TerminateJobObject($[HANDLE hJob], $[UINT uExitCode])

$~TerminateProcess
$[BOOL ]TerminateProcess($[HANDLE hProcess], $[UINT uExitCode])

$~TerminateThread
$[BOOL ]TerminateThread($[HANDLE hThread], $[DWORD dwExitCode])

$~TermsrvAppInstallMode
$[BOOL ]TermsrvAppInstallMode($[])

$~Thread32First
$[BOOL ]Thread32First($[HANDLE hSnapshot], $[LPTHREADENTRY32 lpte])

$~Thread32Next
$[BOOL ]Thread32Next($[HANDLE hSnapshot], $[LPTHREADENTRY32 lpte])

$~TlsFree
$[BOOL ]TlsFree($[DWORD dwTlsIndex])

$~TlsSetValue
$[BOOL ]TlsSetValue($[DWORD dwTlsIndex], $[LPVOID lpTlsValue])

$~Toolhelp32ReadProcessMemory
$[BOOL ]Toolhelp32ReadProcessMemory($[DWORD th32ProcessID], $[LPCVOID lpBaseAddress], $[LPVOID lpBuffer], $[SIZE_T cbRead], $[SIZE_T lpNumberOfBytesRead])

$~TransactNamedPipe
$[BOOL ]TransactNamedPipe($[HANDLE hNamedPipe], $[LPVOID lpInBuffer], $[DWORD nInBufferSize], $[LPVOID lpOutBuffer], $[DWORD nOutBufferSize], $[LPDWORD lpBytesRead], $[LPOVERLAPPED lpOverlapped])

$~TransmitCommChar
$[BOOL ]TransmitCommChar($[HANDLE hFile], $[char cChar])

$~TryEnterCriticalSection
$[BOOL ]TryEnterCriticalSection($[LPCRITICAL_SECTION lpCriticalSection])

$~TzSpecificLocalTimeToSystemTime
$[BOOL ]TzSpecificLocalTimeToSystemTime($[LPTIME_ZONE_INFORMATION lpTimeZoneInformation], $[LPSYSTEMTIME lpLocalTime], $[LPSYSTEMTIME lpUniversalTime])

$~UnlockFile
$[BOOL ]UnlockFile($[HANDLE hFile], $[DWORD dwFileOffsetLow], $[DWORD dwFileOffsetHigh], $[DWORD nNumberOfBytesToUnlockLow], $[DWORD nNumberOfBytesToUnlockHigh])

$~UnlockFileEx
$[BOOL ]UnlockFileEx($[HANDLE hFile], $[DWORD dwReserved], $[DWORD nNumberOfBytesToUnlockLow], $[DWORD nNumberOfBytesToUnlockHigh], $[LPOVERLAPPED lpOverlapped])

$~UnmapViewOfFile
$[BOOL ]UnmapViewOfFile($[LPCVOID lpBaseAddress])

$~UnregisterWait
$[BOOL ]UnregisterWait($[HANDLE WaitHandle])

$~UnregisterWaitEx
$[BOOL ]UnregisterWaitEx($[HANDLE WaitHandle], $[HANDLE CompletionEvent])

$~UpdateResourceA
$[BOOL ]UpdateResourceA($[HANDLE hUpdate], $[LPCSTR lpType], $[LPCSTR lpName], $[WORD wLanguage], $[LPVOID lpData], $[DWORD cbData])

$~UpdateResourceW
$[BOOL ]UpdateResourceW($[HANDLE hUpdate], $[LPCWSTR lpType], $[LPCWSTR lpName], $[WORD wLanguage], $[LPVOID lpData], $[DWORD cbData])

$~UTRegister
$[BOOL ]UTRegister($[HANDLE hModule], $[LPCSTR lpsz16BitDLL], $[LPCSTR lpszInitName], $[LPCSTR lpszProcName], $[UT32PROC* ppfn32Thunk], $[FARPROC pfnUT32Callback], $[LPVOID lpBuff])

$~VerifyVersionInfoA
$[BOOL ]VerifyVersionInfoA($[LPOSVERSIONINFOEXA lpVersionInfo], $[DWORD dwTypeMask], $[DWORDLONG dwlConditionMask])

$~VerifyVersionInfoW
$[BOOL ]VerifyVersionInfoW($[LPOSVERSIONINFOEXW lpVersionInfo], $[DWORD dwTypeMask], $[DWORDLONG dwlConditionMask])

$~VirtualFree
$[BOOL ]VirtualFree($[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD dwFreeType])

$~VirtualFreeEx
$[BOOL ]VirtualFreeEx($[HANDLE hProcess], $[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD dwFreeType])

$~VirtualLock
$[BOOL ]VirtualLock($[LPVOID lpAddress], $[SIZE_T dwSize])

$~VirtualProtect
$[BOOL ]VirtualProtect($[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD flNewProtect], $[PDWORD lpflOldProtect])

$~VirtualProtectEx
$[BOOL ]VirtualProtectEx($[HANDLE hProcess], $[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD flNewProtect], $[PDWORD lpflOldProtect])

$~VirtualUnlock
$[BOOL ]VirtualUnlock($[LPVOID lpAddress], $[SIZE_T dwSize])

$~WaitCommEvent
$[BOOL ]WaitCommEvent($[HANDLE hFile], $[LPDWORD lpEvtMask], $[LPOVERLAPPED lpOverlapped])

$~WaitForDebugEvent
$[BOOL ]WaitForDebugEvent($[LPDEBUG_EVENT lpDebugEvent], $[DWORD dwMilliseconds])

$~WaitNamedPipeA
$[BOOL ]WaitNamedPipeA($[LPCSTR lpNamedPipeName], $[DWORD nTimeOut])

$~WaitNamedPipeW
$[BOOL ]WaitNamedPipeW($[LPCWSTR lpNamedPipeName], $[DWORD nTimeOut])

$~WriteConsoleA
$[BOOL ]WriteConsoleA($[HANDLE hConsoleOutput], $[const VOID* lpBuffer], $[DWORD nNumberOfCharsToWrite], $[LPDWORD lpNumberOfCharsWritten], $[LPVOID lpReserved])

$~WriteConsoleInputA
$[BOOL ]WriteConsoleInputA($[HANDLE hConsoleInput], $[const INPUT_RECORD* lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsWritten])

$~WriteConsoleInputW
$[BOOL ]WriteConsoleInputW($[HANDLE hConsoleInput], $[const INPUT_RECORD* lpBuffer], $[DWORD nLength], $[LPDWORD lpNumberOfEventsWritten])

$~WriteConsoleOutputA
$[BOOL ]WriteConsoleOutputA($[HANDLE hConsoleOutput], $[const CHAR_INFO* lpBuffer], $[COORD dwBufferSize], $[COORD dwBufferCoord], $[PSMALL_RECT lpWriteRegion])

$~WriteConsoleOutputAttribute
$[BOOL ]WriteConsoleOutputAttribute($[HANDLE hConsoleOutput], $[const WORD* lpAttribute], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfAttrsWritten])

$~WriteConsoleOutputCharacterA
$[BOOL ]WriteConsoleOutputCharacterA($[HANDLE hConsoleOutput], $[LPCSTR lpCharacter], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfCharsWritten])

$~WriteConsoleOutputCharacterW
$[BOOL ]WriteConsoleOutputCharacterW($[HANDLE hConsoleOutput], $[LPCWSTR lpCharacter], $[DWORD nLength], $[COORD dwWriteCoord], $[LPDWORD lpNumberOfCharsWritten])

$~WriteConsoleOutputW
$[BOOL ]WriteConsoleOutputW($[HANDLE hConsoleOutput], $[const CHAR_INFO* lpBuffer], $[COORD dwBufferSize], $[COORD dwBufferCoord], $[PSMALL_RECT lpWriteRegion])

$~WriteConsoleW
$[BOOL ]WriteConsoleW($[HANDLE hConsoleOutput], $[const VOID* lpBuffer], $[DWORD nNumberOfCharsToWrite], $[LPDWORD lpNumberOfCharsWritten], $[LPVOID lpReserved])

$~WriteFile
$[BOOL ]WriteFile($[HANDLE hFile], $[LPCVOID lpBuffer], $[DWORD nNumberOfBytesToWrite], $[LPDWORD lpNumberOfBytesWritten], $[LPOVERLAPPED lpOverlapped])

$~WriteFileEx
$[BOOL ]WriteFileEx($[HANDLE hFile], $[LPCVOID lpBuffer], $[DWORD nNumberOfBytesToWrite], $[LPOVERLAPPED lpOverlapped], $[LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WriteFileGather
$[BOOL ]WriteFileGather($[HANDLE hFile], $[FILE_SEGMENT_ELEMENT* aSegmentArray], $[DWORD nNumberOfBytesToWrite], $[LPDWORD lpReserved], $[LPOVERLAPPED lpOverlapped])

$~WritePrivateProfileSectionA
$[BOOL ]WritePrivateProfileSectionA($[LPCSTR lpAppName], $[LPCSTR lpString], $[LPCSTR lpFileName])

$~WritePrivateProfileSectionW
$[BOOL ]WritePrivateProfileSectionW($[LPCWSTR lpAppName], $[LPCWSTR lpString], $[LPCWSTR lpFileName])

$~WritePrivateProfileStringA
$[BOOL ]WritePrivateProfileStringA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[LPCSTR lpString], $[LPCSTR lpFileName])

$~WritePrivateProfileStringW
$[BOOL ]WritePrivateProfileStringW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[LPCWSTR lpString], $[LPCWSTR lpFileName])

$~WritePrivateProfileStructA
$[BOOL ]WritePrivateProfileStructA($[LPCSTR lpszSection], $[LPCSTR lpszKey], $[LPVOID lpStruct], $[UINT uSizeStruct], $[LPCSTR szFile])

$~WritePrivateProfileStructW
$[BOOL ]WritePrivateProfileStructW($[LPCWSTR lpszSection], $[LPCWSTR lpszKey], $[LPVOID lpStruct], $[UINT uSizeStruct], $[LPCWSTR szFile])

$~WriteProcessMemory
$[BOOL ]WriteProcessMemory($[HANDLE hProcess], $[LPVOID lpBaseAddress], $[LPVOID lpBuffer], $[DWORD nSize], $[LPDWORD lpNumberOfBytesWritten])

$~WriteProfileSectionA
$[BOOL ]WriteProfileSectionA($[LPCSTR lpAppName], $[LPCSTR lpString])

$~WriteProfileSectionW
$[BOOL ]WriteProfileSectionW($[LPCWSTR lpAppName], $[LPCWSTR lpString])

$~WriteProfileStringA
$[BOOL ]WriteProfileStringA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[LPCSTR lpString])

$~WriteProfileStringW
$[BOOL ]WriteProfileStringW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[LPCWSTR lpString])

$~ZombifyActCtx
$[BOOL ]ZombifyActCtx($[HANDLE hActCtx])

$~GetConsoleFontSize
$[COORD ]GetConsoleFontSize($[HANDLE hConsoleOutput], $[DWORD nFont])

$~GetLargestConsoleWindowSize
$[COORD ]GetLargestConsoleWindowSize($[HANDLE hConsoleOutput])

$~AddLocalAlternateComputerNameA
$[DWORD ]AddLocalAlternateComputerNameA($[LPCSTR lpDnsFQHostname], $[ULONG ulFlags])

$~AddLocalAlternateComputerNameW
$[DWORD ]AddLocalAlternateComputerNameW($[LPCWSTR lpDnsFQHostname], $[ULONG ulFlags])

$~CreateTapePartition
$[DWORD ]CreateTapePartition($[HANDLE hDevice], $[DWORD dwPartitionMethod], $[DWORD dwCount], $[DWORD dwSize])

$~EraseTape
$[DWORD ]EraseTape($[HANDLE hDevice], $[DWORD dwEraseType], $[BOOL bImmediate])

$~ExpandEnvironmentStringsA
$[DWORD ]ExpandEnvironmentStringsA($[LPCSTR lpSrc], $[LPSTR lpDst], $[DWORD nSize])

$~ExpandEnvironmentStringsW
$[DWORD ]ExpandEnvironmentStringsW($[LPCWSTR lpSrc], $[LPWSTR lpDst], $[DWORD nSize])

$~FormatMessageA
$[DWORD ]FormatMessageA($[DWORD dwFlags], $[LPCVOID lpSource], $[DWORD dwMessageId], $[DWORD dwLanguageId], $[LPSTR lpBuffer], $[DWORD nSize], $[va_list* Arguments])

$~FormatMessageW
$[DWORD ]FormatMessageW($[DWORD dwFlags], $[LPCVOID lpSource], $[DWORD dwMessageId], $[DWORD dwLanguageId], $[LPWSTR lpBuffer], $[DWORD nSize], $[va_list* Arguments])

$~GetCompressedFileSizeA
$[DWORD ]GetCompressedFileSizeA($[LPCSTR lpFileName], $[LPDWORD lpFileSizeHigh])

$~GetCompressedFileSizeW
$[DWORD ]GetCompressedFileSizeW($[LPCWSTR lpFileName], $[LPDWORD lpFileSizeHigh])

$~GetConsoleAliasA
$[DWORD ]GetConsoleAliasA($[LPSTR lpSource], $[LPSTR lpTargetBuffer], $[DWORD TargetBufferLength], $[LPSTR lpExeName])

$~GetConsoleAliasesA
$[DWORD ]GetConsoleAliasesA($[LPSTR lpAliasBuffer], $[DWORD AliasBufferLength], $[LPSTR lpExeName])

$~GetConsoleAliasesLengthA
$[DWORD ]GetConsoleAliasesLengthA($[LPSTR lpExeName])

$~GetConsoleAliasesLengthW
$[DWORD ]GetConsoleAliasesLengthW($[LPWSTR lpExeName])

$~GetConsoleAliasesW
$[DWORD ]GetConsoleAliasesW($[LPWSTR lpAliasBuffer], $[DWORD AliasBufferLength], $[LPWSTR lpExeName])

$~GetConsoleAliasExesA
$[DWORD ]GetConsoleAliasExesA($[LPSTR lpExeNameBuffer], $[DWORD ExeNameBufferLength])

$~GetConsoleAliasExesLengthA
$[DWORD ]GetConsoleAliasExesLengthA($[])

$~GetConsoleAliasExesLengthW
$[DWORD ]GetConsoleAliasExesLengthW($[])

$~GetConsoleAliasExesW
$[DWORD ]GetConsoleAliasExesW($[LPWSTR lpExeNameBuffer], $[DWORD ExeNameBufferLength])

$~GetConsoleAliasW
$[DWORD ]GetConsoleAliasW($[LPWSTR lpSource], $[LPWSTR lpTargetBuffer], $[DWORD TargetBufferLength], $[LPWSTR lpExeName])

$~GetConsoleProcessList
$[DWORD ]GetConsoleProcessList($[LPDWORD lpdwProcessList], $[DWORD dwProcessCount])

$~GetConsoleTitleA
$[DWORD ]GetConsoleTitleA($[LPSTR lpConsoleTitle], $[DWORD nSize])

$~GetConsoleTitleW
$[DWORD ]GetConsoleTitleW($[LPWSTR lpConsoleTitle], $[DWORD nSize])

$~GetCurrentDirectoryA
$[DWORD ]GetCurrentDirectoryA($[DWORD nBufferLength], $[LPSTR lpBuffer])

$~GetCurrentDirectoryW
$[DWORD ]GetCurrentDirectoryW($[DWORD nBufferLength], $[LPWSTR lpBuffer])

$~GetCurrentProcessId
$[DWORD ]GetCurrentProcessId($[])

$~GetCurrentThreadId
$[DWORD ]GetCurrentThreadId($[])

$~GetDllDirectoryA
$[DWORD ]GetDllDirectoryA($[DWORD nBufferLength], $[LPSTR lpBuffer])

$~GetDllDirectoryW
$[DWORD ]GetDllDirectoryW($[DWORD nBufferLength], $[LPWSTR lpBuffer])

$~GetEnvironmentVariableA
$[DWORD ]GetEnvironmentVariableA($[LPCSTR lpName], $[LPSTR lpBuffer], $[DWORD nSize])

$~GetEnvironmentVariableW
$[DWORD ]GetEnvironmentVariableW($[LPCWSTR lpName], $[LPWSTR lpBuffer], $[DWORD nSize])

$~GetFileAttributesA
$[DWORD ]GetFileAttributesA($[LPCSTR lpFileName])

$~GetFileAttributesW
$[DWORD ]GetFileAttributesW($[LPCWSTR lpFileName])

$~GetFileSize
$[DWORD ]GetFileSize($[HANDLE hFile], $[LPDWORD lpFileSizeHigh])

$~GetFileType
$[DWORD ]GetFileType($[HANDLE hFile])

$~GetFirmwareEnvironmentVariableA
$[DWORD ]GetFirmwareEnvironmentVariableA($[LPCSTR lpName], $[LPCSTR lpGuid], $[PVOID pBuffer], $[DWORD nSize])

$~GetFirmwareEnvironmentVariableW
$[DWORD ]GetFirmwareEnvironmentVariableW($[LPCWSTR lpName], $[LPCWSTR lpGuid], $[PVOID pBuffer], $[DWORD nSize])

$~GetFullPathNameA
$[DWORD ]GetFullPathNameA($[LPCSTR lpFileName], $[DWORD nBufferLength], $[LPSTR lpBuffer], $[LPSTR* lpFilePart])

$~GetFullPathNameW
$[DWORD ]GetFullPathNameW($[LPCWSTR lpFileName], $[DWORD nBufferLength], $[LPWSTR lpBuffer], $[LPWSTR* lpFilePart])

$~GetLastError
$[DWORD ]GetLastError($[])

$~GetLogicalDrives
$[DWORD ]GetLogicalDrives($[])

$~GetLogicalDriveStringsA
$[DWORD ]GetLogicalDriveStringsA($[DWORD nBufferLength], $[LPSTR lpBuffer])

$~GetLogicalDriveStringsW
$[DWORD ]GetLogicalDriveStringsW($[DWORD nBufferLength], $[LPWSTR lpBuffer])

$~GetLongPathNameA
$[DWORD ]GetLongPathNameA($[LPCSTR lpszShortPath], $[LPSTR lpszLongPath], $[DWORD cchBuffer])

$~GetLongPathNameW
$[DWORD ]GetLongPathNameW($[LPCWSTR lpszShortPath], $[LPWSTR lpszLongPath], $[DWORD cchBuffer])

$~GetModuleFileNameA
$[DWORD ]GetModuleFileNameA($[HMODULE hModule], $[LPSTR lpFilename], $[DWORD nSize])

$~GetModuleFileNameW
$[DWORD ]GetModuleFileNameW($[HMODULE hModule], $[LPWSTR lpFilename], $[DWORD nSize])

$~GetPriorityClass
$[DWORD ]GetPriorityClass($[HANDLE hProcess])

$~GetPrivateProfileSectionA
$[DWORD ]GetPrivateProfileSectionA($[LPCSTR lpAppName], $[LPSTR lpReturnedString], $[DWORD nSize], $[LPCSTR lpFileName])

$~GetPrivateProfileSectionNamesA
$[DWORD ]GetPrivateProfileSectionNamesA($[LPSTR lpszReturnBuffer], $[DWORD nSize], $[LPCSTR lpFileName])

$~GetPrivateProfileSectionNamesW
$[DWORD ]GetPrivateProfileSectionNamesW($[LPWSTR lpszReturnBuffer], $[DWORD nSize], $[LPCWSTR lpFileName])

$~GetPrivateProfileSectionW
$[DWORD ]GetPrivateProfileSectionW($[LPCWSTR lpAppName], $[LPWSTR lpReturnedString], $[DWORD nSize], $[LPCWSTR lpFileName])

$~GetPrivateProfileStringA
$[DWORD ]GetPrivateProfileStringA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[LPCSTR lpDefault], $[LPSTR lpReturnedString], $[DWORD nSize], $[LPCSTR lpFileName])

$~GetPrivateProfileStringW
$[DWORD ]GetPrivateProfileStringW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[LPCWSTR lpDefault], $[LPWSTR lpReturnedString], $[DWORD nSize], $[LPCWSTR lpFileName])

$~GetProcessHeaps
$[DWORD ]GetProcessHeaps($[DWORD NumberOfHeaps], $[PHANDLE ProcessHeaps])

$~GetProcessId
$[DWORD ]GetProcessId($[HANDLE Process])

$~GetProcessVersion
$[DWORD ]GetProcessVersion($[DWORD ProcessId])

$~GetProfileSectionA
$[DWORD ]GetProfileSectionA($[LPCSTR lpAppName], $[LPSTR lpReturnedString], $[DWORD nSize])

$~GetProfileSectionW
$[DWORD ]GetProfileSectionW($[LPCWSTR lpAppName], $[LPWSTR lpReturnedString], $[DWORD nSize])

$~GetProfileStringA
$[DWORD ]GetProfileStringA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[LPCSTR lpDefault], $[LPSTR lpReturnedString], $[DWORD nSize])

$~GetProfileStringW
$[DWORD ]GetProfileStringW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[LPCWSTR lpDefault], $[LPWSTR lpReturnedString], $[DWORD nSize])

$~GetShortPathNameA
$[DWORD ]GetShortPathNameA($[LPCSTR lpszLongPath], $[LPSTR lpszShortPath], $[DWORD cchBuffer])

$~GetShortPathNameW
$[DWORD ]GetShortPathNameW($[LPCWSTR lpszLongPath], $[LPWSTR lpszShortPath], $[DWORD cchBuffer])

$~GetTapeParameters
$[DWORD ]GetTapeParameters($[HANDLE hDevice], $[DWORD dwOperation], $[LPDWORD lpdwSize], $[LPVOID lpTapeInformation])

$~GetTapePosition
$[DWORD ]GetTapePosition($[HANDLE hDevice], $[DWORD dwPositionType], $[LPDWORD lpdwPartition], $[LPDWORD lpdwOffsetLow], $[LPDWORD lpdwOffsetHigh])

$~GetTapeStatus
$[DWORD ]GetTapeStatus($[HANDLE hDevice])

$~GetTempPathA
$[DWORD ]GetTempPathA($[DWORD nBufferLength], $[LPSTR lpBuffer])

$~GetTempPathW
$[DWORD ]GetTempPathW($[DWORD nBufferLength], $[LPWSTR lpBuffer])

$~GetTickCount
$[DWORD ]GetTickCount($[])

$~GetTimeZoneInformation
$[DWORD ]GetTimeZoneInformation($[LPTIME_ZONE_INFORMATION lpTimeZoneInformation])

$~GetVersion
$[DWORD ]GetVersion($[])

$~LoadModule
$[DWORD ]LoadModule($[LPCSTR lpModuleName], $[LPVOID lpParameterBlock])

$~PrepareTape
$[DWORD ]PrepareTape($[HANDLE hDevice], $[DWORD dwOperation], $[BOOL bImmediate])

$~QueryDosDeviceA
$[DWORD ]QueryDosDeviceA($[LPCSTR lpDeviceName], $[LPSTR lpTargetPath], $[DWORD ucchMax])

$~QueryDosDeviceW
$[DWORD ]QueryDosDeviceW($[LPCWSTR lpDeviceName], $[LPWSTR lpTargetPath], $[DWORD ucchMax])

$~QueueUserAPC
$[DWORD ]QueueUserAPC($[PAPCFUNC pfnAPC], $[HANDLE hThread], $[ULONG_PTR dwData])

$~ResumeThread
$[DWORD ]ResumeThread($[HANDLE hThread])

$~SearchPathA
$[DWORD ]SearchPathA($[LPCSTR lpPath], $[LPCSTR lpFileName], $[LPCSTR lpExtension], $[DWORD nBufferLength], $[LPSTR lpBuffer], $[LPSTR* lpFilePart])

$~SearchPathW
$[DWORD ]SearchPathW($[LPCWSTR lpPath], $[LPCWSTR lpFileName], $[LPCWSTR lpExtension], $[DWORD nBufferLength], $[LPWSTR lpBuffer], $[LPWSTR* lpFilePart])

$~SetCriticalSectionSpinCount
$[DWORD ]SetCriticalSectionSpinCount($[LPCRITICAL_SECTION lpCriticalSection], $[DWORD dwSpinCount])

$~SetFilePointer
$[DWORD ]SetFilePointer($[HANDLE hFile], $[LONG lDistanceToMove], $[PLONG lpDistanceToMoveHigh], $[DWORD dwMoveMethod])

$~SetTapeParameters
$[DWORD ]SetTapeParameters($[HANDLE hDevice], $[DWORD dwOperation], $[LPVOID lpTapeInformation])

$~SetTapePosition
$[DWORD ]SetTapePosition($[HANDLE hDevice], $[DWORD dwPositionMethod], $[DWORD dwPartition], $[DWORD dwOffsetLow], $[DWORD dwOffsetHigh], $[BOOL bImmediate])

$~SetThreadIdealProcessor
$[DWORD ]SetThreadIdealProcessor($[HANDLE hThread], $[DWORD dwIdealProcessor])

$~SignalObjectAndWait
$[DWORD ]SignalObjectAndWait($[HANDLE hObjectToSignal], $[HANDLE hObjectToWaitOn], $[DWORD dwMilliseconds], $[BOOL bAlertable])

$~SizeofResource
$[DWORD ]SizeofResource($[HMODULE hModule], $[HRSRC hResInfo])

$~SleepEx
$[DWORD ]SleepEx($[DWORD dwMilliseconds], $[BOOL bAlertable])

$~SuspendThread
$[DWORD ]SuspendThread($[HANDLE hThread])

$~TlsAlloc
$[DWORD ]TlsAlloc($[])

$~VerLanguageNameA
$[DWORD ]VerLanguageNameA($[DWORD wLang], $[LPSTR szLang], $[DWORD nSize])

$~VerLanguageNameW
$[DWORD ]VerLanguageNameW($[DWORD wLang], $[LPWSTR szLang], $[DWORD nSize])

$~WaitForMultipleObjects
$[DWORD ]WaitForMultipleObjects($[DWORD nCount], $[const HANDLE* lpHandles], $[BOOL bWaitAll], $[DWORD dwMilliseconds])

$~WaitForMultipleObjectsEx
$[DWORD ]WaitForMultipleObjectsEx($[DWORD nCount], $[const HANDLE* lpHandles], $[BOOL bWaitAll], $[DWORD dwMilliseconds], $[BOOL bAlertable])

$~WaitForSingleObject
$[DWORD ]WaitForSingleObject($[HANDLE hHandle], $[DWORD dwMilliseconds])

$~WaitForSingleObjectEx
$[DWORD ]WaitForSingleObjectEx($[HANDLE hHandle], $[DWORD dwMilliseconds], $[BOOL bAlertable])

$~WriteTapemark
$[DWORD ]WriteTapemark($[HANDLE hDevice], $[DWORD dwTapemarkType], $[DWORD dwTapemarkCount], $[BOOL bImmediate])

$~WTSGetActiveConsoleSessionId
$[DWORD ]WTSGetActiveConsoleSessionId($[])

$~SetThreadAffinityMask
$[DWORD_PTR ]SetThreadAffinityMask($[HANDLE hThread], $[DWORD_PTR dwThreadAffinityMask])

$~SetThreadExecutionState
$[EXECUTION_STATE ]SetThreadExecutionState($[EXECUTION_STATE esFlags])

$~GetProcAddress
$[FARPROC ]GetProcAddress($[HMODULE hModule], $[LPCSTR lpProcName])

$~GetUserGeoID
$[GEOID ]GetUserGeoID($[GEOCLASS GeoClass])

$~BeginUpdateResourceA
$[HANDLE ]BeginUpdateResourceA($[LPCSTR pFileName], $[BOOL bDeleteExistingResources])

$~BeginUpdateResourceW
$[HANDLE ]BeginUpdateResourceW($[LPCWSTR pFileName], $[BOOL bDeleteExistingResources])

$~CreateActCtxA
$[HANDLE ]CreateActCtxA($[PACTCTX pActCtx])

$~CreateActCtxW
$[HANDLE ]CreateActCtxW($[PACTCTX pActCtx])

$~CreateConsoleScreenBuffer
$[HANDLE ]CreateConsoleScreenBuffer($[DWORD dwDesiredAccess], $[DWORD dwShareMode], $[const SECURITY_ATTRIBUTES* lpSecurityAttributes], $[DWORD dwFlags], $[LPVOID lpScreenBufferData])

$~CreateEventA
$[HANDLE ]CreateEventA($[LPSECURITY_ATTRIBUTES lpEventAttributes], $[BOOL bManualReset], $[BOOL bInitialState], $[LPCSTR lpName])

$~CreateEventW
$[HANDLE ]CreateEventW($[LPSECURITY_ATTRIBUTES lpEventAttributes], $[BOOL bManualReset], $[BOOL bInitialState], $[LPCWSTR lpName])

$~CreateFileA
$[HANDLE ]CreateFileA($[LPCSTR lpFileName], $[DWORD dwDesiredAccess], $[DWORD dwShareMode], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[DWORD dwCreationDisposition], $[DWORD dwFlagsAndAttributes], $[HANDLE hTemplateFile])

$~CreateFileMappingA
$[HANDLE ]CreateFileMappingA($[HANDLE hFile], $[LPSECURITY_ATTRIBUTES lpAttributes], $[DWORD flProtect], $[DWORD dwMaximumSizeHigh], $[DWORD dwMaximumSizeLow], $[LPCSTR lpName])

$~CreateFileMappingW
$[HANDLE ]CreateFileMappingW($[HANDLE hFile], $[LPSECURITY_ATTRIBUTES lpAttributes], $[DWORD flProtect], $[DWORD dwMaximumSizeHigh], $[DWORD dwMaximumSizeLow], $[LPCWSTR lpName])

$~CreateFileW
$[HANDLE ]CreateFileW($[LPCWSTR lpFileName], $[DWORD dwDesiredAccess], $[DWORD dwShareMode], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes], $[DWORD dwCreationDisposition], $[DWORD dwFlagsAndAttributes], $[HANDLE hTemplateFile])

$~CreateIoCompletionPort
$[HANDLE ]CreateIoCompletionPort($[HANDLE FileHandle], $[HANDLE ExistingCompletionPort], $[ULONG_PTR CompletionKey], $[DWORD NumberOfConcurrentThreads])

$~CreateJobObjectA
$[HANDLE ]CreateJobObjectA($[LPSECURITY_ATTRIBUTES lpJobAttributes], $[LPCSTR lpName])

$~CreateJobObjectW
$[HANDLE ]CreateJobObjectW($[LPSECURITY_ATTRIBUTES lpJobAttributes], $[LPCWSTR lpName])

$~CreateMailslotA
$[HANDLE ]CreateMailslotA($[LPCSTR lpName], $[DWORD nMaxMessageSize], $[DWORD lReadTimeout], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateMailslotW
$[HANDLE ]CreateMailslotW($[LPCWSTR lpName], $[DWORD nMaxMessageSize], $[DWORD lReadTimeout], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateMemoryResourceNotification
$[HANDLE ]CreateMemoryResourceNotification($[MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType])

$~CreateMutexA
$[HANDLE ]CreateMutexA($[LPSECURITY_ATTRIBUTES lpMutexAttributes], $[BOOL bInitialOwner], $[LPCSTR lpName])

$~CreateMutexW
$[HANDLE ]CreateMutexW($[LPSECURITY_ATTRIBUTES lpMutexAttributes], $[BOOL bInitialOwner], $[LPCWSTR lpName])

$~CreateNamedPipeA
$[HANDLE ]CreateNamedPipeA($[LPCSTR lpName], $[DWORD dwOpenMode], $[DWORD dwPipeMode], $[DWORD nMaxInstances], $[DWORD nOutBufferSize], $[DWORD nInBufferSize], $[DWORD nDefaultTimeOut], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateNamedPipeW
$[HANDLE ]CreateNamedPipeW($[LPCWSTR lpName], $[DWORD dwOpenMode], $[DWORD dwPipeMode], $[DWORD nMaxInstances], $[DWORD nOutBufferSize], $[DWORD nInBufferSize], $[DWORD nDefaultTimeOut], $[LPSECURITY_ATTRIBUTES lpSecurityAttributes])

$~CreateRemoteThread
$[HANDLE ]CreateRemoteThread($[HANDLE hProcess], $[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[SIZE_T dwStackSize], $[LPTHREAD_START_ROUTINE lpStartAddress], $[LPVOID lpParameter], $[DWORD dwCreationFlags], $[LPDWORD lpThreadId])

$~CreateSemaphoreA
$[HANDLE ]CreateSemaphoreA($[LPSECURITY_ATTRIBUTES lpSemaphoreAttributes], $[LONG lInitialCount], $[LONG lMaximumCount], $[LPCSTR lpName])

$~CreateSemaphoreW
$[HANDLE ]CreateSemaphoreW($[LPSECURITY_ATTRIBUTES lpSemaphoreAttributes], $[LONG lInitialCount], $[LONG lMaximumCount], $[LPCWSTR lpName])

$~CreateThread
$[HANDLE ]CreateThread($[LPSECURITY_ATTRIBUTES lpThreadAttributes], $[SIZE_T dwStackSize], $[LPTHREAD_START_ROUTINE lpStartAddress], $[LPVOID lpParameter], $[DWORD dwCreationFlags], $[LPDWORD lpThreadId])

$~CreateTimerQueue
$[HANDLE ]CreateTimerQueue($[])

$~CreateToolhelp32Snapshot
$[HANDLE ]CreateToolhelp32Snapshot($[DWORD dwFlags], $[DWORD th32ProcessID])

$~CreateWaitableTimerA
$[HANDLE ]CreateWaitableTimerA($[LPSECURITY_ATTRIBUTES lpTimerAttributes], $[BOOL bManualReset], $[LPCSTR lpTimerName])

$~CreateWaitableTimerW
$[HANDLE ]CreateWaitableTimerW($[LPSECURITY_ATTRIBUTES lpTimerAttributes], $[BOOL bManualReset], $[LPCWSTR lpTimerName])

$~FindFirstChangeNotificationA
$[HANDLE ]FindFirstChangeNotificationA($[LPCSTR lpPathName], $[BOOL bWatchSubtree], $[DWORD dwNotifyFilter])

$~FindFirstChangeNotificationW
$[HANDLE ]FindFirstChangeNotificationW($[LPCWSTR lpPathName], $[BOOL bWatchSubtree], $[DWORD dwNotifyFilter])

$~FindFirstFileA
$[HANDLE ]FindFirstFileA($[LPCSTR lpFileName], $[LPWIN32_FIND_DATA lpFindFileData])

$~FindFirstFileExA
$[HANDLE ]FindFirstFileExA($[LPCSTR lpFileName], $[FINDEX_INFO_LEVELS fInfoLevelId], $[LPWIN32_FIND_DATA lpFindFileData], $[FINDEX_SEARCH_OPS fSearchOp], $[LPVOID lpSearchFilter], $[DWORD dwAdditionalFlags])

$~FindFirstFileExW
$[HANDLE ]FindFirstFileExW($[LPCWSTR lpFileName], $[FINDEX_INFO_LEVELS fInfoLevelId], $[LPWIN32_FIND_DATAW lpFindFileData], $[FINDEX_SEARCH_OPS fSearchOp], $[LPVOID lpSearchFilter], $[DWORD dwAdditionalFlags])

$~FindFirstFileW
$[HANDLE ]FindFirstFileW($[LPCWSTR lpFileName], $[LPWIN32_FIND_DATAW lpFindFileData])

$~FindFirstVolumeA
$[HANDLE ]FindFirstVolumeA($[LPSTR lpszVolumeName], $[DWORD cchBufferLength])

$~FindFirstVolumeMountPointA
$[HANDLE ]FindFirstVolumeMountPointA($[LPSTR lpszRootPathName], $[LPSTR lpszVolumeMountPoint], $[DWORD cchBufferLength])

$~FindFirstVolumeMountPointW
$[HANDLE ]FindFirstVolumeMountPointW($[LPWSTR lpszRootPathName], $[LPWSTR lpszVolumeMountPoint], $[DWORD cchBufferLength])

$~FindFirstVolumeW
$[HANDLE ]FindFirstVolumeW($[LPWSTR lpszVolumeName], $[DWORD cchBufferLength])

$~GetCurrentProcess
$[HANDLE ]GetCurrentProcess($[])

$~GetCurrentThread
$[HANDLE ]GetCurrentThread($[])

$~GetProcessHeap
$[HANDLE ]GetProcessHeap($[])

$~GetStdHandle
$[HANDLE ]GetStdHandle($[DWORD nStdHandle])

$~HeapCreate
$[HANDLE ]HeapCreate($[DWORD flOptions], $[SIZE_T dwInitialSize], $[SIZE_T dwMaximumSize])

$~OpenEventA
$[HANDLE ]OpenEventA($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCSTR lpName])

$~OpenEventW
$[HANDLE ]OpenEventW($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCWSTR lpName])

$~OpenFileMappingA
$[HANDLE ]OpenFileMappingA($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCSTR lpName])

$~OpenFileMappingW
$[HANDLE ]OpenFileMappingW($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCWSTR lpName])

$~OpenJobObjectA
$[HANDLE ]OpenJobObjectA($[DWORD dwDesiredAccess], $[BOOL bInheritHandles], $[LPCSTR lpName])

$~OpenJobObjectW
$[HANDLE ]OpenJobObjectW($[DWORD dwDesiredAccess], $[BOOL bInheritHandles], $[LPCWSTR lpName])

$~OpenMutexA
$[HANDLE ]OpenMutexA($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCSTR lpName])

$~OpenMutexW
$[HANDLE ]OpenMutexW($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCWSTR lpName])

$~OpenProcess
$[HANDLE ]OpenProcess($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[DWORD dwProcessId])

$~OpenSemaphoreA
$[HANDLE ]OpenSemaphoreA($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCSTR lpName])

$~OpenSemaphoreW
$[HANDLE ]OpenSemaphoreW($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCWSTR lpName])

$~OpenThread
$[HANDLE ]OpenThread($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[DWORD dwThreadId])

$~OpenWaitableTimerA
$[HANDLE ]OpenWaitableTimerA($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCSTR lpTimerName])

$~OpenWaitableTimerW
$[HANDLE ]OpenWaitableTimerW($[DWORD dwDesiredAccess], $[BOOL bInheritHandle], $[LPCWSTR lpTimerName])

$~OpenFile
$[HFILE ]OpenFile($[LPCSTR lpFileName], $[LPOFSTRUCT lpReOpenBuff], $[UINT uStyle])

$~GlobalAlloc
$[HGLOBAL ]GlobalAlloc($[UINT uFlags], $[SIZE_T dwBytes])

$~GlobalFree
$[HGLOBAL ]GlobalFree($[HGLOBAL hMem])

$~GlobalHandle
$[HGLOBAL ]GlobalHandle($[LPCVOID pMem])

$~GlobalReAlloc
$[HGLOBAL ]GlobalReAlloc($[HGLOBAL hMem], $[SIZE_T dwBytes], $[UINT uFlags])

$~LoadResource
$[HGLOBAL ]LoadResource($[HMODULE hModule], $[HRSRC hResInfo])

$~LocalAlloc
$[HLOCAL ]LocalAlloc($[UINT uFlags], $[SIZE_T uBytes])

$~LocalFree
$[HLOCAL ]LocalFree($[HLOCAL hMem])

$~LocalHandle
$[HLOCAL ]LocalHandle($[LPCVOID pMem])

$~LocalReAlloc
$[HLOCAL ]LocalReAlloc($[HLOCAL hMem], $[SIZE_T uBytes], $[UINT uFlags])

$~GetModuleHandleA
$[HMODULE ]GetModuleHandleA($[LPCSTR lpModuleName])

$~GetModuleHandleW
$[HMODULE ]GetModuleHandleW($[LPCWSTR lpModuleName])

$~LoadLibraryA
$[HMODULE ]LoadLibraryA($[LPCSTR lpFileName])

$~LoadLibraryExA
$[HMODULE ]LoadLibraryExA($[LPCSTR lpFileName], $[HANDLE hFile], $[DWORD dwFlags])

$~LoadLibraryExW
$[HMODULE ]LoadLibraryExW($[LPCWSTR lpFileName], $[HANDLE hFile], $[DWORD dwFlags])

$~LoadLibraryW
$[HMODULE ]LoadLibraryW($[LPCWSTR lpFileName])

$~GetStringTypeA
$[HRESULT ]GetStringTypeA($[USER_INPUT_STRING_TYPE* pnStringType])

$~GetStringTypeW
$[HRESULT ]GetStringTypeW($[USER_INPUT_STRING_TYPE* pnStringType])

$~FindResourceA
$[HRSRC ]FindResourceA($[HMODULE hModule], $[LPCSTR lpName], $[LPCSTR lpType])

$~FindResourceExA
$[HRSRC ]FindResourceExA($[HMODULE hModule], $[LPCSTR lpType], $[LPCSTR lpName], $[WORD wLanguage])

$~FindResourceExW
$[HRSRC ]FindResourceExW($[HMODULE hModule], $[LPCWSTR lpType], $[LPCWSTR lpName], $[WORD wLanguage])

$~FindResourceW
$[HRSRC ]FindResourceW($[HMODULE hModule], $[LPCWSTR lpName], $[LPCWSTR lpType])

$~GetConsoleWindow
$[HWND ]GetConsoleWindow($[])

$~CompareStringA
$[int ]CompareStringA($[LCID Locale], $[DWORD dwCmpFlags], $[LPCSTR lpString1], $[int cchCount1], $[LPCSTR lpString2], $[int cchCount2])

$~CompareStringW
$[int ]CompareStringW($[LCID Locale], $[DWORD dwCmpFlags], $[LPCWSTR lpString1], $[int cchCount1], $[LPCWSTR lpString2], $[int cchCount2])

$~FoldStringA
$[int ]FoldStringA($[DWORD dwMapFlags], $[LPCSTR lpSrcStr], $[int cchSrc], $[LPSTR lpDestStr], $[int cchDest])

$~FoldStringW
$[int ]FoldStringW($[DWORD dwMapFlags], $[LPCWSTR lpSrcStr], $[int cchSrc], $[LPWSTR lpDestStr], $[int cchDest])

$~GetCalendarInfoA
$[int ]GetCalendarInfoA($[LCID Locale], $[CALID Calendar], $[CALTYPE CalType], $[LPSTR lpCalData], $[int cchData], $[LPDWORD lpValue])

$~GetCalendarInfoW
$[int ]GetCalendarInfoW($[LCID Locale], $[CALID Calendar], $[CALTYPE CalType], $[LPWSTR lpCalData], $[int cchData], $[LPDWORD lpValue])

$~GetCurrencyFormatA
$[int ]GetCurrencyFormatA($[LCID Locale], $[DWORD dwFlags], $[LPCSTR lpValue], $[CONST CURRENCYFMT* lpFormat], $[LPSTR lpCurrencyStr], $[int cchCurrency])

$~GetCurrencyFormatW
$[int ]GetCurrencyFormatW($[LCID Locale], $[DWORD dwFlags], $[LPCWSTR lpValue], $[CONST CURRENCYFMT* lpFormat], $[LPWSTR lpCurrencyStr], $[int cchCurrency])

$~GetDateFormatA
$[int ]GetDateFormatA($[LCID Locale], $[DWORD dwFlags], $[CONST SYSTEMTIME* lpDate], $[LPCSTR lpFormat], $[LPSTR lpDateStr], $[int cchDate])

$~GetDateFormatW
$[int ]GetDateFormatW($[LCID Locale], $[DWORD dwFlags], $[CONST SYSTEMTIME* lpDate], $[LPCWSTR lpFormat], $[LPWSTR lpDateStr], $[int cchDate])

$~GetExpandedNameA
$[INT ]GetExpandedNameA($[LPSTR lpszSource], $[LPSTR lpszBuffer])

$~GetExpandedNameW
$[INT ]GetExpandedNameW($[LPWSTR lpszSource], $[LPWSTR lpszBuffer])

$~GetGeoInfoA
$[int ]GetGeoInfoA($[GEOID GeoId], $[GEOTYPE GeoType], $[LPSTR lpGeoData], $[int cchData], $[LANGID language])

$~GetGeoInfoW
$[int ]GetGeoInfoW($[GEOID GeoId], $[GEOTYPE GeoType], $[LPWSTR lpGeoData], $[int cchData], $[LANGID language])

$~GetLocaleInfoA
$[int ]GetLocaleInfoA($[LCID Locale], $[LCTYPE LCType], $[LPSTR lpLCData], $[int cchData])

$~GetLocaleInfoW
$[int ]GetLocaleInfoW($[LCID Locale], $[LCTYPE LCType], $[LPWSTR lpLCData], $[int cchData])

$~GetNumberFormatA
$[int ]GetNumberFormatA($[LCID Locale], $[DWORD dwFlags], $[LPCSTR lpValue], $[CONST NUMBERFMT* lpFormat], $[LPSTR lpNumberStr], $[int cchNumber])

$~GetNumberFormatW
$[int ]GetNumberFormatW($[LCID Locale], $[DWORD dwFlags], $[LPCWSTR lpValue], $[CONST NUMBERFMT* lpFormat], $[LPWSTR lpNumberStr], $[int cchNumber])

$~GetThreadPriority
$[int ]GetThreadPriority($[HANDLE hThread])

$~GetTimeFormatA
$[int ]GetTimeFormatA($[LCID Locale], $[DWORD dwFlags], $[CONST SYSTEMTIME* lpTime], $[LPCSTR lpFormat], $[LPSTR lpTimeStr], $[int cchTime])

$~GetTimeFormatW
$[int ]GetTimeFormatW($[LCID Locale], $[DWORD dwFlags], $[CONST SYSTEMTIME* lpTime], $[LPCWSTR lpFormat], $[LPWSTR lpTimeStr], $[int cchTime])

$~LCMapStringA
$[int ]LCMapStringA($[LCID Locale], $[DWORD dwMapFlags], $[LPCSTR lpSrcStr], $[int cchSrc], $[LPSTR lpDestStr], $[int cchDest])

$~LCMapStringW
$[int ]LCMapStringW($[LCID Locale], $[DWORD dwMapFlags], $[LPCWSTR lpSrcStr], $[int cchSrc], $[LPWSTR lpDestStr], $[int cchDest])

$~lstrcmp
$[int ]lstrcmp($[LPCSTR lpString1], $[LPCSTR lpString2])

$~lstrcmpA
$[int ]lstrcmpA($[LPCSTR lpString1], $[LPCSTR lpString2])

$~lstrcmpi
$[int ]lstrcmpi($[LPCSTR lpString1], $[LPCSTR lpString2])

$~lstrcmpiA
$[int ]lstrcmpiA($[LPCSTR lpString1], $[LPCSTR lpString2])

$~lstrcmpiW
$[int ]lstrcmpiW($[LPCWSTR lpString1], $[LPCSTR lpString2])

$~lstrcmpW
$[int ]lstrcmpW($[LPCWSTR lpString1], $[LPCSTR lpString2])

$~lstrlen
$[int ]lstrlen($[LPCSTR lpString])

$~lstrlenA
$[int ]lstrlenA($[LPCSTR lpString])

$~lstrlenW
$[int ]lstrlenW($[LPCWSTR lpString])

$~LZInit
$[INT ]LZInit($[INT hfSource])

$~LZOpenFileA
$[INT ]LZOpenFileA($[LPSTR lpFileName], $[LPOFSTRUCT lpReOpenBuf], $[WORD wStyle])

$~LZOpenFileW
$[INT ]LZOpenFileW($[LPWSTR lpFileName], $[LPOFSTRUCT lpReOpenBuf], $[WORD wStyle])

$~LZRead
$[INT ]LZRead($[INT hFile], $[LPSTR lpBuffer], $[INT cbRead])

$~MulDiv
$[int ]MulDiv($[int nNumber], $[int nNumerator], $[int nDenominator])

$~MultiByteToWideChar
$[int ]MultiByteToWideChar($[UINT CodePage], $[DWORD dwFlags], $[LPCSTR lpMultiByteStr], $[int cbMultiByte], $[LPWSTR lpWideCharStr], $[int cchWideChar])

$~SetCalendarInfoA
$[int ]SetCalendarInfoA($[LCID Locale], $[CALID Calendar], $[CALTYPE CalType], $[LPCSTR lpCalData])

$~SetCalendarInfoW
$[int ]SetCalendarInfoW($[LCID Locale], $[CALID Calendar], $[CALTYPE CalType], $[LPCWSTR lpCalData])

$~WideCharToMultiByte
$[int ]WideCharToMultiByte($[UINT CodePage], $[DWORD dwFlags], $[LPCWSTR lpWideCharStr], $[int cchWideChar], $[LPSTR lpMultiByteStr], $[int cbMultiByte], $[LPCSTR lpDefaultChar], $[LPBOOL lpUsedDefaultChar])

$~GetSystemDefaultLangID
$[LANGID ]GetSystemDefaultLangID($[])

$~GetSystemDefaultUILanguage
$[LANGID ]GetSystemDefaultUILanguage($[])

$~GetUserDefaultLangID
$[LANGID ]GetUserDefaultLangID($[])

$~GetUserDefaultUILanguage
$[LANGID ]GetUserDefaultUILanguage($[])

$~SetThreadUILanguage
$[LANGID ]SetThreadUILanguage($[LANGID LangId])

$~ConvertDefaultLocale
$[LCID ]ConvertDefaultLocale($[LCID Locale])

$~GetSystemDefaultLCID
$[LCID ]GetSystemDefaultLCID($[])

$~GetThreadLocale
$[LCID ]GetThreadLocale($[])

$~GetUserDefaultLCID
$[LCID ]GetUserDefaultLCID($[])

$~CompareFileTime
$[LONG ]CompareFileTime($[const FILETIME* lpFileTime1], $[const FILETIME* lpFileTime2])

$~CopyLZFile
$[LONG ]CopyLZFile($[INT hfSource], $[INT hfDest])

$~InterlockedCompareExchange
$[LONG ]InterlockedCompareExchange($[LONG volatile* Destination], $[LONG Exchange], $[LONG Comparand])

$~InterlockedDecrement
$[LONG ]InterlockedDecrement($[LONG volatile* Addend])

$~InterlockedExchange
$[LONG ]InterlockedExchange($[LONG volatile* Target], $[LONG Value])

$~InterlockedExchangeAdd
$[LONG ]InterlockedExchangeAdd($[LONG volatile* Addend], $[LONG Value])

$~InterlockedIncrement
$[LONG ]InterlockedIncrement($[LONG volatile* Addend])

$~LZCopy
$[LONG ]LZCopy($[INT hfSource], $[INT hfDest])

$~LZSeek
$[LONG ]LZSeek($[INT hFile], $[LONG lOffset], $[INT iOrigin])

$~UnhandledExceptionFilter
$[LONG ]UnhandledExceptionFilter($[struct _EXCEPTION_POINTERS* ExceptionInfo])

$~_hread
$[LONG ]_hread($[HFile hFile], $[LPCSTR lpBuffer], $[UINT cbRead])

$~_hwrite
$[LONG ]_hwrite($[HFile hFile], $[LPCSTR lpBuffer], $[UINT cbWrite])

$~_lclose
$[LONG ]_lclose($[HFile hFile])

$~_lcreat
$[LONG ]_lcreat($[LPCSTR lpszFileName], $[int fnAttribute])

$~_llseek
$[LONG ]_llseek($[HFile hFile], $[LONG lOffset], $[int nOrigin])

$~_lopen
$[LONG ]_lopen($[const char *filename], $[int oflag], $[int pmode[optional])

$~_lread
$[LONG ]_lread($[HFile hFile], $[LPCSTR lpBuffer], $[UINT cbRead])

$~_lwrite
$[LONG ]_lwrite($[HFile hFile], $[LPCSTR lpBuffer], $[UINT cbWrite])

$~GetCommandLineA
$[LPSTR ]GetCommandLineA($[])

$~lstrcat
$[LPSTR ]lstrcat($[LPSTR lpString1], $[LPSTR lpString2])

$~lstrcatA
$[LPSTR ]lstrcatA($[LPSTR lpString1], $[LPSTR lpString2])

$~lstrcatW
$[LPSTR ]lstrcatW($[LPWSTR lpString1], $[LPSTR lpString2])

$~lstrcpy
$[LPSTR ]lstrcpy($[LPSTR lpString1], $[LPSTR lpString2])

$~lstrcpyA
$[LPSTR ]lstrcpyA($[LPSTR lpString1], $[LPSTR lpString2])

$~lstrcpyn
$[LPSTR ]lstrcpyn($[LPSTR lpString1], $[LPCSTR lpString2], $[int iMaxLength])

$~lstrcpynA
$[LPSTR ]lstrcpynA($[LPSTR lpString1], $[LPCSTR lpString2], $[int iMaxLength])

$~lstrcpynW
$[LPSTR ]lstrcpynW($[LPWSTR lpString1], $[LPCSTR lpString2], $[int iMaxLength])

$~lstrcpyW
$[LPSTR ]lstrcpyW($[LPWSTR lpString1], $[LPSTR lpString2])

$~SetUnhandledExceptionFilter
$[LPTOP_LEVEL_EXCEPTION_FILTER ]SetUnhandledExceptionFilter($[LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter])

$~ConvertThreadToFiber
$[LPVOID ]ConvertThreadToFiber($[LPVOID lpParameter])

$~CreateFiber
$[LPVOID ]CreateFiber($[SIZE_T dwStackSize], $[LPFIBER_START_ROUTINE lpStartAddress], $[LPVOID lpParameter])

$~CreateFiberEx
$[LPVOID ]CreateFiberEx($[SIZE_T dwStackCommitSize], $[SIZE_T dwStackReserveSize], $[DWORD dwFlags], $[LPFIBER_START_ROUTINE lpStartAddress], $[LPVOID lpParameter])

$~GetEnvironmentStrings
$[LPVOID ]GetEnvironmentStrings($[])

$~GetEnvironmentStringsA
$[LPVOID ]GetEnvironmentStringsA($[])

$~GetEnvironmentStringsW
$[LPVOID ]GetEnvironmentStringsW($[])

$~GlobalLock
$[LPVOID ]GlobalLock($[HGLOBAL hMem])

$~HeapAlloc
$[LPVOID ]HeapAlloc($[HANDLE hHeap], $[DWORD dwFlags], $[SIZE_T dwBytes])

$~HeapReAlloc
$[LPVOID ]HeapReAlloc($[HANDLE hHeap], $[DWORD dwFlags], $[LPVOID lpMem], $[SIZE_T dwBytes])

$~LocalLock
$[LPVOID ]LocalLock($[HLOCAL hMem])

$~LockResource
$[LPVOID ]LockResource($[HGLOBAL hResData])

$~MapViewOfFile
$[LPVOID ]MapViewOfFile($[HANDLE hFileMappingObject], $[DWORD dwDesiredAccess], $[DWORD dwFileOffsetHigh], $[DWORD dwFileOffsetLow], $[SIZE_T dwNumberOfBytesToMap])

$~MapViewOfFileEx
$[LPVOID ]MapViewOfFileEx($[HANDLE hFileMappingObject], $[DWORD dwDesiredAccess], $[DWORD dwFileOffsetHigh], $[DWORD dwFileOffsetLow], $[SIZE_T dwNumberOfBytesToMap], $[LPVOID lpBaseAddress])

$~TlsGetValue
$[LPVOID ]TlsGetValue($[DWORD dwTlsIndex])

$~VirtualAlloc
$[LPVOID ]VirtualAlloc($[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD flAllocationType], $[DWORD flProtect])

$~VirtualAllocEx
$[LPVOID ]VirtualAllocEx($[HANDLE hProcess], $[LPVOID lpAddress], $[SIZE_T dwSize], $[DWORD flAllocationType], $[DWORD flProtect])

$~GetCommandLineW
$[LPWSTR ]GetCommandLineW($[])

$~InterlockedFlushSList
$[PSLIST_ENTRY ]InterlockedFlushSList($[PSLIST_HEADER ListHead])

$~InterlockedPopEntrySList
$[PSLIST_ENTRY ]InterlockedPopEntrySList($[PSLIST_HEADER ListHead])

$~InterlockedPushEntrySList
$[PSLIST_ENTRY ]InterlockedPushEntrySList($[PSLIST_HEADER ListHead], $[PSLIST_ENTRY ListEntry])

$~AddVectoredExceptionHandler
$[PVOID ]AddVectoredExceptionHandler($[ULONG FirstHandler], $[PVECTORED_EXCEPTION_HANDLER VectoredHandler])

$~GlobalSize
$[SIZE_T ]GlobalSize($[HGLOBAL hMem])

$~HeapSize
$[SIZE_T ]HeapSize($[HANDLE hHeap], $[DWORD dwFlags], $[LPCVOID lpMem])

$~VirtualQuery
$[SIZE_T ]VirtualQuery($[LPCVOID lpAddress], $[PMEMORY_BASIC_INFORMATION lpBuffer], $[SIZE_T dwLength])

$~VirtualQueryEx
$[SIZE_T ]VirtualQueryEx($[HANDLE hProcess], $[LPCVOID lpAddress], $[PMEMORY_BASIC_INFORMATION lpBuffer], $[SIZE_T dwLength])

$~GetACP
$[UINT ]GetACP($[])

$~GetAtomNameA
$[UINT ]GetAtomNameA($[ATOM nAtom], $[LPSTR lpBuffer], $[int nSize])

$~GetAtomNameW
$[UINT ]GetAtomNameW($[ATOM nAtom], $[LPWSTR lpBuffer], $[int nSize])

$~GetConsoleCP
$[UINT ]GetConsoleCP($[])

$~GetConsoleOutputCP
$[UINT ]GetConsoleOutputCP($[])

$~GetDriveTypeA
$[UINT ]GetDriveTypeA($[LPCSTR lpRootPathName])

$~GetDriveTypeW
$[UINT ]GetDriveTypeW($[LPCWSTR lpRootPathName])

$~GetOEMCP
$[UINT ]GetOEMCP($[])

$~GetPrivateProfileIntA
$[UINT ]GetPrivateProfileIntA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[INT nDefault], $[LPCSTR lpFileName])

$~GetPrivateProfileIntW
$[UINT ]GetPrivateProfileIntW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[INT nDefault], $[LPCWSTR lpFileName])

$~GetProfileIntA
$[UINT ]GetProfileIntA($[LPCSTR lpAppName], $[LPCSTR lpKeyName], $[INT nDefault])

$~GetProfileIntW
$[UINT ]GetProfileIntW($[LPCWSTR lpAppName], $[LPCWSTR lpKeyName], $[INT nDefault])

$~GetSystemDirectoryA
$[UINT ]GetSystemDirectoryA($[LPSTR lpBuffer], $[UINT uSize])

$~GetSystemDirectoryW
$[UINT ]GetSystemDirectoryW($[LPWSTR lpBuffer], $[UINT uSize])

$~GetSystemWindowsDirectoryA
$[UINT ]GetSystemWindowsDirectoryA($[LPSTR lpBuffer], $[UINT uSize])

$~GetSystemWindowsDirectoryW
$[UINT ]GetSystemWindowsDirectoryW($[LPWSTR lpBuffer], $[UINT uSize])

$~GetSystemWow64DirectoryA
$[UINT ]GetSystemWow64DirectoryA($[LPSTR lpBuffer], $[UINT uSize])

$~GetSystemWow64DirectoryW
$[UINT ]GetSystemWow64DirectoryW($[LPWSTR lpBuffer], $[UINT uSize])

$~GetTempFileNameA
$[UINT ]GetTempFileNameA($[LPCSTR lpPathName], $[LPCSTR lpPrefixString], $[UINT uUnique], $[LPSTR lpTempFileName])

$~GetTempFileNameW
$[UINT ]GetTempFileNameW($[LPCWSTR lpPathName], $[LPCWSTR lpPrefixString], $[UINT uUnique], $[LPWSTR lpTempFileName])

$~GetWindowsDirectoryA
$[UINT ]GetWindowsDirectoryA($[LPSTR lpBuffer], $[UINT uSize])

$~GetWindowsDirectoryW
$[UINT ]GetWindowsDirectoryW($[LPWSTR lpBuffer], $[UINT uSize])

$~GetWriteWatch
$[UINT ]GetWriteWatch($[DWORD dwFlags], $[PVOID lpBaseAddress], $[SIZE_T dwRegionSize], $[PVOID* lpAddresses], $[PULONG_PTR lpdwCount], $[PULONG lpdwGranularity])

$~GlobalFlags
$[UINT ]GlobalFlags($[HGLOBAL hMem])

$~GlobalGetAtomNameA
$[UINT ]GlobalGetAtomNameA($[ATOM nAtom], $[LPSTR lpBuffer], $[int nSize])

$~GlobalGetAtomNameW
$[UINT ]GlobalGetAtomNameW($[ATOM nAtom], $[LPWSTR lpBuffer], $[int nSize])

$~HeapCompact
$[UINT ]HeapCompact($[HANDLE hHeap], $[DWORD dwFlags])

$~LocalFlags
$[UINT ]LocalFlags($[HLOCAL hMem])

$~LocalSize
$[UINT ]LocalSize($[HLOCAL hMem])

$~ResetWriteWatch
$[UINT ]ResetWriteWatch($[LPVOID lpBaseAddress], $[SIZE_T dwRegionSize])

$~SetErrorMode
$[UINT ]SetErrorMode($[UINT uMode])

$~SetHandleCount
$[UINT ]SetHandleCount($[UINT uNumber])

$~WinExec
$[UINT ]WinExec($[LPCSTR lpCmdLine], $[UINT uCmdShow])

$~GetComPlusPackageInstallStatus
$[ULONG ]GetComPlusPackageInstallStatus($[])

$~RemoveVectoredExceptionHandler
$[ULONG ]RemoveVectoredExceptionHandler($[PVOID Handler])

$~VerSetConditionMask
$[ULONGLONG ]VerSetConditionMask($[ULONGLONG dwlConditionMask], $[DWORD dwTypeBitMask], $[BYTE dwConditionMask])

$~QueryDepthSList
$[USHORT ]QueryDepthSList($[PSLIST_HEADER ListHead])

$~AddRefActCtx
$[void ]AddRefActCtx($[HANDLE hActCtx])

$~DebugBreak
$[void ]DebugBreak($[])

$~DeleteCriticalSection
$[void ]DeleteCriticalSection($[LPCRITICAL_SECTION lpCriticalSection])

$~DeleteFiber
$[VOID ]DeleteFiber($[LPVOID lpFiber])

$~EnterCriticalSection
$[void ]EnterCriticalSection($[LPCRITICAL_SECTION lpCriticalSection])

$~ExitProcess
$[VOID ]ExitProcess($[UINT uExitCode])

$~ExitThread
$[VOID ]ExitThread($[DWORD dwExitCode])

$~FatalAppExitA
$[void ]FatalAppExitA($[UINT uAction], $[LPCSTR lpMessageText])

$~FatalAppExitW
$[void ]FatalAppExitW($[UINT uAction], $[LPCWSTR lpMessageText])

$~FatalExit
$[void ]FatalExit($[int ExitCode])

$~FreeLibraryAndExitThread
$[VOID ]FreeLibraryAndExitThread($[HMODULE hModule], $[DWORD dwExitCode])

$~GetLocalTime
$[void ]GetLocalTime($[LPSYSTEMTIME lpSystemTime])

$~GetNativeSystemInfo
$[void ]GetNativeSystemInfo($[LPSYSTEM_INFO lpSystemInfo])

$~GetStartupInfoA
$[VOID ]GetStartupInfoA($[LPSTARTUPINFO lpStartupInfo])

$~GetStartupInfoW
$[VOID ]GetStartupInfoW($[LPSTARTUPINFO lpStartupInfo])

$~GetSystemInfo
$[void ]GetSystemInfo($[LPSYSTEM_INFO lpSystemInfo])

$~GetSystemTime
$[void ]GetSystemTime($[LPSYSTEMTIME lpSystemTime])

$~GetSystemTimeAsFileTime
$[void ]GetSystemTimeAsFileTime($[LPFILETIME lpSystemTimeAsFileTime])

$~GlobalMemoryStatus
$[void ]GlobalMemoryStatus($[LPMEMORYSTATUS lpBuffer])

$~InitializeCriticalSection
$[void ]InitializeCriticalSection($[LPCRITICAL_SECTION lpCriticalSection])

$~InitializeSListHead
$[void ]InitializeSListHead($[PSLIST_HEADER ListHead])

$~LeaveCriticalSection
$[void ]LeaveCriticalSection($[LPCRITICAL_SECTION lpCriticalSection])

$~LZClose
$[void ]LZClose($[INT hFile])

$~OutputDebugStringA
$[void ]OutputDebugStringA($[LPCSTR lpOutputString])

$~OutputDebugStringW
$[void ]OutputDebugStringW($[LPCWSTR lpOutputString])

$~RaiseException
$[void ]RaiseException($[DWORD dwExceptionCode], $[DWORD dwExceptionFlags], $[DWORD nNumberOfArguments], $[const ULONG_PTR* lpArguments])

$~ReleaseActCtx
$[void ]ReleaseActCtx($[HANDLE hActCtx])

$~RtlCaptureContext
$[VOID ]RtlCaptureContext($[PCONTEXT ContextRecord])

$~RtlFillMemory
$[VOID ]RtlFillMemory($[PVOID *Destination], $[SIZE_T Length], $[UCHAR Fill])

$~RtlMoveMemory
$[VOID ]RtlMoveMemory($[PVOID *Destination], $[PCVOID Destination], $[SIZE_T Length])

$~RtlUnwind
$[void ]RtlUnwind($[PVOID TargetFrame], $[PVOID TargetIp], $[PEXCEPTION_RECORD ExceptionRecord], $[PVOID ReturnValue])

$~SetFileApisToANSI
$[void ]SetFileApisToANSI($[])

$~SetFileApisToOEM
$[void ]SetFileApisToOEM($[])

$~SetLastError
$[void ]SetLastError($[DWORD dwErrCode])

$~Sleep
$[void ]Sleep($[DWORD dwMilliseconds])

$~SwitchToFiber
$[VOID ]SwitchToFiber($[LPVOID lpFiber])

$~UTUnRegister
$[VOID ]UTUnRegister($[HANDLE hModule])

$~ZeroMemory
$[void ]ZeroMemory($[PVOID Destination], $[SIZE_T Length])

$; msvcrt.dll
$; ----------
$~asctime
$[char* ]asctime($[const struct tm *timeptr])

$~fgets
$[char* ]fgets($[char *string], $[int n], $[FILE *stream])

$~setlocale
$[char* ]setlocale($[int category], $[const char *locale])

$~strcat
$[char* ]strcat($[char *strDestination], $[const char *strSource])

$~strchr
$[char* ]strchr($[const char *string], $[int c])

$~strerror
$[char* ]strerror($[int errnum])

$~strncat
$[char* ]strncat($[char *strDest], $[const char *strSource], $[size_t count])

$~strncpy
$[char* ]strncpy($[char *strDest], $[const char *strSource], $[size_t count])

$~strstr
$[char* ]strstr($[const char *string], $[const char *strCharSet])

$~strtok
$[char* ]strtok($[char *strToken], $[const char *strDelimit])

$~wcsrchr
$[char* ]wcsrchr($[const wchar_t *string], $[int c])

$~_cgets
$[char* ]_cgets($[char *buffer])

$~_ecvt
$[char* ]_ecvt($[double value], $[int count], $[int *dec], $[int *sign])

$~_fcvt
$[char* ]_fcvt($[double value], $[int count], $[int *dec], $[int *sign])

$~_fullpath
$[char* ]_fullpath($[char *absPath], $[const char *relPath], $[size_t maxLength])

$~_gcvt
$[char* ]_gcvt($[double value], $[int digits], $[char *buffer])

$~_getcwd
$[char* ]_getcwd($[char *buffer], $[int maxlen])

$~_getdcwd
$[char* ]_getdcwd($[int drive], $[char *buffer], $[int maxlen])

$~_ltoa
$[char* ]_ltoa($[long value], $[char *string], $[int radix])

$~_mktemp
$[char* ]_mktemp($[char *template])

$~_strdate
$[char* ]_strdate($[char *datestr])

$~_strdup
$[char* ]_strdup($[const char *strSource])

$~_strerror
$[char* ]_strerror($[const char *strErrMsg])

$~_strlwr
$[char* ]_strlwr($[char *string])

$~_strnset
$[char* ]_strnset($[char *string], $[int c], $[size_t count])

$~_strrev
$[char* ]_strrev($[char *string])

$~_strset
$[char* ]_strset($[char *string], $[int c])

$~_strtime
$[char* ]_strtime($[char *timestr])

$~_strupr
$[char* ]_strupr($[char *string])

$~_tempnam
$[char* ]_tempnam($[const char *dir], $[const char *prefix])

$~_ultoa
$[char* ]_ultoa($[unsigned long value], $[char *string], $[int radix])

$~ctime
$[char* ]ctime($[const time_t *timer])

$~_ui64toa
$[char* ]_ui64toa($[int value], $[char *string], $[int radix])

$~atof
$[double ]atof($[const char *string])

$~difftime
$[double ]difftime($[time_t timer1], $[time_t timer0])

$~fabs
$[double ]fabs($[double x])

$~floor
$[double ]floor($[double x])

$~fmod
$[double ]fmod($[double x], $[double y])

$~log
$[double ]log($[double x])

$~log10
$[double ]log10($[double x])

$~sinh
$[double ]sinh($[double x])

$~sqrt
$[double ]sqrt($[double x])

$~strtod
$[double ]strtod($[const char *nptr], $[char **endptr])

$~wcstod
$[double ]wcstod($[const wchar_t *nptr], $[wchar_t **endptr])

$~_cabs
$[double ]_cabs($[_complex z])

$~_hypot
$[double ]_hypot($[double x], $[double y])

$~_j0
$[double ]_j0($[double x])

$~_nextafter
$[double ]_nextafter($[double x], $[double y])

$~_scalb
$[double ]_scalb($[double x], $[long exp])

$~_y0
$[double ]_y0($[double x])

$~fopen
$[FILE* ]fopen($[const char *filename], $[const char *mode])

$~freopen
$[FILE* ]freopen($[const char *path], $[const char *mode], $[FILE *stream])

$~tmpfile
$[FILE* ]tmpfile($[void])

$~_fdopen
$[FILE* ]_fdopen($[int handle], $[const char *mode])

$~_fsopen
$[FILE* ]_fsopen($[const char *filename], $[const char *mode], $[int shflag])

$~_popen
$[FILE* ]_popen($[const char *command], $[const char *mode])

$~_wpopen
$[FILE* ]_wpopen($[const wchar_t *command], $[const wchar_t *mode])

$~atexit
$[int ]atexit($[FARPROC func])

$~fclose
$[int ]fclose($[FILE *stream])

$~feof
$[int ]feof($[FILE *stream])

$~ferror
$[int ]ferror($[FILE *stream])

$~fflush
$[int ]fflush($[FILE *stream])

$~fgetc
$[int ]fgetc($[FILE *stream])

$~fgetpos
$[int ]fgetpos($[FILE *stream], $[fpos_t *pos])

$~fprintf
$[int ]fprintf($[FILE *stream], $[const char *format])

$~fputc
$[int ]fputc($[int c], $[FILE *stream])

$~fputs
$[int ]fputs($[const char *string], $[FILE *stream])

$~fscanf
$[int ]fscanf($[FILE *stream], $[const char *format])

$~fsetpos
$[int ]fsetpos($[FILE *stream], $[const fpos_t *pos])

$~isalnum
$[int ]isalnum($[int c])

$~isalpha
$[int ]isalpha($[int c])

$~iscntrl
$[int ]iscntrl($[int c])

$~isgraph
$[int ]isgraph($[int c])

$~isleadbyte
$[int ]isleadbyte($[int c])

$~isprint
$[int ]isprint($[int c])

$~ispunct
$[int ]ispunct($[int c])

$~isspace
$[int ]isspace($[int c])

$~isupper
$[int ]isupper($[int c])

$~iswalpha
$[int ]iswalpha($[wint_t c])

$~iswascii
$[int ]iswascii($[wint_t c])

$~iswcntrl
$[int ]iswcntrl($[wint_t c])

$~iswctype
$[int ]iswctype($[wint_t c], $[wctype_t desc])

$~iswdigit
$[int ]iswdigit($[wint_t c])

$~iswgraph
$[int ]iswgraph($[wint_t c])

$~iswpunct
$[int ]iswpunct($[wint_t c])

$~iswxdigit
$[int ]iswxdigit($[wint_t c])

$~isxdigit
$[int ]isxdigit($[int c])

$~mbtowc
$[int ]mbtowc($[wchar_t *wchar], $[const char *mbchar], $[size_t count])

$~memcmp
$[int ]memcmp($[const void *buf1], $[const void *buf2], $[size_t count])

$~printf
$[int ]printf($[const char *format])

$~putchar
$[int ]putchar($[int c])

$~rand
$[int ]rand($[void])

$~scanf
$[int ]scanf($[const char *format])

$~setvbuf
$[int ]setvbuf($[FILE *stream], $[char *buffer], $[int mode], $[size_t size])

$~sprintf
$[int ]sprintf($[char *buffer], $[const char *format])

$~sscanf
$[int ]sscanf($[const char *buffer], $[const char *format])

$~strcmp
$[int ]strcmp($[const char *string1], $[const char *string2])

$~strncmp
$[int ]strncmp($[const char *string1], $[const char *string2], $[size_t count])

$~swprintf
$[int ]swprintf($[wchar_t *buffer], $[const wchar_t *format])

$~swscanf
$[int ]swscanf($[const wchar_t *buffer], $[const wchar_t *format])

$~tolower
$[int ]tolower($[int c])

$~toupper
$[int ]toupper($[int c])

$~towlower
$[int ]towlower($[int c])

$~towupper
$[int ]towupper($[int c])

$~ungetc
$[int ]ungetc($[int c], $[FILE *stream])

$~vfprintf
$[int ]vfprintf($[FILE *stream], $[const char *format], $[va_list argptr])

$~vsprintf
$[int ]vsprintf($[char *buffer], $[const char *format], $[va_list argptr])

$~vswprintf
$[int ]vswprintf($[wchar_t *buffer], $[const wchar_t *format], $[va_list argptr])

$~wcscmp
$[int ]wcscmp($[const wchar_t *string1], $[const wchar_t *string2])

$~wcscoll
$[int ]wcscoll($[const wchar_t *string1], $[const wchar_t *string2])

$~wcsncmp
$[int ]wcsncmp($[const wchar_t *string1], $[const wchar_t *string2], $[size_t count])

$~wscanf
$[int ]wscanf($[const wchar_t *format])

$~_access
$[int ]_access($[const char *path], $[int mode])

$~_chdrive
$[int ]_chdrive($[int drive])

$~_chmod
$[int ]_chmod($[const char *filename], $[int pmode])

$~_chsize
$[int ]_chsize($[int fd], $[long size])

$~_cputs
$[int ]_cputs($[const char *string])

$~_creat
$[int ]_creat($[const char *filename], $[int pmode])

$~_cscanf
$[int ]_cscanf($[const char *format])

$~_cwait
$[int ]_cwait($[int *termstat], $[int procHandle], $[int action])

$~_dup
$[int ]_dup($[int fd])

$~_dup2
$[int ]_dup2($[int handle1], $[int handle2])

$~_eof
$[int ]_eof($[int handle])

$~_execle
$[int ]_execle($[const char *cmdname], $[const char *arg0])

$~_execv
$[int ]_execv($[const char *cmdname], $[const char *const *argv])

$~_execve
$[int ]_execve($[const char *cmdname], $[const char *const *argv], $[const char *const *envp])

$~_execvp
$[int ]_execvp($[const char *cmdname], $[const char *const *argv])

$~_fgetchar
$[int ]_fgetchar($[void])

$~_fileno
$[int ]_fileno($[FILE *stream])

$~_findclose
$[int ]_findclose($[long handle])

$~_findnext
$[int ]_findnext($[intptr_t handle], $[struct _finddata_t *fileinfo])

$~_finite
$[int ]_finite($[double x])

$~_flushall
$[int ]_flushall($[void])

$~handler
$[int ]_fpieee_flt($[unsigned long exc_code], $[struct _EXCEPTION_POINTERS *exc_info], $[int handler])

$~_fputchar
$[int ]_fputchar($[int c])

$~_fstat
$[int ]_fstat($[int handle], $[struct _stat *buffer])

$~_futime
$[int ]_futime($[int handle], $[struct _utimbuf *filetime])

$~_getch
$[int ]_getch($[void])

$~_getche
$[int ]_getche($[void])

$~_getdrive
$[int ]_getdrive($[void])

$~_getmaxstdio
$[int ]_getmaxstdio($[void])

$~_getmbcp
$[int ]_getmbcp($[void])

$~_getpid
$[int ]_getpid($[void])

$~_getw
$[int ]_getw($[FILE *stream])

$~_heapadd
$[int ]_heapadd($[void *memblock], $[size_t size])

$~_heapchk
$[int ]_heapchk($[void])

$~_heapmin
$[int ]_heapmin($[void])

$~_heapset
$[int ]_heapset($[unsigned int fill])

$~_heapwalk
$[int ]_heapwalk($[_HEAPINFO *entryinfo])

$~_inp
$[int ]_inp($[unsigned short port])

$~_isatty
$[int ]_isatty($[int handle])

$~_ismbbalnum
$[int ]_ismbbalnum($[unsigned int c])

$~_ismbbalpha
$[int ]_ismbbalpha($[unsigned int c])

$~_ismbbkalnum
$[int ]_ismbbkalnum($[unsigned int c])

$~_ismbbkana
$[int ]_ismbbkana($[unsigned int c])

$~_ismbbkprint
$[int ]_ismbbkprint($[unsigned int c])

$~_ismbblead
$[int ]_ismbblead($[unsigned int c])

$~_ismbbpunct
$[int ]_ismbbpunct($[unsigned int c])

$~_ismbbtrail
$[int ]_ismbbtrail($[unsigned int c])

$~_ismbcalnum
$[int ]_ismbcalnum($[unsigned int c])

$~_ismbcalpha
$[int ]_ismbcalpha($[unsigned int c])

$~_ismbcdigit
$[int ]_ismbcdigit($[unsigned int c])

$~_ismbcgraph
$[int ]_ismbcgraph($[unsigned int c])

$~_ismbchira
$[int ]_ismbchira($[unsigned int c])

$~_ismbckata
$[int ]_ismbckata($[unsigned int c])

$~_ismbcl0
$[int ]_ismbcl0($[unsigned int c])

$~_ismbcl1
$[int ]_ismbcl1($[unsigned int c])

$~_ismbcl2
$[int ]_ismbcl2($[unsigned int c])

$~_ismbclegal
$[int ]_ismbclegal($[unsigned int c])

$~_ismbclower
$[int ]_ismbclower($[unsigned int c])

$~_ismbcprint
$[int ]_ismbcprint($[unsigned int c])

$~_ismbcpunct
$[int ]_ismbcpunct($[unsigned int c])

$~_ismbcspace
$[int ]_ismbcspace($[unsigned int c])

$~_ismbcsymbol
$[int ]_ismbcsymbol($[unsigned int c])

$~_ismbcupper
$[int ]_ismbcupper($[unsigned int c])

$~_ismbslead
$[int ]_ismbslead($[const unsigned char *string], $[const unsigned char *current])

$~_ismbstrail
$[int ]_ismbstrail($[const unsigned char *string], $[const unsigned char *current])

$~_isnan
$[int ]_isnan($[double x])

$~_kbhit
$[int ]_kbhit($[void])

$~_locking
$[int ]_locking($[int handle], $[int mode], $[long nbytes])

$~_mbbtype
$[int ]_mbbtype($[unsigned char c], $[int type])

$~_mbsbtype
$[int ]_mbsbtype($[const unsigned char *mbstr], $[size_t count])

$~_mbsicmp
$[int ]_mbsicmp($[const unsigned char *string1], $[const unsigned char_t *string2])

$~_mbsnbcmp
$[int ]_mbsnbcmp($[const unsigned char *string1], $[const unsigned char* string2], $[size_t count])

$~_mbsnbcoll
$[int ]_mbsnbcoll($[const unsigned char *string1], $[const unsigned char string2], $[size_t count])

$~_mbsnbicmp
$[int ]_mbsnbicmp($[const unsigned char *string1], $[const unsigned char *string2], $[size_t count])

$~_mbsncmp
$[int ]_mbsncmp($[const unsigned char *string1], $[const unsigned char* string2], $[size_t count])

$~_mbsnicmp
$[int ]_mbsnicmp($[const unsigned char *string1], $[const unsigned char *string2], $[size_t count])

$~_mbsrchr
$[int ]_mbsrchr($[const unsigned char *string], $[unsigned int c])

$~_memicmp
$[int ]_memicmp($[const void *buf1], $[const void *buf2], $[size_t count])

$~_mkdir
$[int ]_mkdir($[const char *dirname])

$~_open
$[int ]_open($[const char *filename], $[int oflag [], $[int pmode])

$~_outp
$[int ]_outp($[unsigned short port], $[int databyte])

$~_pclose
$[int ]_pclose($[FILE *stream])

$~_pipe
$[int ]_pipe($[int *phandles], $[unsigned int psize], $[int textmode])

$~_putch
$[int ]_putch($[int c])

$~_putenv
$[int ]_putenv($[const char *envstring])

$~_putw
$[int ]_putw($[int binint], $[FILE *stream])

$~_read
$[int ]_read($[int handle], $[void *buffer], $[unsigned int count])

$~_resetstkoflw
$[int ]_resetstkoflw($[void])

$~_rmdir
$[int ]_rmdir($[const char *dirname])

$~_rmtmp
$[int ]_rmtmp($[void])

$~_setmbcp
$[int ]_setmbcp($[int codepage])

$~_set_sbh_threshold
$[int ]_set_sbh_threshold($[size_t size])

$~_set_SSE2_enable
$[int ]_set_SSE2_enable($[int flag])

$~_snprintf
$[int ]_snprintf($[char *buffer], $[size_t count], $[const char *format])

$~_snscanf
$[int ]_snscanf($[const char * input], $[size_t length], $[const char * format])

$~_sopen
$[int ]_sopen($[const char *filename], $[int oflag], $[int shflag [], $[int pmode ])

$~_spawnlp
$[int ]_spawnlp($[int mode], $[const char *cmdname], $[const char *arg0])

$~_spawnlpe
$[int ]_spawnlpe($[int mode], $[const char *cmdname], $[const char *arg0])

$~_spawnv
$[int ]_spawnv($[int mode], $[const char *cmdname], $[const char *const *argv])

$~_spawnve
$[int ]_spawnve($[int mode], $[const char *cmdname], $[const char *const *argv], $[const char *const *envp])

$~_spawnvp
$[int ]_spawnvp($[int mode], $[const char *cmdname], $[const char *const *argv])

$~_stat
$[int ]_stat($[const char *path], $[struct _stat *buffer])

$~_stricmp
$[int ]_stricmp($[const char *string1], $[const char *string2])

$~_stricoll
$[int ]_stricoll($[const char *string1], $[const char *string2])

$~_strncoll
$[int ]_strncoll($[const char *string1], $[const char *string2], $[size_t count])

$~_strnicmp
$[int ]_strnicmp($[const char *string1], $[const char *string2], $[size_t count])

$~_umask
$[int ]_umask($[int pmode])

$~_ungetch
$[int ]_ungetch($[int c])

$~_unlink
$[int ]_unlink($[const char *filename])

$~_utime
$[int ]_utime($[const char *filename], $[struct _utimbuf *times])

$~_vscprintf
$[int ]_vscprintf($[const char *format], $[va_list argptr])

$~_vsnprintf
$[int ]_vsnprintf($[char *buffer], $[size_t count], $[const char *format], $[va_list argptr])

$~_waccess
$[int ]_waccess($[const wchar_t *path], $[int mode])

$~_wchmod
$[int ]_wchmod($[const wchar_t *filename], $[int pmode])

$~_wcreat
$[int ]_wcreat($[const wchar_t *filename], $[int pmode])

$~_wcsicmp
$[int ]_wcsicmp($[const wchar_t *string1], $[const wchar_t *string2])

$~_wcsicoll
$[int ]_wcsicoll($[const wchar_t *string1], $[const wchar_t *string2])

$~_wcsncoll
$[int ]_wcsncoll($[const wchar_t *string1], $[const wchar_t *string2], $[size_t count])

$~_wcsnicmp
$[int ]_wcsnicmp($[const wchar_t *string1], $[const wchar_t *string2], $[size_t count])

$~_wexecl
$[int ]_wexecl($[const wchar_t *cmdname], $[const wchar_t *arg0])

$~_wexecle
$[int ]_wexecle($[const wchar_t *cmdname], $[const wchar_t *arg0])

$~_wexecv
$[int ]_wexecv($[const wchar_t *cmdname], $[const wchar_t *const *argv])

$~_wexecve
$[int ]_wexecve($[const wchar_t *cmdname], $[const wchar_t *const *argv], $[const wchar_t *const *envp])

$~_wmkdir
$[int ]_wmkdir($[const wchar_t *dirname])

$~_wputenv
$[int ]_wputenv($[const wchar_t *envstring])

$~_wremove
$[int ]_wremove($[const wchar_t *path])

$~_write
$[int ]_write($[int fd], $[const void *buffer], $[unsigned int count])

$~_wrmdir
$[int ]_wrmdir($[const wchar_t *dirname])

$~_wsopen
$[int ]_wsopen($[const wchar_t *filename], $[int oflag], $[int shflag [], $[int pmode ])

$~_wspawnl
$[int ]_wspawnl($[int mode], $[const wchar_t *cmdname], $[const wchar_t *arg0])

$~_wspawnle
$[int ]_wspawnle($[int mode], $[const wchar_t *cmdname], $[const wchar_t *arg0])

$~_wspawnlp
$[int ]_wspawnlp($[int mode], $[const wchar_t *cmdname], $[const wchar_t *arg0])

$~_wspawnv
$[int ]_wspawnv($[int mode], $[const wchar_t *cmdname], $[const wchar_t *const *argv])

$~_wspawnve
$[int ]_wspawnve($[int mode], $[const wchar_t *cmdname], $[const wchar_t *const *argv], $[const wchar_t *const *envp])

$~_wspawnvp
$[int ]_wspawnvp($[int mode], $[const wchar_t *cmdname], $[const wchar_t *const *argv])

$~_wstat
$[int ]_wstat($[const wchar_t *path], $[struct _stat *buffer])

$~_wsystem
$[int ]_wsystem($[const wchar_t *command])

$~_execl
$[intptr_t ]_execl($[const char *cmdname], $[const char *arg0])

$~_execlp
$[intptr_t ]_execlp($[const char *cmdname], $[const char *arg0])

$~_execlpe
$[intptr_t ]_execlpe($[const char *cmdname], $[const char *arg0])

$~_findfirst
$[intptr_t ]_findfirst($[const char *filespec], $[struct _finddata_t *fileinfo])

$~_spawnl
$[intptr_t ]_spawnl($[int mode], $[const char *cmdname], $[const char *arg0])

$~_spawnvpe
$[intptr_t ]_spawnvpe($[int mode], $[const char *cmdname], $[const char *const *argv], $[const char *const *envp])

$~ftell
$[long ]ftell($[FILE *stream])

$~labs
$[long ]labs($[long n])

$~strtol
$[long ]strtol($[const char *nptr], $[char **endptr], $[int base])

$~wcstol
$[long ]wcstol($[const wchar_t *nptr], $[wchar_t **endptr], $[int base])

$~_get_osfhandle
$[long ]_get_osfhandle($[int fd])

$~_lseek
$[long ]_lseek($[int handle], $[long offset], $[int origin])

$~_tell
$[long ]_tell($[int handle])

$~_wfindfirst
$[long ]_wfindfirst($[wchar_t *filespec], $[struct _wfinddata_t *fileinfo])

$~fread
$[size_t ]fread($[void *buffer], $[size_t size], $[size_t count], $[FILE *stream])

$~fwrite
$[size_t ]fwrite($[const void *buffer], $[size_t size], $[size_t count], $[FILE *stream])

$~mblen
$[size_t ]mblen($[const unsigned char *c])

$~mbstowcs
$[size_t ]mbstowcs($[wchar_t *wcstr], $[const char *mbstr], $[size_t count])

$~strcspn
$[size_t ]strcspn($[const char *string], $[const char *strCharSet])

$~strftime
$[size_t ]strftime($[char *strDest], $[size_t maxsize], $[const char *format], $[const struct tm *timeptr])

$~strlen
$[size_t ]strlen($[const char *string])

$~strxfrm
$[size_t ]strxfrm($[char *strDest], $[const char *strSource], $[size_t count])

$~wcscspn
$[size_t ]wcscspn($[const wchar_t *string], $[const wchar_t *strCharSet])

$~wcsftime
$[size_t ]wcsftime($[wchar_t *strDest], $[size_t maxsize], $[const wchar_t *format], $[const struct tm *timeptr])

$~wcslen
$[size_t ]wcslen($[const wchar_t *string])

$~wcsspn
$[size_t ]wcsspn($[const wchar_t *string], $[const wchar_t *strCharSet])

$~wcsxfrm
$[size_t ]wcsxfrm($[wchar_t *strDest], $[const wchar_t *strSource], $[size_t count])

$~_mbclen
$[size_t ]_mbclen($[const unsigned char *c])

$~_mbscspn
$[size_t ]_mbscspn($[const unsigned char *string], $[const unsigned char *strCharSet])

$~_mbslen
$[size_t ]_mbslen($[const unsigned char *string])

$~_mbsspn
$[size_t ]_mbsspn($[const unsigned char *string], $[const unsigned char *strCharSet])

$~_mbstrlen
$[size_t ]_mbstrlen($[const char *string])

$~_msize
$[size_t ]_msize($[void *memblock])

$~localeconv
$[struct lconv * ]localeconv($[void])

$~gmtime
$[struct tm * ]gmtime($[const time_t *timer])

$~mktime
$[time_t ]mktime($[struct tm *timeptr])

$~_beginthread
$[uintptr_t ]_beginthread($[FARPROC pFunction], $[DWORD stack_size], $[void* arglist])

$~_mbscat
$[unsigned char* ]_mbscat($[unsigned char *strDestination], $[const unsigned char *strSource])

$~_mbschr
$[unsigned char* ]_mbschr($[const unsigned char *string], $[unsigned int c])

$~_mbscpy
$[unsigned char* ]_mbscpy($[unsigned char *strDestination], $[const unsigned char *strSource])

$~_mbsdup
$[unsigned char* ]_mbsdup($[const unsigned char *strSource])

$~_mbsinc
$[unsigned char* ]_mbsinc($[const unsigned char *current])

$~_mbslwr
$[unsigned char* ]_mbslwr($[unsigned char *string])

$~_mbsnbcat
$[unsigned char* ]_mbsnbcat($[unsigned char *dest], $[const unsigned char *src], $[size_t count])

$~_mbsnbcpy
$[unsigned char* ]_mbsnbcpy($[unsigned char *dest], $[const unsigned char *src], $[size_t count])

$~_mbsnbset
$[unsigned char* ]_mbsnbset($[unsigned char *string], $[unsigned int c], $[size_t count])

$~_mbsncat
$[unsigned char* ]_mbsncat($[unsigned char *strDest], $[const unsigned char *strSource], $[size_t count])

$~_mbsncpy
$[unsigned char* ]_mbsncpy($[unsigned char *strDest], $[const unsigned char *strSource], $[size_t count])

$~_mbsninc
$[unsigned char* ]_mbsninc($[const unsigned char *string], $[size_t count])

$~_mbsnset
$[unsigned char* ]_mbsnset($[unsigned char *string], $[unsigned int c], $[size_t count])

$~_mbspbrk
$[unsigned char* ]_mbspbrk($[const unsigned char*string], $[const unsigned char *strCharSet])

$~_mbsrev
$[unsigned char* ]_mbsrev($[unsigned char *string])

$~_mbsset
$[unsigned char* ]_mbsset($[unsigned char *string], $[unsigned int c])

$~_mbsspnp
$[unsigned char* ]_mbsspnp($[const unsigned char *string1], $[const unsigned char *string2])

$~_mbstok
$[unsigned char* ]_mbstok($[unsigned char*strToken], $[const unsigned char *strDelimit])

$~_mbsupr
$[unsigned char* ]_mbsupr($[unsigned char *string])

$~_clearfp
$[unsigned int ]_clearfp($[void])

$~_control87
$[unsigned int ]_control87($[unsigned int new], $[unsigned int mask])

$~_mbbtombc
$[unsigned int ]_mbbtombc($[unsigned int c])

$~_mbcjistojms
$[unsigned int ]_mbcjistojms($[unsigned int c])

$~_mbcjmstojis
$[unsigned int ]_mbcjmstojis($[unsigned int c])

$~_mbctohira
$[unsigned int ]_mbctohira($[unsigned int c])

$~_mbctolower
$[unsigned int ]_mbctolower($[unsigned int c])

$~_mbctombb
$[unsigned int ]_mbctombb($[unsigned int c])

$~_mbsnextc
$[unsigned int ]_mbsnextc($[const unsigned char *string])

$~_rotl
$[unsigned int ]_rotl($[unsigned int value], $[int shift])

$~_rotr
$[unsigned int ]_rotr($[unsigned int value], $[int shift])

$~_statusfp
$[unsigned int ]_statusfp($[void])

$~strtoul
$[unsigned long ]strtoul($[const char *nptr], $[char **endptr], $[int base])

$~wcstoul
$[unsigned long ]wcstoul($[const wchar_t *nptr], $[wchar_t **endptr], $[int base])

$~_getdrives
$[unsigned long ]_getdrives($[])

$~_inpd
$[unsigned long ]_inpd($[unsigned short port])

$~_inpw
$[unsigned short ]_inpw($[unsigned short port])

$~_getdiskfree
$[unsigned ]_getdiskfree($[unsigned drive], $[struct _diskfree_t * driveinfo])

$~_strtoui64
$[unsigned __int64 ]_strtoui64($[const char *nptr], $[char **endptr], $[int base])

$~_wcstoui64
$[unsigned __int64 ]_wcstoui64($[const wchar_t *nptr], $[wchar_t **endptr], $[int base])

$~calloc
$[void* ]calloc($[size_t num], $[size_t size])

$~malloc
$[void* ]malloc($[size_t size])

$~_aligned_malloc
$[void* ]_aligned_malloc($[size_t size], $[size_t alignment])

$~_aligned_offset_malloc
$[void* ]_aligned_offset_malloc($[size_t size], $[size_t alignment], $[size_t offset])

$~_aligned_offset_realloc
$[void* ]_aligned_offset_realloc($[void *memblock], $[size_t size], $[size_t alignment], $[size_t offset])

$~_aligned_realloc
$[void* ]_aligned_realloc($[void *memblock], $[size_t size], $[size_t alignment])

$~_expand
$[void* ]_expand($[void *memblock], $[size_t size])

$~_lfind
$[void* ]_lfind($[const void *key], $[const void *base], $[unsigned int *num], $[unsigned int width], $[FARPROC compare])

$~_lsearch
$[void* ]_lsearch($[const void *key], $[void *base], $[unsigned int *num], $[unsigned int width], $[FARPROC compare])

$~_memccpy
$[void* ]_memccpy($[void *dest], $[const void *src], $[int c], $[size_t count])

$~clearerr
$[void ]clearerr($[FILE *stream])

$~qsort
$[void ]qsort($[void *base], $[size_t num], $[size_t width], $[FARPROC compare])

$~setbuf
$[void ]setbuf($[FILE *stream], $[char *buffer])

$~srand
$[void ]srand($[unsigned int seed])

$~_aligned_free
$[void ]_aligned_free($[void *memblock])

$~_cexit
$[void ]_cexit($[void])

$~_c_exit
$[void ]_c_exit($[void])

$~_endthread
$[void ]_endthread($[void])

$~_endthreadex
$[void ]_endthreadex($[void])

$~_exit
$[void ]_exit($[int status])

$~_fpreset
$[void ]_fpreset($[void])

$~_ftime
$[void ]_ftime($[struct _timeb *timeptr])

$~_makepath
$[void ]_makepath($[char *path], $[const char *drive], $[const char *dir], $[const char *fname], $[const char *ext])

$~_mbccpy
$[void ]_mbccpy($[unsigned char *dest], $[const unsigned char *src])

$~_searchenv
$[void ]_searchenv($[const char *filename], $[const char *varname], $[char *pathname])

$~_splitpath
$[void ]_splitpath($[const char *path], $[char *drive], $[char *dir], $[char *fname], $[char *ext])

$~_swab
$[void ]_swab($[char *src], $[char *dest], $[int n])

$~_tzset
$[void ]_tzset($[void])

$~_wmakepath
$[void ]_wmakepath($[wchar_t *path], $[const wchar_t *drive], $[const wchar_t *dir], $[const wchar_t *fname], $[const wchar_t *ext])

$~_wperror
$[void ]_wperror($[const wchar_t *string])

$~_wsearchenv
$[void ]_wsearchenv($[const wchar_t *filename], $[const wchar_t *varname], $[wchar_t *pathname])

$~_wsplitpath
$[void ]_wsplitpath($[const wchar_t *path], $[wchar_t *drive], $[wchar_t *dir], $[wchar_t *fname], $[wchar_t *ext])

$~wcscat
$[wchar_t* ]wcscat($[wchar_t *strDestination], $[const wchar_t *strSource])

$~wcschr
$[wchar_t* ]wcschr($[const wchar_t *string], $[wint_t c])

$~wcscpy
$[wchar_t* ]wcscpy($[wchar_t *strDestination], $[const wchar_t *strSource])

$~wcsncat
$[wchar_t* ]wcsncat($[wchar_t *strDest], $[const wchar_t *strSource], $[size_t count])

$~wcsncpy
$[wchar_t* ]wcsncpy($[wchar_t *strDest], $[const wchar_t *strSource], $[size_t count])

$~wcspbrk
$[wchar_t* ]wcspbrk($[const wchar_t *string], $[const wchar_t *strCharSet])

$~wcsstr
$[wchar_t* ]wcsstr($[const wchar_t *string], $[const wchar_t *strCharSet])

$~wcstok
$[wchar_t* ]wcstok($[wchar_t *strToken], $[const wchar_t *strDelimit])

$~_ltow
$[wchar_t* ]_ltow($[long value], $[wchar_t *string], $[int radix])

$~_ui64tow
$[wchar_t* ]_ui64tow($[unsigned __int64 value], $[wchar_t *string], $[int radix])

$~_wcsdup
$[wchar_t* ]_wcsdup($[const wchar_t *strSource])

$~_wcserror
$[wchar_t* ]_wcserror($[int errnum])

$~_wcslwr
$[wchar_t* ]_wcslwr($[wchar_t *string])

$~_wcsnset
$[wchar_t* ]_wcsnset($[wchar_t *string], $[wchar_t c], $[size_t count])

$~_wcsrev
$[wchar_t* ]_wcsrev($[wchar_t *string])

$~_wcsset
$[wchar_t* ]_wcsset($[wchar_t *string], $[wchar_t c])

$~_wcsupr
$[wchar_t* ]_wcsupr($[wchar_t *string])

$~_wctime
$[wchar_t* ]_wctime($[const time_t *timer])

$~_wfullpath
$[wchar_t* ]_wfullpath($[wchar_t *absPath], $[const wchar_t *relPath], $[size_t maxLength])

$~_wgetdcwd
$[wchar_t* ]_wgetdcwd($[int drive], $[wchar_t *buffer], $[int maxlen])

$~_wgetenv
$[wchar_t* ]_wgetenv($[const wchar_t *varname])

$~_wmktemp
$[wchar_t* ]_wmktemp($[wchar_t *template])

$~_wsetlocale
$[wchar_t* ]_wsetlocale($[int category], $[const wchar_t *locale])

$~_wstrdate
$[wchar_t* ]_wstrdate($[wchar_t *datestr])

$~_wstrtime
$[wchar_t* ]_wstrtime($[wchar_t *timestr])

$~_wtempnam
$[wchar_t* ]_wtempnam($[wchar_t *dir], $[wchar_t *prefix])

$~_wtmpnam
$[wchar_t* ]_wtmpnam($[wchar_t *string])

$~fputwc
$[wint_t ]fputwc($[wint_t c], $[FILE *stream])

$~getwc
$[wint_t ]getwc($[FILE *stream])

$~putwchar
$[wint_t ]putwchar($[wint_t c])

$~_fgetwchar
$[wint_t ]_fgetwchar($[void])

$~_fputwchar
$[wint_t ]_fputwchar($[wint_t c])

$~_filelengthi64
$[__int64 ]_filelengthi64($[int handle])

$~_findfirsti64
$[__int64 ]_findfirsti64($[char *filespec], $[struct _finddata_t *fileinfo])

$~_fstati64
$[__int64 ]_fstati64($[int handle], $[struct _stat *buffer])

$~_lseeki64
$[__int64 ]_lseeki64($[int handle], $[__int64 offset], $[int origin])

$~_strtoi64
$[__int64 ]_strtoi64($[const char *nptr], $[char **endptr], $[int base])

$~_telli64
$[__int64 ]_telli64($[int handle])

$~_wcstoi64
$[__int64 ]_wcstoi64($[const char *nptr], $[char **endptr], $[int base])

$~_wfindfirsti64
$[__int64 ]_wfindfirsti64($[wchar_t *filespec], $[struct _wfinddata_t *fileinfo])

$~_wstati64
$[__int64 ]_wstati64($[const wchar_t *path], $[struct _stat *buffer])

$~_wtoi64
$[__int64 ]_wtoi64($[wchar_t *string])

$; ntdll.dll
$; ---------
$~RtlIsNameLegalDOS8Dot3
$[BOOLEAN ]RtlIsNameLegalDOS8Dot3($[PUNICODE_STRING Name], $[POEM_STRING OemName], $[PBOOLEAN NameContainsSpaces])

$~RtlTimeToSecondsSince1970
$[BOOLEAN ]RtlTimeToSecondsSince1970($[PLARGE_INTEGER Time], $[PULONG ElapsedSeconds])

$~strcpy
$[char* ]strcpy($[char *strDestination], $[const char *strSource])

$~strpbrk
$[char* ]strpbrk($[const char *string], $[const char *strCharSet])

$~_itoa
$[char* ]_itoa($[int value], $[char *string], $[int radix])

$~cos
$[double ]cos($[double x])

$~sin
$[double ]sin($[double x])

$~isdigit
$[int ]isdigit($[int c])

$~_tolower
$[int ]_tolower($[int c])

$~_toupper
$[int ]_toupper($[int c])

$~__isascii
$[int ]__isascii($[int c])

$~__iscsym
$[int ]__iscsym($[int c])

$~__toascii
$[int ]__toascii($[int c])

$~RtlExtendedIntegerMultiply
$[LARGE_INTEGER ]RtlExtendedIntegerMultiply($[LARGE_INTEGER Multiplicand], $[LONG Multiplier])

$~RtlExtendedLargeIntegerDivide
$[LARGE_INTEGER ]RtlExtendedLargeIntegerDivide($[LARGE_INTEGER Dividend], $[ULONG Divisor], $[PULONG Remainder])

$~LdrGetDllHandle
$[NTSTATUS NTAPI ]LdrGetDllHandle($[PWORD pwPath], $[PVOID], $[PUNICODE_STRING ModuleFileName], $[PHANDLE pHModule])

$~LdrGetDllHandleEx
$[NTSTATUS NTAPI ]LdrGetDllHandleEx($[UNKNOWN], $[PWORD pwPath], $[PVOID], $[PUNICODE_STRING ModuleFileName], $[PHANDLE pHModule])

$~LdrGetProcedureAddress
$[NTSTATUS NTAPI ]LdrGetProcedureAddress($[HMODULE ModuleHandle], $[PANSI_STRING FunctionName], $[WORD Ordinal], $[PVOID FunAddr])

$~LdrLoadDll
$[NTSTATUS NTAPI ]LdrLoadDll($[PWCHAR PathToFile], $[ULONG Flags], $[PUNICODE_STRING ModuleFileName], $[PHANDLE ModuleHandle])

$~LdrUnloadDll
$[NTSTATUS NTAPI ]LdrUnloadDll($[HANDLE ModuleHandle])

$~NtCompareTokens
$[NTSTATUS NTAPI ]NtCompareTokens($[Handle FirstTokenHandle], $[Handle SecondTokenHandle], $[PBOOLEAN Equal])

$~ZwCompareTokens
$[NTSTATUS NTAPI ]ZwCompareTokens($[Handle FirstTokenHandle], $[Handle SecondTokenHandle], $[PBOOLEAN Equal])

$~NtCreateFile
$[NTSTATUS ]NtCreateFile($[PHANDLE FileHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PIO_STATUS_BLOCK IoStatusBlock], $[PLARGE_INTEGER AllocationSize], $[ULONG FileAttributes], $[ULONG ShareAccess], $[ULONG CreateDisposition], $[ULONG CreateOptions], $[PVOID EaBuffer], $[ULONG EaLength])

$~NtDeviceIoControlFile
$[NTSTATUS ]NtDeviceIoControlFile($[HANDLE FileHandle], $[HANDLE Event], $[PIO_APC_ROUTINE ApcRoutine], $[PVOID ApcContext], $[PIO_STATUS_BLOCK IoStatusBlock], $[ULONG IoControlCode], $[PVOID InputBuffer], $[ULONG InputBufferLength], $[PVOID OutputBuffer], $[ULONG OutputBufferLength])

$~NtOpenFile
$[NTSTATUS ]NtOpenFile($[PHANDLE FileHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PIO_STATUS_BLOCK IoStatusBlock], $[ULONG ShareAccess], $[ULONG OpenOptions])

$~NtOpenThread
$[NTSTATUS ]NtOpenThread($[PHANDLE ThreadHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PCLIENT_ID ClientId])

$~NtQueryInformationProcess
$[NTSTATUS ]NtQueryInformationProcess($[HANDLE ProcessHandle], $[PROCESSINFOCLASS ProcessInformationClass], $[PVOID ProcessInformation], $[ULONG ProcessInformationLength], $[PULONG ReturnLength])

$~NtQueryInformationThread
$[NTSTATUS ]NtQueryInformationThread($[HANDLE ThreadHandle], $[THREADINFOCLASS ThreadInformationClass], $[PVOID ThreadInformation], $[ULONG ThreadInformationLength], $[PULONG ReturnLength])

$~NtQueryObject
$[NTSTATUS ]NtQueryObject($[HANDLE Handle], $[OBJECT_INFORMATION_CLASS ObjectInformationClass], $[PVOID ObjectInformation], $[ULONG ObjectInformationLength], $[PULONG ReturnLength])

$~NtQueryPerformanceCounter
$[NTSTATUS ]NtQueryPerformanceCounter($[PLARGE_INTEGER PerformanceCounter], $[PLARGE_INTEGER PerformanceFrequency])

$~NtQuerySystemInformation
$[NTSTATUS ]NtQuerySystemInformation($[SYSTEM_INFORMATION_CLASS SystemInformationClass], $[PVOID SystemInformation], $[ULONG SystemInformationLength], $[PULONG ReturnLength])

$~NtQuerySystemTime
$[NTSTATUS ]NtQuerySystemTime($[PLARGE_INTEGER SystemTime])

$~NtWaitForSingleObject
$[NTSTATUS ]NtWaitForSingleObject($[HANDLE Handle], $[BOOLEAN Alertable], $[PLARGE_INTEGER Timeout])

$~NtWaitLowEventPair
$[NTSTATUS ]NtWaitLowEventPair($[HANDLE EventPairHandle])

$~NtWriteFileGather
$[NTSTATUS ]NtWriteFileGather($[HANDLE FileHandle], $[HANDLE Event], $[PIO_APC_ROUTINE ApcRoutine], $[PVOID ApcContext], $[PIO_STATUS_BLOCK IoStatusBlock], $[FILE_SEGMENT_ELEMENT SegmentArray], $[ULONG Length], $[PLARGE_INTEGER ByteOffset], $[PULONG Key])

$~RtlAnsiStringToUnicodeString
$[NTSTATUS ]RtlAnsiStringToUnicodeString($[PUNICODE_STRING DestinationString], $[PCANSI_STRING SourceString], $[BOOLEAN AllocateDestinationString])

$~RtlCharToInteger
$[NTSTATUS ]RtlCharToInteger($[PCSZ String], $[ULONG Base], $[PULONG Value])

$~RtlConvertSidToUnicodeString
$[NTSTATUS ]RtlConvertSidToUnicodeString($[PUNICODE_STRING UnicodeString], $[PSID pSid], $[BOOLEAN AllocateDestinationString])

$~RtlLocalTimeToSystemTime
$[NTSTATUS ]RtlLocalTimeToSystemTime($[PLARGE_INTEGER LocalTime], $[PLARGE_INTEGER SystemTime])

$~RtlUnicodeStringToAnsiString
$[NTSTATUS ]RtlUnicodeStringToAnsiString($[PANSI_STRING DestinationString], $[PUNICODE_STRING SourceString], $[BOOLEAN AllocateDestinationString])

$~RtlUnicodeStringToOemString
$[NTSTATUS ]RtlUnicodeStringToOemString($[POEM_STRING DestinationString], $[PUNICODE_STRING SourceString], $[BOOLEAN AllocateDestinationString])

$~RtlUnicodeToMultiByteSize
$[NTSTATUS ]RtlUnicodeToMultiByteSize($[PULONG BytesInMultiByteString], $[PWCH UnicodeString], $[ULONG BytesInUnicodeString])

$~ZwCreateFile
$[NTSTATUS ]ZwCreateFile($[PHANDLE FileHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PIO_STATUS_BLOCK IoStatusBlock], $[PLARGE_INTEGER AllocationSize], $[ULONG FileAttributes], $[ULONG ShareAccess], $[ULONG CreateDisposition], $[ULONG CreateOptions], $[PVOID EaBuffer], $[ULONG EaLength])

$~ZwDeviceIoControlFile
$[NTSTATUS ]ZwDeviceIoControlFile($[HANDLE FileHandle], $[HANDLE Event], $[PIO_APC_ROUTINE ApcRoutine], $[PVOID ApcContext], $[PIO_STATUS_BLOCK IoStatusBlock], $[ULONG IoControlCode], $[PVOID InputBuffer], $[ULONG InputBufferLength], $[PVOID OutputBuffer], $[ULONG OutputBufferLength])

$~ZwOpenFile
$[NTSTATUS ]ZwOpenFile($[PHANDLE FileHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PIO_STATUS_BLOCK IoStatusBlock], $[ULONG ShareAccess], $[ULONG OpenOptions])

$~ZwOpenThread
$[NTSTATUS ]ZwOpenThread($[PHANDLE ThreadHandle], $[ACCESS_MASK DesiredAccess], $[POBJECT_ATTRIBUTES ObjectAttributes], $[PCLIENT_ID ClientId])

$~ZwQueryInformationProcess
$[NTSTATUS ]ZwQueryInformationProcess($[HANDLE ProcessHandle], $[PROCESSINFOCLASS ProcessInformationClass], $[PVOID ProcessInformation], $[ULONG ProcessInformationLength], $[PULONG ReturnLength])

$~ZwQueryInformationThread
$[NTSTATUS ]ZwQueryInformationThread($[HANDLE ThreadHandle], $[THREADINFOCLASS ThreadInformationClass], $[PVOID ThreadInformation], $[ULONG ThreadInformationLength], $[PULONG ReturnLength])

$~ZwQueryObject
$[NTSTATUS ]ZwQueryObject($[HANDLE Handle], $[OBJECT_INFORMATION_CLASS ObjectInformationClass], $[PVOID ObjectInformation], $[ULONG ObjectInformationLength], $[PULONG ReturnLength])

$~ZwQueryPerformanceCounter
$[NTSTATUS ]ZwQueryPerformanceCounter($[PLARGE_INTEGER PerformanceCounter], $[PLARGE_INTEGER PerformanceFrequency])

$~ZwQuerySystemInformation
$[NTSTATUS ]ZwQuerySystemInformation($[SYSTEM_INFORMATION_CLASS SystemInformationClass], $[PVOID SystemInformation], $[ULONG SystemInformationLength], $[PULONG ReturnLength])

$~ZwQuerySystemTime
$[NTSTATUS ]ZwQuerySystemTime($[PLARGE_INTEGER SystemTime])

$~ZwWaitForSingleObject
$[NTSTATUS ]ZwWaitForSingleObject($[HANDLE Handle], $[BOOLEAN Alertable], $[PLARGE_INTEGER Timeout])

$~ZwWaitLowEventPair
$[NTSTATUS ]ZwWaitLowEventPair($[HANDLE EventPairHandle])

$~ZwWriteFileGather
$[NTSTATUS ]ZwWriteFileGather($[HANDLE FileHandle], $[HANDLE Event], $[PIO_APC_ROUTINE ApcRoutine], $[PVOID ApcContext], $[PIO_STATUS_BLOCK IoStatusBlock], $[FILE_SEGMENT_ELEMENT SegmentArray], $[ULONG Length], $[PLARGE_INTEGER ByteOffset], $[PULONG Key])

$~RtlPcToFileHeader
$[PVOID ]RtlPcToFileHeader($[PVOID PcValue], $[PVOID* BaseOfImage])

$~strspn
$[size_t ]strspn($[const char *string], $[const char *strCharSet])

$~RtlUniform
$[ULONG ]RtlUniform($[PULONG Seed])

$~bsearch
$[void* ]bsearch($[const void *key], $[const void *base], $[size_t num], $[size_t width], $[FARPROC])

$~memchr
$[void* ]memchr($[const void *buf], $[int c], $[size_t count])

$~memcpy
$[void* ]memcpy($[void *dest], $[const void *src], $[size_t count])

$~memmove
$[void* ]memmove($[void *dest], $[const void *src], $[size_t count])

$~memset
$[void* ]memset($[void *dest], $[int c], $[size_t count])

$~RtlFreeAnsiString
$[void ]RtlFreeAnsiString($[PANSI_STRING AnsiString])

$~RtlFreeOemString
$[void ]RtlFreeOemString($[POEM_STRING OemString])

$~RtlInitString
$[void ]RtlInitString($[PSTRING DestinationString], $[PCSZ SourceString])

$~RtlInitUnicodeString
$[VOID ]RtlInitUnicodeString($[PUNICODE_STRING DestinationString], $[PCWSTR SourceString])

$; ole32.dll
$; ---------
$~CoDosDateTimeToFileTime
$[BOOL ]CoDosDateTimeToFileTime($[WORD nDosDate], $[WORD nDosTime], $[FILETIME * lpFileTime])

$~CoFileTimeToDosDateTime
$[BOOL ]CoFileTimeToDosDateTime($[FILETIME * lpFileTime], $[LPWORD lpDosDate], $[LPWORD lpDosTime])

$~CoIsHandlerConnected
$[BOOL ]CoIsHandlerConnected($[LPUNKNOWN pUnk])

$~CoIsOle1Class
$[BOOL ]CoIsOle1Class($[REFCLSID rclsid])

$~IsAccelerator
$[BOOL ]IsAccelerator($[HACCEL hAccel], $[INT cAccelEntries], $[LPMSG lpMsg], $[WORD * lpwCmd])

$~IsEqualGUID
$[BOOL ]IsEqualGUID($[REFGUID rguid1], $[REFGUID rguid2])

$~OleIsRunning
$[BOOL ]OleIsRunning($[LPOLEOBJECT pObject])

$~CoGetCurrentProcess
$[DWORD ]CoGetCurrentProcess($[])

$~OleDuplicateData
$[HANDLE ]OleDuplicateData($[HANDLE hSrc], $[CLIPFORMAT cfFormat], $[UINT uiFlags])

$~OleGetIconOfClass
$[HGLOBAL ]OleGetIconOfClass($[REFCLSID rclsid], $[LPOLESTR lpszLabel], $[BOOL fUseTypeAsLabel])

$~OleGetIconOfFile
$[HGLOBAL ]OleGetIconOfFile($[LPOLESTR lpszPath], $[BOOL fUseFileAsLabel])

$~OleMetafilePictFromIconAndLabel
$[HGLOBAL ]OleMetafilePictFromIconAndLabel($[HICON hIcon], $[LPOLESTR lpszLabel], $[LPOLESTR lpszSourceFile], $[UINT iIconIndex])

$~CoLoadLibrary
$[HINSTANCE ]CoLoadLibrary($[LPOLESTR lpszLibName], $[BOOL bAutoFree])

$~OleCreateMenuDescriptor
$[HOLEMENU ]OleCreateMenuDescriptor($[HMENU hmenuCombined], $[LPOLEMENUGROUPWIDTHS lpMenuWidths])

$~BindMoniker
$[HRESULT ]BindMoniker($[LPMONIKER pmk], $[DWORD grfOpt], $[REFIID iidResult], $[LPVOID FAR * ppvResult])

$~CLSIDFromProgID
$[HRESULT ]CLSIDFromProgID($[LPCOLESTR progid], $[LPCLSID clsid])

$~CLSIDFromProgIDEx
$[HRESULT ]CLSIDFromProgIDEx($[LPCOLESTR progid], $[LPCLSID riid])

$~CLSIDFromString
$[HRESULT ]CLSIDFromString($[LPCWSTR s], $[LPCLSID clsid])

$~CoAllowSetForegroundWindow
$[HRESULT ]CoAllowSetForegroundWindow($[IUnknown * pUnk], $[LPVOID lpvReserved])

$~CoBuildVersion
$[HRESULT ]CoBuildVersion($[])

$~CoCancelCall
$[HRESULT ]CoCancelCall($[DWORD dwThreadID], $[ULONG ulTimeout])

$~CoCopyProxy
$[HRESULT ]CoCopyProxy($[IUnknown * pProxy], $[IUnknown ** ppCopy])

$~CoCreateFreeThreadedMarshaler
$[HRESULT ]CoCreateFreeThreadedMarshaler($[LPUNKNOWN punkOuter], $[LPUNKNOWN* ppunkMarshal])

$~CoCreateGuid
$[HRESULT ]CoCreateGuid($[GUID* pguid])

$~CoDisableCallCancellation
$[HRESULT ]CoDisableCallCancellation($[LPVOID pvReserved])

$~CoEnableCallCancellation
$[HRESULT ]CoEnableCallCancellation($[LPVOID pvReserved])

$~CoFileTimeNow
$[HRESULT ]CoFileTimeNow($[FILETIME * lpFileTime])

$~CoGetCallContext
$[HRESULT ]CoGetCallContext($[REFIID riid], $[void ** ppInterface])

$~CoGetCallerTID
$[HRESULT ]CoGetCallerTID($[LPDWORD lpdwTID])

$~CoGetCancelObject
$[HRESULT ]CoGetCancelObject($[DWORD dwThreadID], $[REFIID riid], $[void ** ppUnk])

$~CoGetCurrentLogicalThreadId
$[HRESULT ]CoGetCurrentLogicalThreadId($[GUID * pGUID])

$~CoGetDefaultContext
$[HRESULT ]CoGetDefaultContext($[APTTYPE aptType], $[REFIID riid], $[void ** ppv])

$~CoGetInstanceFromFile
$[HRESULT ]CoGetInstanceFromFile($[COSERVERINFO * pServerInfo], $[CLSID * pclsid], $[IUnknown * punkOuter], $[DWORD dwClsCtx], $[DWORD grfMode], $[OLECHAR * szName], $[ULONG cmq], $[MULTI_QI * rgmqResults])

$~CoGetInstanceFromIStorage
$[HRESULT ]CoGetInstanceFromIStorage($[COSERVERINFO * pServerInfo], $[CLSID * pclsid], $[IUnknown * punkOuter], $[DWORD dwClsCtx], $[IStorage * pstg], $[ULONG cmq], $[MULTI_QI * rgmqResults])

$~CoGetInterceptor
$[HRESULT ]CoGetInterceptor($[REFIID iidIntercepted], $[IUnknown * punkOuter], $[REFIID iid], $[void ** ppv])

$~CoGetInterfaceAndReleaseStream
$[HRESULT ]CoGetInterfaceAndReleaseStream($[LPSTREAM pStm], $[REFIID riid], $[LPVOID * ppv])

$~CoGetMalloc
$[HRESULT ]CoGetMalloc($[DWORD dwMemContext], $[LPMALLOC * ppMalloc])

$~CoGetStdMarshalEx
$[HRESULT ]CoGetStdMarshalEx($[IUnknown * pUnkOuter], $[DWORD dwSMEXFlags], $[IUnknown ** ppUnkInner], )

$~CoGetTreatAsClass
$[HRESULT ]CoGetTreatAsClass($[REFCLSID clsidOld], $[LPCLSID pclsidNew])

$~CoImpersonateClient
$[HRESULT ]CoImpersonateClient($[])

$~CoInitialize
$[HRESULT ]CoInitialize($[LPVOID pvReserved])

$~CoInitializeEx
$[HRESULT ]CoInitializeEx($[void * pvReserved], $[DWORD dwCoInit])

$~CoInitializeSecurity
$[HRESULT ]CoInitializeSecurity($[PSECURITY_DESCRIPTOR pVoid], $[LONG cAuthSvc], $[SOLE_AUTHENTICATION_SERVICE * asAuthSvc], $[void * pReserved1], $[DWORD dwAuthnLevel], $[DWORD dwImpLevel], $[SOLE_AUTHENTICATION_LIST * pAuthList], $[DWORD dwCapabilities], $[void * pReserved3])

$~CoInstall
$[HRESULT ]CoInstall($[IBindCtx * pbc], $[DWORD dwFlags], $[uCLSSPEC * pClassSpec], $[QUERYCONTEXT * pQuery], $[LPWSTR pszCodeBase])

$~CoInvalidateRemoteMachineBindings
$[HRESULT ]CoInvalidateRemoteMachineBindings($[LPOLESTR pszMachineName])

$~CoMarshalInterThreadInterfaceInStream
$[HRESULT ]CoMarshalInterThreadInterfaceInStream($[REFIID riid], $[LPUNKNOWN pUnk], $[LPSTREAM * ppStm])

$~CoQueryAuthenticationServices
$[HRESULT ]CoQueryAuthenticationServices($[DWORD * pcAuthSvc], $[SOLE_AUTHENTICATION_SERVICE ** asAuthSvc])

$~CoQueryClientBlanket
$[HRESULT ]CoQueryClientBlanket($[DWORD * pAuthnSvc], $[DWORD * pAuthzSvc], $[OLECHAR ** pServerPrincName], $[DWORD * pAuthnLevel], $[DWORD * pImpLevel], $[RPC_AUTHZ_HANDLE * pPrivs], $[DWORD * pCapabilities])

$~CoQueryProxyBlanket
$[HRESULT ]CoQueryProxyBlanket($[IUnknown * pProxy], $[DWORD * pAuthnSvc], $[DWORD * pAuthzSvc], $[OLECHAR ** pServerPrincName], $[DWORD * pAuthnLevel], $[DWORD * pImpLevel], $[RPC_AUTH_IDENTITY_HANDLE * ppAuthInfo], $[DWORD * pCapabilities])

$~CoRegisterInitializeSpy
$[HRESULT ]CoRegisterInitializeSpy($[LPINITIALIZESPY lpInitializeSpy], $[ULARGE_INTEGER * pUliCookie])

$~CoRegisterMallocSpy
$[HRESULT ]CoRegisterMallocSpy($[LPMALLOCSPY pMallocSpy])

$~CoRegisterMessageFilter
$[HRESULT ]CoRegisterMessageFilter($[LPMESSAGEFILTER lpMessageFilter], $[LPMESSAGEFILTER * lplpMessageFilter])

$~CoRegisterSurrogate
$[HRESULT ]CoRegisterSurrogate($[ISurrogate * pSurrogate])

$~CoRegisterSurrogateEx
$[HRESULT ]CoRegisterSurrogateEx($[REFGUID rguidProcessID], $[void * reserved])

$~CoRevertToSelf
$[HRESULT ]CoRevertToSelf($[void])

$~CoRevokeClassObject
$[HRESULT ]CoRevokeClassObject($[DWORD dwRegister])

$~CoRevokeInitializeSpy
$[HRESULT ]CoRevokeInitializeSpy($[ULARGE_INTEGER uliCookie])

$~CoRevokeMallocSpy
$[HRESULT ]CoRevokeMallocSpy($[])

$~CoSetCancelObject
$[HRESULT ]CoSetCancelObject($[IUnknown * pUnk])

$~CoSetProxyBlanket
$[HRESULT ]CoSetProxyBlanket($[IUnknown * pProxy], $[DWORD dwAuthnSvc], $[DWORD dwAuthzSvc], $[WCHAR * pServerPrincName], $[DWORD dwAuthnLevel], $[DWORD dwImpLevel], $[RPC_AUTH_IDENTITY_HANDLE pAuthInfo], $[DWORD dwCapabilities])

$~CoSwitchCallContext
$[HRESULT ]CoSwitchCallContext($[IUnknown * pNewObject], $[IUnknown ** ppOldObject])

$~CoTestCancel
$[HRESULT ]CoTestCancel($[])

$~CoWaitForMultipleHandles
$[HRESULT ]CoWaitForMultipleHandles($[DWORD dwFlags], $[DWORD dwTimeout], $[ULONG cHandles], $[LPHANDLE pHandles], $[LPDWORD lpdwindex])

$~FmtIdToPropStgName
$[HRESULT ]FmtIdToPropStgName($[const FMTID* pfmtid], $[LPOLESTR oszName])

$~GetErrorInfo
$[HRESULT ]GetErrorInfo($[DWORD dwReserved], $[IerrorInfo** pperrinfo])

$~OleCreateEx
$[HRESULT ]OleCreateEx($[REFCLSID rclsid], $[REFIID riid], $[DWORD dwFlags], $[DWORD renderopt], $[ULONG cFormats], $[DWORD rgAdvf], $[LPFORMATETC rgFormatEtc], $[LPADVISESINK pAdviseSink], $[IAdviseSink pointer DWORD* rgdwConnection], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateFromDataEx
$[HRESULT ]OleCreateFromDataEx($[LPDATAOBJECT pSrcDataObj], $[REFIID riid], $[DWORD dwFlags], $[DWORD renderopt], $[ULONG cFormats], $[DWORD rgAdvf], $[LPFORMATETC rgFormatEtc], $[LPADVISESINK pAdviseSink], $[DWORD FAR* rgdwConnection], $[LPCLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateFromFileEx
$[HRESULT ]OleCreateFromFileEx($[REFCLSID rclsid], $[LPCOLESTR lpszFileName], $[REFIID riid], $[DWORD dwFlags], $[DWORD renderopt], $[ULONG cFormats], $[DWORD rgAdvf], $[LPFORMATETC rgFormatEtc], $[LPADVISESINK pAdviseSink], $[DWORD FAR* rgdwConnection], $[LPCLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateLinkFromDataEx
$[HRESULT ]OleCreateLinkFromDataEx($[LPDATAOBJECT pSrcDataObj], $[REFIID riid], $[DWORD dwFlags], $[DWORD renderopt], $[ULONG cFormats], $[DWORD rgAdvf], $[LPFORMATETC rgFormatEtc], $[LPADVISESINK pAdviseSink], $[DWORD FAR* rgdwConnection], $[LPCLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateLinkToFileEx
$[HRESULT ]OleCreateLinkToFileEx($[LPCOLESTR lpszFileName], $[REFIID riid], $[DWORD dwFlags], $[DWORD renderopt], $[ULONG cFormats], $[DWORD rgAdvf], $[LPFORMATETC rgFormatEtc], $[LPADVISESINK pAdviseSink], $[DWORD FAR* rgdwConnection], $[LPCLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~PropStgNameToFmtId
$[HRESULT ]PropStgNameToFmtId($[const LPOLESTR oszName], $[FMTID* pfmtid])

$~PropVariantChangeType
$[HRESULT ]PropVariantChangeType($[PROPVARIANT *ppropvarDest], $[REFPROPVARIANT propvarSrc], $[PROPVAR_CHANGE_FLAGS flags], $[VARTYPE vt])

$~PropVariantClear
$[HRESULT ]PropVariantClear($[PROPVARIANT *pvar])

$~PropVariantCopy
$[HRESULT ]PropVariantCopy($[PROPVARIANT *pvarDest], $[const PROPVARIANT *pvarSrc])

$~SetErrorInfo
$[HRESULT ]SetErrorInfo($[DWORD dwReserved], $[IErrorInfo *perrinfo])

$~StgConvertPropertyToVariant
$[HRESULT ]StgConvertPropertyToVariant($[const SERIALIZEDPROPERTYVALUE *pprop], $[USHORT CodePage], $[PROPVARIANT *pVar], $[PMemoryAllocator *pma])

$~StgConvertVariantToProperty
$[HRESULT ]StgConvertVariantToProperty($[const PROPVARIANT *pVar], $[USHORT CodePage], $[SERIALIZEDPROPERTYVALUE *pprop], $[ULONG *pcb], $[PROPID pid], $[BOOLEAN fReserved], $[ULONG *pcIndirect])

$~StgCreateDocfile
$[HRESULT ]StgCreateDocfile($[const WCHAR* pwcsName], $[DWORD grfMode], $[DWORD reserved], $[IStorage** ppstgOpen])

$~StgCreatePropSetStg
$[HRESULT ]StgCreatePropSetStg($[IStorage* pStorage], $[DWORD dwReserved], $[IPropertySetStorage** ppPropSetStg])

$~StgCreatePropStg
$[HRESULT ]StgCreatePropStg($[IUnknown* pUnk], $[REFFMTID fmtid], $[const CLSID* pclsid], $[DWORD grfFlags], $[DWORD dwReserved], $[IPropertyStorage** ppPropStg])

$~StgOpenPropStg
$[HRESULT ]StgOpenPropStg($[IUnknown* pUnk], $[REFFMTID fmtid], $[DWORD grfFlags], $[DWORD dwReserved], $[IPropertyStorage** ppPropStg])

$~StgOpenStorage
$[HRESULT ]StgOpenStorage($[const WCHAR* pwcsName], $[IStorage* pstgPriority], $[DWORD grfMode], $[SNB snbExclude], $[DWORD reserved], $[IStorage** ppstgOpen])

$~StgOpenStorageEx
$[HRESULT ]StgOpenStorageEx($[const WCHAR* pwcsName], $[DWORD grfMode], $[STGFMT stgfmt], $[DWORD grfAttrs], $[STGOPTIONS* pStgOptions], $[void* reserved2], $[REFIID riid], $[void** ppObjectOpen])

$~DllGetClassObject
$[HRESULTI ]DllGetClassObject($[REFCLSID rclsid], $[REFIID riid], $[LPVOID * ppv])

$~StringFromGUID2
$[int ]StringFromGUID2($[REFGUID rguid], $[LPOLESTR lpsz], $[int cchMax])

$~CoTaskMemAlloc
$[LPVOID ]CoTaskMemAlloc($[ULONG cb])

$~CoTaskMemRealloc
$[LPVOID ]CoTaskMemRealloc($[LPVOID pv], $[ULONG cb])

$~CoDisconnectObject
$[STDAPI ]CoDisconnectObject($[IUnknown * pUnk], $[DWORD dwReserved])

$~CoGetContextToken
$[STDAPI ]CoGetContextToken($[ULONG_PTR * pToken])

$~CoGetMarshalSizeMax
$[STDAPI ]CoGetMarshalSizeMax($[ULONG * pulSize], $[REFIID riid], $[IUnknown * pUnk], $[DWORD dwDestContext], $[LPVOID pvDestContext], $[DWORD mshlflags])

$~CoGetStandardMarshal
$[STDAPI ]CoGetStandardMarshal($[REFIID riid], $[IUnknown * pUnk], $[DWORD dwDestContext], $[LPVOID pvDestContext], $[DWORD mshlflags], $[LPMARSHAL * ppMarshal])

$~CoLockObjectExternal
$[STDAPI ]CoLockObjectExternal($[IUnknown * pUnk], $[BOOL fLock], $[BOOL fLastUnlockReleases])

$~CoMarshalHresult
$[STDAPI ]CoMarshalHresult($[IStream * pStm], $[HRESULT hresult])

$~CoMarshalInterface
$[STDAPI ]CoMarshalInterface($[IStream * pStm], $[REFIID riid], $[IUnknown * pUnk], $[DWORD dwDestContext], $[void * pvDestContext], $[DWORD mshlflags])

$~CoRegisterClassObject
$[STDAPI ]CoRegisterClassObject($[REFCLSID rclsid], $[IUnknown * pUnk], $[DWORD dwClsContext], $[DWORD flags], $[LPDWORD lpdwRegister])

$~CoReleaseMarshalData
$[STDAPI ]CoReleaseMarshalData($[IStream * pStm])

$~CoTreatAsClass
$[STDAPI ]CoTreatAsClass($[REFCLSID clsidOld], $[REFCLSID clsidNew])

$~CoUnmarshalHresult
$[STDAPI ]CoUnmarshalHresult($[LPSTREAM pStm], $[HRESULT * phresult])

$~CoUnmarshalInterface
$[STDAPI ]CoUnmarshalInterface($[IStream * pStm], $[REFIID riid], $[void ** ppv])

$~DllRegisterServer
$[STDAPI ]DllRegisterServer($[])

$~CLIPFORMAT_UserMarshal
$[ULONG ]CLIPFORMAT_UserMarshal($[ULONG* pFlags], $[unsigned char* pBuffer], $[CLIPFORMAT* pCF])

$~CLIPFORMAT_UserSize
$[ULONG ]CLIPFORMAT_UserSize($[ULONG* pFlags], $[ULONG StartingSize], $[CLIPFORMAT* pCF])

$~CLIPFORMAT_UserUnmarshal
$[ULONG ]CLIPFORMAT_UserUnmarshal($[ULONG* pFlags], $[unsigned char* pBuffer], $[CLIPFORMAT* pCF])

$~CoAddRefServerProcess
$[ULONG ]CoAddRefServerProcess($[])

$~CoReleaseServerProcess
$[ULONG ]CoReleaseServerProcess($[])

$~StgPropertyLengthAsVariant
$[ULONG ]StgPropertyLengthAsVariant($[SERIALIZEDPROPERTYVALUE *pProp], $[ULONG cbProp], $[USHORT CodePage], $[BYTE bReserved])

$~CoFreeAllLibraries
$[void ]CoFreeAllLibraries($[])

$~CoFreeLibrary
$[void ]CoFreeLibrary($[HINSTANCE hInst])

$~CoFreeUnusedLibraries
$[void ]CoFreeUnusedLibraries($[])

$~CoFreeUnusedLibrariesEx
$[void ]CoFreeUnusedLibrariesEx($[DWORD dwUnloadDelay], $[DWORD dwReserved])

$~CoTaskMemFree
$[void ]CoTaskMemFree($[void * pv])

$~CoUninitialize
$[void ]CoUninitialize($[])

$~OleDestroyMenuDescriptor
$[void ]OleDestroyMenuDescriptor($[HOLEMENU holemenu])

$~OleUninitialize
$[void ]OleUninitialize($[])

$~ReleaseStgMedium
$[void ]ReleaseStgMedium($[STGMEDIUM * pmedium])

$~UpdateDCOMSettings
$[void ]UpdateDCOMSettings($[])

$~CoGetObject
$[WINOLEAPI ]CoGetObject($[LPCWSTR pszName], $[BIND_OPTS * pBindOptions], $[REFIID riid], $[void ** ppv])

$~CoGetObjectContext
$[WINOLEAPI ]CoGetObjectContext($[REFIID riid], $[LPVOID ** ppv])

$~CoGetPSClsid
$[WINOLEAPI ]CoGetPSClsid($[REFIID riid], $[CLSID * pclsid])

$~CoRegisterPSClsid
$[WINOLEAPI ]CoRegisterPSClsid($[REFIID riid], $[REFCLSID rclsid])

$~CoResumeClassObjects
$[WINOLEAPI ]CoResumeClassObjects($[])

$~CoSuspendClassObjects
$[WINOLEAPI ]CoSuspendClassObjects($[])

$~CreateAntiMoniker
$[WINOLEAPI ]CreateAntiMoniker($[LPMONIKER FAR * ppmk])

$~CreateBindCtx
$[WINOLEAPI ]CreateBindCtx($[DWORD reserved], $[LPBC FAR * ppbc])

$~CreateClassMoniker
$[WINOLEAPI ]CreateClassMoniker($[REFCLSID rclsid], $[IMoniker ** ppmk])

$~CreateDataAdviseHolder
$[WINOLEAPI ]CreateDataAdviseHolder($[IDataAdviseHolder **ppDAHolder])

$~CreateDataCache
$[WINOLEAPI ]CreateDataCache($[LPUNKNOWN pUnkOuter], $[REFCLSID rclsid], $[REFIID riid], $[LPVOID FAR *ppvObj])

$~CreateErrorInfo
$[WINOLEAPI ]CreateErrorInfo($[ICreateErrorInfo **pperrinfo])

$~CreateFileMoniker
$[WINOLEAPI ]CreateFileMoniker($[LPCOLESTR lpszPathName], $[LPMONIKER FAR * ppmk])

$~CreateGenericComposite
$[WINOLEAPI ]CreateGenericComposite($[LPMONIKER pmkFirst], $[LPMONIKER pmkRest], $[LPMONIKER FAR * ppmkComposite])

$~CreateILockBytesOnHGlobal
$[WINOLEAPI ]CreateILockBytesOnHGlobal($[HGLOBAL hGlobal], $[BOOL fDeleteOnRelease], $[ILockBytes** ppLkbyt])

$~CreateItemMoniker
$[WINOLEAPI ]CreateItemMoniker($[LPCOLESTR lpszDelim], $[LPCOLESTR lpszItem], $[LPMONIKER FAR * ppmk])

$~CreateObjrefMoniker
$[WINOLEAPI ]CreateObjrefMoniker($[LPUNKNOWN pUnk], $[LPMONIKER * ppMk])

$~CreateOleAdviseHolder
$[WINOLEAPI ]CreateOleAdviseHolder($[LPOLEADVISEHOLDER FAR* ppOAHolder])

$~CreatePointerMoniker
$[WINOLEAPI ]CreatePointerMoniker($[LPUNKNOWN punk], $[LPMONIKER FAR * ppmk])

$~CreateStreamOnHGlobal
$[WINOLEAPI ]CreateStreamOnHGlobal($[HGLOBAL hGlobal], $[BOOL fDeleteOnRelease], $[LPSTREAM* ppstm])

$~DoDragDrop
$[WINOLEAPI ]DoDragDrop($[IDataObject * pDataObject], $[IDropSource * pDropSource], $[DWORD dwOKEffect], $[DWORD * pdwEffect])

$~FreePropVariantArray
$[WINOLEAPI ]FreePropVariantArray($[ULONG cVariants], $[PROPVARIANT* rgvars])

$~GetClassFile
$[WINOLEAPI ]GetClassFile($[LPCWSTR szFileName], $[CLSID * pclsid])

$~GetConvertStg
$[WINOLEAPI ]GetConvertStg($[IStorage* pStg])

$~GetHGlobalFromILockBytes
$[WINOLEAPI ]GetHGlobalFromILockBytes($[ILockBytes* pLkbyt], $[HGLOBAL* phglobal])

$~GetHGlobalFromStream
$[WINOLEAPI ]GetHGlobalFromStream($[IStream* pstm], $[HGLOBAL* phglobal])

$~GetRunningObjectTable
$[WINOLEAPI ]GetRunningObjectTable($[DWORD reserved], $[LPRUNNINGOBJECTTABLE * pprot])

$~IIDFromString
$[WINOLEAPI ]IIDFromString($[LPOLESTR lpsz], $[LPIID lpiid])

$~MkParseDisplayName
$[WINOLEAPI ]MkParseDisplayName($[LPBC pbc], $[LPCOLESTR szUserName], $[ULONG FAR * pchEaten], $[LPMONIKER FAR * ppmk])

$~MonikerRelativePathTo
$[WINOLEAPI ]MonikerRelativePathTo($[LPMONIKER pmkSrc], $[LPMONIKER pmkDest], $[LPMONIKER FAR * ppmkRelPath], $[BOOL dwReserved])

$~OleConvertIStorageToOLESTREAM
$[WINOLEAPI ]OleConvertIStorageToOLESTREAM($[IStorage* pStg], $[LPOLESTREAM lpolestream])

$~OleConvertIStorageToOLESTREAMEx
$[WINOLEAPI ]OleConvertIStorageToOLESTREAMEx($[IStorage* pStg], $[CLIPFORMAT cfFormat], $[LONG lWidth], $[LONG lHeight], $[DWORD dwSize], $[STGMEDIUM pmedium], $[LPOLESTREAM lpolestm])

$~OleConvertOLESTREAMToIStorage
$[WINOLEAPI ]OleConvertOLESTREAMToIStorage($[LPOLESTREAM lpolestream], $[IStorage* pstg], $[const DVTARGETDEVICE* ptd])

$~OleConvertOLESTREAMToIStorageEx
$[WINOLEAPI ]OleConvertOLESTREAMToIStorageEx($[LPOLESTREAM lpolestm], $[IStorage* pstg], $[CLIPFORMAT* pcfFormat], $[LONG* plWidth], $[LONG* plHeight], $[DWORD* pdwSize], $[STGMEDIUM pmedium])

$~OleCreate
$[WINOLEAPI ]OleCreate($[REFCLSID rclsid], $[REFIID riid], $[DWORD renderopt], $[FORMATETC * pFormatEtc], $[IOleClientSite * pClientSite], $[IStorage * pStg], $[void ** ppvObject])

$~OleCreateDefaultHandler
$[WINOLEAPI ]OleCreateDefaultHandler($[REFCLSID clsid], $[LPUNKNOWN pUnkOuter], $[REFIID riid], $[LPVOID FAR * ppvObj])

$~OleCreateEmbeddingHelper
$[WINOLEAPI ]OleCreateEmbeddingHelper($[REFCLSID clsid], $[LPUNKNOWN pUnkOuter], $[DWORD flags], $[LPCLASSFACTORY pCF], $[REFIID riid], $[LPVOID * ppvObj])

$~OleCreateFromData
$[WINOLEAPI ]OleCreateFromData($[LPDATAOBJECT pSrcDataObj], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateFromFile
$[WINOLEAPI ]OleCreateFromFile($[REFCLSID rclsid], $[LPCOLESTR lpszFileName], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateLink
$[WINOLEAPI ]OleCreateLink($[LPMONIKER pmkLinkSrc], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateLinkFromData
$[WINOLEAPI ]OleCreateLinkFromData($[LPDATAOBJECT pSrcDataObj], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleCreateLinkToFile
$[WINOLEAPI ]OleCreateLinkToFile($[LPWSTR lpszFileName], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[IOleClientSite * pClientSite], $[IStorage * pStg], $[void ** ppvObj])

$~OleCreateStaticFromData
$[WINOLEAPI ]OleCreateStaticFromData($[LPDATAOBJECT pSrcDataObj], $[REFIID riid], $[DWORD renderopt], $[LPFORMATETC pFormatEtc], $[LPOLECLIENTSITE pClientSite], $[LPSTORAGE pStg], $[LPVOID FAR* ppvObj])

$~OleDoAutoConvert
$[WINOLEAPI ]OleDoAutoConvert($[IStorage * pStg], $[LPCLSID pClsidNew])

$~OleDraw
$[WINOLEAPI ]OleDraw($[IUnknown * pUnk], $[DWORD dwAspect], $[HDC hdcDraw], $[LPCRECT lprcBounds])

$~OleFlushClipboard
$[WINOLEAPI ]OleFlushClipboard($[])

$~OleGetAutoConvert
$[WINOLEAPI ]OleGetAutoConvert($[REFCLSID clsidOld], $[LPCLSID pClsidNew])

$~OleGetClipboard
$[WINOLEAPI ]OleGetClipboard($[IDataObject ** ppDataObj])

$~OleInitialize
$[WINOLEAPI ]OleInitialize($[LPVOID pvReserved])

$~OleIsCurrentClipboard
$[WINOLEAPI ]OleIsCurrentClipboard($[IDataObject * pDataObject])

$~OleLoad
$[WINOLEAPI ]OleLoad($[IStorage * pStg], $[REFIID riid], $[IOleClientSite * pClientSite], $[LPVOID * ppvObj])

$~OleLoadFromStream
$[WINOLEAPI ]OleLoadFromStream($[IStream * pStm], $[REFIID iidInterface], $[void ** ppvObj])

$~OleLockRunning
$[WINOLEAPI ]OleLockRunning($[LPUNKNOWN pUnknown], $[BOOL fLock], $[BOOL fLastUnlockCloses])

$~OleNoteObjectVisible
$[WINOLEAPI ]OleNoteObjectVisible($[LPUNKNOWN pUnknown], $[BOOL fVisible])

$~OleQueryCreateFromData
$[WINOLEAPI ]OleQueryCreateFromData($[IDataObject * pSrcDataObject])

$~OleQueryLinkFromData
$[WINOLEAPI ]OleQueryLinkFromData($[IDataObject * pSrcDataObject])

$~OleRegEnumFormatEtc
$[WINOLEAPI ]OleRegEnumFormatEtc($[DWORD dwDirection], $[IEnumFORMATETC** ppenumFormatetc])

$~OleRegEnumVerbs
$[WINOLEAPI ]OleRegEnumVerbs($[REFCLSID clsid], $[LPENUMOLEVERB * ppenumOleVerb])

$~OleRegGetMiscStatus
$[WINOLEAPI ]OleRegGetMiscStatus($[REFCLSID clsid], $[DWORD dwFormOfType], $[LPOLESTR * pszUserType])

$~OleRegGetUserType
$[WINOLEAPI ]OleRegGetUserType($[REFCLSID clsid], $[DWORD dwFormOfType], $[LPOLESTR * pszUserType])

$~OleRun
$[WINOLEAPI ]OleRun($[LPUNKNOWN pUnknown])

$~OleSave
$[WINOLEAPI ]OleSave($[IPersistStorage * pPS], $[IStorage * pStg], $[BOOL fSameAsLoad])

$~OleSaveToStream
$[WINOLEAPI ]OleSaveToStream($[IPersistStream * pPStm], $[IStream * pStm])

$~OleSetAutoConvert
$[WINOLEAPI ]OleSetAutoConvert($[REFCLSID clsidOld], $[REFCLSID clsidNew])

$~OleSetClipboard
$[WINOLEAPI ]OleSetClipboard($[IDataObject * pDataObj])

$~OleSetContainedObject
$[WINOLEAPI ]OleSetContainedObject($[LPUNKNOWN pUnk], $[BOOL fContained])

$~OleSetMenuDescriptor
$[WINOLEAPI ]OleSetMenuDescriptor($[HOLEMENU holemenu], $[HWND hwndFrame], $[HWND hwndActiveObject], $[LPOLEINPLACEFRAME lpFrame], $[LPOLEINPLACEACTIVEOBJECT lpActiveObj])

$~OleTranslateAccelerator
$[WINOLEAPI ]OleTranslateAccelerator($[LPOLEINPLACEFRAME lpFrame], $[LPOLEINPLACEFRAMEINFO lpFrameInfo], $[LPMSG lpmsg])

$~ProgIDFromCLSID
$[WINOLEAPI ]ProgIDFromCLSID($[REFCLSID clsid], $[LPOLESTR * lplpszProgID])

$~ReadClassStg
$[WINOLEAPI ]ReadClassStg($[IStorage* pStg], $[CLSID* pclsid])

$~ReadClassStm
$[WINOLEAPI ]ReadClassStm($[IStream* pStm], $[CLSID* pclsid])

$~ReadFmtUserTypeStg
$[WINOLEAPI ]ReadFmtUserTypeStg($[IStorage* pStg], $[CLIPFORMAT* pcf], $[LPWSTR* lplpszUserType])

$~RegisterDragDrop
$[WINOLEAPI ]RegisterDragDrop($[HWND hwnd], $[IDropTarget * pDropTarget])

$~RevokeDragDrop
$[WINOLEAPI ]RevokeDragDrop($[HWND hwnd])

$~SetConvertStg
$[WINOLEAPI ]SetConvertStg($[IStorage* pStg], $[BOOL fConvert])

$~StgCreateDocfileOnILockBytes
$[WINOLEAPI ]StgCreateDocfileOnILockBytes($[ILockBytes* plkbyt], $[DWORD grfMode], $[DWORD reserved], $[IStorage** ppstgOpen])

$~StgCreateStorageEx
$[WINOLEAPI ]StgCreateStorageEx($[const WCHAR* pwcsName], $[DWORD grfMode], $[STGFMT stgfmt], $[DWORD grfAttrs], $[STGOPTIONS* pStgOptions], $[PSECURITY_DESCRIPTOR* pSecurityDescriptor], $[REFIID riid], $[void** ppObjectOpen])

$~StgGetIFillLockBytesOnFile
$[WINOLEAPI ]StgGetIFillLockBytesOnFile($[OLECHAR* pwcsName], $[IFillLockBytes** ppflb])

$~StgGetIFillLockBytesOnILockBytes
$[WINOLEAPI ]StgGetIFillLockBytesOnILockBytes($[ILockBytes* pilb], $[IFillLockBytes** ppflb])

$~StgIsStorageFile
$[WINOLEAPI ]StgIsStorageFile($[const WCHAR* pwcsName])

$~StgIsStorageILockBytes
$[WINOLEAPI ]StgIsStorageILockBytes($[ILockBytes* plkbyt])

$~StgOpenAsyncDocfileOnIFillLockBytes
$[WINOLEAPI ]StgOpenAsyncDocfileOnIFillLockBytes($[IFillLockBytes* ppflb], $[DWORD grfmode], $[DWORD asyncFlags], $[IStorage** ppstgOpen])

$~StgOpenStorageOnILockBytes
$[WINOLEAPI ]StgOpenStorageOnILockBytes($[ILockBytes* plkbyt], $[IStorage* pStgPriority], $[DWORD grfMode], $[SNB snbExclude], $[DWORD reserved], $[IStorage** ppstgOpen])

$~StgSetTimes
$[WINOLEAPI ]StgSetTimes($[WCHAR const* lpszName], $[FILETIME const* pctime], $[FILETIME const* patime], $[FILETIME const* pmtime])

$~StringFromCLSID
$[WINOLEAPI ]StringFromCLSID($[REFCLSID rclsid], $[LPOLESTR * ppsz])

$~StringFromIID
$[WINOLEAPI ]StringFromIID($[REFIID rclsid], $[LPOLESTR * lplpsz])

$~WriteClassStg
$[WINOLEAPI ]WriteClassStg($[IStorage* pStg], $[REFCLSID rclsid])

$~WriteClassStm
$[WINOLEAPI ]WriteClassStm($[IStream* pStm], $[REFCLSID rclsid])

$~WriteFmtUserTypeStg
$[WINOLEAPI ]WriteFmtUserTypeStg($[IStorage* pStg], $[CLIPFORMAT cf], $[LPWSTR* lpszUserType])

$; psapi.dll
$; ---------
$~EnumProcesses
$[BOOL ]EnumProcesses($[DWORD* lpidProcess], $[DWORD cb], $[DWORD* cbNeeded])

$~EnumProcessModules
$[BOOL ]EnumProcessModules($[HANDLE hProcess], $[HMODULE* lphModule], $[DWORD cb], $[LPDWORD lpcbNeeded])

$~GetModuleBaseNameA
$[DWORD ]GetModuleBaseNameA($[HANDLE hProcess], $[HMODULE hModule], $[LPSTR lpBaseName], $[DWORD nSize])

$~GetModuleBaseNameW
$[DWORD ]GetModuleBaseNameW($[HANDLE hProcess], $[HMODULE hModule], $[LPWSTR lpBaseName], $[DWORD nSize])

$; rasapi32.dll
$; ------------
$~DDMGetPhonebookInfo
$[DWORD ]DDMGetPhonebookInfo($[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~DwCloneEntry
$[DWORD ]DwCloneEntry($[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~DwDeleteSubEntry
$[DWORD ]DwDeleteSubEntry($[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~DwEnumEntriesForAllUsers
$[DWORD ]DwEnumEntriesForAllUsers($[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~DwEnumEntryDetails
$[DWORD ]DwEnumEntryDetails($[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~DwRasRefreshKerbScCreds
$[DWORD ]DwRasRefreshKerbScCreds($[UNKNOWN])

$~DwRasUninitialize
$[DWORD ]DwRasUninitialize($[])

$~RasAutodialAddressToNetwork
$[DWORD ]RasAutodialAddressToNetwork ($[wchar_t *cbData], $[LPWSTR lpString1], $[int])

$~RasAutodialEntryToNetwork
$[DWORD ]RasAutodialEntryToNetwork($[int lpValueName], $[LPWSTR lpString1], $[int])

$~RasAutoDialSharedConnection
$[DWORD ]RasAutoDialSharedConnection($[])

$~RasClearConnectionStatistics
$[DWORD ]RasClearConnectionStatistics($[HRASCONN hRasConn], $[RAS_STATS* lpStatistics])

$~RasClearLinkStatistics
$[DWORD ]RasClearLinkStatistics($[HRASCONN hRasConn], $[DWORD dwSubEntry])

$~RasConnectionNotificationA
$[DWORD ]RasConnectionNotificationA($[HRASCONN hrasconn], $[HANDLE hEvent], $[DWORD dwFlags])

$~RasConnectionNotificationW
$[DWORD ]RasConnectionNotificationW($[HRASCONN hrasconn], $[HANDLE hEvent], $[DWORD dwFlags])

$~RasCreatePhonebookEntryA
$[DWORD ]RasCreatePhonebookEntryA($[HWND hwnd], $[LPCSTR lpszPhonebook])

$~RasCreatePhonebookEntryW
$[DWORD ]RasCreatePhonebookEntryW($[HWND hwnd], $[LPCWSTR lpszPhonebook])

$~RasDeleteEntryA
$[DWORD ]RasDeleteEntryA($[LPWSTR lpszPhonebook], $[LPWSTR lpszEntry])

$~RasDeleteEntryW
$[DWORD ]RasDeleteEntryW($[LPWSTR lpszPhonebook], $[LPWSTR lpszEntry])

$~RasDeleteSubEntryA
$[DWORD ]RasDeleteSubEntryA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry], $[DWORD dwSubEntryId])

$~RasDeleteSubEntryW
$[DWORD ]RasDeleteSubEntryW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry], $[DWORD dwSubEntryId])

$~RasDialA
$[DWORD ]RasDialA($[LPRASDIALEXTENSIONS dialExtensions], $[LPSTR phoneBookPath], $[LPRASDIALPARAMS rasDialParam], $[DWORD NotifierType], $[LPVOID notifier], $[LPHRASCONN pRasConn])

$~RasDialW
$[DWORD ]RasDialW($[LPRASDIALEXTENSIONS dialExtensions], $[LPWSTR phoneBookPath], $[LPRASDIALPARAMS rasDialParam], $[DWORD NotifierType], $[LPVOID notifier], $[LPHRASCONN pRasConn])

$~RasDialWow
$[DWORD ]RasDialWow($[UNKNOWN], $[UNKNOWN], $[UNKNOWN], $[UNKNOWN])

$~RasEditPhonebookEntryA
$[DWORD ]RasEditPhonebookEntryA($[HWND hwnd], $[LPCSTR lpszPhonebook], $[LPCSTR lpszEntryName])

$~RasEditPhonebookEntryW
$[DWORD ]RasEditPhonebookEntryW($[HWND hwnd], $[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntryName])

$~RasEnumAutodialAddressesA
$[DWORD ]RasEnumAutodialAddressesA($[LPSTR* lppAddresses], $[LPDWORD lpdwcbAddresses], $[LPDWORD lpdwcAddresses])

$~RasEnumAutodialAddressesW
$[DWORD ]RasEnumAutodialAddressesW($[LPWSTR* lppAddresses], $[LPDWORD lpdwcbAddresses], $[LPDWORD lpdwcAddresses])

$~RasEnumConnectionsA
$[DWORD ]RasEnumConnectionsA($[LPRASCONN lprasconn], $[LPDWORD lpcb], $[LPDWORD lpcConnections])

$~RasEnumConnectionsW
$[DWORD ]RasEnumConnectionsW($[LPRASCONN lprasconn], $[LPDWORD lpcb], $[LPDWORD lpcConnections])

$~RasEnumConnectionsWow
$[DWORD ]RasEnumConnectionsWow($[LPRASCONN lprasconn], $[LPDWORD lpcb], $[LPDWORD lpcConnections])

$~RasEnumDevicesA
$[DWORD ]RasEnumDevicesA($[LPRASDEVINFOW lpRasDevinfo], $[LPDWORD lpcb], $[LPDWORD lpcDevices])

$~RasEnumDevicesW
$[DWORD ]RasEnumDevicesW($[LPRASDEVINFOW lpRasDevinfo], $[LPDWORD lpcb], $[LPDWORD lpcDevices])

$~RasEnumEntriesA
$[DWORD ]RasEnumEntriesA($[LPWSTR Reserved], $[LPWSTR lpszPhoneBookPath], $[LPRASENTRYNAME lprasentryname], $[LPDWORD lpcb], $[LPDWORD lpcEntries])

$~RasEnumEntriesW
$[DWORD ]RasEnumEntriesW($[LPWSTR Reserved], $[LPWSTR lpszPhoneBookPath], $[LPRASENTRYNAME lprasentryname], $[LPDWORD lpcb], $[LPDWORD lpcEntries])

$~RasEnumEntriesWow
$[DWORD ]RasEnumEntriesWow($[LPWSTR Reserved], $[LPWSTR lpszPhoneBookPath], $[LPRASENTRYNAME lprasentryname], $[LPDWORD lpcb], $[LPDWORD lpcEntries])

$~RasFreeEapUserIdentityA
$[DWORD ]RasFreeEapUserIdentityA($[HGLOBAL hMem])

$~RasFreeEapUserIdentityW
$[DWORD ]RasFreeEapUserIdentityW($[HGLOBAL hMem])

$~RasGetAutodialAddressA
$[DWORD ]RasGetAutodialAddressA($[LPCSTR lpszAddress], $[LPDWORD lpdwReserved], $[LPRASAUTODIALENTRY lpAutoDialEntries], $[LPDWORD lpdwcbAutoDialEntries], $[LPDWORD lpdwcAutoDialEntries])

$~RasGetAutodialAddressW
$[DWORD ]RasGetAutodialAddressW($[LPCWSTR lpszAddress], $[LPDWORD lpdwReserved], $[LPRASAUTODIALENTRY lpAutoDialEntries], $[LPDWORD lpdwcbAutoDialEntries], $[LPDWORD lpdwcAutoDialEntries])

$~RasGetAutodialEnableA
$[DWORD ]RasGetAutodialEnableA($[DWORD], $[LPBOOL])

$~RasGetAutodialEnableW
$[DWORD ]RasGetAutodialEnableW($[DWORD], $[LPBOOL])

$~RasGetAutodialParamA
$[DWORD ]RasGetAutodialParamA($[DWORD dwKey], $[LPVOID lpvValue], $[LPDWORD lpdwcbValue])

$~RasGetAutodialParamW
$[DWORD ]RasGetAutodialParamW($[DWORD dwKey], $[LPVOID lpvValue], $[LPDWORD lpdwcbValue])

$~RasGetConnectionStatistics
$[DWORD ]RasGetConnectionStatistics($[HRASCONN hRasConn], $[RAS_STATS* lpStatistics])

$~RasGetConnectResponse
$[DWORD ]RasGetConnectResponse($[UNKNOWN], $[UNKNOWN])

$~RasGetConnectStatusA
$[DWORD ]RasGetConnectStatusA($[HRASCONN hrasconn], $[LPRASCONNSTATUS lprasconnstatus])

$~RasGetConnectStatusW
$[DWORD ]RasGetConnectStatusW($[HRASCONN hrasconn], $[LPRASCONNSTATUS lprasconnstatus])

$~RasGetCountryInfoA
$[DWORD ]RasGetCountryInfoA($[LPRASCTRYINFO lpRasCtryInfo], $[LPDWORD lpdwSize])

$~RasGetCountryInfoW
$[DWORD ]RasGetCountryInfoW($[LPRASCTRYINFO lpRasCtryInfo], $[LPDWORD lpdwSize])

$~RasGetCredentialsA
$[DWORD ]RasGetCredentialsA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry], $[LPRASCREDENTIALS lpCredentials])

$~RasGetCredentialsW
$[DWORD ]RasGetCredentialsW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry], $[LPRASCREDENTIALS lpCredentials])

$~RasGetCustomAuthDataA
$[DWORD ]RasGetCustomAuthDataA($[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[BYTE* pbCustomAuthData], $[DWORD* pdwSizeofCustomAuthData])

$~RasGetCustomAuthDataW
$[DWORD ]RasGetCustomAuthDataW($[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[BYTE* pbCustomAuthData], $[DWORD* pdwSizeofCustomAuthData])

$~RasGetEapUserDataA
$[DWORD ]RasGetEapUserDataA($[HANDLE hToken], $[LPCSTR pszPhonebook], $[LPCSTR pszEntry], $[PBYTE pbEapData], $[PDWORD pdwSizeofEapData])

$~RasGetEapUserDataW
$[DWORD ]RasGetEapUserDataW($[HANDLE hToken], $[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[PBYTE pbEapData], $[PDWORD pdwSizeofEapData])

$~RasGetEntryDialParamsA
$[DWORD ]RasGetEntryDialParamsA($[LPCSTR lpszPhonebook], $[LPRASDIALPARAMS lprasdialparams], $[LPBOOL lpfPassword])

$~RasGetEntryDialParamsW
$[DWORD ]RasGetEntryDialParamsW($[LPCWSTR lpszPhonebook], $[LPRASDIALPARAMS lprasdialparams], $[LPBOOL lpfPassword])

$~RasGetEntryPropertiesA
$[DWORD ]RasGetEntryPropertiesA($[LPWSTR lpszPhoneBook], $[LPWSTR szEntry], $[LPRASENTRY lpbEntry], $[LPDWORD lpdwEntrySize], $[LPBYTE lpb], $[LPDWORD lpdwSize])

$~RasGetEntryPropertiesW
$[DWORD ]RasGetEntryPropertiesW($[LPWSTR lpszPhoneBook], $[LPWSTR szEntry], $[LPRASENTRY lpbEntry], $[LPDWORD lpdwEntrySize], $[LPBYTE lpb], $[LPDWORD lpdwSize])

$~RasGetErrorStringA
$[DWORD ]RasGetErrorStringA($[UINT uErrorValue], $[LPSTR lpszErrorString], $[DWORD cBufSize])

$~RasGetErrorStringW
$[DWORD ]RasGetErrorStringW($[UINT uErrorValue], $[LPWSTR lpszErrorString], $[DWORD cBufSize])

$~RasGetLinkStatistics
$[DWORD ]RasGetLinkStatistics($[HRASCONN hRasConn], $[DWORD dwSubEntry], $[RAS_STATS* lpStatistics])

$~RasGetProjectionInfoA
$[DWORD ]RasGetProjectionInfoA($[HRASCONN hrasconn], $[RASPROJECTION rasprojection], $[LPVOID lpprojection], $[LPDWORD lpcb])

$~RasGetProjectionInfoW
$[DWORD ]RasGetProjectionInfoW($[HRASCONN hrasconn], $[RASPROJECTION rasprojection], $[LPVOID lpprojection], $[LPDWORD lpcb])

$~RasGetSubEntryHandleA
$[DWORD ]RasGetSubEntryHandleA($[HRASCONN hrasconn], $[DWORD dwSubEntry], $[LPHRASCONN lphrasconn])

$~RasGetSubEntryHandleW
$[DWORD ]RasGetSubEntryHandleW($[HRASCONN hrasconn], $[DWORD dwSubEntry], $[LPHRASCONN lphrasconn])

$~RasGetSubEntryPropertiesA
$[DWORD ]RasGetSubEntryPropertiesA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry], $[DWORD dwSubEntry], $[LPRASSUBENTRY lpRasSubEntry], $[LPDWORD lpdwcb], $[LPBYTE lpbDeviceConfig], $[LPDWORD lpcbDeviceConfig])

$~RasGetSubEntryPropertiesW
$[DWORD ]RasGetSubEntryPropertiesW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry], $[DWORD dwSubEntry], $[LPRASSUBENTRY lpRasSubEntry], $[LPDWORD lpdwcb], $[LPBYTE lpbDeviceConfig], $[LPDWORD lpcbDeviceConfig])

$~RasHangUpA
$[DWORD ]RasHangUpA($[HRASCONN hrasconn])

$~RasHangUpW
$[DWORD ]RasHangUpW($[HRASCONN hrasconn])

$~RasHangUpWow
$[DWORD ]RasHangUpWow($[HRASCONN hrasconn])

$~RasRenameEntryA
$[DWORD ]RasRenameEntryA($[LPWSTR lpszPhonebook], $[LPWSTR lpszOldEntry], $[LPWSTR lpszNewEntry])

$~RasRenameEntryW
$[DWORD ]RasRenameEntryW($[LPWSTR lpszPhonebook], $[LPWSTR lpszOldEntry], $[LPWSTR lpszNewEntry])

$~RasSetAutodialEnableA
$[DWORD ]RasSetAutodialEnableA($[DWORD dwDialingLocation], $[BOOL fEnabled])

$~RasSetAutodialEnableW
$[DWORD ]RasSetAutodialEnableW($[DWORD dwDialingLocation], $[BOOL fEnabled])

$~RasSetAutodialParamA
$[DWORD ]RasSetAutodialParamA($[DWORD dwKey], $[LPVOID lpvValue], $[DWORD dwcbValue])

$~RasSetAutodialParamW
$[DWORD ]RasSetAutodialParamW($[DWORD dwKey], $[LPVOID lpvValue], $[DWORD dwcbValue])

$~RasSetCredentialsA
$[DWORD ]RasSetCredentialsA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry], $[LPRASCREDENTIALS lpCredentials], $[BOOL fClearCredentials])

$~RasSetCredentialsW
$[DWORD ]RasSetCredentialsW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry], $[LPRASCREDENTIALS lpCredentials], $[BOOL fClearCredentials])

$~RasSetCustomAuthDataA
$[DWORD ]RasSetCustomAuthDataA($[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[BYTE* pbCustomAuthData], $[DWORD dwSizeofCustomAuthData])

$~RasSetCustomAuthDataW
$[DWORD ]RasSetCustomAuthDataW($[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[BYTE* pbCustomAuthData], $[DWORD dwSizeofCustomAuthData])

$~RasSetEapUserDataA
$[DWORD ]RasSetEapUserDataA($[HANDLE hToken], $[LPCSTR pszPhonebook], $[LPCSTR pszEntry], $[BYTE* pbEapData], $[DWORD dwSizeofEapData])

$~RasSetEapUserDataW
$[DWORD ]RasSetEapUserDataW($[HANDLE hToken], $[LPCWSTR pszPhonebook], $[LPCWSTR pszEntry], $[BYTE* pbEapData], $[DWORD dwSizeofEapData])

$~RasSetEntryDialParamsA
$[DWORD ]RasSetEntryDialParamsA($[LPCSTR lpszPhonebook], $[LPRASDIALPARAMS lprasdialparams], $[BOOL fRemovePassword])

$~RasSetEntryDialParamsW
$[DWORD ]RasSetEntryDialParamsW($[LPCWSTR lpszPhonebook], $[LPRASDIALPARAMS lprasdialparams], $[BOOL fRemovePassword])

$~RasSetEntryPropertiesA
$[DWORD ]RasSetEntryPropertiesA($[LPWSTR lpszPhoneBook], $[LPWSTR szEntry], $[LPRASENTRY lpbEntry], $[DWORD dwEntrySize], $[LPBYTE lpb], $[DWORD dwSize])

$~RasSetEntryPropertiesW
$[DWORD ]RasSetEntryPropertiesW($[LPWSTR lpszPhoneBook], $[LPWSTR szEntry], $[LPRASENTRY lpbEntry], $[DWORD dwEntrySize], $[LPBYTE lpb], $[DWORD dwSize])

$~RasSetSubEntryPropertiesA
$[DWORD ]RasSetSubEntryPropertiesA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry], $[DWORD dwSubEntry], $[LPRASSUBENTRY lpRasSubEntry], $[DWORD dwcbRasSubEntry LPBYTE lpbDeviceConfig], $[DWORD dwcbDeviceConfig])

$~RasSetSubEntryPropertiesW
$[DWORD ]RasSetSubEntryPropertiesW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry], $[DWORD dwSubEntry], $[LPRASSUBENTRY lpRasSubEntry], $[DWORD dwcbRasSubEntry LPBYTE lpbDeviceConfig], $[DWORD dwcbDeviceConfig])

$~RasValidateEntryNameA
$[DWORD ]RasValidateEntryNameA($[LPCSTR lpszPhonebook], $[LPCSTR lpszEntry])

$~RasValidateEntryNameW
$[DWORD ]RasValidateEntryNameW($[LPCWSTR lpszPhonebook], $[LPCWSTR lpszEntry])

$; secur32.dll
$; -----------
$~GetComputerObjectNameA
$[BOOLEAN ]GetComputerObjectNameA($[EXTENDED_NAME_FORMAT NameFormat], $[LPSTR lpNameBuffer], $[PULONG lpnSize])

$~GetComputerObjectNameW
$[BOOLEAN ]GetComputerObjectNameW($[EXTENDED_NAME_FORMAT NameFormat], $[LPWSTR lpNameBuffer], $[PULONG lpnSize])

$~GetUserNameExA
$[BOOLEAN ]GetUserNameExA($[EXTENDED_NAME_FORMAT NameFormat], $[LPSTR lpNameBuffer], $[PULONG lpnSize])

$~GetUserNameExW
$[BOOLEAN ]GetUserNameExW($[EXTENDED_NAME_FORMAT NameFormat], $[LPWSTR lpNameBuffer], $[PULONG lpnSize])

$~TranslateNameA
$[BOOLEAN ]TranslateNameA($[LPCSTR lpAccountName], $[EXTENDED_NAME_FORMAT AccountNameFormat], $[EXTENDED_NAME_FORMAT DesiredNameFormat], $[LPSTR lpTranslatedName], $[PULONG nSize])

$~TranslateNameW
$[BOOLEAN ]TranslateNameW($[LPCWSTR lpAccountName], $[EXTENDED_NAME_FORMAT AccountNameFormat], $[EXTENDED_NAME_FORMAT DesiredNameFormat], $[LPWSTR lpTranslatedName], $[PULONG nSize])

$~GetSecurityUserInfo
$[HRESULT ]GetSecurityUserInfo($[PLUID LogonId], $[ULONG Flags], $[PSecurityUserData *UserInformation])

$~SecpTranslateNameEx
$[int ]SecpTranslateNameEx($[DWORD dwErrCode], $[wchar_t *], $[int], $[int], $[int], $[int])

$~AddCredentialsA
$[NTSTATUS ]AddCredentialsA($[LSA_SEC_HANDLE CredentialHandle], $[PANSI_STRING PrincipalName], $[PANSI_STRING Package], $[ULONG CredentialUseFlags], $[PVOID AuthorizationData], $[PVOID GetKeyFunction], $[PVOID GetKeyArgument], $[PTimeStamp ExpirationTime])

$~AddCredentialsW
$[NTSTATUS ]AddCredentialsW($[LSA_SEC_HANDLE CredentialHandle], $[PUNICODE_STRING PrincipalName], $[PUNICODE_STRING Package], $[ULONG CredentialUseFlags], $[PVOID AuthorizationData], $[PVOID GetKeyFunction], $[PVOID GetKeyArgument], $[PTimeStamp ExpirationTime])

$~LsaCallAuthenticationPackage
$[NTSTATUS ]LsaCallAuthenticationPackage($[HANDLE LsaHandle], $[ULONG AuthenticationPackage], $[PVOID ProtocolSubmitBuffer], $[ULONG SubmitBufferLength], $[PVOID* ProtocolReturnBuffer], $[PULONG ReturnBufferLength], $[PNTSTATUS ProtocolStatus])

$~LsaConnectUntrusted
$[NTSTATUS ]LsaConnectUntrusted($[PHANDLE LsaHandle])

$~LsaDeregisterLogonProcess
$[NTSTATUS ]LsaDeregisterLogonProcess($[HANDLE LsaHandle])

$~LsaFreeReturnBuffer
$[NTSTATUS ]LsaFreeReturnBuffer($[PVOID Buffer])

$~LsaLogonUser
$[NTSTATUS ]LsaLogonUser($[HANDLE LsaHandle], $[PLSA_STRING OriginName], $[SECURITY_LOGON_TYPE LogonType], $[ULONG AuthenticationPackage], $[PVOID AuthenticationInformation], $[ULONG AuthenticationInformationLength], $[PTOKEN_GROUPS LocalGroups], $[PTOKEN_SOURCE SourceContext], $[PVOID* ProfileBuffer], $[PULONG ProfileBufferLength], $[PLUID LogonId], $[PHANDLE Token], $[PQUOTA_LIMITS Quotas], $[PNTSTATUS SubStatus])

$~LsaLookupAuthenticationPackage
$[NTSTATUS ]LsaLookupAuthenticationPackage($[HANDLE LsaHandle], $[PLSA_STRING PackageName], $[PULONG AuthenticationPackage])

$~LsaRegisterLogonProcess
$[NTSTATUS ]LsaRegisterLogonProcess($[PLSA_STRING LogonProcessName], $[PHANDLE LsaHandle], $[PLSA_OPERATIONAL_MODE SecurityMode])

$~LsaRegisterPolicyChangeNotification
$[NTSTATUS ]LsaRegisterPolicyChangeNotification($[POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass], $[HANDLE NotificationEventHandle])

$~LsaUnregisterPolicyChangeNotification
$[NTSTATUS ]LsaUnregisterPolicyChangeNotification($[POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass], $[HANDLE NotificationEventHandle])

$~LsaEnumerateLogonSessions
$[NTSTATUS NTAPI ]LsaEnumerateLogonSessions($[PULONG LogonSessionCount], $[PLUID* LogonSessionList])

$~LsaGetLogonSessionData
$[NTSTATUS NTAPI ]LsaGetLogonSessionData($[PLUID LogonId], $[PSECURITY_LOGON_SESSION_DATA* ppLogonSessionData])

$~SealMessage
$[NTSTATUS ]SealMessage($[LSA_SEC_HANDLE ContextHandle], $[ULONG QualityOfProtection], $[PSecBufferDesc MessageBuffers], $[ULONG MessageSequenceNumber])

$~UnsealMessage
$[NTSTATUS ]UnsealMessage($[LSA_SEC_HANDLE ContextHandle], $[PSecBufferDesc MessageBuffers], $[ULONG MessageSequenceNumber], $[PULONG QualityOfProtection])

$~InitSecurityInterfaceA
$[PSecurityFunctionTable SEC_Entry ]InitSecurityInterfaceA($[])

$~InitSecurityInterfaceW
$[PSecurityFunctionTable SEC_Entry ]InitSecurityInterfaceW($[])

$~AcceptSecurityContext
$[SECURITY_STATUS SEC_Entry ]AcceptSecurityContext($[PCredHandle phCredential], $[PCtxtHandle phContext], $[PSecBufferDesc pInput], $[ULONG fContextReq], $[ULONG TargetDataRep], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[PULONG pfContextAttr], $[PTimeStamp ptsTimeStamp])

$~AcquireCredentialsHandleA
$[SECURITY_STATUS SEC_Entry ]AcquireCredentialsHandleA($[SEC_CHAR* pszPrincipal], $[SEC_CHAR* pszPackage], $[ULONG fCredentialUse], $[PLUID pvLogonID], $[PVOID pAuthData], $[SEC_GET_KEY_FN pGetKeyFn], $[PVOID pvGetKeyArgument], $[PCredHandle phCredential], $[PTimeStamp ptsExpiry])

$~AcquireCredentialsHandleW
$[SECURITY_STATUS SEC_Entry ]AcquireCredentialsHandleW($[SEC_CHAR* pszPrincipal], $[SEC_CHAR* pszPackage], $[ULONG fCredentialUse], $[PLUID pvLogonID], $[PVOID pAuthData], $[SEC_GET_KEY_FN pGetKeyFn], $[PVOID pvGetKeyArgument], $[PCredHandle phCredential], $[PTimeStamp ptsExpiry])

$~ApplyControlToken
$[SECURITY_STATUS SEC_Entry ]ApplyControlToken($[PCtxtHandle phContext], $[PSecBufferDesc pInput])

$~CompleteAuthToken
$[SECURITY_STATUS SEC_Entry ]CompleteAuthToken($[PCtxtHandle phContext], $[PSecBufferDesc pToken])

$~DecryptMessage
$[SECURITY_STATUS SEC_Entry ]DecryptMessage($[PCtxtHandle phContext], $[PSecBufferDesc pMessage], $[ULONG MessageSeqNo], $[PULONG pfQOP])

$~DeleteSecurityContext
$[SECURITY_STATUS SEC_Entry ]DeleteSecurityContext($[PCtxtHandle phContext])

$~EncryptMessage
$[SECURITY_STATUS SEC_Entry ]EncryptMessage($[PCtxtHandle phContext], $[ULONG fQOP], $[PSecBufferDesc pMessage], $[ULONG MessageSeqNo])

$~EnumerateSecurityPackagesA
$[SECURITY_STATUS SEC_Entry ]EnumerateSecurityPackagesA($[PULONG pcPackages], $[PSecPkgInfo* ppPackageInfo])

$~EnumerateSecurityPackagesW
$[SECURITY_STATUS SEC_Entry ]EnumerateSecurityPackagesW($[PULONG pcPackages], $[PSecPkgInfo* ppPackageInfo])

$~ExportSecurityContext
$[SECURITY_STATUS SEC_Entry ]ExportSecurityContext($[PCtxtHandle phContext], $[Ulong fFlags], $[PSecBuffer pPackedContext], $[HANDLE* pToken])

$~FreeContextBuffer
$[SECURITY_STATUS SEC_Entry ]FreeContextBuffer($[PVOID pvContextBuffer])

$~FreeCredentialsHandle
$[SECURITY_STATUS SEC_Entry ]FreeCredentialsHandle($[PCredHandle phCredential])

$~ImpersonateSecurityContext
$[SECURITY_STATUS SEC_Entry ]ImpersonateSecurityContext($[PCtxtHandle phContext])

$~ImportSecurityContextA
$[SECURITY_STATUS SEC_Entry ]ImportSecurityContextA($[PSECURITY_STRING* pszPackage], $[PSecBuffer pPackedContext], $[HANDLE pToken], $[PCtxtHandle phContext])

$~ImportSecurityContextW
$[SECURITY_STATUS SEC_Entry ]ImportSecurityContextW($[PSECURITY_STRING* pszPackage], $[PSecBuffer pPackedContext], $[HANDLE pToken], $[PCtxtHandle phContext])

$~InitializeSecurityContextA
$[SECURITY_STATUS SEC_Entry ]InitializeSecurityContextA($[PCredHandle phCredential], $[PCtxtHandle phContext], $[SEC_CHAR* pszTargetName], $[ULONG fContextReq], $[ULONG Reserved1], $[ULONG TargetDataRep], $[PSecBufferDesc pInput], $[ULONG Reserved2], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[PULONG pfContextAttr], $[PTimeStamp ptsExpiry])

$~InitializeSecurityContextW
$[SECURITY_STATUS SEC_Entry ]InitializeSecurityContextW($[PCredHandle phCredential], $[PCtxtHandle phContext], $[SEC_CHAR* pszTargetName], $[ULONG fContextReq], $[ULONG Reserved1], $[ULONG TargetDataRep], $[PSecBufferDesc pInput], $[ULONG Reserved2], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[PULONG pfContextAttr], $[PTimeStamp ptsExpiry])

$~MakeSignature
$[SECURITY_STATUS SEC_Entry ]MakeSignature($[PCtxtHandle phContext], $[ULONG fQOP], $[PSecBufferDesc pMessage], $[ULONG MessageSeqNo])

$~QueryContextAttributesA
$[SECURITY_STATUS SEC_Entry ]QueryContextAttributesA($[PCtxtHandle phContext], $[ULONG ulAttribute], $[PVOID pBuffer])

$~QueryContextAttributesW
$[SECURITY_STATUS SEC_Entry ]QueryContextAttributesW($[PCtxtHandle phContext], $[ULONG ulAttribute], $[PVOID pBuffer])

$~QueryCredentialsAttributesA
$[SECURITY_STATUS SEC_Entry ]QueryCredentialsAttributesA($[PCredHandle phCredential], $[ULONG ulAttribute], $[PVOID pBuffer])

$~QueryCredentialsAttributesW
$[SECURITY_STATUS SEC_Entry ]QueryCredentialsAttributesW($[PCredHandle phCredential], $[ULONG ulAttribute], $[PVOID pBuffer])

$~QuerySecurityContextToken
$[SECURITY_STATUS SEC_Entry ]QuerySecurityContextToken($[PCtxtHandle phContext], $[HANDLE* phToken])

$~QuerySecurityPackageInfoA
$[SECURITY_STATUS SEC_Entry ]QuerySecurityPackageInfoA($[SEC_CHAR* pszPackageName], $[PSecPkgInfo* ppPackageInfo])

$~QuerySecurityPackageInfoW
$[SECURITY_STATUS SEC_Entry ]QuerySecurityPackageInfoW($[SEC_CHAR* pszPackageName], $[PSecPkgInfo* ppPackageInfo])

$~RevertSecurityContext
$[SECURITY_STATUS SEC_Entry ]RevertSecurityContext($[PCtxtHandle phContext])

$~SaslAcceptSecurityContext
$[SECURITY_STATUS SEC_ENTRY ]SaslAcceptSecurityContext($[PCredHandle phCredential], $[PCtxtHandle phContext], $[PSecBufferDesc pInput], $[unsigned long fContextReq], $[unsigned long TargetDataRep], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[unsigned long SEC_FAR* pfContextAttr], $[PTimeStamp ptsExpiry])

$~SaslEnumerateProfilesA
$[SECURITY_STATUS SEC_ENTRY ]SaslEnumerateProfilesA($[LPTSTR* ProfileList], $[ULONG* ProfileCount])

$~SaslEnumerateProfilesW
$[SECURITY_STATUS SEC_ENTRY ]SaslEnumerateProfilesW($[LPTSTR* ProfileList], $[ULONG* ProfileCount])

$~SaslGetProfilePackageA
$[SECURITY_STATUS SEC_ENTRY ]SaslGetProfilePackageA($[LPSTR ProfileName], $[PSecPkgInfo* PackageInfo])

$~SaslGetProfilePackageW
$[SECURITY_STATUS SEC_ENTRY ]SaslGetProfilePackageW($[LPWSTR ProfileName], $[PSecPkgInfo* PackageInfo])

$~SaslIdentifyPackageA
$[SECURITY_STATUS SEC_ENTRY ]SaslIdentifyPackageA($[PSecBufferDesc pInput], $[PSecPkgInfo* PackageInfo])

$~SaslIdentifyPackageW
$[SECURITY_STATUS SEC_ENTRY ]SaslIdentifyPackageW($[PSecBufferDesc pInput], $[PSecPkgInfo* PackageInfo])

$~SaslInitializeSecurityContextA
$[SECURITY_STATUS SEC_ENTRY ]SaslInitializeSecurityContextA($[PCredHandle phCredential], $[PCtxtHandle phContext], $[LPSTR pszTargetName], $[unsigned long fContextReq], $[unsigned long Reserved1], $[unsigned long TargetDataRep], $[PSecBufferDesc pInput], $[unsigned long Reserved2], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[unsigned long SEC_FAR* pfContextAttr], $[PTimeStamp ptsExpiry])

$~SaslInitializeSecurityContextW
$[SECURITY_STATUS SEC_ENTRY ]SaslInitializeSecurityContextW($[PCredHandle phCredential], $[PCtxtHandle phContext], $[LPWSTR pszTargetName], $[unsigned long fContextReq], $[unsigned long Reserved1], $[unsigned long TargetDataRep], $[PSecBufferDesc pInput], $[unsigned long Reserved2], $[PCtxtHandle phNewContext], $[PSecBufferDesc pOutput], $[unsigned long SEC_FAR* pfContextAttr], $[PTimeStamp ptsExpiry])

$~SetContextAttributesA
$[SECURITY_STATUS SEC_ENTRY ]SetContextAttributesA($[PCtxtHandle phContext], $[unsigned long ulAttribute], $[void SEC_FAR* pBuffer], $[unsigned long cbBuffer])

$~SetContextAttributesW
$[SECURITY_STATUS SEC_ENTRY ]SetContextAttributesW($[PCtxtHandle phContext], $[unsigned long ulAttribute], $[void SEC_FAR* pBuffer], $[unsigned long cbBuffer])

$~VerifySignature
$[SECURITY_STATUS SEC_Entry ]VerifySignature($[PCtxtHandle phContext], $[PSecBufferDesc pMessage], $[ULONG MessageSeqNo], $[PULONG pfQOP])

$; shell32.dll
$; -----------
$~DAD_AutoScroll
$[BOOL ]DAD_AutoScroll($[HWND hwnd], $[AUTO_SCROLL_DATA *pad], $[const POINT *pptNow])

$~DAD_DragEnterEx
$[BOOL ]DAD_DragEnterEx($[HWND hwndTarget], $[const POINT ptStart])

$~DAD_DragEnterEx2
$[BOOL ]DAD_DragEnterEx2($[HWND hwndTarget], $[const POINT ptStart], $[IDataObject *pdtObject])

$~DAD_DragLeave
$[BOOL ]DAD_DragLeave($[])

$~DAD_DragMove
$[BOOL ]DAD_DragMove($[POINT pt])

$~DAD_SetDragImage
$[BOOL ]DAD_SetDragImage($[HIMAGELIST him], $[POINT *pptOffset])

$~DAD_ShowDragImage
$[BOOL ]DAD_ShowDragImage($[BOOL fShow])

$~DragQueryPoint
$[BOOL ]DragQueryPoint($[HDROP hDrop], $[LPPOINT lppt])

$~GetFileNameFromBrowse
$[BOOL ]GetFileNameFromBrowse($[HWND hwnd], $[LPWSTR pszFilePath], $[UINT cchFilePath], $[LPCWSTR pszWorkingDir], $[LPCWSTR pszDefExt], $[LPCWSTR pszFilters], $[LPCWSTR szTitle])

$~ILIsEqual
$[BOOL ]ILIsEqual($[PCIDLIST_ABSOLUTE pidl1], $[PCIDLIST_ABSOLUTE pidl2])

$~ILIsParent
$[BOOL ]ILIsParent($[PCIDLIST_ABSOLUTE pidl1], $[PCIDLIST_ABSOLUTE pidl2], $[BOOL fImmediate])

$~ILRemoveLastID
$[BOOL ]ILRemoveLastID($[PUIDLIST_RELATIVE pidl])

$~IsUserAnAdmin
$[BOOL ]IsUserAnAdmin($[])

$~PathIsSlowA
$[BOOL ]PathIsSlowA($[LPCSTR pszFile], $[DWORD dwAttr])

$~PathIsSlowW
$[BOOL ]PathIsSlowW($[LPCWSTR pszFile], $[DWORD dwAttr])

$~PathMakeUniqueName
$[BOOL ]PathMakeUniqueName($[LPWSTR pszUniqueName], $[UINT cchMax], $[LPCWSTR pszTemplate], $[LPCWSTR pszLongPlate], $[LPCWSTR pszDir])

$~PathResolve
$[BOOL ]PathResolve($[LPWSTR pszPath], $[LPCWSTR *dirs], $[UINT fFlags])

$~PathYetAnotherMakeUniqueName
$[BOOL ]PathYetAnotherMakeUniqueName($[LPWSTR pszUniqueName], $[LPCWSTR pszPath], $[LPCWSTR pszShort], $[LPCWSTR pszFileSpec])

$~ReadCabinetState
$[BOOL ]ReadCabinetState($[CABINETSTATE *lpState], $[int cbLength])

$~SHChangeNotification_Unlock
$[BOOL ]SHChangeNotification_Unlock($[HANDLE hLock])

$~SHChangeNotifyDeregister
$[BOOL ]SHChangeNotifyDeregister($[ULONG ulID])

$~SHCreateProcessAsUserW
$[BOOL ]SHCreateProcessAsUserW($[PSHCREATEPROCESSINFOW pscpi])

$~ShellExecuteEx
$[BOOL ]ShellExecuteEx($[LPSHELLEXECUTEINFO lpExecInfo])

$~ShellExecuteExA
$[BOOL ]ShellExecuteExA($[LPSHELLEXECUTEINFO lpExecInfo])

$~ShellExecuteExW
$[BOOL ]ShellExecuteExW($[LPSHELLEXECUTEINFO lpExecInfo])

$~Shell_GetImageLists
$[BOOL ]Shell_GetImageLists($[HIMAGELIST *phiml], $[HIMAGELIST *phimlSmall])

$~Shell_NotifyIcon
$[BOOL ]Shell_NotifyIcon($[DWORD dwMessage], $[PNOTIFYICONDATAA lpdata])

$~Shell_NotifyIconA
$[BOOL ]Shell_NotifyIconA($[DWORD dwMessage], $[PNOTIFYICONDATAA lpdata])

$~Shell_NotifyIconW
$[BOOL ]Shell_NotifyIconW($[DWORD dwMessage], $[PNOTIFYICONDATAW lpdata])

$~SHFindFiles
$[BOOL ]SHFindFiles($[PCIDLIST_ABSOLUTE pidlFolder], $[PCIDLIST_ABSOLUTE pidlSaveFile])

$~SHFreeShared
$[BOOL ]SHFreeShared($[HANDLE hData], $[DWORD dwSourceProcId])

$~SHGetDiskFreeSpaceA
$[BOOL ]SHGetDiskFreeSpaceA($[LPCSTR pszVolume], $[ULARGE_INTEGER *pqwFreeCaller], $[ULARGE_INTEGER *pqwTot], $[ULARGE_INTEGER *pqwFree])

$~SHGetDiskFreeSpaceExA
$[BOOL ]SHGetDiskFreeSpaceExA($[LPCSTR pszVolume], $[ULARGE_INTEGER *pqwFreeCaller], $[ULARGE_INTEGER *pqwTot], $[ULARGE_INTEGER *pqwFree])

$~SHGetDiskFreeSpaceExW
$[BOOL ]SHGetDiskFreeSpaceExW($[LPCWSTR pszVolume], $[ULARGE_INTEGER *pqwFreeCaller], $[ULARGE_INTEGER *pqwTot], $[ULARGE_INTEGER *pqwFree])

$~SHGetNewLinkInfo
$[BOOL ]SHGetNewLinkInfo($[LPCSTR pszLinkTo], $[LPCSTR pszDir], $[LPSTR pszName], $[BOOL *pfMustCopy], $[UINT uFlags])

$~SHGetNewLinkInfoA
$[BOOL ]SHGetNewLinkInfoA($[LPCSTR pszLinkTo], $[LPCSTR pszDir], $[LPSTR pszName], $[BOOL *pfMustCopy], $[UINT uFlags])

$~SHGetNewLinkInfoW
$[BOOL ]SHGetNewLinkInfoW($[LPCSTR pszLinkTo], $[LPCSTR pszDir], $[LPSTR pszName], $[BOOL *pfMustCopy], $[UINT uFlags])

$~SHGetPathFromIDList
$[BOOL ]SHGetPathFromIDList($[LPCITEMIDLIST pidl], $[LPSTR pszPath])

$~SHGetPathFromIDListA
$[BOOL ]SHGetPathFromIDListA($[LPCITEMIDLIST pidl], $[LPSTR pszPath])

$~SHGetPathFromIDListW
$[BOOL ]SHGetPathFromIDListW($[LPCITEMIDLIST pidl], $[LPWSTR pszPath])

$~SHGetSpecialFolderPathA
$[BOOL ]SHGetSpecialFolderPathA($[HWND hwndOwner], $[LPSTR lpszPath], $[int nFolder], $[BOOL fCreate])

$~SHGetSpecialFolderPathW
$[BOOL ]SHGetSpecialFolderPathW($[HWND hwndOwner], $[LPWSTR lpszPath], $[int nFolder], $[BOOL fCreate])

$~SHInvokePrinterCommandA
$[BOOL ]SHInvokePrinterCommandA($[HWND hwnd], $[UINT uAction], $[LPCSTR lpBuf1], $[LPCSTR lpBuf2], $[BOOL fModal])

$~SHInvokePrinterCommandW
$[BOOL ]SHInvokePrinterCommandW($[HWND hwnd], $[UINT uAction], $[LPCWSTR lpBuf1], $[LPCWSTR lpBuf2], $[BOOL fModal])

$~SHObjectProperties
$[BOOL ]SHObjectProperties($[HWND hwnd], $[DWORD dwType], $[LPCWSTR szObject], $[LPCWSTR szPage])

$~SHOpenPropSheetW
$[BOOL ]SHOpenPropSheetW($[LPCWSTR pszCaption], $[HKEY* ahkeys], $[UINT ckeys], $[CLSID *pclsidDef], $[IDataObject *pdtobj], $[IShellBrowser *psb], $[LPCWSTR pStartPage])

$~SHTestTokenMembership
$[BOOL ]SHTestTokenMembership($[HANDLE hToken], $[ULONG ulRID])

$~SHUnlockShared
$[BOOL ]SHUnlockShared($[LPVOID lpvData])

$~SHValidateUNC
$[BOOL ]SHValidateUNC($[HWND hwndOwner], $[LPWSTR pszFile], $[UINT fConnect])

$~SignalFileOpen
$[BOOL ]SignalFileOpen($[PCIDLIST_ABSOLUTE pidl])

$~Win32DeleteFile
$[BOOL ]Win32DeleteFile($[LPCSTR pszFileName])

$~WriteCabinetState
$[BOOL ]WriteCabinetState($[CABINETSTATE *lpState])

$~DoEnvironmentSubstA
$[DWORD ]DoEnvironmentSubstA($[LPSTR pszString], $[UINT cchString])

$~DoEnvironmentSubstW
$[DWORD ]DoEnvironmentSubstW($[LPWSTR pszString], $[UINT cchString])

$~SHFormatDrive
$[DWORD ]SHFormatDrive($[HWND hwnd], $[UINT drive], $[UINT fmtID], $[UINT options])

$~SHRestricted
$[DWORD ]SHRestricted($[RESTRICTIONS rest])

$~SHGetFileInfo
$[DWORD_PTR ]SHGetFileInfo($[LPCSTR pszPath], $[DWORD dwFileAttributes], $[SHFILEINFOA *psfi], $[UINT cbFileInfo], $[UINT uFlags])

$~SHGetFileInfoA
$[DWORD_PTR ]SHGetFileInfoA($[LPCSTR pszPath], $[DWORD dwFileAttributes], $[SHFILEINFOA *psfi], $[UINT cbFileInfo], $[UINT uFlags])

$~SHGetFileInfoW
$[DWORD_PTR ]SHGetFileInfoW($[LPCWSTR pszPath], $[DWORD dwFileAttributes], $[SHFILEINFOW *psfi], $[UINT cbFileInfo], $[UINT uFlags])

$~PifMgr_OpenProperties
$[HANDLE ]PifMgr_OpenProperties($[LPCWSTR pszApp], $[LPCWSTR lpszPIF], $[UINT hInf], $[UINT flOpt])

$~SHAllocShared
$[HANDLE ]SHAllocShared($[LPCVOID pvData], $[DWORD dwSize], $[DWORD dwDestinationProcessId])

$~SHChangeNotification_Lock
$[HANDLE ]SHChangeNotification_Lock($[HANDLE hChange], $[DWORD dwProcId], $[LPITEMIDLIST **pppidl], $[LONG *plEvent])

$~DuplicateIcon
$[HICON ]DuplicateIcon($[HINSTANCE hInst], $[HICON hIcon])

$~ExtractAssociatedIconA
$[HICON ]ExtractAssociatedIconA($[HINSTANCE hInst], $[LPSTR lpIconPath], $[LPWORD lpiIcon])

$~ExtractAssociatedIconExA
$[HICON ]ExtractAssociatedIconExA($[HINSTANCE hInst], $[LPSTR lpIconPath], $[LPWORD lpiIconIndex], $[LPWORD lpiIconId])

$~ExtractAssociatedIconExW
$[HICON ]ExtractAssociatedIconExW($[HINSTANCE hInst], $[LPWSTR lpIconPath], $[LPWORD lpiIconIndex], $[LPWORD lpiIconId])

$~ExtractAssociatedIconW
$[HICON ]ExtractAssociatedIconW($[HINSTANCE hInst], $[LPWSTR lpIconPath], $[LPWORD lpiIcon])

$~ExtractIconA
$[HICON ]ExtractIconA($[HINSTANCE hInst], $[LPCSTR lpszExeFileName], $[UINT nIconIndex])

$~ExtractIconW
$[HICON ]ExtractIconW($[HINSTANCE hInst], $[LPCWSTR lpszExeFileName], $[UINT nIconIndex])

$~FindExecutableA
$[HINSTANCE ]FindExecutableA($[LPCSTR lpFile], $[LPCSTR lpDirectory], $[LPSTR lpResult])

$~FindExecutableW
$[HINSTANCE ]FindExecutableW($[LPCWSTR lpFile], $[LPCWSTR lpDirectory], $[LPWSTR lpResult])

$~ShellExecuteA
$[HINSTANCE ]ShellExecuteA($[HWND hwnd], $[LPCSTR lpOperation], $[LPCSTR lpFile], $[LPCSTR lpParameters], $[LPCSTR lpDirectory], $[INT nShowCmd])

$~ShellExecuteW
$[HINSTANCE ]ShellExecuteW($[HWND hwnd], $[LPCWSTR lpOperation], $[LPCWSTR lpFile], $[LPCWSTR lpParameters], $[LPCWSTR lpDirectory], $[INT nShowCmd])

$~SHGetShellStyleHInstance
$[HINSTANCE ]SHGetShellStyleHInstance($[])

$~WOWShellExecute
$[HINSTANCE ]WOWShellExecute($[HWND hwnd], $[LPCSTR lpOperation], $[LPCSTR lpFile], $[LPCSTR lpParameters], $[LPCSTR lpDirectory], $[INT nShowCmd], $[void *lpfnCBWinExec])

$~SHCreatePropSheetExtArray
$[HPSXA ]SHCreatePropSheetExtArray($[HKEY hkey], $[LPCWSTR pszSubkey], $[UINT max_iface])

$~DllGetVersion
$[HRESULT CALLBACK ]DllGetVersion($[DLLVERSIONINFO *pdvi])

$~DllInstall
$[HRESULT ]DllInstall($[BOOL bInstall], $[LPCWSTR pszCmdLine])

$~ILLoadFromStream
$[HRESULT ]ILLoadFromStream($[IStream *pstm], $[PIDLIST_RELATIVE *pidl])

$~ILSaveToStream
$[HRESULT ]ILSaveToStream($[IStream * pstm], $[PCUIDLIST_RELATIVE pidl])

$~SHBindToParent
$[HRESULT ]SHBindToParent($[PCIDLIST_ABSOLUTE pidl], $[REFIID riid], $[VOID **ppv], $[PCUITEMID_CHILD *ppidlLast])

$~SHCLSIDFromString
$[HRESULT ]SHCLSIDFromString($[LPCWSTR psz], $[CLSID pcClsid])

$~SHCoCreateInstance
$[HRESULT ]SHCoCreateInstance($[LPCWSTR pszCLSID], $[const CLSID *pclsid], $[IUnknown *pUnkOuter], $[REFIID riid], $[void **ppv])

$~SHCreateFileExtractIconW
$[HRESULT ]SHCreateFileExtractIconW($[LPCWSTR pszFile], $[DWORD dwFileAttributes], $[REFIID riid], $[void **ppv])

$~SHCreateQueryCancelAutoPlayMoniker
$[HRESULT ]SHCreateQueryCancelAutoPlayMoniker($[IMoniker **ppmoniker])

$~SHCreateShellFolderView
$[HRESULT ]SHCreateShellFolderView($[const SFV_CREATE *pcsfv], $[IShellView **ppsv])

$~SHCreateShellFolderViewEx
$[HRESULT ]SHCreateShellFolderViewEx($[LPCSFV pcsfv], $[IShellView **ppsv])

$~SHCreateShellItem
$[HRESULT ]SHCreateShellItem($[LPCITEMIDLIST pidlParent], $[IShellFolder *psfParent], $[LPCITEMIDLIST pidl], $[IShellItem **ppsi])

$~SHCreateStdEnumFmtEtc
$[HRESULT ]SHCreateStdEnumFmtEtc($[UINT cfmt], $[FORMATETC* afmt], $[IEnumFORMATETC **ppenumFormatEtc])

$~SHDefExtractIconA
$[HRESULT ]SHDefExtractIconA($[LPCSTR pszIconFile], $[int iIndex], $[UINT uFlags], $[HICON *phiconLarge], $[HICON *phiconSmall], $[UINT nIconSize])

$~SHDefExtractIconW
$[HRESULT ]SHDefExtractIconW($[LPCWSTR pszIconFile], $[int iIndex], $[UINT uFlags], $[HICON *phiconLarge], $[HICON *phiconSmall], $[UINT nIconSize])

$~SHDoDragDrop
$[HRESULT ]SHDoDragDrop($[HWND hwnd], $[IDataObject *pdtobj], $[IDropSource *pdsrc], $[DWORD dwEffect], $[DWORD *pdwEffect])

$~SHEmptyRecycleBinA
$[HRESULT ]SHEmptyRecycleBinA($[HWND hwnd], $[LPCSTR pszRootPath], $[DWORD dwFlags])

$~SHEmptyRecycleBinW
$[HRESULT ]SHEmptyRecycleBinW($[HWND hwnd], $[LPCWSTR pszRootPath], $[DWORD dwFlags])

$~SHEnumerateUnreadMailAccountsW
$[HRESULT ]SHEnumerateUnreadMailAccountsW($[HKEY hKeyUser], $[DWORD dwIndex], $[LPWSTR pszMailAddress], $[int cchMailAddress])

$~SHFlushClipboard
$[HRESULT ]SHFlushClipboard($[])

$~SHGetAttributesFromDataObject
$[HRESULT ]SHGetAttributesFromDataObject($[IDataObject *pdo], $[DWORD dwAttributeMask], $[DWORD *pdwAttributes], $[UINT *pcItems])

$~SHGetDataFromIDListA
$[HRESULT ]SHGetDataFromIDListA($[IShellFolder *psf], $[PCUITEMID_CHILD pidl], $[int nFormat], $[PVOID pv], $[int cb])

$~SHGetDataFromIDListW
$[HRESULT ]SHGetDataFromIDListW($[IShellFolder *psf], $[PCUITEMID_CHILD pidl], $[int nFormat], $[PVOID pv], $[int cb])

$~SHGetDesktopFolder
$[HRESULT ]SHGetDesktopFolder($[IShellFolder **ppshf])

$~SHGetFolderLocation
$[HRESULT ]SHGetFolderLocation($[HWND hwndOwner], $[int nFolder], $[HANDLE hToken], $[DWORD dwReserved], $[LPITEMIDLIST *ppidl])

$~SHGetFolderPathA
$[HRESULT ]SHGetFolderPathA($[HWND hwndOwner], $[int nFolder], $[HANDLE hToken], $[DWORD dwFlags], $[LPSTR pszPath])

$~SHGetFolderPathAndSubDirA
$[HRESULT ]SHGetFolderPathAndSubDirA($[HWND hwnd], $[int csidl], $[HANDLE hToken], $[DWORD dwFlags], $[LPCSTR pszSubDir], $[LPSTR pszPath])

$~SHGetFolderPathAndSubDirW
$[HRESULT ]SHGetFolderPathAndSubDirW($[HWND hwnd], $[int csidl], $[HANDLE hToken], $[DWORD dwFlags], $[LPCWSTR pszSubDir], $[LPWSTR pszPath])

$~SHGetFolderPathW
$[HRESULT ]SHGetFolderPathW($[HWND hwndOwner], $[int nFolder], $[HANDLE hToken], $[DWORD dwFlags], $[LPWSTR pszPath])

$~SHGetInstanceExplorer
$[HRESULT ]SHGetInstanceExplorer($[IUnknown **ppunk])

$~SHGetMalloc
$[HRESULT ]SHGetMalloc($[LPMALLOC *ppMalloc])

$~SHGetRealIDL
$[HRESULT ]SHGetRealIDL($[IShellFolder *psf], $[PCUITEMID_CHILD pidlSimple], $[PITEMID_CHILD *ppidlReal])

$~SHGetSetFolderCustomSettingsW
$[HRESULT ]SHGetSetFolderCustomSettingsW($[LPSHFOLDERCUSTOMSETTINGS pfcs], $[LPCWSTR pszPath], $[DWORD dwReadWrite])

$~SHGetSpecialFolderLocation
$[HRESULT ]SHGetSpecialFolderLocation($[HWND hwndOwner], $[int nFolder], $[LPITEMIDLIST *ppidl])

$~SHGetUnreadMailCountW
$[HRESULT ]SHGetUnreadMailCountW($[HKEY hKeyUser], $[LPCWSTR pszMailAddress], $[DWORD *pdwCount], $[FILETIME *pFileTime], $[LPCWSTR pszShellExecuteCommand], $[int cchShellExecuteCommand])

$~SHILCreateFromPath
$[HRESULT ]SHILCreateFromPath($[LPCWSTR pszPath], $[PIDLIST_ABSOLUTE *ppidl], $[DWORD *rgflnOut])

$~SHIsFileAvailableOffline
$[HRESULT ]SHIsFileAvailableOffline($[LPCWSTR pszPath], $[LPDWORD pdwStatus])

$~SHLimitInputEdit
$[HRESULT ]SHLimitInputEdit($[HWND hwndEdit], $[IShellFolder *psf])

$~SHLoadInProc
$[HRESULT ]SHLoadInProc($[REFCLSID rclsid])

$~SHLoadNonloadedIconOverlayIdentifiers
$[HRESULT ]SHLoadNonloadedIconOverlayIdentifiers($[])

$~SHLoadOLE
$[HRESULT ]SHLoadOLE($[LPARAM lParam])

$~SHMapIDListToImageListIndexAsync
$[HRESULT ]SHMapIDListToImageListIndexAsync($[IShellTaskScheduler *pts], $[IShellFolder *psf], $[LPCITEMIDLIST pidl], $[UINT flags], $[PFNASYNCICONTASKBALLBACK pfn], $[void *pvData], $[void *pvHint], $[int *piIndex], $[int *piIndexSel])

$~SHMultiFileProperties
$[HRESULT ]SHMultiFileProperties($[IDataObject *pdtobj], $[DWORD dwFlags])

$~SHOpenFolderAndSelectItems
$[HRESULT ]SHOpenFolderAndSelectItems($[LPCITEMIDLIST pidlFolder], $[UINT cidl], $[LPCITEMIDLIST *apidl], $[DWORD dwFlags])

$~SHParseDisplayName
$[HRESULT ]SHParseDisplayName($[LPCWSTR pszName], $[IBindCtx *pbc], $[PIDLIST_ABSOLUTE *ppidl], $[SFGAOF sfgaoIn], $[SFGAOF *psfgaoOut])

$~SHPathPrepareForWriteA
$[HRESULT ]SHPathPrepareForWriteA($[HWND hwnd], $[IUnknown *punkEnableModless], $[LPCSTR pszPath], $[DWORD dwFlags])

$~SHPathPrepareForWriteW
$[HRESULT ]SHPathPrepareForWriteW($[HWND hwnd], $[IUnknown *punkEnableModless], $[LPCWSTR pszPath], $[DWORD dwFlags])

$~SHPropStgCreate
$[HRESULT ]SHPropStgCreate($[IPropertySetStorage *psstg], $[REFFMTID fmtid], $[const CLSID *pclsid], $[DWORD grfFlags], $[DWORD grfMode], $[DWORD dwDisposition], $[IPropertyStorage **ppstg], $[UINT *puCodePage])

$~SHPropStgReadMultiple
$[HRESULT ]SHPropStgReadMultiple($[IPropertyStorage *pps], $[UINT uCodePage], $[ULONG cpspec], $[PROPSPEC* rgpspec], $[PROPVARIANT* rgvar])

$~SHPropStgWriteMultiple
$[HRESULT ]SHPropStgWriteMultiple($[IPropertyStorage *pps], $[UINT *uCodePage], $[ULONG cpspec], $[PROPSPEC* rgpspec], $[PROPVARIANT* rgvar], $[PROPID propidNameFirst])

$~SHQueryRecycleBinA
$[HRESULT ]SHQueryRecycleBinA($[LPCSTR pszRootPath], $[LPSHQUERYRBINFO pSHQueryRBInfo])

$~SHQueryRecycleBinW
$[HRESULT ]SHQueryRecycleBinW($[LPCWSTR pszRootPath], $[LPSHQUERYRBINFO pSHQueryRBInfo])

$~SHSetLocalizedName
$[HRESULT ]SHSetLocalizedName($[LPCWSTR pszPath], $[LPCWSTR pszResModule], $[int idsRes])

$~SHSetUnreadMailCountW
$[HRESULT ]SHSetUnreadMailCountW($[LPCWSTR pszMailAddress], $[DWORD dwCount], $[LPCWSTR pszShellExecuteCommand])

$~SHStartNetConnectionDialogW
$[HRESULT ]SHStartNetConnectionDialogW($[HWND hwnd], $[LPCWSTR pszRemoteName], $[DWORD dwType])

$~SHFind_InitMenuPopup
$[IContextMenu* ]SHFind_InitMenuPopup($[HMENU hmenu], $[HWND hwnd], $[UINT idCmdFirst], $[UINT idCmdLast])

$~CallCPLEntry16
$[int ]CallCPLEntry16($[HINSTANCE hInst], $[FARPROC16 lpfnEntry], $[HWND hwndCPL], $[UINT msg], $[LPARAM lParam1], $[LPARAM lParam2])

$~CDefFolderMenu_Create2
$[int ]CDefFolderMenu_Create2($[LPCITEMIDLIST pidlFolder], $[HWND hwnd], $[UINT cidl], $[LPCITEMIDLIST *apidl], $[IShellFolder *psf], $[LPFNDFMCALLBACK lpfn], $[UINT nKeys], $[const HKEY *ahkeyClsKeys], $[IContextMenu **ppcm])

$~IsNetDrive
$[int ]IsNetDrive($[int iDrive])

$~PathCleanupSpec
$[int ]PathCleanupSpec($[LPCWSTR pszDir], $[LPWSTR pszSpec])

$~PathIsExe
$[int ]PathIsExe($[LPCWSTR szfile])

$~PickIconDlg
$[int ]PickIconDlg($[HWND hwnd], $[LPWSTR pszIconPath], $[UINT cchIconPath], $[int *piIconIndex])

$~PifMgr_CloseProperties
$[int ]PifMgr_CloseProperties($[HANDLE hProps], $[UINT flOpt])

$~PifMgr_GetProperties
$[int ]PifMgr_GetProperties($[HANDLE hProps], $[LPCSTR pszGroup], $[VOID *lpProps], $[int cbProps], $[UINT flOpt])

$~PifMgr_SetProperties
$[int ]PifMgr_SetProperties($[HANDLE hProps], $[LPCSTR pszGroup], $[VOID *lpProps], $[int cbProps], $[UINT flOpt])

$~RealDriveType
$[int ]RealDriveType($[int iDrive], $[BOOL fOKToHitNet])

$~RestartDialog
$[int ]RestartDialog($[HWND hParent], $[LPCWSTR pszPrompt], $[DWORD dwFlags])

$~RestartDialogEx
$[int ]RestartDialogEx($[HWND hParent], $[LPCWSTR pszPrompt], $[DWORD dwFlags], $[HWND dwReasonCode])

$~SHAddFromPropSheetExtArray
$[int ]SHAddFromPropSheetExtArray($[HPSXA hpsxa], $[LPFNADDPROPSHEETPAGE lpfnAddPage], $[LPARAM lParam])

$~SHCreateDirectory
$[int ]SHCreateDirectory($[HWND hwnd], $[LPCWSTR pszPath])

$~SHCreateDirectoryExA
$[int ]SHCreateDirectoryExA($[HWND hwnd], $[LPCSTR pszPath], $[SECURITY_ATTRIBUTES *psa])

$~SHCreateDirectoryExW
$[int ]SHCreateDirectoryExW($[HWND hwnd], $[LPCWSTR pszPath], $[SECURITY_ATTRIBUTES *psa])

$~ShellAboutA
$[int ]ShellAboutA($[HWND hWnd], $[LPCSTR szApp], $[LPCSTR szOtherStuff], $[HICON hIcon])

$~ShellAboutW
$[int ]ShellAboutW($[HWND hWnd], $[LPCWSTR szApp], $[LPCWSTR szOtherStuff], $[HICON hIcon])

$~ShellMessageBoxA
$[int ]ShellMessageBoxA($[HINSTANCE hInst], $[HWND hWnd], $[LPCSTR pszMsg], $[LPCSTR pszTitle], $[UINT fuStyle])

$~ShellMessageBoxW
$[int ]ShellMessageBoxW($[HINSTANCE hInst], $[HWND hWnd], $[LPCWSTR pszMsg], $[LPCWSTR pszTitle], $[UINT fuStyle])

$~Shell_GetCachedImageIndex
$[int ]Shell_GetCachedImageIndex($[LPCWSTR pszIconPath], $[int iIconIndex], $[UINT uIconFlags])

$~SHFileOperation
$[int ]SHFileOperation($[LPSHFILEOPSTRUCT lpFileOp])

$~SHFileOperationA
$[int ]SHFileOperationA($[LPSHFILEOPSTRUCT lpFileOp])

$~SHFileOperationW
$[int ]SHFileOperationW($[LPSHFILEOPSTRUCT lpFileOp])

$~SHGetIconOverlayIndexA
$[int ]SHGetIconOverlayIndexA($[LPCSTR pszIconPath], $[int iIconIndex])

$~SHGetIconOverlayIndexW
$[int ]SHGetIconOverlayIndexW($[LPCWSTR pszIconPath], $[int iIconIndex])

$~SHHandleUpdateImage
$[int ]SHHandleUpdateImage($[PCIDLIST_ABSOLUTE pidlExtra])

$~SHMapPIDLToSystemImageListIndex
$[int ]SHMapPIDLToSystemImageListIndex($[IShellFolder *psf], $[PCUITEMID_CHILD pidl], $[int *piIndex])

$~OpenRegStream
$[IStream* ]OpenRegStream($[HKEY hkey], $[LPCWSTR pszSubkey], $[LPCWSTR pszValue], $[DWORD grfMode])

$~PathProcessCommand
$[LONG ]PathProcessCommand($[LPCWSTR lpSrc], $[LPWSTR lpDest], $[int iDestMax], $[DWORD dwFlags])

$~ILFindChild
$[LPITEMIDLIST ]ILFindChild($[PCIDLIST_ABSOLUTE pidlParent], $[PCIDLIST_ABSOLUTE pidlChild])

$~SHCloneSpecialIDList
$[LPITEMIDLIST ]SHCloneSpecialIDList($[HWND hwndOwner], $[int csidl], $[bool fCreate])

$~StrRChrA
$[LPSTR ]StrRChrA($[LPCSTR lpStart], $[LPCSTR lpEnd], $[CHAR Match])

$~SHAlloc
$[LPVOID ]SHAlloc($[SIZE_T cb])

$~SHLockShared
$[LPVOID ]SHLockShared($[HANDLE * hData], $[DWORD dwOtherProcId])

$~CommandLineToArgvW
$[LPWSTR* ]CommandLineToArgvW($[LPCWSTR lpCmdLine], $[int *pNumArgs])

$~StrRChrW
$[LPWSTR ]StrRChrW($[LPCWSTR lpStart], $[LPCWSTR lpEnd], $[WCHAR wMatch])

$~SHShellFolderView_Message
$[LRESULT ]SHShellFolderView_Message($[HWND hwnd], $[UINT uMsg], $[lParam lparam])

$~ILCombine
$[PIDLIST_ABSOLUTE ]ILCombine($[PCIDLIST_ABSOLUTE pidl1], $[PCUIDLIST_RELATIVE pidl2])

$~ILCreateFromPath
$[PIDLIST_ABSOLUTE ]ILCreateFromPath($[LPCSTR pszPath])

$~ILCreateFromPathA
$[PIDLIST_ABSOLUTE ]ILCreateFromPathA($[LPCSTR pszPath])

$~ILCreateFromPathW
$[PIDLIST_ABSOLUTE ]ILCreateFromPathW($[LPCSTR pszPath])

$~SHBrowseForFolder
$[PIDLIST_ABSOLUTE ]SHBrowseForFolder($[LPBROWSEINFO lpbi])

$~SHBrowseForFolderA
$[PIDLIST_ABSOLUTE ]SHBrowseForFolderA($[LPBROWSEINFO lpbi])

$~SHBrowseForFolderW
$[PIDLIST_ABSOLUTE ]SHBrowseForFolderW($[LPBROWSEINFO lpbi])

$~SHSimpleIDListFromPath
$[PIDLIST_ABSOLUTE ]SHSimpleIDListFromPath($[LPCWSTR pszPath])

$~ILAppendID
$[PIDLIST_RELATIVE ]ILAppendID($[PIDLIST_RELATIVE pidl], $[LPSHITEMID pmkid], $[BOOL fAppend])

$~ILClone
$[PIDLIST_RELATIVE ]ILClone($[PCUIDLIST_RELATIVE pidl])

$~ILCloneFirst
$[PITEMID_CHILD ]ILCloneFirst($[PCUIDLIST_RELATIVE pidl])

$~ILGetNext
$[PUIDLIST_RELATIVE ]ILGetNext($[PCUIDLIST_RELATIVE pidl])

$~ILFindLastID
$[PUITEMID_CHILD ]ILFindLastID($[PCUIDLIST_RELATIVE pidl])

$~DragQueryFile
$[UINT ]DragQueryFile($[HDROP hDrop], $[UINT iFile], $[LPSTR lpszFile], $[UINT cch])

$~DragQueryFileA
$[UINT ]DragQueryFileA($[HDROP hDrop], $[UINT iFile], $[LPSTR lpszFile], $[UINT cch])

$~DragQueryFileW
$[UINT ]DragQueryFileW($[HDROP hDrop], $[UINT iFile], $[LPWSTR lpszFile], $[UINT cch])

$~ExtractIconEx
$[UINT ]ExtractIconEx($[LPCSTR lpszFile], $[int nIconIndex], $[HICON *phiconLarge], $[HICON *phiconSmall], $[UINT nIcons])

$~ExtractIconExA
$[UINT ]ExtractIconExA($[LPCSTR lpszFile], $[int nIconIndex], $[HICON *phiconLarge], $[HICON *phiconSmall], $[UINT nIcons])

$~ExtractIconExW
$[UINT ]ExtractIconExW($[LPCWSTR lpszFile], $[int nIconIndex], $[HICON *phiconLarge], $[HICON *phiconSmall], $[UINT nIcons])

$~ILGetSize
$[UINT ]ILGetSize($[PCUIDLIST_RELATIVE pidl])

$~Shell_MergeMenus
$[UINT ]Shell_MergeMenus($[HMENU hmDst], $[HMENU hmSrc], $[UINT uInsert], $[UINT uIDAdjust], $[UINT uIDAdjustMax], $[ULONG uFlags])

$~SHReplaceFromPropSheetExtArray
$[UINT ]SHReplaceFromPropSheetExtArray($[HPSXA hpsxa], $[UINT uPageID], $[LPFNADDPROPSHEETPAGE lpfnReplaceWith], $[LPARAM lParam])

$~SHAppBarMessage
$[UINT_PTR ]SHAppBarMessage($[DWORD dwMessage], $[PAPPBARDATA pData])

$~SHChangeNotifyRegister
$[ULONG ]SHChangeNotifyRegister($[HWND hwnd], $[int fSources], $[LONG fEvents], $[UINT wMsg], $[int cEntries], $[SHChangeNotifyEntry *pfsne])

$~DragAcceptFiles
$[VOID ]DragAcceptFiles($[HWND hWnd], $[BOOL fAccept])

$~DragFinish
$[VOID ]DragFinish($[HDROP hDrop])

$~ILFree
$[void ]ILFree($[PIDLIST_RELATIVE pidl])

$~PathGetShortPath
$[void ]PathGetShortPath($[LPWSTR pszLongPath])

$~SHAddToRecentDocs
$[void ]SHAddToRecentDocs($[UINT uFlags], $[LPCVOID pv])

$~SHChangeNotify
$[void ]SHChangeNotify($[LONG wEventId], $[UINT uFlags], $[LPCVOID dwItem1], $[LPCVOID dwItem2])

$~SHDestroyPropSheetExtArray
$[void ]SHDestroyPropSheetExtArray($[HPSXA hpsxa])

$~SHFlushSFCache
$[void ]SHFlushSFCache($[])

$~SHFree
$[void ]SHFree($[void *pv])

$~SHFreeNameMappings
$[void ]SHFreeNameMappings($[HANDLE hNameMappings])

$~SHGetSetSettings
$[void ]SHGetSetSettings($[LPSHELLSTATE lpss], $[DWORD dwMask], $[BOOL bSet])

$~SHGetSettings
$[void ]SHGetSettings($[LPSHELLFLAGSTATE lpsfs], $[DWORD dwMask])

$~SHSetInstanceExplorer
$[void ]SHSetInstanceExplorer($[IUnknown *punk])

$~SHUpdateImageA
$[void ]SHUpdateImageA($[LPCSTR pszHashItem], $[int iIndex], $[UINT uFlags], $[int iImageIndex])

$~SHUpdateImageW
$[void ]SHUpdateImageW($[LPCWSTR pszHashItem], $[int iIndex], $[UINT uFlags], $[int iImageIndex])

$; user32.dll
$; ----------
$~RegisterClassA
$[ATOM ]RegisterClassA($[CONST WNDCLASS *lpWndClass])

$~RegisterClassExA
$[ATOM ]RegisterClassExA($[CONST WNDCLASSEX *lpwcx])

$~RegisterClassExW
$[ATOM ]RegisterClassExW($[CONST WNDCLASSEX *lpwcx])

$~RegisterClassW
$[ATOM ]RegisterClassW($[CONST WNDCLASS *lpWndClass])

$~AdjustWindowRect
$[BOOL ]AdjustWindowRect($[LPRECT lpRect], $[DWORD dwStyle], $[BOOL bMenu])

$~AdjustWindowRectEx
$[BOOL ]AdjustWindowRectEx($[LPRECT lpRect], $[DWORD dwStyle], $[BOOL bMenu], $[DWORD dwExStyle])

$~AllowSetForegroundWindow
$[BOOL ]AllowSetForegroundWindow($[DWORD dwProcessId])

$~AnimateWindow
$[BOOL ]AnimateWindow($[HWND hwnd], $[DWORD dwTime], $[DWORD dwFlags])

$~AnyPopup
$[BOOL ]AnyPopup($[])

$~AppendMenuA
$[BOOL ]AppendMenuA($[HMENU hMenu], $[UINT uFlags], $[UINT_PTR uIDNewItem], $[LPCSTR lpNewItem])

$~AppendMenuW
$[BOOL ]AppendMenuW($[HMENU hMenu], $[UINT uFlags], $[UINT_PTR uIDNewItem], $[LPCWSTR lpNewItem])

$~AttachThreadInput
$[BOOL ]AttachThreadInput($[DWORD idAttach], $[DWORD idAttachTo], $[BOOL fAttach])

$~BlockInput
$[BOOL ]BlockInput($[BOOL fBlockIt])

$~BringWindowToTop
$[BOOL ]BringWindowToTop($[HWND hWnd])

$~CallMsgFilter
$[BOOL ]CallMsgFilter($[LPMSG lpMsg], $[int nCode])

$~CallMsgFilterA
$[BOOL ]CallMsgFilterA($[LPMSG lpMsg], $[int nCode])

$~CallMsgFilterW
$[BOOL ]CallMsgFilterW($[LPMSG lpMsg], $[int nCode])

$~ChangeClipboardChain
$[BOOL ]ChangeClipboardChain($[HWND hWndRemove], $[HWND hWndNewNext])

$~CharToOemA
$[BOOL ]CharToOemA($[LPCSTR lpszSrc], $[LPSTR lpszDst])

$~CharToOemBuffA
$[BOOL ]CharToOemBuffA($[LPCSTR lpszSrc], $[LPSTR lpszDst], $[DWORD cchDstLength])

$~CharToOemBuffW
$[BOOL ]CharToOemBuffW($[LPCWSTR lpszSrc], $[LPSTR lpszDst], $[DWORD cchDstLength])

$~CharToOemW
$[BOOL ]CharToOemW($[LPCWSTR lpszSrc], $[LPSTR lpszDst])

$~CheckDlgButton
$[BOOL ]CheckDlgButton($[HWND hDlg], $[int nIDButton], $[UINT uCheck])

$~CheckMenuRadioItem
$[BOOL ]CheckMenuRadioItem($[HMENU hmenu], $[UINT idFirst], $[UINT idLast], $[UINT idCheck], $[UINT uFlags])

$~CheckRadioButton
$[BOOL ]CheckRadioButton($[HWND hDlg], $[int nIDFirstButton], $[int nIDLastButton], $[int nIDCheckButton])

$~ClientToScreen
$[BOOL ]ClientToScreen($[HWND hWnd], $[LPPOINT lpPoint])

$~ClipCursor
$[BOOL ]ClipCursor($[const RECT *lpRect])

$~CloseClipboard
$[BOOL ]CloseClipboard($[VOID])

$~CloseDesktop
$[BOOL ]CloseDesktop($[HDESK hDesktop])

$~CloseWindow
$[BOOL ]CloseWindow($[HWND hWnd])

$~CloseWindowStation
$[BOOL ]CloseWindowStation($[HWINSTA hWinSta])

$~CopyRect
$[BOOL ]CopyRect($[LPRECT lprcDst], $[CONST RECT* lprcSrc])

$~CreateCaret
$[BOOL ]CreateCaret($[HWND hWnd], $[HBITMAP hBitmap], $[int nWidth], $[int nHeight])

$~DdeAbandonTransaction
$[BOOL ]DdeAbandonTransaction($[DWORD idInst], $[HCONV hConv], $[DWORD idTransaction])

$~DdeDisconnect
$[BOOL ]DdeDisconnect($[HCONV hConv])

$~DdeDisconnectList
$[BOOL ]DdeDisconnectList($[HCONVLIST hConvList])

$~DdeEnableCallback
$[BOOL ]DdeEnableCallback($[DWORD idInst], $[HCONV hConv], $[UINT wCmd])

$~DdeFreeDataHandle
$[BOOL ]DdeFreeDataHandle($[HDDEDATA hData])

$~DdeFreeStringHandle
$[BOOL ]DdeFreeStringHandle($[DWORD idInst], $[HSZ hsz])

$~DdeImpersonateClient
$[BOOL ]DdeImpersonateClient($[HCONV hConv])

$~DdeKeepStringHandle
$[BOOL ]DdeKeepStringHandle($[DWORD idInst], $[HSZ hsz])

$~DdePostAdvise
$[BOOL ]DdePostAdvise($[DWORD idInst], $[HSZ hszTopic], $[HSZ hszItem])

$~DdeSetQualityOfService
$[BOOL ]DdeSetQualityOfService($[HWND hwndClient], $[const SECURITY_QUALITY_OF_SERVICE *pqosNew], $[PSECURITY_QUALITY_OF_SERVICE pqosPrev])

$~DdeSetUserHandle
$[BOOL ]DdeSetUserHandle($[HCONV hConv], $[DWORD id], $[DWORD_PTR hUser])

$~DdeUnaccessData
$[BOOL ]DdeUnaccessData($[HDDEDATA hData])

$~DdeUninitialize
$[BOOL ]DdeUninitialize($[DWORD idInst])

$~DeleteMenu
$[BOOL ]DeleteMenu($[HMENU hMenu], $[UINT uPosition], $[UINT uFlags])

$~DeregisterShellHookWindow
$[BOOL ]DeregisterShellHookWindow($[HWND hWnd])

$~DestroyAcceleratorTable
$[BOOL ]DestroyAcceleratorTable($[HACCEL hAccel])

$~DestroyCaret
$[BOOL ]DestroyCaret($[])

$~DestroyCursor
$[BOOL ]DestroyCursor($[HCURSOR hCursor])

$~DestroyIcon
$[BOOL ]DestroyIcon($[HICON hIcon])

$~DestroyMenu
$[BOOL ]DestroyMenu($[HMENU hMenu])

$~DestroyWindow
$[BOOL ]DestroyWindow($[HWND hWnd])

$~DlgDirSelectComboBoxExA
$[BOOL ]DlgDirSelectComboBoxExA($[HWND hDlg], $[LPSTR lpString], $[int nCount], $[int nIDComboBox])

$~DlgDirSelectComboBoxExW
$[BOOL ]DlgDirSelectComboBoxExW($[HWND hDlg], $[LPWSTR lpString], $[int nCount], $[int nIDComboBox])

$~DlgDirSelectExA
$[BOOL ]DlgDirSelectExA($[HWND hDlg], $[LPSTR lpString], $[int nCount], $[int nIDListBox])

$~DlgDirSelectExW
$[BOOL ]DlgDirSelectExW($[HWND hDlg], $[LPWSTR lpString], $[int nCount], $[int nIDListBox])

$~DragDetect
$[BOOL ]DragDetect($[HWND hwnd], $[POINT Point])

$~DrawAnimatedRects
$[BOOL ]DrawAnimatedRects($[HWND hwnd], $[int idAni], $[CONST RECT *lprcFrom])

$~DrawCaption
$[BOOL ]DrawCaption($[HWND hwnd], $[HDC hdc], $[LPCRECT lprc], $[UINT uFlags])

$~DrawEdge
$[BOOL ]DrawEdge($[HDC hdc], $[LPRECT qrc], $[UINT edge], $[UINT grfFlags])

$~DrawFocusRect
$[BOOL ]DrawFocusRect($[HDC hDC], $[CONST RECT* lprc])

$~DrawFrameControl
$[BOOL ]DrawFrameControl($[HDC hdc], $[LPRECT lprc], $[UINT uType], $[UINT uState])

$~DrawIcon
$[BOOL ]DrawIcon($[HDC hDC], $[int X], $[int Y], $[HICON hIcon])

$~DrawIconEx
$[BOOL ]DrawIconEx($[HDC hdc], $[int xLeft], $[int yTop], $[HICON hIcon], $[int cxWidth], $[int cyWidth], $[UINT istepIfAniCur], $[HBRUSH hbrFlickerFreeDraw], $[UINT diFlags])

$~DrawMenuBar
$[BOOL ]DrawMenuBar($[HWND hWnd])

$~DrawStateA
$[BOOL ]DrawStateA($[HDC hdc], $[HBRUSH hbr], $[DRAWSTATEPROC lpOutputFunc], $[LPARAM lData], $[WPARAM wData], $[int x], $[int y], $[int cx], $[int cy], $[UINT fuFlags])

$~DrawStateW
$[BOOL ]DrawStateW($[HDC hdc], $[HBRUSH hbr], $[DRAWSTATEPROC lpOutputFunc], $[LPARAM lData], $[WPARAM wData], $[int x], $[int y], $[int cx], $[int cy], $[UINT fuFlags])

$~EmptyClipboard
$[BOOL ]EmptyClipboard($[VOID])

$~EnableMenuItem
$[BOOL ]EnableMenuItem($[HMENU hMenu], $[UINT uIDEnableItem], $[UINT uEnable])

$~EnableScrollBar
$[BOOL ]EnableScrollBar($[HWND hWnd], $[UINT wSBflags], $[UINT wArrows])

$~EnableWindow
$[BOOL ]EnableWindow($[HWND hWnd], $[BOOL bEnable])

$~EndDeferWindowPos
$[BOOL ]EndDeferWindowPos($[HDWP hWinPosInfo])

$~EndDialog
$[BOOL ]EndDialog($[HWND hDlg], $[INT_PTR nResult])

$~EndMenu
$[BOOL ]EndMenu($[])

$~EndPaint
$[BOOL ]EndPaint($[HWND hWnd], $[CONST PAINTSTRUCT *lpPaint])

$~EndTask
$[BOOL ]EndTask($[HWND hWnd], $[BOOL fShutDown], $[BOOL fForce])

$~EnumChildWindows
$[BOOL ]EnumChildWindows($[HWND hWndParent], $[WNDENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EnumDesktopsA
$[BOOL ]EnumDesktopsA($[HWINSTA hwinsta], $[DESKTOPENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EnumDesktopsW
$[BOOL ]EnumDesktopsW($[HWINSTA hwinsta], $[DESKTOPENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EnumDesktopWindows
$[BOOL ]EnumDesktopWindows($[HDESK hDesktop], $[WNDENUMPROC lpfn], $[LPARAM lParam])

$~EnumDisplayDevicesA
$[BOOL ]EnumDisplayDevicesA($[LPCSTR lpDevice], $[DWORD iDevNum], $[PDISPLAY_DEVICE lpDisplayDevice], $[DWORD dwFlags])

$~EnumDisplayDevicesW
$[BOOL ]EnumDisplayDevicesW($[LPCWSTR lpDevice], $[DWORD iDevNum], $[PDISPLAY_DEVICE lpDisplayDevice], $[DWORD dwFlags])

$~EnumDisplayMonitors
$[BOOL ]EnumDisplayMonitors($[HDC hdc], $[LPCRECT lprcClip], $[MONITORENUMPROC lpfnEnum], $[LPARAM dwData])

$~EnumDisplaySettingsA
$[BOOL ]EnumDisplaySettingsA($[LPCSTR lpszDeviceName], $[DWORD iModeNum], $[LPDEVMODE lpDevMode])

$~EnumDisplaySettingsExA
$[BOOL ]EnumDisplaySettingsExA($[LPCSTR lpszDeviceName], $[DWORD iModeNum], $[LPDEVMODE lpDevMode], $[DWORD dwFlags])

$~EnumDisplaySettingsExW
$[BOOL ]EnumDisplaySettingsExW($[LPCWSTR lpszDeviceName], $[DWORD iModeNum], $[LPDEVMODE lpDevMode], $[DWORD dwFlags])

$~EnumDisplaySettingsW
$[BOOL ]EnumDisplaySettingsW($[LPCWSTR lpszDeviceName], $[DWORD iModeNum], $[LPDEVMODE lpDevMode])

$~EnumThreadWindows
$[BOOL ]EnumThreadWindows($[DWORD dwThreadId], $[WNDENUMPROC lpfn], $[LPARAM lParam])

$~EnumWindows
$[BOOL ]EnumWindows($[WNDENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EnumWindowStationsA
$[BOOL ]EnumWindowStationsA($[WINSTAENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EnumWindowStationsW
$[BOOL ]EnumWindowStationsW($[WINSTAENUMPROC lpEnumFunc], $[LPARAM lParam])

$~EqualRect
$[BOOL ]EqualRect($[CONST RECT *lprc1], $[CONST RECT *lprc2])

$~ExitWindowsEx
$[BOOL ]ExitWindowsEx($[UINT uFlags], $[DWORD dwReason])

$~FlashWindow
$[BOOL ]FlashWindow($[HWND hWnd], $[BOOL bInvert])

$~FlashWindowEx
$[BOOL ]FlashWindowEx($[PFLASHWINFO pfwi])

$~FreeDDElParam
$[BOOL ]FreeDDElParam($[UINT msg], $[LPARAM lParam])

$~GetAltTabInfo
$[BOOL ]GetAltTabInfo($[HWND hwnd], $[int iItem], $[PALTTABINFO pati], $[LPSTR pszItemText], $[UINT cchItemText])

$~GetAltTabInfoA
$[BOOL ]GetAltTabInfoA($[HWND hwnd], $[int iItem], $[PALTTABINFO pati], $[LPSTR pszItemText], $[UINT cchItemText])

$~GetAltTabInfoW
$[BOOL ]GetAltTabInfoW($[HWND hwnd], $[int iItem], $[PALTTABINFO pati], $[LPSTR pszItemText], $[UINT cchItemText])

$~GetCaretPos
$[BOOL ]GetCaretPos($[LPPOINT lpPoint])

$~GetClassInfoA
$[BOOL ]GetClassInfoA($[HINSTANCE hInstance], $[LPCSTR lpClassName], $[LPWNDCLASS lpWndClass])

$~GetClassInfoExA
$[BOOL ]GetClassInfoExA($[HINSTANCE hinst], $[LPCSTR lpszClass], $[LPWNDCLASSEX lpwcx])

$~GetClassInfoExW
$[BOOL ]GetClassInfoExW($[HINSTANCE hinst], $[LPCWSTR lpszClass], $[LPWNDCLASSEX lpwcx])

$~GetClassInfoW
$[BOOL ]GetClassInfoW($[HINSTANCE hInstance], $[LPCWSTR lpClassName], $[LPWNDCLASS lpWndClass])

$~GetClientRect
$[BOOL ]GetClientRect($[HWND hWnd], $[LPRECT lpRect])

$~GetClipCursor
$[BOOL ]GetClipCursor($[LPRECT lpRect])

$~GetComboBoxInfo
$[BOOL ]GetComboBoxInfo($[HWND hwndCombo], $[PCOMBOBOXINFO pcbi])

$~GetCursorInfo
$[BOOL ]GetCursorInfo($[PCURSORINFO pci])

$~GetCursorPos
$[BOOL ]GetCursorPos($[LPPOINT lpPoint])

$~GetGUIThreadInfo
$[BOOL ]GetGUIThreadInfo($[DWORD idThread], $[LPGUITHREADINFO lpgui])

$~GetIconInfo
$[BOOL ]GetIconInfo($[HICON hIcon], $[PICONINFO piconinfo])

$~GetInputState
$[BOOL ]GetInputState($[])

$~GetKeyboardLayoutNameA
$[BOOL ]GetKeyboardLayoutNameA($[LPSTR pwszKLID])

$~GetKeyboardLayoutNameW
$[BOOL ]GetKeyboardLayoutNameW($[LPWSTR pwszKLID])

$~GetKeyboardState
$[BOOL ]GetKeyboardState($[PBYTE lpKeyState])

$~GetLastInputInfo
$[BOOL ]GetLastInputInfo($[PLASTINPUTINFO plii])

$~GetLayeredWindowAttributes
$[BOOL ]GetLayeredWindowAttributes($[HWND hwnd], $[COLORREF *pcrKey], $[BYTE *pbAlpha], $[DWORD *pdwFlags])

$~GetMenuBarInfo
$[BOOL ]GetMenuBarInfo($[HWND hwnd], $[LONG idObject], $[LONG idItem], $[PMENUBARINFO pmbi])

$~GetMenuInfo
$[BOOL ]GetMenuInfo($[HMENU hmenu], $[LPCMENUINFO lpcmi])

$~GetMenuItemInfoA
$[BOOL ]GetMenuItemInfoA($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPMENUITEMINFO lpmii])

$~GetMenuItemInfoW
$[BOOL ]GetMenuItemInfoW($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPMENUITEMINFO lpmii])

$~GetMenuItemRect
$[BOOL ]GetMenuItemRect($[HWND hWnd], $[HMENU hMenu], $[UINT uItem], $[LPRECT lprcItem])

$~GetMessageA
$[BOOL ]GetMessageA($[LPMSG lpMsg], $[HWND hWnd], $[UINT wMsgFilterMin], $[UINT wMsgFilterMax])

$~GetMessageW
$[BOOL ]GetMessageW($[LPMSG lpMsg], $[HWND hWnd], $[UINT wMsgFilterMin], $[UINT wMsgFilterMax])

$~GetMonitorInfoA
$[BOOL ]GetMonitorInfoA($[HMONITOR hMonitor], $[LPMONITORINFO lpmi])

$~GetMonitorInfoW
$[BOOL ]GetMonitorInfoW($[HMONITOR hMonitor], $[LPMONITORINFO lpmi])

$~GetProcessDefaultLayout
$[BOOL ]GetProcessDefaultLayout($[DWORD *pdwDefaultLayout])

$~GetScrollBarInfo
$[BOOL ]GetScrollBarInfo($[HWND hwnd], $[LONG idObject], $[PSCROLLBARINFO psbi])

$~GetScrollInfo
$[BOOL ]GetScrollInfo($[HWND hwnd], $[int fnBar], $[LPSCROLLINFO lpsi])

$~GetScrollRange
$[BOOL ]GetScrollRange($[HWND hWnd], $[int nBar], $[LPINT lpMinPos], $[LPINT lpMaxPos])

$~GetTitleBarInfo
$[BOOL ]GetTitleBarInfo($[HWND hwnd], $[PTITLEBARINFO pti])

$~GetUpdateRect
$[BOOL ]GetUpdateRect($[HWND hWnd], $[LPRECT lpRect], $[BOOL bErase])

$~GetUserObjectInformationA
$[BOOL ]GetUserObjectInformationA($[HANDLE hObj], $[int nIndex], $[PVOID pvInfo], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetUserObjectInformationW
$[BOOL ]GetUserObjectInformationW($[HANDLE hObj], $[int nIndex], $[PVOID pvInfo], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetUserObjectSecurity
$[BOOL ]GetUserObjectSecurity($[HANDLE hObj], $[PSECURITY_INFORMATION pSIRequested], $[PSECURITY_DESCRIPTOR pSD], $[DWORD nLength], $[LPDWORD lpnLengthNeeded])

$~GetWindowInfo
$[BOOL ]GetWindowInfo($[HWND hwnd], $[PWINDOWINFO pwi])

$~GetWindowPlacement
$[BOOL ]GetWindowPlacement($[HWND hWnd], $[WINDOWPLACEMENT *lpwndpl])

$~GetWindowRect
$[BOOL ]GetWindowRect($[HWND hWnd], $[LPRECT lpRect])

$~GrayStringA
$[BOOL ]GrayStringA($[HDC hDC], $[HBRUSH hBrush], $[GRAYSTRINGPROC lpOutputFunc], $[LPARAM lpData], $[int nCount], $[int X], $[int Y], $[int nWidth], $[int nHeight])

$~GrayStringW
$[BOOL ]GrayStringW($[HDC hDC], $[HBRUSH hBrush], $[GRAYSTRINGPROC lpOutputFunc], $[LPARAM lpData], $[int nCount], $[int X], $[int Y], $[int nWidth], $[int nHeight])

$~HideCaret
$[BOOL ]HideCaret($[HWND hWnd])

$~HiliteMenuItem
$[BOOL ]HiliteMenuItem($[HWND hwnd], $[HMENU hmenu], $[UINT uItemHilite], $[UINT uHilite])

$~ImpersonateDdeClientWindow
$[BOOL ]ImpersonateDdeClientWindow($[HWND hWndClient], $[HWND hWndServer])

$~InflateRect
$[BOOL ]InflateRect($[LPRECT lprc], $[int dx], $[int dy])

$~InSendMessage
$[BOOL ]InSendMessage($[])

$~InsertMenuA
$[BOOL ]InsertMenuA($[HMENU hMenu], $[UINT uPosition], $[UINT uFlags], $[PTR uIDNewItem], $[LPCSTR lpNewItem])

$~InsertMenuItemA
$[BOOL ]InsertMenuItemA($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPCMENUITEMINFO lpmii])

$~InsertMenuItemW
$[BOOL ]InsertMenuItemW($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPCMENUITEMINFO lpmii])

$~InsertMenuW
$[BOOL ]InsertMenuW($[HMENU hMenu], $[UINT uPosition], $[UINT uFlags], $[PTR uIDNewItem], $[LPCWSTR lpNewItem])

$~IntersectRect
$[BOOL ]IntersectRect($[LPRECT lprcDst], $[CONST RECT *lprcSrc1], $[CONST RECT *lprcSrc2])

$~InvalidateRect
$[BOOL ]InvalidateRect($[HWND hWnd], $[CONST RECT* lpRect], $[BOOL bErase])

$~InvalidateRgn
$[BOOL ]InvalidateRgn($[HWND hWnd], $[HRGN hRgn], $[BOOL bErase])

$~InvertRect
$[BOOL ]InvertRect($[HDC hDC], $[CONST RECT *lprc])

$~IsCharAlphaA
$[BOOL ]IsCharAlphaA($[T HAR ch])

$~IsCharAlphaNumericA
$[BOOL ]IsCharAlphaNumericA($[T HAR ch])

$~IsCharAlphaNumericW
$[BOOL ]IsCharAlphaNumericW($[TWHAR ch])

$~IsCharAlphaW
$[BOOL ]IsCharAlphaW($[TWHAR ch])

$~IsCharLowerA
$[BOOL ]IsCharLowerA($[T HAR ch])

$~IsCharLowerW
$[BOOL ]IsCharLowerW($[TWHAR ch])

$~IsCharUpperA
$[BOOL ]IsCharUpperA($[T HAR ch])

$~IsCharUpperW
$[BOOL ]IsCharUpperW($[TWHAR ch])

$~IsChild
$[BOOL ]IsChild($[HWND hWndParent], $[HWND hWnd])

$~IsClipboardFormatAvailable
$[BOOL ]IsClipboardFormatAvailable($[UINT format])

$~IsDialogMessage
$[BOOL ]IsDialogMessage($[HWND hDlg], $[LPMSG lpMsg])

$~IsDialogMessageA
$[BOOL ]IsDialogMessageA($[HWND hDlg], $[LPMSG lpMsg])

$~IsDialogMessageW
$[BOOL ]IsDialogMessageW($[HWND hDlg], $[LPMSG lpMsg])

$~IsGUIThread
$[BOOL ]IsGUIThread($[BOOL bConvert])

$~IsHungAppWindow
$[BOOL ]IsHungAppWindow($[HWND hWnd])

$~IsIconic
$[BOOL ]IsIconic($[HWND hWnd])

$~IsMenu
$[BOOL ]IsMenu($[HMENU hMenu])

$~IsRectEmpty
$[BOOL ]IsRectEmpty($[CONST RECT* lprc])

$~IsWindow
$[BOOL ]IsWindow($[HWND hWnd])

$~IsWindowEnabled
$[BOOL ]IsWindowEnabled($[HWND hWnd])

$~IsWindowUnicode
$[BOOL ]IsWindowUnicode($[HWND hWnd])

$~IsWindowVisible
$[BOOL ]IsWindowVisible($[HWND hWnd])

$~IsWinEventHookInstalled
$[BOOL ]IsWinEventHookInstalled($[DWORD event])

$~IsZoomed
$[BOOL ]IsZoomed($[HWND hWnd])

$~KillTimer
$[BOOL ]KillTimer($[HWND hWnd], $[UINT_PTR uIDEvent])

$~LockSetForegroundWindow
$[BOOL ]LockSetForegroundWindow($[UINT uLockCode])

$~LockWindowUpdate
$[BOOL ]LockWindowUpdate($[HWND hWndLock])

$~LockWorkStation
$[BOOL ]LockWorkStation($[])

$~MapDialogRect
$[BOOL ]MapDialogRect($[HWND hDlg], $[LPRECT lpRect])

$~MessageBeep
$[BOOL ]MessageBeep($[UINT uType])

$~ModifyMenuA
$[BOOL ]ModifyMenuA($[HMENU hMnu], $[UINT uPosition], $[UINT uFlags], $[PTR uIDNewItem], $[LPCSTR lpNewItem])

$~ModifyMenuW
$[BOOL ]ModifyMenuW($[HMENU hMnu], $[UINT uPosition], $[UINT uFlags], $[PTR uIDNewItem], $[LPCWSTR lpNewItem])

$~MoveWindow
$[BOOL ]MoveWindow($[HWND hWnd], $[int X], $[int Y], $[int nWidth], $[int nHeight], $[BOOL bRepaint])

$~OemToCharA
$[BOOL ]OemToCharA($[LPCSTR lpszSrc], $[LPSTR lpszDst])

$~OemToCharBuffA
$[BOOL ]OemToCharBuffA($[LPCSTR lpszSrc], $[LPSTR lpszDst], $[DWORD cchDstLength])

$~OemToCharBuffW
$[BOOL ]OemToCharBuffW($[LPCWSTR lpszSrc], $[LPWSTR lpszDst], $[DWORD cchDstLength])

$~OemToCharW
$[BOOL ]OemToCharW($[LPCSTR lpszSrc], $[LPWSTR lpszDst])

$~OpenClipboard
$[BOOL ]OpenClipboard($[HWND hWndNewOwner])

$~OpenIcon
$[BOOL ]OpenIcon($[HWND hWnd])

$~PaintDesktop
$[BOOL ]PaintDesktop($[HDC hdc])

$~PeekMessageA
$[BOOL ]PeekMessageA($[LPMSG lpMsg], $[HWND hWnd], $[UINT wMsgFilterMin], $[UINT wMsgFilterMax], $[UINT wRemoveMsg])

$~PeekMessageW
$[BOOL ]PeekMessageW($[LPMSG lpMsg], $[HWND hWnd], $[UINT wMsgFilterMin], $[UINT wMsgFilterMax], $[UINT wRemoveMsg])

$~PostMessageA
$[BOOL ]PostMessageA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~PostMessageW
$[BOOL ]PostMessageW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~PostThreadMessageA
$[BOOL ]PostThreadMessageA($[DWORD idThread], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~PostThreadMessageW
$[BOOL ]PostThreadMessageW($[DWORD idThread], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~PrintWindow
$[BOOL ]PrintWindow($[HWND hwnd], $[HDC hdcBlt], $[UINT nFlags])

$~PtInRect
$[BOOL ]PtInRect($[CONST RECT *lprc], $[POINT Point])

$~RedrawWindow
$[BOOL ]RedrawWindow($[HWND hWnd], $[CONST RECT *lprcUpdate], $[HRGN hrgnUpdate], $[UINT flags])

$~RegisterHotKey
$[BOOL ]RegisterHotKey($[HWND hWnd], $[int id], $[UINT fsModifiers], $[UINT vk])

$~RegisterRawInputDevices
$[BOOL ]RegisterRawInputDevices($[PCRAWINPUTDEVICE pRawInputDevices], $[UINT uiNumDevices], $[UINT cbSize])

$~RegisterShellHookWindow
$[BOOL ]RegisterShellHookWindow($[HWND hWnd])

$~RemoveMenu
$[BOOL ]RemoveMenu($[HMENU hMenu], $[UINT uPosition], $[UINT uFlags])

$~ReplyMessage
$[BOOL ]ReplyMessage($[LRESULT lResult])

$~ScreenToClient
$[BOOL ]ScreenToClient($[HWND hWnd], $[LPPOINT lpPoint])

$~ScrollDC
$[BOOL ]ScrollDC($[HDC hDC], $[int dx], $[int dy], $[const RECT *lprcScroll], $[const RECT *lprcClip], $[HRGN hrgnUpdate], $[LPRECT lprcUpdate])

$~ScrollWindow
$[BOOL ]ScrollWindow($[HWND hWnd], $[int XAmount], $[int YAmount], $[const RECT *lpRect], $[const RECT *lpClipRect])

$~SendMessageCallbackA
$[BOOL ]SendMessageCallbackA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam], $[SENDASYNCPROC lpCallBack], $[ULONG_PTR dwData])

$~SendMessageCallbackW
$[BOOL ]SendMessageCallbackW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam], $[SENDASYNCPROC lpCallBack], $[ULONG_PTR dwData])

$~SendNotifyMessageA
$[BOOL ]SendNotifyMessageA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~SendNotifyMessageW
$[BOOL ]SendNotifyMessageW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~SetCaretBlinkTime
$[BOOL ]SetCaretBlinkTime($[UINT uMSeconds])

$~SetCaretPos
$[BOOL ]SetCaretPos($[int X], $[int Y])

$~SetCursorPos
$[BOOL ]SetCursorPos($[int X], $[int Y])

$~SetDlgItemInt
$[BOOL ]SetDlgItemInt($[HWND hDlg], $[int nIDDlgItem], $[UINT uValue], $[BOOL bSigned])

$~SetDlgItemTextA
$[BOOL ]SetDlgItemTextA($[HWND hDlg], $[int nIDDlgItem], $[LPCSTR lpString])

$~SetDlgItemTextW
$[BOOL ]SetDlgItemTextW($[HWND hDlg], $[int nIDDlgItem], $[LPCWSTR lpString])

$~SetDoubleClickTime
$[BOOL ]SetDoubleClickTime($[UINT uInterval])

$~SetForegroundWindow
$[BOOL ]SetForegroundWindow($[HWND hWnd])

$~SetKeyboardState
$[BOOL ]SetKeyboardState($[LPBYTE lpKeyState])

$~SetLayeredWindowAttributes
$[BOOL ]SetLayeredWindowAttributes($[HWND hwnd], $[COLORREF crKey], $[BYTE bAlpha], $[DWORD dwFlags])

$~SetMenu
$[BOOL ]SetMenu($[HWND hWnd], $[HMENU hMenu])

$~SetMenuContextHelpId
$[BOOL ]SetMenuContextHelpId($[HMENU hmenu], $[DWORD dwContextHelpId])

$~SetMenuDefaultItem
$[BOOL ]SetMenuDefaultItem($[HMENU hMenu], $[UINT uItem], $[UINT fByPos])

$~SetMenuInfo
$[BOOL ]SetMenuInfo($[HMENU hmenu], $[LPCMENUINFO lpcmi])

$~SetMenuItemBitmaps
$[BOOL ]SetMenuItemBitmaps($[HMENU hMenu], $[UINT uPosition], $[UINT uFlags], $[HBITMAP hBitmapUnchecked], $[HBITMAP hBitmapChecked])

$~SetMenuItemInfoA
$[BOOL ]SetMenuItemInfoA($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPMENUITEMINFO lpmii])

$~SetMenuItemInfoW
$[BOOL ]SetMenuItemInfoW($[HMENU hMenu], $[UINT uItem], $[BOOL fByPosition], $[LPMENUITEMINFO lpmii])

$~SetProcessDefaultLayout
$[BOOL ]SetProcessDefaultLayout($[DWORD dwDefaultLayout])

$~SetProcessWindowStation
$[BOOL ]SetProcessWindowStation($[HWINSTA hWinSta])

$~SetPropA
$[BOOL ]SetPropA($[HWND hWnd], $[LPCSTR lpString], $[HANDLE hData])

$~SetPropW
$[BOOL ]SetPropW($[HWND hWnd], $[LPCWSTR lpString], $[HANDLE hData])

$~SetRectEmpty
$[BOOL ]SetRectEmpty($[LPRECT lprc])

$~SetScrollRange
$[BOOL ]SetScrollRange($[HWND hWnd], $[int nBar], $[int nMinPos], $[int nMaxPos], $[BOOL bRedraw])

$~SetSysColors
$[BOOL ]SetSysColors($[int cElements], $[const INT* lpaElements], $[const COLORREF* lpaRgbValues])

$~SetSysColorsTemp
$[BOOL ]SetSysColorsTemp($[int cElements], $[const INT* lpaElements], $[const COLORREF* lpaRgbValues])

$~SetSystemCursor
$[BOOL ]SetSystemCursor($[HCURSOR hcur], $[DWORD id])

$~SetThreadDesktop
$[BOOL ]SetThreadDesktop($[HDESK hDesktop])

$~SetUserObjectInformationA
$[BOOL ]SetUserObjectInformationA($[HANDLE hObj], $[int nIndex], $[PVOID pvInfo], $[DWORD nLength])

$~SetUserObjectInformationW
$[BOOL ]SetUserObjectInformationW($[HANDLE hObj], $[int nIndex], $[PVOID pvInfo], $[DWORD nLength])

$~SetUserObjectSecurity
$[BOOL ]SetUserObjectSecurity($[HANDLE hObj], $[PSECURITY_INFORMATION pSIRequested], $[PSECURITY_DESCRIPTOR pSID])

$~SetWindowContextHelpId
$[BOOL ]SetWindowContextHelpId($[HWND hwnd], $[DWORD dwContextHelpId])

$~SetWindowPlacement
$[BOOL ]SetWindowPlacement($[HWND hWnd], $[WINDOWPLACEMENT *lpwndpl])

$~SetWindowPos
$[BOOL ]SetWindowPos($[HWND hWnd], $[HWND hWndInsertAfter], $[int X], $[int Y], $[int cx], $[int cy], $[UINT uFlags])

$~SetWindowTextA
$[BOOL ]SetWindowTextA($[HWND hWnd], $[LPCSTR lpString])

$~SetWindowTextW
$[BOOL ]SetWindowTextW($[HWND hWnd], $[LPCWSTR lpString])

$~ShowCaret
$[BOOL ]ShowCaret($[HWND hWnd])

$~ShowOwnedPopups
$[BOOL ]ShowOwnedPopups($[HWND hWnd], $[BOOL fShow])

$~ShowScrollBar
$[BOOL ]ShowScrollBar($[HWND hWnd], $[int wBar], $[BOOL bShow])

$~ShowWindow
$[BOOL ]ShowWindow($[HWND hWnd], $[int nCmdShow])

$~ShowWindowAsync
$[BOOL ]ShowWindowAsync($[HWND hWnd], $[int nCmdShow])

$~SubtractRect
$[BOOL ]SubtractRect($[LPRECT lprcDst], $[CONST RECT *lprcSrc1], $[CONST RECT *lprcSrc2])

$~SwapMouseButton
$[BOOL ]SwapMouseButton($[BOOL fSwap])

$~SwitchDesktop
$[BOOL ]SwitchDesktop($[HDESK hDesktop])

$~SystemParametersInfoA
$[BOOL ]SystemParametersInfoA($[UINT uiAction], $[UINT uiParam], $[PVOID pvParam], $[UINT fWinIni])

$~SystemParametersInfoW
$[BOOL ]SystemParametersInfoW($[UINT uiAction], $[UINT uiParam], $[PVOID pvParam], $[UINT fWinIni])

$~TrackMouseEvent
$[BOOL ]TrackMouseEvent($[LPTRACKMOUSEEVENT lpEventTrack])

$~TrackPopupMenu
$[BOOL ]TrackPopupMenu($[HMENU hMenu], $[UINT uFlags], $[int x], $[int y], $[int nReserved], $[HWND hWnd], $[HWND prcRect])

$~TrackPopupMenuEx
$[BOOL ]TrackPopupMenuEx($[HMENU hmenu], $[UINT fuFlags], $[int x], $[int y], $[HWND hwnd], $[LPTPMPARAMS lptpm])

$~TranslateMDISysAccel
$[BOOL ]TranslateMDISysAccel($[HWND hWndClient], $[LPMSG lpMsg])

$~TranslateMessage
$[BOOL ]TranslateMessage($[const MSG *lpMsg])

$~UnhookWindowsHookEx
$[BOOL ]UnhookWindowsHookEx($[HHOOK hhk])

$~UnhookWinEvent
$[BOOL ]UnhookWinEvent($[HWINEVENTHOOK hWinEventHook])

$~UnionRect
$[BOOL ]UnionRect($[LPRECT lprcDst], $[CONST RECT *lprcSrc1], $[CONST RECT *lprcSrc2])

$~UnloadKeyboardLayout
$[BOOL ]UnloadKeyboardLayout($[HKL hkl])

$~UnpackDDElParam
$[BOOL ]UnpackDDElParam($[UINT msg], $[LPARAM lParam], $[PUINT_PTR puiLo], $[PUINT_PTR puiHi])

$~UnregisterClassA
$[BOOL ]UnregisterClassA($[LPCSTR lpClassName], $[HINSTANCE hInstance])

$~UnregisterClassW
$[BOOL ]UnregisterClassW($[LPCWSTR lpClassName], $[HINSTANCE hInstance])

$~UnregisterDeviceNotification
$[BOOL ]UnregisterDeviceNotification($[HDEVNOTIFY Handle])

$~UnregisterHotKey
$[BOOL ]UnregisterHotKey($[HWND hWnd], $[int id])

$~UpdateLayeredWindow
$[BOOL ]UpdateLayeredWindow($[HWND hwnd], $[HDC hdcDst], $[POINT *pptDst], $[SIZE *psize], $[HDC hdcSrc], $[POINT *pptSrc], $[COLORREF crKey], $[BLENDFUNCTION *pblend], $[DWORD dwFlags])

$~UpdateWindow
$[BOOL ]UpdateWindow($[HWND hWnd])

$~UserHandleGrantAccess
$[BOOL ]UserHandleGrantAccess($[HANDLE hUserHandle], $[HANDLE hJob], $[BOOL bGrant])

$~ValidateRect
$[BOOL ]ValidateRect($[HWND hWnd], $[CONST RECT *lpRect])

$~ValidateRgn
$[BOOL ]ValidateRgn($[HWND hWnd], $[HRGN hRgn])

$~WaitMessage
$[BOOL ]WaitMessage($[])

$~WinHelpA
$[BOOL ]WinHelpA($[HWND hWndMain], $[LPCSTR lpszHelp], $[UINT uCommand], $[ULONG_PTR dwData])

$~WinHelpW
$[BOOL ]WinHelpW($[HWND hWndMain], $[LPCWSTR lpszHelp], $[UINT uCommand], $[ULONG_PTR dwData])

$~CharLowerBuffA
$[DWORD ]CharLowerBuffA($[LPSTR lpsz], $[DWORD cchLength])

$~CharLowerBuffW
$[DWORD ]CharLowerBuffW($[LPWSTR lpsz], $[DWORD cchLength])

$~CharUpperBuffA
$[DWORD ]CharUpperBuffA($[LPSTR lpsz], $[DWORD cchLength])

$~CharUpperBuffW
$[DWORD ]CharUpperBuffW($[LPWSTR lpsz], $[DWORD cchLength])

$~CheckMenuItem
$[DWORD ]CheckMenuItem($[HMENU hmenu], $[UINT uIDCheckItem], $[UINT uCheck])

$~DdeGetData
$[DWORD ]DdeGetData($[HDDEDATA hData], $[LPBYTE pDst], $[DWORD cbMax], $[DWORD cbOff])

$~DdeQueryStringA
$[DWORD ]DdeQueryStringA($[DWORD idInst], $[HSZ hsz], $[LPSTR psz], $[DWORD cchMax], $[int iCodePage])

$~DdeQueryStringW
$[DWORD ]DdeQueryStringW($[DWORD idInst], $[HSZ hsz], $[LPWSTR psz], $[DWORD cchMax], $[int iCodePage])

$~GetClassLongA
$[DWORD ]GetClassLongA($[HWND hWnd], $[int nIndex])

$~GetClassLongW
$[DWORD ]GetClassLongW($[HWND hWnd], $[int nIndex])

$~GetClipboardSequenceNumber
$[DWORD ]GetClipboardSequenceNumber($[VOID])

$~GetGuiResources
$[DWORD ]GetGuiResources($[HANDLE hProcess], $[DWORD uiFlags])

$~GetListBoxInfo
$[DWORD ]GetListBoxInfo($[HWND hwnd])

$~GetMenuContextHelpId
$[DWORD ]GetMenuContextHelpId($[HMENU hmenu])

$~GetMessagePos
$[DWORD ]GetMessagePos($[])

$~GetQueueStatus
$[DWORD ]GetQueueStatus($[UINT flags])

$~GetSysColor
$[DWORD ]GetSysColor($[int nIndex])

$~GetTabbedTextExtentA
$[DWORD ]GetTabbedTextExtentA($[HDC hDC], $[LPSTR lpString], $[int nCount], $[int nTabPositions], $[CONST LPINT lpnTabStopPositions])

$~GetTabbedTextExtentW
$[DWORD ]GetTabbedTextExtentW($[HDC hDC], $[LPCWSTR lpString], $[int nCount], $[int nTabPositions], $[CONST LPINT lpnTabStopPositions])

$~GetWindowContextHelpId
$[DWORD ]GetWindowContextHelpId($[HWND hwnd])

$~GetWindowThreadProcessId
$[DWORD ]GetWindowThreadProcessId($[HWND hWnd], $[LPDWORD lpdwProcessId])

$~InSendMessageEx
$[DWORD ]InSendMessageEx($[LPVOID lpReserved])

$~MsgWaitForMultipleObjects
$[DWORD ]MsgWaitForMultipleObjects($[DWORD nCount], $[const HANDLE* pHandles], $[BOOL bWaitAll], $[DWORD dwMilliseconds], $[DWORD dwWakeMask])

$~MsgWaitForMultipleObjectsEx
$[DWORD ]MsgWaitForMultipleObjectsEx($[DWORD nCount], $[const HANDLE* pHandles], $[DWORD dwMilliseconds], $[DWORD dwWakeMask], $[DWORD dwFlags])

$~OemKeyScan
$[DWORD ]OemKeyScan($[WORD wOemChar])

$~SetClassLongA
$[DWORD ]SetClassLongA($[HWND hWnd], $[int nIndex], $[LONG dwNewLong])

$~SetClassLongW
$[DWORD ]SetClassLongW($[HWND hWnd], $[int nIndex], $[LONG dwNewLong])

$~WaitForInputIdle
$[DWORD ]WaitForInputIdle($[HANDLE hProcess], $[DWORD dwMilliseconds])

$~CreateAcceleratorTableA
$[HACCEL ]CreateAcceleratorTableA($[LPACCEL lpaccl], $[int cEntries])

$~CreateAcceleratorTableW
$[HACCEL ]CreateAcceleratorTableW($[LPACCEL lpaccl], $[int cEntries])

$~LoadAcceleratorsA
$[HACCEL ]LoadAcceleratorsA($[HINSTANCE hInstance], $[LPCSTR lpTableName])

$~LoadAcceleratorsW
$[HACCEL ]LoadAcceleratorsW($[HINSTANCE hInstance], $[LPCWSTR lpTableName])

$~CopyImage
$[HANDLE ]CopyImage($[HANDLE hImage], $[UINT uType], $[int cxDesired], $[int cyDesired], $[UINT fuFlags])

$~GetClipboardData
$[HANDLE ]GetClipboardData($[UINT uFormat])

$~GetPropA
$[HANDLE ]GetPropA($[HWND hWnd], $[LPCSTR lpString])

$~GetPropW
$[HANDLE ]GetPropW($[HWND hWnd], $[LPCWSTR lpString])

$~LoadImageA
$[HANDLE ]LoadImageA($[HINSTANCE hinst], $[LPCSTR lpszName], $[UINT uType], $[int cxDesired], $[int cyDesired], $[UINT fuLoad])

$~LoadImageW
$[HANDLE ]LoadImageW($[HINSTANCE hinst], $[LPCWSTR lpszName], $[UINT uType], $[int cxDesired], $[int cyDesired], $[UINT fuLoad])

$~RemovePropA
$[HANDLE ]RemovePropA($[HWND hWnd], $[LPCSTR lpString])

$~RemovePropW
$[HANDLE ]RemovePropW($[HWND hWnd], $[LPCWSTR lpString])

$~SetClipboardData
$[HANDLE ]SetClipboardData($[UINT uFormat], $[HANDLE hMem])

$~LoadBitmapA
$[HBITMAP ]LoadBitmapA($[HINSTANCE hInstance], $[LPCSTR lpBitmapName])

$~LoadBitmapW
$[HBITMAP ]LoadBitmapW($[HINSTANCE hInstance], $[LPCWSTR lpBitmapName])

$~GetSysColorBrush
$[HBRUSH ]GetSysColorBrush($[int nIndex])

$~DdeConnect
$[HCONV ]DdeConnect($[DWORD idInst], $[HSZ hszService], $[HSZ hszTopic], $[PCONVCONTEXT pCC])

$~DdeQueryNextServer
$[HCONV ]DdeQueryNextServer($[HCONVLIST hConvList], $[HCONV hConvPrev])

$~DdeReconnect
$[HCONV ]DdeReconnect($[HCONV hConv])

$~DdeConnectList
$[HCONVLIST ]DdeConnectList($[DWORD idInst], $[HSZ hszService], $[HSZ hszTopic], $[HCONVLIST hConvList], $[PCONVCONTEXT pCC])

$~CreateCursor
$[HCURSOR ]CreateCursor($[HINSTANCE hInst], $[int xHotSpot], $[int yHotSpot], $[int nWidth], $[int nHeight], $[const VOID *pvANDPlane], $[const VOID *pvXORPlane])

$~GetCursor
$[HCURSOR ]GetCursor($[])

$~LoadCursorA
$[HCURSOR ]LoadCursorA($[HINSTANCE hInstance], $[LPCSTR lpCursorName])

$~LoadCursorFromFileA
$[HCURSOR ]LoadCursorFromFileA($[LPCSTR lpFileName])

$~LoadCursorFromFileW
$[HCURSOR ]LoadCursorFromFileW($[LPCWSTR lpFileName])

$~LoadCursorW
$[HCURSOR ]LoadCursorW($[HINSTANCE hInstance], $[LPCWSTR lpCursorName])

$~SetCursor
$[HCURSOR ]SetCursor($[HCURSOR hCursor])

$~BeginPaint
$[HDC ]BeginPaint($[HWND hwnd], $[LPPAINTSTRUCT lpPaint])

$~GetDC
$[HDC ]GetDC($[HWND hWnd])

$~GetDCEx
$[HDC ]GetDCEx($[HWND hWnd], $[HRGN hrgnClip], $[DWORD flags])

$~GetWindowDC
$[HDC ]GetWindowDC($[HWND hWnd])

$~DdeAddData
$[HDDEDATA ]DdeAddData($[HDDEDATA hData], $[LPBYTE pSrc], $[DWORD cb], $[DWORD cbOff])

$~DdeClientTransaction
$[HDDEDATA ]DdeClientTransaction($[LPBYTE pData], $[DWORD cbData], $[HCONV hConv], $[HSZ hszItem], $[UINT wFmt], $[UINT wType], $[DWORD dwTimeout], $[LPDWORD pdwResult])

$~DdeCreateDataHandle
$[HDDEDATA ]DdeCreateDataHandle($[DWORD idInst], $[LPBYTE pSrc], $[DWORD cb], $[DWORD cbOff], $[HSZ hszItem], $[UINT wFmt], $[UINT afCmd])

$~DdeNameService
$[HDDEDATA ]DdeNameService($[DWORD idInst], $[UINT hsz1], $[UINT hsz2], $[UINT afCmd])

$~CreateDesktopA
$[HDESK ]CreateDesktopA($[LPCSTR lpszDesktop], $[LPCSTR lpszDevice], $[LPDEVMODE pDevmode], $[DWORD dwFlags], $[ACCESS_MASK dwDesiredAccess], $[LPSECURITY_ATTRIBUTES lpsa])

$~CreateDesktopW
$[HDESK ]CreateDesktopW($[LPCWSTR lpszDesktop], $[LPCWSTR lpszDevice], $[LPDEVMODE pDevmode], $[DWORD dwFlags], $[ACCESS_MASK dwDesiredAccess], $[LPSECURITY_ATTRIBUTES lpsa])

$~GetThreadDesktop
$[HDESK ]GetThreadDesktop($[DWORD dwThreadId])

$~OpenDesktopA
$[HDESK ]OpenDesktopA($[LPSTR lpszDesktop], $[DWORD dwFlags], $[BOOL fInherit], $[ACCESS_MASK dwDesiredAccess])

$~OpenDesktopW
$[HDESK ]OpenDesktopW($[LPWSTR lpszDesktop], $[DWORD dwFlags], $[BOOL fInherit], $[ACCESS_MASK dwDesiredAccess])

$~OpenInputDesktop
$[HDESK ]OpenInputDesktop($[DWORD dwFlags], $[BOOL fInherit], $[ACCESS_MASK dwDesiredAccess])

$~RegisterDeviceNotificationA
$[HDEVNOTIFY ]RegisterDeviceNotificationA($[HANDLE hRecipient], $[LPVOID NotificationFilter], $[DWORD Flags])

$~RegisterDeviceNotificationW
$[HDEVNOTIFY ]RegisterDeviceNotificationW($[HANDLE hRecipient], $[LPVOID NotificationFilter], $[DWORD Flags])

$~BeginDeferWindowPos
$[HDWP ]BeginDeferWindowPos($[int nNumWindows])

$~DeferWindowPos
$[HDWP ]DeferWindowPos($[HDWP hWinPosInfo], $[HWND hWnd], $[HWND hWndInsertAfter], $[int x], $[int y], $[int cx], $[int cy], $[UINT uFlags])

$~SetWindowsHookA
$[HHOOK ]SetWindowsHookA($[int idHook], $[HOOKPROC lpfn])

$~SetWindowsHookExA
$[HHOOK ]SetWindowsHookExA($[int idHook], $[HOOKPROC lpfn], $[HINSTANCE hMod], $[DWORD dwThreadId])

$~SetWindowsHookExW
$[HHOOK ]SetWindowsHookExW($[int idHook], $[HOOKPROC lpfn], $[HINSTANCE hMod], $[DWORD dwThreadId])

$~SetWindowsHookW
$[HHOOK ]SetWindowsHookW($[int idHook], $[HOOKPROC lpfn])

$~CopyIcon
$[HICON ]CopyIcon($[HICON hIcon])

$~CreateIcon
$[HICON ]CreateIcon($[HINSTANCE hInstance], $[int nWidth], $[int nHeight], $[BYTE cPlanes], $[BYTE cBitsPixel], $[const BYTE *lpbANDbits], $[const BYTE *lpbXORbits])

$~CreateIconFromResource
$[HICON ]CreateIconFromResource($[PBYTE presbits], $[DWORD dwResSize], $[BOOL fIcon], $[DWORD dwVer])

$~CreateIconFromResourceEx
$[HICON ]CreateIconFromResourceEx($[PBYTE pbIconBits], $[DWORD cbIconBits], $[BOOL fIcon], $[DWORD dwVersion], $[int cxDesired], $[int cyDesired], $[UINT uFlags])

$~CreateIconIndirect
$[HICON ]CreateIconIndirect($[PICONINFO piconinfo])

$~LoadIconA
$[HICON ]LoadIconA($[HINSTANCE hInstance], $[LPCSTR lpIconName])

$~LoadIconW
$[HICON ]LoadIconW($[HINSTANCE hInstance], $[LPCWSTR lpIconName])

$~ActivateKeyboardLayout
$[HKL ]ActivateKeyboardLayout($[HKL hkl], $[UINT Flags])

$~GetKeyboardLayout
$[HKL ]GetKeyboardLayout($[DWORD idThread])

$~LoadKeyboardLayoutA
$[HKL ]LoadKeyboardLayoutA($[LPCSTR pwszKLID], $[UINT Flags])

$~LoadKeyboardLayoutW
$[HKL ]LoadKeyboardLayoutW($[LPCWSTR pwszKLID], $[UINT Flags])

$~CreateMenu
$[HMENU ]CreateMenu($[])

$~CreatePopupMenu
$[HMENU ]CreatePopupMenu($[])

$~GetMenu
$[HMENU ]GetMenu($[HWND hWnd])

$~GetSubMenu
$[HMENU ]GetSubMenu($[HMENU hMenu], $[int nPos])

$~GetSystemMenu
$[HMENU ]GetSystemMenu($[HWND hWnd], $[BOOL bRevert])

$~LoadMenuA
$[HMENU ]LoadMenuA($[HINSTANCE hInstance], $[LPCSTR lpMenuName])

$~LoadMenuIndirectA
$[HMENU ]LoadMenuIndirectA($[CONST MENUTEMPLATE *lpMenuTemplate])

$~LoadMenuIndirectW
$[HMENU ]LoadMenuIndirectW($[CONST MENUTEMPLATE *lpMenuTemplate])

$~LoadMenuW
$[HMENU ]LoadMenuW($[HINSTANCE hInstance], $[LPCWSTR lpMenuName])

$~MonitorFromPoint
$[HMONITOR ]MonitorFromPoint($[POINT Point], $[DWORD dwFlags])

$~MonitorFromRect
$[HMONITOR ]MonitorFromRect($[LPCRECT lprc], $[DWORD dwFlags])

$~MonitorFromWindow
$[HMONITOR ]MonitorFromWindow($[HWND hwnd], $[DWORD dwFlags])

$~DdeCreateStringHandleA
$[HSZ ]DdeCreateStringHandleA($[DWORD idInst], $[LPSTR psz], $[int iCodePage])

$~DdeCreateStringHandleW
$[HSZ ]DdeCreateStringHandleW($[DWORD idInst], $[LPWSTR psz], $[int iCodePage])

$~SetWinEventHook
$[HWINEVENTHOOK ]SetWinEventHook($[UINT eventMin], $[UINT eventMax], $[HMODULE hmodWinEventProc], $[WINEVENTPROC lpfnWinEventProc], $[DWORD idProcess], $[DWORD idThread], $[UINT dwflags])

$~CreateWindowStationA
$[HWINSTA ]CreateWindowStationA($[LPCSTR lpwinsta], $[DWORD dwFlags], $[ACCESS_MASK dwDesiredAccess], $[LPSECURITY_ATTRIBUTES lpsa])

$~CreateWindowStationW
$[HWINSTA ]CreateWindowStationW($[LPCWSTR lpwinsta], $[DWORD dwFlags], $[ACCESS_MASK dwDesiredAccess], $[LPSECURITY_ATTRIBUTES lpsa])

$~GetProcessWindowStation
$[HWINSTA ]GetProcessWindowStation($[])

$~OpenWindowStationA
$[HWINSTA ]OpenWindowStationA($[LPSTR lpszWinSta], $[BOOL fInherit], $[ACCESS_MASK dwDesiredAccess])

$~OpenWindowStationW
$[HWINSTA ]OpenWindowStationW($[LPWSTR lpszWinSta], $[BOOL fInherit], $[ACCESS_MASK dwDesiredAccess])

$~ChildWindowFromPoint
$[HWND ]ChildWindowFromPoint($[HWND hWndParent], $[POINT Point])

$~ChildWindowFromPointEx
$[HWND ]ChildWindowFromPointEx($[HWND hwndParent], $[POINT Point], $[UINT uFlags])

$~CreateDialogIndirectParamA
$[HWND ]CreateDialogIndirectParamA($[HINSTANCE hInstance], $[LPCDLGTEMPLATE lpTemplate], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM lParamInit])

$~CreateDialogIndirectParamW
$[HWND ]CreateDialogIndirectParamW($[HINSTANCE hInstance], $[LPCDLGTEMPLATE lpTemplate], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM lParamInit])

$~CreateDialogParamA
$[HWND ]CreateDialogParamA($[HINSTANCE hInstance], $[LPCSTR lpTemplateName], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~CreateDialogParamW
$[HWND ]CreateDialogParamW($[HINSTANCE hInstance], $[LPCWSTR lpTemplateName], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~CreateMDIWindowA
$[HWND ]CreateMDIWindowA($[LPCSTR lpClassName], $[LPCSTR lpWindowName], $[DWORD dwStyle], $[int X], $[int Y], $[int nWidth], $[int nHeight], $[HWND hWndParent], $[HINSTANCE hInstance], $[LPARAM lParam])

$~CreateMDIWindowW
$[HWND ]CreateMDIWindowW($[LPCWSTR lpClassName], $[LPCWSTR lpWindowName], $[DWORD dwStyle], $[int X], $[int Y], $[int nWidth], $[int nHeight], $[HWND hWndParent], $[HINSTANCE hInstance], $[LPARAM lParam])

$~CreateWindowExA
$[HWND ]CreateWindowExA($[DWORD dwExStyle], $[LPCSTR lpClassName], $[LPCSTR lpWindowName], $[DWORD dwStyle], $[int x], $[int y], $[int nWidth], $[int nHeight], $[HWND hWndParent], $[HMENU hMenu], $[HINSTANCE hInstance], $[LPVOID lpParam])

$~CreateWindowExW
$[HWND ]CreateWindowExW($[DWORD dwExStyle], $[LPCWSTR lpClassName], $[LPCWSTR lpWindowName], $[DWORD dwStyle], $[int x], $[int y], $[int nWidth], $[int nHeight], $[HWND hWndParent], $[HMENU hMenu], $[HINSTANCE hInstance], $[LPVOID lpParam])

$~FindWindowA
$[HWND ]FindWindowA($[LPCSTR lpClassName], $[LPCSTR lpWindowName])

$~FindWindowExA
$[HWND ]FindWindowExA($[HWND hwndParent], $[HWND hwndChildAfter], $[LPCSTR lpszClass], $[LPCSTR lpszWindow])

$~FindWindowExW
$[HWND ]FindWindowExW($[HWND hwndParent], $[HWND hwndChildAfter], $[LPCWSTR lpszClass], $[LPCWSTR lpszWindow])

$~FindWindowW
$[HWND ]FindWindowW($[LPCWSTR lpClassName], $[LPCWSTR lpWindowName])

$~GetActiveWindow
$[HWND ]GetActiveWindow($[])

$~GetAncestor
$[HWND ]GetAncestor($[HWND hwnd], $[UINT gaFlags])

$~GetCapture
$[HWND ]GetCapture($[])

$~GetClipboardOwner
$[HWND ]GetClipboardOwner($[VOID])

$~GetClipboardViewer
$[HWND ]GetClipboardViewer($[VOID])

$~GetDesktopWindow
$[HWND ]GetDesktopWindow($[])

$~GetDlgItem
$[HWND ]GetDlgItem($[HWND hDlg], $[int nIDDlgItem])

$~GetFocus
$[HWND ]GetFocus($[])

$~GetForegroundWindow
$[HWND ]GetForegroundWindow($[])

$~GetLastActivePopup
$[HWND ]GetLastActivePopup($[HWND hWnd])

$~GetNextDlgGroupItem
$[HWND ]GetNextDlgGroupItem($[HWND hDlg], $[HWND hCtl], $[BOOL bPrevious])

$~GetNextDlgTabItem
$[HWND ]GetNextDlgTabItem($[HWND hDlg], $[HWND hCtl], $[BOOL bPrevious])

$~GetOpenClipboardWindow
$[HWND ]GetOpenClipboardWindow($[VOID])

$~GetParent
$[HWND ]GetParent($[HWND hWnd])

$~GetShellWindow
$[HWND ]GetShellWindow($[])

$~GetTopWindow
$[HWND ]GetTopWindow($[HWND hWnd])

$~GetWindow
$[HWND ]GetWindow($[HWND hWnd], $[UINT uCmd])

$~RealChildWindowFromPoint
$[HWND ]RealChildWindowFromPoint($[HWND hwndParent], $[LONG ptParentClientCoordsX], $[LONG ptParentClientCoordsY])

$~SetActiveWindow
$[HWND ]SetActiveWindow($[HWND hWnd])

$~SetClipboardViewer
$[HWND ]SetClipboardViewer($[HWND hWndNewViewer])

$~SetFocus
$[HWND ]SetFocus($[HWND hWnd])

$~SetParent
$[HWND ]SetParent($[HWND hWndChild], $[HWND hWndNewParent])

$~WindowFromDC
$[HWND ]WindowFromDC($[HDC hDC])

$~WindowFromPoint
$[HWND ]WindowFromPoint($[POINT Point])

$~CopyAcceleratorTableA
$[int ]CopyAcceleratorTableA($[HACCEL hAccelSrc], $[LPACCEL lpAccelDst], $[int cAccelEntries])

$~CopyAcceleratorTableW
$[int ]CopyAcceleratorTableW($[HACCEL hAccelSrc], $[LPACCEL lpAccelDst], $[int cAccelEntries])

$~CountClipboardFormats
$[int ]CountClipboardFormats($[VOID])

$~DdeCmpStringHandles
$[int ]DdeCmpStringHandles($[HSZ hsz1], $[HSZ hsz2])

$~DlgDirListA
$[int ]DlgDirListA($[HWND hDlg], $[LPSTR lpPathSpec], $[int nIDListBox], $[int nIDStaticPath], $[UINT uFileType])

$~DlgDirListComboBoxA
$[int ]DlgDirListComboBoxA($[HWND hDlg], $[LPSTR lpPathSpec], $[int nIDComboBox], $[int nIDStaticPath], $[UINT uFiletype])

$~DlgDirListComboBoxW
$[int ]DlgDirListComboBoxW($[HWND hDlg], $[LPWSTR lpPathSpec], $[int nIDComboBox], $[int nIDStaticPath], $[UINT uFiletype])

$~DlgDirListW
$[int ]DlgDirListW($[HWND hDlg], $[LPWSTR lpPathSpec], $[int nIDListBox], $[int nIDStaticPath], $[UINT uFileType])

$~DrawTextA
$[int ]DrawTextA($[HDC hDC], $[LPCSTR lpString], $[int nCount], $[LPRECT lpRect], $[UINT uFormat])

$~DrawTextExA
$[int ]DrawTextExA($[HDC hdc], $[LPSTR lpchText], $[int cchText], $[LPRECT lprc], $[UINT dwDTFormat], $[LPDRAWTEXTPARAMS lpDTParams])

$~DrawTextExW
$[int ]DrawTextExW($[HDC hdc], $[LPWSTR lpchText], $[int cchText], $[LPRECT lprc], $[UINT dwDTFormat], $[LPDRAWTEXTPARAMS lpDTParams])

$~DrawTextW
$[int ]DrawTextW($[HDC hDC], $[LPCWSTR lpString], $[int nCount], $[LPRECT lpRect], $[UINT uFormat])

$~EnumPropsA
$[int ]EnumPropsA($[HWND hWnd], $[PROPENUMPROC lpEnumFunc])

$~EnumPropsExA
$[int ]EnumPropsExA($[HWND hWnd], $[PROPENUMPROCEX lpEnumFunc], $[LPARAM lParam])

$~EnumPropsExW
$[int ]EnumPropsExW($[HWND hWnd], $[PROPENUMPROCEX lpEnumFunc], $[LPARAM lParam])

$~EnumPropsW
$[int ]EnumPropsW($[HWND hWnd], $[PROPENUMPROC lpEnumFunc])

$~ExcludeUpdateRgn
$[int ]ExcludeUpdateRgn($[HDC hDC], $[HWND hWnd])

$~FillRect
$[int ]FillRect($[HDC hDC], $[CONST RECT *lprc], $[HBRUSH hbr])

$~FrameRect
$[int ]FrameRect($[HDC hDC], $[CONST RECT *lprc], $[HBRUSH hbr])

$~GetClassNameA
$[int ]GetClassNameA($[HWND hWnd], $[LPSTR lpClassName], $[int nMaxCount])

$~GetClassNameW
$[int ]GetClassNameW($[HWND hWnd], $[LPWSTR lpClassName], $[int nMaxCount])

$~GetClipboardFormatNameA
$[int ]GetClipboardFormatNameA($[UINT format], $[LPSTR lpszFormatName], $[int cchMaxCount])

$~GetClipboardFormatNameW
$[int ]GetClipboardFormatNameW($[UINT format], $[LPWSTR lpszFormatName], $[int cchMaxCount])

$~GetDlgCtrlID
$[int ]GetDlgCtrlID($[HWND hwndCtl])

$~GetKeyboardType
$[int ]GetKeyboardType($[int nTypeFlag])

$~GetKeyNameTextA
$[int ]GetKeyNameTextA($[LONG lParam], $[LPSTR lpString], $[int nSize])

$~GetKeyNameTextW
$[int ]GetKeyNameTextW($[LONG lParam], $[LPWSTR lpString], $[int nSize])

$~GetMenuItemCount
$[int ]GetMenuItemCount($[HMENU hMenu])

$~GetMenuStringA
$[int ]GetMenuStringA($[HMENU hMenu], $[UINT uIDItem], $[LPSTR lpString], $[int nMaxCount], $[UINT uFlag])

$~GetMenuStringW
$[int ]GetMenuStringW($[HMENU hMenu], $[UINT uIDItem], $[LPWSTR lpString], $[int nMaxCount], $[UINT uFlag])

$~GetMouseMovePointsEx
$[int ]GetMouseMovePointsEx($[UINT cbSize], $[LPMOUSEMOVEPOINT lppt], $[LPMOUSEMOVEPOINT lpptBuf], $[int nBufPoints], $[DWORD resolution])

$~GetPriorityClipboardFormat
$[int ]GetPriorityClipboardFormat($[UINT *paFormatPriorityList], $[int cFormats])

$~GetScrollPos
$[int ]GetScrollPos($[HWND hWnd], $[int nBar])

$~GetSystemMetrics
$[int ]GetSystemMetrics($[int nIndex])

$~GetUpdateRgn
$[int ]GetUpdateRgn($[HWND hWnd], $[HRGN hRgn], $[BOOL bErase])

$~GetWindowRgn
$[int ]GetWindowRgn($[HWND hWnd], $[HRGN hRgn])

$~GetWindowRgnBox
$[int ]GetWindowRgnBox($[HWND hWnd], $[LPRECT lprc])

$~GetWindowTextA
$[int ]GetWindowTextA($[HWND hWnd], $[LPSTR lpString], $[int nMaxCount])

$~GetWindowTextLengthA
$[int ]GetWindowTextLengthA($[HWND hWnd])

$~GetWindowTextLengthW
$[int ]GetWindowTextLengthW($[HWND hWnd])

$~GetWindowTextW
$[int ]GetWindowTextW($[HWND hWnd], $[LPWSTR lpString], $[int nMaxCount])

$~InternalGetWindowText
$[int ]InternalGetWindowText($[HWND hWnd], $[LPWSTR lpString], $[int nMaxCount])

$~LoadStringA
$[int ]LoadStringA($[HINSTANCE hInstance], $[UINT uID], $[LPSTR lpBuffer], $[int nBufferMax])

$~LoadStringW
$[int ]LoadStringW($[HINSTANCE hInstance], $[UINT uID], $[LPWSTR lpBuffer], $[int nBufferMax])

$~LookupIconIdFromDirectory
$[int ]LookupIconIdFromDirectory($[PBYTE presbits], $[BOOL fIcon])

$~LookupIconIdFromDirectoryEx
$[int ]LookupIconIdFromDirectoryEx($[PBYTE presbits], $[BOOL fIcon], $[int cxDesired], $[int cyDesired], $[UINT Flags])

$~MapWindowPoints
$[int ]MapWindowPoints($[HWND hWndFrom], $[HWND hWndTo], $[LPPOINT lpPoints], $[UINT cPoints])

$~MenuItemFromPoint
$[int ]MenuItemFromPoint($[HWND hWnd], $[HMENU hMenu], $[LONG ptScreenX], $[LONG ptScreenY])

$~MessageBoxA
$[int ]MessageBoxA($[HWND hWnd], $[LPCSTR lpText], $[LPCSTR lpCaption], $[UINT uType])

$~MessageBoxExA
$[int ]MessageBoxExA($[HWND hWnd], $[LPCSTR lpText], $[LPCSTR lpCaption], $[UINT uType], $[WORD wLanguageId])

$~MessageBoxExW
$[int ]MessageBoxExW($[HWND hWnd], $[LPCWSTR lpText], $[LPCWSTR lpCaption], $[UINT uType], $[WORD wLanguageId])

$~MessageBoxIndirectA
$[int ]MessageBoxIndirectA($[const LPMSGBOXPARAMS lpMsgBoxParams])

$~MessageBoxIndirectW
$[int ]MessageBoxIndirectW($[const LPMSGBOXPARAMS lpMsgBoxParams])

$~MessageBoxTimeoutA
$[int ]MessageBoxTimeoutA($[HWND hWnd], $[LPCSTR lpText], $[LPCSTR lpCaption], $[UINT uType], $[WORD wLanguageId], $[DWORD dwTimeOutInMs])

$~MessageBoxTimeoutW
$[int ]MessageBoxTimeoutW($[HWND hWnd], $[LPCWSTR lpText], $[LPCWSTR lpCaption], $[UINT uType], $[WORD wLanguageId], $[DWORD dwTimeOutInMs])

$~MessageBoxW
$[int ]MessageBoxW($[HWND hWnd], $[LPCWSTR lpText], $[LPCWSTR lpCaption], $[UINT uType])

$~ReleaseDC
$[int ]ReleaseDC($[HWND hWnd], $[HDC hDC])

$~ScrollWindowEx
$[int ]ScrollWindowEx($[HWND hWnd], $[int dx], $[int dy], $[const RECT *prcScroll], $[const RECT *prcClip], $[HRGN hrgnUpdate], $[LPRECT prcUpdate], $[UINT flags])

$~SetScrollInfo
$[int ]SetScrollInfo($[HWND hwnd], $[int fnBar], $[LPCSCROLLINFO lpsi], $[BOOL fRedraw])

$~SetScrollPos
$[int ]SetScrollPos($[HWND hWnd], $[int nBar], $[int nPos], $[BOOL bRedraw])

$~SetWindowRgn
$[int ]SetWindowRgn($[HWND hWnd], $[HRGN hRgn], $[BOOL bRedraw])

$~ShowCursor
$[int ]ShowCursor($[BOOL bShow])

$~ToAscii
$[int ]ToAscii($[UINT uVirtKey], $[UINT uScanCode], $[PBYTE lpKeyState], $[LPWORD lpChar], $[UINT uFlags])

$~ToAsciiEx
$[int ]ToAsciiEx($[UINT uVirtKey], $[UINT uScanCode], $[PBYTE lpKeyState], $[LPWORD lpChar], $[UINT uFlags], $[HKL dwhkl])

$~ToUnicode
$[int ]ToUnicode($[UINT wVirtKey], $[UINT wScanCode], $[const PBYTE lpKeyState], $[LPWSTR pwszBuff], $[int cchBuff], $[UINT wFlags])

$~ToUnicodeEx
$[int ]ToUnicodeEx($[UINT wVirtKey], $[UINT wScanCode], $[const PBYTE lpKeyState], $[LPWSTR pwszBuff], $[int cchBuff], $[UINT wFlags], $[HKL dwhkl])

$~TranslateAccelerator
$[int ]TranslateAccelerator($[LPMSG lpMsg], $[const GUID *pguidCmdGroup], $[DWORD nCmdID])

$~TranslateAcceleratorA
$[int ]TranslateAcceleratorA($[LPMSG lpMsg], $[const GUID *pguidCmdGroup], $[DWORD nCmdID])

$~TranslateAcceleratorW
$[int ]TranslateAcceleratorW($[LPMSG lpMsg], $[const GUID *pguidCmdGroup], $[DWORD nCmdID])

$~wsprintfA
$[int ]wsprintfA($[LPSTR lpOut], $[LPCSTR lpFmt])

$~wsprintfW
$[int ]wsprintfW($[LPWSTR lpOut], $[LPCWSTR lpFmt])

$~wvsprintfA
$[int ]wvsprintfA($[LPSTR lpOutput], $[LPCSTR lpFmt], $[va_list arglist])

$~wvsprintfW
$[int ]wvsprintfW($[LPWSTR lpOutput], $[LPCWSTR lpFmt], $[va_list arglist])

$~DialogBoxIndirectParamA
$[INT_PTR ]DialogBoxIndirectParamA($[HINSTANCE hInstance], $[LPCDLGTEMPLATE hDialogTemplate], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~DialogBoxIndirectParamW
$[INT_PTR ]DialogBoxIndirectParamW($[HINSTANCE hInstance], $[LPCDLGTEMPLATE hDialogTemplate], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~DialogBoxParamA
$[INT_PTR ]DialogBoxParamA($[HINSTANCE hInstance], $[LPCSTR lpTemplateName], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~DialogBoxParamW
$[INT_PTR ]DialogBoxParamW($[HINSTANCE hInstance], $[LPCWSTR lpTemplateName], $[HWND hWndParent], $[DLGPROC lpDialogFunc], $[LPARAM dwInitParam])

$~BroadcastSystemMessage
$[long ]BroadcastSystemMessage($[DWORD dwFlags], $[LPDWORD lpdwRecipients], $[UINT uiMessage], $[WPARAM wParam], $[LPARAM lParam])

$~BroadcastSystemMessageA
$[long ]BroadcastSystemMessageA($[DWORD dwFlags], $[LPDWORD lpdwRecipients], $[UINT uiMessage], $[WPARAM wParam], $[LPARAM lParam])

$~BroadcastSystemMessageExA
$[long ]BroadcastSystemMessageExA($[DWORD dwFlags], $[LPDWORD lpdwRecipients], $[UINT uiMessage], $[WPARAM wParam], $[LPARAM lParam], $[PBSMINFO pBSMInfo])

$~BroadcastSystemMessageExW
$[long ]BroadcastSystemMessageExW($[DWORD dwFlags], $[LPDWORD lpdwRecipients], $[UINT uiMessage], $[WPARAM wParam], $[LPARAM lParam], $[PBSMINFO pBSMInfo])

$~BroadcastSystemMessageW
$[long ]BroadcastSystemMessageW($[DWORD dwFlags], $[LPDWORD lpdwRecipients], $[UINT uiMessage], $[WPARAM wParam], $[LPARAM lParam])

$~ChangeDisplaySettingsA
$[LONG ]ChangeDisplaySettingsA($[LPDEVMODE lpDevMode], $[DWORD dwflags])

$~ChangeDisplaySettingsExA
$[LONG ]ChangeDisplaySettingsExA($[LPCSTR lpszDeviceName], $[LPDEVMODE lpDevMode], $[HWND hwnd], $[DWORD dwflags], $[LPVOID lParam])

$~ChangeDisplaySettingsExW
$[LONG ]ChangeDisplaySettingsExW($[LPCWSTR lpszDeviceName], $[LPDEVMODE lpDevMode], $[HWND hwnd], $[DWORD dwflags], $[LPVOID lParam])

$~ChangeDisplaySettingsW
$[LONG ]ChangeDisplaySettingsW($[LPDEVMODE lpDevMode], $[DWORD dwflags])

$~GetDialogBaseUnits
$[LONG ]GetDialogBaseUnits($[])

$~GetMenuCheckMarkDimensions
$[LONG ]GetMenuCheckMarkDimensions($[])

$~GetMessageTime
$[LONG ]GetMessageTime($[])

$~GetWindowLongA
$[LONG ]GetWindowLongA($[HWND hWnd], $[int nIndex])

$~GetWindowLongW
$[LONG ]GetWindowLongW($[HWND hWnd], $[int nIndex])

$~SetWindowLongA
$[LONG ]SetWindowLongA($[HWND hWnd], $[int nIndex], $[LONG dwNewLong])

$~SetWindowLongW
$[LONG ]SetWindowLongW($[HWND hWnd], $[int nIndex], $[LONG dwNewLong])

$~TabbedTextOutA
$[LONG ]TabbedTextOutA($[HDC hDC], $[int X], $[int Y], $[LPCSTR lpString], $[int nCount], $[int nTabPositions], $[CONST LPINT lpnTabStopPositions], $[int nTabOrigin])

$~TabbedTextOutW
$[LONG ]TabbedTextOutW($[HDC hDC], $[int X], $[int Y], $[LPCWSTR lpString], $[int nCount], $[int nTabPositions], $[CONST LPINT lpnTabStopPositions], $[int nTabOrigin])

$~GetMessageExtraInfo
$[LPARAM ]GetMessageExtraInfo($[])

$~PackDDElParam
$[LPARAM ]PackDDElParam($[UINT msg], $[UINT_PTR uiLo], $[UINT_PTR uiHi])

$~ReuseDDElParam
$[LPARAM ]ReuseDDElParam($[LPARAM lParam], $[UINT msgIn], $[UINT msgOut], $[UINT_PTR uiLo], $[UINT_PTR uiHi])

$~SetMessageExtraInfo
$[LPARAM ]SetMessageExtraInfo($[LPARAM lParam])

$~DdeAccessData
$[LPBYTE ]DdeAccessData($[HDDEDATA hData], $[LPDWORD pcbDataSize])

$~CharLowerA
$[LPSTR ]CharLowerA($[LPSTR lpsz])

$~CharNextA
$[LPSTR ]CharNextA($[LPCSTR lpsz])

$~CharPrevA
$[LPSTR ]CharPrevA($[LPCSTR lpszStart], $[LPCSTR lpszCurrent])

$~CharUpperA
$[LPSTR ]CharUpperA($[LPSTR lpsz])

$~CharLowerW
$[LPWSTR ]CharLowerW($[LPWSTR lpsz])

$~CharNextW
$[LPWSTR ]CharNextW($[LPCWSTR lpsz])

$~CharPrevW
$[LPWSTR ]CharPrevW($[LPCWSTR lpszStart], $[LPCWSTR lpszCurrent])

$~CharUpperW
$[LPWSTR ]CharUpperW($[LPWSTR lpsz])

$~CallNextHookEx
$[LRESULT ]CallNextHookEx($[HHOOK hhk], $[int nCode], $[WPARAM wParam], $[LPARAM lParam])

$~CallWindowProcA
$[LRESULT ]CallWindowProcA($[WNDPROC lpPrevWndFunc], $[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~CallWindowProcW
$[LRESULT ]CallWindowProcW($[WNDPROC lpPrevWndFunc], $[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~DefDlgProcA
$[LRESULT ]DefDlgProcA($[HWND hDlg], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~DefDlgProcW
$[LRESULT ]DefDlgProcW($[HWND hDlg], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~DefFrameProcA
$[LRESULT ]DefFrameProcA($[HWND hWnd], $[HWND hWndMDIClient], $[UINT uMsg], $[WPARAM wParam], $[LPARAM lParam])

$~DefFrameProcW
$[LRESULT ]DefFrameProcW($[HWND hWnd], $[HWND hWndMDIClient], $[UINT uMsg], $[WPARAM wParam], $[LPARAM lParam])

$~DefMDIChildProcA
$[LRESULT ]DefMDIChildProcA($[HWND hWnd], $[UINT uMsg], $[WPARAM wParam], $[LPARAM lParam])

$~DefMDIChildProcW
$[LRESULT ]DefMDIChildProcW($[HWND hWnd], $[UINT uMsg], $[WPARAM wParam], $[LPARAM lParam])

$~DefRawInputProc
$[LRESULT ]DefRawInputProc($[PRAWINPUT *paRawInput], $[INT nInput], $[UINT cbSizeHeader])

$~DefWindowProcA
$[LRESULT ]DefWindowProcA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~DefWindowProcW
$[LRESULT ]DefWindowProcW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~DispatchMessageA
$[LRESULT ]DispatchMessageA($[const MSG *lpmsg])

$~DispatchMessageW
$[LRESULT ]DispatchMessageW($[const MSG *lpmsg])

$~SendDlgItemMessageA
$[LRESULT ]SendDlgItemMessageA($[HWND hDlg], $[int nIDDlgItem], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~SendDlgItemMessageW
$[LRESULT ]SendDlgItemMessageW($[HWND hDlg], $[int nIDDlgItem], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~SendMessageA
$[LRESULT ]SendMessageA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~SendMessageTimeoutA
$[LRESULT ]SendMessageTimeoutA($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam], $[UINT fuFlags], $[UINT uTimeout], $[PDWORD_PTR lpdwResult])

$~SendMessageTimeoutW
$[LRESULT ]SendMessageTimeoutW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam], $[UINT fuFlags], $[UINT uTimeout], $[PDWORD_PTR lpdwResult])

$~SendMessageW
$[LRESULT ]SendMessageW($[HWND hWnd], $[UINT Msg], $[WPARAM wParam], $[LPARAM lParam])

$~GetAsyncKeyState
$[SHORT ]GetAsyncKeyState($[int vKey])

$~GetKeyState
$[SHORT ]GetKeyState($[int nVirtKey])

$~VkKeyScanA
$[SHORT ]VkKeyScanA($[T HAR ch])

$~VkKeyScanExA
$[SHORT ]VkKeyScanExA($[T HAR ch], $[HKL dwhkl])

$~VkKeyScanExW
$[SHORT ]VkKeyScanExW($[TWHAR ch], $[HKL dwhkl])

$~VkKeyScanW
$[SHORT ]VkKeyScanW($[TWHAR ch])

$~ArrangeIconicWindows
$[UINT ]ArrangeIconicWindows($[HWND hWnd])

$~DdeGetLastError
$[UINT ]DdeGetLastError($[DWORD idInst])

$~DdeInitializeA
$[UINT ]DdeInitializeA($[LPDWORD pidInst], $[PFNCALLBACK pfnCallback], $[DWORD afCmd], $[DWORD ulRes])

$~DdeInitializeW
$[UINT ]DdeInitializeW($[LPDWORD pidInst], $[PFNCALLBACK pfnCallback], $[DWORD afCmd], $[DWORD ulRes])

$~DdeQueryConvInfo
$[UINT ]DdeQueryConvInfo($[HCONV hConv], $[DWORD idTransaction], $[PCONVINFO pConvInfo])

$~EnumClipboardFormats
$[UINT ]EnumClipboardFormats($[UINT format])

$~GetDlgItemInt
$[UINT ]GetDlgItemInt($[HWND hDlg], $[int nIDDlgItem], $[BOOL *lpTranslated], $[BOOL bSigned])

$~GetDlgItemTextA
$[UINT ]GetDlgItemTextA($[HWND hDlg], $[int nIDDlgItem], $[LPSTR lpString], $[int nMaxCount])

$~GetDlgItemTextW
$[UINT ]GetDlgItemTextW($[HWND hDlg], $[int nIDDlgItem], $[LPWSTR lpString], $[int nMaxCount])

$~GetDoubleClickTime
$[UINT ]GetDoubleClickTime($[])

$~GetKBCodePage
$[UINT ]GetKBCodePage($[])

$~GetKeyboardLayoutList
$[UINT ]GetKeyboardLayoutList($[int nBuff], $[HKL *lpList])

$~GetMenuDefaultItem
$[UINT ]GetMenuDefaultItem($[HMENU hMenu], $[UINT fByPos], $[UINT gmdiFlags])

$~GetMenuItemID
$[UINT ]GetMenuItemID($[HMENU hMenu], $[int nPos])

$~GetMenuState
$[UINT ]GetMenuState($[HMENU hMenu], $[UINT uId], $[UINT uFlags])

$~GetRawInputBuffer
$[UINT ]GetRawInputBuffer($[PRAWINPUT pData], $[PUINT pcbSize], $[UINT cbSizeHeader])

$~GetRawInputData
$[UINT ]GetRawInputData($[HRAWINPUT hRawInput], $[UINT uiCommand], $[LPVOID pData], $[PUINT pcbSize], $[UINT cbSizeHeader])

$~GetRawInputDeviceInfoA
$[UINT ]GetRawInputDeviceInfoA($[HANDLE hDevice], $[UINT uiCommand], $[LPVOID pData], $[PUINT pcbSize])

$~GetRawInputDeviceInfoW
$[UINT ]GetRawInputDeviceInfoW($[HANDLE hDevice], $[UINT uiCommand], $[LPVOID pData], $[PUINT pcbSize])

$~GetRawInputDeviceList
$[UINT ]GetRawInputDeviceList($[PRAWINPUTDEVICELIST pRawInputDeviceList], $[PUINT puiNumDevices], $[UINT cbSize])

$~GetRegisteredRawInputDevices
$[UINT ]GetRegisteredRawInputDevices($[PRAWINPUTDEVICE pRawInputDevices], $[PUINT puiNumDevices], $[UINT cbSize])

$~GetWindowModuleFileName
$[UINT ]GetWindowModuleFileName($[HWND hwnd], $[LPSTR lpszFileName], $[UINT cchFileNameMax])

$~GetWindowModuleFileNameA
$[UINT ]GetWindowModuleFileNameA($[HWND hwnd], $[LPSTR lpszFileName], $[UINT cchFileNameMax])

$~GetWindowModuleFileNameW
$[UINT ]GetWindowModuleFileNameW($[HWND hwnd], $[LPSTR lpszFileName], $[UINT cchFileNameMax])

$~IsDlgButtonChecked
$[UINT ]IsDlgButtonChecked($[HWND hDlg], $[int nIDButton])

$~MapVirtualKeyA
$[UINT ]MapVirtualKeyA($[UINT uCode], $[UINT uMapType])

$~MapVirtualKeyExA
$[UINT ]MapVirtualKeyExA($[UINT uCode], $[UINT uMapType], $[HKL dwhkl])

$~MapVirtualKeyExW
$[UINT ]MapVirtualKeyExW($[UINT uCode], $[UINT uMapType], $[HKL dwhkl])

$~MapVirtualKeyW
$[UINT ]MapVirtualKeyW($[UINT uCode], $[UINT uMapType])

$~PrivateExtractIconsA
$[UINT ]PrivateExtractIconsA($[LPCSTR lpszFile], $[int nIconIndex], $[int cxIcon], $[int cyIcon], $[HICON *phicon], $[UINT *piconid], $[UINT nIcons], $[UINT flags])

$~PrivateExtractIconsW
$[UINT ]PrivateExtractIconsW($[LPCWSTR lpszFile], $[int nIconIndex], $[int cxIcon], $[int cyIcon], $[HICON *phicon], $[UINT *piconid], $[UINT nIcons], $[UINT flags])

$~RealGetWindowClass
$[UINT ]RealGetWindowClass($[HWND hwnd], $[LPSTR pszType], $[UINT cchType])

$~RealGetWindowClassA
$[UINT ]RealGetWindowClassA($[HWND hwnd], $[LPSTR pszType], $[UINT cchType])

$~RealGetWindowClassW
$[UINT ]RealGetWindowClassW($[HWND hwnd], $[LPSTR pszType], $[UINT cchType])

$~RegisterClipboardFormatA
$[UINT ]RegisterClipboardFormatA($[LPCSTR lpszFormat])

$~RegisterClipboardFormatW
$[UINT ]RegisterClipboardFormatW($[LPCWSTR lpszFormat])

$~RegisterWindowMessageA
$[UINT ]RegisterWindowMessageA($[LPCSTR lpString])

$~RegisterWindowMessageW
$[UINT ]RegisterWindowMessageW($[LPCWSTR lpString])

$~SendInput
$[UINT ]SendInput($[UINT nInputs], $[LPINPUT pInputs], $[int cbSize])

$~SetTimer
$[UINT_PTR ]SetTimer($[HWND hWnd], $[UINT_PTR nIDEvent], $[UINT uElapse], $[TIMERPROC lpTimerFunc])

$~ScrollChildren
$[virtual void ]ScrollChildren($[int dx], $[int dy])

$~DisableProcessWindowsGhosting
$[void ]DisableProcessWindowsGhosting($[])

$~keybd_event
$[VOID ]keybd_event($[BYTE bVk], $[BYTE bScan], $[DWORD dwFlags], $[PTR dwExtraInfo])

$~mouse_event
$[VOID ]mouse_event($[DWORD dwFlags], $[DWORD dx], $[DWORD dy], $[DWORD dwData], $[ULONG_PTR dwExtraInfo])

$~NotifyWinEvent
$[void ]NotifyWinEvent($[DWORD event], $[HWND hwnd], $[LONG idObject], $[LONG idChild])

$~OffsetRect
$[void ]OffsetRect($[LPRECT lprc], $[int x], $[int y])

$~PostQuitMessage
$[void ]PostQuitMessage($[int nExitCode])

$~SetLastErrorEx
$[void ]SetLastErrorEx($[DWORD dwErrCode], $[DWORD dwType])

$~SetRect
$[void ]SetRect($[LPRECT lprc], $[int x1], $[int y1], $[int x2], $[int y2])

$~SwitchToThisWindow
$[VOID ]SwitchToThisWindow($[HWND hWnd], $[BOOL fAltTab])

$~CascadeWindows
$[WORD ]CascadeWindows($[HWND hwndParent], $[UINT wHow], $[const RECT *lpRect], $[UINT cKids], $[const HWND *lpKids])

$~GetClassWord
$[WORD ]GetClassWord($[HWND hWnd], $[int nIndex])

$~SetClassWord
$[WORD ]SetClassWord($[HWND hWnd], $[int nIndex], $[WORD wNewWord])

$~TileChildWindows
$[WORD ]TileChildWindows($[HWND hwndParent], $[UINT wHow])

$~TileWindows
$[WORD ]TileWindows($[HWND hwndParent], $[UINT wHow], $[RECT *lpRect], $[UINT cKids], $[const HWND *lpKids])

$; vdmdbg.dll
$; ----------
$~VDMEnumProcessWOW
$[INT ]VDMEnumProcessWOW($[PROCESSENUMPROC fp], $[LPARAM lparam])

$~VDMEnumTaskWOW
$[INT ]VDMEnumTaskWOW($[DWORD dwProcessId], $[TASKENUMPROC fp], $[LPARAM lparam])

$~VDMEnumTaskWOWEx
$[INT ]VDMEnumTaskWOWEx($[DWORD dwProcessId], $[TASKENUMPROCEX fp], $[LPARAM lparam])

$; winsta.dll
$; ----------
$~WinStationEnumerateProcesses
$[DWORD ]WinStationEnumerateProcesses($[HANDLE hServer], $[ULONG LogonId], $[DWORD], $[PVOID Buffer], $[ULONG Length], $[PULONG pReturnLength])

$; ws2_32.dll
$; ----------
$~WSAGetOverlappedResult
$[BOOL WSAAPI ]WSAGetOverlappedResult($[SOCKET Socket], $[LPWSAOVERLAPPED lpOverlapped], $[LPDWORD lpcbTransfer], $[BOOL fWait], $[LPDWORD lpdwFlags])

$~WSAGetQOSByName
$[BOOL WSAAPI ]WSAGetQOSByName($[SOCKET Socket], $[LPWSABUF lpQOSName], $[LPQOS lpQOS])

$~WSACloseEvent
$[BOOL ]WSACloseEvent($[WSAEVENT hEvent])

$~WSAResetEvent
$[BOOL ]WSAResetEvent($[WSAEVENT hEvent])

$~WSASetEvent
$[BOOL ]WSASetEvent($[WSAEVENT hEvent])

$~inet_ntoa
$[char* FAR ]inet_ntoa($[DWORD in])

$~WSAWaitForMultipleEvents
$[DWORD ]WSAWaitForMultipleEvents($[DWORD cEvents], $[const WSAEVENT* lphEvents], $[BOOL fWaitAll], $[DWORD dwTimeout], $[BOOL fAlertable])

$~WSAAsyncGetHostByAddr
$[HANDLE ]WSAAsyncGetHostByAddr($[HWND hWnd], $[unsigned int wMsg], $[const char* addr], $[int len], $[int type], $[char* buf], $[int buflen])

$~WSAAsyncGetHostByName
$[HANDLE ]WSAAsyncGetHostByName($[HWND hWnd], $[unsigned int wMsg], $[const char* name], $[char* buf], $[int buflen])

$~WSAAsyncGetProtoByName
$[HANDLE ]WSAAsyncGetProtoByName($[HWND hWnd], $[unsigned int wMsg], $[const char* name], $[char* buf], $[int buflen])

$~WSAAsyncGetProtoByNumber
$[HANDLE ]WSAAsyncGetProtoByNumber($[HWND hWnd], $[unsigned int wMsg], $[int number], $[char* buf], $[int buflen])

$~WSAAsyncGetServByName
$[HANDLE ]WSAAsyncGetServByName($[HWND hWnd], $[unsigned int wMsg], $[const char* name], $[const byte* proto], $[char* buf], $[int buflen])

$~WSAAsyncGetServByPort
$[HANDLE ]WSAAsyncGetServByPort($[HWND hWnd], $[unsigned int wMsg], $[int port], $[const byte* proto], $[char* buf], $[int buflen])

$~bind
$[int ]bind($[SOCKET Socket], $[const struct sockaddr* name], $[int namelen])

$~closesocket
$[int ]closesocket($[SOCKET Socket])

$~connect
$[int ]connect($[SOCKET Socket], $[const struct sockaddr* name], $[int namelen])

$~gethostname
$[int ]gethostname($[char* name], $[int namelen])

$~getpeername
$[int ]getpeername($[SOCKET Socket], $[struct sockaddr* name], $[int* namelen])

$~getsockname
$[int ]getsockname($[SOCKET Socket], $[struct sockaddr* name], $[int* namelen])

$~getsockopt
$[int ]getsockopt($[SOCKET Socket], $[int level], $[int optname], $[byte* optval], $[int* optlen])

$~ioctlsocket
$[int ]ioctlsocket($[SOCKET Socket], $[long cmd], $[u_long* argp])

$~listen
$[int ]listen($[SOCKET Socket], $[int backlog])

$~recv
$[int ]recv($[SOCKET Socket], $[PBYTE buf], $[int len], $[int flags])

$~recvfrom
$[int ]recvfrom($[SOCKET Socket], $[PBYTE buf], $[int len], $[int flags], $[struct sockaddr* from], $[int* fromlen])

$~select
$[int ]select($[int nfds], $[fd_set* readfds], $[fd_set* writefds], $[fd_set* exceptfds], $[const struct timeval* timeout])

$~send
$[int ]send($[SOCKET Socket], $[PBYTE buf], $[int len], $[int flags])

$~sendto
$[int ]sendto($[SOCKET Socket], $[PBYTE buf], $[int len], $[int flags], $[const struct sockaddr* to], $[int tolen])

$~setsockopt
$[int ]setsockopt($[SOCKET Socket], $[int level], $[int optname], $[const byte* optval], $[int optlen])

$~shutdown
$[int ]shutdown($[SOCKET Socket], $[int how])

$~WSAAddressToStringA
$[INT ]WSAAddressToStringA($[LPSOCKADDR lpsaAddress], $[DWORD dwAddressLength], $[LPWSAPROTOCOL_INFOA lpProtocolInfo], $[LPSTR lpszAddressString], $[LPDWORD lpdwAddressStringLength])

$~WSAAddressToStringW
$[INT ]WSAAddressToStringW($[LPSOCKADDR lpsaAddress], $[DWORD dwAddressLength], $[LPWSAPROTOCOL_INFOW lpProtocolInfo], $[LPWSTR lpszAddressString], $[LPDWORD lpdwAddressStringLength])

$~getaddrinfo
$[int WSAAPI ]getaddrinfo($[const char FAR* nodename], $[const char FAR* servname], $[const struct addrinfo FAR* hints], $[struct addrinfo FAR** res])

$~getnameinfo
$[int WSAAPI ]getnameinfo($[const struct sockaddr FAR* sa], $[socklen_t salen], $[char FAR* host], $[DWORD hostlen], $[char FAR* serv], $[DWORD servlen], $[int flags])

$~WSAEnumNameSpaceProvidersA
$[INT WSAAPI ]WSAEnumNameSpaceProvidersA($[LPDWORD lpdwBufferLength], $[LPWSANAMESPACE_INFO lpnspBuffer])

$~WSAEnumNameSpaceProvidersW
$[INT WSAAPI ]WSAEnumNameSpaceProvidersW($[LPDWORD lpdwBufferLength], $[LPWSANAMESPACE_INFO lpnspBuffer])

$~WSANSPIoctl
$[int WSAAPI ]WSANSPIoctl($[HANDLE hLookup], $[DWORD dwControlCode], $[LPVOID lpvInBuffer], $[DWORD cbInBuffer], $[LPVOID lpvOutBuffer], $[DWORD cbOutBuffer], $[LPDWORD lpcbBytesReturned], $[LPWSACOMPLETION lpCompletion])

$~WSAProviderConfigChange
$[int WSAAPI ]WSAProviderConfigChange($[LPHANDLE lpNotificationHandle], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSAAsyncSelect
$[int ]WSAAsyncSelect($[SOCKET Socket], $[HWND hWnd], $[unsigned int wMsg], $[long lEvent])

$~WSACancelAsyncRequest
$[int ]WSACancelAsyncRequest($[HANDLE hAsyncTaskHandle])

$~WSACleanup
$[int ]WSACleanup($[])

$~WSAConnect
$[int ]WSAConnect($[SOCKET Socket], $[const struct sockaddr* name], $[int namelen], $[LPWSABUF lpCallerData], $[LPWSABUF lpCalleeData], $[LPQOS lpSQOS], $[LPQOS lpGQOS])

$~WSADuplicateSocketA
$[int ]WSADuplicateSocketA($[SOCKET Socket], $[DWORD dwProcessId], $[LPWSAPROTOCOL_INFOA lpProtocolInfo])

$~WSADuplicateSocketW
$[int ]WSADuplicateSocketW($[SOCKET Socket], $[DWORD dwProcessId], $[LPWSAPROTOCOL_INFOW lpProtocolInfo])

$~WSAEnumNetworkEvents
$[int ]WSAEnumNetworkEvents($[SOCKET Socket], $[WSAEVENT hEventObject], $[LPWSANETWORKEVENTS lpNetworkEvents])

$~WSAEnumProtocolsA
$[int ]WSAEnumProtocolsA($[LPINT lpiProtocols], $[LPWSAPROTOCOL_INFOA lpProtocolBuffer], $[LPDWORD lpdwBufferLength])

$~WSAEnumProtocolsW
$[int ]WSAEnumProtocolsW($[LPINT lpiProtocols], $[LPWSAPROTOCOL_INFOW lpProtocolBuffer], $[LPDWORD lpdwBufferLength])

$~WSAEventSelect
$[int ]WSAEventSelect($[SOCKET Socket], $[WSAEVENT hEventObject], $[long lNetworkEvents])

$~WSAGetLastError
$[int ]WSAGetLastError($[])

$~WSAGetServiceClassInfoA
$[INT ]WSAGetServiceClassInfoA($[LPGUID lpProviderId], $[LPGUID lpServiceClassId], $[LPDWORD lpdwBufferLength], $[LPWSASERVICECLASSINFO lpServiceClassInfo])

$~WSAGetServiceClassInfoW
$[INT ]WSAGetServiceClassInfoW($[LPGUID lpProviderId], $[LPGUID lpServiceClassId], $[LPDWORD lpdwBufferLength], $[LPWSASERVICECLASSINFO lpServiceClassInfo])

$~WSAGetServiceClassNameByClassIdA
$[INT ]WSAGetServiceClassNameByClassIdA($[LPGUID lpServiceClassId], $[LPSTR lpszServiceClassName], $[LPDWORD lpdwBufferLength])

$~WSAGetServiceClassNameByClassIdW
$[INT ]WSAGetServiceClassNameByClassIdW($[LPGUID lpServiceClassId], $[LPWSTR lpszServiceClassName], $[LPDWORD lpdwBufferLength])

$~WSAHtonl
$[int ]WSAHtonl($[SOCKET Socket], $[u_long hostlong], $[u_long* lpnetlong])

$~WSAHtons
$[int ]WSAHtons($[SOCKET Socket], $[u_short hostshort], $[u_short* lpnetshort])

$~WSAInstallServiceClassA
$[INT ]WSAInstallServiceClassA($[LPWSASERVICECLASSINFO lpServiceClassInfo])

$~WSAInstallServiceClassW
$[INT ]WSAInstallServiceClassW($[LPWSASERVICECLASSINFO lpServiceClassInfo])

$~WSAIoctl
$[int ]WSAIoctl($[SOCKET Socket], $[DWORD dwIoControlCode], $[LPVOID lpvInBuffer], $[DWORD cbInBuffer], $[LPVOID lpvOutBuffer], $[DWORD cbOutBuffer], $[LPDWORD lpcbBytesReturned], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSALookupServiceBeginA
$[INT ]WSALookupServiceBeginA($[LPWSAQUERYSET lpqsRestrictions], $[DWORD dwControlFlags], $[LPHANDLE lphLookup])

$~WSALookupServiceBeginW
$[INT ]WSALookupServiceBeginW($[LPWSAQUERYSET lpqsRestrictions], $[DWORD dwControlFlags], $[LPHANDLE lphLookup])

$~WSALookupServiceEnd
$[INT ]WSALookupServiceEnd($[HANDLE hLookup])

$~WSALookupServiceNextA
$[INT ]WSALookupServiceNextA($[HANDLE hLookup], $[DWORD dwControlFlags], $[LPDWORD lpdwBufferLength], $[LPWSAQUERYSET lpqsResults])

$~WSALookupServiceNextW
$[INT ]WSALookupServiceNextW($[HANDLE hLookup], $[DWORD dwControlFlags], $[LPDWORD lpdwBufferLength], $[LPWSAQUERYSET lpqsResults])

$~WSARecv
$[int ]WSARecv($[SOCKET Socket], $[LPWSABUF lpBuffers], $[DWORD dwBufferCount], $[LPDWORD lpNumberOfBytesRecvd], $[LPDWORD lpFlags], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSARecvDisconnect
$[int ]WSARecvDisconnect($[SOCKET Socket], $[LPWSABUF lpInboundDisconnectData])

$~WSARecvFrom
$[int ]WSARecvFrom($[SOCKET Socket], $[LPWSABUF lpBuffers], $[DWORD dwBufferCount], $[LPDWORD lpNumberOfBytesRecvd], $[LPDWORD lpFlags], $[struct sockaddr* lpFrom], $[LPINT lpFromlen], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSARemoveServiceClass
$[INT ]WSARemoveServiceClass($[LPGUID lpServiceClassId])

$~WSASend
$[int ]WSASend($[SOCKET Socket], $[LPWSABUF lpBuffers], $[DWORD dwBufferCount], $[LPDWORD lpNumberOfBytesSent], $[DWORD dwFlags], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSASendDisconnect
$[int ]WSASendDisconnect($[SOCKET Socket], $[LPWSABUF lpOutboundDisconnectData])

$~WSASendTo
$[int ]WSASendTo($[SOCKET Socket], $[LPWSABUF lpBuffers], $[DWORD dwBufferCount], $[LPDWORD lpNumberOfBytesSent], $[DWORD dwFlags], $[const struct sockaddr* lpTo], $[int iToLen], $[LPWSAOVERLAPPED lpOverlapped], $[LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine])

$~WSASetServiceA
$[INT ]WSASetServiceA($[LPWSAQUERYSET lpqsRegInfo], $[WSAESETSERVICEOP essOperation], $[DWORD dwControlFlags])

$~WSASetServiceW
$[INT ]WSASetServiceW($[LPWSAQUERYSET lpqsRegInfo], $[WSAESETSERVICEOP essOperation], $[DWORD dwControlFlags])

$~WSAStartup
$[int ]WSAStartup($[WORD wVersionRequested], $[LPWSADATA lpWSAData])

$~WSAStringToAddressA
$[INT ]WSAStringToAddressA($[LPSTR AddressString], $[INT AddressFamily], $[LPWSAPROTOCOL_INFOA lpProtocolInfo], $[LPSOCKADDR lpAddress], $[LPINT lpAddressLength])

$~WSAStringToAddressW
$[INT ]WSAStringToAddressW($[LPWSTR AddressString], $[INT AddressFamily], $[LPWSAPROTOCOL_INFOW lpProtocolInfo], $[LPSOCKADDR lpAddress], $[LPINT lpAddressLength])

$~WSCDeinstallProvider
$[int ]WSCDeinstallProvider($[LPGUID lpProviderId], $[LPINT lpErrno])

$~WSCEnableNSProvider
$[int ]WSCEnableNSProvider($[LPGUID lpProviderId], $[BOOL fEnable])

$~WSCEnumProtocols
$[int ]WSCEnumProtocols($[LPINT lpiProtocols], $[LPWSAPROTOCOL_INFOW lpProtocolBuffer], $[LPDWORD lpdwBufferLength], $[LPINT lpErrno])

$~WSCGetProviderPath
$[int ]WSCGetProviderPath($[LPGUID lpProviderId], $[LPWSTR lpszProviderDllPath], $[LPINT lpProviderDllPathLen], $[LPINT lpErrno])

$~WSCInstallNameSpace
$[int ]WSCInstallNameSpace($[LPWSTR lpszIdentifier], $[LPWSTR lpszPathName], $[DWORD dwNameSpace], $[DWORD dwVersion], $[LPGUID lpProviderId])

$~WSCInstallProvider
$[int ]WSCInstallProvider($[const LPGUID lpProviderId], $[const LPWSTR lpszProviderDllPath], $[const LPWSAPROTOCOL_INFOW lpProtocolInfoList], $[DWORD dwNumberOfEntries], $[LPINT lpErrno])

$~WSCUnInstallNameSpace
$[int ]WSCUnInstallNameSpace($[LPGUID lpProviderId])

$~WSCUpdateProvider
$[int ]WSCUpdateProvider($[LPGUID lpProviderId], $[const WCHAR* lpszProviderDllPath], $[const LPWSAPROTOCOL_INFOW lpProtocolInfoList], $[DWORD dwNumberOfEntries], $[LPINT lpErrno])

$~WSCWriteNameSpaceOrder
$[int ]WSCWriteNameSpaceOrder($[LPGUID lpProviderId], $[DWORD dwNumberOfEntries])

$~WSCWriteProviderOrder
$[int ]WSCWriteProviderOrder($[LPDWORD lpwdCatalogEntryId], $[DWORD dwNumberOfEntries])

$~__WSAFDIsSet
$[int ]__WSAFDIsSet($[SOCKET fd], $[fd_set* set])

$~accept
$[SOCKET ]accept($[SOCKET Socket], $[struct sockaddr* addr], $[int* addrlen])

$~WSAAccept
$[SOCKET ]WSAAccept($[SOCKET Socket], $[struct sockaddr* addr], $[LPINT addrlen], $[LPCONDITIONPROC lpfnCondition], $[DWORD dwCallbackData])

$~socket
$[SOCKET WSAAPI ]socket($[int af], $[int type], $[int protocol])

$~WSAJoinLeaf
$[SOCKET ]WSAJoinLeaf($[SOCKET Socket], $[const struct sockaddr* name], $[int namelen], $[LPWSABUF lpCallerData], $[LPWSABUF lpCalleeData], $[LPQOS lpSQOS], $[LPQOS lpGQOS], $[DWORD dwFlags])

$~WSASocketA
$[SOCKET ]WSASocketA($[int af], $[int type], $[int protocol], $[LPWSAPROTOCOL_INFOA lpProtocolInfo], $[UINT group], $[DWORD dwFlags])

$~WSASocketW
$[SOCKET ]WSASocketW($[int af], $[int type], $[int protocol], $[LPWSAPROTOCOL_INFOW lpProtocolInfo], $[UINT group], $[DWORD dwFlags])

$~gethostbyaddr
$[struct HOSTENT* FAR ]gethostbyaddr($[const char* addr], $[int len], $[int type])

$~gethostbyname
$[struct hostent* FAR ]gethostbyname($[const char* name])

$~getprotobyname
$[struct PROTOENT* FAR ]getprotobyname($[const char* name])

$~getprotobynumber
$[struct PROTOENT* FAR ]getprotobynumber($[int number])

$~getservbyname
$[struct servent* FAR ]getservbyname($[const char* name], $[const byte* proto])

$~getservbyport
$[struct servent* FAR ]getservbyport($[int port], $[const byte* proto])

$~inet_addr
$[unsigned long ]inet_addr($[const char* cp])

$~htonl
$[u_long ]htonl($[u_long hostlong])

$~htons
$[u_short ]htons($[u_short hostshort])

$~freeaddrinfo
$[void ]freeaddrinfo($[struct addrinfo* ai])

$~WSASetLastError
$[void ]WSASetLastError($[int iError])

$~WPUCompleteOverlappedRequest
$[WSAEVENT ]WPUCompleteOverlappedRequest($[SOCKET Socket], $[LPWSAOVERLAPPED lpOverlapped], $[DWORD dwError], $[DWORD cbTransferred], $[LPINT lpErrno])

$~WSACreateEvent
$[WSAEVENT ]WSACreateEvent($[])
