windows.h.js

var ffi = require('ffi');

var
 int8 = ffi.types.int8,
 uint8 = ffi.types.uint8,
 int16 = ffi.types.int16,
 uint16 = ffi.types.uint16,
 int32 = ffi.types.int32,
 uint32 = ffi.types.uint32,
 int64 = ffi.types.int64,
 uint64 = ffi.types.uint64,
 float = ffi.types.float,
 double = ffi.types.double,
 byte = ffi.types.byte,
 char = ffi.types.char,
 uchar = ffi.types.uchar,
 short = ffi.types.short,
 ushort = ffi.types.ushort,
 int = ffi.types.int,
 uint = ffi.types.uint,
 long = ffi.types.long,
 ulong = ffi.types.ulong,
 longlong = ffi.types.longlong,
 ulonglong = ffi.types.ulonglong,
 size_t = ffi.types.size_t;

exports.enums = {};
exports.callbacks = {};
exports.structs = {};
exports.functions = {};

function ENUM(name, def){}
function CALLBACK(ret, params){}
function STRUCT(name, def){}
function FN(name, ret, params){}
function DEF(name, ffiType){}
function PTR(type){}

var
 uintptr_t = DEF('uintptr_t', uint),
 va_list = DEF('va_list', PTR(int8)),
 size_t = DEF('size_t', uint),
 rsize_t = DEF('rsize_t', uint),
 wchar_t = DEF('wchar_t', ushort),
 wint_t = DEF('wint_t', ushort),
 wctype_t = DEF('wctype_t', ushort),
 errno_t = DEF('errno_t', int),
 ULONG = DEF('ULONG', ulong),
 PULONG = DEF('PULONG', PTR(ulong)),
 USHORT = DEF('USHORT', ushort),
 PUSHORT = DEF('PUSHORT', PTR(ushort)),
 UCHAR = DEF('UCHAR', uchar),
 PUCHAR = DEF('PUCHAR', PTR(uchar)),
 DWORD = DEF('DWORD', ulong),
 BOOL = DEF('BOOL', int),
 BYTE = DEF('BYTE', uchar),
 WORD = DEF('WORD', ushort),
 FLOAT = DEF('FLOAT', float),
 PFLOAT = DEF('PFLOAT', PTR(float)),
 PBOOL = DEF('PBOOL', PTR(int)),
 LPBOOL = DEF('LPBOOL', PTR(int)),
 PBYTE = DEF('PBYTE', PTR(uchar)),
 LPBYTE = DEF('LPBYTE', PTR(uchar)),
 LPINT = DEF('LPINT', PTR(int)),
 PWORD = DEF('PWORD', PTR(ushort)),
 LPWORD = DEF('LPWORD', PTR(ushort)),
 LPLONG = DEF('LPLONG', PTR(long)),
 PDWORD = DEF('PDWORD', PTR(ulong)),
 LPDWORD = DEF('LPDWORD', PTR(ulong)),
 LPVOID = DEF('LPVOID', PTR('void')),
 LPCVOID = DEF('LPCVOID', PTR('void')),
 INT = DEF('INT', int),
 UINT = DEF('UINT', uint),
 PUINT = DEF('PUINT', PTR(uint)),
 UINT16 = DEF('UINT16', ushort),
 UINT32 = DEF('UINT32', uint),
 UINT64 = DEF('UINT64', ulonglong),
 INT_PTR = DEF('INT_PTR', int),
 UINT_PTR = DEF('UINT_PTR', uint),
 PUINT_PTR = DEF('PUINT_PTR', PTR(uint)),
 LONG_PTR = DEF('LONG_PTR', long),
 ULONG_PTR = DEF('ULONG_PTR', ulong),
 PULONG_PTR = DEF('PULONG_PTR', PTR(ulong)),
 SIZE_T = DEF('SIZE_T', ulong),
 PSIZE_T = DEF('PSIZE_T', PTR(ulong)),
 DWORD_PTR = DEF('DWORD_PTR', ulong),
 PDWORD_PTR = DEF('PDWORD_PTR', PTR(ulong)),
 LONG64 = DEF('LONG64', longlong),
 ULONG64 = DEF('ULONG64', ulonglong),
 PULONG64 = DEF('PULONG64', PTR(ulonglong)),
 DWORD64 = DEF('DWORD64', ulonglong),
 KAFFINITY = DEF('KAFFINITY', ulong),
 PVOID = DEF('PVOID', PTR('void')),
 PVOID64 = DEF('PVOID64', PTR('void')),
 CHAR = DEF('CHAR', int8),
 SHORT = DEF('SHORT', short),
 LONG = DEF('LONG', long),
 WCHAR = DEF('WCHAR', ushort),
 PWCHAR = DEF('PWCHAR', PTR(ushort)),
 LPWCH = DEF('LPWCH', PTR(ushort)),
 LPWSTR = DEF('LPWSTR', PTR(ushort)),
 PWSTR = DEF('PWSTR', PTR(ushort)),
 PUWSTR = DEF('PUWSTR', PTR(ushort)),
 LPCWSTR = DEF('LPCWSTR', PTR(ushort)),
 PCWSTR = DEF('PCWSTR', PTR(ushort)),
 PCUWSTR = DEF('PCUWSTR', PTR(ushort)),
 PZZWSTR = DEF('PZZWSTR', PTR(ushort)),
 PCZZWSTR = DEF('PCZZWSTR', PTR(ushort)),
 PCNZWCH = DEF('PCNZWCH', PTR(ushort)),
 LPCH = DEF('LPCH', PTR(int8)),
 LPCCH = DEF('LPCCH', PTR(int8)),
 LPSTR = DEF('LPSTR', PTR(int8)),
 PSTR = DEF('PSTR', PTR(int8)),
 LPCSTR = DEF('LPCSTR', PTR(int8)),
 PCNZCH = DEF('PCNZCH', PTR(int8)),
 PLONG = DEF('PLONG', PTR(long)),
 HANDLE = DEF('HANDLE', PTR('void')),
 HRESULT = DEF('HRESULT', long),
 CCHAR = DEF('CCHAR', int8),
 LCID = DEF('LCID', ulong),
 LANGID = DEF('LANGID', ushort),
 LONGLONG = DEF('LONGLONG', longlong),
 ULONGLONG = DEF('ULONGLONG', ulonglong),
 PULONGLONG = DEF('PULONGLONG', PTR(ulonglong)),
 USN = DEF('USN', longlong),
 DWORDLONG = DEF('DWORDLONG', ulonglong),
 BOOLEAN = DEF('BOOLEAN', uchar),
 PBOOLEAN = DEF('PBOOLEAN', PTR(uchar)),
 PACCESS_TOKEN = DEF('PACCESS_TOKEN', PTR('void')),
 PSECURITY_DESCRIPTOR = DEF('PSECURITY_DESCRIPTOR', PTR('void')),
 PSID = DEF('PSID', PTR('void')),
 ACCESS_MASK = DEF('ACCESS_MASK', ulong),
 PACCESS_MASK = DEF('PACCESS_MASK', PTR(ulong)),
 SECURITY_DESCRIPTOR_CONTROL = DEF('SECURITY_DESCRIPTOR_CONTROL', ushort),
 PSECURITY_DESCRIPTOR_CONTROL = DEF('PSECURITY_DESCRIPTOR_CONTROL', PTR(ushort)),
 SECURITY_CONTEXT_TRACKING_MODE = DEF('SECURITY_CONTEXT_TRACKING_MODE', uchar),
 SECURITY_INFORMATION = DEF('SECURITY_INFORMATION', ulong),
 PSECURITY_INFORMATION = DEF('PSECURITY_INFORMATION', PTR(ulong)),
 EXECUTION_STATE = DEF('EXECUTION_STATE', ulong),
 SAVEPOINT_ID = DEF('SAVEPOINT_ID', ulong),
 TP_VERSION = DEF('TP_VERSION', ulong),
 WPARAM = DEF('WPARAM', uint),
 LPARAM = DEF('LPARAM', long),
 LRESULT = DEF('LRESULT', long),
 ATOM = DEF('ATOM', ushort),
 HGLOBAL = DEF('HGLOBAL', PTR('void')),
 HLOCAL = DEF('HLOCAL', PTR('void')),
 HGDIOBJ = DEF('HGDIOBJ', PTR('void')),
 HFILE = DEF('HFILE', int),
 COLORREF = DEF('COLORREF', ulong),
 PUMS_CONTEXT = DEF('PUMS_CONTEXT', PTR('void')),
 PUMS_COMPLETION_LIST = DEF('PUMS_COMPLETION_LIST', PTR('void')),
 LCSCSTYPE = DEF('LCSCSTYPE', long),
 LCSGAMUTMATCH = DEF('LCSGAMUTMATCH', long),
 FXPT2DOT30 = DEF('FXPT2DOT30', long),
 COLOR16 = DEF('COLOR16', ushort),
 HDWP = DEF('HDWP', PTR('void')),
 HDEVNOTIFY = DEF('HDEVNOTIFY', PTR('void')),
 HPOWERNOTIFY = DEF('HPOWERNOTIFY', PTR('void')),
 LGRPID = DEF('LGRPID', ulong),
 LCTYPE = DEF('LCTYPE', ulong),
 CALTYPE = DEF('CALTYPE', ulong),
 CALID = DEF('CALID', ulong),
 NLS_FUNCTION = DEF('NLS_FUNCTION', ulong),
 GEOID = DEF('GEOID', long),
 GEOTYPE = DEF('GEOTYPE', ulong),
 GEOCLASS = DEF('GEOCLASS', ulong),
 REGSAM = DEF('REGSAM', ulong),
 LSTATUS = DEF('LSTATUS', long),
 MMVERSION = DEF('MMVERSION', uint),
 MMRESULT = DEF('MMRESULT', uint),
 LPUINT = DEF('LPUINT', PTR(uint)),
 FOURCC = DEF('FOURCC', ulong),
 HPSTR = DEF('HPSTR', PTR(int8)),
 MCIERROR = DEF('MCIERROR', ulong),
 MCIDEVICEID = DEF('MCIDEVICEID', uint),
 RPC_STATUS = DEF('RPC_STATUS', long),
 RPC_CSTR = DEF('RPC_CSTR', PTR(uchar)),
 RPC_WSTR = DEF('RPC_WSTR', PTR(ushort)),
 RPC_BINDING_HANDLE = DEF('RPC_BINDING_HANDLE', PTR('void')),
 handle_t = DEF('handle_t', PTR('void')),
 RPC_IF_HANDLE = DEF('RPC_IF_HANDLE', PTR('void')),
 RPC_AUTH_IDENTITY_HANDLE = DEF('RPC_AUTH_IDENTITY_HANDLE', PTR('void')),
 RPC_ADDRESS_CHANGE_FN = DEF('RPC_ADDRESS_CHANGE_FN', CALLBACK('void', [PTR('void')])),
 I_RPC_MUTEX = DEF('I_RPC_MUTEX', PTR('void')),
 RPC_NS_HANDLE = DEF('RPC_NS_HANDLE', PTR('void')),
 FILEOP_FLAGS = DEF('FILEOP_FLAGS', ushort),
 u_short = DEF('u_short', ushort),
 u_int = DEF('u_int', uint),
 u_long = DEF('u_long', ulong),
 SOCKET = DEF('SOCKET', uint),
 ALG_ID = DEF('ALG_ID', uint),
 HCRYPTPROV = DEF('HCRYPTPROV', ulong),
 HCRYPTKEY = DEF('HCRYPTKEY', ulong),
 HCRYPTHASH = DEF('HCRYPTHASH', ulong),
 NTSTATUS = DEF('NTSTATUS', long),
 BCRYPT_HANDLE = DEF('BCRYPT_HANDLE', PTR('void')),
 BCRYPT_ALG_HANDLE = DEF('BCRYPT_ALG_HANDLE', PTR('void')),
 BCRYPT_KEY_HANDLE = DEF('BCRYPT_KEY_HANDLE', PTR('void')),
 BCRYPT_HASH_HANDLE = DEF('BCRYPT_HASH_HANDLE', PTR('void')),
 BCRYPT_SECRET_HANDLE = DEF('BCRYPT_SECRET_HANDLE', PTR('void')),
 SECURITY_STATUS = DEF('SECURITY_STATUS', long),
 NCRYPT_HANDLE = DEF('NCRYPT_HANDLE', ulong),
 NCRYPT_PROV_HANDLE = DEF('NCRYPT_PROV_HANDLE', ulong),
 NCRYPT_KEY_HANDLE = DEF('NCRYPT_KEY_HANDLE', ulong),
 NCRYPT_SECRET_HANDLE = DEF('NCRYPT_SECRET_HANDLE', ulong),
 HCRYPTPROV_OR_NCRYPT_KEY_HANDLE = DEF('HCRYPTPROV_OR_NCRYPT_KEY_HANDLE', ulong),
 HCRYPTPROV_LEGACY = DEF('HCRYPTPROV_LEGACY', ulong),
 HCRYPTOIDFUNCSET = DEF('HCRYPTOIDFUNCSET', PTR('void')),
 HCRYPTOIDFUNCADDR = DEF('HCRYPTOIDFUNCADDR', PTR('void')),
 HCRYPTMSG = DEF('HCRYPTMSG', PTR('void')),
 HCERTSTORE = DEF('HCERTSTORE', PTR('void')),
 HCERTSTOREPROV = DEF('HCERTSTOREPROV', PTR('void')),
 HCRYPTDEFAULTCONTEXT = DEF('HCRYPTDEFAULTCONTEXT', PTR('void')),
 HCRYPTASYNC = DEF('HCRYPTASYNC', PTR('void')),
 HCERTCHAINENGINE = DEF('HCERTCHAINENGINE', PTR('void')),
 HCERT_SERVER_OCSP_RESPONSE = DEF('HCERT_SERVER_OCSP_RESPONSE', PTR('void')),
 NDR_CCONTEXT = DEF('NDR_CCONTEXT', PTR('void')),
 PFORMAT_STRING = DEF('PFORMAT_STRING', PTR(uchar)),
 RPC_SS_THREAD_HANDLE = DEF('RPC_SS_THREAD_HANDLE', PTR('void')),
 LPOLESTR = DEF('LPOLESTR', PTR(ushort)),
 LPCOLESTR = DEF('LPCOLESTR', PTR(ushort)),
 DOUBLE = DEF('DOUBLE', double),
 SCODE = DEF('SCODE', long),
 CLIPFORMAT = DEF('CLIPFORMAT', ushort),
 HMETAFILEPICT = DEF('HMETAFILEPICT', PTR('void')),
 DATE = DEF('DATE', double),
 BSTR = DEF('BSTR', PTR(ushort)),
 VARIANT_BOOL = DEF('VARIANT_BOOL', short),
 VARTYPE = DEF('VARTYPE', ushort),
 PROPID = DEF('PROPID', ulong),
 DEVICE_DATA_MANAGEMENT_SET_ACTION = DEF('DEVICE_DATA_MANAGEMENT_SET_ACTION', ulong),
 LPCBYTE = DEF('LPCBYTE', PTR(uchar)),
 SCARDCONTEXT = DEF('SCARDCONTEXT', ulong),
 LPSCARDCONTEXT = DEF('LPSCARDCONTEXT', PTR(ulong)),
 SCARDHANDLE = DEF('SCARDHANDLE', ulong),
 LPSCARDHANDLE = DEF('LPSCARDHANDLE', PTR(ulong)),
 RPCOLEDATAREP = DEF('RPCOLEDATAREP', ulong),
 HOLEMENU = DEF('HOLEMENU', PTR('void')),
 DISPID = DEF('DISPID', long),
 MEMBERID = DEF('MEMBERID', long),
 HREFTYPE = DEF('HREFTYPE', ulong),
 PROPVAR_PAD1 = DEF('PROPVAR_PAD1', ushort),
 PROPVAR_PAD2 = DEF('PROPVAR_PAD2', ushort),
 PROPVAR_PAD3 = DEF('PROPVAR_PAD3', ushort),
 SC_LOCK = DEF('SC_LOCK', PTR('void'));

var EXCEPTION_DISPOSITION = ENUM('EXCEPTION_DISPOSITION', {
 ContinueExecution: 0,
 ContinueSearch: 1,
 NestedException: 2,
 CollidedUnwind: 3
});

var SID_NAME_USE = ENUM('SID_NAME_USE', {
 TypeUser: 1,
 TypeGroup: 1,
 TypeDomain: 2,
 TypeAlias: 3,
 TypeWellKnownGroup: 4,
 TypeDeletedAccount: 5,
 TypeInvalid: 6,
 TypeUnknown: 7,
 TypeComputer: 8,
 TypeLabel: 9
});

var WELL_KNOWN_SID_TYPE = ENUM('WELL_KNOWN_SID_TYPE', {
 WinNullSid: 0,
 WinWorldSid: 1,
 WinLocalSid: 2,
 WinCreatorOwnerSid: 3,
 WinCreatorGroupSid: 4,
 WinCreatorOwnerServerSid: 5,
 WinCreatorGroupServerSid: 6,
 WinNtAuthoritySid: 7,
 WinDialupSid: 8,
 WinNetworkSid: 9,
 WinBatchSid: 10,
 WinInteractiveSid: 11,
 WinServiceSid: 12,
 WinAnonymousSid: 13,
 WinProxySid: 14,
 WinEnterpriseControllersSid: 15,
 WinSelfSid: 16,
 WinAuthenticatedUserSid: 17,
 WinRestrictedCodeSid: 18,
 WinTerminalServerSid: 19,
 WinRemoteLogonSid: 20,
 WinLogonIdsSid: 21,
 WinLocalSystemSid: 22,
 WinLocalServiceSid: 23,
 WinNetworkServiceSid: 24,
 WinBuiltinDomainSid: 25,
 WinBuiltinAdministratorsSid: 26,
 WinBuiltinUsersSid: 27,
 WinBuiltinGuestsSid: 28,
 WinBuiltinPowerUsersSid: 29,
 WinBuiltinAccountOperatorsSid: 30,
 WinBuiltinSystemOperatorsSid: 31,
 WinBuiltinPrintOperatorsSid: 32,
 WinBuiltinBackupOperatorsSid: 33,
 WinBuiltinReplicatorSid: 34,
 WinBuiltinPreWindows2000CompatibleAccessSid: 35,
 WinBuiltinRemoteDesktopUsersSid: 36,
 WinBuiltinNetworkConfigurationOperatorsSid: 37,
 WinAccountAdministratorSid: 38,
 WinAccountGuestSid: 39,
 WinAccountKrbtgtSid: 40,
 WinAccountDomainAdminsSid: 41,
 WinAccountDomainUsersSid: 42,
 WinAccountDomainGuestsSid: 43,
 WinAccountComputersSid: 44,
 WinAccountControllersSid: 45,
 WinAccountCertAdminsSid: 46,
 WinAccountSchemaAdminsSid: 47,
 WinAccountEnterpriseAdminsSid: 48,
 WinAccountPolicyAdminsSid: 49,
 WinAccountRasAndIasServersSid: 50,
 WinNtlmAuthenticationSid: 51,
 WinDigestAuthenticationSid: 52,
 WinChannelAuthenticationSid: 53,
 WinThisOrganizationSid: 54,
 WinOtherOrganizationSid: 55,
 WinBuiltinIncomingForestTrustBuildersSid: 56,
 WinBuiltinPerfMonitoringUsersSid: 57,
 WinBuiltinPerfLoggingUsersSid: 58,
 WinBuiltinAuthorizationAccessSid: 59,
 WinBuiltinTerminalServerLicenseServersSid: 60,
 WinBuiltinDcomUsersSid: 61,
 WinBuiltinUsersSid: 62,
 WinUserSid: 63,
 WinBuiltinCryptoOperatorsSid: 64,
 WinUntrustedLabelSid: 65,
 WinLowLabelSid: 66,
 WinMediumLabelSid: 67,
 WinHighLabelSid: 68,
 WinSystemLabelSid: 69,
 WinWriteRestrictedCodeSid: 70,
 WinCreatorOwnerRightsSid: 71,
 WinCacheablePrincipalsGroupSid: 72,
 WinNonCacheablePrincipalsGroupSid: 73,
 WinEnterpriseReadonlyControllersSid: 74,
 WinAccountReadonlyControllersSid: 75,
 WinBuiltinEventLogReadersGroup: 76,
 WinNewEnterpriseReadonlyControllersSid: 77,
 WinBuiltinCertSvcComAccessGroup: 78,
 WinMediumPlusLabelSid: 79,
 WinLocalLogonSid: 80,
 WinConsoleLogonSid: 81,
 WinThisOrganizationCertificateSid: 82
});

var ACL_INFORMATION_CLASS = ENUM('ACL_INFORMATION_CLASS', {
 RevisionInformation: 1,
 SizeInformation: 1
});

var AUDIT_EVENT_TYPE = ENUM('AUDIT_EVENT_TYPE', {
 ObjectAccess: 0,
 DirectoryServiceAccess: 1
});

var ACCESS_REASON_TYPE = ENUM('ACCESS_REASON_TYPE', {
 None: 0x00000000,
 AllowedAce: 0x00010000,
 DeniedAce: 0x00020000,
 AllowedParentAce: 0x00030000,
 DeniedParentAce: 0x00040000,
 MissingPrivilege: 0x00100000,
 FromPrivilege: 0x00200000,
 IntegrityLevel: 0x00300000,
 Ownership: 0x00400000,
 NullDacl: 0x00500000,
 EmptyDacl: 0x00600000,
 NoSd: 0x00700000,
 NoGrant: 0x00800000
});

var SECURITY_IMPERSONATION_LEVEL = ENUM('SECURITY_IMPERSONATION_LEVEL', {
 Anonymous: 0,
 Identification: 1,
 Impersonation: 2,
 Delegation: 3
});

var TOKEN_TYPE = ENUM('TOKEN_TYPE', {
 Primary: 1,
 Impersonation: 1
});

var TOKEN_ELEVATION_TYPE = ENUM('TOKEN_ELEVATION_TYPE', {
 Default: 1,
 Full: 1,
 Limited: 2
});

var TOKEN_INFORMATION_CLASS = ENUM('TOKEN_INFORMATION_CLASS', {
 User: 1,
 Groups: 1,
 Privileges: 2,
 Owner: 3,
 PrimaryGroup: 4,
 DefaultDacl: 5,
 Source: 6,
 Type: 7,
 ImpersonationLevel: 8,
 Statistics: 9,
 RestrictedSids: 10,
 SessionId: 11,
 GroupsAndPrivileges: 12,
 SessionReference: 13,
 SandBoxInert: 14,
 AuditPolicy: 15,
 Origin: 16,
 ElevationType: 17,
 LinkedToken: 18,
 Elevation: 19,
 HasRestrictions: 20,
 AccessInformation: 21,
 VirtualizationAllowed: 22,
 VirtualizationEnabled: 23,
 IntegrityLevel: 24,
 UiAccess: 25,
 MandatoryPolicy: 26,
 LogonSid: 27,
 MaxClass: 28
});

var MANDATORY_LEVEL = ENUM('MANDATORY_LEVEL', {
 Untrusted: 0,
 Low: 1,
 Medium: 2,
 High: 3,
 System: 4,
 SecureProcess: 5,
 Count: 6
});

var HARDWARE_COUNTER_TYPE = ENUM('HARDWARE_COUNTER_TYPE', {
 PmcCounter: 0,
 MaxType: 1
});

var JOBOBJECTINFOCLASS = ENUM('JOBOBJECTINFOCLASS', {
 BasicAccountingInformation: 1,
 BasicLimitInformation: 1,
 BasicProcessIdList: 2,
 BasicUiRestrictions: 3,
 SecurityLimitInformation: 4,
 EndOfTimeInformation: 5,
 AssociateCompletionPortInformation: 6,
 BasicAndIoAccountingInformation: 7,
 ExtendedLimitInformation: 8,
 SetInformation: 9,
 GroupInformation: 10,
 MaxClass: 11
});

var LOGICAL_PROCESSOR_RELATIONSHIP = ENUM('LOGICAL_PROCESSOR_RELATIONSHIP', {
 Core: 0,
 NumaNode: 1,
 Cache: 2,
 Package: 3,
 Group: 4,
 All: 0xffff
});

var PROCESSOR_CACHE_TYPE = ENUM('PROCESSOR_CACHE_TYPE', {
 Unified: 0,
 Instruction: 1,
 Data: 2,
 Trace: 3
});

var SYSTEM_POWER_STATE = ENUM('SYSTEM_POWER_STATE', {
 Unspecified: 0,
 Working: 1,
 Sleeping1: 2,
 Sleeping2: 3,
 Sleeping3: 4,
 Hibernate: 5,
 Shutdown: 6,
 Maximum: 7
});

var POWER_ACTION = ENUM('POWER_ACTION', {
 None: 0,
 Reserved: 1,
 Sleep: 2,
 Hibernate: 3,
 Shutdown: 4,
 ShutdownReset: 5,
 ShutdownOff: 6,
 WarmEject: 7
});

var DEVICE_POWER_STATE = ENUM('DEVICE_POWER_STATE', {
 Unspecified: 0,
 D0: 1,
 D1: 2,
 D2: 3,
 D3: 4,
 Maximum: 5
});

var MONITOR_DISPLAY_STATE = ENUM('MONITOR_DISPLAY_STATE', {
 PowerOff: 0,
 PowerOn: 1,
 PowerDim: 2
});

var LATENCY_TIME = ENUM('LATENCY_TIME', {
 LtDontCare: 0,
 LtLowestLatency: 1
});

var POWER_REQUEST_TYPE = ENUM('POWER_REQUEST_TYPE', {
 DisplayRequired: 0,
 SystemRequired: 1,
 AwayModeRequired: 2
});

var POWER_INFORMATION_LEVEL = ENUM('POWER_INFORMATION_LEVEL', {
 SystemPolicyAc: 0,
 SystemPolicyDc: 1,
 VerifySystemPolicyAc: 2,
 VerifySystemPolicyDc: 3,
 SystemCapabilities: 4,
 SystemBatteryState: 5,
 SystemStateHandler: 6,
 ProcessorStateHandler: 7,
 SystemPolicyCurrent: 8,
 AdministratorPolicy: 9,
 SystemReserveHiberFile: 10,
 ProcessorInformation: 11,
 SystemInformation: 12,
 ProcessorStateHandler2: 13,
 LastWakeTime: 14,
 LastSleepTime: 15,
 SystemExecutionState: 16,
 SystemStateNotifyHandler: 17,
 ProcessorPolicyAc: 18,
 ProcessorPolicyDc: 19,
 VerifyProcessorPolicyAc: 20,
 VerifyProcessorPolicyDc: 21,
 ProcessorPolicyCurrent: 22,
 SystemStateLogging: 23,
 SystemLoggingEntry: 24,
 SetSettingValue: 25,
 NotifyUserSetting: 26,
 Unused0: 27,
 Unused1: 28,
 SystemVideoState: 29,
 TraceApplicationMessage: 30,
 TraceApplicationMessageEnd: 31,
 ProcessorPerfStates: 32,
 ProcessorIdleStates: 33,
 ProcessorCap: 34,
 SystemWakeSource: 35,
 SystemHiberFileInformation: 36,
 TraceServiceMessage: 37,
 ProcessorLoad: 38,
 ShutdownNotification: 39,
 MonitorCapabilities: 40,
 SessionInit: 41,
 SessionDisplayState: 42,
 RequestCreate: 43,
 RequestAction: 44,
 GetRequestList: 45,
 ProcessorEx: 46,
 NotifyUserModeLegacyEvent: 47,
 GroupPark: 48,
 ProcessorIdleDomains: 49,
 WakeTimerList: 50,
 SystemHiberFileSize: 51,
 Maximum: 52
});

var SYSTEM_POWER_CONDITION = ENUM('SYSTEM_POWER_CONDITION', {
 Ac: 0,
 Dc: 1,
 Hot: 2,
 Maximum: 3
});

var POWER_PLATFORM_ROLE = ENUM('POWER_PLATFORM_ROLE', {
 Unspecified: 0,
 Desktop: 1,
 Mobile: 2,
 Workstation: 3,
 EnterpriseServer: 4,
 SohoServer: 5,
 AppliancePc: 6,
 PerformanceServer: 7,
 Maximum: 8
});

var IMAGE_AUX_SYMBOL_TYPE = ENUM('IMAGE_AUX_SYMBOL_TYPE', {
 TokenDef: 1
});

var IMPORT_OBJECT_TYPE = ENUM('IMPORT_OBJECT_TYPE', {
 Code: 0,
 Data: 1,
 Const: 2
});

var IMPORT_OBJECT_NAME_TYPE = ENUM('IMPORT_OBJECT_NAME_TYPE', {
 Ordinal: 0,
 Name: 1,
 NoPrefix: 2,
 Undecorate: 3
});

var ReplacesCorHdrNumericDefines = ENUM('ReplacesCorHdrNumericDefines', {
 ComimageFlagsIlonly: 0x00000001,
 ComimageFlags32bitrequired: 0x00000002,
 ComimageFlagsIlLibrary: 0x00000004,
 ComimageFlagsStrongnamesigned: 0x00000008,
 ComimageFlagsNativeEntrypoint: 0x00000010,
 ComimageFlagsTrackdebugdata: 0x00010000,
 VersionMajorV2: 2,
 VersionMajor: 7,
 VersionMinor: 0,
 DeletedNameLength: 8,
 VtablegapNameLength: 8,
 NativeTypeMaxCb: 1,
 IlmethodSectSmallMaxDatasize: 0xFF,
 ImageMihMethodrva: 0x01,
 ImageMihEhrva: 0x02,
 ImageMihBasicblock: 0x08,
 Vtable32bit: 0x01,
 Vtable64bit: 0x02,
 VtableFromUnmanaged: 0x04,
 VtableFromUnmanagedRetainAppdomain: 0x08,
 VtableCallMostDerived: 0x10,
 ImageEatjThunkSize: 32,
 MaxClassName: 1024,
 MaxPackageName: 1024
});

var UMS_THREAD_INFO_CLASS = ENUM('UMS_THREAD_INFO_CLASS', {
 InvalidClass: 0,
 UserContext: 1,
 Priority: 2,
 Affinity: 3,
 Teb: 4,
 IsSuspended: 5,
 IsTerminated: 6,
 MaxClass: 7
});

var UMS_SCHEDULER_REASON = ENUM('UMS_SCHEDULER_REASON', {
 Startup: 0,
 ThreadBlocked: 1,
 ThreadYield: 2
});

var HEAP_INFORMATION_CLASS = ENUM('HEAP_INFORMATION_CLASS', {
 CompatibilityInformation: 0,
 EnableTerminationCorruption: 1
});

var ACTIVATION_CONTEXT_INFO_CLASS = ENUM('ACTIVATION_CONTEXT_INFO_CLASS', {
 BasicInformation: 1,
 DetailedInformation: 2,
 AssemblyDetailedInformationContext: 3,
 FileInformationAssemblyOfAssemblyContext: 4,
 RunlevelInformationContext: 5,
 CompatibilityInformationContext: 6,
 ManifestResourceName: 7,
 MaxClass: 7,
 AssemblyDetailedInformationContxt: 3,
 FileInformationAssemblyOfAssemblyContxt: 4
});

var ACTCTX_REQUESTED_RUN_LEVEL = ENUM('ACTCTX_REQUESTED_RUN_LEVEL', {
 Unspecified: 0,
 AsInvoker: 1,
 HighestAvailable: 2,
 RequireAdmin: 3,
 Numbers: 4
});

var ACTCTX_COMPATIBILITY_ELEMENT_TYPE = ENUM('ACTCTX_COMPATIBILITY_ELEMENT_TYPE', {
 Unknown: 0,
 Os: 1,
 Mitigation: 2
});

var SERVICE_NODE_TYPE = ENUM('SERVICE_NODE_TYPE', {
 DriverType: SERVICE_KERNEL_DRIVER,
 FileSystemType: SERVICE_FILE_SYSTEM_DRIVER,
 Win32OwnProcess: SERVICE_WIN32_OWN_PROCESS,
 Win32ShareProcess: SERVICE_WIN32_SHARE_PROCESS,
 AdapterType: SERVICE_ADAPTER,
 RecognizerType: SERVICE_RECOGNIZER_DRIVER
});

var SERVICE_LOAD_TYPE = ENUM('SERVICE_LOAD_TYPE', {
 BootLoad: SERVICE_BOOT_START,
 SystemLoad: SERVICE_SYSTEM_START,
 AutoLoad: SERVICE_AUTO_START,
 DemandLoad: SERVICE_DEMAND_START,
 DisableLoad: SERVICE_DISABLED
});

var SERVICE_ERROR_TYPE = ENUM('SERVICE_ERROR_TYPE', {
 IgnoreError: SERVICE_ERROR_IGNORE,
 NormalError: SERVICE_ERROR_NORMAL,
 SevereError: SERVICE_ERROR_SEVERE,
 CriticalError: SERVICE_ERROR_CRITICAL
});

var TAPE_DRIVE_PROBLEM_TYPE = ENUM('TAPE_DRIVE_PROBLEM_TYPE', {
 None: 0,
 ReadWriteWarning: 1,
 ReadWriteError: 2,
 ReadWarning: 3,
 WriteWarning: 4,
 ReadError: 5,
 WriteError: 6,
 HardwareError: 7,
 UnsupportedMedia: 8,
 ScsiConnectionError: 9,
 TimetoClean: 10,
 CleanNow: 11,
 MediaLifeExpired: 12,
 SnappedTape: 13
});

var TRANSACTION_OUTCOME = ENUM('TRANSACTION_OUTCOME', {
 Undetermined: 1,
 Committed: 1,
 Aborted: 2
});

var TRANSACTION_STATE = ENUM('TRANSACTION_STATE', {
 Normal: 1,
 Indoubt: 1,
 CommittedNotify: 2
});

var TRANSACTION_INFORMATION_CLASS = ENUM('TRANSACTION_INFORMATION_CLASS', {
 BasicInformation: 0,
 PropertiesInformation: 1,
 EnlistmentInformation: 2,
 SuperiorEnlistmentInformation: 3,
 BindInformation: 4,
 DtcPrivateInformation: 5
});

var TRANSACTIONMANAGER_INFORMATION_CLASS = ENUM('TRANSACTIONMANAGER_INFORMATION_CLASS', {
 BasicInformation: 0,
 LogInformation: 1,
 LogPathInformation: 2,
 RecoveryInformation: 4,
 OnlineProbeInformation: 3,
 OldestInformation: 5
});

var RESOURCEMANAGER_INFORMATION_CLASS = ENUM('RESOURCEMANAGER_INFORMATION_CLASS', {
 BasicInformation: 0,
 CompletionInformation: 1
});

var ENLISTMENT_INFORMATION_CLASS = ENUM('ENLISTMENT_INFORMATION_CLASS', {
 BasicInformation: 0,
 RecoveryInformation: 1,
 CrmInformation: 2
});

var KTMOBJECT_TYPE = ENUM('KTMOBJECT_TYPE', {
 Transaction: 0,
 TransactionManager: 1,
 ResourceManager: 2,
 Enlistment: 3,
 Invalid: 4
});

var TP_CALLBACK_PRIORITY = ENUM('TP_CALLBACK_PRIORITY', {
 High: 0,
 Normal: 1,
 Low: 2,
 Invalid: 3
});

var DEP_SYSTEM_POLICY_TYPE = ENUM('DEP_SYSTEM_POLICY_TYPE', {
 AlwaysOff: 0,
 AlwaysOn: 1,
 OptIn: 2,
 OptOut: 3,
 TotalCount: 4
});

var MEMORY_RESOURCE_NOTIFICATION_TYPE = ENUM('MEMORY_RESOURCE_NOTIFICATION_TYPE', {
 LowNotification: 0,
 HighNotification: 1
});

var PROC_THREAD_ATTRIBUTE_NUM = ENUM('PROC_THREAD_ATTRIBUTE_NUM', {
 ParentProcess: 0,
 ExtendedFlags: 1,
 HandleList: 2,
 GroupAffinity: 3,
 PreferredNode: 4,
 IdealProcessor: 5,
 UmsThread: 6,
 MitigationPolicy: 7,
 Max: 8
});

var GET_FILEEX_INFO_LEVELS = ENUM('GET_FILEEX_INFO_LEVELS', {
 Standard: 0,
 MaxLevel: 1
});

var FINDEX_INFO_LEVELS = ENUM('FINDEX_INFO_LEVELS', {
 Standard: 0,
 Basic: 1,
 MaxLevel: 2
});

var FINDEX_SEARCH_OPS = ENUM('FINDEX_SEARCH_OPS', {
 NameMatch: 0,
 LimitToDirectories: 1,
 LimitToDevices: 2,
 MaxOp: 3
});

var STREAM_INFO_LEVELS = ENUM('STREAM_INFO_LEVELS', {
 FindStandard: 0,
 FindMaxLevel: 1
});

var PIPE_ATTRIBUTE_TYPE = ENUM('PIPE_ATTRIBUTE_TYPE', {
 Attribute: 0,
 ConnectionAttribute: 1,
 HandleAttribute: 2
});

var COMPUTER_NAME_FORMAT = ENUM('COMPUTER_NAME_FORMAT', {
 NetBios: 0,
 DnsHostname: 1,
 DnsDomain: 2,
 DnsFullyQualified: 3,
 PhysicalNetBios: 4,
 PhysicalDnsHostname: 5,
 PhysicalDnsDomain: 6,
 PhysicalDnsFullyQualified: 7,
 Max: 8
});

var FILE_INFO_BY_HANDLE_CLASS = ENUM('FILE_INFO_BY_HANDLE_CLASS', {
 BasicInfo: 0,
 StandardInfo: 1,
 NameInfo: 2,
 RenameInfo: 3,
 DispositionInfo: 4,
 AllocationInfo: 5,
 EndOfInfo: 6,
 StreamInfo: 7,
 CompressionInfo: 8,
 AttributeTagInfo: 9,
 IdBothDirectoryInfo: 10,
 IdBothDirectoryRestartInfo: 11,
 IoPriorityHintInfo: 12,
 RemoteProtocolInfo: 13,
 MaximumClass: 14
});

var PRIORITY_HINT = ENUM('PRIORITY_HINT', {
 VeryLow: 0,
 Low: 1,
 Normal: 2,
 MaximumType: 3
});

var FILE_ID_TYPE = ENUM('FILE_ID_TYPE', {
 Type: 0,
 ObjectType: 1,
 MaximumType: 2
});

var DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY = ENUM('DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY', {
 Other: 0,
 Hd15: 0,
 Svideo: 1,
 CompositeVideo: 2,
 ComponentVideo: 3,
 Dvi: 4,
 Hdmi: 5,
 Lvds: 6,
 Jpn: 8,
 Sdi: 9,
 DisplayportExternal: 10,
 DisplayportEmbedded: 11,
 UdiExternal: 12,
 UdiEmbedded: 13,
 Sdtvdongle: 14,
 Internal: 15,
 ForceUint32: 16
});

var DISPLAYCONFIG_SCANLINE_ORDERING = ENUM('DISPLAYCONFIG_SCANLINE_ORDERING', {
 Unspecified: 0,
 Progressive: 1,
 Interlaced: 2,
 InterlacedUpperfieldfirst: 3,
 InterlacedLowerfieldfirst: 3,
 ForceUint32: 5
});

var DISPLAYCONFIG_SCALING = ENUM('DISPLAYCONFIG_SCALING', {
 Identity: 1,
 Centered: 2,
 Stretched: 3,
 Aspectratiocenteredmax: 4,
 Custom: 5,
 Preferred: 128,
 ForceUint32: 6
});

var DISPLAYCONFIG_ROTATION = ENUM('DISPLAYCONFIG_ROTATION', {
 Identity: 1,
 Rotate90: 2,
 Rotate180: 3,
 Rotate270: 4,
 ForceUint32: 4
});

var DISPLAYCONFIG_MODE_INFO_TYPE = ENUM('DISPLAYCONFIG_MODE_INFO_TYPE', {
 Source: 1,
 Target: 2,
 ForceUint32: 2
});

var DISPLAYCONFIG_PIXELFORMAT = ENUM('DISPLAYCONFIG_PIXELFORMAT', {
 8bpp: 1,
 16bpp: 2,
 24bpp: 3,
 32bpp: 4,
 Nongdi: 5,
 ForceUint32: 5
});

var DISPLAYCONFIG_TOPOLOGY_ID = ENUM('DISPLAYCONFIG_TOPOLOGY_ID', {
 Internal: 0x00000001,
 Clone: 0x00000002,
 Extend: 0x00000004,
 External: 0x00000008,
 ForceUint32: 4
});

var DISPLAYCONFIG_DEVICE_INFO_TYPE = ENUM('DISPLAYCONFIG_DEVICE_INFO_TYPE', {
 GetSourceName: 1,
 GetTargetName: 2,
 GetTargetPreferredMode: 3,
 GetAdapterName: 4,
 SetTargetPersistence: 5,
 ForceUint32: 5
});

var SYSNLS_FUNCTION = ENUM('SYSNLS_FUNCTION', {
 CompareString: 0x0001
});

var SYSGEOTYPE = ENUM('SYSGEOTYPE', {
 Nation: 0x0001,
 Latitude: 0x0002,
 Longitude: 0x0003,
 Iso2: 0x0004,
 Iso3: 0x0005,
 Rfc1766: 0x0006,
 Lcid: 0x0007,
 Friendlyname: 0x0008,
 Officialname: 0x0009,
 Timezones: 0x000A,
 Officiallanguages: 0x000B
});

var SYSGEOCLASS = ENUM('SYSGEOCLASS', {
 Nation: 16,
 Region: 14
});

var NORM_FORM = ENUM('NORM_FORM', {
 NormalizationOther: 0,
 NormalizationC: 0x1,
 NormalizationD: 0x2,
 NormalizationKc: 0x5,
 NormalizationKd: 0x6
});

var RPC_HTTP_REDIRECTOR_STAGE = ENUM('RPC_HTTP_REDIRECTOR_STAGE', {
 Redirect: 1,
 Access1: 1,
 Session: 2,
 Access2: 3,
 Interface: 4
});

var RPC_ADDRESS_CHANGE_TYPE = ENUM('RPC_ADDRESS_CHANGE_TYPE', {
 ProtocolNotLoaded: 1,
 ProtocolLoaded: 1,
 ProtocolChange: 2
});

var RpcPerfCounters = ENUM('RpcPerfCounters', {
 CurrentUniqueUser: 1,
 BackEndConnectionAttempts: 1,
 BackEndConnectionFailed: 2,
 RequestsSecond: 3,
 IncomingConnections: 4,
 IncomingBandwidth: 5,
 OutgoingBandwidth: 6,
 AttemptedLbsDecisions: 7,
 FailedLbsDecisions: 8,
 AttemptedLbsMessages: 9,
 FailedLbsMessages: 10,
 LastCounter: 11
});

var RPC_NOTIFICATION_TYPES = ENUM('RPC_NOTIFICATION_TYPES', {
 None: 0,
 Event: 1,
 Apc: 2,
 Ioc: 3,
 Hwnd: 4,
 Callback: 5
});

var RPC_ASYNC_EVENT = ENUM('RPC_ASYNC_EVENT', {
 CallComplete: 0,
 SendComplete: 1,
 ReceiveComplete: 2,
 ClientDisconnect: 3,
 ClientCancel: 4
});

var ExtendedErrorParamTypes = ENUM('ExtendedErrorParamTypes', {
 EeptAnsiString: 1,
 EeptUnicodeString: 1,
 EeptLongVal: 2,
 EeptShortVal: 3,
 EeptPointerVal: 4,
 EeptNone: 5,
 EeptBinary: 6
});

var RpcLocalAddressFormat = ENUM('RpcLocalAddressFormat', {
 RlafInvalid: 0,
 RlafiPv4: 1,
 RlafiPv6: 2
});

var RpcCallType = ENUM('RpcCallType', {
 RctInvalid: 0,
 RctNormal: 1,
 RctTraining: 2,
 RctGuaranteed: 3
});

var RpcCallClientLocality = ENUM('RpcCallClientLocality', {
 RcclInvalid: 0,
 RcclLocal: 1,
 RcclRemote: 2,
 RcclUnknownLocality: 3
});

var RPC_NOTIFICATIONS = ENUM('RPC_NOTIFICATIONS', {
 CallNone: 0,
 ClientDisconnect: 1,
 CallCancel: 2
});

var ASSOCCLASS = ENUM('ASSOCCLASS', {
 ShellKey: 0,
 ProgidKey: 1,
 ProgidStr: 2,
 ClsidKey: 3,
 ClsidStr: 4,
 AppKey: 5,
 AppStr: 6,
 SystemStr: 7,
 Folder: 8,
 Star: 9
});

var QUERY_USER_NOTIFICATION_STATE = ENUM('QUERY_USER_NOTIFICATION_STATE', {
 QunsPresent: 1,
 QunsBusy: 2,
 QunsRunningD3dFullScreen: 3,
 QunsPresentationMode: 4,
 QunsAcceptsNotifications: 5,
 QunsQuietTime: 6
});

var SHSTOCKICONID = ENUM('SHSTOCKICONID', {
 SiidDocnoassoc: 0,
 SiidDocassoc: 1,
 SiidApplication: 2,
 SiidFolder: 3,
 SiidFolderopen: 4,
 SiidDrive525: 5,
 SiidDrive35: 6,
 SiidDriveremove: 7,
 SiidDrivefixed: 8,
 SiidDrivenet: 9,
 SiidDrivenetdisabled: 10,
 SiidDrivecd: 11,
 SiidDriveram: 12,
 SiidWorld: 13,
 SiidServer: 15,
 SiidPrinter: 16,
 SiidMynetwork: 17,
 SiidFind: 22,
 SiidHelp: 23,
 SiidShare: 28,
 SiidLink: 29,
 SiidSlowfile: 30,
 SiidRecycler: 31,
 SiidRecyclerfull: 32,
 SiidMediacdaudio: 40,
 SiidLock: 47,
 SiidAutolist: 49,
 SiidPrinternet: 50,
 SiidServershare: 51,
 SiidPrinterfax: 52,
 SiidPrinterfaxnet: 53,
 SiidPrinterfile: 54,
 SiidStack: 55,
 SiidMediasvcd: 56,
 SiidStuffedfolder: 57,
 SiidDriveunknown: 58,
 SiidDrivedvd: 59,
 SiidMediadvd: 60,
 SiidMediadvdram: 61,
 SiidMediadvdrw: 62,
 SiidMediadvdr: 63,
 SiidMediadvdrom: 64,
 SiidMediacdaudioplus: 65,
 SiidMediacdrw: 66,
 SiidMediacdr: 67,
 SiidMediacdburn: 68,
 SiidMediablankcd: 69,
 SiidMediacdrom: 70,
 SiidAudiofiles: 71,
 SiidImagefiles: 72,
 SiidVideofiles: 73,
 SiidMixedfiles: 74,
 SiidFolderback: 75,
 SiidFolderfront: 76,
 SiidShield: 77,
 SiidWarning: 78,
 SiidInfo: 79,
 SiidError: 80,
 SiidKey: 81,
 SiidSoftware: 82,
 SiidRename: 83,
 SiidDelete: 84,
 SiidMediaaudiodvd: 85,
 SiidMediamoviedvd: 86,
 SiidMediaenhancedcd: 87,
 SiidMediaenhanceddvd: 88,
 SiidMediahddvd: 89,
 SiidMediabluray: 90,
 SiidMediavcd: 91,
 SiidMediadvdplusr: 92,
 SiidMediadvdplusrw: 93,
 SiidDesktoppc: 94,
 SiidMobilepc: 95,
 SiidUsers: 96,
 SiidMediasmartmedia: 97,
 SiidMediacompactflash: 98,
 SiidDevicecellphone: 99,
 SiidDevicecamera: 100,
 SiidDevicevideocamera: 101,
 SiidDeviceaudioplayer: 102,
 SiidNetworkconnect: 103,
 SiidInternet: 104,
 SiidZipfile: 105,
 SiidSettings: 106,
 SiidDrivehddvd: 132,
 SiidDrivebd: 133,
 SiidMediahddvdrom: 134,
 SiidMediahddvdr: 135,
 SiidMediahddvdram: 136,
 SiidMediabdrom: 137,
 SiidMediabdr: 138,
 SiidMediabdre: 139,
 SiidClustereddrive: 140,
 SiidMaxIcons: 174
});

var USER_MARSHAL_CB_TYPE = ENUM('USER_MARSHAL_CB_TYPE', {
 BufferSize: 0,
 Marshall: 1,
 Unmarshall: 2,
 Free: 3
});

var IDL_CS_CONVERT = ENUM('IDL_CS_CONVERT', {
 NoConvert: 0,
 InPlaceConvert: 1,
 NewBufferConvert: 2
});

var XLAT_SIDE = ENUM('XLAT_SIDE', {
 Server: 1,
 Client: 1
});

var STUB_PHASE = ENUM('STUB_PHASE', {
 Unmarshal: 0,
 CallServer: 1,
 Marshal: 2,
 CallServerNoHresult: 3
});

var PROXY_PHASE = ENUM('PROXY_PHASE', {
 Calcsize: 0,
 Getbuffer: 1,
 Marshal: 2,
 Sendreceive: 3,
 Unmarshal: 4
});

var MEMCTX = ENUM('MEMCTX', {
 Task: 1,
 Shared: 2,
 Macsystem: 3,
 Unknown: 3,
 Same: 4
});

var CLSCTX = ENUM('CLSCTX', {
 InprocServer: 0x1,
 InprocHandler: 0x2,
 LocalServer: 0x4,
 InprocServer16: 0x8,
 RemoteServer: 0x10,
 InprocHandler16: 0x20,
 Reserved1: 0x40,
 Reserved2: 0x80,
 Reserved3: 0x100,
 Reserved4: 0x200,
 NoCodeDownload: 0x400,
 Reserved5: 0x800,
 NoCustomMarshal: 0x1000,
 EnableCodeDownload: 0x2000,
 NoFailureLog: 0x4000,
 DisableAaa: 0x8000,
 EnableAaa: 0x10000,
 FromDefaultContext: 0x20000,
 Activate32BitServer: 0x40000,
 Activate64BitServer: 0x80000,
 EnableCloaking: 0x100000,
 PsDll: 21
});

var MSHLFLAGS = ENUM('MSHLFLAGS', {
 Normal: 0,
 Tablestrong: 1,
 Tableweak: 2,
 Noping: 4,
 Reserved1: 8,
 Reserved2: 16,
 Reserved3: 32,
 Reserved4: 64
});

var MSHCTX = ENUM('MSHCTX', {
 Local: 0,
 Nosharedmem: 1,
 Differentmachine: 2,
 Inproc: 3,
 Crossctx: 4
});

var DVASPECT = ENUM('DVASPECT', {
 Content: 1,
 Thumbnail: 2,
 Icon: 4,
 Docprint: 8
});

var STGC = ENUM('STGC', {
 Default: 0,
 Overwrite: 1,
 Onlyifcurrent: 2,
 Dangerouslycommitmerelytodiskcache: 4,
 Consolidate: 8
});

var STGMOVE = ENUM('STGMOVE', {
 Move: 0,
 Copy: 1,
 Shallowcopy: 2
});

var STATFLAG = ENUM('STATFLAG', {
 Default: 0,
 Noname: 1,
 Noopen: 2
});

var VARENUM = ENUM('VARENUM', {
 VtEmpty: 0,
 VtNull: 1,
 VtI2: 2,
 VtI4: 3,
 VtR4: 4,
 VtR8: 5,
 VtCy: 6,
 VtDate: 7,
 VtBstr: 8,
 VtDispatch: 9,
 VtError: 10,
 VtBool: 11,
 VtVariant: 12,
 VtUnknown: 13,
 VtDecimal: 14,
 VtI1: 16,
 VtUi1: 17,
 VtUi2: 18,
 VtUi4: 19,
 VtI8: 20,
 VtUi8: 21,
 VtInt: 22,
 VtUint: 23,
 VtVoid: 24,
 VtHresult: 25,
 VtPtr: 26,
 VtSafearray: 27,
 VtCarray: 28,
 VtUserdefined: 29,
 VtLpstr: 30,
 VtLpwstr: 31,
 VtRecord: 36,
 VtIntPtr: 37,
 VtUintPtr: 38,
 VtFiletime: 64,
 VtBlob: 65,
 VtStream: 66,
 VtStorage: 67,
 VtStreamedObject: 68,
 VtStoredObject: 69,
 VtBlobObject: 70,
 VtCf: 71,
 VtClsid: 72,
 VtVersionedStream: 73,
 VtBstrBlob: 0xfff,
 VtVector: 0x1000,
 VtArray: 0x2000,
 VtByref: 0x4000,
 VtReserved: 0x8000,
 VtIllegal: 0xffff,
 VtIllegalmasked: 0xfff,
 VtTypemask: 0xfff
});

var TYSPEC = ENUM('TYSPEC', {
 Clsid: 0,
 Fileext: 1,
 Mimetype: 2,
 Filename: 3,
 Progid: 4,
 Packagename: 5,
 Objectid: 6
});

var STORAGE_MEDIA_TYPE = ENUM('STORAGE_MEDIA_TYPE', {
 Dds4mm: 0x20,
 MiniQic: 1,
 Travan: 2,
 Qic: 3,
 Mp8mm: 4,
 Ame8mm: 5,
 Ait18mm: 6,
 Dlt: 7,
 Nctp: 8,
 Ibm3480: 9,
 Ibm3490e: 10,
 IbmMagstar3590: 11,
 IbmMagstarMp: 12,
 StkDataD3: 13,
 SonyDtf: 14,
 Dv6mm: 15,
 Dmi: 16,
 SonyD2: 17,
 CleanerCartridge: 18,
 CdRom: 19,
 CdR: 20,
 CdRw: 21,
 DvdRom: 22,
 DvdR: 23,
 DvdRw: 24,
 Mo3Rw: 25,
 Mo5Wo: 26,
 Mo5Rw: 27,
 Mo5Limdow: 28,
 Pc5Wo: 29,
 Pc5Rw: 30,
 Pd5Rw: 31,
 Abl5Wo: 32,
 PinnacleApex5Rw: 33,
 Sony12Wo: 34,
 Philips12Wo: 35,
 Hitachi12Wo: 36,
 Cygnet12Wo: 37,
 Kodak14Wo: 38,
 MoNfr525: 39,
 Nikon12Rw: 40,
 IomegaZip: 41,
 IomegaJaz: 42,
 SyquestEz135: 43,
 SyquestEzflyer: 44,
 SyquestSyjet: 45,
 AvatarF2: 46,
 Mp28mm: 47,
 DstS: 48,
 DstM: 49,
 DstL: 50,
 VxaTape1: 51,
 VxaTape2: 52,
 Stk9840: 53,
 LtoUltrium: 54,
 LtoAccelis: 55,
 DvdRam: 56,
 Ait8mm: 57,
 Adr1: 58,
 Adr2: 59,
 Stk9940: 60,
 Sait: 61,
 VxaTape: 62
});

var STORAGE_BUS_TYPE = ENUM('STORAGE_BUS_TYPE', {
 Unknown: 0x00,
 Scsi: 1,
 Atapi: 2,
 Ata: 3,
 1394: 4,
 Ssa: 5,
 Fibre: 6,
 Usb: 7,
 Raid: 8,
 TypeiScsi: 9,
 Sas: 10,
 Sata: 11,
 Sd: 12,
 Mmc: 13,
 Virtual: 14,
 FileBackedVirtual: 15,
 Max: 16,
 MaxReserved: 0x7F
});

var STORAGE_QUERY_TYPE = ENUM('STORAGE_QUERY_TYPE', {
 PropertyStandardQuery: 0,
 PropertyExistsQuery: 1,
 PropertyMaskQuery: 2,
 PropertyMaxDefined: 3
});

var STORAGE_PROPERTY_ID = ENUM('STORAGE_PROPERTY_ID', {
 DeviceProperty: 0,
 AdapterProperty: 1,
 DeviceProperty: 2,
 DeviceUniqueProperty: 3,
 DeviceWriteCacheProperty: 4,
 MiniportProperty: 5,
 AccessAlignmentProperty: 6,
 DeviceSeekPenaltyProperty: 7,
 DeviceTrimProperty: 8,
 DeviceWriteAggregationProperty: 9
});

var STORAGE_PORT_CODE_SET = ENUM('STORAGE_PORT_CODE_SET', {
 Reserved: 0,
 Storport: 1,
 ScsIport: 2
});

var STORAGE_IDENTIFIER_CODE_SET = ENUM('STORAGE_IDENTIFIER_CODE_SET', {
 Reserved: 0,
 Binary: 1,
 Ascii: 2,
 Utf8: 3
});

var STORAGE_IDENTIFIER_TYPE = ENUM('STORAGE_IDENTIFIER_TYPE', {
 VendorSpecific: 0,
 VendorId: 1,
 Eui64: 2,
 FcphName: 3,
 PortRelative: 4,
 TargetPortGroup: 5,
 LogicalUnitGroup: 6,
 Md5LogicalUnitIdentifier: 7,
 ScsiNameString: 8
});

var STORAGE_ID_NAA_FORMAT = ENUM('STORAGE_ID_NAA_FORMAT', {
 IeeeExtended: 2,
 IeeeRegistered: 3,
 IeeeeRegisteredExtended: 5
});

var STORAGE_ASSOCIATION_TYPE = ENUM('STORAGE_ASSOCIATION_TYPE', {
 IdDevice: 0,
 IdPort: 1,
 IdTarget: 2
});

var WRITE_CACHE_TYPE = ENUM('WRITE_CACHE_TYPE', {
 Unknown: 0,
 None: 1,
 Back: 2,
 Through: 3
});

var WRITE_CACHE_ENABLE = ENUM('WRITE_CACHE_ENABLE', {
 Unknown: 0,
 Disabled: 1,
 Enabled: 2
});

var WRITE_CACHE_CHANGE = ENUM('WRITE_CACHE_CHANGE', {
 Unknown: 0,
 NotChangeable: 1,
 Changeable: 2
});

var WRITE_THROUGH = ENUM('WRITE_THROUGH', {
 Unknown: 0,
 NotSupported: 1,
 Supported: 2
});

var MEDIA_TYPE = ENUM('MEDIA_TYPE', {
 Unknown: 0,
 F51Pt2512: 1,
 F31Pt44512: 2,
 F32Pt88512: 3,
 F320Pt8512: 4,
 F3720512: 5,
 F5360512: 6,
 F5320512: 7,
 F53201024: 8,
 F5180512: 9,
 F5160512: 10,
 RemovableMedia: 11,
 FixedMedia: 12,
 F3120m512: 13,
 F3640512: 14,
 F5640512: 15,
 F5720512: 16,
 F31Pt2512: 17,
 F31Pt231024: 18,
 F51Pt231024: 19,
 F3128Mb512: 20,
 F3230Mb512: 21,
 F8256128: 22,
 F3200Mb512: 23,
 F3240m512: 24,
 F332m512: 25
});

var PARTITION_STYLE = ENUM('PARTITION_STYLE', {
 Mbr: 0,
 Gpt: 1,
 Raw: 2
});

var DETECTION_TYPE = ENUM('DETECTION_TYPE', {
 None: 0,
 Int13: 1,
 ExInt13: 2
});

var DISK_CACHE_RETENTION_PRIORITY = ENUM('DISK_CACHE_RETENTION_PRIORITY', {
 EqualPriority: 0,
 KeepPrefetchedData: 1,
 KeepReadData: 2
});

var BIN_TYPES = ENUM('BIN_TYPES', {
 RequestSize: 0,
 RequestLocation: 1
});

var ELEMENT_TYPE = ENUM('ELEMENT_TYPE', {
 AllElements: 0,
 ChangerTransport: 1,
 ChangerSlot: 2,
 ChangerIePort: 3,
 ChangerDrive: 4,
 ChangerDoor: 5,
 ChangerKeypad: 6,
 ChangerMaxElement: 7
});

var CHANGER_DEVICE_PROBLEM_TYPE = ENUM('CHANGER_DEVICE_PROBLEM_TYPE', {
 None: 0,
 Hardware: 1,
 ChmError: 2,
 DoorOpen: 3,
 CalibrationError: 4,
 TargetFailure: 5,
 ChmMoveError: 6,
 ChmZeroError: 7,
 CartridgeInsertError: 8,
 PositionError: 9,
 SensorError: 10,
 CartridgeEjectError: 11,
 GripperError: 12,
 DriveError: 13
});

var SHRINK_VOLUME_REQUEST_TYPES = ENUM('SHRINK_VOLUME_REQUEST_TYPES', {
 Prepare: 1,
 Commit: 1,
 Abort: 2
});

var BIDI_TYPE = ENUM('BIDI_TYPE', {
 Null: 0,
 Int: 1,
 Float: 2,
 Bool: 3,
 String: 4,
 Text: 5,
 Enum: 6,
 Blob: 7
});

var PRINTER_OPTION_FLAGS = ENUM('PRINTER_OPTION_FLAGS', {
 NoCache: 0,
 Cache: 1,
 ClientChange: 2,
 NoClientData: 3
});

var EPrintPropertyType = ENUM('EPrintPropertyType', {
 KString: 1,
 K32: 1,
 K64: 2,
 KByte: 3,
 KTime: 4,
 KDevMode: 5,
 KSd: 6,
 KNotificationReply: 7,
 KNotificationOptions: 8,
 KBuffer: 9
});

var EPrintXPSJobProgress = ENUM('EPrintXPSJobProgress', {
 KAddingDocumentSequence: 0,
 KDocumentSequenceAdded: 1,
 KAddingFixedDocument: 2,
 KFixedDocumentAdded: 3,
 KAddingFixedPage: 4,
 KFixedPageAdded: 5,
 KResourceAdded: 6,
 KFontAdded: 7,
 KImageAdded: 8,
 KDocumentCommitted: 9
});

var EPrintXPSJobOperation = ENUM('EPrintXPSJobOperation', {
 KProduction: 1,
 KConsumption: 1
});

var PRINT_EXECUTION_CONTEXT = ENUM('PRINT_EXECUTION_CONTEXT', {
 Application: 0,
 SpoolerService: 1,
 SpoolerIsolationHost: 2,
 FilterPipeline: 3,
 Wow64: 4
});

var REGCLS = ENUM('REGCLS', {
 Singleuse: 0,
 Multipleuse: 1,
 MultiSeparate: 2,
 Suspended: 4,
 Surrogate: 8
});

var EXTCONN = ENUM('EXTCONN', {
 Strong: 0x1,
 Weak: 0x2,
 Callable: 0x4
});

var BIND_FLAGS = ENUM('BIND_FLAGS', {
 Maybotheruser: 1,
 Justtestexistence: 2
});

var MKSYS = ENUM('MKSYS', {
 None: 0,
 Genericcomposite: 1,
 Filemoniker: 2,
 Antimoniker: 3,
 Itemmoniker: 4,
 Pointermoniker: 5,
 Classmoniker: 7,
 Objrefmoniker: 8,
 Sessionmoniker: 9,
 Luamoniker: 10
});

var MKRREDUCE = ENUM('MKRREDUCE', {
 One: 0,
 Touser: 1,
 Throughuser: 2,
 All: 0
});

var STGTY = ENUM('STGTY', {
 Storage: 1,
 Stream: 2,
 Lockbytes: 3,
 Property: 4
});

var STREAM_SEEK = ENUM('STREAM_SEEK', {
 Set: 0,
 Cur: 1,
 End: 2
});

var LOCKTYPE = ENUM('LOCKTYPE', {
 Write: 1,
 Exclusive: 2,
 Onlyonce: 4
});

var ADVF = ENUM('ADVF', {
 Nodata: 1,
 Primefirst: 2,
 Onlyonce: 4,
 Dataonstop: 64,
 AdvfcacheNohandler: 8,
 AdvfcacheForcebuiltin: 16,
 AdvfcacheOnsave: 32
});

var TYMED = ENUM('TYMED', {
 Hglobal: 1,
 File: 2,
 Istream: 4,
 Istorage: 8,
 Gdi: 16,
 Mfpict: 32,
 Enhmf: 64,
 Null: 0
});

var DATADIR = ENUM('DATADIR', {
 Get: 1,
 Set: 2
});

var CALLTYPE = ENUM('CALLTYPE', {
 Toplevel: 1,
 Nested: 2,
 Async: 3,
 ToplevelCallpending: 4,
 AsyncCallpending: 5
});

var SERVERCALL = ENUM('SERVERCALL', {
 Ishandled: 0,
 Rejected: 1,
 Retrylater: 2
});

var PENDINGTYPE = ENUM('PENDINGTYPE', {
 Toplevel: 1,
 Nested: 2
});

var PENDINGMSG = ENUM('PENDINGMSG', {
 Cancelcall: 0,
 Waitnoprocess: 1,
 Waitdefprocess: 2
});

var EOLE_AUTHENTICATION_CAPABILITIES = ENUM('EOLE_AUTHENTICATION_CAPABILITIES', {
 EoacNone: 0,
 EoacMutualAuth: 0x1,
 EoacStaticCloaking: 0x20,
 EoacDynamicCloaking: 0x40,
 EoacAnyAuthority: 0x80,
 EoacMakeFullsic: 0x100,
 EoacDefault: 0x800,
 EoacSecureRefs: 0x2,
 EoacAccessControl: 0x4,
 EoacAppid: 0x8,
 EoacDynamic: 0x10,
 EoacRequireFullsic: 0x200,
 EoacAutoImpersonate: 0x400,
 EoacNoCustomMarshal: 0x2000,
 EoacDisableAaa: 0x1000
});

var RPCOPT_PROPERTIES = ENUM('RPCOPT_PROPERTIES', {
 CombndRpctimeout: 0x1,
 CombndServerLocality: 0x2
});

var RPCOPT_SERVER_LOCALITY_VALUES = ENUM('RPCOPT_SERVER_LOCALITY_VALUES', {
 ProcessLocal: 0,
 MachineLocal: 1,
 Remote: 2
});

var GLOBALOPT_PROPERTIES = ENUM('GLOBALOPT_PROPERTIES', {
 ComglbExceptionHandling: 1,
 ComglbAppid: 2,
 ComglbRpcThreadpoolSetting: 3
});

var GLOBALOPT_EH_VALUES = ENUM('GLOBALOPT_EH_VALUES', {
 ComglbExceptionHandle: 0,
 ComglbExceptionDonotHandleFatal: 1,
 ComglbExceptionDonotHandle: 2,
 ComglbExceptionDonotHandleAny: 2
});

var GLOBALOPT_RPCTP_VALUES = ENUM('GLOBALOPT_RPCTP_VALUES', {
 ComglbThreadpoolSettingDefaultPool: 0,
 ComglbThreadpoolSettingPrivatePool: 1
});

var DCOM_CALL_STATE = ENUM('DCOM_CALL_STATE', {
 None: 0,
 Complete: 0x1,
 Canceled: 0x2
});

var ApplicationType = ENUM('ApplicationType', {
 ServerApplication: 0,
 LibraryApplication: 1
});

var ShutdownType = ENUM('ShutdownType', {
 IdleShutdown: 0,
 ForcedShutdown: 1
});

var APTTYPEQUALIFIER = ENUM('APTTYPEQUALIFIER', {
 None: 0,
 ImplicitMta: 1,
 NaOnMta: 2,
 NaOnSta: 3,
 NaOnImplicitMta: 4,
 NaOnMainsta: 5
});

var APTTYPE = ENUM('APTTYPE', {
 Current: 0,
 Sta: 0,
 Mta: 1,
 Na: 2,
 Mainsta: 3
});

var THDTYPE = ENUM('THDTYPE', {
 Blockmessages: 0,
 Processmessages: 1
});

var COINIT = ENUM('COINIT', {
 Apartmentthreaded: 0x2,
 Multithreaded: 0x0,
 DisableOle1dde: 0x4,
 SpeedOverMemory: 0x8
});

var COMSD = ENUM('COMSD', {
 Launchpermissions: 0,
 Accesspermissions: 1,
 Launchrestrictions: 2,
 Accessrestrictions: 3
});

var STDMSHLFLAGS = ENUM('STDMSHLFLAGS', {
 SmexfServer: 0x01,
 SmexfHandler: 0x02
});

var COWAIT_FLAGS = ENUM('COWAIT_FLAGS', {
 Waitall: 1,
 Alertable: 2,
 Inputavailable: 4
});

var DISCARDCACHE = ENUM('DISCARDCACHE', {
 Saveifdirty: 0,
 Nosave: 1
});

var OLEGETMONIKER = ENUM('OLEGETMONIKER', {
 Onlyifthere: 1,
 Forceassign: 2,
 Unassign: 3,
 Tempforuser: 4
});

var OLEWHICHMK = ENUM('OLEWHICHMK', {
 Container: 1,
 Objrel: 2,
 Objfull: 3
});

var USERCLASSTYPE = ENUM('USERCLASSTYPE', {
 Full: 1,
 Short: 2,
 Appname: 3
});

var OLEMISC = ENUM('OLEMISC', {
 Recomposeonresize: 0x1,
 Onlyiconic: 0x2,
 Insertnotreplace: 0x4,
 Static: 0x8,
 Cantlinkinside: 0x10,
 Canlinkbyole1: 0x20,
 Islinkobject: 0x40,
 Insideout: 0x80,
 Activatewhenvisible: 0x100,
 Renderingisdeviceindependent: 0x200,
 Invisibleatruntime: 0x400,
 Alwaysrun: 0x800,
 Actslikebutton: 0x1000,
 Actslikelabel: 0x2000,
 Nouiactivate: 0x4000,
 Alignable: 0x8000,
 Simpleframe: 0x10000,
 Setclientsitefirst: 0x20000,
 Imemode: 0x40000,
 Ignoreactivatewhenvisible: 0x80000,
 Wantstomenumerge: 0x100000,
 Supportsmultilevelundo: 0x200000
});

var OLECLOSE = ENUM('OLECLOSE', {
 Saveifdirty: 0,
 Nosave: 1,
 Promptsave: 2
});

var OLERENDER = ENUM('OLERENDER', {
 None: 0,
 Draw: 1,
 Format: 2,
 Asis: 3
});

var OLEUPDATE = ENUM('OLEUPDATE', {
 Always: 1,
 Oncall: 3
});

var OLELINKBIND = ENUM('OLELINKBIND', {
 Evenifclassdiff: 1
});

var BINDSPEED = ENUM('BINDSPEED', {
 Indefinite: 1,
 Moderate: 2,
 Immediate: 3
});

var OLECONTF = ENUM('OLECONTF', {
 Embeddings: 1,
 Links: 2,
 Others: 4,
 Onlyuser: 8,
 Onlyifrunning: 16
});

var OLEVERBATTRIB = ENUM('OLEVERBATTRIB', {
 Neverdirties: 1,
 Oncontainermenu: 2
});

var SF_TYPE = ENUM('SF_TYPE', {
 Error: 0,
 I1: 1,
 I2: 2,
 I4: 3,
 I8: 4,
 Bstr: 5,
 Unknown: 6,
 Dispatch: 7,
 Variant: 8,
 Record: 9,
 Haveiid: 10
});

var TYPEKIND = ENUM('TYPEKIND', {
 TkindEnum: 0,
 TkindRecord: 1,
 TkindModule: 2,
 TkindInterface: 3,
 TkindDispatch: 4,
 TkindCoclass: 5,
 TkindAlias: 6,
 TkindUnion: 7,
 TkindMax: 8
});

var CALLCONV = ENUM('CALLCONV', {
 CcFastcall: 0,
 CcCdecl: 1,
 CcMscpascal: 2,
 CcPascal: 3,
 CcMacpascal: 4,
 CcStdcall: 5,
 CcFpfastcall: 6,
 CcSyscall: 7,
 CcMpwcdecl: 8,
 CcMpwpascal: 9,
 CcMax: 10
});

var FUNCKIND = ENUM('FUNCKIND', {
 Virtual: 0,
 Purevirtual: 1,
 Nonvirtual: 2,
 Static: 3,
 Dispatch: 4
});

var INVOKEKIND = ENUM('INVOKEKIND', {
 Func: 1,
 Propertyget: 2,
 Propertyput: 4,
 Propertyputref: 8
});

var VARKIND = ENUM('VARKIND', {
 Perinstance: 0,
 Static: 1,
 Const: 2,
 Dispatch: 3
});

var TYPEFLAGS = ENUM('TYPEFLAGS', {
 Fappobject: 0x1,
 Fcancreate: 0x2,
 Flicensed: 0x4,
 Fpredeclid: 0x8,
 Fhidden: 0x10,
 Fcontrol: 0x20,
 Fdual: 0x40,
 Fnonextensible: 0x80,
 Foleautomation: 0x100,
 Frestricted: 0x200,
 Faggregatable: 0x400,
 Freplaceable: 0x800,
 Fdispatchable: 0x1000,
 Freversebind: 0x2000,
 Fproxy: 0x4000
});

var FUNCFLAGS = ENUM('FUNCFLAGS', {
 Frestricted: 0x1,
 Fsource: 0x2,
 Fbindable: 0x4,
 Frequestedit: 0x8,
 Fdisplaybind: 0x10,
 Fdefaultbind: 0x20,
 Fhidden: 0x40,
 Fusesgetlasterror: 0x80,
 Fdefaultcollelem: 0x100,
 Fuidefault: 0x200,
 Fnonbrowsable: 0x400,
 Freplaceable: 0x800,
 Fimmediatebind: 0x1000
});

var VARFLAGS = ENUM('VARFLAGS', {
 Freadonly: 0x1,
 Fsource: 0x2,
 Fbindable: 0x4,
 Frequestedit: 0x8,
 Fdisplaybind: 0x10,
 Fdefaultbind: 0x20,
 Fhidden: 0x40,
 Frestricted: 0x80,
 Fdefaultcollelem: 0x100,
 Fuidefault: 0x200,
 Fnonbrowsable: 0x400,
 Freplaceable: 0x800,
 Fimmediatebind: 0x1000
});

var DESCKIND = ENUM('DESCKIND', {
 None: 0,
 Funcdesc: 1,
 Vardesc: 2,
 Typecomp: 3,
 Implicitappobj: 4,
 Max: 5
});

var SYSKIND = ENUM('SYSKIND', {
 Win16: 0,
 Win32: 1,
 Mac: 2,
 Win64: 3
});

var LIBFLAGS = ENUM('LIBFLAGS', {
 Frestricted: 0x1,
 Fcontrol: 0x2,
 Fhidden: 0x4,
 Fhasdiskimage: 0x8
});

var CHANGEKIND = ENUM('CHANGEKIND', {
 Addmember: 0,
 Deletemember: 1,
 Setnames: 2,
 Setdocumentation: 3,
 General: 4,
 Invalidate: 5,
 Changefailed: 6,
 Max: 7
});

var DOMNodeType = ENUM('DOMNodeType', {
 Invalid: 0,
 Element: 1,
 Attribute: 2,
 Text: 3,
 CdataSection: 4,
 EntityReference: 5,
 Entity: 6,
 ProcessingInstruction: 7,
 Comment: 8,
 Document: 9,
 DocumentType: 10,
 DocumentFragment: 11,
 Notation: 12
});

var XMLELEM_TYPE = ENUM('XMLELEM_TYPE', {
 Element: 0,
 Text: 1,
 Comment: 2,
 Document: 3,
 Dtd: 4,
 Pi: 5,
 Other: 6
});

var MONIKERPROPERTY = ENUM('MONIKERPROPERTY', {
 Mimetypeprop: 0,
 UseSrcUrl: 0x1,
 Classidprop: 0x2,
 Trusteddownloadprop: 0x3,
 Popuplevelprop: 0x4
});

var BINDVERB = ENUM('BINDVERB', {
 Get: 0,
 Post: 0x1,
 Put: 0x2,
 Custom: 0x3,
 Reserved1: 0x4
});

var BINDINFOF = ENUM('BINDINFOF', {
 Urlencodestgmeddata: 0x1,
 Urlencodedextrainfo: 0x2
});

var BINDF = ENUM('BINDF', {
 Asynchronous: 0x1,
 Asyncstorage: 0x2,
 Noprogressiverendering: 0x4,
 Offlineoperation: 0x8,
 Getnewestversion: 0x10,
 Nowritecache: 0x20,
 Needfile: 0x40,
 Pulldata: 0x80,
 Ignoresecurityproblem: 0x100,
 Resynchronize: 0x200,
 Hyperlink: 0x400,
 NoUi: 0x800,
 Silentoperation: 0x1000,
 PragmaNoCache: 0x2000,
 Getclassobject: 0x4000,
 Reserved1: 0x8000,
 FreeThreaded: 0x10000,
 DirectRead: 0x20000,
 FormsSubmit: 0x40000,
 GetfromcacheIfNetFail: 0x80000,
 Fromurlmon: 0x100000,
 FwdBack: 0x200000,
 Preferdefaulthandler: 0x400000,
 Enforcerestricted: 0x800000
});

var URL_ENCODING = ENUM('URL_ENCODING', {
 None: 0,
 EnableUtf8: 0x10000000,
 DisableUtf8: 0x20000000
});

var BINDINFO_OPTIONS = ENUM('BINDINFO_OPTIONS', {
 Wininetflag: 0x10000,
 EnableUtf8: 0x20000,
 DisableUtf8: 0x40000,
 UseIeEncoding: 0x80000,
 Bindtoobject: 0x100000,
 Securityoptout: 0x200000,
 Ignoremimetextplain: 0x400000,
 Usebindstringcreds: 0x800000,
 Ignorehttphttpsredirects: 0x1000000,
 IgnoreSslerrorsOnce: 0x2000000,
 WpcDownloadblocked: 0x8000000,
 WpcLoggingEnabled: 0x10000000,
 Allowconnectdata: 0x20000000,
 Disableautoredirects: 0x40000000,
 ShdocvwNavigate: 14
});

var BSCF = ENUM('BSCF', {
 Firstdatanotification: 0x1,
 Intermediatedatanotification: 0x2,
 Lastdatanotification: 0x4,
 Datafullyavailable: 0x8,
 Availabledatasizeunknown: 0x10,
 Skipdraindataforfileurls: 0x20,
 64bitlengthdownload: 0x40
});

var BINDSTATUS = ENUM('BINDSTATUS', {
 Findingresource: 1,
 Connecting: 1,
 Redirecting: 2,
 Begindownloaddata: 3,
 Downloadingdata: 4,
 Enddownloaddata: 5,
 Begindownloadcomponents: 6,
 Installingcomponents: 7,
 Enddownloadcomponents: 8,
 Usingcachedcopy: 9,
 Sendingrequest: 10,
 Classidavailable: 11,
 Mimetypeavailable: 12,
 Cachefilenameavailable: 13,
 Beginsyncoperation: 14,
 Endsyncoperation: 15,
 Beginuploaddata: 16,
 Uploadingdata: 17,
 Enduploaddata: 18,
 Protocolclassid: 19,
 Encoding: 20,
 Verifiedmimetypeavailable: 21,
 Classinstalllocation: 22,
 Decoding: 23,
 Loadingmimehandler: 24,
 Contentdispositionattach: 25,
 Filterreportmimetype: 26,
 Clsidcaninstantiate: 27,
 Iunknownavailable: 28,
 Directbind: 29,
 Rawmimetype: 30,
 Proxydetecting: 31,
 Acceptranges: 32,
 CookieSent: 33,
 CompactPolicyReceived: 34,
 CookieSuppressed: 35,
 CookieStateUnknown: 36,
 CookieStateAccept: 37,
 CookieStateReject: 38,
 CookieStatePrompt: 39,
 CookieStateLeash: 40,
 CookieStateDowngrade: 41,
 PolicyHref: 42,
 P3pHeader: 43,
 SessionCookieReceived: 44,
 PersistentCookieReceived: 45,
 SessionCookiesAllowed: 46,
 Cachecontrol: 47,
 Contentdispositionfilename: 48,
 Mimetextplainmismatch: 49,
 Publisheravailable: 50,
 Displaynameavailable: 51,
 SsluxNavblocked: 52,
 ServerMimetypeavailable: 53,
 SniffedClassidavailable: 54,
 64bitProgress: 55
});

var BINDF2 = ENUM('BINDF2', {
 Disablebasicoverhttp: 0x1,
 Disableautocookiehandling: 0x2,
 ReadDataGreaterThan4gb: 0x4,
 DisableHttpRedirectXsecurityid: 0x8,
 Reserved3: 0x20000000,
 Reserved2: 0x40000000,
 Reserved1: 6
});

var AUTHENTICATEF = ENUM('AUTHENTICATEF', {
 Proxy: 0x1,
 Basic: 0x2,
 Http: 0x4
});

var CIP_STATUS = ENUM('CIP_STATUS', {
 DiskFull: 0,
 AccessDenied: 1,
 NewerVersionExists: 2,
 OlderVersionExists: 3,
 NameConflict: 4,
 TrustVerificationComponentMissing: 5,
 ExeSelfRegisterationTimeout: 6,
 UnsafeToAbort: 7,
 NeedReboot: 8,
 NeedRebootUiPermission: 9
});

var Uri_PROPERTY = ENUM('Uri_PROPERTY', {
 AbsoluteUri: 0,
 StringStart: 1,
 Authority: 1,
 DisplayUri: 2,
 Domain: 3,
 Extension: 4,
 Fragment: 5,
 Host: 6,
 Password: 7,
 Path: 8,
 PathAndQuery: 9,
 Query: 10,
 RawUri: 11,
 SchemeName: 12,
 UserInfo: 13,
 UserName: 14,
 StringLast: 16,
 HostType: 15,
 DwordStart: 18,
 Port: 16,
 Scheme: 17,
 Zone: 18,
 DwordLast: 22
});

var Uri_HOST_TYPE = ENUM('Uri_HOST_TYPE', {
 Unknown: 0,
 Dns: 1,
 Ipv4: 2,
 Ipv6: 3,
 Idn: 4
});

var BINDSTRING = ENUM('BINDSTRING', {
 Headers: 1,
 AcceptMimes: 1,
 ExtraUrl: 2,
 Language: 3,
 Username: 4,
 Password: 5,
 UaPixels: 6,
 UaColor: 7,
 Os: 8,
 UserAgent: 9,
 AcceptEncodings: 10,
 PostCookie: 11,
 PostDataMime: 12,
 Url: 13,
 Iid: 14,
 FlagToObject: 15,
 PtrContext: 16,
 XdrOrigin: 17
});

var PI_FLAGS = ENUM('PI_FLAGS', {
 ParseUrl: 0x1,
 FilterMode: 0x2,
 ForceAsync: 0x4,
 UseWorkerthread: 0x8,
 Mimeverification: 0x10,
 Clsidlookup: 0x20,
 Dataprogress: 0x40,
 Synchronous: 0x80,
 Apartmentthreaded: 0x100,
 Classinstall: 0x200,
 Passonbindctx: 0x2000,
 Nomimehandler: 0x8000,
 Loadappdirect: 0x4000,
 PdForceSwitch: 0x10000,
 Preferdefaulthandler: 0x20000
});

var OIBDG_FLAGS = ENUM('OIBDG_FLAGS', {
 Apartmentthreaded: 0x100,
 Dataonly: 0x1000
});

var PARSEACTION = ENUM('PARSEACTION', {
 Canonicalize: 1,
 Friendly: 1,
 SecurityUrl: 2,
 Rootdocument: 3,
 Document: 4,
 Anchor: 5,
 EncodeIsUnescape: 6,
 DecodeIsEscape: 7,
 PathFromUrl: 8,
 UrlFromPath: 9,
 Mime: 10,
 Server: 11,
 Schema: 12,
 Site: 13,
 Domain: 14,
 Location: 15,
 SecurityDomain: 16,
 Escape: 17,
 Unescape: 18
});

var PSUACTION = ENUM('PSUACTION', {
 Default: 1,
 SecurityUrlOnly: 1
});

var QUERYOPTION = ENUM('QUERYOPTION', {
 ExpirationDate: 1,
 TimeOfLastChange: 1,
 ContentEncoding: 2,
 ContentType: 3,
 Refresh: 4,
 Recombine: 5,
 CanNavigate: 6,
 UsesNetwork: 7,
 IsCached: 8,
 IsInstalledentry: 9,
 IsCachedOrMapped: 10,
 UsesCache: 11,
 IsSecure: 12,
 IsSafe: 13,
 UsesHistoryfolder: 14
});

var INTERNETFEATURELIST = ENUM('INTERNETFEATURELIST', {
 ObjectCaching: 0,
 ZoneElevation: 1,
 MimeHandling: 2,
 MimeSniffing: 3,
 WindowRestrictions: 4,
 WebocPopupmanagement: 5,
 Behaviors: 6,
 DisableMkProtocol: 7,
 LocalmachineLockdown: 8,
 Securityband: 9,
 RestrictActivexinstall: 10,
 ValidateNavigateUrl: 11,
 RestrictFiledownload: 12,
 AddonManagement: 13,
 ProtocolLockdown: 14,
 HttpUsernamePasswordDisable: 15,
 SafeBindtoobject: 16,
 UncSavedfilecheck: 17,
 GetUrlDomFilepathUnencoded: 18,
 TabbedBrowsing: 19,
 Sslux: 20,
 DisableNavigationSounds: 21,
 DisableLegacyCompression: 22,
 ForceAddrAndStatus: 23,
 Xmlhttp: 24,
 DisableTelnetProtocol: 25,
 Feeds: 26,
 BlockInputPrompts: 27,
 EntryCount: 28
});

var PUAF = ENUM('PUAF', {
 Default: 0,
 Noui: 0x1,
 Isfile: 0x2,
 WarnIfDenied: 0x4,
 ForceuiForeground: 0x8,
 CheckTifs: 0x10,
 Dontcheckboxindialog: 0x20,
 Trusted: 0x40,
 AcceptWildcardScheme: 0x80,
 Enforcerestricted: 0x100,
 Nosavedfilecheck: 0x200,
 Requiresavedfilecheck: 0x400,
 DontUseCache: 0x1000,
 Reserved1: 0x2000,
 Reserved2: 0x4000,
 LmzUnlocked: 0x10000,
 LmzLocked: 0x20000,
 Defaultzonepol: 0x40000,
 NplUseLockedIfRestricted: 0x80000,
 Nouiiflocked: 0x100000,
 Dragprotocolcheck: 0x200000
});

var PUAFOUT = ENUM('PUAFOUT', {
 Default: 0,
 Islockzonepolicy: 0x1
});

var SZM_FLAGS = ENUM('SZM_FLAGS', {
 Create: 0,
 Delete: 0x1
});

var URLZONE = ENUM('URLZONE', {
 Invalid: 0,
 PredefinedMin: 0,
 LocalMachine: 0,
 Intranet: 3,
 Trusted: 4,
 Internet: 5,
 Untrusted: 6,
 PredefinedMax: 999,
 UserMin: 1000,
 UserMax: 10000
});

var URLTEMPLATE = ENUM('URLTEMPLATE', {
 Custom: 0,
 PredefinedMin: 0x10000,
 Low: 0x10000,
 Medlow: 0x10500,
 Medium: 0x11000,
 Medhigh: 0x11500,
 High: 0x12000,
 PredefinedMax: 0x20000
});

var __MIDL_IInternetZoneManager_0001 = ENUM('__MIDL_IInternetZoneManager_0001', {
 MaxPath: 260,
 MaxDescription: 200
});

var ZAFLAGS = ENUM('ZAFLAGS', {
 CustomEdit: 0x1,
 AddSites: 0x2,
 RequireVerification: 0x4,
 IncludeProxyOverride: 0x8,
 IncludeIntranetSites: 0x10,
 NoUi: 0x20,
 SupportsVerification: 0x40,
 UncAsIntranet: 0x80,
 DetectIntranet: 0x100,
 UseLockedZones: 0x10000,
 VerifyTemplateSettings: 0x20000,
 NoCache: 0x40000
});

var URLZONEREG = ENUM('URLZONEREG', {
 Default: 0,
 Hklm: 1,
 Hkcu: 2
});

var PIDMSI_STATUS_VALUE = ENUM('PIDMSI_STATUS_VALUE', {
 Normal: 0,
 New: 1,
 Prelim: 2,
 Draft: 3,
 Inprogress: 4,
 Edit: 5,
 Review: 6,
 Proof: 7,
 Final: 8,
 Other: 0x7fff
});

var REGKIND = ENUM('REGKIND', {
 Default: 0,
 Register: 1,
 None: 2
});

var SC_ACTION_TYPE = ENUM('SC_ACTION_TYPE', {
 None: 0,
 Restart: 1,
 Reboot: 2,
 RunCommand: 3
});

var SC_STATUS_TYPE = ENUM('SC_STATUS_TYPE', {
 ProcessInfo: 0
});

var SC_ENUM_TYPE = ENUM('SC_ENUM_TYPE', {
 ProcessInfo: 0
});


var PEXCEPTION_ROUTINE = CALLBACK(EXCEPTION_DISPOSITION, [
 PTR(_EXCEPTION_RECORD),
 PTR('void'),
 PTR(_CONTEXT),
 PTR('void')
]);

var PIMAGE_TLS_CALLBACK = CALLBACK('void', [
 PTR('void'),
 ulong,
 PTR('void')
]);

var PRTL_RUN_ONCE_INIT_FN = CALLBACK(ulong, [
 PTR(_RTL_RUN_ONCE),
 PTR('void'),
 PTR(PTR('void'))
]);

var PRTL_UMS_SCHEDULER_ENTRY_POINT = CALLBACK('void', [
 RTL_UMS_SCHEDULER_REASON,
 ulong,
 PTR('void')
]);

var PAPCFUNC = CALLBACK('void', [
 ulong
]);

var PVECTORED_EXCEPTION_HANDLER = CALLBACK(long, [
 PTR(EXCEPTION_POINTERS)
]);

var WAITORTIMERCALLBACKFUNC = CALLBACK('void', [
 PTR('void'),
 uchar
]);

var WORKERCALLBACKFUNC = CALLBACK('void', [
 PTR('void')
]);

var APC_CALLBACK_FUNCTION = CALLBACK('void', [
 ulong,
 PTR('void'),
 PTR('void')
]);

var PFLS_CALLBACK_FUNCTION = CALLBACK('void', [
 PTR('void')
]);

var PSECURE_MEMORY_CACHE_CALLBACK = CALLBACK(uchar, [
 PTR('void'),
 ulong
]);

var PTP_SIMPLE_CALLBACK = CALLBACK('void', [
 PTR(TP_CALLBACK_INSTANCE),
 PTR('void')
]);

var PTP_CLEANUP_GROUP_CANCEL_CALLBACK = CALLBACK('void', [
 PTR('void'),
 PTR('void')
]);

var PTP_WORK_CALLBACK = CALLBACK('void', [
 PTR(TP_CALLBACK_INSTANCE),
 PTR('void'),
 PTR(TP_WORK)
]);

var PTP_TIMER_CALLBACK = CALLBACK('void', [
 PTR(TP_CALLBACK_INSTANCE),
 PTR('void'),
 PTR(TP_TIMER)
]);

var PTP_WAIT_CALLBACK = CALLBACK('void', [
 PTR(TP_CALLBACK_INSTANCE),
 PTR('void'),
 PTR(TP_WAIT),
 ulong
]);

var PTHREAD_START_ROUTINE = CALLBACK(ulong, [
 PTR('void')
]);

var LPTHREAD_START_ROUTINE = CALLBACK(ulong, [
 PTR('void')
]);

var PFIBER_START_ROUTINE = CALLBACK('void', [
 PTR('void')
]);

var LPFIBER_START_ROUTINE = CALLBACK('void', [
 PTR('void')
]);

var PINIT_ONCE_FN = CALLBACK(int, [
 PTR(_RTL_RUN_ONCE),
 PTR('void'),
 PTR(PTR('void'))
]);

var PTOP_LEVEL_EXCEPTION_FILTER = CALLBACK(long, [
 PTR(EXCEPTION_POINTERS)
]);

var LPTOP_LEVEL_EXCEPTION_FILTER = CALLBACK(long, [
 PTR(EXCEPTION_POINTERS)
]);

var PUMS_SCHEDULER_ENTRY_POINT = CALLBACK('void', [
 UMS_SCHEDULER_REASON,
 ulong,
 PTR('void')
]);

var PFE_EXPORT_FUNC = CALLBACK(ulong, [
 PTR(uchar),
 PTR('void'),
 ulong
]);

var PFE_IMPORT_FUNC = CALLBACK(ulong, [
 PTR(uchar),
 PTR('void'),
 PTR(ulong)
]);

var LPOVERLAPPED_COMPLETION_ROUTINE = CALLBACK('void', [
 ulong,
 ulong,
 PTR(OVERLAPPED)
]);

var PTIMERAPCROUTINE = CALLBACK('void', [
 PTR('void'),
 ulong,
 ulong
]);

var PGET_MODULE_HANDLE_EXA = CALLBACK(int, [
 ulong,
 PTR(int8),
 PTR(PTR(HINSTANCE__))
]);

var PGET_MODULE_HANDLE_EXW = CALLBACK(int, [
 ulong,
 PTR(ushort),
 PTR(PTR(HINSTANCE__))
]);

var ENUMRESTYPEPROCA = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(int8),
 long
]);

var ENUMRESTYPEPROCW = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(ushort),
 long
]);

var ENUMRESNAMEPROCA = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(int8),
 PTR(int8),
 long
]);

var ENUMRESNAMEPROCW = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(ushort),
 PTR(ushort),
 long
]);

var ENUMRESLANGPROCA = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(int8),
 PTR(int8),
 ushort,
 long
]);

var ENUMRESLANGPROCW = CALLBACK(int, [
 PTR(HINSTANCE__),
 PTR(ushort),
 PTR(ushort),
 ushort,
 long
]);

var PGET_SYSTEM_WOW64_DIRECTORY_A = CALLBACK(uint, [
 PTR(int8),
 uint
]);

var PGET_SYSTEM_WOW64_DIRECTORY_W = CALLBACK(uint, [
 PTR(ushort),
 uint
]);

var LPPROGRESS_ROUTINE = CALLBACK(ulong, [
 _LARGE_INTEGER,
 _LARGE_INTEGER,
 _LARGE_INTEGER,
 _LARGE_INTEGER,
 ulong,
 ulong,
 PTR('void'),
 PTR('void'),
 PTR('void')
]);

var WAITORTIMERCALLBACK = CALLBACK('void', [
 PTR('void'),
 uchar
]);

var PTP_WIN32_IO_CALLBACK = CALLBACK('void', [
 PTR(TP_CALLBACK_INSTANCE),
 PTR('void'),
 PTR('void'),
 ulong,
 ulong,
 PTR(TP_IO)
]);

var PQUERYACTCTXW_FUNC = CALLBACK(int, [
 ulong,
 PTR('void'),
 PTR('void'),
 ulong,
 PTR('void'),
 ulong,
 PTR(ulong)
]);

var APPLICATION_RECOVERY_CALLBACK = CALLBACK(ulong, [
 PTR('void')
]);

var OLDFONTENUMPROCA = CALLBACK(int, [
 PTR(LOGFONT),
 PTR(TEXTMETRIC),
 ulong,
 long
]);

var OLDFONTENUMPROCW = CALLBACK(int, [
 PTR(LOGFONTW),
 PTR(TEXTMETRICW),
 ulong,
 long
]);

var FONTENUMPROCA = CALLBACK(int, [
 PTR(LOGFONT),
 PTR(TEXTMETRIC),
 ulong,
 long
]);

var FONTENUMPROCW = CALLBACK(int, [
 PTR(LOGFONTW),
 PTR(TEXTMETRICW),
 ulong,
 long
]);

var FONTENUMPROC = CALLBACK(int, [
 PTR(LOGFONT),
 PTR(TEXTMETRIC),
 ulong,
 long
]);

var GOBJENUMPROC = CALLBACK(int, [
 PTR('void'),
 long
]);

var LINEDDAPROC = CALLBACK('void', [
 int,
 int,
 long
]);

var LPFNDEVMODE = CALLBACK(uint, [
 PTR(HWND__),
 PTR(HINSTANCE__),
 PTR(DEVMODE),
 PTR(int8),
 PTR(int8),
 PTR(DEVMODE),
 PTR(int8),
 uint
]);

var LPFNDEVCAPS = CALLBACK(ulong, [
 PTR(int8),
 PTR(int8),
 uint,
 PTR(int8),
 PTR(DEVMODE)
]);

var MFENUMPROC = CALLBACK(int, [
 PTR(HDC__),
 PTR(HANDLETABLE),
 PTR(METARECORD),
 int,
 long
]);

var ENHMFENUMPROC = CALLBACK(int, [
 PTR(HDC__),
 PTR(HANDLETABLE),
 PTR(ENHMETARECORD),
 int,
 long
]);

var ABORTPROC = CALLBACK(int, [
 PTR(HDC__),
 int
]);

var ICMENUMPROCA = CALLBACK(int, [
 PTR(int8),
 long
]);

var ICMENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 long
]);

var WNDPROC = CALLBACK(long, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var DLGPROC = CALLBACK(int, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var TIMERPROC = CALLBACK('void', [
 PTR(HWND__),
 uint,
 uint,
 ulong
]);

var GRAYSTRINGPROC = CALLBACK(int, [
 PTR(HDC__),
 long,
 int
]);

var WNDENUMPROC = CALLBACK(int, [
 PTR(HWND__),
 long
]);

var HOOKPROC = CALLBACK(long, [
 int,
 uint,
 long
]);

var SENDASYNCPROC = CALLBACK('void', [
 PTR(HWND__),
 uint,
 ulong,
 long
]);

var PROPENUMPROCA = CALLBACK(int, [
 PTR(HWND__),
 PTR(int8),
 PTR('void')
]);

var PROPENUMPROCW = CALLBACK(int, [
 PTR(HWND__),
 PTR(ushort),
 PTR('void')
]);

var PROPENUMPROCEXA = CALLBACK(int, [
 PTR(HWND__),
 PTR(int8),
 PTR('void'),
 ulong
]);

var PROPENUMPROCEXW = CALLBACK(int, [
 PTR(HWND__),
 PTR(ushort),
 PTR('void'),
 ulong
]);

var EDITWORDBREAKPROCA = CALLBACK(int, [
 PTR(int8),
 int,
 int,
 int
]);

var EDITWORDBREAKPROCW = CALLBACK(int, [
 PTR(ushort),
 int,
 int,
 int
]);

var DRAWSTATEPROC = CALLBACK(int, [
 PTR(HDC__),
 long,
 uint,
 int,
 int
]);

var PROPENUMPROC = CALLBACK(int, [
 PTR(HWND__),
 PTR(int8),
 PTR('void')
]);

var PROPENUMPROCEX = CALLBACK(int, [
 PTR(HWND__),
 PTR(int8),
 PTR('void'),
 ulong
]);

var EDITWORDBREAKPROC = CALLBACK(int, [
 PTR(int8),
 int,
 int,
 int
]);

var NAMEENUMPROCA = CALLBACK(int, [
 PTR(int8),
 long
]);

var NAMEENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 long
]);

var WINSTAENUMPROCA = CALLBACK(int, [
 PTR(int8),
 long
]);

var DESKTOPENUMPROCA = CALLBACK(int, [
 PTR(int8),
 long
]);

var WINSTAENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 long
]);

var DESKTOPENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 long
]);

var WINSTAENUMPROC = CALLBACK(int, [
 PTR(int8),
 long
]);

var DESKTOPENUMPROC = CALLBACK(int, [
 PTR(int8),
 long
]);

var PREGISTERCLASSNAMEW = CALLBACK(uchar, [
 PTR(ushort)
]);

var MSGBOXCALLBACK = CALLBACK('void', [
 PTR(HELPINFO)
]);

var MONITORENUMPROC = CALLBACK(int, [
 PTR(HMONITOR__),
 PTR(HDC__),
 PTR(RECT),
 long
]);

var WINEVENTPROC = CALLBACK('void', [
 PTR(HWINEVENTHOOK__),
 ulong,
 PTR(HWND__),
 long,
 long,
 ulong,
 ulong
]);

var LANGUAGEGROUP_ENUMPROCA = CALLBACK(int, [
 ulong,
 PTR(int8),
 PTR(int8),
 ulong,
 long
]);

var LANGGROUPLOCALE_ENUMPROCA = CALLBACK(int, [
 ulong,
 ulong,
 PTR(int8),
 long
]);

var UILANGUAGE_ENUMPROCA = CALLBACK(int, [
 PTR(int8),
 long
]);

var LOCALE_ENUMPROCA = CALLBACK(int, [
 PTR(int8)
]);

var CODEPAGE_ENUMPROCA = CALLBACK(int, [
 PTR(int8)
]);

var DATEFMT_ENUMPROCA = CALLBACK(int, [
 PTR(int8)
]);

var DATEFMT_ENUMPROCEXA = CALLBACK(int, [
 PTR(int8),
 ulong
]);

var TIMEFMT_ENUMPROCA = CALLBACK(int, [
 PTR(int8)
]);

var CALINFO_ENUMPROCA = CALLBACK(int, [
 PTR(int8)
]);

var CALINFO_ENUMPROCEXA = CALLBACK(int, [
 PTR(int8),
 ulong
]);

var LANGUAGEGROUP_ENUMPROCW = CALLBACK(int, [
 ulong,
 PTR(ushort),
 PTR(ushort),
 ulong,
 long
]);

var LANGGROUPLOCALE_ENUMPROCW = CALLBACK(int, [
 ulong,
 ulong,
 PTR(ushort),
 long
]);

var UILANGUAGE_ENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 long
]);

var LOCALE_ENUMPROCW = CALLBACK(int, [
 PTR(ushort)
]);

var CODEPAGE_ENUMPROCW = CALLBACK(int, [
 PTR(ushort)
]);

var DATEFMT_ENUMPROCW = CALLBACK(int, [
 PTR(ushort)
]);

var DATEFMT_ENUMPROCEXW = CALLBACK(int, [
 PTR(ushort),
 ulong
]);

var TIMEFMT_ENUMPROCW = CALLBACK(int, [
 PTR(ushort)
]);

var CALINFO_ENUMPROCW = CALLBACK(int, [
 PTR(ushort)
]);

var CALINFO_ENUMPROCEXW = CALLBACK(int, [
 PTR(ushort),
 ulong
]);

var GEO_ENUMPROC = CALLBACK(int, [
 long
]);

var CALINFO_ENUMPROCEXEX = CALLBACK(int, [
 PTR(ushort),
 ulong,
 PTR(ushort),
 long
]);

var DATEFMT_ENUMPROCEXEX = CALLBACK(int, [
 PTR(ushort),
 ulong,
 long
]);

var TIMEFMT_ENUMPROCEX = CALLBACK(int, [
 PTR(ushort),
 long
]);

var LOCALE_ENUMPROCEX = CALLBACK(int, [
 PTR(ushort),
 ulong,
 long
]);

var PHANDLER_ROUTINE = CALLBACK(int, [
 ulong
]);

var PQUERYHANDLER = CALLBACK(ulong, [
 PTR('void'),
 PTR(val_context),
 ulong,
 PTR('void'),
 PTR(ulong),
 ulong
]);

var PFNCALLBACK = CALLBACK(PTR(HDDEDATA__), [
 uint,
 uint,
 PTR(HCONV__),
 PTR(HSZ__),
 PTR(HSZ__),
 PTR(HDDEDATA__),
 ulong,
 ulong
]);

var DRIVERPROC = CALLBACK(long, [
 ulong,
 PTR(HDRVR__),
 uint,
 long,
 long
]);

var LPDRVCALLBACK = CALLBACK('void', [
 PTR(HDRVR__),
 uint,
 ulong,
 ulong,
 ulong
]);

var PDRVCALLBACK = CALLBACK('void', [
 PTR(HDRVR__),
 uint,
 ulong,
 ulong,
 ulong
]);

var LPWAVECALLBACK = CALLBACK('void', [
 PTR(HDRVR__),
 uint,
 ulong,
 ulong,
 ulong
]);

var LPMIDICALLBACK = CALLBACK('void', [
 PTR(HDRVR__),
 uint,
 ulong,
 ulong,
 ulong
]);

var LPTIMECALLBACK = CALLBACK('void', [
 uint,
 uint,
 ulong,
 ulong,
 ulong
]);

var LPMMIOPROC = CALLBACK(long, [
 PTR(int8),
 uint,
 long,
 long
]);

var YIELDPROC = CALLBACK(uint, [
 uint,
 ulong
]);

var RPC_NEW_HTTP_PROXY_CHANNEL = CALLBACK(long, [
 RPC_HTTP_REDIRECTOR_STAGE,
 PTR(ushort),
 PTR(ushort),
 PTR(ushort),
 PTR(ushort),
 PTR('void'),
 PTR('void'),
 PTR('void'),
 PTR('void'),
 ulong,
 PTR(PTR(ushort)),
 PTR(PTR(ushort))
]);

var RPC_HTTP_PROXY_FREE_STRING = CALLBACK('void', [
 PTR(ushort)
]);

var RPC_AUTH_KEY_RETRIEVAL_FN = CALLBACK('void', [
 PTR('void'),
 PTR(ushort),
 ulong,
 PTR(PTR('void')),
 PTR(long)
]);

var RPC_MGMT_AUTHORIZATION_FN = CALLBACK(int, [
 PTR('void'),
 ulong,
 PTR(long)
]);

var RPC_DISPATCH_FUNCTION = CALLBACK('void', [
 PTR(RPC_MESSAGE)
]);

var PRPC_RUNDOWN = CALLBACK('void', [
 PTR('void')
]);

var RPCLT_PDU_FILTER_FUNC = CALLBACK('void', [
 PTR('void'),
 uint,
 int
]);

var RPC_SETFILTER_FUNC = CALLBACK('void', [
 PTR(CALLBACK('void', [PTR('void'), uint, int]))
]);

var RPC_BLOCKING_FN = CALLBACK(long, [
 PTR('void'),
 PTR('void'),
 PTR('void')
]);

var I_RpcProxyIsValidMachineFn = CALLBACK(long, [
 PTR(ushort),
 PTR(ushort),
 ulong
]);

var I_RpcProxyGetClientAddressFn = CALLBACK(long, [
 PTR('void'),
 PTR(int8),
 PTR(ulong)
]);

var I_RpcProxyGetConnectionTimeoutFn = CALLBACK(long, [
 PTR(ulong)
]);

var I_RpcPerformCalloutFn = CALLBACK(long, [
 PTR('void'),
 PTR(RDR_CALLOUT_STATE),
 RPC_HTTP_REDIRECTOR_STAGE
]);

var I_RpcFreeCalloutStateFn = CALLBACK('void', [
 PTR(RDR_CALLOUT_STATE)
]);

var I_RpcProxyGetClientSessionAndResourceUUID = CALLBACK(long, [
 PTR('void'),
 PTR(int),
 PTR(UUID),
 PTR(int),
 PTR(UUID)
]);

var I_RpcProxyFilterIfFn = CALLBACK(long, [
 PTR('void'),
 PTR(UUID),
 ushort,
 PTR(int)
]);

var I_RpcProxyUpdatePerfCounterFn = CALLBACK('void', [
 RpcPerfCounters,
 int,
 ulong
]);

var I_RpcProxyUpdatePerfCounterBackendServerFn = CALLBACK('void', [
 PTR(ushort),
 int
]);

var PFN_RPCNOTIFICATION_ROUTINE = CALLBACK('void', [
 PTR(_RPC_ASYNC_STATE),
 PTR('void'),
 RPC_ASYNC_EVENT
]);

var PFNCANSHAREFOLDERW = CALLBACK(long, [
 PTR(ushort)
]);

var PFNSHOWSHAREFOLDERUIW = CALLBACK(long, [
 PTR(HWND__),
 PTR(ushort)
]);

var PCRYPT_DECRYPT_PRIVATE_KEY_FUNC = CALLBACK(int, [
 CRYPT_ALGORITHM_IDENTIFIER,
 CRYPT_ATTR_BLOB,
 PTR(uchar),
 PTR(ulong),
 PTR('void')
]);

var PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC = CALLBACK(int, [
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(CRYPT_ATTR_BLOB),
 PTR(uchar),
 PTR(ulong),
 PTR('void')
]);

var PCRYPT_RESOLVE_HCRYPTPROV_FUNC = CALLBACK(int, [
 PTR(CRYPT_PRIVATE_KEY_INFO),
 PTR(ulong),
 PTR('void')
]);

var PFN_CRYPT_ALLOC = CALLBACK(PTR('void'), [
 uint
]);

var PFN_CRYPT_FREE = CALLBACK('void', [
 PTR('void')
]);

var PFN_CRYPT_ENUM_OID_FUNC = CALLBACK(int, [
 ulong,
 PTR(int8),
 PTR(int8),
 ulong,
 PTR(ulong),
 PTR(PTR(ushort)),
 PTR(PTR(uchar)),
 PTR(ulong),
 PTR('void')
]);

var PFN_CRYPT_ENUM_OID_INFO = CALLBACK(int, [
 PTR(CCRYPT_OID_INFO),
 PTR('void')
]);

var PFN_CMSG_STREAM_OUTPUT = CALLBACK(int, [
 PTR('void'),
 PTR(uchar),
 ulong,
 int
]);

var PFN_CMSG_ALLOC = CALLBACK(PTR('void'), [
 uint
]);

var PFN_CMSG_FREE = CALLBACK('void', [
 PTR('void')
]);

var PFN_CMSG_GEN_ENCRYPT_KEY = CALLBACK(int, [
 PTR(ulong),
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR('void'),
 PTR(CERT_PUBLIC_KEY_INFO),
 PTR(CALLBACK(PTR('void'), [uint])),
 PTR(ulong),
 PTR(PTR(uchar)),
 PTR(ulong)
]);

var PFN_CMSG_EXPORT_ENCRYPT_KEY = CALLBACK(int, [
 ulong,
 ulong,
 PTR(CERT_PUBLIC_KEY_INFO),
 PTR(uchar),
 PTR(ulong)
]);

var PFN_CMSG_IMPORT_ENCRYPT_KEY = CALLBACK(int, [
 ulong,
 ulong,
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(uchar),
 ulong,
 PTR(ulong)
]);

var PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY = CALLBACK(int, [
 PTR(CMSG_CONTENT_ENCRYPT_INFO),
 ulong,
 PTR('void')
]);

var PFN_CMSG_EXPORT_KEY_TRANS = CALLBACK(int, [
 PTR(CMSG_CONTENT_ENCRYPT_INFO),
 PTR(CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO),
 PTR(CMSG_KEY_TRANS_ENCRYPT_INFO),
 ulong,
 PTR('void')
]);

var PFN_CMSG_EXPORT_KEY_AGREE = CALLBACK(int, [
 PTR(CMSG_CONTENT_ENCRYPT_INFO),
 PTR(CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO),
 PTR(CMSG_KEY_AGREE_ENCRYPT_INFO),
 ulong,
 PTR('void')
]);

var PFN_CMSG_EXPORT_MAIL_LIST = CALLBACK(int, [
 PTR(CMSG_CONTENT_ENCRYPT_INFO),
 PTR(CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO),
 PTR(CMSG_MAIL_LIST_ENCRYPT_INFO),
 ulong,
 PTR('void')
]);

var PFN_CMSG_IMPORT_KEY_TRANS = CALLBACK(int, [
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(CMSG_CTRL_KEY_TRANS_DECRYPT_PARA),
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CMSG_IMPORT_KEY_AGREE = CALLBACK(int, [
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(CMSG_CTRL_KEY_AGREE_DECRYPT_PARA),
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CMSG_IMPORT_MAIL_LIST = CALLBACK(int, [
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(CMSG_CTRL_MAIL_LIST_DECRYPT_PARA),
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CMSG_CNG_IMPORT_KEY_TRANS = CALLBACK(int, [
 PTR(CMSG_CNG_CONTENT_DECRYPT_INFO),
 PTR(CMSG_CTRL_KEY_TRANS_DECRYPT_PARA),
 ulong,
 PTR('void')
]);

var PFN_CMSG_CNG_IMPORT_KEY_AGREE = CALLBACK(int, [
 PTR(CMSG_CNG_CONTENT_DECRYPT_INFO),
 PTR(CMSG_CTRL_KEY_AGREE_DECRYPT_PARA),
 ulong,
 PTR('void')
]);

var PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY = CALLBACK(int, [
 PTR(CMSG_CNG_CONTENT_DECRYPT_INFO),
 ulong,
 PTR('void')
]);

var PFN_CERT_DLL_OPEN_STORE_PROV_FUNC = CALLBACK(int, [
 PTR(int8),
 ulong,
 ulong,
 ulong,
 PTR('void'),
 PTR('void'),
 PTR(CERT_STORE_PROV_INFO)
]);

var PFN_CERT_STORE_PROV_CLOSE = CALLBACK('void', [
 PTR('void'),
 ulong
]);

var PFN_CERT_STORE_PROV_READ_CERT = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 ulong,
 PTR(PTR(CERT_CONTEXT))
]);

var PFN_CERT_STORE_PROV_WRITE_CERT = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_DELETE_CERT = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_SET_CERT_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 ulong,
 ulong,
 PTR('void')
]);

var PFN_CERT_STORE_PROV_READ_CRL = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 ulong,
 PTR(PTR(CRL_CONTEXT))
]);

var PFN_CERT_STORE_PROV_WRITE_CRL = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_DELETE_CRL = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_SET_CRL_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 ulong,
 ulong,
 PTR('void')
]);

var PFN_CERT_STORE_PROV_READ_CTL = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 ulong,
 PTR(PTR(CTL_CONTEXT))
]);

var PFN_CERT_STORE_PROV_WRITE_CTL = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_DELETE_CTL = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 ulong
]);

var PFN_CERT_STORE_PROV_SET_CTL_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 ulong,
 ulong,
 PTR('void')
]);

var PFN_CERT_STORE_PROV_CONTROL = CALLBACK(int, [
 PTR('void'),
 ulong,
 ulong,
 PTR('void')
]);

var PFN_CERT_STORE_PROV_FIND_CERT = CALLBACK(int, [
 PTR('void'),
 PTR(CCERT_STORE_PROV_FIND_INFO),
 PTR(CERT_CONTEXT),
 ulong,
 PTR(PTR('void')),
 PTR(PTR(CERT_CONTEXT))
]);

var PFN_CERT_STORE_PROV_FREE_FIND_CERT = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 PTR('void'),
 ulong
]);

var PFN_CERT_STORE_PROV_GET_CERT_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CERT_CONTEXT),
 ulong,
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CERT_STORE_PROV_FIND_CRL = CALLBACK(int, [
 PTR('void'),
 PTR(CCERT_STORE_PROV_FIND_INFO),
 PTR(CRL_CONTEXT),
 ulong,
 PTR(PTR('void')),
 PTR(PTR(CRL_CONTEXT))
]);

var PFN_CERT_STORE_PROV_FREE_FIND_CRL = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 PTR('void'),
 ulong
]);

var PFN_CERT_STORE_PROV_GET_CRL_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CRL_CONTEXT),
 ulong,
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CERT_STORE_PROV_FIND_CTL = CALLBACK(int, [
 PTR('void'),
 PTR(CCERT_STORE_PROV_FIND_INFO),
 PTR(CTL_CONTEXT),
 ulong,
 PTR(PTR('void')),
 PTR(PTR(CTL_CONTEXT))
]);

var PFN_CERT_STORE_PROV_FREE_FIND_CTL = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 PTR('void'),
 ulong
]);

var PFN_CERT_STORE_PROV_GET_CTL_PROPERTY = CALLBACK(int, [
 PTR('void'),
 PTR(CTL_CONTEXT),
 ulong,
 ulong,
 PTR('void'),
 PTR(ulong)
]);

var PFN_CERT_CREATE_CONTEXT_SORT_FUNC = CALLBACK(int, [
 ulong,
 ulong,
 ulong,
 PTR('void')
]);

var PFN_CERT_ENUM_SYSTEM_STORE_LOCATION = CALLBACK(int, [
 PTR(ushort),
 ulong,
 PTR('void'),
 PTR('void')
]);

var PFN_CERT_ENUM_SYSTEM_STORE = CALLBACK(int, [
 PTR('void'),
 ulong,
 PTR(CERT_SYSTEM_STORE_INFO),
 PTR('void'),
 PTR('void')
]);

var PFN_CERT_ENUM_PHYSICAL_STORE = CALLBACK(int, [
 PTR('void'),
 ulong,
 PTR(ushort),
 PTR(CERT_PHYSICAL_STORE_INFO),
 PTR('void'),
 PTR('void')
]);

var PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC = CALLBACK(int, [
 ulong,
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR(PTR('void')),
 PTR(PTR(ushort))
]);

var PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC = CALLBACK(int, [
 ulong,
 ulong,
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR('void'),
 PTR(ushort),
 PTR(ushort),
 PTR(uchar),
 ulong,
 PTR(uchar),
 PTR(ulong)
]);

var PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC = CALLBACK(int, [
 ulong,
 PTR(CERT_PUBLIC_KEY_INFO),
 PTR(CRYPT_ALGORITHM_IDENTIFIER),
 PTR('void'),
 PTR(ushort),
 PTR(ushort),
 PTR(uchar),
 ulong,
 PTR(uchar),
 ulong
]);

var PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC = CALLBACK(int, [
 ulong,
 ulong,
 PTR(int8),
 ulong,
 PTR('void'),
 PTR(CERT_PUBLIC_KEY_INFO),
 PTR(ulong)
]);

var PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC = CALLBACK(int, [
 PTR('void'),
 ulong,
 PTR(int8),
 ulong,
 PTR('void'),
 PTR(CERT_PUBLIC_KEY_INFO),
 PTR(ulong)
]);

var PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC = CALLBACK(int, [
 ulong,
 PTR(CERT_PUBLIC_KEY_INFO),
 ulong,
 PTR('void'),
 PTR(PTR('void'))
]);

var PFN_IMPORT_PRIV_KEY_FUNC = CALLBACK(int, [
 ulong,
 PTR(CRYPT_PRIVATE_KEY_INFO),
 ulong,
 PTR('void')
]);

var PFN_EXPORT_PRIV_KEY_FUNC = CALLBACK(int, [
 ulong,
 ulong,
 PTR(int8),
 ulong,
 PTR('void'),
 PTR(CRYPT_PRIVATE_KEY_INFO),
 PTR(ulong)
]);

var PFN_CRYPT_GET_SIGNER_CERTIFICATE = CALLBACK(PTR(CERT_CONTEXT), [
 PTR('void'),
 ulong,
 PTR(CERT_INFO),
 PTR('void')
]);

var PFN_CRYPT_ASYNC_PARAM_FREE_FUNC = CALLBACK('void', [
 PTR(int8),
 PTR('void')
]);

var PFN_FREE_ENCODED_OBJECT_FUNC = CALLBACK('void', [
 PTR(int8),
 PTR(CRYPT_BLOB_ARRAY),
 PTR('void')
]);

var PFN_CRYPT_CANCEL_RETRIEVAL = CALLBACK(int, [
 ulong,
 PTR('void')
]);

var PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC = CALLBACK('void', [
 PTR('void'),
 ulong,
 PTR(int8),
 PTR(int8),
 PTR('void')
]);

var PFN_CANCEL_ASYNC_RETRIEVAL_FUNC = CALLBACK(int, [
 PTR('void')
]);

var PFN_CRYPT_ENUM_KEYID_PROP = CALLBACK(int, [
 PTR(CRYPT_ATTR_BLOB),
 ulong,
 PTR('void'),
 PTR('void'),
 ulong,
 PTR(ulong),
 PTR(PTR('void')),
 PTR(ulong)
]);

var PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK = CALLBACK(int, [
 PTR(CERT_CONTEXT),
 PTR('void')
]);

var NDR_RUNDOWN = CALLBACK('void', [
 PTR('void')
]);

var NDR_NOTIFY_ROUTINE = CALLBACK('void', [
 
]);

var NDR_NOTIFY2_ROUTINE = CALLBACK('void', [
 uchar
]);

var EXPR_EVAL = CALLBACK('void', [
 PTR(_MIDL_STUB_MESSAGE)
]);

var GENERIC_BINDING_ROUTINE = CALLBACK(PTR('void'), [
 PTR('void')
]);

var GENERIC_UNBIND_ROUTINE = CALLBACK('void', [
 PTR('void'),
 PTR(uchar)
]);

var XMIT_HELPER_ROUTINE = CALLBACK('void', [
 PTR(MIDL_STUB_MESSAGE)
]);

var USER_MARSHAL_SIZING_ROUTINE = CALLBACK(ulong, [
 PTR(ulong),
 ulong,
 PTR('void')
]);

var USER_MARSHAL_MARSHALLING_ROUTINE = CALLBACK(PTR(uchar), [
 PTR(ulong),
 PTR(uchar),
 PTR('void')
]);

var USER_MARSHAL_UNMARSHALLING_ROUTINE = CALLBACK(PTR(uchar), [
 PTR(ulong),
 PTR(uchar),
 PTR('void')
]);

var USER_MARSHAL_FREEING_ROUTINE = CALLBACK('void', [
 PTR(ulong),
 PTR('void')
]);

var CS_TYPE_NET_SIZE_ROUTINE = CALLBACK('void', [
 PTR('void'),
 ulong,
 ulong,
 PTR(IDL_CS_CONVERT),
 PTR(ulong),
 PTR(ulong)
]);

var CS_TYPE_LOCAL_SIZE_ROUTINE = CALLBACK('void', [
 PTR('void'),
 ulong,
 ulong,
 PTR(IDL_CS_CONVERT),
 PTR(ulong),
 PTR(ulong)
]);

var CS_TYPE_TO_NETCS_ROUTINE = CALLBACK('void', [
 PTR('void'),
 ulong,
 PTR('void'),
 ulong,
 PTR(uchar),
 PTR(ulong),
 PTR(ulong)
]);

var CS_TYPE_FROM_NETCS_ROUTINE = CALLBACK('void', [
 PTR('void'),
 ulong,
 PTR(uchar),
 ulong,
 ulong,
 PTR('void'),
 PTR(ulong),
 PTR(ulong)
]);

var CS_TAG_GETTING_ROUTINE = CALLBACK('void', [
 PTR('void'),
 int,
 PTR(ulong),
 PTR(ulong),
 PTR(ulong),
 PTR(ulong)
]);

var STUB_THUNK = CALLBACK('void', [
 PTR(MIDL_STUB_MESSAGE)
]);

var LPOCNCONNPROCA = CALLBACK(ulong, [
 ulong,
 PTR(int8),
 PTR(int8),
 PTR('void')
]);

var LPOCNCONNPROCW = CALLBACK(ulong, [
 ulong,
 PTR(ushort),
 PTR(ushort),
 PTR('void')
]);

var LPOCNCHKPROC = CALLBACK(int, [
 ulong,
 ulong,
 PTR('void')
]);

var LPOCNDSCPROC = CALLBACK('void', [
 ulong,
 ulong,
 PTR('void')
]);

var LPFNPSPCALLBACKA = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 PTR(_PROPSHEETPAGEA)
]);

var LPFNPSPCALLBACKW = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 PTR(_PROPSHEETPAGEW)
]);

var PFNPROPSHEETCALLBACK = CALLBACK(int, [
 PTR(HWND__),
 uint,
 long
]);

var LPFNADDPROPSHEETPAGE = CALLBACK(int, [
 PTR(_PSP),
 long
]);

var LPFNADDPROPSHEETPAGES = CALLBACK(int, [
 PTR('void'),
 PTR(CALLBACK(int, [PTR(_PSP), long])),
 long
]);

var _onexit_t = CALLBACK(int, [
 
]);

var _purecall_handler = CALLBACK('void', [
 
]);

var _invalid_parameter_handler = CALLBACK('void', [
 PTR(ushort),
 PTR(ushort),
 PTR(ushort),
 uint,
 uint
]);

var LPFNGETCLASSOBJECT = CALLBACK(long, [
 PTR(UUID),
 PTR(UUID),
 PTR(PTR('void'))
]);

var LPFNCANUNLOADNOW = CALLBACK(long, [
 
]);

var LPOFNHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPCCHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPFRHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPCFHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPPRINTHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPSETUPHOOKPROC = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPPAGEPAINTHOOK = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPPAGESETUPHOOK = CALLBACK(uint, [
 PTR(HWND__),
 uint,
 uint,
 long
]);

var LPSERVICE_MAIN_FUNCTIONW = CALLBACK('void', [
 ulong,
 PTR(PTR(ushort))
]);

var LPSERVICE_MAIN_FUNCTIONA = CALLBACK('void', [
 ulong,
 PTR(PTR(int8))
]);

var LPHANDLER_FUNCTION = CALLBACK('void', [
 ulong
]);

var LPHANDLER_FUNCTION_EX = CALLBACK(ulong, [
 ulong,
 ulong,
 PTR('void'),
 PTR('void')
]);

var PFN_SC_NOTIFY_CALLBACK = CALLBACK('void', [
 PTR('void')
]);

var IMCENUMPROC = CALLBACK(int, [
 PTR(HIMC__),
 long
]);

var REGISTERWORDENUMPROCA = CALLBACK(int, [
 PTR(int8),
 ulong,
 PTR(int8),
 PTR('void')
]);

var REGISTERWORDENUMPROCW = CALLBACK(int, [
 PTR(ushort),
 ulong,
 PTR(ushort),
 PTR('void')
]);


var threadlocinfo = STRUCT('threadlocinfo', {
 refcount: int,
 lc_codepage: uint,
 lc_collate_cp: uint,
 lc_handle: pointer,
 lc_id: pointer,
 lc_category: pointer,
 lc_clike: int,
 mb_cur_max: int,
 lconv_intl_refcount: PTR(int),
 lconv_num_refcount: PTR(int),
 lconv_mon_refcount: PTR(int),
 lconv: PTR(lconv),
 ctype1_refcount: PTR(int),
 ctype1: PTR(ushort),
 pctype: PTR(ushort),
 pclmap: PTR(uchar),
 pcumap: PTR(uchar),
 lc_time_curr: PTR(__lc_time_data)
});



var _locale_tstruct = STRUCT('_locale_tstruct', {
 locinfo: pthreadlocinfo,
 mbcinfo: pthreadmbcinfo
});

var LC_ID = STRUCT('LC_ID', {
 wLanguage: ushort,
 wCountry: ushort,
 wCodePage: ushort
});

var undefined = STRUCT('undefined', {
 locale: PTR(int8),
 wlocale: PTR(ushort),
 refcount: PTR(int),
 wrefcount: PTR(int)
});


var EXCEPTION_RECORD = STRUCT('EXCEPTION_RECORD', {
 ExceptionCode: DWORD,
 ExceptionFlags: DWORD,
 ExceptionRecord: PTR(_EXCEPTION_RECORD),
 ExceptionAddress: PVOID,
 NumberParameters: DWORD,
 ExceptionInformation: pointer
});

var CONTEXT = STRUCT('CONTEXT', {
 ContextFlags: DWORD,
 Dr0: DWORD,
 Dr1: DWORD,
 Dr2: DWORD,
 Dr3: DWORD,
 Dr6: DWORD,
 Dr7: DWORD,
 FloatSave: FLOATING_SAVE_AREA,
 SegGs: DWORD,
 SegFs: DWORD,
 SegEs: DWORD,
 SegDs: DWORD,
 Edi: DWORD,
 Esi: DWORD,
 Ebx: DWORD,
 Edx: DWORD,
 Ecx: DWORD,
 Eax: DWORD,
 Ebp: DWORD,
 Eip: DWORD,
 SegCs: DWORD,
 EFlags: DWORD,
 Esp: DWORD,
 SegSs: DWORD,
 ExtendedRegisters: pointer
});

var PROCESSOR_NUMBER = STRUCT('PROCESSOR_NUMBER', {
 Group: WORD,
 Number: BYTE,
 Reserved: BYTE
});

var GROUP_AFFINITY = STRUCT('GROUP_AFFINITY', {
 Mask: KAFFINITY,
 Group: WORD,
 Reserved: pointer
});

var FLOAT128 = STRUCT('FLOAT128', {
 LowPart: longlong,
 HighPart: longlong
});

var undefined = STRUCT('undefined', {
 LowPart: DWORD,
 HighPart: LONG
});

var undefined = STRUCT('undefined', {
 LowPart: DWORD,
 HighPart: LONG
});

var undefined = STRUCT('undefined', {
 LowPart: DWORD,
 HighPart: DWORD
});

var undefined = STRUCT('undefined', {
 LowPart: DWORD,
 HighPart: DWORD
});

var LUID = STRUCT('LUID', {
 LowPart: DWORD,
 HighPart: LONG
});

var LIST_ENTRY = STRUCT('LIST_ENTRY', {
 Flink: PTR(_LIST_ENTRY),
 Blink: PTR(_LIST_ENTRY)
});

var SLIST_ENTRY32 = STRUCT('SLIST_ENTRY32', {
 Next: PTR(_SINGLE_LIST_ENTRY)
});

var LIST_ENTRY32 = STRUCT('LIST_ENTRY32', {
 Flink: DWORD,
 Blink: DWORD
});

var LIST_ENTRY64 = STRUCT('LIST_ENTRY64', {
 Flink: ULONGLONG,
 Blink: ULONGLONG
});

var UUID = STRUCT('UUID', {
 Data1: ulong,
 Data2: ushort,
 Data3: ushort,
 Data4: pointer
});

var OBJECTID = STRUCT('OBJECTID', {
 Lineage: GUID,
 Uniquifier: DWORD
});

var M128A = STRUCT('M128A', {
 Low: ULONGLONG,
 High: LONGLONG
});

var XSAVE_FORMAT = STRUCT('XSAVE_FORMAT', {
 ControlWord: WORD,
 StatusWord: WORD,
 TagWord: BYTE,
 Reserved1: BYTE,
 ErrorOpcode: WORD,
 ErrorOffset: DWORD,
 ErrorSelector: WORD,
 Reserved2: WORD,
 DataOffset: DWORD,
 DataSelector: WORD,
 Reserved3: WORD,
 MxCsr: DWORD,
 MxCsr_Mask: DWORD,
 FloatRegisters: pointer,
 XmmRegisters: pointer,
 Reserved4: pointer,
 StackControl: pointer,
 Cr0NpxState: DWORD
});

var XSAVE_AREA_HEADER = STRUCT('XSAVE_AREA_HEADER', {
 Mask: DWORD64,
 Reserved: pointer
});

var XSAVE_AREA = STRUCT('XSAVE_AREA', {
 LegacyState: XSAVE_FORMAT,
 Header: XSAVE_AREA_HEADER
});

var XSTATE_CONTEXT = STRUCT('XSTATE_CONTEXT', {
 Mask: DWORD64,
 Length: DWORD,
 Reserved1: DWORD,
 Area: PXSAVE_AREA,
 Reserved2: DWORD,
 Buffer: PVOID,
 Reserved3: DWORD
});

var CONTEXT_CHUNK = STRUCT('CONTEXT_CHUNK', {
 Offset: LONG,
 Length: DWORD
});

var CONTEXT_EX = STRUCT('CONTEXT_EX', {
 All: CONTEXT_CHUNK,
 Legacy: CONTEXT_CHUNK,
 XState: CONTEXT_CHUNK
});

var FLOATING_SAVE_AREA = STRUCT('FLOATING_SAVE_AREA', {
 ControlWord: DWORD,
 StatusWord: DWORD,
 TagWord: DWORD,
 ErrorOffset: DWORD,
 ErrorSelector: DWORD,
 DataOffset: DWORD,
 DataSelector: DWORD,
 RegisterArea: pointer,
 Cr0NpxState: DWORD
});

var LDT_ENTRY = STRUCT('LDT_ENTRY', {
 LimitLow: WORD,
 BaseLow: WORD,
 HighWord: 
});

var undefined = STRUCT('undefined', {
 BaseMid: BYTE,
 Flags1: BYTE,
 Flags2: BYTE,
 BaseHi: BYTE
});

var undefined = STRUCT('undefined', {
 BaseMid: DWORD,
 Type: DWORD,
 Dpl: DWORD,
 Pres: DWORD,
 LimitHi: DWORD,
 Sys: DWORD,
 Reserved_0: DWORD,
 Default_Big: DWORD,
 Granularity: DWORD,
 BaseHi: DWORD
});

var WOW64_FLOATING_SAVE_AREA = STRUCT('WOW64_FLOATING_SAVE_AREA', {
 ControlWord: DWORD,
 StatusWord: DWORD,
 TagWord: DWORD,
 ErrorOffset: DWORD,
 ErrorSelector: DWORD,
 DataOffset: DWORD,
 DataSelector: DWORD,
 RegisterArea: pointer,
 Cr0NpxState: DWORD
});

var WOW64_CONTEXT = STRUCT('WOW64_CONTEXT', {
 ContextFlags: DWORD,
 Dr0: DWORD,
 Dr1: DWORD,
 Dr2: DWORD,
 Dr3: DWORD,
 Dr6: DWORD,
 Dr7: DWORD,
 FloatSave: WOW64_FLOATING_SAVE_AREA,
 SegGs: DWORD,
 SegFs: DWORD,
 SegEs: DWORD,
 SegDs: DWORD,
 Edi: DWORD,
 Esi: DWORD,
 Ebx: DWORD,
 Edx: DWORD,
 Ecx: DWORD,
 Eax: DWORD,
 Ebp: DWORD,
 Eip: DWORD,
 SegCs: DWORD,
 EFlags: DWORD,
 Esp: DWORD,
 SegSs: DWORD,
 ExtendedRegisters: pointer
});

var WOW64_LDT_ENTRY = STRUCT('WOW64_LDT_ENTRY', {
 LimitLow: WORD,
 BaseLow: WORD,
 HighWord: 
});

var undefined = STRUCT('undefined', {
 BaseMid: BYTE,
 Flags1: BYTE,
 Flags2: BYTE,
 BaseHi: BYTE
});

var undefined = STRUCT('undefined', {
 BaseMid: DWORD,
 Type: DWORD,
 Dpl: DWORD,
 Pres: DWORD,
 LimitHi: DWORD,
 Sys: DWORD,
 Reserved_0: DWORD,
 Default_Big: DWORD,
 Granularity: DWORD,
 BaseHi: DWORD
});

var WOW64_DESCRIPTOR_TABLE_ENTRY = STRUCT('WOW64_DESCRIPTOR_TABLE_ENTRY', {
 Selector: DWORD,
 Descriptor: WOW64_LDT_ENTRY
});

var EXCEPTION_RECORD32 = STRUCT('EXCEPTION_RECORD32', {
 ExceptionCode: DWORD,
 ExceptionFlags: DWORD,
 ExceptionRecord: DWORD,
 ExceptionAddress: DWORD,
 NumberParameters: DWORD,
 ExceptionInformation: pointer
});

var EXCEPTION_RECORD64 = STRUCT('EXCEPTION_RECORD64', {
 ExceptionCode: DWORD,
 ExceptionFlags: DWORD,
 ExceptionRecord: DWORD64,
 ExceptionAddress: DWORD64,
 NumberParameters: DWORD,
 __unusedAlignment: DWORD,
 ExceptionInformation: pointer
});

var EXCEPTION_POINTERS = STRUCT('EXCEPTION_POINTERS', {
 ExceptionRecord: PEXCEPTION_RECORD,
 ContextRecord: PCONTEXT
});

var GENERIC_MAPPING = STRUCT('GENERIC_MAPPING', {
 GenericRead: ACCESS_MASK,
 GenericWrite: ACCESS_MASK,
 GenericExecute: ACCESS_MASK,
 GenericAll: ACCESS_MASK
});

var LUID_AND_ATTRIBUTES = STRUCT('LUID_AND_ATTRIBUTES', {
 Luid: LUID,
 Attributes: DWORD
});

var SID_IDENTIFIER_AUTHORITY = STRUCT('SID_IDENTIFIER_AUTHORITY', {
 Value: pointer
});

var SID = STRUCT('SID', {
 Revision: BYTE,
 SubAuthorityCount: BYTE,
 IdentifierAuthority: SID_IDENTIFIER_AUTHORITY,
 SubAuthority: pointer
});

var SID_AND_ATTRIBUTES = STRUCT('SID_AND_ATTRIBUTES', {
 Sid: PSID,
 Attributes: DWORD
});

var SID_AND_ATTRIBUTES_HASH = STRUCT('SID_AND_ATTRIBUTES_HASH', {
 SidCount: DWORD,
 SidAttr: PSID_AND_ATTRIBUTES,
 Hash: pointer
});

var ACL = STRUCT('ACL', {
 AclRevision: BYTE,
 Sbz1: BYTE,
 AclSize: WORD,
 AceCount: WORD,
 Sbz2: WORD
});

var ACE_HEADER = STRUCT('ACE_HEADER', {
 AceType: BYTE,
 AceFlags: BYTE,
 AceSize: WORD
});

var ACCESS_ALLOWED_ACE = STRUCT('ACCESS_ALLOWED_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var ACCESS_DENIED_ACE = STRUCT('ACCESS_DENIED_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var SYSTEM_AUDIT_ACE = STRUCT('SYSTEM_AUDIT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var SYSTEM_ALARM_ACE = STRUCT('SYSTEM_ALARM_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var SYSTEM_MANDATORY_LABEL_ACE = STRUCT('SYSTEM_MANDATORY_LABEL_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var ACCESS_ALLOWED_OBJECT_ACE = STRUCT('ACCESS_ALLOWED_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var ACCESS_DENIED_OBJECT_ACE = STRUCT('ACCESS_DENIED_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var SYSTEM_AUDIT_OBJECT_ACE = STRUCT('SYSTEM_AUDIT_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var SYSTEM_ALARM_OBJECT_ACE = STRUCT('SYSTEM_ALARM_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var ACCESS_ALLOWED_CALLBACK_ACE = STRUCT('ACCESS_ALLOWED_CALLBACK_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var ACCESS_DENIED_CALLBACK_ACE = STRUCT('ACCESS_DENIED_CALLBACK_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var SYSTEM_AUDIT_CALLBACK_ACE = STRUCT('SYSTEM_AUDIT_CALLBACK_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var SYSTEM_ALARM_CALLBACK_ACE = STRUCT('SYSTEM_ALARM_CALLBACK_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 SidStart: DWORD
});

var ACCESS_ALLOWED_CALLBACK_OBJECT_ACE = STRUCT('ACCESS_ALLOWED_CALLBACK_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var ACCESS_DENIED_CALLBACK_OBJECT_ACE = STRUCT('ACCESS_DENIED_CALLBACK_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var SYSTEM_AUDIT_CALLBACK_OBJECT_ACE = STRUCT('SYSTEM_AUDIT_CALLBACK_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var SYSTEM_ALARM_CALLBACK_OBJECT_ACE = STRUCT('SYSTEM_ALARM_CALLBACK_OBJECT_ACE', {
 Header: ACE_HEADER,
 Mask: ACCESS_MASK,
 Flags: DWORD,
 ObjectType: GUID,
 InheritedObjectType: GUID,
 SidStart: DWORD
});

var ACL_REVISION_INFORMATION = STRUCT('ACL_REVISION_INFORMATION', {
 AclRevision: DWORD
});

var ACL_SIZE_INFORMATION = STRUCT('ACL_SIZE_INFORMATION', {
 AceCount: DWORD,
 AclBytesInUse: DWORD,
 AclBytesFree: DWORD
});

var SECURITY_DESCRIPTOR_RELATIVE = STRUCT('SECURITY_DESCRIPTOR_RELATIVE', {
 Revision: BYTE,
 Sbz1: BYTE,
 Control: SECURITY_DESCRIPTOR_CONTROL,
 Owner: DWORD,
 Group: DWORD,
 Sacl: DWORD,
 Dacl: DWORD
});

var SECURITY_DESCRIPTOR = STRUCT('SECURITY_DESCRIPTOR', {
 Revision: BYTE,
 Sbz1: BYTE,
 Control: SECURITY_DESCRIPTOR_CONTROL,
 Owner: PSID,
 Group: PSID,
 Sacl: PACL,
 Dacl: PACL
});

var OBJECT_TYPE_LIST = STRUCT('OBJECT_TYPE_LIST', {
 Level: WORD,
 Sbz: WORD,
 ObjectType: PTR(uint)
});

var PRIVILEGE_SET = STRUCT('PRIVILEGE_SET', {
 PrivilegeCount: DWORD,
 Control: DWORD,
 Privilege: pointer
});

var ACCESS_REASONS = STRUCT('ACCESS_REASONS', {
 Data: pointer
});

var SE_SECURITY_DESCRIPTOR = STRUCT('SE_SECURITY_DESCRIPTOR', {
 Size: DWORD,
 Flags: DWORD,
 SecurityDescriptor: PSECURITY_DESCRIPTOR
});

var SE_ACCESS_REQUEST = STRUCT('SE_ACCESS_REQUEST', {
 Size: DWORD,
 SeSecurityDescriptor: PSE_SECURITY_DESCRIPTOR,
 DesiredAccess: ACCESS_MASK,
 PreviouslyGrantedAccess: ACCESS_MASK,
 PrincipalSelfSid: PSID,
 GenericMapping: PGENERIC_MAPPING,
 ObjectTypeListCount: DWORD,
 ObjectTypeList: POBJECT_TYPE_LIST
});

var SE_ACCESS_REPLY = STRUCT('SE_ACCESS_REPLY', {
 Size: DWORD,
 ResultListCount: DWORD,
 GrantedAccess: PACCESS_MASK,
 AccessStatus: PDWORD,
 AccessReason: PACCESS_REASONS,
 Privileges: PTR(pointer)
});

var TOKEN_USER = STRUCT('TOKEN_USER', {
 User: SID_AND_ATTRIBUTES
});

var TOKEN_GROUPS = STRUCT('TOKEN_GROUPS', {
 GroupCount: DWORD,
 Groups: pointer
});

var TOKEN_PRIVILEGES = STRUCT('TOKEN_PRIVILEGES', {
 PrivilegeCount: DWORD,
 Privileges: pointer
});

var TOKEN_OWNER = STRUCT('TOKEN_OWNER', {
 Owner: PSID
});

var TOKEN_PRIMARY_GROUP = STRUCT('TOKEN_PRIMARY_GROUP', {
 PrimaryGroup: PSID
});

var TOKEN_DEFAULT_DACL = STRUCT('TOKEN_DEFAULT_DACL', {
 DefaultDacl: PACL
});

var TOKEN_GROUPS_AND_PRIVILEGES = STRUCT('TOKEN_GROUPS_AND_PRIVILEGES', {
 SidCount: DWORD,
 SidLength: DWORD,
 Sids: PSID_AND_ATTRIBUTES,
 RestrictedSidCount: DWORD,
 RestrictedSidLength: DWORD,
 RestrictedSids: PSID_AND_ATTRIBUTES,
 PrivilegeCount: DWORD,
 PrivilegeLength: DWORD,
 Privileges: PLUID_AND_ATTRIBUTES,
 AuthenticationId: LUID
});

var TOKEN_LINKED_TOKEN = STRUCT('TOKEN_LINKED_TOKEN', {
 LinkedToken: HANDLE
});

var TOKEN_ELEVATION = STRUCT('TOKEN_ELEVATION', {
 TokenIsElevated: DWORD
});

var TOKEN_MANDATORY_LABEL = STRUCT('TOKEN_MANDATORY_LABEL', {
 Label: SID_AND_ATTRIBUTES
});

var TOKEN_MANDATORY_POLICY = STRUCT('TOKEN_MANDATORY_POLICY', {
 Policy: DWORD
});

var TOKEN_ACCESS_INFORMATION = STRUCT('TOKEN_ACCESS_INFORMATION', {
 SidHash: PSID_AND_ATTRIBUTES_HASH,
 RestrictedSidHash: PSID_AND_ATTRIBUTES_HASH,
 Privileges: PTOKEN_PRIVILEGES,
 AuthenticationId: LUID,
 TokenType: TOKEN_TYPE,
 ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
 MandatoryPolicy: TOKEN_MANDATORY_POLICY,
 Flags: DWORD
});

var TOKEN_AUDIT_POLICY = STRUCT('TOKEN_AUDIT_POLICY', {
 PerUserPolicy: pointer
});

var TOKEN_SOURCE = STRUCT('TOKEN_SOURCE', {
 SourceName: pointer,
 SourceIdentifier: LUID
});

var TOKEN_STATISTICS = STRUCT('TOKEN_STATISTICS', {
 TokenId: LUID,
 AuthenticationId: LUID,
 ExpirationTime: LARGE_INTEGER,
 TokenType: TOKEN_TYPE,
 ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
 DynamicCharged: DWORD,
 DynamicAvailable: DWORD,
 GroupCount: DWORD,
 PrivilegeCount: DWORD,
 ModifiedId: LUID
});

var TOKEN_CONTROL = STRUCT('TOKEN_CONTROL', {
 TokenId: LUID,
 AuthenticationId: LUID,
 ModifiedId: LUID,
 TokenSource: TOKEN_SOURCE
});

var TOKEN_ORIGIN = STRUCT('TOKEN_ORIGIN', {
 OriginatingLogonSession: LUID
});

var SECURITY_QUALITY_OF_SERVICE = STRUCT('SECURITY_QUALITY_OF_SERVICE', {
 Length: DWORD,
 ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
 ContextTrackingMode: SECURITY_CONTEXT_TRACKING_MODE,
 EffectiveOnly: BOOLEAN
});

var SE_IMPERSONATION_STATE = STRUCT('SE_IMPERSONATION_STATE', {
 Token: PACCESS_TOKEN,
 CopyOnOpen: BOOLEAN,
 EffectiveOnly: BOOLEAN,
 Level: SECURITY_IMPERSONATION_LEVEL
});

var JOB_SET_ARRAY = STRUCT('JOB_SET_ARRAY', {
 JobHandle: HANDLE,
 MemberLevel: DWORD,
 Flags: DWORD
});

var NT_TIB = STRUCT('NT_TIB', {
 ExceptionList: PTR(_EXCEPTION_REGISTRATION_RECORD),
 StackBase: PVOID,
 StackLimit: PVOID,
 SubSystemTib: PVOID,
 ArbitraryUserPointer: PVOID,
 Self: PTR(_NT_TIB)
});


var NT_TIB32 = STRUCT('NT_TIB32', {
 ExceptionList: DWORD,
 StackBase: DWORD,
 StackLimit: DWORD,
 SubSystemTib: DWORD,
 ArbitraryUserPointer: DWORD,
 Self: DWORD
});

var NT_TIB64 = STRUCT('NT_TIB64', {
 ExceptionList: DWORD64,
 StackBase: DWORD64,
 StackLimit: DWORD64,
 SubSystemTib: DWORD64,
 ArbitraryUserPointer: DWORD64,
 Self: DWORD64
});

var UMS_CREATE_THREAD_ATTRIBUTES = STRUCT('UMS_CREATE_THREAD_ATTRIBUTES', {
 UmsVersion: DWORD,
 UmsContext: PVOID,
 UmsCompletionList: PVOID
});

var QUOTA_LIMITS = STRUCT('QUOTA_LIMITS', {
 PagedPoolLimit: SIZE_T,
 NonPagedPoolLimit: SIZE_T,
 MinimumWorkingSetSize: SIZE_T,
 MaximumWorkingSetSize: SIZE_T,
 PagefileLimit: SIZE_T,
 TimeLimit: LARGE_INTEGER
});

var undefined = STRUCT('undefined', {
 RatePercent: DWORD,
 Reserved0: DWORD
});

var QUOTA_LIMITS_EX = STRUCT('QUOTA_LIMITS_EX', {
 PagedPoolLimit: SIZE_T,
 NonPagedPoolLimit: SIZE_T,
 MinimumWorkingSetSize: SIZE_T,
 MaximumWorkingSetSize: SIZE_T,
 PagefileLimit: SIZE_T,
 TimeLimit: LARGE_INTEGER,
 WorkingSetLimit: SIZE_T,
 Reserved2: SIZE_T,
 Reserved3: SIZE_T,
 Reserved4: SIZE_T,
 Flags: DWORD,
 CpuRateLimit: RATE_QUOTA_LIMIT
});

var IO_COUNTERS = STRUCT('IO_COUNTERS', {
 ReadOperationCount: ULONGLONG,
 WriteOperationCount: ULONGLONG,
 OtherOperationCount: ULONGLONG,
 ReadTransferCount: ULONGLONG,
 WriteTransferCount: ULONGLONG,
 OtherTransferCount: ULONGLONG
});

var JOBOBJECT_BASIC_ACCOUNTING_INFORMATION = STRUCT('JOBOBJECT_BASIC_ACCOUNTING_INFORMATION', {
 TotalUserTime: LARGE_INTEGER,
 TotalKernelTime: LARGE_INTEGER,
 ThisPeriodTotalUserTime: LARGE_INTEGER,
 ThisPeriodTotalKernelTime: LARGE_INTEGER,
 TotalPageFaultCount: DWORD,
 TotalProcesses: DWORD,
 ActiveProcesses: DWORD,
 TotalTerminatedProcesses: DWORD
});

var JOBOBJECT_BASIC_LIMIT_INFORMATION = STRUCT('JOBOBJECT_BASIC_LIMIT_INFORMATION', {
 PerProcessUserTimeLimit: LARGE_INTEGER,
 PerJobUserTimeLimit: LARGE_INTEGER,
 LimitFlags: DWORD,
 MinimumWorkingSetSize: SIZE_T,
 MaximumWorkingSetSize: SIZE_T,
 ActiveProcessLimit: DWORD,
 Affinity: ULONG_PTR,
 PriorityClass: DWORD,
 SchedulingClass: DWORD
});

var JOBOBJECT_EXTENDED_LIMIT_INFORMATION = STRUCT('JOBOBJECT_EXTENDED_LIMIT_INFORMATION', {
 BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
 IoInfo: IO_COUNTERS,
 ProcessMemoryLimit: SIZE_T,
 JobMemoryLimit: SIZE_T,
 PeakProcessMemoryUsed: SIZE_T,
 PeakJobMemoryUsed: SIZE_T
});

var JOBOBJECT_BASIC_PROCESS_ID_LIST = STRUCT('JOBOBJECT_BASIC_PROCESS_ID_LIST', {
 NumberOfAssignedProcesses: DWORD,
 NumberOfProcessIdsInList: DWORD,
 ProcessIdList: pointer
});

var JOBOBJECT_BASIC_UI_RESTRICTIONS = STRUCT('JOBOBJECT_BASIC_UI_RESTRICTIONS', {
 UIRestrictionsClass: DWORD
});

var JOBOBJECT_SECURITY_LIMIT_INFORMATION = STRUCT('JOBOBJECT_SECURITY_LIMIT_INFORMATION', {
 SecurityLimitFlags: DWORD,
 JobToken: HANDLE,
 SidsToDisable: PTOKEN_GROUPS,
 PrivilegesToDelete: PTOKEN_PRIVILEGES,
 RestrictedSids: PTOKEN_GROUPS
});

var JOBOBJECT_END_OF_JOB_TIME_INFORMATION = STRUCT('JOBOBJECT_END_OF_JOB_TIME_INFORMATION', {
 EndOfJobTimeAction: DWORD
});

var JOBOBJECT_ASSOCIATE_COMPLETION_PORT = STRUCT('JOBOBJECT_ASSOCIATE_COMPLETION_PORT', {
 CompletionKey: PVOID,
 CompletionPort: HANDLE
});

var JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION = STRUCT('JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION', {
 BasicInfo: JOBOBJECT_BASIC_ACCOUNTING_INFORMATION,
 IoInfo: IO_COUNTERS
});

var JOBOBJECT_JOBSET_INFORMATION = STRUCT('JOBOBJECT_JOBSET_INFORMATION', {
 MemberLevel: DWORD
});

var CACHE_DESCRIPTOR = STRUCT('CACHE_DESCRIPTOR', {
 Level: BYTE,
 Associativity: BYTE,
 LineSize: WORD,
 Size: DWORD,
 Type: PROCESSOR_CACHE_TYPE
});

var SYSTEM_LOGICAL_PROCESSOR_INFORMATION = STRUCT('SYSTEM_LOGICAL_PROCESSOR_INFORMATION', {
 ProcessorMask: ULONG_PTR,
 Relationship: LOGICAL_PROCESSOR_RELATIONSHIP
});

var undefined = STRUCT('undefined', {
 Flags: BYTE
});

var undefined = STRUCT('undefined', {
 NodeNumber: DWORD
});

var PROCESSOR_RELATIONSHIP = STRUCT('PROCESSOR_RELATIONSHIP', {
 Flags: BYTE,
 Reserved: pointer,
 GroupCount: WORD,
 GroupMask: pointer
});

var NUMA_NODE_RELATIONSHIP = STRUCT('NUMA_NODE_RELATIONSHIP', {
 NodeNumber: DWORD,
 Reserved: pointer,
 GroupMask: GROUP_AFFINITY
});

var CACHE_RELATIONSHIP = STRUCT('CACHE_RELATIONSHIP', {
 Level: BYTE,
 Associativity: BYTE,
 LineSize: WORD,
 CacheSize: DWORD,
 Type: PROCESSOR_CACHE_TYPE,
 Reserved: pointer,
 GroupMask: GROUP_AFFINITY
});

var PROCESSOR_GROUP_INFO = STRUCT('PROCESSOR_GROUP_INFO', {
 MaximumProcessorCount: BYTE,
 ActiveProcessorCount: BYTE,
 Reserved: pointer,
 ActiveProcessorMask: KAFFINITY
});

var GROUP_RELATIONSHIP = STRUCT('GROUP_RELATIONSHIP', {
 MaximumGroupCount: WORD,
 ActiveGroupCount: WORD,
 Reserved: pointer,
 GroupInfo: pointer
});

var SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX = STRUCT('SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX', {
 Relationship: LOGICAL_PROCESSOR_RELATIONSHIP,
 Size: DWORD
});

var SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION = STRUCT('SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION', {
 CycleTime: DWORD64
});

var XSTATE_FEATURE = STRUCT('XSTATE_FEATURE', {
 Offset: DWORD,
 Size: DWORD
});

var XSTATE_CONFIGURATION = STRUCT('XSTATE_CONFIGURATION', {
 EnabledFeatures: DWORD64,
 Size: DWORD,
 OptimizedSave: DWORD,
 Features: pointer
});

var MEMORY_BASIC_INFORMATION = STRUCT('MEMORY_BASIC_INFORMATION', {
 BaseAddress: PVOID,
 AllocationBase: PVOID,
 AllocationProtect: DWORD,
 RegionSize: SIZE_T,
 State: DWORD,
 Protect: DWORD,
 Type: DWORD
});

var MEMORY_BASIC_INFORMATION32 = STRUCT('MEMORY_BASIC_INFORMATION32', {
 BaseAddress: DWORD,
 AllocationBase: DWORD,
 AllocationProtect: DWORD,
 RegionSize: DWORD,
 State: DWORD,
 Protect: DWORD,
 Type: DWORD
});

var MEMORY_BASIC_INFORMATION64 = STRUCT('MEMORY_BASIC_INFORMATION64', {
 BaseAddress: ULONGLONG,
 AllocationBase: ULONGLONG,
 AllocationProtect: DWORD,
 __alignment1: DWORD,
 RegionSize: ULONGLONG,
 State: DWORD,
 Protect: DWORD,
 Type: DWORD,
 __alignment2: DWORD
});

var FILE_NOTIFY_INFORMATION = STRUCT('FILE_NOTIFY_INFORMATION', {
 NextEntryOffset: DWORD,
 Action: DWORD,
 FileNameLength: DWORD,
 FileName: pointer
});

var REPARSE_GUID_DATA_BUFFER = STRUCT('REPARSE_GUID_DATA_BUFFER', {
 ReparseTag: DWORD,
 ReparseDataLength: WORD,
 Reserved: WORD,
 ReparseGuid: GUID,
 GenericReparseBuffer: 
});

var undefined = STRUCT('undefined', {
 DataBuffer: pointer
});

var CM_POWER_DATA = STRUCT('CM_POWER_DATA', {
 PD_Size: DWORD,
 PD_MostRecentPowerState: DEVICE_POWER_STATE,
 PD_Capabilities: DWORD,
 PD_D1Latency: DWORD,
 PD_D2Latency: DWORD,
 PD_D3Latency: DWORD,
 PD_PowerStateMapping: pointer,
 PD_DeepestSystemWake: SYSTEM_POWER_STATE
});

var SET_POWER_SETTING_VALUE = STRUCT('SET_POWER_SETTING_VALUE', {
 Version: DWORD,
 Guid: GUID,
 PowerCondition: SYSTEM_POWER_CONDITION,
 DataLength: DWORD,
 Data: pointer
});

var NOTIFY_USER_POWER_SETTING = STRUCT('NOTIFY_USER_POWER_SETTING', {
 Guid: GUID
});

var APPLICATIONLAUNCH_SETTING_VALUE = STRUCT('APPLICATIONLAUNCH_SETTING_VALUE', {
 ActivationTime: LARGE_INTEGER,
 Flags: DWORD,
 ButtonInstanceID: DWORD
});

var BATTERY_REPORTING_SCALE = STRUCT('BATTERY_REPORTING_SCALE', {
 Granularity: DWORD,
 Capacity: DWORD
});

var PPM_WMI_LEGACY_PERFSTATE = STRUCT('PPM_WMI_LEGACY_PERFSTATE', {
 Frequency: DWORD,
 Flags: DWORD,
 PercentFrequency: DWORD
});

var PPM_WMI_IDLE_STATE = STRUCT('PPM_WMI_IDLE_STATE', {
 Latency: DWORD,
 Power: DWORD,
 TimeCheck: DWORD,
 PromotePercent: BYTE,
 DemotePercent: BYTE,
 StateType: BYTE,
 Reserved: BYTE,
 StateFlags: DWORD,
 Context: DWORD,
 IdleHandler: DWORD,
 Reserved1: DWORD
});

var PPM_WMI_IDLE_STATES = STRUCT('PPM_WMI_IDLE_STATES', {
 Type: DWORD,
 Count: DWORD,
 TargetState: DWORD,
 OldState: DWORD,
 TargetProcessors: DWORD64,
 State: pointer
});

var PPM_WMI_IDLE_STATES_EX = STRUCT('PPM_WMI_IDLE_STATES_EX', {
 Type: DWORD,
 Count: DWORD,
 TargetState: DWORD,
 OldState: DWORD,
 TargetProcessors: PVOID,
 State: pointer
});

var PPM_WMI_PERF_STATE = STRUCT('PPM_WMI_PERF_STATE', {
 Frequency: DWORD,
 Power: DWORD,
 PercentFrequency: BYTE,
 IncreaseLevel: BYTE,
 DecreaseLevel: BYTE,
 Type: BYTE,
 IncreaseTime: DWORD,
 DecreaseTime: DWORD,
 Control: DWORD64,
 Status: DWORD64,
 HitCount: DWORD,
 Reserved1: DWORD,
 Reserved2: DWORD64,
 Reserved3: DWORD64
});

var PPM_WMI_PERF_STATES = STRUCT('PPM_WMI_PERF_STATES', {
 Count: DWORD,
 MaxFrequency: DWORD,
 CurrentState: DWORD,
 MaxPerfState: DWORD,
 MinPerfState: DWORD,
 LowestPerfState: DWORD,
 ThermalConstraint: DWORD,
 BusyAdjThreshold: BYTE,
 PolicyType: BYTE,
 Type: BYTE,
 Reserved: BYTE,
 TimerInterval: DWORD,
 TargetProcessors: DWORD64,
 PStateHandler: DWORD,
 PStateContext: DWORD,
 TStateHandler: DWORD,
 TStateContext: DWORD,
 FeedbackHandler: DWORD,
 Reserved1: DWORD,
 Reserved2: DWORD64,
 State: pointer
});

var PPM_WMI_PERF_STATES_EX = STRUCT('PPM_WMI_PERF_STATES_EX', {
 Count: DWORD,
 MaxFrequency: DWORD,
 CurrentState: DWORD,
 MaxPerfState: DWORD,
 MinPerfState: DWORD,
 LowestPerfState: DWORD,
 ThermalConstraint: DWORD,
 BusyAdjThreshold: BYTE,
 PolicyType: BYTE,
 Type: BYTE,
 Reserved: BYTE,
 TimerInterval: DWORD,
 TargetProcessors: PVOID,
 PStateHandler: DWORD,
 PStateContext: DWORD,
 TStateHandler: DWORD,
 TStateContext: DWORD,
 FeedbackHandler: DWORD,
 Reserved1: DWORD,
 Reserved2: DWORD64,
 State: pointer
});

var PPM_IDLE_STATE_ACCOUNTING = STRUCT('PPM_IDLE_STATE_ACCOUNTING', {
 IdleTransitions: DWORD,
 FailedTransitions: DWORD,
 InvalidBucketIndex: DWORD,
 TotalTime: DWORD64,
 IdleTimeBuckets: pointer
});

var PPM_IDLE_ACCOUNTING = STRUCT('PPM_IDLE_ACCOUNTING', {
 StateCount: DWORD,
 TotalTransitions: DWORD,
 ResetCount: DWORD,
 StartTime: DWORD64,
 State: pointer
});

var PPM_IDLE_STATE_BUCKET_EX = STRUCT('PPM_IDLE_STATE_BUCKET_EX', {
 TotalTimeUs: DWORD64,
 MinTimeUs: DWORD,
 MaxTimeUs: DWORD,
 Count: DWORD
});

var PPM_IDLE_STATE_ACCOUNTING_EX = STRUCT('PPM_IDLE_STATE_ACCOUNTING_EX', {
 TotalTime: DWORD64,
 IdleTransitions: DWORD,
 FailedTransitions: DWORD,
 InvalidBucketIndex: DWORD,
 MinTimeUs: DWORD,
 MaxTimeUs: DWORD,
 IdleTimeBuckets: pointer
});

var PPM_IDLE_ACCOUNTING_EX = STRUCT('PPM_IDLE_ACCOUNTING_EX', {
 StateCount: DWORD,
 TotalTransitions: DWORD,
 ResetCount: DWORD,
 StartTime: DWORD64,
 State: pointer
});

var PPM_PERFSTATE_EVENT = STRUCT('PPM_PERFSTATE_EVENT', {
 State: DWORD,
 Status: DWORD,
 Latency: DWORD,
 Speed: DWORD,
 Processor: DWORD
});

var PPM_PERFSTATE_DOMAIN_EVENT = STRUCT('PPM_PERFSTATE_DOMAIN_EVENT', {
 State: DWORD,
 Latency: DWORD,
 Speed: DWORD,
 Processors: DWORD64
});

var PPM_IDLESTATE_EVENT = STRUCT('PPM_IDLESTATE_EVENT', {
 NewState: DWORD,
 OldState: DWORD,
 Processors: DWORD64
});

var PPM_THERMALCHANGE_EVENT = STRUCT('PPM_THERMALCHANGE_EVENT', {
 ThermalConstraint: DWORD,
 Processors: DWORD64
});

var PPM_THERMAL_POLICY_EVENT = STRUCT('PPM_THERMAL_POLICY_EVENT', {
 Mode: BYTE,
 Processors: DWORD64
});

var POWER_ACTION_POLICY = STRUCT('POWER_ACTION_POLICY', {
 Action: POWER_ACTION,
 Flags: DWORD,
 EventCode: DWORD
});

var SYSTEM_POWER_LEVEL = STRUCT('SYSTEM_POWER_LEVEL', {
 Enable: BOOLEAN,
 Spare: pointer,
 BatteryLevel: DWORD,
 PowerPolicy: POWER_ACTION_POLICY,
 MinSystemState: SYSTEM_POWER_STATE
});

var SYSTEM_POWER_POLICY = STRUCT('SYSTEM_POWER_POLICY', {
 Revision: DWORD,
 PowerButton: POWER_ACTION_POLICY,
 SleepButton: POWER_ACTION_POLICY,
 LidClose: POWER_ACTION_POLICY,
 LidOpenWake: SYSTEM_POWER_STATE,
 Reserved: DWORD,
 Idle: POWER_ACTION_POLICY,
 IdleTimeout: DWORD,
 IdleSensitivity: BYTE,
 DynamicThrottle: BYTE,
 Spare2: pointer,
 MinSleep: SYSTEM_POWER_STATE,
 MaxSleep: SYSTEM_POWER_STATE,
 ReducedLatencySleep: SYSTEM_POWER_STATE,
 WinLogonFlags: DWORD,
 Spare3: DWORD,
 DozeS4Timeout: DWORD,
 BroadcastCapacityResolution: DWORD,
 DischargePolicy: pointer,
 VideoTimeout: DWORD,
 VideoDimDisplay: BOOLEAN,
 VideoReserved: pointer,
 SpindownTimeout: DWORD,
 OptimizeForPower: BOOLEAN,
 FanThrottleTolerance: BYTE,
 ForcedThrottle: BYTE,
 MinThrottle: BYTE,
 OverThrottled: POWER_ACTION_POLICY
});

var PROCESSOR_IDLESTATE_INFO = STRUCT('PROCESSOR_IDLESTATE_INFO', {
 TimeCheck: DWORD,
 DemotePercent: BYTE,
 PromotePercent: BYTE,
 Spare: pointer
});

var PROCESSOR_IDLESTATE_POLICY = STRUCT('PROCESSOR_IDLESTATE_POLICY', {
 Revision: WORD,
 Flags: ,
 PolicyCount: DWORD,
 Policy: pointer
});

var undefined = STRUCT('undefined', {
 AllowScaling: WORD,
 Disabled: WORD,
 Reserved: WORD
});

var PROCESSOR_POWER_POLICY_INFO = STRUCT('PROCESSOR_POWER_POLICY_INFO', {
 TimeCheck: DWORD,
 DemoteLimit: DWORD,
 PromoteLimit: DWORD,
 DemotePercent: BYTE,
 PromotePercent: BYTE,
 Spare: pointer,
 AllowDemotion: DWORD,
 AllowPromotion: DWORD,
 Reserved: DWORD
});

var PROCESSOR_POWER_POLICY = STRUCT('PROCESSOR_POWER_POLICY', {
 Revision: DWORD,
 DynamicThrottle: BYTE,
 Spare: pointer,
 DisableCStates: DWORD,
 Reserved: DWORD,
 PolicyCount: DWORD,
 Policy: pointer
});

var PROCESSOR_PERFSTATE_POLICY = STRUCT('PROCESSOR_PERFSTATE_POLICY', {
 Revision: DWORD,
 MaxThrottle: BYTE,
 MinThrottle: BYTE,
 BusyAdjThreshold: BYTE,
 TimeCheck: DWORD,
 IncreaseTime: DWORD,
 DecreaseTime: DWORD,
 IncreasePercent: DWORD,
 DecreasePercent: DWORD
});

var undefined = STRUCT('undefined', {
 NoDomainAccounting: BYTE,
 IncreasePolicy: BYTE,
 DecreasePolicy: BYTE,
 Reserved: BYTE
});

var ADMINISTRATOR_POWER_POLICY = STRUCT('ADMINISTRATOR_POWER_POLICY', {
 MinSleep: SYSTEM_POWER_STATE,
 MaxSleep: SYSTEM_POWER_STATE,
 MinVideoTimeout: DWORD,
 MaxVideoTimeout: DWORD,
 MinSpindownTimeout: DWORD,
 MaxSpindownTimeout: DWORD
});

var SYSTEM_POWER_CAPABILITIES = STRUCT('SYSTEM_POWER_CAPABILITIES', {
 PowerButtonPresent: BOOLEAN,
 SleepButtonPresent: BOOLEAN,
 LidPresent: BOOLEAN,
 SystemS1: BOOLEAN,
 SystemS2: BOOLEAN,
 SystemS3: BOOLEAN,
 SystemS4: BOOLEAN,
 SystemS5: BOOLEAN,
 HiberFilePresent: BOOLEAN,
 FullWake: BOOLEAN,
 VideoDimPresent: BOOLEAN,
 ApmPresent: BOOLEAN,
 UpsPresent: BOOLEAN,
 ThermalControl: BOOLEAN,
 ProcessorThrottle: BOOLEAN,
 ProcessorMinThrottle: BYTE,
 ProcessorMaxThrottle: BYTE,
 FastSystemS4: BOOLEAN,
 spare2: pointer,
 DiskSpinDown: BOOLEAN,
 spare3: pointer,
 SystemBatteriesPresent: BOOLEAN,
 BatteriesAreShortTerm: BOOLEAN,
 BatteryScale: pointer,
 AcOnLineWake: SYSTEM_POWER_STATE,
 SoftLidWake: SYSTEM_POWER_STATE,
 RtcWake: SYSTEM_POWER_STATE,
 MinDeviceWakeState: SYSTEM_POWER_STATE,
 DefaultLowLatencyWake: SYSTEM_POWER_STATE
});

var SYSTEM_BATTERY_STATE = STRUCT('SYSTEM_BATTERY_STATE', {
 AcOnLine: BOOLEAN,
 BatteryPresent: BOOLEAN,
 Charging: BOOLEAN,
 Discharging: BOOLEAN,
 Spare1: pointer,
 MaxCapacity: DWORD,
 RemainingCapacity: DWORD,
 Rate: DWORD,
 EstimatedTime: DWORD,
 DefaultAlert1: DWORD,
 DefaultAlert2: DWORD
});

var IMAGE_DOS_HEADER = STRUCT('IMAGE_DOS_HEADER', {
 e_magic: WORD,
 e_cblp: WORD,
 e_cp: WORD,
 e_crlc: WORD,
 e_cparhdr: WORD,
 e_minalloc: WORD,
 e_maxalloc: WORD,
 e_ss: WORD,
 e_sp: WORD,
 e_csum: WORD,
 e_ip: WORD,
 e_cs: WORD,
 e_lfarlc: WORD,
 e_ovno: WORD,
 e_res: pointer,
 e_oemid: WORD,
 e_oeminfo: WORD,
 e_res2: pointer,
 e_lfanew: LONG
});

var IMAGE_OS2_HEADER = STRUCT('IMAGE_OS2_HEADER', {
 ne_magic: WORD,
 ne_ver: CHAR,
 ne_rev: CHAR,
 ne_enttab: WORD,
 ne_cbenttab: WORD,
 ne_crc: LONG,
 ne_flags: WORD,
 ne_autodata: WORD,
 ne_heap: WORD,
 ne_stack: WORD,
 ne_csip: LONG,
 ne_sssp: LONG,
 ne_cseg: WORD,
 ne_cmod: WORD,
 ne_cbnrestab: WORD,
 ne_segtab: WORD,
 ne_rsrctab: WORD,
 ne_restab: WORD,
 ne_modtab: WORD,
 ne_imptab: WORD,
 ne_nrestab: LONG,
 ne_cmovent: WORD,
 ne_align: WORD,
 ne_cres: WORD,
 ne_exetyp: BYTE,
 ne_flagsothers: BYTE,
 ne_pretthunks: WORD,
 ne_psegrefbytes: WORD,
 ne_swaparea: WORD,
 ne_expver: WORD
});

var IMAGE_VXD_HEADER = STRUCT('IMAGE_VXD_HEADER', {
 e32_magic: WORD,
 e32_border: BYTE,
 e32_worder: BYTE,
 e32_level: DWORD,
 e32_cpu: WORD,
 e32_os: WORD,
 e32_ver: DWORD,
 e32_mflags: DWORD,
 e32_mpages: DWORD,
 e32_startobj: DWORD,
 e32_eip: DWORD,
 e32_stackobj: DWORD,
 e32_esp: DWORD,
 e32_pagesize: DWORD,
 e32_lastpagesize: DWORD,
 e32_fixupsize: DWORD,
 e32_fixupsum: DWORD,
 e32_ldrsize: DWORD,
 e32_ldrsum: DWORD,
 e32_objtab: DWORD,
 e32_objcnt: DWORD,
 e32_objmap: DWORD,
 e32_itermap: DWORD,
 e32_rsrctab: DWORD,
 e32_rsrccnt: DWORD,
 e32_restab: DWORD,
 e32_enttab: DWORD,
 e32_dirtab: DWORD,
 e32_dircnt: DWORD,
 e32_fpagetab: DWORD,
 e32_frectab: DWORD,
 e32_impmod: DWORD,
 e32_impmodcnt: DWORD,
 e32_impproc: DWORD,
 e32_pagesum: DWORD,
 e32_datapage: DWORD,
 e32_preload: DWORD,
 e32_nrestab: DWORD,
 e32_cbnrestab: DWORD,
 e32_nressum: DWORD,
 e32_autodata: DWORD,
 e32_debuginfo: DWORD,
 e32_debuglen: DWORD,
 e32_instpreload: DWORD,
 e32_instdemand: DWORD,
 e32_heapsize: DWORD,
 e32_res3: pointer,
 e32_winresoff: DWORD,
 e32_winreslen: DWORD,
 e32_devid: WORD,
 e32_ddkver: WORD
});

var IMAGE_FILE_HEADER = STRUCT('IMAGE_FILE_HEADER', {
 Machine: WORD,
 NumberOfSections: WORD,
 TimeDateStamp: DWORD,
 PointerToSymbolTable: DWORD,
 NumberOfSymbols: DWORD,
 SizeOfOptionalHeader: WORD,
 Characteristics: WORD
});

var IMAGE_DATA_DIRECTORY = STRUCT('IMAGE_DATA_DIRECTORY', {
 VirtualAddress: DWORD,
 Size: DWORD
});

var IMAGE_OPTIONAL_HEADER = STRUCT('IMAGE_OPTIONAL_HEADER', {
 Magic: WORD,
 MajorLinkerVersion: BYTE,
 MinorLinkerVersion: BYTE,
 SizeOfCode: DWORD,
 SizeOfInitializedData: DWORD,
 SizeOfUninitializedData: DWORD,
 AddressOfEntryPoint: DWORD,
 BaseOfCode: DWORD,
 BaseOfData: DWORD,
 ImageBase: DWORD,
 SectionAlignment: DWORD,
 FileAlignment: DWORD,
 MajorOperatingSystemVersion: WORD,
 MinorOperatingSystemVersion: WORD,
 MajorImageVersion: WORD,
 MinorImageVersion: WORD,
 MajorSubsystemVersion: WORD,
 MinorSubsystemVersion: WORD,
 Win32VersionValue: DWORD,
 SizeOfImage: DWORD,
 SizeOfHeaders: DWORD,
 CheckSum: DWORD,
 Subsystem: WORD,
 DllCharacteristics: WORD,
 SizeOfStackReserve: DWORD,
 SizeOfStackCommit: DWORD,
 SizeOfHeapReserve: DWORD,
 SizeOfHeapCommit: DWORD,
 LoaderFlags: DWORD,
 NumberOfRvaAndSizes: DWORD,
 DataDirectory: pointer
});

var IMAGE_ROM_OPTIONAL_HEADER = STRUCT('IMAGE_ROM_OPTIONAL_HEADER', {
 Magic: WORD,
 MajorLinkerVersion: BYTE,
 MinorLinkerVersion: BYTE,
 SizeOfCode: DWORD,
 SizeOfInitializedData: DWORD,
 SizeOfUninitializedData: DWORD,
 AddressOfEntryPoint: DWORD,
 BaseOfCode: DWORD,
 BaseOfData: DWORD,
 BaseOfBss: DWORD,
 GprMask: DWORD,
 CprMask: pointer,
 GpValue: DWORD
});

var IMAGE_OPTIONAL_HEADER64 = STRUCT('IMAGE_OPTIONAL_HEADER64', {
 Magic: WORD,
 MajorLinkerVersion: BYTE,
 MinorLinkerVersion: BYTE,
 SizeOfCode: DWORD,
 SizeOfInitializedData: DWORD,
 SizeOfUninitializedData: DWORD,
 AddressOfEntryPoint: DWORD,
 BaseOfCode: DWORD,
 ImageBase: ULONGLONG,
 SectionAlignment: DWORD,
 FileAlignment: DWORD,
 MajorOperatingSystemVersion: WORD,
 MinorOperatingSystemVersion: WORD,
 MajorImageVersion: WORD,
 MinorImageVersion: WORD,
 MajorSubsystemVersion: WORD,
 MinorSubsystemVersion: WORD,
 Win32VersionValue: DWORD,
 SizeOfImage: DWORD,
 SizeOfHeaders: DWORD,
 CheckSum: DWORD,
 Subsystem: WORD,
 DllCharacteristics: WORD,
 SizeOfStackReserve: ULONGLONG,
 SizeOfStackCommit: ULONGLONG,
 SizeOfHeapReserve: ULONGLONG,
 SizeOfHeapCommit: ULONGLONG,
 LoaderFlags: DWORD,
 NumberOfRvaAndSizes: DWORD,
 DataDirectory: pointer
});

var IMAGE_NT_HEADERS64 = STRUCT('IMAGE_NT_HEADERS64', {
 Signature: DWORD,
 FileHeader: IMAGE_FILE_HEADER,
 OptionalHeader: IMAGE_OPTIONAL_HEADER64
});

var IMAGE_NT_HEADERS = STRUCT('IMAGE_NT_HEADERS', {
 Signature: DWORD,
 FileHeader: IMAGE_FILE_HEADER,
 OptionalHeader: IMAGE_OPTIONAL_HEADER32
});

var IMAGE_ROM_HEADERS = STRUCT('IMAGE_ROM_HEADERS', {
 FileHeader: IMAGE_FILE_HEADER,
 OptionalHeader: IMAGE_ROM_OPTIONAL_HEADER
});

var ANON_OBJECT_HEADER = STRUCT('ANON_OBJECT_HEADER', {
 Sig1: WORD,
 Sig2: WORD,
 Version: WORD,
 Machine: WORD,
 TimeDateStamp: DWORD,
 ClassID: CLSID,
 SizeOfData: DWORD
});

var ANON_OBJECT_HEADER_V2 = STRUCT('ANON_OBJECT_HEADER_V2', {
 Sig1: WORD,
 Sig2: WORD,
 Version: WORD,
 Machine: WORD,
 TimeDateStamp: DWORD,
 ClassID: CLSID,
 SizeOfData: DWORD,
 Flags: DWORD,
 MetaDataSize: DWORD,
 MetaDataOffset: DWORD
});

var ANON_OBJECT_HEADER_BIGOBJ = STRUCT('ANON_OBJECT_HEADER_BIGOBJ', {
 Sig1: WORD,
 Sig2: WORD,
 Version: WORD,
 Machine: WORD,
 TimeDateStamp: DWORD,
 ClassID: CLSID,
 SizeOfData: DWORD,
 Flags: DWORD,
 MetaDataSize: DWORD,
 MetaDataOffset: DWORD,
 NumberOfSections: DWORD,
 PointerToSymbolTable: DWORD,
 NumberOfSymbols: DWORD
});

var IMAGE_SECTION_HEADER = STRUCT('IMAGE_SECTION_HEADER', {
 Name: pointer,
 Misc: ,
 VirtualAddress: DWORD,
 SizeOfRawData: DWORD,
 PointerToRawData: DWORD,
 PointerToRelocations: DWORD,
 PointerToLinenumbers: DWORD,
 NumberOfRelocations: WORD,
 NumberOfLinenumbers: WORD,
 Characteristics: DWORD
});

var IMAGE_SYMBOL = STRUCT('IMAGE_SYMBOL', {
 N: ,
 Value: DWORD,
 SectionNumber: SHORT,
 Type: WORD,
 StorageClass: BYTE,
 NumberOfAuxSymbols: BYTE
});

var undefined = STRUCT('undefined', {
 Short: DWORD,
 Long: DWORD
});

var IMAGE_SYMBOL_EX = STRUCT('IMAGE_SYMBOL_EX', {
 N: ,
 Value: DWORD,
 SectionNumber: LONG,
 Type: WORD,
 StorageClass: BYTE,
 NumberOfAuxSymbols: BYTE
});

var undefined = STRUCT('undefined', {
 Short: DWORD,
 Long: DWORD
});

var IMAGE_AUX_SYMBOL_TOKEN_DEF = STRUCT('IMAGE_AUX_SYMBOL_TOKEN_DEF', {
 bAuxType: BYTE,
 bReserved: BYTE,
 SymbolTableIndex: DWORD,
 rgbReserved: pointer
});

var undefined = STRUCT('undefined', {
 TagIndex: DWORD,
 Misc: ,
 FcnAry: ,
 TvIndex: WORD
});

var undefined = STRUCT('undefined', {
 Linenumber: WORD,
 Size: WORD
});

var undefined = STRUCT('undefined', {
 PointerToLinenumber: DWORD,
 PointerToNextFunction: DWORD
});

var undefined = STRUCT('undefined', {
 Dimension: pointer
});

var undefined = STRUCT('undefined', {
 Name: pointer
});

var undefined = STRUCT('undefined', {
 Length: DWORD,
 NumberOfRelocations: WORD,
 NumberOfLinenumbers: WORD,
 CheckSum: DWORD,
 Number: SHORT,
 Selection: BYTE,
 bReserved: BYTE,
 HighNumber: SHORT
});

var undefined = STRUCT('undefined', {
 crc: DWORD,
 rgbReserved: pointer
});

var undefined = STRUCT('undefined', {
 WeakDefaultSymIndex: DWORD,
 WeakSearchType: DWORD,
 rgbReserved: pointer
});

var undefined = STRUCT('undefined', {
 Name: pointer
});

var undefined = STRUCT('undefined', {
 Length: DWORD,
 NumberOfRelocations: WORD,
 NumberOfLinenumbers: WORD,
 CheckSum: DWORD,
 Number: SHORT,
 Selection: BYTE,
 bReserved: BYTE,
 HighNumber: SHORT,
 rgbReserved: pointer
});

var undefined = STRUCT('undefined', {
 TokenDef: IMAGE_AUX_SYMBOL_TOKEN_DEF,
 rgbReserved: pointer
});

var undefined = STRUCT('undefined', {
 crc: DWORD,
 rgbReserved: pointer
});

var IMAGE_RELOCATION = STRUCT('IMAGE_RELOCATION', {
 SymbolTableIndex: DWORD,
 Type: WORD
});

var IMAGE_LINENUMBER = STRUCT('IMAGE_LINENUMBER', {
 Type: ,
 Linenumber: WORD
});

var IMAGE_BASE_RELOCATION = STRUCT('IMAGE_BASE_RELOCATION', {
 VirtualAddress: DWORD,
 SizeOfBlock: DWORD
});

var IMAGE_ARCHIVE_MEMBER_HEADER = STRUCT('IMAGE_ARCHIVE_MEMBER_HEADER', {
 Name: pointer,
 Date: pointer,
 UserID: pointer,
 GroupID: pointer,
 Mode: pointer,
 Size: pointer,
 EndHeader: pointer
});

var IMAGE_EXPORT_DIRECTORY = STRUCT('IMAGE_EXPORT_DIRECTORY', {
 Characteristics: DWORD,
 TimeDateStamp: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 Name: DWORD,
 Base: DWORD,
 NumberOfFunctions: DWORD,
 NumberOfNames: DWORD,
 AddressOfFunctions: DWORD,
 AddressOfNames: DWORD,
 AddressOfNameOrdinals: DWORD
});

var IMAGE_IMPORT_BY_NAME = STRUCT('IMAGE_IMPORT_BY_NAME', {
 Hint: WORD,
 Name: pointer
});

var IMAGE_THUNK_DATA64 = STRUCT('IMAGE_THUNK_DATA64', {
 u1: 
});

var IMAGE_THUNK_DATA = STRUCT('IMAGE_THUNK_DATA', {
 u1: 
});

var IMAGE_TLS_DIRECTORY64 = STRUCT('IMAGE_TLS_DIRECTORY64', {
 StartAddressOfRawData: ULONGLONG,
 EndAddressOfRawData: ULONGLONG,
 AddressOfIndex: ULONGLONG,
 AddressOfCallBacks: ULONGLONG,
 SizeOfZeroFill: DWORD,
 Characteristics: DWORD
});

var IMAGE_TLS_DIRECTORY = STRUCT('IMAGE_TLS_DIRECTORY', {
 StartAddressOfRawData: DWORD,
 EndAddressOfRawData: DWORD,
 AddressOfIndex: DWORD,
 AddressOfCallBacks: DWORD,
 SizeOfZeroFill: DWORD,
 Characteristics: DWORD
});

var IMAGE_IMPORT_DESCRIPTOR = STRUCT('IMAGE_IMPORT_DESCRIPTOR', {
 TimeDateStamp: DWORD,
 ForwarderChain: DWORD,
 Name: DWORD,
 FirstThunk: DWORD
});

var IMAGE_BOUND_IMPORT_DESCRIPTOR = STRUCT('IMAGE_BOUND_IMPORT_DESCRIPTOR', {
 TimeDateStamp: DWORD,
 OffsetModuleName: WORD,
 NumberOfModuleForwarderRefs: WORD
});

var IMAGE_BOUND_FORWARDER_REF = STRUCT('IMAGE_BOUND_FORWARDER_REF', {
 TimeDateStamp: DWORD,
 OffsetModuleName: WORD,
 Reserved: WORD
});

var IMAGE_RESOURCE_DIRECTORY = STRUCT('IMAGE_RESOURCE_DIRECTORY', {
 Characteristics: DWORD,
 TimeDateStamp: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 NumberOfNamedEntries: WORD,
 NumberOfIdEntries: WORD
});


var undefined = STRUCT('undefined', {
 NameOffset: DWORD,
 NameIsString: DWORD
});

var undefined = STRUCT('undefined', {
 OffsetToDirectory: DWORD,
 DataIsDirectory: DWORD
});

var IMAGE_RESOURCE_DIRECTORY_STRING = STRUCT('IMAGE_RESOURCE_DIRECTORY_STRING', {
 Length: WORD,
 NameString: pointer
});

var IMAGE_RESOURCE_DIR_STRING_U = STRUCT('IMAGE_RESOURCE_DIR_STRING_U', {
 Length: WORD,
 NameString: pointer
});

var IMAGE_RESOURCE_DATA_ENTRY = STRUCT('IMAGE_RESOURCE_DATA_ENTRY', {
 OffsetToData: DWORD,
 Size: DWORD,
 CodePage: DWORD,
 Reserved: DWORD
});

var IMAGE_LOAD_CONFIG_DIRECTORY = STRUCT('IMAGE_LOAD_CONFIG_DIRECTORY', {
 Size: DWORD,
 TimeDateStamp: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 GlobalFlagsClear: DWORD,
 GlobalFlagsSet: DWORD,
 CriticalSectionDefaultTimeout: DWORD,
 DeCommitFreeBlockThreshold: DWORD,
 DeCommitTotalFreeThreshold: DWORD,
 LockPrefixTable: DWORD,
 MaximumAllocationSize: DWORD,
 VirtualMemoryThreshold: DWORD,
 ProcessHeapFlags: DWORD,
 ProcessAffinityMask: DWORD,
 CSDVersion: WORD,
 Reserved1: WORD,
 EditList: DWORD,
 SecurityCookie: DWORD,
 SEHandlerTable: DWORD,
 SEHandlerCount: DWORD
});

var IMAGE_LOAD_CONFIG_DIRECTORY64 = STRUCT('IMAGE_LOAD_CONFIG_DIRECTORY64', {
 Size: DWORD,
 TimeDateStamp: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 GlobalFlagsClear: DWORD,
 GlobalFlagsSet: DWORD,
 CriticalSectionDefaultTimeout: DWORD,
 DeCommitFreeBlockThreshold: ULONGLONG,
 DeCommitTotalFreeThreshold: ULONGLONG,
 LockPrefixTable: ULONGLONG,
 MaximumAllocationSize: ULONGLONG,
 VirtualMemoryThreshold: ULONGLONG,
 ProcessAffinityMask: ULONGLONG,
 ProcessHeapFlags: DWORD,
 CSDVersion: WORD,
 Reserved1: WORD,
 EditList: ULONGLONG,
 SecurityCookie: ULONGLONG,
 SEHandlerTable: ULONGLONG,
 SEHandlerCount: ULONGLONG
});

var IMAGE_CE_RUNTIME_FUNCTION_ENTRY = STRUCT('IMAGE_CE_RUNTIME_FUNCTION_ENTRY', {
 FuncStart: DWORD,
 PrologLen: DWORD,
 FuncLen: DWORD,
 ThirtyTwoBit: DWORD,
 ExceptionFlag: DWORD
});

var IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY = STRUCT('IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY', {
 BeginAddress: ULONGLONG,
 EndAddress: ULONGLONG,
 ExceptionHandler: ULONGLONG,
 HandlerData: ULONGLONG,
 PrologEndAddress: ULONGLONG
});

var IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY = STRUCT('IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY', {
 BeginAddress: DWORD,
 EndAddress: DWORD,
 ExceptionHandler: DWORD,
 HandlerData: DWORD,
 PrologEndAddress: DWORD
});

var IMAGE_RUNTIME_FUNCTION_ENTRY = STRUCT('IMAGE_RUNTIME_FUNCTION_ENTRY', {
 BeginAddress: DWORD,
 EndAddress: DWORD,
 UnwindInfoAddress: DWORD
});

var IMAGE_DEBUG_DIRECTORY = STRUCT('IMAGE_DEBUG_DIRECTORY', {
 Characteristics: DWORD,
 TimeDateStamp: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 Type: DWORD,
 SizeOfData: DWORD,
 AddressOfRawData: DWORD,
 PointerToRawData: DWORD
});

var IMAGE_COFF_SYMBOLS_HEADER = STRUCT('IMAGE_COFF_SYMBOLS_HEADER', {
 NumberOfSymbols: DWORD,
 LvaToFirstSymbol: DWORD,
 NumberOfLinenumbers: DWORD,
 LvaToFirstLinenumber: DWORD,
 RvaToFirstByteOfCode: DWORD,
 RvaToLastByteOfCode: DWORD,
 RvaToFirstByteOfData: DWORD,
 RvaToLastByteOfData: DWORD
});

var FPO_DATA = STRUCT('FPO_DATA', {
 ulOffStart: DWORD,
 cbProcSize: DWORD,
 cdwLocals: DWORD,
 cdwParams: WORD,
 cbProlog: WORD,
 cbRegs: WORD,
 fHasSEH: WORD,
 fUseBP: WORD,
 reserved: WORD,
 cbFrame: WORD
});

var IMAGE_DEBUG_MISC = STRUCT('IMAGE_DEBUG_MISC', {
 DataType: DWORD,
 Length: DWORD,
 Unicode: BOOLEAN,
 Reserved: pointer,
 Data: pointer
});

var IMAGE_FUNCTION_ENTRY = STRUCT('IMAGE_FUNCTION_ENTRY', {
 StartingAddress: DWORD,
 EndingAddress: DWORD,
 EndOfPrologue: DWORD
});

var IMAGE_FUNCTION_ENTRY64 = STRUCT('IMAGE_FUNCTION_ENTRY64', {
 StartingAddress: ULONGLONG,
 EndingAddress: ULONGLONG
});

var IMAGE_SEPARATE_DEBUG_HEADER = STRUCT('IMAGE_SEPARATE_DEBUG_HEADER', {
 Signature: WORD,
 Flags: WORD,
 Machine: WORD,
 Characteristics: WORD,
 TimeDateStamp: DWORD,
 CheckSum: DWORD,
 ImageBase: DWORD,
 SizeOfImage: DWORD,
 NumberOfSections: DWORD,
 ExportedNamesSize: DWORD,
 DebugDirectorySize: DWORD,
 SectionAlignment: DWORD,
 Reserved: pointer
});

var NON_PAGED_DEBUG_INFO = STRUCT('NON_PAGED_DEBUG_INFO', {
 Signature: WORD,
 Flags: WORD,
 Size: DWORD,
 Machine: WORD,
 Characteristics: WORD,
 TimeDateStamp: DWORD,
 CheckSum: DWORD,
 SizeOfImage: DWORD,
 ImageBase: ULONGLONG
});

var IMAGE_ARCHITECTURE_HEADER = STRUCT('IMAGE_ARCHITECTURE_HEADER', {
 AmaskValue: uint,
 '': int,
 AmaskShift: uint,
 FirstEntryRVA: DWORD
});

var IMAGE_ARCHITECTURE_ENTRY = STRUCT('IMAGE_ARCHITECTURE_ENTRY', {
 FixupInstRVA: DWORD,
 NewInst: DWORD
});

var IMPORT_OBJECT_HEADER = STRUCT('IMPORT_OBJECT_HEADER', {
 Sig1: WORD,
 Sig2: WORD,
 Version: WORD,
 Machine: WORD,
 TimeDateStamp: DWORD,
 SizeOfData: DWORD,
 Type: WORD,
 NameType: WORD,
 Reserved: WORD
});

var IMAGE_COR20_HEADER = STRUCT('IMAGE_COR20_HEADER', {
 cb: DWORD,
 MajorRuntimeVersion: WORD,
 MinorRuntimeVersion: WORD,
 MetaData: IMAGE_DATA_DIRECTORY,
 Flags: DWORD,
 Resources: IMAGE_DATA_DIRECTORY,
 StrongNameSignature: IMAGE_DATA_DIRECTORY,
 CodeManagerTable: IMAGE_DATA_DIRECTORY,
 VTableFixups: IMAGE_DATA_DIRECTORY,
 ExportAddressTableJumps: IMAGE_DATA_DIRECTORY,
 ManagedNativeHeader: IMAGE_DATA_DIRECTORY
});

var undefined = STRUCT('undefined', {
 Next: SINGLE_LIST_ENTRY,
 Depth: WORD,
 Sequence: WORD
});

var MESSAGE_RESOURCE_ENTRY = STRUCT('MESSAGE_RESOURCE_ENTRY', {
 Length: WORD,
 Flags: WORD,
 Text: pointer
});

var MESSAGE_RESOURCE_BLOCK = STRUCT('MESSAGE_RESOURCE_BLOCK', {
 LowId: DWORD,
 HighId: DWORD,
 OffsetToEntries: DWORD
});

var MESSAGE_RESOURCE_DATA = STRUCT('MESSAGE_RESOURCE_DATA', {
 NumberOfBlocks: DWORD,
 Blocks: pointer
});

var OSVERSIONINFO = STRUCT('OSVERSIONINFO', {
 dwOSVersionInfoSize: DWORD,
 dwMajorVersion: DWORD,
 dwMinorVersion: DWORD,
 dwBuildNumber: DWORD,
 dwPlatformId: DWORD,
 szCSDVersion: pointer
});

var RTL_OSVERSIONINFOW = STRUCT('RTL_OSVERSIONINFOW', {
 dwOSVersionInfoSize: DWORD,
 dwMajorVersion: DWORD,
 dwMinorVersion: DWORD,
 dwBuildNumber: DWORD,
 dwPlatformId: DWORD,
 szCSDVersion: pointer
});

var OSVERSIONINFOEX = STRUCT('OSVERSIONINFOEX', {
 dwOSVersionInfoSize: DWORD,
 dwMajorVersion: DWORD,
 dwMinorVersion: DWORD,
 dwBuildNumber: DWORD,
 dwPlatformId: DWORD,
 szCSDVersion: pointer,
 wServicePackMajor: WORD,
 wServicePackMinor: WORD,
 wSuiteMask: WORD,
 wProductType: BYTE,
 wReserved: BYTE
});

var RTL_OSVERSIONINFOEXW = STRUCT('RTL_OSVERSIONINFOEXW', {
 dwOSVersionInfoSize: DWORD,
 dwMajorVersion: DWORD,
 dwMinorVersion: DWORD,
 dwBuildNumber: DWORD,
 dwPlatformId: DWORD,
 szCSDVersion: pointer,
 wServicePackMajor: WORD,
 wServicePackMinor: WORD,
 wSuiteMask: WORD,
 wProductType: BYTE,
 wReserved: BYTE
});

var CRITICAL_SECTION_DEBUG = STRUCT('CRITICAL_SECTION_DEBUG', {
 Type: WORD,
 CreatorBackTraceIndex: WORD,
 CriticalSection: PTR(_RTL_CRITICAL_SECTION),
 ProcessLocksList: LIST_ENTRY,
 EntryCount: DWORD,
 ContentionCount: DWORD,
 Flags: DWORD,
 CreatorBackTraceIndexHigh: WORD,
 SpareWORD: WORD
});

var CRITICAL_SECTION = STRUCT('CRITICAL_SECTION', {
 DebugInfo: PRTL_CRITICAL_SECTION_DEBUG,
 LockCount: LONG,
 RecursionCount: LONG,
 OwningThread: HANDLE,
 LockSemaphore: HANDLE,
 SpinCount: ULONG_PTR
});

var SRWLOCK = STRUCT('SRWLOCK', {
 Ptr: PVOID
});

var CONDITION_VARIABLE = STRUCT('CONDITION_VARIABLE', {
 Ptr: PVOID
});

var ACTIVATION_CONTEXT_QUERY_INDEX = STRUCT('ACTIVATION_CONTEXT_QUERY_INDEX', {
 ulAssemblyIndex: DWORD,
 ulFileIndexInAssembly: DWORD
});

var ASSEMBLY_FILE_DETAILED_INFORMATION = STRUCT('ASSEMBLY_FILE_DETAILED_INFORMATION', {
 ulFlags: DWORD,
 ulFilenameLength: DWORD,
 ulPathLength: DWORD,
 lpFileName: PCWSTR,
 lpFilePath: PCWSTR
});

var ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION = STRUCT('ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION', {
 ulFlags: DWORD,
 ulEncodedAssemblyIdentityLength: DWORD,
 ulManifestPathType: DWORD,
 ulManifestPathLength: DWORD,
 liManifestLastWriteTime: LARGE_INTEGER,
 ulPolicyPathType: DWORD,
 ulPolicyPathLength: DWORD,
 liPolicyLastWriteTime: LARGE_INTEGER,
 ulMetadataSatelliteRosterIndex: DWORD,
 ulManifestVersionMajor: DWORD,
 ulManifestVersionMinor: DWORD,
 ulPolicyVersionMajor: DWORD,
 ulPolicyVersionMinor: DWORD,
 ulAssemblyDirectoryNameLength: DWORD,
 lpAssemblyEncodedAssemblyIdentity: PCWSTR,
 lpAssemblyManifestPath: PCWSTR,
 lpAssemblyPolicyPath: PCWSTR,
 lpAssemblyDirectoryName: PCWSTR,
 ulFileCount: DWORD
});

var ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION = STRUCT('ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION', {
 ulFlags: DWORD,
 RunLevel: ACTCTX_REQUESTED_RUN_LEVEL,
 UiAccess: DWORD
});

var COMPATIBILITY_CONTEXT_ELEMENT = STRUCT('COMPATIBILITY_CONTEXT_ELEMENT', {
 Id: GUID,
 Type: ACTCTX_COMPATIBILITY_ELEMENT_TYPE
});

var ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION = STRUCT('ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION', {
 ElementCount: DWORD,
 Elements: pointer
});

var SUPPORTED_OS_INFO = STRUCT('SUPPORTED_OS_INFO', {
 OsCount: WORD,
 MitigationExist: WORD,
 OsList: pointer
});

var ACTIVATION_CONTEXT_DETAILED_INFORMATION = STRUCT('ACTIVATION_CONTEXT_DETAILED_INFORMATION', {
 dwFlags: DWORD,
 ulFormatVersion: DWORD,
 ulAssemblyCount: DWORD,
 ulRootManifestPathType: DWORD,
 ulRootManifestPathChars: DWORD,
 ulRootConfigurationPathType: DWORD,
 ulRootConfigurationPathChars: DWORD,
 ulAppDirPathType: DWORD,
 ulAppDirPathChars: DWORD,
 lpRootManifestPath: PCWSTR,
 lpRootConfigurationPath: PCWSTR,
 lpAppDirPath: PCWSTR
});

var HARDWARE_COUNTER_DATA = STRUCT('HARDWARE_COUNTER_DATA', {
 Type: HARDWARE_COUNTER_TYPE,
 Reserved: DWORD,
 Value: DWORD64
});

var PERFORMANCE_DATA = STRUCT('PERFORMANCE_DATA', {
 Size: WORD,
 Version: BYTE,
 HwCountersCount: BYTE,
 ContextSwitchCount: DWORD,
 WaitReasonBitMap: DWORD64,
 CycleTime: DWORD64,
 RetryCount: DWORD,
 Reserved: DWORD,
 HwCounters: pointer
});

var EVENTLOGRECORD = STRUCT('EVENTLOGRECORD', {
 Length: DWORD,
 Reserved: DWORD,
 RecordNumber: DWORD,
 TimeGenerated: DWORD,
 TimeWritten: DWORD,
 EventID: DWORD,
 EventType: WORD,
 NumStrings: WORD,
 EventCategory: WORD,
 ReservedFlags: WORD,
 ClosingRecordNumber: DWORD,
 StringOffset: DWORD,
 UserSidLength: DWORD,
 UserSidOffset: DWORD,
 DataLength: DWORD,
 DataOffset: DWORD
});

var _EVENTSFORLOGFILE = STRUCT('_EVENTSFORLOGFILE', {
 ulSize: DWORD,
 szLogicalLogFile: pointer,
 ulNumRecords: DWORD,
 pEventLogRecords: pointer
});

var _PACKEDEVENTINFO = STRUCT('_PACKEDEVENTINFO', {
 ulSize: DWORD,
 ulNumEventsForLogFile: DWORD,
 ulOffsets: pointer
});

var TAPE_ERASE = STRUCT('TAPE_ERASE', {
 Type: DWORD,
 Immediate: BOOLEAN
});

var TAPE_PREPARE = STRUCT('TAPE_PREPARE', {
 Operation: DWORD,
 Immediate: BOOLEAN
});

var TAPE_WRITE_MARKS = STRUCT('TAPE_WRITE_MARKS', {
 Type: DWORD,
 Count: DWORD,
 Immediate: BOOLEAN
});

var TAPE_GET_POSITION = STRUCT('TAPE_GET_POSITION', {
 Type: DWORD,
 Partition: DWORD,
 Offset: LARGE_INTEGER
});

var TAPE_SET_POSITION = STRUCT('TAPE_SET_POSITION', {
 Method: DWORD,
 Partition: DWORD,
 Offset: LARGE_INTEGER,
 Immediate: BOOLEAN
});

var TAPE_GET_DRIVE_PARAMETERS = STRUCT('TAPE_GET_DRIVE_PARAMETERS', {
 ECC: BOOLEAN,
 Compression: BOOLEAN,
 DataPadding: BOOLEAN,
 ReportSetmarks: BOOLEAN,
 DefaultBlockSize: DWORD,
 MaximumBlockSize: DWORD,
 MinimumBlockSize: DWORD,
 MaximumPartitionCount: DWORD,
 FeaturesLow: DWORD,
 FeaturesHigh: DWORD,
 EOTWarningZoneSize: DWORD
});

var TAPE_SET_DRIVE_PARAMETERS = STRUCT('TAPE_SET_DRIVE_PARAMETERS', {
 ECC: BOOLEAN,
 Compression: BOOLEAN,
 DataPadding: BOOLEAN,
 ReportSetmarks: BOOLEAN,
 EOTWarningZoneSize: DWORD
});

var TAPE_GET_MEDIA_PARAMETERS = STRUCT('TAPE_GET_MEDIA_PARAMETERS', {
 Capacity: LARGE_INTEGER,
 Remaining: LARGE_INTEGER,
 BlockSize: DWORD,
 PartitionCount: DWORD,
 WriteProtected: BOOLEAN
});

var TAPE_SET_MEDIA_PARAMETERS = STRUCT('TAPE_SET_MEDIA_PARAMETERS', {
 BlockSize: DWORD
});

var TAPE_CREATE_PARTITION = STRUCT('TAPE_CREATE_PARTITION', {
 Method: DWORD,
 Count: DWORD,
 Size: DWORD
});

var TAPE_WMI_OPERATIONS = STRUCT('TAPE_WMI_OPERATIONS', {
 Method: DWORD,
 DataBufferSize: DWORD,
 DataBuffer: PVOID
});

var TRANSACTION_NOTIFICATION = STRUCT('TRANSACTION_NOTIFICATION', {
 TransactionKey: PVOID,
 TransactionNotification: ULONG,
 TmVirtualClock: LARGE_INTEGER,
 ArgumentLength: ULONG
});

var TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT = STRUCT('TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT', {
 EnlistmentId: GUID,
 UOW: UOW
});

var TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT = STRUCT('TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT', {
 TmIdentity: GUID,
 Flags: ULONG
});

var TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT = STRUCT('TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT', {
 SavepointId: SAVEPOINT_ID
});

var TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT = STRUCT('TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT', {
 PropagationCookie: ULONG,
 UOW: GUID,
 TmIdentity: GUID,
 BufferLength: ULONG
});

var TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT = STRUCT('TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT', {
 MarshalCookie: ULONG,
 UOW: GUID
});

var KCRM_MARSHAL_HEADER = STRUCT('KCRM_MARSHAL_HEADER', {
 VersionMajor: ULONG,
 VersionMinor: ULONG,
 NumProtocols: ULONG,
 Unused: ULONG
});

var KCRM_TRANSACTION_BLOB = STRUCT('KCRM_TRANSACTION_BLOB', {
 UOW: UOW,
 TmIdentity: GUID,
 IsolationLevel: ULONG,
 IsolationFlags: ULONG,
 Timeout: ULONG,
 Description: pointer
});

var KCRM_PROTOCOL_BLOB = STRUCT('KCRM_PROTOCOL_BLOB', {
 ProtocolId: CRM_PROTOCOL_ID,
 StaticInfoLength: ULONG,
 TransactionIdInfoLength: ULONG,
 Unused1: ULONG,
 Unused2: ULONG
});

var TRANSACTION_BASIC_INFORMATION = STRUCT('TRANSACTION_BASIC_INFORMATION', {
 TransactionId: GUID,
 State: DWORD,
 Outcome: DWORD
});

var TRANSACTIONMANAGER_BASIC_INFORMATION = STRUCT('TRANSACTIONMANAGER_BASIC_INFORMATION', {
 TmIdentity: GUID,
 VirtualClock: LARGE_INTEGER
});

var TRANSACTIONMANAGER_LOG_INFORMATION = STRUCT('TRANSACTIONMANAGER_LOG_INFORMATION', {
 LogIdentity: GUID
});

var TRANSACTIONMANAGER_LOGPATH_INFORMATION = STRUCT('TRANSACTIONMANAGER_LOGPATH_INFORMATION', {
 LogPathLength: DWORD,
 LogPath: pointer
});

var TRANSACTIONMANAGER_RECOVERY_INFORMATION = STRUCT('TRANSACTIONMANAGER_RECOVERY_INFORMATION', {
 LastRecoveredLsn: ULONGLONG
});

var TRANSACTIONMANAGER_OLDEST_INFORMATION = STRUCT('TRANSACTIONMANAGER_OLDEST_INFORMATION', {
 OldestTransactionGuid: GUID
});

var TRANSACTION_PROPERTIES_INFORMATION = STRUCT('TRANSACTION_PROPERTIES_INFORMATION', {
 IsolationLevel: DWORD,
 IsolationFlags: DWORD,
 Timeout: LARGE_INTEGER,
 Outcome: DWORD,
 DescriptionLength: DWORD,
 Description: pointer
});

var TRANSACTION_BIND_INFORMATION = STRUCT('TRANSACTION_BIND_INFORMATION', {
 TmHandle: HANDLE
});

var TRANSACTION_ENLISTMENT_PAIR = STRUCT('TRANSACTION_ENLISTMENT_PAIR', {
 EnlistmentId: GUID,
 ResourceManagerId: GUID
});

var TRANSACTION_ENLISTMENTS_INFORMATION = STRUCT('TRANSACTION_ENLISTMENTS_INFORMATION', {
 NumberOfEnlistments: DWORD,
 EnlistmentPair: pointer
});

var TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION = STRUCT('TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION', {
 SuperiorEnlistmentPair: TRANSACTION_ENLISTMENT_PAIR
});

var RESOURCEMANAGER_BASIC_INFORMATION = STRUCT('RESOURCEMANAGER_BASIC_INFORMATION', {
 ResourceManagerId: GUID,
 DescriptionLength: DWORD,
 Description: pointer
});

var RESOURCEMANAGER_COMPLETION_INFORMATION = STRUCT('RESOURCEMANAGER_COMPLETION_INFORMATION', {
 IoCompletionPortHandle: HANDLE,
 CompletionKey: ULONG_PTR
});

var ENLISTMENT_BASIC_INFORMATION = STRUCT('ENLISTMENT_BASIC_INFORMATION', {
 EnlistmentId: GUID,
 TransactionId: GUID,
 ResourceManagerId: GUID
});

var ENLISTMENT_CRM_INFORMATION = STRUCT('ENLISTMENT_CRM_INFORMATION', {
 CrmTransactionManagerId: GUID,
 CrmResourceManagerId: GUID,
 CrmEnlistmentId: GUID
});

var TRANSACTION_LIST_ENTRY = STRUCT('TRANSACTION_LIST_ENTRY', {
 UOW: UOW
});

var TRANSACTION_LIST_INFORMATION = STRUCT('TRANSACTION_LIST_INFORMATION', {
 NumberOfTransactions: DWORD,
 TransactionInformation: pointer
});

var KTMOBJECT_CURSOR = STRUCT('KTMOBJECT_CURSOR', {
 LastQuery: GUID,
 ObjectIdCount: DWORD,
 ObjectIds: pointer
});



var TP_POOL_STACK_INFORMATION = STRUCT('TP_POOL_STACK_INFORMATION', {
 StackReserve: SIZE_T,
 StackCommit: SIZE_T
});


var TP_CALLBACK_ENVIRON = STRUCT('TP_CALLBACK_ENVIRON', {
 Version: TP_VERSION,
 Pool: PTP_POOL,
 CleanupGroup: PTP_CLEANUP_GROUP,
 CleanupGroupCancelCallback: PTP_CLEANUP_GROUP_CANCEL_CALLBACK,
 RaceDll: PVOID,
 ActivationContext: PTR(_ACTIVATION_CONTEXT),
 FinalizationCallback: PTP_SIMPLE_CALLBACK,
 u: ,
 CallbackPriority: TP_CALLBACK_PRIORITY,
 Size: DWORD
});


var undefined = STRUCT('undefined', {
 LongFunction: DWORD,
 Persistent: DWORD,
 Private: DWORD
});





var HWND__ = STRUCT('HWND__', {
 unused: int
});

var HHOOK__ = STRUCT('HHOOK__', {
 unused: int
});

var HKEY__ = STRUCT('HKEY__', {
 unused: int
});

var HACCEL__ = STRUCT('HACCEL__', {
 unused: int
});

var HBITMAP__ = STRUCT('HBITMAP__', {
 unused: int
});

var HBRUSH__ = STRUCT('HBRUSH__', {
 unused: int
});

var HCOLORSPACE__ = STRUCT('HCOLORSPACE__', {
 unused: int
});

var HDC__ = STRUCT('HDC__', {
 unused: int
});

var HGLRC__ = STRUCT('HGLRC__', {
 unused: int
});

var HDESK__ = STRUCT('HDESK__', {
 unused: int
});

var HENHMETAFILE__ = STRUCT('HENHMETAFILE__', {
 unused: int
});

var HFONT__ = STRUCT('HFONT__', {
 unused: int
});

var HICON__ = STRUCT('HICON__', {
 unused: int
});

var HMENU__ = STRUCT('HMENU__', {
 unused: int
});

var HMETAFILE__ = STRUCT('HMETAFILE__', {
 unused: int
});

var HINSTANCE__ = STRUCT('HINSTANCE__', {
 unused: int
});

var HPALETTE__ = STRUCT('HPALETTE__', {
 unused: int
});

var HPEN__ = STRUCT('HPEN__', {
 unused: int
});

var HRGN__ = STRUCT('HRGN__', {
 unused: int
});

var HRSRC__ = STRUCT('HRSRC__', {
 unused: int
});

var HSPRITE__ = STRUCT('HSPRITE__', {
 unused: int
});

var HLSURF__ = STRUCT('HLSURF__', {
 unused: int
});

var HSTR__ = STRUCT('HSTR__', {
 unused: int
});

var HTASK__ = STRUCT('HTASK__', {
 unused: int
});

var HWINSTA__ = STRUCT('HWINSTA__', {
 unused: int
});

var HKL__ = STRUCT('HKL__', {
 unused: int
});

var HWINEVENTHOOK__ = STRUCT('HWINEVENTHOOK__', {
 unused: int
});

var HMONITOR__ = STRUCT('HMONITOR__', {
 unused: int
});

var HUMPD__ = STRUCT('HUMPD__', {
 unused: int
});

var BORDERWIDTHS = STRUCT('BORDERWIDTHS', {
 left: LONG,
 top: LONG,
 right: LONG,
 bottom: LONG
});

var RECTL = STRUCT('RECTL', {
 left: LONG,
 top: LONG,
 right: LONG,
 bottom: LONG
});

var POINT = STRUCT('POINT', {
 x: LONG,
 y: LONG
});

var POINTL = STRUCT('POINTL', {
 x: LONG,
 y: LONG
});

var SIZEL = STRUCT('SIZEL', {
 cx: LONG,
 cy: LONG
});

var POINTS = STRUCT('POINTS', {
 x: SHORT,
 y: SHORT
});

var FILETIME = STRUCT('FILETIME', {
 dwLowDateTime: DWORD,
 dwHighDateTime: DWORD
});

var OVERLAPPED = STRUCT('OVERLAPPED', {
 Internal: ULONG_PTR,
 InternalHigh: ULONG_PTR,
 hEvent: HANDLE
});

var undefined = STRUCT('undefined', {
 Offset: DWORD,
 OffsetHigh: DWORD
});

var OVERLAPPED_ENTRY = STRUCT('OVERLAPPED_ENTRY', {
 lpCompletionKey: ULONG_PTR,
 lpOverlapped: LPOVERLAPPED,
 Internal: ULONG_PTR,
 dwNumberOfBytesTransferred: DWORD
});

var SECURITY_ATTRIBUTES = STRUCT('SECURITY_ATTRIBUTES', {
 nLength: DWORD,
 lpSecurityDescriptor: LPVOID,
 bInheritHandle: BOOL
});

var PROCESS_INFORMATION = STRUCT('PROCESS_INFORMATION', {
 hProcess: HANDLE,
 hThread: HANDLE,
 dwProcessId: DWORD,
 dwThreadId: DWORD
});

var SYSTEMTIME = STRUCT('SYSTEMTIME', {
 wYear: WORD,
 wMonth: WORD,
 wDayOfWeek: WORD,
 wDay: WORD,
 wHour: WORD,
 wMinute: WORD,
 wSecond: WORD,
 wMilliseconds: WORD
});

var COMMPROP = STRUCT('COMMPROP', {
 wPacketLength: WORD,
 wPacketVersion: WORD,
 dwServiceMask: DWORD,
 dwReserved1: DWORD,
 dwMaxTxQueue: DWORD,
 dwMaxRxQueue: DWORD,
 dwMaxBaud: DWORD,
 dwProvSubType: DWORD,
 dwProvCapabilities: DWORD,
 dwSettableParams: DWORD,
 dwSettableBaud: DWORD,
 wSettableData: WORD,
 wSettableStopParity: WORD,
 dwCurrentTxQueue: DWORD,
 dwCurrentRxQueue: DWORD,
 dwProvSpec1: DWORD,
 dwProvSpec2: DWORD,
 wcProvChar: pointer
});

var COMSTAT = STRUCT('COMSTAT', {
 fCtsHold: DWORD,
 fDsrHold: DWORD,
 fRlsdHold: DWORD,
 fXoffHold: DWORD,
 fXoffSent: DWORD,
 fEof: DWORD,
 fTxim: DWORD,
 fReserved: DWORD,
 cbInQue: DWORD,
 cbOutQue: DWORD
});

var DCB = STRUCT('DCB', {
 DCBlength: DWORD,
 BaudRate: DWORD,
 fBinary: DWORD,
 fParity: DWORD,
 fOutxCtsFlow: DWORD,
 fOutxDsrFlow: DWORD,
 fDtrControl: DWORD,
 fDsrSensitivity: DWORD,
 fTXContinueOnXoff: DWORD,
 fOutX: DWORD,
 fInX: DWORD,
 fErrorChar: DWORD,
 fNull: DWORD,
 fRtsControl: DWORD,
 fAbortOnError: DWORD,
 fDummy2: DWORD,
 wReserved: WORD,
 XonLim: WORD,
 XoffLim: WORD,
 ByteSize: BYTE,
 Parity: BYTE,
 StopBits: BYTE,
 XonChar: int8,
 XoffChar: int8,
 ErrorChar: int8,
 EofChar: int8,
 EvtChar: int8,
 wReserved1: WORD
});

var COMMTIMEOUTS = STRUCT('COMMTIMEOUTS', {
 ReadIntervalTimeout: DWORD,
 ReadTotalTimeoutMultiplier: DWORD,
 ReadTotalTimeoutConstant: DWORD,
 WriteTotalTimeoutMultiplier: DWORD,
 WriteTotalTimeoutConstant: DWORD
});

var COMMCONFIG = STRUCT('COMMCONFIG', {
 dwSize: DWORD,
 wVersion: WORD,
 wReserved: WORD,
 dcb: DCB,
 dwProviderSubType: DWORD,
 dwProviderOffset: DWORD,
 dwProviderSize: DWORD,
 wcProviderData: pointer
});

var SYSTEM_INFO = STRUCT('SYSTEM_INFO', {
 dwPageSize: DWORD,
 lpMinimumApplicationAddress: LPVOID,
 lpMaximumApplicationAddress: LPVOID,
 dwActiveProcessorMask: DWORD_PTR,
 dwNumberOfProcessors: DWORD,
 dwProcessorType: DWORD,
 dwAllocationGranularity: DWORD,
 wProcessorLevel: WORD,
 wProcessorRevision: WORD
});

var undefined = STRUCT('undefined', {
 wProcessorArchitecture: WORD,
 wReserved: WORD
});

var MEMORYSTATUS = STRUCT('MEMORYSTATUS', {
 dwLength: DWORD,
 dwMemoryLoad: DWORD,
 dwTotalPhys: SIZE_T,
 dwAvailPhys: SIZE_T,
 dwTotalPageFile: SIZE_T,
 dwAvailPageFile: SIZE_T,
 dwTotalVirtual: SIZE_T,
 dwAvailVirtual: SIZE_T
});

var EXCEPTION_DEBUG_INFO = STRUCT('EXCEPTION_DEBUG_INFO', {
 ExceptionRecord: EXCEPTION_RECORD,
 dwFirstChance: DWORD
});

var CREATE_THREAD_DEBUG_INFO = STRUCT('CREATE_THREAD_DEBUG_INFO', {
 hThread: HANDLE,
 lpThreadLocalBase: LPVOID,
 lpStartAddress: LPTHREAD_START_ROUTINE
});

var CREATE_PROCESS_DEBUG_INFO = STRUCT('CREATE_PROCESS_DEBUG_INFO', {
 hFile: HANDLE,
 hProcess: HANDLE,
 hThread: HANDLE,
 lpBaseOfImage: LPVOID,
 dwDebugInfoFileOffset: DWORD,
 nDebugInfoSize: DWORD,
 lpThreadLocalBase: LPVOID,
 lpStartAddress: LPTHREAD_START_ROUTINE,
 lpImageName: LPVOID,
 fUnicode: WORD
});

var EXIT_THREAD_DEBUG_INFO = STRUCT('EXIT_THREAD_DEBUG_INFO', {
 dwExitCode: DWORD
});

var EXIT_PROCESS_DEBUG_INFO = STRUCT('EXIT_PROCESS_DEBUG_INFO', {
 dwExitCode: DWORD
});

var LOAD_DLL_DEBUG_INFO = STRUCT('LOAD_DLL_DEBUG_INFO', {
 hFile: HANDLE,
 lpBaseOfDll: LPVOID,
 dwDebugInfoFileOffset: DWORD,
 nDebugInfoSize: DWORD,
 lpImageName: LPVOID,
 fUnicode: WORD
});

var UNLOAD_DLL_DEBUG_INFO = STRUCT('UNLOAD_DLL_DEBUG_INFO', {
 lpBaseOfDll: LPVOID
});

var OUTPUT_DEBUG_STRING_INFO = STRUCT('OUTPUT_DEBUG_STRING_INFO', {
 lpDebugStringData: LPSTR,
 fUnicode: WORD,
 nDebugStringLength: WORD
});

var RIP_INFO = STRUCT('RIP_INFO', {
 dwError: DWORD,
 dwType: DWORD
});

var DEBUG_EVENT = STRUCT('DEBUG_EVENT', {
 dwDebugEventCode: DWORD,
 dwProcessId: DWORD,
 dwThreadId: DWORD,
 u: 
});

var JIT_DEBUG_INFO64 = STRUCT('JIT_DEBUG_INFO64', {
 dwSize: DWORD,
 dwProcessorArchitecture: DWORD,
 dwThreadID: DWORD,
 dwReserved0: DWORD,
 lpExceptionAddress: ULONG64,
 lpExceptionRecord: ULONG64,
 lpContextRecord: ULONG64
});

var OFSTRUCT = STRUCT('OFSTRUCT', {
 cBytes: BYTE,
 fFixedDisk: BYTE,
 nErrCode: WORD,
 Reserved1: WORD,
 Reserved2: WORD,
 szPathName: pointer
});

var MEMORYSTATUSEX = STRUCT('MEMORYSTATUSEX', {
 dwLength: DWORD,
 dwMemoryLoad: DWORD,
 ullTotalPhys: DWORDLONG,
 ullAvailPhys: DWORDLONG,
 ullTotalPageFile: DWORDLONG,
 ullAvailPageFile: DWORDLONG,
 ullTotalVirtual: DWORDLONG,
 ullAvailVirtual: DWORDLONG,
 ullAvailExtendedVirtual: DWORDLONG
});

var PROCESS_HEAP_ENTRY = STRUCT('PROCESS_HEAP_ENTRY', {
 lpData: PVOID,
 cbData: DWORD,
 cbOverhead: BYTE,
 iRegionIndex: BYTE,
 wFlags: WORD
});

var undefined = STRUCT('undefined', {
 hMem: HANDLE,
 dwReserved: pointer
});

var undefined = STRUCT('undefined', {
 dwCommittedSize: DWORD,
 dwUnCommittedSize: DWORD,
 lpFirstBlock: LPVOID,
 lpLastBlock: LPVOID
});

var UMS_SCHEDULER_STARTUP_INFO = STRUCT('UMS_SCHEDULER_STARTUP_INFO', {
 UmsVersion: ULONG,
 CompletionList: PUMS_COMPLETION_LIST,
 SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT,
 SchedulerParam: PVOID
});


var POWER_REQUEST_CONTEXT = STRUCT('POWER_REQUEST_CONTEXT', {
 Version: ULONG,
 Flags: DWORD,
 Reason: 
});

var undefined = STRUCT('undefined', {
 LocalizedReasonModule: HMODULE,
 LocalizedReasonId: ULONG,
 ReasonStringCount: ULONG,
 ReasonStrings: PTR(PTR(ushort))
});

var BY_HANDLE_FILE_INFORMATION = STRUCT('BY_HANDLE_FILE_INFORMATION', {
 dwFileAttributes: DWORD,
 ftCreationTime: FILETIME,
 ftLastAccessTime: FILETIME,
 ftLastWriteTime: FILETIME,
 dwVolumeSerialNumber: DWORD,
 nFileSizeHigh: DWORD,
 nFileSizeLow: DWORD,
 nNumberOfLinks: DWORD,
 nFileIndexHigh: DWORD,
 nFileIndexLow: DWORD
});

var TIME_ZONE_INFORMATION = STRUCT('TIME_ZONE_INFORMATION', {
 Bias: LONG,
 StandardName: pointer,
 StandardDate: SYSTEMTIME,
 StandardBias: LONG,
 DaylightName: pointer,
 DaylightDate: SYSTEMTIME,
 DaylightBias: LONG
});

var DYNAMIC_TIME_ZONE_INFORMATION = STRUCT('DYNAMIC_TIME_ZONE_INFORMATION', {
 Bias: LONG,
 StandardName: pointer,
 StandardDate: SYSTEMTIME,
 StandardBias: LONG,
 DaylightName: pointer,
 DaylightDate: SYSTEMTIME,
 DaylightBias: LONG,
 TimeZoneKeyName: pointer,
 DynamicDaylightTimeDisabled: BOOLEAN
});

var WIN32_STREAM_ID = STRUCT('WIN32_STREAM_ID', {
 dwStreamId: DWORD,
 dwStreamAttributes: DWORD,
 Size: LARGE_INTEGER,
 dwStreamNameSize: DWORD,
 cStreamName: pointer
});

var STARTUPINFO = STRUCT('STARTUPINFO', {
 cb: DWORD,
 lpReserved: LPSTR,
 lpDesktop: LPSTR,
 lpTitle: LPSTR,
 dwX: DWORD,
 dwY: DWORD,
 dwXSize: DWORD,
 dwYSize: DWORD,
 dwXCountChars: DWORD,
 dwYCountChars: DWORD,
 dwFillAttribute: DWORD,
 dwFlags: DWORD,
 wShowWindow: WORD,
 cbReserved2: WORD,
 lpReserved2: LPBYTE,
 hStdInput: HANDLE,
 hStdOutput: HANDLE,
 hStdError: HANDLE
});

var STARTUPINFOW = STRUCT('STARTUPINFOW', {
 cb: DWORD,
 lpReserved: LPWSTR,
 lpDesktop: LPWSTR,
 lpTitle: LPWSTR,
 dwX: DWORD,
 dwY: DWORD,
 dwXSize: DWORD,
 dwYSize: DWORD,
 dwXCountChars: DWORD,
 dwYCountChars: DWORD,
 dwFillAttribute: DWORD,
 dwFlags: DWORD,
 wShowWindow: WORD,
 cbReserved2: WORD,
 lpReserved2: LPBYTE,
 hStdInput: HANDLE,
 hStdOutput: HANDLE,
 hStdError: HANDLE
});

var STARTUPINFOEX = STRUCT('STARTUPINFOEX', {
 StartupInfo: STARTUPINFOA,
 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST
});

var STARTUPINFOEXW = STRUCT('STARTUPINFOEXW', {
 StartupInfo: STARTUPINFOW,
 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST
});

var WIN32_FIND_DATA = STRUCT('WIN32_FIND_DATA', {
 dwFileAttributes: DWORD,
 ftCreationTime: FILETIME,
 ftLastAccessTime: FILETIME,
 ftLastWriteTime: FILETIME,
 nFileSizeHigh: DWORD,
 nFileSizeLow: DWORD,
 dwReserved0: DWORD,
 dwReserved1: DWORD,
 cFileName: pointer,
 cAlternateFileName: pointer
});

var WIN32_FIND_DATAW = STRUCT('WIN32_FIND_DATAW', {
 dwFileAttributes: DWORD,
 ftCreationTime: FILETIME,
 ftLastAccessTime: FILETIME,
 ftLastWriteTime: FILETIME,
 nFileSizeHigh: DWORD,
 nFileSizeLow: DWORD,
 dwReserved0: DWORD,
 dwReserved1: DWORD,
 cFileName: pointer,
 cAlternateFileName: pointer
});

var WIN32_FILE_ATTRIBUTE_DATA = STRUCT('WIN32_FILE_ATTRIBUTE_DATA', {
 dwFileAttributes: DWORD,
 ftCreationTime: FILETIME,
 ftLastAccessTime: FILETIME,
 ftLastWriteTime: FILETIME,
 nFileSizeHigh: DWORD,
 nFileSizeLow: DWORD
});

var WIN32_FIND_STREAM_DATA = STRUCT('WIN32_FIND_STREAM_DATA', {
 StreamSize: LARGE_INTEGER,
 cStreamName: pointer
});

var EVENTLOG_FULL_INFORMATION = STRUCT('EVENTLOG_FULL_INFORMATION', {
 dwFull: DWORD
});

var HW_PROFILE_INFO = STRUCT('HW_PROFILE_INFO', {
 dwDockInfo: DWORD,
 szHwProfileGuid: pointer,
 szHwProfileName: pointer
});

var HW_PROFILE_INFOW = STRUCT('HW_PROFILE_INFOW', {
 dwDockInfo: DWORD,
 szHwProfileGuid: pointer,
 szHwProfileName: pointer
});

var SYSTEM_POWER_STATUS = STRUCT('SYSTEM_POWER_STATUS', {
 ACLineStatus: BYTE,
 BatteryFlag: BYTE,
 BatteryLifePercent: BYTE,
 Reserved1: BYTE,
 BatteryLifeTime: DWORD,
 BatteryFullLifeTime: DWORD
});

var ACTCTX = STRUCT('ACTCTX', {
 cbSize: ULONG,
 dwFlags: DWORD,
 lpSource: LPCSTR,
 wProcessorArchitecture: USHORT,
 wLangId: LANGID,
 lpAssemblyDirectory: LPCSTR,
 lpResourceName: LPCSTR,
 lpApplicationName: LPCSTR,
 hModule: HMODULE
});

var ACTCTXW = STRUCT('ACTCTXW', {
 cbSize: ULONG,
 dwFlags: DWORD,
 lpSource: LPCWSTR,
 wProcessorArchitecture: USHORT,
 wLangId: LANGID,
 lpAssemblyDirectory: LPCWSTR,
 lpResourceName: LPCWSTR,
 lpApplicationName: LPCWSTR,
 hModule: HMODULE
});

var ACTCTX_SECTION_KEYED_DATA_2600 = STRUCT('ACTCTX_SECTION_KEYED_DATA_2600', {
 cbSize: ULONG,
 ulDataFormatVersion: ULONG,
 lpData: PVOID,
 ulLength: ULONG,
 lpSectionGlobalData: PVOID,
 ulSectionGlobalDataLength: ULONG,
 lpSectionBase: PVOID,
 ulSectionTotalLength: ULONG,
 hActCtx: HANDLE,
 ulAssemblyRosterIndex: ULONG
});

var ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = STRUCT('ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA', {
 lpInformation: PVOID,
 lpSectionBase: PVOID,
 ulSectionLength: ULONG,
 lpSectionGlobalDataBase: PVOID,
 ulSectionGlobalDataLength: ULONG
});

var ACTCTX_SECTION_KEYED_DATA = STRUCT('ACTCTX_SECTION_KEYED_DATA', {
 cbSize: ULONG,
 ulDataFormatVersion: ULONG,
 lpData: PVOID,
 ulLength: ULONG,
 lpSectionGlobalData: PVOID,
 ulSectionGlobalDataLength: ULONG,
 lpSectionBase: PVOID,
 ulSectionTotalLength: ULONG,
 hActCtx: HANDLE,
 ulAssemblyRosterIndex: ULONG,
 ulFlags: ULONG,
 AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA
});

var ACTIVATION_CONTEXT_BASIC_INFORMATION = STRUCT('ACTIVATION_CONTEXT_BASIC_INFORMATION', {
 hActCtx: HANDLE,
 dwFlags: DWORD
});

var FILE_BASIC_INFO = STRUCT('FILE_BASIC_INFO', {
 CreationTime: LARGE_INTEGER,
 LastAccessTime: LARGE_INTEGER,
 LastWriteTime: LARGE_INTEGER,
 ChangeTime: LARGE_INTEGER,
 FileAttributes: DWORD
});

var FILE_STANDARD_INFO = STRUCT('FILE_STANDARD_INFO', {
 AllocationSize: LARGE_INTEGER,
 EndOfFile: LARGE_INTEGER,
 NumberOfLinks: DWORD,
 DeletePending: BOOLEAN,
 Directory: BOOLEAN
});

var FILE_NAME_INFO = STRUCT('FILE_NAME_INFO', {
 FileNameLength: DWORD,
 FileName: pointer
});

var FILE_RENAME_INFO = STRUCT('FILE_RENAME_INFO', {
 ReplaceIfExists: BOOLEAN,
 RootDirectory: HANDLE,
 FileNameLength: DWORD,
 FileName: pointer
});

var FILE_ALLOCATION_INFO = STRUCT('FILE_ALLOCATION_INFO', {
 AllocationSize: LARGE_INTEGER
});

var FILE_END_OF_FILE_INFO = STRUCT('FILE_END_OF_FILE_INFO', {
 EndOfFile: LARGE_INTEGER
});

var FILE_STREAM_INFO = STRUCT('FILE_STREAM_INFO', {
 NextEntryOffset: DWORD,
 StreamNameLength: DWORD,
 StreamSize: LARGE_INTEGER,
 StreamAllocationSize: LARGE_INTEGER,
 StreamName: pointer
});

var FILE_COMPRESSION_INFO = STRUCT('FILE_COMPRESSION_INFO', {
 CompressedFileSize: LARGE_INTEGER,
 CompressionFormat: WORD,
 CompressionUnitShift: UCHAR,
 ChunkShift: UCHAR,
 ClusterShift: UCHAR,
 Reserved: pointer
});

var FILE_ATTRIBUTE_TAG_INFO = STRUCT('FILE_ATTRIBUTE_TAG_INFO', {
 FileAttributes: DWORD,
 ReparseTag: DWORD
});

var FILE_DISPOSITION_INFO = STRUCT('FILE_DISPOSITION_INFO', {
 DeleteFileA: BOOLEAN
});

var FILE_ID_BOTH_DIR_INFO = STRUCT('FILE_ID_BOTH_DIR_INFO', {
 NextEntryOffset: DWORD,
 FileIndex: DWORD,
 CreationTime: LARGE_INTEGER,
 LastAccessTime: LARGE_INTEGER,
 LastWriteTime: LARGE_INTEGER,
 ChangeTime: LARGE_INTEGER,
 EndOfFile: LARGE_INTEGER,
 AllocationSize: LARGE_INTEGER,
 FileAttributes: DWORD,
 FileNameLength: DWORD,
 EaSize: DWORD,
 ShortNameLength: CCHAR,
 ShortName: pointer,
 FileId: LARGE_INTEGER,
 FileName: pointer
});

var FILE_IO_PRIORITY_HINT_INFO = STRUCT('FILE_IO_PRIORITY_HINT_INFO', {
 PriorityHint: PRIORITY_HINT
});

var FILE_REMOTE_PROTOCOL_INFO = STRUCT('FILE_REMOTE_PROTOCOL_INFO', {
 StructureVersion: USHORT,
 StructureSize: USHORT,
 Protocol: DWORD,
 ProtocolMajorVersion: USHORT,
 ProtocolMinorVersion: USHORT,
 ProtocolRevision: USHORT,
 Reserved: USHORT,
 Flags: DWORD,
 GenericReserved: ,
 ProtocolSpecificReserved: 
});

var undefined = STRUCT('undefined', {
 Reserved: pointer
});

var undefined = STRUCT('undefined', {
 Reserved: pointer
});

var FILE_ID_DESCRIPTOR = STRUCT('FILE_ID_DESCRIPTOR', {
 dwSize: DWORD,
 Type: FILE_ID_TYPE
});

var DRAWPATRECT = STRUCT('DRAWPATRECT', {
 ptPosition: POINT,
 ptSize: POINT,
 wStyle: WORD,
 wPattern: WORD
});

var PSINJECTDATA = STRUCT('PSINJECTDATA', {
 DataBytes: DWORD,
 InjectionPoint: WORD,
 PageNumber: WORD
});

var PSFEATURE_OUTPUT = STRUCT('PSFEATURE_OUTPUT', {
 bPageIndependent: BOOL,
 bSetPageDevice: BOOL
});

var PSFEATURE_CUSTPAPER = STRUCT('PSFEATURE_CUSTPAPER', {
 lOrientation: LONG,
 lWidth: LONG,
 lHeight: LONG,
 lWidthOffset: LONG,
 lHeightOffset: LONG
});

var XFORM = STRUCT('XFORM', {
 eM11: FLOAT,
 eM12: FLOAT,
 eM21: FLOAT,
 eM22: FLOAT,
 eDx: FLOAT,
 eDy: FLOAT
});

var BITMAP = STRUCT('BITMAP', {
 bmType: LONG,
 bmWidth: LONG,
 bmHeight: LONG,
 bmWidthBytes: LONG,
 bmPlanes: WORD,
 bmBitsPixel: WORD,
 bmBits: LPVOID
});

var RGBTRIPLE = STRUCT('RGBTRIPLE', {
 rgbtBlue: BYTE,
 rgbtGreen: BYTE,
 rgbtRed: BYTE
});

var RGBQUAD = STRUCT('RGBQUAD', {
 rgbBlue: BYTE,
 rgbGreen: BYTE,
 rgbRed: BYTE,
 rgbReserved: BYTE
});

var CIEXYZ = STRUCT('CIEXYZ', {
 ciexyzX: FXPT2DOT30,
 ciexyzY: FXPT2DOT30,
 ciexyzZ: FXPT2DOT30
});

var CIEXYZTRIPLE = STRUCT('CIEXYZTRIPLE', {
 ciexyzRed: CIEXYZ,
 ciexyzGreen: CIEXYZ,
 ciexyzBlue: CIEXYZ
});

var LOGCOLORSPACE = STRUCT('LOGCOLORSPACE', {
 lcsSignature: DWORD,
 lcsVersion: DWORD,
 lcsSize: DWORD,
 lcsCSType: LCSCSTYPE,
 lcsIntent: LCSGAMUTMATCH,
 lcsEndpoints: CIEXYZTRIPLE,
 lcsGammaRed: DWORD,
 lcsGammaGreen: DWORD,
 lcsGammaBlue: DWORD,
 lcsFilename: pointer
});

var LOGCOLORSPACEW = STRUCT('LOGCOLORSPACEW', {
 lcsSignature: DWORD,
 lcsVersion: DWORD,
 lcsSize: DWORD,
 lcsCSType: LCSCSTYPE,
 lcsIntent: LCSGAMUTMATCH,
 lcsEndpoints: CIEXYZTRIPLE,
 lcsGammaRed: DWORD,
 lcsGammaGreen: DWORD,
 lcsGammaBlue: DWORD,
 lcsFilename: pointer
});

var BITMAPCOREHEADER = STRUCT('BITMAPCOREHEADER', {
 bcSize: DWORD,
 bcWidth: WORD,
 bcHeight: WORD,
 bcPlanes: WORD,
 bcBitCount: WORD
});

var BITMAPINFOHEADER = STRUCT('BITMAPINFOHEADER', {
 biSize: DWORD,
 biWidth: LONG,
 biHeight: LONG,
 biPlanes: WORD,
 biBitCount: WORD,
 biCompression: DWORD,
 biSizeImage: DWORD,
 biXPelsPerMeter: LONG,
 biYPelsPerMeter: LONG,
 biClrUsed: DWORD,
 biClrImportant: DWORD
});

var BITMAPV4HEADER = STRUCT('BITMAPV4HEADER', {
 bV4Size: DWORD,
 bV4Width: LONG,
 bV4Height: LONG,
 bV4Planes: WORD,
 bV4BitCount: WORD,
 bV4V4Compression: DWORD,
 bV4SizeImage: DWORD,
 bV4XPelsPerMeter: LONG,
 bV4YPelsPerMeter: LONG,
 bV4ClrUsed: DWORD,
 bV4ClrImportant: DWORD,
 bV4RedMask: DWORD,
 bV4GreenMask: DWORD,
 bV4BlueMask: DWORD,
 bV4AlphaMask: DWORD,
 bV4CSType: DWORD,
 bV4Endpoints: CIEXYZTRIPLE,
 bV4GammaRed: DWORD,
 bV4GammaGreen: DWORD,
 bV4GammaBlue: DWORD
});

var BITMAPV5HEADER = STRUCT('BITMAPV5HEADER', {
 bV5Size: DWORD,
 bV5Width: LONG,
 bV5Height: LONG,
 bV5Planes: WORD,
 bV5BitCount: WORD,
 bV5Compression: DWORD,
 bV5SizeImage: DWORD,
 bV5XPelsPerMeter: LONG,
 bV5YPelsPerMeter: LONG,
 bV5ClrUsed: DWORD,
 bV5ClrImportant: DWORD,
 bV5RedMask: DWORD,
 bV5GreenMask: DWORD,
 bV5BlueMask: DWORD,
 bV5AlphaMask: DWORD,
 bV5CSType: DWORD,
 bV5Endpoints: CIEXYZTRIPLE,
 bV5GammaRed: DWORD,
 bV5GammaGreen: DWORD,
 bV5GammaBlue: DWORD,
 bV5Intent: DWORD,
 bV5ProfileData: DWORD,
 bV5ProfileSize: DWORD,
 bV5Reserved: DWORD
});

var BITMAPINFO = STRUCT('BITMAPINFO', {
 bmiHeader: BITMAPINFOHEADER,
 bmiColors: pointer
});

var BITMAPCOREINFO = STRUCT('BITMAPCOREINFO', {
 bmciHeader: BITMAPCOREHEADER,
 bmciColors: pointer
});

var BITMAPFILEHEADER = STRUCT('BITMAPFILEHEADER', {
 bfType: WORD,
 bfSize: DWORD,
 bfReserved1: WORD,
 bfReserved2: WORD,
 bfOffBits: DWORD
});

var FONTSIGNATURE = STRUCT('FONTSIGNATURE', {
 fsUsb: pointer,
 fsCsb: pointer
});

var CHARSETINFO = STRUCT('CHARSETINFO', {
 ciCharset: UINT,
 ciACP: UINT,
 fs: FONTSIGNATURE
});

var LOCALESIGNATURE = STRUCT('LOCALESIGNATURE', {
 lsUsb: pointer,
 lsCsbDefault: pointer,
 lsCsbSupported: pointer
});

var HANDLETABLE = STRUCT('HANDLETABLE', {
 objectHandle: pointer
});

var METARECORD = STRUCT('METARECORD', {
 rdSize: DWORD,
 rdFunction: WORD,
 rdParm: pointer
});

var METAFILEPICT = STRUCT('METAFILEPICT', {
 mm: LONG,
 xExt: LONG,
 yExt: LONG,
 hMF: HMETAFILE
});

var METAHEADER = STRUCT('METAHEADER', {
 mtType: WORD,
 mtHeaderSize: WORD,
 mtVersion: WORD,
 mtSize: DWORD,
 mtNoObjects: WORD,
 mtMaxRecord: DWORD,
 mtNoParameters: WORD
});

var ENHMETARECORD = STRUCT('ENHMETARECORD', {
 iType: DWORD,
 nSize: DWORD,
 dParm: pointer
});

var ENHMETAHEADER = STRUCT('ENHMETAHEADER', {
 iType: DWORD,
 nSize: DWORD,
 rclBounds: RECTL,
 rclFrame: RECTL,
 dSignature: DWORD,
 nVersion: DWORD,
 nBytes: DWORD,
 nRecords: DWORD,
 nHandles: WORD,
 sReserved: WORD,
 nDescription: DWORD,
 offDescription: DWORD,
 nPalEntries: DWORD,
 szlDevice: SIZEL,
 szlMillimeters: SIZEL,
 cbPixelFormat: DWORD,
 offPixelFormat: DWORD,
 bOpenGL: DWORD,
 szlMicrometers: SIZEL
});

var TEXTMETRIC = STRUCT('TEXTMETRIC', {
 tmHeight: LONG,
 tmAscent: LONG,
 tmDescent: LONG,
 tmInternalLeading: LONG,
 tmExternalLeading: LONG,
 tmAveCharWidth: LONG,
 tmMaxCharWidth: LONG,
 tmWeight: LONG,
 tmOverhang: LONG,
 tmDigitizedAspectX: LONG,
 tmDigitizedAspectY: LONG,
 tmFirstChar: BYTE,
 tmLastChar: BYTE,
 tmDefaultChar: BYTE,
 tmBreakChar: BYTE,
 tmItalic: BYTE,
 tmUnderlined: BYTE,
 tmStruckOut: BYTE,
 tmPitchAndFamily: BYTE,
 tmCharSet: BYTE
});

var TEXTMETRICW = STRUCT('TEXTMETRICW', {
 tmHeight: LONG,
 tmAscent: LONG,
 tmDescent: LONG,
 tmInternalLeading: LONG,
 tmExternalLeading: LONG,
 tmAveCharWidth: LONG,
 tmMaxCharWidth: LONG,
 tmWeight: LONG,
 tmOverhang: LONG,
 tmDigitizedAspectX: LONG,
 tmDigitizedAspectY: LONG,
 tmFirstChar: WCHAR,
 tmLastChar: WCHAR,
 tmDefaultChar: WCHAR,
 tmBreakChar: WCHAR,
 tmItalic: BYTE,
 tmUnderlined: BYTE,
 tmStruckOut: BYTE,
 tmPitchAndFamily: BYTE,
 tmCharSet: BYTE
});

var NEWTEXTMETRIC = STRUCT('NEWTEXTMETRIC', {
 tmHeight: LONG,
 tmAscent: LONG,
 tmDescent: LONG,
 tmInternalLeading: LONG,
 tmExternalLeading: LONG,
 tmAveCharWidth: LONG,
 tmMaxCharWidth: LONG,
 tmWeight: LONG,
 tmOverhang: LONG,
 tmDigitizedAspectX: LONG,
 tmDigitizedAspectY: LONG,
 tmFirstChar: BYTE,
 tmLastChar: BYTE,
 tmDefaultChar: BYTE,
 tmBreakChar: BYTE,
 tmItalic: BYTE,
 tmUnderlined: BYTE,
 tmStruckOut: BYTE,
 tmPitchAndFamily: BYTE,
 tmCharSet: BYTE,
 ntmFlags: DWORD,
 ntmSizeEM: UINT,
 ntmCellHeight: UINT,
 ntmAvgWidth: UINT
});

var NEWTEXTMETRICW = STRUCT('NEWTEXTMETRICW', {
 tmHeight: LONG,
 tmAscent: LONG,
 tmDescent: LONG,
 tmInternalLeading: LONG,
 tmExternalLeading: LONG,
 tmAveCharWidth: LONG,
 tmMaxCharWidth: LONG,
 tmWeight: LONG,
 tmOverhang: LONG,
 tmDigitizedAspectX: LONG,
 tmDigitizedAspectY: LONG,
 tmFirstChar: WCHAR,
 tmLastChar: WCHAR,
 tmDefaultChar: WCHAR,
 tmBreakChar: WCHAR,
 tmItalic: BYTE,
 tmUnderlined: BYTE,
 tmStruckOut: BYTE,
 tmPitchAndFamily: BYTE,
 tmCharSet: BYTE,
 ntmFlags: DWORD,
 ntmSizeEM: UINT,
 ntmCellHeight: UINT,
 ntmAvgWidth: UINT
});

var NEWTEXTMETRICEX = STRUCT('NEWTEXTMETRICEX', {
 ntmTm: NEWTEXTMETRICA,
 ntmFontSig: FONTSIGNATURE
});

var NEWTEXTMETRICEXW = STRUCT('NEWTEXTMETRICEXW', {
 ntmTm: NEWTEXTMETRICW,
 ntmFontSig: FONTSIGNATURE
});

var PELARRAY = STRUCT('PELARRAY', {
 paXCount: LONG,
 paYCount: LONG,
 paXExt: LONG,
 paYExt: LONG,
 paRGBs: BYTE
});

var PATTERN = STRUCT('PATTERN', {
 lbStyle: UINT,
 lbColor: COLORREF,
 lbHatch: ULONG_PTR
});

var LOGBRUSH32 = STRUCT('LOGBRUSH32', {
 lbStyle: UINT,
 lbColor: COLORREF,
 lbHatch: ULONG
});

var LOGPEN = STRUCT('LOGPEN', {
 lopnStyle: UINT,
 lopnWidth: POINT,
 lopnColor: COLORREF
});

var EXTLOGPEN = STRUCT('EXTLOGPEN', {
 elpPenStyle: DWORD,
 elpWidth: DWORD,
 elpBrushStyle: UINT,
 elpColor: COLORREF,
 elpHatch: ULONG_PTR,
 elpNumEntries: DWORD,
 elpStyleEntry: pointer
});

var EXTLOGPEN32 = STRUCT('EXTLOGPEN32', {
 elpPenStyle: DWORD,
 elpWidth: DWORD,
 elpBrushStyle: UINT,
 elpColor: COLORREF,
 elpHatch: ULONG,
 elpNumEntries: DWORD,
 elpStyleEntry: pointer
});

var PALETTEENTRY = STRUCT('PALETTEENTRY', {
 peRed: BYTE,
 peGreen: BYTE,
 peBlue: BYTE,
 peFlags: BYTE
});

var LOGPALETTE = STRUCT('LOGPALETTE', {
 palVersion: WORD,
 palNumEntries: WORD,
 palPalEntry: pointer
});

var LOGFONT = STRUCT('LOGFONT', {
 lfHeight: LONG,
 lfWidth: LONG,
 lfEscapement: LONG,
 lfOrientation: LONG,
 lfWeight: LONG,
 lfItalic: BYTE,
 lfUnderline: BYTE,
 lfStrikeOut: BYTE,
 lfCharSet: BYTE,
 lfOutPrecision: BYTE,
 lfClipPrecision: BYTE,
 lfQuality: BYTE,
 lfPitchAndFamily: BYTE,
 lfFaceName: pointer
});

var LOGFONTW = STRUCT('LOGFONTW', {
 lfHeight: LONG,
 lfWidth: LONG,
 lfEscapement: LONG,
 lfOrientation: LONG,
 lfWeight: LONG,
 lfItalic: BYTE,
 lfUnderline: BYTE,
 lfStrikeOut: BYTE,
 lfCharSet: BYTE,
 lfOutPrecision: BYTE,
 lfClipPrecision: BYTE,
 lfQuality: BYTE,
 lfPitchAndFamily: BYTE,
 lfFaceName: pointer
});

var ENUMLOGFONT = STRUCT('ENUMLOGFONT', {
 elfLogFont: LOGFONTA,
 elfFullName: pointer,
 elfStyle: pointer
});

var ENUMLOGFONTW = STRUCT('ENUMLOGFONTW', {
 elfLogFont: LOGFONTW,
 elfFullName: pointer,
 elfStyle: pointer
});

var ENUMLOGFONTEX = STRUCT('ENUMLOGFONTEX', {
 elfLogFont: LOGFONTA,
 elfFullName: pointer,
 elfStyle: pointer,
 elfScript: pointer
});

var ENUMLOGFONTEXW = STRUCT('ENUMLOGFONTEXW', {
 elfLogFont: LOGFONTW,
 elfFullName: pointer,
 elfStyle: pointer,
 elfScript: pointer
});

var PANOSE = STRUCT('PANOSE', {
 bFamilyType: BYTE,
 bSerifStyle: BYTE,
 bWeight: BYTE,
 bProportion: BYTE,
 bContrast: BYTE,
 bStrokeVariation: BYTE,
 bArmStyle: BYTE,
 bLetterform: BYTE,
 bMidline: BYTE,
 bXHeight: BYTE
});

var EXTLOGFONT = STRUCT('EXTLOGFONT', {
 elfLogFont: LOGFONTA,
 elfFullName: pointer,
 elfStyle: pointer,
 elfVersion: DWORD,
 elfStyleSize: DWORD,
 elfMatch: DWORD,
 elfReserved: DWORD,
 elfVendorId: pointer,
 elfCulture: DWORD,
 elfPanose: PANOSE
});

var EXTLOGFONTW = STRUCT('EXTLOGFONTW', {
 elfLogFont: LOGFONTW,
 elfFullName: pointer,
 elfStyle: pointer,
 elfVersion: DWORD,
 elfStyleSize: DWORD,
 elfMatch: DWORD,
 elfReserved: DWORD,
 elfVendorId: pointer,
 elfCulture: DWORD,
 elfPanose: PANOSE
});

var DEVMODE = STRUCT('DEVMODE', {
 dmDeviceName: pointer,
 dmSpecVersion: WORD,
 dmDriverVersion: WORD,
 dmSize: WORD,
 dmDriverExtra: WORD,
 dmFields: DWORD,
 dmColor: short,
 dmDuplex: short,
 dmYResolution: short,
 dmTTOption: short,
 dmCollate: short,
 dmFormName: pointer,
 dmLogPixels: WORD,
 dmBitsPerPel: DWORD,
 dmPelsWidth: DWORD,
 dmPelsHeight: DWORD,
 dmDisplayFrequency: DWORD,
 dmICMMethod: DWORD,
 dmICMIntent: DWORD,
 dmMediaType: DWORD,
 dmDitherType: DWORD,
 dmReserved1: DWORD,
 dmReserved2: DWORD,
 dmPanningWidth: DWORD,
 dmPanningHeight: DWORD
});

var undefined = STRUCT('undefined', {
 dmOrientation: short,
 dmPaperSize: short,
 dmPaperLength: short,
 dmPaperWidth: short,
 dmScale: short,
 dmCopies: short,
 dmDefaultSource: short,
 dmPrintQuality: short
});

var undefined = STRUCT('undefined', {
 dmPosition: POINTL,
 dmDisplayOrientation: DWORD,
 dmDisplayFixedOutput: DWORD
});

var DEVMODEW = STRUCT('DEVMODEW', {
 dmDeviceName: pointer,
 dmSpecVersion: WORD,
 dmDriverVersion: WORD,
 dmSize: WORD,
 dmDriverExtra: WORD,
 dmFields: DWORD,
 dmColor: short,
 dmDuplex: short,
 dmYResolution: short,
 dmTTOption: short,
 dmCollate: short,
 dmFormName: pointer,
 dmLogPixels: WORD,
 dmBitsPerPel: DWORD,
 dmPelsWidth: DWORD,
 dmPelsHeight: DWORD,
 dmDisplayFrequency: DWORD,
 dmICMMethod: DWORD,
 dmICMIntent: DWORD,
 dmMediaType: DWORD,
 dmDitherType: DWORD,
 dmReserved1: DWORD,
 dmReserved2: DWORD,
 dmPanningWidth: DWORD,
 dmPanningHeight: DWORD
});

var undefined = STRUCT('undefined', {
 dmOrientation: short,
 dmPaperSize: short,
 dmPaperLength: short,
 dmPaperWidth: short,
 dmScale: short,
 dmCopies: short,
 dmDefaultSource: short,
 dmPrintQuality: short
});

var undefined = STRUCT('undefined', {
 dmPosition: POINTL,
 dmDisplayOrientation: DWORD,
 dmDisplayFixedOutput: DWORD
});

var DISPLAY_DEVICE = STRUCT('DISPLAY_DEVICE', {
 cb: DWORD,
 DeviceName: pointer,
 DeviceString: pointer,
 StateFlags: DWORD,
 DeviceID: pointer,
 DeviceKey: pointer
});

var DISPLAY_DEVICEW = STRUCT('DISPLAY_DEVICEW', {
 cb: DWORD,
 DeviceName: pointer,
 DeviceString: pointer,
 StateFlags: DWORD,
 DeviceID: pointer,
 DeviceKey: pointer
});

var DISPLAYCONFIG_RATIONAL = STRUCT('DISPLAYCONFIG_RATIONAL', {
 Numerator: UINT32,
 Denominator: UINT32
});

var DISPLAYCONFIG_2DREGION = STRUCT('DISPLAYCONFIG_2DREGION', {
 cx: UINT32,
 cy: UINT32
});

var DISPLAYCONFIG_VIDEO_SIGNAL_INFO = STRUCT('DISPLAYCONFIG_VIDEO_SIGNAL_INFO', {
 pixelRate: UINT64,
 hSyncFreq: DISPLAYCONFIG_RATIONAL,
 vSyncFreq: DISPLAYCONFIG_RATIONAL,
 activeSize: DISPLAYCONFIG_2DREGION,
 totalSize: DISPLAYCONFIG_2DREGION,
 videoStandard: UINT32,
 scanLineOrdering: DISPLAYCONFIG_SCANLINE_ORDERING
});

var DISPLAYCONFIG_SOURCE_MODE = STRUCT('DISPLAYCONFIG_SOURCE_MODE', {
 width: UINT32,
 height: UINT32,
 pixelFormat: DISPLAYCONFIG_PIXELFORMAT,
 position: POINTL
});

var DISPLAYCONFIG_TARGET_MODE = STRUCT('DISPLAYCONFIG_TARGET_MODE', {
 targetVideoSignalInfo: DISPLAYCONFIG_VIDEO_SIGNAL_INFO
});

var DISPLAYCONFIG_MODE_INFO = STRUCT('DISPLAYCONFIG_MODE_INFO', {
 infoType: DISPLAYCONFIG_MODE_INFO_TYPE,
 id: UINT32,
 adapterId: LUID
});

var DISPLAYCONFIG_PATH_SOURCE_INFO = STRUCT('DISPLAYCONFIG_PATH_SOURCE_INFO', {
 adapterId: LUID,
 id: UINT32,
 modeInfoIdx: UINT32,
 statusFlags: UINT32
});

var DISPLAYCONFIG_PATH_TARGET_INFO = STRUCT('DISPLAYCONFIG_PATH_TARGET_INFO', {
 adapterId: LUID,
 id: UINT32,
 modeInfoIdx: UINT32,
 outputTechnology: DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
 rotation: DISPLAYCONFIG_ROTATION,
 scaling: DISPLAYCONFIG_SCALING,
 refreshRate: DISPLAYCONFIG_RATIONAL,
 scanLineOrdering: DISPLAYCONFIG_SCANLINE_ORDERING,
 targetAvailable: BOOL,
 statusFlags: UINT32
});

var DISPLAYCONFIG_PATH_INFO = STRUCT('DISPLAYCONFIG_PATH_INFO', {
 sourceInfo: DISPLAYCONFIG_PATH_SOURCE_INFO,
 targetInfo: DISPLAYCONFIG_PATH_TARGET_INFO,
 flags: UINT32
});

var DISPLAYCONFIG_DEVICE_INFO_HEADER = STRUCT('DISPLAYCONFIG_DEVICE_INFO_HEADER', {
 type: DISPLAYCONFIG_DEVICE_INFO_TYPE,
 size: UINT32,
 adapterId: LUID,
 id: UINT32
});

var DISPLAYCONFIG_SOURCE_DEVICE_NAME = STRUCT('DISPLAYCONFIG_SOURCE_DEVICE_NAME', {
 header: DISPLAYCONFIG_DEVICE_INFO_HEADER,
 viewGdiDeviceName: pointer
});


var undefined = STRUCT('undefined', {
 friendlyNameFromEdid: UINT32,
 friendlyNameForced: UINT32,
 edidIdsValid: UINT32,
 reserved: UINT32
});

var DISPLAYCONFIG_TARGET_DEVICE_NAME = STRUCT('DISPLAYCONFIG_TARGET_DEVICE_NAME', {
 header: DISPLAYCONFIG_DEVICE_INFO_HEADER,
 flags: DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS,
 outputTechnology: DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
 edidManufactureId: UINT16,
 edidProductCodeId: UINT16,
 connectorInstance: UINT32,
 monitorFriendlyDeviceName: pointer,
 monitorDevicePath: pointer
});

var DISPLAYCONFIG_TARGET_PREFERRED_MODE = STRUCT('DISPLAYCONFIG_TARGET_PREFERRED_MODE', {
 header: DISPLAYCONFIG_DEVICE_INFO_HEADER,
 width: UINT32,
 height: UINT32,
 targetMode: DISPLAYCONFIG_TARGET_MODE
});

var DISPLAYCONFIG_ADAPTER_NAME = STRUCT('DISPLAYCONFIG_ADAPTER_NAME', {
 header: DISPLAYCONFIG_DEVICE_INFO_HEADER,
 adapterDevicePath: pointer
});

var DISPLAYCONFIG_SET_TARGET_PERSISTENCE = STRUCT('DISPLAYCONFIG_SET_TARGET_PERSISTENCE', {
 header: DISPLAYCONFIG_DEVICE_INFO_HEADER
});

var undefined = STRUCT('undefined', {
 bootPersistenceOn: UINT32,
 reserved: UINT32
});

var RGNDATAHEADER = STRUCT('RGNDATAHEADER', {
 dwSize: DWORD,
 iType: DWORD,
 nCount: DWORD,
 nRgnSize: DWORD,
 rcBound: RECT
});

var RGNDATA = STRUCT('RGNDATA', {
 rdh: RGNDATAHEADER,
 Buffer: pointer
});

var ABC = STRUCT('ABC', {
 abcA: int,
 abcB: UINT,
 abcC: int
});

var ABCFLOAT = STRUCT('ABCFLOAT', {
 abcfA: FLOAT,
 abcfB: FLOAT,
 abcfC: FLOAT
});

var OUTLINETEXTMETRIC = STRUCT('OUTLINETEXTMETRIC', {
 otmSize: UINT,
 otmTextMetrics: TEXTMETRICA,
 otmFiller: BYTE,
 otmPanoseNumber: PANOSE,
 otmfsSelection: UINT,
 otmfsType: UINT,
 otmsCharSlopeRise: int,
 otmsCharSlopeRun: int,
 otmItalicAngle: int,
 otmEMSquare: UINT,
 otmAscent: int,
 otmDescent: int,
 otmLineGap: UINT,
 otmsCapEmHeight: UINT,
 otmsXHeight: UINT,
 otmrcFontBox: RECT,
 otmMacAscent: int,
 otmMacDescent: int,
 otmMacLineGap: UINT,
 otmusMinimumPPEM: UINT,
 otmptSubscriptSize: POINT,
 otmptSubscriptOffset: POINT,
 otmptSuperscriptSize: POINT,
 otmptSuperscriptOffset: POINT,
 otmsStrikeoutSize: UINT,
 otmsStrikeoutPosition: int,
 otmsUnderscoreSize: int,
 otmsUnderscorePosition: int,
 otmpFamilyName: PSTR,
 otmpFaceName: PSTR,
 otmpStyleName: PSTR,
 otmpFullName: PSTR
});

var OUTLINETEXTMETRICW = STRUCT('OUTLINETEXTMETRICW', {
 otmSize: UINT,
 otmTextMetrics: TEXTMETRICW,
 otmFiller: BYTE,
 otmPanoseNumber: PANOSE,
 otmfsSelection: UINT,
 otmfsType: UINT,
 otmsCharSlopeRise: int,
 otmsCharSlopeRun: int,
 otmItalicAngle: int,
 otmEMSquare: UINT,
 otmAscent: int,
 otmDescent: int,
 otmLineGap: UINT,
 otmsCapEmHeight: UINT,
 otmsXHeight: UINT,
 otmrcFontBox: RECT,
 otmMacAscent: int,
 otmMacDescent: int,
 otmMacLineGap: UINT,
 otmusMinimumPPEM: UINT,
 otmptSubscriptSize: POINT,
 otmptSubscriptOffset: POINT,
 otmptSuperscriptSize: POINT,
 otmptSuperscriptOffset: POINT,
 otmsStrikeoutSize: UINT,
 otmsStrikeoutPosition: int,
 otmsUnderscoreSize: int,
 otmsUnderscorePosition: int,
 otmpFamilyName: PSTR,
 otmpFaceName: PSTR,
 otmpStyleName: PSTR,
 otmpFullName: PSTR
});

var POLYTEXT = STRUCT('POLYTEXT', {
 x: int,
 y: int,
 n: UINT,
 lpstr: LPCSTR,
 uiFlags: UINT,
 rcl: RECT,
 pdx: PTR(int)
});

var POLYTEXTW = STRUCT('POLYTEXTW', {
 x: int,
 y: int,
 n: UINT,
 lpstr: LPCWSTR,
 uiFlags: UINT,
 rcl: RECT,
 pdx: PTR(int)
});

var FIXED = STRUCT('FIXED', {
 fract: WORD,
 value: short
});

var MAT2 = STRUCT('MAT2', {
 eM11: FIXED,
 eM12: FIXED,
 eM21: FIXED,
 eM22: FIXED
});

var GLYPHMETRICS = STRUCT('GLYPHMETRICS', {
 gmBlackBoxX: UINT,
 gmBlackBoxY: UINT,
 gmptGlyphOrigin: POINT,
 gmCellIncX: short,
 gmCellIncY: short
});

var POINTFX = STRUCT('POINTFX', {
 x: FIXED,
 y: FIXED
});

var TTPOLYCURVE = STRUCT('TTPOLYCURVE', {
 wType: WORD,
 cpfx: WORD,
 apfx: pointer
});

var TTPOLYGONHEADER = STRUCT('TTPOLYGONHEADER', {
 cb: DWORD,
 dwType: DWORD,
 pfxStart: POINTFX
});

var GCP_RESULTS = STRUCT('GCP_RESULTS', {
 lStructSize: DWORD,
 lpOutString: LPSTR,
 lpOrder: PTR(uint),
 lpDx: PTR(int),
 lpCaretPos: PTR(int),
 lpClass: LPSTR,
 lpGlyphs: LPWSTR,
 nGlyphs: UINT,
 nMaxFit: int
});

var GCP_RESULTSW = STRUCT('GCP_RESULTSW', {
 lStructSize: DWORD,
 lpOutString: LPWSTR,
 lpOrder: PTR(uint),
 lpDx: PTR(int),
 lpCaretPos: PTR(int),
 lpClass: LPSTR,
 lpGlyphs: LPWSTR,
 nGlyphs: UINT,
 nMaxFit: int
});

var RASTERIZER_STATUS = STRUCT('RASTERIZER_STATUS', {
 nSize: short,
 wFlags: short,
 nLanguageID: short
});

var PIXELFORMATDESCRIPTOR = STRUCT('PIXELFORMATDESCRIPTOR', {
 nSize: WORD,
 nVersion: WORD,
 dwFlags: DWORD,
 iPixelType: BYTE,
 cColorBits: BYTE,
 cRedBits: BYTE,
 cRedShift: BYTE,
 cGreenBits: BYTE,
 cGreenShift: BYTE,
 cBlueBits: BYTE,
 cBlueShift: BYTE,
 cAlphaBits: BYTE,
 cAlphaShift: BYTE,
 cAccumBits: BYTE,
 cAccumRedBits: BYTE,
 cAccumGreenBits: BYTE,
 cAccumBlueBits: BYTE,
 cAccumAlphaBits: BYTE,
 cDepthBits: BYTE,
 cStencilBits: BYTE,
 cAuxBuffers: BYTE,
 iLayerType: BYTE,
 bReserved: BYTE,
 dwLayerMask: DWORD,
 dwVisibleMask: DWORD,
 dwDamageMask: DWORD
});

var WCRANGE = STRUCT('WCRANGE', {
 wcLow: WCHAR,
 cGlyphs: USHORT
});

var GLYPHSET = STRUCT('GLYPHSET', {
 cbThis: DWORD,
 flAccel: DWORD,
 cGlyphsSupported: DWORD,
 cRanges: DWORD,
 ranges: pointer
});

var DESIGNVECTOR = STRUCT('DESIGNVECTOR', {
 dvReserved: DWORD,
 dvNumAxes: DWORD,
 dvValues: pointer
});

var AXISINFO = STRUCT('AXISINFO', {
 axMinValue: LONG,
 axMaxValue: LONG,
 axAxisName: pointer
});

var AXISINFOW = STRUCT('AXISINFOW', {
 axMinValue: LONG,
 axMaxValue: LONG,
 axAxisName: pointer
});

var AXESLIST = STRUCT('AXESLIST', {
 axlReserved: DWORD,
 axlNumAxes: DWORD,
 axlAxisInfo: pointer
});

var AXESLISTW = STRUCT('AXESLISTW', {
 axlReserved: DWORD,
 axlNumAxes: DWORD,
 axlAxisInfo: pointer
});

var ENUMLOGFONTEXDV = STRUCT('ENUMLOGFONTEXDV', {
 elfEnumLogfontEx: ENUMLOGFONTEXA,
 elfDesignVector: DESIGNVECTOR
});

var ENUMLOGFONTEXDVW = STRUCT('ENUMLOGFONTEXDVW', {
 elfEnumLogfontEx: ENUMLOGFONTEXW,
 elfDesignVector: DESIGNVECTOR
});

var ENUMTEXTMETRIC = STRUCT('ENUMTEXTMETRIC', {
 etmNewTextMetricEx: NEWTEXTMETRICEXA,
 etmAxesList: AXESLISTA
});

var ENUMTEXTMETRICW = STRUCT('ENUMTEXTMETRICW', {
 etmNewTextMetricEx: NEWTEXTMETRICEXW,
 etmAxesList: AXESLISTW
});

var TRIVERTEX = STRUCT('TRIVERTEX', {
 x: LONG,
 y: LONG,
 Red: COLOR16,
 Green: COLOR16,
 Blue: COLOR16,
 Alpha: COLOR16
});

var GRADIENT_TRIANGLE = STRUCT('GRADIENT_TRIANGLE', {
 Vertex1: ULONG,
 Vertex2: ULONG,
 Vertex3: ULONG
});

var GRADIENT_RECT = STRUCT('GRADIENT_RECT', {
 UpperLeft: ULONG,
 LowerRight: ULONG
});

var BLENDFUNCTION = STRUCT('BLENDFUNCTION', {
 BlendOp: BYTE,
 BlendFlags: BYTE,
 SourceConstantAlpha: BYTE,
 AlphaFormat: BYTE
});

var DIBSECTION = STRUCT('DIBSECTION', {
 dsBm: BITMAP,
 dsBmih: BITMAPINFOHEADER,
 dsBitfields: pointer,
 dshSection: HANDLE,
 dsOffset: DWORD
});

var COLORADJUSTMENT = STRUCT('COLORADJUSTMENT', {
 caSize: WORD,
 caFlags: WORD,
 caIlluminantIndex: WORD,
 caRedGamma: WORD,
 caGreenGamma: WORD,
 caBlueGamma: WORD,
 caReferenceBlack: WORD,
 caReferenceWhite: WORD,
 caContrast: SHORT,
 caBrightness: SHORT,
 caColorfulness: SHORT,
 caRedGreenTint: SHORT
});

var DOCINFO = STRUCT('DOCINFO', {
 cbSize: int,
 lpszDocName: LPCSTR,
 lpszOutput: LPCSTR,
 lpszDatatype: LPCSTR,
 fwType: DWORD
});

var DOCINFOW = STRUCT('DOCINFOW', {
 cbSize: int,
 lpszDocName: LPCWSTR,
 lpszOutput: LPCWSTR,
 lpszDatatype: LPCWSTR,
 fwType: DWORD
});

var KERNINGPAIR = STRUCT('KERNINGPAIR', {
 wFirst: WORD,
 wSecond: WORD,
 iKernAmount: int
});

var EMR = STRUCT('EMR', {
 iType: DWORD,
 nSize: DWORD
});

var EMRTEXT = STRUCT('EMRTEXT', {
 ptlReference: POINTL,
 nChars: DWORD,
 offString: DWORD,
 fOptions: DWORD,
 rcl: RECTL,
 offDx: DWORD
});

var EMRREALIZEPALETTE = STRUCT('EMRREALIZEPALETTE', {
 emr: EMR
});

var EMRSETTEXTALIGN = STRUCT('EMRSETTEXTALIGN', {
 emr: EMR,
 iMode: DWORD
});

var EMRSETMITERLIMIT = STRUCT('EMRSETMITERLIMIT', {
 emr: EMR,
 eMiterLimit: FLOAT
});

var EMRRESTOREDC = STRUCT('EMRRESTOREDC', {
 emr: EMR,
 iRelative: LONG
});

var EMRSETARCDIRECTION = STRUCT('EMRSETARCDIRECTION', {
 emr: EMR,
 iArcDirection: DWORD
});

var EMRSETMAPPERFLAGS = STRUCT('EMRSETMAPPERFLAGS', {
 emr: EMR,
 dwFlags: DWORD
});

var EMRSETTEXTCOLOR = STRUCT('EMRSETTEXTCOLOR', {
 emr: EMR,
 crColor: COLORREF
});

var EMRDELETEOBJECT = STRUCT('EMRDELETEOBJECT', {
 emr: EMR,
 ihObject: DWORD
});

var EMRSELECTPALETTE = STRUCT('EMRSELECTPALETTE', {
 emr: EMR,
 ihPal: DWORD
});

var EMRRESIZEPALETTE = STRUCT('EMRRESIZEPALETTE', {
 emr: EMR,
 ihPal: DWORD,
 cEntries: DWORD
});

var EMRSETPALETTEENTRIES = STRUCT('EMRSETPALETTEENTRIES', {
 emr: EMR,
 ihPal: DWORD,
 iStart: DWORD,
 cEntries: DWORD,
 aPalEntries: pointer
});

var EMRSETCOLORADJUSTMENT = STRUCT('EMRSETCOLORADJUSTMENT', {
 emr: EMR,
 ColorAdjustment: COLORADJUSTMENT
});

var EMRGDICOMMENT = STRUCT('EMRGDICOMMENT', {
 emr: EMR,
 cbData: DWORD,
 Data: pointer
});

var EMREOF = STRUCT('EMREOF', {
 emr: EMR,
 nPalEntries: DWORD,
 offPalEntries: DWORD,
 nSizeLast: DWORD
});

var EMRMOVETOEX = STRUCT('EMRMOVETOEX', {
 emr: EMR,
 ptl: POINTL
});

var EMROFFSETCLIPRGN = STRUCT('EMROFFSETCLIPRGN', {
 emr: EMR,
 ptlOffset: POINTL
});

var EMRSTROKEPATH = STRUCT('EMRSTROKEPATH', {
 emr: EMR,
 rclBounds: RECTL
});

var EMRINTERSECTCLIPRECT = STRUCT('EMRINTERSECTCLIPRECT', {
 emr: EMR,
 rclClip: RECTL
});

var EMRSETBRUSHORGEX = STRUCT('EMRSETBRUSHORGEX', {
 emr: EMR,
 ptlOrigin: POINTL
});

var EMRSETWINDOWEXTEX = STRUCT('EMRSETWINDOWEXTEX', {
 emr: EMR,
 szlExtent: SIZEL
});

var EMRSCALEWINDOWEXTEX = STRUCT('EMRSCALEWINDOWEXTEX', {
 emr: EMR,
 xNum: LONG,
 xDenom: LONG,
 yNum: LONG,
 yDenom: LONG
});

var EMRSETWORLDTRANSFORM = STRUCT('EMRSETWORLDTRANSFORM', {
 emr: EMR,
 xform: XFORM
});

var EMRMODIFYWORLDTRANSFORM = STRUCT('EMRMODIFYWORLDTRANSFORM', {
 emr: EMR,
 xform: XFORM,
 iMode: DWORD
});

var EMRSETPIXELV = STRUCT('EMRSETPIXELV', {
 emr: EMR,
 ptlPixel: POINTL,
 crColor: COLORREF
});

var EMREXTFLOODFILL = STRUCT('EMREXTFLOODFILL', {
 emr: EMR,
 ptlStart: POINTL,
 crColor: COLORREF,
 iMode: DWORD
});

var EMRRECTANGLE = STRUCT('EMRRECTANGLE', {
 emr: EMR,
 rclBox: RECTL
});

var EMRROUNDRECT = STRUCT('EMRROUNDRECT', {
 emr: EMR,
 rclBox: RECTL,
 szlCorner: SIZEL
});

var EMRPIE = STRUCT('EMRPIE', {
 emr: EMR,
 rclBox: RECTL,
 ptlStart: POINTL,
 ptlEnd: POINTL
});

var EMRANGLEARC = STRUCT('EMRANGLEARC', {
 emr: EMR,
 ptlCenter: POINTL,
 nRadius: DWORD,
 eStartAngle: FLOAT,
 eSweepAngle: FLOAT
});

var EMRPOLYLINETO = STRUCT('EMRPOLYLINETO', {
 emr: EMR,
 rclBounds: RECTL,
 cptl: DWORD,
 aptl: pointer
});

var EMRPOLYLINETO16 = STRUCT('EMRPOLYLINETO16', {
 emr: EMR,
 rclBounds: RECTL,
 cpts: DWORD,
 apts: pointer
});

var EMRPOLYDRAW = STRUCT('EMRPOLYDRAW', {
 emr: EMR,
 rclBounds: RECTL,
 cptl: DWORD,
 aptl: pointer,
 abTypes: pointer
});

var EMRPOLYDRAW16 = STRUCT('EMRPOLYDRAW16', {
 emr: EMR,
 rclBounds: RECTL,
 cpts: DWORD,
 apts: pointer,
 abTypes: pointer
});

var EMRPOLYPOLYGON = STRUCT('EMRPOLYPOLYGON', {
 emr: EMR,
 rclBounds: RECTL,
 nPolys: DWORD,
 cptl: DWORD,
 aPolyCounts: pointer,
 aptl: pointer
});

var EMRPOLYPOLYGON16 = STRUCT('EMRPOLYPOLYGON16', {
 emr: EMR,
 rclBounds: RECTL,
 nPolys: DWORD,
 cpts: DWORD,
 aPolyCounts: pointer,
 apts: pointer
});

var EMRPAINTRGN = STRUCT('EMRPAINTRGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 RgnData: pointer
});

var EMRFILLRGN = STRUCT('EMRFILLRGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 ihBrush: DWORD,
 RgnData: pointer
});

var EMRFRAMERGN = STRUCT('EMRFRAMERGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 ihBrush: DWORD,
 szlStroke: SIZEL,
 RgnData: pointer
});

var EMREXTSELECTCLIPRGN = STRUCT('EMREXTSELECTCLIPRGN', {
 emr: EMR,
 cbRgnData: DWORD,
 iMode: DWORD,
 RgnData: pointer
});

var EMREXTTEXTOUTW = STRUCT('EMREXTTEXTOUTW', {
 emr: EMR,
 rclBounds: RECTL,
 iGraphicsMode: DWORD,
 exScale: FLOAT,
 eyScale: FLOAT,
 emrtext: EMRTEXT
});

var EMRPOLYTEXTOUTW = STRUCT('EMRPOLYTEXTOUTW', {
 emr: EMR,
 rclBounds: RECTL,
 iGraphicsMode: DWORD,
 exScale: FLOAT,
 eyScale: FLOAT,
 cStrings: LONG,
 aemrtext: pointer
});

var EMRBITBLT = STRUCT('EMRBITBLT', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 cxDest: LONG,
 cyDest: LONG,
 dwRop: DWORD,
 xSrc: LONG,
 ySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD
});

var EMRSTRETCHBLT = STRUCT('EMRSTRETCHBLT', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 cxDest: LONG,
 cyDest: LONG,
 dwRop: DWORD,
 xSrc: LONG,
 ySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 cxSrc: LONG,
 cySrc: LONG
});

var EMRMASKBLT = STRUCT('EMRMASKBLT', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 cxDest: LONG,
 cyDest: LONG,
 dwRop: DWORD,
 xSrc: LONG,
 ySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 xMask: LONG,
 yMask: LONG,
 iUsageMask: DWORD,
 offBmiMask: DWORD,
 cbBmiMask: DWORD,
 offBitsMask: DWORD,
 cbBitsMask: DWORD
});

var EMRPLGBLT = STRUCT('EMRPLGBLT', {
 emr: EMR,
 rclBounds: RECTL,
 aptlDest: pointer,
 xSrc: LONG,
 ySrc: LONG,
 cxSrc: LONG,
 cySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 xMask: LONG,
 yMask: LONG,
 iUsageMask: DWORD,
 offBmiMask: DWORD,
 cbBmiMask: DWORD,
 offBitsMask: DWORD,
 cbBitsMask: DWORD
});

var EMRSETDIBITSTODEVICE = STRUCT('EMRSETDIBITSTODEVICE', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 xSrc: LONG,
 ySrc: LONG,
 cxSrc: LONG,
 cySrc: LONG,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 iUsageSrc: DWORD,
 iStartScan: DWORD,
 cScans: DWORD
});

var EMRSTRETCHDIBITS = STRUCT('EMRSTRETCHDIBITS', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 xSrc: LONG,
 ySrc: LONG,
 cxSrc: LONG,
 cySrc: LONG,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 iUsageSrc: DWORD,
 dwRop: DWORD,
 cxDest: LONG,
 cyDest: LONG
});

var EMREXTCREATEFONTINDIRECTW = STRUCT('EMREXTCREATEFONTINDIRECTW', {
 emr: EMR,
 ihFont: DWORD,
 elfw: EXTLOGFONTW
});

var EMRCREATEPALETTE = STRUCT('EMRCREATEPALETTE', {
 emr: EMR,
 ihPal: DWORD,
 lgpl: LOGPALETTE
});

var EMRCREATEPEN = STRUCT('EMRCREATEPEN', {
 emr: EMR,
 ihPen: DWORD,
 lopn: LOGPEN
});

var EMREXTCREATEPEN = STRUCT('EMREXTCREATEPEN', {
 emr: EMR,
 ihPen: DWORD,
 offBmi: DWORD,
 cbBmi: DWORD,
 offBits: DWORD,
 cbBits: DWORD,
 elp: EXTLOGPEN32
});

var EMRCREATEBRUSHINDIRECT = STRUCT('EMRCREATEBRUSHINDIRECT', {
 emr: EMR,
 ihBrush: DWORD,
 lb: LOGBRUSH32
});

var EMRCREATEMONOBRUSH = STRUCT('EMRCREATEMONOBRUSH', {
 emr: EMR,
 ihBrush: DWORD,
 iUsage: DWORD,
 offBmi: DWORD,
 cbBmi: DWORD,
 offBits: DWORD,
 cbBits: DWORD
});

var EMRCREATEDIBPATTERNBRUSHPT = STRUCT('EMRCREATEDIBPATTERNBRUSHPT', {
 emr: EMR,
 ihBrush: DWORD,
 iUsage: DWORD,
 offBmi: DWORD,
 cbBmi: DWORD,
 offBits: DWORD,
 cbBits: DWORD
});

var EMRFORMAT = STRUCT('EMRFORMAT', {
 dSignature: DWORD,
 nVersion: DWORD,
 cbData: DWORD,
 offData: DWORD
});

var EMRGLSRECORD = STRUCT('EMRGLSRECORD', {
 emr: EMR,
 cbData: DWORD,
 Data: pointer
});

var EMRGLSBOUNDEDRECORD = STRUCT('EMRGLSBOUNDEDRECORD', {
 emr: EMR,
 rclBounds: RECTL,
 cbData: DWORD,
 Data: pointer
});

var EMRPIXELFORMAT = STRUCT('EMRPIXELFORMAT', {
 emr: EMR,
 pfd: PIXELFORMATDESCRIPTOR
});

var EMRCREATECOLORSPACE = STRUCT('EMRCREATECOLORSPACE', {
 emr: EMR,
 ihCS: DWORD,
 lcs: LOGCOLORSPACEA
});

var EMRDELETECOLORSPACE = STRUCT('EMRDELETECOLORSPACE', {
 emr: EMR,
 ihCS: DWORD
});

var EMRDRAWESCAPE = STRUCT('EMRDRAWESCAPE', {
 emr: EMR,
 iEscape: INT,
 cbEscData: INT,
 EscData: pointer
});

var EMRNAMEDESCAPE = STRUCT('EMRNAMEDESCAPE', {
 emr: EMR,
 iEscape: INT,
 cbDriver: INT,
 cbEscData: INT,
 EscData: pointer
});

var EMRSETICMPROFILEW = STRUCT('EMRSETICMPROFILEW', {
 emr: EMR,
 dwFlags: DWORD,
 cbName: DWORD,
 cbData: DWORD,
 Data: pointer
});

var EMRCREATECOLORSPACEW = STRUCT('EMRCREATECOLORSPACEW', {
 emr: EMR,
 ihCS: DWORD,
 lcs: LOGCOLORSPACEW,
 dwFlags: DWORD,
 cbData: DWORD,
 Data: pointer
});

var EMRCOLORMATCHTOTARGET = STRUCT('EMRCOLORMATCHTOTARGET', {
 emr: EMR,
 dwAction: DWORD,
 dwFlags: DWORD,
 cbName: DWORD,
 cbData: DWORD,
 Data: pointer
});

var EMRCOLORCORRECTPALETTE = STRUCT('EMRCOLORCORRECTPALETTE', {
 emr: EMR,
 ihPalette: DWORD,
 nFirstEntry: DWORD,
 nPalEntries: DWORD,
 nReserved: DWORD
});

var EMRALPHABLEND = STRUCT('EMRALPHABLEND', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 cxDest: LONG,
 cyDest: LONG,
 dwRop: DWORD,
 xSrc: LONG,
 ySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 cxSrc: LONG,
 cySrc: LONG
});

var EMRGRADIENTFILL = STRUCT('EMRGRADIENTFILL', {
 emr: EMR,
 rclBounds: RECTL,
 nVer: DWORD,
 nTri: DWORD,
 ulMode: ULONG,
 Ver: pointer
});

var EMRTRANSPARENTBLT = STRUCT('EMRTRANSPARENTBLT', {
 emr: EMR,
 rclBounds: RECTL,
 xDest: LONG,
 yDest: LONG,
 cxDest: LONG,
 cyDest: LONG,
 dwRop: DWORD,
 xSrc: LONG,
 ySrc: LONG,
 xformSrc: XFORM,
 crBkColorSrc: COLORREF,
 iUsageSrc: DWORD,
 offBmiSrc: DWORD,
 cbBmiSrc: DWORD,
 offBitsSrc: DWORD,
 cbBitsSrc: DWORD,
 cxSrc: LONG,
 cySrc: LONG
});

var POINTFLOAT = STRUCT('POINTFLOAT', {
 x: FLOAT,
 y: FLOAT
});

var GLYPHMETRICSFLOAT = STRUCT('GLYPHMETRICSFLOAT', {
 gmfBlackBoxX: FLOAT,
 gmfBlackBoxY: FLOAT,
 gmfptGlyphOrigin: POINTFLOAT,
 gmfCellIncX: FLOAT,
 gmfCellIncY: FLOAT
});

var LAYERPLANEDESCRIPTOR = STRUCT('LAYERPLANEDESCRIPTOR', {
 nSize: WORD,
 nVersion: WORD,
 dwFlags: DWORD,
 iPixelType: BYTE,
 cColorBits: BYTE,
 cRedBits: BYTE,
 cRedShift: BYTE,
 cGreenBits: BYTE,
 cGreenShift: BYTE,
 cBlueBits: BYTE,
 cBlueShift: BYTE,
 cAlphaBits: BYTE,
 cAlphaShift: BYTE,
 cAccumBits: BYTE,
 cAccumRedBits: BYTE,
 cAccumGreenBits: BYTE,
 cAccumBlueBits: BYTE,
 cAccumAlphaBits: BYTE,
 cDepthBits: BYTE,
 cStencilBits: BYTE,
 cAuxBuffers: BYTE,
 iLayerPlane: BYTE,
 bReserved: BYTE,
 crTransparent: COLORREF
});

var WGLSWAP = STRUCT('WGLSWAP', {
 hdc: HDC,
 uiFlags: UINT
});

var CBT_CREATEWND = STRUCT('CBT_CREATEWND', {
 lpcs: PTR(tagCREATESTRUCTA),
 hwndInsertAfter: HWND
});

var CREATESTRUCT = STRUCT('CREATESTRUCT', {
 lpCreateParams: LPVOID,
 hInstance: HINSTANCE,
 hMenu: HMENU,
 hwndParent: HWND,
 cy: int,
 cx: int,
 y: int,
 x: int,
 style: LONG,
 lpszName: LPCSTR,
 lpszClass: LPCSTR,
 dwExStyle: DWORD
});

var CBT_CREATEWNDW = STRUCT('CBT_CREATEWNDW', {
 lpcs: PTR(tagCREATESTRUCTW),
 hwndInsertAfter: HWND
});

var CREATESTRUCTW = STRUCT('CREATESTRUCTW', {
 lpCreateParams: LPVOID,
 hInstance: HINSTANCE,
 hMenu: HMENU,
 hwndParent: HWND,
 cy: int,
 cx: int,
 y: int,
 x: int,
 style: LONG,
 lpszName: LPCWSTR,
 lpszClass: LPCWSTR,
 dwExStyle: DWORD
});

var CBTACTIVATESTRUCT = STRUCT('CBTACTIVATESTRUCT', {
 fMouse: BOOL,
 hWndActive: HWND
});

var WTSSESSION_NOTIFICATION = STRUCT('WTSSESSION_NOTIFICATION', {
 cbSize: DWORD,
 dwSessionId: DWORD
});

var SHELLHOOKINFO = STRUCT('SHELLHOOKINFO', {
 hwnd: HWND,
 rc: RECT
});

var EVENTMSG = STRUCT('EVENTMSG', {
 message: UINT,
 paramL: UINT,
 paramH: UINT,
 time: DWORD,
 hwnd: HWND
});

var CWPSTRUCT = STRUCT('CWPSTRUCT', {
 lParam: LPARAM,
 wParam: WPARAM,
 message: UINT,
 hwnd: HWND
});

var CWPRETSTRUCT = STRUCT('CWPRETSTRUCT', {
 lResult: LRESULT,
 lParam: LPARAM,
 wParam: WPARAM,
 message: UINT,
 hwnd: HWND
});

var KBDLLHOOKSTRUCT = STRUCT('KBDLLHOOKSTRUCT', {
 vkCode: DWORD,
 scanCode: DWORD,
 flags: DWORD,
 time: DWORD,
 dwExtraInfo: ULONG_PTR
});

var MSLLHOOKSTRUCT = STRUCT('MSLLHOOKSTRUCT', {
 pt: POINT,
 mouseData: DWORD,
 flags: DWORD,
 time: DWORD,
 dwExtraInfo: ULONG_PTR
});

var DEBUGHOOKINFO = STRUCT('DEBUGHOOKINFO', {
 idThread: DWORD,
 idThreadInstaller: DWORD,
 lParam: LPARAM,
 wParam: WPARAM,
 code: int
});

var MOUSEHOOKSTRUCT = STRUCT('MOUSEHOOKSTRUCT', {
 pt: POINT,
 hwnd: HWND,
 wHitTestCode: UINT,
 dwExtraInfo: ULONG_PTR
});

var MOUSEHOOKSTRUCTEX = STRUCT('MOUSEHOOKSTRUCTEX', {
 mouseData: DWORD
});

var HARDWAREHOOKSTRUCT = STRUCT('HARDWAREHOOKSTRUCT', {
 hwnd: HWND,
 message: UINT,
 wParam: WPARAM,
 lParam: LPARAM
});

var MOUSEMOVEPOINT = STRUCT('MOUSEMOVEPOINT', {
 x: int,
 y: int,
 time: DWORD,
 dwExtraInfo: ULONG_PTR
});

var USEROBJECTFLAGS = STRUCT('USEROBJECTFLAGS', {
 fInherit: BOOL,
 fReserved: BOOL,
 dwFlags: DWORD
});

var WNDCLASSEX = STRUCT('WNDCLASSEX', {
 cbSize: UINT,
 style: UINT,
 lpfnWndProc: WNDPROC,
 cbClsExtra: int,
 cbWndExtra: int,
 hInstance: HINSTANCE,
 hIcon: HICON,
 hCursor: HCURSOR,
 hbrBackground: HBRUSH,
 lpszMenuName: LPCSTR,
 lpszClassName: LPCSTR,
 hIconSm: HICON
});

var WNDCLASSEXW = STRUCT('WNDCLASSEXW', {
 cbSize: UINT,
 style: UINT,
 lpfnWndProc: WNDPROC,
 cbClsExtra: int,
 cbWndExtra: int,
 hInstance: HINSTANCE,
 hIcon: HICON,
 hCursor: HCURSOR,
 hbrBackground: HBRUSH,
 lpszMenuName: LPCWSTR,
 lpszClassName: LPCWSTR,
 hIconSm: HICON
});

var WNDCLASS = STRUCT('WNDCLASS', {
 style: UINT,
 lpfnWndProc: WNDPROC,
 cbClsExtra: int,
 cbWndExtra: int,
 hInstance: HINSTANCE,
 hIcon: HICON,
 hCursor: HCURSOR,
 hbrBackground: HBRUSH,
 lpszMenuName: LPCSTR,
 lpszClassName: LPCSTR
});

var WNDCLASSW = STRUCT('WNDCLASSW', {
 style: UINT,
 lpfnWndProc: WNDPROC,
 cbClsExtra: int,
 cbWndExtra: int,
 hInstance: HINSTANCE,
 hIcon: HICON,
 hCursor: HCURSOR,
 hbrBackground: HBRUSH,
 lpszMenuName: LPCWSTR,
 lpszClassName: LPCWSTR
});

var MSG = STRUCT('MSG', {
 hwnd: HWND,
 message: UINT,
 wParam: WPARAM,
 lParam: LPARAM,
 time: DWORD,
 pt: POINT
});

var MINMAXINFO = STRUCT('MINMAXINFO', {
 ptReserved: POINT,
 ptMaxSize: POINT,
 ptMaxPosition: POINT,
 ptMinTrackSize: POINT,
 ptMaxTrackSize: POINT
});

var COPYDATASTRUCT = STRUCT('COPYDATASTRUCT', {
 dwData: ULONG_PTR,
 cbData: DWORD,
 lpData: PVOID
});

var MDINEXTMENU = STRUCT('MDINEXTMENU', {
 hmenuIn: HMENU,
 hmenuNext: HMENU,
 hwndNext: HWND
});

var POWERBROADCAST_SETTING = STRUCT('POWERBROADCAST_SETTING', {
 PowerSetting: GUID,
 DataLength: DWORD,
 Data: pointer
});

var WINDOWPOS = STRUCT('WINDOWPOS', {
 hwnd: HWND,
 hwndInsertAfter: HWND,
 x: int,
 y: int,
 cx: int,
 cy: int,
 flags: UINT
});

var NCCALCSIZE_PARAMS = STRUCT('NCCALCSIZE_PARAMS', {
 rgrc: pointer,
 lppos: PWINDOWPOS
});

var TRACKMOUSEEVENT = STRUCT('TRACKMOUSEEVENT', {
 cbSize: DWORD,
 dwFlags: DWORD,
 hwndTrack: HWND,
 dwHoverTime: DWORD
});

var ACCEL = STRUCT('ACCEL', {
 fVirt: BYTE,
 key: WORD,
 cmd: WORD
});

var PAINTSTRUCT = STRUCT('PAINTSTRUCT', {
 hdc: HDC,
 fErase: BOOL,
 rcPaint: RECT,
 fRestore: BOOL,
 fIncUpdate: BOOL,
 rgbReserved: pointer
});

var WINDOWPLACEMENT = STRUCT('WINDOWPLACEMENT', {
 length: UINT,
 flags: UINT,
 showCmd: UINT,
 ptMinPosition: POINT,
 ptMaxPosition: POINT,
 rcNormalPosition: RECT
});

var NMHDR = STRUCT('NMHDR', {
 hwndFrom: HWND,
 idFrom: UINT_PTR,
 code: UINT
});

var STYLESTRUCT = STRUCT('STYLESTRUCT', {
 styleOld: DWORD,
 styleNew: DWORD
});

var MEASUREITEMSTRUCT = STRUCT('MEASUREITEMSTRUCT', {
 CtlType: UINT,
 CtlID: UINT,
 itemID: UINT,
 itemWidth: UINT,
 itemHeight: UINT,
 itemData: ULONG_PTR
});

var DRAWITEMSTRUCT = STRUCT('DRAWITEMSTRUCT', {
 CtlType: UINT,
 CtlID: UINT,
 itemID: UINT,
 itemAction: UINT,
 itemState: UINT,
 hwndItem: HWND,
 hDC: HDC,
 rcItem: RECT,
 itemData: ULONG_PTR
});

var DELETEITEMSTRUCT = STRUCT('DELETEITEMSTRUCT', {
 CtlType: UINT,
 CtlID: UINT,
 itemID: UINT,
 hwndItem: HWND,
 itemData: ULONG_PTR
});

var COMPAREITEMSTRUCT = STRUCT('COMPAREITEMSTRUCT', {
 CtlType: UINT,
 CtlID: UINT,
 hwndItem: HWND,
 itemID1: UINT,
 itemData1: ULONG_PTR,
 itemID2: UINT,
 itemData2: ULONG_PTR,
 dwLocaleId: DWORD
});

var BSMINFO = STRUCT('BSMINFO', {
 cbSize: UINT,
 hdesk: HDESK,
 hwnd: HWND,
 luid: LUID
});

var UPDATELAYEREDWINDOWINFO = STRUCT('UPDATELAYEREDWINDOWINFO', {
 cbSize: DWORD,
 hdcDst: HDC,
 pptDst: PTR(uint),
 psize: PTR(uint),
 hdcSrc: HDC,
 pptSrc: PTR(uint),
 crKey: COLORREF,
 pblend: PTR(uint),
 dwFlags: DWORD,
 prcDirty: PTR(uint)
});

var FLASHWINFO = STRUCT('FLASHWINFO', {
 cbSize: UINT,
 hwnd: HWND,
 dwFlags: DWORD,
 uCount: UINT,
 dwTimeout: DWORD
});

var DLGTEMPLATE = STRUCT('DLGTEMPLATE', {
 style: DWORD,
 dwExtendedStyle: DWORD,
 cdit: WORD,
 x: short,
 y: short,
 cx: short,
 cy: short
});

var DLGITEMTEMPLATE = STRUCT('DLGITEMTEMPLATE', {
 style: DWORD,
 dwExtendedStyle: DWORD,
 x: short,
 y: short,
 cx: short,
 cy: short,
 id: WORD
});

var MOUSEINPUT = STRUCT('MOUSEINPUT', {
 dx: LONG,
 dy: LONG,
 mouseData: DWORD,
 dwFlags: DWORD,
 time: DWORD,
 dwExtraInfo: ULONG_PTR
});

var KEYBDINPUT = STRUCT('KEYBDINPUT', {
 wVk: WORD,
 wScan: WORD,
 dwFlags: DWORD,
 time: DWORD,
 dwExtraInfo: ULONG_PTR
});

var HARDWAREINPUT = STRUCT('HARDWAREINPUT', {
 uMsg: DWORD,
 wParamL: WORD,
 wParamH: WORD
});

var INPUT = STRUCT('INPUT', {
 type: DWORD
});

var HTOUCHINPUT__ = STRUCT('HTOUCHINPUT__', {
 unused: int
});

var TOUCHINPUT = STRUCT('TOUCHINPUT', {
 x: LONG,
 y: LONG,
 hSource: HANDLE,
 dwID: DWORD,
 dwFlags: DWORD,
 dwMask: DWORD,
 dwTime: DWORD,
 dwExtraInfo: ULONG_PTR,
 cxContact: DWORD,
 cyContact: DWORD
});

var LASTINPUTINFO = STRUCT('LASTINPUTINFO', {
 cbSize: UINT,
 dwTime: DWORD
});

var TPMPARAMS = STRUCT('TPMPARAMS', {
 cbSize: UINT,
 rcExclude: RECT
});

var MENUINFO = STRUCT('MENUINFO', {
 cbSize: DWORD,
 fMask: DWORD,
 dwStyle: DWORD,
 cyMax: UINT,
 hbrBack: HBRUSH,
 dwContextHelpID: DWORD,
 dwMenuData: ULONG_PTR
});

var MENUGETOBJECTINFO = STRUCT('MENUGETOBJECTINFO', {
 dwFlags: DWORD,
 uPos: UINT,
 hmenu: HMENU,
 riid: PVOID,
 pvObj: PVOID
});

var MENUITEMINFO = STRUCT('MENUITEMINFO', {
 cbSize: UINT,
 fMask: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hSubMenu: HMENU,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: ULONG_PTR,
 dwTypeData: LPSTR,
 cch: UINT,
 hbmpItem: HBITMAP
});

var MENUITEMINFOW = STRUCT('MENUITEMINFOW', {
 cbSize: UINT,
 fMask: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hSubMenu: HMENU,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: ULONG_PTR,
 dwTypeData: LPWSTR,
 cch: UINT,
 hbmpItem: HBITMAP
});

var DROPSTRUCT = STRUCT('DROPSTRUCT', {
 hwndSource: HWND,
 hwndSink: HWND,
 wFmt: DWORD,
 dwData: ULONG_PTR,
 ptDrop: POINT,
 dwControlData: DWORD
});

var DRAWTEXTPARAMS = STRUCT('DRAWTEXTPARAMS', {
 cbSize: UINT,
 iTabLength: int,
 iLeftMargin: int,
 iRightMargin: int,
 uiLengthDrawn: UINT
});

var HELPINFO = STRUCT('HELPINFO', {
 cbSize: UINT,
 iContextType: int,
 iCtrlId: int,
 hItemHandle: HANDLE,
 dwContextId: DWORD_PTR,
 MousePos: POINT
});

var MSGBOXPARAMS = STRUCT('MSGBOXPARAMS', {
 cbSize: UINT,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpszText: LPCSTR,
 lpszCaption: LPCSTR,
 dwStyle: DWORD,
 lpszIcon: LPCSTR,
 dwContextHelpId: DWORD_PTR,
 lpfnMsgBoxCallback: MSGBOXCALLBACK,
 dwLanguageId: DWORD
});

var MSGBOXPARAMSW = STRUCT('MSGBOXPARAMSW', {
 cbSize: UINT,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpszText: LPCWSTR,
 lpszCaption: LPCWSTR,
 dwStyle: DWORD,
 lpszIcon: LPCWSTR,
 dwContextHelpId: DWORD_PTR,
 lpfnMsgBoxCallback: MSGBOXCALLBACK,
 dwLanguageId: DWORD
});

var MENUITEMTEMPLATEHEADER = STRUCT('MENUITEMTEMPLATEHEADER', {
 versionNumber: WORD,
 offset: WORD
});

var MENUITEMTEMPLATE = STRUCT('MENUITEMTEMPLATE', {
 mtOption: WORD,
 mtID: WORD,
 mtString: pointer
});

var ICONINFO = STRUCT('ICONINFO', {
 fIcon: BOOL,
 xHotspot: DWORD,
 yHotspot: DWORD,
 hbmMask: HBITMAP,
 hbmColor: HBITMAP
});

var CURSORSHAPE = STRUCT('CURSORSHAPE', {
 xHotSpot: int,
 yHotSpot: int,
 cx: int,
 cy: int,
 cbWidth: int,
 Planes: BYTE,
 BitsPixel: BYTE
});

var ICONINFOEX = STRUCT('ICONINFOEX', {
 cbSize: DWORD,
 fIcon: BOOL,
 xHotspot: DWORD,
 yHotspot: DWORD,
 hbmMask: HBITMAP,
 hbmColor: HBITMAP,
 wResID: WORD,
 szModName: pointer,
 szResName: pointer
});

var ICONINFOEXW = STRUCT('ICONINFOEXW', {
 cbSize: DWORD,
 fIcon: BOOL,
 xHotspot: DWORD,
 yHotspot: DWORD,
 hbmMask: HBITMAP,
 hbmColor: HBITMAP,
 wResID: WORD,
 szModName: pointer,
 szResName: pointer
});

var SCROLLINFO = STRUCT('SCROLLINFO', {
 cbSize: UINT,
 fMask: UINT,
 nMin: int,
 nMax: int,
 nPage: UINT,
 nPos: int,
 nTrackPos: int
});

var MDICREATESTRUCT = STRUCT('MDICREATESTRUCT', {
 szClass: LPCSTR,
 szTitle: LPCSTR,
 hOwner: HANDLE,
 x: int,
 y: int,
 cx: int,
 cy: int,
 style: DWORD,
 lParam: LPARAM
});

var MDICREATESTRUCTW = STRUCT('MDICREATESTRUCTW', {
 szClass: LPCWSTR,
 szTitle: LPCWSTR,
 hOwner: HANDLE,
 x: int,
 y: int,
 cx: int,
 cy: int,
 style: DWORD,
 lParam: LPARAM
});

var CLIENTCREATESTRUCT = STRUCT('CLIENTCREATESTRUCT', {
 hWindowMenu: HANDLE,
 idFirstChild: UINT
});

var MULTIKEYHELP = STRUCT('MULTIKEYHELP', {
 mkSize: DWORD,
 mkKeylist: CHAR,
 szKeyphrase: pointer
});

var MULTIKEYHELPW = STRUCT('MULTIKEYHELPW', {
 mkSize: DWORD,
 mkKeylist: WCHAR,
 szKeyphrase: pointer
});

var HELPWININFO = STRUCT('HELPWININFO', {
 wStructSize: int,
 x: int,
 y: int,
 dx: int,
 dy: int,
 wMax: int,
 rgchMember: pointer
});

var HELPWININFOW = STRUCT('HELPWININFOW', {
 wStructSize: int,
 x: int,
 y: int,
 dx: int,
 dy: int,
 wMax: int,
 rgchMember: pointer
});

var NONCLIENTMETRICS = STRUCT('NONCLIENTMETRICS', {
 cbSize: UINT,
 iBorderWidth: int,
 iScrollWidth: int,
 iScrollHeight: int,
 iCaptionWidth: int,
 iCaptionHeight: int,
 lfCaptionFont: LOGFONTA,
 iSmCaptionWidth: int,
 iSmCaptionHeight: int,
 lfSmCaptionFont: LOGFONTA,
 iMenuWidth: int,
 iMenuHeight: int,
 lfMenuFont: LOGFONTA,
 lfStatusFont: LOGFONTA,
 lfMessageFont: LOGFONTA,
 iPaddedBorderWidth: int
});

var NONCLIENTMETRICSW = STRUCT('NONCLIENTMETRICSW', {
 cbSize: UINT,
 iBorderWidth: int,
 iScrollWidth: int,
 iScrollHeight: int,
 iCaptionWidth: int,
 iCaptionHeight: int,
 lfCaptionFont: LOGFONTW,
 iSmCaptionWidth: int,
 iSmCaptionHeight: int,
 lfSmCaptionFont: LOGFONTW,
 iMenuWidth: int,
 iMenuHeight: int,
 lfMenuFont: LOGFONTW,
 lfStatusFont: LOGFONTW,
 lfMessageFont: LOGFONTW,
 iPaddedBorderWidth: int
});

var MINIMIZEDMETRICS = STRUCT('MINIMIZEDMETRICS', {
 cbSize: UINT,
 iWidth: int,
 iHorzGap: int,
 iVertGap: int,
 iArrange: int
});

var ICONMETRICS = STRUCT('ICONMETRICS', {
 cbSize: UINT,
 iHorzSpacing: int,
 iVertSpacing: int,
 iTitleWrap: int,
 lfFont: LOGFONTA
});

var ICONMETRICSW = STRUCT('ICONMETRICSW', {
 cbSize: UINT,
 iHorzSpacing: int,
 iVertSpacing: int,
 iTitleWrap: int,
 lfFont: LOGFONTW
});

var ANIMATIONINFO = STRUCT('ANIMATIONINFO', {
 cbSize: UINT,
 iMinAnimate: int
});

var SERIALKEYS = STRUCT('SERIALKEYS', {
 cbSize: UINT,
 dwFlags: DWORD,
 lpszActivePort: LPSTR,
 lpszPort: LPSTR,
 iBaudRate: UINT,
 iPortState: UINT,
 iActive: UINT
});

var SERIALKEYSW = STRUCT('SERIALKEYSW', {
 cbSize: UINT,
 dwFlags: DWORD,
 lpszActivePort: LPWSTR,
 lpszPort: LPWSTR,
 iBaudRate: UINT,
 iPortState: UINT,
 iActive: UINT
});

var HIGHCONTRAST = STRUCT('HIGHCONTRAST', {
 cbSize: UINT,
 dwFlags: DWORD,
 lpszDefaultScheme: LPSTR
});

var HIGHCONTRASTW = STRUCT('HIGHCONTRASTW', {
 cbSize: UINT,
 dwFlags: DWORD,
 lpszDefaultScheme: LPWSTR
});

var VIDEOPARAMETERS = STRUCT('VIDEOPARAMETERS', {
 Guid: GUID,
 dwOffset: ULONG,
 dwCommand: ULONG,
 dwFlags: ULONG,
 dwMode: ULONG,
 dwTVStandard: ULONG,
 dwAvailableModes: ULONG,
 dwAvailableTVStandard: ULONG,
 dwFlickerFilter: ULONG,
 dwOverScanX: ULONG,
 dwOverScanY: ULONG,
 dwMaxUnscaledX: ULONG,
 dwMaxUnscaledY: ULONG,
 dwPositionX: ULONG,
 dwPositionY: ULONG,
 dwBrightness: ULONG,
 dwContrast: ULONG,
 dwCPType: ULONG,
 dwCPCommand: ULONG,
 dwCPStandard: ULONG,
 dwCPKey: ULONG,
 bCP_APSTriggerBits: ULONG,
 bOEMCopyProtection: pointer
});

var FILTERKEYS = STRUCT('FILTERKEYS', {
 cbSize: UINT,
 dwFlags: DWORD,
 iWaitMSec: DWORD,
 iDelayMSec: DWORD,
 iRepeatMSec: DWORD,
 iBounceMSec: DWORD
});

var STICKYKEYS = STRUCT('STICKYKEYS', {
 cbSize: UINT,
 dwFlags: DWORD
});

var MOUSEKEYS = STRUCT('MOUSEKEYS', {
 cbSize: UINT,
 dwFlags: DWORD,
 iMaxSpeed: DWORD,
 iTimeToMaxSpeed: DWORD,
 iCtrlSpeed: DWORD,
 dwReserved1: DWORD,
 dwReserved2: DWORD
});

var ACCESSTIMEOUT = STRUCT('ACCESSTIMEOUT', {
 cbSize: UINT,
 dwFlags: DWORD,
 iTimeOutMSec: DWORD
});

var SOUNDSENTRY = STRUCT('SOUNDSENTRY', {
 cbSize: UINT,
 dwFlags: DWORD,
 iFSTextEffect: DWORD,
 iFSTextEffectMSec: DWORD,
 iFSTextEffectColorBits: DWORD,
 iFSGrafEffect: DWORD,
 iFSGrafEffectMSec: DWORD,
 iFSGrafEffectColor: DWORD,
 iWindowsEffect: DWORD,
 iWindowsEffectMSec: DWORD,
 lpszWindowsEffectDLL: LPSTR,
 iWindowsEffectOrdinal: DWORD
});

var SOUNDSENTRYW = STRUCT('SOUNDSENTRYW', {
 cbSize: UINT,
 dwFlags: DWORD,
 iFSTextEffect: DWORD,
 iFSTextEffectMSec: DWORD,
 iFSTextEffectColorBits: DWORD,
 iFSGrafEffect: DWORD,
 iFSGrafEffectMSec: DWORD,
 iFSGrafEffectColor: DWORD,
 iWindowsEffect: DWORD,
 iWindowsEffectMSec: DWORD,
 lpszWindowsEffectDLL: LPWSTR,
 iWindowsEffectOrdinal: DWORD
});

var TOGGLEKEYS = STRUCT('TOGGLEKEYS', {
 cbSize: UINT,
 dwFlags: DWORD
});

var AUDIODESCRIPTION = STRUCT('AUDIODESCRIPTION', {
 cbSize: UINT,
 Enabled: BOOL,
 Locale: LCID
});

var MONITORINFO = STRUCT('MONITORINFO', {
 cbSize: DWORD,
 rcMonitor: RECT,
 rcWork: RECT,
 dwFlags: DWORD
});

var MONITORINFOEX = STRUCT('MONITORINFOEX', {
 szDevice: pointer
});

var MONITORINFOEXW = STRUCT('MONITORINFOEXW', {
 szDevice: pointer
});

var GUITHREADINFO = STRUCT('GUITHREADINFO', {
 cbSize: DWORD,
 flags: DWORD,
 hwndActive: HWND,
 hwndFocus: HWND,
 hwndCapture: HWND,
 hwndMenuOwner: HWND,
 hwndMoveSize: HWND,
 hwndCaret: HWND,
 rcCaret: RECT
});

var CURSORINFO = STRUCT('CURSORINFO', {
 cbSize: DWORD,
 flags: DWORD,
 hCursor: HCURSOR,
 ptScreenPos: POINT
});

var WINDOWINFO = STRUCT('WINDOWINFO', {
 cbSize: DWORD,
 rcWindow: RECT,
 rcClient: RECT,
 dwStyle: DWORD,
 dwExStyle: DWORD,
 dwWindowStatus: DWORD,
 cxWindowBorders: UINT,
 cyWindowBorders: UINT,
 atomWindowType: ATOM,
 wCreatorVersion: WORD
});

var TITLEBARINFO = STRUCT('TITLEBARINFO', {
 cbSize: DWORD,
 rcTitleBar: RECT,
 rgstate: pointer
});

var TITLEBARINFOEX = STRUCT('TITLEBARINFOEX', {
 cbSize: DWORD,
 rcTitleBar: RECT,
 rgstate: pointer,
 rgrect: pointer
});

var MENUBARINFO = STRUCT('MENUBARINFO', {
 cbSize: DWORD,
 rcBar: RECT,
 hMenu: HMENU,
 hwndMenu: HWND,
 fBarFocused: BOOL,
 fFocused: BOOL
});

var SCROLLBARINFO = STRUCT('SCROLLBARINFO', {
 cbSize: DWORD,
 rcScrollBar: RECT,
 dxyLineButton: int,
 xyThumbTop: int,
 xyThumbBottom: int,
 reserved: int,
 rgstate: pointer
});

var COMBOBOXINFO = STRUCT('COMBOBOXINFO', {
 cbSize: DWORD,
 rcItem: RECT,
 rcButton: RECT,
 stateButton: DWORD,
 hwndCombo: HWND,
 hwndItem: HWND,
 hwndList: HWND
});

var ALTTABINFO = STRUCT('ALTTABINFO', {
 cbSize: DWORD,
 cItems: int,
 cColumns: int,
 cRows: int,
 iColFocus: int,
 iRowFocus: int,
 cxItem: int,
 cyItem: int,
 ptStart: POINT
});

var HRAWINPUT__ = STRUCT('HRAWINPUT__', {
 unused: int
});

var RAWINPUTHEADER = STRUCT('RAWINPUTHEADER', {
 dwType: DWORD,
 dwSize: DWORD,
 hDevice: HANDLE,
 wParam: WPARAM
});

var RAWMOUSE = STRUCT('RAWMOUSE', {
 usFlags: USHORT,
 ulRawButtons: ULONG,
 lLastX: LONG,
 lLastY: LONG,
 ulExtraInformation: ULONG
});

var undefined = STRUCT('undefined', {
 usButtonFlags: USHORT,
 usButtonData: USHORT
});

var RAWKEYBOARD = STRUCT('RAWKEYBOARD', {
 MakeCode: USHORT,
 Flags: USHORT,
 Reserved: USHORT,
 VKey: USHORT,
 Message: UINT,
 ExtraInformation: ULONG
});

var RAWHID = STRUCT('RAWHID', {
 dwSizeHid: DWORD,
 dwCount: DWORD,
 bRawData: pointer
});

var RAWINPUT = STRUCT('RAWINPUT', {
 header: RAWINPUTHEADER,
 data: 
});

var RID_DEVICE_INFO_MOUSE = STRUCT('RID_DEVICE_INFO_MOUSE', {
 dwId: DWORD,
 dwNumberOfButtons: DWORD,
 dwSampleRate: DWORD,
 fHasHorizontalWheel: BOOL
});

var RID_DEVICE_INFO_KEYBOARD = STRUCT('RID_DEVICE_INFO_KEYBOARD', {
 dwType: DWORD,
 dwSubType: DWORD,
 dwKeyboardMode: DWORD,
 dwNumberOfFunctionKeys: DWORD,
 dwNumberOfIndicators: DWORD,
 dwNumberOfKeysTotal: DWORD
});

var RID_DEVICE_INFO_HID = STRUCT('RID_DEVICE_INFO_HID', {
 dwVendorId: DWORD,
 dwProductId: DWORD,
 dwVersionNumber: DWORD,
 usUsagePage: USHORT,
 usUsage: USHORT
});

var RID_DEVICE_INFO = STRUCT('RID_DEVICE_INFO', {
 cbSize: DWORD,
 dwType: DWORD
});

var RAWINPUTDEVICE = STRUCT('RAWINPUTDEVICE', {
 usUsagePage: USHORT,
 usUsage: USHORT,
 dwFlags: DWORD,
 hwndTarget: HWND
});

var RAWINPUTDEVICELIST = STRUCT('RAWINPUTDEVICELIST', {
 hDevice: HANDLE,
 dwType: DWORD
});

var CHANGEFILTERSTRUCT = STRUCT('CHANGEFILTERSTRUCT', {
 cbSize: DWORD,
 ExtStatus: DWORD
});

var HGESTUREINFO__ = STRUCT('HGESTUREINFO__', {
 unused: int
});

var GESTUREINFO = STRUCT('GESTUREINFO', {
 cbSize: UINT,
 dwFlags: DWORD,
 dwID: DWORD,
 hwndTarget: HWND,
 ptsLocation: POINTS,
 dwInstanceID: DWORD,
 dwSequenceID: DWORD,
 ullArguments: ULONGLONG,
 cbExtraArgs: UINT
});

var GESTURENOTIFYSTRUCT = STRUCT('GESTURENOTIFYSTRUCT', {
 cbSize: UINT,
 dwFlags: DWORD,
 hwndTarget: HWND,
 ptsLocation: POINTS,
 dwInstanceID: DWORD
});

var GESTURECONFIG = STRUCT('GESTURECONFIG', {
 dwID: DWORD,
 dwWant: DWORD,
 dwBlock: DWORD
});

var CPINFO = STRUCT('CPINFO', {
 MaxCharSize: UINT,
 DefaultChar: pointer,
 LeadByte: pointer
});

var CPINFOEX = STRUCT('CPINFOEX', {
 MaxCharSize: UINT,
 DefaultChar: pointer,
 LeadByte: pointer,
 UnicodeDefaultChar: WCHAR,
 CodePage: UINT,
 CodePageName: pointer
});

var CPINFOEXW = STRUCT('CPINFOEXW', {
 MaxCharSize: UINT,
 DefaultChar: pointer,
 LeadByte: pointer,
 UnicodeDefaultChar: WCHAR,
 CodePage: UINT,
 CodePageName: pointer
});

var NUMBERFMT = STRUCT('NUMBERFMT', {
 NumDigits: UINT,
 LeadingZero: UINT,
 Grouping: UINT,
 lpDecimalSep: LPSTR,
 lpThousandSep: LPSTR,
 NegativeOrder: UINT
});

var NUMBERFMTW = STRUCT('NUMBERFMTW', {
 NumDigits: UINT,
 LeadingZero: UINT,
 Grouping: UINT,
 lpDecimalSep: LPWSTR,
 lpThousandSep: LPWSTR,
 NegativeOrder: UINT
});

var CURRENCYFMT = STRUCT('CURRENCYFMT', {
 NumDigits: UINT,
 LeadingZero: UINT,
 Grouping: UINT,
 lpDecimalSep: LPSTR,
 lpThousandSep: LPSTR,
 NegativeOrder: UINT,
 PositiveOrder: UINT,
 lpCurrencySymbol: LPSTR
});

var CURRENCYFMTW = STRUCT('CURRENCYFMTW', {
 NumDigits: UINT,
 LeadingZero: UINT,
 Grouping: UINT,
 lpDecimalSep: LPWSTR,
 lpThousandSep: LPWSTR,
 NegativeOrder: UINT,
 PositiveOrder: UINT,
 lpCurrencySymbol: LPWSTR
});

var NLSVERSIONINFO = STRUCT('NLSVERSIONINFO', {
 dwNLSVersionInfoSize: DWORD,
 dwNLSVersion: DWORD,
 dwDefinedVersion: DWORD
});

var NLSVERSIONINFOEX = STRUCT('NLSVERSIONINFOEX', {
 dwNLSVersionInfoSize: DWORD,
 dwNLSVersion: DWORD,
 dwDefinedVersion: DWORD,
 dwEffectiveId: DWORD,
 guidCustomVersion: GUID
});

var FILEMUIINFO = STRUCT('FILEMUIINFO', {
 dwSize: DWORD,
 dwVersion: DWORD,
 dwFileType: DWORD,
 pChecksum: pointer,
 pServiceChecksum: pointer,
 dwLanguageNameOffset: DWORD,
 dwTypeIDMainSize: DWORD,
 dwTypeIDMainOffset: DWORD,
 dwTypeNameMainOffset: DWORD,
 dwTypeIDMUISize: DWORD,
 dwTypeIDMUIOffset: DWORD,
 dwTypeNameMUIOffset: DWORD,
 abBuffer: pointer
});

var COORD = STRUCT('COORD', {
 X: SHORT,
 Y: SHORT
});

var SMALL_RECT = STRUCT('SMALL_RECT', {
 Left: SHORT,
 Top: SHORT,
 Right: SHORT,
 Bottom: SHORT
});

var KEY_EVENT_RECORD = STRUCT('KEY_EVENT_RECORD', {
 bKeyDown: BOOL,
 wRepeatCount: WORD,
 wVirtualKeyCode: WORD,
 wVirtualScanCode: WORD,
 uChar: ,
 dwControlKeyState: DWORD
});

var MOUSE_EVENT_RECORD = STRUCT('MOUSE_EVENT_RECORD', {
 dwMousePosition: COORD,
 dwButtonState: DWORD,
 dwControlKeyState: DWORD,
 dwEventFlags: DWORD
});

var WINDOW_BUFFER_SIZE_RECORD = STRUCT('WINDOW_BUFFER_SIZE_RECORD', {
 dwSize: COORD
});

var MENU_EVENT_RECORD = STRUCT('MENU_EVENT_RECORD', {
 dwCommandId: UINT
});

var FOCUS_EVENT_RECORD = STRUCT('FOCUS_EVENT_RECORD', {
 bSetFocus: BOOL
});

var INPUT_RECORD = STRUCT('INPUT_RECORD', {
 EventType: WORD,
 Event: 
});

var CHAR_INFO = STRUCT('CHAR_INFO', {
 Char: ,
 Attributes: WORD
});

var CONSOLE_SCREEN_BUFFER_INFO = STRUCT('CONSOLE_SCREEN_BUFFER_INFO', {
 dwSize: COORD,
 dwCursorPosition: COORD,
 wAttributes: WORD,
 srWindow: SMALL_RECT,
 dwMaximumWindowSize: COORD
});

var CONSOLE_SCREEN_BUFFER_INFOEX = STRUCT('CONSOLE_SCREEN_BUFFER_INFOEX', {
 cbSize: ULONG,
 dwSize: COORD,
 dwCursorPosition: COORD,
 wAttributes: WORD,
 srWindow: SMALL_RECT,
 dwMaximumWindowSize: COORD,
 wPopupAttributes: WORD,
 bFullscreenSupported: BOOL,
 ColorTable: pointer
});

var CONSOLE_CURSOR_INFO = STRUCT('CONSOLE_CURSOR_INFO', {
 dwSize: DWORD,
 bVisible: BOOL
});

var CONSOLE_FONT_INFO = STRUCT('CONSOLE_FONT_INFO', {
 nFont: DWORD,
 dwFontSize: COORD
});

var CONSOLE_FONT_INFOEX = STRUCT('CONSOLE_FONT_INFOEX', {
 cbSize: ULONG,
 nFont: DWORD,
 dwFontSize: COORD,
 FontFamily: UINT,
 FontWeight: UINT,
 FaceName: pointer
});

var CONSOLE_HISTORY_INFO = STRUCT('CONSOLE_HISTORY_INFO', {
 cbSize: UINT,
 HistoryBufferSize: UINT,
 NumberOfHistoryBuffers: UINT,
 dwFlags: DWORD
});

var CONSOLE_SELECTION_INFO = STRUCT('CONSOLE_SELECTION_INFO', {
 dwFlags: DWORD,
 dwSelectionAnchor: COORD,
 srSelection: SMALL_RECT
});

var CONSOLE_READCONSOLE_CONTROL = STRUCT('CONSOLE_READCONSOLE_CONTROL', {
 nLength: ULONG,
 nInitialChars: ULONG,
 dwCtrlWakeupMask: ULONG,
 dwControlKeyState: ULONG
});

var VS_FIXEDFILEINFO = STRUCT('VS_FIXEDFILEINFO', {
 dwSignature: DWORD,
 dwStrucVersion: DWORD,
 dwFileVersionMS: DWORD,
 dwFileVersionLS: DWORD,
 dwProductVersionMS: DWORD,
 dwProductVersionLS: DWORD,
 dwFileFlagsMask: DWORD,
 dwFileFlags: DWORD,
 dwFileOS: DWORD,
 dwFileType: DWORD,
 dwFileSubtype: DWORD,
 dwFileDateMS: DWORD,
 dwFileDateLS: DWORD
});

var val_context = STRUCT('val_context', {
 valuelen: int,
 value_context: LPVOID,
 val_buff_ptr: LPVOID
});

var PVALUE = STRUCT('PVALUE', {
 pv_valuename: LPSTR,
 pv_valuelen: int,
 pv_value_context: LPVOID,
 pv_type: DWORD
});

var PVALUEW = STRUCT('PVALUEW', {
 pv_valuename: LPWSTR,
 pv_valuelen: int,
 pv_value_context: LPVOID,
 pv_type: DWORD
});

var REG_PROVIDER = STRUCT('REG_PROVIDER', {
 pi_R0_1val: PQUERYHANDLER,
 pi_R0_allvals: PQUERYHANDLER,
 pi_R3_1val: PQUERYHANDLER,
 pi_R3_allvals: PQUERYHANDLER,
 pi_flags: DWORD,
 pi_key_context: LPVOID
});

var VALENT = STRUCT('VALENT', {
 ve_valuename: LPSTR,
 ve_valuelen: DWORD,
 ve_valueptr: DWORD_PTR,
 ve_type: DWORD
});

var VALENTW = STRUCT('VALENTW', {
 ve_valuename: LPWSTR,
 ve_valuelen: DWORD,
 ve_valueptr: DWORD_PTR,
 ve_type: DWORD
});

var NETRESOURCE = STRUCT('NETRESOURCE', {
 dwScope: DWORD,
 dwType: DWORD,
 dwDisplayType: DWORD,
 dwUsage: DWORD,
 lpLocalName: LPSTR,
 lpRemoteName: LPSTR,
 lpComment: LPSTR,
 lpProvider: LPSTR
});

var NETRESOURCEW = STRUCT('NETRESOURCEW', {
 dwScope: DWORD,
 dwType: DWORD,
 dwDisplayType: DWORD,
 dwUsage: DWORD,
 lpLocalName: LPWSTR,
 lpRemoteName: LPWSTR,
 lpComment: LPWSTR,
 lpProvider: LPWSTR
});

var CONNECTDLGSTRUCT = STRUCT('CONNECTDLGSTRUCT', {
 cbStructure: DWORD,
 hwndOwner: HWND,
 lpConnRes: LPNETRESOURCEA,
 dwFlags: DWORD,
 dwDevNum: DWORD
});

var CONNECTDLGSTRUCTW = STRUCT('CONNECTDLGSTRUCTW', {
 cbStructure: DWORD,
 hwndOwner: HWND,
 lpConnRes: LPNETRESOURCEW,
 dwFlags: DWORD,
 dwDevNum: DWORD
});

var DISCDLGSTRUCT = STRUCT('DISCDLGSTRUCT', {
 cbStructure: DWORD,
 hwndOwner: HWND,
 lpLocalName: LPSTR,
 lpRemoteName: LPSTR,
 dwFlags: DWORD
});

var DISCDLGSTRUCTW = STRUCT('DISCDLGSTRUCTW', {
 cbStructure: DWORD,
 hwndOwner: HWND,
 lpLocalName: LPWSTR,
 lpRemoteName: LPWSTR,
 dwFlags: DWORD
});

var UNIVERSAL_NAME_INFO = STRUCT('UNIVERSAL_NAME_INFO', {
 lpUniversalName: LPSTR
});

var UNIVERSAL_NAME_INFOW = STRUCT('UNIVERSAL_NAME_INFOW', {
 lpUniversalName: LPWSTR
});

var REMOTE_NAME_INFO = STRUCT('REMOTE_NAME_INFO', {
 lpUniversalName: LPSTR,
 lpConnectionName: LPSTR,
 lpRemainingPath: LPSTR
});

var REMOTE_NAME_INFOW = STRUCT('REMOTE_NAME_INFOW', {
 lpUniversalName: LPWSTR,
 lpConnectionName: LPWSTR,
 lpRemainingPath: LPWSTR
});

var NETINFOSTRUCT = STRUCT('NETINFOSTRUCT', {
 cbStructure: DWORD,
 dwProviderVersion: DWORD,
 dwStatus: DWORD,
 dwCharacteristics: DWORD,
 dwHandle: ULONG_PTR,
 wNetType: WORD,
 dwPrinters: DWORD,
 dwDrives: DWORD
});

var NETCONNECTINFOSTRUCT = STRUCT('NETCONNECTINFOSTRUCT', {
 cbStructure: DWORD,
 dwFlags: DWORD,
 dwSpeed: DWORD,
 dwDelay: DWORD,
 dwOptDataSize: DWORD
});

var DDEACK = STRUCT('DDEACK', {
 bAppReturnCode: ushort,
 reserved: ushort,
 fBusy: ushort,
 fAck: ushort
});

var DDEADVISE = STRUCT('DDEADVISE', {
 reserved: ushort,
 fDeferUpd: ushort,
 fAckReq: ushort,
 cfFormat: short
});

var DDEDATA = STRUCT('DDEDATA', {
 unused: ushort,
 fResponse: ushort,
 fRelease: ushort,
 reserved: ushort,
 fAckReq: ushort,
 cfFormat: short,
 Value: pointer
});

var DDEPOKE = STRUCT('DDEPOKE', {
 unused: ushort,
 fRelease: ushort,
 fReserved: ushort,
 cfFormat: short,
 Value: pointer
});

var DDELN = STRUCT('DDELN', {
 unused: ushort,
 fRelease: ushort,
 fDeferUpd: ushort,
 fAckReq: ushort,
 cfFormat: short
});

var DDEUP = STRUCT('DDEUP', {
 unused: ushort,
 fAck: ushort,
 fRelease: ushort,
 fReserved: ushort,
 fAckReq: ushort,
 cfFormat: short,
 rgb: pointer
});

var HCONVLIST__ = STRUCT('HCONVLIST__', {
 unused: int
});

var HCONV__ = STRUCT('HCONV__', {
 unused: int
});

var HSZ__ = STRUCT('HSZ__', {
 unused: int
});

var HDDEDATA__ = STRUCT('HDDEDATA__', {
 unused: int
});

var HSZPAIR = STRUCT('HSZPAIR', {
 hszSvc: HSZ,
 hszTopic: HSZ
});

var CONVCONTEXT = STRUCT('CONVCONTEXT', {
 cb: UINT,
 wFlags: UINT,
 wCountryID: UINT,
 iCodePage: int,
 dwLangID: DWORD,
 dwSecurity: DWORD,
 qos: SECURITY_QUALITY_OF_SERVICE
});

var CONVINFO = STRUCT('CONVINFO', {
 cb: DWORD,
 hUser: DWORD_PTR,
 hConvPartner: HCONV,
 hszSvcPartner: HSZ,
 hszServiceReq: HSZ,
 hszTopic: HSZ,
 hszItem: HSZ,
 wFmt: UINT,
 wType: UINT,
 wStatus: UINT,
 wConvst: UINT,
 wLastError: UINT,
 hConvList: HCONVLIST,
 ConvCtxt: CONVCONTEXT,
 hwnd: HWND,
 hwndPartner: HWND
});

var DDEML_MSG_HOOK_DATA = STRUCT('DDEML_MSG_HOOK_DATA', {
 uiLo: UINT_PTR,
 uiHi: UINT_PTR,
 cbData: DWORD,
 Data: pointer
});

var MONMSGSTRUCT = STRUCT('MONMSGSTRUCT', {
 cb: UINT,
 hwndTo: HWND,
 dwTime: DWORD,
 hTask: HANDLE,
 wMsg: UINT,
 wParam: WPARAM,
 lParam: LPARAM,
 dmhd: DDEML_MSG_HOOK_DATA
});

var MONCBSTRUCT = STRUCT('MONCBSTRUCT', {
 cb: UINT,
 dwTime: DWORD,
 hTask: HANDLE,
 dwRet: DWORD,
 wType: UINT,
 wFmt: UINT,
 hConv: HCONV,
 hsz1: HSZ,
 hsz2: HSZ,
 hData: HDDEDATA,
 dwData1: ULONG_PTR,
 dwData2: ULONG_PTR,
 cc: CONVCONTEXT,
 cbData: DWORD,
 Data: pointer
});

var MONHSZSTRUCT = STRUCT('MONHSZSTRUCT', {
 cb: UINT,
 fsAction: BOOL,
 dwTime: DWORD,
 hsz: HSZ,
 hTask: HANDLE,
 str: pointer
});

var MONHSZSTRUCTW = STRUCT('MONHSZSTRUCTW', {
 cb: UINT,
 fsAction: BOOL,
 dwTime: DWORD,
 hsz: HSZ,
 hTask: HANDLE,
 str: pointer
});

var MONERRSTRUCT = STRUCT('MONERRSTRUCT', {
 cb: UINT,
 wLastError: UINT,
 dwTime: DWORD,
 hTask: HANDLE
});

var MONLINKSTRUCT = STRUCT('MONLINKSTRUCT', {
 cb: UINT,
 dwTime: DWORD,
 hTask: HANDLE,
 fEstablished: BOOL,
 fNoData: BOOL,
 hszSvc: HSZ,
 hszTopic: HSZ,
 hszItem: HSZ,
 wFmt: UINT,
 fServer: BOOL,
 hConvServer: HCONV,
 hConvClient: HCONV
});

var MONCONVSTRUCT = STRUCT('MONCONVSTRUCT', {
 cb: UINT,
 fConnect: BOOL,
 dwTime: DWORD,
 hTask: HANDLE,
 hszSvc: HSZ,
 hszTopic: HSZ,
 hConvClient: HCONV,
 hConvServer: HCONV
});

var CRGB = STRUCT('CRGB', {
 bRed: BYTE,
 bGreen: BYTE,
 bBlue: BYTE,
 bExtra: BYTE
});

var MMTIME = STRUCT('MMTIME', {
 wType: UINT,
 u: 
});

var undefined = STRUCT('undefined', {
 hour: BYTE,
 min: BYTE,
 sec: BYTE,
 frame: BYTE,
 fps: BYTE,
 dummy: BYTE,
 pad: pointer
});

var undefined = STRUCT('undefined', {
 songptrpos: DWORD
});

var HDRVR__ = STRUCT('HDRVR__', {
 unused: int
});

var DRVCONFIGINFOEX = STRUCT('DRVCONFIGINFOEX', {
 dwDCISize: DWORD,
 lpszDCISectionName: LPCWSTR,
 lpszDCIAliasName: LPCWSTR,
 dnDevNode: DWORD
});

var DRVCONFIGINFO = STRUCT('DRVCONFIGINFO', {
 dwDCISize: DWORD,
 lpszDCISectionName: LPCWSTR,
 lpszDCIAliasName: LPCWSTR
});

var HWAVE__ = STRUCT('HWAVE__', {
 unused: int
});

var HWAVEIN__ = STRUCT('HWAVEIN__', {
 unused: int
});

var HWAVEOUT__ = STRUCT('HWAVEOUT__', {
 unused: int
});

var WAVEHDR = STRUCT('WAVEHDR', {
 lpData: LPSTR,
 dwBufferLength: DWORD,
 dwBytesRecorded: DWORD,
 dwUser: DWORD_PTR,
 dwFlags: DWORD,
 dwLoops: DWORD,
 lpNext: PTR(wavehdr_tag),
 reserved: DWORD_PTR
});

var WAVEOUTCAPS = STRUCT('WAVEOUTCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var WAVEOUTCAPSW = STRUCT('WAVEOUTCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var WAVEOUTCAPS2 = STRUCT('WAVEOUTCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var WAVEOUTCAPS2W = STRUCT('WAVEOUTCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var WAVEINCAPS = STRUCT('WAVEINCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD
});

var WAVEINCAPSW = STRUCT('WAVEINCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD
});

var WAVEINCAPS2 = STRUCT('WAVEINCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var WAVEINCAPS2W = STRUCT('WAVEINCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var WAVEFORMAT = STRUCT('WAVEFORMAT', {
 wFormatTag: WORD,
 nChannels: WORD,
 nSamplesPerSec: DWORD,
 nAvgBytesPerSec: DWORD,
 nBlockAlign: WORD
});

var PCMWAVEFORMAT = STRUCT('PCMWAVEFORMAT', {
 wf: WAVEFORMAT,
 wBitsPerSample: WORD
});

var WAVEFORMATEX = STRUCT('WAVEFORMATEX', {
 wFormatTag: WORD,
 nChannels: WORD,
 nSamplesPerSec: DWORD,
 nAvgBytesPerSec: DWORD,
 nBlockAlign: WORD,
 wBitsPerSample: WORD,
 cbSize: WORD
});

var HMIDI__ = STRUCT('HMIDI__', {
 unused: int
});

var HMIDIIN__ = STRUCT('HMIDIIN__', {
 unused: int
});

var HMIDIOUT__ = STRUCT('HMIDIOUT__', {
 unused: int
});

var HMIDISTRM__ = STRUCT('HMIDISTRM__', {
 unused: int
});

var MIDIOUTCAPS = STRUCT('MIDIOUTCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD
});

var MIDIOUTCAPSW = STRUCT('MIDIOUTCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD
});

var MIDIOUTCAPS2 = STRUCT('MIDIOUTCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIDIOUTCAPS2W = STRUCT('MIDIOUTCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIDIINCAPS = STRUCT('MIDIINCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwSupport: DWORD
});

var MIDIINCAPSW = STRUCT('MIDIINCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwSupport: DWORD
});

var MIDIINCAPS2 = STRUCT('MIDIINCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIDIINCAPS2W = STRUCT('MIDIINCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIDIHDR = STRUCT('MIDIHDR', {
 lpData: LPSTR,
 dwBufferLength: DWORD,
 dwBytesRecorded: DWORD,
 dwUser: DWORD_PTR,
 dwFlags: DWORD,
 lpNext: PTR(midihdr_tag),
 reserved: DWORD_PTR,
 dwOffset: DWORD,
 dwReserved: pointer
});

var MIDIEVENT = STRUCT('MIDIEVENT', {
 dwDeltaTime: DWORD,
 dwStreamID: DWORD,
 dwEvent: DWORD,
 dwParms: pointer
});

var MIDISTRMBUFFVER = STRUCT('MIDISTRMBUFFVER', {
 dwVersion: DWORD,
 dwMid: DWORD,
 dwOEMVersion: DWORD
});

var MIDIPROPTIMEDIV = STRUCT('MIDIPROPTIMEDIV', {
 cbStruct: DWORD,
 dwTimeDiv: DWORD
});

var MIDIPROPTEMPO = STRUCT('MIDIPROPTEMPO', {
 cbStruct: DWORD,
 dwTempo: DWORD
});

var AUXCAPS = STRUCT('AUXCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var AUXCAPSW = STRUCT('AUXCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var AUXCAPS2 = STRUCT('AUXCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var AUXCAPS2W = STRUCT('AUXCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var HMIXEROBJ__ = STRUCT('HMIXEROBJ__', {
 unused: int
});

var HMIXER__ = STRUCT('HMIXER__', {
 unused: int
});

var MIXERCAPS = STRUCT('MIXERCAPS', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 fdwSupport: DWORD,
 cDestinations: DWORD
});

var MIXERCAPSW = STRUCT('MIXERCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 fdwSupport: DWORD,
 cDestinations: DWORD
});

var MIXERCAPS2 = STRUCT('MIXERCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 fdwSupport: DWORD,
 cDestinations: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIXERCAPS2W = STRUCT('MIXERCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer,
 fdwSupport: DWORD,
 cDestinations: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIXERLINE = STRUCT('MIXERLINE', {
 cbStruct: DWORD,
 dwDestination: DWORD,
 dwSource: DWORD,
 dwLineID: DWORD,
 fdwLine: DWORD,
 dwUser: DWORD_PTR,
 dwComponentType: DWORD,
 cChannels: DWORD,
 cConnections: DWORD,
 cControls: DWORD,
 szShortName: pointer,
 szName: pointer,
 Target: 
});

var undefined = STRUCT('undefined', {
 dwType: DWORD,
 dwDeviceID: DWORD,
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer
});

var MIXERLINEW = STRUCT('MIXERLINEW', {
 cbStruct: DWORD,
 dwDestination: DWORD,
 dwSource: DWORD,
 dwLineID: DWORD,
 fdwLine: DWORD,
 dwUser: DWORD_PTR,
 dwComponentType: DWORD,
 cChannels: DWORD,
 cConnections: DWORD,
 cControls: DWORD,
 szShortName: pointer,
 szName: pointer,
 Target: 
});

var undefined = STRUCT('undefined', {
 dwType: DWORD,
 dwDeviceID: DWORD,
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: pointer
});

var MIXERCONTROL = STRUCT('MIXERCONTROL', {
 cbStruct: DWORD,
 dwControlID: DWORD,
 dwControlType: DWORD,
 fdwControl: DWORD,
 cMultipleItems: DWORD,
 szShortName: pointer,
 szName: pointer,
 Bounds: ,
 Metrics: 
});

var undefined = STRUCT('undefined', {
 lMinimum: LONG,
 lMaximum: LONG
});

var undefined = STRUCT('undefined', {
 dwMinimum: DWORD,
 dwMaximum: DWORD
});

var MIXERCONTROLW = STRUCT('MIXERCONTROLW', {
 cbStruct: DWORD,
 dwControlID: DWORD,
 dwControlType: DWORD,
 fdwControl: DWORD,
 cMultipleItems: DWORD,
 szShortName: pointer,
 szName: pointer,
 Bounds: ,
 Metrics: 
});

var undefined = STRUCT('undefined', {
 lMinimum: LONG,
 lMaximum: LONG
});

var undefined = STRUCT('undefined', {
 dwMinimum: DWORD,
 dwMaximum: DWORD
});

var MIXERLINECONTROLS = STRUCT('MIXERLINECONTROLS', {
 cbStruct: DWORD,
 dwLineID: DWORD,
 cControls: DWORD,
 cbmxctrl: DWORD,
 pamxctrl: LPMIXERCONTROLA
});

var MIXERLINECONTROLSW = STRUCT('MIXERLINECONTROLSW', {
 cbStruct: DWORD,
 dwLineID: DWORD,
 cControls: DWORD,
 cbmxctrl: DWORD,
 pamxctrl: LPMIXERCONTROLW
});

var MIXERCONTROLDETAILS = STRUCT('MIXERCONTROLDETAILS', {
 cbStruct: DWORD,
 dwControlID: DWORD,
 cChannels: DWORD,
 cbDetails: DWORD,
 paDetails: LPVOID
});

var MIXERCONTROLDETAILS_LISTTEXT = STRUCT('MIXERCONTROLDETAILS_LISTTEXT', {
 dwParam1: DWORD,
 dwParam2: DWORD,
 szName: pointer
});

var MIXERCONTROLDETAILS_LISTTEXTW = STRUCT('MIXERCONTROLDETAILS_LISTTEXTW', {
 dwParam1: DWORD,
 dwParam2: DWORD,
 szName: pointer
});

var MIXERCONTROLDETAILS_BOOLEAN = STRUCT('MIXERCONTROLDETAILS_BOOLEAN', {
 fValue: LONG
});

var MIXERCONTROLDETAILS_SIGNED = STRUCT('MIXERCONTROLDETAILS_SIGNED', {
 lValue: LONG
});

var MIXERCONTROLDETAILS_UNSIGNED = STRUCT('MIXERCONTROLDETAILS_UNSIGNED', {
 dwValue: DWORD
});

var TIMECAPS = STRUCT('TIMECAPS', {
 wPeriodMin: UINT,
 wPeriodMax: UINT
});

var JOYCAPS = STRUCT('JOYCAPS', {
 wMid: WORD,
 wPid: WORD,
 szPname: pointer,
 wXmin: UINT,
 wXmax: UINT,
 wYmin: UINT,
 wYmax: UINT,
 wZmin: UINT,
 wZmax: UINT,
 wNumButtons: UINT,
 wPeriodMin: UINT,
 wPeriodMax: UINT,
 wRmin: UINT,
 wRmax: UINT,
 wUmin: UINT,
 wUmax: UINT,
 wVmin: UINT,
 wVmax: UINT,
 wCaps: UINT,
 wMaxAxes: UINT,
 wNumAxes: UINT,
 wMaxButtons: UINT,
 szRegKey: pointer,
 szOEMVxD: pointer
});

var JOYCAPSW = STRUCT('JOYCAPSW', {
 wMid: WORD,
 wPid: WORD,
 szPname: pointer,
 wXmin: UINT,
 wXmax: UINT,
 wYmin: UINT,
 wYmax: UINT,
 wZmin: UINT,
 wZmax: UINT,
 wNumButtons: UINT,
 wPeriodMin: UINT,
 wPeriodMax: UINT,
 wRmin: UINT,
 wRmax: UINT,
 wUmin: UINT,
 wUmax: UINT,
 wVmin: UINT,
 wVmax: UINT,
 wCaps: UINT,
 wMaxAxes: UINT,
 wNumAxes: UINT,
 wMaxButtons: UINT,
 szRegKey: pointer,
 szOEMVxD: pointer
});

var JOYCAPS2 = STRUCT('JOYCAPS2', {
 wMid: WORD,
 wPid: WORD,
 szPname: pointer,
 wXmin: UINT,
 wXmax: UINT,
 wYmin: UINT,
 wYmax: UINT,
 wZmin: UINT,
 wZmax: UINT,
 wNumButtons: UINT,
 wPeriodMin: UINT,
 wPeriodMax: UINT,
 wRmin: UINT,
 wRmax: UINT,
 wUmin: UINT,
 wUmax: UINT,
 wVmin: UINT,
 wVmax: UINT,
 wCaps: UINT,
 wMaxAxes: UINT,
 wNumAxes: UINT,
 wMaxButtons: UINT,
 szRegKey: pointer,
 szOEMVxD: pointer,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var JOYCAPS2W = STRUCT('JOYCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 szPname: pointer,
 wXmin: UINT,
 wXmax: UINT,
 wYmin: UINT,
 wYmax: UINT,
 wZmin: UINT,
 wZmax: UINT,
 wNumButtons: UINT,
 wPeriodMin: UINT,
 wPeriodMax: UINT,
 wRmin: UINT,
 wRmax: UINT,
 wUmin: UINT,
 wUmax: UINT,
 wVmin: UINT,
 wVmax: UINT,
 wCaps: UINT,
 wMaxAxes: UINT,
 wNumAxes: UINT,
 wMaxButtons: UINT,
 szRegKey: pointer,
 szOEMVxD: pointer,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var JOYINFO = STRUCT('JOYINFO', {
 wXpos: UINT,
 wYpos: UINT,
 wZpos: UINT,
 wButtons: UINT
});

var JOYINFOEX = STRUCT('JOYINFOEX', {
 dwSize: DWORD,
 dwFlags: DWORD,
 dwXpos: DWORD,
 dwYpos: DWORD,
 dwZpos: DWORD,
 dwRpos: DWORD,
 dwUpos: DWORD,
 dwVpos: DWORD,
 dwButtons: DWORD,
 dwButtonNumber: DWORD,
 dwPOV: DWORD,
 dwReserved1: DWORD,
 dwReserved2: DWORD
});

var HMMIO__ = STRUCT('HMMIO__', {
 unused: int
});

var MMIOINFO = STRUCT('MMIOINFO', {
 dwFlags: DWORD,
 fccIOProc: FOURCC,
 pIOProc: LPMMIOPROC,
 wErrorRet: UINT,
 htask: HTASK,
 cchBuffer: LONG,
 pchBuffer: HPSTR,
 pchNext: HPSTR,
 pchEndRead: HPSTR,
 pchEndWrite: HPSTR,
 lBufOffset: LONG,
 lDiskOffset: LONG,
 adwInfo: pointer,
 dwReserved1: DWORD,
 dwReserved2: DWORD,
 hmmio: HMMIO
});

var MMCKINFO = STRUCT('MMCKINFO', {
 ckid: FOURCC,
 cksize: DWORD,
 fccType: FOURCC,
 dwDataOffset: DWORD,
 dwFlags: DWORD
});

var MCI_GENERIC_PARMS = STRUCT('MCI_GENERIC_PARMS', {
 dwCallback: DWORD_PTR
});

var MCI_OPEN_PARMS = STRUCT('MCI_OPEN_PARMS', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCSTR,
 lpstrElementName: LPCSTR,
 lpstrAlias: LPCSTR
});

var MCI_OPEN_PARMSW = STRUCT('MCI_OPEN_PARMSW', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCWSTR,
 lpstrElementName: LPCWSTR,
 lpstrAlias: LPCWSTR
});

var MCI_PLAY_PARMS = STRUCT('MCI_PLAY_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrom: DWORD,
 dwTo: DWORD
});

var MCI_SEEK_PARMS = STRUCT('MCI_SEEK_PARMS', {
 dwCallback: DWORD_PTR,
 dwTo: DWORD
});

var MCI_STATUS_PARMS = STRUCT('MCI_STATUS_PARMS', {
 dwCallback: DWORD_PTR,
 dwReturn: DWORD_PTR,
 dwItem: DWORD,
 dwTrack: DWORD
});

var MCI_INFO_PARMS = STRUCT('MCI_INFO_PARMS', {
 dwCallback: DWORD_PTR,
 lpstrReturn: LPSTR,
 dwRetSize: DWORD
});

var MCI_INFO_PARMSW = STRUCT('MCI_INFO_PARMSW', {
 dwCallback: DWORD_PTR,
 lpstrReturn: LPWSTR,
 dwRetSize: DWORD
});

var MCI_GETDEVCAPS_PARMS = STRUCT('MCI_GETDEVCAPS_PARMS', {
 dwCallback: DWORD_PTR,
 dwReturn: DWORD,
 dwItem: DWORD
});

var MCI_SYSINFO_PARMS = STRUCT('MCI_SYSINFO_PARMS', {
 dwCallback: DWORD_PTR,
 lpstrReturn: LPSTR,
 dwRetSize: DWORD,
 dwNumber: DWORD,
 wDeviceType: UINT
});

var MCI_SYSINFO_PARMSW = STRUCT('MCI_SYSINFO_PARMSW', {
 dwCallback: DWORD_PTR,
 lpstrReturn: LPWSTR,
 dwRetSize: DWORD,
 dwNumber: DWORD,
 wDeviceType: UINT
});

var MCI_SET_PARMS = STRUCT('MCI_SET_PARMS', {
 dwCallback: DWORD_PTR,
 dwTimeFormat: DWORD,
 dwAudio: DWORD
});

var MCI_BREAK_PARMS = STRUCT('MCI_BREAK_PARMS', {
 dwCallback: DWORD_PTR,
 nVirtKey: int,
 hwndBreak: HWND
});

var MCI_SAVE_PARMS = STRUCT('MCI_SAVE_PARMS', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCSTR
});

var MCI_SAVE_PARMSW = STRUCT('MCI_SAVE_PARMSW', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCWSTR
});

var MCI_LOAD_PARMS = STRUCT('MCI_LOAD_PARMS', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCSTR
});

var MCI_LOAD_PARMSW = STRUCT('MCI_LOAD_PARMSW', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCWSTR
});

var MCI_RECORD_PARMS = STRUCT('MCI_RECORD_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrom: DWORD,
 dwTo: DWORD
});

var MCI_VD_PLAY_PARMS = STRUCT('MCI_VD_PLAY_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrom: DWORD,
 dwTo: DWORD,
 dwSpeed: DWORD
});

var MCI_VD_STEP_PARMS = STRUCT('MCI_VD_STEP_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrames: DWORD
});

var MCI_VD_ESCAPE_PARMS = STRUCT('MCI_VD_ESCAPE_PARMS', {
 dwCallback: DWORD_PTR,
 lpstrCommand: LPCSTR
});

var MCI_VD_ESCAPE_PARMSW = STRUCT('MCI_VD_ESCAPE_PARMSW', {
 dwCallback: DWORD_PTR,
 lpstrCommand: LPCWSTR
});

var MCI_WAVE_OPEN_PARMS = STRUCT('MCI_WAVE_OPEN_PARMS', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCSTR,
 lpstrElementName: LPCSTR,
 lpstrAlias: LPCSTR,
 dwBufferSeconds: DWORD
});

var MCI_WAVE_OPEN_PARMSW = STRUCT('MCI_WAVE_OPEN_PARMSW', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCWSTR,
 lpstrElementName: LPCWSTR,
 lpstrAlias: LPCWSTR,
 dwBufferSeconds: DWORD
});

var MCI_WAVE_DELETE_PARMS = STRUCT('MCI_WAVE_DELETE_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrom: DWORD,
 dwTo: DWORD
});

var MCI_WAVE_SET_PARMS = STRUCT('MCI_WAVE_SET_PARMS', {
 dwCallback: DWORD_PTR,
 dwTimeFormat: DWORD,
 dwAudio: DWORD,
 wInput: UINT,
 wOutput: UINT,
 wFormatTag: WORD,
 wReserved2: WORD,
 nChannels: WORD,
 wReserved3: WORD,
 nSamplesPerSec: DWORD,
 nAvgBytesPerSec: DWORD,
 nBlockAlign: WORD,
 wReserved4: WORD,
 wBitsPerSample: WORD,
 wReserved5: WORD
});

var MCI_SEQ_SET_PARMS = STRUCT('MCI_SEQ_SET_PARMS', {
 dwCallback: DWORD_PTR,
 dwTimeFormat: DWORD,
 dwAudio: DWORD,
 dwTempo: DWORD,
 dwPort: DWORD,
 dwSlave: DWORD,
 dwMaster: DWORD,
 dwOffset: DWORD
});

var MCI_ANIM_OPEN_PARMS = STRUCT('MCI_ANIM_OPEN_PARMS', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCSTR,
 lpstrElementName: LPCSTR,
 lpstrAlias: LPCSTR,
 dwStyle: DWORD,
 hWndParent: HWND
});

var MCI_ANIM_OPEN_PARMSW = STRUCT('MCI_ANIM_OPEN_PARMSW', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCWSTR,
 lpstrElementName: LPCWSTR,
 lpstrAlias: LPCWSTR,
 dwStyle: DWORD,
 hWndParent: HWND
});

var MCI_ANIM_PLAY_PARMS = STRUCT('MCI_ANIM_PLAY_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrom: DWORD,
 dwTo: DWORD,
 dwSpeed: DWORD
});

var MCI_ANIM_STEP_PARMS = STRUCT('MCI_ANIM_STEP_PARMS', {
 dwCallback: DWORD_PTR,
 dwFrames: DWORD
});

var MCI_ANIM_WINDOW_PARMS = STRUCT('MCI_ANIM_WINDOW_PARMS', {
 dwCallback: DWORD_PTR,
 hWnd: HWND,
 nCmdShow: UINT,
 lpstrText: LPCSTR
});

var MCI_ANIM_WINDOW_PARMSW = STRUCT('MCI_ANIM_WINDOW_PARMSW', {
 dwCallback: DWORD_PTR,
 hWnd: HWND,
 nCmdShow: UINT,
 lpstrText: LPCWSTR
});

var MCI_ANIM_RECT_PARMS = STRUCT('MCI_ANIM_RECT_PARMS', {
 dwCallback: DWORD_PTR,
 rc: RECT
});

var MCI_ANIM_UPDATE_PARMS = STRUCT('MCI_ANIM_UPDATE_PARMS', {
 dwCallback: DWORD_PTR,
 rc: RECT,
 hDC: HDC
});

var MCI_OVLY_OPEN_PARMS = STRUCT('MCI_OVLY_OPEN_PARMS', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCSTR,
 lpstrElementName: LPCSTR,
 lpstrAlias: LPCSTR,
 dwStyle: DWORD,
 hWndParent: HWND
});

var MCI_OVLY_OPEN_PARMSW = STRUCT('MCI_OVLY_OPEN_PARMSW', {
 dwCallback: DWORD_PTR,
 wDeviceID: MCIDEVICEID,
 lpstrDeviceType: LPCWSTR,
 lpstrElementName: LPCWSTR,
 lpstrAlias: LPCWSTR,
 dwStyle: DWORD,
 hWndParent: HWND
});

var MCI_OVLY_WINDOW_PARMS = STRUCT('MCI_OVLY_WINDOW_PARMS', {
 dwCallback: DWORD_PTR,
 hWnd: HWND,
 nCmdShow: UINT,
 lpstrText: LPCSTR
});

var MCI_OVLY_WINDOW_PARMSW = STRUCT('MCI_OVLY_WINDOW_PARMSW', {
 dwCallback: DWORD_PTR,
 hWnd: HWND,
 nCmdShow: UINT,
 lpstrText: LPCWSTR
});

var MCI_OVLY_RECT_PARMS = STRUCT('MCI_OVLY_RECT_PARMS', {
 dwCallback: DWORD_PTR,
 rc: RECT
});

var MCI_OVLY_SAVE_PARMS = STRUCT('MCI_OVLY_SAVE_PARMS', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCSTR,
 rc: RECT
});

var MCI_OVLY_SAVE_PARMSW = STRUCT('MCI_OVLY_SAVE_PARMSW', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCWSTR,
 rc: RECT
});

var MCI_OVLY_LOAD_PARMS = STRUCT('MCI_OVLY_LOAD_PARMS', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCSTR,
 rc: RECT
});

var MCI_OVLY_LOAD_PARMSW = STRUCT('MCI_OVLY_LOAD_PARMSW', {
 dwCallback: DWORD_PTR,
 lpfilename: LPCWSTR,
 rc: RECT
});

var NCB = STRUCT('NCB', {
 ncb_command: UCHAR,
 ncb_retcode: UCHAR,
 ncb_lsn: UCHAR,
 ncb_num: UCHAR,
 ncb_buffer: PUCHAR,
 ncb_length: WORD,
 ncb_callname: pointer,
 ncb_name: pointer,
 ncb_rto: UCHAR,
 ncb_sto: UCHAR,
 ncb_post: PTR(pointer),
 ncb_lana_num: UCHAR,
 ncb_cmd_cplt: UCHAR,
 ncb_reserve: pointer,
 ncb_event: HANDLE
});

var ADAPTER_STATUS = STRUCT('ADAPTER_STATUS', {
 adapter_address: pointer,
 rev_major: UCHAR,
 reserved0: UCHAR,
 adapter_type: UCHAR,
 rev_minor: UCHAR,
 duration: WORD,
 frmr_recv: WORD,
 frmr_xmit: WORD,
 iframe_recv_err: WORD,
 xmit_aborts: WORD,
 xmit_success: DWORD,
 recv_success: DWORD,
 iframe_xmit_err: WORD,
 recv_buff_unavail: WORD,
 t1_timeouts: WORD,
 ti_timeouts: WORD,
 reserved1: DWORD,
 free_ncbs: WORD,
 max_cfg_ncbs: WORD,
 max_ncbs: WORD,
 xmit_buf_unavail: WORD,
 max_dgram_size: WORD,
 pending_sess: WORD,
 max_cfg_sess: WORD,
 max_sess: WORD,
 max_sess_pkt_size: WORD,
 name_count: WORD
});

var NAME_BUFFER = STRUCT('NAME_BUFFER', {
 name: pointer,
 name_num: UCHAR,
 name_flags: UCHAR
});

var SESSION_HEADER = STRUCT('SESSION_HEADER', {
 sess_name: UCHAR,
 num_sess: UCHAR,
 rcv_dg_outstanding: UCHAR,
 rcv_any_outstanding: UCHAR
});

var SESSION_BUFFER = STRUCT('SESSION_BUFFER', {
 lsn: UCHAR,
 state: UCHAR,
 local_name: pointer,
 remote_name: pointer,
 rcvs_outstanding: UCHAR,
 sends_outstanding: UCHAR
});

var LANA_ENUM = STRUCT('LANA_ENUM', {
 length: UCHAR,
 lana: pointer
});

var FIND_NAME_HEADER = STRUCT('FIND_NAME_HEADER', {
 node_count: WORD,
 reserved: UCHAR,
 unique_group: UCHAR
});

var FIND_NAME_BUFFER = STRUCT('FIND_NAME_BUFFER', {
 length: UCHAR,
 access_control: UCHAR,
 frame_control: UCHAR,
 destination_addr: pointer,
 source_addr: pointer,
 routing_info: pointer
});

var ACTION_HEADER = STRUCT('ACTION_HEADER', {
 transport_id: ULONG,
 action_code: USHORT,
 reserved: USHORT
});

var RPC_BINDING_VECTOR = STRUCT('RPC_BINDING_VECTOR', {
 Count: ulong,
 BindingH: pointer
});

var UUID_VECTOR = STRUCT('UUID_VECTOR', {
 Count: ulong,
 Uuid: pointer
});

var RPC_IF_ID = STRUCT('RPC_IF_ID', {
 Uuid: UUID,
 VersMajor: ushort,
 VersMinor: ushort
});

var RPC_PROTSEQ_VECTORA = STRUCT('RPC_PROTSEQ_VECTORA', {
 Count: uint,
 Protseq: pointer
});

var RPC_PROTSEQ_VECTORW = STRUCT('RPC_PROTSEQ_VECTORW', {
 Count: uint,
 Protseq: pointer
});

var RPC_POLICY = STRUCT('RPC_POLICY', {
 Length: uint,
 EndpointFlags: ulong,
 NICFlags: ulong
});

var RPC_STATS_VECTOR = STRUCT('RPC_STATS_VECTOR', {
 Count: uint,
 Stats: pointer
});

var RPC_IF_ID_VECTOR = STRUCT('RPC_IF_ID_VECTOR', {
 Count: ulong,
 IfId: pointer
});

var RPC_SECURITY_QOS = STRUCT('RPC_SECURITY_QOS', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong
});

var SEC_WINNT_AUTH_IDENTITY_W = STRUCT('SEC_WINNT_AUTH_IDENTITY_W', {
 User: PTR(ushort),
 UserLength: ulong,
 Domain: PTR(ushort),
 DomainLength: ulong,
 Password: PTR(ushort),
 PasswordLength: ulong,
 Flags: ulong
});

var SEC_WINNT_AUTH_IDENTITY_A = STRUCT('SEC_WINNT_AUTH_IDENTITY_A', {
 User: PTR(uchar),
 UserLength: ulong,
 Domain: PTR(uchar),
 DomainLength: ulong,
 Password: PTR(uchar),
 PasswordLength: ulong,
 Flags: ulong
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_W = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_W', {
 TransportCredentials: PTR(uint),
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(ushort)
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_A = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_A', {
 TransportCredentials: PTR(uint),
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(uchar)
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W', {
 TransportCredentials: PTR(uint),
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(ushort),
 ProxyCredentials: PTR(uint),
 NumberOfProxyAuthnSchemes: ulong,
 ProxyAuthnSchemes: PTR(ulong)
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A', {
 TransportCredentials: PTR(uint),
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(uchar),
 ProxyCredentials: PTR(uint),
 NumberOfProxyAuthnSchemes: ulong,
 ProxyAuthnSchemes: PTR(ulong)
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W', {
 TransportCredentials: RPC_AUTH_IDENTITY_HANDLE,
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(ushort),
 ProxyCredentials: RPC_AUTH_IDENTITY_HANDLE,
 NumberOfProxyAuthnSchemes: ulong,
 ProxyAuthnSchemes: PTR(ulong)
});

var RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A = STRUCT('RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A', {
 TransportCredentials: RPC_AUTH_IDENTITY_HANDLE,
 Flags: ulong,
 AuthenticationTarget: ulong,
 NumberOfAuthnSchemes: ulong,
 AuthnSchemes: PTR(ulong),
 ServerCertificateSubject: PTR(uchar),
 ProxyCredentials: RPC_AUTH_IDENTITY_HANDLE,
 NumberOfProxyAuthnSchemes: ulong,
 ProxyAuthnSchemes: PTR(ulong)
});

var RPC_SECURITY_QOS_V2_W = STRUCT('RPC_SECURITY_QOS_V2_W', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: 
});

var RPC_SECURITY_QOS_V2_A = STRUCT('RPC_SECURITY_QOS_V2_A', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: 
});

var RPC_SECURITY_QOS_V3_W = STRUCT('RPC_SECURITY_QOS_V3_W', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: ,
 Sid: PTR('void')
});

var RPC_SECURITY_QOS_V3_A = STRUCT('RPC_SECURITY_QOS_V3_A', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: ,
 Sid: PTR('void')
});

var RPC_SECURITY_QOS_V4_W = STRUCT('RPC_SECURITY_QOS_V4_W', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: ,
 Sid: PTR('void'),
 EffectiveOnly: uint
});

var RPC_SECURITY_QOS_V4_A = STRUCT('RPC_SECURITY_QOS_V4_A', {
 Version: ulong,
 Capabilities: ulong,
 IdentityTracking: ulong,
 ImpersonationType: ulong,
 AdditionalSecurityInfoType: ulong,
 u: ,
 Sid: PTR('void'),
 EffectiveOnly: uint
});

var RPC_BINDING_HANDLE_TEMPLATE_V1_W = STRUCT('RPC_BINDING_HANDLE_TEMPLATE_V1_W', {
 Version: ulong,
 Flags: ulong,
 ProtocolSequence: ulong,
 NetworkAddress: PTR(ushort),
 StringEndpoint: PTR(ushort),
 u1: ,
 ObjectUuid: UUID
});

var RPC_BINDING_HANDLE_TEMPLATE_V1_A = STRUCT('RPC_BINDING_HANDLE_TEMPLATE_V1_A', {
 Version: ulong,
 Flags: ulong,
 ProtocolSequence: ulong,
 NetworkAddress: PTR(uchar),
 StringEndpoint: PTR(uchar),
 u1: ,
 ObjectUuid: UUID
});

var RPC_BINDING_HANDLE_SECURITY_V1_W = STRUCT('RPC_BINDING_HANDLE_SECURITY_V1_W', {
 Version: ulong,
 ServerPrincName: PTR(ushort),
 AuthnLevel: ulong,
 AuthnSvc: ulong,
 AuthIdentity: PTR(uint),
 SecurityQos: PTR(uint)
});

var RPC_BINDING_HANDLE_SECURITY_V1_A = STRUCT('RPC_BINDING_HANDLE_SECURITY_V1_A', {
 Version: ulong,
 ServerPrincName: PTR(uchar),
 AuthnLevel: ulong,
 AuthnSvc: ulong,
 AuthIdentity: PTR(uint),
 SecurityQos: PTR(uint)
});

var RPC_BINDING_HANDLE_OPTIONS_V1 = STRUCT('RPC_BINDING_HANDLE_OPTIONS_V1', {
 Version: ulong,
 Flags: ulong,
 ComTimeout: ulong,
 CallTimeout: ulong
});

var RPC_CLIENT_INFORMATION1 = STRUCT('RPC_CLIENT_INFORMATION1', {
 UserName: PTR(uchar),
 ComputerName: PTR(uchar),
 Privilege: ushort,
 AuthFlags: ulong
});

var RPC_VERSION = STRUCT('RPC_VERSION', {
 MajorVersion: ushort,
 MinorVersion: ushort
});

var RPC_SYNTAX_IDENTIFIER = STRUCT('RPC_SYNTAX_IDENTIFIER', {
 SyntaxGUID: GUID,
 SyntaxVersion: RPC_VERSION
});

var RPC_MESSAGE = STRUCT('RPC_MESSAGE', {
 Handle: RPC_BINDING_HANDLE,
 DataRepresentation: ulong,
 Buffer: PTR('void'),
 BufferLength: uint,
 ProcNum: uint,
 TransferSyntax: PRPC_SYNTAX_IDENTIFIER,
 RpcInterfaceInformation: PTR('void'),
 ReservedForRuntime: PTR('void'),
 ManagerEpv: PTR('void'),
 ImportContext: PTR('void'),
 RpcFlags: ulong
});

var RPC_DISPATCH_TABLE = STRUCT('RPC_DISPATCH_TABLE', {
 DispatchTableCount: uint,
 DispatchTable: PTR(RPC_DISPATCH_FUNCTION),
 Reserved: LONG_PTR
});

var RPC_PROTSEQ_ENDPOINT = STRUCT('RPC_PROTSEQ_ENDPOINT', {
 RpcProtocolSequence: PTR(uchar),
 Endpoint: PTR(uchar)
});

var RPC_SERVER_INTERFACE = STRUCT('RPC_SERVER_INTERFACE', {
 Length: uint,
 InterfaceId: RPC_SYNTAX_IDENTIFIER,
 TransferSyntax: RPC_SYNTAX_IDENTIFIER,
 DispatchTable: PRPC_DISPATCH_TABLE,
 RpcProtseqEndpointCount: uint,
 RpcProtseqEndpoint: PRPC_PROTSEQ_ENDPOINT,
 DefaultManagerEpv: PTR('void'),
 InterpreterInfo: PTR('void'),
 Flags: uint
});

var RPC_CLIENT_INTERFACE = STRUCT('RPC_CLIENT_INTERFACE', {
 Length: uint,
 InterfaceId: RPC_SYNTAX_IDENTIFIER,
 TransferSyntax: RPC_SYNTAX_IDENTIFIER,
 DispatchTable: PRPC_DISPATCH_TABLE,
 RpcProtseqEndpointCount: uint,
 RpcProtseqEndpoint: PRPC_PROTSEQ_ENDPOINT,
 Reserved: ULONG_PTR,
 InterpreterInfo: PTR('void'),
 Flags: uint
});

var RPC_TRANSFER_SYNTAX = STRUCT('RPC_TRANSFER_SYNTAX', {
 Uuid: UUID,
 VersMajor: ushort,
 VersMinor: ushort
});

var RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR = STRUCT('RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR', {
 BufferSize: ulong,
 Buffer: PTR(int8)
});

var RDR_CALLOUT_STATE = STRUCT('RDR_CALLOUT_STATE', {
 LastError: RPC_STATUS,
 LastEEInfo: PTR('void'),
 LastCalledStage: RPC_HTTP_REDIRECTOR_STAGE,
 ServerName: PTR(ushort),
 ServerPort: PTR(ushort),
 RemoteUser: PTR(ushort),
 AuthType: PTR(ushort),
 ResourceTypePresent: uchar,
 SessionIdPresent: uchar,
 InterfacePresent: uchar,
 ResourceType: UUID,
 SessionId: UUID,
 Interface: RPC_SYNTAX_IDENTIFIER,
 CertContext: PTR('void')
});

var I_RpcProxyCallbackInterface = STRUCT('I_RpcProxyCallbackInterface', {
 IsValidMachineFn: I_RpcProxyIsValidMachineFn,
 GetClientAddressFn: I_RpcProxyGetClientAddressFn,
 GetConnectionTimeoutFn: I_RpcProxyGetConnectionTimeoutFn,
 PerformCalloutFn: I_RpcPerformCalloutFn,
 FreeCalloutStateFn: I_RpcFreeCalloutStateFn,
 GetClientSessionAndResourceUUIDFn: I_RpcProxyGetClientSessionAndResourceUUID,
 ProxyFilterIfFn: I_RpcProxyFilterIfFn,
 RpcProxyUpdatePerfCounterFn: I_RpcProxyUpdatePerfCounterFn,
 RpcProxyUpdatePerfCounterBackendServerFn: I_RpcProxyUpdatePerfCounterBackendServerFn
});

var RPC_ASYNC_STATE = STRUCT('RPC_ASYNC_STATE', {
 Size: uint,
 Signature: ulong,
 Lock: long,
 Flags: ulong,
 StubInfo: PTR('void'),
 UserInfo: PTR('void'),
 RuntimeInfo: PTR('void'),
 Event: RPC_ASYNC_EVENT,
 NotificationType: RPC_NOTIFICATION_TYPES,
 u: RPC_ASYNC_NOTIFICATION_INFO,
 Reserved: pointer
});

var undefined = STRUCT('undefined', {
 NotificationRoutine: PFN_RPCNOTIFICATION_ROUTINE,
 hThread: HANDLE
});

var undefined = STRUCT('undefined', {
 hIOPort: HANDLE,
 dwNumberOfBytesTransferred: DWORD,
 dwCompletionKey: DWORD_PTR,
 lpOverlapped: LPOVERLAPPED
});

var undefined = STRUCT('undefined', {
 hWnd: HWND,
 Msg: UINT
});

var BinaryParam = STRUCT('BinaryParam', {
 Buffer: PTR('void'),
 Size: short
});

var RPC_EE_INFO_PARAM = STRUCT('RPC_EE_INFO_PARAM', {
 ParameterType: ExtendedErrorParamTypes,
 u: 
});

var RPC_EXTENDED_ERROR_INFO = STRUCT('RPC_EXTENDED_ERROR_INFO', {
 Version: ULONG,
 ComputerName: LPWSTR,
 ProcessID: ULONG,
 u: ,
 GeneratingComponent: ULONG,
 Status: ULONG,
 DetectionLocation: USHORT,
 Flags: USHORT,
 NumberOfParameters: int,
 Parameters: pointer
});

var RPC_ERROR_ENUM_HANDLE = STRUCT('RPC_ERROR_ENUM_HANDLE', {
 Signature: ULONG,
 CurrentPos: PTR('void'),
 Head: PTR('void')
});

var RPC_CALL_LOCAL_ADDRESS_V1 = STRUCT('RPC_CALL_LOCAL_ADDRESS_V1', {
 Version: uint,
 Buffer: PTR('void'),
 BufferSize: ulong,
 AddressFormat: RpcLocalAddressFormat
});

var RPC_CALL_ATTRIBUTES_V1_W = STRUCT('RPC_CALL_ATTRIBUTES_V1_W', {
 Version: uint,
 Flags: ulong,
 ServerPrincipalNameBufferLength: ulong,
 ServerPrincipalName: PTR(ushort),
 ClientPrincipalNameBufferLength: ulong,
 ClientPrincipalName: PTR(ushort),
 AuthenticationLevel: ulong,
 AuthenticationService: ulong,
 NullSession: BOOL
});

var RPC_CALL_ATTRIBUTES_V1_A = STRUCT('RPC_CALL_ATTRIBUTES_V1_A', {
 Version: uint,
 Flags: ulong,
 ServerPrincipalNameBufferLength: ulong,
 ServerPrincipalName: PTR(uchar),
 ClientPrincipalNameBufferLength: ulong,
 ClientPrincipalName: PTR(uchar),
 AuthenticationLevel: ulong,
 AuthenticationService: ulong,
 NullSession: BOOL
});

var RPC_CALL_ATTRIBUTES_V2_W = STRUCT('RPC_CALL_ATTRIBUTES_V2_W', {
 Version: uint,
 Flags: ulong,
 ServerPrincipalNameBufferLength: ulong,
 ServerPrincipalName: PTR(ushort),
 ClientPrincipalNameBufferLength: ulong,
 ClientPrincipalName: PTR(ushort),
 AuthenticationLevel: ulong,
 AuthenticationService: ulong,
 NullSession: BOOL,
 KernelModeCaller: BOOL,
 ProtocolSequence: ulong,
 IsClientLocal: RpcCallClientLocality,
 ClientPID: HANDLE,
 CallStatus: ulong,
 CallType: RpcCallType,
 CallLocalAddress: PTR(uint),
 OpNum: ushort,
 InterfaceUuid: UUID
});

var RPC_CALL_ATTRIBUTES = STRUCT('RPC_CALL_ATTRIBUTES', {
 Version: uint,
 Flags: ulong,
 ServerPrincipalNameBufferLength: ulong,
 ServerPrincipalName: PTR(uchar),
 ClientPrincipalNameBufferLength: ulong,
 ClientPrincipalName: PTR(uchar),
 AuthenticationLevel: ulong,
 AuthenticationService: ulong,
 NullSession: BOOL,
 KernelModeCaller: BOOL,
 ProtocolSequence: ulong,
 IsClientLocal: ulong,
 ClientPID: HANDLE,
 CallStatus: ulong,
 CallType: RpcCallType,
 CallLocalAddress: PTR(uint),
 OpNum: ushort,
 InterfaceUuid: UUID
});

var HDROP__ = STRUCT('HDROP__', {
 unused: int
});

var DRAGINFO = STRUCT('DRAGINFO', {
 uSize: UINT,
 pt: POINT,
 fNC: BOOL,
 lpFileList: LPSTR,
 grfKeyState: DWORD
});

var DRAGINFOW = STRUCT('DRAGINFOW', {
 uSize: UINT,
 pt: POINT,
 fNC: BOOL,
 lpFileList: LPWSTR,
 grfKeyState: DWORD
});

var APPBARDATA = STRUCT('APPBARDATA', {
 cbSize: DWORD,
 hWnd: HWND,
 uCallbackMessage: UINT,
 uEdge: UINT,
 rc: RECT,
 lParam: LPARAM
});

var SHFILEOPSTRUCT = STRUCT('SHFILEOPSTRUCT', {
 hwnd: HWND,
 wFunc: UINT,
 pFrom: LPCSTR,
 pTo: LPCSTR,
 fFlags: FILEOP_FLAGS,
 fAnyOperationsAborted: BOOL,
 hNameMappings: LPVOID,
 lpszProgressTitle: LPCSTR
});

var SHFILEOPSTRUCTW = STRUCT('SHFILEOPSTRUCTW', {
 hwnd: HWND,
 wFunc: UINT,
 pFrom: LPCWSTR,
 pTo: LPCWSTR,
 fFlags: FILEOP_FLAGS,
 fAnyOperationsAborted: BOOL,
 hNameMappings: LPVOID,
 lpszProgressTitle: LPCWSTR
});

var SHNAMEMAPPING = STRUCT('SHNAMEMAPPING', {
 pszOldPath: LPSTR,
 pszNewPath: LPSTR,
 cchOldPath: int,
 cchNewPath: int
});

var SHNAMEMAPPINGW = STRUCT('SHNAMEMAPPINGW', {
 pszOldPath: LPWSTR,
 pszNewPath: LPWSTR,
 cchOldPath: int,
 cchNewPath: int
});

var SHELLEXECUTEINFO = STRUCT('SHELLEXECUTEINFO', {
 cbSize: DWORD,
 fMask: ULONG,
 hwnd: HWND,
 lpVerb: LPCSTR,
 lpFile: LPCSTR,
 lpParameters: LPCSTR,
 lpDirectory: LPCSTR,
 nShow: int,
 hInstApp: HINSTANCE,
 lpIDList: PTR('void'),
 lpClass: LPCSTR,
 hkeyClass: HKEY,
 dwHotKey: DWORD,
 hProcess: HANDLE
});

var SHELLEXECUTEINFOW = STRUCT('SHELLEXECUTEINFOW', {
 cbSize: DWORD,
 fMask: ULONG,
 hwnd: HWND,
 lpVerb: LPCWSTR,
 lpFile: LPCWSTR,
 lpParameters: LPCWSTR,
 lpDirectory: LPCWSTR,
 nShow: int,
 hInstApp: HINSTANCE,
 lpIDList: PTR('void'),
 lpClass: LPCWSTR,
 hkeyClass: HKEY,
 dwHotKey: DWORD,
 hProcess: HANDLE
});

var SHCREATEPROCESSINFOW = STRUCT('SHCREATEPROCESSINFOW', {
 cbSize: DWORD,
 fMask: ULONG,
 hwnd: HWND,
 pszFile: LPCWSTR,
 pszParameters: LPCWSTR,
 pszCurrentDirectory: LPCWSTR,
 hUserToken: HANDLE,
 lpProcessAttributes: LPSECURITY_ATTRIBUTES,
 lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 bInheritHandles: BOOL,
 dwCreationFlags: DWORD,
 lpStartupInfo: LPSTARTUPINFOW,
 lpProcessInformation: LPPROCESS_INFORMATION
});

var ASSOCIATIONELEMENT = STRUCT('ASSOCIATIONELEMENT', {
 ac: ASSOCCLASS,
 hkClass: HKEY,
 pszClass: PCWSTR
});

var SHQUERYRBINFO = STRUCT('SHQUERYRBINFO', {
 cbSize: DWORD,
 i64Size: longlong,
 i64NumItems: longlong
});

var NOTIFYICONDATA = STRUCT('NOTIFYICONDATA', {
 cbSize: DWORD,
 hWnd: HWND,
 uID: UINT,
 uFlags: UINT,
 uCallbackMessage: UINT,
 hIcon: HICON,
 szTip: pointer,
 dwState: DWORD,
 dwStateMask: DWORD,
 szInfo: pointer,
 szInfoTitle: pointer,
 dwInfoFlags: DWORD,
 guidItem: GUID,
 hBalloonIcon: HICON
});

var NOTIFYICONDATAW = STRUCT('NOTIFYICONDATAW', {
 cbSize: DWORD,
 hWnd: HWND,
 uID: UINT,
 uFlags: UINT,
 uCallbackMessage: UINT,
 hIcon: HICON,
 szTip: pointer,
 dwState: DWORD,
 dwStateMask: DWORD,
 szInfo: pointer,
 szInfoTitle: pointer,
 dwInfoFlags: DWORD,
 guidItem: GUID,
 hBalloonIcon: HICON
});

var NOTIFYICONIDENTIFIER = STRUCT('NOTIFYICONIDENTIFIER', {
 cbSize: DWORD,
 hWnd: HWND,
 uID: UINT,
 guidItem: GUID
});

var SHFILEINFO = STRUCT('SHFILEINFO', {
 hIcon: HICON,
 iIcon: int,
 dwAttributes: DWORD,
 szDisplayName: pointer,
 szTypeName: pointer
});

var SHFILEINFOW = STRUCT('SHFILEINFOW', {
 hIcon: HICON,
 iIcon: int,
 dwAttributes: DWORD,
 szDisplayName: pointer,
 szTypeName: pointer
});

var SHSTOCKICONINFO = STRUCT('SHSTOCKICONINFO', {
 cbSize: DWORD,
 hIcon: HICON,
 iSysImageIndex: int,
 iIcon: int,
 szPath: pointer
});

var OPEN_PRINTER_PROPS_INFO = STRUCT('OPEN_PRINTER_PROPS_INFO', {
 dwSize: DWORD,
 pszSheetName: LPSTR,
 uSheetIndex: UINT,
 dwFlags: DWORD,
 bModal: BOOL
});

var OPEN_PRINTER_PROPS_INFOW = STRUCT('OPEN_PRINTER_PROPS_INFOW', {
 dwSize: DWORD,
 pszSheetName: LPWSTR,
 uSheetIndex: UINT,
 dwFlags: DWORD,
 bModal: BOOL
});

var NC_ADDRESS = STRUCT('NC_ADDRESS', {
 pAddrInfo: PTR(NET_ADDRESS_INFO_),
 PortNumber: USHORT,
 PrefixLength: BYTE
});


var PERF_DATA_BLOCK = STRUCT('PERF_DATA_BLOCK', {
 Signature: pointer,
 LittleEndian: DWORD,
 Version: DWORD,
 Revision: DWORD,
 TotalByteLength: DWORD,
 HeaderLength: DWORD,
 NumObjectTypes: DWORD,
 DefaultObject: LONG,
 SystemTime: SYSTEMTIME,
 PerfTime: LARGE_INTEGER,
 PerfFreq: LARGE_INTEGER,
 PerfTime100nSec: LARGE_INTEGER,
 SystemNameLength: DWORD,
 SystemNameOffset: DWORD
});

var PERF_OBJECT_TYPE = STRUCT('PERF_OBJECT_TYPE', {
 TotalByteLength: DWORD,
 DefinitionLength: DWORD,
 HeaderLength: DWORD,
 ObjectNameTitleIndex: DWORD,
 ObjectNameTitle: LPWSTR,
 ObjectHelpTitleIndex: DWORD,
 ObjectHelpTitle: LPWSTR,
 DetailLevel: DWORD,
 NumCounters: DWORD,
 DefaultCounter: LONG,
 NumInstances: LONG,
 CodePage: DWORD,
 PerfTime: LARGE_INTEGER,
 PerfFreq: LARGE_INTEGER
});

var PERF_COUNTER_DEFINITION = STRUCT('PERF_COUNTER_DEFINITION', {
 ByteLength: DWORD,
 CounterNameTitleIndex: DWORD,
 CounterNameTitle: LPWSTR,
 CounterHelpTitleIndex: DWORD,
 CounterHelpTitle: LPWSTR,
 DefaultScale: LONG,
 DetailLevel: DWORD,
 CounterType: DWORD,
 CounterSize: DWORD,
 CounterOffset: DWORD
});

var PERF_INSTANCE_DEFINITION = STRUCT('PERF_INSTANCE_DEFINITION', {
 ByteLength: DWORD,
 ParentObjectTitleIndex: DWORD,
 ParentObjectInstance: DWORD,
 UniqueID: LONG,
 NameOffset: DWORD,
 NameLength: DWORD
});

var PERF_COUNTER_BLOCK = STRUCT('PERF_COUNTER_BLOCK', {
 ByteLength: DWORD
});

var FD_SET = STRUCT('FD_SET', {
 fd_count: u_int,
 fd_array: pointer
});

var TIMEVAL = STRUCT('TIMEVAL', {
 tv_sec: long,
 tv_usec: long
});

var HOSTENT = STRUCT('HOSTENT', {
 h_name: PTR(int8),
 h_aliases: PTR(PTR(int8)),
 h_addrtype: short,
 h_length: short,
 h_addr_list: PTR(PTR(int8))
});

var netent = STRUCT('netent', {
 n_name: PTR(int8),
 n_aliases: PTR(PTR(int8)),
 n_addrtype: short,
 n_net: u_long
});

var SERVENT = STRUCT('SERVENT', {
 s_name: PTR(int8),
 s_aliases: PTR(PTR(int8)),
 s_port: short,
 s_proto: PTR(int8)
});

var PROTOENT = STRUCT('PROTOENT', {
 p_name: PTR(int8),
 p_aliases: PTR(PTR(int8)),
 p_proto: short
});

var IN_ADDR = STRUCT('IN_ADDR', {
 S_un: 
});

var undefined = STRUCT('undefined', {
 s_b1: UCHAR,
 s_b2: UCHAR,
 s_b3: UCHAR,
 s_b4: UCHAR
});

var undefined = STRUCT('undefined', {
 s_w1: USHORT,
 s_w2: USHORT
});

var SOCKADDR_IN = STRUCT('SOCKADDR_IN', {
 sin_family: short,
 sin_port: u_short,
 sin_addr: IN_ADDR,
 sin_zero: pointer
});

var WSADATA = STRUCT('WSADATA', {
 wVersion: WORD,
 wHighVersion: WORD,
 szDescription: pointer,
 szSystemStatus: pointer,
 iMaxSockets: ushort,
 iMaxUdpDg: ushort,
 lpVendorInfo: PTR(int8)
});

var ip_mreq = STRUCT('ip_mreq', {
 imr_multiaddr: IN_ADDR,
 imr_interface: IN_ADDR
});

var SOCKADDR = STRUCT('SOCKADDR', {
 sa_family: u_short,
 sa_data: pointer
});

var sockproto = STRUCT('sockproto', {
 sp_family: u_short,
 sp_protocol: u_short
});

var LINGER = STRUCT('LINGER', {
 l_onoff: u_short,
 l_linger: u_short
});

var TRANSMIT_FILE_BUFFERS = STRUCT('TRANSMIT_FILE_BUFFERS', {
 Head: PVOID,
 HeadLength: DWORD,
 Tail: PVOID,
 TailLength: DWORD
});

var CMS_KEY_INFO = STRUCT('CMS_KEY_INFO', {
 dwVersion: DWORD,
 Algid: ALG_ID,
 pbOID: PTR(uchar),
 cbOID: DWORD
});

var HMAC_INFO = STRUCT('HMAC_INFO', {
 HashAlgid: ALG_ID,
 pbInnerString: PTR(uchar),
 cbInnerString: DWORD,
 pbOuterString: PTR(uchar),
 cbOuterString: DWORD
});

var SCHANNEL_ALG = STRUCT('SCHANNEL_ALG', {
 dwUse: DWORD,
 Algid: ALG_ID,
 cBits: DWORD,
 dwFlags: DWORD,
 dwReserved: DWORD
});

var PROV_ENUMALGS = STRUCT('PROV_ENUMALGS', {
 aiAlgid: ALG_ID,
 dwBitLen: DWORD,
 dwNameLen: DWORD,
 szName: pointer
});

var PROV_ENUMALGS_EX = STRUCT('PROV_ENUMALGS_EX', {
 aiAlgid: ALG_ID,
 dwDefaultLen: DWORD,
 dwMinLen: DWORD,
 dwMaxLen: DWORD,
 dwProtocols: DWORD,
 dwNameLen: DWORD,
 szName: pointer,
 dwLongNameLen: DWORD,
 szLongName: pointer
});

var PUBLICKEYSTRUC = STRUCT('PUBLICKEYSTRUC', {
 bType: BYTE,
 bVersion: BYTE,
 reserved: WORD,
 aiKeyAlg: ALG_ID
});

var RSAPUBKEY = STRUCT('RSAPUBKEY', {
 magic: DWORD,
 bitlen: DWORD,
 pubexp: DWORD
});

var TEKPUBKEY = STRUCT('TEKPUBKEY', {
 magic: DWORD,
 bitlen: DWORD
});

var DSSSEED = STRUCT('DSSSEED', {
 counter: DWORD,
 seed: pointer
});

var DSSPUBKEY_VER3 = STRUCT('DSSPUBKEY_VER3', {
 magic: DWORD,
 bitlenP: DWORD,
 bitlenQ: DWORD,
 bitlenJ: DWORD,
 DSSSeed: DSSSEED
});

var DSSPRIVKEY_VER3 = STRUCT('DSSPRIVKEY_VER3', {
 magic: DWORD,
 bitlenP: DWORD,
 bitlenQ: DWORD,
 bitlenJ: DWORD,
 bitlenX: DWORD,
 DSSSeed: DSSSEED
});

var KEY_TYPE_SUBTYPE = STRUCT('KEY_TYPE_SUBTYPE', {
 dwKeySpec: DWORD,
 Type: GUID,
 Subtype: GUID
});

var CERT_FORTEZZA_DATA_PROP = STRUCT('CERT_FORTEZZA_DATA_PROP', {
 SerialNumber: pointer,
 CertIndex: int,
 CertLabel: pointer
});

var CRYPT_RC4_KEY_STATE = STRUCT('CRYPT_RC4_KEY_STATE', {
 Key: pointer,
 SBox: pointer,
 i: uchar,
 j: uchar
});

var CRYPT_DES_KEY_STATE = STRUCT('CRYPT_DES_KEY_STATE', {
 Key: pointer,
 IV: pointer,
 Feedback: pointer
});

var CRYPT_3DES_KEY_STATE = STRUCT('CRYPT_3DES_KEY_STATE', {
 Key: pointer,
 IV: pointer,
 Feedback: pointer
});

var CRYPT_AES_128_KEY_STATE = STRUCT('CRYPT_AES_128_KEY_STATE', {
 Key: pointer,
 IV: pointer,
 EncryptionState: pointer,
 DecryptionState: pointer,
 Feedback: pointer
});

var CRYPT_AES_256_KEY_STATE = STRUCT('CRYPT_AES_256_KEY_STATE', {
 Key: pointer,
 IV: pointer,
 EncryptionState: pointer,
 DecryptionState: pointer,
 Feedback: pointer
});

var CRYPT_ATTR_BLOB = STRUCT('CRYPT_ATTR_BLOB', {
 cbData: DWORD,
 pbData: PTR(uchar)
});

var CMS_DH_KEY_INFO = STRUCT('CMS_DH_KEY_INFO', {
 dwVersion: DWORD,
 Algid: ALG_ID,
 pszContentEncObjId: LPSTR,
 PubInfo: CRYPT_DATA_BLOB,
 pReserved: PTR('void')
});

var BCRYPT_AUTH_TAG_LENGTHS_STRUCT = STRUCT('BCRYPT_AUTH_TAG_LENGTHS_STRUCT', {
 dwMinLength: ULONG,
 dwMaxLength: ULONG,
 dwIncrement: ULONG
});

var BCRYPT_OID = STRUCT('BCRYPT_OID', {
 cbOID: ULONG,
 pbOID: PUCHAR
});

var BCRYPT_OID_LIST = STRUCT('BCRYPT_OID_LIST', {
 dwOIDCount: ULONG,
 pOIDs: PTR(uint)
});

var BCRYPT_PKCS1_PADDING_INFO = STRUCT('BCRYPT_PKCS1_PADDING_INFO', {
 pszAlgId: LPCWSTR
});

var BCRYPT_PSS_PADDING_INFO = STRUCT('BCRYPT_PSS_PADDING_INFO', {
 pszAlgId: LPCWSTR,
 cbSalt: ULONG
});

var BCRYPT_OAEP_PADDING_INFO = STRUCT('BCRYPT_OAEP_PADDING_INFO', {
 pszAlgId: LPCWSTR,
 pbLabel: PUCHAR,
 cbLabel: ULONG
});

var BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO = STRUCT('BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO', {
 cbSize: ULONG,
 dwInfoVersion: ULONG,
 pbNonce: PUCHAR,
 cbNonce: ULONG,
 pbAuthData: PUCHAR,
 cbAuthData: ULONG,
 pbTag: PUCHAR,
 cbTag: ULONG,
 pbMacContext: PUCHAR,
 cbMacContext: ULONG,
 cbAAD: ULONG,
 cbData: ULONGLONG,
 dwFlags: ULONG
});

var NCryptBuffer = STRUCT('NCryptBuffer', {
 cbBuffer: ULONG,
 BufferType: ULONG,
 pvBuffer: PVOID
});

var NCryptBufferDesc = STRUCT('NCryptBufferDesc', {
 ulVersion: ULONG,
 cBuffers: ULONG,
 pBuffers: PBCryptBuffer
});

var BCRYPT_KEY_BLOB = STRUCT('BCRYPT_KEY_BLOB', {
 Magic: ULONG
});

var BCRYPT_RSAKEY_BLOB = STRUCT('BCRYPT_RSAKEY_BLOB', {
 Magic: ULONG,
 BitLength: ULONG,
 cbPublicExp: ULONG,
 cbModulus: ULONG,
 cbPrime1: ULONG,
 cbPrime2: ULONG
});

var BCRYPT_ECCKEY_BLOB = STRUCT('BCRYPT_ECCKEY_BLOB', {
 dwMagic: ULONG,
 cbKey: ULONG
});

var BCRYPT_DH_KEY_BLOB = STRUCT('BCRYPT_DH_KEY_BLOB', {
 dwMagic: ULONG,
 cbKey: ULONG
});

var BCRYPT_DH_PARAMETER_HEADER = STRUCT('BCRYPT_DH_PARAMETER_HEADER', {
 cbLength: ULONG,
 dwMagic: ULONG,
 cbKeyLength: ULONG
});

var BCRYPT_DSA_KEY_BLOB = STRUCT('BCRYPT_DSA_KEY_BLOB', {
 dwMagic: ULONG,
 cbKey: ULONG,
 Count: pointer,
 Seed: pointer,
 q: pointer
});

var BCRYPT_KEY_DATA_BLOB_HEADER = STRUCT('BCRYPT_KEY_DATA_BLOB_HEADER', {
 dwMagic: ULONG,
 dwVersion: ULONG,
 cbKeyData: ULONG
});

var BCRYPT_DSA_PARAMETER_HEADER = STRUCT('BCRYPT_DSA_PARAMETER_HEADER', {
 cbLength: ULONG,
 dwMagic: ULONG,
 cbKeyLength: ULONG,
 Count: pointer,
 Seed: pointer,
 q: pointer
});

var BCRYPT_ALGORITHM_IDENTIFIER = STRUCT('BCRYPT_ALGORITHM_IDENTIFIER', {
 pszName: LPWSTR,
 dwClass: ULONG,
 dwFlags: ULONG
});

var BCRYPT_PROVIDER_NAME = STRUCT('BCRYPT_PROVIDER_NAME', {
 pszProviderName: LPWSTR
});

var BCRYPT_INTERFACE_VERSION = STRUCT('BCRYPT_INTERFACE_VERSION', {
 MajorVersion: USHORT,
 MinorVersion: USHORT
});

var CRYPT_INTERFACE_REG = STRUCT('CRYPT_INTERFACE_REG', {
 dwInterface: ULONG,
 dwFlags: ULONG,
 cFunctions: ULONG,
 rgpszFunctions: PTR(PTR(ushort))
});

var CRYPT_IMAGE_REG = STRUCT('CRYPT_IMAGE_REG', {
 pszImage: PWSTR,
 cInterfaces: ULONG,
 rgpInterfaces: PTR(pointer)
});

var CRYPT_PROVIDER_REG = STRUCT('CRYPT_PROVIDER_REG', {
 cAliases: ULONG,
 rgpszAliases: PTR(PTR(ushort)),
 pUM: PCRYPT_IMAGE_REG,
 pKM: PCRYPT_IMAGE_REG
});

var CRYPT_PROVIDERS = STRUCT('CRYPT_PROVIDERS', {
 cProviders: ULONG,
 rgpszProviders: PTR(PTR(ushort))
});

var CRYPT_CONTEXT_CONFIG = STRUCT('CRYPT_CONTEXT_CONFIG', {
 dwFlags: ULONG,
 dwReserved: ULONG
});

var CRYPT_CONTEXT_FUNCTION_CONFIG = STRUCT('CRYPT_CONTEXT_FUNCTION_CONFIG', {
 dwFlags: ULONG,
 dwReserved: ULONG
});

var CRYPT_CONTEXTS = STRUCT('CRYPT_CONTEXTS', {
 cContexts: ULONG,
 rgpszContexts: PTR(PTR(ushort))
});

var CRYPT_CONTEXT_FUNCTIONS = STRUCT('CRYPT_CONTEXT_FUNCTIONS', {
 cFunctions: ULONG,
 rgpszFunctions: PTR(PTR(ushort))
});

var CRYPT_CONTEXT_FUNCTION_PROVIDERS = STRUCT('CRYPT_CONTEXT_FUNCTION_PROVIDERS', {
 cProviders: ULONG,
 rgpszProviders: PTR(PTR(ushort))
});

var CRYPT_PROPERTY_REF = STRUCT('CRYPT_PROPERTY_REF', {
 pszProperty: PWSTR,
 cbValue: ULONG,
 pbValue: PUCHAR
});

var CRYPT_IMAGE_REF = STRUCT('CRYPT_IMAGE_REF', {
 pszImage: PWSTR,
 dwFlags: ULONG
});

var CRYPT_PROVIDER_REF = STRUCT('CRYPT_PROVIDER_REF', {
 dwInterface: ULONG,
 pszFunction: PWSTR,
 pszProvider: PWSTR,
 cProperties: ULONG,
 rgpProperties: PTR(pointer),
 pUM: PCRYPT_IMAGE_REF,
 pKM: PCRYPT_IMAGE_REF
});

var CRYPT_PROVIDER_REFS = STRUCT('CRYPT_PROVIDER_REFS', {
 cProviders: ULONG,
 rgpProviders: PTR(pointer)
});

var NCryptAlgorithmName = STRUCT('NCryptAlgorithmName', {
 pszName: LPWSTR,
 dwClass: DWORD,
 dwAlgOperations: DWORD,
 dwFlags: DWORD
});

var NCryptKeyName = STRUCT('NCryptKeyName', {
 pszName: LPWSTR,
 pszAlgid: LPWSTR,
 dwLegacyKeySpec: DWORD,
 dwFlags: DWORD
});

var NCryptProviderName = STRUCT('NCryptProviderName', {
 pszName: LPWSTR,
 pszComment: LPWSTR
});

var NCRYPT_UI_POLICY_BLOB = STRUCT('NCRYPT_UI_POLICY_BLOB', {
 dwVersion: DWORD,
 dwFlags: DWORD,
 cbCreationTitle: DWORD,
 cbFriendlyName: DWORD,
 cbDescription: DWORD
});

var NCRYPT_UI_POLICY = STRUCT('NCRYPT_UI_POLICY', {
 dwVersion: DWORD,
 dwFlags: DWORD,
 pszCreationTitle: LPCWSTR,
 pszFriendlyName: LPCWSTR,
 pszDescription: LPCWSTR
});

var NCRYPT_SUPPORTED_LENGTHS = STRUCT('NCRYPT_SUPPORTED_LENGTHS', {
 dwMinLength: DWORD,
 dwMaxLength: DWORD,
 dwIncrement: DWORD,
 dwDefaultLength: DWORD
});

var CRYPT_BIT_BLOB = STRUCT('CRYPT_BIT_BLOB', {
 cbData: DWORD,
 pbData: PTR(uchar),
 cUnusedBits: DWORD
});

var CRYPT_ALGORITHM_IDENTIFIER = STRUCT('CRYPT_ALGORITHM_IDENTIFIER', {
 pszObjId: LPSTR,
 Parameters: CRYPT_OBJID_BLOB
});

var CRYPT_OBJID_TABLE = STRUCT('CRYPT_OBJID_TABLE', {
 dwAlgId: DWORD,
 pszObjId: LPCSTR
});

var CRYPT_HASH_INFO = STRUCT('CRYPT_HASH_INFO', {
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Hash: CRYPT_HASH_BLOB
});

var CERT_EXTENSION = STRUCT('CERT_EXTENSION', {
 pszObjId: LPSTR,
 fCritical: BOOL,
 Value: CRYPT_OBJID_BLOB
});

var CRYPT_ATTRIBUTE_TYPE_VALUE = STRUCT('CRYPT_ATTRIBUTE_TYPE_VALUE', {
 pszObjId: LPSTR,
 Value: CRYPT_OBJID_BLOB
});

var CRYPT_ATTRIBUTE = STRUCT('CRYPT_ATTRIBUTE', {
 pszObjId: LPSTR,
 cValue: DWORD,
 rgValue: PCRYPT_ATTR_BLOB
});

var CMSG_ATTR = STRUCT('CMSG_ATTR', {
 cAttr: DWORD,
 rgAttr: PCRYPT_ATTRIBUTE
});

var CERT_RDN_ATTR = STRUCT('CERT_RDN_ATTR', {
 pszObjId: LPSTR,
 dwValueType: DWORD,
 Value: CERT_RDN_VALUE_BLOB
});

var CERT_RDN = STRUCT('CERT_RDN', {
 cRDNAttr: DWORD,
 rgRDNAttr: PCERT_RDN_ATTR
});

var CERT_NAME_INFO = STRUCT('CERT_NAME_INFO', {
 cRDN: DWORD,
 rgRDN: PCERT_RDN
});

var CERT_NAME_VALUE = STRUCT('CERT_NAME_VALUE', {
 dwValueType: DWORD,
 Value: CERT_RDN_VALUE_BLOB
});

var CERT_PUBLIC_KEY_INFO = STRUCT('CERT_PUBLIC_KEY_INFO', {
 Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
 PublicKey: CRYPT_BIT_BLOB
});

var CRYPT_PRIVATE_KEY_INFO = STRUCT('CRYPT_PRIVATE_KEY_INFO', {
 Version: DWORD,
 Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
 PrivateKey: CRYPT_DER_BLOB,
 pAttributes: PCRYPT_ATTRIBUTES
});

var CRYPT_ENCRYPTED_PRIVATE_KEY_INFO = STRUCT('CRYPT_ENCRYPTED_PRIVATE_KEY_INFO', {
 EncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedPrivateKey: CRYPT_DATA_BLOB
});

var CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS = STRUCT('CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS', {
 PrivateKey: CRYPT_DIGEST_BLOB,
 pResolvehCryptProvFunc: PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
 pVoidResolveFunc: LPVOID,
 pDecryptPrivateKeyFunc: PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
 pVoidDecryptFunc: LPVOID
});

var CRYPT_PKCS8_EXPORT_PARAMS = STRUCT('CRYPT_PKCS8_EXPORT_PARAMS', {
 hCryptProv: HCRYPTPROV,
 dwKeySpec: DWORD,
 pszPrivateKeyObjId: LPSTR,
 pEncryptPrivateKeyFunc: PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC,
 pVoidEncryptFunc: LPVOID
});

var CERT_INFO = STRUCT('CERT_INFO', {
 dwVersion: DWORD,
 SerialNumber: CRYPT_INTEGER_BLOB,
 SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Issuer: CERT_NAME_BLOB,
 NotBefore: FILETIME,
 NotAfter: FILETIME,
 Subject: CERT_NAME_BLOB,
 SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
 IssuerUniqueId: CRYPT_BIT_BLOB,
 SubjectUniqueId: CRYPT_BIT_BLOB,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRL_ENTRY = STRUCT('CRL_ENTRY', {
 SerialNumber: CRYPT_INTEGER_BLOB,
 RevocationDate: FILETIME,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRL_INFO = STRUCT('CRL_INFO', {
 dwVersion: DWORD,
 SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Issuer: CERT_NAME_BLOB,
 ThisUpdate: FILETIME,
 NextUpdate: FILETIME,
 cCRLEntry: DWORD,
 rgCRLEntry: PCRL_ENTRY,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CERT_OR_CRL_BLOB = STRUCT('CERT_OR_CRL_BLOB', {
 dwChoice: DWORD,
 cbEncoded: DWORD,
 pbEncoded: PTR(uchar)
});

var CERT_OR_CRL_BUNDLE = STRUCT('CERT_OR_CRL_BUNDLE', {
 cItem: DWORD,
 rgItem: PCERT_OR_CRL_BLOB
});

var CERT_REQUEST_INFO = STRUCT('CERT_REQUEST_INFO', {
 dwVersion: DWORD,
 Subject: CERT_NAME_BLOB,
 SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
 cAttribute: DWORD,
 rgAttribute: PCRYPT_ATTRIBUTE
});

var CERT_KEYGEN_REQUEST_INFO = STRUCT('CERT_KEYGEN_REQUEST_INFO', {
 dwVersion: DWORD,
 SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
 pwszChallengeString: LPWSTR
});

var CERT_SIGNED_CONTENT_INFO = STRUCT('CERT_SIGNED_CONTENT_INFO', {
 ToBeSigned: CRYPT_DER_BLOB,
 SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Signature: CRYPT_BIT_BLOB
});

var CERT_ENHKEY_USAGE = STRUCT('CERT_ENHKEY_USAGE', {
 cUsageIdentifier: DWORD,
 rgpszUsageIdentifier: PTR(PTR(int8))
});

var CTL_ENTRY = STRUCT('CTL_ENTRY', {
 SubjectIdentifier: CRYPT_DATA_BLOB,
 cAttribute: DWORD,
 rgAttribute: PCRYPT_ATTRIBUTE
});

var CTL_INFO = STRUCT('CTL_INFO', {
 dwVersion: DWORD,
 SubjectUsage: CTL_USAGE,
 ListIdentifier: CRYPT_DATA_BLOB,
 SequenceNumber: CRYPT_INTEGER_BLOB,
 ThisUpdate: FILETIME,
 NextUpdate: FILETIME,
 SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 cCTLEntry: DWORD,
 rgCTLEntry: PCTL_ENTRY,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRYPT_TIME_STAMP_REQUEST_INFO = STRUCT('CRYPT_TIME_STAMP_REQUEST_INFO', {
 pszTimeStampAlgorithm: LPSTR,
 pszContentType: LPSTR,
 Content: CRYPT_OBJID_BLOB,
 cAttribute: DWORD,
 rgAttribute: PCRYPT_ATTRIBUTE
});

var CRYPT_ENROLLMENT_NAME_VALUE_PAIR = STRUCT('CRYPT_ENROLLMENT_NAME_VALUE_PAIR', {
 pwszName: LPWSTR,
 pwszValue: LPWSTR
});

var CRYPT_CSP_PROVIDER = STRUCT('CRYPT_CSP_PROVIDER', {
 dwKeySpec: DWORD,
 pwszProviderName: LPWSTR,
 Signature: CRYPT_BIT_BLOB
});

var CRYPT_ENCODE_PARA = STRUCT('CRYPT_ENCODE_PARA', {
 cbSize: DWORD,
 pfnAlloc: PFN_CRYPT_ALLOC,
 pfnFree: PFN_CRYPT_FREE
});

var CRYPT_DECODE_PARA = STRUCT('CRYPT_DECODE_PARA', {
 cbSize: DWORD,
 pfnAlloc: PFN_CRYPT_ALLOC,
 pfnFree: PFN_CRYPT_FREE
});

var CERT_EXTENSIONS = STRUCT('CERT_EXTENSIONS', {
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CERT_AUTHORITY_KEY_ID_INFO = STRUCT('CERT_AUTHORITY_KEY_ID_INFO', {
 KeyId: CRYPT_DATA_BLOB,
 CertIssuer: CERT_NAME_BLOB,
 CertSerialNumber: CRYPT_INTEGER_BLOB
});

var CERT_PRIVATE_KEY_VALIDITY = STRUCT('CERT_PRIVATE_KEY_VALIDITY', {
 NotBefore: FILETIME,
 NotAfter: FILETIME
});

var CERT_KEY_ATTRIBUTES_INFO = STRUCT('CERT_KEY_ATTRIBUTES_INFO', {
 KeyId: CRYPT_DATA_BLOB,
 IntendedKeyUsage: CRYPT_BIT_BLOB,
 pPrivateKeyUsagePeriod: PCERT_PRIVATE_KEY_VALIDITY
});

var CERT_POLICY_ID = STRUCT('CERT_POLICY_ID', {
 cCertPolicyElementId: DWORD,
 rgpszCertPolicyElementId: PTR(PTR(int8))
});

var CERT_KEY_USAGE_RESTRICTION_INFO = STRUCT('CERT_KEY_USAGE_RESTRICTION_INFO', {
 cCertPolicyId: DWORD,
 rgCertPolicyId: PCERT_POLICY_ID,
 RestrictedKeyUsage: CRYPT_BIT_BLOB
});

var CERT_OTHER_NAME = STRUCT('CERT_OTHER_NAME', {
 pszObjId: LPSTR,
 Value: CRYPT_OBJID_BLOB
});

var CERT_ALT_NAME_ENTRY = STRUCT('CERT_ALT_NAME_ENTRY', {
 dwAltNameChoice: DWORD
});

var CERT_ALT_NAME_INFO = STRUCT('CERT_ALT_NAME_INFO', {
 cAltEntry: DWORD,
 rgAltEntry: PCERT_ALT_NAME_ENTRY
});

var CERT_BASIC_CONSTRAINTS_INFO = STRUCT('CERT_BASIC_CONSTRAINTS_INFO', {
 SubjectType: CRYPT_BIT_BLOB,
 fPathLenConstraint: BOOL,
 dwPathLenConstraint: DWORD,
 cSubtreesConstraint: DWORD,
 rgSubtreesConstraint: PTR(uint)
});

var CERT_BASIC_CONSTRAINTS2_INFO = STRUCT('CERT_BASIC_CONSTRAINTS2_INFO', {
 fCA: BOOL,
 fPathLenConstraint: BOOL,
 dwPathLenConstraint: DWORD
});

var CERT_POLICY_QUALIFIER_INFO = STRUCT('CERT_POLICY_QUALIFIER_INFO', {
 pszPolicyQualifierId: LPSTR,
 Qualifier: CRYPT_OBJID_BLOB
});

var CERT_POLICY_INFO = STRUCT('CERT_POLICY_INFO', {
 pszPolicyIdentifier: LPSTR,
 cPolicyQualifier: DWORD,
 rgPolicyQualifier: PTR(uint)
});

var CERT_POLICIES_INFO = STRUCT('CERT_POLICIES_INFO', {
 cPolicyInfo: DWORD,
 rgPolicyInfo: PTR(uint)
});

var CERT_POLICY_QUALIFIER_NOTICE_REFERENCE = STRUCT('CERT_POLICY_QUALIFIER_NOTICE_REFERENCE', {
 pszOrganization: LPSTR,
 cNoticeNumbers: DWORD,
 rgNoticeNumbers: PTR(int)
});

var CERT_POLICY_QUALIFIER_USER_NOTICE = STRUCT('CERT_POLICY_QUALIFIER_USER_NOTICE', {
 pNoticeReference: PTR(uint),
 pszDisplayText: LPWSTR
});

var CPS_URLS = STRUCT('CPS_URLS', {
 pszURL: LPWSTR,
 pAlgorithm: PTR(uint),
 pDigest: PTR(uint)
});

var CERT_POLICY95_QUALIFIER1 = STRUCT('CERT_POLICY95_QUALIFIER1', {
 pszPracticesReference: LPWSTR,
 pszNoticeIdentifier: LPSTR,
 pszNSINoticeIdentifier: LPSTR,
 cCPSURLs: DWORD,
 rgCPSURLs: PTR(uint)
});

var CERT_POLICY_MAPPING = STRUCT('CERT_POLICY_MAPPING', {
 pszIssuerDomainPolicy: LPSTR,
 pszSubjectDomainPolicy: LPSTR
});

var CERT_POLICY_MAPPINGS_INFO = STRUCT('CERT_POLICY_MAPPINGS_INFO', {
 cPolicyMapping: DWORD,
 rgPolicyMapping: PCERT_POLICY_MAPPING
});

var CERT_POLICY_CONSTRAINTS_INFO = STRUCT('CERT_POLICY_CONSTRAINTS_INFO', {
 fRequireExplicitPolicy: BOOL,
 dwRequireExplicitPolicySkipCerts: DWORD,
 fInhibitPolicyMapping: BOOL,
 dwInhibitPolicyMappingSkipCerts: DWORD
});

var CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY = STRUCT('CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY', {
 pszObjId: LPSTR,
 cValue: DWORD,
 rgValue: PCRYPT_DER_BLOB
});

var CRYPT_CONTENT_INFO = STRUCT('CRYPT_CONTENT_INFO', {
 pszObjId: LPSTR,
 Content: CRYPT_DER_BLOB
});

var CRYPT_SEQUENCE_OF_ANY = STRUCT('CRYPT_SEQUENCE_OF_ANY', {
 cValue: DWORD,
 rgValue: PCRYPT_DER_BLOB
});

var CERT_AUTHORITY_KEY_ID2_INFO = STRUCT('CERT_AUTHORITY_KEY_ID2_INFO', {
 KeyId: CRYPT_DATA_BLOB,
 AuthorityCertIssuer: CERT_ALT_NAME_INFO,
 AuthorityCertSerialNumber: CRYPT_INTEGER_BLOB
});

var CERT_ACCESS_DESCRIPTION = STRUCT('CERT_ACCESS_DESCRIPTION', {
 pszAccessMethod: LPSTR,
 AccessLocation: CERT_ALT_NAME_ENTRY
});

var CERT_SUBJECT_INFO_ACCESS = STRUCT('CERT_SUBJECT_INFO_ACCESS', {
 cAccDescr: DWORD,
 rgAccDescr: PCERT_ACCESS_DESCRIPTION
});

var CRL_DIST_POINT_NAME = STRUCT('CRL_DIST_POINT_NAME', {
 dwDistPointNameChoice: DWORD
});

var CRL_DIST_POINT = STRUCT('CRL_DIST_POINT', {
 DistPointName: CRL_DIST_POINT_NAME,
 ReasonFlags: CRYPT_BIT_BLOB,
 CRLIssuer: CERT_ALT_NAME_INFO
});

var CRL_DIST_POINTS_INFO = STRUCT('CRL_DIST_POINTS_INFO', {
 cDistPoint: DWORD,
 rgDistPoint: PCRL_DIST_POINT
});

var CROSS_CERT_DIST_POINTS_INFO = STRUCT('CROSS_CERT_DIST_POINTS_INFO', {
 dwSyncDeltaTime: DWORD,
 cDistPoint: DWORD,
 rgDistPoint: PCERT_ALT_NAME_INFO
});

var CERT_PAIR = STRUCT('CERT_PAIR', {
 Forward: CERT_BLOB,
 Reverse: CERT_BLOB
});

var CRL_ISSUING_DIST_POINT = STRUCT('CRL_ISSUING_DIST_POINT', {
 DistPointName: CRL_DIST_POINT_NAME,
 fOnlyContainsUserCerts: BOOL,
 fOnlyContainsCACerts: BOOL,
 OnlySomeReasonFlags: CRYPT_BIT_BLOB,
 fIndirectCRL: BOOL
});

var CERT_GENERAL_SUBTREE = STRUCT('CERT_GENERAL_SUBTREE', {
 Base: CERT_ALT_NAME_ENTRY,
 dwMinimum: DWORD,
 fMaximum: BOOL,
 dwMaximum: DWORD
});

var CERT_NAME_CONSTRAINTS_INFO = STRUCT('CERT_NAME_CONSTRAINTS_INFO', {
 cPermittedSubtree: DWORD,
 rgPermittedSubtree: PCERT_GENERAL_SUBTREE,
 cExcludedSubtree: DWORD,
 rgExcludedSubtree: PCERT_GENERAL_SUBTREE
});

var CERT_DSS_PARAMETERS = STRUCT('CERT_DSS_PARAMETERS', {
 p: CRYPT_UINT_BLOB,
 q: CRYPT_UINT_BLOB,
 g: CRYPT_UINT_BLOB
});

var CERT_DH_PARAMETERS = STRUCT('CERT_DH_PARAMETERS', {
 p: CRYPT_UINT_BLOB,
 g: CRYPT_UINT_BLOB
});

var CERT_ECC_SIGNATURE = STRUCT('CERT_ECC_SIGNATURE', {
 r: CRYPT_UINT_BLOB,
 s: CRYPT_UINT_BLOB
});

var CERT_X942_DH_VALIDATION_PARAMS = STRUCT('CERT_X942_DH_VALIDATION_PARAMS', {
 seed: CRYPT_BIT_BLOB,
 pgenCounter: DWORD
});

var CERT_X942_DH_PARAMETERS = STRUCT('CERT_X942_DH_PARAMETERS', {
 p: CRYPT_UINT_BLOB,
 g: CRYPT_UINT_BLOB,
 q: CRYPT_UINT_BLOB,
 j: CRYPT_UINT_BLOB,
 pValidationParams: PCERT_X942_DH_VALIDATION_PARAMS
});

var CRYPT_X942_OTHER_INFO = STRUCT('CRYPT_X942_OTHER_INFO', {
 pszContentEncryptionObjId: LPSTR,
 rgbCounter: pointer,
 rgbKeyLength: pointer,
 PubInfo: CRYPT_DATA_BLOB
});

var CRYPT_ECC_CMS_SHARED_INFO = STRUCT('CRYPT_ECC_CMS_SHARED_INFO', {
 Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EntityUInfo: CRYPT_DATA_BLOB,
 rgbSuppPubInfo: pointer
});

var CRYPT_RC2_CBC_PARAMETERS = STRUCT('CRYPT_RC2_CBC_PARAMETERS', {
 dwVersion: DWORD,
 fIV: BOOL,
 rgbIV: pointer
});

var CRYPT_SMIME_CAPABILITY = STRUCT('CRYPT_SMIME_CAPABILITY', {
 pszObjId: LPSTR,
 Parameters: CRYPT_OBJID_BLOB
});

var CRYPT_SMIME_CAPABILITIES = STRUCT('CRYPT_SMIME_CAPABILITIES', {
 cCapability: DWORD,
 rgCapability: PCRYPT_SMIME_CAPABILITY
});

var CERT_QC_STATEMENT = STRUCT('CERT_QC_STATEMENT', {
 pszStatementId: LPSTR,
 StatementInfo: CRYPT_OBJID_BLOB
});

var CERT_QC_STATEMENTS_EXT_INFO = STRUCT('CERT_QC_STATEMENTS_EXT_INFO', {
 cStatement: DWORD,
 rgStatement: PCERT_QC_STATEMENT
});

var CRYPT_MASK_GEN_ALGORITHM = STRUCT('CRYPT_MASK_GEN_ALGORITHM', {
 pszObjId: LPSTR,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
});

var CRYPT_RSA_SSA_PSS_PARAMETERS = STRUCT('CRYPT_RSA_SSA_PSS_PARAMETERS', {
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
 dwSaltLength: DWORD,
 dwTrailerField: DWORD
});

var CRYPT_PSOURCE_ALGORITHM = STRUCT('CRYPT_PSOURCE_ALGORITHM', {
 pszObjId: LPSTR,
 EncodingParameters: CRYPT_DATA_BLOB
});

var CRYPT_RSAES_OAEP_PARAMETERS = STRUCT('CRYPT_RSAES_OAEP_PARAMETERS', {
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
 PSourceAlgorithm: CRYPT_PSOURCE_ALGORITHM
});

var CMC_TAGGED_ATTRIBUTE = STRUCT('CMC_TAGGED_ATTRIBUTE', {
 dwBodyPartID: DWORD,
 Attribute: CRYPT_ATTRIBUTE
});

var CMC_TAGGED_CERT_REQUEST = STRUCT('CMC_TAGGED_CERT_REQUEST', {
 dwBodyPartID: DWORD,
 SignedCertRequest: CRYPT_DER_BLOB
});

var CMC_TAGGED_REQUEST = STRUCT('CMC_TAGGED_REQUEST', {
 dwTaggedRequestChoice: DWORD
});

var CMC_TAGGED_CONTENT_INFO = STRUCT('CMC_TAGGED_CONTENT_INFO', {
 dwBodyPartID: DWORD,
 EncodedContentInfo: CRYPT_DER_BLOB
});

var CMC_TAGGED_OTHER_MSG = STRUCT('CMC_TAGGED_OTHER_MSG', {
 dwBodyPartID: DWORD,
 pszObjId: LPSTR,
 Value: CRYPT_OBJID_BLOB
});

var CMC_DATA_INFO = STRUCT('CMC_DATA_INFO', {
 cTaggedAttribute: DWORD,
 rgTaggedAttribute: PCMC_TAGGED_ATTRIBUTE,
 cTaggedRequest: DWORD,
 rgTaggedRequest: PCMC_TAGGED_REQUEST,
 cTaggedContentInfo: DWORD,
 rgTaggedContentInfo: PCMC_TAGGED_CONTENT_INFO,
 cTaggedOtherMsg: DWORD,
 rgTaggedOtherMsg: PCMC_TAGGED_OTHER_MSG
});

var CMC_RESPONSE_INFO = STRUCT('CMC_RESPONSE_INFO', {
 cTaggedAttribute: DWORD,
 rgTaggedAttribute: PCMC_TAGGED_ATTRIBUTE,
 cTaggedContentInfo: DWORD,
 rgTaggedContentInfo: PCMC_TAGGED_CONTENT_INFO,
 cTaggedOtherMsg: DWORD,
 rgTaggedOtherMsg: PCMC_TAGGED_OTHER_MSG
});

var CMC_PEND_INFO = STRUCT('CMC_PEND_INFO', {
 PendToken: CRYPT_DATA_BLOB,
 PendTime: FILETIME
});

var CMC_STATUS_INFO = STRUCT('CMC_STATUS_INFO', {
 dwStatus: DWORD,
 cBodyList: DWORD,
 rgdwBodyList: PTR(ulong),
 pwszStatusString: LPWSTR,
 dwOtherInfoChoice: DWORD
});

var CMC_ADD_EXTENSIONS_INFO = STRUCT('CMC_ADD_EXTENSIONS_INFO', {
 dwCmcDataReference: DWORD,
 cCertReference: DWORD,
 rgdwCertReference: PTR(ulong),
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CMC_ADD_ATTRIBUTES_INFO = STRUCT('CMC_ADD_ATTRIBUTES_INFO', {
 dwCmcDataReference: DWORD,
 cCertReference: DWORD,
 rgdwCertReference: PTR(ulong),
 cAttribute: DWORD,
 rgAttribute: PCRYPT_ATTRIBUTE
});

var CERT_TEMPLATE_EXT = STRUCT('CERT_TEMPLATE_EXT', {
 pszObjId: LPSTR,
 dwMajorVersion: DWORD,
 fMinorVersion: BOOL,
 dwMinorVersion: DWORD
});

var CERT_HASHED_URL = STRUCT('CERT_HASHED_URL', {
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Hash: CRYPT_HASH_BLOB,
 pwszUrl: LPWSTR
});

var CERT_LOGOTYPE_DETAILS = STRUCT('CERT_LOGOTYPE_DETAILS', {
 pwszMimeType: LPWSTR,
 cHashedUrl: DWORD,
 rgHashedUrl: PCERT_HASHED_URL
});

var CERT_LOGOTYPE_REFERENCE = STRUCT('CERT_LOGOTYPE_REFERENCE', {
 cHashedUrl: DWORD,
 rgHashedUrl: PCERT_HASHED_URL
});

var CERT_LOGOTYPE_IMAGE_INFO = STRUCT('CERT_LOGOTYPE_IMAGE_INFO', {
 dwLogotypeImageInfoChoice: DWORD,
 dwFileSize: DWORD,
 dwXSize: DWORD,
 dwYSize: DWORD,
 dwLogotypeImageResolutionChoice: DWORD,
 pwszLanguage: LPWSTR
});

var CERT_LOGOTYPE_IMAGE = STRUCT('CERT_LOGOTYPE_IMAGE', {
 LogotypeDetails: CERT_LOGOTYPE_DETAILS,
 pLogotypeImageInfo: PCERT_LOGOTYPE_IMAGE_INFO
});

var CERT_LOGOTYPE_AUDIO_INFO = STRUCT('CERT_LOGOTYPE_AUDIO_INFO', {
 dwFileSize: DWORD,
 dwPlayTime: DWORD,
 dwChannels: DWORD,
 dwSampleRate: DWORD,
 pwszLanguage: LPWSTR
});

var CERT_LOGOTYPE_AUDIO = STRUCT('CERT_LOGOTYPE_AUDIO', {
 LogotypeDetails: CERT_LOGOTYPE_DETAILS,
 pLogotypeAudioInfo: PCERT_LOGOTYPE_AUDIO_INFO
});

var CERT_LOGOTYPE_DATA = STRUCT('CERT_LOGOTYPE_DATA', {
 cLogotypeImage: DWORD,
 rgLogotypeImage: PCERT_LOGOTYPE_IMAGE,
 cLogotypeAudio: DWORD,
 rgLogotypeAudio: PCERT_LOGOTYPE_AUDIO
});

var CERT_LOGOTYPE_INFO = STRUCT('CERT_LOGOTYPE_INFO', {
 dwLogotypeInfoChoice: DWORD
});

var CERT_OTHER_LOGOTYPE_INFO = STRUCT('CERT_OTHER_LOGOTYPE_INFO', {
 pszObjId: LPSTR,
 LogotypeInfo: CERT_LOGOTYPE_INFO
});

var CERT_LOGOTYPE_EXT_INFO = STRUCT('CERT_LOGOTYPE_EXT_INFO', {
 cCommunityLogo: DWORD,
 rgCommunityLogo: PCERT_LOGOTYPE_INFO,
 pIssuerLogo: PCERT_LOGOTYPE_INFO,
 pSubjectLogo: PCERT_LOGOTYPE_INFO,
 cOtherLogo: DWORD,
 rgOtherLogo: PCERT_OTHER_LOGOTYPE_INFO
});

var CERT_BIOMETRIC_DATA = STRUCT('CERT_BIOMETRIC_DATA', {
 dwTypeOfBiometricDataChoice: DWORD,
 HashedUrl: CERT_HASHED_URL
});

var CERT_BIOMETRIC_EXT_INFO = STRUCT('CERT_BIOMETRIC_EXT_INFO', {
 cBiometricData: DWORD,
 rgBiometricData: PCERT_BIOMETRIC_DATA
});

var OCSP_SIGNATURE_INFO = STRUCT('OCSP_SIGNATURE_INFO', {
 SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 Signature: CRYPT_BIT_BLOB,
 cCertEncoded: DWORD,
 rgCertEncoded: PCERT_BLOB
});

var OCSP_SIGNED_REQUEST_INFO = STRUCT('OCSP_SIGNED_REQUEST_INFO', {
 ToBeSigned: CRYPT_DER_BLOB,
 pOptionalSignatureInfo: POCSP_SIGNATURE_INFO
});

var OCSP_CERT_ID = STRUCT('OCSP_CERT_ID', {
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 IssuerNameHash: CRYPT_HASH_BLOB,
 IssuerKeyHash: CRYPT_HASH_BLOB,
 SerialNumber: CRYPT_INTEGER_BLOB
});

var OCSP_REQUEST_ENTRY = STRUCT('OCSP_REQUEST_ENTRY', {
 CertId: OCSP_CERT_ID,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var OCSP_REQUEST_INFO = STRUCT('OCSP_REQUEST_INFO', {
 dwVersion: DWORD,
 pRequestorName: PCERT_ALT_NAME_ENTRY,
 cRequestEntry: DWORD,
 rgRequestEntry: POCSP_REQUEST_ENTRY,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var OCSP_RESPONSE_INFO = STRUCT('OCSP_RESPONSE_INFO', {
 dwStatus: DWORD,
 pszObjId: LPSTR,
 Value: CRYPT_OBJID_BLOB
});

var OCSP_BASIC_SIGNED_RESPONSE_INFO = STRUCT('OCSP_BASIC_SIGNED_RESPONSE_INFO', {
 ToBeSigned: CRYPT_DER_BLOB,
 SignatureInfo: OCSP_SIGNATURE_INFO
});

var OCSP_BASIC_REVOKED_INFO = STRUCT('OCSP_BASIC_REVOKED_INFO', {
 RevocationDate: FILETIME,
 dwCrlReasonCode: DWORD
});

var OCSP_BASIC_RESPONSE_ENTRY = STRUCT('OCSP_BASIC_RESPONSE_ENTRY', {
 CertId: OCSP_CERT_ID,
 dwCertStatus: DWORD,
 ThisUpdate: FILETIME,
 NextUpdate: FILETIME,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var OCSP_BASIC_RESPONSE_INFO = STRUCT('OCSP_BASIC_RESPONSE_INFO', {
 dwVersion: DWORD,
 dwResponderIdChoice: DWORD,
 ProducedAt: FILETIME,
 cResponseEntry: DWORD,
 rgResponseEntry: POCSP_BASIC_RESPONSE_ENTRY,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRYPT_OID_FUNC_ENTRY = STRUCT('CRYPT_OID_FUNC_ENTRY', {
 pszOID: LPCSTR,
 pvFuncAddr: PTR('void')
});

var CCRYPT_OID_INFO = STRUCT('CCRYPT_OID_INFO', {
 cbSize: DWORD,
 pszOID: LPCSTR,
 pwszName: LPCWSTR,
 dwGroupId: DWORD,
 ExtraInfo: CRYPT_DATA_BLOB
});

var CERT_ISSUER_SERIAL_NUMBER = STRUCT('CERT_ISSUER_SERIAL_NUMBER', {
 Issuer: CERT_NAME_BLOB,
 SerialNumber: CRYPT_INTEGER_BLOB
});

var CERT_ID = STRUCT('CERT_ID', {
 dwIdChoice: DWORD
});

var CMSG_SIGNER_ENCODE_INFO = STRUCT('CMSG_SIGNER_ENCODE_INFO', {
 cbSize: DWORD,
 pCertInfo: PCERT_INFO,
 dwKeySpec: DWORD,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvHashAuxInfo: PTR('void'),
 cAuthAttr: DWORD,
 rgAuthAttr: PCRYPT_ATTRIBUTE,
 cUnauthAttr: DWORD,
 rgUnauthAttr: PCRYPT_ATTRIBUTE
});

var CMSG_SIGNED_ENCODE_INFO = STRUCT('CMSG_SIGNED_ENCODE_INFO', {
 cbSize: DWORD,
 cSigners: DWORD,
 rgSigners: PCMSG_SIGNER_ENCODE_INFO,
 cCertEncoded: DWORD,
 rgCertEncoded: PCERT_BLOB,
 cCrlEncoded: DWORD,
 rgCrlEncoded: PCRL_BLOB
});

var _CMSG_RECIPIENT_ENCODE_INFO = STRUCT('_CMSG_RECIPIENT_ENCODE_INFO', {
 dwRecipientChoice: DWORD
});

var CMSG_ENVELOPED_ENCODE_INFO = STRUCT('CMSG_ENVELOPED_ENCODE_INFO', {
 cbSize: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvEncryptionAuxInfo: PTR('void'),
 cRecipients: DWORD,
 rgpRecipients: PTR(pointer)
});

var CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = STRUCT('CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', {
 cbSize: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvKeyEncryptionAuxInfo: PTR('void'),
 hCryptProv: HCRYPTPROV_LEGACY,
 RecipientPublicKey: CRYPT_BIT_BLOB,
 RecipientId: CERT_ID
});

var CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = STRUCT('CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', {
 cbSize: DWORD,
 RecipientPublicKey: CRYPT_BIT_BLOB,
 RecipientId: CERT_ID,
 Date: FILETIME,
 pOtherAttr: PCRYPT_ATTRIBUTE_TYPE_VALUE
});

var CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = STRUCT('CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', {
 cbSize: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvKeyEncryptionAuxInfo: PTR('void'),
 KeyWrapAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvKeyWrapAuxInfo: PTR('void'),
 hCryptProv: HCRYPTPROV_LEGACY,
 dwKeySpec: DWORD,
 dwKeyChoice: DWORD,
 UserKeyingMaterial: CRYPT_DATA_BLOB,
 cRecipientEncryptedKeys: DWORD,
 rgpRecipientEncryptedKeys: PTR(pointer)
});

var CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = STRUCT('CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', {
 cbSize: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvKeyEncryptionAuxInfo: PTR('void'),
 hCryptProv: HCRYPTPROV,
 dwKeyChoice: DWORD,
 KeyId: CRYPT_DATA_BLOB,
 Date: FILETIME,
 pOtherAttr: PCRYPT_ATTRIBUTE_TYPE_VALUE
});

var CMSG_RC2_AUX_INFO = STRUCT('CMSG_RC2_AUX_INFO', {
 cbSize: DWORD,
 dwBitLen: DWORD
});

var CMSG_SP3_COMPATIBLE_AUX_INFO = STRUCT('CMSG_SP3_COMPATIBLE_AUX_INFO', {
 cbSize: DWORD,
 dwFlags: DWORD
});

var CMSG_RC4_AUX_INFO = STRUCT('CMSG_RC4_AUX_INFO', {
 cbSize: DWORD,
 dwBitLen: DWORD
});

var CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO = STRUCT('CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO', {
 cbSize: DWORD,
 SignedInfo: CMSG_SIGNED_ENCODE_INFO,
 EnvelopedInfo: CMSG_ENVELOPED_ENCODE_INFO
});

var CMSG_HASHED_ENCODE_INFO = STRUCT('CMSG_HASHED_ENCODE_INFO', {
 cbSize: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvHashAuxInfo: PTR('void')
});

var CMSG_ENCRYPTED_ENCODE_INFO = STRUCT('CMSG_ENCRYPTED_ENCODE_INFO', {
 cbSize: DWORD,
 ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvEncryptionAuxInfo: PTR('void')
});

var CMSG_STREAM_INFO = STRUCT('CMSG_STREAM_INFO', {
 cbContent: DWORD,
 pfnStreamOutput: PFN_CMSG_STREAM_OUTPUT,
 pvArg: PTR('void')
});

var CMSG_SIGNER_INFO = STRUCT('CMSG_SIGNER_INFO', {
 dwVersion: DWORD,
 Issuer: CERT_NAME_BLOB,
 SerialNumber: CRYPT_INTEGER_BLOB,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedHash: CRYPT_DATA_BLOB,
 AuthAttrs: CRYPT_ATTRIBUTES,
 UnauthAttrs: CRYPT_ATTRIBUTES
});

var CMSG_CMS_SIGNER_INFO = STRUCT('CMSG_CMS_SIGNER_INFO', {
 dwVersion: DWORD,
 SignerId: CERT_ID,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedHash: CRYPT_DATA_BLOB,
 AuthAttrs: CRYPT_ATTRIBUTES,
 UnauthAttrs: CRYPT_ATTRIBUTES
});

var CMSG_KEY_TRANS_RECIPIENT_INFO = STRUCT('CMSG_KEY_TRANS_RECIPIENT_INFO', {
 dwVersion: DWORD,
 RecipientId: CERT_ID,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedKey: CRYPT_DATA_BLOB
});

var CMSG_RECIPIENT_ENCRYPTED_KEY_INFO = STRUCT('CMSG_RECIPIENT_ENCRYPTED_KEY_INFO', {
 RecipientId: CERT_ID,
 EncryptedKey: CRYPT_DATA_BLOB,
 Date: FILETIME,
 pOtherAttr: PCRYPT_ATTRIBUTE_TYPE_VALUE
});

var CMSG_KEY_AGREE_RECIPIENT_INFO = STRUCT('CMSG_KEY_AGREE_RECIPIENT_INFO', {
 dwVersion: DWORD,
 dwOriginatorChoice: DWORD,
 UserKeyingMaterial: CRYPT_DATA_BLOB,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 cRecipientEncryptedKeys: DWORD,
 rgpRecipientEncryptedKeys: PTR(pointer)
});

var CMSG_MAIL_LIST_RECIPIENT_INFO = STRUCT('CMSG_MAIL_LIST_RECIPIENT_INFO', {
 dwVersion: DWORD,
 KeyId: CRYPT_DATA_BLOB,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedKey: CRYPT_DATA_BLOB,
 Date: FILETIME,
 pOtherAttr: PCRYPT_ATTRIBUTE_TYPE_VALUE
});

var CMSG_CMS_RECIPIENT_INFO = STRUCT('CMSG_CMS_RECIPIENT_INFO', {
 dwRecipientChoice: DWORD
});

var CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA = STRUCT('CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA', {
 cbSize: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 dwSignerIndex: DWORD,
 dwSignerType: DWORD,
 pvSigner: PTR('void')
});

var CMSG_CTRL_DECRYPT_PARA = STRUCT('CMSG_CTRL_DECRYPT_PARA', {
 cbSize: DWORD,
 dwKeySpec: DWORD,
 dwRecipientIndex: DWORD
});

var CMSG_CTRL_KEY_TRANS_DECRYPT_PARA = STRUCT('CMSG_CTRL_KEY_TRANS_DECRYPT_PARA', {
 cbSize: DWORD,
 dwKeySpec: DWORD,
 pKeyTrans: PCMSG_KEY_TRANS_RECIPIENT_INFO,
 dwRecipientIndex: DWORD
});

var CMSG_CTRL_KEY_AGREE_DECRYPT_PARA = STRUCT('CMSG_CTRL_KEY_AGREE_DECRYPT_PARA', {
 cbSize: DWORD,
 dwKeySpec: DWORD,
 pKeyAgree: PCMSG_KEY_AGREE_RECIPIENT_INFO,
 dwRecipientIndex: DWORD,
 dwRecipientEncryptedKeyIndex: DWORD,
 OriginatorPublicKey: CRYPT_BIT_BLOB
});

var CMSG_CTRL_MAIL_LIST_DECRYPT_PARA = STRUCT('CMSG_CTRL_MAIL_LIST_DECRYPT_PARA', {
 cbSize: DWORD,
 hCryptProv: HCRYPTPROV,
 pMailList: PCMSG_MAIL_LIST_RECIPIENT_INFO,
 dwRecipientIndex: DWORD,
 dwKeyChoice: DWORD
});

var CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA = STRUCT('CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA', {
 cbSize: DWORD,
 dwSignerIndex: DWORD,
 blob: CRYPT_DATA_BLOB
});

var CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA = STRUCT('CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA', {
 cbSize: DWORD,
 dwSignerIndex: DWORD,
 dwUnauthAttrIndex: DWORD
});

var CMSG_CONTENT_ENCRYPT_INFO = STRUCT('CMSG_CONTENT_ENCRYPT_INFO', {
 cbSize: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvEncryptionAuxInfo: PTR('void'),
 cRecipients: DWORD,
 rgCmsRecipients: PCMSG_RECIPIENT_ENCODE_INFO,
 pfnAlloc: PFN_CMSG_ALLOC,
 pfnFree: PFN_CMSG_FREE,
 dwEncryptFlags: DWORD,
 dwFlags: DWORD,
 fCNG: BOOL,
 pbCNGContentEncryptKeyObject: PTR(uchar),
 pbContentEncryptKey: PTR(uchar),
 cbContentEncryptKey: DWORD
});

var CMSG_KEY_TRANS_ENCRYPT_INFO = STRUCT('CMSG_KEY_TRANS_ENCRYPT_INFO', {
 cbSize: DWORD,
 dwRecipientIndex: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedKey: CRYPT_DATA_BLOB,
 dwFlags: DWORD
});

var CMSG_KEY_AGREE_KEY_ENCRYPT_INFO = STRUCT('CMSG_KEY_AGREE_KEY_ENCRYPT_INFO', {
 cbSize: DWORD,
 EncryptedKey: CRYPT_DATA_BLOB
});

var CMSG_KEY_AGREE_ENCRYPT_INFO = STRUCT('CMSG_KEY_AGREE_ENCRYPT_INFO', {
 cbSize: DWORD,
 dwRecipientIndex: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 UserKeyingMaterial: CRYPT_DATA_BLOB,
 dwOriginatorChoice: DWORD,
 cKeyAgreeKeyEncryptInfo: DWORD,
 rgpKeyAgreeKeyEncryptInfo: PTR(pointer),
 dwFlags: DWORD
});

var CMSG_MAIL_LIST_ENCRYPT_INFO = STRUCT('CMSG_MAIL_LIST_ENCRYPT_INFO', {
 cbSize: DWORD,
 dwRecipientIndex: DWORD,
 KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 EncryptedKey: CRYPT_DATA_BLOB,
 dwFlags: DWORD
});

var CMSG_CNG_CONTENT_DECRYPT_INFO = STRUCT('CMSG_CNG_CONTENT_DECRYPT_INFO', {
 cbSize: DWORD,
 ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pfnAlloc: PFN_CMSG_ALLOC,
 pfnFree: PFN_CMSG_FREE,
 hNCryptKey: NCRYPT_KEY_HANDLE,
 pbContentEncryptKey: PTR(uchar),
 cbContentEncryptKey: DWORD,
 hCNGContentEncryptKey: BCRYPT_KEY_HANDLE,
 pbCNGContentEncryptKeyObject: PTR(uchar)
});

var CERT_CONTEXT = STRUCT('CERT_CONTEXT', {
 dwCertEncodingType: DWORD,
 pbCertEncoded: PTR(uchar),
 cbCertEncoded: DWORD,
 pCertInfo: PCERT_INFO,
 hCertStore: HCERTSTORE
});

var CRL_CONTEXT = STRUCT('CRL_CONTEXT', {
 dwCertEncodingType: DWORD,
 pbCrlEncoded: PTR(uchar),
 cbCrlEncoded: DWORD,
 pCrlInfo: PCRL_INFO,
 hCertStore: HCERTSTORE
});

var CTL_CONTEXT = STRUCT('CTL_CONTEXT', {
 dwMsgAndCertEncodingType: DWORD,
 pbCtlEncoded: PTR(uchar),
 cbCtlEncoded: DWORD,
 pCtlInfo: PCTL_INFO,
 hCertStore: HCERTSTORE,
 hCryptMsg: HCRYPTMSG,
 pbCtlContent: PTR(uchar),
 cbCtlContent: DWORD
});

var CRYPT_KEY_PROV_PARAM = STRUCT('CRYPT_KEY_PROV_PARAM', {
 dwParam: DWORD,
 pbData: PTR(uchar),
 cbData: DWORD,
 dwFlags: DWORD
});

var CRYPT_KEY_PROV_INFO = STRUCT('CRYPT_KEY_PROV_INFO', {
 pwszContainerName: LPWSTR,
 pwszProvName: LPWSTR,
 dwProvType: DWORD,
 dwFlags: DWORD,
 cProvParam: DWORD,
 rgProvParam: PCRYPT_KEY_PROV_PARAM,
 dwKeySpec: DWORD
});

var CERT_KEY_CONTEXT = STRUCT('CERT_KEY_CONTEXT', {
 cbSize: DWORD,
 dwKeySpec: DWORD
});

var ROOT_INFO_LUID = STRUCT('ROOT_INFO_LUID', {
 LowPart: DWORD,
 HighPart: LONG
});

var CRYPT_SMART_CARD_ROOT_INFO = STRUCT('CRYPT_SMART_CARD_ROOT_INFO', {
 rgbCardID: pointer,
 luid: ROOT_INFO_LUID
});


var CERT_REGISTRY_STORE_CLIENT_GPT_PARA = STRUCT('CERT_REGISTRY_STORE_CLIENT_GPT_PARA', {
 hKeyBase: HKEY,
 pwszRegPath: LPWSTR
});

var CERT_REGISTRY_STORE_ROAMING_PARA = STRUCT('CERT_REGISTRY_STORE_ROAMING_PARA', {
 hKey: HKEY,
 pwszStoreDirectory: LPWSTR
});

var CERT_LDAP_STORE_OPENED_PARA = STRUCT('CERT_LDAP_STORE_OPENED_PARA', {
 pvLdapSessionHandle: PTR('void'),
 pwszLdapUrl: LPCWSTR
});

var CERT_STORE_PROV_INFO = STRUCT('CERT_STORE_PROV_INFO', {
 cbSize: DWORD,
 cStoreProvFunc: DWORD,
 rgpvStoreProvFunc: PTR(PTR('void')),
 hStoreProv: HCERTSTOREPROV,
 dwStoreProvFlags: DWORD,
 hStoreProvFuncAddr2: HCRYPTOIDFUNCADDR
});

var CCERT_STORE_PROV_FIND_INFO = STRUCT('CCERT_STORE_PROV_FIND_INFO', {
 cbSize: DWORD,
 dwMsgAndCertEncodingType: DWORD,
 dwFindFlags: DWORD,
 dwFindType: DWORD,
 pvFindPara: PTR('void')
});

var CRL_FIND_ISSUED_FOR_PARA = STRUCT('CRL_FIND_ISSUED_FOR_PARA', {
 pSubjectCert: PCCERT_CONTEXT,
 pIssuerCert: PCCERT_CONTEXT
});

var CTL_ANY_SUBJECT_INFO = STRUCT('CTL_ANY_SUBJECT_INFO', {
 SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 SubjectIdentifier: CRYPT_DATA_BLOB
});

var CTL_FIND_USAGE_PARA = STRUCT('CTL_FIND_USAGE_PARA', {
 cbSize: DWORD,
 SubjectUsage: CTL_USAGE,
 ListIdentifier: CRYPT_DATA_BLOB,
 pSigner: PCERT_INFO
});

var CTL_FIND_SUBJECT_PARA = STRUCT('CTL_FIND_SUBJECT_PARA', {
 cbSize: DWORD,
 pUsagePara: PCTL_FIND_USAGE_PARA,
 dwSubjectType: DWORD,
 pvSubject: PTR('void')
});

var CERT_CREATE_CONTEXT_PARA = STRUCT('CERT_CREATE_CONTEXT_PARA', {
 cbSize: DWORD,
 pfnFree: PFN_CRYPT_FREE,
 pvFree: PTR('void'),
 pfnSort: PFN_CERT_CREATE_CONTEXT_SORT_FUNC,
 pvSort: PTR('void')
});

var CERT_SYSTEM_STORE_INFO = STRUCT('CERT_SYSTEM_STORE_INFO', {
 cbSize: DWORD
});

var CERT_PHYSICAL_STORE_INFO = STRUCT('CERT_PHYSICAL_STORE_INFO', {
 cbSize: DWORD,
 pszOpenStoreProvider: LPSTR,
 dwOpenEncodingType: DWORD,
 dwOpenFlags: DWORD,
 OpenParameters: CRYPT_DATA_BLOB,
 dwFlags: DWORD,
 dwPriority: DWORD
});

var CTL_VERIFY_USAGE_PARA = STRUCT('CTL_VERIFY_USAGE_PARA', {
 cbSize: DWORD,
 ListIdentifier: CRYPT_DATA_BLOB,
 cCtlStore: DWORD,
 rghCtlStore: PTR(PTR('void')),
 cSignerStore: DWORD,
 rghSignerStore: PTR(PTR('void'))
});

var CTL_VERIFY_USAGE_STATUS = STRUCT('CTL_VERIFY_USAGE_STATUS', {
 cbSize: DWORD,
 dwError: DWORD,
 dwFlags: DWORD,
 ppCtl: PTR(pointer),
 dwCtlEntryIndex: DWORD,
 ppSigner: PTR(pointer),
 dwSignerIndex: DWORD
});

var CERT_REVOCATION_CRL_INFO = STRUCT('CERT_REVOCATION_CRL_INFO', {
 cbSize: DWORD,
 pBaseCrlContext: PCCRL_CONTEXT,
 pDeltaCrlContext: PCCRL_CONTEXT,
 pCrlEntry: PCRL_ENTRY,
 fDeltaCrlEntry: BOOL
});

var _CERT_REVOCATION_CHAIN_PARA = STRUCT('_CERT_REVOCATION_CHAIN_PARA', {
 cbSize: DWORD,
 hChainEngine: HCERTCHAINENGINE,
 hAdditionalStore: HCERTSTORE,
 dwChainFlags: DWORD,
 dwUrlRetrievalTimeout: DWORD,
 pftCurrentTime: LPFILETIME,
 pftCacheResync: LPFILETIME,
 cbMaxUrlRetrievalByteCount: DWORD
});

var CERT_REVOCATION_PARA = STRUCT('CERT_REVOCATION_PARA', {
 cbSize: DWORD,
 pIssuerCert: PCCERT_CONTEXT,
 cCertStore: DWORD,
 rgCertStore: PTR(PTR('void')),
 hCrlStore: HCERTSTORE,
 pftTimeToUse: LPFILETIME
});

var CERT_REVOCATION_STATUS = STRUCT('CERT_REVOCATION_STATUS', {
 cbSize: DWORD,
 dwIndex: DWORD,
 dwError: DWORD,
 dwReason: DWORD,
 fHasFreshnessTime: BOOL,
 dwFreshnessTime: DWORD
});

var CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA = STRUCT('CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA', {
 cOID: DWORD,
 rgpszOID: PTR(PTR(int8))
});

var CRYPT_SIGN_MESSAGE_PARA = STRUCT('CRYPT_SIGN_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgEncodingType: DWORD,
 pSigningCert: PCCERT_CONTEXT,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvHashAuxInfo: PTR('void'),
 cMsgCert: DWORD,
 rgpMsgCert: PTR(pointer),
 cMsgCrl: DWORD,
 rgpMsgCrl: PTR(pointer),
 cAuthAttr: DWORD,
 rgAuthAttr: PCRYPT_ATTRIBUTE,
 cUnauthAttr: DWORD,
 rgUnauthAttr: PCRYPT_ATTRIBUTE,
 dwFlags: DWORD,
 dwInnerContentType: DWORD
});

var CRYPT_VERIFY_MESSAGE_PARA = STRUCT('CRYPT_VERIFY_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgAndCertEncodingType: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 pfnGetSignerCertificate: PFN_CRYPT_GET_SIGNER_CERTIFICATE,
 pvGetArg: PTR('void')
});

var CRYPT_ENCRYPT_MESSAGE_PARA = STRUCT('CRYPT_ENCRYPT_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgEncodingType: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvEncryptionAuxInfo: PTR('void'),
 dwFlags: DWORD,
 dwInnerContentType: DWORD
});

var CRYPT_DECRYPT_MESSAGE_PARA = STRUCT('CRYPT_DECRYPT_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgAndCertEncodingType: DWORD,
 cCertStore: DWORD,
 rghCertStore: PTR(PTR('void'))
});

var CRYPT_HASH_MESSAGE_PARA = STRUCT('CRYPT_HASH_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgEncodingType: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvHashAuxInfo: PTR('void')
});

var CRYPT_KEY_SIGN_MESSAGE_PARA = STRUCT('CRYPT_KEY_SIGN_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgAndCertEncodingType: DWORD,
 dwKeySpec: DWORD,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 pvHashAuxInfo: PTR('void'),
 PubKeyAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
});

var CRYPT_KEY_VERIFY_MESSAGE_PARA = STRUCT('CRYPT_KEY_VERIFY_MESSAGE_PARA', {
 cbSize: DWORD,
 dwMsgEncodingType: DWORD,
 hCryptProv: HCRYPTPROV_LEGACY
});

var CERT_CHAIN = STRUCT('CERT_CHAIN', {
 cCerts: DWORD,
 certs: PCERT_BLOB,
 keyLocatorInfo: CRYPT_KEY_PROV_INFO
});

var CRYPT_BLOB_ARRAY = STRUCT('CRYPT_BLOB_ARRAY', {
 cBlob: DWORD,
 rgBlob: PCRYPT_DATA_BLOB
});

var CRYPT_CREDENTIALS = STRUCT('CRYPT_CREDENTIALS', {
 cbSize: DWORD,
 pszCredentialsOid: LPCSTR,
 pvCredentials: LPVOID
});

var CRYPT_PASSWORD_CREDENTIALS = STRUCT('CRYPT_PASSWORD_CREDENTIALS', {
 cbSize: DWORD,
 pszUsername: LPSTR,
 pszPassword: LPSTR
});

var CRYPT_PASSWORD_CREDENTIALSW = STRUCT('CRYPT_PASSWORD_CREDENTIALSW', {
 cbSize: DWORD,
 pszUsername: LPWSTR,
 pszPassword: LPWSTR
});

var CRYPTNET_URL_CACHE_PRE_FETCH_INFO = STRUCT('CRYPTNET_URL_CACHE_PRE_FETCH_INFO', {
 cbSize: DWORD,
 dwObjectType: DWORD,
 dwError: DWORD,
 dwReserved: DWORD,
 ThisUpdateTime: FILETIME,
 NextUpdateTime: FILETIME,
 PublishTime: FILETIME
});

var CRYPTNET_URL_CACHE_FLUSH_INFO = STRUCT('CRYPTNET_URL_CACHE_FLUSH_INFO', {
 cbSize: DWORD,
 dwExemptSeconds: DWORD,
 ExpireTime: FILETIME
});

var CRYPTNET_URL_CACHE_RESPONSE_INFO = STRUCT('CRYPTNET_URL_CACHE_RESPONSE_INFO', {
 cbSize: DWORD,
 wResponseType: WORD,
 wResponseFlags: WORD,
 LastModifiedTime: FILETIME,
 dwMaxAge: DWORD,
 pwszETag: LPCWSTR,
 dwProxyId: DWORD
});

var CRYPT_RETRIEVE_AUX_INFO = STRUCT('CRYPT_RETRIEVE_AUX_INFO', {
 cbSize: DWORD,
 pLastSyncTime: PTR(uint),
 dwMaxUrlRetrievalByteCount: DWORD,
 pPreFetchInfo: PCRYPTNET_URL_CACHE_PRE_FETCH_INFO,
 pFlushInfo: PCRYPTNET_URL_CACHE_FLUSH_INFO,
 ppResponseInfo: PTR(pointer),
 pwszCacheFileNamePrefix: LPWSTR,
 pftCacheResync: LPFILETIME,
 fProxyCacheRetrieval: BOOL,
 dwHttpStatusCode: DWORD
});

var CRYPT_ASYNC_RETRIEVAL_COMPLETION = STRUCT('CRYPT_ASYNC_RETRIEVAL_COMPLETION', {
 pfnCompletion: PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC,
 pvCompletion: LPVOID
});

var CRYPT_URL_ARRAY = STRUCT('CRYPT_URL_ARRAY', {
 cUrl: DWORD,
 rgwszUrl: PTR(PTR(ushort))
});

var CRYPT_URL_INFO = STRUCT('CRYPT_URL_INFO', {
 cbSize: DWORD,
 dwSyncDeltaTime: DWORD,
 cGroup: DWORD,
 rgcGroupEntry: PTR(ulong)
});

var CERT_CRL_CONTEXT_PAIR = STRUCT('CERT_CRL_CONTEXT_PAIR', {
 pCertContext: PCCERT_CONTEXT,
 pCrlContext: PCCRL_CONTEXT
});

var CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO = STRUCT('CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO', {
 cbSize: DWORD,
 iDeltaCrlIndicator: int,
 pftCacheResync: LPFILETIME,
 pLastSyncTime: LPFILETIME,
 pMaxAgeTime: LPFILETIME,
 pChainPara: PCERT_REVOCATION_CHAIN_PARA,
 pDeltaCrlIndicator: PCRYPT_INTEGER_BLOB
});

var CRYPTPROTECT_PROMPTSTRUCT = STRUCT('CRYPTPROTECT_PROMPTSTRUCT', {
 cbSize: DWORD,
 dwPromptFlags: DWORD,
 hwndApp: HWND,
 szPrompt: LPCWSTR
});

var CERT_CHAIN_ENGINE_CONFIG = STRUCT('CERT_CHAIN_ENGINE_CONFIG', {
 cbSize: DWORD,
 hRestrictedRoot: HCERTSTORE,
 hRestrictedTrust: HCERTSTORE,
 hRestrictedOther: HCERTSTORE,
 cAdditionalStore: DWORD,
 rghAdditionalStore: PTR(PTR('void')),
 dwFlags: DWORD,
 dwUrlRetrievalTimeout: DWORD,
 MaximumCachedCertificates: DWORD,
 CycleDetectionModulus: DWORD,
 hExclusiveRoot: HCERTSTORE,
 hExclusiveTrustedPeople: HCERTSTORE
});

var CERT_TRUST_STATUS = STRUCT('CERT_TRUST_STATUS', {
 dwErrorStatus: DWORD,
 dwInfoStatus: DWORD
});

var CERT_REVOCATION_INFO = STRUCT('CERT_REVOCATION_INFO', {
 cbSize: DWORD,
 dwRevocationResult: DWORD,
 pszRevocationOid: LPCSTR,
 pvOidSpecificInfo: LPVOID,
 fHasFreshnessTime: BOOL,
 dwFreshnessTime: DWORD,
 pCrlInfo: PCERT_REVOCATION_CRL_INFO
});

var CERT_TRUST_LIST_INFO = STRUCT('CERT_TRUST_LIST_INFO', {
 cbSize: DWORD,
 pCtlEntry: PCTL_ENTRY,
 pCtlContext: PCCTL_CONTEXT
});

var CERT_CHAIN_ELEMENT = STRUCT('CERT_CHAIN_ELEMENT', {
 cbSize: DWORD,
 pCertContext: PCCERT_CONTEXT,
 TrustStatus: CERT_TRUST_STATUS,
 pRevocationInfo: PCERT_REVOCATION_INFO,
 pIssuanceUsage: PCERT_ENHKEY_USAGE,
 pApplicationUsage: PCERT_ENHKEY_USAGE,
 pwszExtendedErrorInfo: LPCWSTR
});

var CERT_SIMPLE_CHAIN = STRUCT('CERT_SIMPLE_CHAIN', {
 cbSize: DWORD,
 TrustStatus: CERT_TRUST_STATUS,
 cElement: DWORD,
 rgpElement: PTR(pointer),
 pTrustListInfo: PCERT_TRUST_LIST_INFO,
 fHasRevocationFreshnessTime: BOOL,
 dwRevocationFreshnessTime: DWORD
});

var _CERT_CHAIN_CONTEXT = STRUCT('_CERT_CHAIN_CONTEXT', {
 cbSize: DWORD,
 TrustStatus: CERT_TRUST_STATUS,
 cChain: DWORD,
 rgpChain: PTR(pointer),
 cLowerQualityChainContext: DWORD,
 rgpLowerQualityChainContext: PTR(pointer),
 fHasRevocationFreshnessTime: BOOL,
 dwRevocationFreshnessTime: DWORD,
 dwCreateFlags: DWORD,
 ChainId: GUID
});

var CERT_USAGE_MATCH = STRUCT('CERT_USAGE_MATCH', {
 dwType: DWORD,
 Usage: CERT_ENHKEY_USAGE
});

var CTL_USAGE_MATCH = STRUCT('CTL_USAGE_MATCH', {
 dwType: DWORD,
 Usage: CTL_USAGE
});

var CERT_CHAIN_PARA = STRUCT('CERT_CHAIN_PARA', {
 cbSize: DWORD,
 RequestedUsage: CERT_USAGE_MATCH
});

var CRL_REVOCATION_INFO = STRUCT('CRL_REVOCATION_INFO', {
 pCrlEntry: PCRL_ENTRY,
 pCrlContext: PCCRL_CONTEXT,
 pCrlIssuerChain: PCCERT_CHAIN_CONTEXT
});

var CERT_CHAIN_FIND_BY_ISSUER_PARA = STRUCT('CERT_CHAIN_FIND_BY_ISSUER_PARA', {
 cbSize: DWORD,
 pszUsageIdentifier: LPCSTR,
 dwKeySpec: DWORD,
 dwAcquirePrivateKeyFlags: DWORD,
 cIssuer: DWORD,
 rgIssuer: PTR(uint),
 pfnFindCallback: PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
 pvFindArg: PTR('void')
});

var CERT_CHAIN_POLICY_PARA = STRUCT('CERT_CHAIN_POLICY_PARA', {
 cbSize: DWORD,
 dwFlags: DWORD,
 pvExtraPolicyPara: PTR('void')
});

var CERT_CHAIN_POLICY_STATUS = STRUCT('CERT_CHAIN_POLICY_STATUS', {
 cbSize: DWORD,
 dwError: DWORD,
 lChainIndex: LONG,
 lElementIndex: LONG,
 pvExtraPolicyStatus: PTR('void')
});

var AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA = STRUCT('AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA', {
 cbSize: DWORD,
 dwRegPolicySettings: DWORD,
 pSignerInfo: PCMSG_SIGNER_INFO
});

var AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS = STRUCT('AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS', {
 cbSize: DWORD,
 fCommercial: BOOL
});

var AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA = STRUCT('AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA', {
 cbSize: DWORD,
 dwRegPolicySettings: DWORD,
 fCommercial: BOOL
});

var SSL_EXTRA_CERT_CHAIN_POLICY_PARA = STRUCT('SSL_EXTRA_CERT_CHAIN_POLICY_PARA', {
 dwAuthType: DWORD,
 fdwChecks: DWORD,
 pwszServerName: PTR(ushort)
});

var EV_EXTRA_CERT_CHAIN_POLICY_PARA = STRUCT('EV_EXTRA_CERT_CHAIN_POLICY_PARA', {
 cbSize: DWORD,
 dwRootProgramQualifierFlags: DWORD
});

var EV_EXTRA_CERT_CHAIN_POLICY_STATUS = STRUCT('EV_EXTRA_CERT_CHAIN_POLICY_STATUS', {
 cbSize: DWORD,
 dwQualifiers: DWORD,
 dwIssuanceUsageIndex: DWORD
});

var CRYPT_PKCS12_PBE_PARAMS = STRUCT('CRYPT_PKCS12_PBE_PARAMS', {
 iIterations: int,
 cbSalt: ULONG
});

var _CERT_SERVER_OCSP_RESPONSE_CONTEXT = STRUCT('_CERT_SERVER_OCSP_RESPONSE_CONTEXT', {
 cbSize: DWORD,
 pbEncodedOcspResponse: PTR(uchar),
 cbEncodedOcspResponse: DWORD
});

var CERT_SELECT_CHAIN_PARA = STRUCT('CERT_SELECT_CHAIN_PARA', {
 hChainEngine: HCERTCHAINENGINE,
 pTime: PFILETIME,
 hAdditionalStore: HCERTSTORE,
 pChainPara: PCERT_CHAIN_PARA,
 dwFlags: DWORD
});

var CERT_SELECT_CRITERIA = STRUCT('CERT_SELECT_CRITERIA', {
 dwType: DWORD,
 cPara: DWORD,
 ppPara: PTR(PTR('void'))
});

var CRYPT_TIMESTAMP_REQUEST = STRUCT('CRYPT_TIMESTAMP_REQUEST', {
 dwVersion: DWORD,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 HashedMessage: CRYPT_DER_BLOB,
 pszTSAPolicyId: LPSTR,
 Nonce: CRYPT_INTEGER_BLOB,
 fCertReq: BOOL,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRYPT_TIMESTAMP_RESPONSE = STRUCT('CRYPT_TIMESTAMP_RESPONSE', {
 dwStatus: DWORD,
 cFreeText: DWORD,
 rgFreeText: PTR(PTR(ushort)),
 FailureInfo: CRYPT_BIT_BLOB,
 ContentInfo: CRYPT_DER_BLOB
});

var CRYPT_TIMESTAMP_ACCURACY = STRUCT('CRYPT_TIMESTAMP_ACCURACY', {
 dwSeconds: DWORD,
 dwMillis: DWORD,
 dwMicros: DWORD
});

var CRYPT_TIMESTAMP_INFO = STRUCT('CRYPT_TIMESTAMP_INFO', {
 dwVersion: DWORD,
 pszTSAPolicyId: LPSTR,
 HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
 HashedMessage: CRYPT_DER_BLOB,
 SerialNumber: CRYPT_INTEGER_BLOB,
 ftTime: FILETIME,
 pvAccuracy: PCRYPT_TIMESTAMP_ACCURACY,
 fOrdering: BOOL,
 Nonce: CRYPT_DER_BLOB,
 Tsa: CRYPT_DER_BLOB,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var CRYPT_TIMESTAMP_CONTEXT = STRUCT('CRYPT_TIMESTAMP_CONTEXT', {
 cbEncoded: DWORD,
 pbEncoded: PTR(uchar),
 pTimeStamp: PCRYPT_TIMESTAMP_INFO
});

var CRYPT_TIMESTAMP_PARA = STRUCT('CRYPT_TIMESTAMP_PARA', {
 pszTSAPolicyId: LPCSTR,
 fRequestCerts: BOOL,
 Nonce: CRYPT_INTEGER_BLOB,
 cExtension: DWORD,
 rgExtension: PCERT_EXTENSION
});

var EFS_CERTIFICATE_BLOB = STRUCT('EFS_CERTIFICATE_BLOB', {
 dwCertEncodingType: DWORD,
 cbData: DWORD,
 pbData: PBYTE
});

var EFS_HASH_BLOB = STRUCT('EFS_HASH_BLOB', {
 cbData: DWORD,
 pbData: PBYTE
});

var EFS_RPC_BLOB = STRUCT('EFS_RPC_BLOB', {
 cbData: DWORD,
 pbData: PBYTE
});

var EFS_PIN_BLOB = STRUCT('EFS_PIN_BLOB', {
 cbPadding: DWORD,
 cbData: DWORD,
 pbData: PBYTE
});

var EFS_KEY_INFO = STRUCT('EFS_KEY_INFO', {
 dwVersion: DWORD,
 Entropy: ULONG,
 Algorithm: ALG_ID,
 KeyLength: ULONG
});

var EFS_COMPATIBILITY_INFO = STRUCT('EFS_COMPATIBILITY_INFO', {
 EfsVersion: DWORD
});

var EFS_DECRYPTION_STATUS_INFO = STRUCT('EFS_DECRYPTION_STATUS_INFO', {
 dwDecryptionError: DWORD,
 dwHashOffset: DWORD,
 cbHash: DWORD
});

var EFS_ENCRYPTION_STATUS_INFO = STRUCT('EFS_ENCRYPTION_STATUS_INFO', {
 bHasCurrentKey: BOOL,
 dwEncryptionError: DWORD
});

var ENCRYPTION_CERTIFICATE = STRUCT('ENCRYPTION_CERTIFICATE', {
 cbTotalLength: DWORD,
 pUserSid: PTR(uint),
 pCertBlob: PEFS_CERTIFICATE_BLOB
});

var ENCRYPTION_CERTIFICATE_HASH = STRUCT('ENCRYPTION_CERTIFICATE_HASH', {
 cbTotalLength: DWORD,
 pUserSid: PTR(uint),
 pHash: PEFS_HASH_BLOB,
 lpDisplayInformation: LPWSTR
});

var ENCRYPTION_CERTIFICATE_HASH_LIST = STRUCT('ENCRYPTION_CERTIFICATE_HASH_LIST', {
 nCert_Hash: DWORD,
 pUsers: PTR(pointer)
});

var ENCRYPTION_CERTIFICATE_LIST = STRUCT('ENCRYPTION_CERTIFICATE_LIST', {
 nUsers: DWORD,
 pUsers: PTR(pointer)
});

var ENCRYPTED_FILE_METADATA_SIGNATURE = STRUCT('ENCRYPTED_FILE_METADATA_SIGNATURE', {
 dwEfsAccessType: DWORD,
 pCertificatesAdded: PENCRYPTION_CERTIFICATE_HASH_LIST,
 pEncryptionCertificate: PENCRYPTION_CERTIFICATE,
 pEfsStreamSignature: PEFS_RPC_BLOB
});

var RPC_IMPORT_CONTEXT_P = STRUCT('RPC_IMPORT_CONTEXT_P', {
 LookupContext: RPC_NS_HANDLE,
 ProposedHandle: RPC_BINDING_HANDLE,
 Bindings: PTR(uint)
});

var undefined = STRUCT('undefined', {
 pad: pointer,
 userContext: PTR('void')
});

var SCONTEXT_QUEUE = STRUCT('SCONTEXT_QUEUE', {
 NumberOfObjects: ulong,
 ArrayOfObjects: PTR(pointer)
});

var MIDL_STUB_MESSAGE = STRUCT('MIDL_STUB_MESSAGE', {
 RpcMsg: PRPC_MESSAGE,
 Buffer: PTR(uchar),
 BufferStart: PTR(uchar),
 BufferEnd: PTR(uchar),
 BufferMark: PTR(uchar),
 BufferLength: ulong,
 MemorySize: ulong,
 Memory: PTR(uchar),
 IsClient: uchar,
 Pad: uchar,
 uFlags2: ushort,
 ReuseBuffer: int,
 pAllocAllNodesContext: PTR(NDR_ALLOC_ALL_NODES_CONTEXT),
 pPointerQueueState: PTR(NDR_POINTER_QUEUE_STATE),
 IgnoreEmbeddedPointers: int,
 PointerBufferMark: PTR(uchar),
 CorrDespIncrement: uchar,
 uFlags: uchar,
 UniquePtrCount: ushort,
 MaxCount: ULONG_PTR,
 Offset: ulong,
 ActualCount: ulong,
 pfnAllocate: PTR(pointer),
 pfnFree: PTR(pointer),
 StackTop: PTR(uchar),
 pPresentedType: PTR(uchar),
 pTransmitType: PTR(uchar),
 SavedHandle: handle_t,
 StubDesc: PTR(_MIDL_STUB_DESC),
 FullPtrXlatTables: PTR(_FULL_PTR_XLAT_TABLES),
 FullPtrRefId: ulong,
 PointerLength: ulong,
 fInDontFree: int,
 fDontCallFreeInst: int,
 fInOnlyParam: int,
 fHasReturn: int,
 fHasExtensions: int,
 fHasNewCorrDesc: int,
 fIsIn: int,
 fIsOut: int,
 fIsOicf: int,
 fBufferValid: int,
 fHasMemoryValidateCallback: int,
 fInFree: int,
 fNeedMCCP: int,
 fUnused: int,
 fUnused2: int,
 dwDestContext: ulong,
 pvDestContext: PTR('void'),
 SavedContextHandles: PTR(pointer),
 ParamNumber: long,
 pRpcChannelBuffer: PTR(IRpcChannelBuffer),
 pArrayInfo: PARRAY_INFO,
 SizePtrCountArray: PTR(ulong),
 SizePtrOffsetArray: PTR(ulong),
 SizePtrLengthArray: PTR(ulong),
 pArgQueue: PTR('void'),
 dwStubPhase: ulong,
 LowStackMark: PTR('void'),
 pAsyncMsg: PNDR_ASYNC_MESSAGE,
 pCorrInfo: PNDR_CORRELATION_INFO,
 pCorrMemory: PTR(uchar),
 pMemoryList: PTR('void'),
 pCSInfo: INT_PTR,
 ConformanceMark: PTR(uchar),
 VarianceMark: PTR(uchar),
 Unused: INT_PTR,
 pContext: PTR(_NDR_PROC_CONTEXT),
 ContextHandleHash: PTR('void'),
 pUserMarshalList: PTR('void'),
 Reserved51_3: INT_PTR,
 Reserved51_4: INT_PTR,
 Reserved51_5: INT_PTR
});

var MIDL_STUB_DESC = STRUCT('MIDL_STUB_DESC', {
 RpcInterfaceInformation: PTR('void'),
 pfnAllocate: PTR(pointer),
 pfnFree: PTR(pointer),
 IMPLICIT_HANDLE_INFO: ,
 apfnNdrRundownRoutines: PTR(NDR_RUNDOWN),
 aGenericBindingRoutinePairs: PTR(uint),
 apfnExprEval: PTR(EXPR_EVAL),
 aXmitQuintuple: PTR(uint),
 pFormatTypes: PTR(uchar),
 fCheckBounds: int,
 Version: ulong,
 pMallocFreeStruct: PTR(uint),
 MIDLVersion: long,
 CommFaultOffsets: PTR(uint),
 aUserMarshalQuadruple: PTR(uint),
 NotifyRoutineTable: PTR(NDR_NOTIFY_ROUTINE),
 mFlags: ULONG_PTR,
 CsRoutineTables: PTR(uint),
 ProxyServerInfo: PTR('void'),
 pExprInfo: PTR(uint)
});

var FULL_PTR_XLAT_TABLES = STRUCT('FULL_PTR_XLAT_TABLES', {
 RefIdToPointer: PTR('void'),
 PointerToRefId: PTR('void'),
 NextRefId: ulong,
 XlatSide: XLAT_SIDE
});

var ARRAY_INFO = STRUCT('ARRAY_INFO', {
 Dimension: long,
 BufferConformanceMark: PTR(ulong),
 BufferVarianceMark: PTR(ulong),
 MaxCountArray: PTR(ulong),
 OffsetArray: PTR(ulong),
 ActualCountArray: PTR(ulong)
});



var MIDL_SYNTAX_INFO = STRUCT('MIDL_SYNTAX_INFO', {
 TransferSyntax: RPC_SYNTAX_IDENTIFIER,
 DispatchTable: PTR(uint),
 ProcString: PFORMAT_STRING,
 FmtStringOffset: PTR(ushort),
 TypeString: PFORMAT_STRING,
 aUserMarshalQuadruple: PTR('void'),
 pReserved1: ULONG_PTR,
 pReserved2: ULONG_PTR
});




var IRpcChannelBuffer = STRUCT('IRpcChannelBuffer', {
 lpVtbl: PTR(IRpcChannelBufferVtbl)
});

var GENERIC_BINDING_ROUTINE_PAIR = STRUCT('GENERIC_BINDING_ROUTINE_PAIR', {
 pfnBind: GENERIC_BINDING_ROUTINE,
 pfnUnbind: GENERIC_UNBIND_ROUTINE
});

var GENERIC_BINDING_INFO = STRUCT('GENERIC_BINDING_INFO', {
 pObj: PTR('void'),
 Size: uint,
 pfnBind: GENERIC_BINDING_ROUTINE,
 pfnUnbind: GENERIC_UNBIND_ROUTINE
});

var XMIT_ROUTINE_QUINTUPLE = STRUCT('XMIT_ROUTINE_QUINTUPLE', {
 pfnTranslateToXmit: XMIT_HELPER_ROUTINE,
 pfnTranslateFromXmit: XMIT_HELPER_ROUTINE,
 pfnFreeXmit: XMIT_HELPER_ROUTINE,
 pfnFreeInst: XMIT_HELPER_ROUTINE
});

var USER_MARSHAL_ROUTINE_QUADRUPLE = STRUCT('USER_MARSHAL_ROUTINE_QUADRUPLE', {
 pfnBufferSize: USER_MARSHAL_SIZING_ROUTINE,
 pfnMarshall: USER_MARSHAL_MARSHALLING_ROUTINE,
 pfnUnmarshall: USER_MARSHAL_UNMARSHALLING_ROUTINE,
 pfnFree: USER_MARSHAL_FREEING_ROUTINE
});

var USER_MARSHAL_CB = STRUCT('USER_MARSHAL_CB', {
 Flags: ulong,
 pStubMsg: PMIDL_STUB_MESSAGE,
 pReserve: PFORMAT_STRING,
 Signature: ulong,
 CBType: USER_MARSHAL_CB_TYPE,
 pFormat: PFORMAT_STRING,
 pTypeFormat: PFORMAT_STRING
});

var MALLOC_FREE_STRUCT = STRUCT('MALLOC_FREE_STRUCT', {
 pfnAllocate: PTR(pointer),
 pfnFree: PTR(pointer)
});

var COMM_FAULT_OFFSETS = STRUCT('COMM_FAULT_OFFSETS', {
 CommOffset: short,
 FaultOffset: short
});

var NDR_CS_SIZE_CONVERT_ROUTINES = STRUCT('NDR_CS_SIZE_CONVERT_ROUTINES', {
 pfnNetSize: CS_TYPE_NET_SIZE_ROUTINE,
 pfnToNetCs: CS_TYPE_TO_NETCS_ROUTINE,
 pfnLocalSize: CS_TYPE_LOCAL_SIZE_ROUTINE,
 pfnFromNetCs: CS_TYPE_FROM_NETCS_ROUTINE
});

var NDR_CS_ROUTINES = STRUCT('NDR_CS_ROUTINES', {
 pSizeConvertRoutines: PTR(uint),
 pTagGettingRoutines: PTR(CS_TAG_GETTING_ROUTINE)
});

var NDR_EXPR_DESC = STRUCT('NDR_EXPR_DESC', {
 pOffset: PTR(ushort),
 pFormatExpr: PFORMAT_STRING
});

var MIDL_FORMAT_STRING = STRUCT('MIDL_FORMAT_STRING', {
 Pad: short,
 Format: pointer
});

var MIDL_SERVER_INFO = STRUCT('MIDL_SERVER_INFO', {
 pStubDesc: PMIDL_STUB_DESC,
 DispatchTable: PTR(pointer),
 ProcString: PFORMAT_STRING,
 FmtStringOffset: PTR(ushort),
 ThunkTable: PTR(STUB_THUNK),
 pTransferSyntax: PRPC_SYNTAX_IDENTIFIER,
 nCount: ULONG_PTR,
 pSyntaxInfo: PMIDL_SYNTAX_INFO
});

var MIDL_STUBLESS_PROXY_INFO = STRUCT('MIDL_STUBLESS_PROXY_INFO', {
 pStubDesc: PMIDL_STUB_DESC,
 ProcFormatString: PFORMAT_STRING,
 FormatStringOffset: PTR(ushort),
 pTransferSyntax: PRPC_SYNTAX_IDENTIFIER,
 nCount: ULONG_PTR,
 pSyntaxInfo: PMIDL_SYNTAX_INFO
});

var IRpcStubBuffer = STRUCT('IRpcStubBuffer', {
 lpVtbl: PTR(IRpcStubBufferVtbl)
});

var NDR_USER_MARSHAL_INFO_LEVEL1 = STRUCT('NDR_USER_MARSHAL_INFO_LEVEL1', {
 Buffer: PTR('void'),
 BufferSize: ulong,
 pfnAllocate: PTR(pointer),
 pfnFree: PTR(pointer),
 pRpcChannelBuffer: PTR(IRpcChannelBuffer),
 Reserved: pointer
});

var NDR_USER_MARSHAL_INFO = STRUCT('NDR_USER_MARSHAL_INFO', {
 InformationLevel: ulong
});

var RemHGLOBAL = STRUCT('RemHGLOBAL', {
 fNullHGlobal: long,
 cbData: ulong,
 data: pointer
});

var RemHMETAFILEPICT = STRUCT('RemHMETAFILEPICT', {
 mm: long,
 xExt: long,
 yExt: long,
 cbData: ulong,
 data: pointer
});

var RemHENHMETAFILE = STRUCT('RemHENHMETAFILE', {
 cbData: ulong,
 data: pointer
});

var RemHBITMAP = STRUCT('RemHBITMAP', {
 cbData: ulong,
 data: pointer
});

var RemHPALETTE = STRUCT('RemHPALETTE', {
 cbData: ulong,
 data: pointer
});

var RemHBRUSH = STRUCT('RemHBRUSH', {
 cbData: ulong,
 data: pointer
});

var COAUTHIDENTITY = STRUCT('COAUTHIDENTITY', {
 User: PTR(ushort),
 UserLength: ULONG,
 Domain: PTR(ushort),
 DomainLength: ULONG,
 Password: PTR(ushort),
 PasswordLength: ULONG,
 Flags: ULONG
});

var COAUTHINFO = STRUCT('COAUTHINFO', {
 dwAuthnSvc: DWORD,
 dwAuthzSvc: DWORD,
 pwszServerPrincName: LPWSTR,
 dwAuthnLevel: DWORD,
 dwImpersonationLevel: DWORD,
 pAuthIdentityData: PTR(uint),
 dwCapabilities: DWORD
});

var BYTE_BLOB = STRUCT('BYTE_BLOB', {
 clSize: ulong,
 abData: pointer
});

var WORD_BLOB = STRUCT('WORD_BLOB', {
 clSize: ulong,
 asData: pointer
});

var DWORD_BLOB = STRUCT('DWORD_BLOB', {
 clSize: ulong,
 alData: pointer
});

var FLAGGED_BYTE_BLOB = STRUCT('FLAGGED_BYTE_BLOB', {
 fFlags: ulong,
 clSize: ulong,
 abData: pointer
});

var FLAGGED_WORD_BLOB = STRUCT('FLAGGED_WORD_BLOB', {
 fFlags: ulong,
 clSize: ulong,
 asData: pointer
});

var BYTE_SIZEDARR = STRUCT('BYTE_SIZEDARR', {
 clSize: ulong,
 pData: PTR(uchar)
});

var WORD_SIZEDARR = STRUCT('WORD_SIZEDARR', {
 clSize: ulong,
 pData: PTR(ushort)
});

var DWORD_SIZEDARR = STRUCT('DWORD_SIZEDARR', {
 clSize: ulong,
 pData: PTR(ulong)
});

var HYPER_SIZEDARR = STRUCT('HYPER_SIZEDARR', {
 clSize: ulong,
 pData: PTR(longlong)
});

var userCLIPFORMAT = STRUCT('userCLIPFORMAT', {
 fContext: long,
 u: __MIDL_IWinTypes_0001
});

var GDI_NONREMOTE = STRUCT('GDI_NONREMOTE', {
 fContext: long,
 u: __MIDL_IWinTypes_0002
});

var userHGLOBAL = STRUCT('userHGLOBAL', {
 fContext: long,
 u: __MIDL_IWinTypes_0003
});

var userHMETAFILE = STRUCT('userHMETAFILE', {
 fContext: long,
 u: __MIDL_IWinTypes_0004
});

var remoteMETAFILEPICT = STRUCT('remoteMETAFILEPICT', {
 mm: long,
 xExt: long,
 yExt: long,
 hMF: PTR(uint)
});

var userHMETAFILEPICT = STRUCT('userHMETAFILEPICT', {
 fContext: long,
 u: __MIDL_IWinTypes_0005
});

var userHENHMETAFILE = STRUCT('userHENHMETAFILE', {
 fContext: long,
 u: __MIDL_IWinTypes_0006
});

var userBITMAP = STRUCT('userBITMAP', {
 bmType: LONG,
 bmWidth: LONG,
 bmHeight: LONG,
 bmWidthBytes: LONG,
 bmPlanes: WORD,
 bmBitsPixel: WORD,
 cbSize: ULONG,
 pBuffer: pointer
});

var userHBITMAP = STRUCT('userHBITMAP', {
 fContext: long,
 u: __MIDL_IWinTypes_0007
});

var userHPALETTE = STRUCT('userHPALETTE', {
 fContext: long,
 u: __MIDL_IWinTypes_0008
});

var RemotableHandle = STRUCT('RemotableHandle', {
 fContext: long,
 u: __MIDL_IWinTypes_0009
});

var undefined = STRUCT('undefined', {
 Lo: ulong,
 Hi: long
});

var DECIMAL = STRUCT('DECIMAL', {
 wReserved: USHORT,
 Hi32: ULONG
});

var undefined = STRUCT('undefined', {
 scale: BYTE,
 sign: BYTE
});

var undefined = STRUCT('undefined', {
 Lo32: ULONG,
 Mid32: ULONG
});

var BSTRBLOB = STRUCT('BSTRBLOB', {
 cbSize: ULONG,
 pData: PTR(uchar)
});

var BLOB = STRUCT('BLOB', {
 cbSize: ULONG,
 pBlobData: PTR(uchar)
});

var CLIPDATA = STRUCT('CLIPDATA', {
 cbSize: ULONG,
 ulClipFmt: long,
 pClipData: PTR(uchar)
});

var PROPERTYKEY = STRUCT('PROPERTYKEY', {
 fmtid: GUID,
 pid: DWORD
});

var CSPLATFORM = STRUCT('CSPLATFORM', {
 dwPlatformId: DWORD,
 dwVersionHi: DWORD,
 dwVersionLo: DWORD,
 dwProcessorArch: DWORD
});

var QUERYCONTEXT = STRUCT('QUERYCONTEXT', {
 dwContext: DWORD,
 Platform: CSPLATFORM,
 Locale: LCID,
 dwVersionHi: DWORD,
 dwVersionLo: DWORD
});

var uCLSSPEC = STRUCT('uCLSSPEC', {
 tyspec: DWORD,
 tagged_union: __MIDL___MIDL_itf_wtypes_0000_0001_0005
});

var undefined = STRUCT('undefined', {
 pPackageName: LPOLESTR,
 PolicyId: GUID
});

var undefined = STRUCT('undefined', {
 ObjectId: GUID,
 PolicyId: GUID
});

var STORAGE_HOTPLUG_INFO = STRUCT('STORAGE_HOTPLUG_INFO', {
 Size: DWORD,
 MediaRemovable: BOOLEAN,
 MediaHotplug: BOOLEAN,
 DeviceHotplug: BOOLEAN,
 WriteCacheEnableOverride: BOOLEAN
});

var STORAGE_DEVICE_NUMBER = STRUCT('STORAGE_DEVICE_NUMBER', {
 DeviceType: DWORD,
 DeviceNumber: DWORD,
 PartitionNumber: DWORD
});

var STORAGE_BUS_RESET_REQUEST = STRUCT('STORAGE_BUS_RESET_REQUEST', {
 PathId: BYTE
});

var STORAGE_BREAK_RESERVATION_REQUEST = STRUCT('STORAGE_BREAK_RESERVATION_REQUEST', {
 Length: DWORD,
 _unused: BYTE,
 PathId: BYTE,
 TargetId: BYTE,
 Lun: BYTE
});

var PREVENT_MEDIA_REMOVAL = STRUCT('PREVENT_MEDIA_REMOVAL', {
 PreventMediaRemoval: BOOLEAN
});

var CLASS_MEDIA_CHANGE_CONTEXT = STRUCT('CLASS_MEDIA_CHANGE_CONTEXT', {
 MediaChangeCount: DWORD,
 NewState: DWORD
});

var TAPE_STATISTICS = STRUCT('TAPE_STATISTICS', {
 Version: DWORD,
 Flags: DWORD,
 RecoveredWrites: LARGE_INTEGER,
 UnrecoveredWrites: LARGE_INTEGER,
 RecoveredReads: LARGE_INTEGER,
 UnrecoveredReads: LARGE_INTEGER,
 CompressionRatioReads: BYTE,
 CompressionRatioWrites: BYTE
});

var TAPE_GET_STATISTICS = STRUCT('TAPE_GET_STATISTICS', {
 Operation: DWORD
});

var DEVICE_MEDIA_INFO = STRUCT('DEVICE_MEDIA_INFO', {
 DeviceSpecific: 
});

var undefined = STRUCT('undefined', {
 Cylinders: LARGE_INTEGER,
 MediaType: STORAGE_MEDIA_TYPE,
 TracksPerCylinder: DWORD,
 SectorsPerTrack: DWORD,
 BytesPerSector: DWORD,
 NumberMediaSides: DWORD,
 MediaCharacteristics: DWORD
});

var undefined = STRUCT('undefined', {
 Cylinders: LARGE_INTEGER,
 MediaType: STORAGE_MEDIA_TYPE,
 TracksPerCylinder: DWORD,
 SectorsPerTrack: DWORD,
 BytesPerSector: DWORD,
 NumberMediaSides: DWORD,
 MediaCharacteristics: DWORD
});

var undefined = STRUCT('undefined', {
 MediaType: STORAGE_MEDIA_TYPE,
 MediaCharacteristics: DWORD,
 CurrentBlockSize: DWORD,
 BusType: STORAGE_BUS_TYPE,
 BusSpecificData: 
});

var undefined = STRUCT('undefined', {
 MediumType: BYTE,
 DensityCode: BYTE
});

var GET_MEDIA_TYPES = STRUCT('GET_MEDIA_TYPES', {
 DeviceType: DWORD,
 MediaInfoCount: DWORD,
 MediaInfo: pointer
});

var STORAGE_PREDICT_FAILURE = STRUCT('STORAGE_PREDICT_FAILURE', {
 PredictFailure: DWORD,
 VendorSpecific: pointer
});

var STORAGE_PROPERTY_QUERY = STRUCT('STORAGE_PROPERTY_QUERY', {
 PropertyId: STORAGE_PROPERTY_ID,
 QueryType: STORAGE_QUERY_TYPE,
 AdditionalParameters: pointer
});

var STORAGE_DESCRIPTOR_HEADER = STRUCT('STORAGE_DESCRIPTOR_HEADER', {
 Version: DWORD,
 Size: DWORD
});

var STORAGE_DEVICE_DESCRIPTOR = STRUCT('STORAGE_DEVICE_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 DeviceType: BYTE,
 DeviceTypeModifier: BYTE,
 RemovableMedia: BOOLEAN,
 CommandQueueing: BOOLEAN,
 VendorIdOffset: DWORD,
 ProductIdOffset: DWORD,
 ProductRevisionOffset: DWORD,
 SerialNumberOffset: DWORD,
 BusType: STORAGE_BUS_TYPE,
 RawPropertiesLength: DWORD,
 RawDeviceProperties: pointer
});

var STORAGE_ADAPTER_DESCRIPTOR = STRUCT('STORAGE_ADAPTER_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 MaximumTransferLength: DWORD,
 MaximumPhysicalPages: DWORD,
 AlignmentMask: DWORD,
 AdapterUsesPio: BOOLEAN,
 AdapterScansDown: BOOLEAN,
 CommandQueueing: BOOLEAN,
 AcceleratedTransfer: BOOLEAN,
 BusType: BYTE,
 BusMajorVersion: WORD,
 BusMinorVersion: WORD
});

var STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR = STRUCT('STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 BytesPerCacheLine: DWORD,
 BytesOffsetForCacheAlignment: DWORD,
 BytesPerLogicalSector: DWORD,
 BytesPerPhysicalSector: DWORD,
 BytesOffsetForSectorAlignment: DWORD
});

var STORAGE_MINIPORT_DESCRIPTOR = STRUCT('STORAGE_MINIPORT_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 Portdriver: STORAGE_PORT_CODE_SET,
 LUNResetSupported: BOOLEAN,
 TargetResetSupported: BOOLEAN
});

var STORAGE_IDENTIFIER = STRUCT('STORAGE_IDENTIFIER', {
 CodeSet: STORAGE_IDENTIFIER_CODE_SET,
 Type: STORAGE_IDENTIFIER_TYPE,
 IdentifierSize: WORD,
 NextOffset: WORD,
 Association: STORAGE_ASSOCIATION_TYPE,
 Identifier: pointer
});

var STORAGE_DEVICE_ID_DESCRIPTOR = STRUCT('STORAGE_DEVICE_ID_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 NumberOfIdentifiers: DWORD,
 Identifiers: pointer
});

var DEVICE_SEEK_PENALTY_DESCRIPTOR = STRUCT('DEVICE_SEEK_PENALTY_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 IncursSeekPenalty: BOOLEAN
});

var DEVICE_WRITE_AGGREGATION_DESCRIPTOR = STRUCT('DEVICE_WRITE_AGGREGATION_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 BenefitsFromWriteAggregation: BOOLEAN
});

var DEVICE_TRIM_DESCRIPTOR = STRUCT('DEVICE_TRIM_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 TrimEnabled: BOOLEAN
});

var DEVICE_DATA_SET_RANGE = STRUCT('DEVICE_DATA_SET_RANGE', {
 StartingOffset: LONGLONG,
 LengthInBytes: DWORDLONG
});

var DEVICE_MANAGE_DATA_SET_ATTRIBUTES = STRUCT('DEVICE_MANAGE_DATA_SET_ATTRIBUTES', {
 Size: DWORD,
 Action: DEVICE_DATA_MANAGEMENT_SET_ACTION,
 Flags: DWORD,
 ParameterBlockOffset: DWORD,
 ParameterBlockLength: DWORD,
 DataSetRangesOffset: DWORD,
 DataSetRangesLength: DWORD
});

var DEVICE_DSM_NOTIFICATION_PARAMETERS = STRUCT('DEVICE_DSM_NOTIFICATION_PARAMETERS', {
 Size: DWORD,
 Flags: DWORD,
 NumFileTypeIDs: DWORD,
 FileTypeID: pointer
});

var STORAGE_GET_BC_PROPERTIES_OUTPUT = STRUCT('STORAGE_GET_BC_PROPERTIES_OUTPUT', {
 MaximumRequestsPerPeriod: DWORD,
 MinimumPeriod: DWORD,
 MaximumRequestSize: DWORDLONG,
 EstimatedTimePerRequest: DWORD,
 NumOutStandingRequests: DWORD,
 RequestSize: DWORDLONG
});

var STORAGE_ALLOCATE_BC_STREAM_INPUT = STRUCT('STORAGE_ALLOCATE_BC_STREAM_INPUT', {
 Version: DWORD,
 RequestsPerPeriod: DWORD,
 Period: DWORD,
 RetryFailures: BOOLEAN,
 Discardable: BOOLEAN,
 Reserved1: pointer,
 AccessType: DWORD,
 AccessMode: DWORD
});

var STORAGE_ALLOCATE_BC_STREAM_OUTPUT = STRUCT('STORAGE_ALLOCATE_BC_STREAM_OUTPUT', {
 RequestSize: DWORDLONG,
 NumOutStandingRequests: DWORD
});

var STORAGE_PRIORITY_HINT_SUPPORT = STRUCT('STORAGE_PRIORITY_HINT_SUPPORT', {
 SupportFlags: DWORD
});

var STORAGE_MEDIA_SERIAL_NUMBER_DATA = STRUCT('STORAGE_MEDIA_SERIAL_NUMBER_DATA', {
 Reserved: WORD,
 SerialNumberLength: WORD,
 SerialNumber: pointer
});

var STORAGE_READ_CAPACITY = STRUCT('STORAGE_READ_CAPACITY', {
 Version: DWORD,
 Size: DWORD,
 BlockLength: DWORD,
 NumberOfBlocks: LARGE_INTEGER,
 DiskLength: LARGE_INTEGER
});

var STORAGE_WRITE_CACHE_PROPERTY = STRUCT('STORAGE_WRITE_CACHE_PROPERTY', {
 Version: DWORD,
 Size: DWORD,
 WriteCacheType: WRITE_CACHE_TYPE,
 WriteCacheEnabled: WRITE_CACHE_ENABLE,
 WriteCacheChangeable: WRITE_CACHE_CHANGE,
 WriteThroughSupported: WRITE_THROUGH,
 FlushCacheSupported: BOOLEAN,
 UserDefinedPowerProtection: BOOLEAN,
 NVCacheEnabled: BOOLEAN
});

var PERSISTENT_RESERVE_COMMAND = STRUCT('PERSISTENT_RESERVE_COMMAND', {
 Version: DWORD,
 Size: DWORD
});

var undefined = STRUCT('undefined', {
 ServiceAction: BYTE,
 Reserved1: BYTE,
 AllocationLength: WORD
});

var undefined = STRUCT('undefined', {
 ServiceAction: BYTE,
 Reserved1: BYTE,
 Type: BYTE,
 Scope: BYTE,
 ParameterList: pointer
});

var FORMAT_PARAMETERS = STRUCT('FORMAT_PARAMETERS', {
 MediaType: MEDIA_TYPE,
 StartCylinderNumber: DWORD,
 EndCylinderNumber: DWORD,
 StartHeadNumber: DWORD,
 EndHeadNumber: DWORD
});

var FORMAT_EX_PARAMETERS = STRUCT('FORMAT_EX_PARAMETERS', {
 MediaType: MEDIA_TYPE,
 StartCylinderNumber: DWORD,
 EndCylinderNumber: DWORD,
 StartHeadNumber: DWORD,
 EndHeadNumber: DWORD,
 FormatGapLength: WORD,
 SectorsPerTrack: WORD,
 SectorNumber: pointer
});

var DISK_GEOMETRY = STRUCT('DISK_GEOMETRY', {
 Cylinders: LARGE_INTEGER,
 MediaType: MEDIA_TYPE,
 TracksPerCylinder: DWORD,
 SectorsPerTrack: DWORD,
 BytesPerSector: DWORD
});

var PARTITION_INFORMATION = STRUCT('PARTITION_INFORMATION', {
 StartingOffset: LARGE_INTEGER,
 PartitionLength: LARGE_INTEGER,
 HiddenSectors: DWORD,
 PartitionNumber: DWORD,
 PartitionType: BYTE,
 BootIndicator: BOOLEAN,
 RecognizedPartition: BOOLEAN,
 RewritePartition: BOOLEAN
});

var SET_PARTITION_INFORMATION_MBR = STRUCT('SET_PARTITION_INFORMATION_MBR', {
 PartitionType: BYTE
});

var DRIVE_LAYOUT_INFORMATION = STRUCT('DRIVE_LAYOUT_INFORMATION', {
 PartitionCount: DWORD,
 Signature: DWORD,
 PartitionEntry: pointer
});

var VERIFY_INFORMATION = STRUCT('VERIFY_INFORMATION', {
 StartingOffset: LARGE_INTEGER,
 Length: DWORD
});

var REASSIGN_BLOCKS = STRUCT('REASSIGN_BLOCKS', {
 Reserved: WORD,
 Count: WORD,
 BlockNumber: pointer
});

var REASSIGN_BLOCKS_EX = STRUCT('REASSIGN_BLOCKS_EX', {
 Reserved: WORD,
 Count: WORD,
 BlockNumber: pointer
});

var SET_PARTITION_INFORMATION_GPT = STRUCT('SET_PARTITION_INFORMATION_GPT', {
 PartitionType: GUID,
 PartitionId: GUID,
 Attributes: DWORD64,
 Name: pointer
});

var PARTITION_INFORMATION_MBR = STRUCT('PARTITION_INFORMATION_MBR', {
 PartitionType: BYTE,
 BootIndicator: BOOLEAN,
 RecognizedPartition: BOOLEAN,
 HiddenSectors: DWORD
});

var SET_PARTITION_INFORMATION_EX = STRUCT('SET_PARTITION_INFORMATION_EX', {
 PartitionStyle: PARTITION_STYLE
});

var CREATE_DISK_GPT = STRUCT('CREATE_DISK_GPT', {
 DiskId: GUID,
 MaxPartitionCount: DWORD
});

var CREATE_DISK_MBR = STRUCT('CREATE_DISK_MBR', {
 Signature: DWORD
});

var CREATE_DISK = STRUCT('CREATE_DISK', {
 PartitionStyle: PARTITION_STYLE
});

var GET_LENGTH_INFORMATION = STRUCT('GET_LENGTH_INFORMATION', {
 Length: LARGE_INTEGER
});

var PARTITION_INFORMATION_EX = STRUCT('PARTITION_INFORMATION_EX', {
 PartitionStyle: PARTITION_STYLE,
 StartingOffset: LARGE_INTEGER,
 PartitionLength: LARGE_INTEGER,
 PartitionNumber: DWORD,
 RewritePartition: BOOLEAN
});

var DRIVE_LAYOUT_INFORMATION_GPT = STRUCT('DRIVE_LAYOUT_INFORMATION_GPT', {
 DiskId: GUID,
 StartingUsableOffset: LARGE_INTEGER,
 UsableLength: LARGE_INTEGER,
 MaxPartitionCount: DWORD
});

var DRIVE_LAYOUT_INFORMATION_MBR = STRUCT('DRIVE_LAYOUT_INFORMATION_MBR', {
 Signature: DWORD
});

var DRIVE_LAYOUT_INFORMATION_EX = STRUCT('DRIVE_LAYOUT_INFORMATION_EX', {
 PartitionStyle: DWORD,
 PartitionCount: DWORD,
 PartitionEntry: pointer
});

var DISK_INT13_INFO = STRUCT('DISK_INT13_INFO', {
 DriveSelect: WORD,
 MaxCylinders: DWORD,
 SectorsPerTrack: WORD,
 MaxHeads: WORD,
 NumberDrives: WORD
});

var DISK_EX_INT13_INFO = STRUCT('DISK_EX_INT13_INFO', {
 ExBufferSize: WORD,
 ExFlags: WORD,
 ExCylinders: DWORD,
 ExHeads: DWORD,
 ExSectorsPerTrack: DWORD,
 ExSectorsPerDrive: DWORD64,
 ExSectorSize: WORD,
 ExReserved: WORD
});

var DISK_DETECTION_INFO = STRUCT('DISK_DETECTION_INFO', {
 SizeOfDetectInfo: DWORD,
 DetectionType: DETECTION_TYPE
});

var undefined = STRUCT('undefined', {
 Int13: DISK_INT13_INFO,
 ExInt13: DISK_EX_INT13_INFO
});

var DISK_PARTITION_INFO = STRUCT('DISK_PARTITION_INFO', {
 SizeOfPartitionInfo: DWORD,
 PartitionStyle: PARTITION_STYLE
});

var undefined = STRUCT('undefined', {
 Signature: DWORD,
 CheckSum: DWORD
});

var undefined = STRUCT('undefined', {
 DiskId: GUID
});

var DISK_GEOMETRY_EX = STRUCT('DISK_GEOMETRY_EX', {
 Geometry: DISK_GEOMETRY,
 DiskSize: LARGE_INTEGER,
 Data: pointer
});

var DISK_CONTROLLER_NUMBER = STRUCT('DISK_CONTROLLER_NUMBER', {
 ControllerNumber: DWORD,
 DiskNumber: DWORD
});

var DISK_CACHE_INFORMATION = STRUCT('DISK_CACHE_INFORMATION', {
 ParametersSavable: BOOLEAN,
 ReadCacheEnabled: BOOLEAN,
 WriteCacheEnabled: BOOLEAN,
 ReadRetentionPriority: DISK_CACHE_RETENTION_PRIORITY,
 WriteRetentionPriority: DISK_CACHE_RETENTION_PRIORITY,
 DisablePrefetchTransferLength: WORD,
 PrefetchScalar: BOOLEAN
});

var undefined = STRUCT('undefined', {
 Minimum: WORD,
 Maximum: WORD,
 MaximumBlocks: WORD
});

var undefined = STRUCT('undefined', {
 Minimum: WORD,
 Maximum: WORD
});

var DISK_GROW_PARTITION = STRUCT('DISK_GROW_PARTITION', {
 PartitionNumber: DWORD,
 BytesToGrow: LARGE_INTEGER
});

var HISTOGRAM_BUCKET = STRUCT('HISTOGRAM_BUCKET', {
 Reads: DWORD,
 Writes: DWORD
});

var DISK_HISTOGRAM = STRUCT('DISK_HISTOGRAM', {
 DiskSize: LARGE_INTEGER,
 Start: LARGE_INTEGER,
 End: LARGE_INTEGER,
 Average: LARGE_INTEGER,
 AverageRead: LARGE_INTEGER,
 AverageWrite: LARGE_INTEGER,
 Granularity: DWORD,
 Size: DWORD,
 ReadCount: DWORD,
 WriteCount: DWORD,
 Histogram: PHISTOGRAM_BUCKET
});

var DISK_PERFORMANCE = STRUCT('DISK_PERFORMANCE', {
 BytesRead: LARGE_INTEGER,
 BytesWritten: LARGE_INTEGER,
 ReadTime: LARGE_INTEGER,
 WriteTime: LARGE_INTEGER,
 IdleTime: LARGE_INTEGER,
 ReadCount: DWORD,
 WriteCount: DWORD,
 QueueDepth: DWORD,
 SplitCount: DWORD,
 QueryTime: LARGE_INTEGER,
 StorageDeviceNumber: DWORD,
 StorageManagerName: pointer
});

var DISK_RECORD = STRUCT('DISK_RECORD', {
 ByteOffset: LARGE_INTEGER,
 StartTime: LARGE_INTEGER,
 EndTime: LARGE_INTEGER,
 VirtualAddress: PVOID,
 NumberOfBytes: DWORD,
 DeviceNumber: BYTE,
 ReadRequest: BOOLEAN
});

var DISK_LOGGING = STRUCT('DISK_LOGGING', {
 Function: BYTE,
 BufferAddress: PVOID,
 BufferSize: DWORD
});

var BIN_RANGE = STRUCT('BIN_RANGE', {
 StartValue: LARGE_INTEGER,
 Length: LARGE_INTEGER
});

var PERF_BIN = STRUCT('PERF_BIN', {
 NumberOfBins: DWORD,
 TypeOfBin: DWORD,
 BinsRanges: pointer
});

var BIN_COUNT = STRUCT('BIN_COUNT', {
 BinRange: BIN_RANGE,
 BinCount: DWORD
});

var BIN_RESULTS = STRUCT('BIN_RESULTS', {
 NumberOfBins: DWORD,
 BinCounts: pointer
});

var GETVERSIONINPARAMS = STRUCT('GETVERSIONINPARAMS', {
 bVersion: BYTE,
 bRevision: BYTE,
 bReserved: BYTE,
 bIDEDeviceMap: BYTE,
 fCapabilities: DWORD,
 dwReserved: pointer
});

var IDEREGS = STRUCT('IDEREGS', {
 bFeaturesReg: BYTE,
 bSectorCountReg: BYTE,
 bSectorNumberReg: BYTE,
 bCylLowReg: BYTE,
 bCylHighReg: BYTE,
 bDriveHeadReg: BYTE,
 bCommandReg: BYTE,
 bReserved: BYTE
});

var SENDCMDINPARAMS = STRUCT('SENDCMDINPARAMS', {
 cBufferSize: DWORD,
 irDriveRegs: IDEREGS,
 bDriveNumber: BYTE,
 bReserved: pointer,
 dwReserved: pointer,
 bBuffer: pointer
});

var DRIVERSTATUS = STRUCT('DRIVERSTATUS', {
 bDriverError: BYTE,
 bIDEError: BYTE,
 bReserved: pointer,
 dwReserved: pointer
});

var SENDCMDOUTPARAMS = STRUCT('SENDCMDOUTPARAMS', {
 cBufferSize: DWORD,
 DriverStatus: DRIVERSTATUS,
 bBuffer: pointer
});

var CHANGER_ELEMENT = STRUCT('CHANGER_ELEMENT', {
 ElementType: ELEMENT_TYPE,
 ElementAddress: DWORD
});

var CHANGER_ELEMENT_LIST = STRUCT('CHANGER_ELEMENT_LIST', {
 Element: CHANGER_ELEMENT,
 NumberOfElements: DWORD
});

var GET_CHANGER_PARAMETERS = STRUCT('GET_CHANGER_PARAMETERS', {
 Size: DWORD,
 NumberTransportElements: WORD,
 NumberStorageElements: WORD,
 NumberCleanerSlots: WORD,
 NumberIEElements: WORD,
 NumberDataTransferElements: WORD,
 NumberOfDoors: WORD,
 FirstSlotNumber: WORD,
 FirstDriveNumber: WORD,
 FirstTransportNumber: WORD,
 FirstIEPortNumber: WORD,
 FirstCleanerSlotAddress: WORD,
 MagazineSize: WORD,
 DriveCleanTimeout: DWORD,
 Features0: DWORD,
 Features1: DWORD,
 MoveFromTransport: BYTE,
 MoveFromSlot: BYTE,
 MoveFromIePort: BYTE,
 MoveFromDrive: BYTE,
 ExchangeFromTransport: BYTE,
 ExchangeFromSlot: BYTE,
 ExchangeFromIePort: BYTE,
 ExchangeFromDrive: BYTE,
 LockUnlockCapabilities: BYTE,
 PositionCapabilities: BYTE,
 Reserved1: pointer,
 Reserved2: pointer
});

var CHANGER_PRODUCT_DATA = STRUCT('CHANGER_PRODUCT_DATA', {
 VendorId: pointer,
 ProductId: pointer,
 Revision: pointer,
 SerialNumber: pointer,
 DeviceType: BYTE
});

var CHANGER_SET_ACCESS = STRUCT('CHANGER_SET_ACCESS', {
 Element: CHANGER_ELEMENT,
 Control: DWORD
});

var CHANGER_READ_ELEMENT_STATUS = STRUCT('CHANGER_READ_ELEMENT_STATUS', {
 ElementList: CHANGER_ELEMENT_LIST,
 VolumeTagInfo: BOOLEAN
});

var CHANGER_ELEMENT_STATUS = STRUCT('CHANGER_ELEMENT_STATUS', {
 Element: CHANGER_ELEMENT,
 SrcElementAddress: CHANGER_ELEMENT,
 Flags: DWORD,
 ExceptionCode: DWORD,
 TargetId: BYTE,
 Lun: BYTE,
 Reserved: WORD,
 PrimaryVolumeID: pointer,
 AlternateVolumeID: pointer
});

var CHANGER_ELEMENT_STATUS_EX = STRUCT('CHANGER_ELEMENT_STATUS_EX', {
 Element: CHANGER_ELEMENT,
 SrcElementAddress: CHANGER_ELEMENT,
 Flags: DWORD,
 ExceptionCode: DWORD,
 TargetId: BYTE,
 Lun: BYTE,
 Reserved: WORD,
 PrimaryVolumeID: pointer,
 AlternateVolumeID: pointer,
 VendorIdentification: pointer,
 ProductIdentification: pointer,
 SerialNumber: pointer
});

var CHANGER_INITIALIZE_ELEMENT_STATUS = STRUCT('CHANGER_INITIALIZE_ELEMENT_STATUS', {
 ElementList: CHANGER_ELEMENT_LIST,
 BarCodeScan: BOOLEAN
});

var CHANGER_SET_POSITION = STRUCT('CHANGER_SET_POSITION', {
 Transport: CHANGER_ELEMENT,
 Destination: CHANGER_ELEMENT,
 Flip: BOOLEAN
});

var CHANGER_EXCHANGE_MEDIUM = STRUCT('CHANGER_EXCHANGE_MEDIUM', {
 Transport: CHANGER_ELEMENT,
 Source: CHANGER_ELEMENT,
 Destination1: CHANGER_ELEMENT,
 Destination2: CHANGER_ELEMENT,
 Flip1: BOOLEAN,
 Flip2: BOOLEAN
});

var CHANGER_MOVE_MEDIUM = STRUCT('CHANGER_MOVE_MEDIUM', {
 Transport: CHANGER_ELEMENT,
 Source: CHANGER_ELEMENT,
 Destination: CHANGER_ELEMENT,
 Flip: BOOLEAN
});

var CHANGER_SEND_VOLUME_TAG_INFORMATION = STRUCT('CHANGER_SEND_VOLUME_TAG_INFORMATION', {
 StartingElement: CHANGER_ELEMENT,
 ActionCode: DWORD,
 VolumeIDTemplate: pointer
});

var READ_ELEMENT_ADDRESS_INFO = STRUCT('READ_ELEMENT_ADDRESS_INFO', {
 NumberOfElements: DWORD,
 ElementStatus: pointer
});

var CSV_NAMESPACE_INFO = STRUCT('CSV_NAMESPACE_INFO', {
 Version: DWORD,
 DeviceNumber: DWORD,
 StartingOffset: LARGE_INTEGER,
 SectorSize: DWORD
});

var PATHNAME_BUFFER = STRUCT('PATHNAME_BUFFER', {
 PathNameLength: DWORD,
 Name: pointer
});

var FSCTL_QUERY_FAT_BPB_BUFFER = STRUCT('FSCTL_QUERY_FAT_BPB_BUFFER', {
 First0x24BytesOfBootSector: pointer
});

var NTFS_VOLUME_DATA_BUFFER = STRUCT('NTFS_VOLUME_DATA_BUFFER', {
 VolumeSerialNumber: LARGE_INTEGER,
 NumberSectors: LARGE_INTEGER,
 TotalClusters: LARGE_INTEGER,
 FreeClusters: LARGE_INTEGER,
 TotalReserved: LARGE_INTEGER,
 BytesPerSector: DWORD,
 BytesPerCluster: DWORD,
 BytesPerFileRecordSegment: DWORD,
 ClustersPerFileRecordSegment: DWORD,
 MftValidDataLength: LARGE_INTEGER,
 MftStartLcn: LARGE_INTEGER,
 Mft2StartLcn: LARGE_INTEGER,
 MftZoneStart: LARGE_INTEGER,
 MftZoneEnd: LARGE_INTEGER
});

var NTFS_EXTENDED_VOLUME_DATA = STRUCT('NTFS_EXTENDED_VOLUME_DATA', {
 ByteCount: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD
});

var STARTING_LCN_INPUT_BUFFER = STRUCT('STARTING_LCN_INPUT_BUFFER', {
 StartingLcn: LARGE_INTEGER
});

var VOLUME_BITMAP_BUFFER = STRUCT('VOLUME_BITMAP_BUFFER', {
 StartingLcn: LARGE_INTEGER,
 BitmapSize: LARGE_INTEGER,
 Buffer: pointer
});

var STARTING_VCN_INPUT_BUFFER = STRUCT('STARTING_VCN_INPUT_BUFFER', {
 StartingVcn: LARGE_INTEGER
});

var RETRIEVAL_POINTERS_BUFFER = STRUCT('RETRIEVAL_POINTERS_BUFFER', {
 ExtentCount: DWORD,
 StartingVcn: LARGE_INTEGER,
 Extents: pointer
});

var undefined = STRUCT('undefined', {
 NextVcn: LARGE_INTEGER,
 Lcn: LARGE_INTEGER
});

var NTFS_FILE_RECORD_INPUT_BUFFER = STRUCT('NTFS_FILE_RECORD_INPUT_BUFFER', {
 FileReferenceNumber: LARGE_INTEGER
});

var NTFS_FILE_RECORD_OUTPUT_BUFFER = STRUCT('NTFS_FILE_RECORD_OUTPUT_BUFFER', {
 FileReferenceNumber: LARGE_INTEGER,
 FileRecordLength: DWORD,
 FileRecordBuffer: pointer
});

var MOVE_FILE_DATA = STRUCT('MOVE_FILE_DATA', {
 FileHandle: HANDLE,
 StartingVcn: LARGE_INTEGER,
 StartingLcn: LARGE_INTEGER,
 ClusterCount: DWORD
});

var MOVE_FILE_RECORD_DATA = STRUCT('MOVE_FILE_RECORD_DATA', {
 FileHandle: HANDLE,
 SourceFileRecord: LARGE_INTEGER,
 TargetFileRecord: LARGE_INTEGER
});

var FIND_BY_SID_DATA = STRUCT('FIND_BY_SID_DATA', {
 Restart: DWORD,
 Sid: SID
});

var FIND_BY_SID_OUTPUT = STRUCT('FIND_BY_SID_OUTPUT', {
 NextEntryOffset: DWORD,
 FileIndex: DWORD,
 FileNameLength: DWORD,
 FileName: pointer
});

var MFT_ENUM_DATA = STRUCT('MFT_ENUM_DATA', {
 StartFileReferenceNumber: DWORDLONG,
 LowUsn: USN,
 HighUsn: USN
});

var CREATE_USN_JOURNAL_DATA = STRUCT('CREATE_USN_JOURNAL_DATA', {
 MaximumSize: DWORDLONG,
 AllocationDelta: DWORDLONG
});

var READ_USN_JOURNAL_DATA = STRUCT('READ_USN_JOURNAL_DATA', {
 StartUsn: USN,
 ReasonMask: DWORD,
 ReturnOnlyOnClose: DWORD,
 Timeout: DWORDLONG,
 BytesToWaitFor: DWORDLONG,
 UsnJournalID: DWORDLONG
});

var USN_RECORD = STRUCT('USN_RECORD', {
 RecordLength: DWORD,
 MajorVersion: WORD,
 MinorVersion: WORD,
 FileReferenceNumber: DWORDLONG,
 ParentFileReferenceNumber: DWORDLONG,
 Usn: USN,
 TimeStamp: LARGE_INTEGER,
 Reason: DWORD,
 SourceInfo: DWORD,
 SecurityId: DWORD,
 FileAttributes: DWORD,
 FileNameLength: WORD,
 FileNameOffset: WORD,
 FileName: pointer
});

var USN_JOURNAL_DATA = STRUCT('USN_JOURNAL_DATA', {
 UsnJournalID: DWORDLONG,
 FirstUsn: USN,
 NextUsn: USN,
 LowestValidUsn: USN,
 MaxUsn: USN,
 MaximumSize: DWORDLONG,
 AllocationDelta: DWORDLONG
});

var DELETE_USN_JOURNAL_DATA = STRUCT('DELETE_USN_JOURNAL_DATA', {
 UsnJournalID: DWORDLONG,
 DeleteFlags: DWORD
});

var MARK_HANDLE_INFO = STRUCT('MARK_HANDLE_INFO', {
 UsnSourceInfo: DWORD,
 VolumeHandle: HANDLE,
 HandleInfo: DWORD
});

var BULK_SECURITY_TEST_DATA = STRUCT('BULK_SECURITY_TEST_DATA', {
 DesiredAccess: ACCESS_MASK,
 SecurityIds: pointer
});

var FILE_PREFETCH = STRUCT('FILE_PREFETCH', {
 Type: DWORD,
 Count: DWORD,
 Prefetch: pointer
});

var FILE_PREFETCH_EX = STRUCT('FILE_PREFETCH_EX', {
 Type: DWORD,
 Count: DWORD,
 Context: PVOID,
 Prefetch: pointer
});

var FILESYSTEM_STATISTICS = STRUCT('FILESYSTEM_STATISTICS', {
 FileSystemType: WORD,
 Version: WORD,
 SizeOfCompleteStructure: DWORD,
 UserFileReads: DWORD,
 UserFileReadBytes: DWORD,
 UserDiskReads: DWORD,
 UserFileWrites: DWORD,
 UserFileWriteBytes: DWORD,
 UserDiskWrites: DWORD,
 MetaDataReads: DWORD,
 MetaDataReadBytes: DWORD,
 MetaDataDiskReads: DWORD,
 MetaDataWrites: DWORD,
 MetaDataWriteBytes: DWORD,
 MetaDataDiskWrites: DWORD
});

var FAT_STATISTICS = STRUCT('FAT_STATISTICS', {
 CreateHits: DWORD,
 SuccessfulCreates: DWORD,
 FailedCreates: DWORD,
 NonCachedReads: DWORD,
 NonCachedReadBytes: DWORD,
 NonCachedWrites: DWORD,
 NonCachedWriteBytes: DWORD,
 NonCachedDiskReads: DWORD,
 NonCachedDiskWrites: DWORD
});

var EXFAT_STATISTICS = STRUCT('EXFAT_STATISTICS', {
 CreateHits: DWORD,
 SuccessfulCreates: DWORD,
 FailedCreates: DWORD,
 NonCachedReads: DWORD,
 NonCachedReadBytes: DWORD,
 NonCachedWrites: DWORD,
 NonCachedWriteBytes: DWORD,
 NonCachedDiskReads: DWORD,
 NonCachedDiskWrites: DWORD
});

var NTFS_STATISTICS = STRUCT('NTFS_STATISTICS', {
 LogFileFullExceptions: DWORD,
 OtherExceptions: DWORD,
 MftReads: DWORD,
 MftReadBytes: DWORD,
 MftWrites: DWORD,
 MftWriteBytes: DWORD,
 MftWritesUserLevel: ,
 MftWritesFlushForLogFileFull: WORD,
 MftWritesLazyWriter: WORD,
 MftWritesUserRequest: WORD,
 Mft2Writes: DWORD,
 Mft2WriteBytes: DWORD,
 Mft2WritesUserLevel: ,
 Mft2WritesFlushForLogFileFull: WORD,
 Mft2WritesLazyWriter: WORD,
 Mft2WritesUserRequest: WORD,
 RootIndexReads: DWORD,
 RootIndexReadBytes: DWORD,
 RootIndexWrites: DWORD,
 RootIndexWriteBytes: DWORD,
 BitmapReads: DWORD,
 BitmapReadBytes: DWORD,
 BitmapWrites: DWORD,
 BitmapWriteBytes: DWORD,
 BitmapWritesFlushForLogFileFull: WORD,
 BitmapWritesLazyWriter: WORD,
 BitmapWritesUserRequest: WORD,
 BitmapWritesUserLevel: ,
 MftBitmapReads: DWORD,
 MftBitmapReadBytes: DWORD,
 MftBitmapWrites: DWORD,
 MftBitmapWriteBytes: DWORD,
 MftBitmapWritesFlushForLogFileFull: WORD,
 MftBitmapWritesLazyWriter: WORD,
 MftBitmapWritesUserRequest: WORD,
 MftBitmapWritesUserLevel: ,
 UserIndexReads: DWORD,
 UserIndexReadBytes: DWORD,
 UserIndexWrites: DWORD,
 UserIndexWriteBytes: DWORD,
 LogFileReads: DWORD,
 LogFileReadBytes: DWORD,
 LogFileWrites: DWORD,
 LogFileWriteBytes: DWORD,
 Allocate: 
});

var undefined = STRUCT('undefined', {
 Write: WORD,
 Create: WORD,
 SetInfo: WORD,
 Flush: WORD
});

var undefined = STRUCT('undefined', {
 Write: WORD,
 Create: WORD,
 SetInfo: WORD,
 Flush: WORD
});

var undefined = STRUCT('undefined', {
 Write: WORD,
 Create: WORD,
 SetInfo: WORD
});

var undefined = STRUCT('undefined', {
 Write: WORD,
 Create: WORD,
 SetInfo: WORD,
 Flush: WORD
});

var undefined = STRUCT('undefined', {
 Calls: DWORD,
 Clusters: DWORD,
 Hints: DWORD,
 RunsReturned: DWORD,
 HintsHonored: DWORD,
 HintsClusters: DWORD,
 Cache: DWORD,
 CacheClusters: DWORD,
 CacheMiss: DWORD,
 CacheMissClusters: DWORD
});

var FILE_OBJECTID_BUFFER = STRUCT('FILE_OBJECTID_BUFFER', {
 ObjectId: pointer
});

var undefined = STRUCT('undefined', {
 BirthVolumeId: pointer,
 BirthObjectId: pointer,
 DomainId: pointer
});

var FILE_SET_SPARSE_BUFFER = STRUCT('FILE_SET_SPARSE_BUFFER', {
 SetSparse: BOOLEAN
});

var FILE_ZERO_DATA_INFORMATION = STRUCT('FILE_ZERO_DATA_INFORMATION', {
 FileOffset: LARGE_INTEGER,
 BeyondFinalZero: LARGE_INTEGER
});

var FILE_ALLOCATED_RANGE_BUFFER = STRUCT('FILE_ALLOCATED_RANGE_BUFFER', {
 FileOffset: LARGE_INTEGER,
 Length: LARGE_INTEGER
});

var ENCRYPTION_BUFFER = STRUCT('ENCRYPTION_BUFFER', {
 EncryptionOperation: DWORD,
 Private: pointer
});

var DECRYPTION_STATUS_BUFFER = STRUCT('DECRYPTION_STATUS_BUFFER', {
 NoEncryptedStreams: BOOLEAN
});

var REQUEST_RAW_ENCRYPTED_DATA = STRUCT('REQUEST_RAW_ENCRYPTED_DATA', {
 FileOffset: LONGLONG,
 Length: DWORD
});

var ENCRYPTED_DATA_INFO = STRUCT('ENCRYPTED_DATA_INFO', {
 StartingFileOffset: DWORDLONG,
 OutputBufferOffset: DWORD,
 BytesWithinFileSize: DWORD,
 BytesWithinValidDataLength: DWORD,
 CompressionFormat: WORD,
 DataUnitShift: BYTE,
 ChunkShift: BYTE,
 ClusterShift: BYTE,
 EncryptionFormat: BYTE,
 NumberOfDataBlocks: WORD,
 DataBlockSize: pointer
});

var PLEX_READ_DATA_REQUEST = STRUCT('PLEX_READ_DATA_REQUEST', {
 ByteOffset: LARGE_INTEGER,
 ByteLength: DWORD,
 PlexNumber: DWORD
});

var SI_COPYFILE = STRUCT('SI_COPYFILE', {
 SourceFileNameLength: DWORD,
 DestinationFileNameLength: DWORD,
 Flags: DWORD,
 FileNameBuffer: pointer
});

var FILE_MAKE_COMPATIBLE_BUFFER = STRUCT('FILE_MAKE_COMPATIBLE_BUFFER', {
 CloseDisc: BOOLEAN
});

var FILE_SET_DEFECT_MGMT_BUFFER = STRUCT('FILE_SET_DEFECT_MGMT_BUFFER', {
 Disable: BOOLEAN
});

var FILE_QUERY_SPARING_BUFFER = STRUCT('FILE_QUERY_SPARING_BUFFER', {
 SparingUnitBytes: DWORD,
 SoftwareSparing: BOOLEAN,
 TotalSpareBlocks: DWORD,
 FreeSpareBlocks: DWORD
});

var FILE_QUERY_ON_DISK_VOL_INFO_BUFFER = STRUCT('FILE_QUERY_ON_DISK_VOL_INFO_BUFFER', {
 DirectoryCount: LARGE_INTEGER,
 FileCount: LARGE_INTEGER,
 FsFormatMajVersion: WORD,
 FsFormatMinVersion: WORD,
 FsFormatName: pointer,
 FormatTime: LARGE_INTEGER,
 LastUpdateTime: LARGE_INTEGER,
 CopyrightInfo: pointer,
 AbstractInfo: pointer,
 FormattingImplementationInfo: pointer,
 LastModifyingImplementationInfo: pointer
});

var SHRINK_VOLUME_INFORMATION = STRUCT('SHRINK_VOLUME_INFORMATION', {
 ShrinkRequestType: SHRINK_VOLUME_REQUEST_TYPES,
 Flags: DWORDLONG,
 NewNumberOfSectors: LONGLONG
});

var TXFS_MODIFY_RM = STRUCT('TXFS_MODIFY_RM', {
 Flags: DWORD,
 LogContainerCountMax: DWORD,
 LogContainerCountMin: DWORD,
 LogContainerCount: DWORD,
 LogGrowthIncrement: DWORD,
 LogAutoShrinkPercentage: DWORD,
 Reserved: DWORDLONG,
 LoggingMode: WORD
});

var TXFS_QUERY_RM_INFORMATION = STRUCT('TXFS_QUERY_RM_INFORMATION', {
 BytesRequired: DWORD,
 TailLsn: DWORDLONG,
 CurrentLsn: DWORDLONG,
 ArchiveTailLsn: DWORDLONG,
 LogContainerSize: DWORDLONG,
 HighestVirtualClock: LARGE_INTEGER,
 LogContainerCount: DWORD,
 LogContainerCountMax: DWORD,
 LogContainerCountMin: DWORD,
 LogGrowthIncrement: DWORD,
 LogAutoShrinkPercentage: DWORD,
 Flags: DWORD,
 LoggingMode: WORD,
 Reserved: WORD,
 RmState: DWORD,
 LogCapacity: DWORDLONG,
 LogFree: DWORDLONG,
 TopsSize: DWORDLONG,
 TopsUsed: DWORDLONG,
 TransactionCount: DWORDLONG,
 OnePCCount: DWORDLONG,
 TwoPCCount: DWORDLONG,
 NumberLogFileFull: DWORDLONG,
 OldestTransactionAge: DWORDLONG,
 RMName: GUID,
 TmLogPathOffset: DWORD
});

var TXFS_ROLLFORWARD_REDO_INFORMATION = STRUCT('TXFS_ROLLFORWARD_REDO_INFORMATION', {
 LastVirtualClock: LARGE_INTEGER,
 LastRedoLsn: DWORDLONG,
 HighestRecoveryLsn: DWORDLONG,
 Flags: DWORD
});

var TXFS_START_RM_INFORMATION = STRUCT('TXFS_START_RM_INFORMATION', {
 Flags: DWORD,
 LogContainerSize: DWORDLONG,
 LogContainerCountMin: DWORD,
 LogContainerCountMax: DWORD,
 LogGrowthIncrement: DWORD,
 LogAutoShrinkPercentage: DWORD,
 TmLogPathOffset: DWORD,
 TmLogPathLength: WORD,
 LoggingMode: WORD,
 LogPathLength: WORD,
 Reserved: WORD,
 LogPath: pointer
});

var TXFS_GET_METADATA_INFO_OUT = STRUCT('TXFS_GET_METADATA_INFO_OUT', {
 TxfFileId: ,
 LockingTransaction: GUID,
 LastLsn: DWORDLONG,
 TransactionState: DWORD
});

var undefined = STRUCT('undefined', {
 LowPart: LONGLONG,
 HighPart: LONGLONG
});

var TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY = STRUCT('TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY', {
 Offset: DWORDLONG,
 NameFlags: DWORD,
 FileId: LONGLONG,
 Reserved1: DWORD,
 Reserved2: DWORD,
 Reserved3: LONGLONG,
 FileName: pointer
});

var TXFS_LIST_TRANSACTION_LOCKED_FILES = STRUCT('TXFS_LIST_TRANSACTION_LOCKED_FILES', {
 KtmTransaction: GUID,
 NumberOfFiles: DWORDLONG,
 BufferSizeRequired: DWORDLONG,
 Offset: DWORDLONG
});

var TXFS_LIST_TRANSACTIONS_ENTRY = STRUCT('TXFS_LIST_TRANSACTIONS_ENTRY', {
 TransactionId: GUID,
 TransactionState: DWORD,
 Reserved1: DWORD,
 Reserved2: DWORD,
 Reserved3: LONGLONG
});

var TXFS_LIST_TRANSACTIONS = STRUCT('TXFS_LIST_TRANSACTIONS', {
 NumberOfTransactions: DWORDLONG,
 BufferSizeRequired: DWORDLONG
});


var TXFS_WRITE_BACKUP_INFORMATION = STRUCT('TXFS_WRITE_BACKUP_INFORMATION', {
 Buffer: pointer
});

var TXFS_GET_TRANSACTED_VERSION = STRUCT('TXFS_GET_TRANSACTED_VERSION', {
 ThisBaseVersion: DWORD,
 LatestVersion: DWORD,
 ThisMiniVersion: WORD,
 FirstMiniVersion: WORD,
 LatestMiniVersion: WORD
});

var TXFS_SAVEPOINT_INFORMATION = STRUCT('TXFS_SAVEPOINT_INFORMATION', {
 KtmTransaction: HANDLE,
 ActionCode: DWORD,
 SavepointId: DWORD
});

var TXFS_CREATE_MINIVERSION_INFO = STRUCT('TXFS_CREATE_MINIVERSION_INFO', {
 StructureVersion: WORD,
 StructureLength: WORD,
 BaseVersion: DWORD,
 MiniVersion: WORD
});

var TXFS_TRANSACTION_ACTIVE_INFO = STRUCT('TXFS_TRANSACTION_ACTIVE_INFO', {
 TransactionsActiveAtSnapshot: BOOLEAN
});

var BOOT_AREA_INFO = STRUCT('BOOT_AREA_INFO', {
 BootSectorCount: DWORD,
 BootSectors: pointer
});

var undefined = STRUCT('undefined', {
 Offset: LARGE_INTEGER
});

var RETRIEVAL_POINTER_BASE = STRUCT('RETRIEVAL_POINTER_BASE', {
 FileAreaOffset: LARGE_INTEGER
});

var FILE_FS_PERSISTENT_VOLUME_INFORMATION = STRUCT('FILE_FS_PERSISTENT_VOLUME_INFORMATION', {
 VolumeFlags: DWORD,
 FlagMask: DWORD,
 Version: DWORD,
 Reserved: DWORD
});

var FILE_SYSTEM_RECOGNITION_INFORMATION = STRUCT('FILE_SYSTEM_RECOGNITION_INFORMATION', {
 FileSystem: pointer
});

var REQUEST_OPLOCK_INPUT_BUFFER = STRUCT('REQUEST_OPLOCK_INPUT_BUFFER', {
 StructureVersion: WORD,
 StructureLength: WORD,
 RequestedOplockLevel: DWORD,
 Flags: DWORD
});

var REQUEST_OPLOCK_OUTPUT_BUFFER = STRUCT('REQUEST_OPLOCK_OUTPUT_BUFFER', {
 StructureVersion: WORD,
 StructureLength: WORD,
 OriginalOplockLevel: DWORD,
 NewOplockLevel: DWORD,
 Flags: DWORD,
 AccessMode: ACCESS_MASK,
 ShareMode: WORD
});

var SD_CHANGE_MACHINE_SID_INPUT = STRUCT('SD_CHANGE_MACHINE_SID_INPUT', {
 CurrentMachineSIDOffset: WORD,
 CurrentMachineSIDLength: WORD,
 NewMachineSIDOffset: WORD,
 NewMachineSIDLength: WORD
});

var SD_CHANGE_MACHINE_SID_OUTPUT = STRUCT('SD_CHANGE_MACHINE_SID_OUTPUT', {
 NumSDChangedSuccess: DWORDLONG,
 NumSDChangedFail: DWORDLONG,
 NumSDUnused: DWORDLONG,
 NumSDTotal: DWORDLONG,
 NumMftSDChangedSuccess: DWORDLONG,
 NumMftSDChangedFail: DWORDLONG,
 NumMftSDTotal: DWORDLONG
});

var SD_GLOBAL_CHANGE_INPUT = STRUCT('SD_GLOBAL_CHANGE_INPUT', {
 Flags: DWORD,
 ChangeType: DWORD
});

var SD_GLOBAL_CHANGE_OUTPUT = STRUCT('SD_GLOBAL_CHANGE_OUTPUT', {
 Flags: DWORD,
 ChangeType: DWORD
});

var EXTENDED_ENCRYPTED_DATA_INFO = STRUCT('EXTENDED_ENCRYPTED_DATA_INFO', {
 ExtendedCode: DWORD,
 Length: DWORD,
 Flags: DWORD,
 Reserved: DWORD
});

var LOOKUP_STREAM_FROM_CLUSTER_INPUT = STRUCT('LOOKUP_STREAM_FROM_CLUSTER_INPUT', {
 Flags: DWORD,
 NumberOfClusters: DWORD,
 Cluster: pointer
});

var LOOKUP_STREAM_FROM_CLUSTER_OUTPUT = STRUCT('LOOKUP_STREAM_FROM_CLUSTER_OUTPUT', {
 Offset: DWORD,
 NumberOfMatches: DWORD,
 BufferSizeRequired: DWORD
});

var LOOKUP_STREAM_FROM_CLUSTER_ENTRY = STRUCT('LOOKUP_STREAM_FROM_CLUSTER_ENTRY', {
 OffsetToNext: DWORD,
 Flags: DWORD,
 Reserved: LARGE_INTEGER,
 Cluster: LARGE_INTEGER,
 FileName: pointer
});

var FILE_TYPE_NOTIFICATION_INPUT = STRUCT('FILE_TYPE_NOTIFICATION_INPUT', {
 Flags: DWORD,
 NumFileTypeIDs: DWORD,
 FileTypeID: pointer
});

var DISK_EXTENT = STRUCT('DISK_EXTENT', {
 DiskNumber: DWORD,
 StartingOffset: LARGE_INTEGER,
 ExtentLength: LARGE_INTEGER
});

var VOLUME_DISK_EXTENTS = STRUCT('VOLUME_DISK_EXTENTS', {
 NumberOfDiskExtents: DWORD,
 Extents: pointer
});

var VOLUME_GET_GPT_ATTRIBUTES_INFORMATION = STRUCT('VOLUME_GET_GPT_ATTRIBUTES_INFORMATION', {
 GptAttributes: DWORDLONG
});

var SCARD_IO_REQUEST = STRUCT('SCARD_IO_REQUEST', {
 dwProtocol: DWORD,
 cbPciLength: DWORD
});

var SCARD_T0_COMMAND = STRUCT('SCARD_T0_COMMAND', {
 bCla: BYTE,
 bIns: BYTE,
 bP1: BYTE,
 bP2: BYTE,
 bP3: BYTE
});

var SCARD_T0_REQUEST = STRUCT('SCARD_T0_REQUEST', {
 ioRequest: SCARD_IO_REQUEST,
 bSw1: BYTE,
 bSw2: BYTE
});

var SCARD_T1_REQUEST = STRUCT('SCARD_T1_REQUEST', {
 ioRequest: SCARD_IO_REQUEST
});

var SCARD_READERSTATE = STRUCT('SCARD_READERSTATE', {
 szReader: LPCSTR,
 pvUserData: LPVOID,
 dwCurrentState: DWORD,
 dwEventState: DWORD,
 cbAtr: DWORD,
 rgbAtr: pointer
});

var SCARD_READERSTATEW = STRUCT('SCARD_READERSTATEW', {
 szReader: LPCWSTR,
 pvUserData: LPVOID,
 dwCurrentState: DWORD,
 dwEventState: DWORD,
 cbAtr: DWORD,
 rgbAtr: pointer
});

var SCARD_ATRMASK = STRUCT('SCARD_ATRMASK', {
 cbAtr: DWORD,
 rgbAtr: pointer,
 rgbMask: pointer
});

var OPENCARD_SEARCH_CRITERIA = STRUCT('OPENCARD_SEARCH_CRITERIA', {
 dwStructSize: DWORD,
 lpstrGroupNames: LPSTR,
 nMaxGroupNames: DWORD,
 rgguidInterfaces: LPCGUID,
 cguidInterfaces: DWORD,
 lpstrCardNames: LPSTR,
 nMaxCardNames: DWORD,
 lpfnCheck: LPOCNCHKPROC,
 lpfnConnect: LPOCNCONNPROCA,
 lpfnDisconnect: LPOCNDSCPROC,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD
});

var OPENCARD_SEARCH_CRITERIAW = STRUCT('OPENCARD_SEARCH_CRITERIAW', {
 dwStructSize: DWORD,
 lpstrGroupNames: LPWSTR,
 nMaxGroupNames: DWORD,
 rgguidInterfaces: LPCGUID,
 cguidInterfaces: DWORD,
 lpstrCardNames: LPWSTR,
 nMaxCardNames: DWORD,
 lpfnCheck: LPOCNCHKPROC,
 lpfnConnect: LPOCNCONNPROCW,
 lpfnDisconnect: LPOCNDSCPROC,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD
});

var OPENCARDNAME_EX = STRUCT('OPENCARDNAME_EX', {
 dwStructSize: DWORD,
 hSCardContext: SCARDCONTEXT,
 hwndOwner: HWND,
 dwFlags: DWORD,
 lpstrTitle: LPCSTR,
 lpstrSearchDesc: LPCSTR,
 hIcon: HICON,
 pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAA,
 lpfnConnect: LPOCNCONNPROCA,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD,
 lpstrRdr: LPSTR,
 nMaxRdr: DWORD,
 lpstrCard: LPSTR,
 nMaxCard: DWORD,
 dwActiveProtocol: DWORD,
 hCardHandle: SCARDHANDLE
});

var OPENCARDNAME_EXW = STRUCT('OPENCARDNAME_EXW', {
 dwStructSize: DWORD,
 hSCardContext: SCARDCONTEXT,
 hwndOwner: HWND,
 dwFlags: DWORD,
 lpstrTitle: LPCWSTR,
 lpstrSearchDesc: LPCWSTR,
 hIcon: HICON,
 pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAW,
 lpfnConnect: LPOCNCONNPROCW,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD,
 lpstrRdr: LPWSTR,
 nMaxRdr: DWORD,
 lpstrCard: LPWSTR,
 nMaxCard: DWORD,
 dwActiveProtocol: DWORD,
 hCardHandle: SCARDHANDLE
});

var OPENCARDNAME = STRUCT('OPENCARDNAME', {
 dwStructSize: DWORD,
 hwndOwner: HWND,
 hSCardContext: SCARDCONTEXT,
 lpstrGroupNames: LPSTR,
 nMaxGroupNames: DWORD,
 lpstrCardNames: LPSTR,
 nMaxCardNames: DWORD,
 rgguidInterfaces: LPCGUID,
 cguidInterfaces: DWORD,
 lpstrRdr: LPSTR,
 nMaxRdr: DWORD,
 lpstrCard: LPSTR,
 nMaxCard: DWORD,
 lpstrTitle: LPCSTR,
 dwFlags: DWORD,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD,
 dwActiveProtocol: DWORD,
 lpfnConnect: LPOCNCONNPROCA,
 lpfnCheck: LPOCNCHKPROC,
 lpfnDisconnect: LPOCNDSCPROC,
 hCardHandle: SCARDHANDLE
});

var OPENCARDNAMEW = STRUCT('OPENCARDNAMEW', {
 dwStructSize: DWORD,
 hwndOwner: HWND,
 hSCardContext: SCARDCONTEXT,
 lpstrGroupNames: LPWSTR,
 nMaxGroupNames: DWORD,
 lpstrCardNames: LPWSTR,
 nMaxCardNames: DWORD,
 rgguidInterfaces: LPCGUID,
 cguidInterfaces: DWORD,
 lpstrRdr: LPWSTR,
 nMaxRdr: DWORD,
 lpstrCard: LPWSTR,
 nMaxCard: DWORD,
 lpstrTitle: LPCWSTR,
 dwFlags: DWORD,
 pvUserData: LPVOID,
 dwShareMode: DWORD,
 dwPreferredProtocols: DWORD,
 dwActiveProtocol: DWORD,
 lpfnConnect: LPOCNCONNPROCW,
 lpfnCheck: LPOCNCHKPROC,
 lpfnDisconnect: LPOCNDSCPROC,
 hCardHandle: SCARDHANDLE
});


var PROPSHEETPAGEA = STRUCT('PROPSHEETPAGEA', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKA,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCSTR,
 pszHeaderSubTitle: LPCSTR,
 hActCtx: HANDLE
});

var PROPSHEETPAGEW = STRUCT('PROPSHEETPAGEW', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCWSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKW,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCWSTR,
 pszHeaderSubTitle: LPCWSTR,
 hActCtx: HANDLE
});

var PROPSHEETPAGEA_V1 = STRUCT('PROPSHEETPAGEA_V1', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKA,
 pcRefParent: PTR(uint)
});

var PROPSHEETPAGEA_V2 = STRUCT('PROPSHEETPAGEA_V2', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKA,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCSTR,
 pszHeaderSubTitle: LPCSTR
});

var PROPSHEETPAGEA_V3 = STRUCT('PROPSHEETPAGEA_V3', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKA,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCSTR,
 pszHeaderSubTitle: LPCSTR,
 hActCtx: HANDLE
});

var PROPSHEETPAGEW_V1 = STRUCT('PROPSHEETPAGEW_V1', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCWSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKW,
 pcRefParent: PTR(uint)
});

var PROPSHEETPAGEW_V2 = STRUCT('PROPSHEETPAGEW_V2', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCWSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKW,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCWSTR,
 pszHeaderSubTitle: LPCWSTR
});

var PROPSHEETPAGEW_V3 = STRUCT('PROPSHEETPAGEW_V3', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hInstance: HINSTANCE,
 pszTitle: LPCWSTR,
 pfnDlgProc: DLGPROC,
 lParam: LPARAM,
 pfnCallback: LPFNPSPCALLBACKW,
 pcRefParent: PTR(uint),
 pszHeaderTitle: LPCWSTR,
 pszHeaderSubTitle: LPCWSTR,
 hActCtx: HANDLE
});

var PROPSHEETHEADERA_V1 = STRUCT('PROPSHEETHEADERA_V1', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hwndParent: HWND,
 hInstance: HINSTANCE,
 pszCaption: LPCSTR,
 nPages: UINT,
 pfnCallback: PFNPROPSHEETCALLBACK
});

var PROPSHEETHEADERA = STRUCT('PROPSHEETHEADERA', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hwndParent: HWND,
 hInstance: HINSTANCE,
 pszCaption: LPCSTR,
 nPages: UINT,
 pfnCallback: PFNPROPSHEETCALLBACK,
 hplWatermark: HPALETTE
});

var PROPSHEETHEADERW_V1 = STRUCT('PROPSHEETHEADERW_V1', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hwndParent: HWND,
 hInstance: HINSTANCE,
 pszCaption: LPCWSTR,
 nPages: UINT,
 pfnCallback: PFNPROPSHEETCALLBACK
});

var PROPSHEETHEADERW = STRUCT('PROPSHEETHEADERW', {
 dwSize: DWORD,
 dwFlags: DWORD,
 hwndParent: HWND,
 hInstance: HINSTANCE,
 pszCaption: LPCWSTR,
 nPages: UINT,
 pfnCallback: PFNPROPSHEETCALLBACK,
 hplWatermark: HPALETTE
});

var PSHNOTIFY = STRUCT('PSHNOTIFY', {
 hdr: NMHDR,
 lParam: LPARAM
});

var PRINTER_INFO_1 = STRUCT('PRINTER_INFO_1', {
 Flags: DWORD,
 pDescription: LPSTR,
 pName: LPSTR,
 pComment: LPSTR
});

var PRINTER_INFO_1W = STRUCT('PRINTER_INFO_1W', {
 Flags: DWORD,
 pDescription: LPWSTR,
 pName: LPWSTR,
 pComment: LPWSTR
});

var PRINTER_INFO_2 = STRUCT('PRINTER_INFO_2', {
 pServerName: LPSTR,
 pPrinterName: LPSTR,
 pShareName: LPSTR,
 pPortName: LPSTR,
 pDriverName: LPSTR,
 pComment: LPSTR,
 pLocation: LPSTR,
 pDevMode: LPDEVMODEA,
 pSepFile: LPSTR,
 pPrintProcessor: LPSTR,
 pDatatype: LPSTR,
 pParameters: LPSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Attributes: DWORD,
 Priority: DWORD,
 DefaultPriority: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 Status: DWORD,
 cJobs: DWORD,
 AveragePPM: DWORD
});

var PRINTER_INFO_2W = STRUCT('PRINTER_INFO_2W', {
 pServerName: LPWSTR,
 pPrinterName: LPWSTR,
 pShareName: LPWSTR,
 pPortName: LPWSTR,
 pDriverName: LPWSTR,
 pComment: LPWSTR,
 pLocation: LPWSTR,
 pDevMode: LPDEVMODEW,
 pSepFile: LPWSTR,
 pPrintProcessor: LPWSTR,
 pDatatype: LPWSTR,
 pParameters: LPWSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Attributes: DWORD,
 Priority: DWORD,
 DefaultPriority: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 Status: DWORD,
 cJobs: DWORD,
 AveragePPM: DWORD
});

var PRINTER_INFO_3 = STRUCT('PRINTER_INFO_3', {
 pSecurityDescriptor: PSECURITY_DESCRIPTOR
});

var PRINTER_INFO_4 = STRUCT('PRINTER_INFO_4', {
 pPrinterName: LPSTR,
 pServerName: LPSTR,
 Attributes: DWORD
});

var PRINTER_INFO_4W = STRUCT('PRINTER_INFO_4W', {
 pPrinterName: LPWSTR,
 pServerName: LPWSTR,
 Attributes: DWORD
});

var PRINTER_INFO_5 = STRUCT('PRINTER_INFO_5', {
 pPrinterName: LPSTR,
 pPortName: LPSTR,
 Attributes: DWORD,
 DeviceNotSelectedTimeout: DWORD,
 TransmissionRetryTimeout: DWORD
});

var PRINTER_INFO_5W = STRUCT('PRINTER_INFO_5W', {
 pPrinterName: LPWSTR,
 pPortName: LPWSTR,
 Attributes: DWORD,
 DeviceNotSelectedTimeout: DWORD,
 TransmissionRetryTimeout: DWORD
});

var PRINTER_INFO_6 = STRUCT('PRINTER_INFO_6', {
 dwStatus: DWORD
});

var PRINTER_INFO_7 = STRUCT('PRINTER_INFO_7', {
 pszObjectGUID: LPSTR,
 dwAction: DWORD
});

var PRINTER_INFO_7W = STRUCT('PRINTER_INFO_7W', {
 pszObjectGUID: LPWSTR,
 dwAction: DWORD
});

var PRINTER_INFO_8 = STRUCT('PRINTER_INFO_8', {
 pDevMode: LPDEVMODEA
});

var PRINTER_INFO_8W = STRUCT('PRINTER_INFO_8W', {
 pDevMode: LPDEVMODEW
});

var PRINTER_INFO_9 = STRUCT('PRINTER_INFO_9', {
 pDevMode: LPDEVMODEA
});

var PRINTER_INFO_9W = STRUCT('PRINTER_INFO_9W', {
 pDevMode: LPDEVMODEW
});

var JOB_INFO_1 = STRUCT('JOB_INFO_1', {
 JobId: DWORD,
 pPrinterName: LPSTR,
 pMachineName: LPSTR,
 pUserName: LPSTR,
 pDocument: LPSTR,
 pDatatype: LPSTR,
 pStatus: LPSTR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 TotalPages: DWORD,
 PagesPrinted: DWORD,
 Submitted: SYSTEMTIME
});

var JOB_INFO_1W = STRUCT('JOB_INFO_1W', {
 JobId: DWORD,
 pPrinterName: LPWSTR,
 pMachineName: LPWSTR,
 pUserName: LPWSTR,
 pDocument: LPWSTR,
 pDatatype: LPWSTR,
 pStatus: LPWSTR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 TotalPages: DWORD,
 PagesPrinted: DWORD,
 Submitted: SYSTEMTIME
});

var JOB_INFO_2 = STRUCT('JOB_INFO_2', {
 JobId: DWORD,
 pPrinterName: LPSTR,
 pMachineName: LPSTR,
 pUserName: LPSTR,
 pDocument: LPSTR,
 pNotifyName: LPSTR,
 pDatatype: LPSTR,
 pPrintProcessor: LPSTR,
 pParameters: LPSTR,
 pDriverName: LPSTR,
 pDevMode: LPDEVMODEA,
 pStatus: LPSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 TotalPages: DWORD,
 Size: DWORD,
 Submitted: SYSTEMTIME,
 Time: DWORD,
 PagesPrinted: DWORD
});

var JOB_INFO_2W = STRUCT('JOB_INFO_2W', {
 JobId: DWORD,
 pPrinterName: LPWSTR,
 pMachineName: LPWSTR,
 pUserName: LPWSTR,
 pDocument: LPWSTR,
 pNotifyName: LPWSTR,
 pDatatype: LPWSTR,
 pPrintProcessor: LPWSTR,
 pParameters: LPWSTR,
 pDriverName: LPWSTR,
 pDevMode: LPDEVMODEW,
 pStatus: LPWSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 TotalPages: DWORD,
 Size: DWORD,
 Submitted: SYSTEMTIME,
 Time: DWORD,
 PagesPrinted: DWORD
});

var JOB_INFO_3 = STRUCT('JOB_INFO_3', {
 JobId: DWORD,
 NextJobId: DWORD,
 Reserved: DWORD
});

var JOB_INFO_4 = STRUCT('JOB_INFO_4', {
 JobId: DWORD,
 pPrinterName: LPSTR,
 pMachineName: LPSTR,
 pUserName: LPSTR,
 pDocument: LPSTR,
 pNotifyName: LPSTR,
 pDatatype: LPSTR,
 pPrintProcessor: LPSTR,
 pParameters: LPSTR,
 pDriverName: LPSTR,
 pDevMode: LPDEVMODEA,
 pStatus: LPSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 TotalPages: DWORD,
 Size: DWORD,
 Submitted: SYSTEMTIME,
 Time: DWORD,
 PagesPrinted: DWORD,
 SizeHigh: LONG
});

var JOB_INFO_4W = STRUCT('JOB_INFO_4W', {
 JobId: DWORD,
 pPrinterName: LPWSTR,
 pMachineName: LPWSTR,
 pUserName: LPWSTR,
 pDocument: LPWSTR,
 pNotifyName: LPWSTR,
 pDatatype: LPWSTR,
 pPrintProcessor: LPWSTR,
 pParameters: LPWSTR,
 pDriverName: LPWSTR,
 pDevMode: LPDEVMODEW,
 pStatus: LPWSTR,
 pSecurityDescriptor: PSECURITY_DESCRIPTOR,
 Status: DWORD,
 Priority: DWORD,
 Position: DWORD,
 StartTime: DWORD,
 UntilTime: DWORD,
 TotalPages: DWORD,
 Size: DWORD,
 Submitted: SYSTEMTIME,
 Time: DWORD,
 PagesPrinted: DWORD,
 SizeHigh: LONG
});

var ADDJOB_INFO_1 = STRUCT('ADDJOB_INFO_1', {
 Path: LPSTR,
 JobId: DWORD
});

var ADDJOB_INFO_1W = STRUCT('ADDJOB_INFO_1W', {
 Path: LPWSTR,
 JobId: DWORD
});

var DRIVER_INFO_1 = STRUCT('DRIVER_INFO_1', {
 pName: LPSTR
});

var DRIVER_INFO_1W = STRUCT('DRIVER_INFO_1W', {
 pName: LPWSTR
});

var DRIVER_INFO_2 = STRUCT('DRIVER_INFO_2', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR
});

var DRIVER_INFO_2W = STRUCT('DRIVER_INFO_2W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR
});

var DRIVER_INFO_3 = STRUCT('DRIVER_INFO_3', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR,
 pHelpFile: LPSTR,
 pDependentFiles: LPSTR,
 pMonitorName: LPSTR,
 pDefaultDataType: LPSTR
});

var DRIVER_INFO_3W = STRUCT('DRIVER_INFO_3W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR,
 pHelpFile: LPWSTR,
 pDependentFiles: LPWSTR,
 pMonitorName: LPWSTR,
 pDefaultDataType: LPWSTR
});

var DRIVER_INFO_4 = STRUCT('DRIVER_INFO_4', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR,
 pHelpFile: LPSTR,
 pDependentFiles: LPSTR,
 pMonitorName: LPSTR,
 pDefaultDataType: LPSTR,
 pszzPreviousNames: LPSTR
});

var DRIVER_INFO_4W = STRUCT('DRIVER_INFO_4W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR,
 pHelpFile: LPWSTR,
 pDependentFiles: LPWSTR,
 pMonitorName: LPWSTR,
 pDefaultDataType: LPWSTR,
 pszzPreviousNames: LPWSTR
});

var DRIVER_INFO_5 = STRUCT('DRIVER_INFO_5', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR,
 dwDriverAttributes: DWORD,
 dwConfigVersion: DWORD,
 dwDriverVersion: DWORD
});

var DRIVER_INFO_5W = STRUCT('DRIVER_INFO_5W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR,
 dwDriverAttributes: DWORD,
 dwConfigVersion: DWORD,
 dwDriverVersion: DWORD
});

var DRIVER_INFO_6 = STRUCT('DRIVER_INFO_6', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR,
 pHelpFile: LPSTR,
 pDependentFiles: LPSTR,
 pMonitorName: LPSTR,
 pDefaultDataType: LPSTR,
 pszzPreviousNames: LPSTR,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 pszMfgName: LPSTR,
 pszOEMUrl: LPSTR,
 pszHardwareID: LPSTR,
 pszProvider: LPSTR
});

var DRIVER_INFO_6W = STRUCT('DRIVER_INFO_6W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR,
 pHelpFile: LPWSTR,
 pDependentFiles: LPWSTR,
 pMonitorName: LPWSTR,
 pDefaultDataType: LPWSTR,
 pszzPreviousNames: LPWSTR,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 pszMfgName: LPWSTR,
 pszOEMUrl: LPWSTR,
 pszHardwareID: LPWSTR,
 pszProvider: LPWSTR
});

var DRIVER_INFO_8 = STRUCT('DRIVER_INFO_8', {
 cVersion: DWORD,
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDriverPath: LPSTR,
 pDataFile: LPSTR,
 pConfigFile: LPSTR,
 pHelpFile: LPSTR,
 pDependentFiles: LPSTR,
 pMonitorName: LPSTR,
 pDefaultDataType: LPSTR,
 pszzPreviousNames: LPSTR,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 pszMfgName: LPSTR,
 pszOEMUrl: LPSTR,
 pszHardwareID: LPSTR,
 pszProvider: LPSTR,
 pszPrintProcessor: LPSTR,
 pszVendorSetup: LPSTR,
 pszzColorProfiles: LPSTR,
 pszInfPath: LPSTR,
 dwPrinterDriverAttributes: DWORD,
 pszzCoreDriverDependencies: LPSTR,
 ftMinInboxDriverVerDate: FILETIME,
 dwlMinInboxDriverVerVersion: DWORDLONG
});

var DRIVER_INFO_8W = STRUCT('DRIVER_INFO_8W', {
 cVersion: DWORD,
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDriverPath: LPWSTR,
 pDataFile: LPWSTR,
 pConfigFile: LPWSTR,
 pHelpFile: LPWSTR,
 pDependentFiles: LPWSTR,
 pMonitorName: LPWSTR,
 pDefaultDataType: LPWSTR,
 pszzPreviousNames: LPWSTR,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 pszMfgName: LPWSTR,
 pszOEMUrl: LPWSTR,
 pszHardwareID: LPWSTR,
 pszProvider: LPWSTR,
 pszPrintProcessor: LPWSTR,
 pszVendorSetup: LPWSTR,
 pszzColorProfiles: LPWSTR,
 pszInfPath: LPWSTR,
 dwPrinterDriverAttributes: DWORD,
 pszzCoreDriverDependencies: LPWSTR,
 ftMinInboxDriverVerDate: FILETIME,
 dwlMinInboxDriverVerVersion: DWORDLONG
});

var DOC_INFO_1 = STRUCT('DOC_INFO_1', {
 pDocName: LPSTR,
 pOutputFile: LPSTR,
 pDatatype: LPSTR
});

var DOC_INFO_1W = STRUCT('DOC_INFO_1W', {
 pDocName: LPWSTR,
 pOutputFile: LPWSTR,
 pDatatype: LPWSTR
});

var FORM_INFO_1 = STRUCT('FORM_INFO_1', {
 Flags: DWORD,
 pName: LPSTR,
 Size: SIZEL,
 ImageableArea: RECTL
});

var FORM_INFO_1W = STRUCT('FORM_INFO_1W', {
 Flags: DWORD,
 pName: LPWSTR,
 Size: SIZEL,
 ImageableArea: RECTL
});

var FORM_INFO_2 = STRUCT('FORM_INFO_2', {
 Flags: DWORD,
 pName: LPCSTR,
 Size: SIZEL,
 ImageableArea: RECTL,
 pKeyword: LPCSTR,
 StringType: DWORD,
 pMuiDll: LPCSTR,
 dwResourceId: DWORD,
 pDisplayName: LPCSTR,
 wLangId: LANGID
});

var FORM_INFO_2W = STRUCT('FORM_INFO_2W', {
 Flags: DWORD,
 pName: LPCWSTR,
 Size: SIZEL,
 ImageableArea: RECTL,
 pKeyword: LPCSTR,
 StringType: DWORD,
 pMuiDll: LPCWSTR,
 dwResourceId: DWORD,
 pDisplayName: LPCWSTR,
 wLangId: LANGID
});

var DOC_INFO_2 = STRUCT('DOC_INFO_2', {
 pDocName: LPSTR,
 pOutputFile: LPSTR,
 pDatatype: LPSTR,
 dwMode: DWORD,
 JobId: DWORD
});

var DOC_INFO_2W = STRUCT('DOC_INFO_2W', {
 pDocName: LPWSTR,
 pOutputFile: LPWSTR,
 pDatatype: LPWSTR,
 dwMode: DWORD,
 JobId: DWORD
});

var DOC_INFO_3 = STRUCT('DOC_INFO_3', {
 pDocName: LPSTR,
 pOutputFile: LPSTR,
 pDatatype: LPSTR,
 dwFlags: DWORD
});

var DOC_INFO_3W = STRUCT('DOC_INFO_3W', {
 pDocName: LPWSTR,
 pOutputFile: LPWSTR,
 pDatatype: LPWSTR,
 dwFlags: DWORD
});

var PRINTPROCESSOR_INFO_1 = STRUCT('PRINTPROCESSOR_INFO_1', {
 pName: LPSTR
});

var PRINTPROCESSOR_INFO_1W = STRUCT('PRINTPROCESSOR_INFO_1W', {
 pName: LPWSTR
});

var PRINTPROCESSOR_CAPS_1 = STRUCT('PRINTPROCESSOR_CAPS_1', {
 dwLevel: DWORD,
 dwNupOptions: DWORD,
 dwPageOrderFlags: DWORD,
 dwNumberOfCopies: DWORD
});

var PRINTPROCESSOR_CAPS_2 = STRUCT('PRINTPROCESSOR_CAPS_2', {
 dwLevel: DWORD,
 dwNupOptions: DWORD,
 dwPageOrderFlags: DWORD,
 dwNumberOfCopies: DWORD,
 dwDuplexHandlingCaps: DWORD,
 dwNupDirectionCaps: DWORD,
 dwNupBorderCaps: DWORD,
 dwBookletHandlingCaps: DWORD,
 dwScalingCaps: DWORD
});

var PORT_INFO_1 = STRUCT('PORT_INFO_1', {
 pName: LPSTR
});

var PORT_INFO_1W = STRUCT('PORT_INFO_1W', {
 pName: LPWSTR
});

var PORT_INFO_2 = STRUCT('PORT_INFO_2', {
 pPortName: LPSTR,
 pMonitorName: LPSTR,
 pDescription: LPSTR,
 fPortType: DWORD,
 Reserved: DWORD
});

var PORT_INFO_2W = STRUCT('PORT_INFO_2W', {
 pPortName: LPWSTR,
 pMonitorName: LPWSTR,
 pDescription: LPWSTR,
 fPortType: DWORD,
 Reserved: DWORD
});

var PORT_INFO_3 = STRUCT('PORT_INFO_3', {
 dwStatus: DWORD,
 pszStatus: LPSTR,
 dwSeverity: DWORD
});

var PORT_INFO_3W = STRUCT('PORT_INFO_3W', {
 dwStatus: DWORD,
 pszStatus: LPWSTR,
 dwSeverity: DWORD
});

var MONITOR_INFO_1 = STRUCT('MONITOR_INFO_1', {
 pName: LPSTR
});

var MONITOR_INFO_1W = STRUCT('MONITOR_INFO_1W', {
 pName: LPWSTR
});

var MONITOR_INFO_2 = STRUCT('MONITOR_INFO_2', {
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDLLName: LPSTR
});

var MONITOR_INFO_2W = STRUCT('MONITOR_INFO_2W', {
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDLLName: LPWSTR
});

var DATATYPES_INFO_1 = STRUCT('DATATYPES_INFO_1', {
 pName: LPSTR
});

var DATATYPES_INFO_1W = STRUCT('DATATYPES_INFO_1W', {
 pName: LPWSTR
});

var PRINTER_DEFAULTS = STRUCT('PRINTER_DEFAULTS', {
 pDatatype: LPSTR,
 pDevMode: LPDEVMODEA,
 DesiredAccess: ACCESS_MASK
});

var PRINTER_DEFAULTSW = STRUCT('PRINTER_DEFAULTSW', {
 pDatatype: LPWSTR,
 pDevMode: LPDEVMODEW,
 DesiredAccess: ACCESS_MASK
});

var PRINTER_ENUM_VALUES = STRUCT('PRINTER_ENUM_VALUES', {
 pValueName: LPSTR,
 cbValueName: DWORD,
 dwType: DWORD,
 pData: LPBYTE,
 cbData: DWORD
});

var PRINTER_ENUM_VALUESW = STRUCT('PRINTER_ENUM_VALUESW', {
 pValueName: LPWSTR,
 cbValueName: DWORD,
 dwType: DWORD,
 pData: LPBYTE,
 cbData: DWORD
});

var PRINTER_NOTIFY_OPTIONS_TYPE = STRUCT('PRINTER_NOTIFY_OPTIONS_TYPE', {
 Type: WORD,
 Reserved0: WORD,
 Reserved1: DWORD,
 Reserved2: DWORD,
 Count: DWORD,
 pFields: PWORD
});

var PRINTER_NOTIFY_OPTIONS = STRUCT('PRINTER_NOTIFY_OPTIONS', {
 Version: DWORD,
 Flags: DWORD,
 Count: DWORD,
 pTypes: PPRINTER_NOTIFY_OPTIONS_TYPE
});

var PRINTER_NOTIFY_INFO_DATA = STRUCT('PRINTER_NOTIFY_INFO_DATA', {
 Type: WORD,
 Field: WORD,
 Reserved: DWORD,
 Id: DWORD,
 NotifyData: 
});

var undefined = STRUCT('undefined', {
 cbBuf: DWORD,
 pBuf: LPVOID
});

var PRINTER_NOTIFY_INFO = STRUCT('PRINTER_NOTIFY_INFO', {
 Version: DWORD,
 Flags: DWORD,
 Count: DWORD,
 aData: pointer
});

var BINARY_CONTAINER = STRUCT('BINARY_CONTAINER', {
 cbBuf: DWORD,
 pData: LPBYTE
});

var BIDI_DATA = STRUCT('BIDI_DATA', {
 dwBidiType: DWORD,
 u: 
});

var BIDI_REQUEST_DATA = STRUCT('BIDI_REQUEST_DATA', {
 dwReqNumber: DWORD,
 pSchema: LPWSTR,
 data: BIDI_DATA
});

var BIDI_REQUEST_CONTAINER = STRUCT('BIDI_REQUEST_CONTAINER', {
 Version: DWORD,
 Flags: DWORD,
 Count: DWORD,
 aData: pointer
});

var BIDI_RESPONSE_DATA = STRUCT('BIDI_RESPONSE_DATA', {
 dwResult: DWORD,
 dwReqNumber: DWORD,
 pSchema: LPWSTR,
 data: BIDI_DATA
});

var BIDI_RESPONSE_CONTAINER = STRUCT('BIDI_RESPONSE_CONTAINER', {
 Version: DWORD,
 Flags: DWORD,
 Count: DWORD,
 aData: pointer
});

var PROVIDOR_INFO_1 = STRUCT('PROVIDOR_INFO_1', {
 pName: LPSTR,
 pEnvironment: LPSTR,
 pDLLName: LPSTR
});

var PROVIDOR_INFO_1W = STRUCT('PROVIDOR_INFO_1W', {
 pName: LPWSTR,
 pEnvironment: LPWSTR,
 pDLLName: LPWSTR
});

var PROVIDOR_INFO_2 = STRUCT('PROVIDOR_INFO_2', {
 pOrder: LPSTR
});

var PROVIDOR_INFO_2W = STRUCT('PROVIDOR_INFO_2W', {
 pOrder: LPWSTR
});

var PRINTER_OPTIONS = STRUCT('PRINTER_OPTIONS', {
 cbSize: UINT,
 dwFlags: DWORD
});

var PRINTER_OPTIONSW = STRUCT('PRINTER_OPTIONSW', {
 cbSize: UINT,
 dwFlags: DWORD
});

var PRINTER_CONNECTION_INFO_1 = STRUCT('PRINTER_CONNECTION_INFO_1', {
 dwFlags: DWORD,
 pszDriverName: LPSTR
});

var PRINTER_CONNECTION_INFO_1W = STRUCT('PRINTER_CONNECTION_INFO_1W', {
 dwFlags: DWORD,
 pszDriverName: LPWSTR
});

var CORE_PRINTER_DRIVER = STRUCT('CORE_PRINTER_DRIVER', {
 CoreDriverGUID: GUID,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 szPackageID: pointer
});

var CORE_PRINTER_DRIVERW = STRUCT('CORE_PRINTER_DRIVERW', {
 CoreDriverGUID: GUID,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 szPackageID: pointer
});

var PrintPropertyValue = STRUCT('PrintPropertyValue', {
 ePropertyType: EPrintPropertyType,
 value: 
});

var undefined = STRUCT('undefined', {
 cbBuf: DWORD,
 pBuf: LPVOID
});

var PrintNamedProperty = STRUCT('PrintNamedProperty', {
 propertyName: PTR(ushort),
 propertyValue: PrintPropertyValue
});

var PrintPropertiesCollection = STRUCT('PrintPropertiesCollection', {
 numberOfProperties: ULONG,
 propertiesCollection: PTR(uint)
});

var PRINT_EXECUTION_DATA = STRUCT('PRINT_EXECUTION_DATA', {
 context: PRINT_EXECUTION_CONTEXT,
 clientAppPID: DWORD
});

var div_t = STRUCT('div_t', {
 quot: int,
 rem: int
});

var ldiv_t = STRUCT('ldiv_t', {
 quot: long,
 rem: long
});

var lldiv_t = STRUCT('lldiv_t', {
 quot: longlong,
 rem: longlong
});

var _LDOUBLE = STRUCT('_LDOUBLE', {
 ld: pointer
});

var _CRT_DOUBLE = STRUCT('_CRT_DOUBLE', {
 x: double
});

var _CRT_FLOAT = STRUCT('_CRT_FLOAT', {
 f: float
});

var _LONGDOUBLE = STRUCT('_LONGDOUBLE', {
 x: pointer
});

var _LDBL12 = STRUCT('_LDBL12', {
 ld12: pointer
});

var IUnknown = STRUCT('IUnknown', {
 lpVtbl: PTR(IUnknownVtbl)
});

var AsyncIUnknown = STRUCT('AsyncIUnknown', {
 lpVtbl: PTR(AsyncIUnknownVtbl)
});

var IClassFactory = STRUCT('IClassFactory', {
 lpVtbl: PTR(IClassFactoryVtbl)
});

var IUnknownVtbl = STRUCT('IUnknownVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer)
});

var AsyncIUnknownVtbl = STRUCT('AsyncIUnknownVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_QueryInterface: PTR(pointer),
 Finish_QueryInterface: PTR(pointer),
 Begin_AddRef: PTR(pointer),
 Finish_AddRef: PTR(pointer),
 Begin_Release: PTR(pointer),
 Finish_Release: PTR(pointer)
});

var IClassFactoryVtbl = STRUCT('IClassFactoryVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateInstance: PTR(pointer),
 LockServer: PTR(pointer)
});

var IMarshal = STRUCT('IMarshal', {
 lpVtbl: PTR(IMarshalVtbl)
});

var IMarshal2 = STRUCT('IMarshal2', {
 lpVtbl: PTR(IMarshal2Vtbl)
});

var IMalloc = STRUCT('IMalloc', {
 lpVtbl: PTR(IMallocVtbl)
});

var IMallocSpy = STRUCT('IMallocSpy', {
 lpVtbl: PTR(IMallocSpyVtbl)
});

var IStdMarshalInfo = STRUCT('IStdMarshalInfo', {
 lpVtbl: PTR(IStdMarshalInfoVtbl)
});

var IExternalConnection = STRUCT('IExternalConnection', {
 lpVtbl: PTR(IExternalConnectionVtbl)
});

var IMultiQI = STRUCT('IMultiQI', {
 lpVtbl: PTR(IMultiQIVtbl)
});

var AsyncIMultiQI = STRUCT('AsyncIMultiQI', {
 lpVtbl: PTR(AsyncIMultiQIVtbl)
});

var IInternalUnknown = STRUCT('IInternalUnknown', {
 lpVtbl: PTR(IInternalUnknownVtbl)
});

var IEnumUnknown = STRUCT('IEnumUnknown', {
 lpVtbl: PTR(IEnumUnknownVtbl)
});

var IBindCtx = STRUCT('IBindCtx', {
 lpVtbl: PTR(IBindCtxVtbl)
});

var IEnumMoniker = STRUCT('IEnumMoniker', {
 lpVtbl: PTR(IEnumMonikerVtbl)
});

var IRunnableObject = STRUCT('IRunnableObject', {
 lpVtbl: PTR(IRunnableObjectVtbl)
});

var IRunningObjectTable = STRUCT('IRunningObjectTable', {
 lpVtbl: PTR(IRunningObjectTableVtbl)
});

var IPersist = STRUCT('IPersist', {
 lpVtbl: PTR(IPersistVtbl)
});

var IPersistStream = STRUCT('IPersistStream', {
 lpVtbl: PTR(IPersistStreamVtbl)
});

var IMoniker = STRUCT('IMoniker', {
 lpVtbl: PTR(IMonikerVtbl)
});

var IROTData = STRUCT('IROTData', {
 lpVtbl: PTR(IROTDataVtbl)
});

var IEnumString = STRUCT('IEnumString', {
 lpVtbl: PTR(IEnumStringVtbl)
});

var ISequentialStream = STRUCT('ISequentialStream', {
 lpVtbl: PTR(ISequentialStreamVtbl)
});

var IStream = STRUCT('IStream', {
 lpVtbl: PTR(IStreamVtbl)
});

var IEnumSTATSTG = STRUCT('IEnumSTATSTG', {
 lpVtbl: PTR(IEnumSTATSTGVtbl)
});

var IStorage = STRUCT('IStorage', {
 lpVtbl: PTR(IStorageVtbl)
});

var IPersistFile = STRUCT('IPersistFile', {
 lpVtbl: PTR(IPersistFileVtbl)
});

var IPersistStorage = STRUCT('IPersistStorage', {
 lpVtbl: PTR(IPersistStorageVtbl)
});

var ILockBytes = STRUCT('ILockBytes', {
 lpVtbl: PTR(ILockBytesVtbl)
});

var IEnumFORMATETC = STRUCT('IEnumFORMATETC', {
 lpVtbl: PTR(IEnumFORMATETCVtbl)
});

var IEnumSTATDATA = STRUCT('IEnumSTATDATA', {
 lpVtbl: PTR(IEnumSTATDATAVtbl)
});

var IRootStorage = STRUCT('IRootStorage', {
 lpVtbl: PTR(IRootStorageVtbl)
});

var IAdviseSink = STRUCT('IAdviseSink', {
 lpVtbl: PTR(IAdviseSinkVtbl)
});

var AsyncIAdviseSink = STRUCT('AsyncIAdviseSink', {
 lpVtbl: PTR(AsyncIAdviseSinkVtbl)
});

var IAdviseSink2 = STRUCT('IAdviseSink2', {
 lpVtbl: PTR(IAdviseSink2Vtbl)
});

var AsyncIAdviseSink2 = STRUCT('AsyncIAdviseSink2', {
 lpVtbl: PTR(AsyncIAdviseSink2Vtbl)
});

var IDataObject = STRUCT('IDataObject', {
 lpVtbl: PTR(IDataObjectVtbl)
});

var IDataAdviseHolder = STRUCT('IDataAdviseHolder', {
 lpVtbl: PTR(IDataAdviseHolderVtbl)
});

var IMessageFilter = STRUCT('IMessageFilter', {
 lpVtbl: PTR(IMessageFilterVtbl)
});

var IRpcChannelBuffer2 = STRUCT('IRpcChannelBuffer2', {
 lpVtbl: PTR(IRpcChannelBuffer2Vtbl)
});

var IAsyncRpcChannelBuffer = STRUCT('IAsyncRpcChannelBuffer', {
 lpVtbl: PTR(IAsyncRpcChannelBufferVtbl)
});

var IRpcChannelBuffer3 = STRUCT('IRpcChannelBuffer3', {
 lpVtbl: PTR(IRpcChannelBuffer3Vtbl)
});

var IRpcSyntaxNegotiate = STRUCT('IRpcSyntaxNegotiate', {
 lpVtbl: PTR(IRpcSyntaxNegotiateVtbl)
});

var IRpcProxyBuffer = STRUCT('IRpcProxyBuffer', {
 lpVtbl: PTR(IRpcProxyBufferVtbl)
});

var IPSFactoryBuffer = STRUCT('IPSFactoryBuffer', {
 lpVtbl: PTR(IPSFactoryBufferVtbl)
});

var IChannelHook = STRUCT('IChannelHook', {
 lpVtbl: PTR(IChannelHookVtbl)
});

var IClientSecurity = STRUCT('IClientSecurity', {
 lpVtbl: PTR(IClientSecurityVtbl)
});

var IServerSecurity = STRUCT('IServerSecurity', {
 lpVtbl: PTR(IServerSecurityVtbl)
});

var IClassActivator = STRUCT('IClassActivator', {
 lpVtbl: PTR(IClassActivatorVtbl)
});

var IRpcOptions = STRUCT('IRpcOptions', {
 lpVtbl: PTR(IRpcOptionsVtbl)
});

var IGlobalOptions = STRUCT('IGlobalOptions', {
 lpVtbl: PTR(IGlobalOptionsVtbl)
});

var IFillLockBytes = STRUCT('IFillLockBytes', {
 lpVtbl: PTR(IFillLockBytesVtbl)
});

var IProgressNotify = STRUCT('IProgressNotify', {
 lpVtbl: PTR(IProgressNotifyVtbl)
});

var ILayoutStorage = STRUCT('ILayoutStorage', {
 lpVtbl: PTR(ILayoutStorageVtbl)
});

var IBlockingLock = STRUCT('IBlockingLock', {
 lpVtbl: PTR(IBlockingLockVtbl)
});

var ITimeAndNoticeControl = STRUCT('ITimeAndNoticeControl', {
 lpVtbl: PTR(ITimeAndNoticeControlVtbl)
});

var IOplockStorage = STRUCT('IOplockStorage', {
 lpVtbl: PTR(IOplockStorageVtbl)
});

var ISurrogate = STRUCT('ISurrogate', {
 lpVtbl: PTR(ISurrogateVtbl)
});

var IGlobalInterfaceTable = STRUCT('IGlobalInterfaceTable', {
 lpVtbl: PTR(IGlobalInterfaceTableVtbl)
});

var IDirectWriterLock = STRUCT('IDirectWriterLock', {
 lpVtbl: PTR(IDirectWriterLockVtbl)
});

var ISynchronize = STRUCT('ISynchronize', {
 lpVtbl: PTR(ISynchronizeVtbl)
});

var ISynchronizeHandle = STRUCT('ISynchronizeHandle', {
 lpVtbl: PTR(ISynchronizeHandleVtbl)
});

var ISynchronizeEvent = STRUCT('ISynchronizeEvent', {
 lpVtbl: PTR(ISynchronizeEventVtbl)
});

var ISynchronizeContainer = STRUCT('ISynchronizeContainer', {
 lpVtbl: PTR(ISynchronizeContainerVtbl)
});

var ISynchronizeMutex = STRUCT('ISynchronizeMutex', {
 lpVtbl: PTR(ISynchronizeMutexVtbl)
});

var ICancelMethodCalls = STRUCT('ICancelMethodCalls', {
 lpVtbl: PTR(ICancelMethodCallsVtbl)
});

var IAsyncManager = STRUCT('IAsyncManager', {
 lpVtbl: PTR(IAsyncManagerVtbl)
});

var ICallFactory = STRUCT('ICallFactory', {
 lpVtbl: PTR(ICallFactoryVtbl)
});

var IRpcHelper = STRUCT('IRpcHelper', {
 lpVtbl: PTR(IRpcHelperVtbl)
});

var IReleaseMarshalBuffers = STRUCT('IReleaseMarshalBuffers', {
 lpVtbl: PTR(IReleaseMarshalBuffersVtbl)
});

var IWaitMultiple = STRUCT('IWaitMultiple', {
 lpVtbl: PTR(IWaitMultipleVtbl)
});

var IUrlMon = STRUCT('IUrlMon', {
 lpVtbl: PTR(IUrlMonVtbl)
});

var IForegroundTransfer = STRUCT('IForegroundTransfer', {
 lpVtbl: PTR(IForegroundTransferVtbl)
});

var IAddrTrackingControl = STRUCT('IAddrTrackingControl', {
 lpVtbl: PTR(IAddrTrackingControlVtbl)
});

var IAddrExclusionControl = STRUCT('IAddrExclusionControl', {
 lpVtbl: PTR(IAddrExclusionControlVtbl)
});

var IPipeByte = STRUCT('IPipeByte', {
 lpVtbl: PTR(IPipeByteVtbl)
});

var AsyncIPipeByte = STRUCT('AsyncIPipeByte', {
 lpVtbl: PTR(AsyncIPipeByteVtbl)
});

var IPipeLong = STRUCT('IPipeLong', {
 lpVtbl: PTR(IPipeLongVtbl)
});

var AsyncIPipeLong = STRUCT('AsyncIPipeLong', {
 lpVtbl: PTR(AsyncIPipeLongVtbl)
});

var IPipeDouble = STRUCT('IPipeDouble', {
 lpVtbl: PTR(IPipeDoubleVtbl)
});

var AsyncIPipeDouble = STRUCT('AsyncIPipeDouble', {
 lpVtbl: PTR(AsyncIPipeDoubleVtbl)
});

var IThumbnailExtractor = STRUCT('IThumbnailExtractor', {
 lpVtbl: PTR(IThumbnailExtractorVtbl)
});

var IDummyHICONIncluder = STRUCT('IDummyHICONIncluder', {
 lpVtbl: PTR(IDummyHICONIncluderVtbl)
});




var IProcessLock = STRUCT('IProcessLock', {
 lpVtbl: PTR(IProcessLockVtbl)
});

var ISurrogateService = STRUCT('ISurrogateService', {
 lpVtbl: PTR(ISurrogateServiceVtbl)
});

var IComThreadingInfo = STRUCT('IComThreadingInfo', {
 lpVtbl: PTR(IComThreadingInfoVtbl)
});

var IProcessInitControl = STRUCT('IProcessInitControl', {
 lpVtbl: PTR(IProcessInitControlVtbl)
});

var IInitializeSpy = STRUCT('IInitializeSpy', {
 lpVtbl: PTR(IInitializeSpyVtbl)
});

var COSERVERINFO = STRUCT('COSERVERINFO', {
 dwReserved1: DWORD,
 pwszName: LPWSTR,
 pAuthInfo: PTR(uint),
 dwReserved2: DWORD
});

var IMarshalVtbl = STRUCT('IMarshalVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetUnmarshalClass: PTR(pointer),
 GetMarshalSizeMax: PTR(pointer),
 MarshalInterface: PTR(pointer),
 UnmarshalInterface: PTR(pointer),
 ReleaseMarshalData: PTR(pointer),
 DisconnectObject: PTR(pointer)
});

var IMarshal2Vtbl = STRUCT('IMarshal2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetUnmarshalClass: PTR(pointer),
 GetMarshalSizeMax: PTR(pointer),
 MarshalInterface: PTR(pointer),
 UnmarshalInterface: PTR(pointer),
 ReleaseMarshalData: PTR(pointer),
 DisconnectObject: PTR(pointer)
});

var IMallocVtbl = STRUCT('IMallocVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Alloc: PTR(pointer),
 Realloc: PTR(pointer),
 Free: PTR(pointer),
 GetSize: PTR(pointer),
 DidAlloc: PTR(pointer),
 HeapMinimize: PTR(pointer)
});

var IMallocSpyVtbl = STRUCT('IMallocSpyVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 PreAlloc: PTR(pointer),
 PostAlloc: PTR(pointer),
 PreFree: PTR(pointer),
 PostFree: PTR(pointer),
 PreRealloc: PTR(pointer),
 PostRealloc: PTR(pointer),
 PreGetSize: PTR(pointer),
 PostGetSize: PTR(pointer),
 PreDidAlloc: PTR(pointer),
 PostDidAlloc: PTR(pointer),
 PreHeapMinimize: PTR(pointer),
 PostHeapMinimize: PTR(pointer)
});

var IStdMarshalInfoVtbl = STRUCT('IStdMarshalInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassForHandler: PTR(pointer)
});

var IExternalConnectionVtbl = STRUCT('IExternalConnectionVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AddConnection: PTR(pointer),
 ReleaseConnection: PTR(pointer)
});

var MULTI_QI = STRUCT('MULTI_QI', {
 pIID: PTR(uint),
 pItf: PTR(uint),
 hr: HRESULT
});

var IMultiQIVtbl = STRUCT('IMultiQIVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryMultipleInterfaces: PTR(pointer)
});

var AsyncIMultiQIVtbl = STRUCT('AsyncIMultiQIVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_QueryMultipleInterfaces: PTR(pointer),
 Finish_QueryMultipleInterfaces: PTR(pointer)
});

var IInternalUnknownVtbl = STRUCT('IInternalUnknownVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryInternalInterface: PTR(pointer)
});

var IEnumUnknownVtbl = STRUCT('IEnumUnknownVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var BIND_OPTS = STRUCT('BIND_OPTS', {
 cbStruct: DWORD,
 grfFlags: DWORD,
 grfMode: DWORD,
 dwTickCountDeadline: DWORD
});

var BIND_OPTS2 = STRUCT('BIND_OPTS2', {
 cbStruct: DWORD,
 grfFlags: DWORD,
 grfMode: DWORD,
 dwTickCountDeadline: DWORD,
 dwTrackFlags: DWORD,
 dwClassContext: DWORD,
 locale: LCID,
 pServerInfo: PTR(uint)
});

var BIND_OPTS3 = STRUCT('BIND_OPTS3', {
 cbStruct: DWORD,
 grfFlags: DWORD,
 grfMode: DWORD,
 dwTickCountDeadline: DWORD,
 dwTrackFlags: DWORD,
 dwClassContext: DWORD,
 locale: LCID,
 pServerInfo: PTR(uint),
 hwnd: HWND
});

var IBindCtxVtbl = STRUCT('IBindCtxVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 RegisterObjectBound: PTR(pointer),
 RevokeObjectBound: PTR(pointer),
 ReleaseBoundObjects: PTR(pointer),
 SetBindOptions: PTR(pointer),
 GetBindOptions: PTR(pointer),
 GetRunningObjectTable: PTR(pointer),
 RegisterObjectParam: PTR(pointer),
 GetObjectParam: PTR(pointer),
 EnumObjectParam: PTR(pointer),
 RevokeObjectParam: PTR(pointer)
});

var IEnumMonikerVtbl = STRUCT('IEnumMonikerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var IRunnableObjectVtbl = STRUCT('IRunnableObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetRunningClass: PTR(pointer),
 Run: PTR(pointer),
 IsRunning: PTR(pointer),
 LockRunning: PTR(pointer),
 SetContainedObject: PTR(pointer)
});

var IRunningObjectTableVtbl = STRUCT('IRunningObjectTableVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Register: PTR(pointer),
 Revoke: PTR(pointer),
 IsRunning: PTR(pointer),
 GetObjectA: PTR(pointer),
 NoteChangeTime: PTR(pointer),
 GetTimeOfLastChange: PTR(pointer),
 EnumRunning: PTR(pointer)
});

var IPersistVtbl = STRUCT('IPersistVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer)
});

var IPersistStreamVtbl = STRUCT('IPersistStreamVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer),
 IsDirty: PTR(pointer),
 Load: PTR(pointer),
 Save: PTR(pointer),
 GetSizeMax: PTR(pointer)
});

var IMonikerVtbl = STRUCT('IMonikerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer),
 IsDirty: PTR(pointer),
 Load: PTR(pointer),
 Save: PTR(pointer),
 GetSizeMax: PTR(pointer),
 BindToObject: PTR(pointer),
 BindToStorage: PTR(pointer),
 Reduce: PTR(pointer),
 ComposeWith: PTR(pointer),
 Enum: PTR(pointer),
 IsEqual: PTR(pointer),
 Hash: PTR(pointer),
 IsRunning: PTR(pointer),
 GetTimeOfLastChange: PTR(pointer),
 Inverse: PTR(pointer),
 CommonPrefixWith: PTR(pointer),
 RelativePathTo: PTR(pointer),
 GetDisplayName: PTR(pointer),
 ParseDisplayName: PTR(pointer),
 IsSystemMoniker: PTR(pointer)
});

var IROTDataVtbl = STRUCT('IROTDataVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetComparisonData: PTR(pointer)
});

var IEnumStringVtbl = STRUCT('IEnumStringVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var ISequentialStreamVtbl = STRUCT('ISequentialStreamVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Read: PTR(pointer),
 Write: PTR(pointer)
});

var STATSTG = STRUCT('STATSTG', {
 pwcsName: LPOLESTR,
 type: DWORD,
 cbSize: ULARGE_INTEGER,
 mtime: FILETIME,
 ctime: FILETIME,
 atime: FILETIME,
 grfMode: DWORD,
 grfLocksSupported: DWORD,
 clsid: CLSID,
 grfStateBits: DWORD,
 reserved: DWORD
});

var IStreamVtbl = STRUCT('IStreamVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Read: PTR(pointer),
 Write: PTR(pointer),
 Seek: PTR(pointer),
 SetSize: PTR(pointer),
 CopyTo: PTR(pointer),
 Commit: PTR(pointer),
 Revert: PTR(pointer),
 LockRegion: PTR(pointer),
 UnlockRegion: PTR(pointer),
 Stat: PTR(pointer),
 Clone: PTR(pointer)
});

var IEnumSTATSTGVtbl = STRUCT('IEnumSTATSTGVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var RemSNB = STRUCT('RemSNB', {
 ulCntStr: ulong,
 ulCntChar: ulong,
 rgString: pointer
});

var IStorageVtbl = STRUCT('IStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateStream: PTR(pointer),
 OpenStream: PTR(pointer),
 CreateStorage: PTR(pointer),
 OpenStorage: PTR(pointer),
 CopyTo: PTR(pointer),
 MoveElementTo: PTR(pointer),
 Commit: PTR(pointer),
 Revert: PTR(pointer),
 EnumElements: PTR(pointer),
 DestroyElement: PTR(pointer),
 RenameElement: PTR(pointer),
 SetElementTimes: PTR(pointer),
 SetClass: PTR(pointer),
 SetStateBits: PTR(pointer),
 Stat: PTR(pointer)
});

var IPersistFileVtbl = STRUCT('IPersistFileVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer),
 IsDirty: PTR(pointer),
 Load: PTR(pointer),
 Save: PTR(pointer),
 SaveCompleted: PTR(pointer),
 GetCurFile: PTR(pointer)
});

var IPersistStorageVtbl = STRUCT('IPersistStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer),
 IsDirty: PTR(pointer),
 InitNew: PTR(pointer),
 Load: PTR(pointer),
 Save: PTR(pointer),
 SaveCompleted: PTR(pointer),
 HandsOffStorage: PTR(pointer)
});

var ILockBytesVtbl = STRUCT('ILockBytesVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ReadAt: PTR(pointer),
 WriteAt: PTR(pointer),
 Flush: PTR(pointer),
 SetSize: PTR(pointer),
 LockRegion: PTR(pointer),
 UnlockRegion: PTR(pointer),
 Stat: PTR(pointer)
});

var DVTARGETDEVICE = STRUCT('DVTARGETDEVICE', {
 tdSize: DWORD,
 tdDriverNameOffset: WORD,
 tdDeviceNameOffset: WORD,
 tdPortNameOffset: WORD,
 tdExtDevmodeOffset: WORD,
 tdData: pointer
});

var FORMATETC = STRUCT('FORMATETC', {
 cfFormat: CLIPFORMAT,
 ptd: PTR(uint),
 dwAspect: DWORD,
 lindex: LONG,
 tymed: DWORD
});

var IEnumFORMATETCVtbl = STRUCT('IEnumFORMATETCVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var STATDATA = STRUCT('STATDATA', {
 formatetc: FORMATETC,
 advf: DWORD,
 pAdvSink: PTR(uint),
 dwConnection: DWORD
});

var IEnumSTATDATAVtbl = STRUCT('IEnumSTATDATAVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var IRootStorageVtbl = STRUCT('IRootStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SwitchToFile: PTR(pointer)
});

var RemSTGMEDIUM = STRUCT('RemSTGMEDIUM', {
 tymed: DWORD,
 dwHandleType: DWORD,
 pData: ulong,
 pUnkForRelease: ulong,
 cbData: ulong,
 data: pointer
});

var ASYNC_STGMEDIUM = STRUCT('ASYNC_STGMEDIUM', {
 tymed: DWORD,
 pUnkForRelease: PTR(uint)
});

var GDI_OBJECT = STRUCT('GDI_OBJECT', {
 ObjectType: DWORD,
 u: __MIDL_IAdviseSink_0002
});

var userSTGMEDIUM = STRUCT('userSTGMEDIUM', {
 pUnkForRelease: PTR(uint)
});

var _STGMEDIUM_UNION = STRUCT('_STGMEDIUM_UNION', {
 tymed: DWORD,
 u: __MIDL_IAdviseSink_0003
});

var userFLAG_STGMEDIUM = STRUCT('userFLAG_STGMEDIUM', {
 ContextFlags: long,
 fPassOwnership: long,
 Stgmed: userSTGMEDIUM
});

var FLAG_STGMEDIUM = STRUCT('FLAG_STGMEDIUM', {
 ContextFlags: long,
 fPassOwnership: long,
 Stgmed: STGMEDIUM
});

var IAdviseSinkVtbl = STRUCT('IAdviseSinkVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnDataChange: PTR(pointer),
 OnViewChange: PTR(pointer),
 OnRename: PTR(pointer),
 OnSave: PTR(pointer),
 OnClose: PTR(pointer)
});

var AsyncIAdviseSinkVtbl = STRUCT('AsyncIAdviseSinkVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_OnDataChange: PTR(pointer),
 Finish_OnDataChange: PTR(pointer),
 Begin_OnViewChange: PTR(pointer),
 Finish_OnViewChange: PTR(pointer),
 Begin_OnRename: PTR(pointer),
 Finish_OnRename: PTR(pointer),
 Begin_OnSave: PTR(pointer),
 Finish_OnSave: PTR(pointer),
 Begin_OnClose: PTR(pointer),
 Finish_OnClose: PTR(pointer)
});

var IAdviseSink2Vtbl = STRUCT('IAdviseSink2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnDataChange: PTR(pointer),
 OnViewChange: PTR(pointer),
 OnRename: PTR(pointer),
 OnSave: PTR(pointer),
 OnClose: PTR(pointer),
 OnLinkSrcChange: PTR(pointer)
});

var AsyncIAdviseSink2Vtbl = STRUCT('AsyncIAdviseSink2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_OnDataChange: PTR(pointer),
 Finish_OnDataChange: PTR(pointer),
 Begin_OnViewChange: PTR(pointer),
 Finish_OnViewChange: PTR(pointer),
 Begin_OnRename: PTR(pointer),
 Finish_OnRename: PTR(pointer),
 Begin_OnSave: PTR(pointer),
 Finish_OnSave: PTR(pointer),
 Begin_OnClose: PTR(pointer),
 Finish_OnClose: PTR(pointer),
 Begin_OnLinkSrcChange: PTR(pointer),
 Finish_OnLinkSrcChange: PTR(pointer)
});

var IDataObjectVtbl = STRUCT('IDataObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetData: PTR(pointer),
 GetDataHere: PTR(pointer),
 QueryGetData: PTR(pointer),
 GetCanonicalFormatEtc: PTR(pointer),
 SetData: PTR(pointer),
 EnumFormatEtc: PTR(pointer),
 DAdvise: PTR(pointer),
 DUnadvise: PTR(pointer),
 EnumDAdvise: PTR(pointer)
});

var IDataAdviseHolderVtbl = STRUCT('IDataAdviseHolderVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Advise: PTR(pointer),
 Unadvise: PTR(pointer),
 EnumAdvise: PTR(pointer),
 SendOnDataChange: PTR(pointer)
});

var INTERFACEINFO = STRUCT('INTERFACEINFO', {
 pUnk: PTR(uint),
 iid: IID,
 wMethod: WORD
});

var IMessageFilterVtbl = STRUCT('IMessageFilterVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 HandleInComingCall: PTR(pointer),
 RetryRejectedCall: PTR(pointer),
 MessagePending: PTR(pointer)
});

var RPCOLEMESSAGE = STRUCT('RPCOLEMESSAGE', {
 reserved1: PTR('void'),
 dataRepresentation: RPCOLEDATAREP,
 Buffer: PTR('void'),
 cbBuffer: ULONG,
 iMethod: ULONG,
 reserved2: pointer,
 rpcFlags: ULONG
});

var IRpcChannelBufferVtbl = STRUCT('IRpcChannelBufferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBuffer: PTR(pointer),
 SendReceive: PTR(pointer),
 FreeBuffer: PTR(pointer),
 GetDestCtx: PTR(pointer),
 IsConnected: PTR(pointer)
});

var IRpcChannelBuffer2Vtbl = STRUCT('IRpcChannelBuffer2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBuffer: PTR(pointer),
 SendReceive: PTR(pointer),
 FreeBuffer: PTR(pointer),
 GetDestCtx: PTR(pointer),
 IsConnected: PTR(pointer),
 GetProtocolVersion: PTR(pointer)
});

var IAsyncRpcChannelBufferVtbl = STRUCT('IAsyncRpcChannelBufferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBuffer: PTR(pointer),
 SendReceive: PTR(pointer),
 FreeBuffer: PTR(pointer),
 GetDestCtx: PTR(pointer),
 IsConnected: PTR(pointer),
 GetProtocolVersion: PTR(pointer),
 Send: PTR(pointer),
 Receive: PTR(pointer),
 GetDestCtxEx: PTR(pointer)
});

var IRpcChannelBuffer3Vtbl = STRUCT('IRpcChannelBuffer3Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBuffer: PTR(pointer),
 SendReceive: PTR(pointer),
 FreeBuffer: PTR(pointer),
 GetDestCtx: PTR(pointer),
 IsConnected: PTR(pointer),
 GetProtocolVersion: PTR(pointer),
 Send: PTR(pointer),
 Receive: PTR(pointer),
 Cancel: PTR(pointer),
 GetCallContext: PTR(pointer),
 GetDestCtxEx: PTR(pointer),
 GetState: PTR(pointer),
 RegisterAsync: PTR(pointer)
});

var IRpcSyntaxNegotiateVtbl = STRUCT('IRpcSyntaxNegotiateVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 NegotiateSyntax: PTR(pointer)
});

var IRpcProxyBufferVtbl = STRUCT('IRpcProxyBufferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Connect: PTR(pointer),
 Disconnect: PTR(pointer)
});

var IRpcStubBufferVtbl = STRUCT('IRpcStubBufferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Connect: PTR(pointer),
 Disconnect: PTR(pointer),
 Invoke: PTR(pointer),
 IsIIDSupported: PTR(pointer),
 CountRefs: PTR(pointer),
 DebugServerQueryInterface: PTR(pointer),
 DebugServerRelease: PTR(pointer)
});

var IPSFactoryBufferVtbl = STRUCT('IPSFactoryBufferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateProxy: PTR(pointer),
 CreateStub: PTR(pointer)
});

var SChannelHookCallInfo = STRUCT('SChannelHookCallInfo', {
 iid: IID,
 cbSize: DWORD,
 uCausality: GUID,
 dwServerPid: DWORD,
 iMethod: DWORD,
 pObject: PTR('void')
});

var IChannelHookVtbl = STRUCT('IChannelHookVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ClientGetSize: PTR(pointer),
 ClientFillBuffer: PTR(pointer),
 ClientNotify: PTR(pointer),
 ServerNotify: PTR(pointer),
 ServerGetSize: PTR(pointer),
 ServerFillBuffer: PTR(pointer)
});

var SOLE_AUTHENTICATION_SERVICE = STRUCT('SOLE_AUTHENTICATION_SERVICE', {
 dwAuthnSvc: DWORD,
 dwAuthzSvc: DWORD,
 pPrincipalName: PTR(ushort),
 hr: HRESULT
});

var SOLE_AUTHENTICATION_INFO = STRUCT('SOLE_AUTHENTICATION_INFO', {
 dwAuthnSvc: DWORD,
 dwAuthzSvc: DWORD,
 pAuthInfo: PTR('void')
});

var SOLE_AUTHENTICATION_LIST = STRUCT('SOLE_AUTHENTICATION_LIST', {
 cAuthInfo: DWORD,
 aAuthInfo: PTR(uint)
});

var IClientSecurityVtbl = STRUCT('IClientSecurityVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryBlanket: PTR(pointer),
 SetBlanket: PTR(pointer),
 CopyProxy: PTR(pointer)
});

var IServerSecurityVtbl = STRUCT('IServerSecurityVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryBlanket: PTR(pointer),
 ImpersonateClient: PTR(pointer),
 RevertToSelf: PTR(pointer),
 IsImpersonating: PTR(pointer)
});

var IClassActivatorVtbl = STRUCT('IClassActivatorVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassObject: PTR(pointer)
});

var IRpcOptionsVtbl = STRUCT('IRpcOptionsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Set: PTR(pointer),
 Query: PTR(pointer)
});

var IGlobalOptionsVtbl = STRUCT('IGlobalOptionsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Set: PTR(pointer),
 Query: PTR(pointer)
});

var IFillLockBytesVtbl = STRUCT('IFillLockBytesVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 FillAppend: PTR(pointer),
 FillAt: PTR(pointer),
 SetFillSize: PTR(pointer),
 Terminate: PTR(pointer)
});

var IProgressNotifyVtbl = STRUCT('IProgressNotifyVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnProgress: PTR(pointer)
});

var StorageLayout = STRUCT('StorageLayout', {
 LayoutType: DWORD,
 pwcsElementName: PTR(ushort),
 cOffset: LARGE_INTEGER,
 cBytes: LARGE_INTEGER
});

var ILayoutStorageVtbl = STRUCT('ILayoutStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 LayoutScript: PTR(pointer),
 BeginMonitor: PTR(pointer),
 EndMonitor: PTR(pointer),
 ReLayoutDocfile: PTR(pointer),
 ReLayoutDocfileOnILockBytes: PTR(pointer)
});

var IBlockingLockVtbl = STRUCT('IBlockingLockVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Lock: PTR(pointer),
 Unlock: PTR(pointer)
});

var ITimeAndNoticeControlVtbl = STRUCT('ITimeAndNoticeControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SuppressChanges: PTR(pointer)
});

var IOplockStorageVtbl = STRUCT('IOplockStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateStorageEx: PTR(pointer),
 OpenStorageEx: PTR(pointer)
});

var ISurrogateVtbl = STRUCT('ISurrogateVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 LoadDllServer: PTR(pointer),
 FreeSurrogate: PTR(pointer)
});

var IGlobalInterfaceTableVtbl = STRUCT('IGlobalInterfaceTableVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 RegisterInterfaceInGlobal: PTR(pointer),
 RevokeInterfaceFromGlobal: PTR(pointer),
 GetInterfaceFromGlobal: PTR(pointer)
});

var IDirectWriterLockVtbl = STRUCT('IDirectWriterLockVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 WaitForWriteAccess: PTR(pointer),
 ReleaseWriteAccess: PTR(pointer),
 HaveWriteAccess: PTR(pointer)
});

var ISynchronizeVtbl = STRUCT('ISynchronizeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Wait: PTR(pointer),
 Signal: PTR(pointer),
 Reset: PTR(pointer)
});

var ISynchronizeHandleVtbl = STRUCT('ISynchronizeHandleVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetHandle: PTR(pointer)
});

var ISynchronizeEventVtbl = STRUCT('ISynchronizeEventVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetHandle: PTR(pointer),
 SetEventHandle: PTR(pointer)
});

var ISynchronizeContainerVtbl = STRUCT('ISynchronizeContainerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AddSynchronize: PTR(pointer),
 WaitMultiple: PTR(pointer)
});

var ISynchronizeMutexVtbl = STRUCT('ISynchronizeMutexVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Wait: PTR(pointer),
 Signal: PTR(pointer),
 Reset: PTR(pointer),
 ReleaseMutex: PTR(pointer)
});

var ICancelMethodCallsVtbl = STRUCT('ICancelMethodCallsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Cancel: PTR(pointer),
 TestCancel: PTR(pointer)
});

var IAsyncManagerVtbl = STRUCT('IAsyncManagerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CompleteCall: PTR(pointer),
 GetCallContext: PTR(pointer),
 GetState: PTR(pointer)
});

var ICallFactoryVtbl = STRUCT('ICallFactoryVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateCall: PTR(pointer)
});

var IRpcHelperVtbl = STRUCT('IRpcHelperVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetDCOMProtocolVersion: PTR(pointer),
 GetIIDFromOBJREF: PTR(pointer)
});

var IReleaseMarshalBuffersVtbl = STRUCT('IReleaseMarshalBuffersVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ReleaseMarshalBuffer: PTR(pointer)
});

var IWaitMultipleVtbl = STRUCT('IWaitMultipleVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 WaitMultiple: PTR(pointer),
 AddSynchronize: PTR(pointer)
});

var IUrlMonVtbl = STRUCT('IUrlMonVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AsyncGetClassBits: PTR(pointer)
});

var IForegroundTransferVtbl = STRUCT('IForegroundTransferVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AllowForegroundTransfer: PTR(pointer)
});

var IAddrTrackingControlVtbl = STRUCT('IAddrTrackingControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 EnableCOMDynamicAddrTracking: PTR(pointer),
 DisableCOMDynamicAddrTracking: PTR(pointer)
});

var IAddrExclusionControlVtbl = STRUCT('IAddrExclusionControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetCurrentAddrExclusionList: PTR(pointer),
 UpdateAddrExclusionList: PTR(pointer)
});

var IPipeByteVtbl = STRUCT('IPipeByteVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Pull: PTR(pointer),
 Push: PTR(pointer)
});

var AsyncIPipeByteVtbl = STRUCT('AsyncIPipeByteVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_Pull: PTR(pointer),
 Finish_Pull: PTR(pointer),
 Begin_Push: PTR(pointer),
 Finish_Push: PTR(pointer)
});

var IPipeLongVtbl = STRUCT('IPipeLongVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Pull: PTR(pointer),
 Push: PTR(pointer)
});

var AsyncIPipeLongVtbl = STRUCT('AsyncIPipeLongVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_Pull: PTR(pointer),
 Finish_Pull: PTR(pointer),
 Begin_Push: PTR(pointer),
 Finish_Push: PTR(pointer)
});

var IPipeDoubleVtbl = STRUCT('IPipeDoubleVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Pull: PTR(pointer),
 Push: PTR(pointer)
});

var AsyncIPipeDoubleVtbl = STRUCT('AsyncIPipeDoubleVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Begin_Pull: PTR(pointer),
 Finish_Pull: PTR(pointer),
 Begin_Push: PTR(pointer),
 Finish_Push: PTR(pointer)
});

var IThumbnailExtractorVtbl = STRUCT('IThumbnailExtractorVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ExtractThumbnail: PTR(pointer),
 OnFileUpdated: PTR(pointer)
});

var IDummyHICONIncluderVtbl = STRUCT('IDummyHICONIncluderVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Dummy: PTR(pointer)
});

var IProcessLockVtbl = STRUCT('IProcessLockVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AddRefOnProcess: PTR(pointer),
 ReleaseRefOnProcess: PTR(pointer)
});

var ISurrogateServiceVtbl = STRUCT('ISurrogateServiceVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Init: PTR(pointer),
 ApplicationLaunch: PTR(pointer),
 ApplicationFree: PTR(pointer),
 CatalogRefresh: PTR(pointer),
 ProcessShutdown: PTR(pointer)
});

var IComThreadingInfoVtbl = STRUCT('IComThreadingInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetCurrentApartmentType: PTR(pointer),
 GetCurrentThreadType: PTR(pointer),
 GetCurrentLogicalThreadId: PTR(pointer),
 SetCurrentLogicalThreadId: PTR(pointer)
});

var IProcessInitControlVtbl = STRUCT('IProcessInitControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ResetInitializerTimeout: PTR(pointer)
});

var IInitializeSpyVtbl = STRUCT('IInitializeSpyVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 PreInitialize: PTR(pointer),
 PostInitialize: PTR(pointer),
 PreUninitialize: PTR(pointer),
 PostUninitialize: PTR(pointer)
});

var SOleTlsDataPublic = STRUCT('SOleTlsDataPublic', {
 pvReserved0: pointer,
 dwReserved0: pointer,
 pvReserved1: pointer,
 dwReserved1: pointer,
 pvReserved2: pointer,
 dwReserved2: pointer,
 pCurrentCtx: PTR('void')
});

var STGOPTIONS = STRUCT('STGOPTIONS', {
 usVersion: USHORT,
 reserved: USHORT,
 ulSectorSize: ULONG,
 pwcsTemplateFile: PTR(ushort)
});

var IPersistMoniker = STRUCT('IPersistMoniker', {
 lpVtbl: PTR(IPersistMonikerVtbl)
});

var IMonikerProp = STRUCT('IMonikerProp', {
 lpVtbl: PTR(IMonikerPropVtbl)
});

var IBindProtocol = STRUCT('IBindProtocol', {
 lpVtbl: PTR(IBindProtocolVtbl)
});

var IBinding = STRUCT('IBinding', {
 lpVtbl: PTR(IBindingVtbl)
});


var IBindStatusCallbackEx = STRUCT('IBindStatusCallbackEx', {
 lpVtbl: PTR(IBindStatusCallbackExVtbl)
});

var IAuthenticate = STRUCT('IAuthenticate', {
 lpVtbl: PTR(IAuthenticateVtbl)
});

var IAuthenticateEx = STRUCT('IAuthenticateEx', {
 lpVtbl: PTR(IAuthenticateExVtbl)
});

var IHttpNegotiate = STRUCT('IHttpNegotiate', {
 lpVtbl: PTR(IHttpNegotiateVtbl)
});

var IHttpNegotiate2 = STRUCT('IHttpNegotiate2', {
 lpVtbl: PTR(IHttpNegotiate2Vtbl)
});

var IHttpNegotiate3 = STRUCT('IHttpNegotiate3', {
 lpVtbl: PTR(IHttpNegotiate3Vtbl)
});

var IWinInetFileStream = STRUCT('IWinInetFileStream', {
 lpVtbl: PTR(IWinInetFileStreamVtbl)
});

var IWindowForBindingUI = STRUCT('IWindowForBindingUI', {
 lpVtbl: PTR(IWindowForBindingUIVtbl)
});

var ICodeInstall = STRUCT('ICodeInstall', {
 lpVtbl: PTR(ICodeInstallVtbl)
});

var IUri = STRUCT('IUri', {
 lpVtbl: PTR(IUriVtbl)
});

var IUriContainer = STRUCT('IUriContainer', {
 lpVtbl: PTR(IUriContainerVtbl)
});

var IUriBuilder = STRUCT('IUriBuilder', {
 lpVtbl: PTR(IUriBuilderVtbl)
});

var IUriBuilderFactory = STRUCT('IUriBuilderFactory', {
 lpVtbl: PTR(IUriBuilderFactoryVtbl)
});

var IWinInetInfo = STRUCT('IWinInetInfo', {
 lpVtbl: PTR(IWinInetInfoVtbl)
});

var IHttpSecurity = STRUCT('IHttpSecurity', {
 lpVtbl: PTR(IHttpSecurityVtbl)
});

var IWinInetHttpInfo = STRUCT('IWinInetHttpInfo', {
 lpVtbl: PTR(IWinInetHttpInfoVtbl)
});

var IWinInetCacheHints = STRUCT('IWinInetCacheHints', {
 lpVtbl: PTR(IWinInetCacheHintsVtbl)
});

var IWinInetCacheHints2 = STRUCT('IWinInetCacheHints2', {
 lpVtbl: PTR(IWinInetCacheHints2Vtbl)
});

var IBindHost = STRUCT('IBindHost', {
 lpVtbl: PTR(IBindHostVtbl)
});

var IInternet = STRUCT('IInternet', {
 lpVtbl: PTR(IInternetVtbl)
});

var IInternetBindInfo = STRUCT('IInternetBindInfo', {
 lpVtbl: PTR(IInternetBindInfoVtbl)
});

var IInternetBindInfoEx = STRUCT('IInternetBindInfoEx', {
 lpVtbl: PTR(IInternetBindInfoExVtbl)
});

var IInternetProtocolRoot = STRUCT('IInternetProtocolRoot', {
 lpVtbl: PTR(IInternetProtocolRootVtbl)
});

var IInternetProtocol = STRUCT('IInternetProtocol', {
 lpVtbl: PTR(IInternetProtocolVtbl)
});

var IInternetProtocolEx = STRUCT('IInternetProtocolEx', {
 lpVtbl: PTR(IInternetProtocolExVtbl)
});

var IInternetProtocolSink = STRUCT('IInternetProtocolSink', {
 lpVtbl: PTR(IInternetProtocolSinkVtbl)
});

var IInternetProtocolSinkStackable = STRUCT('IInternetProtocolSinkStackable', {
 lpVtbl: PTR(IInternetProtocolSinkStackableVtbl)
});

var IInternetSession = STRUCT('IInternetSession', {
 lpVtbl: PTR(IInternetSessionVtbl)
});

var IInternetThreadSwitch = STRUCT('IInternetThreadSwitch', {
 lpVtbl: PTR(IInternetThreadSwitchVtbl)
});

var IInternetPriority = STRUCT('IInternetPriority', {
 lpVtbl: PTR(IInternetPriorityVtbl)
});

var IInternetProtocolInfo = STRUCT('IInternetProtocolInfo', {
 lpVtbl: PTR(IInternetProtocolInfoVtbl)
});

var IInternetSecurityMgrSite = STRUCT('IInternetSecurityMgrSite', {
 lpVtbl: PTR(IInternetSecurityMgrSiteVtbl)
});

var IInternetSecurityManager = STRUCT('IInternetSecurityManager', {
 lpVtbl: PTR(IInternetSecurityManagerVtbl)
});

var IInternetSecurityManagerEx = STRUCT('IInternetSecurityManagerEx', {
 lpVtbl: PTR(IInternetSecurityManagerExVtbl)
});

var IInternetSecurityManagerEx2 = STRUCT('IInternetSecurityManagerEx2', {
 lpVtbl: PTR(IInternetSecurityManagerEx2Vtbl)
});

var IZoneIdentifier = STRUCT('IZoneIdentifier', {
 lpVtbl: PTR(IZoneIdentifierVtbl)
});

var IInternetHostSecurityManager = STRUCT('IInternetHostSecurityManager', {
 lpVtbl: PTR(IInternetHostSecurityManagerVtbl)
});

var IInternetZoneManager = STRUCT('IInternetZoneManager', {
 lpVtbl: PTR(IInternetZoneManagerVtbl)
});

var IInternetZoneManagerEx = STRUCT('IInternetZoneManagerEx', {
 lpVtbl: PTR(IInternetZoneManagerExVtbl)
});

var IInternetZoneManagerEx2 = STRUCT('IInternetZoneManagerEx2', {
 lpVtbl: PTR(IInternetZoneManagerEx2Vtbl)
});

var ISoftDistExt = STRUCT('ISoftDistExt', {
 lpVtbl: PTR(ISoftDistExtVtbl)
});

var ICatalogFileInfo = STRUCT('ICatalogFileInfo', {
 lpVtbl: PTR(ICatalogFileInfoVtbl)
});

var IDataFilter = STRUCT('IDataFilter', {
 lpVtbl: PTR(IDataFilterVtbl)
});

var IEncodingFilterFactory = STRUCT('IEncodingFilterFactory', {
 lpVtbl: PTR(IEncodingFilterFactoryVtbl)
});

var IWrappedProtocol = STRUCT('IWrappedProtocol', {
 lpVtbl: PTR(IWrappedProtocolVtbl)
});

var IOleAdviseHolder = STRUCT('IOleAdviseHolder', {
 lpVtbl: PTR(IOleAdviseHolderVtbl)
});

var IOleCache = STRUCT('IOleCache', {
 lpVtbl: PTR(IOleCacheVtbl)
});

var IOleCache2 = STRUCT('IOleCache2', {
 lpVtbl: PTR(IOleCache2Vtbl)
});

var IOleCacheControl = STRUCT('IOleCacheControl', {
 lpVtbl: PTR(IOleCacheControlVtbl)
});

var IParseDisplayName = STRUCT('IParseDisplayName', {
 lpVtbl: PTR(IParseDisplayNameVtbl)
});

var IOleContainer = STRUCT('IOleContainer', {
 lpVtbl: PTR(IOleContainerVtbl)
});

var IOleClientSite = STRUCT('IOleClientSite', {
 lpVtbl: PTR(IOleClientSiteVtbl)
});

var IOleObject = STRUCT('IOleObject', {
 lpVtbl: PTR(IOleObjectVtbl)
});

var IOleWindow = STRUCT('IOleWindow', {
 lpVtbl: PTR(IOleWindowVtbl)
});

var IOleLink = STRUCT('IOleLink', {
 lpVtbl: PTR(IOleLinkVtbl)
});

var IOleItemContainer = STRUCT('IOleItemContainer', {
 lpVtbl: PTR(IOleItemContainerVtbl)
});

var IOleInPlaceUIWindow = STRUCT('IOleInPlaceUIWindow', {
 lpVtbl: PTR(IOleInPlaceUIWindowVtbl)
});

var IOleInPlaceActiveObject = STRUCT('IOleInPlaceActiveObject', {
 lpVtbl: PTR(IOleInPlaceActiveObjectVtbl)
});

var IOleInPlaceFrame = STRUCT('IOleInPlaceFrame', {
 lpVtbl: PTR(IOleInPlaceFrameVtbl)
});

var IOleInPlaceObject = STRUCT('IOleInPlaceObject', {
 lpVtbl: PTR(IOleInPlaceObjectVtbl)
});

var IOleInPlaceSite = STRUCT('IOleInPlaceSite', {
 lpVtbl: PTR(IOleInPlaceSiteVtbl)
});

var IContinue = STRUCT('IContinue', {
 lpVtbl: PTR(IContinueVtbl)
});

var IViewObject = STRUCT('IViewObject', {
 lpVtbl: PTR(IViewObjectVtbl)
});

var IViewObject2 = STRUCT('IViewObject2', {
 lpVtbl: PTR(IViewObject2Vtbl)
});

var IDropSource = STRUCT('IDropSource', {
 lpVtbl: PTR(IDropSourceVtbl)
});

var IDropTarget = STRUCT('IDropTarget', {
 lpVtbl: PTR(IDropTargetVtbl)
});

var IDropSourceNotify = STRUCT('IDropSourceNotify', {
 lpVtbl: PTR(IDropSourceNotifyVtbl)
});

var IEnumOLEVERB = STRUCT('IEnumOLEVERB', {
 lpVtbl: PTR(IEnumOLEVERBVtbl)
});

var IOleAdviseHolderVtbl = STRUCT('IOleAdviseHolderVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Advise: PTR(pointer),
 Unadvise: PTR(pointer),
 EnumAdvise: PTR(pointer),
 SendOnRename: PTR(pointer),
 SendOnSave: PTR(pointer),
 SendOnClose: PTR(pointer)
});

var IOleCacheVtbl = STRUCT('IOleCacheVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Cache: PTR(pointer),
 Uncache: PTR(pointer),
 EnumCache: PTR(pointer),
 InitCache: PTR(pointer),
 SetData: PTR(pointer)
});

var IOleCache2Vtbl = STRUCT('IOleCache2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Cache: PTR(pointer),
 Uncache: PTR(pointer),
 EnumCache: PTR(pointer),
 InitCache: PTR(pointer),
 SetData: PTR(pointer),
 UpdateCache: PTR(pointer),
 DiscardCache: PTR(pointer)
});

var IOleCacheControlVtbl = STRUCT('IOleCacheControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnRun: PTR(pointer),
 OnStop: PTR(pointer)
});

var IParseDisplayNameVtbl = STRUCT('IParseDisplayNameVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ParseDisplayName: PTR(pointer)
});

var IOleContainerVtbl = STRUCT('IOleContainerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ParseDisplayName: PTR(pointer),
 EnumObjects: PTR(pointer),
 LockContainer: PTR(pointer)
});

var IOleClientSiteVtbl = STRUCT('IOleClientSiteVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SaveObject: PTR(pointer),
 GetMoniker: PTR(pointer),
 GetContainer: PTR(pointer),
 ShowObject: PTR(pointer),
 OnShowWindow: PTR(pointer),
 RequestNewObjectLayout: PTR(pointer)
});

var IOleObjectVtbl = STRUCT('IOleObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetClientSite: PTR(pointer),
 GetClientSite: PTR(pointer),
 SetHostNames: PTR(pointer),
 Close: PTR(pointer),
 SetMoniker: PTR(pointer),
 GetMoniker: PTR(pointer),
 InitFromData: PTR(pointer),
 GetClipboardData: PTR(pointer),
 DoVerb: PTR(pointer),
 EnumVerbs: PTR(pointer),
 Update: PTR(pointer),
 IsUpToDate: PTR(pointer),
 GetUserClassID: PTR(pointer),
 GetUserType: PTR(pointer),
 SetExtent: PTR(pointer),
 GetExtent: PTR(pointer),
 Advise: PTR(pointer),
 Unadvise: PTR(pointer),
 EnumAdvise: PTR(pointer),
 GetMiscStatus: PTR(pointer),
 SetColorScheme: PTR(pointer)
});

var LINKSRCDESCRIPTOR = STRUCT('LINKSRCDESCRIPTOR', {
 cbSize: ULONG,
 clsid: CLSID,
 dwDrawAspect: DWORD,
 sizel: SIZEL,
 pointl: POINTL,
 dwStatus: DWORD,
 dwFullUserTypeName: DWORD,
 dwSrcOfCopy: DWORD
});

var IOleWindowVtbl = STRUCT('IOleWindowVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer)
});

var IOleLinkVtbl = STRUCT('IOleLinkVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetUpdateOptions: PTR(pointer),
 GetUpdateOptions: PTR(pointer),
 SetSourceMoniker: PTR(pointer),
 GetSourceMoniker: PTR(pointer),
 SetSourceDisplayName: PTR(pointer),
 GetSourceDisplayName: PTR(pointer),
 BindToSource: PTR(pointer),
 BindIfRunning: PTR(pointer),
 GetBoundSource: PTR(pointer),
 UnbindSource: PTR(pointer),
 Update: PTR(pointer)
});

var IOleItemContainerVtbl = STRUCT('IOleItemContainerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ParseDisplayName: PTR(pointer),
 EnumObjects: PTR(pointer),
 LockContainer: PTR(pointer),
 GetObjectA: PTR(pointer),
 GetObjectStorage: PTR(pointer),
 IsRunning: PTR(pointer)
});

var IOleInPlaceUIWindowVtbl = STRUCT('IOleInPlaceUIWindowVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer),
 GetBorder: PTR(pointer),
 RequestBorderSpace: PTR(pointer),
 SetBorderSpace: PTR(pointer),
 SetActiveObject: PTR(pointer)
});

var IOleInPlaceActiveObjectVtbl = STRUCT('IOleInPlaceActiveObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer),
 TranslateAcceleratorA: PTR(pointer),
 OnFrameWindowActivate: PTR(pointer),
 OnDocWindowActivate: PTR(pointer),
 ResizeBorder: PTR(pointer),
 EnableModeless: PTR(pointer)
});

var OLEINPLACEFRAMEINFO = STRUCT('OLEINPLACEFRAMEINFO', {
 cb: UINT,
 fMDIApp: BOOL,
 hwndFrame: HWND,
 haccel: HACCEL,
 cAccelEntries: UINT
});

var OLEMENUGROUPWIDTHS = STRUCT('OLEMENUGROUPWIDTHS', {
 width: pointer
});

var IOleInPlaceFrameVtbl = STRUCT('IOleInPlaceFrameVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer),
 GetBorder: PTR(pointer),
 RequestBorderSpace: PTR(pointer),
 SetBorderSpace: PTR(pointer),
 SetActiveObject: PTR(pointer),
 InsertMenus: PTR(pointer),
 SetMenu: PTR(pointer),
 RemoveMenus: PTR(pointer),
 SetStatusText: PTR(pointer),
 EnableModeless: PTR(pointer),
 TranslateAcceleratorA: PTR(pointer)
});

var IOleInPlaceObjectVtbl = STRUCT('IOleInPlaceObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer),
 InPlaceDeactivate: PTR(pointer),
 UIDeactivate: PTR(pointer),
 SetObjectRects: PTR(pointer),
 ReactivateAndUndo: PTR(pointer)
});

var IOleInPlaceSiteVtbl = STRUCT('IOleInPlaceSiteVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 ContextSensitiveHelp: PTR(pointer),
 CanInPlaceActivate: PTR(pointer),
 OnInPlaceActivate: PTR(pointer),
 OnUIActivate: PTR(pointer),
 GetWindowContext: PTR(pointer),
 Scroll: PTR(pointer),
 OnUIDeactivate: PTR(pointer),
 OnInPlaceDeactivate: PTR(pointer),
 DiscardUndoState: PTR(pointer),
 DeactivateAndUndo: PTR(pointer),
 OnPosRectChange: PTR(pointer)
});

var IContinueVtbl = STRUCT('IContinueVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 FContinue: PTR(pointer)
});

var IViewObjectVtbl = STRUCT('IViewObjectVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Draw: PTR(pointer),
 GetColorSet: PTR(pointer),
 Freeze: PTR(pointer),
 Unfreeze: PTR(pointer),
 SetAdvise: PTR(pointer),
 GetAdvise: PTR(pointer)
});

var IViewObject2Vtbl = STRUCT('IViewObject2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Draw: PTR(pointer),
 GetColorSet: PTR(pointer),
 Freeze: PTR(pointer),
 Unfreeze: PTR(pointer),
 SetAdvise: PTR(pointer),
 GetAdvise: PTR(pointer),
 GetExtent: PTR(pointer)
});

var IDropSourceVtbl = STRUCT('IDropSourceVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryContinueDrag: PTR(pointer),
 GiveFeedback: PTR(pointer)
});

var IDropTargetVtbl = STRUCT('IDropTargetVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 DragEnter: PTR(pointer),
 DragOver: PTR(pointer),
 DragLeave: PTR(pointer),
 Drop: PTR(pointer)
});

var IDropSourceNotifyVtbl = STRUCT('IDropSourceNotifyVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 DragEnterTarget: PTR(pointer),
 DragLeaveTarget: PTR(pointer)
});

var OLEVERB = STRUCT('OLEVERB', {
 lVerb: LONG,
 lpszVerbName: LPOLESTR,
 fuFlags: DWORD,
 grfAttribs: DWORD
});

var IEnumOLEVERBVtbl = STRUCT('IEnumOLEVERBVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var IServiceProvider = STRUCT('IServiceProvider', {
 lpVtbl: PTR(IServiceProviderVtbl)
});

var IServiceProviderVtbl = STRUCT('IServiceProviderVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryService: PTR(pointer)
});

var IXMLDOMImplementation = STRUCT('IXMLDOMImplementation', {
 lpVtbl: PTR(IXMLDOMImplementationVtbl)
});

var IXMLDOMNode = STRUCT('IXMLDOMNode', {
 lpVtbl: PTR(IXMLDOMNodeVtbl)
});

var IXMLDOMDocumentFragment = STRUCT('IXMLDOMDocumentFragment', {
 lpVtbl: PTR(IXMLDOMDocumentFragmentVtbl)
});

var IXMLDOMDocument = STRUCT('IXMLDOMDocument', {
 lpVtbl: PTR(IXMLDOMDocumentVtbl)
});

var IXMLDOMNodeList = STRUCT('IXMLDOMNodeList', {
 lpVtbl: PTR(IXMLDOMNodeListVtbl)
});

var IXMLDOMNamedNodeMap = STRUCT('IXMLDOMNamedNodeMap', {
 lpVtbl: PTR(IXMLDOMNamedNodeMapVtbl)
});

var IXMLDOMCharacterData = STRUCT('IXMLDOMCharacterData', {
 lpVtbl: PTR(IXMLDOMCharacterDataVtbl)
});

var IXMLDOMAttribute = STRUCT('IXMLDOMAttribute', {
 lpVtbl: PTR(IXMLDOMAttributeVtbl)
});

var IXMLDOMElement = STRUCT('IXMLDOMElement', {
 lpVtbl: PTR(IXMLDOMElementVtbl)
});

var IXMLDOMText = STRUCT('IXMLDOMText', {
 lpVtbl: PTR(IXMLDOMTextVtbl)
});

var IXMLDOMComment = STRUCT('IXMLDOMComment', {
 lpVtbl: PTR(IXMLDOMCommentVtbl)
});

var IXMLDOMProcessingInstruction = STRUCT('IXMLDOMProcessingInstruction', {
 lpVtbl: PTR(IXMLDOMProcessingInstructionVtbl)
});

var IXMLDOMCDATASection = STRUCT('IXMLDOMCDATASection', {
 lpVtbl: PTR(IXMLDOMCDATASectionVtbl)
});

var IXMLDOMDocumentType = STRUCT('IXMLDOMDocumentType', {
 lpVtbl: PTR(IXMLDOMDocumentTypeVtbl)
});

var IXMLDOMNotation = STRUCT('IXMLDOMNotation', {
 lpVtbl: PTR(IXMLDOMNotationVtbl)
});

var IXMLDOMEntity = STRUCT('IXMLDOMEntity', {
 lpVtbl: PTR(IXMLDOMEntityVtbl)
});

var IXMLDOMEntityReference = STRUCT('IXMLDOMEntityReference', {
 lpVtbl: PTR(IXMLDOMEntityReferenceVtbl)
});

var IXMLDOMParseError = STRUCT('IXMLDOMParseError', {
 lpVtbl: PTR(IXMLDOMParseErrorVtbl)
});

var IXTLRuntime = STRUCT('IXTLRuntime', {
 lpVtbl: PTR(IXTLRuntimeVtbl)
});

var XMLDOMDocumentEvents = STRUCT('XMLDOMDocumentEvents', {
 lpVtbl: PTR(XMLDOMDocumentEventsVtbl)
});



var IXMLHttpRequest = STRUCT('IXMLHttpRequest', {
 lpVtbl: PTR(IXMLHttpRequestVtbl)
});


var IXMLDSOControl = STRUCT('IXMLDSOControl', {
 lpVtbl: PTR(IXMLDSOControlVtbl)
});


var IXMLElementCollection = STRUCT('IXMLElementCollection', {
 lpVtbl: PTR(IXMLElementCollectionVtbl)
});

var IXMLDocument = STRUCT('IXMLDocument', {
 lpVtbl: PTR(IXMLDocumentVtbl)
});

var IXMLDocument2 = STRUCT('IXMLDocument2', {
 lpVtbl: PTR(IXMLDocument2Vtbl)
});

var IXMLElement = STRUCT('IXMLElement', {
 lpVtbl: PTR(IXMLElementVtbl)
});

var IXMLElement2 = STRUCT('IXMLElement2', {
 lpVtbl: PTR(IXMLElement2Vtbl)
});

var IXMLAttribute = STRUCT('IXMLAttribute', {
 lpVtbl: PTR(IXMLAttributeVtbl)
});

var IXMLError = STRUCT('IXMLError', {
 lpVtbl: PTR(IXMLErrorVtbl)
});


var ICreateTypeInfo = STRUCT('ICreateTypeInfo', {
 lpVtbl: PTR(ICreateTypeInfoVtbl)
});

var ICreateTypeInfo2 = STRUCT('ICreateTypeInfo2', {
 lpVtbl: PTR(ICreateTypeInfo2Vtbl)
});

var ICreateTypeLib = STRUCT('ICreateTypeLib', {
 lpVtbl: PTR(ICreateTypeLibVtbl)
});

var ICreateTypeLib2 = STRUCT('ICreateTypeLib2', {
 lpVtbl: PTR(ICreateTypeLib2Vtbl)
});

var IDispatch = STRUCT('IDispatch', {
 lpVtbl: PTR(IDispatchVtbl)
});

var IEnumVARIANT = STRUCT('IEnumVARIANT', {
 lpVtbl: PTR(IEnumVARIANTVtbl)
});

var ITypeComp = STRUCT('ITypeComp', {
 lpVtbl: PTR(ITypeCompVtbl)
});

var ITypeInfo = STRUCT('ITypeInfo', {
 lpVtbl: PTR(ITypeInfoVtbl)
});

var ITypeInfo2 = STRUCT('ITypeInfo2', {
 lpVtbl: PTR(ITypeInfo2Vtbl)
});

var ITypeLib = STRUCT('ITypeLib', {
 lpVtbl: PTR(ITypeLibVtbl)
});

var ITypeLib2 = STRUCT('ITypeLib2', {
 lpVtbl: PTR(ITypeLib2Vtbl)
});

var ITypeChangeEvents = STRUCT('ITypeChangeEvents', {
 lpVtbl: PTR(ITypeChangeEventsVtbl)
});

var IErrorInfo = STRUCT('IErrorInfo', {
 lpVtbl: PTR(IErrorInfoVtbl)
});

var ICreateErrorInfo = STRUCT('ICreateErrorInfo', {
 lpVtbl: PTR(ICreateErrorInfoVtbl)
});

var ISupportErrorInfo = STRUCT('ISupportErrorInfo', {
 lpVtbl: PTR(ISupportErrorInfoVtbl)
});

var ITypeFactory = STRUCT('ITypeFactory', {
 lpVtbl: PTR(ITypeFactoryVtbl)
});

var ITypeMarshal = STRUCT('ITypeMarshal', {
 lpVtbl: PTR(ITypeMarshalVtbl)
});

var IRecordInfo = STRUCT('IRecordInfo', {
 lpVtbl: PTR(IRecordInfoVtbl)
});

var IErrorLog = STRUCT('IErrorLog', {
 lpVtbl: PTR(IErrorLogVtbl)
});

var IPropertyBag = STRUCT('IPropertyBag', {
 lpVtbl: PTR(IPropertyBagVtbl)
});

var SAFEARRAYBOUND = STRUCT('SAFEARRAYBOUND', {
 cElements: ULONG,
 lLbound: LONG
});

var _wireVARIANT = STRUCT('_wireVARIANT', {
 clSize: DWORD,
 rpcReserved: DWORD,
 vt: USHORT,
 wReserved1: USHORT,
 wReserved2: USHORT,
 wReserved3: USHORT
});

var _wireBRECORD = STRUCT('_wireBRECORD', {
 fFlags: ULONG,
 clSize: ULONG,
 pRecInfo: PTR(uint),
 pRecord: PTR(uchar)
});

var SAFEARR_BSTR = STRUCT('SAFEARR_BSTR', {
 Size: ULONG,
 aBstr: PTR(pointer)
});

var SAFEARR_UNKNOWN = STRUCT('SAFEARR_UNKNOWN', {
 Size: ULONG,
 apUnknown: PTR(PTR(uint))
});

var SAFEARR_DISPATCH = STRUCT('SAFEARR_DISPATCH', {
 Size: ULONG,
 apDispatch: PTR(PTR(uint))
});

var SAFEARR_VARIANT = STRUCT('SAFEARR_VARIANT', {
 Size: ULONG,
 aVariant: PTR(pointer)
});

var SAFEARR_BRECORD = STRUCT('SAFEARR_BRECORD', {
 Size: ULONG,
 aRecord: PTR(pointer)
});

var SAFEARR_HAVEIID = STRUCT('SAFEARR_HAVEIID', {
 Size: ULONG,
 apUnknown: PTR(PTR(uint)),
 iid: IID
});

var SAFEARRAYUNION = STRUCT('SAFEARRAYUNION', {
 sfType: ULONG,
 u: __MIDL_IOleAutomationTypes_0001
});

var _wireSAFEARRAY = STRUCT('_wireSAFEARRAY', {
 cDims: USHORT,
 fFeatures: USHORT,
 cbElements: ULONG,
 cLocks: ULONG,
 uArrayStructs: SAFEARRAYUNION,
 rgsabound: pointer
});

var SAFEARRAY = STRUCT('SAFEARRAY', {
 cDims: USHORT,
 fFeatures: USHORT,
 cbElements: ULONG,
 cLocks: ULONG,
 pvData: PVOID,
 rgsabound: pointer
});


var undefined = STRUCT('undefined', {
 vt: VARTYPE,
 wReserved1: WORD,
 wReserved2: WORD,
 wReserved3: WORD
});

var undefined = STRUCT('undefined', {
 pvRecord: PVOID,
 pRecInfo: PTR(uint)
});

var TYPEDESC = STRUCT('TYPEDESC', {
 vt: VARTYPE
});

var ARRAYDESC = STRUCT('ARRAYDESC', {
 tdescElem: TYPEDESC,
 cDims: USHORT,
 rgbounds: pointer
});

var PARAMDESCEX = STRUCT('PARAMDESCEX', {
 cBytes: ULONG,
 varDefaultValue: VARIANTARG
});

var PARAMDESC = STRUCT('PARAMDESC', {
 pparamdescex: LPPARAMDESCEX,
 wParamFlags: USHORT
});

var IDLDESC = STRUCT('IDLDESC', {
 dwReserved: ULONG_PTR,
 wIDLFlags: USHORT
});

var ELEMDESC = STRUCT('ELEMDESC', {
 tdesc: TYPEDESC
});

var TYPEATTR = STRUCT('TYPEATTR', {
 guid: GUID,
 lcid: LCID,
 dwReserved: DWORD,
 memidConstructor: MEMBERID,
 memidDestructor: MEMBERID,
 lpstrSchema: LPOLESTR,
 cbSizeInstance: ULONG,
 typekind: TYPEKIND,
 cFuncs: WORD,
 cVars: WORD,
 cImplTypes: WORD,
 cbSizeVft: WORD,
 cbAlignment: WORD,
 wTypeFlags: WORD,
 wMajorVerNum: WORD,
 wMinorVerNum: WORD,
 tdescAlias: TYPEDESC,
 idldescType: IDLDESC
});

var DISPPARAMS = STRUCT('DISPPARAMS', {
 rgvarg: PTR(uint),
 rgdispidNamedArgs: PTR(long),
 cArgs: UINT,
 cNamedArgs: UINT
});

var EXCEPINFO = STRUCT('EXCEPINFO', {
 wCode: WORD,
 wReserved: WORD,
 bstrSource: BSTR,
 bstrDescription: BSTR,
 bstrHelpFile: BSTR,
 dwHelpContext: DWORD,
 pvReserved: PVOID,
 pfnDeferredFillIn: PTR(pointer),
 scode: SCODE
});

var FUNCDESC = STRUCT('FUNCDESC', {
 memid: MEMBERID,
 lprgscode: PTR(long),
 lprgelemdescParam: PTR(uint),
 funckind: FUNCKIND,
 invkind: INVOKEKIND,
 callconv: CALLCONV,
 cParams: SHORT,
 cParamsOpt: SHORT,
 oVft: SHORT,
 cScodes: SHORT,
 elemdescFunc: ELEMDESC,
 wFuncFlags: WORD
});

var VARDESC = STRUCT('VARDESC', {
 memid: MEMBERID,
 lpstrSchema: LPOLESTR,
 elemdescVar: ELEMDESC,
 wVarFlags: WORD,
 varkind: VARKIND
});

var CLEANLOCALSTORAGE = STRUCT('CLEANLOCALSTORAGE', {
 pInterface: PTR(uint),
 pStorage: PVOID,
 flags: DWORD
});

var CUSTDATAITEM = STRUCT('CUSTDATAITEM', {
 guid: GUID,
 varValue: VARIANTARG
});

var CUSTDATA = STRUCT('CUSTDATA', {
 cCustData: DWORD,
 prgCustData: LPCUSTDATAITEM
});

var ICreateTypeInfoVtbl = STRUCT('ICreateTypeInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetGuid: PTR(pointer),
 SetTypeFlags: PTR(pointer),
 SetDocString: PTR(pointer),
 SetHelpContext: PTR(pointer),
 SetVersion: PTR(pointer),
 AddRefTypeInfo: PTR(pointer),
 AddFuncDesc: PTR(pointer),
 AddImplType: PTR(pointer),
 SetImplTypeFlags: PTR(pointer),
 SetAlignment: PTR(pointer),
 SetSchema: PTR(pointer),
 AddVarDesc: PTR(pointer),
 SetFuncAndParamNames: PTR(pointer),
 SetVarName: PTR(pointer),
 SetTypeDescAlias: PTR(pointer),
 DefineFuncAsDllEntry: PTR(pointer),
 SetFuncDocString: PTR(pointer),
 SetVarDocString: PTR(pointer),
 SetFuncHelpContext: PTR(pointer),
 SetVarHelpContext: PTR(pointer),
 SetMops: PTR(pointer),
 SetTypeIdldesc: PTR(pointer),
 LayOut: PTR(pointer)
});

var ICreateTypeInfo2Vtbl = STRUCT('ICreateTypeInfo2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetGuid: PTR(pointer),
 SetTypeFlags: PTR(pointer),
 SetDocString: PTR(pointer),
 SetHelpContext: PTR(pointer),
 SetVersion: PTR(pointer),
 AddRefTypeInfo: PTR(pointer),
 AddFuncDesc: PTR(pointer),
 AddImplType: PTR(pointer),
 SetImplTypeFlags: PTR(pointer),
 SetAlignment: PTR(pointer),
 SetSchema: PTR(pointer),
 AddVarDesc: PTR(pointer),
 SetFuncAndParamNames: PTR(pointer),
 SetVarName: PTR(pointer),
 SetTypeDescAlias: PTR(pointer),
 DefineFuncAsDllEntry: PTR(pointer),
 SetFuncDocString: PTR(pointer),
 SetVarDocString: PTR(pointer),
 SetFuncHelpContext: PTR(pointer),
 SetVarHelpContext: PTR(pointer),
 SetMops: PTR(pointer),
 SetTypeIdldesc: PTR(pointer),
 LayOut: PTR(pointer),
 DeleteFuncDesc: PTR(pointer),
 DeleteFuncDescByMemId: PTR(pointer),
 DeleteVarDesc: PTR(pointer),
 DeleteVarDescByMemId: PTR(pointer),
 DeleteImplType: PTR(pointer),
 SetCustData: PTR(pointer),
 SetFuncCustData: PTR(pointer),
 SetParamCustData: PTR(pointer),
 SetVarCustData: PTR(pointer),
 SetImplTypeCustData: PTR(pointer),
 SetHelpStringContext: PTR(pointer),
 SetFuncHelpStringContext: PTR(pointer),
 SetVarHelpStringContext: PTR(pointer),
 Invalidate: PTR(pointer),
 SetName: PTR(pointer)
});

var ICreateTypeLibVtbl = STRUCT('ICreateTypeLibVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateTypeInfo: PTR(pointer),
 SetName: PTR(pointer),
 SetVersion: PTR(pointer),
 SetGuid: PTR(pointer),
 SetDocString: PTR(pointer),
 SetHelpFileName: PTR(pointer),
 SetHelpContext: PTR(pointer),
 SetLcid: PTR(pointer),
 SetLibFlags: PTR(pointer),
 SaveAllChanges: PTR(pointer)
});

var ICreateTypeLib2Vtbl = STRUCT('ICreateTypeLib2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateTypeInfo: PTR(pointer),
 SetName: PTR(pointer),
 SetVersion: PTR(pointer),
 SetGuid: PTR(pointer),
 SetDocString: PTR(pointer),
 SetHelpFileName: PTR(pointer),
 SetHelpContext: PTR(pointer),
 SetLcid: PTR(pointer),
 SetLibFlags: PTR(pointer),
 SaveAllChanges: PTR(pointer),
 DeleteTypeInfo: PTR(pointer),
 SetCustData: PTR(pointer),
 SetHelpStringContext: PTR(pointer),
 SetHelpStringDll: PTR(pointer)
});

var IDispatchVtbl = STRUCT('IDispatchVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer)
});

var IEnumVARIANTVtbl = STRUCT('IEnumVARIANTVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var ITypeCompVtbl = STRUCT('ITypeCompVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Bind: PTR(pointer),
 BindType: PTR(pointer)
});

var ITypeInfoVtbl = STRUCT('ITypeInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeAttr: PTR(pointer),
 GetTypeComp: PTR(pointer),
 GetFuncDesc: PTR(pointer),
 GetVarDesc: PTR(pointer),
 GetNames: PTR(pointer),
 GetRefTypeOfImplType: PTR(pointer),
 GetImplTypeFlags: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 GetDocumentation: PTR(pointer),
 GetDllEntry: PTR(pointer),
 GetRefTypeInfo: PTR(pointer),
 AddressOfMember: PTR(pointer),
 CreateInstance: PTR(pointer),
 GetMops: PTR(pointer),
 GetContainingTypeLib: PTR(pointer),
 ReleaseTypeAttr: PTR(pointer),
 ReleaseFuncDesc: PTR(pointer),
 ReleaseVarDesc: PTR(pointer)
});

var ITypeInfo2Vtbl = STRUCT('ITypeInfo2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeAttr: PTR(pointer),
 GetTypeComp: PTR(pointer),
 GetFuncDesc: PTR(pointer),
 GetVarDesc: PTR(pointer),
 GetNames: PTR(pointer),
 GetRefTypeOfImplType: PTR(pointer),
 GetImplTypeFlags: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 GetDocumentation: PTR(pointer),
 GetDllEntry: PTR(pointer),
 GetRefTypeInfo: PTR(pointer),
 AddressOfMember: PTR(pointer),
 CreateInstance: PTR(pointer),
 GetMops: PTR(pointer),
 GetContainingTypeLib: PTR(pointer),
 ReleaseTypeAttr: PTR(pointer),
 ReleaseFuncDesc: PTR(pointer),
 ReleaseVarDesc: PTR(pointer),
 GetTypeKind: PTR(pointer),
 GetTypeFlags: PTR(pointer),
 GetFuncIndexOfMemId: PTR(pointer),
 GetVarIndexOfMemId: PTR(pointer),
 GetCustData: PTR(pointer),
 GetFuncCustData: PTR(pointer),
 GetParamCustData: PTR(pointer),
 GetVarCustData: PTR(pointer),
 GetImplTypeCustData: PTR(pointer),
 GetDocumentation2: PTR(pointer),
 GetAllCustData: PTR(pointer),
 GetAllFuncCustData: PTR(pointer),
 GetAllParamCustData: PTR(pointer),
 GetAllVarCustData: PTR(pointer),
 GetAllImplTypeCustData: PTR(pointer)
});

var TLIBATTR = STRUCT('TLIBATTR', {
 guid: GUID,
 lcid: LCID,
 syskind: SYSKIND,
 wMajorVerNum: WORD,
 wMinorVerNum: WORD,
 wLibFlags: WORD
});

var ITypeLibVtbl = STRUCT('ITypeLibVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetTypeInfoType: PTR(pointer),
 GetTypeInfoOfGuid: PTR(pointer),
 GetLibAttr: PTR(pointer),
 GetTypeComp: PTR(pointer),
 GetDocumentation: PTR(pointer),
 IsName: PTR(pointer),
 FindName: PTR(pointer),
 ReleaseTLibAttr: PTR(pointer)
});

var ITypeLib2Vtbl = STRUCT('ITypeLib2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetTypeInfoType: PTR(pointer),
 GetTypeInfoOfGuid: PTR(pointer),
 GetLibAttr: PTR(pointer),
 GetTypeComp: PTR(pointer),
 GetDocumentation: PTR(pointer),
 IsName: PTR(pointer),
 FindName: PTR(pointer),
 ReleaseTLibAttr: PTR(pointer),
 GetCustData: PTR(pointer),
 GetLibStatistics: PTR(pointer),
 GetDocumentation2: PTR(pointer),
 GetAllCustData: PTR(pointer)
});

var ITypeChangeEventsVtbl = STRUCT('ITypeChangeEventsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 RequestTypeChange: PTR(pointer),
 AfterTypeChange: PTR(pointer)
});

var IErrorInfoVtbl = STRUCT('IErrorInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetGUID: PTR(pointer),
 GetSource: PTR(pointer),
 GetDescription: PTR(pointer),
 GetHelpFile: PTR(pointer),
 GetHelpContext: PTR(pointer)
});

var ICreateErrorInfoVtbl = STRUCT('ICreateErrorInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetGUID: PTR(pointer),
 SetSource: PTR(pointer),
 SetDescription: PTR(pointer),
 SetHelpFile: PTR(pointer),
 SetHelpContext: PTR(pointer)
});

var ISupportErrorInfoVtbl = STRUCT('ISupportErrorInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 InterfaceSupportsErrorInfo: PTR(pointer)
});

var ITypeFactoryVtbl = STRUCT('ITypeFactoryVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateFromTypeInfo: PTR(pointer)
});

var ITypeMarshalVtbl = STRUCT('ITypeMarshalVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Size: PTR(pointer),
 Marshal: PTR(pointer),
 Unmarshal: PTR(pointer),
 Free: PTR(pointer)
});

var IRecordInfoVtbl = STRUCT('IRecordInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 RecordInit: PTR(pointer),
 RecordClear: PTR(pointer),
 RecordCopy: PTR(pointer),
 GetGuid: PTR(pointer),
 GetName: PTR(pointer),
 GetSize: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetField: PTR(pointer),
 GetFieldNoCopy: PTR(pointer),
 PutField: PTR(pointer),
 PutFieldNoCopy: PTR(pointer),
 GetFieldNames: PTR(pointer),
 IsMatchingType: PTR(pointer),
 RecordCreate: PTR(pointer),
 RecordCreateCopy: PTR(pointer),
 RecordDestroy: PTR(pointer)
});

var IErrorLogVtbl = STRUCT('IErrorLogVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 AddError: PTR(pointer)
});

var IPropertyBagVtbl = STRUCT('IPropertyBagVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Read: PTR(pointer),
 Write: PTR(pointer)
});

var XML_ERROR = STRUCT('XML_ERROR', {
 _nLine: uint,
 _pchBuf: BSTR,
 _cchBuf: uint,
 _ich: uint,
 _pszFound: BSTR,
 _pszExpected: BSTR,
 _reserved1: DWORD,
 _reserved2: DWORD
});

var IXMLDOMImplementationVtbl = STRUCT('IXMLDOMImplementationVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 hasFeature: PTR(pointer)
});

var IXMLDOMNodeVtbl = STRUCT('IXMLDOMNodeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer)
});

var IXMLDOMDocumentFragmentVtbl = STRUCT('IXMLDOMDocumentFragmentVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer)
});

var IXMLDOMDocumentVtbl = STRUCT('IXMLDOMDocumentVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_doctype: PTR(pointer),
 get_implementation: PTR(pointer),
 get_documentElement: PTR(pointer),
 putref_documentElement: PTR(pointer),
 createElement: PTR(pointer),
 createDocumentFragment: PTR(pointer),
 createTextNode: PTR(pointer),
 createComment: PTR(pointer),
 createCDATASection: PTR(pointer),
 createProcessingInstruction: PTR(pointer),
 createAttribute: PTR(pointer),
 createEntityReference: PTR(pointer),
 getElementsByTagName: PTR(pointer),
 createNode: PTR(pointer),
 nodeFromID: PTR(pointer),
 load: PTR(pointer),
 get_readyState: PTR(pointer),
 get_parseError: PTR(pointer),
 get_url: PTR(pointer),
 get_async: PTR(pointer),
 put_async: PTR(pointer),
 abort: PTR(pointer),
 loadXML: PTR(pointer),
 save: PTR(pointer),
 get_validateOnParse: PTR(pointer),
 put_validateOnParse: PTR(pointer),
 get_resolveExternals: PTR(pointer),
 put_resolveExternals: PTR(pointer),
 get_preserveWhiteSpace: PTR(pointer),
 put_preserveWhiteSpace: PTR(pointer),
 put_onreadystatechange: PTR(pointer),
 put_ondataavailable: PTR(pointer),
 put_ontransformnode: PTR(pointer)
});

var IXMLDOMNodeListVtbl = STRUCT('IXMLDOMNodeListVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_item: PTR(pointer),
 get_length: PTR(pointer),
 nextNode: PTR(pointer),
 reset: PTR(pointer),
 get__newEnum: PTR(pointer)
});

var IXMLDOMNamedNodeMapVtbl = STRUCT('IXMLDOMNamedNodeMapVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 getNamedItem: PTR(pointer),
 setNamedItem: PTR(pointer),
 removeNamedItem: PTR(pointer),
 get_item: PTR(pointer),
 get_length: PTR(pointer),
 getQualifiedItem: PTR(pointer),
 removeQualifiedItem: PTR(pointer),
 nextNode: PTR(pointer),
 reset: PTR(pointer),
 get__newEnum: PTR(pointer)
});

var IXMLDOMCharacterDataVtbl = STRUCT('IXMLDOMCharacterDataVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_data: PTR(pointer),
 put_data: PTR(pointer),
 get_length: PTR(pointer),
 substringData: PTR(pointer),
 appendData: PTR(pointer),
 insertData: PTR(pointer),
 deleteData: PTR(pointer),
 replaceData: PTR(pointer)
});

var IXMLDOMAttributeVtbl = STRUCT('IXMLDOMAttributeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_name: PTR(pointer),
 get_value: PTR(pointer),
 put_value: PTR(pointer)
});

var IXMLDOMElementVtbl = STRUCT('IXMLDOMElementVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_tagName: PTR(pointer),
 getAttribute: PTR(pointer),
 setAttribute: PTR(pointer),
 removeAttribute: PTR(pointer),
 getAttributeNode: PTR(pointer),
 setAttributeNode: PTR(pointer),
 removeAttributeNode: PTR(pointer),
 getElementsByTagName: PTR(pointer),
 normalize: PTR(pointer)
});

var IXMLDOMTextVtbl = STRUCT('IXMLDOMTextVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_data: PTR(pointer),
 put_data: PTR(pointer),
 get_length: PTR(pointer),
 substringData: PTR(pointer),
 appendData: PTR(pointer),
 insertData: PTR(pointer),
 deleteData: PTR(pointer),
 replaceData: PTR(pointer),
 splitText: PTR(pointer)
});

var IXMLDOMCommentVtbl = STRUCT('IXMLDOMCommentVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_data: PTR(pointer),
 put_data: PTR(pointer),
 get_length: PTR(pointer),
 substringData: PTR(pointer),
 appendData: PTR(pointer),
 insertData: PTR(pointer),
 deleteData: PTR(pointer),
 replaceData: PTR(pointer)
});

var IXMLDOMProcessingInstructionVtbl = STRUCT('IXMLDOMProcessingInstructionVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_target: PTR(pointer),
 get_data: PTR(pointer),
 put_data: PTR(pointer)
});

var IXMLDOMCDATASectionVtbl = STRUCT('IXMLDOMCDATASectionVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_data: PTR(pointer),
 put_data: PTR(pointer),
 get_length: PTR(pointer),
 substringData: PTR(pointer),
 appendData: PTR(pointer),
 insertData: PTR(pointer),
 deleteData: PTR(pointer),
 replaceData: PTR(pointer),
 splitText: PTR(pointer)
});

var IXMLDOMDocumentTypeVtbl = STRUCT('IXMLDOMDocumentTypeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_name: PTR(pointer),
 get_entities: PTR(pointer),
 get_notations: PTR(pointer)
});

var IXMLDOMNotationVtbl = STRUCT('IXMLDOMNotationVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_publicId: PTR(pointer),
 get_systemId: PTR(pointer)
});

var IXMLDOMEntityVtbl = STRUCT('IXMLDOMEntityVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 get_publicId: PTR(pointer),
 get_systemId: PTR(pointer),
 get_notationName: PTR(pointer)
});

var IXMLDOMEntityReferenceVtbl = STRUCT('IXMLDOMEntityReferenceVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer)
});

var IXMLDOMParseErrorVtbl = STRUCT('IXMLDOMParseErrorVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_errorCode: PTR(pointer),
 get_url: PTR(pointer),
 get_reason: PTR(pointer),
 get_srcText: PTR(pointer),
 get_line: PTR(pointer),
 get_linepos: PTR(pointer),
 get_filepos: PTR(pointer)
});

var IXTLRuntimeVtbl = STRUCT('IXTLRuntimeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_nodeName: PTR(pointer),
 get_nodeValue: PTR(pointer),
 put_nodeValue: PTR(pointer),
 get_nodeType: PTR(pointer),
 get_parentNode: PTR(pointer),
 get_childNodes: PTR(pointer),
 get_firstChild: PTR(pointer),
 get_lastChild: PTR(pointer),
 get_previousSibling: PTR(pointer),
 get_nextSibling: PTR(pointer),
 get_attributes: PTR(pointer),
 insertBefore: PTR(pointer),
 replaceChild: PTR(pointer),
 removeChild: PTR(pointer),
 appendChild: PTR(pointer),
 hasChildNodes: PTR(pointer),
 get_ownerDocument: PTR(pointer),
 cloneNode: PTR(pointer),
 get_nodeTypeString: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 get_specified: PTR(pointer),
 get_definition: PTR(pointer),
 get_nodeTypedValue: PTR(pointer),
 put_nodeTypedValue: PTR(pointer),
 get_dataType: PTR(pointer),
 put_dataType: PTR(pointer),
 get_xml: PTR(pointer),
 transformNode: PTR(pointer),
 selectNodes: PTR(pointer),
 selectSingleNode: PTR(pointer),
 get_parsed: PTR(pointer),
 get_namespaceURI: PTR(pointer),
 get_prefix: PTR(pointer),
 get_baseName: PTR(pointer),
 transformNodeToObject: PTR(pointer),
 uniqueID: PTR(pointer),
 depth: PTR(pointer),
 childNumber: PTR(pointer),
 ancestorChildNumber: PTR(pointer),
 absoluteChildNumber: PTR(pointer),
 formatIndex: PTR(pointer),
 formatNumber: PTR(pointer),
 formatDate: PTR(pointer),
 formatTime: PTR(pointer)
});

var XMLDOMDocumentEventsVtbl = STRUCT('XMLDOMDocumentEventsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer)
});

var IXMLHttpRequestVtbl = STRUCT('IXMLHttpRequestVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 open: PTR(pointer),
 setRequestHeader: PTR(pointer),
 getResponseHeader: PTR(pointer),
 getAllResponseHeaders: PTR(pointer),
 send: PTR(pointer),
 abort: PTR(pointer),
 get_status: PTR(pointer),
 get_statusText: PTR(pointer),
 get_responseXML: PTR(pointer),
 get_responseText: PTR(pointer),
 get_responseBody: PTR(pointer),
 get_responseStream: PTR(pointer),
 get_readyState: PTR(pointer),
 put_onreadystatechange: PTR(pointer)
});

var IXMLDSOControlVtbl = STRUCT('IXMLDSOControlVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_XMLDocument: PTR(pointer),
 put_XMLDocument: PTR(pointer),
 get_JavaDSOCompatible: PTR(pointer),
 put_JavaDSOCompatible: PTR(pointer),
 get_readyState: PTR(pointer)
});

var IXMLElementCollectionVtbl = STRUCT('IXMLElementCollectionVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 put_length: PTR(pointer),
 get_length: PTR(pointer),
 get__newEnum: PTR(pointer),
 item: PTR(pointer)
});

var IXMLDocumentVtbl = STRUCT('IXMLDocumentVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_root: PTR(pointer),
 get_fileSize: PTR(pointer),
 get_fileModifiedDate: PTR(pointer),
 get_fileUpdatedDate: PTR(pointer),
 get_URL: PTR(pointer),
 put_URL: PTR(pointer),
 get_mimeType: PTR(pointer),
 get_readyState: PTR(pointer),
 get_charset: PTR(pointer),
 put_charset: PTR(pointer),
 get_version: PTR(pointer),
 get_doctype: PTR(pointer),
 get_dtdURL: PTR(pointer),
 createElement: PTR(pointer)
});

var IXMLDocument2Vtbl = STRUCT('IXMLDocument2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_root: PTR(pointer),
 get_fileSize: PTR(pointer),
 get_fileModifiedDate: PTR(pointer),
 get_fileUpdatedDate: PTR(pointer),
 get_URL: PTR(pointer),
 put_URL: PTR(pointer),
 get_mimeType: PTR(pointer),
 get_readyState: PTR(pointer),
 get_charset: PTR(pointer),
 put_charset: PTR(pointer),
 get_version: PTR(pointer),
 get_doctype: PTR(pointer),
 get_dtdURL: PTR(pointer),
 createElement: PTR(pointer),
 get_async: PTR(pointer),
 put_async: PTR(pointer)
});

var IXMLElementVtbl = STRUCT('IXMLElementVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_tagName: PTR(pointer),
 put_tagName: PTR(pointer),
 get_parent: PTR(pointer),
 setAttribute: PTR(pointer),
 getAttribute: PTR(pointer),
 removeAttribute: PTR(pointer),
 get_children: PTR(pointer),
 get_type: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 addChild: PTR(pointer),
 removeChild: PTR(pointer)
});

var IXMLElement2Vtbl = STRUCT('IXMLElement2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_tagName: PTR(pointer),
 put_tagName: PTR(pointer),
 get_parent: PTR(pointer),
 setAttribute: PTR(pointer),
 getAttribute: PTR(pointer),
 removeAttribute: PTR(pointer),
 get_children: PTR(pointer),
 get_type: PTR(pointer),
 get_text: PTR(pointer),
 put_text: PTR(pointer),
 addChild: PTR(pointer),
 removeChild: PTR(pointer),
 get_attributes: PTR(pointer)
});

var IXMLAttributeVtbl = STRUCT('IXMLAttributeVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetTypeInfoCount: PTR(pointer),
 GetTypeInfo: PTR(pointer),
 GetIDsOfNames: PTR(pointer),
 Invoke: PTR(pointer),
 get_name: PTR(pointer),
 get_value: PTR(pointer)
});

var IXMLErrorVtbl = STRUCT('IXMLErrorVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetErrorInfo: PTR(pointer)
});

var IPersistMonikerVtbl = STRUCT('IPersistMonikerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetClassID: PTR(pointer),
 IsDirty: PTR(pointer),
 Load: PTR(pointer),
 Save: PTR(pointer),
 SaveCompleted: PTR(pointer),
 GetCurMoniker: PTR(pointer)
});

var IMonikerPropVtbl = STRUCT('IMonikerPropVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 PutProperty: PTR(pointer)
});

var IBindProtocolVtbl = STRUCT('IBindProtocolVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateBinding: PTR(pointer)
});

var IBindingVtbl = STRUCT('IBindingVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Abort: PTR(pointer),
 Suspend: PTR(pointer),
 Resume: PTR(pointer),
 SetPriority: PTR(pointer),
 GetPriority: PTR(pointer),
 GetBindResult: PTR(pointer)
});

var BINDINFO = STRUCT('BINDINFO', {
 cbSize: ULONG,
 szExtraInfo: LPWSTR,
 stgmedData: STGMEDIUM,
 grfBindInfoF: DWORD,
 dwBindVerb: DWORD,
 szCustomVerb: LPWSTR,
 cbstgmedData: DWORD,
 dwOptions: DWORD,
 dwOptionsFlags: DWORD,
 dwCodePage: DWORD,
 securityAttributes: SECURITY_ATTRIBUTES,
 iid: IID,
 pUnk: PTR(uint),
 dwReserved: DWORD
});

var REMSECURITY_ATTRIBUTES = STRUCT('REMSECURITY_ATTRIBUTES', {
 nLength: DWORD,
 lpSecurityDescriptor: DWORD,
 bInheritHandle: BOOL
});

var RemBINDINFO = STRUCT('RemBINDINFO', {
 cbSize: ULONG,
 szExtraInfo: LPWSTR,
 grfBindInfoF: DWORD,
 dwBindVerb: DWORD,
 szCustomVerb: LPWSTR,
 cbstgmedData: DWORD,
 dwOptions: DWORD,
 dwOptionsFlags: DWORD,
 dwCodePage: DWORD,
 securityAttributes: REMSECURITY_ATTRIBUTES,
 iid: IID,
 pUnk: PTR(uint),
 dwReserved: DWORD
});

var RemFORMATETC = STRUCT('RemFORMATETC', {
 cfFormat: DWORD,
 ptd: DWORD,
 dwAspect: DWORD,
 lindex: LONG,
 tymed: DWORD
});

var IBindStatusCallbackVtbl = STRUCT('IBindStatusCallbackVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnStartBinding: PTR(pointer),
 GetPriority: PTR(pointer),
 OnLowResource: PTR(pointer),
 OnProgress: PTR(pointer),
 OnStopBinding: PTR(pointer),
 GetBindInfo: PTR(pointer),
 OnDataAvailable: PTR(pointer),
 OnObjectAvailable: PTR(pointer)
});

var IBindStatusCallbackExVtbl = STRUCT('IBindStatusCallbackExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 OnStartBinding: PTR(pointer),
 GetPriority: PTR(pointer),
 OnLowResource: PTR(pointer),
 OnProgress: PTR(pointer),
 OnStopBinding: PTR(pointer),
 GetBindInfo: PTR(pointer),
 OnDataAvailable: PTR(pointer),
 OnObjectAvailable: PTR(pointer),
 GetBindInfoEx: PTR(pointer)
});

var IAuthenticateVtbl = STRUCT('IAuthenticateVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Authenticate: PTR(pointer)
});

var AUTHENTICATEINFO = STRUCT('AUTHENTICATEINFO', {
 dwFlags: DWORD,
 dwReserved: DWORD
});

var IAuthenticateExVtbl = STRUCT('IAuthenticateExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Authenticate: PTR(pointer),
 AuthenticateEx: PTR(pointer)
});

var IHttpNegotiateVtbl = STRUCT('IHttpNegotiateVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 BeginningTransaction: PTR(pointer),
 OnResponse: PTR(pointer)
});

var IHttpNegotiate2Vtbl = STRUCT('IHttpNegotiate2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 BeginningTransaction: PTR(pointer),
 OnResponse: PTR(pointer),
 GetRootSecurityId: PTR(pointer)
});

var IHttpNegotiate3Vtbl = STRUCT('IHttpNegotiate3Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 BeginningTransaction: PTR(pointer),
 OnResponse: PTR(pointer),
 GetRootSecurityId: PTR(pointer),
 GetSerializedClientCertContext: PTR(pointer)
});

var IWinInetFileStreamVtbl = STRUCT('IWinInetFileStreamVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetHandleForUnlock: PTR(pointer),
 SetDeleteFile: PTR(pointer)
});

var IWindowForBindingUIVtbl = STRUCT('IWindowForBindingUIVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer)
});

var ICodeInstallVtbl = STRUCT('ICodeInstallVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 OnCodeInstallProblem: PTR(pointer)
});

var IUriVtbl = STRUCT('IUriVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetPropertyBSTR: PTR(pointer),
 GetPropertyLength: PTR(pointer),
 GetPropertyDWORD: PTR(pointer),
 HasProperty: PTR(pointer),
 GetAbsoluteUri: PTR(pointer),
 GetAuthority: PTR(pointer),
 GetDisplayUri: PTR(pointer),
 GetDomain: PTR(pointer),
 GetExtension: PTR(pointer),
 GetFragment: PTR(pointer),
 GetHost: PTR(pointer),
 GetPassword: PTR(pointer),
 GetPath: PTR(pointer),
 GetPathAndQuery: PTR(pointer),
 GetQuery: PTR(pointer),
 GetRawUri: PTR(pointer),
 GetSchemeName: PTR(pointer),
 GetUserInfo: PTR(pointer),
 GetUserNameA: PTR(pointer),
 GetHostType: PTR(pointer),
 GetPort: PTR(pointer),
 GetScheme: PTR(pointer),
 GetZone: PTR(pointer),
 GetProperties: PTR(pointer),
 IsEqual: PTR(pointer)
});

var IUriContainerVtbl = STRUCT('IUriContainerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetIUri: PTR(pointer)
});

var IUriBuilderVtbl = STRUCT('IUriBuilderVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateUriSimple: PTR(pointer),
 CreateUri: PTR(pointer),
 CreateUriWithFlags: PTR(pointer),
 GetIUri: PTR(pointer),
 SetIUri: PTR(pointer),
 GetFragment: PTR(pointer),
 GetHost: PTR(pointer),
 GetPassword: PTR(pointer),
 GetPath: PTR(pointer),
 GetPort: PTR(pointer),
 GetQuery: PTR(pointer),
 GetSchemeName: PTR(pointer),
 GetUserNameA: PTR(pointer),
 SetFragment: PTR(pointer),
 SetHost: PTR(pointer),
 SetPassword: PTR(pointer),
 SetPath: PTR(pointer),
 SetPortA: PTR(pointer),
 SetQuery: PTR(pointer),
 SetSchemeName: PTR(pointer),
 SetUserName: PTR(pointer),
 RemoveProperties: PTR(pointer),
 HasBeenModified: PTR(pointer)
});

var IUriBuilderFactoryVtbl = STRUCT('IUriBuilderFactoryVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateIUriBuilder: PTR(pointer),
 CreateInitializedIUriBuilder: PTR(pointer)
});

var IWinInetInfoVtbl = STRUCT('IWinInetInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryOption: PTR(pointer)
});

var IHttpSecurityVtbl = STRUCT('IHttpSecurityVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 OnSecurityProblem: PTR(pointer)
});

var IWinInetHttpInfoVtbl = STRUCT('IWinInetHttpInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 QueryOption: PTR(pointer),
 QueryInfo: PTR(pointer)
});

var IWinInetCacheHintsVtbl = STRUCT('IWinInetCacheHintsVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetCacheExtension: PTR(pointer)
});

var IWinInetCacheHints2Vtbl = STRUCT('IWinInetCacheHints2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetCacheExtension: PTR(pointer),
 SetCacheExtension2: PTR(pointer)
});

var IBindHostVtbl = STRUCT('IBindHostVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 CreateMoniker: PTR(pointer),
 MonikerBindToStorage: PTR(pointer),
 MonikerBindToObject: PTR(pointer)
});

var IInternetVtbl = STRUCT('IInternetVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer)
});

var IInternetBindInfoVtbl = STRUCT('IInternetBindInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBindInfo: PTR(pointer),
 GetBindString: PTR(pointer)
});

var IInternetBindInfoExVtbl = STRUCT('IInternetBindInfoExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetBindInfo: PTR(pointer),
 GetBindString: PTR(pointer),
 GetBindInfoEx: PTR(pointer)
});

var PROTOCOLDATA = STRUCT('PROTOCOLDATA', {
 grfFlags: DWORD,
 dwState: DWORD,
 pData: LPVOID,
 cbData: ULONG
});

var StartParam = STRUCT('StartParam', {
 iid: IID,
 pIBindCtx: PTR(uint),
 pItf: PTR(uint)
});

var IInternetProtocolRootVtbl = STRUCT('IInternetProtocolRootVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Start: PTR(pointer),
 Continue: PTR(pointer),
 Abort: PTR(pointer),
 Terminate: PTR(pointer),
 Suspend: PTR(pointer),
 Resume: PTR(pointer)
});

var IInternetProtocolVtbl = STRUCT('IInternetProtocolVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Start: PTR(pointer),
 Continue: PTR(pointer),
 Abort: PTR(pointer),
 Terminate: PTR(pointer),
 Suspend: PTR(pointer),
 Resume: PTR(pointer),
 Read: PTR(pointer),
 Seek: PTR(pointer),
 LockRequest: PTR(pointer),
 UnlockRequest: PTR(pointer)
});

var IInternetProtocolExVtbl = STRUCT('IInternetProtocolExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Start: PTR(pointer),
 Continue: PTR(pointer),
 Abort: PTR(pointer),
 Terminate: PTR(pointer),
 Suspend: PTR(pointer),
 Resume: PTR(pointer),
 Read: PTR(pointer),
 Seek: PTR(pointer),
 LockRequest: PTR(pointer),
 UnlockRequest: PTR(pointer),
 StartEx: PTR(pointer)
});

var IInternetProtocolSinkVtbl = STRUCT('IInternetProtocolSinkVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Switch: PTR(pointer),
 ReportProgress: PTR(pointer),
 ReportData: PTR(pointer),
 ReportResult: PTR(pointer)
});

var IInternetProtocolSinkStackableVtbl = STRUCT('IInternetProtocolSinkStackableVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SwitchSink: PTR(pointer),
 CommitSwitch: PTR(pointer),
 RollbackSwitch: PTR(pointer)
});

var IInternetSessionVtbl = STRUCT('IInternetSessionVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 RegisterNameSpace: PTR(pointer),
 UnregisterNameSpace: PTR(pointer),
 RegisterMimeFilter: PTR(pointer),
 UnregisterMimeFilter: PTR(pointer),
 CreateBinding: PTR(pointer),
 SetSessionOption: PTR(pointer),
 GetSessionOption: PTR(pointer)
});

var IInternetThreadSwitchVtbl = STRUCT('IInternetThreadSwitchVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Prepare: PTR(pointer),
 Continue: PTR(pointer)
});

var IInternetPriorityVtbl = STRUCT('IInternetPriorityVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetPriority: PTR(pointer),
 GetPriority: PTR(pointer)
});

var IInternetProtocolInfoVtbl = STRUCT('IInternetProtocolInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ParseUrl: PTR(pointer),
 CombineUrl: PTR(pointer),
 CompareUrl: PTR(pointer),
 QueryInfo: PTR(pointer)
});

var IInternetSecurityMgrSiteVtbl = STRUCT('IInternetSecurityMgrSiteVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWindow: PTR(pointer),
 EnableModeless: PTR(pointer)
});

var IInternetSecurityManagerVtbl = STRUCT('IInternetSecurityManagerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetSecuritySite: PTR(pointer),
 GetSecuritySite: PTR(pointer),
 MapUrlToZone: PTR(pointer),
 GetSecurityId: PTR(pointer),
 ProcessUrlAction: PTR(pointer),
 QueryCustomPolicy: PTR(pointer),
 SetZoneMapping: PTR(pointer),
 GetZoneMappings: PTR(pointer)
});

var IInternetSecurityManagerExVtbl = STRUCT('IInternetSecurityManagerExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetSecuritySite: PTR(pointer),
 GetSecuritySite: PTR(pointer),
 MapUrlToZone: PTR(pointer),
 GetSecurityId: PTR(pointer),
 ProcessUrlAction: PTR(pointer),
 QueryCustomPolicy: PTR(pointer),
 SetZoneMapping: PTR(pointer),
 GetZoneMappings: PTR(pointer),
 ProcessUrlActionEx: PTR(pointer)
});

var IInternetSecurityManagerEx2Vtbl = STRUCT('IInternetSecurityManagerEx2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 SetSecuritySite: PTR(pointer),
 GetSecuritySite: PTR(pointer),
 MapUrlToZone: PTR(pointer),
 GetSecurityId: PTR(pointer),
 ProcessUrlAction: PTR(pointer),
 QueryCustomPolicy: PTR(pointer),
 SetZoneMapping: PTR(pointer),
 GetZoneMappings: PTR(pointer),
 ProcessUrlActionEx: PTR(pointer),
 MapUrlToZoneEx2: PTR(pointer),
 ProcessUrlActionEx2: PTR(pointer),
 GetSecurityIdEx2: PTR(pointer),
 QueryCustomPolicyEx2: PTR(pointer)
});

var IZoneIdentifierVtbl = STRUCT('IZoneIdentifierVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetId: PTR(pointer),
 SetId: PTR(pointer),
 Remove: PTR(pointer)
});

var IInternetHostSecurityManagerVtbl = STRUCT('IInternetHostSecurityManagerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetSecurityId: PTR(pointer),
 ProcessUrlAction: PTR(pointer),
 QueryCustomPolicy: PTR(pointer)
});

var ZONEATTRIBUTES = STRUCT('ZONEATTRIBUTES', {
 cbSize: ULONG,
 szDisplayName: pointer,
 szDescription: pointer,
 szIconPath: pointer,
 dwTemplateMinLevel: DWORD,
 dwTemplateRecommended: DWORD,
 dwTemplateCurrentLevel: DWORD,
 dwFlags: DWORD
});

var IInternetZoneManagerVtbl = STRUCT('IInternetZoneManagerVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetZoneAttributes: PTR(pointer),
 SetZoneAttributes: PTR(pointer),
 GetZoneCustomPolicy: PTR(pointer),
 SetZoneCustomPolicy: PTR(pointer),
 GetZoneActionPolicy: PTR(pointer),
 SetZoneActionPolicy: PTR(pointer),
 PromptAction: PTR(pointer),
 LogAction: PTR(pointer),
 CreateZoneEnumerator: PTR(pointer),
 GetZoneAt: PTR(pointer),
 DestroyZoneEnumerator: PTR(pointer),
 CopyTemplatePoliciesToZone: PTR(pointer)
});

var IInternetZoneManagerExVtbl = STRUCT('IInternetZoneManagerExVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetZoneAttributes: PTR(pointer),
 SetZoneAttributes: PTR(pointer),
 GetZoneCustomPolicy: PTR(pointer),
 SetZoneCustomPolicy: PTR(pointer),
 GetZoneActionPolicy: PTR(pointer),
 SetZoneActionPolicy: PTR(pointer),
 PromptAction: PTR(pointer),
 LogAction: PTR(pointer),
 CreateZoneEnumerator: PTR(pointer),
 GetZoneAt: PTR(pointer),
 DestroyZoneEnumerator: PTR(pointer),
 CopyTemplatePoliciesToZone: PTR(pointer),
 GetZoneActionPolicyEx: PTR(pointer),
 SetZoneActionPolicyEx: PTR(pointer)
});

var IInternetZoneManagerEx2Vtbl = STRUCT('IInternetZoneManagerEx2Vtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetZoneAttributes: PTR(pointer),
 SetZoneAttributes: PTR(pointer),
 GetZoneCustomPolicy: PTR(pointer),
 SetZoneCustomPolicy: PTR(pointer),
 GetZoneActionPolicy: PTR(pointer),
 SetZoneActionPolicy: PTR(pointer),
 PromptAction: PTR(pointer),
 LogAction: PTR(pointer),
 CreateZoneEnumerator: PTR(pointer),
 GetZoneAt: PTR(pointer),
 DestroyZoneEnumerator: PTR(pointer),
 CopyTemplatePoliciesToZone: PTR(pointer),
 GetZoneActionPolicyEx: PTR(pointer),
 SetZoneActionPolicyEx: PTR(pointer),
 GetZoneAttributesEx: PTR(pointer),
 GetZoneSecurityState: PTR(pointer),
 GetIESecurityState: PTR(pointer),
 FixUnsecureSettings: PTR(pointer)
});

var CODEBASEHOLD = STRUCT('CODEBASEHOLD', {
 cbSize: ULONG,
 szDistUnit: LPWSTR,
 szCodeBase: LPWSTR,
 dwVersionMS: DWORD,
 dwVersionLS: DWORD,
 dwStyle: DWORD
});

var SOFTDISTINFO = STRUCT('SOFTDISTINFO', {
 cbSize: ULONG,
 dwFlags: DWORD,
 dwAdState: DWORD,
 szTitle: LPWSTR,
 szAbstract: LPWSTR,
 szHREF: LPWSTR,
 dwInstalledVersionMS: DWORD,
 dwInstalledVersionLS: DWORD,
 dwUpdateVersionMS: DWORD,
 dwUpdateVersionLS: DWORD,
 dwAdvertisedVersionMS: DWORD,
 dwAdvertisedVersionLS: DWORD,
 dwReserved: DWORD
});

var ISoftDistExtVtbl = STRUCT('ISoftDistExtVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ProcessSoftDist: PTR(pointer),
 GetFirstCodeBase: PTR(pointer),
 GetNextCodeBase: PTR(pointer),
 AsyncInstallDistributionUnit: PTR(pointer)
});

var ICatalogFileInfoVtbl = STRUCT('ICatalogFileInfoVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetCatalogFile: PTR(pointer),
 GetJavaTrust: PTR(pointer)
});

var IDataFilterVtbl = STRUCT('IDataFilterVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 DoEncode: PTR(pointer),
 DoDecode: PTR(pointer),
 SetEncodingLevel: PTR(pointer)
});

var PROTOCOLFILTERDATA = STRUCT('PROTOCOLFILTERDATA', {
 cbSize: DWORD,
 pProtocolSink: PTR(uint),
 pProtocol: PTR(uint),
 pUnk: PTR(uint),
 dwFilterFlags: DWORD
});

var DATAINFO = STRUCT('DATAINFO', {
 ulTotalSize: ULONG,
 ulavrPacketSize: ULONG,
 ulConnectSpeed: ULONG,
 ulProcessorSpeed: ULONG
});

var IEncodingFilterFactoryVtbl = STRUCT('IEncodingFilterFactoryVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 FindBestFilter: PTR(pointer),
 GetDefaultFilter: PTR(pointer)
});

var HIT_LOGGING_INFO = STRUCT('HIT_LOGGING_INFO', {
 dwStructSize: DWORD,
 lpszLoggedUrlName: LPSTR,
 StartTime: SYSTEMTIME,
 EndTime: SYSTEMTIME,
 lpszExtendedInfo: LPSTR
});

var CONFIRMSAFETY = STRUCT('CONFIRMSAFETY', {
 clsid: CLSID,
 pUnk: PTR(uint),
 dwFlags: DWORD
});

var IWrappedProtocolVtbl = STRUCT('IWrappedProtocolVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetWrapperCode: PTR(pointer)
});

var IPropertyStorage = STRUCT('IPropertyStorage', {
 lpVtbl: PTR(IPropertyStorageVtbl)
});

var IPropertySetStorage = STRUCT('IPropertySetStorage', {
 lpVtbl: PTR(IPropertySetStorageVtbl)
});

var IEnumSTATPROPSTG = STRUCT('IEnumSTATPROPSTG', {
 lpVtbl: PTR(IEnumSTATPROPSTGVtbl)
});

var IEnumSTATPROPSETSTG = STRUCT('IEnumSTATPROPSETSTG', {
 lpVtbl: PTR(IEnumSTATPROPSETSTGVtbl)
});

var VERSIONEDSTREAM = STRUCT('VERSIONEDSTREAM', {
 guidVersion: GUID,
 pStream: PTR(uint)
});


var CAC = STRUCT('CAC', {
 cElems: ULONG,
 pElems: PTR(int8)
});

var CAUB = STRUCT('CAUB', {
 cElems: ULONG,
 pElems: PTR(uchar)
});

var CAI = STRUCT('CAI', {
 cElems: ULONG,
 pElems: PTR(short)
});

var CAUI = STRUCT('CAUI', {
 cElems: ULONG,
 pElems: PTR(ushort)
});

var CAL = STRUCT('CAL', {
 cElems: ULONG,
 pElems: PTR(long)
});

var CAUL = STRUCT('CAUL', {
 cElems: ULONG,
 pElems: PTR(ulong)
});

var CAFLT = STRUCT('CAFLT', {
 cElems: ULONG,
 pElems: PTR(float)
});

var CADBL = STRUCT('CADBL', {
 cElems: ULONG,
 pElems: PTR(double)
});

var CACY = STRUCT('CACY', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CADATE = STRUCT('CADATE', {
 cElems: ULONG,
 pElems: PTR(double)
});

var CABSTR = STRUCT('CABSTR', {
 cElems: ULONG,
 pElems: PTR(PTR(ushort))
});

var CABSTRBLOB = STRUCT('CABSTRBLOB', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CABOOL = STRUCT('CABOOL', {
 cElems: ULONG,
 pElems: PTR(short)
});

var CASCODE = STRUCT('CASCODE', {
 cElems: ULONG,
 pElems: PTR(long)
});

var CAPROPVARIANT = STRUCT('CAPROPVARIANT', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CAH = STRUCT('CAH', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CAUH = STRUCT('CAUH', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CALPSTR = STRUCT('CALPSTR', {
 cElems: ULONG,
 pElems: PTR(PTR(int8))
});

var CALPWSTR = STRUCT('CALPWSTR', {
 cElems: ULONG,
 pElems: PTR(PTR(ushort))
});

var CAFILETIME = STRUCT('CAFILETIME', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CACLIPDATA = STRUCT('CACLIPDATA', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var CACLSID = STRUCT('CACLSID', {
 cElems: ULONG,
 pElems: PTR(uint)
});

var undefined = STRUCT('undefined', {
 vt: VARTYPE,
 wReserved1: PROPVAR_PAD1,
 wReserved2: PROPVAR_PAD2,
 wReserved3: PROPVAR_PAD3
});

var PROPSPEC = STRUCT('PROPSPEC', {
 ulKind: ULONG
});

var STATPROPSTG = STRUCT('STATPROPSTG', {
 lpwstrName: LPOLESTR,
 propid: PROPID,
 vt: VARTYPE
});

var STATPROPSETSTG = STRUCT('STATPROPSETSTG', {
 fmtid: FMTID,
 clsid: CLSID,
 grfFlags: DWORD,
 mtime: FILETIME,
 ctime: FILETIME,
 atime: FILETIME,
 dwOSVersion: DWORD
});

var IPropertyStorageVtbl = STRUCT('IPropertyStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 ReadMultiple: PTR(pointer),
 WriteMultiple: PTR(pointer),
 DeleteMultiple: PTR(pointer),
 ReadPropertyNames: PTR(pointer),
 WritePropertyNames: PTR(pointer),
 DeletePropertyNames: PTR(pointer),
 Commit: PTR(pointer),
 Revert: PTR(pointer),
 Enum: PTR(pointer),
 SetTimes: PTR(pointer),
 SetClass: PTR(pointer),
 Stat: PTR(pointer)
});

var IPropertySetStorageVtbl = STRUCT('IPropertySetStorageVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Create: PTR(pointer),
 Open: PTR(pointer),
 Delete: PTR(pointer),
 Enum: PTR(pointer)
});

var IEnumSTATPROPSTGVtbl = STRUCT('IEnumSTATPROPSTGVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var IEnumSTATPROPSETSTGVtbl = STRUCT('IEnumSTATPROPSETSTGVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 Next: PTR(pointer),
 Skip: PTR(pointer),
 Reset: PTR(pointer),
 Clone: PTR(pointer)
});

var SERIALIZEDPROPERTYVALUE = STRUCT('SERIALIZEDPROPERTYVALUE', {
 dwType: DWORD,
 rgb: pointer
});

var NUMPARSE = STRUCT('NUMPARSE', {
 cDig: INT,
 dwInFlags: ULONG,
 dwOutFlags: ULONG,
 cchUsed: INT,
 nBaseShift: INT,
 nPwr10: INT
});

var UDATE = STRUCT('UDATE', {
 st: SYSTEMTIME,
 wDayOfYear: USHORT
});

var PARAMDATA = STRUCT('PARAMDATA', {
 szName: PTR(ushort),
 vt: VARTYPE
});

var METHODDATA = STRUCT('METHODDATA', {
 szName: PTR(ushort),
 ppdata: PTR(uint),
 dispid: DISPID,
 iMeth: UINT,
 cc: CALLCONV,
 cArgs: UINT,
 wFlags: WORD,
 vtReturn: VARTYPE
});

var INTERFACEDATA = STRUCT('INTERFACEDATA', {
 pmethdata: PTR(uint),
 cMembers: UINT
});

var OLESTREAM = STRUCT('OLESTREAM', {
 lpstbl: LPOLESTREAMVTBL
});

var OLESTREAMVTBL = STRUCT('OLESTREAMVTBL', {
 Get: PTR(pointer),
 Put: PTR(pointer)
});

var OPENFILENAME_NT4 = STRUCT('OPENFILENAME_NT4', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpstrFilter: LPCSTR,
 lpstrCustomFilter: LPSTR,
 nMaxCustFilter: DWORD,
 nFilterIndex: DWORD,
 lpstrFile: LPSTR,
 nMaxFile: DWORD,
 lpstrFileTitle: LPSTR,
 nMaxFileTitle: DWORD,
 lpstrInitialDir: LPCSTR,
 lpstrTitle: LPCSTR,
 Flags: DWORD,
 nFileOffset: WORD,
 nFileExtension: WORD,
 lpstrDefExt: LPCSTR,
 lCustData: LPARAM,
 lpfnHook: LPOFNHOOKPROC,
 lpTemplateName: LPCSTR
});

var OPENFILENAME_NT4W = STRUCT('OPENFILENAME_NT4W', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpstrFilter: LPCWSTR,
 lpstrCustomFilter: LPWSTR,
 nMaxCustFilter: DWORD,
 nFilterIndex: DWORD,
 lpstrFile: LPWSTR,
 nMaxFile: DWORD,
 lpstrFileTitle: LPWSTR,
 nMaxFileTitle: DWORD,
 lpstrInitialDir: LPCWSTR,
 lpstrTitle: LPCWSTR,
 Flags: DWORD,
 nFileOffset: WORD,
 nFileExtension: WORD,
 lpstrDefExt: LPCWSTR,
 lCustData: LPARAM,
 lpfnHook: LPOFNHOOKPROC,
 lpTemplateName: LPCWSTR
});

var OPENFILENAME = STRUCT('OPENFILENAME', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpstrFilter: LPCSTR,
 lpstrCustomFilter: LPSTR,
 nMaxCustFilter: DWORD,
 nFilterIndex: DWORD,
 lpstrFile: LPSTR,
 nMaxFile: DWORD,
 lpstrFileTitle: LPSTR,
 nMaxFileTitle: DWORD,
 lpstrInitialDir: LPCSTR,
 lpstrTitle: LPCSTR,
 Flags: DWORD,
 nFileOffset: WORD,
 nFileExtension: WORD,
 lpstrDefExt: LPCSTR,
 lCustData: LPARAM,
 lpfnHook: LPOFNHOOKPROC,
 lpTemplateName: LPCSTR,
 pvReserved: PTR('void'),
 dwReserved: DWORD,
 FlagsEx: DWORD
});

var OPENFILENAMEW = STRUCT('OPENFILENAMEW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 lpstrFilter: LPCWSTR,
 lpstrCustomFilter: LPWSTR,
 nMaxCustFilter: DWORD,
 nFilterIndex: DWORD,
 lpstrFile: LPWSTR,
 nMaxFile: DWORD,
 lpstrFileTitle: LPWSTR,
 nMaxFileTitle: DWORD,
 lpstrInitialDir: LPCWSTR,
 lpstrTitle: LPCWSTR,
 Flags: DWORD,
 nFileOffset: WORD,
 nFileExtension: WORD,
 lpstrDefExt: LPCWSTR,
 lCustData: LPARAM,
 lpfnHook: LPOFNHOOKPROC,
 lpTemplateName: LPCWSTR,
 pvReserved: PTR('void'),
 dwReserved: DWORD,
 FlagsEx: DWORD
});

var OFNOTIFY = STRUCT('OFNOTIFY', {
 hdr: NMHDR,
 lpOFN: LPOPENFILENAMEA,
 pszFile: LPSTR
});

var OFNOTIFYW = STRUCT('OFNOTIFYW', {
 hdr: NMHDR,
 lpOFN: LPOPENFILENAMEW,
 pszFile: LPWSTR
});

var OFNOTIFYEX = STRUCT('OFNOTIFYEX', {
 hdr: NMHDR,
 lpOFN: LPOPENFILENAMEA,
 psf: LPVOID,
 pidl: LPVOID
});

var OFNOTIFYEXW = STRUCT('OFNOTIFYEXW', {
 hdr: NMHDR,
 lpOFN: LPOPENFILENAMEW,
 psf: LPVOID,
 pidl: LPVOID
});

var CHOOSECOLOR = STRUCT('CHOOSECOLOR', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HWND,
 rgbResult: COLORREF,
 lpCustColors: PTR(ulong),
 Flags: DWORD,
 lCustData: LPARAM,
 lpfnHook: LPCCHOOKPROC,
 lpTemplateName: LPCSTR
});

var CHOOSECOLORW = STRUCT('CHOOSECOLORW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HWND,
 rgbResult: COLORREF,
 lpCustColors: PTR(ulong),
 Flags: DWORD,
 lCustData: LPARAM,
 lpfnHook: LPCCHOOKPROC,
 lpTemplateName: LPCWSTR
});

var FINDREPLACE = STRUCT('FINDREPLACE', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 Flags: DWORD,
 lpstrFindWhat: LPSTR,
 lpstrReplaceWith: LPSTR,
 wFindWhatLen: WORD,
 wReplaceWithLen: WORD,
 lCustData: LPARAM,
 lpfnHook: LPFRHOOKPROC,
 lpTemplateName: LPCSTR
});

var FINDREPLACEW = STRUCT('FINDREPLACEW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hInstance: HINSTANCE,
 Flags: DWORD,
 lpstrFindWhat: LPWSTR,
 lpstrReplaceWith: LPWSTR,
 wFindWhatLen: WORD,
 wReplaceWithLen: WORD,
 lCustData: LPARAM,
 lpfnHook: LPFRHOOKPROC,
 lpTemplateName: LPCWSTR
});

var CHOOSEFONT = STRUCT('CHOOSEFONT', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDC: HDC,
 lpLogFont: LPLOGFONTA,
 iPointSize: INT,
 Flags: DWORD,
 rgbColors: COLORREF,
 lCustData: LPARAM,
 lpfnHook: LPCFHOOKPROC,
 lpTemplateName: LPCSTR,
 hInstance: HINSTANCE,
 lpszStyle: LPSTR,
 nFontType: WORD,
 ___MISSING_ALIGNMENT__: WORD,
 nSizeMin: INT,
 nSizeMax: INT
});

var CHOOSEFONTW = STRUCT('CHOOSEFONTW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDC: HDC,
 lpLogFont: LPLOGFONTW,
 iPointSize: INT,
 Flags: DWORD,
 rgbColors: COLORREF,
 lCustData: LPARAM,
 lpfnHook: LPCFHOOKPROC,
 lpTemplateName: LPCWSTR,
 hInstance: HINSTANCE,
 lpszStyle: LPWSTR,
 nFontType: WORD,
 ___MISSING_ALIGNMENT__: WORD,
 nSizeMin: INT,
 nSizeMax: INT
});

var PRINTDLG = STRUCT('PRINTDLG', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 hDC: HDC,
 Flags: DWORD,
 nFromPage: WORD,
 nToPage: WORD,
 nMinPage: WORD,
 nMaxPage: WORD,
 nCopies: WORD,
 hInstance: HINSTANCE,
 lCustData: LPARAM,
 lpfnPrintHook: LPPRINTHOOKPROC,
 lpfnSetupHook: LPSETUPHOOKPROC,
 lpPrintTemplateName: LPCSTR,
 lpSetupTemplateName: LPCSTR,
 hPrintTemplate: HGLOBAL,
 hSetupTemplate: HGLOBAL
});

var PRINTDLGW = STRUCT('PRINTDLGW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 hDC: HDC,
 Flags: DWORD,
 nFromPage: WORD,
 nToPage: WORD,
 nMinPage: WORD,
 nMaxPage: WORD,
 nCopies: WORD,
 hInstance: HINSTANCE,
 lCustData: LPARAM,
 lpfnPrintHook: LPPRINTHOOKPROC,
 lpfnSetupHook: LPSETUPHOOKPROC,
 lpPrintTemplateName: LPCWSTR,
 lpSetupTemplateName: LPCWSTR,
 hPrintTemplate: HGLOBAL,
 hSetupTemplate: HGLOBAL
});

var IPrintDialogCallback = STRUCT('IPrintDialogCallback', {
 lpVtbl: PTR(IPrintDialogCallbackVtbl)
});

var IPrintDialogCallbackVtbl = STRUCT('IPrintDialogCallbackVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 InitDone: PTR(pointer),
 SelectionChange: PTR(pointer),
 HandleMessage: PTR(pointer)
});

var IPrintDialogServices = STRUCT('IPrintDialogServices', {
 lpVtbl: PTR(IPrintDialogServicesVtbl)
});

var IPrintDialogServicesVtbl = STRUCT('IPrintDialogServicesVtbl', {
 QueryInterface: PTR(pointer),
 AddRef: PTR(pointer),
 Release: PTR(pointer),
 GetCurrentDevMode: PTR(pointer),
 GetCurrentPrinterName: PTR(pointer),
 GetCurrentPortName: PTR(pointer)
});

var PRINTPAGERANGE = STRUCT('PRINTPAGERANGE', {
 nFromPage: DWORD,
 nToPage: DWORD
});

var PRINTDLGEX = STRUCT('PRINTDLGEX', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 hDC: HDC,
 Flags: DWORD,
 Flags2: DWORD,
 ExclusionFlags: DWORD,
 nPageRanges: DWORD,
 nMaxPageRanges: DWORD,
 lpPageRanges: LPPRINTPAGERANGE,
 nMinPage: DWORD,
 nMaxPage: DWORD,
 nCopies: DWORD,
 hInstance: HINSTANCE,
 lpPrintTemplateName: LPCSTR,
 lpCallback: LPUNKNOWN,
 nPropertyPages: DWORD,
 lphPropertyPages: PTR(pointer),
 nStartPage: DWORD,
 dwResultAction: DWORD
});

var PRINTDLGEXW = STRUCT('PRINTDLGEXW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 hDC: HDC,
 Flags: DWORD,
 Flags2: DWORD,
 ExclusionFlags: DWORD,
 nPageRanges: DWORD,
 nMaxPageRanges: DWORD,
 lpPageRanges: LPPRINTPAGERANGE,
 nMinPage: DWORD,
 nMaxPage: DWORD,
 nCopies: DWORD,
 hInstance: HINSTANCE,
 lpPrintTemplateName: LPCWSTR,
 lpCallback: LPUNKNOWN,
 nPropertyPages: DWORD,
 lphPropertyPages: PTR(pointer),
 nStartPage: DWORD,
 dwResultAction: DWORD
});

var DEVNAMES = STRUCT('DEVNAMES', {
 wDriverOffset: WORD,
 wDeviceOffset: WORD,
 wOutputOffset: WORD,
 wDefault: WORD
});

var PAGESETUPDLG = STRUCT('PAGESETUPDLG', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 Flags: DWORD,
 ptPaperSize: POINT,
 rtMinMargin: RECT,
 rtMargin: RECT,
 hInstance: HINSTANCE,
 lCustData: LPARAM,
 lpfnPageSetupHook: LPPAGESETUPHOOK,
 lpfnPagePaintHook: LPPAGEPAINTHOOK,
 lpPageSetupTemplateName: LPCSTR,
 hPageSetupTemplate: HGLOBAL
});

var PAGESETUPDLGW = STRUCT('PAGESETUPDLGW', {
 lStructSize: DWORD,
 hwndOwner: HWND,
 hDevMode: HGLOBAL,
 hDevNames: HGLOBAL,
 Flags: DWORD,
 ptPaperSize: POINT,
 rtMinMargin: RECT,
 rtMargin: RECT,
 hInstance: HINSTANCE,
 lCustData: LPARAM,
 lpfnPageSetupHook: LPPAGESETUPHOOK,
 lpfnPagePaintHook: LPPAGEPAINTHOOK,
 lpPageSetupTemplateName: LPCWSTR,
 hPageSetupTemplate: HGLOBAL
});

var SERVICE_DESCRIPTION = STRUCT('SERVICE_DESCRIPTION', {
 lpDescription: LPSTR
});

var SERVICE_DESCRIPTIONW = STRUCT('SERVICE_DESCRIPTIONW', {
 lpDescription: LPWSTR
});

var SC_ACTION = STRUCT('SC_ACTION', {
 Type: SC_ACTION_TYPE,
 Delay: DWORD
});

var SERVICE_FAILURE_ACTIONS = STRUCT('SERVICE_FAILURE_ACTIONS', {
 dwResetPeriod: DWORD,
 lpRebootMsg: LPSTR,
 lpCommand: LPSTR,
 cActions: DWORD,
 lpsaActions: PTR(uint)
});

var SERVICE_FAILURE_ACTIONSW = STRUCT('SERVICE_FAILURE_ACTIONSW', {
 dwResetPeriod: DWORD,
 lpRebootMsg: LPWSTR,
 lpCommand: LPWSTR,
 cActions: DWORD,
 lpsaActions: PTR(uint)
});

var SERVICE_DELAYED_AUTO_START_INFO = STRUCT('SERVICE_DELAYED_AUTO_START_INFO', {
 fDelayedAutostart: BOOL
});

var SERVICE_FAILURE_ACTIONS_FLAG = STRUCT('SERVICE_FAILURE_ACTIONS_FLAG', {
 fFailureActionsOnNonCrashFailures: BOOL
});

var SERVICE_SID_INFO = STRUCT('SERVICE_SID_INFO', {
 dwServiceSidType: DWORD
});

var SERVICE_REQUIRED_PRIVILEGES_INFO = STRUCT('SERVICE_REQUIRED_PRIVILEGES_INFO', {
 pmszRequiredPrivileges: LPSTR
});

var SERVICE_REQUIRED_PRIVILEGES_INFOW = STRUCT('SERVICE_REQUIRED_PRIVILEGES_INFOW', {
 pmszRequiredPrivileges: LPWSTR
});

var SERVICE_PRESHUTDOWN_INFO = STRUCT('SERVICE_PRESHUTDOWN_INFO', {
 dwPreshutdownTimeout: DWORD
});

var SERVICE_TRIGGER_SPECIFIC_DATA_ITEM = STRUCT('SERVICE_TRIGGER_SPECIFIC_DATA_ITEM', {
 dwDataType: DWORD,
 cbData: DWORD,
 pData: PBYTE
});

var SERVICE_TRIGGER = STRUCT('SERVICE_TRIGGER', {
 dwTriggerType: DWORD,
 dwAction: DWORD,
 pTriggerSubtype: PTR(uint),
 cDataItems: DWORD,
 pDataItems: PSERVICE_TRIGGER_SPECIFIC_DATA_ITEM
});

var SERVICE_TRIGGER_INFO = STRUCT('SERVICE_TRIGGER_INFO', {
 cTriggers: DWORD,
 pTriggers: PSERVICE_TRIGGER,
 pReserved: PBYTE
});

var SERVICE_PREFERRED_NODE_INFO = STRUCT('SERVICE_PREFERRED_NODE_INFO', {
 usPreferredNode: USHORT,
 fDelete: BOOLEAN
});

var SERVICE_TIMECHANGE_INFO = STRUCT('SERVICE_TIMECHANGE_INFO', {
 liNewTime: LARGE_INTEGER,
 liOldTime: LARGE_INTEGER
});

var SC_HANDLE__ = STRUCT('SC_HANDLE__', {
 unused: int
});

var SERVICE_STATUS_HANDLE__ = STRUCT('SERVICE_STATUS_HANDLE__', {
 unused: int
});

var SERVICE_STATUS = STRUCT('SERVICE_STATUS', {
 dwServiceType: DWORD,
 dwCurrentState: DWORD,
 dwControlsAccepted: DWORD,
 dwWin32ExitCode: DWORD,
 dwServiceSpecificExitCode: DWORD,
 dwCheckPoint: DWORD,
 dwWaitHint: DWORD
});

var SERVICE_STATUS_PROCESS = STRUCT('SERVICE_STATUS_PROCESS', {
 dwServiceType: DWORD,
 dwCurrentState: DWORD,
 dwControlsAccepted: DWORD,
 dwWin32ExitCode: DWORD,
 dwServiceSpecificExitCode: DWORD,
 dwCheckPoint: DWORD,
 dwWaitHint: DWORD,
 dwProcessId: DWORD,
 dwServiceFlags: DWORD
});

var ENUM_SERVICE_STATUS = STRUCT('ENUM_SERVICE_STATUS', {
 lpServiceName: LPSTR,
 lpDisplayName: LPSTR,
 ServiceStatus: SERVICE_STATUS
});

var ENUM_SERVICE_STATUSW = STRUCT('ENUM_SERVICE_STATUSW', {
 lpServiceName: LPWSTR,
 lpDisplayName: LPWSTR,
 ServiceStatus: SERVICE_STATUS
});

var ENUM_SERVICE_STATUS_PROCESS = STRUCT('ENUM_SERVICE_STATUS_PROCESS', {
 lpServiceName: LPSTR,
 lpDisplayName: LPSTR,
 ServiceStatusProcess: SERVICE_STATUS_PROCESS
});

var ENUM_SERVICE_STATUS_PROCESSW = STRUCT('ENUM_SERVICE_STATUS_PROCESSW', {
 lpServiceName: LPWSTR,
 lpDisplayName: LPWSTR,
 ServiceStatusProcess: SERVICE_STATUS_PROCESS
});

var QUERY_SERVICE_LOCK_STATUS = STRUCT('QUERY_SERVICE_LOCK_STATUS', {
 fIsLocked: DWORD,
 lpLockOwner: LPSTR,
 dwLockDuration: DWORD
});

var QUERY_SERVICE_LOCK_STATUSW = STRUCT('QUERY_SERVICE_LOCK_STATUSW', {
 fIsLocked: DWORD,
 lpLockOwner: LPWSTR,
 dwLockDuration: DWORD
});

var QUERY_SERVICE_CONFIG = STRUCT('QUERY_SERVICE_CONFIG', {
 dwServiceType: DWORD,
 dwStartType: DWORD,
 dwErrorControl: DWORD,
 lpBinaryPathName: LPSTR,
 lpLoadOrderGroup: LPSTR,
 dwTagId: DWORD,
 lpDependencies: LPSTR,
 lpServiceStartName: LPSTR,
 lpDisplayName: LPSTR
});

var QUERY_SERVICE_CONFIGW = STRUCT('QUERY_SERVICE_CONFIGW', {
 dwServiceType: DWORD,
 dwStartType: DWORD,
 dwErrorControl: DWORD,
 lpBinaryPathName: LPWSTR,
 lpLoadOrderGroup: LPWSTR,
 dwTagId: DWORD,
 lpDependencies: LPWSTR,
 lpServiceStartName: LPWSTR,
 lpDisplayName: LPWSTR
});

var SERVICE_TABLE_ENTRY = STRUCT('SERVICE_TABLE_ENTRY', {
 lpServiceName: LPSTR,
 lpServiceProc: LPSERVICE_MAIN_FUNCTIONA
});

var SERVICE_TABLE_ENTRYW = STRUCT('SERVICE_TABLE_ENTRYW', {
 lpServiceName: LPWSTR,
 lpServiceProc: LPSERVICE_MAIN_FUNCTIONW
});

var SERVICE_NOTIFY_1 = STRUCT('SERVICE_NOTIFY_1', {
 dwVersion: DWORD,
 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
 pContext: PVOID,
 dwNotificationStatus: DWORD,
 ServiceStatus: SERVICE_STATUS_PROCESS
});

var SERVICE_NOTIFY = STRUCT('SERVICE_NOTIFY', {
 dwVersion: DWORD,
 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
 pContext: PVOID,
 dwNotificationStatus: DWORD,
 ServiceStatus: SERVICE_STATUS_PROCESS,
 dwNotificationTriggered: DWORD,
 pszServiceNames: LPSTR
});

var SERVICE_NOTIFYW = STRUCT('SERVICE_NOTIFYW', {
 dwVersion: DWORD,
 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
 pContext: PVOID,
 dwNotificationStatus: DWORD,
 ServiceStatus: SERVICE_STATUS_PROCESS,
 dwNotificationTriggered: DWORD,
 pszServiceNames: LPWSTR
});

var SERVICE_CONTROL_STATUS_REASON_PARAMS = STRUCT('SERVICE_CONTROL_STATUS_REASON_PARAMS', {
 dwReason: DWORD,
 pszComment: LPSTR,
 ServiceStatus: SERVICE_STATUS_PROCESS
});

var SERVICE_CONTROL_STATUS_REASON_PARAMSW = STRUCT('SERVICE_CONTROL_STATUS_REASON_PARAMSW', {
 dwReason: DWORD,
 pszComment: LPWSTR,
 ServiceStatus: SERVICE_STATUS_PROCESS
});

var MODEMDEVCAPS = STRUCT('MODEMDEVCAPS', {
 dwActualSize: DWORD,
 dwRequiredSize: DWORD,
 dwDevSpecificOffset: DWORD,
 dwDevSpecificSize: DWORD,
 dwModemProviderVersion: DWORD,
 dwModemManufacturerOffset: DWORD,
 dwModemManufacturerSize: DWORD,
 dwModemModelOffset: DWORD,
 dwModemModelSize: DWORD,
 dwModemVersionOffset: DWORD,
 dwModemVersionSize: DWORD,
 dwDialOptions: DWORD,
 dwCallSetupFailTimer: DWORD,
 dwInactivityTimeout: DWORD,
 dwSpeakerVolume: DWORD,
 dwSpeakerMode: DWORD,
 dwModemOptions: DWORD,
 dwMaxDTERate: DWORD,
 dwMaxDCERate: DWORD,
 abVariablePortion: pointer
});

var MODEMSETTINGS = STRUCT('MODEMSETTINGS', {
 dwActualSize: DWORD,
 dwRequiredSize: DWORD,
 dwDevSpecificOffset: DWORD,
 dwDevSpecificSize: DWORD,
 dwCallSetupFailTimer: DWORD,
 dwInactivityTimeout: DWORD,
 dwSpeakerVolume: DWORD,
 dwSpeakerMode: DWORD,
 dwPreferredModemOptions: DWORD,
 dwNegotiatedModemOptions: DWORD,
 dwNegotiatedDCERate: DWORD,
 abVariablePortion: pointer
});

var HIMC__ = STRUCT('HIMC__', {
 unused: int
});

var HIMCC__ = STRUCT('HIMCC__', {
 unused: int
});

var COMPOSITIONFORM = STRUCT('COMPOSITIONFORM', {
 dwStyle: DWORD,
 ptCurrentPos: POINT,
 rcArea: RECT
});

var CANDIDATEFORM = STRUCT('CANDIDATEFORM', {
 dwIndex: DWORD,
 dwStyle: DWORD,
 ptCurrentPos: POINT,
 rcArea: RECT
});

var CANDIDATELIST = STRUCT('CANDIDATELIST', {
 dwSize: DWORD,
 dwStyle: DWORD,
 dwCount: DWORD,
 dwSelection: DWORD,
 dwPageStart: DWORD,
 dwPageSize: DWORD,
 dwOffset: pointer
});

var REGISTERWORD = STRUCT('REGISTERWORD', {
 lpReading: LPSTR,
 lpWord: LPSTR
});

var REGISTERWORDW = STRUCT('REGISTERWORDW', {
 lpReading: LPWSTR,
 lpWord: LPWSTR
});

var RECONVERTSTRING = STRUCT('RECONVERTSTRING', {
 dwSize: DWORD,
 dwVersion: DWORD,
 dwStrLen: DWORD,
 dwStrOffset: DWORD,
 dwCompStrLen: DWORD,
 dwCompStrOffset: DWORD,
 dwTargetStrLen: DWORD,
 dwTargetStrOffset: DWORD
});

var STYLEBUF = STRUCT('STYLEBUF', {
 dwStyle: DWORD,
 szDescription: pointer
});

var STYLEBUFW = STRUCT('STYLEBUFW', {
 dwStyle: DWORD,
 szDescription: pointer
});

var IMEMENUITEMINFO = STRUCT('IMEMENUITEMINFO', {
 cbSize: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: DWORD,
 szString: pointer,
 hbmpItem: HBITMAP
});

var IMEMENUITEMINFOW = STRUCT('IMEMENUITEMINFOW', {
 cbSize: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: DWORD,
 szString: pointer,
 hbmpItem: HBITMAP
});

var IMECHARPOSITION = STRUCT('IMECHARPOSITION', {
 dwSize: DWORD,
 dwCharPos: DWORD,
 pt: POINT,
 cLineHeight: UINT,
 rcDocument: RECT
});


FN('wcsicoll', 'void', { _Str1: PTR(ushort), _Str2: PTR(ushort) });
FN('InterlockedBitTestAndSet', BOOLEAN, { Base: PTR(long), Bit: LONG });
FN('InterlockedBitTestAndReset', BOOLEAN, { Base: PTR(long), Bit: LONG });
FN('InterlockedBitTestAndComplement', BOOLEAN, { Base: PTR(long), Bit: LONG });
FN('MemoryBarrier', 'void', {  });
FN('ReadPMC', DWORD64, { Counter: DWORD });
FN('ReadTimeStampCounter', DWORD64, {  });
FN('DbgRaiseAssertionFailure', 'void', {  });
FN('GetFiberData', PVOID, {  });
FN('GetCurrentFiber', PVOID, {  });
FN('RtlUnwind', 'void', { TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID });
FN('RtlInitializeSListHead', 'void', { ListHead: PSLIST_HEADER });
FN('RtlFirstEntrySList', PSINGLE_LIST_ENTRY, { ListHead: PTR(uint) });
FN('RtlInterlockedPopEntrySList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER });
FN('RtlInterlockedPushEntrySList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER, ListEntry: PSINGLE_LIST_ENTRY });
FN('RtlInterlockedFlushSList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER });
FN('RtlQueryDepthSList', WORD, { ListHead: PSLIST_HEADER });
FN('RtlRunOnceInitialize', 'void', { RunOnce: PRTL_RUN_ONCE });
FN('RtlRunOnceExecuteOnce', DWORD, { RunOnce: PRTL_RUN_ONCE, InitFn: PRTL_RUN_ONCE_INIT_FN, Parameter: PVOID, Context: PTR(PTR('void')) });
FN('RtlRunOnceBeginInitialize', DWORD, { RunOnce: PRTL_RUN_ONCE, Flags: DWORD, Context: PTR(PTR('void')) });
FN('RtlRunOnceComplete', DWORD, { RunOnce: PRTL_RUN_ONCE, Flags: DWORD, Context: PVOID });
FN('HEAP_MAKE_TAG_FLAGS', DWORD, { TagBase: DWORD, Tag: DWORD });
FN('RtlCaptureStackBackTrace', WORD, { FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: PTR(PTR('void')), BackTraceHash: PDWORD });
FN('RtlCaptureContext', 'void', { ContextRecord: PCONTEXT });
FN('RtlCompareMemory', SIZE_T, { Source1: PTR('void'), Source2: PTR('void'), Length: SIZE_T });
FN('RtlSecureZeroMemory', PVOID, { ptr: PVOID, cnt: SIZE_T });
FN('RtlPcToFileHeader', PVOID, { PcValue: PVOID, BaseOfImage: PTR(PTR('void')) });
FN('VerSetConditionMask', ULONGLONG, { ConditionMask: ULONGLONG, TypeMask: DWORD, Condition: BYTE });
FN('RtlGetProductInfo', BOOLEAN, { OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, ReturnedProductType: PDWORD });
FN('RtlCopyExtendedContext', DWORD, { Destination: PCONTEXT_EX, ContextFlags: DWORD, Source: PCONTEXT_EX });
FN('RtlInitializeExtendedContext', DWORD, { Context: PVOID, ContextFlags: DWORD, ContextEx: PTR(pointer) });
FN('RtlGetEnabledExtendedFeatures', DWORD64, { FeatureMask: DWORD64 });
FN('RtlGetExtendedContextLength', DWORD, { ContextFlags: DWORD, ContextLength: PDWORD });
FN('RtlGetExtendedFeaturesMask', DWORD64, { ContextEx: PCONTEXT_EX });
FN('RtlLocateExtendedFeature', PVOID, { ContextEx: PCONTEXT_EX, FeatureId: DWORD, Length: PDWORD });
FN('RtlLocateLegacyContext', PCONTEXT, { ContextEx: PCONTEXT_EX, Length: PDWORD });
FN('RtlSetExtendedFeaturesMask', 'void', { ContextEx: PCONTEXT_EX, FeatureMask: DWORD64 });
FN('TpInitializeCallbackEnviron', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON });
FN('TpSetCallbackThreadpool', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, Pool: PTP_POOL });
FN('TpSetCallbackCleanupGroup', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, CleanupGroup: PTP_CLEANUP_GROUP, CleanupGroupCancelCallback: PTP_CLEANUP_GROUP_CANCEL_CALLBACK });
FN('TpSetCallbackActivationContext', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, ActivationContext: PTR(_ACTIVATION_CONTEXT) });
FN('TpSetCallbackNoActivationContext', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON });
FN('TpSetCallbackLongFunction', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON });
FN('TpSetCallbackRaceWithDll', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, DllHandle: PVOID });
FN('TpSetCallbackFinalizationCallback', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, FinalizationCallback: PTP_SIMPLE_CALLBACK });
FN('TpSetCallbackPriority', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON, Priority: TP_CALLBACK_PRIORITY });
FN('TpSetCallbackPersistent', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON });
FN('TpDestroyCallbackEnviron', 'void', { CallbackEnviron: PTP_CALLBACK_ENVIRON });
FN('NtCurrentTeb', struct _TEB, {  });
FN('InitOnceInitialize', 'void', { InitOnce: PINIT_ONCE });
FN('InitOnceExecuteOnce', BOOL, { InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: PTR(PTR('void')) });
FN('InitOnceBeginInitialize', BOOL, { lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: PTR(PTR('void')) });
FN('InitOnceComplete', BOOL, { lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID });
FN('InitializeSRWLock', 'void', { SRWLock: PSRWLOCK });
FN('ReleaseSRWLockExclusive', 'void', { SRWLock: PSRWLOCK });
FN('ReleaseSRWLockShared', 'void', { SRWLock: PSRWLOCK });
FN('AcquireSRWLockExclusive', 'void', { SRWLock: PSRWLOCK });
FN('AcquireSRWLockShared', 'void', { SRWLock: PSRWLOCK });
FN('TryAcquireSRWLockExclusive', BOOLEAN, { SRWLock: PSRWLOCK });
FN('TryAcquireSRWLockShared', BOOLEAN, { SRWLock: PSRWLOCK });
FN('InitializeConditionVariable', 'void', { ConditionVariable: PCONDITION_VARIABLE });
FN('WakeConditionVariable', 'void', { ConditionVariable: PCONDITION_VARIABLE });
FN('WakeAllConditionVariable', 'void', { ConditionVariable: PCONDITION_VARIABLE });
FN('SleepConditionVariableCS', BOOL, { ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION, dwMilliseconds: DWORD });
FN('SleepConditionVariableSRW', BOOL, { ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD, Flags: ULONG });
FN('EncodePointer', PVOID, { Ptr: PVOID });
FN('DecodePointer', PVOID, { Ptr: PVOID });
FN('EncodeSystemPointer', PVOID, { Ptr: PVOID });
FN('DecodeSystemPointer', PVOID, { Ptr: PVOID });
FN('InterlockedIncrement', LONG, { lpAddend: PTR(long) });
FN('InterlockedDecrement', LONG, { lpAddend: PTR(long) });
FN('InterlockedExchange', LONG, { Target: PTR(long), Value: LONG });
FN('InterlockedExchangeAdd', LONG, { Addend: PTR(long), Value: LONG });
FN('InterlockedCompareExchange', LONG, { Destination: PTR(long), Exchange: LONG, Comperand: LONG });
FN('InterlockedCompareExchange64', LONGLONG, { Destination: PTR(longlong), Exchange: LONGLONG, Comperand: LONGLONG });
FN('InterlockedAnd64', LONGLONG, { Destination: PTR(longlong), Value: LONGLONG });
FN('InterlockedOr64', LONGLONG, { Destination: PTR(longlong), Value: LONGLONG });
FN('InterlockedXor64', LONGLONG, { Destination: PTR(longlong), Value: LONGLONG });
FN('InterlockedIncrement64', LONGLONG, { Addend: PTR(longlong) });
FN('InterlockedDecrement64', LONGLONG, { Addend: PTR(longlong) });
FN('InterlockedExchange64', LONGLONG, { Target: PTR(longlong), Value: LONGLONG });
FN('InterlockedExchangeAdd64', LONGLONG, { Addend: PTR(longlong), Value: LONGLONG });
FN('InitializeSListHead', 'void', { ListHead: PSLIST_HEADER });
FN('InterlockedPopEntrySList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER });
FN('InterlockedPushEntrySList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER, ListEntry: PSINGLE_LIST_ENTRY });
FN('InterlockedFlushSList', PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER });
FN('QueryDepthSList', USHORT, { ListHead: PSLIST_HEADER });
FN('FreeResource', BOOL, { hResData: HGLOBAL });
FN('LockResource', LPVOID, { hResData: HGLOBAL });
FN('WinMain', 'void', { hInstance: HINSTANCE, hPrevInstance: HINSTANCE, lpCmdLine: LPSTR, nShowCmd: int });
FN('wWinMain', 'void', { hInstance: HINSTANCE, hPrevInstance: HINSTANCE, lpCmdLine: LPWSTR, nShowCmd: int });
FN('FreeLibrary', BOOL, { hLibModule: HMODULE });
FN('FreeLibraryAndExitThread', 'void', { hLibModule: HMODULE, dwExitCode: DWORD });
FN('DisableThreadLibraryCalls', BOOL, { hLibModule: HMODULE });
FN('GetProcAddress', FARPROC, { hModule: HMODULE, lpProcName: LPCSTR });
FN('GetVersion', DWORD, {  });
FN('GlobalAlloc', HGLOBAL, { uFlags: UINT, dwBytes: SIZE_T });
FN('GlobalReAlloc', HGLOBAL, { hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT });
FN('GlobalSize', SIZE_T, { hMem: HGLOBAL });
FN('GlobalFlags', UINT, { hMem: HGLOBAL });
FN('GlobalLock', LPVOID, { hMem: HGLOBAL });
FN('GlobalHandle', HGLOBAL, { pMem: LPCVOID });
FN('GlobalUnlock', BOOL, { hMem: HGLOBAL });
FN('GlobalFree', HGLOBAL, { hMem: HGLOBAL });
FN('GlobalCompact', SIZE_T, { dwMinFree: DWORD });
FN('GlobalFix', 'void', { hMem: HGLOBAL });
FN('GlobalUnfix', 'void', { hMem: HGLOBAL });
FN('GlobalWire', LPVOID, { hMem: HGLOBAL });
FN('GlobalUnWire', BOOL, { hMem: HGLOBAL });
FN('GlobalMemoryStatus', 'void', { lpBuffer: LPMEMORYSTATUS });
FN('GlobalMemoryStatusEx', BOOL, { lpBuffer: LPMEMORYSTATUSEX });
FN('LocalAlloc', HLOCAL, { uFlags: UINT, uBytes: SIZE_T });
FN('LocalReAlloc', HLOCAL, { hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT });
FN('LocalLock', LPVOID, { hMem: HLOCAL });
FN('LocalHandle', HLOCAL, { pMem: LPCVOID });
FN('LocalUnlock', BOOL, { hMem: HLOCAL });
FN('LocalSize', SIZE_T, { hMem: HLOCAL });
FN('LocalFlags', UINT, { hMem: HLOCAL });
FN('LocalFree', HLOCAL, { hMem: HLOCAL });
FN('LocalShrink', SIZE_T, { hMem: HLOCAL, cbNewSize: UINT });
FN('LocalCompact', SIZE_T, { uMinFree: UINT });
FN('FlushInstructionCache', BOOL, { hProcess: HANDLE, lpBaseAddress: LPCVOID, dwSize: SIZE_T });
FN('FlushProcessWriteBuffers', 'void', {  });
FN('QueryThreadCycleTime', BOOL, { ThreadHandle: HANDLE, CycleTime: PULONG64 });
FN('QueryProcessCycleTime', BOOL, { ProcessHandle: HANDLE, CycleTime: PULONG64 });
FN('QueryIdleProcessorCycleTime', BOOL, { BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64 });
FN('QueryIdleProcessorCycleTimeEx', BOOL, { Group: USHORT, BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64 });
FN('QueryUnbiasedInterruptTime', BOOL, { UnbiasedTime: PULONGLONG });
FN('GetProcessorSystemCycleTime', BOOL, { Group: USHORT, Buffer: PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, ReturnedLength: PDWORD });
FN('VirtualAlloc', LPVOID, { lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD });
FN('VirtualFree', BOOL, { lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD });
FN('VirtualProtect', BOOL, { lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD });
FN('VirtualQuery', SIZE_T, { lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T });
FN('VirtualAllocEx', LPVOID, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD });
FN('VirtualAllocExNuma', LPVOID, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD });
FN('GetWriteWatch', UINT, { dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: PTR(PTR('void')), lpdwCount: PTR(ulong), lpdwGranularity: PULONG });
FN('ResetWriteWatch', UINT, { lpBaseAddress: LPVOID, dwRegionSize: SIZE_T });
FN('GetLargePageMinimum', SIZE_T, {  });
FN('EnumSystemFirmwareTables', UINT, { FirmwareTableProviderSignature: DWORD, pFirmwareTableEnumBuffer: PVOID, BufferSize: DWORD });
FN('GetSystemFirmwareTable', UINT, { FirmwareTableProviderSignature: DWORD, FirmwareTableID: DWORD, pFirmwareTableBuffer: PVOID, BufferSize: DWORD });
FN('GetPhysicallyInstalledSystemMemory', BOOL, { TotalMemoryInKilobytes: PULONGLONG });
FN('VirtualFreeEx', BOOL, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD });
FN('VirtualProtectEx', BOOL, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD });
FN('VirtualQueryEx', SIZE_T, { hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T });
FN('HeapCreate', HANDLE, { flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T });
FN('HeapDestroy', BOOL, { hHeap: HANDLE });
FN('HeapAlloc', LPVOID, { hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T });
FN('HeapReAlloc', LPVOID, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T });
FN('HeapFree', BOOL, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID });
FN('HeapSize', SIZE_T, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID });
FN('HeapValidate', BOOL, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID });
FN('HeapCompact', SIZE_T, { hHeap: HANDLE, dwFlags: DWORD });
FN('GetProcessHeap', HANDLE, {  });
FN('GetProcessHeaps', DWORD, { NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE });
FN('HeapLock', BOOL, { hHeap: HANDLE });
FN('HeapUnlock', BOOL, { hHeap: HANDLE });
FN('HeapWalk', BOOL, { hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY });
FN('HeapSetInformation', BOOL, { HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T });
FN('HeapQueryInformation', BOOL, { HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T });
FN('GetBinaryTypeA', BOOL, { lpApplicationName: LPCSTR, lpBinaryType: LPDWORD });
FN('GetBinaryTypeW', BOOL, { lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD });
FN('GetShortPathNameA', DWORD, { lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD });
FN('GetShortPathNameW', DWORD, { lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD });
FN('GetLongPathNameA', DWORD, { lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD });
FN('GetLongPathNameW', DWORD, { lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD });
FN('GetLongPathNameTransactedA', DWORD, { lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE });
FN('GetLongPathNameTransactedW', DWORD, { lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE });
FN('GetProcessAffinityMask', BOOL, { hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR });
FN('SetProcessAffinityMask', BOOL, { hProcess: HANDLE, dwProcessAffinityMask: DWORD_PTR });
FN('GetProcessGroupAffinity', BOOL, { hProcess: HANDLE, GroupCount: PUSHORT, GroupArray: PUSHORT });
FN('GetProcessHandleCount', BOOL, { hProcess: HANDLE, pdwHandleCount: PDWORD });
FN('GetProcessTimes', BOOL, { hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME });
FN('GetProcessIoCounters', BOOL, { hProcess: HANDLE, lpIoCounters: PIO_COUNTERS });
FN('GetProcessWorkingSetSize', BOOL, { hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T });
FN('GetProcessWorkingSetSizeEx', BOOL, { hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD });
FN('SetProcessWorkingSetSize', BOOL, { hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T });
FN('SetProcessWorkingSetSizeEx', BOOL, { hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD });
FN('SetProcessAffinityUpdateMode', BOOL, { hProcess: HANDLE, dwFlags: DWORD });
FN('QueryProcessAffinityUpdateMode', BOOL, { hProcess: HANDLE, lpdwFlags: LPDWORD });
FN('OpenProcess', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwProcessId: DWORD });
FN('GetCurrentProcess', HANDLE, {  });
FN('GetCurrentProcessId', DWORD, {  });
FN('ExitProcess', 'void', { uExitCode: UINT });
FN('TerminateProcess', BOOL, { hProcess: HANDLE, uExitCode: UINT });
FN('GetExitCodeProcess', BOOL, { hProcess: HANDLE, lpExitCode: LPDWORD });
FN('FatalExit', 'void', { ExitCode: int });
FN('GetEnvironmentStrings', LPCH, {  });
FN('GetEnvironmentStringsW', LPWCH, {  });
FN('SetEnvironmentStringsA', BOOL, { NewEnvironment: LPCH });
FN('SetEnvironmentStringsW', BOOL, { NewEnvironment: LPWCH });
FN('FreeEnvironmentStringsA', BOOL, { LPCH: LPCH });
FN('FreeEnvironmentStringsW', BOOL, { LPWCH: LPWCH });
FN('RaiseException', 'void', { dwExceptionCode: DWORD, dwExceptionFlags: DWORD, nNumberOfArguments: DWORD, lpArguments: PTR(ulong) });
FN('RaiseFailFastException', 'void', { pExceptionRecord: PEXCEPTION_RECORD, pContextRecord: PCONTEXT, dwFlags: DWORD });
FN('UnhandledExceptionFilter', LONG, { ExceptionInfo: PTR(EXCEPTION_POINTERS) });
FN('SetUnhandledExceptionFilter', LPTOP_LEVEL_EXCEPTION_FILTER, { lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER });
FN('CreateFiber', LPVOID, { dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID });
FN('CreateFiberEx', LPVOID, { dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID });
FN('DeleteFiber', 'void', { lpFiber: LPVOID });
FN('ConvertThreadToFiber', LPVOID, { lpParameter: LPVOID });
FN('ConvertThreadToFiberEx', LPVOID, { lpParameter: LPVOID, dwFlags: DWORD });
FN('ConvertFiberToThread', BOOL, {  });
FN('IsThreadAFiber', BOOL, {  });
FN('SwitchToFiber', 'void', { lpFiber: LPVOID });
FN('SwitchToThread', BOOL, {  });
FN('CreateUmsCompletionList', BOOL, { UmsCompletionList: PTR(PTR('void')) });
FN('DequeueUmsCompletionListItems', BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: PTR(PTR('void')) });
FN('GetUmsCompletionListEvent', BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE });
FN('ExecuteUmsThread', BOOL, { UmsThread: PUMS_CONTEXT });
FN('UmsThreadYield', BOOL, { SchedulerParam: PVOID });
FN('DeleteUmsCompletionList', BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST });
FN('GetCurrentUmsThread', PUMS_CONTEXT, {  });
FN('GetNextUmsListItem', PUMS_CONTEXT, { UmsContext: PUMS_CONTEXT });
FN('QueryUmsThreadInformation', BOOL, { UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG });
FN('SetUmsThreadInformation', BOOL, { UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG });
FN('DeleteUmsThreadContext', BOOL, { UmsThread: PUMS_CONTEXT });
FN('CreateUmsThreadContext', BOOL, { lpUmsThread: PTR(PTR('void')) });
FN('EnterUmsSchedulingMode', BOOL, { SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO });
FN('CreateThread', HANDLE, { lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD });
FN('CreateRemoteThread', HANDLE, { hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD });
FN('CreateRemoteThreadEx', HANDLE, { hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, lpThreadId: LPDWORD });
FN('GetCurrentThread', HANDLE, {  });
FN('GetCurrentThreadId', DWORD, {  });
FN('SetThreadStackGuarantee', BOOL, { StackSizeInBytes: PULONG });
FN('GetProcessIdOfThread', DWORD, { Thread: HANDLE });
FN('GetThreadId', DWORD, { Thread: HANDLE });
FN('GetProcessId', DWORD, { Process: HANDLE });
FN('GetCurrentProcessorNumber', DWORD, {  });
FN('GetCurrentProcessorNumberEx', 'void', { ProcNumber: PPROCESSOR_NUMBER });
FN('GetThreadGroupAffinity', BOOL, { hThread: HANDLE, GroupAffinity: PGROUP_AFFINITY });
FN('SetThreadAffinityMask', DWORD_PTR, { hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR });
FN('SetThreadGroupAffinity', BOOL, { hThread: HANDLE, GroupAffinity: PTR(uint), PreviousGroupAffinity: PGROUP_AFFINITY });
FN('SetThreadIdealProcessorEx', BOOL, { hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER, lpPreviousIdealProcessor: PPROCESSOR_NUMBER });
FN('GetThreadIdealProcessorEx', BOOL, { hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER });
FN('SetThreadIdealProcessor', DWORD, { hThread: HANDLE, dwIdealProcessor: DWORD });
FN('SetProcessDEPPolicy', BOOL, { dwFlags: DWORD });
FN('GetProcessDEPPolicy', BOOL, { hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL });
FN('SetProcessPriorityBoost', BOOL, { hProcess: HANDLE, bDisablePriorityBoost: BOOL });
FN('GetProcessPriorityBoost', BOOL, { hProcess: HANDLE, pDisablePriorityBoost: PBOOL });
FN('RequestWakeupLatency', BOOL, { latency: LATENCY_TIME });
FN('IsSystemResumeAutomatic', BOOL, {  });
FN('OpenThread', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwThreadId: DWORD });
FN('SetThreadPriority', BOOL, { hThread: HANDLE, nPriority: int });
FN('SetThreadPriorityBoost', BOOL, { hThread: HANDLE, bDisablePriorityBoost: BOOL });
FN('GetThreadPriorityBoost', BOOL, { hThread: HANDLE, pDisablePriorityBoost: PBOOL });
FN('GetThreadPriority', 'void', { hThread: HANDLE });
FN('GetThreadTimes', BOOL, { hThread: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME });
FN('GetThreadIOPendingFlag', BOOL, { hThread: HANDLE, lpIOIsPending: PBOOL });
FN('ExitThread', 'void', { dwExitCode: DWORD });
FN('TerminateThread', BOOL, { hThread: HANDLE, dwExitCode: DWORD });
FN('GetExitCodeThread', BOOL, { hThread: HANDLE, lpExitCode: LPDWORD });
FN('GetThreadSelectorEntry', BOOL, { hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY });
FN('SetThreadExecutionState', EXECUTION_STATE, { esFlags: EXECUTION_STATE });
FN('PowerCreateRequest', HANDLE, { Context: PREASON_CONTEXT });
FN('PowerSetRequest', BOOL, { PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE });
FN('PowerClearRequest', BOOL, { PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE });
FN('GetLastError', DWORD, {  });
FN('SetLastError', 'void', { dwErrCode: DWORD });
FN('GetOverlappedResult', BOOL, { hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL });
FN('CreateIoCompletionPort', HANDLE, { FileHandle: HANDLE, ExistingCompletionPort: HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD });
FN('GetQueuedCompletionStatus', BOOL, { CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: PULONG_PTR, lpOverlapped: PTR(pointer), dwMilliseconds: DWORD });
FN('GetQueuedCompletionStatusEx', BOOL, { CompletionPort: HANDLE, lpCompletionPortEntries: LPOVERLAPPED_ENTRY, ulCount: ULONG, ulNumEntriesRemoved: PULONG, dwMilliseconds: DWORD, fAlertable: BOOL });
FN('PostQueuedCompletionStatus', BOOL, { CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: LPOVERLAPPED });
FN('SetFileCompletionNotificationModes', BOOL, { FileHandle: HANDLE, Flags: UCHAR });
FN('SetFileIoOverlappedRange', BOOL, { FileHandle: HANDLE, OverlappedRangeStart: PUCHAR, Length: ULONG });
FN('GetErrorMode', UINT, {  });
FN('SetErrorMode', UINT, { uMode: UINT });
FN('GetThreadErrorMode', DWORD, {  });
FN('SetThreadErrorMode', BOOL, { dwNewMode: DWORD, lpOldMode: LPDWORD });
FN('ReadProcessMemory', BOOL, { hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: PTR(ulong) });
FN('WriteProcessMemory', BOOL, { hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: PTR(ulong) });
FN('GetThreadContext', BOOL, { hThread: HANDLE, lpContext: LPCONTEXT });
FN('SetThreadContext', BOOL, { hThread: HANDLE, lpContext: PTR(uint) });
FN('Wow64GetThreadContext', BOOL, { hThread: HANDLE, lpContext: PWOW64_CONTEXT });
FN('Wow64GetThreadSelectorEntry', BOOL, { hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY });
FN('Wow64SetThreadContext', BOOL, { hThread: HANDLE, lpContext: PTR(uint) });
FN('SuspendThread', DWORD, { hThread: HANDLE });
FN('Wow64SuspendThread', DWORD, { hThread: HANDLE });
FN('ResumeThread', DWORD, { hThread: HANDLE });
FN('QueueUserAPC', DWORD, { pfnAPC: PAPCFUNC, hThread: HANDLE, dwData: ULONG_PTR });
FN('IsDebuggerPresent', BOOL, {  });
FN('CheckRemoteDebuggerPresent', BOOL, { hProcess: HANDLE, pbDebuggerPresent: PBOOL });
FN('DebugBreak', 'void', {  });
FN('WaitForDebugEvent', BOOL, { lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD });
FN('ContinueDebugEvent', BOOL, { dwProcessId: DWORD, dwThreadId: DWORD, dwContinueStatus: DWORD });
FN('DebugActiveProcess', BOOL, { dwProcessId: DWORD });
FN('DebugActiveProcessStop', BOOL, { dwProcessId: DWORD });
FN('DebugSetProcessKillOnExit', BOOL, { KillOnExit: BOOL });
FN('DebugBreakProcess', BOOL, { Process: HANDLE });
FN('InitializeCriticalSection', 'void', { lpCriticalSection: LPCRITICAL_SECTION });
FN('EnterCriticalSection', 'void', { lpCriticalSection: LPCRITICAL_SECTION });
FN('LeaveCriticalSection', 'void', { lpCriticalSection: LPCRITICAL_SECTION });
FN('InitializeCriticalSectionAndSpinCount', BOOL, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD });
FN('InitializeCriticalSectionEx', BOOL, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD });
FN('SetCriticalSectionSpinCount', DWORD, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD });
FN('TryEnterCriticalSection', BOOL, { lpCriticalSection: LPCRITICAL_SECTION });
FN('DeleteCriticalSection', 'void', { lpCriticalSection: LPCRITICAL_SECTION });
FN('SetEvent', BOOL, { hEvent: HANDLE });
FN('ResetEvent', BOOL, { hEvent: HANDLE });
FN('PulseEvent', BOOL, { hEvent: HANDLE });
FN('ReleaseSemaphore', BOOL, { hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG });
FN('ReleaseMutex', BOOL, { hMutex: HANDLE });
FN('WaitForSingleObject', DWORD, { hHandle: HANDLE, dwMilliseconds: DWORD });
FN('WaitForMultipleObjects', DWORD, { nCount: DWORD, lpHandles: PTR(PTR('void')), bWaitAll: BOOL, dwMilliseconds: DWORD });
FN('Sleep', 'void', { dwMilliseconds: DWORD });
FN('LoadResource', HGLOBAL, { hModule: HMODULE, hResInfo: HRSRC });
FN('SizeofResource', DWORD, { hModule: HMODULE, hResInfo: HRSRC });
FN('GlobalDeleteAtom', ATOM, { nAtom: ATOM });
FN('InitAtomTable', BOOL, { nSize: DWORD });
FN('DeleteAtom', ATOM, { nAtom: ATOM });
FN('SetHandleCount', UINT, { uNumber: UINT });
FN('GetLogicalDrives', DWORD, {  });
FN('LockFile', BOOL, { hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD });
FN('UnlockFile', BOOL, { hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD });
FN('LockFileEx', BOOL, { hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED });
FN('UnlockFileEx', BOOL, { hFile: HANDLE, dwReserved: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED });
FN('GetFileInformationByHandle', BOOL, { hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION });
FN('GetFileType', DWORD, { hFile: HANDLE });
FN('GetFileSize', DWORD, { hFile: HANDLE, lpFileSizeHigh: LPDWORD });
FN('GetFileSizeEx', BOOL, { hFile: HANDLE, lpFileSize: PLARGE_INTEGER });
FN('GetStdHandle', HANDLE, { nStdHandle: DWORD });
FN('SetStdHandle', BOOL, { nStdHandle: DWORD, hHandle: HANDLE });
FN('SetStdHandleEx', BOOL, { nStdHandle: DWORD, hHandle: HANDLE, phPrevValue: PHANDLE });
FN('WriteFile', BOOL, { hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('ReadFile', BOOL, { hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('FlushFileBuffers', BOOL, { hFile: HANDLE });
FN('DeviceIoControl', BOOL, { hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('RequestDeviceWakeup', BOOL, { hDevice: HANDLE });
FN('CancelDeviceWakeupRequest', BOOL, { hDevice: HANDLE });
FN('GetDevicePowerState', BOOL, { hDevice: HANDLE, pfOn: PTR(int) });
FN('SetMessageWaitingIndicator', BOOL, { hMsgIndicator: HANDLE, ulMsgCount: ULONG });
FN('SetEndOfFile', BOOL, { hFile: HANDLE });
FN('SetFilePointer', DWORD, { hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD });
FN('SetFilePointerEx', BOOL, { hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD });
FN('FindClose', BOOL, { hFindFile: HANDLE });
FN('GetFileTime', BOOL, { hFile: HANDLE, lpCreationTime: LPFILETIME, lpLastAccessTime: LPFILETIME, lpLastWriteTime: LPFILETIME });
FN('SetFileTime', BOOL, { hFile: HANDLE, lpCreationTime: PTR(uint), lpLastAccessTime: PTR(uint), lpLastWriteTime: PTR(uint) });
FN('SetFileValidData', BOOL, { hFile: HANDLE, ValidDataLength: LONGLONG });
FN('SetFileShortNameA', BOOL, { hFile: HANDLE, lpShortName: LPCSTR });
FN('SetFileShortNameW', BOOL, { hFile: HANDLE, lpShortName: LPCWSTR });
FN('CloseHandle', BOOL, { hObject: HANDLE });
FN('DuplicateHandle', BOOL, { hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD });
FN('GetHandleInformation', BOOL, { hObject: HANDLE, lpdwFlags: LPDWORD });
FN('SetHandleInformation', BOOL, { hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD });
FN('LoadModule', DWORD, { lpModuleName: LPCSTR, lpParameterBlock: LPVOID });
FN('WinExec', UINT, { lpCmdLine: LPCSTR, uCmdShow: UINT });
FN('ClearCommBreak', BOOL, { hFile: HANDLE });
FN('ClearCommError', BOOL, { hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT });
FN('SetupComm', BOOL, { hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD });
FN('EscapeCommFunction', BOOL, { hFile: HANDLE, dwFunc: DWORD });
FN('GetCommConfig', BOOL, { hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD });
FN('GetCommMask', BOOL, { hFile: HANDLE, lpEvtMask: LPDWORD });
FN('GetCommProperties', BOOL, { hFile: HANDLE, lpCommProp: LPCOMMPROP });
FN('GetCommModemStatus', BOOL, { hFile: HANDLE, lpModemStat: LPDWORD });
FN('GetCommState', BOOL, { hFile: HANDLE, lpDCB: LPDCB });
FN('GetCommTimeouts', BOOL, { hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS });
FN('PurgeComm', BOOL, { hFile: HANDLE, dwFlags: DWORD });
FN('SetCommBreak', BOOL, { hFile: HANDLE });
FN('SetCommConfig', BOOL, { hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD });
FN('SetCommMask', BOOL, { hFile: HANDLE, dwEvtMask: DWORD });
FN('SetCommState', BOOL, { hFile: HANDLE, lpDCB: LPDCB });
FN('SetCommTimeouts', BOOL, { hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS });
FN('TransmitCommChar', BOOL, { hFile: HANDLE, cChar: int8 });
FN('WaitCommEvent', BOOL, { hFile: HANDLE, lpEvtMask: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('SetTapePosition', DWORD, { hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL });
FN('GetTapePosition', DWORD, { hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD });
FN('PrepareTape', DWORD, { hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL });
FN('EraseTape', DWORD, { hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL });
FN('CreateTapePartition', DWORD, { hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD });
FN('WriteTapemark', DWORD, { hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL });
FN('GetTapeStatus', DWORD, { hDevice: HANDLE });
FN('GetTapeParameters', DWORD, { hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID });
FN('SetTapeParameters', DWORD, { hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID });
FN('Beep', BOOL, { dwFreq: DWORD, dwDuration: DWORD });
FN('MulDiv', 'void', { nNumber: int, nNumerator: int, nDenominator: int });
FN('GetSystemTime', 'void', { lpSystemTime: LPSYSTEMTIME });
FN('GetSystemTimeAsFileTime', 'void', { lpSystemTimeAsFileTime: LPFILETIME });
FN('SetSystemTime', BOOL, { lpSystemTime: PTR(uint) });
FN('GetLocalTime', 'void', { lpSystemTime: LPSYSTEMTIME });
FN('SetLocalTime', BOOL, { lpSystemTime: PTR(uint) });
FN('GetSystemInfo', 'void', { lpSystemInfo: LPSYSTEM_INFO });
FN('GetSystemDEPPolicy', DEP_SYSTEM_POLICY_TYPE, {  });
FN('SetSystemFileCacheSize', BOOL, { MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD });
FN('GetSystemFileCacheSize', BOOL, { lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD });
FN('GetSystemRegistryQuota', BOOL, { pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD });
FN('GetSystemTimes', BOOL, { lpIdleTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME });
FN('GetNativeSystemInfo', 'void', { lpSystemInfo: LPSYSTEM_INFO });
FN('IsProcessorFeaturePresent', BOOL, { ProcessorFeature: DWORD });
FN('SystemTimeToTzSpecificLocalTime', BOOL, { lpTimeZoneInformation: PTR(uint), lpUniversalTime: PTR(uint), lpLocalTime: LPSYSTEMTIME });
FN('TzSpecificLocalTimeToSystemTime', BOOL, { lpTimeZoneInformation: PTR(uint), lpLocalTime: PTR(uint), lpUniversalTime: LPSYSTEMTIME });
FN('GetTimeZoneInformationForYear', BOOL, { wYear: USHORT, pdtzi: PDYNAMIC_TIME_ZONE_INFORMATION, ptzi: LPTIME_ZONE_INFORMATION });
FN('GetTimeZoneInformation', DWORD, { lpTimeZoneInformation: LPTIME_ZONE_INFORMATION });
FN('SetTimeZoneInformation', BOOL, { lpTimeZoneInformation: PTR(uint) });
FN('GetDynamicTimeZoneInformation', DWORD, { pTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION });
FN('SetDynamicTimeZoneInformation', BOOL, { lpTimeZoneInformation: PTR(uint) });
FN('SystemTimeToFileTime', BOOL, { lpSystemTime: PTR(uint), lpFileTime: LPFILETIME });
FN('FileTimeToLocalFileTime', BOOL, { lpFileTime: PTR(uint), lpLocalFileTime: LPFILETIME });
FN('LocalFileTimeToFileTime', BOOL, { lpLocalFileTime: PTR(uint), lpFileTime: LPFILETIME });
FN('FileTimeToSystemTime', BOOL, { lpFileTime: PTR(uint), lpSystemTime: LPSYSTEMTIME });
FN('CompareFileTime', LONG, { lpFileTime1: PTR(uint), lpFileTime2: PTR(uint) });
FN('FileTimeToDosDateTime', BOOL, { lpFileTime: PTR(uint), lpFatDate: LPWORD, lpFatTime: LPWORD });
FN('DosDateTimeToFileTime', BOOL, { wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME });
FN('GetTickCount', DWORD, {  });
FN('GetTickCount64', ULONGLONG, {  });
FN('SetSystemTimeAdjustment', BOOL, { dwTimeAdjustment: DWORD, bTimeAdjustmentDisabled: BOOL });
FN('GetSystemTimeAdjustment', BOOL, { lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD, lpTimeAdjustmentDisabled: PBOOL });
FN('FormatMessageA', DWORD, { dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: PTR(PTR(int8)) });
FN('FormatMessageW', DWORD, { dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: PTR(PTR(int8)) });
FN('CreatePipe', BOOL, { hReadPipe: PHANDLE, hWritePipe: PHANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD });
FN('ConnectNamedPipe', BOOL, { hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED });
FN('DisconnectNamedPipe', BOOL, { hNamedPipe: HANDLE });
FN('SetNamedPipeHandleState', BOOL, { hNamedPipe: HANDLE, lpMode: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD });
FN('GetNamedPipeInfo', BOOL, { hNamedPipe: HANDLE, lpFlags: LPDWORD, lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD, lpMaxInstances: LPDWORD });
FN('PeekNamedPipe', BOOL, { hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD, lpBytesRead: LPDWORD, lpTotalBytesAvail: LPDWORD, lpBytesLeftThisMessage: LPDWORD });
FN('TransactNamedPipe', BOOL, { hNamedPipe: HANDLE, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('CreateMailslotA', HANDLE, { lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateMailslotW', HANDLE, { lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('GetMailslotInfo', BOOL, { hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD });
FN('SetMailslotInfo', BOOL, { hMailslot: HANDLE, lReadTimeout: DWORD });
FN('MapViewOfFile', LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T });
FN('FlushViewOfFile', BOOL, { lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T });
FN('UnmapViewOfFile', BOOL, { lpBaseAddress: LPCVOID });
FN('EncryptFileA', BOOL, { lpFileName: LPCSTR });
FN('EncryptFileW', BOOL, { lpFileName: LPCWSTR });
FN('DecryptFileA', BOOL, { lpFileName: LPCSTR, dwReserved: DWORD });
FN('DecryptFileW', BOOL, { lpFileName: LPCWSTR, dwReserved: DWORD });
FN('FileEncryptionStatusA', BOOL, { lpFileName: LPCSTR, lpStatus: LPDWORD });
FN('FileEncryptionStatusW', BOOL, { lpFileName: LPCWSTR, lpStatus: LPDWORD });
FN('OpenEncryptedFileRawA', DWORD, { lpFileName: LPCSTR, ulFlags: ULONG, pvContext: PTR(PTR('void')) });
FN('OpenEncryptedFileRawW', DWORD, { lpFileName: LPCWSTR, ulFlags: ULONG, pvContext: PTR(PTR('void')) });
FN('ReadEncryptedFileRaw', DWORD, { pfExportCallback: PFE_EXPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID });
FN('WriteEncryptedFileRaw', DWORD, { pfImportCallback: PFE_IMPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID });
FN('CloseEncryptedFileRaw', 'void', { pvContext: PVOID });
FN('lstrcmpA', 'void', { lpString1: LPCSTR, lpString2: LPCSTR });
FN('lstrcmpW', 'void', { lpString1: LPCWSTR, lpString2: LPCWSTR });
FN('lstrcmpiA', 'void', { lpString1: LPCSTR, lpString2: LPCSTR });
FN('lstrcmpiW', 'void', { lpString1: LPCWSTR, lpString2: LPCWSTR });
FN('lstrcpynA', LPSTR, { lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int });
FN('lstrcpynW', LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int });
FN('lstrcpyA', LPSTR, { lpString1: LPSTR, lpString2: LPCSTR });
FN('lstrcpyW', LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR });
FN('lstrcatA', LPSTR, { lpString1: LPSTR, lpString2: LPCSTR });
FN('lstrcatW', LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR });
FN('lstrlenA', 'void', { lpString: LPCSTR });
FN('lstrlenW', 'void', { lpString: LPCWSTR });
FN('OpenFile', HFILE, { lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT });
FN('_lopen', HFILE, { lpPathName: LPCSTR, iReadWrite: int });
FN('_lcreat', HFILE, { lpPathName: LPCSTR, iAttribute: int });
FN('_lread', UINT, { hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT });
FN('_lwrite', UINT, { hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT });
FN('_hread', 'void', { hFile: HFILE, lpBuffer: LPVOID, lBytes: long });
FN('_hwrite', 'void', { hFile: HFILE, lpBuffer: LPCCH, lBytes: long });
FN('_lclose', HFILE, { hFile: HFILE });
FN('_llseek', LONG, { hFile: HFILE, lOffset: LONG, iOrigin: int });
FN('IsTextUnicode', BOOL, { lpv: PTR('void'), iSize: int, lpiResult: LPINT });
FN('FlsAlloc', DWORD, { lpCallback: PFLS_CALLBACK_FUNCTION });
FN('FlsGetValue', PVOID, { dwFlsIndex: DWORD });
FN('FlsSetValue', BOOL, { dwFlsIndex: DWORD, lpFlsData: PVOID });
FN('FlsFree', BOOL, { dwFlsIndex: DWORD });
FN('TlsAlloc', DWORD, {  });
FN('TlsGetValue', LPVOID, { dwTlsIndex: DWORD });
FN('TlsSetValue', BOOL, { dwTlsIndex: DWORD, lpTlsValue: LPVOID });
FN('TlsFree', BOOL, { dwTlsIndex: DWORD });
FN('SleepEx', DWORD, { dwMilliseconds: DWORD, bAlertable: BOOL });
FN('WaitForSingleObjectEx', DWORD, { hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL });
FN('WaitForMultipleObjectsEx', DWORD, { nCount: DWORD, lpHandles: PTR(PTR('void')), bWaitAll: BOOL, dwMilliseconds: DWORD, bAlertable: BOOL });
FN('SignalObjectAndWait', DWORD, { hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL });
FN('ReadFileEx', BOOL, { hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE });
FN('WriteFileEx', BOOL, { hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE });
FN('BackupRead', BOOL, { hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: PTR(PTR('void')) });
FN('BackupSeek', BOOL, { hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: PTR(PTR('void')) });
FN('BackupWrite', BOOL, { hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: PTR(PTR('void')) });
FN('ReadFileScatter', BOOL, { hFile: HANDLE, aSegmentArray: PTR(uint), nNumberOfBytesToRead: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('WriteFileGather', BOOL, { hFile: HANDLE, aSegmentArray: PTR(uint), nNumberOfBytesToWrite: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('CreateMutexA', HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCSTR });
FN('CreateMutexW', HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCWSTR });
FN('OpenMutexA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR });
FN('OpenMutexW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR });
FN('CreateEventA', HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR });
FN('CreateEventW', HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR });
FN('OpenEventA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR });
FN('OpenEventW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR });
FN('CreateSemaphoreA', HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR });
FN('CreateSemaphoreW', HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR });
FN('OpenSemaphoreA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR });
FN('OpenSemaphoreW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR });
FN('CreateWaitableTimerA', HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR });
FN('CreateWaitableTimerW', HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR });
FN('OpenWaitableTimerA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR });
FN('OpenWaitableTimerW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCWSTR });
FN('SetWaitableTimerEx', BOOL, { hTimer: HANDLE, lpDueTime: PTR(uint), lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG });
FN('SetWaitableTimer', BOOL, { hTimer: HANDLE, lpDueTime: PTR(uint), lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: BOOL });
FN('CancelWaitableTimer', BOOL, { hTimer: HANDLE });
FN('CreateMutexExA', HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateMutexExW', HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateEventExA', HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateEventExW', HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateSemaphoreExA', HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateSemaphoreExW', HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateWaitableTimerExA', HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateWaitableTimerExW', HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD });
FN('CreateFileMappingA', HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR });
FN('CreateFileMappingW', HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR });
FN('CreateFileMappingNumaA', HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD });
FN('CreateFileMappingNumaW', HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD });
FN('OpenFileMappingA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR });
FN('OpenFileMappingW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR });
FN('GetLogicalDriveStringsA', DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR });
FN('GetLogicalDriveStringsW', DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR });
FN('CreateMemoryResourceNotification', HANDLE, { NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE });
FN('QueryMemoryResourceNotification', BOOL, { ResourceNotificationHandle: HANDLE, ResourceState: PBOOL });
FN('LoadLibraryA', HMODULE, { lpLibFileName: LPCSTR });
FN('LoadLibraryW', HMODULE, { lpLibFileName: LPCWSTR });
FN('LoadLibraryExA', HMODULE, { lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD });
FN('LoadLibraryExW', HMODULE, { lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD });
FN('GetModuleFileNameA', DWORD, { hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD });
FN('GetModuleFileNameW', DWORD, { hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD });
FN('GetModuleHandleA', HMODULE, { lpModuleName: LPCSTR });
FN('GetModuleHandleW', HMODULE, { lpModuleName: LPCWSTR });
FN('GetModuleHandleExA', BOOL, { dwFlags: DWORD, lpModuleName: LPCSTR, phModule: PTR(pointer) });
FN('GetModuleHandleExW', BOOL, { dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: PTR(pointer) });
FN('NeedCurrentDirectoryForExePathA', BOOL, { ExeName: LPCSTR });
FN('NeedCurrentDirectoryForExePathW', BOOL, { ExeName: LPCWSTR });
FN('QueryFullProcessImageNameA', BOOL, { hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD });
FN('QueryFullProcessImageNameW', BOOL, { hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD });
FN('InitializeProcThreadAttributeList', BOOL, { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount: DWORD, dwFlags: DWORD, lpSize: PSIZE_T });
FN('DeleteProcThreadAttributeList', 'void', { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST });
FN('UpdateProcThreadAttribute', BOOL, { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags: DWORD, Attribute: DWORD_PTR, lpValue: PVOID, cbSize: SIZE_T, lpPreviousValue: PVOID, lpReturnSize: PSIZE_T });
FN('CreateProcessA', BOOL, { lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION });
FN('CreateProcessW', BOOL, { lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION });
FN('SetProcessShutdownParameters', BOOL, { dwLevel: DWORD, dwFlags: DWORD });
FN('GetProcessShutdownParameters', BOOL, { lpdwLevel: LPDWORD, lpdwFlags: LPDWORD });
FN('GetProcessVersion', DWORD, { ProcessId: DWORD });
FN('FatalAppExitA', 'void', { uAction: UINT, lpMessageText: LPCSTR });
FN('FatalAppExitW', 'void', { uAction: UINT, lpMessageText: LPCWSTR });
FN('GetStartupInfoA', 'void', { lpStartupInfo: LPSTARTUPINFOA });
FN('GetStartupInfoW', 'void', { lpStartupInfo: LPSTARTUPINFOW });
FN('GetCommandLineA', LPSTR, {  });
FN('GetCommandLineW', LPWSTR, {  });
FN('GetEnvironmentVariableA', DWORD, { lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD });
FN('GetEnvironmentVariableW', DWORD, { lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD });
FN('SetEnvironmentVariableA', BOOL, { lpName: LPCSTR, lpValue: LPCSTR });
FN('SetEnvironmentVariableW', BOOL, { lpName: LPCWSTR, lpValue: LPCWSTR });
FN('ExpandEnvironmentStringsA', DWORD, { lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD });
FN('ExpandEnvironmentStringsW', DWORD, { lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD });
FN('GetFirmwareEnvironmentVariableA', DWORD, { lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD });
FN('GetFirmwareEnvironmentVariableW', DWORD, { lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD });
FN('SetFirmwareEnvironmentVariableA', BOOL, { lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD });
FN('SetFirmwareEnvironmentVariableW', BOOL, { lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD });
FN('OutputDebugStringA', 'void', { lpOutputString: LPCSTR });
FN('OutputDebugStringW', 'void', { lpOutputString: LPCWSTR });
FN('FindResourceA', HRSRC, { hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR });
FN('FindResourceW', HRSRC, { hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR });
FN('FindResourceExA', HRSRC, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD });
FN('FindResourceExW', HRSRC, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD });
FN('EnumResourceTypesA', BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR });
FN('EnumResourceTypesW', BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR });
FN('EnumResourceNamesA', BOOL, { hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR });
FN('EnumResourceNamesW', BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR });
FN('EnumResourceLanguagesA', BOOL, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR });
FN('EnumResourceLanguagesW', BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR });
FN('EnumResourceTypesExA', BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('EnumResourceTypesExW', BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('EnumResourceNamesExA', BOOL, { hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('EnumResourceNamesExW', BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('EnumResourceLanguagesExA', BOOL, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('EnumResourceLanguagesExW', BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID });
FN('BeginUpdateResourceA', HANDLE, { pFileName: LPCSTR, bDeleteExistingResources: BOOL });
FN('BeginUpdateResourceW', HANDLE, { pFileName: LPCWSTR, bDeleteExistingResources: BOOL });
FN('UpdateResourceA', BOOL, { hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD });
FN('UpdateResourceW', BOOL, { hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD });
FN('EndUpdateResourceA', BOOL, { hUpdate: HANDLE, fDiscard: BOOL });
FN('EndUpdateResourceW', BOOL, { hUpdate: HANDLE, fDiscard: BOOL });
FN('GlobalAddAtomA', ATOM, { lpString: LPCSTR });
FN('GlobalAddAtomW', ATOM, { lpString: LPCWSTR });
FN('GlobalFindAtomA', ATOM, { lpString: LPCSTR });
FN('GlobalFindAtomW', ATOM, { lpString: LPCWSTR });
FN('GlobalGetAtomNameA', UINT, { nAtom: ATOM, lpBuffer: LPSTR, nSize: int });
FN('GlobalGetAtomNameW', UINT, { nAtom: ATOM, lpBuffer: LPWSTR, nSize: int });
FN('AddAtomA', ATOM, { lpString: LPCSTR });
FN('AddAtomW', ATOM, { lpString: LPCWSTR });
FN('FindAtomA', ATOM, { lpString: LPCSTR });
FN('FindAtomW', ATOM, { lpString: LPCWSTR });
FN('GetAtomNameA', UINT, { nAtom: ATOM, lpBuffer: LPSTR, nSize: int });
FN('GetAtomNameW', UINT, { nAtom: ATOM, lpBuffer: LPWSTR, nSize: int });
FN('GetProfileIntA', UINT, { lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT });
FN('GetProfileIntW', UINT, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT });
FN('GetProfileStringA', DWORD, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD });
FN('GetProfileStringW', DWORD, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD });
FN('WriteProfileStringA', BOOL, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR });
FN('WriteProfileStringW', BOOL, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR });
FN('GetProfileSectionA', DWORD, { lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD });
FN('GetProfileSectionW', DWORD, { lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD });
FN('WriteProfileSectionA', BOOL, { lpAppName: LPCSTR, lpString: LPCSTR });
FN('WriteProfileSectionW', BOOL, { lpAppName: LPCWSTR, lpString: LPCWSTR });
FN('GetPrivateProfileIntA', UINT, { lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR });
FN('GetPrivateProfileIntW', UINT, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR });
FN('GetPrivateProfileStringA', DWORD, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR });
FN('GetPrivateProfileStringW', DWORD, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR });
FN('WritePrivateProfileStringA', BOOL, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR });
FN('WritePrivateProfileStringW', BOOL, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR });
FN('GetPrivateProfileSectionA', DWORD, { lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR });
FN('GetPrivateProfileSectionW', DWORD, { lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR });
FN('WritePrivateProfileSectionA', BOOL, { lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR });
FN('WritePrivateProfileSectionW', BOOL, { lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR });
FN('GetPrivateProfileSectionNamesA', DWORD, { lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR });
FN('GetPrivateProfileSectionNamesW', DWORD, { lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR });
FN('GetPrivateProfileStructA', BOOL, { lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR });
FN('GetPrivateProfileStructW', BOOL, { lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR });
FN('WritePrivateProfileStructA', BOOL, { lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR });
FN('WritePrivateProfileStructW', BOOL, { lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR });
FN('GetDriveTypeA', UINT, { lpRootPathName: LPCSTR });
FN('GetDriveTypeW', UINT, { lpRootPathName: LPCWSTR });
FN('GetSystemDirectoryA', UINT, { lpBuffer: LPSTR, uSize: UINT });
FN('GetSystemDirectoryW', UINT, { lpBuffer: LPWSTR, uSize: UINT });
FN('GetTempPathA', DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR });
FN('GetTempPathW', DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR });
FN('GetTempFileNameA', UINT, { lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR });
FN('GetTempFileNameW', UINT, { lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR });
FN('GetWindowsDirectoryA', UINT, { lpBuffer: LPSTR, uSize: UINT });
FN('GetWindowsDirectoryW', UINT, { lpBuffer: LPWSTR, uSize: UINT });
FN('GetSystemWindowsDirectoryA', UINT, { lpBuffer: LPSTR, uSize: UINT });
FN('GetSystemWindowsDirectoryW', UINT, { lpBuffer: LPWSTR, uSize: UINT });
FN('GetSystemWow64DirectoryA', UINT, { lpBuffer: LPSTR, uSize: UINT });
FN('GetSystemWow64DirectoryW', UINT, { lpBuffer: LPWSTR, uSize: UINT });
FN('Wow64EnableWow64FsRedirection', BOOLEAN, { Wow64FsEnableRedirection: BOOLEAN });
FN('Wow64DisableWow64FsRedirection', BOOL, { OldValue: PTR(PTR('void')) });
FN('Wow64RevertWow64FsRedirection', BOOL, { OlValue: PVOID });
FN('SetCurrentDirectoryA', BOOL, { lpPathName: LPCSTR });
FN('SetCurrentDirectoryW', BOOL, { lpPathName: LPCWSTR });
FN('GetCurrentDirectoryA', DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR });
FN('GetCurrentDirectoryW', DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR });
FN('SetDllDirectoryA', BOOL, { lpPathName: LPCSTR });
FN('SetDllDirectoryW', BOOL, { lpPathName: LPCWSTR });
FN('GetDllDirectoryA', DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR });
FN('GetDllDirectoryW', DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR });
FN('SetSearchPathMode', BOOL, { Flags: DWORD });
FN('GetDiskFreeSpaceA', BOOL, { lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD });
FN('GetDiskFreeSpaceW', BOOL, { lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD });
FN('GetDiskFreeSpaceExA', BOOL, { lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER });
FN('GetDiskFreeSpaceExW', BOOL, { lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER });
FN('CreateDirectoryA', BOOL, { lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateDirectoryW', BOOL, { lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateDirectoryExA', BOOL, { lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateDirectoryExW', BOOL, { lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateDirectoryTransactedA', BOOL, { lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE });
FN('CreateDirectoryTransactedW', BOOL, { lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE });
FN('RemoveDirectoryA', BOOL, { lpPathName: LPCSTR });
FN('RemoveDirectoryW', BOOL, { lpPathName: LPCWSTR });
FN('RemoveDirectoryTransactedA', BOOL, { lpPathName: LPCSTR, hTransaction: HANDLE });
FN('RemoveDirectoryTransactedW', BOOL, { lpPathName: LPCWSTR, hTransaction: HANDLE });
FN('GetFullPathNameA', DWORD, { lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)) });
FN('GetFullPathNameW', DWORD, { lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)) });
FN('GetFullPathNameTransactedA', DWORD, { lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)), hTransaction: HANDLE });
FN('GetFullPathNameTransactedW', DWORD, { lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)), hTransaction: HANDLE });
FN('DefineDosDeviceA', BOOL, { dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR });
FN('DefineDosDeviceW', BOOL, { dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR });
FN('QueryDosDeviceA', DWORD, { lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD });
FN('QueryDosDeviceW', DWORD, { lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD });
FN('CreateFileA', HANDLE, { lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE });
FN('CreateFileW', HANDLE, { lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE });
FN('CreateFileTransactedA', HANDLE, { lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID });
FN('CreateFileTransactedW', HANDLE, { lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID });
FN('ReOpenFile', HANDLE, { hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlagsAndAttributes: DWORD });
FN('SetFileAttributesA', BOOL, { lpFileName: LPCSTR, dwFileAttributes: DWORD });
FN('SetFileAttributesW', BOOL, { lpFileName: LPCWSTR, dwFileAttributes: DWORD });
FN('GetFileAttributesA', DWORD, { lpFileName: LPCSTR });
FN('GetFileAttributesW', DWORD, { lpFileName: LPCWSTR });
FN('SetFileAttributesTransactedA', BOOL, { lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE });
FN('SetFileAttributesTransactedW', BOOL, { lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE });
FN('GetFileAttributesTransactedA', BOOL, { lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE });
FN('GetFileAttributesTransactedW', BOOL, { lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE });
FN('GetFileAttributesExA', BOOL, { lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID });
FN('GetFileAttributesExW', BOOL, { lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID });
FN('GetCompressedFileSizeA', DWORD, { lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD });
FN('GetCompressedFileSizeW', DWORD, { lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD });
FN('GetCompressedFileSizeTransactedA', DWORD, { lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE });
FN('GetCompressedFileSizeTransactedW', DWORD, { lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE });
FN('DeleteFileA', BOOL, { lpFileName: LPCSTR });
FN('DeleteFileW', BOOL, { lpFileName: LPCWSTR });
FN('DeleteFileTransactedA', BOOL, { lpFileName: LPCSTR, hTransaction: HANDLE });
FN('DeleteFileTransactedW', BOOL, { lpFileName: LPCWSTR, hTransaction: HANDLE });
FN('CheckNameLegalDOS8Dot3A', BOOL, { lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL });
FN('CheckNameLegalDOS8Dot3W', BOOL, { lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL });
FN('FindFirstFileExA', HANDLE, { lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD });
FN('FindFirstFileExW', HANDLE, { lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD });
FN('FindFirstFileTransactedA', HANDLE, { lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE });
FN('FindFirstFileTransactedW', HANDLE, { lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE });
FN('FindFirstFileA', HANDLE, { lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA });
FN('FindFirstFileW', HANDLE, { lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW });
FN('FindNextFileA', BOOL, { hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA });
FN('FindNextFileW', BOOL, { hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW });
FN('SearchPathA', DWORD, { lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)) });
FN('SearchPathW', DWORD, { lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)) });
FN('CopyFileA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL });
FN('CopyFileW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL });
FN('CopyFileExA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD });
FN('CopyFileExW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD });
FN('CopyFileTransactedA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE });
FN('CopyFileTransactedW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE });
FN('MoveFileA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR });
FN('MoveFileW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR });
FN('MoveFileExA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD });
FN('MoveFileExW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD });
FN('MoveFileWithProgressA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD });
FN('MoveFileWithProgressW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD });
FN('MoveFileTransactedA', BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE });
FN('MoveFileTransactedW', BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE });
FN('ReplaceFileA', BOOL, { lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID });
FN('ReplaceFileW', BOOL, { lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID });
FN('CreateHardLinkA', BOOL, { lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateHardLinkW', BOOL, { lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateHardLinkTransactedA', BOOL, { lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE });
FN('CreateHardLinkTransactedW', BOOL, { lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE });
FN('FindFirstStreamW', HANDLE, { lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD });
FN('FindFirstStreamTransactedW', HANDLE, { lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE });
FN('FindNextStreamW', BOOL, { hFindStream: HANDLE, lpFindStreamData: LPVOID });
FN('FindFirstFileNameW', HANDLE, { lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWCHAR });
FN('FindNextFileNameW', BOOL, { hFindStream: HANDLE, StringLength: LPDWORD, LinkName: PWCHAR });
FN('FindFirstFileNameTransactedW', HANDLE, { lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWCHAR, hTransaction: HANDLE });
FN('CreateNamedPipeA', HANDLE, { lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('CreateNamedPipeW', HANDLE, { lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('GetNamedPipeHandleStateA', BOOL, { hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD });
FN('GetNamedPipeHandleStateW', BOOL, { hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR, nMaxUserNameSize: DWORD });
FN('CallNamedPipeA', BOOL, { lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD });
FN('CallNamedPipeW', BOOL, { lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD });
FN('WaitNamedPipeA', BOOL, { lpNamedPipeName: LPCSTR, nTimeOut: DWORD });
FN('WaitNamedPipeW', BOOL, { lpNamedPipeName: LPCWSTR, nTimeOut: DWORD });
FN('GetNamedPipeAttribute', BOOL, { Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR, AttributeValue: PVOID, AttributeValueLength: PSIZE_T });
FN('SetNamedPipeAttribute', BOOL, { Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR, AttributeValue: PVOID, AttributeValueLength: SIZE_T });
FN('GetNamedPipeClientComputerNameA', BOOL, { Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG });
FN('GetNamedPipeClientComputerNameW', BOOL, { Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG });
FN('GetNamedPipeClientProcessId', BOOL, { Pipe: HANDLE, ClientProcessId: PULONG });
FN('GetNamedPipeClientSessionId', BOOL, { Pipe: HANDLE, ClientSessionId: PULONG });
FN('GetNamedPipeServerProcessId', BOOL, { Pipe: HANDLE, ServerProcessId: PULONG });
FN('GetNamedPipeServerSessionId', BOOL, { Pipe: HANDLE, ServerSessionId: PULONG });
FN('SetVolumeLabelA', BOOL, { lpRootPathName: LPCSTR, lpVolumeName: LPCSTR });
FN('SetVolumeLabelW', BOOL, { lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR });
FN('SetFileApisToOEM', 'void', {  });
FN('SetFileApisToANSI', 'void', {  });
FN('AreFileApisANSI', BOOL, {  });
FN('GetVolumeInformationA', BOOL, { lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD });
FN('GetVolumeInformationW', BOOL, { lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD });
FN('GetVolumeInformationByHandleW', BOOL, { hFile: HANDLE, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD });
FN('CancelSynchronousIo', BOOL, { hThread: HANDLE });
FN('CancelIoEx', BOOL, { hFile: HANDLE, lpOverlapped: LPOVERLAPPED });
FN('CancelIo', BOOL, { hFile: HANDLE });
FN('SetFileBandwidthReservation', BOOL, { hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD });
FN('GetFileBandwidthReservation', BOOL, { hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD });
FN('ClearEventLogA', BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCSTR });
FN('ClearEventLogW', BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCWSTR });
FN('BackupEventLogA', BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCSTR });
FN('BackupEventLogW', BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCWSTR });
FN('CloseEventLog', BOOL, { hEventLog: HANDLE });
FN('DeregisterEventSource', BOOL, { hEventLog: HANDLE });
FN('NotifyChangeEventLog', BOOL, { hEventLog: HANDLE, hEvent: HANDLE });
FN('GetNumberOfEventLogRecords', BOOL, { hEventLog: HANDLE, NumberOfRecords: PDWORD });
FN('GetOldestEventLogRecord', BOOL, { hEventLog: HANDLE, OldestRecord: PDWORD });
FN('OpenEventLogA', HANDLE, { lpUNCServerName: LPCSTR, lpSourceName: LPCSTR });
FN('OpenEventLogW', HANDLE, { lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR });
FN('RegisterEventSourceA', HANDLE, { lpUNCServerName: LPCSTR, lpSourceName: LPCSTR });
FN('RegisterEventSourceW', HANDLE, { lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR });
FN('OpenBackupEventLogA', HANDLE, { lpUNCServerName: LPCSTR, lpFileName: LPCSTR });
FN('OpenBackupEventLogW', HANDLE, { lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR });
FN('ReadEventLogA', BOOL, { hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: PTR(ulong), pnMinNumberOfBytesNeeded: PTR(ulong) });
FN('ReadEventLogW', BOOL, { hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: PTR(ulong), pnMinNumberOfBytesNeeded: PTR(ulong) });
FN('ReportEventA', BOOL, { hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: PTR(PTR(int8)), lpRawData: LPVOID });
FN('ReportEventW', BOOL, { hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: PTR(PTR(ushort)), lpRawData: LPVOID });
FN('GetEventLogInformation', BOOL, { hEventLog: HANDLE, dwInfoLevel: DWORD, lpBuffer: LPVOID, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD });
FN('DuplicateToken', BOOL, { ExistingTokenHandle: HANDLE, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, DuplicateTokenHandle: PHANDLE });
FN('GetKernelObjectSecurity', BOOL, { Handle: HANDLE, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('ImpersonateNamedPipeClient', BOOL, { hNamedPipe: HANDLE });
FN('ImpersonateSelf', BOOL, { ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL });
FN('RevertToSelf', BOOL, {  });
FN('SetThreadToken', BOOL, { Thread: PHANDLE, Token: HANDLE });
FN('AccessCheck', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccess: LPDWORD, AccessStatus: LPBOOL });
FN('AccessCheckByType', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, DesiredAccess: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccess: LPDWORD, AccessStatus: LPBOOL });
FN('AccessCheckByTypeResultList', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, DesiredAccess: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccessList: LPDWORD, AccessStatusList: LPDWORD });
FN('OpenProcessToken', BOOL, { ProcessHandle: HANDLE, DesiredAccess: DWORD, TokenHandle: PHANDLE });
FN('OpenThreadToken', BOOL, { ThreadHandle: HANDLE, DesiredAccess: DWORD, OpenAsSelf: BOOL, TokenHandle: PHANDLE });
FN('GetTokenInformation', BOOL, { TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD, ReturnLength: PDWORD });
FN('SetTokenInformation', BOOL, { TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD });
FN('AdjustTokenPrivileges', BOOL, { TokenHandle: HANDLE, DisableAllPrivileges: BOOL, NewState: PTOKEN_PRIVILEGES, BufferLength: DWORD, PreviousState: PTOKEN_PRIVILEGES, ReturnLength: PDWORD });
FN('AdjustTokenGroups', BOOL, { TokenHandle: HANDLE, ResetToDefault: BOOL, NewState: PTOKEN_GROUPS, BufferLength: DWORD, PreviousState: PTOKEN_GROUPS, ReturnLength: PDWORD });
FN('PrivilegeCheck', BOOL, { ClientToken: HANDLE, RequiredPrivileges: PPRIVILEGE_SET, pfResult: LPBOOL });
FN('AccessCheckAndAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL });
FN('AccessCheckAndAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeAndAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeAndAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatus: LPBOOL, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeResultListAndAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeResultListAndAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeResultListAndAuditAlarmByHandleA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCSTR, ObjectName: LPCSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL });
FN('AccessCheckByTypeResultListAndAuditAlarmByHandleW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, ObjectTypeName: LPCWSTR, ObjectName: LPCWSTR, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, DesiredAccess: DWORD, AuditType: AUDIT_EVENT_TYPE, Flags: DWORD, ObjectTypeList: POBJECT_TYPE_LIST, ObjectTypeListLength: DWORD, GenericMapping: PGENERIC_MAPPING, ObjectCreation: BOOL, GrantedAccess: LPDWORD, AccessStatusList: LPDWORD, pfGenerateOnClose: LPBOOL });
FN('ObjectOpenAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ObjectTypeName: LPSTR, ObjectName: LPSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: BOOL, AccessGranted: BOOL, GenerateOnClose: LPBOOL });
FN('ObjectOpenAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ObjectTypeName: LPWSTR, ObjectName: LPWSTR, pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GrantedAccess: DWORD, Privileges: PPRIVILEGE_SET, ObjectCreation: BOOL, AccessGranted: BOOL, GenerateOnClose: LPBOOL });
FN('ObjectPrivilegeAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL });
FN('ObjectPrivilegeAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL });
FN('ObjectCloseAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: BOOL });
FN('ObjectCloseAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: BOOL });
FN('ObjectDeleteAuditAlarmA', BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: BOOL });
FN('ObjectDeleteAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: BOOL });
FN('PrivilegedServiceAuditAlarmA', BOOL, { SubsystemName: LPCSTR, ServiceName: LPCSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL });
FN('PrivilegedServiceAuditAlarmW', BOOL, { SubsystemName: LPCWSTR, ServiceName: LPCWSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL });
FN('IsWellKnownSid', BOOL, { pSid: PSID, WellKnownSidType: WELL_KNOWN_SID_TYPE });
FN('CreateWellKnownSid', BOOL, { WellKnownSidType: WELL_KNOWN_SID_TYPE, DomainSid: PSID, pSid: PSID, cbSid: PTR(ulong) });
FN('EqualDomainSid', BOOL, { pSid1: PSID, pSid2: PSID, pfEqual: PTR(int) });
FN('GetWindowsAccountDomainSid', BOOL, { pSid: PSID, pDomainSid: PSID, cbDomainSid: PTR(ulong) });
FN('IsValidSid', BOOL, { pSid: PSID });
FN('EqualSid', BOOL, { pSid1: PSID, pSid2: PSID });
FN('EqualPrefixSid', BOOL, { pSid1: PSID, pSid2: PSID });
FN('GetSidLengthRequired', DWORD, { nSubAuthorityCount: UCHAR });
FN('AllocateAndInitializeSid', BOOL, { pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, nSubAuthorityCount: BYTE, nSubAuthority0: DWORD, nSubAuthority1: DWORD, nSubAuthority2: DWORD, nSubAuthority3: DWORD, nSubAuthority4: DWORD, nSubAuthority5: DWORD, nSubAuthority6: DWORD, nSubAuthority7: DWORD, pSid: PTR(PTR('void')) });
FN('FreeSid', PVOID, { pSid: PSID });
FN('InitializeSid', BOOL, { Sid: PSID, pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, nSubAuthorityCount: BYTE });
FN('GetSidIdentifierAuthority', PSID_IDENTIFIER_AUTHORITY, { pSid: PSID });
FN('GetSidSubAuthority', PDWORD, { pSid: PSID, nSubAuthority: DWORD });
FN('GetSidSubAuthorityCount', PUCHAR, { pSid: PSID });
FN('GetLengthSid', DWORD, { pSid: PSID });
FN('CopySid', BOOL, { nDestinationSidLength: DWORD, pDestinationSid: PSID, pSourceSid: PSID });
FN('AreAllAccessesGranted', BOOL, { GrantedAccess: DWORD, DesiredAccess: DWORD });
FN('AreAnyAccessesGranted', BOOL, { GrantedAccess: DWORD, DesiredAccess: DWORD });
FN('MapGenericMask', 'void', { AccessMask: PDWORD, GenericMapping: PGENERIC_MAPPING });
FN('IsValidAcl', BOOL, { pAcl: PACL });
FN('InitializeAcl', BOOL, { pAcl: PACL, nAclLength: DWORD, dwAclRevision: DWORD });
FN('GetAclInformation', BOOL, { pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS });
FN('SetAclInformation', BOOL, { pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS });
FN('AddAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, dwStartingAceIndex: DWORD, pAceList: LPVOID, nAceListLength: DWORD });
FN('DeleteAce', BOOL, { pAcl: PACL, dwAceIndex: DWORD });
FN('GetAce', BOOL, { pAcl: PACL, dwAceIndex: DWORD, pAce: PTR(PTR('void')) });
FN('AddAccessAllowedAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID });
FN('AddAccessAllowedAceEx', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID });
FN('AddMandatoryAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, MandatoryPolicy: DWORD, pLabelSid: PSID });
FN('AddConditionalAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AceType: UCHAR, AccessMask: DWORD, pSid: PSID, ConditionStr: PWCHAR, ReturnLength: PTR(ulong) });
FN('AddAccessDeniedAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID });
FN('AddAccessDeniedAceEx', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID });
FN('AddAuditAccessAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL });
FN('AddAuditAccessAceEx', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL });
FN('AddAccessAllowedObjectAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID });
FN('AddAccessDeniedObjectAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID });
FN('AddAuditAccessObjectAce', BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL });
FN('FindFirstFreeAce', BOOL, { pAcl: PACL, pAce: PTR(PTR('void')) });
FN('InitializeSecurityDescriptor', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, dwRevision: DWORD });
FN('IsValidSecurityDescriptor', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('IsValidRelativeSecurityDescriptor', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, SecurityDescriptorLength: ULONG, RequiredInformation: SECURITY_INFORMATION });
FN('GetSecurityDescriptorLength', DWORD, { pSecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('GetSecurityDescriptorControl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pControl: PSECURITY_DESCRIPTOR_CONTROL, lpdwRevision: LPDWORD });
FN('SetSecurityDescriptorControl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, ControlBitsOfInterest: SECURITY_DESCRIPTOR_CONTROL, ControlBitsToSet: SECURITY_DESCRIPTOR_CONTROL });
FN('SetSecurityDescriptorDacl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, bDaclPresent: BOOL, pDacl: PACL, bDaclDefaulted: BOOL });
FN('GetSecurityDescriptorDacl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbDaclPresent: LPBOOL, pDacl: PTR(pointer), lpbDaclDefaulted: LPBOOL });
FN('SetSecurityDescriptorSacl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, bSaclPresent: BOOL, pSacl: PACL, bSaclDefaulted: BOOL });
FN('GetSecurityDescriptorSacl', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbSaclPresent: LPBOOL, pSacl: PTR(pointer), lpbSaclDefaulted: LPBOOL });
FN('SetSecurityDescriptorOwner', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: PSID, bOwnerDefaulted: BOOL });
FN('GetSecurityDescriptorOwner', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: PTR(PTR('void')), lpbOwnerDefaulted: LPBOOL });
FN('SetSecurityDescriptorGroup', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: PSID, bGroupDefaulted: BOOL });
FN('GetSecurityDescriptorGroup', BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: PTR(PTR('void')), lpbGroupDefaulted: LPBOOL });
FN('SetSecurityDescriptorRMControl', DWORD, { SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR });
FN('GetSecurityDescriptorRMControl', DWORD, { SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR });
FN('CreatePrivateObjectSecurity', BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: PTR(PTR('void')), IsDirectoryObject: BOOL, Token: HANDLE, GenericMapping: PGENERIC_MAPPING });
FN('ConvertToAutoInheritPrivateObjectSecurity', BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR, NewSecurityDescriptor: PTR(PTR('void')), ObjectType: PTR(uint), IsDirectoryObject: BOOLEAN, GenericMapping: PGENERIC_MAPPING });
FN('CreatePrivateObjectSecurityEx', BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: PTR(PTR('void')), ObjectType: PTR(uint), IsContainerObject: BOOL, AutoInheritFlags: ULONG, Token: HANDLE, GenericMapping: PGENERIC_MAPPING });
FN('CreatePrivateObjectSecurityWithMultipleInheritance', BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: PTR(PTR('void')), ObjectTypes: PTR(PTR(uint)), GuidCount: ULONG, IsContainerObject: BOOL, AutoInheritFlags: ULONG, Token: HANDLE, GenericMapping: PGENERIC_MAPPING });
FN('SetPrivateObjectSecurity', BOOL, { SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: PTR(PTR('void')), GenericMapping: PGENERIC_MAPPING, Token: HANDLE });
FN('SetPrivateObjectSecurityEx', BOOL, { SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: PTR(PTR('void')), AutoInheritFlags: ULONG, GenericMapping: PGENERIC_MAPPING, Token: HANDLE });
FN('GetPrivateObjectSecurity', BOOL, { ObjectDescriptor: PSECURITY_DESCRIPTOR, SecurityInformation: SECURITY_INFORMATION, ResultantDescriptor: PSECURITY_DESCRIPTOR, DescriptorLength: DWORD, ReturnLength: PDWORD });
FN('DestroyPrivateObjectSecurity', BOOL, { ObjectDescriptor: PTR(PTR('void')) });
FN('MakeSelfRelativeSD', BOOL, { pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwBufferLength: LPDWORD });
FN('MakeAbsoluteSD', BOOL, { pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwAbsoluteSecurityDescriptorSize: LPDWORD, pDacl: PACL, lpdwDaclSize: LPDWORD, pSacl: PACL, lpdwSaclSize: LPDWORD, pOwner: PSID, lpdwOwnerSize: LPDWORD, pPrimaryGroup: PSID, lpdwPrimaryGroupSize: LPDWORD });
FN('MakeAbsoluteSD2', BOOL, { pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwBufferSize: LPDWORD });
FN('QuerySecurityAccessMask', 'void', { SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD });
FN('SetSecurityAccessMask', 'void', { SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD });
FN('SetFileSecurityA', BOOL, { lpFileName: LPCSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('SetFileSecurityW', BOOL, { lpFileName: LPCWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('GetFileSecurityA', BOOL, { lpFileName: LPCSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('GetFileSecurityW', BOOL, { lpFileName: LPCWSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('SetKernelObjectSecurity', BOOL, { Handle: HANDLE, SecurityInformation: SECURITY_INFORMATION, SecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('FindFirstChangeNotificationA', HANDLE, { lpPathName: LPCSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD });
FN('FindFirstChangeNotificationW', HANDLE, { lpPathName: LPCWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD });
FN('FindNextChangeNotification', BOOL, { hChangeHandle: HANDLE });
FN('FindCloseChangeNotification', BOOL, { hChangeHandle: HANDLE });
FN('ReadDirectoryChangesW', BOOL, { hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE });
FN('VirtualLock', BOOL, { lpAddress: LPVOID, dwSize: SIZE_T });
FN('VirtualUnlock', BOOL, { lpAddress: LPVOID, dwSize: SIZE_T });
FN('MapViewOfFileEx', LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID });
FN('MapViewOfFileExNuma', LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD });
FN('SetPriorityClass', BOOL, { hProcess: HANDLE, dwPriorityClass: DWORD });
FN('GetPriorityClass', DWORD, { hProcess: HANDLE });
FN('IsBadReadPtr', BOOL, { lp: PTR('void'), ucb: UINT_PTR });
FN('IsBadWritePtr', BOOL, { lp: LPVOID, ucb: UINT_PTR });
FN('IsBadHugeReadPtr', BOOL, { lp: PTR('void'), ucb: UINT_PTR });
FN('IsBadHugeWritePtr', BOOL, { lp: LPVOID, ucb: UINT_PTR });
FN('IsBadCodePtr', BOOL, { lpfn: FARPROC });
FN('IsBadStringPtrA', BOOL, { lpsz: LPCSTR, ucchMax: UINT_PTR });
FN('IsBadStringPtrW', BOOL, { lpsz: LPCWSTR, ucchMax: UINT_PTR });
FN('LookupAccountSidA', BOOL, { lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountSidW', BOOL, { lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountSidLocalA', BOOL, { Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountSidLocalW', BOOL, { Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountNameA', BOOL, { lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountNameW', BOOL, { lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountNameLocalA', BOOL, { lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupAccountNameLocalW', BOOL, { lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE });
FN('LookupPrivilegeValueA', BOOL, { lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID });
FN('LookupPrivilegeValueW', BOOL, { lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID });
FN('LookupPrivilegeNameA', BOOL, { lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD });
FN('LookupPrivilegeNameW', BOOL, { lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD });
FN('LookupPrivilegeDisplayNameA', BOOL, { lpSystemName: LPCSTR, lpName: LPCSTR, lpDisplayName: LPSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD });
FN('LookupPrivilegeDisplayNameW', BOOL, { lpSystemName: LPCWSTR, lpName: LPCWSTR, lpDisplayName: LPWSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD });
FN('AllocateLocallyUniqueId', BOOL, { Luid: PLUID });
FN('BuildCommDCBA', BOOL, { lpDef: LPCSTR, lpDCB: LPDCB });
FN('BuildCommDCBW', BOOL, { lpDef: LPCWSTR, lpDCB: LPDCB });
FN('BuildCommDCBAndTimeoutsA', BOOL, { lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS });
FN('BuildCommDCBAndTimeoutsW', BOOL, { lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS });
FN('CommConfigDialogA', BOOL, { lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG });
FN('CommConfigDialogW', BOOL, { lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG });
FN('GetDefaultCommConfigA', BOOL, { lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD });
FN('GetDefaultCommConfigW', BOOL, { lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD });
FN('SetDefaultCommConfigA', BOOL, { lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD });
FN('SetDefaultCommConfigW', BOOL, { lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD });
FN('GetComputerNameA', BOOL, { lpBuffer: LPSTR, nSize: LPDWORD });
FN('GetComputerNameW', BOOL, { lpBuffer: LPWSTR, nSize: LPDWORD });
FN('SetComputerNameA', BOOL, { lpComputerName: LPCSTR });
FN('SetComputerNameW', BOOL, { lpComputerName: LPCWSTR });
FN('GetComputerNameExA', BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD });
FN('GetComputerNameExW', BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD });
FN('SetComputerNameExA', BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCSTR });
FN('SetComputerNameExW', BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR });
FN('DnsHostnameToComputerNameA', BOOL, { Hostname: LPCSTR, ComputerName: LPSTR, nSize: LPDWORD });
FN('DnsHostnameToComputerNameW', BOOL, { Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD });
FN('GetUserNameA', BOOL, { lpBuffer: LPSTR, pcbBuffer: LPDWORD });
FN('GetUserNameW', BOOL, { lpBuffer: LPWSTR, pcbBuffer: LPDWORD });
FN('LogonUserA', BOOL, { lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE });
FN('LogonUserW', BOOL, { lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE });
FN('LogonUserExA', BOOL, { lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: PTR(PTR('void')), ppProfileBuffer: PTR(PTR('void')), pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS });
FN('LogonUserExW', BOOL, { lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: PTR(PTR('void')), ppProfileBuffer: PTR(PTR('void')), pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS });
FN('ImpersonateLoggedOnUser', BOOL, { hToken: HANDLE });
FN('CreateProcessAsUserA', BOOL, { hToken: HANDLE, lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA, lpProcessInformation: LPPROCESS_INFORMATION });
FN('CreateProcessAsUserW', BOOL, { hToken: HANDLE, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION });
FN('CreateProcessWithLogonW', BOOL, { lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION });
FN('CreateProcessWithTokenW', BOOL, { hToken: HANDLE, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION });
FN('ImpersonateAnonymousToken', BOOL, { ThreadHandle: HANDLE });
FN('DuplicateTokenEx', BOOL, { hExistingToken: HANDLE, dwDesiredAccess: DWORD, lpTokenAttributes: LPSECURITY_ATTRIBUTES, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, TokenType: TOKEN_TYPE, phNewToken: PHANDLE });
FN('CreateRestrictedToken', BOOL, { ExistingTokenHandle: HANDLE, Flags: DWORD, DisableSidCount: DWORD, SidsToDisable: PSID_AND_ATTRIBUTES, DeletePrivilegeCount: DWORD, PrivilegesToDelete: PLUID_AND_ATTRIBUTES, RestrictedSidCount: DWORD, SidsToRestrict: PSID_AND_ATTRIBUTES, NewTokenHandle: PHANDLE });
FN('IsTokenRestricted', BOOL, { TokenHandle: HANDLE });
FN('IsTokenUntrusted', BOOL, { TokenHandle: HANDLE });
FN('CheckTokenMembership', BOOL, { TokenHandle: HANDLE, SidToCheck: PSID, IsMember: PBOOL });
FN('RegisterWaitForSingleObject', BOOL, { phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG });
FN('RegisterWaitForSingleObjectEx', HANDLE, { hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG });
FN('UnregisterWait', BOOL, { WaitHandle: HANDLE });
FN('UnregisterWaitEx', BOOL, { WaitHandle: HANDLE, CompletionEvent: HANDLE });
FN('QueueUserWorkItem', BOOL, { Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG });
FN('BindIoCompletionCallback', BOOL, { FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG });
FN('CreateTimerQueue', HANDLE, {  });
FN('CreateTimerQueueTimer', BOOL, { phNewTimer: PHANDLE, TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, Flags: ULONG });
FN('ChangeTimerQueueTimer', BOOL, { TimerQueue: HANDLE, Timer: HANDLE, DueTime: ULONG, Period: ULONG });
FN('DeleteTimerQueueTimer', BOOL, { TimerQueue: HANDLE, Timer: HANDLE, CompletionEvent: HANDLE });
FN('DeleteTimerQueueEx', BOOL, { TimerQueue: HANDLE, CompletionEvent: HANDLE });
FN('SetTimerQueueTimer', HANDLE, { TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: BOOL });
FN('CancelTimerQueueTimer', BOOL, { TimerQueue: HANDLE, Timer: HANDLE });
FN('DeleteTimerQueue', BOOL, { TimerQueue: HANDLE });
FN('CreateThreadpool', PTP_POOL, { reserved: PVOID });
FN('SetThreadpoolThreadMaximum', 'void', { ptpp: PTP_POOL, cthrdMost: DWORD });
FN('SetThreadpoolThreadMinimum', BOOL, { ptpp: PTP_POOL, cthrdMic: DWORD });
FN('SetThreadpoolStackInformation', BOOL, { ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION });
FN('QueryThreadpoolStackInformation', BOOL, { ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION });
FN('CloseThreadpool', 'void', { ptpp: PTP_POOL });
FN('CreateThreadpoolCleanupGroup', PTP_CLEANUP_GROUP, {  });
FN('CloseThreadpoolCleanupGroupMembers', 'void', { ptpcg: PTP_CLEANUP_GROUP, fCancelPendingCallbacks: BOOL, pvCleanupContext: PVOID });
FN('CloseThreadpoolCleanupGroup', 'void', { ptpcg: PTP_CLEANUP_GROUP });
FN('InitializeThreadpoolEnvironment', 'void', { pcbe: PTP_CALLBACK_ENVIRON });
FN('SetThreadpoolCallbackPool', 'void', { pcbe: PTP_CALLBACK_ENVIRON, ptpp: PTP_POOL });
FN('SetThreadpoolCallbackCleanupGroup', 'void', { pcbe: PTP_CALLBACK_ENVIRON, ptpcg: PTP_CLEANUP_GROUP, pfng: PTP_CLEANUP_GROUP_CANCEL_CALLBACK });
FN('SetThreadpoolCallbackRunsLong', 'void', { pcbe: PTP_CALLBACK_ENVIRON });
FN('SetThreadpoolCallbackLibrary', 'void', { pcbe: PTP_CALLBACK_ENVIRON, mod: PVOID });
FN('SetThreadpoolCallbackPriority', 'void', { pcbe: PTP_CALLBACK_ENVIRON, Priority: TP_CALLBACK_PRIORITY });
FN('SetThreadpoolCallbackPersistent', 'void', { pcbe: PTP_CALLBACK_ENVIRON });
FN('DestroyThreadpoolEnvironment', 'void', { pcbe: PTP_CALLBACK_ENVIRON });
FN('SetEventWhenCallbackReturns', 'void', { pci: PTP_CALLBACK_INSTANCE, evt: HANDLE });
FN('ReleaseSemaphoreWhenCallbackReturns', 'void', { pci: PTP_CALLBACK_INSTANCE, sem: HANDLE, crel: DWORD });
FN('ReleaseMutexWhenCallbackReturns', 'void', { pci: PTP_CALLBACK_INSTANCE, mut: HANDLE });
FN('LeaveCriticalSectionWhenCallbackReturns', 'void', { pci: PTP_CALLBACK_INSTANCE, pcs: PCRITICAL_SECTION });
FN('FreeLibraryWhenCallbackReturns', 'void', { pci: PTP_CALLBACK_INSTANCE, mod: HMODULE });
FN('CallbackMayRunLong', BOOL, { pci: PTP_CALLBACK_INSTANCE });
FN('DisassociateCurrentThreadFromCallback', 'void', { pci: PTP_CALLBACK_INSTANCE });
FN('TrySubmitThreadpoolCallback', BOOL, { pfns: PTP_SIMPLE_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON });
FN('CreateThreadpoolWork', PTP_WORK, { pfnwk: PTP_WORK_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON });
FN('SubmitThreadpoolWork', 'void', { pwk: PTP_WORK });
FN('WaitForThreadpoolWorkCallbacks', 'void', { pwk: PTP_WORK, fCancelPendingCallbacks: BOOL });
FN('CloseThreadpoolWork', 'void', { pwk: PTP_WORK });
FN('CreateThreadpoolTimer', PTP_TIMER, { pfnti: PTP_TIMER_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON });
FN('SetThreadpoolTimer', 'void', { pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD });
FN('IsThreadpoolTimerSet', BOOL, { pti: PTP_TIMER });
FN('WaitForThreadpoolTimerCallbacks', 'void', { pti: PTP_TIMER, fCancelPendingCallbacks: BOOL });
FN('CloseThreadpoolTimer', 'void', { pti: PTP_TIMER });
FN('CreateThreadpoolWait', PTP_WAIT, { pfnwa: PTP_WAIT_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON });
FN('SetThreadpoolWait', 'void', { pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME });
FN('WaitForThreadpoolWaitCallbacks', 'void', { pwa: PTP_WAIT, fCancelPendingCallbacks: BOOL });
FN('CloseThreadpoolWait', 'void', { pwa: PTP_WAIT });
FN('CreateThreadpoolIo', PTP_IO, { fl: HANDLE, pfnio: PTP_WIN32_IO_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON });
FN('StartThreadpoolIo', 'void', { pio: PTP_IO });
FN('CancelThreadpoolIo', 'void', { pio: PTP_IO });
FN('WaitForThreadpoolIoCallbacks', 'void', { pio: PTP_IO, fCancelPendingCallbacks: BOOL });
FN('CloseThreadpoolIo', 'void', { pio: PTP_IO });
FN('CreatePrivateNamespaceA', HANDLE, { lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR });
FN('CreatePrivateNamespaceW', HANDLE, { lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR });
FN('OpenPrivateNamespaceA', HANDLE, { lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR });
FN('OpenPrivateNamespaceW', HANDLE, { lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR });
FN('ClosePrivateNamespace', BOOLEAN, { Handle: HANDLE, Flags: ULONG });
FN('CreateBoundaryDescriptorA', HANDLE, { Name: LPCSTR, Flags: ULONG });
FN('CreateBoundaryDescriptorW', HANDLE, { Name: LPCWSTR, Flags: ULONG });
FN('AddSIDToBoundaryDescriptor', BOOL, { BoundaryDescriptor: PTR(PTR('void')), RequiredSid: PSID });
FN('AddIntegrityLabelToBoundaryDescriptor', BOOL, { BoundaryDescriptor: PTR(PTR('void')), IntegrityLabel: PSID });
FN('DeleteBoundaryDescriptor', 'void', { BoundaryDescriptor: HANDLE });
FN('GetCurrentHwProfileA', BOOL, { lpHwProfileInfo: LPHW_PROFILE_INFOA });
FN('GetCurrentHwProfileW', BOOL, { lpHwProfileInfo: LPHW_PROFILE_INFOW });
FN('QueryPerformanceCounter', BOOL, { lpPerformanceCount: PTR(uint) });
FN('QueryPerformanceFrequency', BOOL, { lpFrequency: PTR(uint) });
FN('GetVersionExA', BOOL, { lpVersionInformation: LPOSVERSIONINFOA });
FN('GetVersionExW', BOOL, { lpVersionInformation: LPOSVERSIONINFOW });
FN('VerifyVersionInfoA', BOOL, { lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG });
FN('VerifyVersionInfoW', BOOL, { lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG });
FN('GetProductInfo', BOOL, { dwOSMajorVersion: DWORD, dwOSMinorVersion: DWORD, dwSpMajorVersion: DWORD, dwSpMinorVersion: DWORD, pdwReturnedProductType: PDWORD });
FN('HRESULT_FROM_WIN32', HRESULT, { x: ulong });
FN('GetSystemPowerStatus', BOOL, { lpSystemPowerStatus: LPSYSTEM_POWER_STATUS });
FN('SetSystemPowerState', BOOL, { fSuspend: BOOL, fForce: BOOL });
FN('AllocateUserPhysicalPages', BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR });
FN('AllocateUserPhysicalPagesNuma', BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD });
FN('FreeUserPhysicalPages', BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR });
FN('MapUserPhysicalPages', BOOL, { VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR });
FN('MapUserPhysicalPagesScatter', BOOL, { VirtualAddresses: PTR(PTR('void')), NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR });
FN('CreateJobObjectA', HANDLE, { lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR });
FN('CreateJobObjectW', HANDLE, { lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR });
FN('OpenJobObjectA', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR });
FN('OpenJobObjectW', HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR });
FN('AssignProcessToJobObject', BOOL, { hJob: HANDLE, hProcess: HANDLE });
FN('TerminateJobObject', BOOL, { hJob: HANDLE, uExitCode: UINT });
FN('QueryInformationJobObject', BOOL, { hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD, lpReturnLength: LPDWORD });
FN('SetInformationJobObject', BOOL, { hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD });
FN('IsProcessInJob', BOOL, { ProcessHandle: HANDLE, JobHandle: HANDLE, Result: PBOOL });
FN('CreateJobSet', BOOL, { NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG });
FN('AddVectoredExceptionHandler', PVOID, { First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER });
FN('RemoveVectoredExceptionHandler', ULONG, { Handle: PVOID });
FN('AddVectoredContinueHandler', PVOID, { First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER });
FN('RemoveVectoredContinueHandler', ULONG, { Handle: PVOID });
FN('FindFirstVolumeA', HANDLE, { lpszVolumeName: LPSTR, cchBufferLength: DWORD });
FN('FindFirstVolumeW', HANDLE, { lpszVolumeName: LPWSTR, cchBufferLength: DWORD });
FN('FindNextVolumeA', BOOL, { hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD });
FN('FindNextVolumeW', BOOL, { hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD });
FN('FindVolumeClose', BOOL, { hFindVolume: HANDLE });
FN('FindFirstVolumeMountPointA', HANDLE, { lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD });
FN('FindFirstVolumeMountPointW', HANDLE, { lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD });
FN('FindNextVolumeMountPointA', BOOL, { hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD });
FN('FindNextVolumeMountPointW', BOOL, { hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD });
FN('FindVolumeMountPointClose', BOOL, { hFindVolumeMountPoint: HANDLE });
FN('SetVolumeMountPointA', BOOL, { lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR });
FN('SetVolumeMountPointW', BOOL, { lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR });
FN('DeleteVolumeMountPointA', BOOL, { lpszVolumeMountPoint: LPCSTR });
FN('DeleteVolumeMountPointW', BOOL, { lpszVolumeMountPoint: LPCWSTR });
FN('GetVolumeNameForVolumeMountPointA', BOOL, { lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD });
FN('GetVolumeNameForVolumeMountPointW', BOOL, { lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD });
FN('GetVolumePathNameA', BOOL, { lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD });
FN('GetVolumePathNameW', BOOL, { lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD });
FN('GetVolumePathNamesForVolumeNameA', BOOL, { lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD });
FN('GetVolumePathNamesForVolumeNameW', BOOL, { lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD });
FN('CreateActCtxA', HANDLE, { pActCtx: PCACTCTXA });
FN('CreateActCtxW', HANDLE, { pActCtx: PCACTCTXW });
FN('AddRefActCtx', 'void', { hActCtx: HANDLE });
FN('ReleaseActCtx', 'void', { hActCtx: HANDLE });
FN('ZombifyActCtx', BOOL, { hActCtx: HANDLE });
FN('ActivateActCtx', BOOL, { hActCtx: HANDLE, lpCookie: PTR(ulong) });
FN('DeactivateActCtx', BOOL, { dwFlags: DWORD, ulCookie: ULONG_PTR });
FN('GetCurrentActCtx', BOOL, { lphActCtx: PTR(PTR('void')) });
FN('FindActCtxSectionStringA', BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA });
FN('FindActCtxSectionStringW', BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA });
FN('FindActCtxSectionGuid', BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpGuidToFind: PTR(uint), ReturnedData: PACTCTX_SECTION_KEYED_DATA });
FN('QueryActCtxW', BOOL, { dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: PTR(ulong) });
FN('ProcessIdToSessionId', BOOL, { dwProcessId: DWORD, pSessionId: PTR(ulong) });
FN('WTSGetActiveConsoleSessionId', DWORD, {  });
FN('IsWow64Process', BOOL, { hProcess: HANDLE, Wow64Process: PBOOL });
FN('GetLogicalProcessorInformation', BOOL, { Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, ReturnedLength: PDWORD });
FN('GetLogicalProcessorInformationEx', BOOL, { RelationshipType: LOGICAL_PROCESSOR_RELATIONSHIP, Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, ReturnedLength: PDWORD });
FN('GetActiveProcessorGroupCount', WORD, {  });
FN('GetMaximumProcessorGroupCount', WORD, {  });
FN('GetActiveProcessorCount', DWORD, { GroupNumber: WORD });
FN('GetMaximumProcessorCount', DWORD, { GroupNumber: WORD });
FN('GetNumaHighestNodeNumber', BOOL, { HighestNodeNumber: PULONG });
FN('GetNumaProcessorNode', BOOL, { Processor: UCHAR, NodeNumber: PUCHAR });
FN('GetNumaNodeNumberFromHandle', BOOL, { hFile: HANDLE, NodeNumber: PUSHORT });
FN('GetNumaProcessorNodeEx', BOOL, { Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT });
FN('GetNumaNodeProcessorMask', BOOL, { Node: UCHAR, ProcessorMask: PULONGLONG });
FN('GetNumaNodeProcessorMaskEx', BOOL, { Node: USHORT, ProcessorMask: PGROUP_AFFINITY });
FN('GetNumaAvailableMemoryNode', BOOL, { Node: UCHAR, AvailableBytes: PULONGLONG });
FN('GetNumaAvailableMemoryNodeEx', BOOL, { Node: USHORT, AvailableBytes: PULONGLONG });
FN('GetNumaProximityNode', BOOL, { ProximityId: ULONG, NodeNumber: PUCHAR });
FN('GetNumaProximityNodeEx', BOOL, { ProximityId: ULONG, NodeNumber: PUSHORT });
FN('RegisterApplicationRecoveryCallback', HRESULT, { pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD });
FN('UnregisterApplicationRecoveryCallback', HRESULT, {  });
FN('RegisterApplicationRestart', HRESULT, { pwzCommandline: PCWSTR, dwFlags: DWORD });
FN('UnregisterApplicationRestart', HRESULT, {  });
FN('GetApplicationRecoveryCallback', HRESULT, { hProcess: HANDLE, pRecoveryCallback: PTR(APPLICATION_RECOVERY_CALLBACK), ppvParameter: PTR(PTR('void')), pdwPingInterval: PDWORD, pdwFlags: PDWORD });
FN('GetApplicationRestartSettings', HRESULT, { hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD });
FN('ApplicationRecoveryInProgress', HRESULT, { pbCancelled: PBOOL });
FN('ApplicationRecoveryFinished', 'void', { bSuccess: BOOL });
FN('SetFileInformationByHandle', BOOL, { hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD });
FN('GetFileInformationByHandleEx', BOOL, { hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD });
FN('OpenFileById', HANDLE, { hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD });
FN('CreateSymbolicLinkA', BOOLEAN, { lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD });
FN('CreateSymbolicLinkW', BOOLEAN, { lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD });
FN('CreateSymbolicLinkTransactedA', BOOLEAN, { lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE });
FN('CreateSymbolicLinkTransactedW', BOOLEAN, { lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE });
FN('GetFinalPathNameByHandleA', DWORD, { hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD });
FN('GetFinalPathNameByHandleW', DWORD, { hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD });
FN('QueryActCtxSettingsW', BOOL, { dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: PTR(ulong) });
FN('ReplacePartitionUnit', BOOL, { TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG });
FN('AddSecureMemoryCacheCallback', BOOL, { pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK });
FN('RemoveSecureMemoryCacheCallback', BOOL, { pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK });
FN('CopyExtendedContext', BOOL, { Destination: PCONTEXT_EX, ContextFlags: DWORD, Source: PCONTEXT_EX });
FN('InitializeExtendedContext', BOOL, { Context: PVOID, ContextFlags: DWORD, ContextEx: PTR(pointer) });
FN('GetEnabledExtendedFeatures', DWORD64, { FeatureMask: DWORD64 });
FN('GetExtendedContextLength', BOOL, { ContextFlags: DWORD, ContextLength: PDWORD });
FN('GetExtendedFeaturesMask', DWORD64, { ContextEx: PCONTEXT_EX });
FN('LocateExtendedFeature', PVOID, { ContextEx: PCONTEXT_EX, FeatureId: DWORD, Length: PDWORD });
FN('LocateLegacyContext', PCONTEXT, { ContextEx: PCONTEXT_EX, Length: PDWORD });
FN('SetExtendedFeaturesMask', 'void', { ContextEx: PCONTEXT_EX, FeatureMask: DWORD64 });
FN('EnableThreadProfiling', DWORD, { ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: PTR(PTR('void')) });
FN('DisableThreadProfiling', DWORD, { PerformanceDataHandle: HANDLE });
FN('QueryThreadProfiling', DWORD, { ThreadHandle: HANDLE, Enabled: PBOOLEAN });
FN('ReadThreadProfilingData', DWORD, { PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA });
FN('AddFontResourceA', 'void', { LPCSTR: LPCSTR });
FN('AddFontResourceW', 'void', { LPCWSTR: LPCWSTR });
FN('AnimatePalette', BOOL, { hPal: HPALETTE, iStartIndex: UINT, cEntries: UINT, ppe: PTR(uint) });
FN('Arc', BOOL, { hdc: HDC, x1: int, y1: int, x2: int, y2: int, x3: int, y3: int, x4: int, y4: int });
FN('BitBlt', BOOL, { hdc: HDC, x: int, y: int, cx: int, cy: int, hdcSrc: HDC, x1: int, y1: int, rop: DWORD });
FN('CancelDC', BOOL, { hdc: HDC });
FN('Chord', BOOL, { hdc: HDC, x1: int, y1: int, x2: int, y2: int, x3: int, y3: int, x4: int, y4: int });
FN('ChoosePixelFormat', 'void', { hdc: HDC, ppfd: PTR(uint) });
FN('CloseMetaFile', HMETAFILE, { hdc: HDC });
FN('CombineRgn', 'void', { hrgnDst: HRGN, hrgnSrc1: HRGN, hrgnSrc2: HRGN, iMode: int });
FN('CopyMetaFileA', HMETAFILE, { LPCSTR: LPCSTR });
FN('CopyMetaFileW', HMETAFILE, { LPCWSTR: LPCWSTR });
FN('CreateBitmap', HBITMAP, { nWidth: int, nHeight: int, nPlanes: UINT, nBitCount: UINT, lpBits: PTR('void') });
FN('CreateBitmapIndirect', HBITMAP, { pbm: PTR(uint) });
FN('CreateBrushIndirect', HBRUSH, { plbrush: PTR(uint) });
FN('CreateCompatibleBitmap', HBITMAP, { hdc: HDC, cx: int, cy: int });
FN('CreateDiscardableBitmap', HBITMAP, { hdc: HDC, cx: int, cy: int });
FN('CreateCompatibleDC', HDC, { hdc: HDC });
FN('CreateDCA', HDC, { pwszDriver: LPCSTR, pwszDevice: LPCSTR, pszPort: LPCSTR, pdm: PTR(uint) });
FN('CreateDCW', HDC, { pwszDriver: LPCWSTR, pwszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: PTR(uint) });
FN('CreateDIBitmap', HBITMAP, { hdc: HDC, pbmih: PTR(uint), flInit: DWORD, pjBits: PTR('void'), pbmi: PTR(uint), iUsage: UINT });
FN('CreateDIBPatternBrush', HBRUSH, { h: HGLOBAL, iUsage: UINT });
FN('CreateDIBPatternBrushPt', HBRUSH, { lpPackedDIB: PTR('void'), iUsage: UINT });
FN('CreateEllipticRgn', HRGN, { x1: int, y1: int, x2: int, y2: int });
FN('CreateEllipticRgnIndirect', HRGN, { lprect: PTR(uint) });
FN('CreateFontIndirectA', HFONT, { lplf: PTR(uint) });
FN('CreateFontIndirectW', HFONT, { lplf: PTR(uint) });
FN('CreateFontA', HFONT, { cHeight: int, cWidth: int, cEscapement: int, cOrientation: int, cWeight: int, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCSTR });
FN('CreateFontW', HFONT, { cHeight: int, cWidth: int, cEscapement: int, cOrientation: int, cWeight: int, bItalic: DWORD, bUnderline: DWORD, bStrikeOut: DWORD, iCharSet: DWORD, iOutPrecision: DWORD, iClipPrecision: DWORD, iQuality: DWORD, iPitchAndFamily: DWORD, pszFaceName: LPCWSTR });
FN('CreateHatchBrush', HBRUSH, { iHatch: int, color: COLORREF });
FN('CreateICA', HDC, { pszDriver: LPCSTR, pszDevice: LPCSTR, pszPort: LPCSTR, pdm: PTR(uint) });
FN('CreateICW', HDC, { pszDriver: LPCWSTR, pszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: PTR(uint) });
FN('CreateMetaFileA', HDC, { pszFile: LPCSTR });
FN('CreateMetaFileW', HDC, { pszFile: LPCWSTR });
FN('CreatePalette', HPALETTE, { plpal: PTR(uint) });
FN('CreatePen', HPEN, { iStyle: int, cWidth: int, color: COLORREF });
FN('CreatePenIndirect', HPEN, { plpen: PTR(uint) });
FN('CreatePolyPolygonRgn', HRGN, { pptl: PTR(uint), pc: PTR(int), cPoly: int, iMode: int });
FN('CreatePatternBrush', HBRUSH, { hbm: HBITMAP });
FN('CreateRectRgn', HRGN, { x1: int, y1: int, x2: int, y2: int });
FN('CreateRectRgnIndirect', HRGN, { lprect: PTR(uint) });
FN('CreateRoundRectRgn', HRGN, { x1: int, y1: int, x2: int, y2: int, w: int, h: int });
FN('CreateScalableFontResourceA', BOOL, { fdwHidden: DWORD, lpszFont: LPCSTR, lpszFile: LPCSTR, lpszPath: LPCSTR });
FN('CreateScalableFontResourceW', BOOL, { fdwHidden: DWORD, lpszFont: LPCWSTR, lpszFile: LPCWSTR, lpszPath: LPCWSTR });
FN('CreateSolidBrush', HBRUSH, { color: COLORREF });
FN('DeleteDC', BOOL, { hdc: HDC });
FN('DeleteMetaFile', BOOL, { hmf: HMETAFILE });
FN('DeleteObject', BOOL, { ho: HGDIOBJ });
FN('DescribePixelFormat', 'void', { hdc: HDC, iPixelFormat: int, nBytes: UINT, ppfd: LPPIXELFORMATDESCRIPTOR });
FN('DeviceCapabilitiesA', 'void', { pDevice: LPCSTR, pPort: LPCSTR, fwCapability: WORD, pOutput: LPSTR, pDevMode: PTR(uint) });
FN('DeviceCapabilitiesW', 'void', { pDevice: LPCWSTR, pPort: LPCWSTR, fwCapability: WORD, pOutput: LPWSTR, pDevMode: PTR(uint) });
FN('DrawEscape', 'void', { hdc: HDC, iEscape: int, cjIn: int, lpIn: LPCSTR });
FN('Ellipse', BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int });
FN('EnumFontFamiliesExA', 'void', { hdc: HDC, lpLogfont: LPLOGFONTA, lpProc: FONTENUMPROCA, lParam: LPARAM, dwFlags: DWORD });
FN('EnumFontFamiliesExW', 'void', { hdc: HDC, lpLogfont: LPLOGFONTW, lpProc: FONTENUMPROCW, lParam: LPARAM, dwFlags: DWORD });
FN('EnumFontFamiliesA', 'void', { hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM });
FN('EnumFontFamiliesW', 'void', { hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM });
FN('EnumFontsA', 'void', { hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM });
FN('EnumFontsW', 'void', { hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM });
FN('EnumObjects', 'void', { hdc: HDC, nType: int, lpFunc: GOBJENUMPROC, lParam: LPARAM });
FN('EqualRgn', BOOL, { hrgn1: HRGN, hrgn2: HRGN });
FN('Escape', 'void', { hdc: HDC, iEscape: int, cjIn: int, pvIn: LPCSTR, pvOut: LPVOID });
FN('ExtEscape', 'void', { hdc: HDC, iEscape: int, cjInput: int, lpInData: LPCSTR, cjOutput: int, lpOutData: LPSTR });
FN('ExcludeClipRect', 'void', { hdc: HDC, left: int, top: int, right: int, bottom: int });
FN('ExtCreateRegion', HRGN, { lpx: PTR(uint), nCount: DWORD, lpData: PTR(uint) });
FN('ExtFloodFill', BOOL, { hdc: HDC, x: int, y: int, color: COLORREF, type: UINT });
FN('FillRgn', BOOL, { hdc: HDC, hrgn: HRGN, hbr: HBRUSH });
FN('FloodFill', BOOL, { hdc: HDC, x: int, y: int, color: COLORREF });
FN('FrameRgn', BOOL, { hdc: HDC, hrgn: HRGN, hbr: HBRUSH, w: int, h: int });
FN('GetROP2', 'void', { hdc: HDC });
FN('GetAspectRatioFilterEx', BOOL, { hdc: HDC, lpsize: LPSIZE });
FN('GetBkColor', COLORREF, { hdc: HDC });
FN('GetDCBrushColor', COLORREF, { hdc: HDC });
FN('GetDCPenColor', COLORREF, { hdc: HDC });
FN('GetBkMode', 'void', { hdc: HDC });
FN('GetBitmapBits', LONG, { hbit: HBITMAP, cb: LONG, lpvBits: LPVOID });
FN('GetBitmapDimensionEx', BOOL, { hbit: HBITMAP, lpsize: LPSIZE });
FN('GetBoundsRect', UINT, { hdc: HDC, lprect: LPRECT, flags: UINT });
FN('GetBrushOrgEx', BOOL, { hdc: HDC, lppt: LPPOINT });
FN('GetCharWidthA', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT });
FN('GetCharWidthW', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT });
FN('GetCharWidth32A', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT });
FN('GetCharWidth32W', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT });
FN('GetCharWidthFloatA', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT });
FN('GetCharWidthFloatW', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT });
FN('GetCharABCWidthsA', BOOL, { hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC });
FN('GetCharABCWidthsW', BOOL, { hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC });
FN('GetCharABCWidthsFloatA', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT });
FN('GetCharABCWidthsFloatW', BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT });
FN('GetClipBox', 'void', { hdc: HDC, lprect: LPRECT });
FN('GetClipRgn', 'void', { hdc: HDC, hrgn: HRGN });
FN('GetMetaRgn', 'void', { hdc: HDC, hrgn: HRGN });
FN('GetCurrentObject', HGDIOBJ, { hdc: HDC, type: UINT });
FN('GetCurrentPositionEx', BOOL, { hdc: HDC, lppt: LPPOINT });
FN('GetDeviceCaps', 'void', { hdc: HDC, index: int });
FN('GetDIBits', 'void', { hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpvBits: LPVOID, lpbmi: LPBITMAPINFO, usage: UINT });
FN('GetFontData', DWORD, { hdc: HDC, dwTable: DWORD, dwOffset: DWORD, pvBuffer: PVOID, cjBuffer: DWORD });
FN('GetGlyphOutlineA', DWORD, { hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: PTR(uint) });
FN('GetGlyphOutlineW', DWORD, { hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: PTR(uint) });
FN('GetGraphicsMode', 'void', { hdc: HDC });
FN('GetMapMode', 'void', { hdc: HDC });
FN('GetMetaFileBitsEx', UINT, { hMF: HMETAFILE, cbBuffer: UINT, lpData: LPVOID });
FN('GetMetaFileA', HMETAFILE, { lpName: LPCSTR });
FN('GetMetaFileW', HMETAFILE, { lpName: LPCWSTR });
FN('GetNearestColor', COLORREF, { hdc: HDC, color: COLORREF });
FN('GetNearestPaletteIndex', UINT, { h: HPALETTE, color: COLORREF });
FN('GetObjectType', DWORD, { h: HGDIOBJ });
FN('GetOutlineTextMetricsA', UINT, { hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICA });
FN('GetOutlineTextMetricsW', UINT, { hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICW });
FN('GetPaletteEntries', UINT, { hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY });
FN('GetPixel', COLORREF, { hdc: HDC, x: int, y: int });
FN('GetPixelFormat', 'void', { hdc: HDC });
FN('GetPolyFillMode', 'void', { hdc: HDC });
FN('GetRasterizerCaps', BOOL, { lpraststat: LPRASTERIZER_STATUS, cjBytes: UINT });
FN('GetRandomRgn', 'void', { hdc: HDC, hrgn: HRGN, i: INT });
FN('GetRegionData', DWORD, { hrgn: HRGN, nCount: DWORD, lpRgnData: LPRGNDATA });
FN('GetRgnBox', 'void', { hrgn: HRGN, lprc: LPRECT });
FN('GetStockObject', HGDIOBJ, { i: int });
FN('GetStretchBltMode', 'void', { hdc: HDC });
FN('GetSystemPaletteEntries', UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY });
FN('GetSystemPaletteUse', UINT, { hdc: HDC });
FN('GetTextCharacterExtra', 'void', { hdc: HDC });
FN('GetTextAlign', UINT, { hdc: HDC });
FN('GetTextColor', COLORREF, { hdc: HDC });
FN('GetTextExtentPointA', BOOL, { hdc: HDC, lpString: LPCSTR, c: int, lpsz: LPSIZE });
FN('GetTextExtentPointW', BOOL, { hdc: HDC, lpString: LPCWSTR, c: int, lpsz: LPSIZE });
FN('GetTextExtentPoint32A', BOOL, { hdc: HDC, lpString: LPCSTR, c: int, psizl: LPSIZE });
FN('GetTextExtentPoint32W', BOOL, { hdc: HDC, lpString: LPCWSTR, c: int, psizl: LPSIZE });
FN('GetTextExtentExPointA', BOOL, { hdc: HDC, lpszString: LPCSTR, cchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE });
FN('GetTextExtentExPointW', BOOL, { hdc: HDC, lpszString: LPCWSTR, cchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE });
FN('GetTextCharset', 'void', { hdc: HDC });
FN('GetTextCharsetInfo', 'void', { hdc: HDC, lpSig: LPFONTSIGNATURE, dwFlags: DWORD });
FN('TranslateCharsetInfo', BOOL, { lpSrc: PTR(ulong), lpCs: LPCHARSETINFO, dwFlags: DWORD });
FN('GetFontLanguageInfo', DWORD, { hdc: HDC });
FN('GetCharacterPlacementA', DWORD, { hdc: HDC, lpString: LPCSTR, nCount: int, nMexExtent: int, lpResults: LPGCP_RESULTSA, dwFlags: DWORD });
FN('GetCharacterPlacementW', DWORD, { hdc: HDC, lpString: LPCWSTR, nCount: int, nMexExtent: int, lpResults: LPGCP_RESULTSW, dwFlags: DWORD });
FN('GetFontUnicodeRanges', DWORD, { hdc: HDC, lpgs: LPGLYPHSET });
FN('GetGlyphIndicesA', DWORD, { hdc: HDC, lpstr: LPCSTR, c: int, pgi: LPWORD, fl: DWORD });
FN('GetGlyphIndicesW', DWORD, { hdc: HDC, lpstr: LPCWSTR, c: int, pgi: LPWORD, fl: DWORD });
FN('GetTextExtentPointI', BOOL, { hdc: HDC, pgiIn: LPWORD, cgi: int, psize: LPSIZE });
FN('GetTextExtentExPointI', BOOL, { hdc: HDC, lpwszString: LPWORD, cwchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE });
FN('GetCharWidthI', BOOL, { hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, piWidths: LPINT });
FN('GetCharABCWidthsI', BOOL, { hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, pabc: LPABC });
FN('AddFontResourceExA', 'void', { name: LPCSTR, fl: DWORD, res: PVOID });
FN('AddFontResourceExW', 'void', { name: LPCWSTR, fl: DWORD, res: PVOID });
FN('RemoveFontResourceExA', BOOL, { name: LPCSTR, fl: DWORD, pdv: PVOID });
FN('RemoveFontResourceExW', BOOL, { name: LPCWSTR, fl: DWORD, pdv: PVOID });
FN('AddFontMemResourceEx', HANDLE, { pFileView: PVOID, cjSize: DWORD, pvResrved: PVOID, pNumFonts: PTR(ulong) });
FN('RemoveFontMemResourceEx', BOOL, { h: HANDLE });
FN('CreateFontIndirectExA', HFONT, { PTR(uint): PTR(uint) });
FN('CreateFontIndirectExW', HFONT, { PTR(uint): PTR(uint) });
FN('GetViewportExtEx', BOOL, { hdc: HDC, lpsize: LPSIZE });
FN('GetViewportOrgEx', BOOL, { hdc: HDC, lppoint: LPPOINT });
FN('GetWindowExtEx', BOOL, { hdc: HDC, lpsize: LPSIZE });
FN('GetWindowOrgEx', BOOL, { hdc: HDC, lppoint: LPPOINT });
FN('IntersectClipRect', 'void', { hdc: HDC, left: int, top: int, right: int, bottom: int });
FN('InvertRgn', BOOL, { hdc: HDC, hrgn: HRGN });
FN('LineDDA', BOOL, { xStart: int, yStart: int, xEnd: int, yEnd: int, lpProc: LINEDDAPROC, data: LPARAM });
FN('LineTo', BOOL, { hdc: HDC, x: int, y: int });
FN('MaskBlt', BOOL, { hdcDest: HDC, xDest: int, yDest: int, width: int, height: int, hdcSrc: HDC, xSrc: int, ySrc: int, hbmMask: HBITMAP, xMask: int, yMask: int, rop: DWORD });
FN('PlgBlt', BOOL, { hdcDest: HDC, lpPoint: PTR(uint), hdcSrc: HDC, xSrc: int, ySrc: int, width: int, height: int, hbmMask: HBITMAP, xMask: int, yMask: int });
FN('OffsetClipRgn', 'void', { hdc: HDC, x: int, y: int });
FN('OffsetRgn', 'void', { hrgn: HRGN, x: int, y: int });
FN('PatBlt', BOOL, { hdc: HDC, x: int, y: int, w: int, h: int, rop: DWORD });
FN('Pie', BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, xr1: int, yr1: int, xr2: int, yr2: int });
FN('PlayMetaFile', BOOL, { hdc: HDC, hmf: HMETAFILE });
FN('PaintRgn', BOOL, { hdc: HDC, hrgn: HRGN });
FN('PolyPolygon', BOOL, { hdc: HDC, apt: PTR(uint), asz: PTR(int), csz: int });
FN('PtInRegion', BOOL, { hrgn: HRGN, x: int, y: int });
FN('PtVisible', BOOL, { hdc: HDC, x: int, y: int });
FN('RectInRegion', BOOL, { hrgn: HRGN, lprect: PTR(uint) });
FN('RectVisible', BOOL, { hdc: HDC, lprect: PTR(uint) });
FN('Rectangle', BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int });
FN('RestoreDC', BOOL, { hdc: HDC, nSavedDC: int });
FN('ResetDCA', HDC, { hdc: HDC, lpdm: PTR(uint) });
FN('ResetDCW', HDC, { hdc: HDC, lpdm: PTR(uint) });
FN('RealizePalette', UINT, { hdc: HDC });
FN('RemoveFontResourceA', BOOL, { lpFileName: LPCSTR });
FN('RemoveFontResourceW', BOOL, { lpFileName: LPCWSTR });
FN('RoundRect', BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, width: int, height: int });
FN('ResizePalette', BOOL, { hpal: HPALETTE, n: UINT });
FN('SaveDC', 'void', { hdc: HDC });
FN('SelectClipRgn', 'void', { hdc: HDC, hrgn: HRGN });
FN('ExtSelectClipRgn', 'void', { hdc: HDC, hrgn: HRGN, mode: int });
FN('SetMetaRgn', 'void', { hdc: HDC });
FN('SelectObject', HGDIOBJ, { hdc: HDC, h: HGDIOBJ });
FN('SelectPalette', HPALETTE, { hdc: HDC, hPal: HPALETTE, bForceBkgd: BOOL });
FN('SetBkColor', COLORREF, { hdc: HDC, color: COLORREF });
FN('SetDCBrushColor', COLORREF, { hdc: HDC, color: COLORREF });
FN('SetDCPenColor', COLORREF, { hdc: HDC, color: COLORREF });
FN('SetBkMode', 'void', { hdc: HDC, mode: int });
FN('SetBitmapBits', LONG, { hbm: HBITMAP, cb: DWORD, pvBits: PTR('void') });
FN('SetBoundsRect', UINT, { hdc: HDC, lprect: PTR(uint), flags: UINT });
FN('SetDIBits', 'void', { hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpBits: PTR('void'), lpbmi: PTR(uint), ColorUse: UINT });
FN('SetDIBitsToDevice', 'void', { hdc: HDC, xDest: int, yDest: int, w: DWORD, h: DWORD, xSrc: int, ySrc: int, StartScan: UINT, cLines: UINT, lpvBits: PTR('void'), lpbmi: PTR(uint), ColorUse: UINT });
FN('SetMapperFlags', DWORD, { hdc: HDC, flags: DWORD });
FN('SetGraphicsMode', 'void', { hdc: HDC, iMode: int });
FN('SetMapMode', 'void', { hdc: HDC, iMode: int });
FN('SetLayout', DWORD, { hdc: HDC, l: DWORD });
FN('GetLayout', DWORD, { hdc: HDC });
FN('SetMetaFileBitsEx', HMETAFILE, { cbBuffer: UINT, lpData: PTR(uchar) });
FN('SetPaletteEntries', UINT, { hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: PTR(uint) });
FN('SetPixel', COLORREF, { hdc: HDC, x: int, y: int, color: COLORREF });
FN('SetPixelV', BOOL, { hdc: HDC, x: int, y: int, color: COLORREF });
FN('SetPixelFormat', BOOL, { hdc: HDC, format: int, ppfd: PTR(uint) });
FN('SetPolyFillMode', 'void', { hdc: HDC, mode: int });
FN('StretchBlt', BOOL, { hdcDest: HDC, xDest: int, yDest: int, wDest: int, hDest: int, hdcSrc: HDC, xSrc: int, ySrc: int, wSrc: int, hSrc: int, rop: DWORD });
FN('SetRectRgn', BOOL, { hrgn: HRGN, left: int, top: int, right: int, bottom: int });
FN('StretchDIBits', 'void', { hdc: HDC, xDest: int, yDest: int, DestWidth: int, DestHeight: int, xSrc: int, ySrc: int, SrcWidth: int, SrcHeight: int, lpBits: PTR('void'), lpbmi: PTR(uint), iUsage: UINT, rop: DWORD });
FN('SetROP2', 'void', { hdc: HDC, rop2: int });
FN('SetStretchBltMode', 'void', { hdc: HDC, mode: int });
FN('SetSystemPaletteUse', UINT, { hdc: HDC, use: UINT });
FN('SetTextCharacterExtra', 'void', { hdc: HDC, extra: int });
FN('SetTextColor', COLORREF, { hdc: HDC, color: COLORREF });
FN('SetTextAlign', UINT, { hdc: HDC, align: UINT });
FN('SetTextJustification', BOOL, { hdc: HDC, extra: int, count: int });
FN('UpdateColors', BOOL, { hdc: HDC });
FN('AlphaBlend', BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, ftn: BLENDFUNCTION });
FN('TransparentBlt', BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, crTransparent: UINT });
FN('GradientFill', BOOL, { hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nMesh: ULONG, ulMode: ULONG });
FN('GdiAlphaBlend', BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, ftn: BLENDFUNCTION });
FN('GdiTransparentBlt', BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, crTransparent: UINT });
FN('GdiGradientFill', BOOL, { hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nCount: ULONG, ulMode: ULONG });
FN('PlayMetaFileRecord', BOOL, { hdc: HDC, lpHandleTable: LPHANDLETABLE, lpMR: LPMETARECORD, noObjs: UINT });
FN('EnumMetaFile', BOOL, { hdc: HDC, hmf: HMETAFILE, proc: MFENUMPROC, param: LPARAM });
FN('CloseEnhMetaFile', HENHMETAFILE, { hdc: HDC });
FN('CopyEnhMetaFileA', HENHMETAFILE, { hEnh: HENHMETAFILE, lpFileName: LPCSTR });
FN('CopyEnhMetaFileW', HENHMETAFILE, { hEnh: HENHMETAFILE, lpFileName: LPCWSTR });
FN('CreateEnhMetaFileA', HDC, { hdc: HDC, lpFilename: LPCSTR, lprc: PTR(uint), lpDesc: LPCSTR });
FN('CreateEnhMetaFileW', HDC, { hdc: HDC, lpFilename: LPCWSTR, lprc: PTR(uint), lpDesc: LPCWSTR });
FN('DeleteEnhMetaFile', BOOL, { hmf: HENHMETAFILE });
FN('EnumEnhMetaFile', BOOL, { hdc: HDC, hmf: HENHMETAFILE, proc: ENHMFENUMPROC, param: LPVOID, lpRect: PTR(uint) });
FN('GetEnhMetaFileA', HENHMETAFILE, { lpName: LPCSTR });
FN('GetEnhMetaFileW', HENHMETAFILE, { lpName: LPCWSTR });
FN('GetEnhMetaFileBits', UINT, { hEMF: HENHMETAFILE, nSize: UINT, lpData: LPBYTE });
FN('GetEnhMetaFileDescriptionA', UINT, { hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPSTR });
FN('GetEnhMetaFileDescriptionW', UINT, { hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPWSTR });
FN('GetEnhMetaFileHeader', UINT, { hemf: HENHMETAFILE, nSize: UINT, lpEnhMetaHeader: LPENHMETAHEADER });
FN('GetEnhMetaFilePaletteEntries', UINT, { hemf: HENHMETAFILE, nNumEntries: UINT, lpPaletteEntries: LPPALETTEENTRY });
FN('GetEnhMetaFilePixelFormat', UINT, { hemf: HENHMETAFILE, cbBuffer: UINT, ppfd: PTR(uint) });
FN('GetWinMetaFileBits', UINT, { hemf: HENHMETAFILE, cbData16: UINT, pData16: LPBYTE, iMapMode: INT, hdcRef: HDC });
FN('PlayEnhMetaFile', BOOL, { hdc: HDC, hmf: HENHMETAFILE, lprect: PTR(uint) });
FN('PlayEnhMetaFileRecord', BOOL, { hdc: HDC, pht: LPHANDLETABLE, pmr: PTR(uint), cht: UINT });
FN('SetEnhMetaFileBits', HENHMETAFILE, { nSize: UINT, pb: PTR(uchar) });
FN('SetWinMetaFileBits', HENHMETAFILE, { nSize: UINT, lpMeta16Data: PTR(uchar), hdcRef: HDC, lpMFP: PTR(uint) });
FN('GdiComment', BOOL, { hdc: HDC, nSize: UINT, lpData: PTR(uchar) });
FN('GetTextMetricsA', BOOL, { hdc: HDC, lptm: LPTEXTMETRICA });
FN('GetTextMetricsW', BOOL, { hdc: HDC, lptm: LPTEXTMETRICW });
FN('AngleArc', BOOL, { hdc: HDC, x: int, y: int, r: DWORD, StartAngle: FLOAT, SweepAngle: FLOAT });
FN('PolyPolyline', BOOL, { hdc: HDC, apt: PTR(uint), asz: PTR(ulong), csz: DWORD });
FN('GetWorldTransform', BOOL, { hdc: HDC, lpxf: LPXFORM });
FN('SetWorldTransform', BOOL, { hdc: HDC, lpxf: PTR(uint) });
FN('ModifyWorldTransform', BOOL, { hdc: HDC, lpxf: PTR(uint), mode: DWORD });
FN('CombineTransform', BOOL, { lpxfOut: LPXFORM, lpxf1: PTR(uint), lpxf2: PTR(uint) });
FN('CreateDIBSection', HBITMAP, { hdc: HDC, lpbmi: PTR(uint), usage: UINT, ppvBits: PTR(PTR('void')), hSection: HANDLE, offset: DWORD });
FN('GetDIBColorTable', UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: PTR(uint) });
FN('SetDIBColorTable', UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: PTR(uint) });
FN('SetColorAdjustment', BOOL, { hdc: HDC, lpca: PTR(uint) });
FN('GetColorAdjustment', BOOL, { hdc: HDC, lpca: LPCOLORADJUSTMENT });
FN('CreateHalftonePalette', HPALETTE, { hdc: HDC });
FN('StartDocA', 'void', { hdc: HDC, lpdi: PTR(uint) });
FN('StartDocW', 'void', { hdc: HDC, lpdi: PTR(uint) });
FN('EndDoc', 'void', { hdc: HDC });
FN('StartPage', 'void', { hdc: HDC });
FN('EndPage', 'void', { hdc: HDC });
FN('AbortDoc', 'void', { hdc: HDC });
FN('SetAbortProc', 'void', { hdc: HDC, proc: ABORTPROC });
FN('AbortPath', BOOL, { hdc: HDC });
FN('ArcTo', BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, xr1: int, yr1: int, xr2: int, yr2: int });
FN('BeginPath', BOOL, { hdc: HDC });
FN('CloseFigure', BOOL, { hdc: HDC });
FN('EndPath', BOOL, { hdc: HDC });
FN('FillPath', BOOL, { hdc: HDC });
FN('FlattenPath', BOOL, { hdc: HDC });
FN('GetPath', 'void', { hdc: HDC, apt: LPPOINT, aj: LPBYTE, cpt: int });
FN('PathToRegion', HRGN, { hdc: HDC });
FN('PolyDraw', BOOL, { hdc: HDC, apt: PTR(uint), aj: PTR(uchar), cpt: int });
FN('SelectClipPath', BOOL, { hdc: HDC, mode: int });
FN('SetArcDirection', 'void', { hdc: HDC, dir: int });
FN('SetMiterLimit', BOOL, { hdc: HDC, limit: FLOAT, old: PFLOAT });
FN('StrokeAndFillPath', BOOL, { hdc: HDC });
FN('StrokePath', BOOL, { hdc: HDC });
FN('WidenPath', BOOL, { hdc: HDC });
FN('ExtCreatePen', HPEN, { iPenStyle: DWORD, cWidth: DWORD, plbrush: PTR(uint), cStyle: DWORD, pstyle: PTR(ulong) });
FN('GetMiterLimit', BOOL, { hdc: HDC, plimit: PFLOAT });
FN('GetArcDirection', 'void', { hdc: HDC });
FN('GetObjectA', 'void', { h: HANDLE, c: int, pv: LPVOID });
FN('GetObjectW', 'void', { h: HANDLE, c: int, pv: LPVOID });
FN('MoveToEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('TextOutA', BOOL, { hdc: HDC, x: int, y: int, lpString: LPCSTR, c: int });
FN('TextOutW', BOOL, { hdc: HDC, x: int, y: int, lpString: LPCWSTR, c: int });
FN('ExtTextOutA', BOOL, { hdc: HDC, x: int, y: int, options: UINT, lprect: PTR(uint), lpString: LPCSTR, c: UINT, lpDx: PTR(int) });
FN('ExtTextOutW', BOOL, { hdc: HDC, x: int, y: int, options: UINT, lprect: PTR(uint), lpString: LPCWSTR, c: UINT, lpDx: PTR(int) });
FN('PolyTextOutA', BOOL, { hdc: HDC, ppt: PTR(uint), nstrings: int });
FN('PolyTextOutW', BOOL, { hdc: HDC, ppt: PTR(uint), nstrings: int });
FN('CreatePolygonRgn', HRGN, { pptl: PTR(uint), cPoint: int, iMode: int });
FN('DPtoLP', BOOL, { hdc: HDC, lppt: LPPOINT, c: int });
FN('LPtoDP', BOOL, { hdc: HDC, lppt: LPPOINT, c: int });
FN('Polygon', BOOL, { hdc: HDC, apt: PTR(uint), cpt: int });
FN('Polyline', BOOL, { hdc: HDC, apt: PTR(uint), cpt: int });
FN('PolyBezier', BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD });
FN('PolyBezierTo', BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD });
FN('PolylineTo', BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD });
FN('SetViewportExtEx', BOOL, { hdc: HDC, x: int, y: int, lpsz: LPSIZE });
FN('SetViewportOrgEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('SetWindowExtEx', BOOL, { hdc: HDC, x: int, y: int, lpsz: LPSIZE });
FN('SetWindowOrgEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('OffsetViewportOrgEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('OffsetWindowOrgEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('ScaleViewportExtEx', BOOL, { hdc: HDC, xn: int, dx: int, yn: int, yd: int, lpsz: LPSIZE });
FN('ScaleWindowExtEx', BOOL, { hdc: HDC, xn: int, xd: int, yn: int, yd: int, lpsz: LPSIZE });
FN('SetBitmapDimensionEx', BOOL, { hbm: HBITMAP, w: int, h: int, lpsz: LPSIZE });
FN('SetBrushOrgEx', BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT });
FN('GetTextFaceA', 'void', { hdc: HDC, c: int, lpName: LPSTR });
FN('GetTextFaceW', 'void', { hdc: HDC, c: int, lpName: LPWSTR });
FN('GetKerningPairsA', DWORD, { hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR });
FN('GetKerningPairsW', DWORD, { hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR });
FN('GetDCOrgEx', BOOL, { hdc: HDC, lppt: LPPOINT });
FN('FixBrushOrgEx', BOOL, { hdc: HDC, x: int, y: int, ptl: LPPOINT });
FN('UnrealizeObject', BOOL, { h: HGDIOBJ });
FN('GdiFlush', BOOL, {  });
FN('GdiSetBatchLimit', DWORD, { dw: DWORD });
FN('GdiGetBatchLimit', DWORD, {  });
FN('SetICMMode', 'void', { hdc: HDC, mode: int });
FN('CheckColorsInGamut', BOOL, { hdc: HDC, lpRGBTriple: LPRGBTRIPLE, dlpBuffer: LPVOID, nCount: DWORD });
FN('GetColorSpace', HCOLORSPACE, { hdc: HDC });
FN('GetLogColorSpaceA', BOOL, { hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEA, nSize: DWORD });
FN('GetLogColorSpaceW', BOOL, { hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEW, nSize: DWORD });
FN('CreateColorSpaceA', HCOLORSPACE, { lplcs: LPLOGCOLORSPACEA });
FN('CreateColorSpaceW', HCOLORSPACE, { lplcs: LPLOGCOLORSPACEW });
FN('SetColorSpace', HCOLORSPACE, { hdc: HDC, hcs: HCOLORSPACE });
FN('DeleteColorSpace', BOOL, { hcs: HCOLORSPACE });
FN('GetICMProfileA', BOOL, { hdc: HDC, pBufSize: LPDWORD, pszFilename: LPSTR });
FN('GetICMProfileW', BOOL, { hdc: HDC, pBufSize: LPDWORD, pszFilename: LPWSTR });
FN('SetICMProfileA', BOOL, { hdc: HDC, lpFileName: LPSTR });
FN('SetICMProfileW', BOOL, { hdc: HDC, lpFileName: LPWSTR });
FN('GetDeviceGammaRamp', BOOL, { hdc: HDC, lpRamp: LPVOID });
FN('SetDeviceGammaRamp', BOOL, { hdc: HDC, lpRamp: LPVOID });
FN('ColorMatchToTarget', BOOL, { hdc: HDC, hdcTarget: HDC, action: DWORD });
FN('EnumICMProfilesA', 'void', { hdc: HDC, proc: ICMENUMPROCA, param: LPARAM });
FN('EnumICMProfilesW', 'void', { hdc: HDC, proc: ICMENUMPROCW, param: LPARAM });
FN('UpdateICMRegKeyA', BOOL, { reserved: DWORD, lpszCMID: LPSTR, lpszFileName: LPSTR, command: UINT });
FN('UpdateICMRegKeyW', BOOL, { reserved: DWORD, lpszCMID: LPWSTR, lpszFileName: LPWSTR, command: UINT });
FN('ColorCorrectPalette', BOOL, { hdc: HDC, hPal: HPALETTE, deFirst: DWORD, num: DWORD });
FN('wglCopyContext', BOOL, { UINT: UINT });
FN('wglCreateContext', HGLRC, { HDC: HDC });
FN('wglCreateLayerContext', HGLRC, { int: int });
FN('wglDeleteContext', BOOL, { HGLRC: HGLRC });
FN('wglGetCurrentContext', HGLRC, {  });
FN('wglGetCurrentDC', HDC, {  });
FN('wglGetProcAddress', PROC, { LPCSTR: LPCSTR });
FN('wglMakeCurrent', BOOL, { HGLRC: HGLRC });
FN('wglShareLists', BOOL, { HGLRC: HGLRC });
FN('wglUseFontBitmapsA', BOOL, { DWORD: DWORD });
FN('wglUseFontBitmapsW', BOOL, { DWORD: DWORD });
FN('SwapBuffers', BOOL, { HDC: HDC });
FN('wglUseFontOutlinesA', BOOL, { LPGLYPHMETRICSFLOAT: LPGLYPHMETRICSFLOAT });
FN('wglUseFontOutlinesW', BOOL, { LPGLYPHMETRICSFLOAT: LPGLYPHMETRICSFLOAT });
FN('wglDescribeLayerPlane', BOOL, { LPLAYERPLANEDESCRIPTOR: LPLAYERPLANEDESCRIPTOR });
FN('wglSetLayerPaletteEntries', 'void', { PTR(ulong): PTR(ulong) });
FN('wglGetLayerPaletteEntries', 'void', { PTR(ulong): PTR(ulong) });
FN('wglRealizeLayerPalette', BOOL, { BOOL: BOOL });
FN('wglSwapLayerBuffers', BOOL, { UINT: UINT });
FN('wglSwapMultipleBuffers', DWORD, { PTR(uint): PTR(uint) });
FN('wvsprintfA', 'void', { LPCSTR: LPCSTR, arglist: va_list });
FN('wvsprintfW', 'void', { LPCWSTR: LPCWSTR, arglist: va_list });
FN('wsprintfA', 'void', { LPCSTR: LPCSTR });
FN('wsprintfW', 'void', { LPCWSTR: LPCWSTR });
FN('LoadKeyboardLayoutA', HKL, { pwszKLID: LPCSTR, Flags: UINT });
FN('LoadKeyboardLayoutW', HKL, { pwszKLID: LPCWSTR, Flags: UINT });
FN('ActivateKeyboardLayout', HKL, { hkl: HKL, Flags: UINT });
FN('ToUnicodeEx', 'void', { wVirtKey: UINT, wScanCode: UINT, lpKeyState: PTR(uchar), pwszBuff: LPWSTR, cchBuff: int, wFlags: UINT, dwhkl: HKL });
FN('UnloadKeyboardLayout', BOOL, { hkl: HKL });
FN('GetKeyboardLayoutNameA', BOOL, { pwszKLID: LPSTR });
FN('GetKeyboardLayoutNameW', BOOL, { pwszKLID: LPWSTR });
FN('GetKeyboardLayoutList', 'void', { nBuff: int, lpList: PTR(pointer) });
FN('GetKeyboardLayout', HKL, { idThread: DWORD });
FN('GetMouseMovePointsEx', 'void', { cbSize: UINT, lppt: LPMOUSEMOVEPOINT, lpptBuf: LPMOUSEMOVEPOINT, nBufPoints: int, resolution: DWORD });
FN('CreateDesktopA', HDESK, { lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES });
FN('CreateDesktopW', HDESK, { lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES });
FN('CreateDesktopExA', HDESK, { lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID });
FN('CreateDesktopExW', HDESK, { lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID });
FN('OpenDesktopA', HDESK, { lpszDesktop: LPCSTR, dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK });
FN('OpenDesktopW', HDESK, { lpszDesktop: LPCWSTR, dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK });
FN('OpenInputDesktop', HDESK, { dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK });
FN('EnumDesktopsA', BOOL, { hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCA, lParam: LPARAM });
FN('EnumDesktopsW', BOOL, { hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCW, lParam: LPARAM });
FN('EnumDesktopWindows', BOOL, { hDesktop: HDESK, lpfn: WNDENUMPROC, lParam: LPARAM });
FN('SwitchDesktop', BOOL, { hDesktop: HDESK });
FN('SetThreadDesktop', BOOL, { hDesktop: HDESK });
FN('CloseDesktop', BOOL, { hDesktop: HDESK });
FN('GetThreadDesktop', HDESK, { dwThreadId: DWORD });
FN('CreateWindowStationA', HWINSTA, { lpwinsta: LPCSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES });
FN('CreateWindowStationW', HWINSTA, { lpwinsta: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES });
FN('OpenWindowStationA', HWINSTA, { lpszWinSta: LPCSTR, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK });
FN('OpenWindowStationW', HWINSTA, { lpszWinSta: LPCWSTR, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK });
FN('EnumWindowStationsA', BOOL, { lpEnumFunc: WINSTAENUMPROCA, lParam: LPARAM });
FN('EnumWindowStationsW', BOOL, { lpEnumFunc: WINSTAENUMPROCW, lParam: LPARAM });
FN('CloseWindowStation', BOOL, { hWinSta: HWINSTA });
FN('SetProcessWindowStation', BOOL, { hWinSta: HWINSTA });
FN('GetProcessWindowStation', HWINSTA, {  });
FN('SetUserObjectSecurity', BOOL, { hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR });
FN('GetUserObjectSecurity', BOOL, { hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('GetUserObjectInformationA', BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('GetUserObjectInformationW', BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD });
FN('SetUserObjectInformationA', BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD });
FN('SetUserObjectInformationW', BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD });
FN('IsHungAppWindow', BOOL, { hwnd: HWND });
FN('DisableProcessWindowsGhosting', 'void', {  });
FN('RegisterWindowMessageA', UINT, { lpString: LPCSTR });
FN('RegisterWindowMessageW', UINT, { lpString: LPCWSTR });
FN('TrackMouseEvent', BOOL, { lpEventTrack: LPTRACKMOUSEEVENT });
FN('DrawEdge', BOOL, { hdc: HDC, qrc: LPRECT, edge: UINT, grfFlags: UINT });
FN('DrawFrameControl', BOOL, { UINT: UINT });
FN('DrawCaption', BOOL, { hwnd: HWND, hdc: HDC, lprect: PTR(uint), flags: UINT });
FN('DrawAnimatedRects', BOOL, { hwnd: HWND, idAni: int, lprcFrom: PTR(uint), lprcTo: PTR(uint) });
FN('GetMessageA', BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT });
FN('GetMessageW', BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT });
FN('TranslateMessage', BOOL, { lpMsg: PTR(uint) });
FN('DispatchMessageA', LRESULT, { lpMsg: PTR(uint) });
FN('DispatchMessageW', LRESULT, { lpMsg: PTR(uint) });
FN('SetMessageQueue', BOOL, { cMessagesMax: int });
FN('PeekMessageA', BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT });
FN('PeekMessageW', BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT });
FN('RegisterHotKey', BOOL, { hWnd: HWND, id: int, fsModifiers: UINT, vk: UINT });
FN('UnregisterHotKey', BOOL, { hWnd: HWND, id: int });
FN('ExitWindowsEx', BOOL, { uFlags: UINT, dwReason: DWORD });
FN('SwapMouseButton', BOOL, { fSwap: BOOL });
FN('GetMessagePos', DWORD, {  });
FN('GetMessageTime', LONG, {  });
FN('GetMessageExtraInfo', LPARAM, {  });
FN('IsWow64Message', BOOL, {  });
FN('SetMessageExtraInfo', LPARAM, { lParam: LPARAM });
FN('SendMessageA', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('SendMessageW', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('SendMessageTimeoutA', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR });
FN('SendMessageTimeoutW', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR });
FN('SendNotifyMessageA', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('SendNotifyMessageW', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('SendMessageCallbackA', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR });
FN('SendMessageCallbackW', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR });
FN('BroadcastSystemMessageExA', 'void', { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO });
FN('BroadcastSystemMessageExW', 'void', { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO });
FN('BroadcastSystemMessageA', 'void', { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('BroadcastSystemMessageW', 'void', { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('RegisterDeviceNotificationA', HDEVNOTIFY, { hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD });
FN('RegisterDeviceNotificationW', HDEVNOTIFY, { hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD });
FN('UnregisterDeviceNotification', BOOL, { Handle: HDEVNOTIFY });
FN('RegisterPowerSettingNotification', HPOWERNOTIFY, { hRecipient: HANDLE, PowerSettingGuid: LPCGUID, Flags: DWORD });
FN('UnregisterPowerSettingNotification', BOOL, { Handle: HPOWERNOTIFY });
FN('PostMessageA', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('PostMessageW', BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('PostThreadMessageA', BOOL, { idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('PostThreadMessageW', BOOL, { idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('AttachThreadInput', BOOL, { idAttach: DWORD, idAttachTo: DWORD, fAttach: BOOL });
FN('ReplyMessage', BOOL, { lResult: LRESULT });
FN('WaitMessage', BOOL, {  });
FN('WaitForInputIdle', DWORD, { hProcess: HANDLE, dwMilliseconds: DWORD });
FN('DefWindowProcA', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('DefWindowProcW', LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('PostQuitMessage', 'void', { nExitCode: int });
FN('CallWindowProcA', LRESULT, { lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('CallWindowProcW', LRESULT, { lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('InSendMessage', BOOL, {  });
FN('InSendMessageEx', DWORD, { lpReserved: LPVOID });
FN('GetDoubleClickTime', UINT, {  });
FN('SetDoubleClickTime', BOOL, { UINT: UINT });
FN('RegisterClassA', ATOM, { lpWndClass: PTR(uint) });
FN('RegisterClassW', ATOM, { lpWndClass: PTR(uint) });
FN('UnregisterClassA', BOOL, { lpClassName: LPCSTR, hInstance: HINSTANCE });
FN('UnregisterClassW', BOOL, { lpClassName: LPCWSTR, hInstance: HINSTANCE });
FN('GetClassInfoA', BOOL, { hInstance: HINSTANCE, lpClassName: LPCSTR, lpWndClass: LPWNDCLASSA });
FN('GetClassInfoW', BOOL, { hInstance: HINSTANCE, lpClassName: LPCWSTR, lpWndClass: LPWNDCLASSW });
FN('RegisterClassExA', ATOM, { PTR(uint): PTR(uint) });
FN('RegisterClassExW', ATOM, { PTR(uint): PTR(uint) });
FN('GetClassInfoExA', BOOL, { hInstance: HINSTANCE, lpszClass: LPCSTR, lpwcx: LPWNDCLASSEXA });
FN('GetClassInfoExW', BOOL, { hInstance: HINSTANCE, lpszClass: LPCWSTR, lpwcx: LPWNDCLASSEXW });
FN('CreateWindowExA', HWND, { dwExStyle: DWORD, lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID });
FN('CreateWindowExW', HWND, { dwExStyle: DWORD, lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: LPVOID });
FN('IsWindow', BOOL, { hWnd: HWND });
FN('IsMenu', BOOL, { hMenu: HMENU });
FN('IsChild', BOOL, { hWndParent: HWND, hWnd: HWND });
FN('DestroyWindow', BOOL, { hWnd: HWND });
FN('ShowWindow', BOOL, { hWnd: HWND, nCmdShow: int });
FN('AnimateWindow', BOOL, { hWnd: HWND, dwTime: DWORD, dwFlags: DWORD });
FN('UpdateLayeredWindow', BOOL, { hWnd: HWND, hdcDst: HDC, pptDst: PTR(uint), psize: PTR(uint), hdcSrc: HDC, pptSrc: PTR(uint), crKey: COLORREF, pblend: PTR(uint), dwFlags: DWORD });
FN('UpdateLayeredWindowIndirect', BOOL, { hWnd: HWND, pULWInfo: PTR(uint) });
FN('GetLayeredWindowAttributes', BOOL, { hwnd: HWND, pcrKey: PTR(ulong), pbAlpha: PTR(uchar), pdwFlags: PTR(ulong) });
FN('PrintWindow', BOOL, { hwnd: HWND, hdcBlt: HDC, nFlags: UINT });
FN('SetLayeredWindowAttributes', BOOL, { hwnd: HWND, crKey: COLORREF, bAlpha: BYTE, dwFlags: DWORD });
FN('ShowWindowAsync', BOOL, { hWnd: HWND, nCmdShow: int });
FN('FlashWindow', BOOL, { hWnd: HWND, bInvert: BOOL });
FN('FlashWindowEx', BOOL, { pfwi: PFLASHWINFO });
FN('ShowOwnedPopups', BOOL, { hWnd: HWND, fShow: BOOL });
FN('OpenIcon', BOOL, { hWnd: HWND });
FN('CloseWindow', BOOL, { hWnd: HWND });
FN('MoveWindow', BOOL, { hWnd: HWND, X: int, Y: int, nWidth: int, nHeight: int, bRepaint: BOOL });
FN('SetWindowPos', BOOL, { hWnd: HWND, hWndInsertAfter: HWND, X: int, Y: int, cx: int, cy: int, uFlags: UINT });
FN('GetWindowPlacement', BOOL, { hWnd: HWND, lpwndpl: PTR(uint) });
FN('SetWindowPlacement', BOOL, { hWnd: HWND, lpwndpl: PTR(uint) });
FN('GetWindowDisplayAffinity', BOOL, { hWnd: HWND, pdwAffinity: PTR(ulong) });
FN('SetWindowDisplayAffinity', BOOL, { hWnd: HWND, dwAffinity: DWORD });
FN('BeginDeferWindowPos', HDWP, { nNumWindows: int });
FN('DeferWindowPos', HDWP, { hWinPosInfo: HDWP, hWnd: HWND, hWndInsertAfter: HWND, x: int, y: int, cx: int, cy: int, uFlags: UINT });
FN('EndDeferWindowPos', BOOL, { hWinPosInfo: HDWP });
FN('IsWindowVisible', BOOL, { hWnd: HWND });
FN('IsIconic', BOOL, { hWnd: HWND });
FN('AnyPopup', BOOL, {  });
FN('BringWindowToTop', BOOL, { hWnd: HWND });
FN('IsZoomed', BOOL, { hWnd: HWND });
FN('CreateDialogParamA', HWND, { hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('CreateDialogParamW', HWND, { hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('CreateDialogIndirectParamA', HWND, { hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('CreateDialogIndirectParamW', HWND, { hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('DialogBoxParamA', INT_PTR, { hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('DialogBoxParamW', INT_PTR, { hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('DialogBoxIndirectParamA', INT_PTR, { hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('DialogBoxIndirectParamW', INT_PTR, { hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM });
FN('EndDialog', BOOL, { hDlg: HWND, nResult: INT_PTR });
FN('GetDlgItem', HWND, { hDlg: HWND, nIDDlgItem: int });
FN('SetDlgItemInt', BOOL, { hDlg: HWND, nIDDlgItem: int, uValue: UINT, bSigned: BOOL });
FN('GetDlgItemInt', UINT, { hDlg: HWND, nIDDlgItem: int, lpTranslated: PTR(int), bSigned: BOOL });
FN('SetDlgItemTextA', BOOL, { hDlg: HWND, nIDDlgItem: int, lpString: LPCSTR });
FN('SetDlgItemTextW', BOOL, { hDlg: HWND, nIDDlgItem: int, lpString: LPCWSTR });
FN('GetDlgItemTextA', UINT, { hDlg: HWND, nIDDlgItem: int, lpString: LPSTR, cchMax: int });
FN('GetDlgItemTextW', UINT, { hDlg: HWND, nIDDlgItem: int, lpString: LPWSTR, cchMax: int });
FN('CheckDlgButton', BOOL, { hDlg: HWND, nIDButton: int, uCheck: UINT });
FN('CheckRadioButton', BOOL, { hDlg: HWND, nIDFirstButton: int, nIDLastButton: int, nIDCheckButton: int });
FN('IsDlgButtonChecked', UINT, { hDlg: HWND, nIDButton: int });
FN('SendDlgItemMessageA', LRESULT, { hDlg: HWND, nIDDlgItem: int, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('SendDlgItemMessageW', LRESULT, { hDlg: HWND, nIDDlgItem: int, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('GetNextDlgGroupItem', HWND, { hDlg: HWND, hCtl: HWND, bPrevious: BOOL });
FN('GetNextDlgTabItem', HWND, { hDlg: HWND, hCtl: HWND, bPrevious: BOOL });
FN('GetDlgCtrlID', 'void', { hWnd: HWND });
FN('GetDialogBaseUnits', 'void', {  });
FN('DefDlgProcA', LRESULT, { hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('DefDlgProcW', LRESULT, { hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('CallMsgFilterA', BOOL, { lpMsg: LPMSG, nCode: int });
FN('CallMsgFilterW', BOOL, { lpMsg: LPMSG, nCode: int });
FN('OpenClipboard', BOOL, { hWndNewOwner: HWND });
FN('CloseClipboard', BOOL, {  });
FN('GetClipboardSequenceNumber', DWORD, {  });
FN('GetClipboardOwner', HWND, {  });
FN('SetClipboardViewer', HWND, { hWndNewViewer: HWND });
FN('GetClipboardViewer', HWND, {  });
FN('ChangeClipboardChain', BOOL, { hWndRemove: HWND, hWndNewNext: HWND });
FN('SetClipboardData', HANDLE, { uFormat: UINT, hMem: HANDLE });
FN('GetClipboardData', HANDLE, { uFormat: UINT });
FN('RegisterClipboardFormatA', UINT, { lpszFormat: LPCSTR });
FN('RegisterClipboardFormatW', UINT, { lpszFormat: LPCWSTR });
FN('CountClipboardFormats', 'void', {  });
FN('EnumClipboardFormats', UINT, { format: UINT });
FN('GetClipboardFormatNameA', 'void', { format: UINT, lpszFormatName: LPSTR, cchMaxCount: int });
FN('GetClipboardFormatNameW', 'void', { format: UINT, lpszFormatName: LPWSTR, cchMaxCount: int });
FN('EmptyClipboard', BOOL, {  });
FN('IsClipboardFormatAvailable', BOOL, { format: UINT });
FN('GetPriorityClipboardFormat', 'void', { paFormatPriorityList: PTR(uint), cFormats: int });
FN('GetOpenClipboardWindow', HWND, {  });
FN('AddClipboardFormatListener', BOOL, { hwnd: HWND });
FN('RemoveClipboardFormatListener', BOOL, { hwnd: HWND });
FN('GetUpdatedClipboardFormats', BOOL, { lpuiFormats: PUINT, cFormats: UINT, pcFormatsOut: PUINT });
FN('CharToOemA', BOOL, { pSrc: LPCSTR, pDst: LPSTR });
FN('CharToOemW', BOOL, { pSrc: LPCWSTR, pDst: LPSTR });
FN('OemToCharA', BOOL, { pSrc: LPCSTR, pDst: LPSTR });
FN('OemToCharW', BOOL, { pSrc: LPCSTR, pDst: LPWSTR });
FN('CharToOemBuffA', BOOL, { lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD });
FN('CharToOemBuffW', BOOL, { lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD });
FN('OemToCharBuffA', BOOL, { lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD });
FN('OemToCharBuffW', BOOL, { lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD });
FN('CharUpperA', LPSTR, { lpsz: LPSTR });
FN('CharUpperW', LPWSTR, { lpsz: LPWSTR });
FN('CharUpperBuffA', DWORD, { lpsz: LPSTR, cchLength: DWORD });
FN('CharUpperBuffW', DWORD, { lpsz: LPWSTR, cchLength: DWORD });
FN('CharLowerA', LPSTR, { lpsz: LPSTR });
FN('CharLowerW', LPWSTR, { lpsz: LPWSTR });
FN('CharLowerBuffA', DWORD, { lpsz: LPSTR, cchLength: DWORD });
FN('CharLowerBuffW', DWORD, { lpsz: LPWSTR, cchLength: DWORD });
FN('CharNextA', LPSTR, { lpsz: LPCSTR });
FN('CharNextW', LPWSTR, { lpsz: LPCWSTR });
FN('CharPrevA', LPSTR, { lpszStart: LPCSTR, lpszCurrent: LPCSTR });
FN('CharPrevW', LPWSTR, { lpszStart: LPCWSTR, lpszCurrent: LPCWSTR });
FN('CharNextExA', LPSTR, { CodePage: WORD, lpCurrentChar: LPCSTR, dwFlags: DWORD });
FN('CharPrevExA', LPSTR, { CodePage: WORD, lpStart: LPCSTR, lpCurrentChar: LPCSTR, dwFlags: DWORD });
FN('IsCharAlphaA', BOOL, { ch: CHAR });
FN('IsCharAlphaW', BOOL, { ch: WCHAR });
FN('IsCharAlphaNumericA', BOOL, { ch: CHAR });
FN('IsCharAlphaNumericW', BOOL, { ch: WCHAR });
FN('IsCharUpperA', BOOL, { ch: CHAR });
FN('IsCharUpperW', BOOL, { ch: WCHAR });
FN('IsCharLowerA', BOOL, { ch: CHAR });
FN('IsCharLowerW', BOOL, { ch: WCHAR });
FN('SetFocus', HWND, { hWnd: HWND });
FN('GetActiveWindow', HWND, {  });
FN('GetFocus', HWND, {  });
FN('GetKBCodePage', UINT, {  });
FN('GetKeyState', SHORT, { nVirtKey: int });
FN('GetAsyncKeyState', SHORT, { vKey: int });
FN('GetKeyboardState', BOOL, { lpKeyState: PBYTE });
FN('SetKeyboardState', BOOL, { lpKeyState: LPBYTE });
FN('GetKeyNameTextA', 'void', { lParam: LONG, lpString: LPSTR, cchSize: int });
FN('GetKeyNameTextW', 'void', { lParam: LONG, lpString: LPWSTR, cchSize: int });
FN('GetKeyboardType', 'void', { nTypeFlag: int });
FN('ToAscii', 'void', { uVirtKey: UINT, uScanCode: UINT, lpKeyState: PTR(uchar), lpChar: LPWORD, uFlags: UINT });
FN('ToAsciiEx', 'void', { uVirtKey: UINT, uScanCode: UINT, lpKeyState: PTR(uchar), lpChar: LPWORD, uFlags: UINT, dwhkl: HKL });
FN('ToUnicode', 'void', { wVirtKey: UINT, wScanCode: UINT, lpKeyState: PTR(uchar), pwszBuff: LPWSTR, cchBuff: int, wFlags: UINT });
FN('OemKeyScan', DWORD, { wOemChar: WORD });
FN('VkKeyScanA', SHORT, { ch: CHAR });
FN('VkKeyScanW', SHORT, { ch: WCHAR });
FN('VkKeyScanExA', SHORT, { ch: CHAR, dwhkl: HKL });
FN('VkKeyScanExW', SHORT, { ch: WCHAR, dwhkl: HKL });
FN('keybd_event', 'void', { bVk: BYTE, bScan: BYTE, dwFlags: DWORD, dwExtraInfo: ULONG_PTR });
FN('mouse_event', 'void', { dwFlags: DWORD, dx: DWORD, dy: DWORD, dwData: DWORD, dwExtraInfo: ULONG_PTR });
FN('SendInput', UINT, { cInputs: UINT, pInputs: LPINPUT, cbSize: int });
FN('GetTouchInputInfo', BOOL, { hTouchInput: HTOUCHINPUT, cInputs: UINT, pInputs: PTOUCHINPUT, cbSize: int });
FN('CloseTouchInputHandle', BOOL, { hTouchInput: HTOUCHINPUT });
FN('RegisterTouchWindow', BOOL, { hwnd: HWND, ulFlags: ULONG });
FN('UnregisterTouchWindow', BOOL, { hwnd: HWND });
FN('IsTouchWindow', BOOL, { hwnd: HWND, pulFlags: PULONG });
FN('GetLastInputInfo', BOOL, { plii: PLASTINPUTINFO });
FN('MapVirtualKeyA', UINT, { uCode: UINT, uMapType: UINT });
FN('MapVirtualKeyW', UINT, { uCode: UINT, uMapType: UINT });
FN('MapVirtualKeyExA', UINT, { uCode: UINT, uMapType: UINT, dwhkl: HKL });
FN('MapVirtualKeyExW', UINT, { uCode: UINT, uMapType: UINT, dwhkl: HKL });
FN('GetInputState', BOOL, {  });
FN('GetQueueStatus', DWORD, { flags: UINT });
FN('GetCapture', HWND, {  });
FN('SetCapture', HWND, { hWnd: HWND });
FN('ReleaseCapture', BOOL, {  });
FN('MsgWaitForMultipleObjects', DWORD, { nCount: DWORD, pHandles: PTR(PTR('void')), fWaitAll: BOOL, dwMilliseconds: DWORD, dwWakeMask: DWORD });
FN('MsgWaitForMultipleObjectsEx', DWORD, { nCount: DWORD, pHandles: PTR(PTR('void')), dwMilliseconds: DWORD, dwWakeMask: DWORD, dwFlags: DWORD });
FN('SetTimer', UINT_PTR, { hWnd: HWND, nIDEvent: UINT_PTR, uElapse: UINT, lpTimerFunc: TIMERPROC });
FN('KillTimer', BOOL, { hWnd: HWND, uIDEvent: UINT_PTR });
FN('IsWindowUnicode', BOOL, { hWnd: HWND });
FN('EnableWindow', BOOL, { hWnd: HWND, bEnable: BOOL });
FN('IsWindowEnabled', BOOL, { hWnd: HWND });
FN('LoadAcceleratorsA', HACCEL, { hInstance: HINSTANCE, lpTableName: LPCSTR });
FN('LoadAcceleratorsW', HACCEL, { hInstance: HINSTANCE, lpTableName: LPCWSTR });
FN('CreateAcceleratorTableA', HACCEL, { paccel: LPACCEL, cAccel: int });
FN('CreateAcceleratorTableW', HACCEL, { paccel: LPACCEL, cAccel: int });
FN('DestroyAcceleratorTable', BOOL, { hAccel: HACCEL });
FN('CopyAcceleratorTableA', 'void', { hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int });
FN('CopyAcceleratorTableW', 'void', { hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int });
FN('TranslateAcceleratorA', 'void', { hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG });
FN('TranslateAcceleratorW', 'void', { hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG });
FN('GetSystemMetrics', 'void', { nIndex: int });
FN('LoadMenuA', HMENU, { hInstance: HINSTANCE, lpMenuName: LPCSTR });
FN('LoadMenuW', HMENU, { hInstance: HINSTANCE, lpMenuName: LPCWSTR });
FN('LoadMenuIndirectA', HMENU, { lpMenuTemplate: PTR('void') });
FN('LoadMenuIndirectW', HMENU, { lpMenuTemplate: PTR('void') });
FN('GetMenu', HMENU, { hWnd: HWND });
FN('SetMenu', BOOL, { hWnd: HWND, hMenu: HMENU });
FN('ChangeMenuA', BOOL, { hMenu: HMENU, cmd: UINT, lpszNewItem: LPCSTR, cmdInsert: UINT, flags: UINT });
FN('ChangeMenuW', BOOL, { hMenu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR, cmdInsert: UINT, flags: UINT });
FN('HiliteMenuItem', BOOL, { hWnd: HWND, hMenu: HMENU, uIDHiliteItem: UINT, uHilite: UINT });
FN('GetMenuStringA', 'void', { hMenu: HMENU, uIDItem: UINT, lpString: LPSTR, cchMax: int, flags: UINT });
FN('GetMenuStringW', 'void', { hMenu: HMENU, uIDItem: UINT, lpString: LPWSTR, cchMax: int, flags: UINT });
FN('GetMenuState', UINT, { hMenu: HMENU, uId: UINT, uFlags: UINT });
FN('DrawMenuBar', BOOL, { hWnd: HWND });
FN('GetSystemMenu', HMENU, { hWnd: HWND, bRevert: BOOL });
FN('CreateMenu', HMENU, {  });
FN('CreatePopupMenu', HMENU, {  });
FN('DestroyMenu', BOOL, { hMenu: HMENU });
FN('CheckMenuItem', DWORD, { hMenu: HMENU, uIDCheckItem: UINT, uCheck: UINT });
FN('EnableMenuItem', BOOL, { hMenu: HMENU, uIDEnableItem: UINT, uEnable: UINT });
FN('GetSubMenu', HMENU, { hMenu: HMENU, nPos: int });
FN('GetMenuItemID', UINT, { hMenu: HMENU, nPos: int });
FN('GetMenuItemCount', 'void', { hMenu: HMENU });
FN('InsertMenuA', BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR });
FN('InsertMenuW', BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR });
FN('AppendMenuA', BOOL, { hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR });
FN('AppendMenuW', BOOL, { hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR });
FN('ModifyMenuA', BOOL, { hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR });
FN('ModifyMenuW', BOOL, { hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR });
FN('RemoveMenu', BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT });
FN('DeleteMenu', BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT });
FN('SetMenuItemBitmaps', BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, hBitmapUnchecked: HBITMAP, hBitmapChecked: HBITMAP });
FN('GetMenuCheckMarkDimensions', LONG, {  });
FN('TrackPopupMenu', BOOL, { hMenu: HMENU, uFlags: UINT, x: int, y: int, nReserved: int, hWnd: HWND, prcRect: PTR(uint) });
FN('TrackPopupMenuEx', BOOL, { LPTPMPARAMS: LPTPMPARAMS });
FN('CalculatePopupWindowPosition', BOOL, { anchorPoint: PTR(uint), windowSize: PTR(uint), flags: UINT, excludeRect: PTR(uint), popupWindowPosition: PTR(uint) });
FN('GetMenuInfo', BOOL, { LPMENUINFO: LPMENUINFO });
FN('SetMenuInfo', BOOL, { LPCMENUINFO: LPCMENUINFO });
FN('EndMenu', BOOL, {  });
FN('InsertMenuItemA', BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmi: LPCMENUITEMINFOA });
FN('InsertMenuItemW', BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmi: LPCMENUITEMINFOW });
FN('GetMenuItemInfoA', BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmii: LPMENUITEMINFOA });
FN('GetMenuItemInfoW', BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmii: LPMENUITEMINFOW });
FN('SetMenuItemInfoA', BOOL, { hmenu: HMENU, item: UINT, fByPositon: BOOL, lpmii: LPCMENUITEMINFOA });
FN('SetMenuItemInfoW', BOOL, { hmenu: HMENU, item: UINT, fByPositon: BOOL, lpmii: LPCMENUITEMINFOW });
FN('GetMenuDefaultItem', UINT, { hMenu: HMENU, fByPos: UINT, gmdiFlags: UINT });
FN('SetMenuDefaultItem', BOOL, { hMenu: HMENU, uItem: UINT, fByPos: UINT });
FN('GetMenuItemRect', BOOL, { hWnd: HWND, hMenu: HMENU, uItem: UINT, lprcItem: LPRECT });
FN('MenuItemFromPoint', 'void', { hWnd: HWND, hMenu: HMENU, ptScreen: POINT });
FN('DragObject', DWORD, { hwndParent: HWND, hwndFrom: HWND, fmt: UINT, data: ULONG_PTR, hcur: HCURSOR });
FN('DragDetect', BOOL, { hwnd: HWND, pt: POINT });
FN('DrawIcon', BOOL, { hDC: HDC, X: int, Y: int, hIcon: HICON });
FN('DrawTextA', 'void', { hdc: HDC, lpchText: LPCSTR, cchText: int, lprc: LPRECT, format: UINT });
FN('DrawTextW', 'void', { hdc: HDC, lpchText: LPCWSTR, cchText: int, lprc: LPRECT, format: UINT });
FN('DrawTextExA', 'void', { hdc: HDC, lpchText: LPSTR, cchText: int, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS });
FN('DrawTextExW', 'void', { hdc: HDC, lpchText: LPWSTR, cchText: int, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS });
FN('GrayStringA', BOOL, { hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int, X: int, Y: int, nWidth: int, nHeight: int });
FN('GrayStringW', BOOL, { hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int, X: int, Y: int, nWidth: int, nHeight: int });
FN('DrawStateA', BOOL, { hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int, y: int, cx: int, cy: int, uFlags: UINT });
FN('DrawStateW', BOOL, { hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int, y: int, cx: int, cy: int, uFlags: UINT });
FN('TabbedTextOutA', LONG, { hdc: HDC, x: int, y: int, lpString: LPCSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int), nTabOrigin: int });
FN('TabbedTextOutW', LONG, { hdc: HDC, x: int, y: int, lpString: LPCWSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int), nTabOrigin: int });
FN('GetTabbedTextExtentA', DWORD, { hdc: HDC, lpString: LPCSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int) });
FN('GetTabbedTextExtentW', DWORD, { hdc: HDC, lpString: LPCWSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int) });
FN('UpdateWindow', BOOL, { hWnd: HWND });
FN('SetActiveWindow', HWND, { hWnd: HWND });
FN('GetForegroundWindow', HWND, {  });
FN('PaintDesktop', BOOL, { hdc: HDC });
FN('SwitchToThisWindow', 'void', { hwnd: HWND, fUnknown: BOOL });
FN('SetForegroundWindow', BOOL, { hWnd: HWND });
FN('AllowSetForegroundWindow', BOOL, { dwProcessId: DWORD });
FN('LockSetForegroundWindow', BOOL, { uLockCode: UINT });
FN('WindowFromDC', HWND, { hDC: HDC });
FN('GetDC', HDC, { hWnd: HWND });
FN('GetDCEx', HDC, { hWnd: HWND, hrgnClip: HRGN, flags: DWORD });
FN('GetWindowDC', HDC, { hWnd: HWND });
FN('ReleaseDC', 'void', { hWnd: HWND, hDC: HDC });
FN('BeginPaint', HDC, { hWnd: HWND, lpPaint: LPPAINTSTRUCT });
FN('EndPaint', BOOL, { hWnd: HWND, lpPaint: PTR(uint) });
FN('GetUpdateRect', BOOL, { hWnd: HWND, lpRect: LPRECT, bErase: BOOL });
FN('GetUpdateRgn', 'void', { hWnd: HWND, hRgn: HRGN, bErase: BOOL });
FN('SetWindowRgn', 'void', { hWnd: HWND, hRgn: HRGN, bRedraw: BOOL });
FN('GetWindowRgn', 'void', { hWnd: HWND, hRgn: HRGN });
FN('GetWindowRgnBox', 'void', { hWnd: HWND, lprc: LPRECT });
FN('ExcludeUpdateRgn', 'void', { hDC: HDC, hWnd: HWND });
FN('InvalidateRect', BOOL, { hWnd: HWND, lpRect: PTR(uint), bErase: BOOL });
FN('ValidateRect', BOOL, { hWnd: HWND, lpRect: PTR(uint) });
FN('InvalidateRgn', BOOL, { hWnd: HWND, hRgn: HRGN, bErase: BOOL });
FN('ValidateRgn', BOOL, { hWnd: HWND, hRgn: HRGN });
FN('RedrawWindow', BOOL, { hWnd: HWND, lprcUpdate: PTR(uint), hrgnUpdate: HRGN, flags: UINT });
FN('LockWindowUpdate', BOOL, { hWndLock: HWND });
FN('ScrollWindow', BOOL, { hWnd: HWND, XAmount: int, YAmount: int, lpRect: PTR(uint), lpClipRect: PTR(uint) });
FN('ScrollDC', BOOL, { hDC: HDC, dx: int, dy: int, lprcScroll: PTR(uint), lprcClip: PTR(uint), hrgnUpdate: HRGN, lprcUpdate: LPRECT });
FN('ScrollWindowEx', 'void', { hWnd: HWND, dx: int, dy: int, prcScroll: PTR(uint), prcClip: PTR(uint), hrgnUpdate: HRGN, prcUpdate: LPRECT, flags: UINT });
FN('SetScrollPos', 'void', { hWnd: HWND, nBar: int, nPos: int, bRedraw: BOOL });
FN('GetScrollPos', 'void', { hWnd: HWND, nBar: int });
FN('SetScrollRange', BOOL, { hWnd: HWND, nBar: int, nMinPos: int, nMaxPos: int, bRedraw: BOOL });
FN('GetScrollRange', BOOL, { hWnd: HWND, nBar: int, lpMinPos: LPINT, lpMaxPos: LPINT });
FN('ShowScrollBar', BOOL, { hWnd: HWND, wBar: int, bShow: BOOL });
FN('EnableScrollBar', BOOL, { hWnd: HWND, wSBflags: UINT, wArrows: UINT });
FN('SetPropA', BOOL, { hWnd: HWND, lpString: LPCSTR, hData: HANDLE });
FN('SetPropW', BOOL, { hWnd: HWND, lpString: LPCWSTR, hData: HANDLE });
FN('GetPropA', HANDLE, { hWnd: HWND, lpString: LPCSTR });
FN('GetPropW', HANDLE, { hWnd: HWND, lpString: LPCWSTR });
FN('RemovePropA', HANDLE, { hWnd: HWND, lpString: LPCSTR });
FN('RemovePropW', HANDLE, { hWnd: HWND, lpString: LPCWSTR });
FN('EnumPropsExA', 'void', { hWnd: HWND, lpEnumFunc: PROPENUMPROCEXA, lParam: LPARAM });
FN('EnumPropsExW', 'void', { hWnd: HWND, lpEnumFunc: PROPENUMPROCEXW, lParam: LPARAM });
FN('EnumPropsA', 'void', { hWnd: HWND, lpEnumFunc: PROPENUMPROCA });
FN('EnumPropsW', 'void', { hWnd: HWND, lpEnumFunc: PROPENUMPROCW });
FN('SetWindowTextA', BOOL, { hWnd: HWND, lpString: LPCSTR });
FN('SetWindowTextW', BOOL, { hWnd: HWND, lpString: LPCWSTR });
FN('GetWindowTextA', 'void', { hWnd: HWND, lpString: LPSTR, nMaxCount: int });
FN('GetWindowTextW', 'void', { hWnd: HWND, lpString: LPWSTR, nMaxCount: int });
FN('GetWindowTextLengthA', 'void', { hWnd: HWND });
FN('GetWindowTextLengthW', 'void', { hWnd: HWND });
FN('GetClientRect', BOOL, { hWnd: HWND, lpRect: LPRECT });
FN('GetWindowRect', BOOL, { hWnd: HWND, lpRect: LPRECT });
FN('AdjustWindowRect', BOOL, { lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL });
FN('AdjustWindowRectEx', BOOL, { lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL, dwExStyle: DWORD });
FN('SetWindowContextHelpId', BOOL, { DWORD: DWORD });
FN('GetWindowContextHelpId', DWORD, { HWND: HWND });
FN('SetMenuContextHelpId', BOOL, { DWORD: DWORD });
FN('GetMenuContextHelpId', DWORD, { HMENU: HMENU });
FN('MessageBoxA', 'void', { hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT });
FN('MessageBoxW', 'void', { hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT });
FN('MessageBoxExA', 'void', { hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD });
FN('MessageBoxExW', 'void', { hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD });
FN('MessageBoxIndirectA', 'void', { lpmbp: PTR(uint) });
FN('MessageBoxIndirectW', 'void', { lpmbp: PTR(uint) });
FN('MessageBeep', BOOL, { uType: UINT });
FN('ShowCursor', 'void', { bShow: BOOL });
FN('SetCursorPos', BOOL, { X: int, Y: int });
FN('SetPhysicalCursorPos', BOOL, { X: int, Y: int });
FN('SetCursor', HCURSOR, { hCursor: HCURSOR });
FN('GetCursorPos', BOOL, { lpPoint: LPPOINT });
FN('GetPhysicalCursorPos', BOOL, { lpPoint: LPPOINT });
FN('ClipCursor', BOOL, { lpRect: PTR(uint) });
FN('GetClipCursor', BOOL, { lpRect: LPRECT });
FN('GetCursor', HCURSOR, {  });
FN('CreateCaret', BOOL, { hWnd: HWND, hBitmap: HBITMAP, nWidth: int, nHeight: int });
FN('GetCaretBlinkTime', UINT, {  });
FN('SetCaretBlinkTime', BOOL, { uMSeconds: UINT });
FN('DestroyCaret', BOOL, {  });
FN('HideCaret', BOOL, { hWnd: HWND });
FN('ShowCaret', BOOL, { hWnd: HWND });
FN('SetCaretPos', BOOL, { X: int, Y: int });
FN('GetCaretPos', BOOL, { lpPoint: LPPOINT });
FN('ClientToScreen', BOOL, { hWnd: HWND, lpPoint: LPPOINT });
FN('ScreenToClient', BOOL, { hWnd: HWND, lpPoint: LPPOINT });
FN('LogicalToPhysicalPoint', BOOL, { hWnd: HWND, lpPoint: LPPOINT });
FN('PhysicalToLogicalPoint', BOOL, { hWnd: HWND, lpPoint: LPPOINT });
FN('MapWindowPoints', 'void', { hWndFrom: HWND, hWndTo: HWND, lpPoints: LPPOINT, cPoints: UINT });
FN('WindowFromPoint', HWND, { Point: POINT });
FN('WindowFromPhysicalPoint', HWND, { Point: POINT });
FN('ChildWindowFromPoint', HWND, { hWndParent: HWND, Point: POINT });
FN('ChildWindowFromPointEx', HWND, { hwnd: HWND, pt: POINT, flags: UINT });
FN('GetSysColor', DWORD, { nIndex: int });
FN('GetSysColorBrush', HBRUSH, { nIndex: int });
FN('SetSysColors', BOOL, { cElements: int, lpaElements: PTR(int), lpaRgbValues: PTR(ulong) });
FN('DrawFocusRect', BOOL, { hDC: HDC, lprc: PTR(uint) });
FN('FillRect', 'void', { hDC: HDC, lprc: PTR(uint), hbr: HBRUSH });
FN('FrameRect', 'void', { hDC: HDC, lprc: PTR(uint), hbr: HBRUSH });
FN('InvertRect', BOOL, { hDC: HDC, lprc: PTR(uint) });
FN('SetRect', BOOL, { lprc: LPRECT, xLeft: int, yTop: int, xRight: int, yBottom: int });
FN('SetRectEmpty', BOOL, { lprc: LPRECT });
FN('CopyRect', BOOL, { lprcDst: LPRECT, lprcSrc: PTR(uint) });
FN('InflateRect', BOOL, { lprc: LPRECT, dx: int, dy: int });
FN('IntersectRect', BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) });
FN('UnionRect', BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) });
FN('SubtractRect', BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) });
FN('OffsetRect', BOOL, { lprc: LPRECT, dx: int, dy: int });
FN('IsRectEmpty', BOOL, { lprc: PTR(uint) });
FN('EqualRect', BOOL, { lprc1: PTR(uint), lprc2: PTR(uint) });
FN('PtInRect', BOOL, { lprc: PTR(uint), pt: POINT });
FN('GetWindowWord', WORD, { hWnd: HWND, nIndex: int });
FN('SetWindowWord', WORD, { hWnd: HWND, nIndex: int, wNewWord: WORD });
FN('GetWindowLongA', LONG, { hWnd: HWND, nIndex: int });
FN('GetWindowLongW', LONG, { hWnd: HWND, nIndex: int });
FN('SetWindowLongA', LONG, { hWnd: HWND, nIndex: int, dwNewLong: LONG });
FN('SetWindowLongW', LONG, { hWnd: HWND, nIndex: int, dwNewLong: LONG });
FN('GetClassWord', WORD, { hWnd: HWND, nIndex: int });
FN('SetClassWord', WORD, { hWnd: HWND, nIndex: int, wNewWord: WORD });
FN('GetClassLongA', DWORD, { hWnd: HWND, nIndex: int });
FN('GetClassLongW', DWORD, { hWnd: HWND, nIndex: int });
FN('SetClassLongA', DWORD, { hWnd: HWND, nIndex: int, dwNewLong: LONG });
FN('SetClassLongW', DWORD, { hWnd: HWND, nIndex: int, dwNewLong: LONG });
FN('GetProcessDefaultLayout', BOOL, { pdwDefaultLayout: PTR(ulong) });
FN('SetProcessDefaultLayout', BOOL, { dwDefaultLayout: DWORD });
FN('GetDesktopWindow', HWND, {  });
FN('GetParent', HWND, { hWnd: HWND });
FN('SetParent', HWND, { hWndChild: HWND, hWndNewParent: HWND });
FN('EnumChildWindows', BOOL, { hWndParent: HWND, lpEnumFunc: WNDENUMPROC, lParam: LPARAM });
FN('FindWindowA', HWND, { lpClassName: LPCSTR, lpWindowName: LPCSTR });
FN('FindWindowW', HWND, { lpClassName: LPCWSTR, lpWindowName: LPCWSTR });
FN('FindWindowExA', HWND, { hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCSTR, lpszWindow: LPCSTR });
FN('FindWindowExW', HWND, { hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCWSTR, lpszWindow: LPCWSTR });
FN('GetShellWindow', HWND, {  });
FN('RegisterShellHookWindow', BOOL, { hwnd: HWND });
FN('DeregisterShellHookWindow', BOOL, { hwnd: HWND });
FN('EnumWindows', BOOL, { lpEnumFunc: WNDENUMPROC, lParam: LPARAM });
FN('EnumThreadWindows', BOOL, { dwThreadId: DWORD, lpfn: WNDENUMPROC, lParam: LPARAM });
FN('GetClassNameA', 'void', { hWnd: HWND, lpClassName: LPSTR, nMaxCount: int });
FN('GetClassNameW', 'void', { hWnd: HWND, lpClassName: LPWSTR, nMaxCount: int });
FN('GetTopWindow', HWND, { hWnd: HWND });
FN('GetWindowThreadProcessId', DWORD, { hWnd: HWND, lpdwProcessId: LPDWORD });
FN('IsGUIThread', BOOL, { bConvert: BOOL });
FN('GetLastActivePopup', HWND, { hWnd: HWND });
FN('GetWindow', HWND, { hWnd: HWND, uCmd: UINT });
FN('SetWindowsHookA', HHOOK, { nFilterType: int, pfnFilterProc: HOOKPROC });
FN('SetWindowsHookW', HHOOK, { nFilterType: int, pfnFilterProc: HOOKPROC });
FN('UnhookWindowsHook', BOOL, { nCode: int, pfnFilterProc: HOOKPROC });
FN('SetWindowsHookExA', HHOOK, { idHook: int, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD });
FN('SetWindowsHookExW', HHOOK, { idHook: int, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD });
FN('UnhookWindowsHookEx', BOOL, { hhk: HHOOK });
FN('CallNextHookEx', LRESULT, { hhk: HHOOK, nCode: int, wParam: WPARAM, lParam: LPARAM });
FN('CheckMenuRadioItem', BOOL, { hmenu: HMENU, first: UINT, last: UINT, check: UINT, flags: UINT });
FN('LoadBitmapA', HBITMAP, { hInstance: HINSTANCE, lpBitmapName: LPCSTR });
FN('LoadBitmapW', HBITMAP, { hInstance: HINSTANCE, lpBitmapName: LPCWSTR });
FN('LoadCursorA', HCURSOR, { hInstance: HINSTANCE, lpCursorName: LPCSTR });
FN('LoadCursorW', HCURSOR, { hInstance: HINSTANCE, lpCursorName: LPCWSTR });
FN('LoadCursorFromFileA', HCURSOR, { lpFileName: LPCSTR });
FN('LoadCursorFromFileW', HCURSOR, { lpFileName: LPCWSTR });
FN('CreateCursor', HCURSOR, { hInst: HINSTANCE, xHotSpot: int, yHotSpot: int, nWidth: int, nHeight: int, pvANDPlane: PTR('void'), pvXORPlane: PTR('void') });
FN('DestroyCursor', BOOL, { hCursor: HCURSOR });
FN('SetSystemCursor', BOOL, { hcur: HCURSOR, id: DWORD });
FN('LoadIconA', HICON, { hInstance: HINSTANCE, lpIconName: LPCSTR });
FN('LoadIconW', HICON, { hInstance: HINSTANCE, lpIconName: LPCWSTR });
FN('PrivateExtractIconsA', UINT, { szFileName: LPCSTR, nIconIndex: int, cxIcon: int, cyIcon: int, phicon: PTR(pointer), piconid: PTR(uint), nIcons: UINT, flags: UINT });
FN('PrivateExtractIconsW', UINT, { szFileName: LPCWSTR, nIconIndex: int, cxIcon: int, cyIcon: int, phicon: PTR(pointer), piconid: PTR(uint), nIcons: UINT, flags: UINT });
FN('CreateIcon', HICON, { hInstance: HINSTANCE, nWidth: int, nHeight: int, cPlanes: BYTE, cBitsPixel: BYTE, lpbANDbits: PTR(uchar), lpbXORbits: PTR(uchar) });
FN('DestroyIcon', BOOL, { hIcon: HICON });
FN('LookupIconIdFromDirectory', 'void', { presbits: PBYTE, fIcon: BOOL });
FN('LookupIconIdFromDirectoryEx', 'void', { presbits: PBYTE, fIcon: BOOL, cxDesired: int, cyDesired: int, Flags: UINT });
FN('CreateIconFromResource', HICON, { presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD });
FN('CreateIconFromResourceEx', HICON, { presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD, cxDesired: int, cyDesired: int, Flags: UINT });
FN('LoadImageA', HANDLE, { hInst: HINSTANCE, name: LPCSTR, type: UINT, cx: int, cy: int, fuLoad: UINT });
FN('LoadImageW', HANDLE, { hInst: HINSTANCE, name: LPCWSTR, type: UINT, cx: int, cy: int, fuLoad: UINT });
FN('CopyImage', HANDLE, { h: HANDLE, type: UINT, cx: int, cy: int, flags: UINT });
FN('DrawIconEx', BOOL, { hdc: HDC, xLeft: int, yTop: int, hIcon: HICON, cxWidth: int, cyWidth: int, istepIfAniCur: UINT, hbrFlickerFreeDraw: HBRUSH, diFlags: UINT });
FN('CreateIconIndirect', HICON, { piconinfo: PICONINFO });
FN('CopyIcon', HICON, { hIcon: HICON });
FN('GetIconInfo', BOOL, { hIcon: HICON, piconinfo: PICONINFO });
FN('GetIconInfoExA', BOOL, { hicon: HICON, piconinfo: PICONINFOEXA });
FN('GetIconInfoExW', BOOL, { hicon: HICON, piconinfo: PICONINFOEXW });
FN('LoadStringA', 'void', { hInstance: HINSTANCE, uID: UINT, lpBuffer: LPSTR, cchBufferMax: int });
FN('LoadStringW', 'void', { hInstance: HINSTANCE, uID: UINT, lpBuffer: LPWSTR, cchBufferMax: int });
FN('IsDialogMessageA', BOOL, { hDlg: HWND, lpMsg: LPMSG });
FN('IsDialogMessageW', BOOL, { hDlg: HWND, lpMsg: LPMSG });
FN('MapDialogRect', BOOL, { hDlg: HWND, lpRect: LPRECT });
FN('DlgDirListA', 'void', { hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int, nIDStaticPath: int, uFileType: UINT });
FN('DlgDirListW', 'void', { hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int, nIDStaticPath: int, uFileType: UINT });
FN('DlgDirSelectExA', BOOL, { hwndDlg: HWND, lpString: LPSTR, chCount: int, idListBox: int });
FN('DlgDirSelectExW', BOOL, { hwndDlg: HWND, lpString: LPWSTR, chCount: int, idListBox: int });
FN('DlgDirListComboBoxA', 'void', { hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int, nIDStaticPath: int, uFiletype: UINT });
FN('DlgDirListComboBoxW', 'void', { hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int, nIDStaticPath: int, uFiletype: UINT });
FN('DlgDirSelectComboBoxExA', BOOL, { hwndDlg: HWND, lpString: LPSTR, cchOut: int, idComboBox: int });
FN('DlgDirSelectComboBoxExW', BOOL, { hwndDlg: HWND, lpString: LPWSTR, cchOut: int, idComboBox: int });
FN('SetScrollInfo', 'void', { hwnd: HWND, nBar: int, lpsi: LPCSCROLLINFO, redraw: BOOL });
FN('GetScrollInfo', BOOL, { hwnd: HWND, nBar: int, lpsi: LPSCROLLINFO });
FN('DefFrameProcA', LRESULT, { hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('DefFrameProcW', LRESULT, { hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('DefMDIChildProcA', LRESULT, { hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('DefMDIChildProcW', LRESULT, { hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM });
FN('TranslateMDISysAccel', BOOL, { hWndClient: HWND, lpMsg: LPMSG });
FN('ArrangeIconicWindows', UINT, { hWnd: HWND });
FN('CreateMDIWindowA', HWND, { lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM });
FN('CreateMDIWindowW', HWND, { lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM });
FN('TileWindows', WORD, { hwndParent: HWND, wHow: UINT, lpRect: PTR(uint), cKids: UINT, lpKids: PTR(pointer) });
FN('CascadeWindows', WORD, { hwndParent: HWND, wHow: UINT, lpRect: PTR(uint), cKids: UINT, lpKids: PTR(pointer) });
FN('WinHelpA', BOOL, { hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: ULONG_PTR });
FN('WinHelpW', BOOL, { hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: ULONG_PTR });
FN('GetGuiResources', DWORD, { hProcess: HANDLE, uiFlags: DWORD });
FN('ChangeDisplaySettingsA', LONG, { lpDevMode: PTR(uint), dwFlags: DWORD });
FN('ChangeDisplaySettingsW', LONG, { lpDevMode: PTR(uint), dwFlags: DWORD });
FN('ChangeDisplaySettingsExA', LONG, { lpszDeviceName: LPCSTR, lpDevMode: PTR(uint), hwnd: HWND, dwflags: DWORD, lParam: LPVOID });
FN('ChangeDisplaySettingsExW', LONG, { lpszDeviceName: LPCWSTR, lpDevMode: PTR(uint), hwnd: HWND, dwflags: DWORD, lParam: LPVOID });
FN('EnumDisplaySettingsA', BOOL, { lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: PTR(uint) });
FN('EnumDisplaySettingsW', BOOL, { lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: PTR(uint) });
FN('EnumDisplaySettingsExA', BOOL, { lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: PTR(uint), dwFlags: DWORD });
FN('EnumDisplaySettingsExW', BOOL, { lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: PTR(uint), dwFlags: DWORD });
FN('EnumDisplayDevicesA', BOOL, { lpDevice: LPCSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEA, dwFlags: DWORD });
FN('EnumDisplayDevicesW', BOOL, { lpDevice: LPCWSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEW, dwFlags: DWORD });
FN('GetDisplayConfigBufferSizes', LONG, { flags: UINT32, numPathArrayElements: PTR(uint), numModeInfoArrayElements: PTR(uint) });
FN('SetDisplayConfig', LONG, { numPathArrayElements: UINT32, pathArray: PTR(uint), numModeInfoArrayElements: UINT32, modeInfoArray: PTR(uint), flags: UINT32 });
FN('QueryDisplayConfig', LONG, { flags: UINT32, numPathArrayElements: PTR(uint), pathArray: PTR(uint), numModeInfoArrayElements: PTR(uint), modeInfoArray: PTR(uint), currentTopologyId: PTR(uint) });
FN('DisplayConfigGetDeviceInfo', LONG, { requestPacket: PTR(uint) });
FN('DisplayConfigSetDeviceInfo', LONG, { setPacket: PTR(uint) });
FN('SystemParametersInfoA', BOOL, { uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT });
FN('SystemParametersInfoW', BOOL, { uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT });
FN('SoundSentry', BOOL, {  });
FN('SetDebugErrorLevel', 'void', { dwLevel: DWORD });
FN('SetLastErrorEx', 'void', { dwErrCode: DWORD, dwType: DWORD });
FN('InternalGetWindowText', 'void', { hWnd: HWND, pString: LPWSTR, cchMaxCount: int });
FN('CancelShutdown', BOOL, {  });
FN('MonitorFromPoint', HMONITOR, { pt: POINT, dwFlags: DWORD });
FN('MonitorFromRect', HMONITOR, { lprc: LPCRECT, dwFlags: DWORD });
FN('MonitorFromWindow', HMONITOR, { hwnd: HWND, dwFlags: DWORD });
FN('GetMonitorInfoA', BOOL, { hMonitor: HMONITOR, lpmi: LPMONITORINFO });
FN('GetMonitorInfoW', BOOL, { hMonitor: HMONITOR, lpmi: LPMONITORINFO });
FN('EnumDisplayMonitors', BOOL, { hdc: HDC, lprcClip: LPCRECT, lpfnEnum: MONITORENUMPROC, dwData: LPARAM });
FN('NotifyWinEvent', 'void', { event: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG });
FN('SetWinEventHook', HWINEVENTHOOK, { eventMin: DWORD, eventMax: DWORD, hmodWinEventProc: HMODULE, pfnWinEventProc: WINEVENTPROC, idProcess: DWORD, idThread: DWORD, dwFlags: DWORD });
FN('IsWinEventHookInstalled', BOOL, { event: DWORD });
FN('UnhookWinEvent', BOOL, { hWinEventHook: HWINEVENTHOOK });
FN('GetGUIThreadInfo', BOOL, { idThread: DWORD, pgui: PGUITHREADINFO });
FN('BlockInput', BOOL, { fBlockIt: BOOL });
FN('SetProcessDPIAware', BOOL, {  });
FN('IsProcessDPIAware', BOOL, {  });
FN('GetWindowModuleFileNameA', UINT, { hwnd: HWND, pszFileName: LPSTR, cchFileNameMax: UINT });
FN('GetWindowModuleFileNameW', UINT, { hwnd: HWND, pszFileName: LPWSTR, cchFileNameMax: UINT });
FN('GetCursorInfo', BOOL, { pci: PCURSORINFO });
FN('GetWindowInfo', BOOL, { hwnd: HWND, pwi: PWINDOWINFO });
FN('GetTitleBarInfo', BOOL, { hwnd: HWND, pti: PTITLEBARINFO });
FN('GetMenuBarInfo', BOOL, { hwnd: HWND, idObject: LONG, idItem: LONG, pmbi: PMENUBARINFO });
FN('GetScrollBarInfo', BOOL, { hwnd: HWND, idObject: LONG, psbi: PSCROLLBARINFO });
FN('GetComboBoxInfo', BOOL, { hwndCombo: HWND, pcbi: PCOMBOBOXINFO });
FN('GetAncestor', HWND, { hwnd: HWND, gaFlags: UINT });
FN('RealChildWindowFromPoint', HWND, { hwndParent: HWND, ptParentClientCoords: POINT });
FN('RealGetWindowClassA', UINT, { hwnd: HWND, ptszClassName: LPSTR, cchClassNameMax: UINT });
FN('RealGetWindowClassW', UINT, { hwnd: HWND, ptszClassName: LPWSTR, cchClassNameMax: UINT });
FN('GetAltTabInfoA', BOOL, { hwnd: HWND, iItem: int, pati: PALTTABINFO, pszItemText: LPSTR, cchItemText: UINT });
FN('GetAltTabInfoW', BOOL, { hwnd: HWND, iItem: int, pati: PALTTABINFO, pszItemText: LPWSTR, cchItemText: UINT });
FN('GetListBoxInfo', DWORD, { hwnd: HWND });
FN('LockWorkStation', BOOL, {  });
FN('UserHandleGrantAccess', BOOL, { hUserHandle: HANDLE, hJob: HANDLE, bGrant: BOOL });
FN('GetRawInputData', UINT, { hRawInput: HRAWINPUT, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT, cbSizeHeader: UINT });
FN('GetRawInputDeviceInfoA', UINT, { hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT });
FN('GetRawInputDeviceInfoW', UINT, { hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT });
FN('GetRawInputBuffer', UINT, { pData: PRAWINPUT, pcbSize: PUINT, cbSizeHeader: UINT });
FN('RegisterRawInputDevices', BOOL, { pRawInputDevices: PCRAWINPUTDEVICE, uiNumDevices: UINT, cbSize: UINT });
FN('GetRegisteredRawInputDevices', UINT, { pRawInputDevices: PRAWINPUTDEVICE, puiNumDevices: PUINT, cbSize: UINT });
FN('GetRawInputDeviceList', UINT, { pRawInputDeviceList: PRAWINPUTDEVICELIST, puiNumDevices: PUINT, cbSize: UINT });
FN('DefRawInputProc', LRESULT, { paRawInput: PTR(pointer), nInput: INT, cbSizeHeader: UINT });
FN('ChangeWindowMessageFilter', BOOL, { message: UINT, dwFlag: DWORD });
FN('ChangeWindowMessageFilterEx', BOOL, { hwnd: HWND, message: UINT, action: DWORD, pChangeFilterStruct: PCHANGEFILTERSTRUCT });
FN('GetGestureInfo', BOOL, { hGestureInfo: HGESTUREINFO, pGestureInfo: PGESTUREINFO });
FN('GetGestureExtraArgs', BOOL, { hGestureInfo: HGESTUREINFO, cbExtraArgs: UINT, pExtraArgs: PBYTE });
FN('CloseGestureInfoHandle', BOOL, { hGestureInfo: HGESTUREINFO });
FN('SetGestureConfig', BOOL, { hwnd: HWND, dwReserved: DWORD, cIDs: UINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT });
FN('GetGestureConfig', BOOL, { hwnd: HWND, dwReserved: DWORD, dwFlags: DWORD, pcIDs: PUINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT });
FN('ShutdownBlockReasonCreate', BOOL, { hWnd: HWND, pwszReason: LPCWSTR });
FN('ShutdownBlockReasonQuery', BOOL, { hWnd: HWND, pwszBuff: LPWSTR, pcchBuff: PTR(ulong) });
FN('ShutdownBlockReasonDestroy', BOOL, { hWnd: HWND });
FN('IsValidCodePage', BOOL, { CodePage: UINT });
FN('GetACP', UINT, {  });
FN('GetOEMCP', UINT, {  });
FN('GetCPInfo', BOOL, { CodePage: UINT, lpCPInfo: LPCPINFO });
FN('GetCPInfoExA', BOOL, { CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA });
FN('GetCPInfoExW', BOOL, { CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW });
FN('IsDBCSLeadByte', BOOL, { TestChar: BYTE });
FN('IsDBCSLeadByteEx', BOOL, { CodePage: UINT, TestChar: BYTE });
FN('MultiByteToWideChar', 'void', { CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCSTR, cbMultiByte: int, lpWideCharStr: LPWSTR, cchWideChar: int });
FN('WideCharToMultiByte', 'void', { CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: int, lpMultiByteStr: LPSTR, cbMultiByte: int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL });
FN('CompareStringA', 'void', { Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: int, lpString2: PCNZCH, cchCount2: int });
FN('CompareStringW', 'void', { Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: int, lpString2: PCNZWCH, cchCount2: int });
FN('FindNLSString', 'void', { Locale: LCID, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, pcchFound: LPINT });
FN('FindStringOrdinal', 'void', { dwFindStringOrdinalFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, bIgnoreCase: BOOL });
FN('LCMapStringA', 'void', { Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpDestStr: LPSTR, cchDest: int });
FN('LCMapStringW', 'void', { Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int });
FN('GetLocaleInfoA', 'void', { Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: int });
FN('GetLocaleInfoW', 'void', { Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int });
FN('SetLocaleInfoA', BOOL, { Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR });
FN('SetLocaleInfoW', BOOL, { Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR });
FN('GetCalendarInfoA', 'void', { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: int, lpValue: LPDWORD });
FN('GetCalendarInfoW', 'void', { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int, lpValue: LPDWORD });
FN('SetCalendarInfoA', BOOL, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR });
FN('SetCalendarInfoW', BOOL, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR });
FN('LCIDToLocaleName', 'void', { Locale: LCID, lpName: LPWSTR, cchName: int, dwFlags: DWORD });
FN('LocaleNameToLCID', LCID, { lpName: LPCWSTR, dwFlags: DWORD });
FN('GetTimeFormatA', 'void', { Locale: LCID, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int });
FN('GetTimeFormatW', 'void', { Locale: LCID, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int });
FN('GetDurationFormat', 'void', { Locale: LCID, dwFlags: DWORD, lpDuration: PTR(uint), ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int });
FN('GetDateFormatA', 'void', { Locale: LCID, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int });
FN('GetDateFormatW', 'void', { Locale: LCID, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int });
FN('GetNumberFormatA', 'void', { Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: PTR(uint), lpNumberStr: LPSTR, cchNumber: int });
FN('GetNumberFormatW', 'void', { Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpNumberStr: LPWSTR, cchNumber: int });
FN('GetCurrencyFormatA', 'void', { Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: PTR(uint), lpCurrencyStr: LPSTR, cchCurrency: int });
FN('GetCurrencyFormatW', 'void', { Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpCurrencyStr: LPWSTR, cchCurrency: int });
FN('EnumCalendarInfoA', BOOL, { lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE });
FN('EnumCalendarInfoW', BOOL, { lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE });
FN('EnumCalendarInfoExA', BOOL, { lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE });
FN('EnumCalendarInfoExW', BOOL, { lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE });
FN('EnumTimeFormatsA', BOOL, { lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD });
FN('EnumTimeFormatsW', BOOL, { lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD });
FN('EnumDateFormatsA', BOOL, { lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD });
FN('EnumDateFormatsW', BOOL, { lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD });
FN('EnumDateFormatsExA', BOOL, { lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD });
FN('EnumDateFormatsExW', BOOL, { lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD });
FN('IsValidLanguageGroup', BOOL, { LanguageGroup: LGRPID, dwFlags: DWORD });
FN('GetNLSVersion', BOOL, { Function: NLS_FUNCTION, Locale: LCID, lpVersionInformation: LPNLSVERSIONINFO });
FN('IsNLSDefinedString', BOOL, { Function: NLS_FUNCTION, dwFlags: DWORD, lpVersionInformation: LPNLSVERSIONINFO, lpString: LPCWSTR, cchStr: INT });
FN('IsValidLocale', BOOL, { Locale: LCID, dwFlags: DWORD });
FN('GetGeoInfoA', 'void', { Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: int, LangId: LANGID });
FN('GetGeoInfoW', 'void', { Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: int, LangId: LANGID });
FN('EnumSystemGeoID', BOOL, { GeoClass: GEOCLASS, ParentGeoId: GEOID, lpGeoEnumProc: GEO_ENUMPROC });
FN('GetUserGeoID', GEOID, { GeoClass: GEOCLASS });
FN('SetUserGeoID', BOOL, { GeoId: GEOID });
FN('ConvertDefaultLocale', LCID, { Locale: LCID });
FN('GetThreadLocale', LCID, {  });
FN('SetThreadLocale', BOOL, { Locale: LCID });
FN('GetSystemDefaultUILanguage', LANGID, {  });
FN('GetUserDefaultUILanguage', LANGID, {  });
FN('GetSystemDefaultLangID', LANGID, {  });
FN('GetUserDefaultLangID', LANGID, {  });
FN('GetSystemDefaultLCID', LCID, {  });
FN('GetUserDefaultLCID', LCID, {  });
FN('SetThreadUILanguage', LANGID, { LangId: LANGID });
FN('GetThreadUILanguage', LANGID, {  });
FN('GetProcessPreferredUILanguages', BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG });
FN('SetProcessPreferredUILanguages', BOOL, { dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG });
FN('GetUserPreferredUILanguages', BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG });
FN('GetSystemPreferredUILanguages', BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG });
FN('GetThreadPreferredUILanguages', BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG });
FN('SetThreadPreferredUILanguages', BOOL, { dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG });
FN('GetFileMUIInfo', BOOL, { dwFlags: DWORD, pcwszFilePath: PCWSTR, pFileMUIInfo: PFILEMUIINFO, pcbFileMUIInfo: PTR(ulong) });
FN('GetFileMUIPath', BOOL, { dwFlags: DWORD, pcwszFilePath: PCWSTR, pwszLanguage: PWSTR, pcchLanguage: PULONG, pwszFileMUIPath: PWSTR, pcchFileMUIPath: PULONG, pululEnumerator: PULONGLONG });
FN('GetUILanguageInfo', BOOL, { dwFlags: DWORD, pwmszLanguage: PCZZWSTR, pwszFallbackLanguages: PZZWSTR, pcchFallbackLanguages: PDWORD, pAttributes: PDWORD });
FN('NotifyUILanguageChange', BOOL, { dwFlags: DWORD, pcwstrNewLanguage: PCWSTR, pcwstrPreviousLanguage: PCWSTR, dwReserved: DWORD, pdwStatusRtrn: PDWORD });
FN('GetStringTypeExA', BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpCharType: LPWORD });
FN('GetStringTypeExW', BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpCharType: LPWORD });
FN('GetStringTypeA', BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpCharType: LPWORD });
FN('GetStringTypeW', BOOL, { dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpCharType: LPWORD });
FN('FoldStringA', 'void', { dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpDestStr: LPSTR, cchDest: int });
FN('FoldStringW', 'void', { dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int });
FN('EnumSystemLanguageGroupsA', BOOL, { lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumSystemLanguageGroupsW', BOOL, { lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumLanguageGroupLocalesA', BOOL, { lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumLanguageGroupLocalesW', BOOL, { lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumUILanguagesA', BOOL, { lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumUILanguagesW', BOOL, { lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR });
FN('EnumSystemLocalesA', BOOL, { lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD });
FN('EnumSystemLocalesW', BOOL, { lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD });
FN('EnumSystemCodePagesA', BOOL, { lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD });
FN('EnumSystemCodePagesW', BOOL, { lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD });
FN('NormalizeString', 'void', { NormForm: NORM_FORM, lpSrcString: LPCWSTR, cwSrcLength: int, lpDstString: LPWSTR, cwDstLength: int });
FN('IsNormalizedString', BOOL, { NormForm: NORM_FORM, lpString: LPCWSTR, cwLength: int });
FN('IdnToAscii', 'void', { dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int, lpASCIICharStr: LPWSTR, cchASCIIChar: int });
FN('IdnToNameprepUnicode', 'void', { dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int, lpNameprepCharStr: LPWSTR, cchNameprepChar: int });
FN('IdnToUnicode', 'void', { dwFlags: DWORD, lpASCIICharStr: LPCWSTR, cchASCIIChar: int, lpUnicodeCharStr: LPWSTR, cchUnicodeChar: int });
FN('VerifyScripts', BOOL, { dwFlags: DWORD, lpLocaleScripts: LPCWSTR, cchLocaleScripts: int, lpTestScripts: LPCWSTR, cchTestScripts: int });
FN('GetStringScripts', 'void', { dwFlags: DWORD, lpString: LPCWSTR, cchString: int, lpScripts: LPWSTR, cchScripts: int });
FN('GetLocaleInfoEx', 'void', { lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int });
FN('GetCalendarInfoEx', 'void', { lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int, lpValue: LPDWORD });
FN('GetTimeFormatEx', 'void', { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int });
FN('GetDateFormatEx', 'void', { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int, lpCalendar: LPCWSTR });
FN('GetDurationFormatEx', 'void', { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDuration: PTR(uint), ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int });
FN('GetNumberFormatEx', 'void', { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpNumberStr: LPWSTR, cchNumber: int });
FN('GetCurrencyFormatEx', 'void', { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpCurrencyStr: LPWSTR, cchCurrency: int });
FN('GetUserDefaultLocaleName', 'void', { lpLocaleName: LPWSTR, cchLocaleName: int });
FN('GetSystemDefaultLocaleName', 'void', { lpLocaleName: LPWSTR, cchLocaleName: int });
FN('GetNLSVersionEx', BOOL, { function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX });
FN('CompareStringEx', 'void', { lpLocaleName: LPCWSTR, dwCmpFlags: DWORD, lpString1: LPCWSTR, cchCount1: int, lpString2: LPCWSTR, cchCount2: int, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM });
FN('FindNLSStringEx', 'void', { lpLocaleName: LPCWSTR, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, pcchFound: LPINT, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM });
FN('LCMapStringEx', 'void', { lpLocaleName: LPCWSTR, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM });
FN('CompareStringOrdinal', 'void', { lpString1: LPCWSTR, cchCount1: int, lpString2: LPCWSTR, cchCount2: int, bIgnoreCase: BOOL });
FN('IsValidLocaleName', BOOL, { lpLocaleName: LPCWSTR });
FN('EnumCalendarInfoExEx', BOOL, { pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX, lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lParam: LPARAM });
FN('EnumDateFormatsExEx', BOOL, { lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM });
FN('EnumTimeFormatsEx', BOOL, { lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM });
FN('EnumSystemLocalesEx', BOOL, { lpLocaleEnumProcEx: LOCALE_ENUMPROCEX, dwFlags: DWORD, lParam: LPARAM, lpReserved: LPVOID });
FN('ResolveLocaleName', 'void', { lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: int });
FN('PeekConsoleInputA', BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD });
FN('PeekConsoleInputW', BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD });
FN('ReadConsoleInputA', BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD });
FN('ReadConsoleInputW', BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD });
FN('WriteConsoleInputA', BOOL, { hConsoleInput: HANDLE, lpBuffer: PTR(uint), nLength: DWORD, lpNumberOfEventsWritten: LPDWORD });
FN('WriteConsoleInputW', BOOL, { hConsoleInput: HANDLE, lpBuffer: PTR(uint), nLength: DWORD, lpNumberOfEventsWritten: LPDWORD });
FN('ReadConsoleOutputA', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT });
FN('ReadConsoleOutputW', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT });
FN('WriteConsoleOutputA', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(uint), dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT });
FN('WriteConsoleOutputW', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(uint), dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT });
FN('ReadConsoleOutputCharacterA', BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD });
FN('ReadConsoleOutputCharacterW', BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD });
FN('ReadConsoleOutputAttribute', BOOL, { hConsoleOutput: HANDLE, lpAttribute: LPWORD, nLength: DWORD, dwReadCoord: COORD, lpNumberOfAttrsRead: LPDWORD });
FN('WriteConsoleOutputCharacterA', BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD });
FN('WriteConsoleOutputCharacterW', BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD });
FN('WriteConsoleOutputAttribute', BOOL, { hConsoleOutput: HANDLE, lpAttribute: PTR(ushort), nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD });
FN('FillConsoleOutputCharacterA', BOOL, { hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD });
FN('FillConsoleOutputCharacterW', BOOL, { hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD });
FN('FillConsoleOutputAttribute', BOOL, { hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD });
FN('GetConsoleMode', BOOL, { hConsoleHandle: HANDLE, lpMode: LPDWORD });
FN('GetNumberOfConsoleInputEvents', BOOL, { hConsoleInput: HANDLE, lpNumberOfEvents: LPDWORD });
FN('GetConsoleScreenBufferInfo', BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO });
FN('GetConsoleScreenBufferInfoEx', BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX });
FN('SetConsoleScreenBufferInfoEx', BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX });
FN('GetLargestConsoleWindowSize', COORD, { hConsoleOutput: HANDLE });
FN('GetConsoleCursorInfo', BOOL, { hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO });
FN('GetCurrentConsoleFont', BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFont: PCONSOLE_FONT_INFO });
FN('GetCurrentConsoleFontEx', BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX });
FN('SetCurrentConsoleFontEx', BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX });
FN('GetConsoleHistoryInfo', BOOL, { lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO });
FN('SetConsoleHistoryInfo', BOOL, { lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO });
FN('GetConsoleFontSize', COORD, { hConsoleOutput: HANDLE, nFont: DWORD });
FN('GetConsoleSelectionInfo', BOOL, { lpConsoleSelectionInfo: PCONSOLE_SELECTION_INFO });
FN('GetNumberOfConsoleMouseButtons', BOOL, { lpNumberOfMouseButtons: LPDWORD });
FN('SetConsoleMode', BOOL, { hConsoleHandle: HANDLE, dwMode: DWORD });
FN('SetConsoleActiveScreenBuffer', BOOL, { hConsoleOutput: HANDLE });
FN('FlushConsoleInputBuffer', BOOL, { hConsoleInput: HANDLE });
FN('SetConsoleScreenBufferSize', BOOL, { hConsoleOutput: HANDLE, dwSize: COORD });
FN('SetConsoleCursorPosition', BOOL, { hConsoleOutput: HANDLE, dwCursorPosition: COORD });
FN('SetConsoleCursorInfo', BOOL, { hConsoleOutput: HANDLE, lpConsoleCursorInfo: PTR(uint) });
FN('ScrollConsoleScreenBufferA', BOOL, { hConsoleOutput: HANDLE, lpScrollRectangle: PTR(uint), lpClipRectangle: PTR(uint), dwDestinationOrigin: COORD, lpFill: PTR(uint) });
FN('ScrollConsoleScreenBufferW', BOOL, { hConsoleOutput: HANDLE, lpScrollRectangle: PTR(uint), lpClipRectangle: PTR(uint), dwDestinationOrigin: COORD, lpFill: PTR(uint) });
FN('SetConsoleWindowInfo', BOOL, { hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: PTR(uint) });
FN('SetConsoleTextAttribute', BOOL, { hConsoleOutput: HANDLE, wAttributes: WORD });
FN('SetConsoleCtrlHandler', BOOL, { HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL });
FN('GenerateConsoleCtrlEvent', BOOL, { dwCtrlEvent: DWORD, dwProcessGroupId: DWORD });
FN('AllocConsole', BOOL, {  });
FN('FreeConsole', BOOL, {  });
FN('AttachConsole', BOOL, { dwProcessId: DWORD });
FN('GetConsoleTitleA', DWORD, { lpConsoleTitle: LPSTR, nSize: DWORD });
FN('GetConsoleTitleW', DWORD, { lpConsoleTitle: LPWSTR, nSize: DWORD });
FN('GetConsoleOriginalTitleA', DWORD, { lpConsoleTitle: LPSTR, nSize: DWORD });
FN('GetConsoleOriginalTitleW', DWORD, { lpConsoleTitle: LPWSTR, nSize: DWORD });
FN('SetConsoleTitleA', BOOL, { lpConsoleTitle: LPCSTR });
FN('SetConsoleTitleW', BOOL, { lpConsoleTitle: LPCWSTR });
FN('ReadConsoleA', BOOL, { hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL });
FN('ReadConsoleW', BOOL, { hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL });
FN('WriteConsoleA', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR('void'), nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID });
FN('WriteConsoleW', BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR('void'), nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID });
FN('CreateConsoleScreenBuffer', HANDLE, { dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: PTR(uint), dwFlags: DWORD, lpScreenBufferData: LPVOID });
FN('GetConsoleCP', UINT, {  });
FN('SetConsoleCP', BOOL, { wCodePageID: UINT });
FN('GetConsoleOutputCP', UINT, {  });
FN('SetConsoleOutputCP', BOOL, { wCodePageID: UINT });
FN('GetConsoleDisplayMode', BOOL, { lpModeFlags: LPDWORD });
FN('SetConsoleDisplayMode', BOOL, { hConsoleOutput: HANDLE, dwFlags: DWORD, lpNewScreenBufferDimensions: PCOORD });
FN('GetConsoleWindow', HWND, {  });
FN('GetConsoleProcessList', DWORD, { lpdwProcessList: LPDWORD, dwProcessCount: DWORD });
FN('AddConsoleAliasA', BOOL, { Source: LPSTR, Target: LPSTR, ExeName: LPSTR });
FN('AddConsoleAliasW', BOOL, { Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR });
FN('GetConsoleAliasA', DWORD, { Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR });
FN('GetConsoleAliasW', DWORD, { Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR });
FN('GetConsoleAliasesLengthA', DWORD, { ExeName: LPSTR });
FN('GetConsoleAliasesLengthW', DWORD, { ExeName: LPWSTR });
FN('GetConsoleAliasExesLengthA', DWORD, {  });
FN('GetConsoleAliasExesLengthW', DWORD, {  });
FN('GetConsoleAliasesA', DWORD, { AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR });
FN('GetConsoleAliasesW', DWORD, { AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR });
FN('GetConsoleAliasExesA', DWORD, { ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD });
FN('GetConsoleAliasExesW', DWORD, { ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD });
FN('VerFindFileA', DWORD, { uFlags: DWORD, szFileName: LPCSTR, szWinDir: LPCSTR, szAppDir: LPCSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT, szDestDir: LPSTR, lpuDestDirLen: PUINT });
FN('VerFindFileW', DWORD, { uFlags: DWORD, szFileName: LPCWSTR, szWinDir: LPCWSTR, szAppDir: LPCWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT, szDestDir: LPWSTR, lpuDestDirLen: PUINT });
FN('VerInstallFileA', DWORD, { uFlags: DWORD, szSrcFileName: LPCSTR, szDestFileName: LPCSTR, szSrcDir: LPCSTR, szDestDir: LPCSTR, szCurDir: LPCSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT });
FN('VerInstallFileW', DWORD, { uFlags: DWORD, szSrcFileName: LPCWSTR, szDestFileName: LPCWSTR, szSrcDir: LPCWSTR, szDestDir: LPCWSTR, szCurDir: LPCWSTR, szTmpFile: LPWSTR, lpuTmpFileLen: PUINT });
FN('GetFileVersionInfoSizeA', DWORD, { lptstrFilename: LPCSTR, lpdwHandle: LPDWORD });
FN('GetFileVersionInfoSizeW', DWORD, { lptstrFilename: LPCWSTR, lpdwHandle: LPDWORD });
FN('GetFileVersionInfoA', BOOL, { lptstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID });
FN('GetFileVersionInfoW', BOOL, { lptstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID });
FN('GetFileVersionInfoSizeExA', DWORD, { dwFlags: DWORD, lpwstrFilename: LPCSTR, lpdwHandle: LPDWORD });
FN('GetFileVersionInfoSizeExW', DWORD, { dwFlags: DWORD, lpwstrFilename: LPCWSTR, lpdwHandle: LPDWORD });
FN('GetFileVersionInfoExA', BOOL, { dwFlags: DWORD, lpwstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID });
FN('GetFileVersionInfoExW', BOOL, { dwFlags: DWORD, lpwstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID });
FN('VerLanguageNameA', DWORD, { wLang: DWORD, szLang: LPSTR, cchLang: DWORD });
FN('VerLanguageNameW', DWORD, { wLang: DWORD, szLang: LPWSTR, cchLang: DWORD });
FN('VerQueryValueA', BOOL, { pBlock: LPCVOID, lpSubBlock: LPCSTR, lplpBuffer: PTR(PTR('void')), puLen: PUINT });
FN('VerQueryValueW', BOOL, { pBlock: LPCVOID, lpSubBlock: LPCWSTR, lplpBuffer: PTR(PTR('void')), puLen: PUINT });
FN('RegCloseKey', LSTATUS, { hKey: HKEY });
FN('RegOverridePredefKey', LSTATUS, { hKey: HKEY, hNewHKey: HKEY });
FN('RegOpenUserClassesRoot', LSTATUS, { hToken: HANDLE, dwOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY });
FN('RegOpenCurrentUser', LSTATUS, { samDesired: REGSAM, phkResult: PHKEY });
FN('RegDisablePredefinedCache', LSTATUS, {  });
FN('RegDisablePredefinedCacheEx', LSTATUS, {  });
FN('RegConnectRegistryA', LSTATUS, { lpMachineName: LPCSTR, hKey: HKEY, phkResult: PHKEY });
FN('RegConnectRegistryW', LSTATUS, { lpMachineName: LPCWSTR, hKey: HKEY, phkResult: PHKEY });
FN('RegConnectRegistryExA', LSTATUS, { lpMachineName: LPCSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY });
FN('RegConnectRegistryExW', LSTATUS, { lpMachineName: LPCWSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY });
FN('RegCreateKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY });
FN('RegCreateKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY });
FN('RegCreateKeyExA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD });
FN('RegCreateKeyExW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD });
FN('RegCreateKeyTransactedA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID });
FN('RegCreateKeyTransactedW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD, hTransaction: HANDLE, pExtendedParemeter: PVOID });
FN('RegDeleteKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR });
FN('RegDeleteKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR });
FN('RegDeleteKeyExA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD });
FN('RegDeleteKeyExW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD });
FN('RegDeleteKeyTransactedA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID });
FN('RegDeleteKeyTransactedW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID });
FN('RegDisableReflectionKey', LONG, { hBase: HKEY });
FN('RegEnableReflectionKey', LONG, { hBase: HKEY });
FN('RegQueryReflectionKey', LONG, { hBase: HKEY, bIsReflectionDisabled: PTR(int) });
FN('RegDeleteValueA', LSTATUS, { hKey: HKEY, lpValueName: LPCSTR });
FN('RegDeleteValueW', LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR });
FN('RegEnumKeyA', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, cchName: DWORD });
FN('RegEnumKeyW', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, cchName: DWORD });
FN('RegEnumKeyExA', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME });
FN('RegEnumKeyExW', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME });
FN('RegEnumValueA', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpValueName: LPSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD });
FN('RegEnumValueW', LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpValueName: LPWSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD });
FN('RegFlushKey', LSTATUS, { hKey: HKEY });
FN('RegGetKeySecurity', LSTATUS, { hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD });
FN('RegLoadKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR });
FN('RegLoadKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR });
FN('RegNotifyChangeKeyValue', LSTATUS, { hKey: HKEY, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, hEvent: HANDLE, fAsynchronous: BOOL });
FN('RegOpenKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY });
FN('RegOpenKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY });
FN('RegOpenKeyExA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY });
FN('RegOpenKeyExW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY });
FN('RegOpenKeyTransactedA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParemeter: PVOID });
FN('RegOpenKeyTransactedW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParemeter: PVOID });
FN('RegQueryInfoKeyA', LSTATUS, { hKey: HKEY, lpClass: LPSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME });
FN('RegQueryInfoKeyW', LSTATUS, { hKey: HKEY, lpClass: LPWSTR, lpcchClass: LPDWORD, lpReserved: LPDWORD, lpcSubKeys: LPDWORD, lpcbMaxSubKeyLen: LPDWORD, lpcbMaxClassLen: LPDWORD, lpcValues: LPDWORD, lpcbMaxValueNameLen: LPDWORD, lpcbMaxValueLen: LPDWORD, lpcbSecurityDescriptor: LPDWORD, lpftLastWriteTime: PFILETIME });
FN('RegQueryValueA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpData: LPSTR, lpcbData: PLONG });
FN('RegQueryValueW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpData: LPWSTR, lpcbData: PLONG });
FN('RegQueryMultipleValuesA', LSTATUS, { hKey: HKEY, val_list: PVALENTA, num_vals: DWORD, lpValueBuf: LPSTR, ldwTotsize: LPDWORD });
FN('RegQueryMultipleValuesW', LSTATUS, { hKey: HKEY, val_list: PVALENTW, num_vals: DWORD, lpValueBuf: LPWSTR, ldwTotsize: LPDWORD });
FN('RegQueryValueExA', LSTATUS, { hKey: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD });
FN('RegQueryValueExW', LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD });
FN('RegReplaceKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR, lpOldFile: LPCSTR });
FN('RegReplaceKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR, lpOldFile: LPCWSTR });
FN('RegRestoreKeyA', LSTATUS, { hKey: HKEY, lpFile: LPCSTR, dwFlags: DWORD });
FN('RegRestoreKeyW', LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, dwFlags: DWORD });
FN('RegRenameKey', LSTATUS, { hKey: HKEY, lpSubKeyName: LPCWSTR, lpNewKeyName: LPCWSTR });
FN('RegSaveKeyA', LSTATUS, { hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('RegSaveKeyW', LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('RegSetKeySecurity', LSTATUS, { hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR });
FN('RegSetValueA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR, cbData: DWORD });
FN('RegSetValueW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, dwType: DWORD, lpData: LPCWSTR, cbData: DWORD });
FN('RegSetValueExA', LSTATUS, { hKey: HKEY, lpValueName: LPCSTR, Reserved: DWORD, dwType: DWORD, lpData: PTR(uchar), cbData: DWORD });
FN('RegSetValueExW', LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR, Reserved: DWORD, dwType: DWORD, lpData: PTR(uchar), cbData: DWORD });
FN('RegUnLoadKeyA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR });
FN('RegUnLoadKeyW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR });
FN('RegDeleteKeyValueA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR });
FN('RegDeleteKeyValueW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR });
FN('RegSetKeyValueA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD });
FN('RegSetKeyValueW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD });
FN('RegDeleteTreeA', LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR });
FN('RegDeleteTreeW', LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR });
FN('RegCopyTreeA', LSTATUS, { hKeySrc: HKEY, lpSubKey: LPCSTR, hKeyDest: HKEY });
FN('RegCopyTreeW', LSTATUS, { hKeySrc: HKEY, lpSubKey: LPCWSTR, hKeyDest: HKEY });
FN('RegGetValueA', LSTATUS, { hkey: HKEY, lpSubKey: LPCSTR, lpValue: LPCSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD });
FN('RegGetValueW', LSTATUS, { hkey: HKEY, lpSubKey: LPCWSTR, lpValue: LPCWSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD });
FN('RegLoadMUIStringA', LSTATUS, { hKey: HKEY, pszValue: LPCSTR, pszOutBuf: LPSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCSTR });
FN('RegLoadMUIStringW', LSTATUS, { hKey: HKEY, pszValue: LPCWSTR, pszOutBuf: LPWSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCWSTR });
FN('RegLoadAppKeyA', LSTATUS, { lpFile: LPCSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD });
FN('RegLoadAppKeyW', LSTATUS, { lpFile: LPCWSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD });
FN('InitiateSystemShutdownA', BOOL, { lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL });
FN('InitiateSystemShutdownW', BOOL, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL });
FN('AbortSystemShutdownA', BOOL, { lpMachineName: LPSTR });
FN('AbortSystemShutdownW', BOOL, { lpMachineName: LPWSTR });
FN('InitiateSystemShutdownExA', BOOL, { lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL, dwReason: DWORD });
FN('InitiateSystemShutdownExW', BOOL, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL, dwReason: DWORD });
FN('InitiateShutdownA', DWORD, { lpMachineName: LPSTR, lpMessage: LPSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD });
FN('InitiateShutdownW', DWORD, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD });
FN('RegSaveKeyExA', LSTATUS, { hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD });
FN('RegSaveKeyExW', LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD });
FN('WNetAddConnectionA', DWORD, { lpRemoteName: LPCSTR, lpPassword: LPCSTR, lpLocalName: LPCSTR });
FN('WNetAddConnectionW', DWORD, { lpRemoteName: LPCWSTR, lpPassword: LPCWSTR, lpLocalName: LPCWSTR });
FN('WNetAddConnection2A', DWORD, { lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD });
FN('WNetAddConnection2W', DWORD, { lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD });
FN('WNetAddConnection3A', DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD });
FN('WNetAddConnection3W', DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD });
FN('WNetCancelConnectionA', DWORD, { lpName: LPCSTR, fForce: BOOL });
FN('WNetCancelConnectionW', DWORD, { lpName: LPCWSTR, fForce: BOOL });
FN('WNetCancelConnection2A', DWORD, { lpName: LPCSTR, dwFlags: DWORD, fForce: BOOL });
FN('WNetCancelConnection2W', DWORD, { lpName: LPCWSTR, dwFlags: DWORD, fForce: BOOL });
FN('WNetGetConnectionA', DWORD, { lpLocalName: LPCSTR, lpRemoteName: LPSTR, lpnLength: LPDWORD });
FN('WNetGetConnectionW', DWORD, { lpLocalName: LPCWSTR, lpRemoteName: LPWSTR, lpnLength: LPDWORD });
FN('WNetRestoreSingleConnectionW', DWORD, { hwndParent: HWND, lpDevice: LPCWSTR, fUseUI: BOOL });
FN('WNetUseConnectionA', DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserId: LPCSTR, dwFlags: DWORD, lpAccessName: LPSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD });
FN('WNetUseConnectionW', DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserId: LPCWSTR, dwFlags: DWORD, lpAccessName: LPWSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD });
FN('WNetConnectionDialog', DWORD, { hwnd: HWND, dwType: DWORD });
FN('WNetDisconnectDialog', DWORD, { hwnd: HWND, dwType: DWORD });
FN('WNetConnectionDialog1A', DWORD, { lpConnDlgStruct: LPCONNECTDLGSTRUCTA });
FN('WNetConnectionDialog1W', DWORD, { lpConnDlgStruct: LPCONNECTDLGSTRUCTW });
FN('WNetDisconnectDialog1A', DWORD, { lpConnDlgStruct: LPDISCDLGSTRUCTA });
FN('WNetDisconnectDialog1W', DWORD, { lpConnDlgStruct: LPDISCDLGSTRUCTW });
FN('WNetOpenEnumA', DWORD, { dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEA, lphEnum: LPHANDLE });
FN('WNetOpenEnumW', DWORD, { dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEW, lphEnum: LPHANDLE });
FN('WNetEnumResourceA', DWORD, { hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD });
FN('WNetEnumResourceW', DWORD, { hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD });
FN('WNetCloseEnum', DWORD, { hEnum: HANDLE });
FN('WNetGetResourceParentA', DWORD, { lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD });
FN('WNetGetResourceParentW', DWORD, { lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD });
FN('WNetGetResourceInformationA', DWORD, { lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: PTR(PTR(int8)) });
FN('WNetGetResourceInformationW', DWORD, { lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: PTR(PTR(ushort)) });
FN('WNetGetUniversalNameA', DWORD, { lpLocalPath: LPCSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD });
FN('WNetGetUniversalNameW', DWORD, { lpLocalPath: LPCWSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD });
FN('WNetGetUserA', DWORD, { lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD });
FN('WNetGetUserW', DWORD, { lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD });
FN('WNetGetProviderNameA', DWORD, { dwNetType: DWORD, lpProviderName: LPSTR, lpBufferSize: LPDWORD });
FN('WNetGetProviderNameW', DWORD, { dwNetType: DWORD, lpProviderName: LPWSTR, lpBufferSize: LPDWORD });
FN('WNetGetNetworkInformationA', DWORD, { lpProvider: LPCSTR, lpNetInfoStruct: LPNETINFOSTRUCT });
FN('WNetGetNetworkInformationW', DWORD, { lpProvider: LPCWSTR, lpNetInfoStruct: LPNETINFOSTRUCT });
FN('WNetGetLastErrorA', DWORD, { lpError: LPDWORD, lpErrorBuf: LPSTR, nErrorBufSize: DWORD, lpNameBuf: LPSTR, nNameBufSize: DWORD });
FN('WNetGetLastErrorW', DWORD, { lpError: LPDWORD, lpErrorBuf: LPWSTR, nErrorBufSize: DWORD, lpNameBuf: LPWSTR, nNameBufSize: DWORD });
FN('MultinetGetConnectionPerformanceA', DWORD, { lpNetResource: LPNETRESOURCEA, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT });
FN('MultinetGetConnectionPerformanceW', DWORD, { lpNetResource: LPNETRESOURCEW, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT });
FN('DdeSetQualityOfService', BOOL, { hwndClient: HWND, pqosNew: PTR(uint), pqosPrev: PSECURITY_QUALITY_OF_SERVICE });
FN('ImpersonateDdeClientWindow', BOOL, { hWndClient: HWND, hWndServer: HWND });
FN('PackDDElParam', LPARAM, { msg: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR });
FN('UnpackDDElParam', BOOL, { msg: UINT, lParam: LPARAM, puiLo: PUINT_PTR, puiHi: PUINT_PTR });
FN('FreeDDElParam', BOOL, { msg: UINT, lParam: LPARAM });
FN('ReuseDDElParam', LPARAM, { lParam: LPARAM, msgIn: UINT, msgOut: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR });
FN('DdeInitializeA', UINT, { pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD });
FN('DdeInitializeW', UINT, { pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD });
FN('DdeUninitialize', BOOL, { idInst: DWORD });
FN('DdeConnectList', HCONVLIST, { idInst: DWORD, hszService: HSZ, hszTopic: HSZ, hConvList: HCONVLIST, pCC: PCONVCONTEXT });
FN('DdeQueryNextServer', HCONV, { hConvList: HCONVLIST, hConvPrev: HCONV });
FN('DdeDisconnectList', BOOL, { hConvList: HCONVLIST });
FN('DdeConnect', HCONV, { idInst: DWORD, hszService: HSZ, hszTopic: HSZ, pCC: PCONVCONTEXT });
FN('DdeDisconnect', BOOL, { hConv: HCONV });
FN('DdeReconnect', HCONV, { hConv: HCONV });
FN('DdeQueryConvInfo', UINT, { hConv: HCONV, idTransaction: DWORD, pConvInfo: PCONVINFO });
FN('DdeSetUserHandle', BOOL, { hConv: HCONV, id: DWORD, hUser: DWORD_PTR });
FN('DdeAbandonTransaction', BOOL, { idInst: DWORD, hConv: HCONV, idTransaction: DWORD });
FN('DdePostAdvise', BOOL, { idInst: DWORD, hszTopic: HSZ, hszItem: HSZ });
FN('DdeEnableCallback', BOOL, { idInst: DWORD, hConv: HCONV, wCmd: UINT });
FN('DdeImpersonateClient', BOOL, { hConv: HCONV });
FN('DdeNameService', HDDEDATA, { idInst: DWORD, hsz1: HSZ, hsz2: HSZ, afCmd: UINT });
FN('DdeClientTransaction', HDDEDATA, { pData: LPBYTE, cbData: DWORD, hConv: HCONV, hszItem: HSZ, wFmt: UINT, wType: UINT, dwTimeout: DWORD, pdwResult: LPDWORD });
FN('DdeCreateDataHandle', HDDEDATA, { idInst: DWORD, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD, hszItem: HSZ, wFmt: UINT, afCmd: UINT });
FN('DdeAddData', HDDEDATA, { hData: HDDEDATA, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD });
FN('DdeGetData', DWORD, { hData: HDDEDATA, pDst: LPBYTE, cbMax: DWORD, cbOff: DWORD });
FN('DdeAccessData', LPBYTE, { hData: HDDEDATA, pcbDataSize: LPDWORD });
FN('DdeUnaccessData', BOOL, { hData: HDDEDATA });
FN('DdeFreeDataHandle', BOOL, { hData: HDDEDATA });
FN('DdeGetLastError', UINT, { idInst: DWORD });
FN('DdeCreateStringHandleA', HSZ, { idInst: DWORD, psz: LPCSTR, iCodePage: int });
FN('DdeCreateStringHandleW', HSZ, { idInst: DWORD, psz: LPCWSTR, iCodePage: int });
FN('DdeQueryStringA', DWORD, { idInst: DWORD, hsz: HSZ, psz: LPSTR, cchMax: DWORD, iCodePage: int });
FN('DdeQueryStringW', DWORD, { idInst: DWORD, hsz: HSZ, psz: LPWSTR, cchMax: DWORD, iCodePage: int });
FN('DdeFreeStringHandle', BOOL, { idInst: DWORD, hsz: HSZ });
FN('DdeKeepStringHandle', BOOL, { idInst: DWORD, hsz: HSZ });
FN('DdeCmpStringHandles', 'void', { hsz1: HSZ, hsz2: HSZ });
FN('LZStart', INT, {  });
FN('LZDone', 'void', {  });
FN('CopyLZFile', LONG, { hfSource: INT, hfDest: INT });
FN('LZCopy', LONG, { hfSource: INT, hfDest: INT });
FN('LZInit', INT, { hfSource: INT });
FN('GetExpandedNameA', INT, { lpszSource: LPSTR, lpszBuffer: LPSTR });
FN('GetExpandedNameW', INT, { lpszSource: LPWSTR, lpszBuffer: LPWSTR });
FN('LZOpenFileA', INT, { lpFileName: LPSTR, lpReOpenBuf: LPOFSTRUCT, wStyle: WORD });
FN('LZOpenFileW', INT, { lpFileName: LPWSTR, lpReOpenBuf: LPOFSTRUCT, wStyle: WORD });
FN('LZSeek', LONG, { hFile: INT, lOffset: LONG, iOrigin: INT });
FN('LZRead', INT, { hFile: INT, lpBuffer: PTR(int8), cbRead: INT });
FN('LZClose', 'void', { hFile: INT });
FN('CloseDriver', LRESULT, { hDriver: HDRVR, lParam1: LPARAM, lParam2: LPARAM });
FN('OpenDriver', HDRVR, { szDriverName: LPCWSTR, szSectionName: LPCWSTR, lParam2: LPARAM });
FN('SendDriverMessage', LRESULT, { hDriver: HDRVR, message: UINT, lParam1: LPARAM, lParam2: LPARAM });
FN('DrvGetModuleHandle', HMODULE, { hDriver: HDRVR });
FN('GetDriverModuleHandle', HMODULE, { hDriver: HDRVR });
FN('DefDriverProc', LRESULT, { dwDriverIdentifier: DWORD_PTR, hdrvr: HDRVR, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM });
FN('sndPlaySoundA', BOOL, { pszSound: LPCSTR, fuSound: UINT });
FN('sndPlaySoundW', BOOL, { pszSound: LPCWSTR, fuSound: UINT });
FN('PlaySoundA', BOOL, { pszSound: LPCSTR, hmod: HMODULE, fdwSound: DWORD });
FN('PlaySoundW', BOOL, { pszSound: LPCWSTR, hmod: HMODULE, fdwSound: DWORD });
FN('waveOutGetNumDevs', UINT, {  });
FN('waveOutGetDevCapsA', MMRESULT, { uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSA, cbwoc: UINT });
FN('waveOutGetDevCapsW', MMRESULT, { uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSW, cbwoc: UINT });
FN('waveOutGetVolume', MMRESULT, { hwo: HWAVEOUT, pdwVolume: LPDWORD });
FN('waveOutSetVolume', MMRESULT, { hwo: HWAVEOUT, dwVolume: DWORD });
FN('waveOutGetErrorTextA', MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT });
FN('waveOutGetErrorTextW', MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT });
FN('waveOutOpen', MMRESULT, { phwo: LPHWAVEOUT, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('waveOutClose', MMRESULT, { hwo: HWAVEOUT });
FN('waveOutPrepareHeader', MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveOutUnprepareHeader', MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveOutWrite', MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveOutPause', MMRESULT, { hwo: HWAVEOUT });
FN('waveOutRestart', MMRESULT, { hwo: HWAVEOUT });
FN('waveOutReset', MMRESULT, { hwo: HWAVEOUT });
FN('waveOutBreakLoop', MMRESULT, { hwo: HWAVEOUT });
FN('waveOutGetPosition', MMRESULT, { hwo: HWAVEOUT, pmmt: LPMMTIME, cbmmt: UINT });
FN('waveOutGetPitch', MMRESULT, { hwo: HWAVEOUT, pdwPitch: LPDWORD });
FN('waveOutSetPitch', MMRESULT, { hwo: HWAVEOUT, dwPitch: DWORD });
FN('waveOutGetPlaybackRate', MMRESULT, { hwo: HWAVEOUT, pdwRate: LPDWORD });
FN('waveOutSetPlaybackRate', MMRESULT, { hwo: HWAVEOUT, dwRate: DWORD });
FN('waveOutGetID', MMRESULT, { hwo: HWAVEOUT, puDeviceID: LPUINT });
FN('waveOutMessage', MMRESULT, { hwo: HWAVEOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR });
FN('waveInGetNumDevs', UINT, {  });
FN('waveInGetDevCapsA', MMRESULT, { uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSA, cbwic: UINT });
FN('waveInGetDevCapsW', MMRESULT, { uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSW, cbwic: UINT });
FN('waveInGetErrorTextA', MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT });
FN('waveInGetErrorTextW', MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT });
FN('waveInOpen', MMRESULT, { phwi: LPHWAVEIN, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('waveInClose', MMRESULT, { hwi: HWAVEIN });
FN('waveInPrepareHeader', MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveInUnprepareHeader', MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveInAddBuffer', MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT });
FN('waveInStart', MMRESULT, { hwi: HWAVEIN });
FN('waveInStop', MMRESULT, { hwi: HWAVEIN });
FN('waveInReset', MMRESULT, { hwi: HWAVEIN });
FN('waveInGetPosition', MMRESULT, { hwi: HWAVEIN, pmmt: LPMMTIME, cbmmt: UINT });
FN('waveInGetID', MMRESULT, { hwi: HWAVEIN, puDeviceID: LPUINT });
FN('waveInMessage', MMRESULT, { hwi: HWAVEIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR });
FN('midiOutGetNumDevs', UINT, {  });
FN('midiStreamOpen', MMRESULT, { phms: LPHMIDISTRM, puDeviceID: LPUINT, cMidi: DWORD, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('midiStreamClose', MMRESULT, { hms: HMIDISTRM });
FN('midiStreamProperty', MMRESULT, { hms: HMIDISTRM, lppropdata: LPBYTE, dwProperty: DWORD });
FN('midiStreamPosition', MMRESULT, { hms: HMIDISTRM, lpmmt: LPMMTIME, cbmmt: UINT });
FN('midiStreamOut', MMRESULT, { hms: HMIDISTRM, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiStreamPause', MMRESULT, { hms: HMIDISTRM });
FN('midiStreamRestart', MMRESULT, { hms: HMIDISTRM });
FN('midiStreamStop', MMRESULT, { hms: HMIDISTRM });
FN('midiConnect', MMRESULT, { hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID });
FN('midiDisconnect', MMRESULT, { hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID });
FN('midiOutGetDevCapsA', MMRESULT, { uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSA, cbmoc: UINT });
FN('midiOutGetDevCapsW', MMRESULT, { uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSW, cbmoc: UINT });
FN('midiOutGetVolume', MMRESULT, { hmo: HMIDIOUT, pdwVolume: LPDWORD });
FN('midiOutSetVolume', MMRESULT, { hmo: HMIDIOUT, dwVolume: DWORD });
FN('midiOutGetErrorTextA', MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT });
FN('midiOutGetErrorTextW', MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT });
FN('midiOutOpen', MMRESULT, { phmo: LPHMIDIOUT, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('midiOutClose', MMRESULT, { hmo: HMIDIOUT });
FN('midiOutPrepareHeader', MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiOutUnprepareHeader', MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiOutShortMsg', MMRESULT, { hmo: HMIDIOUT, dwMsg: DWORD });
FN('midiOutLongMsg', MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiOutReset', MMRESULT, { hmo: HMIDIOUT });
FN('midiOutCachePatches', MMRESULT, { hmo: HMIDIOUT, uBank: UINT, pwpa: LPWORD, fuCache: UINT });
FN('midiOutCacheDrumPatches', MMRESULT, { hmo: HMIDIOUT, uPatch: UINT, pwkya: LPWORD, fuCache: UINT });
FN('midiOutGetID', MMRESULT, { hmo: HMIDIOUT, puDeviceID: LPUINT });
FN('midiOutMessage', MMRESULT, { hmo: HMIDIOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR });
FN('midiInGetNumDevs', UINT, {  });
FN('midiInGetDevCapsA', MMRESULT, { uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSA, cbmic: UINT });
FN('midiInGetDevCapsW', MMRESULT, { uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSW, cbmic: UINT });
FN('midiInGetErrorTextA', MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT });
FN('midiInGetErrorTextW', MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT });
FN('midiInOpen', MMRESULT, { phmi: LPHMIDIIN, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('midiInClose', MMRESULT, { hmi: HMIDIIN });
FN('midiInPrepareHeader', MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiInUnprepareHeader', MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiInAddBuffer', MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT });
FN('midiInStart', MMRESULT, { hmi: HMIDIIN });
FN('midiInStop', MMRESULT, { hmi: HMIDIIN });
FN('midiInReset', MMRESULT, { hmi: HMIDIIN });
FN('midiInGetID', MMRESULT, { hmi: HMIDIIN, puDeviceID: LPUINT });
FN('midiInMessage', MMRESULT, { hmi: HMIDIIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR });
FN('auxGetNumDevs', UINT, {  });
FN('auxGetDevCapsA', MMRESULT, { uDeviceID: UINT_PTR, pac: LPAUXCAPSA, cbac: UINT });
FN('auxGetDevCapsW', MMRESULT, { uDeviceID: UINT_PTR, pac: LPAUXCAPSW, cbac: UINT });
FN('auxSetVolume', MMRESULT, { uDeviceID: UINT, dwVolume: DWORD });
FN('auxGetVolume', MMRESULT, { uDeviceID: UINT, pdwVolume: LPDWORD });
FN('auxOutMessage', MMRESULT, { uDeviceID: UINT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR });
FN('mixerGetNumDevs', UINT, {  });
FN('mixerGetDevCapsA', MMRESULT, { uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSA, cbmxcaps: UINT });
FN('mixerGetDevCapsW', MMRESULT, { uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSW, cbmxcaps: UINT });
FN('mixerOpen', MMRESULT, { phmx: LPHMIXER, uMxId: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD });
FN('mixerClose', MMRESULT, { hmx: HMIXER });
FN('mixerMessage', DWORD, { hmx: HMIXER, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR });
FN('mixerGetLineInfoA', MMRESULT, { hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEA, fdwInfo: DWORD });
FN('mixerGetLineInfoW', MMRESULT, { hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEW, fdwInfo: DWORD });
FN('mixerGetID', MMRESULT, { hmxobj: HMIXEROBJ, puMxId: PTR(uint), fdwId: DWORD });
FN('mixerGetLineControlsA', MMRESULT, { hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSA, fdwControls: DWORD });
FN('mixerGetLineControlsW', MMRESULT, { hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSW, fdwControls: DWORD });
FN('mixerGetControlDetailsA', MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD });
FN('mixerGetControlDetailsW', MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD });
FN('mixerSetControlDetails', MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD });
FN('timeGetSystemTime', MMRESULT, { pmmt: LPMMTIME, cbmmt: UINT });
FN('timeGetTime', DWORD, {  });
FN('timeSetEvent', MMRESULT, { uDelay: UINT, uResolution: UINT, fptc: LPTIMECALLBACK, dwUser: DWORD_PTR, fuEvent: UINT });
FN('timeKillEvent', MMRESULT, { uTimerID: UINT });
FN('timeGetDevCaps', MMRESULT, { ptc: LPTIMECAPS, cbtc: UINT });
FN('timeBeginPeriod', MMRESULT, { uPeriod: UINT });
FN('timeEndPeriod', MMRESULT, { uPeriod: UINT });
FN('joyGetNumDevs', UINT, {  });
FN('joyGetDevCapsA', MMRESULT, { uJoyID: UINT_PTR, pjc: LPJOYCAPSA, cbjc: UINT });
FN('joyGetDevCapsW', MMRESULT, { uJoyID: UINT_PTR, pjc: LPJOYCAPSW, cbjc: UINT });
FN('joyGetPos', MMRESULT, { uJoyID: UINT, pji: LPJOYINFO });
FN('joyGetPosEx', MMRESULT, { uJoyID: UINT, pji: LPJOYINFOEX });
FN('joyGetThreshold', MMRESULT, { uJoyID: UINT, puThreshold: LPUINT });
FN('joyReleaseCapture', MMRESULT, { uJoyID: UINT });
FN('joySetCapture', MMRESULT, { hwnd: HWND, uJoyID: UINT, uPeriod: UINT, fChanged: BOOL });
FN('joySetThreshold', MMRESULT, { uJoyID: UINT, uThreshold: UINT });
FN('mmioStringToFOURCCA', FOURCC, { sz: LPCSTR, uFlags: UINT });
FN('mmioStringToFOURCCW', FOURCC, { sz: LPCWSTR, uFlags: UINT });
FN('mmioInstallIOProcA', LPMMIOPROC, { fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD });
FN('mmioInstallIOProcW', LPMMIOPROC, { fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD });
FN('mmioOpenA', HMMIO, { pszFileName: LPSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD });
FN('mmioOpenW', HMMIO, { pszFileName: LPWSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD });
FN('mmioRenameA', MMRESULT, { pszFileName: LPCSTR, pszNewFileName: LPCSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD });
FN('mmioRenameW', MMRESULT, { pszFileName: LPCWSTR, pszNewFileName: LPCWSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD });
FN('mmioClose', MMRESULT, { hmmio: HMMIO, fuClose: UINT });
FN('mmioRead', LONG, { hmmio: HMMIO, pch: HPSTR, cch: LONG });
FN('mmioWrite', LONG, { hmmio: HMMIO, pch: PTR(int8), cch: LONG });
FN('mmioSeek', LONG, { hmmio: HMMIO, lOffset: LONG, iOrigin: int });
FN('mmioGetInfo', MMRESULT, { hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuInfo: UINT });
FN('mmioSetInfo', MMRESULT, { hmmio: HMMIO, pmmioinfo: LPCMMIOINFO, fuInfo: UINT });
FN('mmioSetBuffer', MMRESULT, { hmmio: HMMIO, pchBuffer: LPSTR, cchBuffer: LONG, fuBuffer: UINT });
FN('mmioFlush', MMRESULT, { hmmio: HMMIO, fuFlush: UINT });
FN('mmioAdvance', MMRESULT, { hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuAdvance: UINT });
FN('mmioSendMessage', LRESULT, { hmmio: HMMIO, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM });
FN('mmioDescend', MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, pmmckiParent: PTR(uint), fuDescend: UINT });
FN('mmioAscend', MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, fuAscend: UINT });
FN('mmioCreateChunk', MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, fuCreate: UINT });
FN('mciSendCommandA', MCIERROR, { mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR });
FN('mciSendCommandW', MCIERROR, { mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR });
FN('mciSendStringA', MCIERROR, { lpstrCommand: LPCSTR, lpstrReturnString: LPSTR, uReturnLength: UINT, hwndCallback: HWND });
FN('mciSendStringW', MCIERROR, { lpstrCommand: LPCWSTR, lpstrReturnString: LPWSTR, uReturnLength: UINT, hwndCallback: HWND });
FN('mciGetDeviceIDA', MCIDEVICEID, { pszDevice: LPCSTR });
FN('mciGetDeviceIDW', MCIDEVICEID, { pszDevice: LPCWSTR });
FN('mciGetDeviceIDFromElementIDA', MCIDEVICEID, { dwElementID: DWORD, lpstrType: LPCSTR });
FN('mciGetDeviceIDFromElementIDW', MCIDEVICEID, { dwElementID: DWORD, lpstrType: LPCWSTR });
FN('mciGetErrorStringA', BOOL, { mcierr: MCIERROR, pszText: LPSTR, cchText: UINT });
FN('mciGetErrorStringW', BOOL, { mcierr: MCIERROR, pszText: LPWSTR, cchText: UINT });
FN('mciSetYieldProc', BOOL, { mciId: MCIDEVICEID, fpYieldProc: YIELDPROC, dwYieldData: DWORD });
FN('mciGetCreatorTask', HTASK, { mciId: MCIDEVICEID });
FN('mciGetYieldProc', YIELDPROC, { mciId: MCIDEVICEID, pdwYieldData: LPDWORD });
FN('Netbios', UCHAR, { pncb: PNCB });
FN('RpcBindingCopy', RPC_STATUS, { SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: PTR(PTR('void')) });
FN('RpcBindingFree', RPC_STATUS, { Binding: PTR(PTR('void')) });
FN('RpcBindingSetOption', RPC_STATUS, { hBinding: RPC_BINDING_HANDLE, option: ulong, optionValue: ULONG_PTR });
FN('RpcBindingInqOption', RPC_STATUS, { hBinding: RPC_BINDING_HANDLE, option: ulong, pOptionValue: PTR(ulong) });
FN('RpcBindingFromStringBindingA', RPC_STATUS, { StringBinding: RPC_CSTR, Binding: PTR(PTR('void')) });
FN('RpcBindingFromStringBindingW', RPC_STATUS, { StringBinding: RPC_WSTR, Binding: PTR(PTR('void')) });
FN('RpcSsGetContextBinding', RPC_STATUS, { ContextHandle: PTR('void'), Binding: PTR(PTR('void')) });
FN('RpcBindingInqObject', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) });
FN('RpcBindingReset', RPC_STATUS, { Binding: RPC_BINDING_HANDLE });
FN('RpcBindingSetObject', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) });
FN('RpcMgmtInqDefaultProtectLevel', RPC_STATUS, { AuthnSvc: ulong, AuthnLevel: PTR(ulong) });
FN('RpcBindingToStringBindingA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(uchar)) });
FN('RpcBindingToStringBindingW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(ushort)) });
FN('RpcBindingVectorFree', RPC_STATUS, { BindingVector: PTR(PTR(uint)) });
FN('RpcStringBindingComposeA', RPC_STATUS, { ObjUuid: RPC_CSTR, ProtSeq: RPC_CSTR, NetworkAddr: RPC_CSTR, Endpoint: RPC_CSTR, Options: RPC_CSTR, StringBinding: PTR(PTR(uchar)) });
FN('RpcStringBindingComposeW', RPC_STATUS, { ObjUuid: RPC_WSTR, ProtSeq: RPC_WSTR, NetworkAddr: RPC_WSTR, Endpoint: RPC_WSTR, Options: RPC_WSTR, StringBinding: PTR(PTR(ushort)) });
FN('RpcStringBindingParseA', RPC_STATUS, { StringBinding: RPC_CSTR, ObjUuid: PTR(PTR(uchar)), Protseq: PTR(PTR(uchar)), NetworkAddr: PTR(PTR(uchar)), Endpoint: PTR(PTR(uchar)), NetworkOptions: PTR(PTR(uchar)) });
FN('RpcStringBindingParseW', RPC_STATUS, { StringBinding: RPC_WSTR, ObjUuid: PTR(PTR(ushort)), Protseq: PTR(PTR(ushort)), NetworkAddr: PTR(PTR(ushort)), Endpoint: PTR(PTR(ushort)), NetworkOptions: PTR(PTR(ushort)) });
FN('RpcStringFreeA', RPC_STATUS, { String: PTR(PTR(uchar)) });
FN('RpcStringFreeW', RPC_STATUS, { String: PTR(PTR(ushort)) });
FN('RpcIfInqId', RPC_STATUS, { RpcIfHandle: RPC_IF_HANDLE, RpcIfId: PTR(uint) });
FN('RpcNetworkIsProtseqValidA', RPC_STATUS, { Protseq: RPC_CSTR });
FN('RpcNetworkIsProtseqValidW', RPC_STATUS, { Protseq: RPC_WSTR });
FN('RpcMgmtInqComTimeout', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Timeout: PTR(uint) });
FN('RpcMgmtSetComTimeout', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Timeout: uint });
FN('RpcMgmtSetCancelTimeout', RPC_STATUS, { Timeout: long });
FN('RpcNetworkInqProtseqsA', RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) });
FN('RpcNetworkInqProtseqsW', RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) });
FN('RpcObjectInqType', RPC_STATUS, { ObjUuid: PTR(uint), TypeUuid: PTR(uint) });
FN('RpcObjectSetInqFn', RPC_STATUS, { InquiryFn: PTR(CALLBACK('void', [PTR(UUID), PTR(UUID), PTR(long)])) });
FN('RpcObjectSetType', RPC_STATUS, { ObjUuid: PTR(uint), TypeUuid: PTR(uint) });
FN('RpcProtseqVectorFreeA', RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) });
FN('RpcProtseqVectorFreeW', RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) });
FN('RpcServerInqBindings', RPC_STATUS, { BindingVector: PTR(PTR(uint)) });
FN('RpcServerInqIf', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR(PTR('void')) });
FN('RpcServerListen', RPC_STATUS, { MinimumCallThreads: uint, MaxCalls: uint, DontWait: uint });
FN('RpcServerRegisterIf', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR('void') });
FN('RpcServerRegisterIfEx', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR('void'), Flags: uint, MaxCalls: uint, IfCallback: PTR(CALLBACK(long, [PTR('void'), PTR('void')])) });
FN('RpcServerRegisterIf2', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR('void'), Flags: uint, MaxCalls: uint, MaxRpcSize: uint, IfCallbackFn: PTR(CALLBACK(long, [PTR('void'), PTR('void')])) });
FN('RpcServerUnregisterIf', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), WaitForCallsToComplete: uint });
FN('RpcServerUnregisterIfEx', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), RundownContextHandles: int });
FN('RpcServerUseAllProtseqs', RPC_STATUS, { MaxCalls: uint, SecurityDescriptor: PTR('void') });
FN('RpcServerUseAllProtseqsEx', RPC_STATUS, { MaxCalls: uint, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseAllProtseqsIf', RPC_STATUS, { MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void') });
FN('RpcServerUseAllProtseqsIfEx', RPC_STATUS, { MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqExA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqExW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqEpA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqEpExA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqEpW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqEpExW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqIfA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqIfExA', RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerUseProtseqIfW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void') });
FN('RpcServerUseProtseqIfExW', RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR('void'), Policy: PRPC_POLICY });
FN('RpcServerYield', 'void', {  });
FN('RpcMgmtStatsVectorFree', RPC_STATUS, { StatsVector: PTR(PTR(uint)) });
FN('RpcMgmtInqStats', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Statistics: PTR(PTR(uint)) });
FN('RpcMgmtIsServerListening', RPC_STATUS, { Binding: RPC_BINDING_HANDLE });
FN('RpcMgmtStopServerListening', RPC_STATUS, { Binding: RPC_BINDING_HANDLE });
FN('RpcMgmtWaitServerListen', RPC_STATUS, {  });
FN('RpcMgmtSetServerStackSize', RPC_STATUS, { ThreadStackSize: ulong });
FN('RpcSsDontSerializeContext', 'void', {  });
FN('RpcMgmtEnableIdleCleanup', RPC_STATUS, {  });
FN('RpcMgmtInqIfIds', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, IfIdVector: PTR(PTR(uint)) });
FN('RpcIfIdVectorFree', RPC_STATUS, { IfIdVector: PTR(PTR(uint)) });
FN('RpcMgmtInqServerPrincNameA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AuthnSvc: ulong, ServerPrincName: PTR(PTR(uchar)) });
FN('RpcMgmtInqServerPrincNameW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AuthnSvc: ulong, ServerPrincName: PTR(PTR(ushort)) });
FN('RpcServerInqDefaultPrincNameA', RPC_STATUS, { AuthnSvc: ulong, PrincName: PTR(PTR(uchar)) });
FN('RpcServerInqDefaultPrincNameW', RPC_STATUS, { AuthnSvc: ulong, PrincName: PTR(PTR(ushort)) });
FN('RpcEpResolveBinding', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE });
FN('RpcNsBindingInqEntryNameA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: PTR(PTR(uchar)) });
FN('RpcNsBindingInqEntryNameW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: PTR(PTR(ushort)) });
FN('RpcBindingCreateA', RPC_STATUS, { Template: PTR(uint), Security: PTR(uint), Options: PTR(uint), Binding: PTR(PTR('void')) });
FN('RpcBindingCreateW', RPC_STATUS, { Template: PTR(uint), Security: PTR(uint), Options: PTR(uint), Binding: PTR(PTR('void')) });
FN('RpcBindingGetTrainingContextHandle', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ContextHandle: PTR(PTR('void')) });
FN('RpcServerInqBindingHandle', RPC_STATUS, { Binding: PTR(PTR('void')) });
FN('RpcImpersonateClient', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE });
FN('RpcRevertToSelfEx', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE });
FN('RpcRevertToSelf', RPC_STATUS, {  });
FN('RpcBindingInqAuthClientA', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR('void')), ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong) });
FN('RpcBindingInqAuthClientW', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR('void')), ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong) });
FN('RpcBindingInqAuthClientExA', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR('void')), ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong), Flags: ulong });
FN('RpcBindingInqAuthClientExW', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR('void')), ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong), Flags: ulong });
FN('RpcBindingInqAuthInfoA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR('void')), AuthzSvc: PTR(ulong) });
FN('RpcBindingInqAuthInfoW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR('void')), AuthzSvc: PTR(ulong) });
FN('RpcBindingSetAuthInfoA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong });
FN('RpcBindingSetAuthInfoExA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong, SecurityQos: PTR(uint) });
FN('RpcBindingSetAuthInfoW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong });
FN('RpcBindingSetAuthInfoExW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong, SecurityQOS: PTR(uint) });
FN('RpcBindingInqAuthInfoExA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR('void')), AuthzSvc: PTR(ulong), RpcQosVersion: ulong, SecurityQOS: PTR(uint) });
FN('RpcBindingInqAuthInfoExW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR('void')), AuthzSvc: PTR(ulong), RpcQosVersion: ulong, SecurityQOS: PTR(uint) });
FN('RpcServerCompleteSecurityCallback', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, Status: RPC_STATUS });
FN('RpcServerRegisterAuthInfoA', RPC_STATUS, { ServerPrincName: RPC_CSTR, AuthnSvc: ulong, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: PTR('void') });
FN('RpcServerRegisterAuthInfoW', RPC_STATUS, { ServerPrincName: RPC_WSTR, AuthnSvc: ulong, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: PTR('void') });
FN('RpcBindingServerFromClient', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, ServerBinding: PTR(PTR('void')) });
FN('RpcRaiseException', 'void', { exception: RPC_STATUS });
FN('RpcTestCancel', RPC_STATUS, {  });
FN('RpcServerTestCancel', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE });
FN('RpcCancelThread', RPC_STATUS, { Thread: PTR('void') });
FN('RpcCancelThreadEx', RPC_STATUS, { Thread: PTR('void'), Timeout: long });
FN('UuidCreate', RPC_STATUS, { Uuid: PTR(uint) });
FN('UuidCreateSequential', RPC_STATUS, { Uuid: PTR(uint) });
FN('UuidToStringA', RPC_STATUS, { Uuid: PTR(uint), StringUuid: PTR(PTR(uchar)) });
FN('UuidFromStringA', RPC_STATUS, { StringUuid: RPC_CSTR, Uuid: PTR(uint) });
FN('UuidToStringW', RPC_STATUS, { Uuid: PTR(uint), StringUuid: PTR(PTR(ushort)) });
FN('UuidFromStringW', RPC_STATUS, { StringUuid: RPC_WSTR, Uuid: PTR(uint) });
FN('UuidCompare', 'void', { Uuid1: PTR(uint), Uuid2: PTR(uint), Status: PTR(long) });
FN('UuidCreateNil', RPC_STATUS, { NilUuid: PTR(uint) });
FN('UuidEqual', 'void', { Uuid1: PTR(uint), Uuid2: PTR(uint), Status: PTR(long) });
FN('UuidHash', 'void', { Uuid: PTR(uint), Status: PTR(long) });
FN('UuidIsNil', 'void', { Uuid: PTR(uint), Status: PTR(long) });
FN('RpcEpRegisterNoReplaceA', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_CSTR });
FN('RpcEpRegisterNoReplaceW', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_WSTR });
FN('RpcEpRegisterA', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_CSTR });
FN('RpcEpRegisterW', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_WSTR });
FN('RpcEpUnregister', RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint) });
FN('DceErrorInqTextA', RPC_STATUS, { RpcStatus: RPC_STATUS, ErrorText: RPC_CSTR });
FN('DceErrorInqTextW', RPC_STATUS, { RpcStatus: RPC_STATUS, ErrorText: RPC_WSTR });
FN('RpcMgmtEpEltInqBegin', RPC_STATUS, { EpBinding: RPC_BINDING_HANDLE, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, ObjectUuid: PTR(uint), InquiryContext: PTR(pointer) });
FN('RpcMgmtEpEltInqDone', RPC_STATUS, { InquiryContext: PTR(pointer) });
FN('RpcMgmtEpEltInqNextA', RPC_STATUS, { InquiryContext: RPC_EP_INQ_HANDLE, IfId: PTR(uint), Binding: PTR(PTR('void')), ObjectUuid: PTR(uint), Annotation: PTR(PTR(uchar)) });
FN('RpcMgmtEpEltInqNextW', RPC_STATUS, { InquiryContext: RPC_EP_INQ_HANDLE, IfId: PTR(uint), Binding: PTR(PTR('void')), ObjectUuid: PTR(uint), Annotation: PTR(PTR(ushort)) });
FN('RpcMgmtEpUnregister', RPC_STATUS, { EpBinding: RPC_BINDING_HANDLE, IfId: PTR(uint), Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) });
FN('RpcMgmtSetAuthorizationFn', RPC_STATUS, { AuthorizationFn: RPC_MGMT_AUTHORIZATION_FN });
FN('RpcExceptionFilter', 'void', { ExceptionCode: ulong });
FN('I_RpcNegotiateTransferSyntax', RPC_STATUS, { Message: PTR(uint) });
FN('I_RpcGetBuffer', RPC_STATUS, { Message: PTR(uint) });
FN('I_RpcGetBufferWithObject', RPC_STATUS, { Message: PTR(uint), ObjectUuid: PTR(uint) });
FN('I_RpcSendReceive', RPC_STATUS, { Message: PTR(uint) });
FN('I_RpcFreeBuffer', RPC_STATUS, { Message: PTR(uint) });
FN('I_RpcSend', RPC_STATUS, { Message: PRPC_MESSAGE });
FN('I_RpcReceive', RPC_STATUS, { Message: PRPC_MESSAGE, Size: uint });
FN('I_RpcFreePipeBuffer', RPC_STATUS, { Message: PTR(uint) });
FN('I_RpcReallocPipeBuffer', RPC_STATUS, { Message: PRPC_MESSAGE, NewSize: uint });
FN('I_RpcRequestMutex', 'void', { Mutex: PTR(PTR('void')) });
FN('I_RpcClearMutex', 'void', { Mutex: I_RPC_MUTEX });
FN('I_RpcDeleteMutex', 'void', { Mutex: I_RPC_MUTEX });
FN('I_RpcAllocate', 'void', { Size: uint });
FN('I_RpcFree', 'void', { Object: PTR('void') });
FN('I_RpcPauseExecution', 'void', { Milliseconds: ulong });
FN('I_RpcGetExtendedError', RPC_STATUS, {  });
FN('I_RpcMonitorAssociation', RPC_STATUS, { Handle: RPC_BINDING_HANDLE, RundownRoutine: PRPC_RUNDOWN, Context: PTR('void') });
FN('I_RpcStopMonitorAssociation', RPC_STATUS, { Handle: RPC_BINDING_HANDLE });
FN('I_RpcGetCurrentCallHandle', RPC_BINDING_HANDLE, {  });
FN('I_RpcGetAssociationContext', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, AssociationContext: PTR(PTR('void')) });
FN('I_RpcGetServerContextList', 'void', { BindingHandle: RPC_BINDING_HANDLE });
FN('I_RpcSetServerContextList', 'void', { BindingHandle: RPC_BINDING_HANDLE, ServerContextList: PTR('void') });
FN('I_RpcNsInterfaceExported', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: PTR(ushort), RpcInterfaceInformation: PTR(uint) });
FN('I_RpcNsInterfaceUnexported', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: PTR(ushort), RpcInterfaceInformation: PTR(uint) });
FN('I_RpcBindingToStaticStringBindingW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(ushort)) });
FN('I_RpcBindingInqSecurityContext', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, SecurityContextHandle: PTR(PTR('void')) });
FN('I_RpcBindingInqSecurityContextKeyInfo', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, KeyInfo: PTR('void') });
FN('I_RpcBindingInqWireIdForSnego', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, WireId: RPC_CSTR });
FN('I_RpcBindingInqMarshalledTargetInfo', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, MarshalledTargetInfoSize: PTR(ulong), MarshalledTargetInfo: PTR(PTR(uchar)) });
FN('I_RpcBindingInqLocalClientPID', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Pid: PTR(ulong) });
FN('I_RpcBindingHandleToAsyncHandle', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AsyncHandle: PTR(PTR('void')) });
FN('I_RpcNsBindingSetEntryNameW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: RPC_WSTR });
FN('I_RpcNsBindingSetEntryNameA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: RPC_CSTR });
FN('I_RpcServerUseProtseqEp2A', RPC_STATUS, { NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR('void'), Policy: PTR('void') });
FN('I_RpcServerUseProtseqEp2W', RPC_STATUS, { NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR('void'), Policy: PTR('void') });
FN('I_RpcServerUseProtseq2W', RPC_STATUS, { NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR('void'), Policy: PTR('void') });
FN('I_RpcServerUseProtseq2A', RPC_STATUS, { NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR('void'), Policy: PTR('void') });
FN('I_RpcServerStartService', RPC_STATUS, { Protseq: RPC_WSTR, Endpoint: RPC_WSTR, IfSpec: RPC_IF_HANDLE });
FN('I_RpcBindingInqDynamicEndpointW', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, DynamicEndpoint: PTR(PTR(ushort)) });
FN('I_RpcBindingInqDynamicEndpointA', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, DynamicEndpoint: PTR(PTR(uchar)) });
FN('I_RpcServerCheckClientRestriction', RPC_STATUS, { Context: RPC_BINDING_HANDLE });
FN('I_RpcBindingInqTransportType', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Type: PTR(uint) });
FN('I_RpcIfInqTransferSyntaxes', RPC_STATUS, { RpcIfHandle: RPC_IF_HANDLE, TransferSyntaxes: PTR(uint), TransferSyntaxSize: uint, TransferSyntaxCount: PTR(uint) });
FN('I_UuidCreate', RPC_STATUS, { Uuid: PTR(uint) });
FN('I_RpcBindingCopy', RPC_STATUS, { SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: PTR(PTR('void')) });
FN('I_RpcBindingIsClientLocal', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, ClientLocalFlag: PTR(uint) });
FN('I_RpcBindingInqConnId', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ConnId: PTR(PTR('void')), pfFirstCall: PTR(int) });
FN('I_RpcBindingCreateNP', RPC_STATUS, { ServerName: RPC_WSTR, ServiceName: RPC_WSTR, NetworkOptions: RPC_WSTR, Binding: PTR(PTR('void')) });
FN('I_RpcSsDontSerializeContext', 'void', {  });
FN('I_RpcLaunchDatagramReceiveThread', RPC_STATUS, { pAddress: PTR('void') });
FN('I_RpcServerRegisterForwardFunction', RPC_STATUS, { pForwardFunction: PTR(CALLBACK(long, [PTR(UUID), PTR(RPC_VERSION), PTR(UUID), PTR(uchar), PTR(PTR('void'))])) });
FN('I_RpcServerInqAddressChangeFn', RPC_ADDRESS_CHANGE_FN, {  });
FN('I_RpcServerSetAddressChangeFn', RPC_STATUS, { pAddressChangeFn: PTR(CALLBACK('void', [PTR('void')])) });
FN('I_RpcServerInqLocalConnAddress', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Buffer: PTR('void'), BufferSize: PTR(ulong), AddressFormat: PTR(ulong) });
FN('I_RpcServerInqRemoteConnAddress', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Buffer: PTR('void'), BufferSize: PTR(ulong), AddressFormat: PTR(ulong) });
FN('I_RpcSessionStrictContextHandle', 'void', {  });
FN('I_RpcTurnOnEEInfoPropagation', RPC_STATUS, {  });
FN('I_RpcConnectionInqSockBuffSize', RPC_STATUS, { RecvBuffSize: PTR(ulong), SendBuffSize: PTR(ulong) });
FN('I_RpcConnectionSetSockBuffSize', RPC_STATUS, { RecvBuffSize: ulong, SendBuffSize: ulong });
FN('I_RpcServerStartListening', RPC_STATUS, { hWnd: PTR('void') });
FN('I_RpcServerStopListening', RPC_STATUS, {  });
FN('I_RpcBindingSetAsync', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, BlockingFn: RPC_BLOCKING_FN, ServerTid: ulong });
FN('I_RpcSetThreadParams', RPC_STATUS, { fClientFree: int, Context: PTR('void'), hWndClient: PTR('void') });
FN('I_RpcWindowProc', 'void', { hWnd: PTR('void'), Message: uint, wParam: uint, lParam: ulong });
FN('I_RpcServerUnregisterEndpointA', RPC_STATUS, { Protseq: RPC_CSTR, Endpoint: RPC_CSTR });
FN('I_RpcServerUnregisterEndpointW', RPC_STATUS, { Protseq: RPC_WSTR, Endpoint: RPC_WSTR });
FN('I_RpcServerInqTransportType', RPC_STATUS, { Type: PTR(uint) });
FN('I_RpcMapWin32Status', 'void', { Status: RPC_STATUS });
FN('I_RpcProxyNewConnection', RPC_STATUS, { ConnectionType: ulong, ServerAddress: PTR(ushort), ServerPort: PTR(ushort), MinConnTimeout: PTR(ushort), ConnectionParameter: PTR('void'), CallOutState: PTR(uint), ProxyCallbackInterface: PTR(uint) });
FN('I_RpcReplyToClientWithStatus', RPC_STATUS, { ConnectionParameter: PTR('void'), RpcStatus: RPC_STATUS });
FN('I_RpcRecordCalloutFailure', 'void', { RpcStatus: RPC_STATUS, CallOutState: PTR(uint), DllName: PTR(ushort) });
FN('I_RpcMgmtEnableDedicatedThreadPool', RPC_STATUS, {  });
FN('RpcNsBindingExportA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, BindingVec: PTR(uint), ObjectUuidVec: PTR(uint) });
FN('RpcNsBindingUnexportA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: PTR(uint) });
FN('RpcNsBindingExportW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, BindingVec: PTR(uint), ObjectUuidVec: PTR(uint) });
FN('RpcNsBindingUnexportW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: PTR(uint) });
FN('RpcNsBindingExportPnPA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) });
FN('RpcNsBindingUnexportPnPA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) });
FN('RpcNsBindingExportPnPW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) });
FN('RpcNsBindingUnexportPnPW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) });
FN('RpcNsBindingLookupBeginA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), BindingMaxCount: ulong, LookupContext: PTR(PTR('void')) });
FN('RpcNsBindingLookupBeginW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), BindingMaxCount: ulong, LookupContext: PTR(PTR('void')) });
FN('RpcNsBindingLookupNext', RPC_STATUS, { LookupContext: RPC_NS_HANDLE, BindingVec: PTR(PTR(uint)) });
FN('RpcNsBindingLookupDone', RPC_STATUS, { LookupContext: PTR(PTR('void')) });
FN('RpcNsGroupDeleteA', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR });
FN('RpcNsGroupMbrAddA', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, MemberName: RPC_CSTR });
FN('RpcNsGroupMbrRemoveA', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, MemberName: RPC_CSTR });
FN('RpcNsGroupMbrInqBeginA', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, InquiryContext: PTR(PTR('void')) });
FN('RpcNsGroupMbrInqNextA', RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, MemberName: PTR(PTR(uchar)) });
FN('RpcNsGroupDeleteW', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR });
FN('RpcNsGroupMbrAddW', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, MemberName: RPC_WSTR });
FN('RpcNsGroupMbrRemoveW', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, MemberName: RPC_WSTR });
FN('RpcNsGroupMbrInqBeginW', RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, InquiryContext: PTR(PTR('void')) });
FN('RpcNsGroupMbrInqNextW', RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, MemberName: PTR(PTR(ushort)) });
FN('RpcNsGroupMbrInqDone', RPC_STATUS, { InquiryContext: PTR(PTR('void')) });
FN('RpcNsProfileDeleteA', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR });
FN('RpcNsProfileEltAddA', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_CSTR, Priority: ulong, Annotation: RPC_CSTR });
FN('RpcNsProfileEltRemoveA', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_CSTR });
FN('RpcNsProfileEltInqBeginA', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, MemberNameSyntax: ulong, MemberName: RPC_CSTR, InquiryContext: PTR(PTR('void')) });
FN('RpcNsProfileEltInqNextA', RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, IfId: PTR(uint), MemberName: PTR(PTR(uchar)), Priority: PTR(ulong), Annotation: PTR(PTR(uchar)) });
FN('RpcNsProfileDeleteW', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR });
FN('RpcNsProfileEltAddW', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_WSTR, Priority: ulong, Annotation: RPC_WSTR });
FN('RpcNsProfileEltRemoveW', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_WSTR });
FN('RpcNsProfileEltInqBeginW', RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, MemberNameSyntax: ulong, MemberName: RPC_WSTR, InquiryContext: PTR(PTR('void')) });
FN('RpcNsProfileEltInqNextW', RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, IfId: PTR(uint), MemberName: PTR(PTR(ushort)), Priority: PTR(ulong), Annotation: PTR(PTR(ushort)) });
FN('RpcNsProfileEltInqDone', RPC_STATUS, { InquiryContext: PTR(PTR('void')) });
FN('RpcNsEntryObjectInqBeginA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, InquiryContext: PTR(PTR('void')) });
FN('RpcNsEntryObjectInqBeginW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, InquiryContext: PTR(PTR('void')) });
FN('RpcNsEntryObjectInqNext', RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, ObjUuid: PTR(uint) });
FN('RpcNsEntryObjectInqDone', RPC_STATUS, { InquiryContext: PTR(PTR('void')) });
FN('RpcNsEntryExpandNameA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, ExpandedName: PTR(PTR(uchar)) });
FN('RpcNsMgmtBindingUnexportA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfId: PTR(uint), VersOption: ulong, ObjectUuidVec: PTR(uint) });
FN('RpcNsMgmtEntryCreateA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR });
FN('RpcNsMgmtEntryDeleteA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR });
FN('RpcNsMgmtEntryInqIfIdsA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfIdVec: PTR(PTR(uint)) });
FN('RpcNsMgmtHandleSetExpAge', RPC_STATUS, { NsHandle: RPC_NS_HANDLE, ExpirationAge: ulong });
FN('RpcNsMgmtInqExpAge', RPC_STATUS, { ExpirationAge: PTR(ulong) });
FN('RpcNsMgmtSetExpAge', RPC_STATUS, { ExpirationAge: ulong });
FN('RpcNsEntryExpandNameW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, ExpandedName: PTR(PTR(ushort)) });
FN('RpcNsMgmtBindingUnexportW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfId: PTR(uint), VersOption: ulong, ObjectUuidVec: PTR(uint) });
FN('RpcNsMgmtEntryCreateW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR });
FN('RpcNsMgmtEntryDeleteW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR });
FN('RpcNsMgmtEntryInqIfIdsW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfIdVec: PTR(PTR(uint)) });
FN('RpcNsBindingImportBeginA', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), ImportContext: PTR(PTR('void')) });
FN('RpcNsBindingImportBeginW', RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), ImportContext: PTR(PTR('void')) });
FN('RpcNsBindingImportNext', RPC_STATUS, { ImportContext: RPC_NS_HANDLE, Binding: PTR(PTR('void')) });
FN('RpcNsBindingImportDone', RPC_STATUS, { ImportContext: PTR(PTR('void')) });
FN('RpcNsBindingSelect', RPC_STATUS, { BindingVec: PTR(uint), Binding: PTR(PTR('void')) });
FN('RpcAsyncInitializeHandle', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Size: uint });
FN('RpcAsyncRegisterInfo', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE });
FN('RpcAsyncGetCallStatus', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE });
FN('RpcAsyncCompleteCall', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Reply: PTR('void') });
FN('RpcAsyncAbortCall', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, ExceptionCode: ulong });
FN('RpcAsyncCancelCall', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, fAbort: BOOL });
FN('RpcErrorStartEnumeration', RPC_STATUS, { EnumHandle: PTR(uint) });
FN('RpcErrorGetNextRecord', RPC_STATUS, { EnumHandle: PTR(uint), CopyStrings: BOOL, ErrorInfo: PTR(uint) });
FN('RpcErrorEndEnumeration', RPC_STATUS, { EnumHandle: PTR(uint) });
FN('RpcErrorResetEnumeration', RPC_STATUS, { EnumHandle: PTR(uint) });
FN('RpcErrorGetNumberOfRecords', RPC_STATUS, { EnumHandle: PTR(uint), Records: PTR(int) });
FN('RpcErrorSaveErrorInfo', RPC_STATUS, { EnumHandle: PTR(uint), ErrorBlob: PTR(PTR('void')), BlobSize: PTR(uint) });
FN('RpcErrorLoadErrorInfo', RPC_STATUS, { ErrorBlob: PVOID, BlobSize: size_t, EnumHandle: PTR(uint) });
FN('RpcErrorAddRecord', RPC_STATUS, { ErrorInfo: PTR(uint) });
FN('RpcErrorClearInformation', 'void', {  });
FN('RpcAsyncCleanupThread', RPC_STATUS, { dwTimeout: DWORD });
FN('RpcGetAuthorizationContextForClient', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, ImpersonateOnReturn: BOOL, Reserved1: PVOID, pExpirationTime: PLARGE_INTEGER, Reserved2: LUID, Reserved3: DWORD, Reserved4: PVOID, pAuthzClientContext: PTR(PTR('void')) });
FN('RpcFreeAuthorizationContext', RPC_STATUS, { pAuthzClientContext: PTR(PTR('void')) });
FN('RpcSsContextLockExclusive', RPC_STATUS, { ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID });
FN('RpcSsContextLockShared', RPC_STATUS, { ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID });
FN('RpcServerInqCallAttributesW', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: PTR('void') });
FN('RpcServerInqCallAttributesA', RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: PTR('void') });
FN('RpcServerSubscribeForNotification', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Notification: RPC_NOTIFICATIONS, NotificationType: RPC_NOTIFICATION_TYPES, NotificationInfo: PTR(uint) });
FN('RpcServerUnsubscribeForNotification', RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Notification: RPC_NOTIFICATIONS, NotificationsQueued: PTR(ulong) });
FN('RpcBindingBind', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE });
FN('RpcBindingUnbind', RPC_STATUS, { Binding: RPC_BINDING_HANDLE });
FN('RpcDiagnoseError', RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE, RpcStatus: RPC_STATUS, EnumHandle: PTR(uint), Options: ULONG, ParentWindow: HWND });
FN('I_RpcAsyncSetHandle', RPC_STATUS, { Message: PRPC_MESSAGE, pAsync: PRPC_ASYNC_STATE });
FN('I_RpcAsyncAbortCall', RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, ExceptionCode: ulong });
FN('I_RpcExceptionFilter', 'void', { ExceptionCode: ulong });
FN('DragQueryFileA', UINT, { hDrop: HDROP, iFile: UINT, lpszFile: LPSTR, cch: UINT });
FN('DragQueryFileW', UINT, { hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT });
FN('DragQueryPoint', BOOL, { hDrop: HDROP, lppt: LPPOINT });
FN('DragFinish', 'void', { hDrop: HDROP });
FN('DragAcceptFiles', 'void', { hWnd: HWND, fAccept: BOOL });
FN('ShellExecuteA', HINSTANCE, { hwnd: HWND, lpOperation: LPCSTR, lpFile: LPCSTR, lpParameters: LPCSTR, lpDirectory: LPCSTR, nShowCmd: INT });
FN('ShellExecuteW', HINSTANCE, { hwnd: HWND, lpOperation: LPCWSTR, lpFile: LPCWSTR, lpParameters: LPCWSTR, lpDirectory: LPCWSTR, nShowCmd: INT });
FN('FindExecutableA', HINSTANCE, { lpFile: LPCSTR, lpDirectory: LPCSTR, lpResult: LPSTR });
FN('FindExecutableW', HINSTANCE, { lpFile: LPCWSTR, lpDirectory: LPCWSTR, lpResult: LPWSTR });
FN('CommandLineToArgvW', LPWSTR, { lpCmdLine: LPCWSTR, pNumArgs: PTR(int) });
FN('ShellAboutA', INT, { hWnd: HWND, szApp: LPCSTR, szOtherStuff: LPCSTR, hIcon: HICON });
FN('ShellAboutW', INT, { hWnd: HWND, szApp: LPCWSTR, szOtherStuff: LPCWSTR, hIcon: HICON });
FN('DuplicateIcon', HICON, { hInst: HINSTANCE, hIcon: HICON });
FN('ExtractAssociatedIconA', HICON, { hInst: HINSTANCE, pszIconPath: LPSTR, piIcon: PTR(ushort) });
FN('ExtractAssociatedIconW', HICON, { hInst: HINSTANCE, pszIconPath: LPWSTR, piIcon: PTR(ushort) });
FN('ExtractAssociatedIconExA', HICON, { hInst: HINSTANCE, pszIconPath: LPSTR, piIconIndex: PTR(ushort), piIconId: PTR(ushort) });
FN('ExtractAssociatedIconExW', HICON, { hInst: HINSTANCE, pszIconPath: LPWSTR, piIconIndex: PTR(ushort), piIconId: PTR(ushort) });
FN('ExtractIconA', HICON, { hInst: HINSTANCE, lpszExeFileName: LPCSTR, nIconIndex: UINT });
FN('ExtractIconW', HICON, { hInst: HINSTANCE, lpszExeFileName: LPCWSTR, nIconIndex: UINT });
FN('SHAppBarMessage', UINT_PTR, { dwMessage: DWORD, pData: PAPPBARDATA });
FN('DoEnvironmentSubstA', DWORD, { szString: LPSTR, cchString: UINT });
FN('DoEnvironmentSubstW', DWORD, { szString: LPWSTR, cchString: UINT });
FN('ExtractIconExA', UINT, { lpszFile: LPCSTR, nIconIndex: int, phiconLarge: PTR(pointer), phiconSmall: PTR(pointer), nIcons: UINT });
FN('ExtractIconExW', UINT, { lpszFile: LPCWSTR, nIconIndex: int, phiconLarge: PTR(pointer), phiconSmall: PTR(pointer), nIcons: UINT });
FN('SHFileOperationA', 'void', { lpFileOp: LPSHFILEOPSTRUCTA });
FN('SHFileOperationW', 'void', { lpFileOp: LPSHFILEOPSTRUCTW });
FN('SHFreeNameMappings', 'void', { hNameMappings: HANDLE });
FN('ShellExecuteExA', BOOL, { pExecInfo: PTR(uint) });
FN('ShellExecuteExW', BOOL, { pExecInfo: PTR(uint) });
FN('SHCreateProcessAsUserW', BOOL, { pscpi: PSHCREATEPROCESSINFOW });
FN('SHEvaluateSystemCommandTemplate', HRESULT, { pszCmdTemplate: PCWSTR, ppszApplication: PTR(PTR(ushort)), ppszCommandLine: PTR(PTR(ushort)), ppszParameters: PTR(PTR(ushort)) });
FN('AssocCreateForClasses', HRESULT, { rgClasses: PTR(uint), cClasses: ULONG, riid: PTR(uint), ppv: PTR(PTR('void')) });
FN('SHQueryRecycleBinA', HRESULT, { pszRootPath: LPCSTR, pSHQueryRBInfo: LPSHQUERYRBINFO });
FN('SHQueryRecycleBinW', HRESULT, { pszRootPath: LPCWSTR, pSHQueryRBInfo: LPSHQUERYRBINFO });
FN('SHEmptyRecycleBinA', HRESULT, { hwnd: HWND, pszRootPath: LPCSTR, dwFlags: DWORD });
FN('SHEmptyRecycleBinW', HRESULT, { hwnd: HWND, pszRootPath: LPCWSTR, dwFlags: DWORD });
FN('SHQueryUserNotificationState', HRESULT, { pquns: PTR(uint) });
FN('SHGetPropertyStoreForWindow', HRESULT, { hwnd: HWND, riid: PTR(uint), ppv: PTR(PTR('void')) });
FN('Shell_NotifyIconA', BOOL, { dwMessage: DWORD, lpData: PNOTIFYICONDATAA });
FN('Shell_NotifyIconW', BOOL, { dwMessage: DWORD, lpData: PNOTIFYICONDATAW });
FN('Shell_NotifyIconGetRect', HRESULT, { identifier: PTR(uint), iconLocation: PTR(uint) });
FN('SHGetFileInfoA', DWORD_PTR, { pszPath: LPCSTR, dwFileAttributes: DWORD, psfi: PTR(uint), cbFileInfo: UINT, uFlags: UINT });
FN('SHGetFileInfoW', DWORD_PTR, { pszPath: LPCWSTR, dwFileAttributes: DWORD, psfi: PTR(uint), cbFileInfo: UINT, uFlags: UINT });
FN('SHGetStockIconInfo', HRESULT, { siid: SHSTOCKICONID, uFlags: UINT, psii: PTR(uint) });
FN('SHGetDiskFreeSpaceExA', BOOL, { pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: PTR(uint), pulTotalNumberOfBytes: PTR(uint), pulTotalNumberOfFreeBytes: PTR(uint) });
FN('SHGetDiskFreeSpaceExW', BOOL, { pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: PTR(uint), pulTotalNumberOfBytes: PTR(uint), pulTotalNumberOfFreeBytes: PTR(uint) });
FN('SHGetNewLinkInfoA', BOOL, { pszLinkTo: LPCSTR, pszDir: LPCSTR, pszName: LPSTR, pfMustCopy: PTR(int), uFlags: UINT });
FN('SHGetNewLinkInfoW', BOOL, { pszLinkTo: LPCWSTR, pszDir: LPCWSTR, pszName: LPWSTR, pfMustCopy: PTR(int), uFlags: UINT });
FN('SHInvokePrinterCommandA', BOOL, { hwnd: HWND, uAction: UINT, lpBuf1: LPCSTR, lpBuf2: LPCSTR, fModal: BOOL });
FN('SHInvokePrinterCommandW', BOOL, { hwnd: HWND, uAction: UINT, lpBuf1: LPCWSTR, lpBuf2: LPCWSTR, fModal: BOOL });
FN('SHLoadNonloadedIconOverlayIdentifiers', HRESULT, {  });
FN('SHIsFileAvailableOffline', HRESULT, { pwszPath: LPCWSTR, pdwStatus: LPDWORD });
FN('SHSetLocalizedName', HRESULT, { pszPath: LPCWSTR, pszResModule: LPCWSTR, idsRes: int });
FN('SHRemoveLocalizedName', HRESULT, { pszPath: LPCWSTR });
FN('SHGetLocalizedName', HRESULT, { pszPath: LPCWSTR, pszResModule: LPWSTR, cch: UINT, pidsRes: PTR(int) });
FN('ShellMessageBoxA', 'void', { hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCSTR, lpcTitle: LPCSTR, fuStyle: UINT });
FN('ShellMessageBoxW', 'void', { hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCWSTR, lpcTitle: LPCWSTR, fuStyle: UINT });
FN('IsLFNDriveA', BOOL, { pszPath: LPCSTR });
FN('IsLFNDriveW', BOOL, { pszPath: LPCWSTR });
FN('SHEnumerateUnreadMailAccountsA', HRESULT, { hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPSTR, cchMailAddress: int });
FN('SHEnumerateUnreadMailAccountsW', HRESULT, { hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPWSTR, cchMailAddress: int });
FN('SHGetUnreadMailCountA', HRESULT, { hKeyUser: HKEY, pszMailAddress: LPCSTR, pdwCount: PTR(ulong), pFileTime: PTR(uint), pszShellExecuteCommand: LPSTR, cchShellExecuteCommand: int });
FN('SHGetUnreadMailCountW', HRESULT, { hKeyUser: HKEY, pszMailAddress: LPCWSTR, pdwCount: PTR(ulong), pFileTime: PTR(uint), pszShellExecuteCommand: LPWSTR, cchShellExecuteCommand: int });
FN('SHSetUnreadMailCountA', HRESULT, { pszMailAddress: LPCSTR, dwCount: DWORD, pszShellExecuteCommand: LPCSTR });
FN('SHSetUnreadMailCountW', HRESULT, { pszMailAddress: LPCWSTR, dwCount: DWORD, pszShellExecuteCommand: LPCWSTR });
FN('SHTestTokenMembership', BOOL, { hToken: HANDLE, ulRID: ULONG });
FN('SHGetImageList', HRESULT, { iImageList: int, riid: PTR(uint), ppvObj: PTR(PTR('void')) });
FN('InitNetworkAddressControl', BOOL, {  });
FN('SHGetDriveMedia', HRESULT, { pszDrive: LPCWSTR, pdwMediaContent: PTR(ulong) });
FN('__WSAFDIsSet', 'void', { PTR(uint): PTR(uint) });
FN('accept', SOCKET, { s: SOCKET, addr: PTR(sockaddr), addrlen: PTR(int) });
FN('bind', 'void', { s: SOCKET, addr: PTR(sockaddr), namelen: int });
FN('closesocket', 'void', { s: SOCKET });
FN('connect', 'void', { s: SOCKET, name: PTR(sockaddr), namelen: int });
FN('ioctlsocket', 'void', { s: SOCKET, cmd: long, argp: PTR(ulong) });
FN('getpeername', 'void', { s: SOCKET, name: PTR(sockaddr), namelen: PTR(int) });
FN('getsockname', 'void', { s: SOCKET, name: PTR(sockaddr), namelen: PTR(int) });
FN('getsockopt', 'void', { s: SOCKET, level: int, optname: int, optval: PTR(int8), optlen: PTR(int) });
FN('htonl', u_long, { hostlong: u_long });
FN('htons', u_short, { hostshort: u_short });
FN('inet_addr', 'void', { cp: PTR(int8) });
FN('inet_ntoa', 'void', { in: IN_ADDR });
FN('listen', 'void', { s: SOCKET, backlog: int });
FN('ntohl', u_long, { netlong: u_long });
FN('ntohs', u_short, { netshort: u_short });
FN('recv', 'void', { s: SOCKET, buf: PTR(int8), len: int, flags: int });
FN('recvfrom', 'void', { s: SOCKET, buf: PTR(int8), len: int, flags: int, from: PTR(sockaddr), fromlen: PTR(int) });
FN('select', 'void', { nfds: int, readfds: PTR(uint), writefds: PTR(uint), exceptfds: PTR(uint), timeout: PTR(timeval) });
FN('send', 'void', { s: SOCKET, buf: PTR(int8), len: int, flags: int });
FN('sendto', 'void', { s: SOCKET, buf: PTR(int8), len: int, flags: int, to: PTR(sockaddr), tolen: int });
FN('setsockopt', 'void', { s: SOCKET, level: int, optname: int, optval: PTR(int8), optlen: int });
FN('shutdown', 'void', { s: SOCKET, how: int });
FN('socket', SOCKET, { af: int, type: int, protocol: int });
FN('gethostbyaddr', HOSTENT, { addr: PTR(int8), len: int, type: int });
FN('gethostbyname', HOSTENT, { name: PTR(int8) });
FN('gethostname', 'void', { name: PTR(int8), namelen: int });
FN('getservbyport', SERVENT, { port: int, proto: PTR(int8) });
FN('getservbyname', SERVENT, { name: PTR(int8), proto: PTR(int8) });
FN('getprotobynumber', PROTOENT, { proto: int });
FN('getprotobyname', PROTOENT, { name: PTR(int8) });
FN('WSAStartup', 'void', { wVersionRequired: WORD, lpWSAData: LPWSADATA });
FN('WSACleanup', 'void', {  });
FN('WSASetLastError', 'void', { iError: int });
FN('WSAGetLastError', 'void', {  });
FN('WSAIsBlocking', BOOL, {  });
FN('WSAUnhookBlockingHook', 'void', {  });
FN('WSASetBlockingHook', FARPROC, { lpBlockFunc: FARPROC });
FN('WSACancelBlockingCall', 'void', {  });
FN('WSAAsyncGetServByName', HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), proto: PTR(int8), buf: PTR(int8), buflen: int });
FN('WSAAsyncGetServByPort', HANDLE, { hWnd: HWND, wMsg: u_int, port: int, proto: PTR(int8), buf: PTR(int8), buflen: int });
FN('WSAAsyncGetProtoByName', HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), buf: PTR(int8), buflen: int });
FN('WSAAsyncGetProtoByNumber', HANDLE, { hWnd: HWND, wMsg: u_int, number: int, buf: PTR(int8), buflen: int });
FN('WSAAsyncGetHostByName', HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), buf: PTR(int8), buflen: int });
FN('WSAAsyncGetHostByAddr', HANDLE, { hWnd: HWND, wMsg: u_int, addr: PTR(int8), len: int, type: int, buf: PTR(int8), buflen: int });
FN('WSACancelAsyncRequest', 'void', { hAsyncTaskHandle: HANDLE });
FN('WSAAsyncSelect', 'void', { s: SOCKET, hWnd: HWND, wMsg: u_int, lEvent: long });
FN('WSARecvEx', 'void', { s: SOCKET, buf: PTR(int8), len: int, flags: PTR(int) });
FN('TransmitFile', BOOL, { hSocket: SOCKET, hFile: HANDLE, nNumberOfBytesToWrite: DWORD, nNumberOfBytesPerSend: DWORD, lpOverlapped: LPOVERLAPPED, lpTransmitBuffers: LPTRANSMIT_FILE_BUFFERS, dwReserved: DWORD });
FN('AcceptEx', BOOL, { sListenSocket: SOCKET, sAcceptSocket: SOCKET, lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, lpdwBytesReceived: LPDWORD, lpOverlapped: LPOVERLAPPED });
FN('GetAcceptExSockaddrs', 'void', { lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, LocalSockaddr: PTR(PTR(sockaddr)), LocalSockaddrLength: LPINT, RemoteSockaddr: PTR(PTR(sockaddr)), RemoteSockaddrLength: LPINT });
FN('CryptAcquireContextA', BOOL, { phProv: PTR(ulong), szContainer: LPCSTR, szProvider: LPCSTR, dwProvType: DWORD, dwFlags: DWORD });
FN('CryptAcquireContextW', BOOL, { phProv: PTR(ulong), szContainer: LPCWSTR, szProvider: LPCWSTR, dwProvType: DWORD, dwFlags: DWORD });
FN('CryptReleaseContext', BOOL, { hProv: HCRYPTPROV, dwFlags: DWORD });
FN('CryptGenKey', BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, dwFlags: DWORD, phKey: PTR(ulong) });
FN('CryptDeriveKey', BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, hBaseData: HCRYPTHASH, dwFlags: DWORD, phKey: PTR(ulong) });
FN('CryptDestroyKey', BOOL, { hKey: HCRYPTKEY });
FN('CryptSetKeyParam', BOOL, { hKey: HCRYPTKEY, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD });
FN('CryptGetKeyParam', BOOL, { hKey: HCRYPTKEY, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD });
FN('CryptSetHashParam', BOOL, { hHash: HCRYPTHASH, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD });
FN('CryptGetHashParam', BOOL, { hHash: HCRYPTHASH, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD });
FN('CryptSetProvParam', BOOL, { hProv: HCRYPTPROV, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD });
FN('CryptGetProvParam', BOOL, { hProv: HCRYPTPROV, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD });
FN('CryptGenRandom', BOOL, { hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: PTR(uchar) });
FN('CryptGetUserKey', BOOL, { hProv: HCRYPTPROV, dwKeySpec: DWORD, phUserKey: PTR(ulong) });
FN('CryptExportKey', BOOL, { hKey: HCRYPTKEY, hExpKey: HCRYPTKEY, dwBlobType: DWORD, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong) });
FN('CryptImportKey', BOOL, { hProv: HCRYPTPROV, pbData: PTR(uchar), dwDataLen: DWORD, hPubKey: HCRYPTKEY, dwFlags: DWORD, phKey: PTR(ulong) });
FN('CryptEncrypt', BOOL, { hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: BOOL, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwBufLen: DWORD });
FN('CryptDecrypt', BOOL, { hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: BOOL, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong) });
FN('CryptCreateHash', BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, hKey: HCRYPTKEY, dwFlags: DWORD, phHash: PTR(ulong) });
FN('CryptHashData', BOOL, { hHash: HCRYPTHASH, pbData: PTR(uchar), dwDataLen: DWORD, dwFlags: DWORD });
FN('CryptHashSessionKey', BOOL, { hHash: HCRYPTHASH, hKey: HCRYPTKEY, dwFlags: DWORD });
FN('CryptDestroyHash', BOOL, { hHash: HCRYPTHASH });
FN('CryptSignHashA', BOOL, { hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCSTR, dwFlags: DWORD, pbSignature: PTR(uchar), pdwSigLen: PTR(ulong) });
FN('CryptSignHashW', BOOL, { hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCWSTR, dwFlags: DWORD, pbSignature: PTR(uchar), pdwSigLen: PTR(ulong) });
FN('CryptVerifySignatureA', BOOL, { hHash: HCRYPTHASH, pbSignature: PTR(uchar), dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCSTR, dwFlags: DWORD });
FN('CryptVerifySignatureW', BOOL, { hHash: HCRYPTHASH, pbSignature: PTR(uchar), dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCWSTR, dwFlags: DWORD });
FN('CryptSetProviderA', BOOL, { pszProvName: LPCSTR, dwProvType: DWORD });
FN('CryptSetProviderW', BOOL, { pszProvName: LPCWSTR, dwProvType: DWORD });
FN('CryptSetProviderExA', BOOL, { pszProvName: LPCSTR, dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD });
FN('CryptSetProviderExW', BOOL, { pszProvName: LPCWSTR, dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD });
FN('CryptGetDefaultProviderA', BOOL, { dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pszProvName: LPSTR, pcbProvName: PTR(ulong) });
FN('CryptGetDefaultProviderW', BOOL, { dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pszProvName: LPWSTR, pcbProvName: PTR(ulong) });
FN('CryptEnumProviderTypesA', BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szTypeName: LPSTR, pcbTypeName: PTR(ulong) });
FN('CryptEnumProviderTypesW', BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szTypeName: LPWSTR, pcbTypeName: PTR(ulong) });
FN('CryptEnumProvidersA', BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szProvName: LPSTR, pcbProvName: PTR(ulong) });
FN('CryptEnumProvidersW', BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szProvName: LPWSTR, pcbProvName: PTR(ulong) });
FN('CryptContextAddRef', BOOL, { hProv: HCRYPTPROV, pdwReserved: PTR(ulong), dwFlags: DWORD });
FN('CryptDuplicateKey', BOOL, { hKey: HCRYPTKEY, pdwReserved: PTR(ulong), dwFlags: DWORD, phKey: PTR(ulong) });
FN('CryptDuplicateHash', BOOL, { hHash: HCRYPTHASH, pdwReserved: PTR(ulong), dwFlags: DWORD, phHash: PTR(ulong) });
FN('GetEncSChannel', BOOL, { pData: PTR(PTR(uchar)), dwDecSize: PTR(ulong) });
FN('BCryptOpenAlgorithmProvider', NTSTATUS, { phAlgorithm: PTR(PTR('void')), pszAlgId: LPCWSTR, pszImplementation: LPCWSTR, dwFlags: ULONG });
FN('BCryptEnumAlgorithms', NTSTATUS, { dwAlgOperations: ULONG, pAlgCount: PTR(ulong), ppAlgList: PTR(PTR(uint)), dwFlags: ULONG });
FN('BCryptEnumProviders', NTSTATUS, { pszAlgId: LPCWSTR, pImplCount: PTR(ulong), ppImplList: PTR(PTR(uint)), dwFlags: ULONG });
FN('BCryptGetProperty', NTSTATUS, { hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptSetProperty', NTSTATUS, { hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG });
FN('BCryptCloseAlgorithmProvider', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, dwFlags: ULONG });
FN('BCryptFreeBuffer', 'void', { pvBuffer: PVOID });
FN('BCryptGenerateSymmetricKey', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phKey: PTR(PTR('void')), pbKeyObject: PUCHAR, cbKeyObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG });
FN('BCryptGenerateKeyPair', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phKey: PTR(PTR('void')), dwLength: ULONG, dwFlags: ULONG });
FN('BCryptEncrypt', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pbInput: PUCHAR, cbInput: ULONG, pPaddingInfo: PTR('void'), pbIV: PUCHAR, cbIV: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptDecrypt', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pbInput: PUCHAR, cbInput: ULONG, pPaddingInfo: PTR('void'), pbIV: PUCHAR, cbIV: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptExportKey', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, hExportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptImportKey', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, hImportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, phKey: PTR(PTR('void')), pbKeyObject: PUCHAR, cbKeyObject: ULONG, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG });
FN('BCryptImportKeyPair', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, hImportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, phKey: PTR(PTR('void')), pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG });
FN('BCryptDuplicateKey', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, phNewKey: PTR(PTR('void')), pbKeyObject: PUCHAR, cbKeyObject: ULONG, dwFlags: ULONG });
FN('BCryptFinalizeKeyPair', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, dwFlags: ULONG });
FN('BCryptDestroyKey', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE });
FN('BCryptDestroySecret', NTSTATUS, { hSecret: BCRYPT_SECRET_HANDLE });
FN('BCryptSignHash', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: PTR('void'), pbInput: PUCHAR, cbInput: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptVerifySignature', NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: PTR('void'), pbHash: PUCHAR, cbHash: ULONG, pbSignature: PUCHAR, cbSignature: ULONG, dwFlags: ULONG });
FN('BCryptSecretAgreement', NTSTATUS, { hPrivKey: BCRYPT_KEY_HANDLE, hPubKey: BCRYPT_KEY_HANDLE, phAgreedSecret: PTR(PTR('void')), dwFlags: ULONG });
FN('BCryptDeriveKey', NTSTATUS, { hSharedSecret: BCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: PTR(uint), pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('BCryptCreateHash', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phHash: PTR(PTR('void')), pbHashObject: PUCHAR, cbHashObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG });
FN('BCryptHashData', NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG });
FN('BCryptFinishHash', NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, pbOutput: PUCHAR, cbOutput: ULONG, dwFlags: ULONG });
FN('BCryptDuplicateHash', NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, phNewHash: PTR(PTR('void')), pbHashObject: PUCHAR, cbHashObject: ULONG, dwFlags: ULONG });
FN('BCryptDestroyHash', NTSTATUS, { hHash: BCRYPT_HASH_HANDLE });
FN('BCryptGenRandom', NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, pbBuffer: PUCHAR, cbBuffer: ULONG, dwFlags: ULONG });
FN('BCryptDeriveKeyCapi', NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, hTargetAlg: BCRYPT_ALG_HANDLE, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG });
FN('BCryptDeriveKeyPBKDF2', NTSTATUS, { hPrf: BCRYPT_ALG_HANDLE, pbPassword: PUCHAR, cbPassword: ULONG, pbSalt: PUCHAR, cbSalt: ULONG, cIterations: ULONGLONG, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG });
FN('BCryptQueryProviderRegistration', NTSTATUS, { pszProvider: LPCWSTR, dwMode: ULONG, dwInterface: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptEnumRegisteredProviders', NTSTATUS, { pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptCreateContext', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG });
FN('BCryptDeleteContext', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR });
FN('BCryptEnumContexts', NTSTATUS, { dwTable: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptConfigureContext', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG });
FN('BCryptQueryContextConfiguration', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptAddContextFunction', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, dwPosition: ULONG });
FN('BCryptRemoveContextFunction', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR });
FN('BCryptEnumContextFunctions', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptConfigureContextFunction', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pConfig: PCRYPT_CONTEXT_FUNCTION_CONFIG });
FN('BCryptQueryContextFunctionConfiguration', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptEnumContextFunctionProviders', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptSetContextFunctionProperty', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, cbValue: ULONG, pbValue: PUCHAR });
FN('BCryptQueryContextFunctionProperty', NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, pcbValue: PTR(ulong), ppbValue: PTR(PTR(uchar)) });
FN('BCryptRegisterConfigChangeNotify', NTSTATUS, { phEvent: PTR(PTR('void')) });
FN('BCryptUnregisterConfigChangeNotify', NTSTATUS, { hEvent: HANDLE });
FN('BCryptResolveProviders', NTSTATUS, { pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProvider: LPCWSTR, dwMode: ULONG, dwFlags: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(pointer) });
FN('BCryptGetFipsAlgorithmMode', NTSTATUS, { pfEnabled: PTR(uchar) });
FN('NCryptOpenStorageProvider', SECURITY_STATUS, { phProvider: PTR(ulong), pszProviderName: LPCWSTR, dwFlags: DWORD });
FN('NCryptEnumAlgorithms', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, dwAlgOperations: DWORD, pdwAlgCount: PTR(ulong), ppAlgList: PTR(PTR(uint)), dwFlags: DWORD });
FN('NCryptIsAlgSupported', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, pszAlgId: LPCWSTR, dwFlags: DWORD });
FN('NCryptEnumKeys', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, pszScope: LPCWSTR, ppKeyName: PTR(PTR(uint)), ppEnumState: PTR(PTR('void')), dwFlags: DWORD });
FN('NCryptEnumStorageProviders', SECURITY_STATUS, { pdwProviderCount: PTR(ulong), ppProviderList: PTR(PTR(uint)), dwFlags: DWORD });
FN('NCryptFreeBuffer', SECURITY_STATUS, { pvInput: PVOID });
FN('NCryptOpenKey', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phKey: PTR(ulong), pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD });
FN('NCryptCreatePersistedKey', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phKey: PTR(ulong), pszAlgId: LPCWSTR, pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD });
FN('NCryptGetProperty', SECURITY_STATUS, { hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD });
FN('NCryptSetProperty', SECURITY_STATUS, { hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PBYTE, cbInput: DWORD, dwFlags: DWORD });
FN('NCryptFinalizeKey', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD });
FN('NCryptEncrypt', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: PTR('void'), pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD });
FN('NCryptDecrypt', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: PTR('void'), pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD });
FN('NCryptImportKey', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, hImportKey: NCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pParameterList: PTR(uint), phKey: PTR(ulong), pbData: PBYTE, cbData: DWORD, dwFlags: DWORD });
FN('NCryptExportKey', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, hExportKey: NCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pParameterList: PTR(uint), pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD });
FN('NCryptSignHash', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: PTR('void'), pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD });
FN('NCryptVerifySignature', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: PTR('void'), pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, dwFlags: DWORD });
FN('NCryptDeleteKey', SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD });
FN('NCryptFreeObject', SECURITY_STATUS, { hObject: NCRYPT_HANDLE });
FN('NCryptIsKeyHandle', BOOL, { hKey: NCRYPT_KEY_HANDLE });
FN('NCryptTranslateHandle', SECURITY_STATUS, { phProvider: PTR(ulong), phKey: PTR(ulong), hLegacyProv: HCRYPTPROV, hLegacyKey: HCRYPTKEY, dwLegacyKeySpec: DWORD, dwFlags: DWORD });
FN('NCryptNotifyChangeKey', SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phEvent: PTR(PTR('void')), dwFlags: DWORD });
FN('NCryptSecretAgreement', SECURITY_STATUS, { hPrivKey: NCRYPT_KEY_HANDLE, hPubKey: NCRYPT_KEY_HANDLE, phAgreedSecret: PTR(ulong), dwFlags: DWORD });
FN('NCryptDeriveKey', SECURITY_STATUS, { hSharedSecret: NCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: PTR(uint), pbDerivedKey: PBYTE, cbDerivedKey: DWORD, pcbResult: PTR(ulong), dwFlags: ULONG });
FN('CryptFormatObject', BOOL, { dwCertEncodingType: DWORD, dwFormatType: DWORD, dwFormatStrType: DWORD, pFormatStruct: PTR('void'), lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbFormat: PTR('void'), pcbFormat: PTR(ulong) });
FN('CryptEncodeObjectEx', BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: PTR('void'), dwFlags: DWORD, pEncodePara: PCRYPT_ENCODE_PARA, pvEncoded: PTR('void'), pcbEncoded: PTR(ulong) });
FN('CryptEncodeObject', BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: PTR('void'), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) });
FN('CryptDecodeObjectEx', BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pDecodePara: PCRYPT_DECODE_PARA, pvStructInfo: PTR('void'), pcbStructInfo: PTR(ulong) });
FN('CryptDecodeObject', BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pvStructInfo: PTR('void'), pcbStructInfo: PTR(ulong) });
FN('CryptInstallOIDFunctionAddress', BOOL, { hModule: HMODULE, dwEncodingType: DWORD, pszFuncName: LPCSTR, cFuncEntry: DWORD, rgFuncEntry: PTR(uint), dwFlags: DWORD });
FN('CryptInitOIDFunctionSet', HCRYPTOIDFUNCSET, { pszFuncName: LPCSTR, dwFlags: DWORD });
FN('CryptGetOIDFunctionAddress', BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pszOID: LPCSTR, dwFlags: DWORD, ppvFuncAddr: PTR(PTR('void')), phFuncAddr: PTR(PTR('void')) });
FN('CryptGetDefaultOIDDllList', BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDllList: PTR(ushort), pcchDllList: PTR(ulong) });
FN('CryptGetDefaultOIDFunctionAddress', BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDll: LPCWSTR, dwFlags: DWORD, ppvFuncAddr: PTR(PTR('void')), phFuncAddr: PTR(PTR('void')) });
FN('CryptFreeOIDFunctionAddress', BOOL, { hFuncAddr: HCRYPTOIDFUNCADDR, dwFlags: DWORD });
FN('CryptRegisterOIDFunction', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszDll: LPCWSTR, pszOverrideFuncName: LPCSTR });
FN('CryptUnregisterOIDFunction', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR });
FN('CryptRegisterDefaultOIDFunction', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, dwIndex: DWORD, pwszDll: LPCWSTR });
FN('CryptUnregisterDefaultOIDFunction', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pwszDll: LPCWSTR });
FN('CryptSetOIDFunctionValue', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, dwValueType: DWORD, pbValueData: PTR(uchar), cbValueData: DWORD });
FN('CryptGetOIDFunctionValue', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, pdwValueType: PTR(ulong), pbValueData: PTR(uchar), pcbValueData: PTR(ulong) });
FN('CryptEnumOIDFunction', BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, dwFlags: DWORD, pvArg: PTR('void'), pfnEnumOIDFunc: PFN_CRYPT_ENUM_OID_FUNC });
FN('CryptFindOIDInfo', PCCRYPT_OID_INFO, { dwKeyType: DWORD, pvKey: PTR('void'), dwGroupId: DWORD });
FN('CryptRegisterOIDInfo', BOOL, { pInfo: PCCRYPT_OID_INFO, dwFlags: DWORD });
FN('CryptUnregisterOIDInfo', BOOL, { pInfo: PCCRYPT_OID_INFO });
FN('CryptEnumOIDInfo', BOOL, { dwGroupId: DWORD, dwFlags: DWORD, pvArg: PTR('void'), pfnEnumOIDInfo: PFN_CRYPT_ENUM_OID_INFO });
FN('CryptFindLocalizedName', LPCWSTR, { pwszCryptName: LPCWSTR });
FN('CryptMsgOpenToEncode', HCRYPTMSG, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: PTR('void'), pszInnerContentObjID: LPSTR, pStreamInfo: PCMSG_STREAM_INFO });
FN('CryptMsgCalculateEncodedLength', DWORD, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: PTR('void'), pszInnerContentObjID: LPSTR, cbData: DWORD });
FN('CryptMsgOpenToDecode', HCRYPTMSG, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, pRecipientInfo: PCERT_INFO, pStreamInfo: PCMSG_STREAM_INFO });
FN('CryptMsgDuplicate', HCRYPTMSG, { hCryptMsg: HCRYPTMSG });
FN('CryptMsgClose', BOOL, { hCryptMsg: HCRYPTMSG });
FN('CryptMsgUpdate', BOOL, { hCryptMsg: HCRYPTMSG, pbData: PTR(uchar), cbData: DWORD, fFinal: BOOL });
FN('CryptMsgGetParam', BOOL, { hCryptMsg: HCRYPTMSG, dwParamType: DWORD, dwIndex: DWORD, pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CryptMsgControl', BOOL, { hCryptMsg: HCRYPTMSG, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: PTR('void') });
FN('CryptMsgVerifyCountersignatureEncoded', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE, cbSignerInfoCountersignature: DWORD, pciCountersigner: PCERT_INFO });
FN('CryptMsgVerifyCountersignatureEncodedEx', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE, cbSignerInfoCountersignature: DWORD, dwSignerType: DWORD, pvSigner: PTR('void'), dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptMsgCountersign', BOOL, { hCryptMsg: HCRYPTMSG, dwIndex: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO });
FN('CryptMsgCountersignEncoded', BOOL, { dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO, pbCountersignature: PBYTE, pcbCountersignature: PDWORD });
FN('CertOpenStore', HCERTSTORE, { lpszStoreProvider: LPCSTR, dwEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pvPara: PTR('void') });
FN('CertDuplicateStore', HCERTSTORE, { hCertStore: HCERTSTORE });
FN('CertSaveStore', BOOL, { hCertStore: HCERTSTORE, dwEncodingType: DWORD, dwSaveAs: DWORD, dwSaveTo: DWORD, pvSaveToPara: PTR('void'), dwFlags: DWORD });
FN('CertCloseStore', BOOL, { hCertStore: HCERTSTORE, dwFlags: DWORD });
FN('CertGetSubjectCertificateFromStore', PCCERT_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pCertId: PCERT_INFO });
FN('CertEnumCertificatesInStore', PCCERT_CONTEXT, { hCertStore: HCERTSTORE, pPrevCertContext: PCCERT_CONTEXT });
FN('CertFindCertificateInStore', PCCERT_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR('void'), pPrevCertContext: PCCERT_CONTEXT });
FN('CertGetIssuerCertificateFromStore', PCCERT_CONTEXT, { hCertStore: HCERTSTORE, pSubjectContext: PCCERT_CONTEXT, pPrevIssuerContext: PCCERT_CONTEXT, pdwFlags: PTR(ulong) });
FN('CertVerifySubjectCertificateContext', BOOL, { pSubject: PCCERT_CONTEXT, pIssuer: PCCERT_CONTEXT, pdwFlags: PTR(ulong) });
FN('CertDuplicateCertificateContext', PCCERT_CONTEXT, { pCertContext: PCCERT_CONTEXT });
FN('CertCreateCertificateContext', PCCERT_CONTEXT, { dwCertEncodingType: DWORD, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD });
FN('CertFreeCertificateContext', BOOL, { pCertContext: PCCERT_CONTEXT });
FN('CertSetCertificateContextProperty', BOOL, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR('void') });
FN('CertGetCertificateContextProperty', BOOL, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CertEnumCertificateContextProperties', DWORD, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD });
FN('CertCreateCTLEntryFromCertificateContextProperties', BOOL, { pCertContext: PCCERT_CONTEXT, cOptAttr: DWORD, rgOptAttr: PCRYPT_ATTRIBUTE, dwFlags: DWORD, pvReserved: PTR('void'), pCtlEntry: PCTL_ENTRY, pcbCtlEntry: PTR(ulong) });
FN('CertSetCertificateContextPropertiesFromCTLEntry', BOOL, { pCertContext: PCCERT_CONTEXT, pCtlEntry: PCTL_ENTRY, dwFlags: DWORD });
FN('CertGetCRLFromStore', PCCRL_CONTEXT, { hCertStore: HCERTSTORE, pIssuerContext: PCCERT_CONTEXT, pPrevCrlContext: PCCRL_CONTEXT, pdwFlags: PTR(ulong) });
FN('CertEnumCRLsInStore', PCCRL_CONTEXT, { hCertStore: HCERTSTORE, pPrevCrlContext: PCCRL_CONTEXT });
FN('CertFindCRLInStore', PCCRL_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR('void'), pPrevCrlContext: PCCRL_CONTEXT });
FN('CertDuplicateCRLContext', PCCRL_CONTEXT, { pCrlContext: PCCRL_CONTEXT });
FN('CertCreateCRLContext', PCCRL_CONTEXT, { dwCertEncodingType: DWORD, pbCrlEncoded: PTR(uchar), cbCrlEncoded: DWORD });
FN('CertFreeCRLContext', BOOL, { pCrlContext: PCCRL_CONTEXT });
FN('CertSetCRLContextProperty', BOOL, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR('void') });
FN('CertGetCRLContextProperty', BOOL, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CertEnumCRLContextProperties', DWORD, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD });
FN('CertFindCertificateInCRL', BOOL, { pCert: PCCERT_CONTEXT, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: PTR('void'), ppCrlEntry: PTR(pointer) });
FN('CertIsValidCRLForCertificate', BOOL, { pCert: PCCERT_CONTEXT, pCrl: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: PTR('void') });
FN('CertAddEncodedCertificateToStore', BOOL, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD, dwAddDisposition: DWORD, ppCertContext: PTR(pointer) });
FN('CertAddCertificateContextToStore', BOOL, { hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertAddSerializedElementToStore', BOOL, { hCertStore: HCERTSTORE, pbElement: PTR(uchar), cbElement: DWORD, dwAddDisposition: DWORD, dwFlags: DWORD, dwContextTypeFlags: DWORD, pdwContextType: PTR(ulong), ppvContext: PTR(PTR('void')) });
FN('CertDeleteCertificateFromStore', BOOL, { pCertContext: PCCERT_CONTEXT });
FN('CertAddEncodedCRLToStore', BOOL, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCrlEncoded: PTR(uchar), cbCrlEncoded: DWORD, dwAddDisposition: DWORD, ppCrlContext: PTR(pointer) });
FN('CertAddCRLContextToStore', BOOL, { hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertDeleteCRLFromStore', BOOL, { pCrlContext: PCCRL_CONTEXT });
FN('CertSerializeCertificateStoreElement', BOOL, { pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) });
FN('CertSerializeCRLStoreElement', BOOL, { pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) });
FN('CertDuplicateCTLContext', PCCTL_CONTEXT, { pCtlContext: PCCTL_CONTEXT });
FN('CertCreateCTLContext', PCCTL_CONTEXT, { dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: PTR(uchar), cbCtlEncoded: DWORD });
FN('CertFreeCTLContext', BOOL, { pCtlContext: PCCTL_CONTEXT });
FN('CertSetCTLContextProperty', BOOL, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR('void') });
FN('CertGetCTLContextProperty', BOOL, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CertEnumCTLContextProperties', DWORD, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD });
FN('CertEnumCTLsInStore', PCCTL_CONTEXT, { hCertStore: HCERTSTORE, pPrevCtlContext: PCCTL_CONTEXT });
FN('CertFindSubjectInCTL', PCTL_ENTRY, { dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR('void'), pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD });
FN('CertFindCTLInStore', PCCTL_CONTEXT, { hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR('void'), pPrevCtlContext: PCCTL_CONTEXT });
FN('CertAddEncodedCTLToStore', BOOL, { hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: PTR(uchar), cbCtlEncoded: DWORD, dwAddDisposition: DWORD, ppCtlContext: PTR(pointer) });
FN('CertAddCTLContextToStore', BOOL, { hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertSerializeCTLStoreElement', BOOL, { pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) });
FN('CertDeleteCTLFromStore', BOOL, { pCtlContext: PCCTL_CONTEXT });
FN('CertAddCertificateLinkToStore', BOOL, { hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertAddCRLLinkToStore', BOOL, { hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertAddCTLLinkToStore', BOOL, { hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(pointer) });
FN('CertAddStoreToCollection', BOOL, { hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE, dwUpdateFlags: DWORD, dwPriority: DWORD });
FN('CertRemoveStoreFromCollection', 'void', { hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE });
FN('CertControlStore', BOOL, { hCertStore: HCERTSTORE, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: PTR('void') });
FN('CertSetStoreProperty', BOOL, { hCertStore: HCERTSTORE, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR('void') });
FN('CertGetStoreProperty', BOOL, { hCertStore: HCERTSTORE, dwPropId: DWORD, pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CertCreateContext', 'void', { dwContextType: DWORD, dwEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pCreatePara: PCERT_CREATE_CONTEXT_PARA });
FN('CertRegisterSystemStore', BOOL, { pvSystemStore: PTR('void'), dwFlags: DWORD, pStoreInfo: PCERT_SYSTEM_STORE_INFO, pvReserved: PTR('void') });
FN('CertRegisterPhysicalStore', BOOL, { pvSystemStore: PTR('void'), dwFlags: DWORD, pwszStoreName: LPCWSTR, pStoreInfo: PCERT_PHYSICAL_STORE_INFO, pvReserved: PTR('void') });
FN('CertUnregisterSystemStore', BOOL, { pvSystemStore: PTR('void'), dwFlags: DWORD });
FN('CertUnregisterPhysicalStore', BOOL, { pvSystemStore: PTR('void'), dwFlags: DWORD, pwszStoreName: LPCWSTR });
FN('CertEnumSystemStoreLocation', BOOL, { dwFlags: DWORD, pvArg: PTR('void'), pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE_LOCATION });
FN('CertEnumSystemStore', BOOL, { dwFlags: DWORD, pvSystemStoreLocationPara: PTR('void'), pvArg: PTR('void'), pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE });
FN('CertEnumPhysicalStore', BOOL, { pvSystemStore: PTR('void'), dwFlags: DWORD, pvArg: PTR('void'), pfnEnum: PFN_CERT_ENUM_PHYSICAL_STORE });
FN('CertGetEnhancedKeyUsage', BOOL, { pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pUsage: PCERT_ENHKEY_USAGE, pcbUsage: PTR(ulong) });
FN('CertSetEnhancedKeyUsage', BOOL, { pCertContext: PCCERT_CONTEXT, pUsage: PCERT_ENHKEY_USAGE });
FN('CertAddEnhancedKeyUsageIdentifier', BOOL, { pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR });
FN('CertRemoveEnhancedKeyUsageIdentifier', BOOL, { pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR });
FN('CertGetValidUsages', BOOL, { cCerts: DWORD, rghCerts: PTR(pointer), cNumOIDs: PTR(int), rghOIDs: PTR(PTR(int8)), pcbOIDs: PTR(ulong) });
FN('CryptMsgGetAndVerifySigner', BOOL, { hCryptMsg: HCRYPTMSG, cSignerStore: DWORD, rghSignerStore: PTR(PTR('void')), dwFlags: DWORD, ppSigner: PTR(pointer), pdwSignerIndex: PTR(ulong) });
FN('CryptMsgSignCTL', BOOL, { dwMsgEncodingType: DWORD, pbCtlContent: PTR(uchar), cbCtlContent: DWORD, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) });
FN('CryptMsgEncodeAndSignCTL', BOOL, { dwMsgEncodingType: DWORD, pCtlInfo: PCTL_INFO, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) });
FN('CertFindSubjectInSortedCTL', BOOL, { pSubjectIdentifier: PCRYPT_DATA_BLOB, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pvReserved: PTR('void'), pEncodedAttributes: PCRYPT_DER_BLOB });
FN('CertEnumSubjectInSortedCTL', BOOL, { pCtlContext: PCCTL_CONTEXT, ppvNextSubject: PTR(PTR('void')), pSubjectIdentifier: PCRYPT_DER_BLOB, pEncodedAttributes: PCRYPT_DER_BLOB });
FN('CertVerifyCTLUsage', BOOL, { dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR('void'), pSubjectUsage: PCTL_USAGE, dwFlags: DWORD, pVerifyUsagePara: PCTL_VERIFY_USAGE_PARA, pVerifyUsageStatus: PCTL_VERIFY_USAGE_STATUS });
FN('CertVerifyRevocation', BOOL, { dwEncodingType: DWORD, dwRevType: DWORD, cContext: DWORD, rgpvContext: PTR(PTR('void')), dwFlags: DWORD, pRevPara: PCERT_REVOCATION_PARA, pRevStatus: PCERT_REVOCATION_STATUS });
FN('CertCompareIntegerBlob', BOOL, { pInt1: PCRYPT_INTEGER_BLOB, pInt2: PCRYPT_INTEGER_BLOB });
FN('CertCompareCertificate', BOOL, { dwCertEncodingType: DWORD, pCertId1: PCERT_INFO, pCertId2: PCERT_INFO });
FN('CertCompareCertificateName', BOOL, { dwCertEncodingType: DWORD, pCertName1: PCERT_NAME_BLOB, pCertName2: PCERT_NAME_BLOB });
FN('CertIsRDNAttrsInCertificateName', BOOL, { dwCertEncodingType: DWORD, dwFlags: DWORD, pCertName: PCERT_NAME_BLOB, pRDN: PCERT_RDN });
FN('CertComparePublicKeyInfo', BOOL, { dwCertEncodingType: DWORD, pPublicKey1: PCERT_PUBLIC_KEY_INFO, pPublicKey2: PCERT_PUBLIC_KEY_INFO });
FN('CertGetPublicKeyLength', DWORD, { dwCertEncodingType: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO });
FN('CryptVerifyCertificateSignature', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO });
FN('CryptVerifyCertificateSignatureEx', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR('void'), dwIssuerType: DWORD, pvIssuer: PTR('void'), dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptHashToBeSigned', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptHashCertificate', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptHashCertificate2', BOOL, { pwszCNGHashAlgid: LPCWSTR, dwFlags: DWORD, pvReserved: PTR('void'), pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptSignCertificate', BOOL, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pbEncodedToBeSigned: PTR(uchar), cbEncodedToBeSigned: DWORD, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: PTR('void'), pbSignature: PTR(uchar), pcbSignature: PTR(ulong) });
FN('CryptSignAndEncodeCertificate', BOOL, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: PTR('void'), pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: PTR('void'), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) });
FN('CertVerifyTimeValidity', LONG, { pTimeToVerify: LPFILETIME, pCertInfo: PCERT_INFO });
FN('CertVerifyCRLTimeValidity', LONG, { pTimeToVerify: LPFILETIME, pCrlInfo: PCRL_INFO });
FN('CertVerifyValidityNesting', BOOL, { pSubjectInfo: PCERT_INFO, pIssuerInfo: PCERT_INFO });
FN('CertVerifyCRLRevocation', BOOL, { dwCertEncodingType: DWORD, pCertId: PCERT_INFO, cCrlInfo: DWORD, rgpCrlInfo: PTR(pointer) });
FN('CertAlgIdToOID', LPCSTR, { dwAlgId: DWORD });
FN('CertOIDToAlgId', DWORD, { pszObjId: LPCSTR });
FN('CertFindExtension', PCERT_EXTENSION, { pszObjId: LPCSTR, cExtensions: DWORD, rgExtensions: PTR(uint) });
FN('CertFindAttribute', PCRYPT_ATTRIBUTE, { pszObjId: LPCSTR, cAttr: DWORD, rgAttr: PTR(uint) });
FN('CertFindRDNAttr', PCERT_RDN_ATTR, { pszObjId: LPCSTR, pName: PCERT_NAME_INFO });
FN('CertGetIntendedKeyUsage', BOOL, { dwCertEncodingType: DWORD, pCertInfo: PCERT_INFO, pbKeyUsage: PTR(uchar), cbKeyUsage: DWORD });
FN('CryptInstallDefaultContext', BOOL, { hCryptProv: HCRYPTPROV, dwDefaultType: DWORD, pvDefaultPara: PTR('void'), dwFlags: DWORD, pvReserved: PTR('void'), phDefaultContext: PTR(PTR('void')) });
FN('CryptUninstallDefaultContext', BOOL, { hDefaultContext: HCRYPTDEFAULTCONTEXT, dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptExportPublicKeyInfo', BOOL, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: PTR(ulong) });
FN('CryptExportPublicKeyInfoEx', BOOL, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: PTR('void'), pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: PTR(ulong) });
FN('CryptExportPublicKeyInfoFromBCryptKeyHandle', BOOL, { hBCryptKey: BCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: PTR('void'), pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: PTR(ulong) });
FN('CryptImportPublicKeyInfo', BOOL, { hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, phKey: PTR(ulong) });
FN('CryptImportPublicKeyInfoEx', BOOL, { hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, aiKeyAlg: ALG_ID, dwFlags: DWORD, pvAuxInfo: PTR('void'), phKey: PTR(ulong) });
FN('CryptImportPublicKeyInfoEx2', BOOL, { dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, dwFlags: DWORD, pvAuxInfo: PTR('void'), phKey: PTR(PTR('void')) });
FN('CryptAcquireCertificatePrivateKey', BOOL, { pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: PTR('void'), phCryptProvOrNCryptKey: PTR(ulong), pdwKeySpec: PTR(ulong), pfCallerFreeProvOrNCryptKey: PTR(int) });
FN('CryptFindCertificateKeyProvInfo', BOOL, { pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptImportPKCS8', BOOL, { sPrivateKeyAndParams: CRYPT_PKCS8_IMPORT_PARAMS, dwFlags: DWORD, phCryptProv: PTR(ulong), pvAuxInfo: PTR('void') });
FN('CryptExportPKCS8', BOOL, { hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, pszPrivateKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: PTR('void'), pbPrivateKeyBlob: PTR(uchar), pcbPrivateKeyBlob: PTR(ulong) });
FN('CryptExportPKCS8Ex', BOOL, { psExportParams: PTR(uint), dwFlags: DWORD, pvAuxInfo: PTR('void'), pbPrivateKeyBlob: PTR(uchar), pcbPrivateKeyBlob: PTR(ulong) });
FN('CryptHashPublicKeyInfo', BOOL, { hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CertRDNValueToStrA', DWORD, { dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPSTR, csz: DWORD });
FN('CertRDNValueToStrW', DWORD, { dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPWSTR, csz: DWORD });
FN('CertNameToStrA', DWORD, { dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPSTR, csz: DWORD });
FN('CertNameToStrW', DWORD, { dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPWSTR, csz: DWORD });
FN('CertStrToNameA', BOOL, { dwCertEncodingType: DWORD, pszX500: LPCSTR, dwStrType: DWORD, pvReserved: PTR('void'), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong), ppszError: PTR(PTR(int8)) });
FN('CertStrToNameW', BOOL, { dwCertEncodingType: DWORD, pszX500: LPCWSTR, dwStrType: DWORD, pvReserved: PTR('void'), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong), ppszError: PTR(PTR(ushort)) });
FN('CertGetNameStringA', DWORD, { pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: PTR('void'), pszNameString: LPSTR, cchNameString: DWORD });
FN('CertGetNameStringW', DWORD, { pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: PTR('void'), pszNameString: LPWSTR, cchNameString: DWORD });
FN('CryptSignMessage', BOOL, { pSignPara: PCRYPT_SIGN_MESSAGE_PARA, fDetachedSignature: BOOL, cToBeSigned: DWORD, rgpbToBeSigned: PTR(PTR(uchar)), rgcbToBeSigned: PTR(ulong), pbSignedBlob: PTR(uchar), pcbSignedBlob: PTR(ulong) });
FN('CryptVerifyMessageSignature', BOOL, { pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD, pbDecoded: PTR(uchar), pcbDecoded: PTR(ulong), ppSignerCert: PTR(pointer) });
FN('CryptGetMessageSignerCount', LONG, { dwMsgEncodingType: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD });
FN('CryptGetMessageCertificates', HCERTSTORE, { dwMsgAndCertEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD });
FN('CryptVerifyDetachedMessageSignature', BOOL, { pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbDetachedSignBlob: PTR(uchar), cbDetachedSignBlob: DWORD, cToBeSigned: DWORD, rgpbToBeSigned: PTR(PTR(uchar)), rgcbToBeSigned: PTR(ulong), ppSignerCert: PTR(pointer) });
FN('CryptEncryptMessage', BOOL, { pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: PTR(pointer), pbToBeEncrypted: PTR(uchar), cbToBeEncrypted: DWORD, pbEncryptedBlob: PTR(uchar), pcbEncryptedBlob: PTR(ulong) });
FN('CryptDecryptMessage', BOOL, { pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pbEncryptedBlob: PTR(uchar), cbEncryptedBlob: DWORD, pbDecrypted: PTR(uchar), pcbDecrypted: PTR(ulong), ppXchgCert: PTR(pointer) });
FN('CryptSignAndEncryptMessage', BOOL, { pSignPara: PCRYPT_SIGN_MESSAGE_PARA, pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: PTR(pointer), pbToBeSignedAndEncrypted: PTR(uchar), cbToBeSignedAndEncrypted: DWORD, pbSignedAndEncryptedBlob: PTR(uchar), pcbSignedAndEncryptedBlob: PTR(ulong) });
FN('CryptDecryptAndVerifyMessageSignature', BOOL, { pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbEncryptedBlob: PTR(uchar), cbEncryptedBlob: DWORD, pbDecrypted: PTR(uchar), pcbDecrypted: PTR(ulong), ppXchgCert: PTR(pointer), ppSignerCert: PTR(pointer) });
FN('CryptDecodeMessage', BOOL, { dwMsgTypeFlags: DWORD, pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbEncodedBlob: PTR(uchar), cbEncodedBlob: DWORD, dwPrevInnerContentType: DWORD, pdwMsgType: PTR(ulong), pdwInnerContentType: PTR(ulong), pbDecoded: PTR(uchar), pcbDecoded: PTR(ulong), ppXchgCert: PTR(pointer), ppSignerCert: PTR(pointer) });
FN('CryptHashMessage', BOOL, { pHashPara: PCRYPT_HASH_MESSAGE_PARA, fDetachedHash: BOOL, cToBeHashed: DWORD, rgpbToBeHashed: PTR(PTR(uchar)), rgcbToBeHashed: PTR(ulong), pbHashedBlob: PTR(uchar), pcbHashedBlob: PTR(ulong), pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptVerifyMessageHash', BOOL, { pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbHashedBlob: PTR(uchar), cbHashedBlob: DWORD, pbToBeHashed: PTR(uchar), pcbToBeHashed: PTR(ulong), pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptVerifyDetachedMessageHash', BOOL, { pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbDetachedHashBlob: PTR(uchar), cbDetachedHashBlob: DWORD, cToBeHashed: DWORD, rgpbToBeHashed: PTR(PTR(uchar)), rgcbToBeHashed: PTR(ulong), pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) });
FN('CryptSignMessageWithKey', BOOL, { pSignPara: PCRYPT_KEY_SIGN_MESSAGE_PARA, pbToBeSigned: PTR(uchar), cbToBeSigned: DWORD, pbSignedBlob: PTR(uchar), pcbSignedBlob: PTR(ulong) });
FN('CryptVerifyMessageSignatureWithKey', BOOL, { pVerifyPara: PCRYPT_KEY_VERIFY_MESSAGE_PARA, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD, pbDecoded: PTR(uchar), pcbDecoded: PTR(ulong) });
FN('CertOpenSystemStoreA', HCERTSTORE, { hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCSTR });
FN('CertOpenSystemStoreW', HCERTSTORE, { hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCWSTR });
FN('CertAddEncodedCertificateToSystemStoreA', BOOL, { szCertStoreName: LPCSTR, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD });
FN('CertAddEncodedCertificateToSystemStoreW', BOOL, { szCertStoreName: LPCWSTR, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD });
FN('FindCertsByIssuer', HRESULT, { pCertChains: PCERT_CHAIN, pcbCertChains: PTR(ulong), pcCertChains: PTR(ulong), pbEncodedIssuerName: PTR(uchar), cbEncodedIssuerName: DWORD, pwszPurpose: LPCWSTR, dwKeySpec: DWORD });
FN('CryptQueryObject', BOOL, { dwObjectType: DWORD, pvObject: PTR('void'), dwExpectedContentTypeFlags: DWORD, dwExpectedFormatTypeFlags: DWORD, dwFlags: DWORD, pdwMsgAndCertEncodingType: PTR(ulong), pdwContentType: PTR(ulong), pdwFormatType: PTR(ulong), phCertStore: PTR(PTR('void')), phMsg: PTR(PTR('void')), ppvContext: PTR(PTR('void')) });
FN('CryptMemAlloc', LPVOID, { cbSize: ULONG });
FN('CryptMemRealloc', LPVOID, { pv: LPVOID, cbSize: ULONG });
FN('CryptMemFree', 'void', { pv: LPVOID });
FN('CryptCreateAsyncHandle', BOOL, { dwFlags: DWORD, phAsync: PHCRYPTASYNC });
FN('CryptSetAsyncParam', BOOL, { hAsync: HCRYPTASYNC, pszParamOid: LPSTR, pvParam: LPVOID, pfnFree: PFN_CRYPT_ASYNC_PARAM_FREE_FUNC });
FN('CryptGetAsyncParam', BOOL, { hAsync: HCRYPTASYNC, pszParamOid: LPSTR, ppvParam: PTR(PTR('void')), ppfnFree: PTR(PFN_CRYPT_ASYNC_PARAM_FREE_FUNC) });
FN('CryptCloseAsyncHandle', BOOL, { hAsync: HCRYPTASYNC });
FN('CryptRetrieveObjectByUrlA', BOOL, { pszUrl: LPCSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: PTR(PTR('void')), hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO });
FN('CryptRetrieveObjectByUrlW', BOOL, { pszUrl: LPCWSTR, pszObjectOid: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, ppvObject: PTR(PTR('void')), hAsyncRetrieve: HCRYPTASYNC, pCredentials: PCRYPT_CREDENTIALS, pvVerify: LPVOID, pAuxInfo: PCRYPT_RETRIEVE_AUX_INFO });
FN('CryptInstallCancelRetrieval', BOOL, { pfnCancel: PFN_CRYPT_CANCEL_RETRIEVAL, pvArg: PTR('void'), dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptUninstallCancelRetrieval', BOOL, { dwFlags: DWORD, pvReserved: PTR('void') });
FN('CryptCancelAsyncRetrieval', BOOL, { hAsyncRetrieval: HCRYPTASYNC });
FN('CryptGetObjectUrl', BOOL, { pszUrlOid: LPCSTR, pvPara: LPVOID, dwFlags: DWORD, pUrlArray: PCRYPT_URL_ARRAY, pcbUrlArray: PTR(ulong), pUrlInfo: PCRYPT_URL_INFO, pcbUrlInfo: PTR(ulong), pvReserved: LPVOID });
FN('CryptGetTimeValidObject', BOOL, { pszTimeValidOid: LPCSTR, pvPara: LPVOID, pIssuer: PCCERT_CONTEXT, pftValidFor: LPFILETIME, dwFlags: DWORD, dwTimeout: DWORD, ppvObject: PTR(PTR('void')), pCredentials: PCRYPT_CREDENTIALS, pExtraInfo: PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO });
FN('CryptFlushTimeValidObject', BOOL, { pszFlushTimeValidOid: LPCSTR, pvPara: LPVOID, pIssuer: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID });
FN('CryptProtectData', BOOL, { pDataIn: PTR(uint), szDataDescr: LPCWSTR, pOptionalEntropy: PTR(uint), pvReserved: PVOID, pPromptStruct: PTR(uint), dwFlags: DWORD, pDataOut: PTR(uint) });
FN('CryptUnprotectData', BOOL, { pDataIn: PTR(uint), ppszDataDescr: PTR(PTR(ushort)), pOptionalEntropy: PTR(uint), pvReserved: PVOID, pPromptStruct: PTR(uint), dwFlags: DWORD, pDataOut: PTR(uint) });
FN('CryptUpdateProtectedState', BOOL, { pOldSid: PSID, pwszOldPassword: LPCWSTR, dwFlags: DWORD, pdwSuccessCount: PTR(ulong), pdwFailureCount: PTR(ulong) });
FN('CryptProtectMemory', BOOL, { pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD });
FN('CryptUnprotectMemory', BOOL, { pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD });
FN('CertCreateSelfSignCertificate', PCCERT_CONTEXT, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pSubjectIssuerBlob: PCERT_NAME_BLOB, dwFlags: DWORD, pKeyProvInfo: PCRYPT_KEY_PROV_INFO, pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pStartTime: PSYSTEMTIME, pEndTime: PSYSTEMTIME, pExtensions: PCERT_EXTENSIONS });
FN('CryptGetKeyIdentifierProperty', BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR('void'), pvData: PTR('void'), pcbData: PTR(ulong) });
FN('CryptSetKeyIdentifierProperty', BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR('void'), pvData: PTR('void') });
FN('CryptEnumKeyIdentifierProperties', BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR('void'), pvArg: PTR('void'), pfnEnum: PFN_CRYPT_ENUM_KEYID_PROP });
FN('CryptCreateKeyIdentifierFromCSP', BOOL, { dwCertEncodingType: DWORD, pszPubKeyOID: LPCSTR, pPubKeyStruc: PTR(uint), cbPubKeyStruc: DWORD, dwFlags: DWORD, pvReserved: PTR('void'), pbHash: PTR(uchar), pcbHash: PTR(ulong) });
FN('CertCreateCertificateChainEngine', BOOL, { pConfig: PCERT_CHAIN_ENGINE_CONFIG, phChainEngine: PTR(PTR('void')) });
FN('CertFreeCertificateChainEngine', 'void', { hChainEngine: HCERTCHAINENGINE });
FN('CertResyncCertificateChainEngine', BOOL, { hChainEngine: HCERTCHAINENGINE });
FN('CertGetCertificateChain', BOOL, { hChainEngine: HCERTCHAINENGINE, pCertContext: PCCERT_CONTEXT, pTime: LPFILETIME, hAdditionalStore: HCERTSTORE, pChainPara: PCERT_CHAIN_PARA, dwFlags: DWORD, pvReserved: LPVOID, ppChainContext: PTR(pointer) });
FN('CertFreeCertificateChain', 'void', { pChainContext: PCCERT_CHAIN_CONTEXT });
FN('CertDuplicateCertificateChain', PCCERT_CHAIN_CONTEXT, { pChainContext: PCCERT_CHAIN_CONTEXT });
FN('CertFindChainInStore', PCCERT_CHAIN_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR('void'), pPrevChainContext: PCCERT_CHAIN_CONTEXT });
FN('CertVerifyCertificateChainPolicy', BOOL, { pszPolicyOID: LPCSTR, pChainContext: PCCERT_CHAIN_CONTEXT, pPolicyPara: PCERT_CHAIN_POLICY_PARA, pPolicyStatus: PCERT_CHAIN_POLICY_STATUS });
FN('CryptStringToBinaryA', BOOL, { pszString: LPCSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: PTR(uchar), pcbBinary: PTR(ulong), pdwSkip: PTR(ulong), pdwFlags: PTR(ulong) });
FN('CryptStringToBinaryW', BOOL, { pszString: LPCWSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: PTR(uchar), pcbBinary: PTR(ulong), pdwSkip: PTR(ulong), pdwFlags: PTR(ulong) });
FN('CryptBinaryToStringA', BOOL, { pbBinary: PTR(uchar), cbBinary: DWORD, dwFlags: DWORD, pszString: LPSTR, pcchString: PTR(ulong) });
FN('CryptBinaryToStringW', BOOL, { pbBinary: PTR(uchar), cbBinary: DWORD, dwFlags: DWORD, pszString: LPWSTR, pcchString: PTR(ulong) });
FN('PFXImportCertStore', HCERTSTORE, { pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD });
FN('PFXIsPFXBlob', BOOL, { pPFX: PTR(uint) });
FN('PFXVerifyPassword', BOOL, { pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD });
FN('PFXExportCertStoreEx', BOOL, { hStore: HCERTSTORE, pPFX: PTR(uint), szPassword: LPCWSTR, pvReserved: PTR('void'), dwFlags: DWORD });
FN('PFXExportCertStore', BOOL, { hStore: HCERTSTORE, pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD });
FN('CertOpenServerOcspResponse', HCERT_SERVER_OCSP_RESPONSE, { pChainContext: PCCERT_CHAIN_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID });
FN('CertAddRefServerOcspResponse', 'void', { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE });
FN('CertCloseServerOcspResponse', 'void', { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD });
FN('CertGetServerOcspResponseContext', PCCERT_SERVER_OCSP_RESPONSE_CONTEXT, { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD, pvReserved: LPVOID });
FN('CertAddRefServerOcspResponseContext', 'void', { pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT });
FN('CertFreeServerOcspResponseContext', 'void', { pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT });
FN('CertRetrieveLogoOrBiometricInfo', BOOL, { pCertContext: PCCERT_CONTEXT, lpszLogoOrBiometricType: LPCSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, dwFlags: DWORD, pvReserved: PTR('void'), ppbData: PTR(PTR(uchar)), pcbData: PTR(ulong), ppwszMimeType: PTR(PTR(ushort)) });
FN('CertSelectCertificateChains', BOOL, { pSelectionContext: LPCGUID, dwFlags: DWORD, pChainParameters: PCCERT_SELECT_CHAIN_PARA, cCriteria: DWORD, rgpCriteria: PCCERT_SELECT_CRITERIA, hStore: HCERTSTORE, pcSelection: PDWORD, pprgpSelection: PTR(PTR(pointer)) });
FN('CertFreeCertificateChainList', 'void', { prgpSelection: PTR(pointer) });
FN('CryptRetrieveTimeStamp', BOOL, { wszUrl: LPCWSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, pszHashId: LPCSTR, pPara: PTR(uint), pbData: PTR(uchar), cbData: DWORD, ppTsContext: PTR(pointer), ppTsSigner: PTR(pointer), phStore: PTR(PTR('void')) });
FN('CryptVerifyTimeStampSignature', BOOL, { pbTSContentInfo: PTR(uchar), cbTSContentInfo: DWORD, pbData: PTR(uchar), cbData: DWORD, hAdditionalStore: HCERTSTORE, ppTsContext: PTR(pointer), ppTsSigner: PTR(pointer), phStore: PTR(PTR('void')) });
FN('QueryUsersOnEncryptedFile', DWORD, { lpFileName: LPCWSTR, pUsers: PTR(pointer) });
FN('QueryRecoveryAgentsOnEncryptedFile', DWORD, { lpFileName: LPCWSTR, pRecoveryAgents: PTR(pointer) });
FN('RemoveUsersFromEncryptedFile', DWORD, { lpFileName: LPCWSTR, pHashes: PENCRYPTION_CERTIFICATE_HASH_LIST });
FN('AddUsersToEncryptedFile', DWORD, { lpFileName: LPCWSTR, pEncryptionCertificates: PENCRYPTION_CERTIFICATE_LIST });
FN('SetUserFileEncryptionKey', DWORD, { pEncryptionCertificate: PENCRYPTION_CERTIFICATE });
FN('SetUserFileEncryptionKeyEx', DWORD, { pEncryptionCertificate: PENCRYPTION_CERTIFICATE, dwCapabilities: DWORD, dwFlags: DWORD, pvReserved: LPVOID });
FN('FreeEncryptionCertificateHashList', 'void', { pUsers: PENCRYPTION_CERTIFICATE_HASH_LIST });
FN('EncryptionDisable', BOOL, { DirPath: LPCWSTR, Disable: BOOL });
FN('DuplicateEncryptionInfoFile', DWORD, { SrcFileName: LPCWSTR, DstFileName: LPCWSTR, dwCreationDistribution: DWORD, dwAttributes: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES });
FN('GetEncryptedFileMetadata', DWORD, { lpFileName: LPCWSTR, pcbMetadata: PDWORD, ppbMetadata: PTR(PTR(uchar)) });
FN('SetEncryptedFileMetadata', DWORD, { lpFileName: LPCWSTR, pbOldMetadata: PBYTE, pbNewMetadata: PBYTE, pOwnerHash: PENCRYPTION_CERTIFICATE_HASH, dwOperation: DWORD, pCertificatesAdded: PENCRYPTION_CERTIFICATE_HASH_LIST });
FN('FreeEncryptedFileMetadata', 'void', { pbMetadata: PBYTE });
FN('I_RpcNsGetBuffer', RPC_STATUS, { Message: PRPC_MESSAGE });
FN('I_RpcNsSendReceive', RPC_STATUS, { Message: PRPC_MESSAGE, Handle: PTR(PTR('void')) });
FN('I_RpcNsRaiseException', 'void', { Message: PRPC_MESSAGE, Status: RPC_STATUS });
FN('I_RpcReBindBuffer', RPC_STATUS, { Message: PRPC_MESSAGE });
FN('I_NsServerBindSearch', RPC_STATUS, {  });
FN('I_NsClientBindSearch', RPC_STATUS, {  });
FN('I_NsClientBindDone', 'void', {  });
FN('MIDL_user_allocate', 'void', { size: size_t });
FN('MIDL_user_free', 'void', { PTR('void'): PTR('void') });
FN('I_RpcDefaultAllocate', 'void', { bh: handle_t, size: size_t, RealAlloc: PTR(pointer) });
FN('I_RpcDefaultFree', 'void', { bh: handle_t, PTR('void'): PTR('void'), RealFree: PTR(pointer) });
FN('NDRCContextBinding', RPC_BINDING_HANDLE, { CContext: NDR_CCONTEXT });
FN('NDRCContextMarshall', 'void', { CContext: NDR_CCONTEXT, pBuff: PTR('void') });
FN('NDRCContextUnmarshall', 'void', { pCContext: PTR(PTR('void')), hBinding: RPC_BINDING_HANDLE, pBuff: PTR('void'), DataRepresentation: ulong });
FN('NDRCContextUnmarshall2', 'void', { pCContext: PTR(PTR('void')), hBinding: RPC_BINDING_HANDLE, pBuff: PTR('void'), DataRepresentation: ulong });
FN('NDRSContextMarshall', 'void', { CContext: NDR_SCONTEXT, pBuff: PTR('void'), userRunDownIn: NDR_RUNDOWN });
FN('NDRSContextUnmarshall', NDR_SCONTEXT, { pBuff: PTR('void'), DataRepresentation: ulong });
FN('NDRSContextMarshallEx', 'void', { BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: PTR('void'), userRunDownIn: NDR_RUNDOWN });
FN('NDRSContextMarshall2', 'void', { BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: PTR('void'), userRunDownIn: NDR_RUNDOWN, CtxGuard: PTR('void'), Flags: ulong });
FN('NDRSContextUnmarshallEx', NDR_SCONTEXT, { BindingHandle: RPC_BINDING_HANDLE, pBuff: PTR('void'), DataRepresentation: ulong });
FN('NDRSContextUnmarshall2', NDR_SCONTEXT, { BindingHandle: RPC_BINDING_HANDLE, pBuff: PTR('void'), DataRepresentation: ulong, CtxGuard: PTR('void'), Flags: ulong });
FN('RpcSsDestroyClientContext', 'void', { ContextHandle: PTR(PTR('void')) });
FN('RpcCsGetTags', 'void', { hBinding: RPC_BINDING_HANDLE, fServerSide: int, pulSendingTag: PTR(ulong), pulDesiredReceivingTag: PTR(ulong), pulReceivingTag: PTR(ulong), pStatus: PTR(ulong) });
FN('NdrClientGetSupportedSyntaxes', RPC_STATUS, { pInf: PTR(uint), pCount: PTR(ulong), pArr: PTR(PTR(uint)) });
FN('NdrServerGetSupportedSyntaxes', RPC_STATUS, { pInf: PTR(uint), pCount: PTR(ulong), pArr: PTR(PTR(uint)), pPreferSyntaxIndex: PTR(ulong) });
FN('NdrSimpleTypeMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), FormatChar: uchar });
FN('NdrPointerMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrCsArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrCsTagMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrSimpleStructMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantStructMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingStructMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexStructMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrFixedArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrVaryingArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexArrayMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrNonConformantStringMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantStringMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrEncapsulatedUnionMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrNonEncapsulatedUnionMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrByteCountPointerMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrXmitOrRepAsMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrUserMarshalMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrInterfacePointerMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrClientContextMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_CCONTEXT, fCheck: int });
FN('NdrServerContextMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN });
FN('NdrServerContextNewMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN, pFormat: PFORMAT_STRING });
FN('NdrSimpleTypeUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), FormatChar: uchar });
FN('NdrCsArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrCsTagUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrRangeUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrCorrelationInitialize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR('void'), CacheSize: ulong, flags: ulong });
FN('NdrCorrelationPass', 'void', { pStubMsg: PMIDL_STUB_MESSAGE });
FN('NdrCorrelationFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE });
FN('NdrPointerUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrSimpleStructUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrConformantStructUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrConformantVaryingStructUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrComplexStructUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrFixedArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrConformantArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrConformantVaryingArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrVaryingArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrComplexArrayUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrNonConformantStringUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrConformantStringUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrEncapsulatedUnionUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrNonEncapsulatedUnionUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrByteCountPointerUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrXmitOrRepAsUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrUserMarshalUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrInterfacePointerUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar });
FN('NdrClientContextUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pContextHandle: PTR(PTR('void')), BindHandle: RPC_BINDING_HANDLE });
FN('NdrServerContextUnmarshall', NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE });
FN('NdrContextHandleInitialize', NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrServerContextNewUnmarshall', NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrPointerBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrCsArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrCsTagBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrSimpleStructBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantStructBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingStructBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexStructBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrFixedArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrVaryingArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexArrayBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantStringBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrNonConformantStringBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrEncapsulatedUnionBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrNonEncapsulatedUnionBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrByteCountPointerBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrXmitOrRepAsBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrUserMarshalBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrInterfacePointerBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrContextHandleSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrPointerMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrContextHandleMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrCsArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrCsTagMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrSimpleStructMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrConformantStructMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingStructMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrComplexStructMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrFixedArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrConformantArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrVaryingArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrComplexArrayMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrConformantStringMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrNonConformantStringMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrEncapsulatedUnionMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrNonEncapsulatedUnionMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrXmitOrRepAsMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrUserMarshalMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrInterfacePointerMemorySize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrPointerFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrCsArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrSimpleStructFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantStructFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingStructFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexStructFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrFixedArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConformantVaryingArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrVaryingArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrComplexArrayFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrEncapsulatedUnionFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrNonEncapsulatedUnionFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrByteCountPointerFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrXmitOrRepAsFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrUserMarshalFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrInterfacePointerFree', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING });
FN('NdrConvert2', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, NumberParams: long });
FN('NdrConvert', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrUserMarshalSimpleTypeConvert', 'void', { pFlags: PTR(ulong), pBuffer: PTR(uchar), FormatChar: uchar });
FN('NdrClientInitializeNew', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: uint });
FN('NdrServerInitializeNew', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC });
FN('NdrServerInitializePartial', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, RequestedBufferSize: ulong });
FN('NdrClientInitialize', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: uint });
FN('NdrServerInitialize', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC });
FN('NdrServerInitializeUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pRpcMsg: PRPC_MESSAGE });
FN('NdrServerInitializeMarshall', 'void', { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE });
FN('NdrGetBuffer', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: ulong, Handle: RPC_BINDING_HANDLE });
FN('NdrNsGetBuffer', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: ulong, Handle: RPC_BINDING_HANDLE });
FN('NdrSendReceive', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: PTR(uchar) });
FN('NdrNsSendReceive', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: PTR(uchar), pAutoHandle: PTR(PTR('void')) });
FN('NdrFreeBuffer', 'void', { pStubMsg: PMIDL_STUB_MESSAGE });
FN('NdrGetDcomProtocolVersion', RPC_STATUS, { pStubMsg: PMIDL_STUB_MESSAGE, pVersion: PTR(uint) });
FN('NdrClientCall2', CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING });
FN('NdrClientCall', CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING });
FN('NdrAsyncClientCall', CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING });
FN('NdrDcomAsyncClientCall', CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING });
FN('NdrAsyncServerCall', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrAsyncStubCall', 'void', { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrDcomAsyncStubCall', 'void', { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrStubCall2', 'void', { pThis: PTR('void'), pChannel: PTR('void'), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrServerCall2', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrStubCall', 'void', { pThis: PTR('void'), pChannel: PTR('void'), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrServerCall', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrServerUnmarshall', 'void', { pChannel: PTR('void'), pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING, pParamList: PTR('void') });
FN('NdrServerMarshall', 'void', { pThis: PTR('void'), pChannel: PTR('void'), pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING });
FN('NdrMapCommAndFaultStatus', RPC_STATUS, { pStubMsg: PMIDL_STUB_MESSAGE, pCommStatus: PTR(ulong), pFaultStatus: PTR(ulong), Status: RPC_STATUS });
FN('RpcSsAllocate', 'void', { Size: size_t });
FN('RpcSsDisableAllocate', 'void', {  });
FN('RpcSsEnableAllocate', 'void', {  });
FN('RpcSsFree', 'void', { NodeToFree: PTR('void') });
FN('RpcSsGetThreadHandle', RPC_SS_THREAD_HANDLE, {  });
FN('RpcSsSetClientAllocFree', 'void', { ClientAlloc: PTR(CALLBACK(PTR('void'), [uint])), ClientFree: PTR(CALLBACK('void', [PTR('void')])) });
FN('RpcSsSetThreadHandle', 'void', { Id: RPC_SS_THREAD_HANDLE });
FN('RpcSsSwapClientAllocFree', 'void', { ClientAlloc: PTR(CALLBACK(PTR('void'), [uint])), ClientFree: PTR(CALLBACK('void', [PTR('void')])), OldClientAlloc: PTR(PTR(CALLBACK(PTR('void'), [uint]))), OldClientFree: PTR(PTR(CALLBACK('void', [PTR('void')]))) });
FN('RpcSmAllocate', 'void', { Size: size_t, pStatus: PTR(long) });
FN('RpcSmClientFree', RPC_STATUS, { pNodeToFree: PTR('void') });
FN('RpcSmDestroyClientContext', RPC_STATUS, { ContextHandle: PTR(PTR('void')) });
FN('RpcSmDisableAllocate', RPC_STATUS, {  });
FN('RpcSmEnableAllocate', RPC_STATUS, {  });
FN('RpcSmFree', RPC_STATUS, { NodeToFree: PTR('void') });
FN('RpcSmGetThreadHandle', RPC_SS_THREAD_HANDLE, { pStatus: PTR(long) });
FN('RpcSmSetClientAllocFree', RPC_STATUS, { ClientAlloc: PTR(CALLBACK(PTR('void'), [uint])), ClientFree: PTR(CALLBACK('void', [PTR('void')])) });
FN('RpcSmSetThreadHandle', RPC_STATUS, { Id: RPC_SS_THREAD_HANDLE });
FN('RpcSmSwapClientAllocFree', RPC_STATUS, { ClientAlloc: PTR(CALLBACK(PTR('void'), [uint])), ClientFree: PTR(CALLBACK('void', [PTR('void')])), OldClientAlloc: PTR(PTR(CALLBACK(PTR('void'), [uint]))), OldClientFree: PTR(PTR(CALLBACK('void', [PTR('void')]))) });
FN('NdrRpcSsEnableAllocate', 'void', { pMessage: PMIDL_STUB_MESSAGE });
FN('NdrRpcSsDisableAllocate', 'void', { pMessage: PMIDL_STUB_MESSAGE });
FN('NdrRpcSmSetClientToOsf', 'void', { pMessage: PMIDL_STUB_MESSAGE });
FN('NdrRpcSmClientAllocate', 'void', { Size: size_t });
FN('NdrRpcSmClientFree', 'void', { NodeToFree: PTR('void') });
FN('NdrRpcSsDefaultAllocate', 'void', { Size: size_t });
FN('NdrRpcSsDefaultFree', 'void', { NodeToFree: PTR('void') });
FN('NdrFullPointerXlatInit', PFULL_PTR_XLAT_TABLES, { NumberOfPointers: ulong, XlatSide: XLAT_SIDE });
FN('NdrFullPointerXlatFree', 'void', { pXlatTables: PFULL_PTR_XLAT_TABLES });
FN('NdrAllocate', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, Len: size_t });
FN('NdrClearOutParameters', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, ArgAddr: PTR('void') });
FN('NdrOleAllocate', 'void', { Size: size_t });
FN('NdrOleFree', 'void', { NodeToFree: PTR('void') });
FN('NdrGetUserMarshalInfo', RPC_STATUS, { pFlags: PTR(ulong), InformationLevel: ulong, pMarshalInfo: PTR(uint) });
FN('NdrCreateServerInterfaceFromStub', RPC_STATUS, { pStub: PTR(IRpcStubBuffer), pServerIf: PTR(uint) });
FN('NdrClientCall3', CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR('void') });
FN('Ndr64AsyncClientCall', CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR('void') });
FN('Ndr64DcomAsyncClientCall', CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR('void') });
FN('Ndr64AsyncServerCall', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('Ndr64AsyncServerCall64', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('Ndr64AsyncServerCallAll', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('Ndr64AsyncStubCall', 'void', { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('Ndr64DcomAsyncStubCall', 'void', { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrStubCall3', 'void', { pThis: PTR('void'), pChannel: PTR('void'), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) });
FN('NdrServerCallAll', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrServerCallNdr64', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrServerCall3', 'void', { pRpcMsg: PRPC_MESSAGE });
FN('NdrPartialIgnoreClientMarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR('void') });
FN('NdrPartialIgnoreServerUnmarshall', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR('void')) });
FN('NdrPartialIgnoreClientBufferSize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR('void') });
FN('NdrPartialIgnoreServerInitialize', 'void', { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR('void')), pFormat: PFORMAT_STRING });
FN('RpcUserFree', 'void', { AsyncHandle: handle_t, pBuffer: PTR('void') });
FN('SCardEstablishContext', LONG, { dwScope: DWORD, pvReserved1: LPCVOID, pvReserved2: LPCVOID, phContext: LPSCARDCONTEXT });
FN('SCardReleaseContext', LONG, { hContext: SCARDCONTEXT });
FN('SCardIsValidContext', LONG, { hContext: SCARDCONTEXT });
FN('SCardListReaderGroupsA', LONG, { hContext: SCARDCONTEXT, mszGroups: LPSTR, pcchGroups: LPDWORD });
FN('SCardListReaderGroupsW', LONG, { hContext: SCARDCONTEXT, mszGroups: LPWSTR, pcchGroups: LPDWORD });
FN('SCardListReadersA', LONG, { hContext: SCARDCONTEXT, mszGroups: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD });
FN('SCardListReadersW', LONG, { hContext: SCARDCONTEXT, mszGroups: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD });
FN('SCardListCardsA', LONG, { hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPSTR, pcchCards: LPDWORD });
FN('SCardListCardsW', LONG, { hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPWSTR, pcchCards: LPDWORD });
FN('SCardListInterfacesA', LONG, { hContext: SCARDCONTEXT, szCard: LPCSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD });
FN('SCardListInterfacesW', LONG, { hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD });
FN('SCardGetProviderIdA', LONG, { hContext: SCARDCONTEXT, szCard: LPCSTR, pguidProviderId: LPGUID });
FN('SCardGetProviderIdW', LONG, { hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidProviderId: LPGUID });
FN('SCardGetCardTypeProviderNameA', LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPSTR, pcchProvider: LPDWORD });
FN('SCardGetCardTypeProviderNameW', LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPWSTR, pcchProvider: LPDWORD });
FN('SCardIntroduceReaderGroupA', LONG, { hContext: SCARDCONTEXT, szGroupName: LPCSTR });
FN('SCardIntroduceReaderGroupW', LONG, { hContext: SCARDCONTEXT, szGroupName: LPCWSTR });
FN('SCardForgetReaderGroupA', LONG, { hContext: SCARDCONTEXT, szGroupName: LPCSTR });
FN('SCardForgetReaderGroupW', LONG, { hContext: SCARDCONTEXT, szGroupName: LPCWSTR });
FN('SCardIntroduceReaderA', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceName: LPCSTR });
FN('SCardIntroduceReaderW', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceName: LPCWSTR });
FN('SCardForgetReaderA', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR });
FN('SCardForgetReaderW', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR });
FN('SCardAddReaderToGroupA', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR });
FN('SCardAddReaderToGroupW', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR });
FN('SCardRemoveReaderFromGroupA', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR });
FN('SCardRemoveReaderFromGroupW', LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR });
FN('SCardIntroduceCardTypeA', LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD });
FN('SCardIntroduceCardTypeW', LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD });
FN('SCardSetCardTypeProviderNameA', LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPCSTR });
FN('SCardSetCardTypeProviderNameW', LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPCWSTR });
FN('SCardForgetCardTypeA', LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR });
FN('SCardForgetCardTypeW', LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR });
FN('SCardFreeMemory', LONG, { hContext: SCARDCONTEXT, pvMem: LPCVOID });
FN('SCardAccessStartedEvent', HANDLE, {  });
FN('SCardReleaseStartedEvent', 'void', {  });
FN('SCardLocateCardsA', LONG, { hContext: SCARDCONTEXT, mszCards: LPCSTR, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD });
FN('SCardLocateCardsW', LONG, { hContext: SCARDCONTEXT, mszCards: LPCWSTR, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD });
FN('SCardLocateCardsByATRA', LONG, { hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD });
FN('SCardLocateCardsByATRW', LONG, { hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD });
FN('SCardGetStatusChangeA', LONG, { hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD });
FN('SCardGetStatusChangeW', LONG, { hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD });
FN('SCardCancel', LONG, { hContext: SCARDCONTEXT });
FN('SCardConnectA', LONG, { hContext: SCARDCONTEXT, szReader: LPCSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD });
FN('SCardConnectW', LONG, { hContext: SCARDCONTEXT, szReader: LPCWSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD });
FN('SCardReconnect', LONG, { hCard: SCARDHANDLE, dwShareMode: DWORD, dwPreferredProtocols: DWORD, dwInitialization: DWORD, pdwActiveProtocol: LPDWORD });
FN('SCardDisconnect', LONG, { hCard: SCARDHANDLE, dwDisposition: DWORD });
FN('SCardBeginTransaction', LONG, { hCard: SCARDHANDLE });
FN('SCardEndTransaction', LONG, { hCard: SCARDHANDLE, dwDisposition: DWORD });
FN('SCardCancelTransaction', LONG, { hCard: SCARDHANDLE });
FN('SCardState', LONG, { hCard: SCARDHANDLE, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD });
FN('SCardStatusA', LONG, { hCard: SCARDHANDLE, mszReaderNames: LPSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD });
FN('SCardStatusW', LONG, { hCard: SCARDHANDLE, mszReaderNames: LPWSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD });
FN('SCardTransmit', LONG, { hCard: SCARDHANDLE, pioSendPci: LPCSCARD_IO_REQUEST, pbSendBuffer: LPCBYTE, cbSendLength: DWORD, pioRecvPci: LPSCARD_IO_REQUEST, pbRecvBuffer: LPBYTE, pcbRecvLength: LPDWORD });
FN('SCardGetTransmitCount', LONG, { hCard: SCARDHANDLE, pcTransmitCount: LPDWORD });
FN('SCardControl', LONG, { hCard: SCARDHANDLE, dwControlCode: DWORD, lpInBuffer: LPCVOID, cbInBufferSize: DWORD, lpOutBuffer: LPVOID, cbOutBufferSize: DWORD, lpBytesReturned: LPDWORD });
FN('SCardGetAttrib', LONG, { hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPBYTE, pcbAttrLen: LPDWORD });
FN('SCardSetAttrib', LONG, { hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPCBYTE, cbAttrLen: DWORD });
FN('SCardUIDlgSelectCardA', LONG, { LPOPENCARDNAME_EXA: LPOPENCARDNAME_EXA });
FN('SCardUIDlgSelectCardW', LONG, { LPOPENCARDNAME_EXW: LPOPENCARDNAME_EXW });
FN('GetOpenCardNameA', LONG, { LPOPENCARDNAMEA: LPOPENCARDNAMEA });
FN('GetOpenCardNameW', LONG, { LPOPENCARDNAMEW: LPOPENCARDNAMEW });
FN('SCardDlgExtendedError', LONG, {  });
FN('SCardReadCacheA', LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: PTR(ulong) });
FN('SCardReadCacheW', LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: PTR(ulong) });
FN('SCardWriteCacheA', LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: DWORD });
FN('SCardWriteCacheW', LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: DWORD });
FN('CreatePropertySheetPageA', HPROPSHEETPAGE, { constPropSheetPagePointer: LPCPROPSHEETPAGEA });
FN('CreatePropertySheetPageW', HPROPSHEETPAGE, { constPropSheetPagePointer: LPCPROPSHEETPAGEW });
FN('DestroyPropertySheetPage', BOOL, { HPROPSHEETPAGE: HPROPSHEETPAGE });
FN('PropertySheetA', INT_PTR, { LPCPROPSHEETHEADERA: LPCPROPSHEETHEADERA });
FN('PropertySheetW', INT_PTR, { LPCPROPSHEETHEADERW: LPCPROPSHEETHEADERW });
FN('EnumPrintersA', BOOL, { Flags: DWORD, Name: LPSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumPrintersW', BOOL, { Flags: DWORD, Name: LPWSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('GetSpoolFileHandle', HANDLE, { hPrinter: HANDLE });
FN('CommitSpoolData', HANDLE, { hPrinter: HANDLE, hSpoolFile: HANDLE, cbCommit: DWORD });
FN('CloseSpoolFileHandle', BOOL, { hPrinter: HANDLE, hSpoolFile: HANDLE });
FN('OpenPrinterA', BOOL, { pPrinterName: LPSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSA });
FN('OpenPrinterW', BOOL, { pPrinterName: LPWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSW });
FN('ResetPrinterA', BOOL, { hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSA });
FN('ResetPrinterW', BOOL, { hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSW });
FN('SetJobA', BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD });
FN('SetJobW', BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD });
FN('GetJobA', BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetJobW', BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('EnumJobsA', BOOL, { hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumJobsW', BOOL, { hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('AddPrinterA', HANDLE, { pName: LPSTR, Level: DWORD, pPrinter: LPBYTE });
FN('AddPrinterW', HANDLE, { pName: LPWSTR, Level: DWORD, pPrinter: LPBYTE });
FN('DeletePrinter', BOOL, { hPrinter: HANDLE });
FN('SetPrinterA', BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD });
FN('SetPrinterW', BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD });
FN('GetPrinterA', BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterW', BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('AddPrinterDriverA', BOOL, { pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE });
FN('AddPrinterDriverW', BOOL, { pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE });
FN('AddPrinterDriverExA', BOOL, { pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD });
FN('AddPrinterDriverExW', BOOL, { pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD });
FN('EnumPrinterDriversA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumPrinterDriversW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('GetPrinterDriverA', BOOL, { hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDriverW', BOOL, { hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDriverDirectoryA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDriverDirectoryW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('DeletePrinterDriverA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR });
FN('DeletePrinterDriverW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR });
FN('DeletePrinterDriverExA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD });
FN('DeletePrinterDriverExW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD });
FN('AddPrintProcessorA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPathName: LPSTR, pPrintProcessorName: LPSTR });
FN('AddPrintProcessorW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPathName: LPWSTR, pPrintProcessorName: LPWSTR });
FN('EnumPrintProcessorsA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumPrintProcessorsW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('GetPrintProcessorDirectoryA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrintProcessorDirectoryW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('EnumPrintProcessorDatatypesA', BOOL, { pName: LPSTR, pPrintProcessorName: LPSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumPrintProcessorDatatypesW', BOOL, { pName: LPWSTR, pPrintProcessorName: LPWSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('DeletePrintProcessorA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPrintProcessorName: LPSTR });
FN('DeletePrintProcessorW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPrintProcessorName: LPWSTR });
FN('StartDocPrinterA', DWORD, { hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE });
FN('StartDocPrinterW', DWORD, { hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE });
FN('StartPagePrinter', BOOL, { hPrinter: HANDLE });
FN('WritePrinter', BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD });
FN('FlushPrinter', BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD, cSleep: DWORD });
FN('EndPagePrinter', BOOL, { hPrinter: HANDLE });
FN('AbortPrinter', BOOL, { hPrinter: HANDLE });
FN('ReadPrinter', BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pNoBytesRead: LPDWORD });
FN('EndDocPrinter', BOOL, { hPrinter: HANDLE });
FN('AddJobA', BOOL, { hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('AddJobW', BOOL, { hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('ScheduleJob', BOOL, { hPrinter: HANDLE, JobId: DWORD });
FN('PrinterProperties', BOOL, { hWnd: HWND, hPrinter: HANDLE });
FN('DocumentPropertiesA', LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA, fMode: DWORD });
FN('DocumentPropertiesW', LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW, fMode: DWORD });
FN('AdvancedDocumentPropertiesA', LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA });
FN('AdvancedDocumentPropertiesW', LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW });
FN('ExtDeviceMode', LONG, { hWnd: HWND, hInst: HANDLE, pDevModeOutput: LPDEVMODEA, pDeviceName: LPSTR, pPort: LPSTR, pDevModeInput: LPDEVMODEA, pProfile: LPSTR, fMode: DWORD });
FN('GetPrinterDataA', DWORD, { hPrinter: HANDLE, pValueName: LPSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDataW', DWORD, { hPrinter: HANDLE, pValueName: LPWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDataExA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDataExW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD });
FN('EnumPrinterDataA', DWORD, { hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD });
FN('EnumPrinterDataW', DWORD, { hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPWSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD });
FN('EnumPrinterDataExA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD });
FN('EnumPrinterDataExW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD });
FN('EnumPrinterKeyA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pSubkey: LPSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD });
FN('EnumPrinterKeyW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pSubkey: LPWSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD });
FN('SetPrinterDataA', DWORD, { hPrinter: HANDLE, pValueName: LPSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD });
FN('SetPrinterDataW', DWORD, { hPrinter: HANDLE, pValueName: LPWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD });
FN('SetPrinterDataExA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD });
FN('SetPrinterDataExW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD });
FN('DeletePrinterDataA', DWORD, { hPrinter: HANDLE, pValueName: LPSTR });
FN('DeletePrinterDataW', DWORD, { hPrinter: HANDLE, pValueName: LPWSTR });
FN('DeletePrinterDataExA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR });
FN('DeletePrinterDataExW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR });
FN('DeletePrinterKeyA', DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR });
FN('DeletePrinterKeyW', DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR });
FN('WaitForPrinterChange', DWORD, { hPrinter: HANDLE, Flags: DWORD });
FN('FindFirstPrinterChangeNotification', HANDLE, { hPrinter: HANDLE, fdwFilter: DWORD, fdwOptions: DWORD, pPrinterNotifyOptions: PVOID });
FN('FindNextPrinterChangeNotification', BOOL, { hChange: HANDLE, pdwChange: PDWORD, pvReserved: LPVOID, ppPrinterNotifyInfo: PTR(PTR('void')) });
FN('FreePrinterNotifyInfo', BOOL, { pPrinterNotifyInfo: PPRINTER_NOTIFY_INFO });
FN('FindClosePrinterChangeNotification', BOOL, { hChange: HANDLE });
FN('PrinterMessageBoxA', DWORD, { hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPSTR, pCaption: LPSTR, dwType: DWORD });
FN('PrinterMessageBoxW', DWORD, { hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPWSTR, pCaption: LPWSTR, dwType: DWORD });
FN('ClosePrinter', BOOL, { hPrinter: HANDLE });
FN('AddFormA', BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE });
FN('AddFormW', BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE });
FN('DeleteFormA', BOOL, { hPrinter: HANDLE, pFormName: LPSTR });
FN('DeleteFormW', BOOL, { hPrinter: HANDLE, pFormName: LPWSTR });
FN('GetFormA', BOOL, { hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetFormW', BOOL, { hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('SetFormA', BOOL, { hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE });
FN('SetFormW', BOOL, { hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE });
FN('EnumFormsA', BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumFormsW', BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumMonitorsA', BOOL, { pName: LPSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumMonitorsW', BOOL, { pName: LPWSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('AddMonitorA', BOOL, { pName: LPSTR, Level: DWORD, pMonitors: LPBYTE });
FN('AddMonitorW', BOOL, { pName: LPWSTR, Level: DWORD, pMonitors: LPBYTE });
FN('DeleteMonitorA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pMonitorName: LPSTR });
FN('DeleteMonitorW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pMonitorName: LPWSTR });
FN('EnumPortsA', BOOL, { pName: LPSTR, Level: DWORD, pPort: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('EnumPortsW', BOOL, { pName: LPWSTR, Level: DWORD, pPort: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD });
FN('AddPortA', BOOL, { pName: LPSTR, hWnd: HWND, pMonitorName: LPSTR });
FN('AddPortW', BOOL, { pName: LPWSTR, hWnd: HWND, pMonitorName: LPWSTR });
FN('ConfigurePortA', BOOL, { pName: LPSTR, hWnd: HWND, pPortName: LPSTR });
FN('ConfigurePortW', BOOL, { pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR });
FN('DeletePortA', BOOL, { pName: LPSTR, hWnd: HWND, pPortName: LPSTR });
FN('DeletePortW', BOOL, { pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR });
FN('XcvDataW', BOOL, { hXcv: HANDLE, pszDataName: PCWSTR, pInputData: PBYTE, cbInputData: DWORD, pOutputData: PBYTE, cbOutputData: DWORD, pcbOutputNeeded: PDWORD, pdwStatus: PDWORD });
FN('GetDefaultPrinterA', BOOL, { pszBuffer: LPSTR, pcchBuffer: LPDWORD });
FN('GetDefaultPrinterW', BOOL, { pszBuffer: LPWSTR, pcchBuffer: LPDWORD });
FN('SetDefaultPrinterA', BOOL, { pszPrinter: LPCSTR });
FN('SetDefaultPrinterW', BOOL, { pszPrinter: LPCWSTR });
FN('SetPortA', BOOL, { pName: LPSTR, pPortName: LPSTR, dwLevel: DWORD, pPortInfo: LPBYTE });
FN('SetPortW', BOOL, { pName: LPWSTR, pPortName: LPWSTR, dwLevel: DWORD, pPortInfo: LPBYTE });
FN('AddPrinterConnectionA', BOOL, { pName: LPSTR });
FN('AddPrinterConnectionW', BOOL, { pName: LPWSTR });
FN('DeletePrinterConnectionA', BOOL, { pName: LPSTR });
FN('DeletePrinterConnectionW', BOOL, { pName: LPWSTR });
FN('ConnectToPrinterDlg', HANDLE, { hwnd: HWND, Flags: DWORD });
FN('AddPrintProvidorA', BOOL, { pName: LPSTR, level: DWORD, pProvidorInfo: LPBYTE });
FN('AddPrintProvidorW', BOOL, { pName: LPWSTR, level: DWORD, pProvidorInfo: LPBYTE });
FN('DeletePrintProvidorA', BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPrintProvidorName: LPSTR });
FN('DeletePrintProvidorW', BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPrintProvidorName: LPWSTR });
FN('IsValidDevmodeA', BOOL, { pDevmode: PDEVMODEA, DevmodeSize: size_t });
FN('IsValidDevmodeW', BOOL, { pDevmode: PDEVMODEW, DevmodeSize: size_t });
FN('OpenPrinter2A', BOOL, { pPrinterName: LPCSTR, phPrinter: LPHANDLE, pDefault: PPRINTER_DEFAULTSA, pOptions: PPRINTER_OPTIONSA });
FN('OpenPrinter2W', BOOL, { pPrinterName: LPCWSTR, phPrinter: LPHANDLE, pDefault: PPRINTER_DEFAULTSW, pOptions: PPRINTER_OPTIONSW });
FN('AddPrinterConnection2A', BOOL, { hWnd: HWND, pszName: LPCSTR, dwLevel: DWORD, pConnectionInfo: PVOID });
FN('AddPrinterConnection2W', BOOL, { hWnd: HWND, pszName: LPCWSTR, dwLevel: DWORD, pConnectionInfo: PVOID });
FN('InstallPrinterDriverFromPackageA', HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszDriverName: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD });
FN('InstallPrinterDriverFromPackageW', HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszDriverName: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD });
FN('UploadPrinterDriverPackageA', HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPSTR, pcchDestInfPath: PULONG });
FN('UploadPrinterDriverPackageW', HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPWSTR, pcchDestInfPath: PULONG });
FN('GetCorePrinterDriversA', HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, pszzCoreDriverDependencies: LPCSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERA });
FN('GetCorePrinterDriversW', HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszzCoreDriverDependencies: LPCWSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERW });
FN('CorePrinterDriverInstalledA', HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, CoreDriverGUID: GUID, ftDriverDate: FILETIME, dwlDriverVersion: DWORDLONG, pbDriverInstalled: PTR(int) });
FN('CorePrinterDriverInstalledW', HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, CoreDriverGUID: GUID, ftDriverDate: FILETIME, dwlDriverVersion: DWORDLONG, pbDriverInstalled: PTR(int) });
FN('GetPrinterDriverPackagePathA', HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, pszLanguage: LPCSTR, pszPackageID: LPCSTR, pszDriverPackageCab: LPSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD });
FN('GetPrinterDriverPackagePathW', HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszLanguage: LPCWSTR, pszPackageID: LPCWSTR, pszDriverPackageCab: LPWSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD });
FN('DeletePrinterDriverPackageA', HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR });
FN('DeletePrinterDriverPackageW', HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR });
FN('ReportJobProcessingProgress', HRESULT, { printerHandle: HANDLE, jobId: ULONG, jobOperation: EPrintXPSJobOperation, jobProgress: EPrintXPSJobProgress });
FN('GetPrinterDriver2A', BOOL, { hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrinterDriver2W', BOOL, { hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD });
FN('GetPrintExecutionData', BOOL, { pData: PTR(uint) });
FN('_set_purecall_handler', _purecall_handler, { _Handler: _purecall_handler });
FN('_get_purecall_handler', _purecall_handler, {  });
FN('_set_invalid_parameter_handler', _invalid_parameter_handler, { _Handler: _invalid_parameter_handler });
FN('_get_invalid_parameter_handler', _invalid_parameter_handler, {  });
FN('_errno', 'void', {  });
FN('_set_errno', errno_t, { _Value: int });
FN('_get_errno', errno_t, { _Value: PTR(int) });
FN('__doserrno', 'void', {  });
FN('_set_doserrno', errno_t, { _Value: ulong });
FN('_get_doserrno', errno_t, { _Value: PTR(ulong) });
FN('__sys_errlist', 'void', {  });
FN('__sys_nerr', 'void', {  });
FN('_get_pgmptr', errno_t, { _Value: PTR(PTR(int8)) });
FN('_get_wpgmptr', errno_t, { _Value: PTR(PTR(ushort)) });
FN('_set_fmode', errno_t, { _Mode: int });
FN('_get_fmode', errno_t, { _PMode: PTR(int) });
FN('exit', 'void', { _Code: int });
FN('_exit', 'void', { _Code: int });
FN('abort', 'void', {  });
FN('_set_abort_behavior', 'void', { _Flags: uint, _Mask: uint });
FN('abs', 'void', { _X: int });
FN('labs', 'void', { _X: long });
FN('llabs', 'void', { _X: longlong });
FN('_abs64', 'void', { longlong: longlong });
FN('atexit', 'void', { PTR(pointer): PTR(pointer) });
FN('atof', 'void', { _String: PTR(int8) });
FN('_atof_l', 'void', { _String: PTR(int8), _Locale: _locale_t });
FN('atoi', 'void', { _Str: PTR(int8) });
FN('_atoi_l', 'void', { _Str: PTR(int8), _Locale: _locale_t });
FN('atol', 'void', { _Str: PTR(int8) });
FN('_atol_l', 'void', { _Str: PTR(int8), _Locale: _locale_t });
FN('bsearch_s', 'void', { _Key: PTR('void'), _Base: PTR('void'), _NumOfElements: rsize_t, _SizeOfElements: rsize_t, _PtFuncCompare: PTR(pointer), _Context: PTR('void') });
FN('bsearch', 'void', { _Key: PTR('void'), _Base: PTR('void'), _NumOfElements: size_t, _SizeOfElements: size_t, _PtFuncCompare: PTR(pointer) });
FN('qsort_s', 'void', { _Base: PTR('void'), _NumOfElements: rsize_t, _SizeOfElements: rsize_t, _PtFuncCompare: PTR(pointer), _Context: PTR('void') });
FN('qsort', 'void', { _Base: PTR('void'), _NumOfElements: size_t, _SizeOfElements: size_t, _PtFuncCompare: PTR(pointer) });
FN('_byteswap_ushort', 'void', { _Short: ushort });
FN('_byteswap_ulong', 'void', { _Long: ulong });
FN('_byteswap_uint64', 'void', { _Int64: ulonglong });
FN('div', div_t, { _Numerator: int, _Denominator: int });
FN('getenv', 'void', { _VarName: PTR(int8) });
FN('getenv_s', errno_t, { _ReturnSize: PTR(uint), _DstBuf: PTR(int8), _DstSize: rsize_t, _VarName: PTR(int8) });
FN('_dupenv_s', errno_t, { _PBuffer: PTR(PTR(int8)), _PBufferSizeInBytes: PTR(uint), _VarName: PTR(int8) });
FN('_itoa_s', errno_t, { _Value: int, _DstBuf: PTR(int8), _Size: size_t, _Radix: int });
FN('_itoa', 'void', { _Value: int, _Dest: PTR(int8), _Radix: int });
FN('_i64toa_s', errno_t, { _Val: longlong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int });
FN('_i64toa', 'void', { _Val: longlong, _DstBuf: PTR(int8), _Radix: int });
FN('_ui64toa_s', errno_t, { _Val: ulonglong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int });
FN('_ui64toa', 'void', { _Val: ulonglong, _DstBuf: PTR(int8), _Radix: int });
FN('_atoi64', 'void', { _String: PTR(int8) });
FN('_atoi64_l', 'void', { _String: PTR(int8), _Locale: _locale_t });
FN('_strtoi64', 'void', { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int });
FN('_strtoi64_l', 'void', { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t });
FN('_strtoui64', 'void', { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int });
FN('_strtoui64_l', 'void', { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t });
FN('ldiv', ldiv_t, { _Numerator: long, _Denominator: long });
FN('lldiv', lldiv_t, { _Numerator: longlong, _Denominator: longlong });
FN('_ltoa_s', errno_t, { _Val: long, _DstBuf: PTR(int8), _Size: size_t, _Radix: int });
FN('_ltoa', 'void', { _Value: long, _Dest: PTR(int8), _Radix: int });
FN('mblen', 'void', { _Ch: PTR(int8), _MaxCount: size_t });
FN('_mblen_l', 'void', { _Ch: PTR(int8), _MaxCount: size_t, _Locale: _locale_t });
FN('_mbstrlen', size_t, { _Str: PTR(int8) });
FN('_mbstrlen_l', size_t, { _Str: PTR(int8), _Locale: _locale_t });
FN('_mbstrnlen', size_t, { _Str: PTR(int8), _MaxCount: size_t });
FN('_mbstrnlen_l', size_t, { _Str: PTR(int8), _MaxCount: size_t, _Locale: _locale_t });
FN('mbtowc', 'void', { _DstCh: PTR(ushort), _SrcCh: PTR(int8), _SrcSizeInBytes: size_t });
FN('_mbtowc_l', 'void', { _DstCh: PTR(ushort), _SrcCh: PTR(int8), _SrcSizeInBytes: size_t, _Locale: _locale_t });
FN('mbstowcs_s', errno_t, { _PtNumOfCharConverted: PTR(uint), _DstBuf: PTR(ushort), _SizeInWords: size_t, _SrcBuf: PTR(int8), _MaxCount: size_t });
FN('mbstowcs', size_t, { _Dest: PTR(ushort), _Source: PTR(int8), _MaxCount: size_t });
FN('_mbstowcs_s_l', errno_t, { _PtNumOfCharConverted: PTR(uint), _DstBuf: PTR(ushort), _SizeInWords: size_t, _SrcBuf: PTR(int8), _MaxCount: size_t, _Locale: _locale_t });
FN('_mbstowcs_l', size_t, { _Dest: PTR(ushort), _Source: PTR(int8), _MaxCount: size_t, _Locale: _locale_t });
FN('rand', 'void', {  });
FN('_set_error_mode', 'void', { _Mode: int });
FN('srand', 'void', { _Seed: uint });
FN('strtod', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)) });
FN('_strtod_l', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Locale: _locale_t });
FN('strtol', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int });
FN('_strtol_l', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t });
FN('strtoul', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int });
FN('_strtoul_l', 'void', { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t });
FN('system', 'void', { _Command: PTR(int8) });
FN('_ultoa_s', errno_t, { _Val: ulong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int });
FN('_ultoa', 'void', { _Value: ulong, _Dest: PTR(int8), _Radix: int });
FN('wctomb', 'void', { _MbCh: PTR(int8), _WCh: wchar_t });
FN('_wctomb_l', 'void', { _MbCh: PTR(int8), _WCh: wchar_t, _Locale: _locale_t });
FN('wctomb_s', errno_t, { _SizeConverted: PTR(int), _MbCh: PTR(int8), _SizeInBytes: rsize_t, _WCh: wchar_t });
FN('_wctomb_s_l', errno_t, { _SizeConverted: PTR(int), _MbCh: PTR(int8), _SizeInBytes: size_t, _WCh: wchar_t, _Locale: _locale_t });
FN('wcstombs_s', errno_t, { _PtNumOfCharConverted: PTR(uint), _Dst: PTR(int8), _DstSizeInBytes: size_t, _Src: PTR(ushort), _MaxCountInBytes: size_t });
FN('wcstombs', size_t, { _Dest: PTR(int8), _Source: PTR(ushort), _MaxCount: size_t });
FN('_wcstombs_s_l', errno_t, { _PtNumOfCharConverted: PTR(uint), _Dst: PTR(int8), _DstSizeInBytes: size_t, _Src: PTR(ushort), _MaxCountInBytes: size_t, _Locale: _locale_t });
FN('_wcstombs_l', size_t, { _Dest: PTR(int8), _Source: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t });
FN('calloc', 'void', { _Count: size_t, _Size: size_t });
FN('free', 'void', { _Memory: PTR('void') });
FN('malloc', 'void', { _Size: size_t });
FN('realloc', 'void', { _Memory: PTR('void'), _NewSize: size_t });
FN('_recalloc', 'void', { _Memory: PTR('void'), _Count: size_t, _Size: size_t });
FN('_aligned_free', 'void', { _Memory: PTR('void') });
FN('_aligned_malloc', 'void', { _Size: size_t, _Alignment: size_t });
FN('_aligned_offset_malloc', 'void', { _Size: size_t, _Alignment: size_t, _Offset: size_t });
FN('_aligned_realloc', 'void', { _Memory: PTR('void'), _NewSize: size_t, _Alignment: size_t });
FN('_aligned_recalloc', 'void', { _Memory: PTR('void'), _Count: size_t, _Size: size_t, _Alignment: size_t });
FN('_aligned_offset_realloc', 'void', { _Memory: PTR('void'), _NewSize: size_t, _Alignment: size_t, _Offset: size_t });
FN('_aligned_offset_recalloc', 'void', { _Memory: PTR('void'), _Count: size_t, _Size: size_t, _Alignment: size_t, _Offset: size_t });
FN('_aligned_msize', size_t, { _Memory: PTR('void'), _Alignment: size_t, _Offset: size_t });
FN('_itow_s', errno_t, { _Val: int, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int });
FN('_itow', wchar_t, { _Value: int, _Dest: PTR(ushort), _Radix: int });
FN('_ltow_s', errno_t, { _Val: long, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int });
FN('_ltow', wchar_t, { _Value: long, _Dest: PTR(ushort), _Radix: int });
FN('_ultow_s', errno_t, { _Val: ulong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int });
FN('_ultow', wchar_t, { _Value: ulong, _Dest: PTR(ushort), _Radix: int });
FN('wcstod', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)) });
FN('_wcstod_l', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Locale: _locale_t });
FN('wcstol', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int });
FN('_wcstol_l', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t });
FN('wcstoul', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int });
FN('_wcstoul_l', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t });
FN('_wgetenv', wchar_t, { _VarName: PTR(ushort) });
FN('_wgetenv_s', errno_t, { _ReturnSize: PTR(uint), _DstBuf: PTR(ushort), _DstSizeInWords: size_t, _VarName: PTR(ushort) });
FN('_wdupenv_s', errno_t, { _Buffer: PTR(PTR(ushort)), _BufferSizeInWords: PTR(uint), _VarName: PTR(ushort) });
FN('_wsystem', 'void', { _Command: PTR(ushort) });
FN('_wtof', 'void', { _Str: PTR(ushort) });
FN('_wtof_l', 'void', { _Str: PTR(ushort), _Locale: _locale_t });
FN('_wtoi', 'void', { _Str: PTR(ushort) });
FN('_wtoi_l', 'void', { _Str: PTR(ushort), _Locale: _locale_t });
FN('_wtol', 'void', { _Str: PTR(ushort) });
FN('_wtol_l', 'void', { _Str: PTR(ushort), _Locale: _locale_t });
FN('_i64tow_s', errno_t, { _Val: longlong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int });
FN('_i64tow', wchar_t, { _Val: longlong, _DstBuf: PTR(ushort), _Radix: int });
FN('_ui64tow_s', errno_t, { _Val: ulonglong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int });
FN('_ui64tow', wchar_t, { _Val: ulonglong, _DstBuf: PTR(ushort), _Radix: int });
FN('_wtoi64', 'void', { _Str: PTR(ushort) });
FN('_wtoi64_l', 'void', { _Str: PTR(ushort), _Locale: _locale_t });
FN('_wcstoi64', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int });
FN('_wcstoi64_l', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t });
FN('_wcstoui64', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int });
FN('_wcstoui64_l', 'void', { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t });
FN('_fullpath', 'void', { _FullPath: PTR(int8), _Path: PTR(int8), _SizeInBytes: size_t });
FN('_ecvt_s', errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDights: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('_ecvt', 'void', { _Val: double, _NumOfDigits: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('_fcvt_s', errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('_fcvt', 'void', { _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('_gcvt_s', errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDigits: int });
FN('_gcvt', 'void', { _Val: double, _NumOfDigits: int, _DstBuf: PTR(int8) });
FN('_atodbl', 'void', { _Result: PTR(uint), _Str: PTR(int8) });
FN('_atoldbl', 'void', { _Result: PTR(uint), _Str: PTR(int8) });
FN('_atoflt', 'void', { _Result: PTR(uint), _Str: PTR(int8) });
FN('_atodbl_l', 'void', { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t });
FN('_atoldbl_l', 'void', { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t });
FN('_atoflt_l', 'void', { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t });
FN('_lrotl', 'void', { _Val: ulong, _Shift: int });
FN('_lrotr', 'void', { _Val: ulong, _Shift: int });
FN('_makepath_s', errno_t, { _PathResult: PTR(int8), _SizeInWords: size_t, _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) });
FN('_makepath', 'void', { _Path: PTR(int8), _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) });
FN('_onexit', _onexit_t, { _Func: _onexit_t });
FN('perror', 'void', { _ErrMsg: PTR(int8) });
FN('_putenv', 'void', { _EnvString: PTR(int8) });
FN('_putenv_s', errno_t, { _Name: PTR(int8), _Value: PTR(int8) });
FN('_searchenv_s', errno_t, { _Filename: PTR(int8), _EnvVar: PTR(int8), _ResultPath: PTR(int8), _SizeInBytes: size_t });
FN('_searchenv', 'void', { _Filename: PTR(int8), _EnvVar: PTR(int8), _ResultPath: PTR(int8) });
FN('_splitpath', 'void', { _FullPath: PTR(int8), _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) });
FN('_splitpath_s', errno_t, { _FullPath: PTR(int8), _Drive: PTR(int8), _DriveSize: size_t, _Dir: PTR(int8), _DirSize: size_t, _Filename: PTR(int8), _FilenameSize: size_t, _Ext: PTR(int8), _ExtSize: size_t });
FN('_swab', 'void', { _Buf1: PTR(int8), _Buf2: PTR(int8), _SizeInBytes: int });
FN('_wfullpath', wchar_t, { _FullPath: PTR(ushort), _Path: PTR(ushort), _SizeInWords: size_t });
FN('_wmakepath_s', errno_t, { _PathResult: PTR(ushort), _SIZE: size_t, _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) });
FN('_wmakepath', 'void', { _ResultPath: PTR(ushort), _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) });
FN('_wperror', 'void', { _ErrMsg: PTR(ushort) });
FN('_wputenv', 'void', { _EnvString: PTR(ushort) });
FN('_wputenv_s', errno_t, { _Name: PTR(ushort), _Value: PTR(ushort) });
FN('_wsearchenv_s', errno_t, { _Filename: PTR(ushort), _EnvVar: PTR(ushort), _ResultPath: PTR(ushort), _SizeInWords: size_t });
FN('_wsearchenv', 'void', { _Filename: PTR(ushort), _EnvVar: PTR(ushort), _ResultPath: PTR(ushort) });
FN('_wsplitpath', 'void', { _FullPath: PTR(ushort), _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) });
FN('_wsplitpath_s', errno_t, { _FullPath: PTR(ushort), _Drive: PTR(ushort), _DriveSize: size_t, _Dir: PTR(ushort), _DirSize: size_t, _Filename: PTR(ushort), _FilenameSize: size_t, _Ext: PTR(ushort), _ExtSize: size_t });
FN('_seterrormode', 'void', { _Mode: int });
FN('_beep', 'void', { _Frequency: uint, _Duration: uint });
FN('_sleep', 'void', { _Duration: ulong });
FN('ecvt', 'void', { _Val: double, _NumOfDigits: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('fcvt', 'void', { _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) });
FN('gcvt', 'void', { _Val: double, _NumOfDigits: int, _DstBuf: PTR(int8) });
FN('itoa', 'void', { _Val: int, _DstBuf: PTR(int8), _Radix: int });
FN('ltoa', 'void', { _Val: long, _DstBuf: PTR(int8), _Radix: int });
FN('putenv', 'void', { _EnvString: PTR(int8) });
FN('swab', 'void', { _Buf1: PTR(int8), _Buf2: PTR(int8), _SizeInBytes: int });
FN('ultoa', 'void', { _Val: ulong, _Dstbuf: PTR(int8), _Radix: int });
FN('onexit', _onexit_t, { _Func: _onexit_t });
FN('IUnknown_QueryInterface_Proxy', HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR('void')) });
FN('IUnknown_QueryInterface_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IUnknown_AddRef_Proxy', ULONG, { This: PTR(uint) });
FN('IUnknown_AddRef_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IUnknown_Release_Proxy', ULONG, { This: PTR(uint) });
FN('IUnknown_Release_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IClassFactory_RemoteCreateInstance_Proxy', HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) });
FN('IClassFactory_RemoteCreateInstance_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IClassFactory_RemoteLockServer_Proxy', HRESULT, { This: PTR(uint), fLock: BOOL });
FN('IClassFactory_RemoteLockServer_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IClassFactory_CreateInstance_Proxy', HRESULT, { This: PTR(uint), pUnkOuter: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR('void')) });
FN('IClassFactory_CreateInstance_Stub', HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) });
FN('IClassFactory_LockServer_Proxy', HRESULT, { This: PTR(uint), fLock: BOOL });
FN('IClassFactory_LockServer_Stub', HRESULT, { This: PTR(uint), fLock: BOOL });
FN('IEnumUnknown_RemoteNext_Proxy', HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) });
FN('IEnumUnknown_RemoteNext_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IBindCtx_RemoteSetBindOptions_Proxy', HRESULT, { This: PTR(uint), pbindopts: PTR(uint) });
FN('IBindCtx_RemoteSetBindOptions_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IBindCtx_RemoteGetBindOptions_Proxy', HRESULT, { This: PTR(uint), pbindopts: PTR(uint) });
FN('IBindCtx_RemoteGetBindOptions_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IEnumMoniker_RemoteNext_Proxy', HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) });
FN('IEnumMoniker_RemoteNext_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IRunnableObject_RemoteIsRunning_Proxy', HRESULT, { This: PTR(uint) });
FN('IRunnableObject_RemoteIsRunning_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IMoniker_RemoteBindToObject_Proxy', HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riidResult: PTR(uint), ppvResult: PTR(PTR(uint)) });
FN('IMoniker_RemoteBindToObject_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IMoniker_RemoteBindToStorage_Proxy', HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) });
FN('IMoniker_RemoteBindToStorage_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IEnumString_RemoteNext_Proxy', HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(ushort)), pceltFetched: PTR(ulong) });
FN('IEnumString_RemoteNext_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('ISequentialStream_RemoteRead_Proxy', HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbRead: PTR(ulong) });
FN('ISequentialStream_RemoteRead_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('ISequentialStream_RemoteWrite_Proxy', HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) });
FN('ISequentialStream_RemoteWrite_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IStream_RemoteSeek_Proxy', HRESULT, { This: PTR(uint), dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: PTR(uint) });
FN('IStream_RemoteSeek_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IStream_RemoteCopyTo_Proxy', HRESULT, { This: PTR(uint), pstm: PTR(uint), cb: ULARGE_INTEGER, pcbRead: PTR(uint), pcbWritten: PTR(uint) });
FN('IStream_RemoteCopyTo_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IEnumSTATSTG_RemoteNext_Proxy', HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) });
FN('IEnumSTATSTG_RemoteNext_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IStorage_RemoteOpenStream_Proxy', HRESULT, { This: PTR(uint), pwcsName: PTR(ushort), cbReserved1: ulong, reserved1: PTR(uchar), grfMode: DWORD, reserved2: DWORD, ppstm: PTR(PTR(uint)) });
FN('IStorage_RemoteOpenStream_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IStorage_RemoteCopyTo_Proxy', HRESULT, { This: PTR(uint), ciidExclude: DWORD, rgiidExclude: PTR(uint), snbExclude: SNB, pstgDest: PTR(uint) });
FN('IStorage_RemoteCopyTo_Stub', 'void', { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) });
FN('IStorage_RemoteEnumElements_Proxy', HRESULT, { This: PTR(uint)