mugli
7/23/2015 - 6:58 PM

windows.h.js INFINITY

windows.h.js INFINITY

var ffi = require('ffi'),
    ref = require('ref'),
    Struct = require('ref-struct'),
    Library = require('./Library'),
    Type = ref.Type,
    NULL = ref.NULL,
    isNull = ref.isNull;


var groups = ['libs', 'types', 'structs', 'callbacks', 'enums'];

module.exports = lookup;

function lookup(name){
  if (name == null || name.toLowerCase() === 'null') {
    return NULL;
  }
  var i = groups.length;
  while (i--) {
    if (name in lookup[groups[i]]) {
      return lookup[groups[i]][name];
    }
  }
  for (var k in lookup.libs) {
    if (name in lookup.libs[k]) {
      return lookup.libs[k][name];
    }
    if ((name + 'A') in lookup.libs[k]) {
      return lookup.libs[k][name + 'A'];
    }
  }
}

lookup.NULL = ref.NULL;
lookup.isNull = ref.isNull;

groups.forEach(function(name){
  lookup[name] = {};
});

var types = lookup.types;

var
 VOID = types.void = ffi.types.void,
 bool = types.bool = ffi.types.bool,
 int8 = types.int8 = ffi.types.int8,
 uint8 = types.uint8 = ffi.types.uint8,
 int16 = types.int16 = ffi.types.int16,
 uint16 = types.uint16 = ffi.types.uint16,
 int32 = types.int32 = ffi.types.int32,
 uint32 = types.uint32 = ffi.types.uint32,
 int64 = types.int64 = ffi.types.int64,
 uint64 = types.uint64 = ffi.types.uint64,
 float = types.float = ffi.types.float,
 double = types.double = ffi.types.double,
 byte = types.byte = ffi.types.byte,
 char = types.char = ffi.types.char,
 uchar = types.uchar = ffi.types.uchar,
 short = types.short = ffi.types.short,
 ushort = types.ushort = ffi.types.ushort,
 int = types.int = ffi.types.int,
 uint = types.uint = ffi.types.uint,
 long = types.long = ffi.types.long,
 ulong = types.ulong = ffi.types.ulong,
 longlong = types.longlong = ffi.types.longlong,
 ulonglong = types.ulonglong = ffi.types.ulonglong,
 size_t = types.size_t = ffi.types.size_t,
 string = types.CString = ffi.types.CString,
 VOIDPTR = TYPEDEF('VOIDPTR', PTR(VOID));


function PTR(type){
  return ref.refType(type);
}

function TYPEDEF(name, type){
  return type.typedef(name);
}

function CALLBACK(name, ret, args){
  var f = new Function('cb', 'ret', 'args', 'return function '+name+'(f){ return cb(ret, args, f) }')(ffi.Callback, ret, args);
  lookup.callbacks[name] = f;
  return TYPEDEF(name, VOIDPTR);
}

function STRUCT(name, fields){
  return lookup.structs[name] = new Struct(name, fields);
}

function ENUM(name, values){
  var enumeration = lookup.enums[name] = new Enumeration(values);
  enumeration.name = name;
  return enumeration;
}

function LIBRARY(name, functions){
  return lookup.libs[name] = new Library(name, functions);
}

function ARRAY(type, length){
  var fields = {};
  Array.apply(null, new Array(length)).forEach(function(x, i){
    fields[i] = type;
  });
  return STRUCT(type.name+'x'+length, fields);
}

function Enumeration(values){
  this._keys = new Map;
  this._values = new Map;
  Object.keys(values).forEach(function(key){
    this._keys.set(key, values[key]);
    this._values.set(values[key], key);
    this[key] = values[key];
  }, this);
}

Enumeration.prototype.toKey = function toKey(v){
  if (this._keys.has(v)) {
    return v;
  } else {
    return this._values.get(v);
  }
};

Enumeration.prototype.toValue = function toValue(v){
  if (this._values.has(v)) {
    return v;
  } else {
    return this._keys.get(v);
  }
};


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

 HWND = TYPEDEF('HWND', HANDLE),
 HHOOK = TYPEDEF('HHOOK', HANDLE),
 HKEY = TYPEDEF('HKEY', HANDLE),
 HACCEL = TYPEDEF('HACCEL', HANDLE),
 HBITMAP = TYPEDEF('HBITMAP', HANDLE),
 HBRUSH = TYPEDEF('HBRUSH', HANDLE),
 HCOLORSPACE = TYPEDEF('HCOLORSPACE', HANDLE),
 HDC = TYPEDEF('HDC', HANDLE),
 HGLRC = TYPEDEF('HGLRC', HANDLE),
 HDESK = TYPEDEF('HDESK', HANDLE),
 HENHMETAFILE = TYPEDEF('HENHMETAFILE', HANDLE),
 HFONT = TYPEDEF('HFONT', HANDLE),
 HICON = TYPEDEF('HICON', HANDLE),
 HMENU = TYPEDEF('HMENU', HANDLE),
 HMETAFILE = TYPEDEF('HMETAFILE', HANDLE),
 HINSTANCE = TYPEDEF('HINSTANCE', HANDLE),
 HPALETTE = TYPEDEF('HPALETTE', HANDLE),
 HPEN = TYPEDEF('HPEN', HANDLE),
 HRGN = TYPEDEF('HRGN', HANDLE),
 HRSRC = TYPEDEF('HRSRC', HANDLE),
 HSPRITE = TYPEDEF('HSPRITE', HANDLE),
 HLSURF = TYPEDEF('HLSURF', HANDLE),
 HSTR = TYPEDEF('HSTR', HANDLE),
 HTASK = TYPEDEF('HTASK', HANDLE),
 HWINSTA = TYPEDEF('HWINSTA', HANDLE),
 HKL = TYPEDEF('HKL', HANDLE),
 HWINEVENTHOOK = TYPEDEF('HWINEVENTHOOK', HANDLE),
 HMONITOR = TYPEDEF('HMONITOR', HANDLE),
 HUMPD = TYPEDEF('HUMPD', HANDLE);


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('PEXCEPTION_ROUTINE', EXCEPTION_DISPOSITION, [PTR(_EXCEPTION_RECORD), PTR(VOID), PTR(_CONTEXT), PTR(VOID)]);
var PIMAGE_TLS_CALLBACK = CALLBACK('PIMAGE_TLS_CALLBACK', VOID, [PTR(VOID), ulong, PTR(VOID)]);
var PRTL_RUN_ONCE_INIT_FN = CALLBACK('PRTL_RUN_ONCE_INIT_FN', ulong, [PTR(_RTL_RUN_ONCE), PTR(VOID), PTR(PTR(VOID))]);
var PRTL_UMS_SCHEDULER_ENTRY_POINT = CALLBACK('PRTL_UMS_SCHEDULER_ENTRY_POINT', VOID, [RTL_UMS_SCHEDULER_REASON, ulong, PTR(VOID)]);
var PAPCFUNC = CALLBACK('PAPCFUNC', VOID, [ulong]);
var PVECTORED_EXCEPTION_HANDLER = CALLBACK('PVECTORED_EXCEPTION_HANDLER', long, [PTR(EXCEPTION_POINTERS)]);
var WAITORTIMERCALLBACKFUNC = CALLBACK('WAITORTIMERCALLBACKFUNC', VOID, [PTR(VOID), uchar]);
var WORKERCALLBACKFUNC = CALLBACK('WORKERCALLBACKFUNC', VOID, [PTR(VOID)]);
var APC_CALLBACK_FUNCTION = CALLBACK('APC_CALLBACK_FUNCTION', VOID, [ulong, PTR(VOID), PTR(VOID)]);
var PFLS_CALLBACK_FUNCTION = CALLBACK('PFLS_CALLBACK_FUNCTION', VOID, [PTR(VOID)]);
var PSECURE_MEMORY_CACHE_CALLBACK = CALLBACK('PSECURE_MEMORY_CACHE_CALLBACK', uchar, [PTR(VOID), ulong]);
var PTP_SIMPLE_CALLBACK = CALLBACK('PTP_SIMPLE_CALLBACK', VOID, [PTR(TP_CALLBACK_INSTANCE), PTR(VOID)]);
var PTP_CLEANUP_GROUP_CANCEL_CALLBACK = CALLBACK('PTP_CLEANUP_GROUP_CANCEL_CALLBACK', VOID, [PTR(VOID), PTR(VOID)]);
var PTP_WORK_CALLBACK = CALLBACK('PTP_WORK_CALLBACK', VOID, [PTR(TP_CALLBACK_INSTANCE), PTR(VOID), PTR(TP_WORK)]);
var PTP_TIMER_CALLBACK = CALLBACK('PTP_TIMER_CALLBACK', VOID, [PTR(TP_CALLBACK_INSTANCE), PTR(VOID), PTR(TP_TIMER)]);
var PTP_WAIT_CALLBACK = CALLBACK('PTP_WAIT_CALLBACK', VOID, [PTR(TP_CALLBACK_INSTANCE), PTR(VOID), PTR(TP_WAIT), ulong]);
var PTHREAD_START_ROUTINE = CALLBACK('PTHREAD_START_ROUTINE', ulong, [PTR(VOID)]);
var LPTHREAD_START_ROUTINE = CALLBACK('LPTHREAD_START_ROUTINE', ulong, [PTR(VOID)]);
var PFIBER_START_ROUTINE = CALLBACK('PFIBER_START_ROUTINE', VOID, [PTR(VOID)]);
var LPFIBER_START_ROUTINE = CALLBACK('LPFIBER_START_ROUTINE', VOID, [PTR(VOID)]);
var PINIT_ONCE_FN = CALLBACK('PINIT_ONCE_FN', int, [PTR(_RTL_RUN_ONCE), PTR(VOID), PTR(PTR(VOID))]);
var PTOP_LEVEL_EXCEPTION_FILTER = CALLBACK('PTOP_LEVEL_EXCEPTION_FILTER', long, [PTR(EXCEPTION_POINTERS)]);
var LPTOP_LEVEL_EXCEPTION_FILTER = CALLBACK('LPTOP_LEVEL_EXCEPTION_FILTER', long, [PTR(EXCEPTION_POINTERS)]);
var PUMS_SCHEDULER_ENTRY_POINT = CALLBACK('PUMS_SCHEDULER_ENTRY_POINT', VOID, [UMS_SCHEDULER_REASON, ulong, PTR(VOID)]);
var PFE_EXPORT_FUNC = CALLBACK('PFE_EXPORT_FUNC', ulong, [PTR(uchar), PTR(VOID), ulong]);
var PFE_IMPORT_FUNC = CALLBACK('PFE_IMPORT_FUNC', ulong, [PTR(uchar), PTR(VOID), PTR(ulong)]);
var LPOVERLAPPED_COMPLETION_ROUTINE = CALLBACK('LPOVERLAPPED_COMPLETION_ROUTINE', VOID, [ulong, ulong, PTR(OVERLAPPED)]);
var PTIMERAPCROUTINE = CALLBACK('PTIMERAPCROUTINE', VOID, [PTR(VOID), ulong, ulong]);
var PGET_MODULE_HANDLE_EXA = CALLBACK('PGET_MODULE_HANDLE_EXA', int, [ulong, PTR(int8), PTR(HINSTANCE)]);
var PGET_MODULE_HANDLE_EXW = CALLBACK('PGET_MODULE_HANDLE_EXW', int, [ulong, PTR(ushort), PTR(HINSTANCE)]);
var ENUMRESTYPEPROCA = CALLBACK('ENUMRESTYPEPROCA', int, [HINSTANCE, PTR(int8), long]);
var ENUMRESTYPEPROCW = CALLBACK('ENUMRESTYPEPROCW', int, [HINSTANCE, PTR(ushort), long]);
var ENUMRESNAMEPROCA = CALLBACK('ENUMRESNAMEPROCA', int, [HINSTANCE, PTR(int8), PTR(int8), long]);
var ENUMRESNAMEPROCW = CALLBACK('ENUMRESNAMEPROCW', int, [HINSTANCE, PTR(ushort), PTR(ushort), long]);
var ENUMRESLANGPROCA = CALLBACK('ENUMRESLANGPROCA', int, [HINSTANCE, PTR(int8), PTR(int8), ushort, long]);
var ENUMRESLANGPROCW = CALLBACK('ENUMRESLANGPROCW', int, [HINSTANCE, PTR(ushort), PTR(ushort), ushort, long]);
var PGET_SYSTEM_WOW64_DIRECTORY_A = CALLBACK('PGET_SYSTEM_WOW64_DIRECTORY_A', uint, [PTR(int8), uint]);
var PGET_SYSTEM_WOW64_DIRECTORY_W = CALLBACK('PGET_SYSTEM_WOW64_DIRECTORY_W', uint, [PTR(ushort), uint]);
var LPPROGRESS_ROUTINE = CALLBACK('LPPROGRESS_ROUTINE', ulong, [_LARGE_INTEGER, _LARGE_INTEGER, _LARGE_INTEGER, _LARGE_INTEGER, ulong, ulong, PTR(VOID), PTR(VOID), PTR(VOID)]);
var WAITORTIMERCALLBACK = CALLBACK('WAITORTIMERCALLBACK', VOID, [PTR(VOID), uchar]);
var PTP_WIN32_IO_CALLBACK = CALLBACK('PTP_WIN32_IO_CALLBACK', VOID, [PTR(TP_CALLBACK_INSTANCE), PTR(VOID), PTR(VOID), ulong, ulong, PTR(TP_IO)]);
var PQUERYACTCTXW_FUNC = CALLBACK('PQUERYACTCTXW_FUNC', int, [ulong, PTR(VOID), PTR(VOID), ulong, PTR(VOID), ulong, PTR(ulong)]);
var APPLICATION_RECOVERY_CALLBACK = CALLBACK('APPLICATION_RECOVERY_CALLBACK', ulong, [PTR(VOID)]);
var OLDFONTENUMPROCA = CALLBACK('OLDFONTENUMPROCA', int, [PTR(LOGFONT), PTR(TEXTMETRIC), ulong, long]);
var OLDFONTENUMPROCW = CALLBACK('OLDFONTENUMPROCW', int, [PTR(LOGFONTW), PTR(TEXTMETRICW), ulong, long]);
var FONTENUMPROCA = CALLBACK('FONTENUMPROCA', int, [PTR(LOGFONT), PTR(TEXTMETRIC), ulong, long]);
var FONTENUMPROCW = CALLBACK('FONTENUMPROCW', int, [PTR(LOGFONTW), PTR(TEXTMETRICW), ulong, long]);
var FONTENUMPROC = CALLBACK('FONTENUMPROC', int, [PTR(LOGFONT), PTR(TEXTMETRIC), ulong, long]);
var GOBJENUMPROC = CALLBACK('GOBJENUMPROC', int, [PTR(VOID), long]);
var LINEDDAPROC = CALLBACK('LINEDDAPROC', VOID, [int, int, long]);
var LPFNDEVMODE = CALLBACK('LPFNDEVMODE', uint, [HWND, HINSTANCE, PTR(DEVMODE), PTR(int8), PTR(int8), PTR(DEVMODE), PTR(int8), uint]);
var LPFNDEVCAPS = CALLBACK('LPFNDEVCAPS', ulong, [PTR(int8), PTR(int8), uint, PTR(int8), PTR(DEVMODE)]);
var MFENUMPROC = CALLBACK('MFENUMPROC', int, [HDC, PTR(HANDLETABLE), PTR(METARECORD), int, long]);
var ENHMFENUMPROC = CALLBACK('ENHMFENUMPROC', int, [HDC, PTR(HANDLETABLE), PTR(ENHMETARECORD), int, long]);
var ABORTPROC = CALLBACK('ABORTPROC', int, [HDC, int]);
var ICMENUMPROCA = CALLBACK('ICMENUMPROCA', int, [PTR(int8), long]);
var ICMENUMPROCW = CALLBACK('ICMENUMPROCW', int, [PTR(ushort), long]);
var WNDPROC = CALLBACK('WNDPROC', long, [HWND, uint, uint, long]);
var DLGPROC = CALLBACK('DLGPROC', int, [HWND, uint, uint, long]);
var TIMERPROC = CALLBACK('TIMERPROC', VOID, [HWND, uint, uint, ulong]);
var GRAYSTRINGPROC = CALLBACK('GRAYSTRINGPROC', int, [HDC, long, int]);
var WNDENUMPROC = CALLBACK('WNDENUMPROC', int, [HWND, long]);
var HOOKPROC = CALLBACK('HOOKPROC', long, [int, uint, long]);
var SENDASYNCPROC = CALLBACK('SENDASYNCPROC', VOID, [HWND, uint, ulong, long]);
var PROPENUMPROCA = CALLBACK('PROPENUMPROCA', int, [HWND, PTR(int8), PTR(VOID)]);
var PROPENUMPROCW = CALLBACK('PROPENUMPROCW', int, [HWND, PTR(ushort), PTR(VOID)]);
var PROPENUMPROCEXA = CALLBACK('PROPENUMPROCEXA', int, [HWND, PTR(int8), PTR(VOID), ulong]);
var PROPENUMPROCEXW = CALLBACK('PROPENUMPROCEXW', int, [HWND, PTR(ushort), PTR(VOID), ulong]);
var EDITWORDBREAKPROCA = CALLBACK('EDITWORDBREAKPROCA', int, [PTR(int8), int, int, int]);
var EDITWORDBREAKPROCW = CALLBACK('EDITWORDBREAKPROCW', int, [PTR(ushort), int, int, int]);
var DRAWSTATEPROC = CALLBACK('DRAWSTATEPROC', int, [HDC, long, uint, int, int]);
var PROPENUMPROC = CALLBACK('PROPENUMPROC', int, [HWND, PTR(int8), PTR(VOID)]);
var PROPENUMPROCEX = CALLBACK('PROPENUMPROCEX', int, [HWND, PTR(int8), PTR(VOID), ulong]);
var EDITWORDBREAKPROC = CALLBACK('EDITWORDBREAKPROC', int, [PTR(int8), int, int, int]);
var NAMEENUMPROCA = CALLBACK('NAMEENUMPROCA', int, [PTR(int8), long]);
var NAMEENUMPROCW = CALLBACK('NAMEENUMPROCW', int, [PTR(ushort), long]);
var WINSTAENUMPROCA = CALLBACK('WINSTAENUMPROCA', int, [PTR(int8), long]);
var DESKTOPENUMPROCA = CALLBACK('DESKTOPENUMPROCA', int, [PTR(int8), long]);
var WINSTAENUMPROCW = CALLBACK('WINSTAENUMPROCW', int, [PTR(ushort), long]);
var DESKTOPENUMPROCW = CALLBACK('DESKTOPENUMPROCW', int, [PTR(ushort), long]);
var WINSTAENUMPROC = CALLBACK('WINSTAENUMPROC', int, [PTR(int8), long]);
var DESKTOPENUMPROC = CALLBACK('DESKTOPENUMPROC', int, [PTR(int8), long]);
var PREGISTERCLASSNAMEW = CALLBACK('PREGISTERCLASSNAMEW', uchar, [PTR(ushort)]);
var MSGBOXCALLBACK = CALLBACK('MSGBOXCALLBACK', VOID, [PTR(HELPINFO)]);
var MONITORENUMPROC = CALLBACK('MONITORENUMPROC', int, [HMONITOR, HDC, PTR(RECT), long]);
var WINEVENTPROC = CALLBACK('WINEVENTPROC', VOID, [HWINEVENTHOOK, ulong, HWND, long, long, ulong, ulong]);
var LANGUAGEGROUP_ENUMPROCA = CALLBACK('LANGUAGEGROUP_ENUMPROCA', int, [ulong, PTR(int8), PTR(int8), ulong, long]);
var LANGGROUPLOCALE_ENUMPROCA = CALLBACK('LANGGROUPLOCALE_ENUMPROCA', int, [ulong, ulong, PTR(int8), long]);
var UILANGUAGE_ENUMPROCA = CALLBACK('UILANGUAGE_ENUMPROCA', int, [PTR(int8), long]);
var LOCALE_ENUMPROCA = CALLBACK('LOCALE_ENUMPROCA', int, [PTR(int8)]);
var CODEPAGE_ENUMPROCA = CALLBACK('CODEPAGE_ENUMPROCA', int, [PTR(int8)]);
var DATEFMT_ENUMPROCA = CALLBACK('DATEFMT_ENUMPROCA', int, [PTR(int8)]);
var DATEFMT_ENUMPROCEXA = CALLBACK('DATEFMT_ENUMPROCEXA', int, [PTR(int8), ulong]);
var TIMEFMT_ENUMPROCA = CALLBACK('TIMEFMT_ENUMPROCA', int, [PTR(int8)]);
var CALINFO_ENUMPROCA = CALLBACK('CALINFO_ENUMPROCA', int, [PTR(int8)]);
var CALINFO_ENUMPROCEXA = CALLBACK('CALINFO_ENUMPROCEXA', int, [PTR(int8), ulong]);
var LANGUAGEGROUP_ENUMPROCW = CALLBACK('LANGUAGEGROUP_ENUMPROCW', int, [ulong, PTR(ushort), PTR(ushort), ulong, long]);
var LANGGROUPLOCALE_ENUMPROCW = CALLBACK('LANGGROUPLOCALE_ENUMPROCW', int, [ulong, ulong, PTR(ushort), long]);
var UILANGUAGE_ENUMPROCW = CALLBACK('UILANGUAGE_ENUMPROCW', int, [PTR(ushort), long]);
var LOCALE_ENUMPROCW = CALLBACK('LOCALE_ENUMPROCW', int, [PTR(ushort)]);
var CODEPAGE_ENUMPROCW = CALLBACK('CODEPAGE_ENUMPROCW', int, [PTR(ushort)]);
var DATEFMT_ENUMPROCW = CALLBACK('DATEFMT_ENUMPROCW', int, [PTR(ushort)]);
var DATEFMT_ENUMPROCEXW = CALLBACK('DATEFMT_ENUMPROCEXW', int, [PTR(ushort), ulong]);
var TIMEFMT_ENUMPROCW = CALLBACK('TIMEFMT_ENUMPROCW', int, [PTR(ushort)]);
var CALINFO_ENUMPROCW = CALLBACK('CALINFO_ENUMPROCW', int, [PTR(ushort)]);
var CALINFO_ENUMPROCEXW = CALLBACK('CALINFO_ENUMPROCEXW', int, [PTR(ushort), ulong]);
var GEO_ENUMPROC = CALLBACK('GEO_ENUMPROC', int, [long]);
var CALINFO_ENUMPROCEXEX = CALLBACK('CALINFO_ENUMPROCEXEX', int, [PTR(ushort), ulong, PTR(ushort), long]);
var DATEFMT_ENUMPROCEXEX = CALLBACK('DATEFMT_ENUMPROCEXEX', int, [PTR(ushort), ulong, long]);
var TIMEFMT_ENUMPROCEX = CALLBACK('TIMEFMT_ENUMPROCEX', int, [PTR(ushort), long]);
var LOCALE_ENUMPROCEX = CALLBACK('LOCALE_ENUMPROCEX', int, [PTR(ushort), ulong, long]);
var PHANDLER_ROUTINE = CALLBACK('PHANDLER_ROUTINE', int, [ulong]);
var PQUERYHANDLER = CALLBACK('PQUERYHANDLER', ulong, [PTR(VOID), PTR(val_context), ulong, PTR(VOID), PTR(ulong), ulong]);
var PFNCALLBACK = CALLBACK('PFNCALLBACK', HDDEDATA, [uint, uint, HCONV, HSZ, HSZ, HDDEDATA, ulong, ulong]);
var DRIVERPROC = CALLBACK('DRIVERPROC', long, [ulong, HDRVR, uint, long, long]);
var LPDRVCALLBACK = CALLBACK('LPDRVCALLBACK', VOID, [HDRVR, uint, ulong, ulong, ulong]);
var PDRVCALLBACK = CALLBACK('PDRVCALLBACK', VOID, [HDRVR, uint, ulong, ulong, ulong]);
var LPWAVECALLBACK = CALLBACK('LPWAVECALLBACK', VOID, [HDRVR, uint, ulong, ulong, ulong]);
var LPMIDICALLBACK = CALLBACK('LPMIDICALLBACK', VOID, [HDRVR, uint, ulong, ulong, ulong]);
var LPTIMECALLBACK = CALLBACK('LPTIMECALLBACK', VOID, [uint, uint, ulong, ulong, ulong]);
var LPMMIOPROC = CALLBACK('LPMMIOPROC', long, [PTR(int8), uint, long, long]);
var YIELDPROC = CALLBACK('YIELDPROC', uint, [uint, ulong]);
var RPC_NEW_HTTP_PROXY_CHANNEL = CALLBACK('RPC_NEW_HTTP_PROXY_CHANNEL', 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('RPC_HTTP_PROXY_FREE_STRING', VOID, [PTR(ushort)]);
var RPC_AUTH_KEY_RETRIEVAL_FN = CALLBACK('RPC_AUTH_KEY_RETRIEVAL_FN', VOID, [PTR(VOID), PTR(ushort), ulong, PTR(PTR(VOID)), PTR(long)]);
var RPC_MGMT_AUTHORIZATION_FN = CALLBACK('RPC_MGMT_AUTHORIZATION_FN', int, [PTR(VOID), ulong, PTR(long)]);
var RPC_DISPATCH_FUNCTION = CALLBACK('RPC_DISPATCH_FUNCTION', VOID, [PTR(RPC_MESSAGE)]);
var PRPC_RUNDOWN = CALLBACK('PRPC_RUNDOWN', VOID, [PTR(VOID)]);
var RPCLT_PDU_FILTER_FUNC = CALLBACK('RPCLT_PDU_FILTER_FUNC', VOID, [PTR(VOID), uint, int]);
var RPC_SETFILTER_FUNC = CALLBACK('RPC_SETFILTER_FUNC', VOID, [PTR(CALLBACK(VOID, [PTR(VOID), uint, int]))]);
var RPC_BLOCKING_FN = CALLBACK('RPC_BLOCKING_FN', long, [PTR(VOID), PTR(VOID), PTR(VOID)]);
var I_RpcProxyIsValidMachineFn = CALLBACK('I_RpcProxyIsValidMachineFn', long, [PTR(ushort), PTR(ushort), ulong]);
var I_RpcProxyGetClientAddressFn = CALLBACK('I_RpcProxyGetClientAddressFn', long, [PTR(VOID), PTR(int8), PTR(ulong)]);
var I_RpcProxyGetConnectionTimeoutFn = CALLBACK('I_RpcProxyGetConnectionTimeoutFn', long, [PTR(ulong)]);
var I_RpcPerformCalloutFn = CALLBACK('I_RpcPerformCalloutFn', long, [PTR(VOID), PTR(RDR_CALLOUT_STATE), RPC_HTTP_REDIRECTOR_STAGE]);
var I_RpcFreeCalloutStateFn = CALLBACK('I_RpcFreeCalloutStateFn', VOID, [PTR(RDR_CALLOUT_STATE)]);
var I_RpcProxyGetClientSessionAndResourceUUID = CALLBACK('I_RpcProxyGetClientSessionAndResourceUUID', long, [PTR(VOID), PTR(int), PTR(UUID), PTR(int), PTR(UUID)]);
var I_RpcProxyFilterIfFn = CALLBACK('I_RpcProxyFilterIfFn', long, [PTR(VOID), PTR(UUID), ushort, PTR(int)]);
var I_RpcProxyUpdatePerfCounterFn = CALLBACK('I_RpcProxyUpdatePerfCounterFn', VOID, [RpcPerfCounters, int, ulong]);
var I_RpcProxyUpdatePerfCounterBackendServerFn = CALLBACK('I_RpcProxyUpdatePerfCounterBackendServerFn', VOID, [PTR(ushort), int]);
var PFN_RPCNOTIFICATION_ROUTINE = CALLBACK('PFN_RPCNOTIFICATION_ROUTINE', VOID, [PTR(_RPC_ASYNC_STATE), PTR(VOID), RPC_ASYNC_EVENT]);
var PFNCANSHAREFOLDERW = CALLBACK('PFNCANSHAREFOLDERW', long, [PTR(ushort)]);
var PFNSHOWSHAREFOLDERUIW = CALLBACK('PFNSHOWSHAREFOLDERUIW', long, [HWND, PTR(ushort)]);
var PCRYPT_DECRYPT_PRIVATE_KEY_FUNC = CALLBACK('PCRYPT_DECRYPT_PRIVATE_KEY_FUNC', int, [CRYPT_ALGORITHM_IDENTIFIER, CRYPT_ATTR_BLOB, PTR(uchar), PTR(ulong), PTR(VOID)]);
var PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC = CALLBACK('PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC', int, [PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(CRYPT_ATTR_BLOB), PTR(uchar), PTR(ulong), PTR(VOID)]);
var PCRYPT_RESOLVE_HCRYPTPROV_FUNC = CALLBACK('PCRYPT_RESOLVE_HCRYPTPROV_FUNC', int, [PTR(CRYPT_PRIVATE_KEY_INFO), PTR(ulong), PTR(VOID)]);
var PFN_CRYPT_ALLOC = CALLBACK('PFN_CRYPT_ALLOC', PTR(VOID), [uint]);
var PFN_CRYPT_FREE = CALLBACK('PFN_CRYPT_FREE', VOID, [PTR(VOID)]);
var PFN_CRYPT_ENUM_OID_FUNC = CALLBACK('PFN_CRYPT_ENUM_OID_FUNC', 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('PFN_CRYPT_ENUM_OID_INFO', int, [PTR(CCRYPT_OID_INFO), PTR(VOID)]);
var PFN_CMSG_STREAM_OUTPUT = CALLBACK('PFN_CMSG_STREAM_OUTPUT', int, [PTR(VOID), PTR(uchar), ulong, int]);
var PFN_CMSG_ALLOC = CALLBACK('PFN_CMSG_ALLOC', PTR(VOID), [uint]);
var PFN_CMSG_FREE = CALLBACK('PFN_CMSG_FREE', VOID, [PTR(VOID)]);
var PFN_CMSG_GEN_ENCRYPT_KEY = CALLBACK('PFN_CMSG_GEN_ENCRYPT_KEY', 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('PFN_CMSG_EXPORT_ENCRYPT_KEY', int, [ulong, ulong, PTR(CERT_PUBLIC_KEY_INFO), PTR(uchar), PTR(ulong)]);
var PFN_CMSG_IMPORT_ENCRYPT_KEY = CALLBACK('PFN_CMSG_IMPORT_ENCRYPT_KEY', int, [ulong, ulong, PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(uchar), ulong, PTR(ulong)]);
var PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY = CALLBACK('PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY', int, [PTR(CMSG_CONTENT_ENCRYPT_INFO), ulong, PTR(VOID)]);
var PFN_CMSG_EXPORT_KEY_TRANS = CALLBACK('PFN_CMSG_EXPORT_KEY_TRANS', 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('PFN_CMSG_EXPORT_KEY_AGREE', 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('PFN_CMSG_EXPORT_MAIL_LIST', 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('PFN_CMSG_IMPORT_KEY_TRANS', int, [PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(CMSG_CTRL_KEY_TRANS_DECRYPT_PARA), ulong, PTR(VOID), PTR(ulong)]);
var PFN_CMSG_IMPORT_KEY_AGREE = CALLBACK('PFN_CMSG_IMPORT_KEY_AGREE', int, [PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(CMSG_CTRL_KEY_AGREE_DECRYPT_PARA), ulong, PTR(VOID), PTR(ulong)]);
var PFN_CMSG_IMPORT_MAIL_LIST = CALLBACK('PFN_CMSG_IMPORT_MAIL_LIST', 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('PFN_CMSG_CNG_IMPORT_KEY_TRANS', 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('PFN_CMSG_CNG_IMPORT_KEY_AGREE', 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('PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY', int, [PTR(CMSG_CNG_CONTENT_DECRYPT_INFO), ulong, PTR(VOID)]);
var PFN_CERT_DLL_OPEN_STORE_PROV_FUNC = CALLBACK('PFN_CERT_DLL_OPEN_STORE_PROV_FUNC', int, [PTR(int8), ulong, ulong, ulong, PTR(VOID), PTR(VOID), PTR(CERT_STORE_PROV_INFO)]);
var PFN_CERT_STORE_PROV_CLOSE = CALLBACK('PFN_CERT_STORE_PROV_CLOSE', VOID, [PTR(VOID), ulong]);
var PFN_CERT_STORE_PROV_READ_CERT = CALLBACK('PFN_CERT_STORE_PROV_READ_CERT', int, [PTR(VOID), PTR(CERT_CONTEXT), ulong, PTR(PTR(CERT_CONTEXT))]);
var PFN_CERT_STORE_PROV_WRITE_CERT = CALLBACK('PFN_CERT_STORE_PROV_WRITE_CERT', int, [PTR(VOID), PTR(CERT_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_DELETE_CERT = CALLBACK('PFN_CERT_STORE_PROV_DELETE_CERT', int, [PTR(VOID), PTR(CERT_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_SET_CERT_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_SET_CERT_PROPERTY', int, [PTR(VOID), PTR(CERT_CONTEXT), ulong, ulong, PTR(VOID)]);
var PFN_CERT_STORE_PROV_READ_CRL = CALLBACK('PFN_CERT_STORE_PROV_READ_CRL', int, [PTR(VOID), PTR(CRL_CONTEXT), ulong, PTR(PTR(CRL_CONTEXT))]);
var PFN_CERT_STORE_PROV_WRITE_CRL = CALLBACK('PFN_CERT_STORE_PROV_WRITE_CRL', int, [PTR(VOID), PTR(CRL_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_DELETE_CRL = CALLBACK('PFN_CERT_STORE_PROV_DELETE_CRL', int, [PTR(VOID), PTR(CRL_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_SET_CRL_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_SET_CRL_PROPERTY', int, [PTR(VOID), PTR(CRL_CONTEXT), ulong, ulong, PTR(VOID)]);
var PFN_CERT_STORE_PROV_READ_CTL = CALLBACK('PFN_CERT_STORE_PROV_READ_CTL', int, [PTR(VOID), PTR(CTL_CONTEXT), ulong, PTR(PTR(CTL_CONTEXT))]);
var PFN_CERT_STORE_PROV_WRITE_CTL = CALLBACK('PFN_CERT_STORE_PROV_WRITE_CTL', int, [PTR(VOID), PTR(CTL_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_DELETE_CTL = CALLBACK('PFN_CERT_STORE_PROV_DELETE_CTL', int, [PTR(VOID), PTR(CTL_CONTEXT), ulong]);
var PFN_CERT_STORE_PROV_SET_CTL_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_SET_CTL_PROPERTY', int, [PTR(VOID), PTR(CTL_CONTEXT), ulong, ulong, PTR(VOID)]);
var PFN_CERT_STORE_PROV_CONTROL = CALLBACK('PFN_CERT_STORE_PROV_CONTROL', int, [PTR(VOID), ulong, ulong, PTR(VOID)]);
var PFN_CERT_STORE_PROV_FIND_CERT = CALLBACK('PFN_CERT_STORE_PROV_FIND_CERT', 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('PFN_CERT_STORE_PROV_FREE_FIND_CERT', int, [PTR(VOID), PTR(CERT_CONTEXT), PTR(VOID), ulong]);
var PFN_CERT_STORE_PROV_GET_CERT_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_GET_CERT_PROPERTY', int, [PTR(VOID), PTR(CERT_CONTEXT), ulong, ulong, PTR(VOID), PTR(ulong)]);
var PFN_CERT_STORE_PROV_FIND_CRL = CALLBACK('PFN_CERT_STORE_PROV_FIND_CRL', 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('PFN_CERT_STORE_PROV_FREE_FIND_CRL', int, [PTR(VOID), PTR(CRL_CONTEXT), PTR(VOID), ulong]);
var PFN_CERT_STORE_PROV_GET_CRL_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_GET_CRL_PROPERTY', int, [PTR(VOID), PTR(CRL_CONTEXT), ulong, ulong, PTR(VOID), PTR(ulong)]);
var PFN_CERT_STORE_PROV_FIND_CTL = CALLBACK('PFN_CERT_STORE_PROV_FIND_CTL', 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('PFN_CERT_STORE_PROV_FREE_FIND_CTL', int, [PTR(VOID), PTR(CTL_CONTEXT), PTR(VOID), ulong]);
var PFN_CERT_STORE_PROV_GET_CTL_PROPERTY = CALLBACK('PFN_CERT_STORE_PROV_GET_CTL_PROPERTY', int, [PTR(VOID), PTR(CTL_CONTEXT), ulong, ulong, PTR(VOID), PTR(ulong)]);
var PFN_CERT_CREATE_CONTEXT_SORT_FUNC = CALLBACK('PFN_CERT_CREATE_CONTEXT_SORT_FUNC', int, [ulong, ulong, ulong, PTR(VOID)]);
var PFN_CERT_ENUM_SYSTEM_STORE_LOCATION = CALLBACK('PFN_CERT_ENUM_SYSTEM_STORE_LOCATION', int, [PTR(ushort), ulong, PTR(VOID), PTR(VOID)]);
var PFN_CERT_ENUM_SYSTEM_STORE = CALLBACK('PFN_CERT_ENUM_SYSTEM_STORE', int, [PTR(VOID), ulong, PTR(CERT_SYSTEM_STORE_INFO), PTR(VOID), PTR(VOID)]);
var PFN_CERT_ENUM_PHYSICAL_STORE = CALLBACK('PFN_CERT_ENUM_PHYSICAL_STORE', int, [PTR(VOID), ulong, PTR(ushort), PTR(CERT_PHYSICAL_STORE_INFO), PTR(VOID), PTR(VOID)]);
var PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC = CALLBACK('PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC', int, [ulong, PTR(CRYPT_ALGORITHM_IDENTIFIER), PTR(PTR(VOID)), PTR(PTR(ushort))]);
var PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC = CALLBACK('PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC', 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('PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC', 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('PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC', 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('PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC', 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('PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC', int, [ulong, PTR(CERT_PUBLIC_KEY_INFO), ulong, PTR(VOID), PTR(PTR(VOID))]);
var PFN_IMPORT_PRIV_KEY_FUNC = CALLBACK('PFN_IMPORT_PRIV_KEY_FUNC', int, [ulong, PTR(CRYPT_PRIVATE_KEY_INFO), ulong, PTR(VOID)]);
var PFN_EXPORT_PRIV_KEY_FUNC = CALLBACK('PFN_EXPORT_PRIV_KEY_FUNC', int, [ulong, ulong, PTR(int8), ulong, PTR(VOID), PTR(CRYPT_PRIVATE_KEY_INFO), PTR(ulong)]);
var PFN_CRYPT_GET_SIGNER_CERTIFICATE = CALLBACK('PFN_CRYPT_GET_SIGNER_CERTIFICATE', PTR(CERT_CONTEXT), [PTR(VOID), ulong, PTR(CERT_INFO), PTR(VOID)]);
var PFN_CRYPT_ASYNC_PARAM_FREE_FUNC = CALLBACK('PFN_CRYPT_ASYNC_PARAM_FREE_FUNC', VOID, [PTR(int8), PTR(VOID)]);
var PFN_FREE_ENCODED_OBJECT_FUNC = CALLBACK('PFN_FREE_ENCODED_OBJECT_FUNC', VOID, [PTR(int8), PTR(CRYPT_BLOB_ARRAY), PTR(VOID)]);
var PFN_CRYPT_CANCEL_RETRIEVAL = CALLBACK('PFN_CRYPT_CANCEL_RETRIEVAL', int, [ulong, PTR(VOID)]);
var PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC = CALLBACK('PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC', VOID, [PTR(VOID), ulong, PTR(int8), PTR(int8), PTR(VOID)]);
var PFN_CANCEL_ASYNC_RETRIEVAL_FUNC = CALLBACK('PFN_CANCEL_ASYNC_RETRIEVAL_FUNC', int, [PTR(VOID)]);
var PFN_CRYPT_ENUM_KEYID_PROP = CALLBACK('PFN_CRYPT_ENUM_KEYID_PROP', 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('PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK', int, [PTR(CERT_CONTEXT), PTR(VOID)]);
var NDR_RUNDOWN = CALLBACK('NDR_RUNDOWN', VOID, [PTR(VOID)]);
var NDR_NOTIFY_ROUTINE = CALLBACK('NDR_NOTIFY_ROUTINE', VOID, []);
var NDR_NOTIFY2_ROUTINE = CALLBACK('NDR_NOTIFY2_ROUTINE', VOID, [uchar]);
var EXPR_EVAL = CALLBACK('EXPR_EVAL', VOID, [PTR(_MIDL_STUB_MESSAGE)]);
var GENERIC_BINDING_ROUTINE = CALLBACK('GENERIC_BINDING_ROUTINE', PTR(VOID), [PTR(VOID)]);
var GENERIC_UNBIND_ROUTINE = CALLBACK('GENERIC_UNBIND_ROUTINE', VOID, [PTR(VOID), PTR(uchar)]);
var XMIT_HELPER_ROUTINE = CALLBACK('XMIT_HELPER_ROUTINE', VOID, [PTR(MIDL_STUB_MESSAGE)]);
var USER_MARSHAL_SIZING_ROUTINE = CALLBACK('USER_MARSHAL_SIZING_ROUTINE', ulong, [PTR(ulong), ulong, PTR(VOID)]);
var USER_MARSHAL_MARSHALLING_ROUTINE = CALLBACK('USER_MARSHAL_MARSHALLING_ROUTINE', PTR(uchar), [PTR(ulong), PTR(uchar), PTR(VOID)]);
var USER_MARSHAL_UNMARSHALLING_ROUTINE = CALLBACK('USER_MARSHAL_UNMARSHALLING_ROUTINE', PTR(uchar), [PTR(ulong), PTR(uchar), PTR(VOID)]);
var USER_MARSHAL_FREEING_ROUTINE = CALLBACK('USER_MARSHAL_FREEING_ROUTINE', VOID, [PTR(ulong), PTR(VOID)]);
var CS_TYPE_NET_SIZE_ROUTINE = CALLBACK('CS_TYPE_NET_SIZE_ROUTINE', VOID, [PTR(VOID), ulong, ulong, PTR(IDL_CS_CONVERT), PTR(ulong), PTR(ulong)]);
var CS_TYPE_LOCAL_SIZE_ROUTINE = CALLBACK('CS_TYPE_LOCAL_SIZE_ROUTINE', VOID, [PTR(VOID), ulong, ulong, PTR(IDL_CS_CONVERT), PTR(ulong), PTR(ulong)]);
var CS_TYPE_TO_NETCS_ROUTINE = CALLBACK('CS_TYPE_TO_NETCS_ROUTINE', VOID, [PTR(VOID), ulong, PTR(VOID), ulong, PTR(uchar), PTR(ulong), PTR(ulong)]);
var CS_TYPE_FROM_NETCS_ROUTINE = CALLBACK('CS_TYPE_FROM_NETCS_ROUTINE', VOID, [PTR(VOID), ulong, PTR(uchar), ulong, ulong, PTR(VOID), PTR(ulong), PTR(ulong)]);
var CS_TAG_GETTING_ROUTINE = CALLBACK('CS_TAG_GETTING_ROUTINE', VOID, [PTR(VOID), int, PTR(ulong), PTR(ulong), PTR(ulong), PTR(ulong)]);
var STUB_THUNK = CALLBACK('STUB_THUNK', VOID, [PTR(MIDL_STUB_MESSAGE)]);
var LPOCNCONNPROCA = CALLBACK('LPOCNCONNPROCA', ulong, [ulong, PTR(int8), PTR(int8), PTR(VOID)]);
var LPOCNCONNPROCW = CALLBACK('LPOCNCONNPROCW', ulong, [ulong, PTR(ushort), PTR(ushort), PTR(VOID)]);
var LPOCNCHKPROC = CALLBACK('LPOCNCHKPROC', int, [ulong, ulong, PTR(VOID)]);
var LPOCNDSCPROC = CALLBACK('LPOCNDSCPROC', VOID, [ulong, ulong, PTR(VOID)]);
var LPFNPSPCALLBACKA = CALLBACK('LPFNPSPCALLBACKA', uint, [HWND, uint, PTR(_PROPSHEETPAGEA)]);
var LPFNPSPCALLBACKW = CALLBACK('LPFNPSPCALLBACKW', uint, [HWND, uint, PTR(_PROPSHEETPAGEW)]);
var PFNPROPSHEETCALLBACK = CALLBACK('PFNPROPSHEETCALLBACK', int, [HWND, uint, long]);
var LPFNADDPROPSHEETPAGE = CALLBACK('LPFNADDPROPSHEETPAGE', int, [PTR(_PSP), long]);
var LPFNADDPROPSHEETPAGES = CALLBACK('LPFNADDPROPSHEETPAGES', int, [PTR(VOID), PTR(CALLBACK(int, [PTR(_PSP), long])), long]);
var _onexit_t = CALLBACK('_onexit_t', int, []);
var _purecall_handler = CALLBACK('_purecall_handler', VOID, []);
var _invalid_parameter_handler = CALLBACK('_invalid_parameter_handler', VOID, [PTR(ushort), PTR(ushort), PTR(ushort), uint, uint]);
var LPFNGETCLASSOBJECT = CALLBACK('LPFNGETCLASSOBJECT', long, [PTR(UUID), PTR(UUID), PTR(PTR(VOID))]);
var LPFNCANUNLOADNOW = CALLBACK('LPFNCANUNLOADNOW', long, []);
var LPOFNHOOKPROC = CALLBACK('LPOFNHOOKPROC', uint, [HWND, uint, uint, long]);
var LPCCHOOKPROC = CALLBACK('LPCCHOOKPROC', uint, [HWND, uint, uint, long]);
var LPFRHOOKPROC = CALLBACK('LPFRHOOKPROC', uint, [HWND, uint, uint, long]);
var LPCFHOOKPROC = CALLBACK('LPCFHOOKPROC', uint, [HWND, uint, uint, long]);
var LPPRINTHOOKPROC = CALLBACK('LPPRINTHOOKPROC', uint, [HWND, uint, uint, long]);
var LPSETUPHOOKPROC = CALLBACK('LPSETUPHOOKPROC', uint, [HWND, uint, uint, long]);
var LPPAGEPAINTHOOK = CALLBACK('LPPAGEPAINTHOOK', uint, [HWND, uint, uint, long]);
var LPPAGESETUPHOOK = CALLBACK('LPPAGESETUPHOOK', uint, [HWND, uint, uint, long]);
var LPSERVICE_MAIN_FUNCTIONW = CALLBACK('LPSERVICE_MAIN_FUNCTIONW', VOID, [ulong, PTR(PTR(ushort))]);
var LPSERVICE_MAIN_FUNCTIONA = CALLBACK('LPSERVICE_MAIN_FUNCTIONA', VOID, [ulong, PTR(PTR(int8))]);
var LPHANDLER_FUNCTION = CALLBACK('LPHANDLER_FUNCTION', VOID, [ulong]);
var LPHANDLER_FUNCTION_EX = CALLBACK('LPHANDLER_FUNCTION_EX', ulong, [ulong, ulong, PTR(VOID), PTR(VOID)]);
var PFN_SC_NOTIFY_CALLBACK = CALLBACK('PFN_SC_NOTIFY_CALLBACK', VOID, [PTR(VOID)]);
var IMCENUMPROC = CALLBACK('IMCENUMPROC', int, [HIMC, long]);
var REGISTERWORDENUMPROCA = CALLBACK('REGISTERWORDENUMPROCA', int, [PTR(int8), ulong, PTR(int8), PTR(VOID)]);
var REGISTERWORDENUMPROCW = CALLBACK('REGISTERWORDENUMPROCW', int, [PTR(ushort), ulong, PTR(ushort), PTR(VOID)]);

var threadlocinfo = STRUCT('threadlocinfo', {
 refcount: int,
 lc_codepage: uint,
 lc_collate_cp: uint,
 lc_handle: ARRAY(undefined, 6),
 lc_id: ARRAY(LC_ID, 6),
 lc_category: ARRAY(undefined, 6),
 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: ARRAY(ULONG_PTR, EXCEPTION_MAXIMUM_PARAMETERS)
});

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: ARRAY(BYTE, MAXIMUM_SUPPORTED_EXTENSION)
});

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

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

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: ARRAY(BYTE, 8)
});

var GUID = TYPEDEF('GUID', UUID);

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: ARRAY(M128A, 8),
 XmmRegisters: ARRAY(M128A, 8),
 Reserved4: ARRAY(BYTE, 192),
 StackControl: ARRAY(DWORD, 7),
 Cr0NpxState: DWORD
});

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

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: ARRAY(BYTE, SIZE_OF_80387_REGISTERS),
 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: ARRAY(BYTE, WOW64_SIZE_OF_80387_REGISTERS),
 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: ARRAY(BYTE, WOW64_MAXIMUM_SUPPORTED_EXTENSION)
});

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: ARRAY(DWORD, EXCEPTION_MAXIMUM_PARAMETERS)
});

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

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: ARRAY(BYTE, 6)
});

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

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: ARRAY(SID_HASH_ENTRY, SID_HASH_SIZE)
});

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: ARRAY(LUID_AND_ATTRIBUTES, ANYSIZE_ARRAY)
});

var ACCESS_REASONS = STRUCT('ACCESS_REASONS', {
 Data: ARRAY(ACCESS_REASON, 32)
});

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(VOIDPTR)
});

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

var TOKEN_GROUPS = STRUCT('TOKEN_GROUPS', {
 GroupCount: DWORD,
 Groups: ARRAY(SID_AND_ATTRIBUTES, ANYSIZE_ARRAY)
});

var TOKEN_PRIVILEGES = STRUCT('TOKEN_PRIVILEGES', {
 PrivilegeCount: DWORD,
 Privileges: ARRAY(LUID_AND_ATTRIBUTES, ANYSIZE_ARRAY)
});

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: ARRAY(BYTE, undefined)
});

var TOKEN_SOURCE = STRUCT('TOKEN_SOURCE', {
 SourceName: ARRAY(CHAR, TOKEN_SOURCE_LENGTH),
 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: ARRAY(ULONG_PTR, 1)
});

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: ARRAY(BYTE, 21),
 GroupCount: WORD,
 GroupMask: ARRAY(GROUP_AFFINITY, ANYSIZE_ARRAY)
});

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

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

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

var GROUP_RELATIONSHIP = STRUCT('GROUP_RELATIONSHIP', {
 MaximumGroupCount: WORD,
 ActiveGroupCount: WORD,
 Reserved: ARRAY(BYTE, 20),
 GroupInfo: ARRAY(PROCESSOR_GROUP_INFO, ANYSIZE_ARRAY)
});

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: ARRAY(XSTATE_FEATURE, MAXIMUM_XSTATE_FEATURES)
});

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: ARRAY(WCHAR, 1)
});

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

var undefined = STRUCT('undefined', {
 DataBuffer: ARRAY(BYTE, 1)
});

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: ARRAY(DEVICE_POWER_STATE, POWER_SYSTEM_MAXIMUM),
 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: ARRAY(BYTE, ANYSIZE_ARRAY)
});

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: ARRAY(PPM_WMI_IDLE_STATE, ANYSIZE_ARRAY)
});

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

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: ARRAY(PPM_WMI_PERF_STATE, ANYSIZE_ARRAY)
});

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: ARRAY(PPM_WMI_PERF_STATE, ANYSIZE_ARRAY)
});

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

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

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: ARRAY(PPM_IDLE_STATE_BUCKET_EX, PROC_IDLE_BUCKET_COUNT_EX)
});

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

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: ARRAY(BYTE, 3),
 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: ARRAY(BYTE, 2),
 MinSleep: SYSTEM_POWER_STATE,
 MaxSleep: SYSTEM_POWER_STATE,
 ReducedLatencySleep: SYSTEM_POWER_STATE,
 WinLogonFlags: DWORD,
 Spare3: DWORD,
 DozeS4Timeout: DWORD,
 BroadcastCapacityResolution: DWORD,
 DischargePolicy: ARRAY(SYSTEM_POWER_LEVEL, NUM_DISCHARGE_POLICIES),
 VideoTimeout: DWORD,
 VideoDimDisplay: BOOLEAN,
 VideoReserved: ARRAY(DWORD, 3),
 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: ARRAY(BYTE, 2)
});

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

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: ARRAY(BYTE, 2),
 AllowDemotion: DWORD,
 AllowPromotion: DWORD,
 Reserved: DWORD
});

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

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: ARRAY(BYTE, 3),
 DiskSpinDown: BOOLEAN,
 spare3: ARRAY(BYTE, 8),
 SystemBatteriesPresent: BOOLEAN,
 BatteriesAreShortTerm: BOOLEAN,
 BatteryScale: ARRAY(BATTERY_REPORTING_SCALE, 3),
 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: ARRAY(BOOLEAN, 4),
 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: ARRAY(WORD, 4),
 e_oemid: WORD,
 e_oeminfo: WORD,
 e_res2: ARRAY(WORD, 10),
 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: ARRAY(BYTE, 12),
 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: ARRAY(IMAGE_DATA_DIRECTORY, IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
});

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: ARRAY(DWORD, 4),
 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: ARRAY(IMAGE_DATA_DIRECTORY, IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
});

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: ARRAY(BYTE, IMAGE_SIZEOF_SHORT_NAME),
 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: ARRAY(BYTE, 12)
});

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: ARRAY(WORD, 4)
});

var undefined = STRUCT('undefined', {
 Name: ARRAY(BYTE, IMAGE_SIZEOF_SYMBOL)
});

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: ARRAY(BYTE, 14)
});

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

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

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

var undefined = STRUCT('undefined', {
 TokenDef: IMAGE_AUX_SYMBOL_TOKEN_DEF,
 rgbReserved: ARRAY(BYTE, 2)
});

var undefined = STRUCT('undefined', {
 crc: DWORD,
 rgbReserved: ARRAY(BYTE, 16)
});

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: ARRAY(BYTE, 16),
 Date: ARRAY(BYTE, 12),
 UserID: ARRAY(BYTE, 6),
 GroupID: ARRAY(BYTE, 6),
 Mode: ARRAY(BYTE, 8),
 Size: ARRAY(BYTE, 10),
 EndHeader: ARRAY(BYTE, 2)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(CHAR,  1 )
});

var IMAGE_RESOURCE_DIR_STRING_U = STRUCT('IMAGE_RESOURCE_DIR_STRING_U', {
 Length: WORD,
 NameString: ARRAY(WCHAR,  1 )
});

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: ARRAY(BYTE,  3 ),
 Data: ARRAY(BYTE,  1 )
});

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: ARRAY(DWORD, 2)
});

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: ARRAY(BYTE,  1 )
});

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: ARRAY(MESSAGE_RESOURCE_BLOCK,  1 )
});

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

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

var OSVERSIONINFOEX = STRUCT('OSVERSIONINFOEX', {
 dwOSVersionInfoSize: DWORD,
 dwMajorVersion: DWORD,
 dwMinorVersion: DWORD,
 dwBuildNumber: DWORD,
 dwPlatformId: DWORD,
 szCSDVersion: ARRAY(CHAR,  128 ),
 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: ARRAY(WCHAR,  128 ),
 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: UNEXPOSED
});

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

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: ARRAY(HARDWARE_COUNTER_DATA, MAX_HW_COUNTERS)
});

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: ARRAY(WCHAR, MAXLOGICALLOGNAMESIZE),
 ulNumRecords: DWORD,
 pEventLogRecords: UNEXPOSED
});

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

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: ARRAY(WCHAR, MAX_TRANSACTION_DESCRIPTION_LENGTH)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(TRANSACTION_ENLISTMENT_PAIR, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(TRANSACTION_LIST_ENTRY, 1)
});

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



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 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: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(CHAR, OFS_MAXPATHNAME)
});

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: ARRAY(DWORD,  3 )
});

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: ARRAY(WCHAR,  32 ),
 StandardDate: SYSTEMTIME,
 StandardBias: LONG,
 DaylightName: ARRAY(WCHAR,  32 ),
 DaylightDate: SYSTEMTIME,
 DaylightBias: LONG
});

var DYNAMIC_TIME_ZONE_INFORMATION = STRUCT('DYNAMIC_TIME_ZONE_INFORMATION', {
 Bias: LONG,
 StandardName: ARRAY(WCHAR,  32 ),
 StandardDate: SYSTEMTIME,
 StandardBias: LONG,
 DaylightName: ARRAY(WCHAR,  32 ),
 DaylightDate: SYSTEMTIME,
 DaylightBias: LONG,
 TimeZoneKeyName: ARRAY(WCHAR,  128 ),
 DynamicDaylightTimeDisabled: BOOLEAN
});

var WIN32_STREAM_ID = STRUCT('WIN32_STREAM_ID', {
 dwStreamId: DWORD,
 dwStreamAttributes: DWORD,
 Size: LARGE_INTEGER,
 dwStreamNameSize: DWORD,
 cStreamName: ARRAY(WCHAR,  ANYSIZE_ARRAY )
});

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: ARRAY(CHAR,  MAX_PATH ),
 cAlternateFileName: ARRAY(CHAR,  14 )
});

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: ARRAY(WCHAR,  MAX_PATH ),
 cAlternateFileName: ARRAY(WCHAR,  14 )
});

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: ARRAY(WCHAR, undefined)
});

var EVENTLOG_FULL_INFORMATION = STRUCT('EVENTLOG_FULL_INFORMATION', {
 dwFull: DWORD
});

var HW_PROFILE_INFO = STRUCT('HW_PROFILE_INFO', {
 dwDockInfo: DWORD,
 szHwProfileGuid: ARRAY(CHAR, HW_PROFILE_GUIDLEN),
 szHwProfileName: ARRAY(CHAR, MAX_PROFILE_LEN)
});

var HW_PROFILE_INFOW = STRUCT('HW_PROFILE_INFOW', {
 dwDockInfo: DWORD,
 szHwProfileGuid: ARRAY(WCHAR, HW_PROFILE_GUIDLEN),
 szHwProfileName: ARRAY(WCHAR, MAX_PROFILE_LEN)
});

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: ARRAY(WCHAR, 1)
});

var FILE_RENAME_INFO = STRUCT('FILE_RENAME_INFO', {
 ReplaceIfExists: BOOLEAN,
 RootDirectory: HANDLE,
 FileNameLength: DWORD,
 FileName: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR, 1)
});

var FILE_COMPRESSION_INFO = STRUCT('FILE_COMPRESSION_INFO', {
 CompressedFileSize: LARGE_INTEGER,
 CompressionFormat: WORD,
 CompressionUnitShift: UCHAR,
 ChunkShift: UCHAR,
 ClusterShift: UCHAR,
 Reserved: ARRAY(UCHAR, 3)
});

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: ARRAY(WCHAR, 12),
 FileId: LARGE_INTEGER,
 FileName: ARRAY(WCHAR, 1)
});

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: ARRAY(DWORD, 8)
});

var undefined = STRUCT('undefined', {
 Reserved: ARRAY(DWORD, 16)
});

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: ARRAY(CHAR, MAX_PATH)
});

var LOGCOLORSPACEW = STRUCT('LOGCOLORSPACEW', {
 lcsSignature: DWORD,
 lcsVersion: DWORD,
 lcsSize: DWORD,
 lcsCSType: LCSCSTYPE,
 lcsIntent: LCSGAMUTMATCH,
 lcsEndpoints: CIEXYZTRIPLE,
 lcsGammaRed: DWORD,
 lcsGammaGreen: DWORD,
 lcsGammaBlue: DWORD,
 lcsFilename: ARRAY(WCHAR, MAX_PATH)
});

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: ARRAY(RGBQUAD, 1)
});

var BITMAPCOREINFO = STRUCT('BITMAPCOREINFO', {
 bmciHeader: BITMAPCOREHEADER,
 bmciColors: ARRAY(RGBTRIPLE, 1)
});

var BITMAPFILEHEADER = STRUCT('BITMAPFILEHEADER', {
 bfType: WORD,
 bfSize: DWORD,
 bfReserved1: WORD,
 bfReserved2: WORD,
 bfOffBits: DWORD
});

var FONTSIGNATURE = STRUCT('FONTSIGNATURE', {
 fsUsb: ARRAY(DWORD, 4),
 fsCsb: ARRAY(DWORD, 2)
});

var CHARSETINFO = STRUCT('CHARSETINFO', {
 ciCharset: UINT,
 ciACP: UINT,
 fs: FONTSIGNATURE
});

var LOCALESIGNATURE = STRUCT('LOCALESIGNATURE', {
 lsUsb: ARRAY(DWORD, 4),
 lsCsbDefault: ARRAY(DWORD, 2),
 lsCsbSupported: ARRAY(DWORD, 2)
});

var HANDLETABLE = STRUCT('HANDLETABLE', {
 objectHandle: ARRAY(HGDIOBJ, 1)
});

var METARECORD = STRUCT('METARECORD', {
 rdSize: DWORD,
 rdFunction: WORD,
 rdParm: ARRAY(WORD, 1)
});

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: ARRAY(DWORD, 1)
});

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: ARRAY(DWORD, 1)
});

var EXTLOGPEN32 = STRUCT('EXTLOGPEN32', {
 elpPenStyle: DWORD,
 elpWidth: DWORD,
 elpBrushStyle: UINT,
 elpColor: COLORREF,
 elpHatch: ULONG,
 elpNumEntries: DWORD,
 elpStyleEntry: ARRAY(DWORD, 1)
});

var PALETTEENTRY = STRUCT('PALETTEENTRY', {
 peRed: BYTE,
 peGreen: BYTE,
 peBlue: BYTE,
 peFlags: BYTE
});

var LOGPALETTE = STRUCT('LOGPALETTE', {
 palVersion: WORD,
 palNumEntries: WORD,
 palPalEntry: ARRAY(PALETTEENTRY, 1)
});

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: ARRAY(CHAR, LF_FACESIZE)
});

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: ARRAY(WCHAR, LF_FACESIZE)
});

var ENUMLOGFONT = STRUCT('ENUMLOGFONT', {
 elfLogFont: LOGFONTA,
 elfFullName: ARRAY(BYTE, LF_FULLFACESIZE),
 elfStyle: ARRAY(BYTE, LF_FACESIZE)
});

var ENUMLOGFONTW = STRUCT('ENUMLOGFONTW', {
 elfLogFont: LOGFONTW,
 elfFullName: ARRAY(WCHAR, LF_FULLFACESIZE),
 elfStyle: ARRAY(WCHAR, LF_FACESIZE)
});

var ENUMLOGFONTEX = STRUCT('ENUMLOGFONTEX', {
 elfLogFont: LOGFONTA,
 elfFullName: ARRAY(BYTE, LF_FULLFACESIZE),
 elfStyle: ARRAY(BYTE, LF_FACESIZE),
 elfScript: ARRAY(BYTE, LF_FACESIZE)
});

var ENUMLOGFONTEXW = STRUCT('ENUMLOGFONTEXW', {
 elfLogFont: LOGFONTW,
 elfFullName: ARRAY(WCHAR, LF_FULLFACESIZE),
 elfStyle: ARRAY(WCHAR, LF_FACESIZE),
 elfScript: ARRAY(WCHAR, LF_FACESIZE)
});

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: ARRAY(BYTE, LF_FULLFACESIZE),
 elfStyle: ARRAY(BYTE, LF_FACESIZE),
 elfVersion: DWORD,
 elfStyleSize: DWORD,
 elfMatch: DWORD,
 elfReserved: DWORD,
 elfVendorId: ARRAY(BYTE, ELF_VENDOR_SIZE),
 elfCulture: DWORD,
 elfPanose: PANOSE
});

var EXTLOGFONTW = STRUCT('EXTLOGFONTW', {
 elfLogFont: LOGFONTW,
 elfFullName: ARRAY(WCHAR, LF_FULLFACESIZE),
 elfStyle: ARRAY(WCHAR, LF_FACESIZE),
 elfVersion: DWORD,
 elfStyleSize: DWORD,
 elfMatch: DWORD,
 elfReserved: DWORD,
 elfVendorId: ARRAY(BYTE, ELF_VENDOR_SIZE),
 elfCulture: DWORD,
 elfPanose: PANOSE
});

var DEVMODE = STRUCT('DEVMODE', {
 dmDeviceName: ARRAY(BYTE, CCHDEVICENAME),
 dmSpecVersion: WORD,
 dmDriverVersion: WORD,
 dmSize: WORD,
 dmDriverExtra: WORD,
 dmFields: DWORD,
 dmColor: short,
 dmDuplex: short,
 dmYResolution: short,
 dmTTOption: short,
 dmCollate: short,
 dmFormName: ARRAY(BYTE, CCHFORMNAME),
 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: ARRAY(WCHAR, CCHDEVICENAME),
 dmSpecVersion: WORD,
 dmDriverVersion: WORD,
 dmSize: WORD,
 dmDriverExtra: WORD,
 dmFields: DWORD,
 dmColor: short,
 dmDuplex: short,
 dmYResolution: short,
 dmTTOption: short,
 dmCollate: short,
 dmFormName: ARRAY(WCHAR, CCHFORMNAME),
 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: ARRAY(CHAR, 32),
 DeviceString: ARRAY(CHAR, 128),
 StateFlags: DWORD,
 DeviceID: ARRAY(CHAR, 128),
 DeviceKey: ARRAY(CHAR, 128)
});

var DISPLAY_DEVICEW = STRUCT('DISPLAY_DEVICEW', {
 cb: DWORD,
 DeviceName: ARRAY(WCHAR, 32),
 DeviceString: ARRAY(WCHAR, 128),
 StateFlags: DWORD,
 DeviceID: ARRAY(WCHAR, 128),
 DeviceKey: ARRAY(WCHAR, 128)
});

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: ARRAY(WCHAR, CCHDEVICENAME)
});


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: ARRAY(WCHAR, 64),
 monitorDevicePath: ARRAY(WCHAR, 128)
});

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: ARRAY(WCHAR, 128)
});

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: ARRAY(undefined, 1)
});

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: ARRAY(POINTFX, 1)
});

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: ARRAY(WCRANGE, 1)
});

var DESIGNVECTOR = STRUCT('DESIGNVECTOR', {
 dvReserved: DWORD,
 dvNumAxes: DWORD,
 dvValues: ARRAY(LONG, MM_MAX_NUMAXES)
});

var AXISINFO = STRUCT('AXISINFO', {
 axMinValue: LONG,
 axMaxValue: LONG,
 axAxisName: ARRAY(BYTE, MM_MAX_AXES_NAMELEN)
});

var AXISINFOW = STRUCT('AXISINFOW', {
 axMinValue: LONG,
 axMaxValue: LONG,
 axAxisName: ARRAY(WCHAR, MM_MAX_AXES_NAMELEN)
});

var AXESLIST = STRUCT('AXESLIST', {
 axlReserved: DWORD,
 axlNumAxes: DWORD,
 axlAxisInfo: ARRAY(AXISINFOA, MM_MAX_NUMAXES)
});

var AXESLISTW = STRUCT('AXESLISTW', {
 axlReserved: DWORD,
 axlNumAxes: DWORD,
 axlAxisInfo: ARRAY(AXISINFOW, MM_MAX_NUMAXES)
});

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: ARRAY(DWORD, 3),
 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: ARRAY(PALETTEENTRY, 1)
});

var EMRSETCOLORADJUSTMENT = STRUCT('EMRSETCOLORADJUSTMENT', {
 emr: EMR,
 ColorAdjustment: COLORADJUSTMENT
});

var EMRGDICOMMENT = STRUCT('EMRGDICOMMENT', {
 emr: EMR,
 cbData: DWORD,
 Data: ARRAY(BYTE, 1)
});

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: ARRAY(POINTL, 1)
});

var EMRPOLYLINETO16 = STRUCT('EMRPOLYLINETO16', {
 emr: EMR,
 rclBounds: RECTL,
 cpts: DWORD,
 apts: ARRAY(POINTS, 1)
});

var EMRPOLYDRAW = STRUCT('EMRPOLYDRAW', {
 emr: EMR,
 rclBounds: RECTL,
 cptl: DWORD,
 aptl: ARRAY(POINTL, 1),
 abTypes: ARRAY(BYTE, 1)
});

var EMRPOLYDRAW16 = STRUCT('EMRPOLYDRAW16', {
 emr: EMR,
 rclBounds: RECTL,
 cpts: DWORD,
 apts: ARRAY(POINTS, 1),
 abTypes: ARRAY(BYTE, 1)
});

var EMRPOLYPOLYGON = STRUCT('EMRPOLYPOLYGON', {
 emr: EMR,
 rclBounds: RECTL,
 nPolys: DWORD,
 cptl: DWORD,
 aPolyCounts: ARRAY(DWORD, 1),
 aptl: ARRAY(POINTL, 1)
});

var EMRPOLYPOLYGON16 = STRUCT('EMRPOLYPOLYGON16', {
 emr: EMR,
 rclBounds: RECTL,
 nPolys: DWORD,
 cpts: DWORD,
 aPolyCounts: ARRAY(DWORD, 1),
 apts: ARRAY(POINTS, 1)
});

var EMRPAINTRGN = STRUCT('EMRPAINTRGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 RgnData: ARRAY(BYTE, 1)
});

var EMRFILLRGN = STRUCT('EMRFILLRGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 ihBrush: DWORD,
 RgnData: ARRAY(BYTE, 1)
});

var EMRFRAMERGN = STRUCT('EMRFRAMERGN', {
 emr: EMR,
 rclBounds: RECTL,
 cbRgnData: DWORD,
 ihBrush: DWORD,
 szlStroke: SIZEL,
 RgnData: ARRAY(BYTE, 1)
});

var EMREXTSELECTCLIPRGN = STRUCT('EMREXTSELECTCLIPRGN', {
 emr: EMR,
 cbRgnData: DWORD,
 iMode: DWORD,
 RgnData: ARRAY(BYTE, 1)
});

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: ARRAY(EMRTEXT, 1)
});

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: ARRAY(POINTL, 3),
 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: ARRAY(BYTE, 1)
});

var EMRGLSBOUNDEDRECORD = STRUCT('EMRGLSBOUNDEDRECORD', {
 emr: EMR,
 rclBounds: RECTL,
 cbData: DWORD,
 Data: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 1)
});

var EMRNAMEDESCAPE = STRUCT('EMRNAMEDESCAPE', {
 emr: EMR,
 iEscape: INT,
 cbDriver: INT,
 cbEscData: INT,
 EscData: ARRAY(BYTE, 1)
});

var EMRSETICMPROFILEW = STRUCT('EMRSETICMPROFILEW', {
 emr: EMR,
 dwFlags: DWORD,
 cbName: DWORD,
 cbData: DWORD,
 Data: ARRAY(BYTE, 1)
});

var EMRCREATECOLORSPACEW = STRUCT('EMRCREATECOLORSPACEW', {
 emr: EMR,
 ihCS: DWORD,
 lcs: LOGCOLORSPACEW,
 dwFlags: DWORD,
 cbData: DWORD,
 Data: ARRAY(BYTE, 1)
});

var EMRCOLORMATCHTOTARGET = STRUCT('EMRCOLORMATCHTOTARGET', {
 emr: EMR,
 dwAction: DWORD,
 dwFlags: DWORD,
 cbName: DWORD,
 cbData: DWORD,
 Data: ARRAY(BYTE, 1)
});

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: ARRAY(TRIVERTEX, 1)
});

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: ARRAY(UCHAR, 1)
});

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: ARRAY(RECT, 3),
 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: ARRAY(BYTE, 32)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(CHAR, MAX_PATH),
 szResName: ARRAY(CHAR, MAX_PATH)
});

var ICONINFOEXW = STRUCT('ICONINFOEXW', {
 cbSize: DWORD,
 fIcon: BOOL,
 xHotspot: DWORD,
 yHotspot: DWORD,
 hbmMask: HBITMAP,
 hbmColor: HBITMAP,
 wResID: WORD,
 szModName: ARRAY(WCHAR, MAX_PATH),
 szResName: ARRAY(WCHAR, MAX_PATH)
});

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: ARRAY(CHAR, 1)
});

var MULTIKEYHELPW = STRUCT('MULTIKEYHELPW', {
 mkSize: DWORD,
 mkKeylist: WCHAR,
 szKeyphrase: ARRAY(WCHAR, 1)
});

var HELPWININFO = STRUCT('HELPWININFO', {
 wStructSize: int,
 x: int,
 y: int,
 dx: int,
 dy: int,
 wMax: int,
 rgchMember: ARRAY(CHAR, 2)
});

var HELPWININFOW = STRUCT('HELPWININFOW', {
 wStructSize: int,
 x: int,
 y: int,
 dx: int,
 dy: int,
 wMax: int,
 rgchMember: ARRAY(WCHAR, 2)
});

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: ARRAY(UCHAR, 256)
});

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 CCHDEVICENAME = 32;
var CCHFORMNAME = 32;

var MONITORINFOEX = STRUCT('MONITORINFOEX', {
 szDevice: ARRAY(CHAR, CCHDEVICENAME)
});

var MONITORINFOEXW = STRUCT('MONITORINFOEXW', {
 szDevice: ARRAY(WCHAR, CCHDEVICENAME)
});

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: ARRAY(DWORD, undefined)
});

var TITLEBARINFOEX = STRUCT('TITLEBARINFOEX', {
 cbSize: DWORD,
 rcTitleBar: RECT,
 rgstate: ARRAY(DWORD, undefined),
 rgrect: ARRAY(RECT, undefined)
});

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: ARRAY(DWORD, undefined)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, MAX_DEFAULTCHAR),
 LeadByte: ARRAY(BYTE, MAX_LEADBYTES)
});

var CPINFOEX = STRUCT('CPINFOEX', {
 MaxCharSize: UINT,
 DefaultChar: ARRAY(BYTE, MAX_DEFAULTCHAR),
 LeadByte: ARRAY(BYTE, MAX_LEADBYTES),
 UnicodeDefaultChar: WCHAR,
 CodePage: UINT,
 CodePageName: ARRAY(CHAR, MAX_PATH)
});

var CPINFOEXW = STRUCT('CPINFOEXW', {
 MaxCharSize: UINT,
 DefaultChar: ARRAY(BYTE, MAX_DEFAULTCHAR),
 LeadByte: ARRAY(BYTE, MAX_LEADBYTES),
 UnicodeDefaultChar: WCHAR,
 CodePage: UINT,
 CodePageName: ARRAY(WCHAR, MAX_PATH)
});

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: ARRAY(BYTE, 16];          // Checksum of the file [out),
 pServiceChecksum: ARRAY(BYTE, 16];   // Checksum of the file [out),
 dwLanguageNameOffset: DWORD,
 dwTypeIDMainSize: DWORD,
 dwTypeIDMainOffset: DWORD,
 dwTypeNameMainOffset: DWORD,
 dwTypeIDMUISize: DWORD,
 dwTypeIDMUIOffset: DWORD,
 dwTypeNameMUIOffset: DWORD,
 abBuffer: ARRAY(BYTE, 8];             // Buffer for extra data [in)
});

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: ARRAY(COLORREF, 16)
});

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: ARRAY(WCHAR, LF_FACESIZE)
});

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: ARRAY(BYTE, 1)
});

var DDEPOKE = STRUCT('DDEPOKE', {
 unused: ushort,
 fRelease: ushort,
 fReserved: ushort,
 cfFormat: short,
 Value: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(DWORD, 8)
});

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: ARRAY(DWORD, 8)
});

var MONHSZSTRUCT = STRUCT('MONHSZSTRUCT', {
 cb: UINT,
 fsAction: BOOL,
 dwTime: DWORD,
 hsz: HSZ,
 hTask: HANDLE,
 str: ARRAY(CHAR, 1)
});

var MONHSZSTRUCTW = STRUCT('MONHSZSTRUCTW', {
 cb: UINT,
 fsAction: BOOL,
 dwTime: DWORD,
 hsz: HSZ,
 hTask: HANDLE,
 str: ARRAY(WCHAR, 1)
});

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: ARRAY(BYTE, 2)
});

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: ARRAY(CHAR, MAXPNAMELEN),
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var WAVEOUTCAPSW = STRUCT('WAVEOUTCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var WAVEOUTCAPS2 = STRUCT('WAVEOUTCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 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: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD
});

var WAVEINCAPSW = STRUCT('WAVEINCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD
});

var WAVEINCAPS2 = STRUCT('WAVEINCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 dwFormats: DWORD,
 wChannels: WORD,
 wReserved1: WORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var WAVEINCAPS2W = STRUCT('WAVEINCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD
});

var MIDIOUTCAPSW = STRUCT('MIDIOUTCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 wTechnology: WORD,
 wVoices: WORD,
 wNotes: WORD,
 wChannelMask: WORD,
 dwSupport: DWORD
});

var MIDIOUTCAPS2 = STRUCT('MIDIOUTCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 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: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 dwSupport: DWORD
});

var MIDIINCAPSW = STRUCT('MIDIINCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 dwSupport: DWORD
});

var MIDIINCAPS2 = STRUCT('MIDIINCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIDIINCAPS2W = STRUCT('MIDIINCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(DWORD_PTR, 8)
});

var MIDIEVENT = STRUCT('MIDIEVENT', {
 dwDeltaTime: DWORD,
 dwStreamID: DWORD,
 dwEvent: DWORD,
 dwParms: ARRAY(DWORD, 1)
});

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: ARRAY(CHAR, MAXPNAMELEN),
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var AUXCAPSW = STRUCT('AUXCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD
});

var AUXCAPS2 = STRUCT('AUXCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 wTechnology: WORD,
 wReserved1: WORD,
 dwSupport: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var AUXCAPS2W = STRUCT('AUXCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 fdwSupport: DWORD,
 cDestinations: DWORD
});

var MIXERCAPSW = STRUCT('MIXERCAPSW', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 fdwSupport: DWORD,
 cDestinations: DWORD
});

var MIXERCAPS2 = STRUCT('MIXERCAPS2', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 fdwSupport: DWORD,
 cDestinations: DWORD,
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var MIXERCAPS2W = STRUCT('MIXERCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MIXER_SHORT_NAME_CHARS),
 szName: ARRAY(CHAR, MIXER_LONG_NAME_CHARS),
 Target:
});

var undefined = STRUCT('undefined', {
 dwType: DWORD,
 dwDeviceID: DWORD,
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(CHAR, MAXPNAMELEN)
});

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: ARRAY(WCHAR, MIXER_SHORT_NAME_CHARS),
 szName: ARRAY(WCHAR, MIXER_LONG_NAME_CHARS),
 Target:
});

var undefined = STRUCT('undefined', {
 dwType: DWORD,
 dwDeviceID: DWORD,
 wMid: WORD,
 wPid: WORD,
 vDriverVersion: MMVERSION,
 szPname: ARRAY(WCHAR, MAXPNAMELEN)
});

var MIXERCONTROL = STRUCT('MIXERCONTROL', {
 cbStruct: DWORD,
 dwControlID: DWORD,
 dwControlType: DWORD,
 fdwControl: DWORD,
 cMultipleItems: DWORD,
 szShortName: ARRAY(CHAR, MIXER_SHORT_NAME_CHARS),
 szName: ARRAY(CHAR, MIXER_LONG_NAME_CHARS),
 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: ARRAY(WCHAR, MIXER_SHORT_NAME_CHARS),
 szName: ARRAY(WCHAR, MIXER_LONG_NAME_CHARS),
 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: ARRAY(CHAR, MIXER_LONG_NAME_CHARS)
});

var MIXERCONTROLDETAILS_LISTTEXTW = STRUCT('MIXERCONTROLDETAILS_LISTTEXTW', {
 dwParam1: DWORD,
 dwParam2: DWORD,
 szName: ARRAY(WCHAR, MIXER_LONG_NAME_CHARS)
});

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: ARRAY(CHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 szOEMVxD: ARRAY(CHAR, MAX_JOYSTICKOEMVXDNAME)
});

var JOYCAPSW = STRUCT('JOYCAPSW', {
 wMid: WORD,
 wPid: WORD,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(WCHAR, MAXPNAMELEN),
 szOEMVxD: ARRAY(WCHAR, MAX_JOYSTICKOEMVXDNAME)
});

var JOYCAPS2 = STRUCT('JOYCAPS2', {
 wMid: WORD,
 wPid: WORD,
 szPname: ARRAY(CHAR, MAXPNAMELEN),
 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: ARRAY(CHAR, MAXPNAMELEN),
 szOEMVxD: ARRAY(CHAR, MAX_JOYSTICKOEMVXDNAME),
 ManufacturerGuid: GUID,
 ProductGuid: GUID,
 NameGuid: GUID
});

var JOYCAPS2W = STRUCT('JOYCAPS2W', {
 wMid: WORD,
 wPid: WORD,
 szPname: ARRAY(WCHAR, MAXPNAMELEN),
 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: ARRAY(WCHAR, MAXPNAMELEN),
 szOEMVxD: ARRAY(WCHAR, MAX_JOYSTICKOEMVXDNAME),
 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: ARRAY(DWORD, 3),
 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: ARRAY(UCHAR, NCBNAMSZ),
 ncb_name: ARRAY(UCHAR, NCBNAMSZ),
 ncb_rto: UCHAR,
 ncb_sto: UCHAR,
 ncb_post: PTR(UNEXPOSED),
 ncb_lana_num: UCHAR,
 ncb_cmd_cplt: UCHAR,
 ncb_reserve: ARRAY(UCHAR, 10),
 ncb_event: HANDLE
});

var ADAPTER_STATUS = STRUCT('ADAPTER_STATUS', {
 adapter_address: ARRAY(UCHAR, 6),
 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: ARRAY(UCHAR, NCBNAMSZ),
 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: ARRAY(UCHAR, NCBNAMSZ),
 remote_name: ARRAY(UCHAR, NCBNAMSZ),
 rcvs_outstanding: UCHAR,
 sends_outstanding: UCHAR
});

var LANA_ENUM = STRUCT('LANA_ENUM', {
 length: UCHAR,
 lana: ARRAY(UCHAR, undefined)
});

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: ARRAY(UCHAR, 6),
 source_addr: ARRAY(UCHAR, 6),
 routing_info: ARRAY(UCHAR, 18)
});

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: ARRAY(RPC_BINDING_HANDLE, 1)
});

var UUID_VECTOR = STRUCT('UUID_VECTOR', {
 Count: ulong,
 Uuid: ARRAY(UUID, 1)
});

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: ARRAY(undefined, 1)
});

var RPC_PROTSEQ_VECTORW = STRUCT('RPC_PROTSEQ_VECTORW', {
 Count: uint,
 Protseq: ARRAY(undefined, 1)
});

var RPC_POLICY = STRUCT('RPC_POLICY', {
 Length: uint,
 EndpointFlags: ulong,
 NICFlags: ulong
});

var RPC_STATS_VECTOR = STRUCT('RPC_STATS_VECTOR', {
 Count: uint,
 Stats: ARRAY(undefined, 1)
});

var RPC_IF_ID_VECTOR = STRUCT('RPC_IF_ID_VECTOR', {
 Count: ulong,
 IfId: ARRAY(RPC_IF_ID, 1)
});

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: ARRAY(LONG_PTR, 4)
});

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: ARRAY(RPC_EE_INFO_PARAM, MaxNumberOfEEInfoParams)
});

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 = TYPEDEF('HDROP', HANDLE);


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: ARRAY(CHAR, 128),
 dwState: DWORD,
 dwStateMask: DWORD,
 szInfo: ARRAY(CHAR, 256),
 szInfoTitle: ARRAY(CHAR, 64),
 dwInfoFlags: DWORD,
 guidItem: GUID,
 hBalloonIcon: HICON
});

var NOTIFYICONDATAW = STRUCT('NOTIFYICONDATAW', {
 cbSize: DWORD,
 hWnd: HWND,
 uID: UINT,
 uFlags: UINT,
 uCallbackMessage: UINT,
 hIcon: HICON,
 szTip: ARRAY(WCHAR, 128),
 dwState: DWORD,
 dwStateMask: DWORD,
 szInfo: ARRAY(WCHAR, 256),
 szInfoTitle: ARRAY(WCHAR, 64),
 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: ARRAY(CHAR, MAX_PATH),
 szTypeName: ARRAY(CHAR, 80)
});

var SHFILEINFOW = STRUCT('SHFILEINFOW', {
 hIcon: HICON,
 iIcon: int,
 dwAttributes: DWORD,
 szDisplayName: ARRAY(WCHAR, MAX_PATH),
 szTypeName: ARRAY(WCHAR, 80)
});

var SHSTOCKICONINFO = STRUCT('SHSTOCKICONINFO', {
 cbSize: DWORD,
 hIcon: HICON,
 iSysImageIndex: int,
 iIcon: int,
 szPath: ARRAY(WCHAR, MAX_PATH)
});

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: ARRAY(WCHAR, 4),
 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: ARRAY(SOCKET, FD_SETSIZE)
});

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: ARRAY(undefined, 8)
});

var WSADATA = STRUCT('WSADATA', {
 wVersion: WORD,
 wHighVersion: WORD,
 szDescription: ARRAY(undefined, undefined),
 szSystemStatus: ARRAY(undefined, undefined),
 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: ARRAY(undefined, 14)
});

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: ARRAY(CHAR, 20)
});

var PROV_ENUMALGS_EX = STRUCT('PROV_ENUMALGS_EX', {
 aiAlgid: ALG_ID,
 dwDefaultLen: DWORD,
 dwMinLen: DWORD,
 dwMaxLen: DWORD,
 dwProtocols: DWORD,
 dwNameLen: DWORD,
 szName: ARRAY(CHAR, 20),
 dwLongNameLen: DWORD,
 szLongName: ARRAY(CHAR, 40)
});

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: ARRAY(BYTE, 20)
});

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: ARRAY(undefined, 8),
 CertIndex: int,
 CertLabel: ARRAY(undefined, 36)
});

var CRYPT_RC4_KEY_STATE = STRUCT('CRYPT_RC4_KEY_STATE', {
 Key: ARRAY(undefined, 16),
 SBox: ARRAY(undefined, 256),
 i: uchar,
 j: uchar
});

var CRYPT_DES_KEY_STATE = STRUCT('CRYPT_DES_KEY_STATE', {
 Key: ARRAY(undefined, 8),
 IV: ARRAY(undefined, 8),
 Feedback: ARRAY(undefined, 8)
});

var CRYPT_3DES_KEY_STATE = STRUCT('CRYPT_3DES_KEY_STATE', {
 Key: ARRAY(undefined, 24),
 IV: ARRAY(undefined, 8),
 Feedback: ARRAY(undefined, 8)
});

var CRYPT_AES_128_KEY_STATE = STRUCT('CRYPT_AES_128_KEY_STATE', {
 Key: ARRAY(undefined, 16),
 IV: ARRAY(undefined, 16),
 EncryptionState: ARRAY(undefined, 11][16),
 DecryptionState: ARRAY(undefined, 11][16),
 Feedback: ARRAY(undefined, 16)
});

var CRYPT_AES_256_KEY_STATE = STRUCT('CRYPT_AES_256_KEY_STATE', {
 Key: ARRAY(undefined, 32),
 IV: ARRAY(undefined, 16),
 EncryptionState: ARRAY(undefined, 15][16),
 DecryptionState: ARRAY(undefined, 15][16),
 Feedback: ARRAY(undefined, 16)
});

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: ARRAY(UCHAR, 4),
 Seed: ARRAY(UCHAR, 20),
 q: ARRAY(UCHAR, 20)
});

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: ARRAY(UCHAR, 4),
 Seed: ARRAY(UCHAR, 20),
 q: ARRAY(UCHAR, 20)
});

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(VOIDPTR)
});

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(VOIDPTR),
 pUM: PCRYPT_IMAGE_REF,
 pKM: PCRYPT_IMAGE_REF
});

var CRYPT_PROVIDER_REFS = STRUCT('CRYPT_PROVIDER_REFS', {
 cProviders: ULONG,
 rgpProviders: PTR(VOIDPTR)
});

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: ARRAY(BYTE, CRYPT_X942_COUNTER_BYTE_LENGTH),
 rgbKeyLength: ARRAY(BYTE, CRYPT_X942_KEY_LENGTH_BYTE_LENGTH),
 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: ARRAY(BYTE, CRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTH)
});

var CRYPT_RC2_CBC_PARAMETERS = STRUCT('CRYPT_RC2_CBC_PARAMETERS', {
 dwVersion: DWORD,
 fIV: BOOL,
 rgbIV: ARRAY(BYTE, 8)
});

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(VOIDPTR)
});

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(VOIDPTR)
});

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(VOIDPTR)
});

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(VOIDPTR),
 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: ARRAY(BYTE, 16),
 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(VOIDPTR),
 dwCtlEntryIndex: DWORD,
 ppSigner: PTR(VOIDPTR),
 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(VOIDPTR),
 cMsgCrl: DWORD,
 rgpMsgCrl: PTR(VOIDPTR),
 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(VOIDPTR),
 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(VOIDPTR),
 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(VOIDPTR),
 cLowerQualityChainContext: DWORD,
 rgpLowerQualityChainContext: PTR(VOIDPTR),
 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(VOIDPTR)
});

var ENCRYPTION_CERTIFICATE_LIST = STRUCT('ENCRYPTION_CERTIFICATE_LIST', {
 nUsers: DWORD,
 pUsers: PTR(VOIDPTR)
});

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: ARRAY(undefined, 2),
 userContext: PTR(VOID)
});

var SCONTEXT_QUEUE = STRUCT('SCONTEXT_QUEUE', {
 NumberOfObjects: ulong,
 ArrayOfObjects: PTR(VOIDPTR)
});

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(UNEXPOSED),
 pfnFree: PTR(UNEXPOSED),
 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(VOIDPTR),
 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(UNEXPOSED),
 pfnFree: PTR(UNEXPOSED),
 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(UNEXPOSED),
 pfnFree: PTR(UNEXPOSED)
});

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: UNEXPOSED
});

var MIDL_SERVER_INFO = STRUCT('MIDL_SERVER_INFO', {
 pStubDesc: PMIDL_STUB_DESC,
 DispatchTable: PTR(VOIDPTR),
 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(UNEXPOSED),
 pfnFree: PTR(UNEXPOSED),
 pRpcChannelBuffer: PTR(IRpcChannelBuffer),
 Reserved: ARRAY(ULONG_PTR, 5)
});

var NDR_USER_MARSHAL_INFO = STRUCT('NDR_USER_MARSHAL_INFO', {
 InformationLevel: ulong
});

var RemHGLOBAL = STRUCT('RemHGLOBAL', {
 fNullHGlobal: long,
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

var RemHMETAFILEPICT = STRUCT('RemHMETAFILEPICT', {
 mm: long,
 xExt: long,
 yExt: long,
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

var RemHENHMETAFILE = STRUCT('RemHENHMETAFILE', {
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

var RemHBITMAP = STRUCT('RemHBITMAP', {
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

var RemHPALETTE = STRUCT('RemHPALETTE', {
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

var RemHBRUSH = STRUCT('RemHBRUSH', {
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

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: ARRAY(byte,  1 )
});

var WORD_BLOB = STRUCT('WORD_BLOB', {
 clSize: ulong,
 asData: ARRAY(undefined,  1 )
});

var DWORD_BLOB = STRUCT('DWORD_BLOB', {
 clSize: ulong,
 alData: ARRAY(undefined,  1 )
});

var FLAGGED_BYTE_BLOB = STRUCT('FLAGGED_BYTE_BLOB', {
 fFlags: ulong,
 clSize: ulong,
 abData: ARRAY(byte,  1 )
});

var FLAGGED_WORD_BLOB = STRUCT('FLAGGED_WORD_BLOB', {
 fFlags: ulong,
 clSize: ulong,
 asData: ARRAY(undefined,  1 )
});

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: ARRAY(byte,  1 )
});

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: ARRAY(DEVICE_MEDIA_INFO, 1)
});

var STORAGE_PREDICT_FAILURE = STRUCT('STORAGE_PREDICT_FAILURE', {
 PredictFailure: DWORD,
 VendorSpecific: ARRAY(BYTE, 512)
});

var STORAGE_PROPERTY_QUERY = STRUCT('STORAGE_PROPERTY_QUERY', {
 PropertyId: STORAGE_PROPERTY_ID,
 QueryType: STORAGE_QUERY_TYPE,
 AdditionalParameters: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 1)
});

var STORAGE_DEVICE_ID_DESCRIPTOR = STRUCT('STORAGE_DEVICE_ID_DESCRIPTOR', {
 Version: DWORD,
 Size: DWORD,
 NumberOfIdentifiers: DWORD,
 Identifiers: ARRAY(BYTE, 1)
});

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: ARRAY(GUID, 1)
});

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: ARRAY(BOOLEAN, 2),
 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: ARRAY(BYTE, 0)
});

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: ARRAY(BYTE, 0)
});

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: ARRAY(WORD, 1)
});

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: ARRAY(PARTITION_INFORMATION, 1)
});

var VERIFY_INFORMATION = STRUCT('VERIFY_INFORMATION', {
 StartingOffset: LARGE_INTEGER,
 Length: DWORD
});

var REASSIGN_BLOCKS = STRUCT('REASSIGN_BLOCKS', {
 Reserved: WORD,
 Count: WORD,
 BlockNumber: ARRAY(DWORD, 1)
});

var REASSIGN_BLOCKS_EX = STRUCT('REASSIGN_BLOCKS_EX', {
 Reserved: WORD,
 Count: WORD,
 BlockNumber: ARRAY(LARGE_INTEGER, 1)
});

var SET_PARTITION_INFORMATION_GPT = STRUCT('SET_PARTITION_INFORMATION_GPT', {
 PartitionType: GUID,
 PartitionId: GUID,
 Attributes: DWORD64,
 Name: ARRAY(WCHAR, 36)
});

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: ARRAY(PARTITION_INFORMATION_EX, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(WCHAR, 8)
});

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: ARRAY(BIN_RANGE, 1)
});

var BIN_COUNT = STRUCT('BIN_COUNT', {
 BinRange: BIN_RANGE,
 BinCount: DWORD
});

var BIN_RESULTS = STRUCT('BIN_RESULTS', {
 NumberOfBins: DWORD,
 BinCounts: ARRAY(BIN_COUNT, 1)
});

var GETVERSIONINPARAMS = STRUCT('GETVERSIONINPARAMS', {
 bVersion: BYTE,
 bRevision: BYTE,
 bReserved: BYTE,
 bIDEDeviceMap: BYTE,
 fCapabilities: DWORD,
 dwReserved: ARRAY(DWORD, 4)
});

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: ARRAY(BYTE, 3),
 dwReserved: ARRAY(DWORD, 4),
 bBuffer: ARRAY(BYTE, 1)
});

var DRIVERSTATUS = STRUCT('DRIVERSTATUS', {
 bDriverError: BYTE,
 bIDEError: BYTE,
 bReserved: ARRAY(BYTE, 2),
 dwReserved: ARRAY(DWORD, 2)
});

var SENDCMDOUTPARAMS = STRUCT('SENDCMDOUTPARAMS', {
 cBufferSize: DWORD,
 DriverStatus: DRIVERSTATUS,
 bBuffer: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 2),
 Reserved2: ARRAY(DWORD, 2)
});

var CHANGER_PRODUCT_DATA = STRUCT('CHANGER_PRODUCT_DATA', {
 VendorId: ARRAY(BYTE, VENDOR_ID_LENGTH),
 ProductId: ARRAY(BYTE, PRODUCT_ID_LENGTH),
 Revision: ARRAY(BYTE, REVISION_LENGTH),
 SerialNumber: ARRAY(BYTE, SERIAL_NUMBER_LENGTH),
 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: ARRAY(BYTE, MAX_VOLUME_ID_SIZE),
 AlternateVolumeID: ARRAY(BYTE, MAX_VOLUME_ID_SIZE)
});

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: ARRAY(BYTE, MAX_VOLUME_ID_SIZE),
 AlternateVolumeID: ARRAY(BYTE, MAX_VOLUME_ID_SIZE),
 VendorIdentification: ARRAY(BYTE, VENDOR_ID_LENGTH),
 ProductIdentification: ARRAY(BYTE, PRODUCT_ID_LENGTH),
 SerialNumber: ARRAY(BYTE, SERIAL_NUMBER_LENGTH)
});

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: ARRAY(BYTE, MAX_VOLUME_TEMPLATE_SIZE)
});

var READ_ELEMENT_ADDRESS_INFO = STRUCT('READ_ELEMENT_ADDRESS_INFO', {
 NumberOfElements: DWORD,
 ElementStatus: ARRAY(CHANGER_ELEMENT_STATUS, 1)
});

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: ARRAY(WCHAR, 1)
});

var FSCTL_QUERY_FAT_BPB_BUFFER = STRUCT('FSCTL_QUERY_FAT_BPB_BUFFER', {
 First0x24BytesOfBootSector: ARRAY(BYTE, 0x24)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(undefined, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(DWORD, 1)
});

var FILE_PREFETCH = STRUCT('FILE_PREFETCH', {
 Type: DWORD,
 Count: DWORD,
 Prefetch: ARRAY(DWORDLONG, 1)
});

var FILE_PREFETCH_EX = STRUCT('FILE_PREFETCH_EX', {
 Type: DWORD,
 Count: DWORD,
 Context: PVOID,
 Prefetch: ARRAY(DWORDLONG, 1)
});

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: ARRAY(BYTE, 16)
});

var undefined = STRUCT('undefined', {
 BirthVolumeId: ARRAY(BYTE, 16),
 BirthObjectId: ARRAY(BYTE, 16),
 DomainId: ARRAY(BYTE, 16)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(DWORD, ANYSIZE_ARRAY)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR,  12),
 FormatTime: LARGE_INTEGER,
 LastUpdateTime: LARGE_INTEGER,
 CopyrightInfo: ARRAY(WCHAR,  34),
 AbstractInfo: ARRAY(WCHAR,  34),
 FormattingImplementationInfo: ARRAY(WCHAR,  34),
 LastModifyingImplementationInfo: ARRAY(WCHAR,  34)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(WCHAR, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(undefined, 2)
});

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: ARRAY(CHAR, 9)
});

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: ARRAY(LARGE_INTEGER, 1)
});

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: ARRAY(WCHAR, 1)
});

var FILE_TYPE_NOTIFICATION_INPUT = STRUCT('FILE_TYPE_NOTIFICATION_INPUT', {
 Flags: DWORD,
 NumFileTypeIDs: DWORD,
 FileTypeID: ARRAY(GUID, 1)
});

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: ARRAY(DISK_EXTENT, ANYSIZE_ARRAY)
});

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: ARRAY(BYTE, 36)
});

var SCARD_READERSTATEW = STRUCT('SCARD_READERSTATEW', {
 szReader: LPCWSTR,
 pvUserData: LPVOID,
 dwCurrentState: DWORD,
 dwEventState: DWORD,
 cbAtr: DWORD,
 rgbAtr: ARRAY(BYTE, 36)
});

var SCARD_ATRMASK = STRUCT('SCARD_ATRMASK', {
 cbAtr: DWORD,
 rgbAtr: ARRAY(BYTE, 36),
 rgbMask: ARRAY(BYTE, 36)
});

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: ARRAY(PRINTER_NOTIFY_INFO_DATA, 1)
});

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: ARRAY(BIDI_REQUEST_DATA,  1 )
});

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: ARRAY(BIDI_RESPONSE_DATA,  1 )
});

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: ARRAY(CHAR, MAX_PATH)
});

var CORE_PRINTER_DRIVERW = STRUCT('CORE_PRINTER_DRIVERW', {
 CoreDriverGUID: GUID,
 ftDriverDate: FILETIME,
 dwlDriverVersion: DWORDLONG,
 szPackageID: ARRAY(WCHAR, MAX_PATH)
});

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: ARRAY(undefined, 10)
});

var _CRT_DOUBLE = STRUCT('_CRT_DOUBLE', {
 x: double
});

var _CRT_FLOAT = STRUCT('_CRT_FLOAT', {
 f: float
});

var _LONGDOUBLE = STRUCT('_LONGDOUBLE', {
 x: longdouble
});

var _LDBL12 = STRUCT('_LDBL12', {
 ld12: ARRAY(undefined, 12)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED)
});

var AsyncIUnknownVtbl = STRUCT('AsyncIUnknownVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_QueryInterface: PTR(UNEXPOSED),
 Finish_QueryInterface: PTR(UNEXPOSED),
 Begin_AddRef: PTR(UNEXPOSED),
 Finish_AddRef: PTR(UNEXPOSED),
 Begin_Release: PTR(UNEXPOSED),
 Finish_Release: PTR(UNEXPOSED)
});

var IClassFactoryVtbl = STRUCT('IClassFactoryVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateInstance: PTR(UNEXPOSED),
 LockServer: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetUnmarshalClass: PTR(UNEXPOSED),
 GetMarshalSizeMax: PTR(UNEXPOSED),
 MarshalInterface: PTR(UNEXPOSED),
 UnmarshalInterface: PTR(UNEXPOSED),
 ReleaseMarshalData: PTR(UNEXPOSED),
 DisconnectObject: PTR(UNEXPOSED)
});

var IMarshal2Vtbl = STRUCT('IMarshal2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetUnmarshalClass: PTR(UNEXPOSED),
 GetMarshalSizeMax: PTR(UNEXPOSED),
 MarshalInterface: PTR(UNEXPOSED),
 UnmarshalInterface: PTR(UNEXPOSED),
 ReleaseMarshalData: PTR(UNEXPOSED),
 DisconnectObject: PTR(UNEXPOSED)
});

var IMallocVtbl = STRUCT('IMallocVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Alloc: PTR(UNEXPOSED),
 Realloc: PTR(UNEXPOSED),
 Free: PTR(UNEXPOSED),
 GetSize: PTR(UNEXPOSED),
 DidAlloc: PTR(UNEXPOSED),
 HeapMinimize: PTR(UNEXPOSED)
});

var IMallocSpyVtbl = STRUCT('IMallocSpyVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 PreAlloc: PTR(UNEXPOSED),
 PostAlloc: PTR(UNEXPOSED),
 PreFree: PTR(UNEXPOSED),
 PostFree: PTR(UNEXPOSED),
 PreRealloc: PTR(UNEXPOSED),
 PostRealloc: PTR(UNEXPOSED),
 PreGetSize: PTR(UNEXPOSED),
 PostGetSize: PTR(UNEXPOSED),
 PreDidAlloc: PTR(UNEXPOSED),
 PostDidAlloc: PTR(UNEXPOSED),
 PreHeapMinimize: PTR(UNEXPOSED),
 PostHeapMinimize: PTR(UNEXPOSED)
});

var IStdMarshalInfoVtbl = STRUCT('IStdMarshalInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassForHandler: PTR(UNEXPOSED)
});

var IExternalConnectionVtbl = STRUCT('IExternalConnectionVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AddConnection: PTR(UNEXPOSED),
 ReleaseConnection: PTR(UNEXPOSED)
});

var MULTI_QI = STRUCT('MULTI_QI', {
 pIID: PTR(uint),
 pItf: PTR(uint),
 hr: HRESULT
});

var IMultiQIVtbl = STRUCT('IMultiQIVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryMultipleInterfaces: PTR(UNEXPOSED)
});

var AsyncIMultiQIVtbl = STRUCT('AsyncIMultiQIVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_QueryMultipleInterfaces: PTR(UNEXPOSED),
 Finish_QueryMultipleInterfaces: PTR(UNEXPOSED)
});

var IInternalUnknownVtbl = STRUCT('IInternalUnknownVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryInternalInterface: PTR(UNEXPOSED)
});

var IEnumUnknownVtbl = STRUCT('IEnumUnknownVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 RegisterObjectBound: PTR(UNEXPOSED),
 RevokeObjectBound: PTR(UNEXPOSED),
 ReleaseBoundObjects: PTR(UNEXPOSED),
 SetBindOptions: PTR(UNEXPOSED),
 GetBindOptions: PTR(UNEXPOSED),
 GetRunningObjectTable: PTR(UNEXPOSED),
 RegisterObjectParam: PTR(UNEXPOSED),
 GetObjectParam: PTR(UNEXPOSED),
 EnumObjectParam: PTR(UNEXPOSED),
 RevokeObjectParam: PTR(UNEXPOSED)
});

var IEnumMonikerVtbl = STRUCT('IEnumMonikerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var IRunnableObjectVtbl = STRUCT('IRunnableObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetRunningClass: PTR(UNEXPOSED),
 Run: PTR(UNEXPOSED),
 IsRunning: PTR(UNEXPOSED),
 LockRunning: PTR(UNEXPOSED),
 SetContainedObject: PTR(UNEXPOSED)
});

var IRunningObjectTableVtbl = STRUCT('IRunningObjectTableVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Register: PTR(UNEXPOSED),
 Revoke: PTR(UNEXPOSED),
 IsRunning: PTR(UNEXPOSED),
 GetObjectA: PTR(UNEXPOSED),
 NoteChangeTime: PTR(UNEXPOSED),
 GetTimeOfLastChange: PTR(UNEXPOSED),
 EnumRunning: PTR(UNEXPOSED)
});

var IPersistVtbl = STRUCT('IPersistVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED)
});

var IPersistStreamVtbl = STRUCT('IPersistStreamVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED),
 IsDirty: PTR(UNEXPOSED),
 Load: PTR(UNEXPOSED),
 Save: PTR(UNEXPOSED),
 GetSizeMax: PTR(UNEXPOSED)
});

var IMonikerVtbl = STRUCT('IMonikerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED),
 IsDirty: PTR(UNEXPOSED),
 Load: PTR(UNEXPOSED),
 Save: PTR(UNEXPOSED),
 GetSizeMax: PTR(UNEXPOSED),
 BindToObject: PTR(UNEXPOSED),
 BindToStorage: PTR(UNEXPOSED),
 Reduce: PTR(UNEXPOSED),
 ComposeWith: PTR(UNEXPOSED),
 Enum: PTR(UNEXPOSED),
 IsEqual: PTR(UNEXPOSED),
 Hash: PTR(UNEXPOSED),
 IsRunning: PTR(UNEXPOSED),
 GetTimeOfLastChange: PTR(UNEXPOSED),
 Inverse: PTR(UNEXPOSED),
 CommonPrefixWith: PTR(UNEXPOSED),
 RelativePathTo: PTR(UNEXPOSED),
 GetDisplayName: PTR(UNEXPOSED),
 ParseDisplayName: PTR(UNEXPOSED),
 IsSystemMoniker: PTR(UNEXPOSED)
});

var IROTDataVtbl = STRUCT('IROTDataVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetComparisonData: PTR(UNEXPOSED)
});

var IEnumStringVtbl = STRUCT('IEnumStringVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var ISequentialStreamVtbl = STRUCT('ISequentialStreamVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Read: PTR(UNEXPOSED),
 Write: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Read: PTR(UNEXPOSED),
 Write: PTR(UNEXPOSED),
 Seek: PTR(UNEXPOSED),
 SetSize: PTR(UNEXPOSED),
 CopyTo: PTR(UNEXPOSED),
 Commit: PTR(UNEXPOSED),
 Revert: PTR(UNEXPOSED),
 LockRegion: PTR(UNEXPOSED),
 UnlockRegion: PTR(UNEXPOSED),
 Stat: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var IEnumSTATSTGVtbl = STRUCT('IEnumSTATSTGVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var RemSNB = STRUCT('RemSNB', {
 ulCntStr: ulong,
 ulCntChar: ulong,
 rgString: ARRAY(OLECHAR,  1 )
});

var IStorageVtbl = STRUCT('IStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateStream: PTR(UNEXPOSED),
 OpenStream: PTR(UNEXPOSED),
 CreateStorage: PTR(UNEXPOSED),
 OpenStorage: PTR(UNEXPOSED),
 CopyTo: PTR(UNEXPOSED),
 MoveElementTo: PTR(UNEXPOSED),
 Commit: PTR(UNEXPOSED),
 Revert: PTR(UNEXPOSED),
 EnumElements: PTR(UNEXPOSED),
 DestroyElement: PTR(UNEXPOSED),
 RenameElement: PTR(UNEXPOSED),
 SetElementTimes: PTR(UNEXPOSED),
 SetClass: PTR(UNEXPOSED),
 SetStateBits: PTR(UNEXPOSED),
 Stat: PTR(UNEXPOSED)
});

var IPersistFileVtbl = STRUCT('IPersistFileVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED),
 IsDirty: PTR(UNEXPOSED),
 Load: PTR(UNEXPOSED),
 Save: PTR(UNEXPOSED),
 SaveCompleted: PTR(UNEXPOSED),
 GetCurFile: PTR(UNEXPOSED)
});

var IPersistStorageVtbl = STRUCT('IPersistStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED),
 IsDirty: PTR(UNEXPOSED),
 InitNew: PTR(UNEXPOSED),
 Load: PTR(UNEXPOSED),
 Save: PTR(UNEXPOSED),
 SaveCompleted: PTR(UNEXPOSED),
 HandsOffStorage: PTR(UNEXPOSED)
});

var ILockBytesVtbl = STRUCT('ILockBytesVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ReadAt: PTR(UNEXPOSED),
 WriteAt: PTR(UNEXPOSED),
 Flush: PTR(UNEXPOSED),
 SetSize: PTR(UNEXPOSED),
 LockRegion: PTR(UNEXPOSED),
 UnlockRegion: PTR(UNEXPOSED),
 Stat: PTR(UNEXPOSED)
});

var DVTARGETDEVICE = STRUCT('DVTARGETDEVICE', {
 tdSize: DWORD,
 tdDriverNameOffset: WORD,
 tdDeviceNameOffset: WORD,
 tdPortNameOffset: WORD,
 tdExtDevmodeOffset: WORD,
 tdData: ARRAY(BYTE,  1 )
});

var FORMATETC = STRUCT('FORMATETC', {
 cfFormat: CLIPFORMAT,
 ptd: PTR(uint),
 dwAspect: DWORD,
 lindex: LONG,
 tymed: DWORD
});

var IEnumFORMATETCVtbl = STRUCT('IEnumFORMATETCVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var STATDATA = STRUCT('STATDATA', {
 formatetc: FORMATETC,
 advf: DWORD,
 pAdvSink: PTR(uint),
 dwConnection: DWORD
});

var IEnumSTATDATAVtbl = STRUCT('IEnumSTATDATAVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var IRootStorageVtbl = STRUCT('IRootStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SwitchToFile: PTR(UNEXPOSED)
});

var RemSTGMEDIUM = STRUCT('RemSTGMEDIUM', {
 tymed: DWORD,
 dwHandleType: DWORD,
 pData: ulong,
 pUnkForRelease: ulong,
 cbData: ulong,
 data: ARRAY(byte,  1 )
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnDataChange: PTR(UNEXPOSED),
 OnViewChange: PTR(UNEXPOSED),
 OnRename: PTR(UNEXPOSED),
 OnSave: PTR(UNEXPOSED),
 OnClose: PTR(UNEXPOSED)
});

var AsyncIAdviseSinkVtbl = STRUCT('AsyncIAdviseSinkVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_OnDataChange: PTR(UNEXPOSED),
 Finish_OnDataChange: PTR(UNEXPOSED),
 Begin_OnViewChange: PTR(UNEXPOSED),
 Finish_OnViewChange: PTR(UNEXPOSED),
 Begin_OnRename: PTR(UNEXPOSED),
 Finish_OnRename: PTR(UNEXPOSED),
 Begin_OnSave: PTR(UNEXPOSED),
 Finish_OnSave: PTR(UNEXPOSED),
 Begin_OnClose: PTR(UNEXPOSED),
 Finish_OnClose: PTR(UNEXPOSED)
});

var IAdviseSink2Vtbl = STRUCT('IAdviseSink2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnDataChange: PTR(UNEXPOSED),
 OnViewChange: PTR(UNEXPOSED),
 OnRename: PTR(UNEXPOSED),
 OnSave: PTR(UNEXPOSED),
 OnClose: PTR(UNEXPOSED),
 OnLinkSrcChange: PTR(UNEXPOSED)
});

var AsyncIAdviseSink2Vtbl = STRUCT('AsyncIAdviseSink2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_OnDataChange: PTR(UNEXPOSED),
 Finish_OnDataChange: PTR(UNEXPOSED),
 Begin_OnViewChange: PTR(UNEXPOSED),
 Finish_OnViewChange: PTR(UNEXPOSED),
 Begin_OnRename: PTR(UNEXPOSED),
 Finish_OnRename: PTR(UNEXPOSED),
 Begin_OnSave: PTR(UNEXPOSED),
 Finish_OnSave: PTR(UNEXPOSED),
 Begin_OnClose: PTR(UNEXPOSED),
 Finish_OnClose: PTR(UNEXPOSED),
 Begin_OnLinkSrcChange: PTR(UNEXPOSED),
 Finish_OnLinkSrcChange: PTR(UNEXPOSED)
});

var IDataObjectVtbl = STRUCT('IDataObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetData: PTR(UNEXPOSED),
 GetDataHere: PTR(UNEXPOSED),
 QueryGetData: PTR(UNEXPOSED),
 GetCanonicalFormatEtc: PTR(UNEXPOSED),
 SetData: PTR(UNEXPOSED),
 EnumFormatEtc: PTR(UNEXPOSED),
 DAdvise: PTR(UNEXPOSED),
 DUnadvise: PTR(UNEXPOSED),
 EnumDAdvise: PTR(UNEXPOSED)
});

var IDataAdviseHolderVtbl = STRUCT('IDataAdviseHolderVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Advise: PTR(UNEXPOSED),
 Unadvise: PTR(UNEXPOSED),
 EnumAdvise: PTR(UNEXPOSED),
 SendOnDataChange: PTR(UNEXPOSED)
});

var INTERFACEINFO = STRUCT('INTERFACEINFO', {
 pUnk: PTR(uint),
 iid: IID,
 wMethod: WORD
});

var IMessageFilterVtbl = STRUCT('IMessageFilterVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 HandleInComingCall: PTR(UNEXPOSED),
 RetryRejectedCall: PTR(UNEXPOSED),
 MessagePending: PTR(UNEXPOSED)
});

var RPCOLEMESSAGE = STRUCT('RPCOLEMESSAGE', {
 reserved1: PTR(VOID),
 dataRepresentation: RPCOLEDATAREP,
 Buffer: PTR(VOID),
 cbBuffer: ULONG,
 iMethod: ULONG,
 reserved2: ARRAY(undefined,  5 ),
 rpcFlags: ULONG
});

var IRpcChannelBufferVtbl = STRUCT('IRpcChannelBufferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBuffer: PTR(UNEXPOSED),
 SendReceive: PTR(UNEXPOSED),
 FreeBuffer: PTR(UNEXPOSED),
 GetDestCtx: PTR(UNEXPOSED),
 IsConnected: PTR(UNEXPOSED)
});

var IRpcChannelBuffer2Vtbl = STRUCT('IRpcChannelBuffer2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBuffer: PTR(UNEXPOSED),
 SendReceive: PTR(UNEXPOSED),
 FreeBuffer: PTR(UNEXPOSED),
 GetDestCtx: PTR(UNEXPOSED),
 IsConnected: PTR(UNEXPOSED),
 GetProtocolVersion: PTR(UNEXPOSED)
});

var IAsyncRpcChannelBufferVtbl = STRUCT('IAsyncRpcChannelBufferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBuffer: PTR(UNEXPOSED),
 SendReceive: PTR(UNEXPOSED),
 FreeBuffer: PTR(UNEXPOSED),
 GetDestCtx: PTR(UNEXPOSED),
 IsConnected: PTR(UNEXPOSED),
 GetProtocolVersion: PTR(UNEXPOSED),
 Send: PTR(UNEXPOSED),
 Receive: PTR(UNEXPOSED),
 GetDestCtxEx: PTR(UNEXPOSED)
});

var IRpcChannelBuffer3Vtbl = STRUCT('IRpcChannelBuffer3Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBuffer: PTR(UNEXPOSED),
 SendReceive: PTR(UNEXPOSED),
 FreeBuffer: PTR(UNEXPOSED),
 GetDestCtx: PTR(UNEXPOSED),
 IsConnected: PTR(UNEXPOSED),
 GetProtocolVersion: PTR(UNEXPOSED),
 Send: PTR(UNEXPOSED),
 Receive: PTR(UNEXPOSED),
 Cancel: PTR(UNEXPOSED),
 GetCallContext: PTR(UNEXPOSED),
 GetDestCtxEx: PTR(UNEXPOSED),
 GetState: PTR(UNEXPOSED),
 RegisterAsync: PTR(UNEXPOSED)
});

var IRpcSyntaxNegotiateVtbl = STRUCT('IRpcSyntaxNegotiateVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 NegotiateSyntax: PTR(UNEXPOSED)
});

var IRpcProxyBufferVtbl = STRUCT('IRpcProxyBufferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Connect: PTR(UNEXPOSED),
 Disconnect: PTR(UNEXPOSED)
});

var IRpcStubBufferVtbl = STRUCT('IRpcStubBufferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Connect: PTR(UNEXPOSED),
 Disconnect: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 IsIIDSupported: PTR(UNEXPOSED),
 CountRefs: PTR(UNEXPOSED),
 DebugServerQueryInterface: PTR(UNEXPOSED),
 DebugServerRelease: PTR(UNEXPOSED)
});

var IPSFactoryBufferVtbl = STRUCT('IPSFactoryBufferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateProxy: PTR(UNEXPOSED),
 CreateStub: PTR(UNEXPOSED)
});

var SChannelHookCallInfo = STRUCT('SChannelHookCallInfo', {
 iid: IID,
 cbSize: DWORD,
 uCausality: GUID,
 dwServerPid: DWORD,
 iMethod: DWORD,
 pObject: PTR(VOID)
});

var IChannelHookVtbl = STRUCT('IChannelHookVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ClientGetSize: PTR(UNEXPOSED),
 ClientFillBuffer: PTR(UNEXPOSED),
 ClientNotify: PTR(UNEXPOSED),
 ServerNotify: PTR(UNEXPOSED),
 ServerGetSize: PTR(UNEXPOSED),
 ServerFillBuffer: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryBlanket: PTR(UNEXPOSED),
 SetBlanket: PTR(UNEXPOSED),
 CopyProxy: PTR(UNEXPOSED)
});

var IServerSecurityVtbl = STRUCT('IServerSecurityVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryBlanket: PTR(UNEXPOSED),
 ImpersonateClient: PTR(UNEXPOSED),
 RevertToSelf: PTR(UNEXPOSED),
 IsImpersonating: PTR(UNEXPOSED)
});

var IClassActivatorVtbl = STRUCT('IClassActivatorVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassObject: PTR(UNEXPOSED)
});

var IRpcOptionsVtbl = STRUCT('IRpcOptionsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Set: PTR(UNEXPOSED),
 Query: PTR(UNEXPOSED)
});

var IGlobalOptionsVtbl = STRUCT('IGlobalOptionsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Set: PTR(UNEXPOSED),
 Query: PTR(UNEXPOSED)
});

var IFillLockBytesVtbl = STRUCT('IFillLockBytesVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 FillAppend: PTR(UNEXPOSED),
 FillAt: PTR(UNEXPOSED),
 SetFillSize: PTR(UNEXPOSED),
 Terminate: PTR(UNEXPOSED)
});

var IProgressNotifyVtbl = STRUCT('IProgressNotifyVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnProgress: PTR(UNEXPOSED)
});

var StorageLayout = STRUCT('StorageLayout', {
 LayoutType: DWORD,
 pwcsElementName: PTR(ushort),
 cOffset: LARGE_INTEGER,
 cBytes: LARGE_INTEGER
});

var ILayoutStorageVtbl = STRUCT('ILayoutStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 LayoutScript: PTR(UNEXPOSED),
 BeginMonitor: PTR(UNEXPOSED),
 EndMonitor: PTR(UNEXPOSED),
 ReLayoutDocfile: PTR(UNEXPOSED),
 ReLayoutDocfileOnILockBytes: PTR(UNEXPOSED)
});

var IBlockingLockVtbl = STRUCT('IBlockingLockVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Lock: PTR(UNEXPOSED),
 Unlock: PTR(UNEXPOSED)
});

var ITimeAndNoticeControlVtbl = STRUCT('ITimeAndNoticeControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SuppressChanges: PTR(UNEXPOSED)
});

var IOplockStorageVtbl = STRUCT('IOplockStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateStorageEx: PTR(UNEXPOSED),
 OpenStorageEx: PTR(UNEXPOSED)
});

var ISurrogateVtbl = STRUCT('ISurrogateVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 LoadDllServer: PTR(UNEXPOSED),
 FreeSurrogate: PTR(UNEXPOSED)
});

var IGlobalInterfaceTableVtbl = STRUCT('IGlobalInterfaceTableVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 RegisterInterfaceInGlobal: PTR(UNEXPOSED),
 RevokeInterfaceFromGlobal: PTR(UNEXPOSED),
 GetInterfaceFromGlobal: PTR(UNEXPOSED)
});

var IDirectWriterLockVtbl = STRUCT('IDirectWriterLockVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 WaitForWriteAccess: PTR(UNEXPOSED),
 ReleaseWriteAccess: PTR(UNEXPOSED),
 HaveWriteAccess: PTR(UNEXPOSED)
});

var ISynchronizeVtbl = STRUCT('ISynchronizeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Wait: PTR(UNEXPOSED),
 Signal: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED)
});

var ISynchronizeHandleVtbl = STRUCT('ISynchronizeHandleVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetHandle: PTR(UNEXPOSED)
});

var ISynchronizeEventVtbl = STRUCT('ISynchronizeEventVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetHandle: PTR(UNEXPOSED),
 SetEventHandle: PTR(UNEXPOSED)
});

var ISynchronizeContainerVtbl = STRUCT('ISynchronizeContainerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AddSynchronize: PTR(UNEXPOSED),
 WaitMultiple: PTR(UNEXPOSED)
});

var ISynchronizeMutexVtbl = STRUCT('ISynchronizeMutexVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Wait: PTR(UNEXPOSED),
 Signal: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 ReleaseMutex: PTR(UNEXPOSED)
});

var ICancelMethodCallsVtbl = STRUCT('ICancelMethodCallsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Cancel: PTR(UNEXPOSED),
 TestCancel: PTR(UNEXPOSED)
});

var IAsyncManagerVtbl = STRUCT('IAsyncManagerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CompleteCall: PTR(UNEXPOSED),
 GetCallContext: PTR(UNEXPOSED),
 GetState: PTR(UNEXPOSED)
});

var ICallFactoryVtbl = STRUCT('ICallFactoryVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateCall: PTR(UNEXPOSED)
});

var IRpcHelperVtbl = STRUCT('IRpcHelperVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetDCOMProtocolVersion: PTR(UNEXPOSED),
 GetIIDFromOBJREF: PTR(UNEXPOSED)
});

var IReleaseMarshalBuffersVtbl = STRUCT('IReleaseMarshalBuffersVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ReleaseMarshalBuffer: PTR(UNEXPOSED)
});

var IWaitMultipleVtbl = STRUCT('IWaitMultipleVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 WaitMultiple: PTR(UNEXPOSED),
 AddSynchronize: PTR(UNEXPOSED)
});

var IUrlMonVtbl = STRUCT('IUrlMonVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AsyncGetClassBits: PTR(UNEXPOSED)
});

var IForegroundTransferVtbl = STRUCT('IForegroundTransferVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AllowForegroundTransfer: PTR(UNEXPOSED)
});

var IAddrTrackingControlVtbl = STRUCT('IAddrTrackingControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 EnableCOMDynamicAddrTracking: PTR(UNEXPOSED),
 DisableCOMDynamicAddrTracking: PTR(UNEXPOSED)
});

var IAddrExclusionControlVtbl = STRUCT('IAddrExclusionControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetCurrentAddrExclusionList: PTR(UNEXPOSED),
 UpdateAddrExclusionList: PTR(UNEXPOSED)
});

var IPipeByteVtbl = STRUCT('IPipeByteVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Pull: PTR(UNEXPOSED),
 Push: PTR(UNEXPOSED)
});

var AsyncIPipeByteVtbl = STRUCT('AsyncIPipeByteVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_Pull: PTR(UNEXPOSED),
 Finish_Pull: PTR(UNEXPOSED),
 Begin_Push: PTR(UNEXPOSED),
 Finish_Push: PTR(UNEXPOSED)
});

var IPipeLongVtbl = STRUCT('IPipeLongVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Pull: PTR(UNEXPOSED),
 Push: PTR(UNEXPOSED)
});

var AsyncIPipeLongVtbl = STRUCT('AsyncIPipeLongVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_Pull: PTR(UNEXPOSED),
 Finish_Pull: PTR(UNEXPOSED),
 Begin_Push: PTR(UNEXPOSED),
 Finish_Push: PTR(UNEXPOSED)
});

var IPipeDoubleVtbl = STRUCT('IPipeDoubleVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Pull: PTR(UNEXPOSED),
 Push: PTR(UNEXPOSED)
});

var AsyncIPipeDoubleVtbl = STRUCT('AsyncIPipeDoubleVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Begin_Pull: PTR(UNEXPOSED),
 Finish_Pull: PTR(UNEXPOSED),
 Begin_Push: PTR(UNEXPOSED),
 Finish_Push: PTR(UNEXPOSED)
});

var IThumbnailExtractorVtbl = STRUCT('IThumbnailExtractorVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ExtractThumbnail: PTR(UNEXPOSED),
 OnFileUpdated: PTR(UNEXPOSED)
});

var IDummyHICONIncluderVtbl = STRUCT('IDummyHICONIncluderVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Dummy: PTR(UNEXPOSED)
});

var IProcessLockVtbl = STRUCT('IProcessLockVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AddRefOnProcess: PTR(UNEXPOSED),
 ReleaseRefOnProcess: PTR(UNEXPOSED)
});

var ISurrogateServiceVtbl = STRUCT('ISurrogateServiceVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Init: PTR(UNEXPOSED),
 ApplicationLaunch: PTR(UNEXPOSED),
 ApplicationFree: PTR(UNEXPOSED),
 CatalogRefresh: PTR(UNEXPOSED),
 ProcessShutdown: PTR(UNEXPOSED)
});

var IComThreadingInfoVtbl = STRUCT('IComThreadingInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetCurrentApartmentType: PTR(UNEXPOSED),
 GetCurrentThreadType: PTR(UNEXPOSED),
 GetCurrentLogicalThreadId: PTR(UNEXPOSED),
 SetCurrentLogicalThreadId: PTR(UNEXPOSED)
});

var IProcessInitControlVtbl = STRUCT('IProcessInitControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ResetInitializerTimeout: PTR(UNEXPOSED)
});

var IInitializeSpyVtbl = STRUCT('IInitializeSpyVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 PreInitialize: PTR(UNEXPOSED),
 PostInitialize: PTR(UNEXPOSED),
 PreUninitialize: PTR(UNEXPOSED),
 PostUninitialize: PTR(UNEXPOSED)
});

var SOleTlsDataPublic = STRUCT('SOleTlsDataPublic', {
 pvReserved0: ARRAY(undefined, 2),
 dwReserved0: ARRAY(DWORD, 3),
 pvReserved1: ARRAY(undefined, 1),
 dwReserved1: ARRAY(DWORD, 3),
 pvReserved2: ARRAY(undefined, 4),
 dwReserved2: ARRAY(DWORD, 1),
 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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Advise: PTR(UNEXPOSED),
 Unadvise: PTR(UNEXPOSED),
 EnumAdvise: PTR(UNEXPOSED),
 SendOnRename: PTR(UNEXPOSED),
 SendOnSave: PTR(UNEXPOSED),
 SendOnClose: PTR(UNEXPOSED)
});

var IOleCacheVtbl = STRUCT('IOleCacheVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Cache: PTR(UNEXPOSED),
 Uncache: PTR(UNEXPOSED),
 EnumCache: PTR(UNEXPOSED),
 InitCache: PTR(UNEXPOSED),
 SetData: PTR(UNEXPOSED)
});

var IOleCache2Vtbl = STRUCT('IOleCache2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Cache: PTR(UNEXPOSED),
 Uncache: PTR(UNEXPOSED),
 EnumCache: PTR(UNEXPOSED),
 InitCache: PTR(UNEXPOSED),
 SetData: PTR(UNEXPOSED),
 UpdateCache: PTR(UNEXPOSED),
 DiscardCache: PTR(UNEXPOSED)
});

var IOleCacheControlVtbl = STRUCT('IOleCacheControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnRun: PTR(UNEXPOSED),
 OnStop: PTR(UNEXPOSED)
});

var IParseDisplayNameVtbl = STRUCT('IParseDisplayNameVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ParseDisplayName: PTR(UNEXPOSED)
});

var IOleContainerVtbl = STRUCT('IOleContainerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ParseDisplayName: PTR(UNEXPOSED),
 EnumObjects: PTR(UNEXPOSED),
 LockContainer: PTR(UNEXPOSED)
});

var IOleClientSiteVtbl = STRUCT('IOleClientSiteVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SaveObject: PTR(UNEXPOSED),
 GetMoniker: PTR(UNEXPOSED),
 GetContainer: PTR(UNEXPOSED),
 ShowObject: PTR(UNEXPOSED),
 OnShowWindow: PTR(UNEXPOSED),
 RequestNewObjectLayout: PTR(UNEXPOSED)
});

var IOleObjectVtbl = STRUCT('IOleObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetClientSite: PTR(UNEXPOSED),
 GetClientSite: PTR(UNEXPOSED),
 SetHostNames: PTR(UNEXPOSED),
 Close: PTR(UNEXPOSED),
 SetMoniker: PTR(UNEXPOSED),
 GetMoniker: PTR(UNEXPOSED),
 InitFromData: PTR(UNEXPOSED),
 GetClipboardData: PTR(UNEXPOSED),
 DoVerb: PTR(UNEXPOSED),
 EnumVerbs: PTR(UNEXPOSED),
 Update: PTR(UNEXPOSED),
 IsUpToDate: PTR(UNEXPOSED),
 GetUserClassID: PTR(UNEXPOSED),
 GetUserType: PTR(UNEXPOSED),
 SetExtent: PTR(UNEXPOSED),
 GetExtent: PTR(UNEXPOSED),
 Advise: PTR(UNEXPOSED),
 Unadvise: PTR(UNEXPOSED),
 EnumAdvise: PTR(UNEXPOSED),
 GetMiscStatus: PTR(UNEXPOSED),
 SetColorScheme: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED)
});

var IOleLinkVtbl = STRUCT('IOleLinkVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetUpdateOptions: PTR(UNEXPOSED),
 GetUpdateOptions: PTR(UNEXPOSED),
 SetSourceMoniker: PTR(UNEXPOSED),
 GetSourceMoniker: PTR(UNEXPOSED),
 SetSourceDisplayName: PTR(UNEXPOSED),
 GetSourceDisplayName: PTR(UNEXPOSED),
 BindToSource: PTR(UNEXPOSED),
 BindIfRunning: PTR(UNEXPOSED),
 GetBoundSource: PTR(UNEXPOSED),
 UnbindSource: PTR(UNEXPOSED),
 Update: PTR(UNEXPOSED)
});

var IOleItemContainerVtbl = STRUCT('IOleItemContainerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ParseDisplayName: PTR(UNEXPOSED),
 EnumObjects: PTR(UNEXPOSED),
 LockContainer: PTR(UNEXPOSED),
 GetObjectA: PTR(UNEXPOSED),
 GetObjectStorage: PTR(UNEXPOSED),
 IsRunning: PTR(UNEXPOSED)
});

var IOleInPlaceUIWindowVtbl = STRUCT('IOleInPlaceUIWindowVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED),
 GetBorder: PTR(UNEXPOSED),
 RequestBorderSpace: PTR(UNEXPOSED),
 SetBorderSpace: PTR(UNEXPOSED),
 SetActiveObject: PTR(UNEXPOSED)
});

var IOleInPlaceActiveObjectVtbl = STRUCT('IOleInPlaceActiveObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED),
 TranslateAcceleratorA: PTR(UNEXPOSED),
 OnFrameWindowActivate: PTR(UNEXPOSED),
 OnDocWindowActivate: PTR(UNEXPOSED),
 ResizeBorder: PTR(UNEXPOSED),
 EnableModeless: PTR(UNEXPOSED)
});

var OLEINPLACEFRAMEINFO = STRUCT('OLEINPLACEFRAMEINFO', {
 cb: UINT,
 fMDIApp: BOOL,
 hwndFrame: HWND,
 haccel: HACCEL,
 cAccelEntries: UINT
});

var OLEMENUGROUPWIDTHS = STRUCT('OLEMENUGROUPWIDTHS', {
 width: ARRAY(LONG,  6 )
});

var IOleInPlaceFrameVtbl = STRUCT('IOleInPlaceFrameVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED),
 GetBorder: PTR(UNEXPOSED),
 RequestBorderSpace: PTR(UNEXPOSED),
 SetBorderSpace: PTR(UNEXPOSED),
 SetActiveObject: PTR(UNEXPOSED),
 InsertMenus: PTR(UNEXPOSED),
 SetMenu: PTR(UNEXPOSED),
 RemoveMenus: PTR(UNEXPOSED),
 SetStatusText: PTR(UNEXPOSED),
 EnableModeless: PTR(UNEXPOSED),
 TranslateAcceleratorA: PTR(UNEXPOSED)
});

var IOleInPlaceObjectVtbl = STRUCT('IOleInPlaceObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED),
 InPlaceDeactivate: PTR(UNEXPOSED),
 UIDeactivate: PTR(UNEXPOSED),
 SetObjectRects: PTR(UNEXPOSED),
 ReactivateAndUndo: PTR(UNEXPOSED)
});

var IOleInPlaceSiteVtbl = STRUCT('IOleInPlaceSiteVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 ContextSensitiveHelp: PTR(UNEXPOSED),
 CanInPlaceActivate: PTR(UNEXPOSED),
 OnInPlaceActivate: PTR(UNEXPOSED),
 OnUIActivate: PTR(UNEXPOSED),
 GetWindowContext: PTR(UNEXPOSED),
 Scroll: PTR(UNEXPOSED),
 OnUIDeactivate: PTR(UNEXPOSED),
 OnInPlaceDeactivate: PTR(UNEXPOSED),
 DiscardUndoState: PTR(UNEXPOSED),
 DeactivateAndUndo: PTR(UNEXPOSED),
 OnPosRectChange: PTR(UNEXPOSED)
});

var IContinueVtbl = STRUCT('IContinueVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 FContinue: PTR(UNEXPOSED)
});

var IViewObjectVtbl = STRUCT('IViewObjectVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Draw: PTR(UNEXPOSED),
 GetColorSet: PTR(UNEXPOSED),
 Freeze: PTR(UNEXPOSED),
 Unfreeze: PTR(UNEXPOSED),
 SetAdvise: PTR(UNEXPOSED),
 GetAdvise: PTR(UNEXPOSED)
});

var IViewObject2Vtbl = STRUCT('IViewObject2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Draw: PTR(UNEXPOSED),
 GetColorSet: PTR(UNEXPOSED),
 Freeze: PTR(UNEXPOSED),
 Unfreeze: PTR(UNEXPOSED),
 SetAdvise: PTR(UNEXPOSED),
 GetAdvise: PTR(UNEXPOSED),
 GetExtent: PTR(UNEXPOSED)
});

var IDropSourceVtbl = STRUCT('IDropSourceVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryContinueDrag: PTR(UNEXPOSED),
 GiveFeedback: PTR(UNEXPOSED)
});

var IDropTargetVtbl = STRUCT('IDropTargetVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 DragEnter: PTR(UNEXPOSED),
 DragOver: PTR(UNEXPOSED),
 DragLeave: PTR(UNEXPOSED),
 Drop: PTR(UNEXPOSED)
});

var IDropSourceNotifyVtbl = STRUCT('IDropSourceNotifyVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 DragEnterTarget: PTR(UNEXPOSED),
 DragLeaveTarget: PTR(UNEXPOSED)
});

var OLEVERB = STRUCT('OLEVERB', {
 lVerb: LONG,
 lpszVerbName: LPOLESTR,
 fuFlags: DWORD,
 grfAttribs: DWORD
});

var IEnumOLEVERBVtbl = STRUCT('IEnumOLEVERBVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var IServiceProvider = STRUCT('IServiceProvider', {
 lpVtbl: PTR(IServiceProviderVtbl)
});

var IServiceProviderVtbl = STRUCT('IServiceProviderVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryService: PTR(UNEXPOSED)
});

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(VOIDPTR)
});

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(VOIDPTR)
});

var SAFEARR_BRECORD = STRUCT('SAFEARR_BRECORD', {
 Size: ULONG,
 aRecord: PTR(VOIDPTR)
});

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: ARRAY(SAFEARRAYBOUND,  1 )
});

var SAFEARRAY = STRUCT('SAFEARRAY', {
 cDims: USHORT,
 fFeatures: USHORT,
 cbElements: ULONG,
 cLocks: ULONG,
 pvData: PVOID,
 rgsabound: ARRAY(SAFEARRAYBOUND,  1 )
});


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: ARRAY(SAFEARRAYBOUND,  1 )
});

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(UNEXPOSED),
 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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetGuid: PTR(UNEXPOSED),
 SetTypeFlags: PTR(UNEXPOSED),
 SetDocString: PTR(UNEXPOSED),
 SetHelpContext: PTR(UNEXPOSED),
 SetVersion: PTR(UNEXPOSED),
 AddRefTypeInfo: PTR(UNEXPOSED),
 AddFuncDesc: PTR(UNEXPOSED),
 AddImplType: PTR(UNEXPOSED),
 SetImplTypeFlags: PTR(UNEXPOSED),
 SetAlignment: PTR(UNEXPOSED),
 SetSchema: PTR(UNEXPOSED),
 AddVarDesc: PTR(UNEXPOSED),
 SetFuncAndParamNames: PTR(UNEXPOSED),
 SetVarName: PTR(UNEXPOSED),
 SetTypeDescAlias: PTR(UNEXPOSED),
 DefineFuncAsDllEntry: PTR(UNEXPOSED),
 SetFuncDocString: PTR(UNEXPOSED),
 SetVarDocString: PTR(UNEXPOSED),
 SetFuncHelpContext: PTR(UNEXPOSED),
 SetVarHelpContext: PTR(UNEXPOSED),
 SetMops: PTR(UNEXPOSED),
 SetTypeIdldesc: PTR(UNEXPOSED),
 LayOut: PTR(UNEXPOSED)
});

var ICreateTypeInfo2Vtbl = STRUCT('ICreateTypeInfo2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetGuid: PTR(UNEXPOSED),
 SetTypeFlags: PTR(UNEXPOSED),
 SetDocString: PTR(UNEXPOSED),
 SetHelpContext: PTR(UNEXPOSED),
 SetVersion: PTR(UNEXPOSED),
 AddRefTypeInfo: PTR(UNEXPOSED),
 AddFuncDesc: PTR(UNEXPOSED),
 AddImplType: PTR(UNEXPOSED),
 SetImplTypeFlags: PTR(UNEXPOSED),
 SetAlignment: PTR(UNEXPOSED),
 SetSchema: PTR(UNEXPOSED),
 AddVarDesc: PTR(UNEXPOSED),
 SetFuncAndParamNames: PTR(UNEXPOSED),
 SetVarName: PTR(UNEXPOSED),
 SetTypeDescAlias: PTR(UNEXPOSED),
 DefineFuncAsDllEntry: PTR(UNEXPOSED),
 SetFuncDocString: PTR(UNEXPOSED),
 SetVarDocString: PTR(UNEXPOSED),
 SetFuncHelpContext: PTR(UNEXPOSED),
 SetVarHelpContext: PTR(UNEXPOSED),
 SetMops: PTR(UNEXPOSED),
 SetTypeIdldesc: PTR(UNEXPOSED),
 LayOut: PTR(UNEXPOSED),
 DeleteFuncDesc: PTR(UNEXPOSED),
 DeleteFuncDescByMemId: PTR(UNEXPOSED),
 DeleteVarDesc: PTR(UNEXPOSED),
 DeleteVarDescByMemId: PTR(UNEXPOSED),
 DeleteImplType: PTR(UNEXPOSED),
 SetCustData: PTR(UNEXPOSED),
 SetFuncCustData: PTR(UNEXPOSED),
 SetParamCustData: PTR(UNEXPOSED),
 SetVarCustData: PTR(UNEXPOSED),
 SetImplTypeCustData: PTR(UNEXPOSED),
 SetHelpStringContext: PTR(UNEXPOSED),
 SetFuncHelpStringContext: PTR(UNEXPOSED),
 SetVarHelpStringContext: PTR(UNEXPOSED),
 Invalidate: PTR(UNEXPOSED),
 SetName: PTR(UNEXPOSED)
});

var ICreateTypeLibVtbl = STRUCT('ICreateTypeLibVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateTypeInfo: PTR(UNEXPOSED),
 SetName: PTR(UNEXPOSED),
 SetVersion: PTR(UNEXPOSED),
 SetGuid: PTR(UNEXPOSED),
 SetDocString: PTR(UNEXPOSED),
 SetHelpFileName: PTR(UNEXPOSED),
 SetHelpContext: PTR(UNEXPOSED),
 SetLcid: PTR(UNEXPOSED),
 SetLibFlags: PTR(UNEXPOSED),
 SaveAllChanges: PTR(UNEXPOSED)
});

var ICreateTypeLib2Vtbl = STRUCT('ICreateTypeLib2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateTypeInfo: PTR(UNEXPOSED),
 SetName: PTR(UNEXPOSED),
 SetVersion: PTR(UNEXPOSED),
 SetGuid: PTR(UNEXPOSED),
 SetDocString: PTR(UNEXPOSED),
 SetHelpFileName: PTR(UNEXPOSED),
 SetHelpContext: PTR(UNEXPOSED),
 SetLcid: PTR(UNEXPOSED),
 SetLibFlags: PTR(UNEXPOSED),
 SaveAllChanges: PTR(UNEXPOSED),
 DeleteTypeInfo: PTR(UNEXPOSED),
 SetCustData: PTR(UNEXPOSED),
 SetHelpStringContext: PTR(UNEXPOSED),
 SetHelpStringDll: PTR(UNEXPOSED)
});

var IDispatchVtbl = STRUCT('IDispatchVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED)
});

var IEnumVARIANTVtbl = STRUCT('IEnumVARIANTVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var ITypeCompVtbl = STRUCT('ITypeCompVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Bind: PTR(UNEXPOSED),
 BindType: PTR(UNEXPOSED)
});

var ITypeInfoVtbl = STRUCT('ITypeInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeAttr: PTR(UNEXPOSED),
 GetTypeComp: PTR(UNEXPOSED),
 GetFuncDesc: PTR(UNEXPOSED),
 GetVarDesc: PTR(UNEXPOSED),
 GetNames: PTR(UNEXPOSED),
 GetRefTypeOfImplType: PTR(UNEXPOSED),
 GetImplTypeFlags: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 GetDocumentation: PTR(UNEXPOSED),
 GetDllEntry: PTR(UNEXPOSED),
 GetRefTypeInfo: PTR(UNEXPOSED),
 AddressOfMember: PTR(UNEXPOSED),
 CreateInstance: PTR(UNEXPOSED),
 GetMops: PTR(UNEXPOSED),
 GetContainingTypeLib: PTR(UNEXPOSED),
 ReleaseTypeAttr: PTR(UNEXPOSED),
 ReleaseFuncDesc: PTR(UNEXPOSED),
 ReleaseVarDesc: PTR(UNEXPOSED)
});

var ITypeInfo2Vtbl = STRUCT('ITypeInfo2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeAttr: PTR(UNEXPOSED),
 GetTypeComp: PTR(UNEXPOSED),
 GetFuncDesc: PTR(UNEXPOSED),
 GetVarDesc: PTR(UNEXPOSED),
 GetNames: PTR(UNEXPOSED),
 GetRefTypeOfImplType: PTR(UNEXPOSED),
 GetImplTypeFlags: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 GetDocumentation: PTR(UNEXPOSED),
 GetDllEntry: PTR(UNEXPOSED),
 GetRefTypeInfo: PTR(UNEXPOSED),
 AddressOfMember: PTR(UNEXPOSED),
 CreateInstance: PTR(UNEXPOSED),
 GetMops: PTR(UNEXPOSED),
 GetContainingTypeLib: PTR(UNEXPOSED),
 ReleaseTypeAttr: PTR(UNEXPOSED),
 ReleaseFuncDesc: PTR(UNEXPOSED),
 ReleaseVarDesc: PTR(UNEXPOSED),
 GetTypeKind: PTR(UNEXPOSED),
 GetTypeFlags: PTR(UNEXPOSED),
 GetFuncIndexOfMemId: PTR(UNEXPOSED),
 GetVarIndexOfMemId: PTR(UNEXPOSED),
 GetCustData: PTR(UNEXPOSED),
 GetFuncCustData: PTR(UNEXPOSED),
 GetParamCustData: PTR(UNEXPOSED),
 GetVarCustData: PTR(UNEXPOSED),
 GetImplTypeCustData: PTR(UNEXPOSED),
 GetDocumentation2: PTR(UNEXPOSED),
 GetAllCustData: PTR(UNEXPOSED),
 GetAllFuncCustData: PTR(UNEXPOSED),
 GetAllParamCustData: PTR(UNEXPOSED),
 GetAllVarCustData: PTR(UNEXPOSED),
 GetAllImplTypeCustData: PTR(UNEXPOSED)
});

var TLIBATTR = STRUCT('TLIBATTR', {
 guid: GUID,
 lcid: LCID,
 syskind: SYSKIND,
 wMajorVerNum: WORD,
 wMinorVerNum: WORD,
 wLibFlags: WORD
});

var ITypeLibVtbl = STRUCT('ITypeLibVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetTypeInfoType: PTR(UNEXPOSED),
 GetTypeInfoOfGuid: PTR(UNEXPOSED),
 GetLibAttr: PTR(UNEXPOSED),
 GetTypeComp: PTR(UNEXPOSED),
 GetDocumentation: PTR(UNEXPOSED),
 IsName: PTR(UNEXPOSED),
 FindName: PTR(UNEXPOSED),
 ReleaseTLibAttr: PTR(UNEXPOSED)
});

var ITypeLib2Vtbl = STRUCT('ITypeLib2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetTypeInfoType: PTR(UNEXPOSED),
 GetTypeInfoOfGuid: PTR(UNEXPOSED),
 GetLibAttr: PTR(UNEXPOSED),
 GetTypeComp: PTR(UNEXPOSED),
 GetDocumentation: PTR(UNEXPOSED),
 IsName: PTR(UNEXPOSED),
 FindName: PTR(UNEXPOSED),
 ReleaseTLibAttr: PTR(UNEXPOSED),
 GetCustData: PTR(UNEXPOSED),
 GetLibStatistics: PTR(UNEXPOSED),
 GetDocumentation2: PTR(UNEXPOSED),
 GetAllCustData: PTR(UNEXPOSED)
});

var ITypeChangeEventsVtbl = STRUCT('ITypeChangeEventsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 RequestTypeChange: PTR(UNEXPOSED),
 AfterTypeChange: PTR(UNEXPOSED)
});

var IErrorInfoVtbl = STRUCT('IErrorInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetGUID: PTR(UNEXPOSED),
 GetSource: PTR(UNEXPOSED),
 GetDescription: PTR(UNEXPOSED),
 GetHelpFile: PTR(UNEXPOSED),
 GetHelpContext: PTR(UNEXPOSED)
});

var ICreateErrorInfoVtbl = STRUCT('ICreateErrorInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetGUID: PTR(UNEXPOSED),
 SetSource: PTR(UNEXPOSED),
 SetDescription: PTR(UNEXPOSED),
 SetHelpFile: PTR(UNEXPOSED),
 SetHelpContext: PTR(UNEXPOSED)
});

var ISupportErrorInfoVtbl = STRUCT('ISupportErrorInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 InterfaceSupportsErrorInfo: PTR(UNEXPOSED)
});

var ITypeFactoryVtbl = STRUCT('ITypeFactoryVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateFromTypeInfo: PTR(UNEXPOSED)
});

var ITypeMarshalVtbl = STRUCT('ITypeMarshalVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Size: PTR(UNEXPOSED),
 Marshal: PTR(UNEXPOSED),
 Unmarshal: PTR(UNEXPOSED),
 Free: PTR(UNEXPOSED)
});

var IRecordInfoVtbl = STRUCT('IRecordInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 RecordInit: PTR(UNEXPOSED),
 RecordClear: PTR(UNEXPOSED),
 RecordCopy: PTR(UNEXPOSED),
 GetGuid: PTR(UNEXPOSED),
 GetName: PTR(UNEXPOSED),
 GetSize: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetField: PTR(UNEXPOSED),
 GetFieldNoCopy: PTR(UNEXPOSED),
 PutField: PTR(UNEXPOSED),
 PutFieldNoCopy: PTR(UNEXPOSED),
 GetFieldNames: PTR(UNEXPOSED),
 IsMatchingType: PTR(UNEXPOSED),
 RecordCreate: PTR(UNEXPOSED),
 RecordCreateCopy: PTR(UNEXPOSED),
 RecordDestroy: PTR(UNEXPOSED)
});

var IErrorLogVtbl = STRUCT('IErrorLogVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 AddError: PTR(UNEXPOSED)
});

var IPropertyBagVtbl = STRUCT('IPropertyBagVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Read: PTR(UNEXPOSED),
 Write: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 hasFeature: PTR(UNEXPOSED)
});

var IXMLDOMNodeVtbl = STRUCT('IXMLDOMNodeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED)
});

var IXMLDOMDocumentFragmentVtbl = STRUCT('IXMLDOMDocumentFragmentVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED)
});

var IXMLDOMDocumentVtbl = STRUCT('IXMLDOMDocumentVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_doctype: PTR(UNEXPOSED),
 get_implementation: PTR(UNEXPOSED),
 get_documentElement: PTR(UNEXPOSED),
 putref_documentElement: PTR(UNEXPOSED),
 createElement: PTR(UNEXPOSED),
 createDocumentFragment: PTR(UNEXPOSED),
 createTextNode: PTR(UNEXPOSED),
 createComment: PTR(UNEXPOSED),
 createCDATASection: PTR(UNEXPOSED),
 createProcessingInstruction: PTR(UNEXPOSED),
 createAttribute: PTR(UNEXPOSED),
 createEntityReference: PTR(UNEXPOSED),
 getElementsByTagName: PTR(UNEXPOSED),
 createNode: PTR(UNEXPOSED),
 nodeFromID: PTR(UNEXPOSED),
 load: PTR(UNEXPOSED),
 get_readyState: PTR(UNEXPOSED),
 get_parseError: PTR(UNEXPOSED),
 get_url: PTR(UNEXPOSED),
 get_async: PTR(UNEXPOSED),
 put_async: PTR(UNEXPOSED),
 abort: PTR(UNEXPOSED),
 loadXML: PTR(UNEXPOSED),
 save: PTR(UNEXPOSED),
 get_validateOnParse: PTR(UNEXPOSED),
 put_validateOnParse: PTR(UNEXPOSED),
 get_resolveExternals: PTR(UNEXPOSED),
 put_resolveExternals: PTR(UNEXPOSED),
 get_preserveWhiteSpace: PTR(UNEXPOSED),
 put_preserveWhiteSpace: PTR(UNEXPOSED),
 put_onreadystatechange: PTR(UNEXPOSED),
 put_ondataavailable: PTR(UNEXPOSED),
 put_ontransformnode: PTR(UNEXPOSED)
});

var IXMLDOMNodeListVtbl = STRUCT('IXMLDOMNodeListVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_item: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 nextNode: PTR(UNEXPOSED),
 reset: PTR(UNEXPOSED),
 get__newEnum: PTR(UNEXPOSED)
});

var IXMLDOMNamedNodeMapVtbl = STRUCT('IXMLDOMNamedNodeMapVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 getNamedItem: PTR(UNEXPOSED),
 setNamedItem: PTR(UNEXPOSED),
 removeNamedItem: PTR(UNEXPOSED),
 get_item: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 getQualifiedItem: PTR(UNEXPOSED),
 removeQualifiedItem: PTR(UNEXPOSED),
 nextNode: PTR(UNEXPOSED),
 reset: PTR(UNEXPOSED),
 get__newEnum: PTR(UNEXPOSED)
});

var IXMLDOMCharacterDataVtbl = STRUCT('IXMLDOMCharacterDataVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_data: PTR(UNEXPOSED),
 put_data: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 substringData: PTR(UNEXPOSED),
 appendData: PTR(UNEXPOSED),
 insertData: PTR(UNEXPOSED),
 deleteData: PTR(UNEXPOSED),
 replaceData: PTR(UNEXPOSED)
});

var IXMLDOMAttributeVtbl = STRUCT('IXMLDOMAttributeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_name: PTR(UNEXPOSED),
 get_value: PTR(UNEXPOSED),
 put_value: PTR(UNEXPOSED)
});

var IXMLDOMElementVtbl = STRUCT('IXMLDOMElementVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_tagName: PTR(UNEXPOSED),
 getAttribute: PTR(UNEXPOSED),
 setAttribute: PTR(UNEXPOSED),
 removeAttribute: PTR(UNEXPOSED),
 getAttributeNode: PTR(UNEXPOSED),
 setAttributeNode: PTR(UNEXPOSED),
 removeAttributeNode: PTR(UNEXPOSED),
 getElementsByTagName: PTR(UNEXPOSED),
 normalize: PTR(UNEXPOSED)
});

var IXMLDOMTextVtbl = STRUCT('IXMLDOMTextVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_data: PTR(UNEXPOSED),
 put_data: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 substringData: PTR(UNEXPOSED),
 appendData: PTR(UNEXPOSED),
 insertData: PTR(UNEXPOSED),
 deleteData: PTR(UNEXPOSED),
 replaceData: PTR(UNEXPOSED),
 splitText: PTR(UNEXPOSED)
});

var IXMLDOMCommentVtbl = STRUCT('IXMLDOMCommentVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_data: PTR(UNEXPOSED),
 put_data: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 substringData: PTR(UNEXPOSED),
 appendData: PTR(UNEXPOSED),
 insertData: PTR(UNEXPOSED),
 deleteData: PTR(UNEXPOSED),
 replaceData: PTR(UNEXPOSED)
});

var IXMLDOMProcessingInstructionVtbl = STRUCT('IXMLDOMProcessingInstructionVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_target: PTR(UNEXPOSED),
 get_data: PTR(UNEXPOSED),
 put_data: PTR(UNEXPOSED)
});

var IXMLDOMCDATASectionVtbl = STRUCT('IXMLDOMCDATASectionVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_data: PTR(UNEXPOSED),
 put_data: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 substringData: PTR(UNEXPOSED),
 appendData: PTR(UNEXPOSED),
 insertData: PTR(UNEXPOSED),
 deleteData: PTR(UNEXPOSED),
 replaceData: PTR(UNEXPOSED),
 splitText: PTR(UNEXPOSED)
});

var IXMLDOMDocumentTypeVtbl = STRUCT('IXMLDOMDocumentTypeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_name: PTR(UNEXPOSED),
 get_entities: PTR(UNEXPOSED),
 get_notations: PTR(UNEXPOSED)
});

var IXMLDOMNotationVtbl = STRUCT('IXMLDOMNotationVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_publicId: PTR(UNEXPOSED),
 get_systemId: PTR(UNEXPOSED)
});

var IXMLDOMEntityVtbl = STRUCT('IXMLDOMEntityVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 get_publicId: PTR(UNEXPOSED),
 get_systemId: PTR(UNEXPOSED),
 get_notationName: PTR(UNEXPOSED)
});

var IXMLDOMEntityReferenceVtbl = STRUCT('IXMLDOMEntityReferenceVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED)
});

var IXMLDOMParseErrorVtbl = STRUCT('IXMLDOMParseErrorVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_errorCode: PTR(UNEXPOSED),
 get_url: PTR(UNEXPOSED),
 get_reason: PTR(UNEXPOSED),
 get_srcText: PTR(UNEXPOSED),
 get_line: PTR(UNEXPOSED),
 get_linepos: PTR(UNEXPOSED),
 get_filepos: PTR(UNEXPOSED)
});

var IXTLRuntimeVtbl = STRUCT('IXTLRuntimeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_nodeName: PTR(UNEXPOSED),
 get_nodeValue: PTR(UNEXPOSED),
 put_nodeValue: PTR(UNEXPOSED),
 get_nodeType: PTR(UNEXPOSED),
 get_parentNode: PTR(UNEXPOSED),
 get_childNodes: PTR(UNEXPOSED),
 get_firstChild: PTR(UNEXPOSED),
 get_lastChild: PTR(UNEXPOSED),
 get_previousSibling: PTR(UNEXPOSED),
 get_nextSibling: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED),
 insertBefore: PTR(UNEXPOSED),
 replaceChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 appendChild: PTR(UNEXPOSED),
 hasChildNodes: PTR(UNEXPOSED),
 get_ownerDocument: PTR(UNEXPOSED),
 cloneNode: PTR(UNEXPOSED),
 get_nodeTypeString: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 get_specified: PTR(UNEXPOSED),
 get_definition: PTR(UNEXPOSED),
 get_nodeTypedValue: PTR(UNEXPOSED),
 put_nodeTypedValue: PTR(UNEXPOSED),
 get_dataType: PTR(UNEXPOSED),
 put_dataType: PTR(UNEXPOSED),
 get_xml: PTR(UNEXPOSED),
 transformNode: PTR(UNEXPOSED),
 selectNodes: PTR(UNEXPOSED),
 selectSingleNode: PTR(UNEXPOSED),
 get_parsed: PTR(UNEXPOSED),
 get_namespaceURI: PTR(UNEXPOSED),
 get_prefix: PTR(UNEXPOSED),
 get_baseName: PTR(UNEXPOSED),
 transformNodeToObject: PTR(UNEXPOSED),
 uniqueID: PTR(UNEXPOSED),
 depth: PTR(UNEXPOSED),
 childNumber: PTR(UNEXPOSED),
 ancestorChildNumber: PTR(UNEXPOSED),
 absoluteChildNumber: PTR(UNEXPOSED),
 formatIndex: PTR(UNEXPOSED),
 formatNumber: PTR(UNEXPOSED),
 formatDate: PTR(UNEXPOSED),
 formatTime: PTR(UNEXPOSED)
});

var XMLDOMDocumentEventsVtbl = STRUCT('XMLDOMDocumentEventsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED)
});

var IXMLHttpRequestVtbl = STRUCT('IXMLHttpRequestVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 open: PTR(UNEXPOSED),
 setRequestHeader: PTR(UNEXPOSED),
 getResponseHeader: PTR(UNEXPOSED),
 getAllResponseHeaders: PTR(UNEXPOSED),
 send: PTR(UNEXPOSED),
 abort: PTR(UNEXPOSED),
 get_status: PTR(UNEXPOSED),
 get_statusText: PTR(UNEXPOSED),
 get_responseXML: PTR(UNEXPOSED),
 get_responseText: PTR(UNEXPOSED),
 get_responseBody: PTR(UNEXPOSED),
 get_responseStream: PTR(UNEXPOSED),
 get_readyState: PTR(UNEXPOSED),
 put_onreadystatechange: PTR(UNEXPOSED)
});

var IXMLDSOControlVtbl = STRUCT('IXMLDSOControlVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_XMLDocument: PTR(UNEXPOSED),
 put_XMLDocument: PTR(UNEXPOSED),
 get_JavaDSOCompatible: PTR(UNEXPOSED),
 put_JavaDSOCompatible: PTR(UNEXPOSED),
 get_readyState: PTR(UNEXPOSED)
});

var IXMLElementCollectionVtbl = STRUCT('IXMLElementCollectionVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 put_length: PTR(UNEXPOSED),
 get_length: PTR(UNEXPOSED),
 get__newEnum: PTR(UNEXPOSED),
 item: PTR(UNEXPOSED)
});

var IXMLDocumentVtbl = STRUCT('IXMLDocumentVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_root: PTR(UNEXPOSED),
 get_fileSize: PTR(UNEXPOSED),
 get_fileModifiedDate: PTR(UNEXPOSED),
 get_fileUpdatedDate: PTR(UNEXPOSED),
 get_URL: PTR(UNEXPOSED),
 put_URL: PTR(UNEXPOSED),
 get_mimeType: PTR(UNEXPOSED),
 get_readyState: PTR(UNEXPOSED),
 get_charset: PTR(UNEXPOSED),
 put_charset: PTR(UNEXPOSED),
 get_version: PTR(UNEXPOSED),
 get_doctype: PTR(UNEXPOSED),
 get_dtdURL: PTR(UNEXPOSED),
 createElement: PTR(UNEXPOSED)
});

var IXMLDocument2Vtbl = STRUCT('IXMLDocument2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_root: PTR(UNEXPOSED),
 get_fileSize: PTR(UNEXPOSED),
 get_fileModifiedDate: PTR(UNEXPOSED),
 get_fileUpdatedDate: PTR(UNEXPOSED),
 get_URL: PTR(UNEXPOSED),
 put_URL: PTR(UNEXPOSED),
 get_mimeType: PTR(UNEXPOSED),
 get_readyState: PTR(UNEXPOSED),
 get_charset: PTR(UNEXPOSED),
 put_charset: PTR(UNEXPOSED),
 get_version: PTR(UNEXPOSED),
 get_doctype: PTR(UNEXPOSED),
 get_dtdURL: PTR(UNEXPOSED),
 createElement: PTR(UNEXPOSED),
 get_async: PTR(UNEXPOSED),
 put_async: PTR(UNEXPOSED)
});

var IXMLElementVtbl = STRUCT('IXMLElementVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_tagName: PTR(UNEXPOSED),
 put_tagName: PTR(UNEXPOSED),
 get_parent: PTR(UNEXPOSED),
 setAttribute: PTR(UNEXPOSED),
 getAttribute: PTR(UNEXPOSED),
 removeAttribute: PTR(UNEXPOSED),
 get_children: PTR(UNEXPOSED),
 get_type: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 addChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED)
});

var IXMLElement2Vtbl = STRUCT('IXMLElement2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_tagName: PTR(UNEXPOSED),
 put_tagName: PTR(UNEXPOSED),
 get_parent: PTR(UNEXPOSED),
 setAttribute: PTR(UNEXPOSED),
 getAttribute: PTR(UNEXPOSED),
 removeAttribute: PTR(UNEXPOSED),
 get_children: PTR(UNEXPOSED),
 get_type: PTR(UNEXPOSED),
 get_text: PTR(UNEXPOSED),
 put_text: PTR(UNEXPOSED),
 addChild: PTR(UNEXPOSED),
 removeChild: PTR(UNEXPOSED),
 get_attributes: PTR(UNEXPOSED)
});

var IXMLAttributeVtbl = STRUCT('IXMLAttributeVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetTypeInfoCount: PTR(UNEXPOSED),
 GetTypeInfo: PTR(UNEXPOSED),
 GetIDsOfNames: PTR(UNEXPOSED),
 Invoke: PTR(UNEXPOSED),
 get_name: PTR(UNEXPOSED),
 get_value: PTR(UNEXPOSED)
});

var IXMLErrorVtbl = STRUCT('IXMLErrorVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetErrorInfo: PTR(UNEXPOSED)
});

var IPersistMonikerVtbl = STRUCT('IPersistMonikerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetClassID: PTR(UNEXPOSED),
 IsDirty: PTR(UNEXPOSED),
 Load: PTR(UNEXPOSED),
 Save: PTR(UNEXPOSED),
 SaveCompleted: PTR(UNEXPOSED),
 GetCurMoniker: PTR(UNEXPOSED)
});

var IMonikerPropVtbl = STRUCT('IMonikerPropVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 PutProperty: PTR(UNEXPOSED)
});

var IBindProtocolVtbl = STRUCT('IBindProtocolVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateBinding: PTR(UNEXPOSED)
});

var IBindingVtbl = STRUCT('IBindingVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Abort: PTR(UNEXPOSED),
 Suspend: PTR(UNEXPOSED),
 Resume: PTR(UNEXPOSED),
 SetPriority: PTR(UNEXPOSED),
 GetPriority: PTR(UNEXPOSED),
 GetBindResult: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnStartBinding: PTR(UNEXPOSED),
 GetPriority: PTR(UNEXPOSED),
 OnLowResource: PTR(UNEXPOSED),
 OnProgress: PTR(UNEXPOSED),
 OnStopBinding: PTR(UNEXPOSED),
 GetBindInfo: PTR(UNEXPOSED),
 OnDataAvailable: PTR(UNEXPOSED),
 OnObjectAvailable: PTR(UNEXPOSED)
});

var IBindStatusCallbackExVtbl = STRUCT('IBindStatusCallbackExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 OnStartBinding: PTR(UNEXPOSED),
 GetPriority: PTR(UNEXPOSED),
 OnLowResource: PTR(UNEXPOSED),
 OnProgress: PTR(UNEXPOSED),
 OnStopBinding: PTR(UNEXPOSED),
 GetBindInfo: PTR(UNEXPOSED),
 OnDataAvailable: PTR(UNEXPOSED),
 OnObjectAvailable: PTR(UNEXPOSED),
 GetBindInfoEx: PTR(UNEXPOSED)
});

var IAuthenticateVtbl = STRUCT('IAuthenticateVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Authenticate: PTR(UNEXPOSED)
});

var AUTHENTICATEINFO = STRUCT('AUTHENTICATEINFO', {
 dwFlags: DWORD,
 dwReserved: DWORD
});

var IAuthenticateExVtbl = STRUCT('IAuthenticateExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Authenticate: PTR(UNEXPOSED),
 AuthenticateEx: PTR(UNEXPOSED)
});

var IHttpNegotiateVtbl = STRUCT('IHttpNegotiateVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 BeginningTransaction: PTR(UNEXPOSED),
 OnResponse: PTR(UNEXPOSED)
});

var IHttpNegotiate2Vtbl = STRUCT('IHttpNegotiate2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 BeginningTransaction: PTR(UNEXPOSED),
 OnResponse: PTR(UNEXPOSED),
 GetRootSecurityId: PTR(UNEXPOSED)
});

var IHttpNegotiate3Vtbl = STRUCT('IHttpNegotiate3Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 BeginningTransaction: PTR(UNEXPOSED),
 OnResponse: PTR(UNEXPOSED),
 GetRootSecurityId: PTR(UNEXPOSED),
 GetSerializedClientCertContext: PTR(UNEXPOSED)
});

var IWinInetFileStreamVtbl = STRUCT('IWinInetFileStreamVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetHandleForUnlock: PTR(UNEXPOSED),
 SetDeleteFile: PTR(UNEXPOSED)
});

var IWindowForBindingUIVtbl = STRUCT('IWindowForBindingUIVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED)
});

var ICodeInstallVtbl = STRUCT('ICodeInstallVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 OnCodeInstallProblem: PTR(UNEXPOSED)
});

var IUriVtbl = STRUCT('IUriVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetPropertyBSTR: PTR(UNEXPOSED),
 GetPropertyLength: PTR(UNEXPOSED),
 GetPropertyDWORD: PTR(UNEXPOSED),
 HasProperty: PTR(UNEXPOSED),
 GetAbsoluteUri: PTR(UNEXPOSED),
 GetAuthority: PTR(UNEXPOSED),
 GetDisplayUri: PTR(UNEXPOSED),
 GetDomain: PTR(UNEXPOSED),
 GetExtension: PTR(UNEXPOSED),
 GetFragment: PTR(UNEXPOSED),
 GetHost: PTR(UNEXPOSED),
 GetPassword: PTR(UNEXPOSED),
 GetPath: PTR(UNEXPOSED),
 GetPathAndQuery: PTR(UNEXPOSED),
 GetQuery: PTR(UNEXPOSED),
 GetRawUri: PTR(UNEXPOSED),
 GetSchemeName: PTR(UNEXPOSED),
 GetUserInfo: PTR(UNEXPOSED),
 GetUserNameA: PTR(UNEXPOSED),
 GetHostType: PTR(UNEXPOSED),
 GetPort: PTR(UNEXPOSED),
 GetScheme: PTR(UNEXPOSED),
 GetZone: PTR(UNEXPOSED),
 GetProperties: PTR(UNEXPOSED),
 IsEqual: PTR(UNEXPOSED)
});

var IUriContainerVtbl = STRUCT('IUriContainerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetIUri: PTR(UNEXPOSED)
});

var IUriBuilderVtbl = STRUCT('IUriBuilderVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateUriSimple: PTR(UNEXPOSED),
 CreateUri: PTR(UNEXPOSED),
 CreateUriWithFlags: PTR(UNEXPOSED),
 GetIUri: PTR(UNEXPOSED),
 SetIUri: PTR(UNEXPOSED),
 GetFragment: PTR(UNEXPOSED),
 GetHost: PTR(UNEXPOSED),
 GetPassword: PTR(UNEXPOSED),
 GetPath: PTR(UNEXPOSED),
 GetPort: PTR(UNEXPOSED),
 GetQuery: PTR(UNEXPOSED),
 GetSchemeName: PTR(UNEXPOSED),
 GetUserNameA: PTR(UNEXPOSED),
 SetFragment: PTR(UNEXPOSED),
 SetHost: PTR(UNEXPOSED),
 SetPassword: PTR(UNEXPOSED),
 SetPath: PTR(UNEXPOSED),
 SetPortA: PTR(UNEXPOSED),
 SetQuery: PTR(UNEXPOSED),
 SetSchemeName: PTR(UNEXPOSED),
 SetUserName: PTR(UNEXPOSED),
 RemoveProperties: PTR(UNEXPOSED),
 HasBeenModified: PTR(UNEXPOSED)
});

var IUriBuilderFactoryVtbl = STRUCT('IUriBuilderFactoryVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateIUriBuilder: PTR(UNEXPOSED),
 CreateInitializedIUriBuilder: PTR(UNEXPOSED)
});

var IWinInetInfoVtbl = STRUCT('IWinInetInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryOption: PTR(UNEXPOSED)
});

var IHttpSecurityVtbl = STRUCT('IHttpSecurityVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 OnSecurityProblem: PTR(UNEXPOSED)
});

var IWinInetHttpInfoVtbl = STRUCT('IWinInetHttpInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 QueryOption: PTR(UNEXPOSED),
 QueryInfo: PTR(UNEXPOSED)
});

var IWinInetCacheHintsVtbl = STRUCT('IWinInetCacheHintsVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetCacheExtension: PTR(UNEXPOSED)
});

var IWinInetCacheHints2Vtbl = STRUCT('IWinInetCacheHints2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetCacheExtension: PTR(UNEXPOSED),
 SetCacheExtension2: PTR(UNEXPOSED)
});

var IBindHostVtbl = STRUCT('IBindHostVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 CreateMoniker: PTR(UNEXPOSED),
 MonikerBindToStorage: PTR(UNEXPOSED),
 MonikerBindToObject: PTR(UNEXPOSED)
});

var IInternetVtbl = STRUCT('IInternetVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED)
});

var IInternetBindInfoVtbl = STRUCT('IInternetBindInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBindInfo: PTR(UNEXPOSED),
 GetBindString: PTR(UNEXPOSED)
});

var IInternetBindInfoExVtbl = STRUCT('IInternetBindInfoExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetBindInfo: PTR(UNEXPOSED),
 GetBindString: PTR(UNEXPOSED),
 GetBindInfoEx: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Start: PTR(UNEXPOSED),
 Continue: PTR(UNEXPOSED),
 Abort: PTR(UNEXPOSED),
 Terminate: PTR(UNEXPOSED),
 Suspend: PTR(UNEXPOSED),
 Resume: PTR(UNEXPOSED)
});

var IInternetProtocolVtbl = STRUCT('IInternetProtocolVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Start: PTR(UNEXPOSED),
 Continue: PTR(UNEXPOSED),
 Abort: PTR(UNEXPOSED),
 Terminate: PTR(UNEXPOSED),
 Suspend: PTR(UNEXPOSED),
 Resume: PTR(UNEXPOSED),
 Read: PTR(UNEXPOSED),
 Seek: PTR(UNEXPOSED),
 LockRequest: PTR(UNEXPOSED),
 UnlockRequest: PTR(UNEXPOSED)
});

var IInternetProtocolExVtbl = STRUCT('IInternetProtocolExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Start: PTR(UNEXPOSED),
 Continue: PTR(UNEXPOSED),
 Abort: PTR(UNEXPOSED),
 Terminate: PTR(UNEXPOSED),
 Suspend: PTR(UNEXPOSED),
 Resume: PTR(UNEXPOSED),
 Read: PTR(UNEXPOSED),
 Seek: PTR(UNEXPOSED),
 LockRequest: PTR(UNEXPOSED),
 UnlockRequest: PTR(UNEXPOSED),
 StartEx: PTR(UNEXPOSED)
});

var IInternetProtocolSinkVtbl = STRUCT('IInternetProtocolSinkVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Switch: PTR(UNEXPOSED),
 ReportProgress: PTR(UNEXPOSED),
 ReportData: PTR(UNEXPOSED),
 ReportResult: PTR(UNEXPOSED)
});

var IInternetProtocolSinkStackableVtbl = STRUCT('IInternetProtocolSinkStackableVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SwitchSink: PTR(UNEXPOSED),
 CommitSwitch: PTR(UNEXPOSED),
 RollbackSwitch: PTR(UNEXPOSED)
});

var IInternetSessionVtbl = STRUCT('IInternetSessionVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 RegisterNameSpace: PTR(UNEXPOSED),
 UnregisterNameSpace: PTR(UNEXPOSED),
 RegisterMimeFilter: PTR(UNEXPOSED),
 UnregisterMimeFilter: PTR(UNEXPOSED),
 CreateBinding: PTR(UNEXPOSED),
 SetSessionOption: PTR(UNEXPOSED),
 GetSessionOption: PTR(UNEXPOSED)
});

var IInternetThreadSwitchVtbl = STRUCT('IInternetThreadSwitchVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Prepare: PTR(UNEXPOSED),
 Continue: PTR(UNEXPOSED)
});

var IInternetPriorityVtbl = STRUCT('IInternetPriorityVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetPriority: PTR(UNEXPOSED),
 GetPriority: PTR(UNEXPOSED)
});

var IInternetProtocolInfoVtbl = STRUCT('IInternetProtocolInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ParseUrl: PTR(UNEXPOSED),
 CombineUrl: PTR(UNEXPOSED),
 CompareUrl: PTR(UNEXPOSED),
 QueryInfo: PTR(UNEXPOSED)
});

var IInternetSecurityMgrSiteVtbl = STRUCT('IInternetSecurityMgrSiteVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWindow: PTR(UNEXPOSED),
 EnableModeless: PTR(UNEXPOSED)
});

var IInternetSecurityManagerVtbl = STRUCT('IInternetSecurityManagerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetSecuritySite: PTR(UNEXPOSED),
 GetSecuritySite: PTR(UNEXPOSED),
 MapUrlToZone: PTR(UNEXPOSED),
 GetSecurityId: PTR(UNEXPOSED),
 ProcessUrlAction: PTR(UNEXPOSED),
 QueryCustomPolicy: PTR(UNEXPOSED),
 SetZoneMapping: PTR(UNEXPOSED),
 GetZoneMappings: PTR(UNEXPOSED)
});

var IInternetSecurityManagerExVtbl = STRUCT('IInternetSecurityManagerExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetSecuritySite: PTR(UNEXPOSED),
 GetSecuritySite: PTR(UNEXPOSED),
 MapUrlToZone: PTR(UNEXPOSED),
 GetSecurityId: PTR(UNEXPOSED),
 ProcessUrlAction: PTR(UNEXPOSED),
 QueryCustomPolicy: PTR(UNEXPOSED),
 SetZoneMapping: PTR(UNEXPOSED),
 GetZoneMappings: PTR(UNEXPOSED),
 ProcessUrlActionEx: PTR(UNEXPOSED)
});

var IInternetSecurityManagerEx2Vtbl = STRUCT('IInternetSecurityManagerEx2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 SetSecuritySite: PTR(UNEXPOSED),
 GetSecuritySite: PTR(UNEXPOSED),
 MapUrlToZone: PTR(UNEXPOSED),
 GetSecurityId: PTR(UNEXPOSED),
 ProcessUrlAction: PTR(UNEXPOSED),
 QueryCustomPolicy: PTR(UNEXPOSED),
 SetZoneMapping: PTR(UNEXPOSED),
 GetZoneMappings: PTR(UNEXPOSED),
 ProcessUrlActionEx: PTR(UNEXPOSED),
 MapUrlToZoneEx2: PTR(UNEXPOSED),
 ProcessUrlActionEx2: PTR(UNEXPOSED),
 GetSecurityIdEx2: PTR(UNEXPOSED),
 QueryCustomPolicyEx2: PTR(UNEXPOSED)
});

var IZoneIdentifierVtbl = STRUCT('IZoneIdentifierVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetId: PTR(UNEXPOSED),
 SetId: PTR(UNEXPOSED),
 Remove: PTR(UNEXPOSED)
});

var IInternetHostSecurityManagerVtbl = STRUCT('IInternetHostSecurityManagerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetSecurityId: PTR(UNEXPOSED),
 ProcessUrlAction: PTR(UNEXPOSED),
 QueryCustomPolicy: PTR(UNEXPOSED)
});

var ZONEATTRIBUTES = STRUCT('ZONEATTRIBUTES', {
 cbSize: ULONG,
 szDisplayName: ARRAY(WCHAR,  260 ),
 szDescription: ARRAY(WCHAR,  200 ),
 szIconPath: ARRAY(WCHAR,  260 ),
 dwTemplateMinLevel: DWORD,
 dwTemplateRecommended: DWORD,
 dwTemplateCurrentLevel: DWORD,
 dwFlags: DWORD
});

var IInternetZoneManagerVtbl = STRUCT('IInternetZoneManagerVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetZoneAttributes: PTR(UNEXPOSED),
 SetZoneAttributes: PTR(UNEXPOSED),
 GetZoneCustomPolicy: PTR(UNEXPOSED),
 SetZoneCustomPolicy: PTR(UNEXPOSED),
 GetZoneActionPolicy: PTR(UNEXPOSED),
 SetZoneActionPolicy: PTR(UNEXPOSED),
 PromptAction: PTR(UNEXPOSED),
 LogAction: PTR(UNEXPOSED),
 CreateZoneEnumerator: PTR(UNEXPOSED),
 GetZoneAt: PTR(UNEXPOSED),
 DestroyZoneEnumerator: PTR(UNEXPOSED),
 CopyTemplatePoliciesToZone: PTR(UNEXPOSED)
});

var IInternetZoneManagerExVtbl = STRUCT('IInternetZoneManagerExVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetZoneAttributes: PTR(UNEXPOSED),
 SetZoneAttributes: PTR(UNEXPOSED),
 GetZoneCustomPolicy: PTR(UNEXPOSED),
 SetZoneCustomPolicy: PTR(UNEXPOSED),
 GetZoneActionPolicy: PTR(UNEXPOSED),
 SetZoneActionPolicy: PTR(UNEXPOSED),
 PromptAction: PTR(UNEXPOSED),
 LogAction: PTR(UNEXPOSED),
 CreateZoneEnumerator: PTR(UNEXPOSED),
 GetZoneAt: PTR(UNEXPOSED),
 DestroyZoneEnumerator: PTR(UNEXPOSED),
 CopyTemplatePoliciesToZone: PTR(UNEXPOSED),
 GetZoneActionPolicyEx: PTR(UNEXPOSED),
 SetZoneActionPolicyEx: PTR(UNEXPOSED)
});

var IInternetZoneManagerEx2Vtbl = STRUCT('IInternetZoneManagerEx2Vtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetZoneAttributes: PTR(UNEXPOSED),
 SetZoneAttributes: PTR(UNEXPOSED),
 GetZoneCustomPolicy: PTR(UNEXPOSED),
 SetZoneCustomPolicy: PTR(UNEXPOSED),
 GetZoneActionPolicy: PTR(UNEXPOSED),
 SetZoneActionPolicy: PTR(UNEXPOSED),
 PromptAction: PTR(UNEXPOSED),
 LogAction: PTR(UNEXPOSED),
 CreateZoneEnumerator: PTR(UNEXPOSED),
 GetZoneAt: PTR(UNEXPOSED),
 DestroyZoneEnumerator: PTR(UNEXPOSED),
 CopyTemplatePoliciesToZone: PTR(UNEXPOSED),
 GetZoneActionPolicyEx: PTR(UNEXPOSED),
 SetZoneActionPolicyEx: PTR(UNEXPOSED),
 GetZoneAttributesEx: PTR(UNEXPOSED),
 GetZoneSecurityState: PTR(UNEXPOSED),
 GetIESecurityState: PTR(UNEXPOSED),
 FixUnsecureSettings: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ProcessSoftDist: PTR(UNEXPOSED),
 GetFirstCodeBase: PTR(UNEXPOSED),
 GetNextCodeBase: PTR(UNEXPOSED),
 AsyncInstallDistributionUnit: PTR(UNEXPOSED)
});

var ICatalogFileInfoVtbl = STRUCT('ICatalogFileInfoVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetCatalogFile: PTR(UNEXPOSED),
 GetJavaTrust: PTR(UNEXPOSED)
});

var IDataFilterVtbl = STRUCT('IDataFilterVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 DoEncode: PTR(UNEXPOSED),
 DoDecode: PTR(UNEXPOSED),
 SetEncodingLevel: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 FindBestFilter: PTR(UNEXPOSED),
 GetDefaultFilter: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetWrapperCode: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 ReadMultiple: PTR(UNEXPOSED),
 WriteMultiple: PTR(UNEXPOSED),
 DeleteMultiple: PTR(UNEXPOSED),
 ReadPropertyNames: PTR(UNEXPOSED),
 WritePropertyNames: PTR(UNEXPOSED),
 DeletePropertyNames: PTR(UNEXPOSED),
 Commit: PTR(UNEXPOSED),
 Revert: PTR(UNEXPOSED),
 Enum: PTR(UNEXPOSED),
 SetTimes: PTR(UNEXPOSED),
 SetClass: PTR(UNEXPOSED),
 Stat: PTR(UNEXPOSED)
});

var IPropertySetStorageVtbl = STRUCT('IPropertySetStorageVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Create: PTR(UNEXPOSED),
 Open: PTR(UNEXPOSED),
 Delete: PTR(UNEXPOSED),
 Enum: PTR(UNEXPOSED)
});

var IEnumSTATPROPSTGVtbl = STRUCT('IEnumSTATPROPSTGVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var IEnumSTATPROPSETSTGVtbl = STRUCT('IEnumSTATPROPSETSTGVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 Next: PTR(UNEXPOSED),
 Skip: PTR(UNEXPOSED),
 Reset: PTR(UNEXPOSED),
 Clone: PTR(UNEXPOSED)
});

var SERIALIZEDPROPERTYVALUE = STRUCT('SERIALIZEDPROPERTYVALUE', {
 dwType: DWORD,
 rgb: ARRAY(BYTE, 1)
});

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(UNEXPOSED),
 Put: PTR(UNEXPOSED)
});

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(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 InitDone: PTR(UNEXPOSED),
 SelectionChange: PTR(UNEXPOSED),
 HandleMessage: PTR(UNEXPOSED)
});

var IPrintDialogServices = STRUCT('IPrintDialogServices', {
 lpVtbl: PTR(IPrintDialogServicesVtbl)
});

var IPrintDialogServicesVtbl = STRUCT('IPrintDialogServicesVtbl', {
 QueryInterface: PTR(UNEXPOSED),
 AddRef: PTR(UNEXPOSED),
 Release: PTR(UNEXPOSED),
 GetCurrentDevMode: PTR(UNEXPOSED),
 GetCurrentPrinterName: PTR(UNEXPOSED),
 GetCurrentPortName: PTR(UNEXPOSED)
});

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(VOIDPTR),
 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(VOIDPTR),
 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: ARRAY(BYTE, 1)
});

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: ARRAY(BYTE, 1)
});

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: ARRAY(DWORD, 1)
});

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: ARRAY(CHAR, STYLE_DESCRIPTION_SIZE)
});

var STYLEBUFW = STRUCT('STYLEBUFW', {
 dwStyle: DWORD,
 szDescription: ARRAY(WCHAR, STYLE_DESCRIPTION_SIZE)
});

var IMEMENUITEMINFO = STRUCT('IMEMENUITEMINFO', {
 cbSize: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: DWORD,
 szString: ARRAY(CHAR, IMEMENUITEM_STRING_SIZE),
 hbmpItem: HBITMAP
});

var IMEMENUITEMINFOW = STRUCT('IMEMENUITEMINFOW', {
 cbSize: UINT,
 fType: UINT,
 fState: UINT,
 wID: UINT,
 hbmpChecked: HBITMAP,
 hbmpUnchecked: HBITMAP,
 dwItemData: DWORD,
 szString: ARRAY(WCHAR, IMEMENUITEM_STRING_SIZE),
 hbmpItem: HBITMAP
});

var IMECHARPOSITION = STRUCT('IMECHARPOSITION', {
 dwSize: DWORD,
 dwCharPos: DWORD,
 pt: POINT,
 cLineHeight: UINT,
 rcDocument: RECT
});
LIBRARY('windows', {
  _invalid_parameter_noinfo: [ VOID, {  } ],
  _invalid_parameter_noinfo_noreturn: [ VOID, {  } ],
  _invoke_watson: [ VOID, { uintptr_t: uintptr_t } ],
  _except_handler: [ EXCEPTION_DISPOSITION, { _ExceptionRecord: PTR(_EXCEPTION_RECORD), _EstablisherFrame: PTR(VOID), _ContextRecord: PTR(_CONTEXT), _DispatcherContext: PTR(VOID) } ],
  _exception_code: [ VOID, {  } ],
  _exception_info: [ VOID, {  } ],
  _abnormal_termination: [ VOID, {  } ],
  __pctype_func: [ VOID, {  } ],
  __pwctype_func: [ wctype_t, {  } ],
  _isctype: [ VOID, { _C: int, _Type: int } ],
  _isctype_l: [ VOID, { _C: int, _Type: int, _Locale: _locale_t } ],
  isalpha: [ VOID, { _C: int } ],
  _isalpha_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isupper: [ VOID, { _C: int } ],
  _isupper_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  islower: [ VOID, { _C: int } ],
  _islower_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isdigit: [ VOID, { _C: int } ],
  _isdigit_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isxdigit: [ VOID, { _C: int } ],
  _isxdigit_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isspace: [ VOID, { _C: int } ],
  _isspace_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  ispunct: [ VOID, { _C: int } ],
  _ispunct_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isalnum: [ VOID, { _C: int } ],
  _isalnum_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isprint: [ VOID, { _C: int } ],
  _isprint_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  isgraph: [ VOID, { _C: int } ],
  _isgraph_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  iscntrl: [ VOID, { _C: int } ],
  _iscntrl_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  toupper: [ VOID, { _C: int } ],
  tolower: [ VOID, { _C: int } ],
  _tolower: [ VOID, { _C: int } ],
  _tolower_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  _toupper: [ VOID, { _C: int } ],
  _toupper_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  __isascii: [ VOID, { _C: int } ],
  __toascii: [ VOID, { _C: int } ],
  __iscsymf: [ VOID, { _C: int } ],
  __iscsym: [ VOID, { _C: int } ],
  iswalpha: [ VOID, { _C: wint_t } ],
  _iswalpha_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswupper: [ VOID, { _C: wint_t } ],
  _iswupper_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswlower: [ VOID, { _C: wint_t } ],
  _iswlower_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswdigit: [ VOID, { _C: wint_t } ],
  _iswdigit_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswxdigit: [ VOID, { _C: wint_t } ],
  _iswxdigit_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswspace: [ VOID, { _C: wint_t } ],
  _iswspace_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswpunct: [ VOID, { _C: wint_t } ],
  _iswpunct_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswalnum: [ VOID, { _C: wint_t } ],
  _iswalnum_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswprint: [ VOID, { _C: wint_t } ],
  _iswprint_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswgraph: [ VOID, { _C: wint_t } ],
  _iswgraph_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswcntrl: [ VOID, { _C: wint_t } ],
  _iswcntrl_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  iswascii: [ VOID, { _C: wint_t } ],
  isleadbyte: [ VOID, { _C: int } ],
  _isleadbyte_l: [ VOID, { _C: int, _Locale: _locale_t } ],
  towupper: [ wint_t, { _C: wint_t } ],
  _towupper_l: [ wint_t, { _C: wint_t, _Locale: _locale_t } ],
  towlower: [ wint_t, { _C: wint_t } ],
  _towlower_l: [ wint_t, { _C: wint_t, _Locale: _locale_t } ],
  iswctype: [ VOID, { _C: wint_t, _Type: wctype_t } ],
  _iswctype_l: [ VOID, { _C: wint_t, _Type: wctype_t, _Locale: _locale_t } ],
  __iswcsymf: [ VOID, { _C: wint_t } ],
  _iswcsymf_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  __iswcsym: [ VOID, { _C: wint_t } ],
  _iswcsym_l: [ VOID, { _C: wint_t, _Locale: _locale_t } ],
  is_wctype: [ VOID, { _C: wint_t, _Type: wctype_t } ],
  ___mb_cur_max_func: [ VOID, {  } ],
  ___mb_cur_max_l_func: [ VOID, { _locale_t: _locale_t } ],
  PtrToPtr64: [ VOID, { p: PTR(VOID) } ],
  Ptr64ToPtr: [ VOID, { p: PTR(VOID) } ],
  HandleToHandle64: [ VOID, { h: PTR(VOID) } ],
  Handle64ToHandle: [ VOID, { h: PTR(VOID) } ],
  Int64ShllMod32: [ ULONGLONG, { Value: ULONGLONG, ShiftCount: DWORD } ],
  Int64ShraMod32: [ LONGLONG, { Value: LONGLONG, ShiftCount: DWORD } ],
  Int64ShrlMod32: [ ULONGLONG, { Value: ULONGLONG, ShiftCount: DWORD } ],
  _rotl: [ VOID, { _Val: uint, _Shift: int } ],
  _rotl64: [ VOID, { _Val: ulonglong, _Shift: int } ],
  _rotr: [ VOID, { _Val: uint, _Shift: int } ],
  _rotr64: [ VOID, { _Val: ulonglong, _Shift: int } ],
  _memccpy: [ VOID, { _Dst: PTR(VOID), _Src: PTR(VOID), _Val: int, _MaxCount: size_t } ],
  memchr: [ VOID, { _Buf: PTR(VOID), _Val: int, _MaxCount: size_t } ],
  _memicmp: [ VOID, { _Buf1: PTR(VOID), _Buf2: PTR(VOID), _Size: size_t } ],
  _memicmp_l: [ VOID, { _Buf1: PTR(VOID), _Buf2: PTR(VOID), _Size: size_t, _Locale: _locale_t } ],
  memcmp: [ VOID, { _Buf1: PTR(VOID), _Buf2: PTR(VOID), _Size: size_t } ],
  memcpy: [ VOID, { _Dst: PTR(VOID), _Src: PTR(VOID), _Size: size_t } ],
  memcpy_s: [ errno_t, { _Dst: PTR(VOID), _DstSize: rsize_t, _Src: PTR(VOID), _MaxCount: rsize_t } ],
  memset: [ VOID, { _Dst: PTR(VOID), _Val: int, _Size: size_t } ],
  memccpy: [ VOID, { _Dst: PTR(VOID), _Src: PTR(VOID), _Val: int, _Size: size_t } ],
  memicmp: [ VOID, { _Buf1: PTR(VOID), _Buf2: PTR(VOID), _Size: size_t } ],
  _strset_s: [ errno_t, { _Dst: PTR(int8), _DstSize: size_t, _Value: int } ],
  _strset: [ VOID, { _Dest: PTR(int8), _Value: int } ],
  strcpy_s: [ errno_t, { _Dst: PTR(int8), _SizeInBytes: rsize_t, _Src: PTR(int8) } ],
  strcpy: [ VOID, { _Dest: PTR(int8), _Source: PTR(int8) } ],
  strcat_s: [ errno_t, { _Dst: PTR(int8), _SizeInBytes: rsize_t, _Src: PTR(int8) } ],
  strcat: [ VOID, { _Dest: PTR(int8), _Source: PTR(int8) } ],
  strcmp: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  strlen: [ size_t, { _Str: PTR(int8) } ],
  strnlen: [ size_t, { _Str: PTR(int8), _MaxCount: size_t } ],
  strnlen_s: [ size_t, { _Str: PTR(int8), _MaxCount: size_t } ],
  memmove_s: [ errno_t, { _Dst: PTR(VOID), _DstSize: rsize_t, _Src: PTR(VOID), _MaxCount: rsize_t } ],
  memmove: [ VOID, { _Dst: PTR(VOID), _Src: PTR(VOID), _Size: size_t } ],
  _strdup: [ VOID, { _Src: PTR(int8) } ],
  strchr: [ VOID, { _Str: PTR(int8), _Val: int } ],
  _stricmp: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  _strcmpi: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  _stricmp_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _Locale: _locale_t } ],
  strcoll: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  _strcoll_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _Locale: _locale_t } ],
  _stricoll: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  _stricoll_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _Locale: _locale_t } ],
  _strncoll: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t } ],
  _strncoll_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  _strnicoll: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t } ],
  _strnicoll_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  strcspn: [ size_t, { _Str: PTR(int8), _Control: PTR(int8) } ],
  _strerror: [ VOID, { _ErrMsg: PTR(int8) } ],
  _strerror_s: [ errno_t, { _Buf: PTR(int8), _SizeInBytes: size_t, _ErrMsg: PTR(int8) } ],
  strerror: [ VOID, { int: int } ],
  strerror_s: [ errno_t, { _Buf: PTR(int8), _SizeInBytes: size_t, _ErrNum: int } ],
  _strlwr_s: [ errno_t, { _Str: PTR(int8), _Size: size_t } ],
  _strlwr: [ VOID, { _String: PTR(int8) } ],
  _strlwr_s_l: [ errno_t, { _Str: PTR(int8), _Size: size_t, _Locale: _locale_t } ],
  _strlwr_l: [ VOID, { _String: PTR(int8), _Locale: _locale_t } ],
  strncat_s: [ errno_t, { _Dst: PTR(int8), _SizeInBytes: rsize_t, _Src: PTR(int8), _MaxCount: rsize_t } ],
  strncat: [ VOID, { _Dest: PTR(int8), _Source: PTR(int8), _Count: size_t } ],
  strncmp: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t } ],
  _strnicmp: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t } ],
  _strnicmp_l: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  strncpy_s: [ errno_t, { _Dst: PTR(int8), _SizeInBytes: rsize_t, _Src: PTR(int8), _MaxCount: rsize_t } ],
  strncpy: [ VOID, { _Dest: PTR(int8), _Source: PTR(int8), _Count: size_t } ],
  _strnset_s: [ errno_t, { _Str: PTR(int8), _SizeInBytes: size_t, _Val: int, _MaxCount: size_t } ],
  _strnset: [ VOID, { _Dest: PTR(int8), _Val: int, _Count: size_t } ],
  strpbrk: [ VOID, { _Str: PTR(int8), _Control: PTR(int8) } ],
  strrchr: [ VOID, { _Str: PTR(int8), _Ch: int } ],
  _strrev: [ VOID, { _Str: PTR(int8) } ],
  strspn: [ size_t, { _Str: PTR(int8), _Control: PTR(int8) } ],
  strstr: [ VOID, { _Str: PTR(int8), _SubStr: PTR(int8) } ],
  strtok: [ VOID, { _Str: PTR(int8), _Delim: PTR(int8) } ],
  strtok_s: [ VOID, { _Str: PTR(int8), _Delim: PTR(int8), _Context: PTR(PTR(int8)) } ],
  _strupr_s: [ errno_t, { _Str: PTR(int8), _Size: size_t } ],
  _strupr: [ VOID, { _String: PTR(int8) } ],
  _strupr_s_l: [ errno_t, { _Str: PTR(int8), _Size: size_t, _Locale: _locale_t } ],
  _strupr_l: [ VOID, { _String: PTR(int8), _Locale: _locale_t } ],
  strxfrm: [ size_t, { _Dst: PTR(int8), _Src: PTR(int8), _MaxCount: size_t } ],
  _strxfrm_l: [ size_t, { _Dst: PTR(int8), _Src: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  strdup: [ VOID, { _Src: PTR(int8) } ],
  strcmpi: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  stricmp: [ VOID, { _Str1: PTR(int8), _Str2: PTR(int8) } ],
  strlwr: [ VOID, { _Str: PTR(int8) } ],
  strnicmp: [ VOID, { _Str1: PTR(int8), _Str: PTR(int8), _MaxCount: size_t } ],
  strnset: [ VOID, { _Str: PTR(int8), _Val: int, _MaxCount: size_t } ],
  strrev: [ VOID, { _Str: PTR(int8) } ],
  strset: [ VOID, { _Str: PTR(int8), _Val: int } ],
  strupr: [ VOID, { _Str: PTR(int8) } ],
  _wcsdup: [ wchar_t, { _Str: PTR(ushort) } ],
  wcscat_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: rsize_t, _Src: PTR(ushort) } ],
  wcscat: [ wchar_t, { _Dest: PTR(ushort), _Source: PTR(ushort) } ],
  wcschr: [ wchar_t, { _Str: PTR(ushort), _Ch: wchar_t } ],
  wcscmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  wcscpy_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: rsize_t, _Src: PTR(ushort) } ],
  wcscpy: [ wchar_t, { _Dest: PTR(ushort), _Source: PTR(ushort) } ],
  wcscspn: [ size_t, { _Str: PTR(ushort), _Control: PTR(ushort) } ],
  wcslen: [ size_t, { _Str: PTR(ushort) } ],
  wcsnlen: [ size_t, { _Src: PTR(ushort), _MaxCount: size_t } ],
  wcsnlen_s: [ size_t, { _Src: PTR(ushort), _MaxCount: size_t } ],
  wcsncat_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: rsize_t, _Src: PTR(ushort), _MaxCount: rsize_t } ],
  wcsncat: [ wchar_t, { _Dest: PTR(ushort), _Source: PTR(ushort), _Count: size_t } ],
  wcsncmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t } ],
  wcsncpy_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: rsize_t, _Src: PTR(ushort), _MaxCount: rsize_t } ],
  wcsncpy: [ wchar_t, { _Dest: PTR(ushort), _Source: PTR(ushort), _Count: size_t } ],
  wcspbrk: [ wchar_t, { _Str: PTR(ushort), _Control: PTR(ushort) } ],
  wcsrchr: [ wchar_t, { _Str: PTR(ushort), _Ch: wchar_t } ],
  wcsspn: [ size_t, { _Str: PTR(ushort), _Control: PTR(ushort) } ],
  wcsstr: [ wchar_t, { _Str: PTR(ushort), _SubStr: PTR(ushort) } ],
  wcstok: [ wchar_t, { _Str: PTR(ushort), _Delim: PTR(ushort) } ],
  wcstok_s: [ wchar_t, { _Str: PTR(ushort), _Delim: PTR(ushort), _Context: PTR(PTR(ushort)) } ],
  _wcserror: [ wchar_t, { _ErrNum: int } ],
  _wcserror_s: [ errno_t, { _Buf: PTR(ushort), _SizeInWords: size_t, _ErrNum: int } ],
  __wcserror: [ wchar_t, { _Str: PTR(ushort) } ],
  __wcserror_s: [ errno_t, { _Buffer: PTR(ushort), _SizeInWords: size_t, _ErrMsg: PTR(ushort) } ],
  _wcsicmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  _wcsicmp_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _Locale: _locale_t } ],
  _wcsnicmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t } ],
  _wcsnicmp_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t } ],
  _wcsnset_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: size_t, _Val: wchar_t, _MaxCount: size_t } ],
  _wcsnset: [ wchar_t, { _Str: PTR(ushort), _Val: wchar_t, _MaxCount: size_t } ],
  _wcsrev: [ wchar_t, { _Str: PTR(ushort) } ],
  _wcsset_s: [ errno_t, { _Dst: PTR(ushort), _SizeInWords: size_t, _Value: wchar_t } ],
  _wcsset: [ wchar_t, { _Str: PTR(ushort), _Val: wchar_t } ],
  _wcslwr_s: [ errno_t, { _Str: PTR(ushort), _SizeInWords: size_t } ],
  _wcslwr: [ wchar_t, { _String: PTR(ushort) } ],
  _wcslwr_s_l: [ errno_t, { _Str: PTR(ushort), _SizeInWords: size_t, _Locale: _locale_t } ],
  _wcslwr_l: [ wchar_t, { _String: PTR(ushort), _Locale: _locale_t } ],
  _wcsupr_s: [ errno_t, { _Str: PTR(ushort), _Size: size_t } ],
  _wcsupr: [ wchar_t, { _String: PTR(ushort) } ],
  _wcsupr_s_l: [ errno_t, { _Str: PTR(ushort), _Size: size_t, _Locale: _locale_t } ],
  _wcsupr_l: [ wchar_t, { _String: PTR(ushort), _Locale: _locale_t } ],
  wcsxfrm: [ size_t, { _Dst: PTR(ushort), _Src: PTR(ushort), _MaxCount: size_t } ],
  _wcsxfrm_l: [ size_t, { _Dst: PTR(ushort), _Src: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t } ],
  wcscoll: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  _wcscoll_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _Locale: _locale_t } ],
  _wcsicoll: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  _wcsicoll_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _Locale: _locale_t } ],
  _wcsncoll: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t } ],
  _wcsncoll_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t } ],
  _wcsnicoll: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t } ],
  _wcsnicoll_l: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t } ],
  wcsdup: [ wchar_t, { _Str: PTR(ushort) } ],
  wcsicmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  wcsnicmp: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort), _MaxCount: size_t } ],
  wcsnset: [ wchar_t, { _Str: PTR(ushort), _Val: wchar_t, _MaxCount: size_t } ],
  wcsrev: [ wchar_t, { _Str: PTR(ushort) } ],
  wcsset: [ wchar_t, { _Str: PTR(ushort), _Val: wchar_t } ],
  wcslwr: [ wchar_t, { _Str: PTR(ushort) } ],
  wcsupr: [ wchar_t, { _Str: PTR(ushort) } ],
  wcsicoll: [ VOID, { _Str1: PTR(ushort), _Str2: PTR(ushort) } ],
  InterlockedBitTestAndSet: [ BOOLEAN, { Base: PTR(long), Bit: LONG } ],
  InterlockedBitTestAndReset: [ BOOLEAN, { Base: PTR(long), Bit: LONG } ],
  InterlockedBitTestAndComplement: [ BOOLEAN, { Base: PTR(long), Bit: LONG } ],
  MemoryBarrier: [ VOID, {  } ],
  ReadPMC: [ DWORD64, { Counter: DWORD } ],
  ReadTimeStampCounter: [ DWORD64, {  } ],
  DbgRaiseAssertionFailure: [ VOID, {  } ],
  GetFiberData: [ PVOID, {  } ],
  GetCurrentFiber: [ PVOID, {  } ],
  RtlUnwind: [ VOID, { TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID } ],
  RtlInitializeSListHead: [ VOID, { ListHead: PSLIST_HEADER } ],
  RtlFirstEntrySList: [ PSINGLE_LIST_ENTRY, { ListHead: PTR(uint) } ],
  RtlInterlockedPopEntrySList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER } ],
  RtlInterlockedPushEntrySList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER, ListEntry: PSINGLE_LIST_ENTRY } ],
  RtlInterlockedFlushSList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER } ],
  RtlQueryDepthSList: [ WORD, { ListHead: PSLIST_HEADER } ],
  RtlRunOnceInitialize: [ VOID, { RunOnce: PRTL_RUN_ONCE } ],
  RtlRunOnceExecuteOnce: [ DWORD, { RunOnce: PRTL_RUN_ONCE, InitFn: PRTL_RUN_ONCE_INIT_FN, Parameter: PVOID, Context: PTR(PTR(VOID)) } ],
  RtlRunOnceBeginInitialize: [ DWORD, { RunOnce: PRTL_RUN_ONCE, Flags: DWORD, Context: PTR(PTR(VOID)) } ],
  RtlRunOnceComplete: [ DWORD, { RunOnce: PRTL_RUN_ONCE, Flags: DWORD, Context: PVOID } ],
  HEAP_MAKE_TAG_FLAGS: [ DWORD, { TagBase: DWORD, Tag: DWORD } ],
  RtlCaptureStackBackTrace: [ WORD, { FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: PTR(PTR(VOID)), BackTraceHash: PDWORD } ],
  RtlCaptureContext: [ VOID, { ContextRecord: PCONTEXT } ],
  RtlCompareMemory: [ SIZE_T, { Source1: PTR(VOID), Source2: PTR(VOID), Length: SIZE_T } ],
  RtlSecureZeroMemory: [ PVOID, { ptr: PVOID, cnt: SIZE_T } ],
  RtlPcToFileHeader: [ PVOID, { PcValue: PVOID, BaseOfImage: PTR(PTR(VOID)) } ],
  VerSetConditionMask: [ ULONGLONG, { ConditionMask: ULONGLONG, TypeMask: DWORD, Condition: BYTE } ],
  RtlGetProductInfo: [ BOOLEAN, { OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, ReturnedProductType: PDWORD } ],
  RtlCopyExtendedContext: [ DWORD, { Destination: PCONTEXT_EX, ContextFlags: DWORD, Source: PCONTEXT_EX } ],
  RtlInitializeExtendedContext: [ DWORD, { Context: PVOID, ContextFlags: DWORD, ContextEx: PTR(VOIDPTR) } ],
  RtlGetEnabledExtendedFeatures: [ DWORD64, { FeatureMask: DWORD64 } ],
  RtlGetExtendedContextLength: [ DWORD, { ContextFlags: DWORD, ContextLength: PDWORD } ],
  RtlGetExtendedFeaturesMask: [ DWORD64, { ContextEx: PCONTEXT_EX } ],
  RtlLocateExtendedFeature: [ PVOID, { ContextEx: PCONTEXT_EX, FeatureId: DWORD, Length: PDWORD } ],
  RtlLocateLegacyContext: [ PCONTEXT, { ContextEx: PCONTEXT_EX, Length: PDWORD } ],
  RtlSetExtendedFeaturesMask: [ VOID, { ContextEx: PCONTEXT_EX, FeatureMask: DWORD64 } ],
  TpInitializeCallbackEnviron: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON } ],
  TpSetCallbackThreadpool: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, Pool: PTP_POOL } ],
  TpSetCallbackCleanupGroup: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, CleanupGroup: PTP_CLEANUP_GROUP, CleanupGroupCancelCallback: PTP_CLEANUP_GROUP_CANCEL_CALLBACK } ],
  TpSetCallbackActivationContext: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, ActivationContext: PTR(_ACTIVATION_CONTEXT) } ],
  TpSetCallbackNoActivationContext: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON } ],
  TpSetCallbackLongFunction: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON } ],
  TpSetCallbackRaceWithDll: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, DllHandle: PVOID } ],
  TpSetCallbackFinalizationCallback: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, FinalizationCallback: PTP_SIMPLE_CALLBACK } ],
  TpSetCallbackPriority: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON, Priority: TP_CALLBACK_PRIORITY } ],
  TpSetCallbackPersistent: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON } ],
  TpDestroyCallbackEnviron: [ VOID, { CallbackEnviron: PTP_CALLBACK_ENVIRON } ],
  NtCurrentTeb: [ struct _TEB, {  } ],
  InitOnceInitialize: [ VOID, { InitOnce: PINIT_ONCE } ],
  InitOnceExecuteOnce: [ BOOL, { InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: PTR(PTR(VOID)) } ],
  InitOnceBeginInitialize: [ BOOL, { lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: PTR(PTR(VOID)) } ],
  InitOnceComplete: [ BOOL, { lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID } ],
  InitializeSRWLock: [ VOID, { SRWLock: PSRWLOCK } ],
  ReleaseSRWLockExclusive: [ VOID, { SRWLock: PSRWLOCK } ],
  ReleaseSRWLockShared: [ VOID, { SRWLock: PSRWLOCK } ],
  AcquireSRWLockExclusive: [ VOID, { SRWLock: PSRWLOCK } ],
  AcquireSRWLockShared: [ VOID, { SRWLock: PSRWLOCK } ],
  TryAcquireSRWLockExclusive: [ BOOLEAN, { SRWLock: PSRWLOCK } ],
  TryAcquireSRWLockShared: [ BOOLEAN, { SRWLock: PSRWLOCK } ],
  InitializeConditionVariable: [ VOID, { ConditionVariable: PCONDITION_VARIABLE } ],
  WakeConditionVariable: [ VOID, { ConditionVariable: PCONDITION_VARIABLE } ],
  WakeAllConditionVariable: [ VOID, { ConditionVariable: PCONDITION_VARIABLE } ],
  SleepConditionVariableCS: [ BOOL, { ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION, dwMilliseconds: DWORD } ],
  SleepConditionVariableSRW: [ BOOL, { ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD, Flags: ULONG } ],
  EncodePointer: [ PVOID, { Ptr: PVOID } ],
  DecodePointer: [ PVOID, { Ptr: PVOID } ],
  EncodeSystemPointer: [ PVOID, { Ptr: PVOID } ],
  DecodeSystemPointer: [ PVOID, { Ptr: PVOID } ],
  InterlockedIncrement: [ LONG, { lpAddend: PTR(long) } ],
  InterlockedDecrement: [ LONG, { lpAddend: PTR(long) } ],
  InterlockedExchange: [ LONG, { Target: PTR(long), Value: LONG } ],
  InterlockedExchangeAdd: [ LONG, { Addend: PTR(long), Value: LONG } ],
  InterlockedCompareExchange: [ LONG, { Destination: PTR(long), Exchange: LONG, Comperand: LONG } ],
  InterlockedCompareExchange64: [ LONGLONG, { Destination: PTR(longlong), Exchange: LONGLONG, Comperand: LONGLONG } ],
  InterlockedAnd64: [ LONGLONG, { Destination: PTR(longlong), Value: LONGLONG } ],
  InterlockedOr64: [ LONGLONG, { Destination: PTR(longlong), Value: LONGLONG } ],
  InterlockedXor64: [ LONGLONG, { Destination: PTR(longlong), Value: LONGLONG } ],
  InterlockedIncrement64: [ LONGLONG, { Addend: PTR(longlong) } ],
  InterlockedDecrement64: [ LONGLONG, { Addend: PTR(longlong) } ],
  InterlockedExchange64: [ LONGLONG, { Target: PTR(longlong), Value: LONGLONG } ],
  InterlockedExchangeAdd64: [ LONGLONG, { Addend: PTR(longlong), Value: LONGLONG } ],
  InitializeSListHead: [ VOID, { ListHead: PSLIST_HEADER } ],
  InterlockedPopEntrySList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER } ],
  InterlockedPushEntrySList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER, ListEntry: PSINGLE_LIST_ENTRY } ],
  InterlockedFlushSList: [ PSINGLE_LIST_ENTRY, { ListHead: PSLIST_HEADER } ],
  QueryDepthSList: [ USHORT, { ListHead: PSLIST_HEADER } ],
  FreeResource: [ BOOL, { hResData: HGLOBAL } ],
  LockResource: [ LPVOID, { hResData: HGLOBAL } ],
  WinMain: [ VOID, { hInstance: HINSTANCE, hPrevInstance: HINSTANCE, lpCmdLine: LPSTR, nShowCmd: int } ],
  wWinMain: [ VOID, { hInstance: HINSTANCE, hPrevInstance: HINSTANCE, lpCmdLine: LPWSTR, nShowCmd: int } ],
  FreeLibrary: [ BOOL, { hLibModule: HMODULE } ],
  FreeLibraryAndExitThread: [ VOID, { hLibModule: HMODULE, dwExitCode: DWORD } ],
  DisableThreadLibraryCalls: [ BOOL, { hLibModule: HMODULE } ],
  GetProcAddress: [ FARPROC, { hModule: HMODULE, lpProcName: LPCSTR } ],
  GetVersion: [ DWORD, {  } ],
  GlobalAlloc: [ HGLOBAL, { uFlags: UINT, dwBytes: SIZE_T } ],
  GlobalReAlloc: [ HGLOBAL, { hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT } ],
  GlobalSize: [ SIZE_T, { hMem: HGLOBAL } ],
  GlobalFlags: [ UINT, { hMem: HGLOBAL } ],
  GlobalLock: [ LPVOID, { hMem: HGLOBAL } ],
  GlobalHandle: [ HGLOBAL, { pMem: LPCVOID } ],
  GlobalUnlock: [ BOOL, { hMem: HGLOBAL } ],
  GlobalFree: [ HGLOBAL, { hMem: HGLOBAL } ],
  GlobalCompact: [ SIZE_T, { dwMinFree: DWORD } ],
  GlobalFix: [ VOID, { hMem: HGLOBAL } ],
  GlobalUnfix: [ VOID, { hMem: HGLOBAL } ],
  GlobalWire: [ LPVOID, { hMem: HGLOBAL } ],
  GlobalUnWire: [ BOOL, { hMem: HGLOBAL } ],
  GlobalMemoryStatus: [ VOID, { lpBuffer: LPMEMORYSTATUS } ],
  GlobalMemoryStatusEx: [ BOOL, { lpBuffer: LPMEMORYSTATUSEX } ],
  LocalAlloc: [ HLOCAL, { uFlags: UINT, uBytes: SIZE_T } ],
  LocalReAlloc: [ HLOCAL, { hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT } ],
  LocalLock: [ LPVOID, { hMem: HLOCAL } ],
  LocalHandle: [ HLOCAL, { pMem: LPCVOID } ],
  LocalUnlock: [ BOOL, { hMem: HLOCAL } ],
  LocalSize: [ SIZE_T, { hMem: HLOCAL } ],
  LocalFlags: [ UINT, { hMem: HLOCAL } ],
  LocalFree: [ HLOCAL, { hMem: HLOCAL } ],
  LocalShrink: [ SIZE_T, { hMem: HLOCAL, cbNewSize: UINT } ],
  LocalCompact: [ SIZE_T, { uMinFree: UINT } ],
  FlushInstructionCache: [ BOOL, { hProcess: HANDLE, lpBaseAddress: LPCVOID, dwSize: SIZE_T } ],
  FlushProcessWriteBuffers: [ VOID, {  } ],
  QueryThreadCycleTime: [ BOOL, { ThreadHandle: HANDLE, CycleTime: PULONG64 } ],
  QueryProcessCycleTime: [ BOOL, { ProcessHandle: HANDLE, CycleTime: PULONG64 } ],
  QueryIdleProcessorCycleTime: [ BOOL, { BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64 } ],
  QueryIdleProcessorCycleTimeEx: [ BOOL, { Group: USHORT, BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64 } ],
  QueryUnbiasedInterruptTime: [ BOOL, { UnbiasedTime: PULONGLONG } ],
  GetProcessorSystemCycleTime: [ BOOL, { Group: USHORT, Buffer: PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, ReturnedLength: PDWORD } ],
  VirtualAlloc: [ LPVOID, { lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD } ],
  VirtualFree: [ BOOL, { lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD } ],
  VirtualProtect: [ BOOL, { lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD } ],
  VirtualQuery: [ SIZE_T, { lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T } ],
  VirtualAllocEx: [ LPVOID, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD } ],
  VirtualAllocExNuma: [ LPVOID, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD } ],
  GetWriteWatch: [ UINT, { dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: PTR(PTR(VOID)), lpdwCount: PTR(ulong), lpdwGranularity: PULONG } ],
  ResetWriteWatch: [ UINT, { lpBaseAddress: LPVOID, dwRegionSize: SIZE_T } ],
  GetLargePageMinimum: [ SIZE_T, {  } ],
  EnumSystemFirmwareTables: [ UINT, { FirmwareTableProviderSignature: DWORD, pFirmwareTableEnumBuffer: PVOID, BufferSize: DWORD } ],
  GetSystemFirmwareTable: [ UINT, { FirmwareTableProviderSignature: DWORD, FirmwareTableID: DWORD, pFirmwareTableBuffer: PVOID, BufferSize: DWORD } ],
  GetPhysicallyInstalledSystemMemory: [ BOOL, { TotalMemoryInKilobytes: PULONGLONG } ],
  VirtualFreeEx: [ BOOL, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD } ],
  VirtualProtectEx: [ BOOL, { hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD } ],
  VirtualQueryEx: [ SIZE_T, { hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T } ],
  HeapCreate: [ HANDLE, { flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T } ],
  HeapDestroy: [ BOOL, { hHeap: HANDLE } ],
  HeapAlloc: [ LPVOID, { hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T } ],
  HeapReAlloc: [ LPVOID, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T } ],
  HeapFree: [ BOOL, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID } ],
  HeapSize: [ SIZE_T, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID } ],
  HeapValidate: [ BOOL, { hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID } ],
  HeapCompact: [ SIZE_T, { hHeap: HANDLE, dwFlags: DWORD } ],
  GetProcessHeap: [ HANDLE, {  } ],
  GetProcessHeaps: [ DWORD, { NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE } ],
  HeapLock: [ BOOL, { hHeap: HANDLE } ],
  HeapUnlock: [ BOOL, { hHeap: HANDLE } ],
  HeapWalk: [ BOOL, { hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY } ],
  HeapSetInformation: [ BOOL, { HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T } ],
  HeapQueryInformation: [ BOOL, { HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID, HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T } ],
  GetBinaryTypeA: [ BOOL, { lpApplicationName: LPCSTR, lpBinaryType: LPDWORD } ],
  GetBinaryTypeW: [ BOOL, { lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD } ],
  GetShortPathNameA: [ DWORD, { lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD } ],
  GetShortPathNameW: [ DWORD, { lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD } ],
  GetLongPathNameA: [ DWORD, { lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD } ],
  GetLongPathNameW: [ DWORD, { lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD } ],
  GetLongPathNameTransactedA: [ DWORD, { lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE } ],
  GetLongPathNameTransactedW: [ DWORD, { lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE } ],
  GetProcessAffinityMask: [ BOOL, { hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR } ],
  SetProcessAffinityMask: [ BOOL, { hProcess: HANDLE, dwProcessAffinityMask: DWORD_PTR } ],
  GetProcessGroupAffinity: [ BOOL, { hProcess: HANDLE, GroupCount: PUSHORT, GroupArray: PUSHORT } ],
  GetProcessHandleCount: [ BOOL, { hProcess: HANDLE, pdwHandleCount: PDWORD } ],
  GetProcessTimes: [ BOOL, { hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME } ],
  GetProcessIoCounters: [ BOOL, { hProcess: HANDLE, lpIoCounters: PIO_COUNTERS } ],
  GetProcessWorkingSetSize: [ BOOL, { hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T } ],
  GetProcessWorkingSetSizeEx: [ BOOL, { hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD } ],
  SetProcessWorkingSetSize: [ BOOL, { hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T } ],
  SetProcessWorkingSetSizeEx: [ BOOL, { hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD } ],
  SetProcessAffinityUpdateMode: [ BOOL, { hProcess: HANDLE, dwFlags: DWORD } ],
  QueryProcessAffinityUpdateMode: [ BOOL, { hProcess: HANDLE, lpdwFlags: LPDWORD } ],
  OpenProcess: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwProcessId: DWORD } ],
  GetCurrentProcess: [ HANDLE, {  } ],
  GetCurrentProcessId: [ DWORD, {  } ],
  ExitProcess: [ VOID, { uExitCode: UINT } ],
  TerminateProcess: [ BOOL, { hProcess: HANDLE, uExitCode: UINT } ],
  GetExitCodeProcess: [ BOOL, { hProcess: HANDLE, lpExitCode: LPDWORD } ],
  FatalExit: [ VOID, { ExitCode: int } ],
  GetEnvironmentStrings: [ LPCH, {  } ],
  GetEnvironmentStringsW: [ LPWCH, {  } ],
  SetEnvironmentStringsA: [ BOOL, { NewEnvironment: LPCH } ],
  SetEnvironmentStringsW: [ BOOL, { NewEnvironment: LPWCH } ],
  FreeEnvironmentStringsA: [ BOOL, { LPCH: LPCH } ],
  FreeEnvironmentStringsW: [ BOOL, { LPWCH: LPWCH } ],
  RaiseException: [ VOID, { dwExceptionCode: DWORD, dwExceptionFlags: DWORD, nNumberOfArguments: DWORD, lpArguments: PTR(ulong) } ],
  RaiseFailFastException: [ VOID, { pExceptionRecord: PEXCEPTION_RECORD, pContextRecord: PCONTEXT, dwFlags: DWORD } ],
  UnhandledExceptionFilter: [ LONG, { ExceptionInfo: PTR(EXCEPTION_POINTERS) } ],
  SetUnhandledExceptionFilter: [ LPTOP_LEVEL_EXCEPTION_FILTER, { lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER } ],
  CreateFiber: [ LPVOID, { dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID } ],
  CreateFiberEx: [ LPVOID, { dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID } ],
  DeleteFiber: [ VOID, { lpFiber: LPVOID } ],
  ConvertThreadToFiber: [ LPVOID, { lpParameter: LPVOID } ],
  ConvertThreadToFiberEx: [ LPVOID, { lpParameter: LPVOID, dwFlags: DWORD } ],
  ConvertFiberToThread: [ BOOL, {  } ],
  IsThreadAFiber: [ BOOL, {  } ],
  SwitchToFiber: [ VOID, { lpFiber: LPVOID } ],
  SwitchToThread: [ BOOL, {  } ],
  CreateUmsCompletionList: [ BOOL, { UmsCompletionList: PTR(PTR(VOID)) } ],
  DequeueUmsCompletionListItems: [ BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: PTR(PTR(VOID)) } ],
  GetUmsCompletionListEvent: [ BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE } ],
  ExecuteUmsThread: [ BOOL, { UmsThread: PUMS_CONTEXT } ],
  UmsThreadYield: [ BOOL, { SchedulerParam: PVOID } ],
  DeleteUmsCompletionList: [ BOOL, { UmsCompletionList: PUMS_COMPLETION_LIST } ],
  GetCurrentUmsThread: [ PUMS_CONTEXT, {  } ],
  GetNextUmsListItem: [ PUMS_CONTEXT, { UmsContext: PUMS_CONTEXT } ],
  QueryUmsThreadInformation: [ BOOL, { UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG } ],
  SetUmsThreadInformation: [ BOOL, { UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG } ],
  DeleteUmsThreadContext: [ BOOL, { UmsThread: PUMS_CONTEXT } ],
  CreateUmsThreadContext: [ BOOL, { lpUmsThread: PTR(PTR(VOID)) } ],
  EnterUmsSchedulingMode: [ BOOL, { SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO } ],
  CreateThread: [ HANDLE, { lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD } ],
  CreateRemoteThread: [ HANDLE, { hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD } ],
  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 } ],
  GetCurrentThread: [ HANDLE, {  } ],
  GetCurrentThreadId: [ DWORD, {  } ],
  SetThreadStackGuarantee: [ BOOL, { StackSizeInBytes: PULONG } ],
  GetProcessIdOfThread: [ DWORD, { Thread: HANDLE } ],
  GetThreadId: [ DWORD, { Thread: HANDLE } ],
  GetProcessId: [ DWORD, { Process: HANDLE } ],
  GetCurrentProcessorNumber: [ DWORD, {  } ],
  GetCurrentProcessorNumberEx: [ VOID, { ProcNumber: PPROCESSOR_NUMBER } ],
  GetThreadGroupAffinity: [ BOOL, { hThread: HANDLE, GroupAffinity: PGROUP_AFFINITY } ],
  SetThreadAffinityMask: [ DWORD_PTR, { hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR } ],
  SetThreadGroupAffinity: [ BOOL, { hThread: HANDLE, GroupAffinity: PTR(uint), PreviousGroupAffinity: PGROUP_AFFINITY } ],
  SetThreadIdealProcessorEx: [ BOOL, { hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER, lpPreviousIdealProcessor: PPROCESSOR_NUMBER } ],
  GetThreadIdealProcessorEx: [ BOOL, { hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER } ],
  SetThreadIdealProcessor: [ DWORD, { hThread: HANDLE, dwIdealProcessor: DWORD } ],
  SetProcessDEPPolicy: [ BOOL, { dwFlags: DWORD } ],
  GetProcessDEPPolicy: [ BOOL, { hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL } ],
  SetProcessPriorityBoost: [ BOOL, { hProcess: HANDLE, bDisablePriorityBoost: BOOL } ],
  GetProcessPriorityBoost: [ BOOL, { hProcess: HANDLE, pDisablePriorityBoost: PBOOL } ],
  RequestWakeupLatency: [ BOOL, { latency: LATENCY_TIME } ],
  IsSystemResumeAutomatic: [ BOOL, {  } ],
  OpenThread: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwThreadId: DWORD } ],
  SetThreadPriority: [ BOOL, { hThread: HANDLE, nPriority: int } ],
  SetThreadPriorityBoost: [ BOOL, { hThread: HANDLE, bDisablePriorityBoost: BOOL } ],
  GetThreadPriorityBoost: [ BOOL, { hThread: HANDLE, pDisablePriorityBoost: PBOOL } ],
  GetThreadPriority: [ VOID, { hThread: HANDLE } ],
  GetThreadTimes: [ BOOL, { hThread: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME } ],
  GetThreadIOPendingFlag: [ BOOL, { hThread: HANDLE, lpIOIsPending: PBOOL } ],
  ExitThread: [ VOID, { dwExitCode: DWORD } ],
  TerminateThread: [ BOOL, { hThread: HANDLE, dwExitCode: DWORD } ],
  GetExitCodeThread: [ BOOL, { hThread: HANDLE, lpExitCode: LPDWORD } ],
  GetThreadSelectorEntry: [ BOOL, { hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY } ],
  SetThreadExecutionState: [ EXECUTION_STATE, { esFlags: EXECUTION_STATE } ],
  PowerCreateRequest: [ HANDLE, { Context: PREASON_CONTEXT } ],
  PowerSetRequest: [ BOOL, { PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE } ],
  PowerClearRequest: [ BOOL, { PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE } ],
  GetLastError: [ DWORD, {  } ],
  SetLastError: [ VOID, { dwErrCode: DWORD } ],
  GetOverlappedResult: [ BOOL, { hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL } ],
  CreateIoCompletionPort: [ HANDLE, { FileHandle: HANDLE, ExistingCompletionPort: HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD } ],
  GetQueuedCompletionStatus: [ BOOL, { CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: PULONG_PTR, lpOverlapped: PTR(VOIDPTR), dwMilliseconds: DWORD } ],
  GetQueuedCompletionStatusEx: [ BOOL, { CompletionPort: HANDLE, lpCompletionPortEntries: LPOVERLAPPED_ENTRY, ulCount: ULONG, ulNumEntriesRemoved: PULONG, dwMilliseconds: DWORD, fAlertable: BOOL } ],
  PostQueuedCompletionStatus: [ BOOL, { CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: LPOVERLAPPED } ],
  SetFileCompletionNotificationModes: [ BOOL, { FileHandle: HANDLE, Flags: UCHAR } ],
  SetFileIoOverlappedRange: [ BOOL, { FileHandle: HANDLE, OverlappedRangeStart: PUCHAR, Length: ULONG } ],
  GetErrorMode: [ UINT, {  } ],
  SetErrorMode: [ UINT, { uMode: UINT } ],
  GetThreadErrorMode: [ DWORD, {  } ],
  SetThreadErrorMode: [ BOOL, { dwNewMode: DWORD, lpOldMode: LPDWORD } ],
  ReadProcessMemory: [ BOOL, { hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: PTR(ulong) } ],
  WriteProcessMemory: [ BOOL, { hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: PTR(ulong) } ],
  GetThreadContext: [ BOOL, { hThread: HANDLE, lpContext: LPCONTEXT } ],
  SetThreadContext: [ BOOL, { hThread: HANDLE, lpContext: PTR(uint) } ],
  Wow64GetThreadContext: [ BOOL, { hThread: HANDLE, lpContext: PWOW64_CONTEXT } ],
  Wow64GetThreadSelectorEntry: [ BOOL, { hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY } ],
  Wow64SetThreadContext: [ BOOL, { hThread: HANDLE, lpContext: PTR(uint) } ],
  SuspendThread: [ DWORD, { hThread: HANDLE } ],
  Wow64SuspendThread: [ DWORD, { hThread: HANDLE } ],
  ResumeThread: [ DWORD, { hThread: HANDLE } ],
  QueueUserAPC: [ DWORD, { pfnAPC: PAPCFUNC, hThread: HANDLE, dwData: ULONG_PTR } ],
  IsDebuggerPresent: [ BOOL, {  } ],
  CheckRemoteDebuggerPresent: [ BOOL, { hProcess: HANDLE, pbDebuggerPresent: PBOOL } ],
  DebugBreak: [ VOID, {  } ],
  WaitForDebugEvent: [ BOOL, { lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD } ],
  ContinueDebugEvent: [ BOOL, { dwProcessId: DWORD, dwThreadId: DWORD, dwContinueStatus: DWORD } ],
  DebugActiveProcess: [ BOOL, { dwProcessId: DWORD } ],
  DebugActiveProcessStop: [ BOOL, { dwProcessId: DWORD } ],
  DebugSetProcessKillOnExit: [ BOOL, { KillOnExit: BOOL } ],
  DebugBreakProcess: [ BOOL, { Process: HANDLE } ],
  InitializeCriticalSection: [ VOID, { lpCriticalSection: LPCRITICAL_SECTION } ],
  EnterCriticalSection: [ VOID, { lpCriticalSection: LPCRITICAL_SECTION } ],
  LeaveCriticalSection: [ VOID, { lpCriticalSection: LPCRITICAL_SECTION } ],
  InitializeCriticalSectionAndSpinCount: [ BOOL, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD } ],
  InitializeCriticalSectionEx: [ BOOL, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD } ],
  SetCriticalSectionSpinCount: [ DWORD, { lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD } ],
  TryEnterCriticalSection: [ BOOL, { lpCriticalSection: LPCRITICAL_SECTION } ],
  DeleteCriticalSection: [ VOID, { lpCriticalSection: LPCRITICAL_SECTION } ],
  SetEvent: [ BOOL, { hEvent: HANDLE } ],
  ResetEvent: [ BOOL, { hEvent: HANDLE } ],
  PulseEvent: [ BOOL, { hEvent: HANDLE } ],
  ReleaseSemaphore: [ BOOL, { hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG } ],
  ReleaseMutex: [ BOOL, { hMutex: HANDLE } ],
  WaitForSingleObject: [ DWORD, { hHandle: HANDLE, dwMilliseconds: DWORD } ],
  WaitForMultipleObjects: [ DWORD, { nCount: DWORD, lpHandles: PTR(PTR(VOID)), bWaitAll: BOOL, dwMilliseconds: DWORD } ],
  Sleep: [ VOID, { dwMilliseconds: DWORD } ],
  LoadResource: [ HGLOBAL, { hModule: HMODULE, hResInfo: HRSRC } ],
  SizeofResource: [ DWORD, { hModule: HMODULE, hResInfo: HRSRC } ],
  GlobalDeleteAtom: [ ATOM, { nAtom: ATOM } ],
  InitAtomTable: [ BOOL, { nSize: DWORD } ],
  DeleteAtom: [ ATOM, { nAtom: ATOM } ],
  SetHandleCount: [ UINT, { uNumber: UINT } ],
  GetLogicalDrives: [ DWORD, {  } ],
  LockFile: [ BOOL, { hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD } ],
  UnlockFile: [ BOOL, { hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD } ],
  LockFileEx: [ BOOL, { hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD, nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED } ],
  UnlockFileEx: [ BOOL, { hFile: HANDLE, dwReserved: DWORD, nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED } ],
  GetFileInformationByHandle: [ BOOL, { hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION } ],
  GetFileType: [ DWORD, { hFile: HANDLE } ],
  GetFileSize: [ DWORD, { hFile: HANDLE, lpFileSizeHigh: LPDWORD } ],
  GetFileSizeEx: [ BOOL, { hFile: HANDLE, lpFileSize: PLARGE_INTEGER } ],
  GetStdHandle: [ HANDLE, { nStdHandle: DWORD } ],
  SetStdHandle: [ BOOL, { nStdHandle: DWORD, hHandle: HANDLE } ],
  SetStdHandleEx: [ BOOL, { nStdHandle: DWORD, hHandle: HANDLE, phPrevValue: PHANDLE } ],
  WriteFile: [ BOOL, { hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  ReadFile: [ BOOL, { hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  FlushFileBuffers: [ BOOL, { hFile: HANDLE } ],
  DeviceIoControl: [ BOOL, { hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  RequestDeviceWakeup: [ BOOL, { hDevice: HANDLE } ],
  CancelDeviceWakeupRequest: [ BOOL, { hDevice: HANDLE } ],
  GetDevicePowerState: [ BOOL, { hDevice: HANDLE, pfOn: PTR(int) } ],
  SetMessageWaitingIndicator: [ BOOL, { hMsgIndicator: HANDLE, ulMsgCount: ULONG } ],
  SetEndOfFile: [ BOOL, { hFile: HANDLE } ],
  SetFilePointer: [ DWORD, { hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD } ],
  SetFilePointerEx: [ BOOL, { hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD } ],
  FindClose: [ BOOL, { hFindFile: HANDLE } ],
  GetFileTime: [ BOOL, { hFile: HANDLE, lpCreationTime: LPFILETIME, lpLastAccessTime: LPFILETIME, lpLastWriteTime: LPFILETIME } ],
  SetFileTime: [ BOOL, { hFile: HANDLE, lpCreationTime: PTR(uint), lpLastAccessTime: PTR(uint), lpLastWriteTime: PTR(uint) } ],
  SetFileValidData: [ BOOL, { hFile: HANDLE, ValidDataLength: LONGLONG } ],
  SetFileShortNameA: [ BOOL, { hFile: HANDLE, lpShortName: LPCSTR } ],
  SetFileShortNameW: [ BOOL, { hFile: HANDLE, lpShortName: LPCWSTR } ],
  CloseHandle: [ BOOL, { hObject: HANDLE } ],
  DuplicateHandle: [ BOOL, { hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD } ],
  GetHandleInformation: [ BOOL, { hObject: HANDLE, lpdwFlags: LPDWORD } ],
  SetHandleInformation: [ BOOL, { hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD } ],
  LoadModule: [ DWORD, { lpModuleName: LPCSTR, lpParameterBlock: LPVOID } ],
  WinExec: [ UINT, { lpCmdLine: LPCSTR, uCmdShow: UINT } ],
  ClearCommBreak: [ BOOL, { hFile: HANDLE } ],
  ClearCommError: [ BOOL, { hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT } ],
  SetupComm: [ BOOL, { hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD } ],
  EscapeCommFunction: [ BOOL, { hFile: HANDLE, dwFunc: DWORD } ],
  GetCommConfig: [ BOOL, { hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD } ],
  GetCommMask: [ BOOL, { hFile: HANDLE, lpEvtMask: LPDWORD } ],
  GetCommProperties: [ BOOL, { hFile: HANDLE, lpCommProp: LPCOMMPROP } ],
  GetCommModemStatus: [ BOOL, { hFile: HANDLE, lpModemStat: LPDWORD } ],
  GetCommState: [ BOOL, { hFile: HANDLE, lpDCB: LPDCB } ],
  GetCommTimeouts: [ BOOL, { hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS } ],
  PurgeComm: [ BOOL, { hFile: HANDLE, dwFlags: DWORD } ],
  SetCommBreak: [ BOOL, { hFile: HANDLE } ],
  SetCommConfig: [ BOOL, { hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD } ],
  SetCommMask: [ BOOL, { hFile: HANDLE, dwEvtMask: DWORD } ],
  SetCommState: [ BOOL, { hFile: HANDLE, lpDCB: LPDCB } ],
  SetCommTimeouts: [ BOOL, { hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS } ],
  TransmitCommChar: [ BOOL, { hFile: HANDLE, cChar: int8 } ],
  WaitCommEvent: [ BOOL, { hFile: HANDLE, lpEvtMask: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  SetTapePosition: [ DWORD, { hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL } ],
  GetTapePosition: [ DWORD, { hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD } ],
  PrepareTape: [ DWORD, { hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL } ],
  EraseTape: [ DWORD, { hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL } ],
  CreateTapePartition: [ DWORD, { hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD } ],
  WriteTapemark: [ DWORD, { hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL } ],
  GetTapeStatus: [ DWORD, { hDevice: HANDLE } ],
  GetTapeParameters: [ DWORD, { hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID } ],
  SetTapeParameters: [ DWORD, { hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID } ],
  Beep: [ BOOL, { dwFreq: DWORD, dwDuration: DWORD } ],
  MulDiv: [ VOID, { nNumber: int, nNumerator: int, nDenominator: int } ],
  GetSystemTime: [ VOID, { lpSystemTime: LPSYSTEMTIME } ],
  GetSystemTimeAsFileTime: [ VOID, { lpSystemTimeAsFileTime: LPFILETIME } ],
  SetSystemTime: [ BOOL, { lpSystemTime: PTR(uint) } ],
  GetLocalTime: [ VOID, { lpSystemTime: LPSYSTEMTIME } ],
  SetLocalTime: [ BOOL, { lpSystemTime: PTR(uint) } ],
  GetSystemInfo: [ VOID, { lpSystemInfo: LPSYSTEM_INFO } ],
  GetSystemDEPPolicy: [ DEP_SYSTEM_POLICY_TYPE, {  } ],
  SetSystemFileCacheSize: [ BOOL, { MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD } ],
  GetSystemFileCacheSize: [ BOOL, { lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD } ],
  GetSystemRegistryQuota: [ BOOL, { pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD } ],
  GetSystemTimes: [ BOOL, { lpIdleTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME } ],
  GetNativeSystemInfo: [ VOID, { lpSystemInfo: LPSYSTEM_INFO } ],
  IsProcessorFeaturePresent: [ BOOL, { ProcessorFeature: DWORD } ],
  SystemTimeToTzSpecificLocalTime: [ BOOL, { lpTimeZoneInformation: PTR(uint), lpUniversalTime: PTR(uint), lpLocalTime: LPSYSTEMTIME } ],
  TzSpecificLocalTimeToSystemTime: [ BOOL, { lpTimeZoneInformation: PTR(uint), lpLocalTime: PTR(uint), lpUniversalTime: LPSYSTEMTIME } ],
  GetTimeZoneInformationForYear: [ BOOL, { wYear: USHORT, pdtzi: PDYNAMIC_TIME_ZONE_INFORMATION, ptzi: LPTIME_ZONE_INFORMATION } ],
  GetTimeZoneInformation: [ DWORD, { lpTimeZoneInformation: LPTIME_ZONE_INFORMATION } ],
  SetTimeZoneInformation: [ BOOL, { lpTimeZoneInformation: PTR(uint) } ],
  GetDynamicTimeZoneInformation: [ DWORD, { pTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION } ],
  SetDynamicTimeZoneInformation: [ BOOL, { lpTimeZoneInformation: PTR(uint) } ],
  SystemTimeToFileTime: [ BOOL, { lpSystemTime: PTR(uint), lpFileTime: LPFILETIME } ],
  FileTimeToLocalFileTime: [ BOOL, { lpFileTime: PTR(uint), lpLocalFileTime: LPFILETIME } ],
  LocalFileTimeToFileTime: [ BOOL, { lpLocalFileTime: PTR(uint), lpFileTime: LPFILETIME } ],
  FileTimeToSystemTime: [ BOOL, { lpFileTime: PTR(uint), lpSystemTime: LPSYSTEMTIME } ],
  CompareFileTime: [ LONG, { lpFileTime1: PTR(uint), lpFileTime2: PTR(uint) } ],
  FileTimeToDosDateTime: [ BOOL, { lpFileTime: PTR(uint), lpFatDate: LPWORD, lpFatTime: LPWORD } ],
  DosDateTimeToFileTime: [ BOOL, { wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME } ],
  GetTickCount: [ DWORD, {  } ],
  GetTickCount64: [ ULONGLONG, {  } ],
  SetSystemTimeAdjustment: [ BOOL, { dwTimeAdjustment: DWORD, bTimeAdjustmentDisabled: BOOL } ],
  GetSystemTimeAdjustment: [ BOOL, { lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD, lpTimeAdjustmentDisabled: PBOOL } ],
  FormatMessageA: [ DWORD, { dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: PTR(PTR(int8)) } ],
  FormatMessageW: [ DWORD, { dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: PTR(PTR(int8)) } ],
  CreatePipe: [ BOOL, { hReadPipe: PHANDLE, hWritePipe: PHANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD } ],
  ConnectNamedPipe: [ BOOL, { hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED } ],
  DisconnectNamedPipe: [ BOOL, { hNamedPipe: HANDLE } ],
  SetNamedPipeHandleState: [ BOOL, { hNamedPipe: HANDLE, lpMode: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD } ],
  GetNamedPipeInfo: [ BOOL, { hNamedPipe: HANDLE, lpFlags: LPDWORD, lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD, lpMaxInstances: LPDWORD } ],
  PeekNamedPipe: [ BOOL, { hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD, lpBytesRead: LPDWORD, lpTotalBytesAvail: LPDWORD, lpBytesLeftThisMessage: LPDWORD } ],
  TransactNamedPipe: [ BOOL, { hNamedPipe: HANDLE, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  CreateMailslotA: [ HANDLE, { lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateMailslotW: [ HANDLE, { lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  GetMailslotInfo: [ BOOL, { hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD } ],
  SetMailslotInfo: [ BOOL, { hMailslot: HANDLE, lReadTimeout: DWORD } ],
  MapViewOfFile: [ LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T } ],
  FlushViewOfFile: [ BOOL, { lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T } ],
  UnmapViewOfFile: [ BOOL, { lpBaseAddress: LPCVOID } ],
  EncryptFileA: [ BOOL, { lpFileName: LPCSTR } ],
  EncryptFileW: [ BOOL, { lpFileName: LPCWSTR } ],
  DecryptFileA: [ BOOL, { lpFileName: LPCSTR, dwReserved: DWORD } ],
  DecryptFileW: [ BOOL, { lpFileName: LPCWSTR, dwReserved: DWORD } ],
  FileEncryptionStatusA: [ BOOL, { lpFileName: LPCSTR, lpStatus: LPDWORD } ],
  FileEncryptionStatusW: [ BOOL, { lpFileName: LPCWSTR, lpStatus: LPDWORD } ],
  OpenEncryptedFileRawA: [ DWORD, { lpFileName: LPCSTR, ulFlags: ULONG, pvContext: PTR(PTR(VOID)) } ],
  OpenEncryptedFileRawW: [ DWORD, { lpFileName: LPCWSTR, ulFlags: ULONG, pvContext: PTR(PTR(VOID)) } ],
  ReadEncryptedFileRaw: [ DWORD, { pfExportCallback: PFE_EXPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID } ],
  WriteEncryptedFileRaw: [ DWORD, { pfImportCallback: PFE_IMPORT_FUNC, pvCallbackContext: PVOID, pvContext: PVOID } ],
  CloseEncryptedFileRaw: [ VOID, { pvContext: PVOID } ],
  lstrcmpA: [ VOID, { lpString1: LPCSTR, lpString2: LPCSTR } ],
  lstrcmpW: [ VOID, { lpString1: LPCWSTR, lpString2: LPCWSTR } ],
  lstrcmpiA: [ VOID, { lpString1: LPCSTR, lpString2: LPCSTR } ],
  lstrcmpiW: [ VOID, { lpString1: LPCWSTR, lpString2: LPCWSTR } ],
  lstrcpynA: [ LPSTR, { lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: int } ],
  lstrcpynW: [ LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: int } ],
  lstrcpyA: [ LPSTR, { lpString1: LPSTR, lpString2: LPCSTR } ],
  lstrcpyW: [ LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR } ],
  lstrcatA: [ LPSTR, { lpString1: LPSTR, lpString2: LPCSTR } ],
  lstrcatW: [ LPWSTR, { lpString1: LPWSTR, lpString2: LPCWSTR } ],
  lstrlenA: [ VOID, { lpString: LPCSTR } ],
  lstrlenW: [ VOID, { lpString: LPCWSTR } ],
  OpenFile: [ HFILE, { lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT } ],
  _lopen: [ HFILE, { lpPathName: LPCSTR, iReadWrite: int } ],
  _lcreat: [ HFILE, { lpPathName: LPCSTR, iAttribute: int } ],
  _lread: [ UINT, { hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT } ],
  _lwrite: [ UINT, { hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT } ],
  _hread: [ VOID, { hFile: HFILE, lpBuffer: LPVOID, lBytes: long } ],
  _hwrite: [ VOID, { hFile: HFILE, lpBuffer: LPCCH, lBytes: long } ],
  _lclose: [ HFILE, { hFile: HFILE } ],
  _llseek: [ LONG, { hFile: HFILE, lOffset: LONG, iOrigin: int } ],
  IsTextUnicode: [ BOOL, { lpv: PTR(VOID), iSize: int, lpiResult: LPINT } ],
  FlsAlloc: [ DWORD, { lpCallback: PFLS_CALLBACK_FUNCTION } ],
  FlsGetValue: [ PVOID, { dwFlsIndex: DWORD } ],
  FlsSetValue: [ BOOL, { dwFlsIndex: DWORD, lpFlsData: PVOID } ],
  FlsFree: [ BOOL, { dwFlsIndex: DWORD } ],
  TlsAlloc: [ DWORD, {  } ],
  TlsGetValue: [ LPVOID, { dwTlsIndex: DWORD } ],
  TlsSetValue: [ BOOL, { dwTlsIndex: DWORD, lpTlsValue: LPVOID } ],
  TlsFree: [ BOOL, { dwTlsIndex: DWORD } ],
  SleepEx: [ DWORD, { dwMilliseconds: DWORD, bAlertable: BOOL } ],
  WaitForSingleObjectEx: [ DWORD, { hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL } ],
  WaitForMultipleObjectsEx: [ DWORD, { nCount: DWORD, lpHandles: PTR(PTR(VOID)), bWaitAll: BOOL, dwMilliseconds: DWORD, bAlertable: BOOL } ],
  SignalObjectAndWait: [ DWORD, { hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL } ],
  ReadFileEx: [ BOOL, { hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE } ],
  WriteFileEx: [ BOOL, { hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE } ],
  BackupRead: [ BOOL, { hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: PTR(PTR(VOID)) } ],
  BackupSeek: [ BOOL, { hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: PTR(PTR(VOID)) } ],
  BackupWrite: [ BOOL, { hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: PTR(PTR(VOID)) } ],
  ReadFileScatter: [ BOOL, { hFile: HANDLE, aSegmentArray: PTR(uint), nNumberOfBytesToRead: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  WriteFileGather: [ BOOL, { hFile: HANDLE, aSegmentArray: PTR(uint), nNumberOfBytesToWrite: DWORD, lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  CreateMutexA: [ HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCSTR } ],
  CreateMutexW: [ HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCWSTR } ],
  OpenMutexA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR } ],
  OpenMutexW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR } ],
  CreateEventA: [ HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR } ],
  CreateEventW: [ HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR } ],
  OpenEventA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR } ],
  OpenEventW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR } ],
  CreateSemaphoreA: [ HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR } ],
  CreateSemaphoreW: [ HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR } ],
  OpenSemaphoreA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR } ],
  OpenSemaphoreW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR } ],
  CreateWaitableTimerA: [ HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR } ],
  CreateWaitableTimerW: [ HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR } ],
  OpenWaitableTimerA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR } ],
  OpenWaitableTimerW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCWSTR } ],
  SetWaitableTimerEx: [ BOOL, { hTimer: HANDLE, lpDueTime: PTR(uint), lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG } ],
  SetWaitableTimer: [ BOOL, { hTimer: HANDLE, lpDueTime: PTR(uint), lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: BOOL } ],
  CancelWaitableTimer: [ BOOL, { hTimer: HANDLE } ],
  CreateMutexExA: [ HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateMutexExW: [ HANDLE, { lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateEventExA: [ HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateEventExW: [ HANDLE, { lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateSemaphoreExA: [ HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateSemaphoreExW: [ HANDLE, { lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateWaitableTimerExA: [ HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateWaitableTimerExW: [ HANDLE, { lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD } ],
  CreateFileMappingA: [ HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR } ],
  CreateFileMappingW: [ HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR } ],
  CreateFileMappingNumaA: [ HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD } ],
  CreateFileMappingNumaW: [ HANDLE, { hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD } ],
  OpenFileMappingA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR } ],
  OpenFileMappingW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR } ],
  GetLogicalDriveStringsA: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR } ],
  GetLogicalDriveStringsW: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR } ],
  CreateMemoryResourceNotification: [ HANDLE, { NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE } ],
  QueryMemoryResourceNotification: [ BOOL, { ResourceNotificationHandle: HANDLE, ResourceState: PBOOL } ],
  LoadLibraryA: [ HMODULE, { lpLibFileName: LPCSTR } ],
  LoadLibraryW: [ HMODULE, { lpLibFileName: LPCWSTR } ],
  LoadLibraryExA: [ HMODULE, { lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD } ],
  LoadLibraryExW: [ HMODULE, { lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD } ],
  GetModuleFileNameA: [ DWORD, { hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD } ],
  GetModuleFileNameW: [ DWORD, { hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD } ],
  GetModuleHandleA: [ HMODULE, { lpModuleName: LPCSTR } ],
  GetModuleHandleW: [ HMODULE, { lpModuleName: LPCWSTR } ],
  GetModuleHandleExA: [ BOOL, { dwFlags: DWORD, lpModuleName: LPCSTR, phModule: PTR(VOIDPTR) } ],
  GetModuleHandleExW: [ BOOL, { dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: PTR(VOIDPTR) } ],
  NeedCurrentDirectoryForExePathA: [ BOOL, { ExeName: LPCSTR } ],
  NeedCurrentDirectoryForExePathW: [ BOOL, { ExeName: LPCWSTR } ],
  QueryFullProcessImageNameA: [ BOOL, { hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD } ],
  QueryFullProcessImageNameW: [ BOOL, { hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD } ],
  InitializeProcThreadAttributeList: [ BOOL, { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount: DWORD, dwFlags: DWORD, lpSize: PSIZE_T } ],
  DeleteProcThreadAttributeList: [ VOID, { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST } ],
  UpdateProcThreadAttribute: [ BOOL, { lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags: DWORD, Attribute: DWORD_PTR, lpValue: PVOID, cbSize: SIZE_T, lpPreviousValue: PVOID, lpReturnSize: PSIZE_T } ],
  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 } ],
  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 } ],
  SetProcessShutdownParameters: [ BOOL, { dwLevel: DWORD, dwFlags: DWORD } ],
  GetProcessShutdownParameters: [ BOOL, { lpdwLevel: LPDWORD, lpdwFlags: LPDWORD } ],
  GetProcessVersion: [ DWORD, { ProcessId: DWORD } ],
  FatalAppExitA: [ VOID, { uAction: UINT, lpMessageText: LPCSTR } ],
  FatalAppExitW: [ VOID, { uAction: UINT, lpMessageText: LPCWSTR } ],
  GetStartupInfoA: [ VOID, { lpStartupInfo: LPSTARTUPINFOA } ],
  GetStartupInfoW: [ VOID, { lpStartupInfo: LPSTARTUPINFOW } ],
  GetCommandLineA: [ LPSTR, {  } ],
  GetCommandLineW: [ LPWSTR, {  } ],
  GetEnvironmentVariableA: [ DWORD, { lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD } ],
  GetEnvironmentVariableW: [ DWORD, { lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD } ],
  SetEnvironmentVariableA: [ BOOL, { lpName: LPCSTR, lpValue: LPCSTR } ],
  SetEnvironmentVariableW: [ BOOL, { lpName: LPCWSTR, lpValue: LPCWSTR } ],
  ExpandEnvironmentStringsA: [ DWORD, { lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD } ],
  ExpandEnvironmentStringsW: [ DWORD, { lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD } ],
  GetFirmwareEnvironmentVariableA: [ DWORD, { lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD } ],
  GetFirmwareEnvironmentVariableW: [ DWORD, { lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD } ],
  SetFirmwareEnvironmentVariableA: [ BOOL, { lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD } ],
  SetFirmwareEnvironmentVariableW: [ BOOL, { lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD } ],
  OutputDebugStringA: [ VOID, { lpOutputString: LPCSTR } ],
  OutputDebugStringW: [ VOID, { lpOutputString: LPCWSTR } ],
  FindResourceA: [ HRSRC, { hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR } ],
  FindResourceW: [ HRSRC, { hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR } ],
  FindResourceExA: [ HRSRC, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD } ],
  FindResourceExW: [ HRSRC, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD } ],
  EnumResourceTypesA: [ BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR } ],
  EnumResourceTypesW: [ BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR } ],
  EnumResourceNamesA: [ BOOL, { hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR } ],
  EnumResourceNamesW: [ BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR } ],
  EnumResourceLanguagesA: [ BOOL, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR } ],
  EnumResourceLanguagesW: [ BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR } ],
  EnumResourceTypesExA: [ BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  EnumResourceTypesExW: [ BOOL, { hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  EnumResourceNamesExA: [ BOOL, { hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  EnumResourceNamesExW: [ BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  EnumResourceLanguagesExA: [ BOOL, { hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  EnumResourceLanguagesExW: [ BOOL, { hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID } ],
  BeginUpdateResourceA: [ HANDLE, { pFileName: LPCSTR, bDeleteExistingResources: BOOL } ],
  BeginUpdateResourceW: [ HANDLE, { pFileName: LPCWSTR, bDeleteExistingResources: BOOL } ],
  UpdateResourceA: [ BOOL, { hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD } ],
  UpdateResourceW: [ BOOL, { hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD } ],
  EndUpdateResourceA: [ BOOL, { hUpdate: HANDLE, fDiscard: BOOL } ],
  EndUpdateResourceW: [ BOOL, { hUpdate: HANDLE, fDiscard: BOOL } ],
  GlobalAddAtomA: [ ATOM, { lpString: LPCSTR } ],
  GlobalAddAtomW: [ ATOM, { lpString: LPCWSTR } ],
  GlobalFindAtomA: [ ATOM, { lpString: LPCSTR } ],
  GlobalFindAtomW: [ ATOM, { lpString: LPCWSTR } ],
  GlobalGetAtomNameA: [ UINT, { nAtom: ATOM, lpBuffer: LPSTR, nSize: int } ],
  GlobalGetAtomNameW: [ UINT, { nAtom: ATOM, lpBuffer: LPWSTR, nSize: int } ],
  AddAtomA: [ ATOM, { lpString: LPCSTR } ],
  AddAtomW: [ ATOM, { lpString: LPCWSTR } ],
  FindAtomA: [ ATOM, { lpString: LPCSTR } ],
  FindAtomW: [ ATOM, { lpString: LPCWSTR } ],
  GetAtomNameA: [ UINT, { nAtom: ATOM, lpBuffer: LPSTR, nSize: int } ],
  GetAtomNameW: [ UINT, { nAtom: ATOM, lpBuffer: LPWSTR, nSize: int } ],
  GetProfileIntA: [ UINT, { lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT } ],
  GetProfileIntW: [ UINT, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT } ],
  GetProfileStringA: [ DWORD, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD } ],
  GetProfileStringW: [ DWORD, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD } ],
  WriteProfileStringA: [ BOOL, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR } ],
  WriteProfileStringW: [ BOOL, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR } ],
  GetProfileSectionA: [ DWORD, { lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD } ],
  GetProfileSectionW: [ DWORD, { lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD } ],
  WriteProfileSectionA: [ BOOL, { lpAppName: LPCSTR, lpString: LPCSTR } ],
  WriteProfileSectionW: [ BOOL, { lpAppName: LPCWSTR, lpString: LPCWSTR } ],
  GetPrivateProfileIntA: [ UINT, { lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR } ],
  GetPrivateProfileIntW: [ UINT, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR } ],
  GetPrivateProfileStringA: [ DWORD, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR } ],
  GetPrivateProfileStringW: [ DWORD, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR } ],
  WritePrivateProfileStringA: [ BOOL, { lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR } ],
  WritePrivateProfileStringW: [ BOOL, { lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR } ],
  GetPrivateProfileSectionA: [ DWORD, { lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR } ],
  GetPrivateProfileSectionW: [ DWORD, { lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR } ],
  WritePrivateProfileSectionA: [ BOOL, { lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR } ],
  WritePrivateProfileSectionW: [ BOOL, { lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR } ],
  GetPrivateProfileSectionNamesA: [ DWORD, { lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR } ],
  GetPrivateProfileSectionNamesW: [ DWORD, { lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR } ],
  GetPrivateProfileStructA: [ BOOL, { lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR } ],
  GetPrivateProfileStructW: [ BOOL, { lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR } ],
  WritePrivateProfileStructA: [ BOOL, { lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR } ],
  WritePrivateProfileStructW: [ BOOL, { lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR } ],
  GetDriveTypeA: [ UINT, { lpRootPathName: LPCSTR } ],
  GetDriveTypeW: [ UINT, { lpRootPathName: LPCWSTR } ],
  GetSystemDirectoryA: [ UINT, { lpBuffer: LPSTR, uSize: UINT } ],
  GetSystemDirectoryW: [ UINT, { lpBuffer: LPWSTR, uSize: UINT } ],
  GetTempPathA: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR } ],
  GetTempPathW: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR } ],
  GetTempFileNameA: [ UINT, { lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR } ],
  GetTempFileNameW: [ UINT, { lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR } ],
  GetWindowsDirectoryA: [ UINT, { lpBuffer: LPSTR, uSize: UINT } ],
  GetWindowsDirectoryW: [ UINT, { lpBuffer: LPWSTR, uSize: UINT } ],
  GetSystemWindowsDirectoryA: [ UINT, { lpBuffer: LPSTR, uSize: UINT } ],
  GetSystemWindowsDirectoryW: [ UINT, { lpBuffer: LPWSTR, uSize: UINT } ],
  GetSystemWow64DirectoryA: [ UINT, { lpBuffer: LPSTR, uSize: UINT } ],
  GetSystemWow64DirectoryW: [ UINT, { lpBuffer: LPWSTR, uSize: UINT } ],
  Wow64EnableWow64FsRedirection: [ BOOLEAN, { Wow64FsEnableRedirection: BOOLEAN } ],
  Wow64DisableWow64FsRedirection: [ BOOL, { OldValue: PTR(PTR(VOID)) } ],
  Wow64RevertWow64FsRedirection: [ BOOL, { OlValue: PVOID } ],
  SetCurrentDirectoryA: [ BOOL, { lpPathName: LPCSTR } ],
  SetCurrentDirectoryW: [ BOOL, { lpPathName: LPCWSTR } ],
  GetCurrentDirectoryA: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR } ],
  GetCurrentDirectoryW: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR } ],
  SetDllDirectoryA: [ BOOL, { lpPathName: LPCSTR } ],
  SetDllDirectoryW: [ BOOL, { lpPathName: LPCWSTR } ],
  GetDllDirectoryA: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPSTR } ],
  GetDllDirectoryW: [ DWORD, { nBufferLength: DWORD, lpBuffer: LPWSTR } ],
  SetSearchPathMode: [ BOOL, { Flags: DWORD } ],
  GetDiskFreeSpaceA: [ BOOL, { lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD } ],
  GetDiskFreeSpaceW: [ BOOL, { lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD, lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD } ],
  GetDiskFreeSpaceExA: [ BOOL, { lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER } ],
  GetDiskFreeSpaceExW: [ BOOL, { lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER } ],
  CreateDirectoryA: [ BOOL, { lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateDirectoryW: [ BOOL, { lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateDirectoryExA: [ BOOL, { lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateDirectoryExW: [ BOOL, { lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateDirectoryTransactedA: [ BOOL, { lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE } ],
  CreateDirectoryTransactedW: [ BOOL, { lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE } ],
  RemoveDirectoryA: [ BOOL, { lpPathName: LPCSTR } ],
  RemoveDirectoryW: [ BOOL, { lpPathName: LPCWSTR } ],
  RemoveDirectoryTransactedA: [ BOOL, { lpPathName: LPCSTR, hTransaction: HANDLE } ],
  RemoveDirectoryTransactedW: [ BOOL, { lpPathName: LPCWSTR, hTransaction: HANDLE } ],
  GetFullPathNameA: [ DWORD, { lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)) } ],
  GetFullPathNameW: [ DWORD, { lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)) } ],
  GetFullPathNameTransactedA: [ DWORD, { lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)), hTransaction: HANDLE } ],
  GetFullPathNameTransactedW: [ DWORD, { lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)), hTransaction: HANDLE } ],
  DefineDosDeviceA: [ BOOL, { dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR } ],
  DefineDosDeviceW: [ BOOL, { dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR } ],
  QueryDosDeviceA: [ DWORD, { lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD } ],
  QueryDosDeviceW: [ DWORD, { lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD } ],
  CreateFileA: [ HANDLE, { lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE } ],
  CreateFileW: [ HANDLE, { lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE } ],
  CreateFileTransactedA: [ HANDLE, { lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID } ],
  CreateFileTransactedW: [ HANDLE, { lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID } ],
  ReOpenFile: [ HANDLE, { hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlagsAndAttributes: DWORD } ],
  SetFileAttributesA: [ BOOL, { lpFileName: LPCSTR, dwFileAttributes: DWORD } ],
  SetFileAttributesW: [ BOOL, { lpFileName: LPCWSTR, dwFileAttributes: DWORD } ],
  GetFileAttributesA: [ DWORD, { lpFileName: LPCSTR } ],
  GetFileAttributesW: [ DWORD, { lpFileName: LPCWSTR } ],
  SetFileAttributesTransactedA: [ BOOL, { lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE } ],
  SetFileAttributesTransactedW: [ BOOL, { lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE } ],
  GetFileAttributesTransactedA: [ BOOL, { lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE } ],
  GetFileAttributesTransactedW: [ BOOL, { lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE } ],
  GetFileAttributesExA: [ BOOL, { lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID } ],
  GetFileAttributesExW: [ BOOL, { lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID } ],
  GetCompressedFileSizeA: [ DWORD, { lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD } ],
  GetCompressedFileSizeW: [ DWORD, { lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD } ],
  GetCompressedFileSizeTransactedA: [ DWORD, { lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE } ],
  GetCompressedFileSizeTransactedW: [ DWORD, { lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE } ],
  DeleteFileA: [ BOOL, { lpFileName: LPCSTR } ],
  DeleteFileW: [ BOOL, { lpFileName: LPCWSTR } ],
  DeleteFileTransactedA: [ BOOL, { lpFileName: LPCSTR, hTransaction: HANDLE } ],
  DeleteFileTransactedW: [ BOOL, { lpFileName: LPCWSTR, hTransaction: HANDLE } ],
  CheckNameLegalDOS8Dot3A: [ BOOL, { lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL } ],
  CheckNameLegalDOS8Dot3W: [ BOOL, { lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL } ],
  FindFirstFileExA: [ HANDLE, { lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD } ],
  FindFirstFileExW: [ HANDLE, { lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD } ],
  FindFirstFileTransactedA: [ HANDLE, { lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE } ],
  FindFirstFileTransactedW: [ HANDLE, { lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE } ],
  FindFirstFileA: [ HANDLE, { lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA } ],
  FindFirstFileW: [ HANDLE, { lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW } ],
  FindNextFileA: [ BOOL, { hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA } ],
  FindNextFileW: [ BOOL, { hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW } ],
  SearchPathA: [ DWORD, { lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: PTR(PTR(int8)) } ],
  SearchPathW: [ DWORD, { lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: PTR(PTR(ushort)) } ],
  CopyFileA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL } ],
  CopyFileW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL } ],
  CopyFileExA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD } ],
  CopyFileExW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD } ],
  CopyFileTransactedA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE } ],
  CopyFileTransactedW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE } ],
  MoveFileA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR } ],
  MoveFileW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR } ],
  MoveFileExA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD } ],
  MoveFileExW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD } ],
  MoveFileWithProgressA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD } ],
  MoveFileWithProgressW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD } ],
  MoveFileTransactedA: [ BOOL, { lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE } ],
  MoveFileTransactedW: [ BOOL, { lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE } ],
  ReplaceFileA: [ BOOL, { lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID } ],
  ReplaceFileW: [ BOOL, { lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID } ],
  CreateHardLinkA: [ BOOL, { lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateHardLinkW: [ BOOL, { lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateHardLinkTransactedA: [ BOOL, { lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE } ],
  CreateHardLinkTransactedW: [ BOOL, { lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE } ],
  FindFirstStreamW: [ HANDLE, { lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD } ],
  FindFirstStreamTransactedW: [ HANDLE, { lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE } ],
  FindNextStreamW: [ BOOL, { hFindStream: HANDLE, lpFindStreamData: LPVOID } ],
  FindFirstFileNameW: [ HANDLE, { lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWCHAR } ],
  FindNextFileNameW: [ BOOL, { hFindStream: HANDLE, StringLength: LPDWORD, LinkName: PWCHAR } ],
  FindFirstFileNameTransactedW: [ HANDLE, { lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWCHAR, hTransaction: HANDLE } ],
  CreateNamedPipeA: [ HANDLE, { lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  CreateNamedPipeW: [ HANDLE, { lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  GetNamedPipeHandleStateA: [ BOOL, { hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD } ],
  GetNamedPipeHandleStateW: [ BOOL, { hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR, nMaxUserNameSize: DWORD } ],
  CallNamedPipeA: [ BOOL, { lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD } ],
  CallNamedPipeW: [ BOOL, { lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD } ],
  WaitNamedPipeA: [ BOOL, { lpNamedPipeName: LPCSTR, nTimeOut: DWORD } ],
  WaitNamedPipeW: [ BOOL, { lpNamedPipeName: LPCWSTR, nTimeOut: DWORD } ],
  GetNamedPipeAttribute: [ BOOL, { Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR, AttributeValue: PVOID, AttributeValueLength: PSIZE_T } ],
  SetNamedPipeAttribute: [ BOOL, { Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR, AttributeValue: PVOID, AttributeValueLength: SIZE_T } ],
  GetNamedPipeClientComputerNameA: [ BOOL, { Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG } ],
  GetNamedPipeClientComputerNameW: [ BOOL, { Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG } ],
  GetNamedPipeClientProcessId: [ BOOL, { Pipe: HANDLE, ClientProcessId: PULONG } ],
  GetNamedPipeClientSessionId: [ BOOL, { Pipe: HANDLE, ClientSessionId: PULONG } ],
  GetNamedPipeServerProcessId: [ BOOL, { Pipe: HANDLE, ServerProcessId: PULONG } ],
  GetNamedPipeServerSessionId: [ BOOL, { Pipe: HANDLE, ServerSessionId: PULONG } ],
  SetVolumeLabelA: [ BOOL, { lpRootPathName: LPCSTR, lpVolumeName: LPCSTR } ],
  SetVolumeLabelW: [ BOOL, { lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR } ],
  SetFileApisToOEM: [ VOID, {  } ],
  SetFileApisToANSI: [ VOID, {  } ],
  AreFileApisANSI: [ BOOL, {  } ],
  GetVolumeInformationA: [ BOOL, { lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD } ],
  GetVolumeInformationW: [ BOOL, { lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD } ],
  GetVolumeInformationByHandleW: [ BOOL, { hFile: HANDLE, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD, lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD, lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD } ],
  CancelSynchronousIo: [ BOOL, { hThread: HANDLE } ],
  CancelIoEx: [ BOOL, { hFile: HANDLE, lpOverlapped: LPOVERLAPPED } ],
  CancelIo: [ BOOL, { hFile: HANDLE } ],
  SetFileBandwidthReservation: [ BOOL, { hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD } ],
  GetFileBandwidthReservation: [ BOOL, { hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD } ],
  ClearEventLogA: [ BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCSTR } ],
  ClearEventLogW: [ BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCWSTR } ],
  BackupEventLogA: [ BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCSTR } ],
  BackupEventLogW: [ BOOL, { hEventLog: HANDLE, lpBackupFileName: LPCWSTR } ],
  CloseEventLog: [ BOOL, { hEventLog: HANDLE } ],
  DeregisterEventSource: [ BOOL, { hEventLog: HANDLE } ],
  NotifyChangeEventLog: [ BOOL, { hEventLog: HANDLE, hEvent: HANDLE } ],
  GetNumberOfEventLogRecords: [ BOOL, { hEventLog: HANDLE, NumberOfRecords: PDWORD } ],
  GetOldestEventLogRecord: [ BOOL, { hEventLog: HANDLE, OldestRecord: PDWORD } ],
  OpenEventLogA: [ HANDLE, { lpUNCServerName: LPCSTR, lpSourceName: LPCSTR } ],
  OpenEventLogW: [ HANDLE, { lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR } ],
  RegisterEventSourceA: [ HANDLE, { lpUNCServerName: LPCSTR, lpSourceName: LPCSTR } ],
  RegisterEventSourceW: [ HANDLE, { lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR } ],
  OpenBackupEventLogA: [ HANDLE, { lpUNCServerName: LPCSTR, lpFileName: LPCSTR } ],
  OpenBackupEventLogW: [ HANDLE, { lpUNCServerName: LPCWSTR, lpFileName: LPCWSTR } ],
  ReadEventLogA: [ BOOL, { hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: PTR(ulong), pnMinNumberOfBytesNeeded: PTR(ulong) } ],
  ReadEventLogW: [ BOOL, { hEventLog: HANDLE, dwReadFlags: DWORD, dwRecordOffset: DWORD, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, pnBytesRead: PTR(ulong), pnMinNumberOfBytesNeeded: PTR(ulong) } ],
  ReportEventA: [ BOOL, { hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: PTR(PTR(int8)), lpRawData: LPVOID } ],
  ReportEventW: [ BOOL, { hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: PTR(PTR(ushort)), lpRawData: LPVOID } ],
  GetEventLogInformation: [ BOOL, { hEventLog: HANDLE, dwInfoLevel: DWORD, lpBuffer: LPVOID, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD } ],
  DuplicateToken: [ BOOL, { ExistingTokenHandle: HANDLE, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, DuplicateTokenHandle: PHANDLE } ],
  GetKernelObjectSecurity: [ BOOL, { Handle: HANDLE, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  ImpersonateNamedPipeClient: [ BOOL, { hNamedPipe: HANDLE } ],
  ImpersonateSelf: [ BOOL, { ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL } ],
  RevertToSelf: [ BOOL, {  } ],
  SetThreadToken: [ BOOL, { Thread: PHANDLE, Token: HANDLE } ],
  AccessCheck: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, DesiredAccess: DWORD, GenericMapping: PGENERIC_MAPPING, PrivilegeSet: PPRIVILEGE_SET, PrivilegeSetLength: LPDWORD, GrantedAccess: LPDWORD, AccessStatus: LPBOOL } ],
  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 } ],
  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 } ],
  OpenProcessToken: [ BOOL, { ProcessHandle: HANDLE, DesiredAccess: DWORD, TokenHandle: PHANDLE } ],
  OpenThreadToken: [ BOOL, { ThreadHandle: HANDLE, DesiredAccess: DWORD, OpenAsSelf: BOOL, TokenHandle: PHANDLE } ],
  GetTokenInformation: [ BOOL, { TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD, ReturnLength: PDWORD } ],
  SetTokenInformation: [ BOOL, { TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, TokenInformation: LPVOID, TokenInformationLength: DWORD } ],
  AdjustTokenPrivileges: [ BOOL, { TokenHandle: HANDLE, DisableAllPrivileges: BOOL, NewState: PTOKEN_PRIVILEGES, BufferLength: DWORD, PreviousState: PTOKEN_PRIVILEGES, ReturnLength: PDWORD } ],
  AdjustTokenGroups: [ BOOL, { TokenHandle: HANDLE, ResetToDefault: BOOL, NewState: PTOKEN_GROUPS, BufferLength: DWORD, PreviousState: PTOKEN_GROUPS, ReturnLength: PDWORD } ],
  PrivilegeCheck: [ BOOL, { ClientToken: HANDLE, RequiredPrivileges: PPRIVILEGE_SET, pfResult: LPBOOL } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  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 } ],
  ObjectPrivilegeAuditAlarmA: [ BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL } ],
  ObjectPrivilegeAuditAlarmW: [ BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, ClientToken: HANDLE, DesiredAccess: DWORD, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL } ],
  ObjectCloseAuditAlarmA: [ BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: BOOL } ],
  ObjectCloseAuditAlarmW: [ BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: BOOL } ],
  ObjectDeleteAuditAlarmA: [ BOOL, { SubsystemName: LPCSTR, HandleId: LPVOID, GenerateOnClose: BOOL } ],
  ObjectDeleteAuditAlarmW: [ BOOL, { SubsystemName: LPCWSTR, HandleId: LPVOID, GenerateOnClose: BOOL } ],
  PrivilegedServiceAuditAlarmA: [ BOOL, { SubsystemName: LPCSTR, ServiceName: LPCSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL } ],
  PrivilegedServiceAuditAlarmW: [ BOOL, { SubsystemName: LPCWSTR, ServiceName: LPCWSTR, ClientToken: HANDLE, Privileges: PPRIVILEGE_SET, AccessGranted: BOOL } ],
  IsWellKnownSid: [ BOOL, { pSid: PSID, WellKnownSidType: WELL_KNOWN_SID_TYPE } ],
  CreateWellKnownSid: [ BOOL, { WellKnownSidType: WELL_KNOWN_SID_TYPE, DomainSid: PSID, pSid: PSID, cbSid: PTR(ulong) } ],
  EqualDomainSid: [ BOOL, { pSid1: PSID, pSid2: PSID, pfEqual: PTR(int) } ],
  GetWindowsAccountDomainSid: [ BOOL, { pSid: PSID, pDomainSid: PSID, cbDomainSid: PTR(ulong) } ],
  IsValidSid: [ BOOL, { pSid: PSID } ],
  EqualSid: [ BOOL, { pSid1: PSID, pSid2: PSID } ],
  EqualPrefixSid: [ BOOL, { pSid1: PSID, pSid2: PSID } ],
  GetSidLengthRequired: [ DWORD, { nSubAuthorityCount: UCHAR } ],
  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)) } ],
  FreeSid: [ PVOID, { pSid: PSID } ],
  InitializeSid: [ BOOL, { Sid: PSID, pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, nSubAuthorityCount: BYTE } ],
  GetSidIdentifierAuthority: [ PSID_IDENTIFIER_AUTHORITY, { pSid: PSID } ],
  GetSidSubAuthority: [ PDWORD, { pSid: PSID, nSubAuthority: DWORD } ],
  GetSidSubAuthorityCount: [ PUCHAR, { pSid: PSID } ],
  GetLengthSid: [ DWORD, { pSid: PSID } ],
  CopySid: [ BOOL, { nDestinationSidLength: DWORD, pDestinationSid: PSID, pSourceSid: PSID } ],
  AreAllAccessesGranted: [ BOOL, { GrantedAccess: DWORD, DesiredAccess: DWORD } ],
  AreAnyAccessesGranted: [ BOOL, { GrantedAccess: DWORD, DesiredAccess: DWORD } ],
  MapGenericMask: [ VOID, { AccessMask: PDWORD, GenericMapping: PGENERIC_MAPPING } ],
  IsValidAcl: [ BOOL, { pAcl: PACL } ],
  InitializeAcl: [ BOOL, { pAcl: PACL, nAclLength: DWORD, dwAclRevision: DWORD } ],
  GetAclInformation: [ BOOL, { pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS } ],
  SetAclInformation: [ BOOL, { pAcl: PACL, pAclInformation: LPVOID, nAclInformationLength: DWORD, dwAclInformationClass: ACL_INFORMATION_CLASS } ],
  AddAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, dwStartingAceIndex: DWORD, pAceList: LPVOID, nAceListLength: DWORD } ],
  DeleteAce: [ BOOL, { pAcl: PACL, dwAceIndex: DWORD } ],
  GetAce: [ BOOL, { pAcl: PACL, dwAceIndex: DWORD, pAce: PTR(PTR(VOID)) } ],
  AddAccessAllowedAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID } ],
  AddAccessAllowedAceEx: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID } ],
  AddMandatoryAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, MandatoryPolicy: DWORD, pLabelSid: PSID } ],
  AddConditionalAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AceType: UCHAR, AccessMask: DWORD, pSid: PSID, ConditionStr: PWCHAR, ReturnLength: PTR(ulong) } ],
  AddAccessDeniedAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AccessMask: DWORD, pSid: PSID } ],
  AddAccessDeniedAceEx: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID } ],
  AddAuditAccessAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL } ],
  AddAuditAccessAceEx: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, dwAccessMask: DWORD, pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL } ],
  AddAccessAllowedObjectAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID } ],
  AddAccessDeniedObjectAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID } ],
  AddAuditAccessObjectAce: [ BOOL, { pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, ObjectTypeGuid: PTR(uint), InheritedObjectTypeGuid: PTR(uint), pSid: PSID, bAuditSuccess: BOOL, bAuditFailure: BOOL } ],
  FindFirstFreeAce: [ BOOL, { pAcl: PACL, pAce: PTR(PTR(VOID)) } ],
  InitializeSecurityDescriptor: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, dwRevision: DWORD } ],
  IsValidSecurityDescriptor: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  IsValidRelativeSecurityDescriptor: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, SecurityDescriptorLength: ULONG, RequiredInformation: SECURITY_INFORMATION } ],
  GetSecurityDescriptorLength: [ DWORD, { pSecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  GetSecurityDescriptorControl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pControl: PSECURITY_DESCRIPTOR_CONTROL, lpdwRevision: LPDWORD } ],
  SetSecurityDescriptorControl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, ControlBitsOfInterest: SECURITY_DESCRIPTOR_CONTROL, ControlBitsToSet: SECURITY_DESCRIPTOR_CONTROL } ],
  SetSecurityDescriptorDacl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, bDaclPresent: BOOL, pDacl: PACL, bDaclDefaulted: BOOL } ],
  GetSecurityDescriptorDacl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbDaclPresent: LPBOOL, pDacl: PTR(VOIDPTR), lpbDaclDefaulted: LPBOOL } ],
  SetSecurityDescriptorSacl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, bSaclPresent: BOOL, pSacl: PACL, bSaclDefaulted: BOOL } ],
  GetSecurityDescriptorSacl: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpbSaclPresent: LPBOOL, pSacl: PTR(VOIDPTR), lpbSaclDefaulted: LPBOOL } ],
  SetSecurityDescriptorOwner: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: PSID, bOwnerDefaulted: BOOL } ],
  GetSecurityDescriptorOwner: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pOwner: PTR(PTR(VOID)), lpbOwnerDefaulted: LPBOOL } ],
  SetSecurityDescriptorGroup: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: PSID, bGroupDefaulted: BOOL } ],
  GetSecurityDescriptorGroup: [ BOOL, { pSecurityDescriptor: PSECURITY_DESCRIPTOR, pGroup: PTR(PTR(VOID)), lpbGroupDefaulted: LPBOOL } ],
  SetSecurityDescriptorRMControl: [ DWORD, { SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR } ],
  GetSecurityDescriptorRMControl: [ DWORD, { SecurityDescriptor: PSECURITY_DESCRIPTOR, RMControl: PUCHAR } ],
  CreatePrivateObjectSecurity: [ BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: PTR(PTR(VOID)), IsDirectoryObject: BOOL, Token: HANDLE, GenericMapping: PGENERIC_MAPPING } ],
  ConvertToAutoInheritPrivateObjectSecurity: [ BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR, NewSecurityDescriptor: PTR(PTR(VOID)), ObjectType: PTR(uint), IsDirectoryObject: BOOLEAN, GenericMapping: PGENERIC_MAPPING } ],
  CreatePrivateObjectSecurityEx: [ BOOL, { ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: PTR(PTR(VOID)), ObjectType: PTR(uint), IsContainerObject: BOOL, AutoInheritFlags: ULONG, Token: HANDLE, GenericMapping: PGENERIC_MAPPING } ],
  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 } ],
  SetPrivateObjectSecurity: [ BOOL, { SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: PTR(PTR(VOID)), GenericMapping: PGENERIC_MAPPING, Token: HANDLE } ],
  SetPrivateObjectSecurityEx: [ BOOL, { SecurityInformation: SECURITY_INFORMATION, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: PTR(PTR(VOID)), AutoInheritFlags: ULONG, GenericMapping: PGENERIC_MAPPING, Token: HANDLE } ],
  GetPrivateObjectSecurity: [ BOOL, { ObjectDescriptor: PSECURITY_DESCRIPTOR, SecurityInformation: SECURITY_INFORMATION, ResultantDescriptor: PSECURITY_DESCRIPTOR, DescriptorLength: DWORD, ReturnLength: PDWORD } ],
  DestroyPrivateObjectSecurity: [ BOOL, { ObjectDescriptor: PTR(PTR(VOID)) } ],
  MakeSelfRelativeSD: [ BOOL, { pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwBufferLength: LPDWORD } ],
  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 } ],
  MakeAbsoluteSD2: [ BOOL, { pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, lpdwBufferSize: LPDWORD } ],
  QuerySecurityAccessMask: [ VOID, { SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD } ],
  SetSecurityAccessMask: [ VOID, { SecurityInformation: SECURITY_INFORMATION, DesiredAccess: LPDWORD } ],
  SetFileSecurityA: [ BOOL, { lpFileName: LPCSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  SetFileSecurityW: [ BOOL, { lpFileName: LPCWSTR, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  GetFileSecurityA: [ BOOL, { lpFileName: LPCSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  GetFileSecurityW: [ BOOL, { lpFileName: LPCWSTR, RequestedInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  SetKernelObjectSecurity: [ BOOL, { Handle: HANDLE, SecurityInformation: SECURITY_INFORMATION, SecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  FindFirstChangeNotificationA: [ HANDLE, { lpPathName: LPCSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD } ],
  FindFirstChangeNotificationW: [ HANDLE, { lpPathName: LPCWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD } ],
  FindNextChangeNotification: [ BOOL, { hChangeHandle: HANDLE } ],
  FindCloseChangeNotification: [ BOOL, { hChangeHandle: HANDLE } ],
  ReadDirectoryChangesW: [ BOOL, { hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE } ],
  VirtualLock: [ BOOL, { lpAddress: LPVOID, dwSize: SIZE_T } ],
  VirtualUnlock: [ BOOL, { lpAddress: LPVOID, dwSize: SIZE_T } ],
  MapViewOfFileEx: [ LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID } ],
  MapViewOfFileExNuma: [ LPVOID, { hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD } ],
  SetPriorityClass: [ BOOL, { hProcess: HANDLE, dwPriorityClass: DWORD } ],
  GetPriorityClass: [ DWORD, { hProcess: HANDLE } ],
  IsBadReadPtr: [ BOOL, { lp: PTR(VOID), ucb: UINT_PTR } ],
  IsBadWritePtr: [ BOOL, { lp: LPVOID, ucb: UINT_PTR } ],
  IsBadHugeReadPtr: [ BOOL, { lp: PTR(VOID), ucb: UINT_PTR } ],
  IsBadHugeWritePtr: [ BOOL, { lp: LPVOID, ucb: UINT_PTR } ],
  IsBadCodePtr: [ BOOL, { lpfn: FARPROC } ],
  IsBadStringPtrA: [ BOOL, { lpsz: LPCSTR, ucchMax: UINT_PTR } ],
  IsBadStringPtrW: [ BOOL, { lpsz: LPCWSTR, ucchMax: UINT_PTR } ],
  LookupAccountSidA: [ BOOL, { lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountSidW: [ BOOL, { lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountSidLocalA: [ BOOL, { Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountSidLocalW: [ BOOL, { Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountNameA: [ BOOL, { lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountNameW: [ BOOL, { lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountNameLocalA: [ BOOL, { lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupAccountNameLocalW: [ BOOL, { lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE } ],
  LookupPrivilegeValueA: [ BOOL, { lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID } ],
  LookupPrivilegeValueW: [ BOOL, { lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID } ],
  LookupPrivilegeNameA: [ BOOL, { lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD } ],
  LookupPrivilegeNameW: [ BOOL, { lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD } ],
  LookupPrivilegeDisplayNameA: [ BOOL, { lpSystemName: LPCSTR, lpName: LPCSTR, lpDisplayName: LPSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD } ],
  LookupPrivilegeDisplayNameW: [ BOOL, { lpSystemName: LPCWSTR, lpName: LPCWSTR, lpDisplayName: LPWSTR, cchDisplayName: LPDWORD, lpLanguageId: LPDWORD } ],
  AllocateLocallyUniqueId: [ BOOL, { Luid: PLUID } ],
  BuildCommDCBA: [ BOOL, { lpDef: LPCSTR, lpDCB: LPDCB } ],
  BuildCommDCBW: [ BOOL, { lpDef: LPCWSTR, lpDCB: LPDCB } ],
  BuildCommDCBAndTimeoutsA: [ BOOL, { lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS } ],
  BuildCommDCBAndTimeoutsW: [ BOOL, { lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS } ],
  CommConfigDialogA: [ BOOL, { lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG } ],
  CommConfigDialogW: [ BOOL, { lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG } ],
  GetDefaultCommConfigA: [ BOOL, { lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD } ],
  GetDefaultCommConfigW: [ BOOL, { lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD } ],
  SetDefaultCommConfigA: [ BOOL, { lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD } ],
  SetDefaultCommConfigW: [ BOOL, { lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD } ],
  GetComputerNameA: [ BOOL, { lpBuffer: LPSTR, nSize: LPDWORD } ],
  GetComputerNameW: [ BOOL, { lpBuffer: LPWSTR, nSize: LPDWORD } ],
  SetComputerNameA: [ BOOL, { lpComputerName: LPCSTR } ],
  SetComputerNameW: [ BOOL, { lpComputerName: LPCWSTR } ],
  GetComputerNameExA: [ BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD } ],
  GetComputerNameExW: [ BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD } ],
  SetComputerNameExA: [ BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCSTR } ],
  SetComputerNameExW: [ BOOL, { NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR } ],
  DnsHostnameToComputerNameA: [ BOOL, { Hostname: LPCSTR, ComputerName: LPSTR, nSize: LPDWORD } ],
  DnsHostnameToComputerNameW: [ BOOL, { Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD } ],
  GetUserNameA: [ BOOL, { lpBuffer: LPSTR, pcbBuffer: LPDWORD } ],
  GetUserNameW: [ BOOL, { lpBuffer: LPWSTR, pcbBuffer: LPDWORD } ],
  LogonUserA: [ BOOL, { lpszUsername: LPCSTR, lpszDomain: LPCSTR, lpszPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE } ],
  LogonUserW: [ BOOL, { lpszUsername: LPCWSTR, lpszDomain: LPCWSTR, lpszPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE } ],
  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 } ],
  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 } ],
  ImpersonateLoggedOnUser: [ BOOL, { hToken: HANDLE } ],
  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 } ],
  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 } ],
  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 } ],
  CreateProcessWithTokenW: [ BOOL, { hToken: HANDLE, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION } ],
  ImpersonateAnonymousToken: [ BOOL, { ThreadHandle: HANDLE } ],
  DuplicateTokenEx: [ BOOL, { hExistingToken: HANDLE, dwDesiredAccess: DWORD, lpTokenAttributes: LPSECURITY_ATTRIBUTES, ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, TokenType: TOKEN_TYPE, phNewToken: PHANDLE } ],
  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 } ],
  IsTokenRestricted: [ BOOL, { TokenHandle: HANDLE } ],
  IsTokenUntrusted: [ BOOL, { TokenHandle: HANDLE } ],
  CheckTokenMembership: [ BOOL, { TokenHandle: HANDLE, SidToCheck: PSID, IsMember: PBOOL } ],
  RegisterWaitForSingleObject: [ BOOL, { phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG } ],
  RegisterWaitForSingleObjectEx: [ HANDLE, { hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG } ],
  UnregisterWait: [ BOOL, { WaitHandle: HANDLE } ],
  UnregisterWaitEx: [ BOOL, { WaitHandle: HANDLE, CompletionEvent: HANDLE } ],
  QueueUserWorkItem: [ BOOL, { Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG } ],
  BindIoCompletionCallback: [ BOOL, { FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG } ],
  CreateTimerQueue: [ HANDLE, {  } ],
  CreateTimerQueueTimer: [ BOOL, { phNewTimer: PHANDLE, TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, Flags: ULONG } ],
  ChangeTimerQueueTimer: [ BOOL, { TimerQueue: HANDLE, Timer: HANDLE, DueTime: ULONG, Period: ULONG } ],
  DeleteTimerQueueTimer: [ BOOL, { TimerQueue: HANDLE, Timer: HANDLE, CompletionEvent: HANDLE } ],
  DeleteTimerQueueEx: [ BOOL, { TimerQueue: HANDLE, CompletionEvent: HANDLE } ],
  SetTimerQueueTimer: [ HANDLE, { TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: BOOL } ],
  CancelTimerQueueTimer: [ BOOL, { TimerQueue: HANDLE, Timer: HANDLE } ],
  DeleteTimerQueue: [ BOOL, { TimerQueue: HANDLE } ],
  CreateThreadpool: [ PTP_POOL, { reserved: PVOID } ],
  SetThreadpoolThreadMaximum: [ VOID, { ptpp: PTP_POOL, cthrdMost: DWORD } ],
  SetThreadpoolThreadMinimum: [ BOOL, { ptpp: PTP_POOL, cthrdMic: DWORD } ],
  SetThreadpoolStackInformation: [ BOOL, { ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION } ],
  QueryThreadpoolStackInformation: [ BOOL, { ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION } ],
  CloseThreadpool: [ VOID, { ptpp: PTP_POOL } ],
  CreateThreadpoolCleanupGroup: [ PTP_CLEANUP_GROUP, {  } ],
  CloseThreadpoolCleanupGroupMembers: [ VOID, { ptpcg: PTP_CLEANUP_GROUP, fCancelPendingCallbacks: BOOL, pvCleanupContext: PVOID } ],
  CloseThreadpoolCleanupGroup: [ VOID, { ptpcg: PTP_CLEANUP_GROUP } ],
  InitializeThreadpoolEnvironment: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON } ],
  SetThreadpoolCallbackPool: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON, ptpp: PTP_POOL } ],
  SetThreadpoolCallbackCleanupGroup: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON, ptpcg: PTP_CLEANUP_GROUP, pfng: PTP_CLEANUP_GROUP_CANCEL_CALLBACK } ],
  SetThreadpoolCallbackRunsLong: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON } ],
  SetThreadpoolCallbackLibrary: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON, mod: PVOID } ],
  SetThreadpoolCallbackPriority: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON, Priority: TP_CALLBACK_PRIORITY } ],
  SetThreadpoolCallbackPersistent: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON } ],
  DestroyThreadpoolEnvironment: [ VOID, { pcbe: PTP_CALLBACK_ENVIRON } ],
  SetEventWhenCallbackReturns: [ VOID, { pci: PTP_CALLBACK_INSTANCE, evt: HANDLE } ],
  ReleaseSemaphoreWhenCallbackReturns: [ VOID, { pci: PTP_CALLBACK_INSTANCE, sem: HANDLE, crel: DWORD } ],
  ReleaseMutexWhenCallbackReturns: [ VOID, { pci: PTP_CALLBACK_INSTANCE, mut: HANDLE } ],
  LeaveCriticalSectionWhenCallbackReturns: [ VOID, { pci: PTP_CALLBACK_INSTANCE, pcs: PCRITICAL_SECTION } ],
  FreeLibraryWhenCallbackReturns: [ VOID, { pci: PTP_CALLBACK_INSTANCE, mod: HMODULE } ],
  CallbackMayRunLong: [ BOOL, { pci: PTP_CALLBACK_INSTANCE } ],
  DisassociateCurrentThreadFromCallback: [ VOID, { pci: PTP_CALLBACK_INSTANCE } ],
  TrySubmitThreadpoolCallback: [ BOOL, { pfns: PTP_SIMPLE_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON } ],
  CreateThreadpoolWork: [ PTP_WORK, { pfnwk: PTP_WORK_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON } ],
  SubmitThreadpoolWork: [ VOID, { pwk: PTP_WORK } ],
  WaitForThreadpoolWorkCallbacks: [ VOID, { pwk: PTP_WORK, fCancelPendingCallbacks: BOOL } ],
  CloseThreadpoolWork: [ VOID, { pwk: PTP_WORK } ],
  CreateThreadpoolTimer: [ PTP_TIMER, { pfnti: PTP_TIMER_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON } ],
  SetThreadpoolTimer: [ VOID, { pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD } ],
  IsThreadpoolTimerSet: [ BOOL, { pti: PTP_TIMER } ],
  WaitForThreadpoolTimerCallbacks: [ VOID, { pti: PTP_TIMER, fCancelPendingCallbacks: BOOL } ],
  CloseThreadpoolTimer: [ VOID, { pti: PTP_TIMER } ],
  CreateThreadpoolWait: [ PTP_WAIT, { pfnwa: PTP_WAIT_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON } ],
  SetThreadpoolWait: [ VOID, { pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME } ],
  WaitForThreadpoolWaitCallbacks: [ VOID, { pwa: PTP_WAIT, fCancelPendingCallbacks: BOOL } ],
  CloseThreadpoolWait: [ VOID, { pwa: PTP_WAIT } ],
  CreateThreadpoolIo: [ PTP_IO, { fl: HANDLE, pfnio: PTP_WIN32_IO_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON } ],
  StartThreadpoolIo: [ VOID, { pio: PTP_IO } ],
  CancelThreadpoolIo: [ VOID, { pio: PTP_IO } ],
  WaitForThreadpoolIoCallbacks: [ VOID, { pio: PTP_IO, fCancelPendingCallbacks: BOOL } ],
  CloseThreadpoolIo: [ VOID, { pio: PTP_IO } ],
  CreatePrivateNamespaceA: [ HANDLE, { lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR } ],
  CreatePrivateNamespaceW: [ HANDLE, { lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR } ],
  OpenPrivateNamespaceA: [ HANDLE, { lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR } ],
  OpenPrivateNamespaceW: [ HANDLE, { lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR } ],
  ClosePrivateNamespace: [ BOOLEAN, { Handle: HANDLE, Flags: ULONG } ],
  CreateBoundaryDescriptorA: [ HANDLE, { Name: LPCSTR, Flags: ULONG } ],
  CreateBoundaryDescriptorW: [ HANDLE, { Name: LPCWSTR, Flags: ULONG } ],
  AddSIDToBoundaryDescriptor: [ BOOL, { BoundaryDescriptor: PTR(PTR(VOID)), RequiredSid: PSID } ],
  AddIntegrityLabelToBoundaryDescriptor: [ BOOL, { BoundaryDescriptor: PTR(PTR(VOID)), IntegrityLabel: PSID } ],
  DeleteBoundaryDescriptor: [ VOID, { BoundaryDescriptor: HANDLE } ],
  GetCurrentHwProfileA: [ BOOL, { lpHwProfileInfo: LPHW_PROFILE_INFOA } ],
  GetCurrentHwProfileW: [ BOOL, { lpHwProfileInfo: LPHW_PROFILE_INFOW } ],
  QueryPerformanceCounter: [ BOOL, { lpPerformanceCount: PTR(uint) } ],
  QueryPerformanceFrequency: [ BOOL, { lpFrequency: PTR(uint) } ],
  GetVersionExA: [ BOOL, { lpVersionInformation: LPOSVERSIONINFOA } ],
  GetVersionExW: [ BOOL, { lpVersionInformation: LPOSVERSIONINFOW } ],
  VerifyVersionInfoA: [ BOOL, { lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG } ],
  VerifyVersionInfoW: [ BOOL, { lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG } ],
  GetProductInfo: [ BOOL, { dwOSMajorVersion: DWORD, dwOSMinorVersion: DWORD, dwSpMajorVersion: DWORD, dwSpMinorVersion: DWORD, pdwReturnedProductType: PDWORD } ],
  HRESULT_FROM_WIN32: [ HRESULT, { x: ulong } ],
  GetSystemPowerStatus: [ BOOL, { lpSystemPowerStatus: LPSYSTEM_POWER_STATUS } ],
  SetSystemPowerState: [ BOOL, { fSuspend: BOOL, fForce: BOOL } ],
  AllocateUserPhysicalPages: [ BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR } ],
  AllocateUserPhysicalPagesNuma: [ BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD } ],
  FreeUserPhysicalPages: [ BOOL, { hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR } ],
  MapUserPhysicalPages: [ BOOL, { VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR } ],
  MapUserPhysicalPagesScatter: [ BOOL, { VirtualAddresses: PTR(PTR(VOID)), NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR } ],
  CreateJobObjectA: [ HANDLE, { lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR } ],
  CreateJobObjectW: [ HANDLE, { lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR } ],
  OpenJobObjectA: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR } ],
  OpenJobObjectW: [ HANDLE, { dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR } ],
  AssignProcessToJobObject: [ BOOL, { hJob: HANDLE, hProcess: HANDLE } ],
  TerminateJobObject: [ BOOL, { hJob: HANDLE, uExitCode: UINT } ],
  QueryInformationJobObject: [ BOOL, { hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD, lpReturnLength: LPDWORD } ],
  SetInformationJobObject: [ BOOL, { hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD } ],
  IsProcessInJob: [ BOOL, { ProcessHandle: HANDLE, JobHandle: HANDLE, Result: PBOOL } ],
  CreateJobSet: [ BOOL, { NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG } ],
  AddVectoredExceptionHandler: [ PVOID, { First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER } ],
  RemoveVectoredExceptionHandler: [ ULONG, { Handle: PVOID } ],
  AddVectoredContinueHandler: [ PVOID, { First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER } ],
  RemoveVectoredContinueHandler: [ ULONG, { Handle: PVOID } ],
  FindFirstVolumeA: [ HANDLE, { lpszVolumeName: LPSTR, cchBufferLength: DWORD } ],
  FindFirstVolumeW: [ HANDLE, { lpszVolumeName: LPWSTR, cchBufferLength: DWORD } ],
  FindNextVolumeA: [ BOOL, { hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD } ],
  FindNextVolumeW: [ BOOL, { hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD } ],
  FindVolumeClose: [ BOOL, { hFindVolume: HANDLE } ],
  FindFirstVolumeMountPointA: [ HANDLE, { lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD } ],
  FindFirstVolumeMountPointW: [ HANDLE, { lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD } ],
  FindNextVolumeMountPointA: [ BOOL, { hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD } ],
  FindNextVolumeMountPointW: [ BOOL, { hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD } ],
  FindVolumeMountPointClose: [ BOOL, { hFindVolumeMountPoint: HANDLE } ],
  SetVolumeMountPointA: [ BOOL, { lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR } ],
  SetVolumeMountPointW: [ BOOL, { lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR } ],
  DeleteVolumeMountPointA: [ BOOL, { lpszVolumeMountPoint: LPCSTR } ],
  DeleteVolumeMountPointW: [ BOOL, { lpszVolumeMountPoint: LPCWSTR } ],
  GetVolumeNameForVolumeMountPointA: [ BOOL, { lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD } ],
  GetVolumeNameForVolumeMountPointW: [ BOOL, { lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD } ],
  GetVolumePathNameA: [ BOOL, { lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD } ],
  GetVolumePathNameW: [ BOOL, { lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD } ],
  GetVolumePathNamesForVolumeNameA: [ BOOL, { lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD } ],
  GetVolumePathNamesForVolumeNameW: [ BOOL, { lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD } ],
  CreateActCtxA: [ HANDLE, { pActCtx: PCACTCTXA } ],
  CreateActCtxW: [ HANDLE, { pActCtx: PCACTCTXW } ],
  AddRefActCtx: [ VOID, { hActCtx: HANDLE } ],
  ReleaseActCtx: [ VOID, { hActCtx: HANDLE } ],
  ZombifyActCtx: [ BOOL, { hActCtx: HANDLE } ],
  ActivateActCtx: [ BOOL, { hActCtx: HANDLE, lpCookie: PTR(ulong) } ],
  DeactivateActCtx: [ BOOL, { dwFlags: DWORD, ulCookie: ULONG_PTR } ],
  GetCurrentActCtx: [ BOOL, { lphActCtx: PTR(PTR(VOID)) } ],
  FindActCtxSectionStringA: [ BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA } ],
  FindActCtxSectionStringW: [ BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA } ],
  FindActCtxSectionGuid: [ BOOL, { dwFlags: DWORD, lpExtensionGuid: PTR(uint), ulSectionId: ULONG, lpGuidToFind: PTR(uint), ReturnedData: PACTCTX_SECTION_KEYED_DATA } ],
  QueryActCtxW: [ BOOL, { dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: PTR(ulong) } ],
  ProcessIdToSessionId: [ BOOL, { dwProcessId: DWORD, pSessionId: PTR(ulong) } ],
  WTSGetActiveConsoleSessionId: [ DWORD, {  } ],
  IsWow64Process: [ BOOL, { hProcess: HANDLE, Wow64Process: PBOOL } ],
  GetLogicalProcessorInformation: [ BOOL, { Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, ReturnedLength: PDWORD } ],
  GetLogicalProcessorInformationEx: [ BOOL, { RelationshipType: LOGICAL_PROCESSOR_RELATIONSHIP, Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, ReturnedLength: PDWORD } ],
  GetActiveProcessorGroupCount: [ WORD, {  } ],
  GetMaximumProcessorGroupCount: [ WORD, {  } ],
  GetActiveProcessorCount: [ DWORD, { GroupNumber: WORD } ],
  GetMaximumProcessorCount: [ DWORD, { GroupNumber: WORD } ],
  GetNumaHighestNodeNumber: [ BOOL, { HighestNodeNumber: PULONG } ],
  GetNumaProcessorNode: [ BOOL, { Processor: UCHAR, NodeNumber: PUCHAR } ],
  GetNumaNodeNumberFromHandle: [ BOOL, { hFile: HANDLE, NodeNumber: PUSHORT } ],
  GetNumaProcessorNodeEx: [ BOOL, { Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT } ],
  GetNumaNodeProcessorMask: [ BOOL, { Node: UCHAR, ProcessorMask: PULONGLONG } ],
  GetNumaNodeProcessorMaskEx: [ BOOL, { Node: USHORT, ProcessorMask: PGROUP_AFFINITY } ],
  GetNumaAvailableMemoryNode: [ BOOL, { Node: UCHAR, AvailableBytes: PULONGLONG } ],
  GetNumaAvailableMemoryNodeEx: [ BOOL, { Node: USHORT, AvailableBytes: PULONGLONG } ],
  GetNumaProximityNode: [ BOOL, { ProximityId: ULONG, NodeNumber: PUCHAR } ],
  GetNumaProximityNodeEx: [ BOOL, { ProximityId: ULONG, NodeNumber: PUSHORT } ],
  RegisterApplicationRecoveryCallback: [ HRESULT, { pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD } ],
  UnregisterApplicationRecoveryCallback: [ HRESULT, {  } ],
  RegisterApplicationRestart: [ HRESULT, { pwzCommandline: PCWSTR, dwFlags: DWORD } ],
  UnregisterApplicationRestart: [ HRESULT, {  } ],
  GetApplicationRecoveryCallback: [ HRESULT, { hProcess: HANDLE, pRecoveryCallback: PTR(APPLICATION_RECOVERY_CALLBACK), ppvParameter: PTR(PTR(VOID)), pdwPingInterval: PDWORD, pdwFlags: PDWORD } ],
  GetApplicationRestartSettings: [ HRESULT, { hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD } ],
  ApplicationRecoveryInProgress: [ HRESULT, { pbCancelled: PBOOL } ],
  ApplicationRecoveryFinished: [ VOID, { bSuccess: BOOL } ],
  SetFileInformationByHandle: [ BOOL, { hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD } ],
  GetFileInformationByHandleEx: [ BOOL, { hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD } ],
  OpenFileById: [ HANDLE, { hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD } ],
  CreateSymbolicLinkA: [ BOOLEAN, { lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD } ],
  CreateSymbolicLinkW: [ BOOLEAN, { lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD } ],
  CreateSymbolicLinkTransactedA: [ BOOLEAN, { lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE } ],
  CreateSymbolicLinkTransactedW: [ BOOLEAN, { lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE } ],
  GetFinalPathNameByHandleA: [ DWORD, { hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD } ],
  GetFinalPathNameByHandleW: [ DWORD, { hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD } ],
  QueryActCtxSettingsW: [ BOOL, { dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: PTR(ulong) } ],
  ReplacePartitionUnit: [ BOOL, { TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG } ],
  AddSecureMemoryCacheCallback: [ BOOL, { pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK } ],
  RemoveSecureMemoryCacheCallback: [ BOOL, { pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK } ],
  CopyExtendedContext: [ BOOL, { Destination: PCONTEXT_EX, ContextFlags: DWORD, Source: PCONTEXT_EX } ],
  InitializeExtendedContext: [ BOOL, { Context: PVOID, ContextFlags: DWORD, ContextEx: PTR(VOIDPTR) } ],
  GetEnabledExtendedFeatures: [ DWORD64, { FeatureMask: DWORD64 } ],
  GetExtendedContextLength: [ BOOL, { ContextFlags: DWORD, ContextLength: PDWORD } ],
  GetExtendedFeaturesMask: [ DWORD64, { ContextEx: PCONTEXT_EX } ],
  LocateExtendedFeature: [ PVOID, { ContextEx: PCONTEXT_EX, FeatureId: DWORD, Length: PDWORD } ],
  LocateLegacyContext: [ PCONTEXT, { ContextEx: PCONTEXT_EX, Length: PDWORD } ],
  SetExtendedFeaturesMask: [ VOID, { ContextEx: PCONTEXT_EX, FeatureMask: DWORD64 } ],
  EnableThreadProfiling: [ DWORD, { ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: PTR(PTR(VOID)) } ],
  DisableThreadProfiling: [ DWORD, { PerformanceDataHandle: HANDLE } ],
  QueryThreadProfiling: [ DWORD, { ThreadHandle: HANDLE, Enabled: PBOOLEAN } ],
  ReadThreadProfilingData: [ DWORD, { PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA } ],
  AddFontResourceA: [ VOID, { LPCSTR: LPCSTR } ],
  AddFontResourceW: [ VOID, { LPCWSTR: LPCWSTR } ],
  AnimatePalette: [ BOOL, { hPal: HPALETTE, iStartIndex: UINT, cEntries: UINT, ppe: PTR(uint) } ],
  Arc: [ BOOL, { hdc: HDC, x1: int, y1: int, x2: int, y2: int, x3: int, y3: int, x4: int, y4: int } ],
  BitBlt: [ BOOL, { hdc: HDC, x: int, y: int, cx: int, cy: int, hdcSrc: HDC, x1: int, y1: int, rop: DWORD } ],
  CancelDC: [ BOOL, { hdc: HDC } ],
  Chord: [ BOOL, { hdc: HDC, x1: int, y1: int, x2: int, y2: int, x3: int, y3: int, x4: int, y4: int } ],
  ChoosePixelFormat: [ VOID, { hdc: HDC, ppfd: PTR(uint) } ],
  CloseMetaFile: [ HMETAFILE, { hdc: HDC } ],
  CombineRgn: [ VOID, { hrgnDst: HRGN, hrgnSrc1: HRGN, hrgnSrc2: HRGN, iMode: int } ],
  CopyMetaFileA: [ HMETAFILE, { LPCSTR: LPCSTR } ],
  CopyMetaFileW: [ HMETAFILE, { LPCWSTR: LPCWSTR } ],
  CreateBitmap: [ HBITMAP, { nWidth: int, nHeight: int, nPlanes: UINT, nBitCount: UINT, lpBits: PTR(VOID) } ],
  CreateBitmapIndirect: [ HBITMAP, { pbm: PTR(uint) } ],
  CreateBrushIndirect: [ HBRUSH, { plbrush: PTR(uint) } ],
  CreateCompatibleBitmap: [ HBITMAP, { hdc: HDC, cx: int, cy: int } ],
  CreateDiscardableBitmap: [ HBITMAP, { hdc: HDC, cx: int, cy: int } ],
  CreateCompatibleDC: [ HDC, { hdc: HDC } ],
  CreateDCA: [ HDC, { pwszDriver: LPCSTR, pwszDevice: LPCSTR, pszPort: LPCSTR, pdm: PTR(uint) } ],
  CreateDCW: [ HDC, { pwszDriver: LPCWSTR, pwszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: PTR(uint) } ],
  CreateDIBitmap: [ HBITMAP, { hdc: HDC, pbmih: PTR(uint), flInit: DWORD, pjBits: PTR(VOID), pbmi: PTR(uint), iUsage: UINT } ],
  CreateDIBPatternBrush: [ HBRUSH, { h: HGLOBAL, iUsage: UINT } ],
  CreateDIBPatternBrushPt: [ HBRUSH, { lpPackedDIB: PTR(VOID), iUsage: UINT } ],
  CreateEllipticRgn: [ HRGN, { x1: int, y1: int, x2: int, y2: int } ],
  CreateEllipticRgnIndirect: [ HRGN, { lprect: PTR(uint) } ],
  CreateFontIndirectA: [ HFONT, { lplf: PTR(uint) } ],
  CreateFontIndirectW: [ HFONT, { lplf: PTR(uint) } ],
  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 } ],
  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 } ],
  CreateHatchBrush: [ HBRUSH, { iHatch: int, color: COLORREF } ],
  CreateICA: [ HDC, { pszDriver: LPCSTR, pszDevice: LPCSTR, pszPort: LPCSTR, pdm: PTR(uint) } ],
  CreateICW: [ HDC, { pszDriver: LPCWSTR, pszDevice: LPCWSTR, pszPort: LPCWSTR, pdm: PTR(uint) } ],
  CreateMetaFileA: [ HDC, { pszFile: LPCSTR } ],
  CreateMetaFileW: [ HDC, { pszFile: LPCWSTR } ],
  CreatePalette: [ HPALETTE, { plpal: PTR(uint) } ],
  CreatePen: [ HPEN, { iStyle: int, cWidth: int, color: COLORREF } ],
  CreatePenIndirect: [ HPEN, { plpen: PTR(uint) } ],
  CreatePolyPolygonRgn: [ HRGN, { pptl: PTR(uint), pc: PTR(int), cPoly: int, iMode: int } ],
  CreatePatternBrush: [ HBRUSH, { hbm: HBITMAP } ],
  CreateRectRgn: [ HRGN, { x1: int, y1: int, x2: int, y2: int } ],
  CreateRectRgnIndirect: [ HRGN, { lprect: PTR(uint) } ],
  CreateRoundRectRgn: [ HRGN, { x1: int, y1: int, x2: int, y2: int, w: int, h: int } ],
  CreateScalableFontResourceA: [ BOOL, { fdwHidden: DWORD, lpszFont: LPCSTR, lpszFile: LPCSTR, lpszPath: LPCSTR } ],
  CreateScalableFontResourceW: [ BOOL, { fdwHidden: DWORD, lpszFont: LPCWSTR, lpszFile: LPCWSTR, lpszPath: LPCWSTR } ],
  CreateSolidBrush: [ HBRUSH, { color: COLORREF } ],
  DeleteDC: [ BOOL, { hdc: HDC } ],
  DeleteMetaFile: [ BOOL, { hmf: HMETAFILE } ],
  DeleteObject: [ BOOL, { ho: HGDIOBJ } ],
  DescribePixelFormat: [ VOID, { hdc: HDC, iPixelFormat: int, nBytes: UINT, ppfd: LPPIXELFORMATDESCRIPTOR } ],
  DeviceCapabilitiesA: [ VOID, { pDevice: LPCSTR, pPort: LPCSTR, fwCapability: WORD, pOutput: LPSTR, pDevMode: PTR(uint) } ],
  DeviceCapabilitiesW: [ VOID, { pDevice: LPCWSTR, pPort: LPCWSTR, fwCapability: WORD, pOutput: LPWSTR, pDevMode: PTR(uint) } ],
  DrawEscape: [ VOID, { hdc: HDC, iEscape: int, cjIn: int, lpIn: LPCSTR } ],
  Ellipse: [ BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int } ],
  EnumFontFamiliesExA: [ VOID, { hdc: HDC, lpLogfont: LPLOGFONTA, lpProc: FONTENUMPROCA, lParam: LPARAM, dwFlags: DWORD } ],
  EnumFontFamiliesExW: [ VOID, { hdc: HDC, lpLogfont: LPLOGFONTW, lpProc: FONTENUMPROCW, lParam: LPARAM, dwFlags: DWORD } ],
  EnumFontFamiliesA: [ VOID, { hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM } ],
  EnumFontFamiliesW: [ VOID, { hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM } ],
  EnumFontsA: [ VOID, { hdc: HDC, lpLogfont: LPCSTR, lpProc: FONTENUMPROCA, lParam: LPARAM } ],
  EnumFontsW: [ VOID, { hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM } ],
  EnumObjects: [ VOID, { hdc: HDC, nType: int, lpFunc: GOBJENUMPROC, lParam: LPARAM } ],
  EqualRgn: [ BOOL, { hrgn1: HRGN, hrgn2: HRGN } ],
  Escape: [ VOID, { hdc: HDC, iEscape: int, cjIn: int, pvIn: LPCSTR, pvOut: LPVOID } ],
  ExtEscape: [ VOID, { hdc: HDC, iEscape: int, cjInput: int, lpInData: LPCSTR, cjOutput: int, lpOutData: LPSTR } ],
  ExcludeClipRect: [ VOID, { hdc: HDC, left: int, top: int, right: int, bottom: int } ],
  ExtCreateRegion: [ HRGN, { lpx: PTR(uint), nCount: DWORD, lpData: PTR(uint) } ],
  ExtFloodFill: [ BOOL, { hdc: HDC, x: int, y: int, color: COLORREF, type: UINT } ],
  FillRgn: [ BOOL, { hdc: HDC, hrgn: HRGN, hbr: HBRUSH } ],
  FloodFill: [ BOOL, { hdc: HDC, x: int, y: int, color: COLORREF } ],
  FrameRgn: [ BOOL, { hdc: HDC, hrgn: HRGN, hbr: HBRUSH, w: int, h: int } ],
  GetROP2: [ VOID, { hdc: HDC } ],
  GetAspectRatioFilterEx: [ BOOL, { hdc: HDC, lpsize: LPSIZE } ],
  GetBkColor: [ COLORREF, { hdc: HDC } ],
  GetDCBrushColor: [ COLORREF, { hdc: HDC } ],
  GetDCPenColor: [ COLORREF, { hdc: HDC } ],
  GetBkMode: [ VOID, { hdc: HDC } ],
  GetBitmapBits: [ LONG, { hbit: HBITMAP, cb: LONG, lpvBits: LPVOID } ],
  GetBitmapDimensionEx: [ BOOL, { hbit: HBITMAP, lpsize: LPSIZE } ],
  GetBoundsRect: [ UINT, { hdc: HDC, lprect: LPRECT, flags: UINT } ],
  GetBrushOrgEx: [ BOOL, { hdc: HDC, lppt: LPPOINT } ],
  GetCharWidthA: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT } ],
  GetCharWidthW: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT } ],
  GetCharWidth32A: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT } ],
  GetCharWidth32W: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: LPINT } ],
  GetCharWidthFloatA: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT } ],
  GetCharWidthFloatW: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpBuffer: PFLOAT } ],
  GetCharABCWidthsA: [ BOOL, { hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC } ],
  GetCharABCWidthsW: [ BOOL, { hdc: HDC, wFirst: UINT, wLast: UINT, lpABC: LPABC } ],
  GetCharABCWidthsFloatA: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT } ],
  GetCharABCWidthsFloatW: [ BOOL, { hdc: HDC, iFirst: UINT, iLast: UINT, lpABC: LPABCFLOAT } ],
  GetClipBox: [ VOID, { hdc: HDC, lprect: LPRECT } ],
  GetClipRgn: [ VOID, { hdc: HDC, hrgn: HRGN } ],
  GetMetaRgn: [ VOID, { hdc: HDC, hrgn: HRGN } ],
  GetCurrentObject: [ HGDIOBJ, { hdc: HDC, type: UINT } ],
  GetCurrentPositionEx: [ BOOL, { hdc: HDC, lppt: LPPOINT } ],
  GetDeviceCaps: [ VOID, { hdc: HDC, index: int } ],
  GetDIBits: [ VOID, { hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpvBits: LPVOID, lpbmi: LPBITMAPINFO, usage: UINT } ],
  GetFontData: [ DWORD, { hdc: HDC, dwTable: DWORD, dwOffset: DWORD, pvBuffer: PVOID, cjBuffer: DWORD } ],
  GetGlyphOutlineA: [ DWORD, { hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: PTR(uint) } ],
  GetGlyphOutlineW: [ DWORD, { hdc: HDC, uChar: UINT, fuFormat: UINT, lpgm: LPGLYPHMETRICS, cjBuffer: DWORD, pvBuffer: LPVOID, lpmat2: PTR(uint) } ],
  GetGraphicsMode: [ VOID, { hdc: HDC } ],
  GetMapMode: [ VOID, { hdc: HDC } ],
  GetMetaFileBitsEx: [ UINT, { hMF: HMETAFILE, cbBuffer: UINT, lpData: LPVOID } ],
  GetMetaFileA: [ HMETAFILE, { lpName: LPCSTR } ],
  GetMetaFileW: [ HMETAFILE, { lpName: LPCWSTR } ],
  GetNearestColor: [ COLORREF, { hdc: HDC, color: COLORREF } ],
  GetNearestPaletteIndex: [ UINT, { h: HPALETTE, color: COLORREF } ],
  GetObjectType: [ DWORD, { h: HGDIOBJ } ],
  GetOutlineTextMetricsA: [ UINT, { hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICA } ],
  GetOutlineTextMetricsW: [ UINT, { hdc: HDC, cjCopy: UINT, potm: LPOUTLINETEXTMETRICW } ],
  GetPaletteEntries: [ UINT, { hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY } ],
  GetPixel: [ COLORREF, { hdc: HDC, x: int, y: int } ],
  GetPixelFormat: [ VOID, { hdc: HDC } ],
  GetPolyFillMode: [ VOID, { hdc: HDC } ],
  GetRasterizerCaps: [ BOOL, { lpraststat: LPRASTERIZER_STATUS, cjBytes: UINT } ],
  GetRandomRgn: [ VOID, { hdc: HDC, hrgn: HRGN, i: INT } ],
  GetRegionData: [ DWORD, { hrgn: HRGN, nCount: DWORD, lpRgnData: LPRGNDATA } ],
  GetRgnBox: [ VOID, { hrgn: HRGN, lprc: LPRECT } ],
  GetStockObject: [ HGDIOBJ, { i: int } ],
  GetStretchBltMode: [ VOID, { hdc: HDC } ],
  GetSystemPaletteEntries: [ UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, pPalEntries: LPPALETTEENTRY } ],
  GetSystemPaletteUse: [ UINT, { hdc: HDC } ],
  GetTextCharacterExtra: [ VOID, { hdc: HDC } ],
  GetTextAlign: [ UINT, { hdc: HDC } ],
  GetTextColor: [ COLORREF, { hdc: HDC } ],
  GetTextExtentPointA: [ BOOL, { hdc: HDC, lpString: LPCSTR, c: int, lpsz: LPSIZE } ],
  GetTextExtentPointW: [ BOOL, { hdc: HDC, lpString: LPCWSTR, c: int, lpsz: LPSIZE } ],
  GetTextExtentPoint32A: [ BOOL, { hdc: HDC, lpString: LPCSTR, c: int, psizl: LPSIZE } ],
  GetTextExtentPoint32W: [ BOOL, { hdc: HDC, lpString: LPCWSTR, c: int, psizl: LPSIZE } ],
  GetTextExtentExPointA: [ BOOL, { hdc: HDC, lpszString: LPCSTR, cchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE } ],
  GetTextExtentExPointW: [ BOOL, { hdc: HDC, lpszString: LPCWSTR, cchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE } ],
  GetTextCharset: [ VOID, { hdc: HDC } ],
  GetTextCharsetInfo: [ VOID, { hdc: HDC, lpSig: LPFONTSIGNATURE, dwFlags: DWORD } ],
  TranslateCharsetInfo: [ BOOL, { lpSrc: PTR(ulong), lpCs: LPCHARSETINFO, dwFlags: DWORD } ],
  GetFontLanguageInfo: [ DWORD, { hdc: HDC } ],
  GetCharacterPlacementA: [ DWORD, { hdc: HDC, lpString: LPCSTR, nCount: int, nMexExtent: int, lpResults: LPGCP_RESULTSA, dwFlags: DWORD } ],
  GetCharacterPlacementW: [ DWORD, { hdc: HDC, lpString: LPCWSTR, nCount: int, nMexExtent: int, lpResults: LPGCP_RESULTSW, dwFlags: DWORD } ],
  GetFontUnicodeRanges: [ DWORD, { hdc: HDC, lpgs: LPGLYPHSET } ],
  GetGlyphIndicesA: [ DWORD, { hdc: HDC, lpstr: LPCSTR, c: int, pgi: LPWORD, fl: DWORD } ],
  GetGlyphIndicesW: [ DWORD, { hdc: HDC, lpstr: LPCWSTR, c: int, pgi: LPWORD, fl: DWORD } ],
  GetTextExtentPointI: [ BOOL, { hdc: HDC, pgiIn: LPWORD, cgi: int, psize: LPSIZE } ],
  GetTextExtentExPointI: [ BOOL, { hdc: HDC, lpwszString: LPWORD, cwchString: int, nMaxExtent: int, lpnFit: LPINT, lpnDx: LPINT, lpSize: LPSIZE } ],
  GetCharWidthI: [ BOOL, { hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, piWidths: LPINT } ],
  GetCharABCWidthsI: [ BOOL, { hdc: HDC, giFirst: UINT, cgi: UINT, pgi: LPWORD, pabc: LPABC } ],
  AddFontResourceExA: [ VOID, { name: LPCSTR, fl: DWORD, res: PVOID } ],
  AddFontResourceExW: [ VOID, { name: LPCWSTR, fl: DWORD, res: PVOID } ],
  RemoveFontResourceExA: [ BOOL, { name: LPCSTR, fl: DWORD, pdv: PVOID } ],
  RemoveFontResourceExW: [ BOOL, { name: LPCWSTR, fl: DWORD, pdv: PVOID } ],
  AddFontMemResourceEx: [ HANDLE, { pFileView: PVOID, cjSize: DWORD, pvResrved: PVOID, pNumFonts: PTR(ulong) } ],
  RemoveFontMemResourceEx: [ BOOL, { h: HANDLE } ],
  CreateFontIndirectExA: [ HFONT, { PTR(uint): PTR(uint) } ],
  CreateFontIndirectExW: [ HFONT, { PTR(uint): PTR(uint) } ],
  GetViewportExtEx: [ BOOL, { hdc: HDC, lpsize: LPSIZE } ],
  GetViewportOrgEx: [ BOOL, { hdc: HDC, lppoint: LPPOINT } ],
  GetWindowExtEx: [ BOOL, { hdc: HDC, lpsize: LPSIZE } ],
  GetWindowOrgEx: [ BOOL, { hdc: HDC, lppoint: LPPOINT } ],
  IntersectClipRect: [ VOID, { hdc: HDC, left: int, top: int, right: int, bottom: int } ],
  InvertRgn: [ BOOL, { hdc: HDC, hrgn: HRGN } ],
  LineDDA: [ BOOL, { xStart: int, yStart: int, xEnd: int, yEnd: int, lpProc: LINEDDAPROC, data: LPARAM } ],
  LineTo: [ BOOL, { hdc: HDC, x: int, y: int } ],
  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 } ],
  PlgBlt: [ BOOL, { hdcDest: HDC, lpPoint: PTR(uint), hdcSrc: HDC, xSrc: int, ySrc: int, width: int, height: int, hbmMask: HBITMAP, xMask: int, yMask: int } ],
  OffsetClipRgn: [ VOID, { hdc: HDC, x: int, y: int } ],
  OffsetRgn: [ VOID, { hrgn: HRGN, x: int, y: int } ],
  PatBlt: [ BOOL, { hdc: HDC, x: int, y: int, w: int, h: int, rop: DWORD } ],
  Pie: [ BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, xr1: int, yr1: int, xr2: int, yr2: int } ],
  PlayMetaFile: [ BOOL, { hdc: HDC, hmf: HMETAFILE } ],
  PaintRgn: [ BOOL, { hdc: HDC, hrgn: HRGN } ],
  PolyPolygon: [ BOOL, { hdc: HDC, apt: PTR(uint), asz: PTR(int), csz: int } ],
  PtInRegion: [ BOOL, { hrgn: HRGN, x: int, y: int } ],
  PtVisible: [ BOOL, { hdc: HDC, x: int, y: int } ],
  RectInRegion: [ BOOL, { hrgn: HRGN, lprect: PTR(uint) } ],
  RectVisible: [ BOOL, { hdc: HDC, lprect: PTR(uint) } ],
  Rectangle: [ BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int } ],
  RestoreDC: [ BOOL, { hdc: HDC, nSavedDC: int } ],
  ResetDCA: [ HDC, { hdc: HDC, lpdm: PTR(uint) } ],
  ResetDCW: [ HDC, { hdc: HDC, lpdm: PTR(uint) } ],
  RealizePalette: [ UINT, { hdc: HDC } ],
  RemoveFontResourceA: [ BOOL, { lpFileName: LPCSTR } ],
  RemoveFontResourceW: [ BOOL, { lpFileName: LPCWSTR } ],
  RoundRect: [ BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, width: int, height: int } ],
  ResizePalette: [ BOOL, { hpal: HPALETTE, n: UINT } ],
  SaveDC: [ VOID, { hdc: HDC } ],
  SelectClipRgn: [ VOID, { hdc: HDC, hrgn: HRGN } ],
  ExtSelectClipRgn: [ VOID, { hdc: HDC, hrgn: HRGN, mode: int } ],
  SetMetaRgn: [ VOID, { hdc: HDC } ],
  SelectObject: [ HGDIOBJ, { hdc: HDC, h: HGDIOBJ } ],
  SelectPalette: [ HPALETTE, { hdc: HDC, hPal: HPALETTE, bForceBkgd: BOOL } ],
  SetBkColor: [ COLORREF, { hdc: HDC, color: COLORREF } ],
  SetDCBrushColor: [ COLORREF, { hdc: HDC, color: COLORREF } ],
  SetDCPenColor: [ COLORREF, { hdc: HDC, color: COLORREF } ],
  SetBkMode: [ VOID, { hdc: HDC, mode: int } ],
  SetBitmapBits: [ LONG, { hbm: HBITMAP, cb: DWORD, pvBits: PTR(VOID) } ],
  SetBoundsRect: [ UINT, { hdc: HDC, lprect: PTR(uint), flags: UINT } ],
  SetDIBits: [ VOID, { hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpBits: PTR(VOID), lpbmi: PTR(uint), ColorUse: UINT } ],
  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 } ],
  SetMapperFlags: [ DWORD, { hdc: HDC, flags: DWORD } ],
  SetGraphicsMode: [ VOID, { hdc: HDC, iMode: int } ],
  SetMapMode: [ VOID, { hdc: HDC, iMode: int } ],
  SetLayout: [ DWORD, { hdc: HDC, l: DWORD } ],
  GetLayout: [ DWORD, { hdc: HDC } ],
  SetMetaFileBitsEx: [ HMETAFILE, { cbBuffer: UINT, lpData: PTR(uchar) } ],
  SetPaletteEntries: [ UINT, { hpal: HPALETTE, iStart: UINT, cEntries: UINT, pPalEntries: PTR(uint) } ],
  SetPixel: [ COLORREF, { hdc: HDC, x: int, y: int, color: COLORREF } ],
  SetPixelV: [ BOOL, { hdc: HDC, x: int, y: int, color: COLORREF } ],
  SetPixelFormat: [ BOOL, { hdc: HDC, format: int, ppfd: PTR(uint) } ],
  SetPolyFillMode: [ VOID, { hdc: HDC, mode: int } ],
  StretchBlt: [ BOOL, { hdcDest: HDC, xDest: int, yDest: int, wDest: int, hDest: int, hdcSrc: HDC, xSrc: int, ySrc: int, wSrc: int, hSrc: int, rop: DWORD } ],
  SetRectRgn: [ BOOL, { hrgn: HRGN, left: int, top: int, right: int, bottom: int } ],
  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 } ],
  SetROP2: [ VOID, { hdc: HDC, rop2: int } ],
  SetStretchBltMode: [ VOID, { hdc: HDC, mode: int } ],
  SetSystemPaletteUse: [ UINT, { hdc: HDC, use: UINT } ],
  SetTextCharacterExtra: [ VOID, { hdc: HDC, extra: int } ],
  SetTextColor: [ COLORREF, { hdc: HDC, color: COLORREF } ],
  SetTextAlign: [ UINT, { hdc: HDC, align: UINT } ],
  SetTextJustification: [ BOOL, { hdc: HDC, extra: int, count: int } ],
  UpdateColors: [ BOOL, { hdc: HDC } ],
  AlphaBlend: [ BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, ftn: BLENDFUNCTION } ],
  TransparentBlt: [ BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, crTransparent: UINT } ],
  GradientFill: [ BOOL, { hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nMesh: ULONG, ulMode: ULONG } ],
  GdiAlphaBlend: [ BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, ftn: BLENDFUNCTION } ],
  GdiTransparentBlt: [ BOOL, { hdcDest: HDC, xoriginDest: int, yoriginDest: int, wDest: int, hDest: int, hdcSrc: HDC, xoriginSrc: int, yoriginSrc: int, wSrc: int, hSrc: int, crTransparent: UINT } ],
  GdiGradientFill: [ BOOL, { hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nCount: ULONG, ulMode: ULONG } ],
  PlayMetaFileRecord: [ BOOL, { hdc: HDC, lpHandleTable: LPHANDLETABLE, lpMR: LPMETARECORD, noObjs: UINT } ],
  EnumMetaFile: [ BOOL, { hdc: HDC, hmf: HMETAFILE, proc: MFENUMPROC, param: LPARAM } ],
  CloseEnhMetaFile: [ HENHMETAFILE, { hdc: HDC } ],
  CopyEnhMetaFileA: [ HENHMETAFILE, { hEnh: HENHMETAFILE, lpFileName: LPCSTR } ],
  CopyEnhMetaFileW: [ HENHMETAFILE, { hEnh: HENHMETAFILE, lpFileName: LPCWSTR } ],
  CreateEnhMetaFileA: [ HDC, { hdc: HDC, lpFilename: LPCSTR, lprc: PTR(uint), lpDesc: LPCSTR } ],
  CreateEnhMetaFileW: [ HDC, { hdc: HDC, lpFilename: LPCWSTR, lprc: PTR(uint), lpDesc: LPCWSTR } ],
  DeleteEnhMetaFile: [ BOOL, { hmf: HENHMETAFILE } ],
  EnumEnhMetaFile: [ BOOL, { hdc: HDC, hmf: HENHMETAFILE, proc: ENHMFENUMPROC, param: LPVOID, lpRect: PTR(uint) } ],
  GetEnhMetaFileA: [ HENHMETAFILE, { lpName: LPCSTR } ],
  GetEnhMetaFileW: [ HENHMETAFILE, { lpName: LPCWSTR } ],
  GetEnhMetaFileBits: [ UINT, { hEMF: HENHMETAFILE, nSize: UINT, lpData: LPBYTE } ],
  GetEnhMetaFileDescriptionA: [ UINT, { hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPSTR } ],
  GetEnhMetaFileDescriptionW: [ UINT, { hemf: HENHMETAFILE, cchBuffer: UINT, lpDescription: LPWSTR } ],
  GetEnhMetaFileHeader: [ UINT, { hemf: HENHMETAFILE, nSize: UINT, lpEnhMetaHeader: LPENHMETAHEADER } ],
  GetEnhMetaFilePaletteEntries: [ UINT, { hemf: HENHMETAFILE, nNumEntries: UINT, lpPaletteEntries: LPPALETTEENTRY } ],
  GetEnhMetaFilePixelFormat: [ UINT, { hemf: HENHMETAFILE, cbBuffer: UINT, ppfd: PTR(uint) } ],
  GetWinMetaFileBits: [ UINT, { hemf: HENHMETAFILE, cbData16: UINT, pData16: LPBYTE, iMapMode: INT, hdcRef: HDC } ],
  PlayEnhMetaFile: [ BOOL, { hdc: HDC, hmf: HENHMETAFILE, lprect: PTR(uint) } ],
  PlayEnhMetaFileRecord: [ BOOL, { hdc: HDC, pht: LPHANDLETABLE, pmr: PTR(uint), cht: UINT } ],
  SetEnhMetaFileBits: [ HENHMETAFILE, { nSize: UINT, pb: PTR(uchar) } ],
  SetWinMetaFileBits: [ HENHMETAFILE, { nSize: UINT, lpMeta16Data: PTR(uchar), hdcRef: HDC, lpMFP: PTR(uint) } ],
  GdiComment: [ BOOL, { hdc: HDC, nSize: UINT, lpData: PTR(uchar) } ],
  GetTextMetricsA: [ BOOL, { hdc: HDC, lptm: LPTEXTMETRICA } ],
  GetTextMetricsW: [ BOOL, { hdc: HDC, lptm: LPTEXTMETRICW } ],
  AngleArc: [ BOOL, { hdc: HDC, x: int, y: int, r: DWORD, StartAngle: FLOAT, SweepAngle: FLOAT } ],
  PolyPolyline: [ BOOL, { hdc: HDC, apt: PTR(uint), asz: PTR(ulong), csz: DWORD } ],
  GetWorldTransform: [ BOOL, { hdc: HDC, lpxf: LPXFORM } ],
  SetWorldTransform: [ BOOL, { hdc: HDC, lpxf: PTR(uint) } ],
  ModifyWorldTransform: [ BOOL, { hdc: HDC, lpxf: PTR(uint), mode: DWORD } ],
  CombineTransform: [ BOOL, { lpxfOut: LPXFORM, lpxf1: PTR(uint), lpxf2: PTR(uint) } ],
  CreateDIBSection: [ HBITMAP, { hdc: HDC, lpbmi: PTR(uint), usage: UINT, ppvBits: PTR(PTR(VOID)), hSection: HANDLE, offset: DWORD } ],
  GetDIBColorTable: [ UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: PTR(uint) } ],
  SetDIBColorTable: [ UINT, { hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: PTR(uint) } ],
  SetColorAdjustment: [ BOOL, { hdc: HDC, lpca: PTR(uint) } ],
  GetColorAdjustment: [ BOOL, { hdc: HDC, lpca: LPCOLORADJUSTMENT } ],
  CreateHalftonePalette: [ HPALETTE, { hdc: HDC } ],
  StartDocA: [ VOID, { hdc: HDC, lpdi: PTR(uint) } ],
  StartDocW: [ VOID, { hdc: HDC, lpdi: PTR(uint) } ],
  EndDoc: [ VOID, { hdc: HDC } ],
  StartPage: [ VOID, { hdc: HDC } ],
  EndPage: [ VOID, { hdc: HDC } ],
  AbortDoc: [ VOID, { hdc: HDC } ],
  SetAbortProc: [ VOID, { hdc: HDC, proc: ABORTPROC } ],
  AbortPath: [ BOOL, { hdc: HDC } ],
  ArcTo: [ BOOL, { hdc: HDC, left: int, top: int, right: int, bottom: int, xr1: int, yr1: int, xr2: int, yr2: int } ],
  BeginPath: [ BOOL, { hdc: HDC } ],
  CloseFigure: [ BOOL, { hdc: HDC } ],
  EndPath: [ BOOL, { hdc: HDC } ],
  FillPath: [ BOOL, { hdc: HDC } ],
  FlattenPath: [ BOOL, { hdc: HDC } ],
  GetPath: [ VOID, { hdc: HDC, apt: LPPOINT, aj: LPBYTE, cpt: int } ],
  PathToRegion: [ HRGN, { hdc: HDC } ],
  PolyDraw: [ BOOL, { hdc: HDC, apt: PTR(uint), aj: PTR(uchar), cpt: int } ],
  SelectClipPath: [ BOOL, { hdc: HDC, mode: int } ],
  SetArcDirection: [ VOID, { hdc: HDC, dir: int } ],
  SetMiterLimit: [ BOOL, { hdc: HDC, limit: FLOAT, old: PFLOAT } ],
  StrokeAndFillPath: [ BOOL, { hdc: HDC } ],
  StrokePath: [ BOOL, { hdc: HDC } ],
  WidenPath: [ BOOL, { hdc: HDC } ],
  ExtCreatePen: [ HPEN, { iPenStyle: DWORD, cWidth: DWORD, plbrush: PTR(uint), cStyle: DWORD, pstyle: PTR(ulong) } ],
  GetMiterLimit: [ BOOL, { hdc: HDC, plimit: PFLOAT } ],
  GetArcDirection: [ VOID, { hdc: HDC } ],
  GetObjectA: [ VOID, { h: HANDLE, c: int, pv: LPVOID } ],
  GetObjectW: [ VOID, { h: HANDLE, c: int, pv: LPVOID } ],
  MoveToEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  TextOutA: [ BOOL, { hdc: HDC, x: int, y: int, lpString: LPCSTR, c: int } ],
  TextOutW: [ BOOL, { hdc: HDC, x: int, y: int, lpString: LPCWSTR, c: int } ],
  ExtTextOutA: [ BOOL, { hdc: HDC, x: int, y: int, options: UINT, lprect: PTR(uint), lpString: LPCSTR, c: UINT, lpDx: PTR(int) } ],
  ExtTextOutW: [ BOOL, { hdc: HDC, x: int, y: int, options: UINT, lprect: PTR(uint), lpString: LPCWSTR, c: UINT, lpDx: PTR(int) } ],
  PolyTextOutA: [ BOOL, { hdc: HDC, ppt: PTR(uint), nstrings: int } ],
  PolyTextOutW: [ BOOL, { hdc: HDC, ppt: PTR(uint), nstrings: int } ],
  CreatePolygonRgn: [ HRGN, { pptl: PTR(uint), cPoint: int, iMode: int } ],
  DPtoLP: [ BOOL, { hdc: HDC, lppt: LPPOINT, c: int } ],
  LPtoDP: [ BOOL, { hdc: HDC, lppt: LPPOINT, c: int } ],
  Polygon: [ BOOL, { hdc: HDC, apt: PTR(uint), cpt: int } ],
  Polyline: [ BOOL, { hdc: HDC, apt: PTR(uint), cpt: int } ],
  PolyBezier: [ BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD } ],
  PolyBezierTo: [ BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD } ],
  PolylineTo: [ BOOL, { hdc: HDC, apt: PTR(uint), cpt: DWORD } ],
  SetViewportExtEx: [ BOOL, { hdc: HDC, x: int, y: int, lpsz: LPSIZE } ],
  SetViewportOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  SetWindowExtEx: [ BOOL, { hdc: HDC, x: int, y: int, lpsz: LPSIZE } ],
  SetWindowOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  OffsetViewportOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  OffsetWindowOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  ScaleViewportExtEx: [ BOOL, { hdc: HDC, xn: int, dx: int, yn: int, yd: int, lpsz: LPSIZE } ],
  ScaleWindowExtEx: [ BOOL, { hdc: HDC, xn: int, xd: int, yn: int, yd: int, lpsz: LPSIZE } ],
  SetBitmapDimensionEx: [ BOOL, { hbm: HBITMAP, w: int, h: int, lpsz: LPSIZE } ],
  SetBrushOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, lppt: LPPOINT } ],
  GetTextFaceA: [ VOID, { hdc: HDC, c: int, lpName: LPSTR } ],
  GetTextFaceW: [ VOID, { hdc: HDC, c: int, lpName: LPWSTR } ],
  GetKerningPairsA: [ DWORD, { hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR } ],
  GetKerningPairsW: [ DWORD, { hdc: HDC, nPairs: DWORD, lpKernPair: LPKERNINGPAIR } ],
  GetDCOrgEx: [ BOOL, { hdc: HDC, lppt: LPPOINT } ],
  FixBrushOrgEx: [ BOOL, { hdc: HDC, x: int, y: int, ptl: LPPOINT } ],
  UnrealizeObject: [ BOOL, { h: HGDIOBJ } ],
  GdiFlush: [ BOOL, {  } ],
  GdiSetBatchLimit: [ DWORD, { dw: DWORD } ],
  GdiGetBatchLimit: [ DWORD, {  } ],
  SetICMMode: [ VOID, { hdc: HDC, mode: int } ],
  CheckColorsInGamut: [ BOOL, { hdc: HDC, lpRGBTriple: LPRGBTRIPLE, dlpBuffer: LPVOID, nCount: DWORD } ],
  GetColorSpace: [ HCOLORSPACE, { hdc: HDC } ],
  GetLogColorSpaceA: [ BOOL, { hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEA, nSize: DWORD } ],
  GetLogColorSpaceW: [ BOOL, { hColorSpace: HCOLORSPACE, lpBuffer: LPLOGCOLORSPACEW, nSize: DWORD } ],
  CreateColorSpaceA: [ HCOLORSPACE, { lplcs: LPLOGCOLORSPACEA } ],
  CreateColorSpaceW: [ HCOLORSPACE, { lplcs: LPLOGCOLORSPACEW } ],
  SetColorSpace: [ HCOLORSPACE, { hdc: HDC, hcs: HCOLORSPACE } ],
  DeleteColorSpace: [ BOOL, { hcs: HCOLORSPACE } ],
  GetICMProfileA: [ BOOL, { hdc: HDC, pBufSize: LPDWORD, pszFilename: LPSTR } ],
  GetICMProfileW: [ BOOL, { hdc: HDC, pBufSize: LPDWORD, pszFilename: LPWSTR } ],
  SetICMProfileA: [ BOOL, { hdc: HDC, lpFileName: LPSTR } ],
  SetICMProfileW: [ BOOL, { hdc: HDC, lpFileName: LPWSTR } ],
  GetDeviceGammaRamp: [ BOOL, { hdc: HDC, lpRamp: LPVOID } ],
  SetDeviceGammaRamp: [ BOOL, { hdc: HDC, lpRamp: LPVOID } ],
  ColorMatchToTarget: [ BOOL, { hdc: HDC, hdcTarget: HDC, action: DWORD } ],
  EnumICMProfilesA: [ VOID, { hdc: HDC, proc: ICMENUMPROCA, param: LPARAM } ],
  EnumICMProfilesW: [ VOID, { hdc: HDC, proc: ICMENUMPROCW, param: LPARAM } ],
  UpdateICMRegKeyA: [ BOOL, { reserved: DWORD, lpszCMID: LPSTR, lpszFileName: LPSTR, command: UINT } ],
  UpdateICMRegKeyW: [ BOOL, { reserved: DWORD, lpszCMID: LPWSTR, lpszFileName: LPWSTR, command: UINT } ],
  ColorCorrectPalette: [ BOOL, { hdc: HDC, hPal: HPALETTE, deFirst: DWORD, num: DWORD } ],
  wglCopyContext: [ BOOL, { UINT: UINT } ],
  wglCreateContext: [ HGLRC, { HDC: HDC } ],
  wglCreateLayerContext: [ HGLRC, { int: int } ],
  wglDeleteContext: [ BOOL, { HGLRC: HGLRC } ],
  wglGetCurrentContext: [ HGLRC, {  } ],
  wglGetCurrentDC: [ HDC, {  } ],
  wglGetProcAddress: [ PROC, { LPCSTR: LPCSTR } ],
  wglMakeCurrent: [ BOOL, { HGLRC: HGLRC } ],
  wglShareLists: [ BOOL, { HGLRC: HGLRC } ],
  wglUseFontBitmapsA: [ BOOL, { DWORD: DWORD } ],
  wglUseFontBitmapsW: [ BOOL, { DWORD: DWORD } ],
  SwapBuffers: [ BOOL, { HDC: HDC } ],
  wglUseFontOutlinesA: [ BOOL, { LPGLYPHMETRICSFLOAT: LPGLYPHMETRICSFLOAT } ],
  wglUseFontOutlinesW: [ BOOL, { LPGLYPHMETRICSFLOAT: LPGLYPHMETRICSFLOAT } ],
  wglDescribeLayerPlane: [ BOOL, { LPLAYERPLANEDESCRIPTOR: LPLAYERPLANEDESCRIPTOR } ],
  wglSetLayerPaletteEntries: [ VOID, { PTR(ulong): PTR(ulong) } ],
  wglGetLayerPaletteEntries: [ VOID, { PTR(ulong): PTR(ulong) } ],
  wglRealizeLayerPalette: [ BOOL, { BOOL: BOOL } ],
  wglSwapLayerBuffers: [ BOOL, { UINT: UINT } ],
  wglSwapMultipleBuffers: [ DWORD, { PTR(uint): PTR(uint) } ],
  wvsprintfA: [ VOID, { LPCSTR: LPCSTR, arglist: va_list } ],
  wvsprintfW: [ VOID, { LPCWSTR: LPCWSTR, arglist: va_list } ],
  wsprintfA: [ VOID, { LPCSTR: LPCSTR } ],
  wsprintfW: [ VOID, { LPCWSTR: LPCWSTR } ],
  LoadKeyboardLayoutA: [ HKL, { pwszKLID: LPCSTR, Flags: UINT } ],
  LoadKeyboardLayoutW: [ HKL, { pwszKLID: LPCWSTR, Flags: UINT } ],
  ActivateKeyboardLayout: [ HKL, { hkl: HKL, Flags: UINT } ],
  ToUnicodeEx: [ VOID, { wVirtKey: UINT, wScanCode: UINT, lpKeyState: PTR(uchar), pwszBuff: LPWSTR, cchBuff: int, wFlags: UINT, dwhkl: HKL } ],
  UnloadKeyboardLayout: [ BOOL, { hkl: HKL } ],
  GetKeyboardLayoutNameA: [ BOOL, { pwszKLID: LPSTR } ],
  GetKeyboardLayoutNameW: [ BOOL, { pwszKLID: LPWSTR } ],
  GetKeyboardLayoutList: [ VOID, { nBuff: int, lpList: PTR(VOIDPTR) } ],
  GetKeyboardLayout: [ HKL, { idThread: DWORD } ],
  GetMouseMovePointsEx: [ VOID, { cbSize: UINT, lppt: LPMOUSEMOVEPOINT, lpptBuf: LPMOUSEMOVEPOINT, nBufPoints: int, resolution: DWORD } ],
  CreateDesktopA: [ HDESK, { lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES } ],
  CreateDesktopW: [ HDESK, { lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES } ],
  CreateDesktopExA: [ HDESK, { lpszDesktop: LPCSTR, lpszDevice: LPCSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID } ],
  CreateDesktopExW: [ HDESK, { lpszDesktop: LPCWSTR, lpszDevice: LPCWSTR, pDevmode: PTR(uint), dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES, ulHeapSize: ULONG, pvoid: PVOID } ],
  OpenDesktopA: [ HDESK, { lpszDesktop: LPCSTR, dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK } ],
  OpenDesktopW: [ HDESK, { lpszDesktop: LPCWSTR, dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK } ],
  OpenInputDesktop: [ HDESK, { dwFlags: DWORD, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK } ],
  EnumDesktopsA: [ BOOL, { hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCA, lParam: LPARAM } ],
  EnumDesktopsW: [ BOOL, { hwinsta: HWINSTA, lpEnumFunc: DESKTOPENUMPROCW, lParam: LPARAM } ],
  EnumDesktopWindows: [ BOOL, { hDesktop: HDESK, lpfn: WNDENUMPROC, lParam: LPARAM } ],
  SwitchDesktop: [ BOOL, { hDesktop: HDESK } ],
  SetThreadDesktop: [ BOOL, { hDesktop: HDESK } ],
  CloseDesktop: [ BOOL, { hDesktop: HDESK } ],
  GetThreadDesktop: [ HDESK, { dwThreadId: DWORD } ],
  CreateWindowStationA: [ HWINSTA, { lpwinsta: LPCSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES } ],
  CreateWindowStationW: [ HWINSTA, { lpwinsta: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: ACCESS_MASK, lpsa: LPSECURITY_ATTRIBUTES } ],
  OpenWindowStationA: [ HWINSTA, { lpszWinSta: LPCSTR, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK } ],
  OpenWindowStationW: [ HWINSTA, { lpszWinSta: LPCWSTR, fInherit: BOOL, dwDesiredAccess: ACCESS_MASK } ],
  EnumWindowStationsA: [ BOOL, { lpEnumFunc: WINSTAENUMPROCA, lParam: LPARAM } ],
  EnumWindowStationsW: [ BOOL, { lpEnumFunc: WINSTAENUMPROCW, lParam: LPARAM } ],
  CloseWindowStation: [ BOOL, { hWinSta: HWINSTA } ],
  SetProcessWindowStation: [ BOOL, { hWinSta: HWINSTA } ],
  GetProcessWindowStation: [ HWINSTA, {  } ],
  SetUserObjectSecurity: [ BOOL, { hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR } ],
  GetUserObjectSecurity: [ BOOL, { hObj: HANDLE, pSIRequested: PSECURITY_INFORMATION, pSID: PSECURITY_DESCRIPTOR, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  GetUserObjectInformationA: [ BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  GetUserObjectInformationW: [ BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD } ],
  SetUserObjectInformationA: [ BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD } ],
  SetUserObjectInformationW: [ BOOL, { hObj: HANDLE, nIndex: int, pvInfo: PVOID, nLength: DWORD } ],
  IsHungAppWindow: [ BOOL, { hwnd: HWND } ],
  DisableProcessWindowsGhosting: [ VOID, {  } ],
  RegisterWindowMessageA: [ UINT, { lpString: LPCSTR } ],
  RegisterWindowMessageW: [ UINT, { lpString: LPCWSTR } ],
  TrackMouseEvent: [ BOOL, { lpEventTrack: LPTRACKMOUSEEVENT } ],
  DrawEdge: [ BOOL, { hdc: HDC, qrc: LPRECT, edge: UINT, grfFlags: UINT } ],
  DrawFrameControl: [ BOOL, { UINT: UINT } ],
  DrawCaption: [ BOOL, { hwnd: HWND, hdc: HDC, lprect: PTR(uint), flags: UINT } ],
  DrawAnimatedRects: [ BOOL, { hwnd: HWND, idAni: int, lprcFrom: PTR(uint), lprcTo: PTR(uint) } ],
  GetMessageA: [ BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT } ],
  GetMessageW: [ BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT } ],
  TranslateMessage: [ BOOL, { lpMsg: PTR(uint) } ],
  DispatchMessageA: [ LRESULT, { lpMsg: PTR(uint) } ],
  DispatchMessageW: [ LRESULT, { lpMsg: PTR(uint) } ],
  SetMessageQueue: [ BOOL, { cMessagesMax: int } ],
  PeekMessageA: [ BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT } ],
  PeekMessageW: [ BOOL, { lpMsg: LPMSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT } ],
  RegisterHotKey: [ BOOL, { hWnd: HWND, id: int, fsModifiers: UINT, vk: UINT } ],
  UnregisterHotKey: [ BOOL, { hWnd: HWND, id: int } ],
  ExitWindowsEx: [ BOOL, { uFlags: UINT, dwReason: DWORD } ],
  SwapMouseButton: [ BOOL, { fSwap: BOOL } ],
  GetMessagePos: [ DWORD, {  } ],
  GetMessageTime: [ LONG, {  } ],
  GetMessageExtraInfo: [ LPARAM, {  } ],
  IsWow64Message: [ BOOL, {  } ],
  SetMessageExtraInfo: [ LPARAM, { lParam: LPARAM } ],
  SendMessageA: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  SendMessageW: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  SendMessageTimeoutA: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR } ],
  SendMessageTimeoutW: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, fuFlags: UINT, uTimeout: UINT, lpdwResult: PDWORD_PTR } ],
  SendNotifyMessageA: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  SendNotifyMessageW: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  SendMessageCallbackA: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR } ],
  SendMessageCallbackW: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM, lpResultCallBack: SENDASYNCPROC, dwData: ULONG_PTR } ],
  BroadcastSystemMessageExA: [ VOID, { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO } ],
  BroadcastSystemMessageExW: [ VOID, { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM, pbsmInfo: PBSMINFO } ],
  BroadcastSystemMessageA: [ VOID, { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  BroadcastSystemMessageW: [ VOID, { flags: DWORD, lpInfo: LPDWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  RegisterDeviceNotificationA: [ HDEVNOTIFY, { hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD } ],
  RegisterDeviceNotificationW: [ HDEVNOTIFY, { hRecipient: HANDLE, NotificationFilter: LPVOID, Flags: DWORD } ],
  UnregisterDeviceNotification: [ BOOL, { Handle: HDEVNOTIFY } ],
  RegisterPowerSettingNotification: [ HPOWERNOTIFY, { hRecipient: HANDLE, PowerSettingGuid: LPCGUID, Flags: DWORD } ],
  UnregisterPowerSettingNotification: [ BOOL, { Handle: HPOWERNOTIFY } ],
  PostMessageA: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  PostMessageW: [ BOOL, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  PostThreadMessageA: [ BOOL, { idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  PostThreadMessageW: [ BOOL, { idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  AttachThreadInput: [ BOOL, { idAttach: DWORD, idAttachTo: DWORD, fAttach: BOOL } ],
  ReplyMessage: [ BOOL, { lResult: LRESULT } ],
  WaitMessage: [ BOOL, {  } ],
  WaitForInputIdle: [ DWORD, { hProcess: HANDLE, dwMilliseconds: DWORD } ],
  DefWindowProcA: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  DefWindowProcW: [ LRESULT, { hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  PostQuitMessage: [ VOID, { nExitCode: int } ],
  CallWindowProcA: [ LRESULT, { lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  CallWindowProcW: [ LRESULT, { lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  InSendMessage: [ BOOL, {  } ],
  InSendMessageEx: [ DWORD, { lpReserved: LPVOID } ],
  GetDoubleClickTime: [ UINT, {  } ],
  SetDoubleClickTime: [ BOOL, { UINT: UINT } ],
  RegisterClassA: [ ATOM, { lpWndClass: PTR(uint) } ],
  RegisterClassW: [ ATOM, { lpWndClass: PTR(uint) } ],
  UnregisterClassA: [ BOOL, { lpClassName: LPCSTR, hInstance: HINSTANCE } ],
  UnregisterClassW: [ BOOL, { lpClassName: LPCWSTR, hInstance: HINSTANCE } ],
  GetClassInfoA: [ BOOL, { hInstance: HINSTANCE, lpClassName: LPCSTR, lpWndClass: LPWNDCLASSA } ],
  GetClassInfoW: [ BOOL, { hInstance: HINSTANCE, lpClassName: LPCWSTR, lpWndClass: LPWNDCLASSW } ],
  RegisterClassExA: [ ATOM, { PTR(uint): PTR(uint) } ],
  RegisterClassExW: [ ATOM, { PTR(uint): PTR(uint) } ],
  GetClassInfoExA: [ BOOL, { hInstance: HINSTANCE, lpszClass: LPCSTR, lpwcx: LPWNDCLASSEXA } ],
  GetClassInfoExW: [ BOOL, { hInstance: HINSTANCE, lpszClass: LPCWSTR, lpwcx: LPWNDCLASSEXW } ],
  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 } ],
  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 } ],
  IsWindow: [ BOOL, { hWnd: HWND } ],
  IsMenu: [ BOOL, { hMenu: HMENU } ],
  IsChild: [ BOOL, { hWndParent: HWND, hWnd: HWND } ],
  DestroyWindow: [ BOOL, { hWnd: HWND } ],
  ShowWindow: [ BOOL, { hWnd: HWND, nCmdShow: int } ],
  AnimateWindow: [ BOOL, { hWnd: HWND, dwTime: DWORD, dwFlags: DWORD } ],
  UpdateLayeredWindow: [ BOOL, { hWnd: HWND, hdcDst: HDC, pptDst: PTR(uint), psize: PTR(uint), hdcSrc: HDC, pptSrc: PTR(uint), crKey: COLORREF, pblend: PTR(uint), dwFlags: DWORD } ],
  UpdateLayeredWindowIndirect: [ BOOL, { hWnd: HWND, pULWInfo: PTR(uint) } ],
  GetLayeredWindowAttributes: [ BOOL, { hwnd: HWND, pcrKey: PTR(ulong), pbAlpha: PTR(uchar), pdwFlags: PTR(ulong) } ],
  PrintWindow: [ BOOL, { hwnd: HWND, hdcBlt: HDC, nFlags: UINT } ],
  SetLayeredWindowAttributes: [ BOOL, { hwnd: HWND, crKey: COLORREF, bAlpha: BYTE, dwFlags: DWORD } ],
  ShowWindowAsync: [ BOOL, { hWnd: HWND, nCmdShow: int } ],
  FlashWindow: [ BOOL, { hWnd: HWND, bInvert: BOOL } ],
  FlashWindowEx: [ BOOL, { pfwi: PFLASHWINFO } ],
  ShowOwnedPopups: [ BOOL, { hWnd: HWND, fShow: BOOL } ],
  OpenIcon: [ BOOL, { hWnd: HWND } ],
  CloseWindow: [ BOOL, { hWnd: HWND } ],
  MoveWindow: [ BOOL, { hWnd: HWND, X: int, Y: int, nWidth: int, nHeight: int, bRepaint: BOOL } ],
  SetWindowPos: [ BOOL, { hWnd: HWND, hWndInsertAfter: HWND, X: int, Y: int, cx: int, cy: int, uFlags: UINT } ],
  GetWindowPlacement: [ BOOL, { hWnd: HWND, lpwndpl: PTR(uint) } ],
  SetWindowPlacement: [ BOOL, { hWnd: HWND, lpwndpl: PTR(uint) } ],
  GetWindowDisplayAffinity: [ BOOL, { hWnd: HWND, pdwAffinity: PTR(ulong) } ],
  SetWindowDisplayAffinity: [ BOOL, { hWnd: HWND, dwAffinity: DWORD } ],
  BeginDeferWindowPos: [ HDWP, { nNumWindows: int } ],
  DeferWindowPos: [ HDWP, { hWinPosInfo: HDWP, hWnd: HWND, hWndInsertAfter: HWND, x: int, y: int, cx: int, cy: int, uFlags: UINT } ],
  EndDeferWindowPos: [ BOOL, { hWinPosInfo: HDWP } ],
  IsWindowVisible: [ BOOL, { hWnd: HWND } ],
  IsIconic: [ BOOL, { hWnd: HWND } ],
  AnyPopup: [ BOOL, {  } ],
  BringWindowToTop: [ BOOL, { hWnd: HWND } ],
  IsZoomed: [ BOOL, { hWnd: HWND } ],
  CreateDialogParamA: [ HWND, { hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  CreateDialogParamW: [ HWND, { hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  CreateDialogIndirectParamA: [ HWND, { hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  CreateDialogIndirectParamW: [ HWND, { hInstance: HINSTANCE, lpTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  DialogBoxParamA: [ INT_PTR, { hInstance: HINSTANCE, lpTemplateName: LPCSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  DialogBoxParamW: [ INT_PTR, { hInstance: HINSTANCE, lpTemplateName: LPCWSTR, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  DialogBoxIndirectParamA: [ INT_PTR, { hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEA, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  DialogBoxIndirectParamW: [ INT_PTR, { hInstance: HINSTANCE, hDialogTemplate: LPCDLGTEMPLATEW, hWndParent: HWND, lpDialogFunc: DLGPROC, dwInitParam: LPARAM } ],
  EndDialog: [ BOOL, { hDlg: HWND, nResult: INT_PTR } ],
  GetDlgItem: [ HWND, { hDlg: HWND, nIDDlgItem: int } ],
  SetDlgItemInt: [ BOOL, { hDlg: HWND, nIDDlgItem: int, uValue: UINT, bSigned: BOOL } ],
  GetDlgItemInt: [ UINT, { hDlg: HWND, nIDDlgItem: int, lpTranslated: PTR(int), bSigned: BOOL } ],
  SetDlgItemTextA: [ BOOL, { hDlg: HWND, nIDDlgItem: int, lpString: LPCSTR } ],
  SetDlgItemTextW: [ BOOL, { hDlg: HWND, nIDDlgItem: int, lpString: LPCWSTR } ],
  GetDlgItemTextA: [ UINT, { hDlg: HWND, nIDDlgItem: int, lpString: LPSTR, cchMax: int } ],
  GetDlgItemTextW: [ UINT, { hDlg: HWND, nIDDlgItem: int, lpString: LPWSTR, cchMax: int } ],
  CheckDlgButton: [ BOOL, { hDlg: HWND, nIDButton: int, uCheck: UINT } ],
  CheckRadioButton: [ BOOL, { hDlg: HWND, nIDFirstButton: int, nIDLastButton: int, nIDCheckButton: int } ],
  IsDlgButtonChecked: [ UINT, { hDlg: HWND, nIDButton: int } ],
  SendDlgItemMessageA: [ LRESULT, { hDlg: HWND, nIDDlgItem: int, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  SendDlgItemMessageW: [ LRESULT, { hDlg: HWND, nIDDlgItem: int, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  GetNextDlgGroupItem: [ HWND, { hDlg: HWND, hCtl: HWND, bPrevious: BOOL } ],
  GetNextDlgTabItem: [ HWND, { hDlg: HWND, hCtl: HWND, bPrevious: BOOL } ],
  GetDlgCtrlID: [ VOID, { hWnd: HWND } ],
  GetDialogBaseUnits: [ VOID, {  } ],
  DefDlgProcA: [ LRESULT, { hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  DefDlgProcW: [ LRESULT, { hDlg: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  CallMsgFilterA: [ BOOL, { lpMsg: LPMSG, nCode: int } ],
  CallMsgFilterW: [ BOOL, { lpMsg: LPMSG, nCode: int } ],
  OpenClipboard: [ BOOL, { hWndNewOwner: HWND } ],
  CloseClipboard: [ BOOL, {  } ],
  GetClipboardSequenceNumber: [ DWORD, {  } ],
  GetClipboardOwner: [ HWND, {  } ],
  SetClipboardViewer: [ HWND, { hWndNewViewer: HWND } ],
  GetClipboardViewer: [ HWND, {  } ],
  ChangeClipboardChain: [ BOOL, { hWndRemove: HWND, hWndNewNext: HWND } ],
  SetClipboardData: [ HANDLE, { uFormat: UINT, hMem: HANDLE } ],
  GetClipboardData: [ HANDLE, { uFormat: UINT } ],
  RegisterClipboardFormatA: [ UINT, { lpszFormat: LPCSTR } ],
  RegisterClipboardFormatW: [ UINT, { lpszFormat: LPCWSTR } ],
  CountClipboardFormats: [ VOID, {  } ],
  EnumClipboardFormats: [ UINT, { format: UINT } ],
  GetClipboardFormatNameA: [ VOID, { format: UINT, lpszFormatName: LPSTR, cchMaxCount: int } ],
  GetClipboardFormatNameW: [ VOID, { format: UINT, lpszFormatName: LPWSTR, cchMaxCount: int } ],
  EmptyClipboard: [ BOOL, {  } ],
  IsClipboardFormatAvailable: [ BOOL, { format: UINT } ],
  GetPriorityClipboardFormat: [ VOID, { paFormatPriorityList: PTR(uint), cFormats: int } ],
  GetOpenClipboardWindow: [ HWND, {  } ],
  AddClipboardFormatListener: [ BOOL, { hwnd: HWND } ],
  RemoveClipboardFormatListener: [ BOOL, { hwnd: HWND } ],
  GetUpdatedClipboardFormats: [ BOOL, { lpuiFormats: PUINT, cFormats: UINT, pcFormatsOut: PUINT } ],
  CharToOemA: [ BOOL, { pSrc: LPCSTR, pDst: LPSTR } ],
  CharToOemW: [ BOOL, { pSrc: LPCWSTR, pDst: LPSTR } ],
  OemToCharA: [ BOOL, { pSrc: LPCSTR, pDst: LPSTR } ],
  OemToCharW: [ BOOL, { pSrc: LPCSTR, pDst: LPWSTR } ],
  CharToOemBuffA: [ BOOL, { lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD } ],
  CharToOemBuffW: [ BOOL, { lpszSrc: LPCWSTR, lpszDst: LPSTR, cchDstLength: DWORD } ],
  OemToCharBuffA: [ BOOL, { lpszSrc: LPCSTR, lpszDst: LPSTR, cchDstLength: DWORD } ],
  OemToCharBuffW: [ BOOL, { lpszSrc: LPCSTR, lpszDst: LPWSTR, cchDstLength: DWORD } ],
  CharUpperA: [ LPSTR, { lpsz: LPSTR } ],
  CharUpperW: [ LPWSTR, { lpsz: LPWSTR } ],
  CharUpperBuffA: [ DWORD, { lpsz: LPSTR, cchLength: DWORD } ],
  CharUpperBuffW: [ DWORD, { lpsz: LPWSTR, cchLength: DWORD } ],
  CharLowerA: [ LPSTR, { lpsz: LPSTR } ],
  CharLowerW: [ LPWSTR, { lpsz: LPWSTR } ],
  CharLowerBuffA: [ DWORD, { lpsz: LPSTR, cchLength: DWORD } ],
  CharLowerBuffW: [ DWORD, { lpsz: LPWSTR, cchLength: DWORD } ],
  CharNextA: [ LPSTR, { lpsz: LPCSTR } ],
  CharNextW: [ LPWSTR, { lpsz: LPCWSTR } ],
  CharPrevA: [ LPSTR, { lpszStart: LPCSTR, lpszCurrent: LPCSTR } ],
  CharPrevW: [ LPWSTR, { lpszStart: LPCWSTR, lpszCurrent: LPCWSTR } ],
  CharNextExA: [ LPSTR, { CodePage: WORD, lpCurrentChar: LPCSTR, dwFlags: DWORD } ],
  CharPrevExA: [ LPSTR, { CodePage: WORD, lpStart: LPCSTR, lpCurrentChar: LPCSTR, dwFlags: DWORD } ],
  IsCharAlphaA: [ BOOL, { ch: CHAR } ],
  IsCharAlphaW: [ BOOL, { ch: WCHAR } ],
  IsCharAlphaNumericA: [ BOOL, { ch: CHAR } ],
  IsCharAlphaNumericW: [ BOOL, { ch: WCHAR } ],
  IsCharUpperA: [ BOOL, { ch: CHAR } ],
  IsCharUpperW: [ BOOL, { ch: WCHAR } ],
  IsCharLowerA: [ BOOL, { ch: CHAR } ],
  IsCharLowerW: [ BOOL, { ch: WCHAR } ],
  SetFocus: [ HWND, { hWnd: HWND } ],
  GetActiveWindow: [ HWND, {  } ],
  GetFocus: [ HWND, {  } ],
  GetKBCodePage: [ UINT, {  } ],
  GetKeyState: [ SHORT, { nVirtKey: int } ],
  GetAsyncKeyState: [ SHORT, { vKey: int } ],
  GetKeyboardState: [ BOOL, { lpKeyState: PBYTE } ],
  SetKeyboardState: [ BOOL, { lpKeyState: LPBYTE } ],
  GetKeyNameTextA: [ VOID, { lParam: LONG, lpString: LPSTR, cchSize: int } ],
  GetKeyNameTextW: [ VOID, { lParam: LONG, lpString: LPWSTR, cchSize: int } ],
  GetKeyboardType: [ VOID, { nTypeFlag: int } ],
  ToAscii: [ VOID, { uVirtKey: UINT, uScanCode: UINT, lpKeyState: PTR(uchar), lpChar: LPWORD, uFlags: UINT } ],
  ToAsciiEx: [ VOID, { uVirtKey: UINT, uScanCode: UINT, lpKeyState: PTR(uchar), lpChar: LPWORD, uFlags: UINT, dwhkl: HKL } ],
  ToUnicode: [ VOID, { wVirtKey: UINT, wScanCode: UINT, lpKeyState: PTR(uchar), pwszBuff: LPWSTR, cchBuff: int, wFlags: UINT } ],
  OemKeyScan: [ DWORD, { wOemChar: WORD } ],
  VkKeyScanA: [ SHORT, { ch: CHAR } ],
  VkKeyScanW: [ SHORT, { ch: WCHAR } ],
  VkKeyScanExA: [ SHORT, { ch: CHAR, dwhkl: HKL } ],
  VkKeyScanExW: [ SHORT, { ch: WCHAR, dwhkl: HKL } ],
  keybd_event: [ VOID, { bVk: BYTE, bScan: BYTE, dwFlags: DWORD, dwExtraInfo: ULONG_PTR } ],
  mouse_event: [ VOID, { dwFlags: DWORD, dx: DWORD, dy: DWORD, dwData: DWORD, dwExtraInfo: ULONG_PTR } ],
  SendInput: [ UINT, { cInputs: UINT, pInputs: LPINPUT, cbSize: int } ],
  GetTouchInputInfo: [ BOOL, { hTouchInput: HTOUCHINPUT, cInputs: UINT, pInputs: PTOUCHINPUT, cbSize: int } ],
  CloseTouchInputHandle: [ BOOL, { hTouchInput: HTOUCHINPUT } ],
  RegisterTouchWindow: [ BOOL, { hwnd: HWND, ulFlags: ULONG } ],
  UnregisterTouchWindow: [ BOOL, { hwnd: HWND } ],
  IsTouchWindow: [ BOOL, { hwnd: HWND, pulFlags: PULONG } ],
  GetLastInputInfo: [ BOOL, { plii: PLASTINPUTINFO } ],
  MapVirtualKeyA: [ UINT, { uCode: UINT, uMapType: UINT } ],
  MapVirtualKeyW: [ UINT, { uCode: UINT, uMapType: UINT } ],
  MapVirtualKeyExA: [ UINT, { uCode: UINT, uMapType: UINT, dwhkl: HKL } ],
  MapVirtualKeyExW: [ UINT, { uCode: UINT, uMapType: UINT, dwhkl: HKL } ],
  GetInputState: [ BOOL, {  } ],
  GetQueueStatus: [ DWORD, { flags: UINT } ],
  GetCapture: [ HWND, {  } ],
  SetCapture: [ HWND, { hWnd: HWND } ],
  ReleaseCapture: [ BOOL, {  } ],
  MsgWaitForMultipleObjects: [ DWORD, { nCount: DWORD, pHandles: PTR(PTR(VOID)), fWaitAll: BOOL, dwMilliseconds: DWORD, dwWakeMask: DWORD } ],
  MsgWaitForMultipleObjectsEx: [ DWORD, { nCount: DWORD, pHandles: PTR(PTR(VOID)), dwMilliseconds: DWORD, dwWakeMask: DWORD, dwFlags: DWORD } ],
  SetTimer: [ UINT_PTR, { hWnd: HWND, nIDEvent: UINT_PTR, uElapse: UINT, lpTimerFunc: TIMERPROC } ],
  KillTimer: [ BOOL, { hWnd: HWND, uIDEvent: UINT_PTR } ],
  IsWindowUnicode: [ BOOL, { hWnd: HWND } ],
  EnableWindow: [ BOOL, { hWnd: HWND, bEnable: BOOL } ],
  IsWindowEnabled: [ BOOL, { hWnd: HWND } ],
  LoadAcceleratorsA: [ HACCEL, { hInstance: HINSTANCE, lpTableName: LPCSTR } ],
  LoadAcceleratorsW: [ HACCEL, { hInstance: HINSTANCE, lpTableName: LPCWSTR } ],
  CreateAcceleratorTableA: [ HACCEL, { paccel: LPACCEL, cAccel: int } ],
  CreateAcceleratorTableW: [ HACCEL, { paccel: LPACCEL, cAccel: int } ],
  DestroyAcceleratorTable: [ BOOL, { hAccel: HACCEL } ],
  CopyAcceleratorTableA: [ VOID, { hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int } ],
  CopyAcceleratorTableW: [ VOID, { hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: int } ],
  TranslateAcceleratorA: [ VOID, { hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG } ],
  TranslateAcceleratorW: [ VOID, { hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG } ],
  GetSystemMetrics: [ VOID, { nIndex: int } ],
  LoadMenuA: [ HMENU, { hInstance: HINSTANCE, lpMenuName: LPCSTR } ],
  LoadMenuW: [ HMENU, { hInstance: HINSTANCE, lpMenuName: LPCWSTR } ],
  LoadMenuIndirectA: [ HMENU, { lpMenuTemplate: PTR(VOID) } ],
  LoadMenuIndirectW: [ HMENU, { lpMenuTemplate: PTR(VOID) } ],
  GetMenu: [ HMENU, { hWnd: HWND } ],
  SetMenu: [ BOOL, { hWnd: HWND, hMenu: HMENU } ],
  ChangeMenuA: [ BOOL, { hMenu: HMENU, cmd: UINT, lpszNewItem: LPCSTR, cmdInsert: UINT, flags: UINT } ],
  ChangeMenuW: [ BOOL, { hMenu: HMENU, cmd: UINT, lpszNewItem: LPCWSTR, cmdInsert: UINT, flags: UINT } ],
  HiliteMenuItem: [ BOOL, { hWnd: HWND, hMenu: HMENU, uIDHiliteItem: UINT, uHilite: UINT } ],
  GetMenuStringA: [ VOID, { hMenu: HMENU, uIDItem: UINT, lpString: LPSTR, cchMax: int, flags: UINT } ],
  GetMenuStringW: [ VOID, { hMenu: HMENU, uIDItem: UINT, lpString: LPWSTR, cchMax: int, flags: UINT } ],
  GetMenuState: [ UINT, { hMenu: HMENU, uId: UINT, uFlags: UINT } ],
  DrawMenuBar: [ BOOL, { hWnd: HWND } ],
  GetSystemMenu: [ HMENU, { hWnd: HWND, bRevert: BOOL } ],
  CreateMenu: [ HMENU, {  } ],
  CreatePopupMenu: [ HMENU, {  } ],
  DestroyMenu: [ BOOL, { hMenu: HMENU } ],
  CheckMenuItem: [ DWORD, { hMenu: HMENU, uIDCheckItem: UINT, uCheck: UINT } ],
  EnableMenuItem: [ BOOL, { hMenu: HMENU, uIDEnableItem: UINT, uEnable: UINT } ],
  GetSubMenu: [ HMENU, { hMenu: HMENU, nPos: int } ],
  GetMenuItemID: [ UINT, { hMenu: HMENU, nPos: int } ],
  GetMenuItemCount: [ VOID, { hMenu: HMENU } ],
  InsertMenuA: [ BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR } ],
  InsertMenuW: [ BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR } ],
  AppendMenuA: [ BOOL, { hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR } ],
  AppendMenuW: [ BOOL, { hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR } ],
  ModifyMenuA: [ BOOL, { hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCSTR } ],
  ModifyMenuW: [ BOOL, { hMnu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR } ],
  RemoveMenu: [ BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT } ],
  DeleteMenu: [ BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT } ],
  SetMenuItemBitmaps: [ BOOL, { hMenu: HMENU, uPosition: UINT, uFlags: UINT, hBitmapUnchecked: HBITMAP, hBitmapChecked: HBITMAP } ],
  GetMenuCheckMarkDimensions: [ LONG, {  } ],
  TrackPopupMenu: [ BOOL, { hMenu: HMENU, uFlags: UINT, x: int, y: int, nReserved: int, hWnd: HWND, prcRect: PTR(uint) } ],
  TrackPopupMenuEx: [ BOOL, { LPTPMPARAMS: LPTPMPARAMS } ],
  CalculatePopupWindowPosition: [ BOOL, { anchorPoint: PTR(uint), windowSize: PTR(uint), flags: UINT, excludeRect: PTR(uint), popupWindowPosition: PTR(uint) } ],
  GetMenuInfo: [ BOOL, { LPMENUINFO: LPMENUINFO } ],
  SetMenuInfo: [ BOOL, { LPCMENUINFO: LPCMENUINFO } ],
  EndMenu: [ BOOL, {  } ],
  InsertMenuItemA: [ BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmi: LPCMENUITEMINFOA } ],
  InsertMenuItemW: [ BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmi: LPCMENUITEMINFOW } ],
  GetMenuItemInfoA: [ BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmii: LPMENUITEMINFOA } ],
  GetMenuItemInfoW: [ BOOL, { hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmii: LPMENUITEMINFOW } ],
  SetMenuItemInfoA: [ BOOL, { hmenu: HMENU, item: UINT, fByPositon: BOOL, lpmii: LPCMENUITEMINFOA } ],
  SetMenuItemInfoW: [ BOOL, { hmenu: HMENU, item: UINT, fByPositon: BOOL, lpmii: LPCMENUITEMINFOW } ],
  GetMenuDefaultItem: [ UINT, { hMenu: HMENU, fByPos: UINT, gmdiFlags: UINT } ],
  SetMenuDefaultItem: [ BOOL, { hMenu: HMENU, uItem: UINT, fByPos: UINT } ],
  GetMenuItemRect: [ BOOL, { hWnd: HWND, hMenu: HMENU, uItem: UINT, lprcItem: LPRECT } ],
  MenuItemFromPoint: [ VOID, { hWnd: HWND, hMenu: HMENU, ptScreen: POINT } ],
  DragObject: [ DWORD, { hwndParent: HWND, hwndFrom: HWND, fmt: UINT, data: ULONG_PTR, hcur: HCURSOR } ],
  DragDetect: [ BOOL, { hwnd: HWND, pt: POINT } ],
  DrawIcon: [ BOOL, { hDC: HDC, X: int, Y: int, hIcon: HICON } ],
  DrawTextA: [ VOID, { hdc: HDC, lpchText: LPCSTR, cchText: int, lprc: LPRECT, format: UINT } ],
  DrawTextW: [ VOID, { hdc: HDC, lpchText: LPCWSTR, cchText: int, lprc: LPRECT, format: UINT } ],
  DrawTextExA: [ VOID, { hdc: HDC, lpchText: LPSTR, cchText: int, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS } ],
  DrawTextExW: [ VOID, { hdc: HDC, lpchText: LPWSTR, cchText: int, lprc: LPRECT, format: UINT, lpdtp: LPDRAWTEXTPARAMS } ],
  GrayStringA: [ BOOL, { hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int, X: int, Y: int, nWidth: int, nHeight: int } ],
  GrayStringW: [ BOOL, { hDC: HDC, hBrush: HBRUSH, lpOutputFunc: GRAYSTRINGPROC, lpData: LPARAM, nCount: int, X: int, Y: int, nWidth: int, nHeight: int } ],
  DrawStateA: [ BOOL, { hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int, y: int, cx: int, cy: int, uFlags: UINT } ],
  DrawStateW: [ BOOL, { hdc: HDC, hbrFore: HBRUSH, qfnCallBack: DRAWSTATEPROC, lData: LPARAM, wData: WPARAM, x: int, y: int, cx: int, cy: int, uFlags: UINT } ],
  TabbedTextOutA: [ LONG, { hdc: HDC, x: int, y: int, lpString: LPCSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int), nTabOrigin: int } ],
  TabbedTextOutW: [ LONG, { hdc: HDC, x: int, y: int, lpString: LPCWSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int), nTabOrigin: int } ],
  GetTabbedTextExtentA: [ DWORD, { hdc: HDC, lpString: LPCSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int) } ],
  GetTabbedTextExtentW: [ DWORD, { hdc: HDC, lpString: LPCWSTR, chCount: int, nTabPositions: int, lpnTabStopPositions: PTR(int) } ],
  UpdateWindow: [ BOOL, { hWnd: HWND } ],
  SetActiveWindow: [ HWND, { hWnd: HWND } ],
  GetForegroundWindow: [ HWND, {  } ],
  PaintDesktop: [ BOOL, { hdc: HDC } ],
  SwitchToThisWindow: [ VOID, { hwnd: HWND, fUnknown: BOOL } ],
  SetForegroundWindow: [ BOOL, { hWnd: HWND } ],
  AllowSetForegroundWindow: [ BOOL, { dwProcessId: DWORD } ],
  LockSetForegroundWindow: [ BOOL, { uLockCode: UINT } ],
  WindowFromDC: [ HWND, { hDC: HDC } ],
  GetDC: [ HDC, { hWnd: HWND } ],
  GetDCEx: [ HDC, { hWnd: HWND, hrgnClip: HRGN, flags: DWORD } ],
  GetWindowDC: [ HDC, { hWnd: HWND } ],
  ReleaseDC: [ VOID, { hWnd: HWND, hDC: HDC } ],
  BeginPaint: [ HDC, { hWnd: HWND, lpPaint: LPPAINTSTRUCT } ],
  EndPaint: [ BOOL, { hWnd: HWND, lpPaint: PTR(uint) } ],
  GetUpdateRect: [ BOOL, { hWnd: HWND, lpRect: LPRECT, bErase: BOOL } ],
  GetUpdateRgn: [ VOID, { hWnd: HWND, hRgn: HRGN, bErase: BOOL } ],
  SetWindowRgn: [ VOID, { hWnd: HWND, hRgn: HRGN, bRedraw: BOOL } ],
  GetWindowRgn: [ VOID, { hWnd: HWND, hRgn: HRGN } ],
  GetWindowRgnBox: [ VOID, { hWnd: HWND, lprc: LPRECT } ],
  ExcludeUpdateRgn: [ VOID, { hDC: HDC, hWnd: HWND } ],
  InvalidateRect: [ BOOL, { hWnd: HWND, lpRect: PTR(uint), bErase: BOOL } ],
  ValidateRect: [ BOOL, { hWnd: HWND, lpRect: PTR(uint) } ],
  InvalidateRgn: [ BOOL, { hWnd: HWND, hRgn: HRGN, bErase: BOOL } ],
  ValidateRgn: [ BOOL, { hWnd: HWND, hRgn: HRGN } ],
  RedrawWindow: [ BOOL, { hWnd: HWND, lprcUpdate: PTR(uint), hrgnUpdate: HRGN, flags: UINT } ],
  LockWindowUpdate: [ BOOL, { hWndLock: HWND } ],
  ScrollWindow: [ BOOL, { hWnd: HWND, XAmount: int, YAmount: int, lpRect: PTR(uint), lpClipRect: PTR(uint) } ],
  ScrollDC: [ BOOL, { hDC: HDC, dx: int, dy: int, lprcScroll: PTR(uint), lprcClip: PTR(uint), hrgnUpdate: HRGN, lprcUpdate: LPRECT } ],
  ScrollWindowEx: [ VOID, { hWnd: HWND, dx: int, dy: int, prcScroll: PTR(uint), prcClip: PTR(uint), hrgnUpdate: HRGN, prcUpdate: LPRECT, flags: UINT } ],
  SetScrollPos: [ VOID, { hWnd: HWND, nBar: int, nPos: int, bRedraw: BOOL } ],
  GetScrollPos: [ VOID, { hWnd: HWND, nBar: int } ],
  SetScrollRange: [ BOOL, { hWnd: HWND, nBar: int, nMinPos: int, nMaxPos: int, bRedraw: BOOL } ],
  GetScrollRange: [ BOOL, { hWnd: HWND, nBar: int, lpMinPos: LPINT, lpMaxPos: LPINT } ],
  ShowScrollBar: [ BOOL, { hWnd: HWND, wBar: int, bShow: BOOL } ],
  EnableScrollBar: [ BOOL, { hWnd: HWND, wSBflags: UINT, wArrows: UINT } ],
  SetPropA: [ BOOL, { hWnd: HWND, lpString: LPCSTR, hData: HANDLE } ],
  SetPropW: [ BOOL, { hWnd: HWND, lpString: LPCWSTR, hData: HANDLE } ],
  GetPropA: [ HANDLE, { hWnd: HWND, lpString: LPCSTR } ],
  GetPropW: [ HANDLE, { hWnd: HWND, lpString: LPCWSTR } ],
  RemovePropA: [ HANDLE, { hWnd: HWND, lpString: LPCSTR } ],
  RemovePropW: [ HANDLE, { hWnd: HWND, lpString: LPCWSTR } ],
  EnumPropsExA: [ VOID, { hWnd: HWND, lpEnumFunc: PROPENUMPROCEXA, lParam: LPARAM } ],
  EnumPropsExW: [ VOID, { hWnd: HWND, lpEnumFunc: PROPENUMPROCEXW, lParam: LPARAM } ],
  EnumPropsA: [ VOID, { hWnd: HWND, lpEnumFunc: PROPENUMPROCA } ],
  EnumPropsW: [ VOID, { hWnd: HWND, lpEnumFunc: PROPENUMPROCW } ],
  SetWindowTextA: [ BOOL, { hWnd: HWND, lpString: LPCSTR } ],
  SetWindowTextW: [ BOOL, { hWnd: HWND, lpString: LPCWSTR } ],
  GetWindowTextA: [ VOID, { hWnd: HWND, lpString: LPSTR, nMaxCount: int } ],
  GetWindowTextW: [ VOID, { hWnd: HWND, lpString: LPWSTR, nMaxCount: int } ],
  GetWindowTextLengthA: [ VOID, { hWnd: HWND } ],
  GetWindowTextLengthW: [ VOID, { hWnd: HWND } ],
  GetClientRect: [ BOOL, { hWnd: HWND, lpRect: LPRECT } ],
  GetWindowRect: [ BOOL, { hWnd: HWND, lpRect: LPRECT } ],
  AdjustWindowRect: [ BOOL, { lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL } ],
  AdjustWindowRectEx: [ BOOL, { lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL, dwExStyle: DWORD } ],
  SetWindowContextHelpId: [ BOOL, { DWORD: DWORD } ],
  GetWindowContextHelpId: [ DWORD, { HWND: HWND } ],
  SetMenuContextHelpId: [ BOOL, { DWORD: DWORD } ],
  GetMenuContextHelpId: [ DWORD, { HMENU: HMENU } ],
  MessageBoxA: [ VOID, { hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT } ],
  MessageBoxW: [ VOID, { hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT } ],
  MessageBoxExA: [ VOID, { hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD } ],
  MessageBoxExW: [ VOID, { hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD } ],
  MessageBoxIndirectA: [ VOID, { lpmbp: PTR(uint) } ],
  MessageBoxIndirectW: [ VOID, { lpmbp: PTR(uint) } ],
  MessageBeep: [ BOOL, { uType: UINT } ],
  ShowCursor: [ VOID, { bShow: BOOL } ],
  SetCursorPos: [ BOOL, { X: int, Y: int } ],
  SetPhysicalCursorPos: [ BOOL, { X: int, Y: int } ],
  SetCursor: [ HCURSOR, { hCursor: HCURSOR } ],
  GetCursorPos: [ BOOL, { lpPoint: LPPOINT } ],
  GetPhysicalCursorPos: [ BOOL, { lpPoint: LPPOINT } ],
  ClipCursor: [ BOOL, { lpRect: PTR(uint) } ],
  GetClipCursor: [ BOOL, { lpRect: LPRECT } ],
  GetCursor: [ HCURSOR, {  } ],
  CreateCaret: [ BOOL, { hWnd: HWND, hBitmap: HBITMAP, nWidth: int, nHeight: int } ],
  GetCaretBlinkTime: [ UINT, {  } ],
  SetCaretBlinkTime: [ BOOL, { uMSeconds: UINT } ],
  DestroyCaret: [ BOOL, {  } ],
  HideCaret: [ BOOL, { hWnd: HWND } ],
  ShowCaret: [ BOOL, { hWnd: HWND } ],
  SetCaretPos: [ BOOL, { X: int, Y: int } ],
  GetCaretPos: [ BOOL, { lpPoint: LPPOINT } ],
  ClientToScreen: [ BOOL, { hWnd: HWND, lpPoint: LPPOINT } ],
  ScreenToClient: [ BOOL, { hWnd: HWND, lpPoint: LPPOINT } ],
  LogicalToPhysicalPoint: [ BOOL, { hWnd: HWND, lpPoint: LPPOINT } ],
  PhysicalToLogicalPoint: [ BOOL, { hWnd: HWND, lpPoint: LPPOINT } ],
  MapWindowPoints: [ VOID, { hWndFrom: HWND, hWndTo: HWND, lpPoints: LPPOINT, cPoints: UINT } ],
  WindowFromPoint: [ HWND, { Point: POINT } ],
  WindowFromPhysicalPoint: [ HWND, { Point: POINT } ],
  ChildWindowFromPoint: [ HWND, { hWndParent: HWND, Point: POINT } ],
  ChildWindowFromPointEx: [ HWND, { hwnd: HWND, pt: POINT, flags: UINT } ],
  GetSysColor: [ DWORD, { nIndex: int } ],
  GetSysColorBrush: [ HBRUSH, { nIndex: int } ],
  SetSysColors: [ BOOL, { cElements: int, lpaElements: PTR(int), lpaRgbValues: PTR(ulong) } ],
  DrawFocusRect: [ BOOL, { hDC: HDC, lprc: PTR(uint) } ],
  FillRect: [ VOID, { hDC: HDC, lprc: PTR(uint), hbr: HBRUSH } ],
  FrameRect: [ VOID, { hDC: HDC, lprc: PTR(uint), hbr: HBRUSH } ],
  InvertRect: [ BOOL, { hDC: HDC, lprc: PTR(uint) } ],
  SetRect: [ BOOL, { lprc: LPRECT, xLeft: int, yTop: int, xRight: int, yBottom: int } ],
  SetRectEmpty: [ BOOL, { lprc: LPRECT } ],
  CopyRect: [ BOOL, { lprcDst: LPRECT, lprcSrc: PTR(uint) } ],
  InflateRect: [ BOOL, { lprc: LPRECT, dx: int, dy: int } ],
  IntersectRect: [ BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) } ],
  UnionRect: [ BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) } ],
  SubtractRect: [ BOOL, { lprcDst: LPRECT, lprcSrc1: PTR(uint), lprcSrc2: PTR(uint) } ],
  OffsetRect: [ BOOL, { lprc: LPRECT, dx: int, dy: int } ],
  IsRectEmpty: [ BOOL, { lprc: PTR(uint) } ],
  EqualRect: [ BOOL, { lprc1: PTR(uint), lprc2: PTR(uint) } ],
  PtInRect: [ BOOL, { lprc: PTR(uint), pt: POINT } ],
  GetWindowWord: [ WORD, { hWnd: HWND, nIndex: int } ],
  SetWindowWord: [ WORD, { hWnd: HWND, nIndex: int, wNewWord: WORD } ],
  GetWindowLongA: [ LONG, { hWnd: HWND, nIndex: int } ],
  GetWindowLongW: [ LONG, { hWnd: HWND, nIndex: int } ],
  SetWindowLongA: [ LONG, { hWnd: HWND, nIndex: int, dwNewLong: LONG } ],
  SetWindowLongW: [ LONG, { hWnd: HWND, nIndex: int, dwNewLong: LONG } ],
  GetClassWord: [ WORD, { hWnd: HWND, nIndex: int } ],
  SetClassWord: [ WORD, { hWnd: HWND, nIndex: int, wNewWord: WORD } ],
  GetClassLongA: [ DWORD, { hWnd: HWND, nIndex: int } ],
  GetClassLongW: [ DWORD, { hWnd: HWND, nIndex: int } ],
  SetClassLongA: [ DWORD, { hWnd: HWND, nIndex: int, dwNewLong: LONG } ],
  SetClassLongW: [ DWORD, { hWnd: HWND, nIndex: int, dwNewLong: LONG } ],
  GetProcessDefaultLayout: [ BOOL, { pdwDefaultLayout: PTR(ulong) } ],
  SetProcessDefaultLayout: [ BOOL, { dwDefaultLayout: DWORD } ],
  GetDesktopWindow: [ HWND, {  } ],
  GetParent: [ HWND, { hWnd: HWND } ],
  SetParent: [ HWND, { hWndChild: HWND, hWndNewParent: HWND } ],
  EnumChildWindows: [ BOOL, { hWndParent: HWND, lpEnumFunc: WNDENUMPROC, lParam: LPARAM } ],
  FindWindowA: [ HWND, { lpClassName: LPCSTR, lpWindowName: LPCSTR } ],
  FindWindowW: [ HWND, { lpClassName: LPCWSTR, lpWindowName: LPCWSTR } ],
  FindWindowExA: [ HWND, { hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCSTR, lpszWindow: LPCSTR } ],
  FindWindowExW: [ HWND, { hWndParent: HWND, hWndChildAfter: HWND, lpszClass: LPCWSTR, lpszWindow: LPCWSTR } ],
  GetShellWindow: [ HWND, {  } ],
  RegisterShellHookWindow: [ BOOL, { hwnd: HWND } ],
  DeregisterShellHookWindow: [ BOOL, { hwnd: HWND } ],
  EnumWindows: [ BOOL, { lpEnumFunc: WNDENUMPROC, lParam: LPARAM } ],
  EnumThreadWindows: [ BOOL, { dwThreadId: DWORD, lpfn: WNDENUMPROC, lParam: LPARAM } ],
  GetClassNameA: [ VOID, { hWnd: HWND, lpClassName: LPSTR, nMaxCount: int } ],
  GetClassNameW: [ VOID, { hWnd: HWND, lpClassName: LPWSTR, nMaxCount: int } ],
  GetTopWindow: [ HWND, { hWnd: HWND } ],
  GetWindowThreadProcessId: [ DWORD, { hWnd: HWND, lpdwProcessId: LPDWORD } ],
  IsGUIThread: [ BOOL, { bConvert: BOOL } ],
  GetLastActivePopup: [ HWND, { hWnd: HWND } ],
  GetWindow: [ HWND, { hWnd: HWND, uCmd: UINT } ],
  SetWindowsHookA: [ HHOOK, { nFilterType: int, pfnFilterProc: HOOKPROC } ],
  SetWindowsHookW: [ HHOOK, { nFilterType: int, pfnFilterProc: HOOKPROC } ],
  UnhookWindowsHook: [ BOOL, { nCode: int, pfnFilterProc: HOOKPROC } ],
  SetWindowsHookExA: [ HHOOK, { idHook: int, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD } ],
  SetWindowsHookExW: [ HHOOK, { idHook: int, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD } ],
  UnhookWindowsHookEx: [ BOOL, { hhk: HHOOK } ],
  CallNextHookEx: [ LRESULT, { hhk: HHOOK, nCode: int, wParam: WPARAM, lParam: LPARAM } ],
  CheckMenuRadioItem: [ BOOL, { hmenu: HMENU, first: UINT, last: UINT, check: UINT, flags: UINT } ],
  LoadBitmapA: [ HBITMAP, { hInstance: HINSTANCE, lpBitmapName: LPCSTR } ],
  LoadBitmapW: [ HBITMAP, { hInstance: HINSTANCE, lpBitmapName: LPCWSTR } ],
  LoadCursorA: [ HCURSOR, { hInstance: HINSTANCE, lpCursorName: LPCSTR } ],
  LoadCursorW: [ HCURSOR, { hInstance: HINSTANCE, lpCursorName: LPCWSTR } ],
  LoadCursorFromFileA: [ HCURSOR, { lpFileName: LPCSTR } ],
  LoadCursorFromFileW: [ HCURSOR, { lpFileName: LPCWSTR } ],
  CreateCursor: [ HCURSOR, { hInst: HINSTANCE, xHotSpot: int, yHotSpot: int, nWidth: int, nHeight: int, pvANDPlane: PTR(VOID), pvXORPlane: PTR(VOID) } ],
  DestroyCursor: [ BOOL, { hCursor: HCURSOR } ],
  SetSystemCursor: [ BOOL, { hcur: HCURSOR, id: DWORD } ],
  LoadIconA: [ HICON, { hInstance: HINSTANCE, lpIconName: LPCSTR } ],
  LoadIconW: [ HICON, { hInstance: HINSTANCE, lpIconName: LPCWSTR } ],
  PrivateExtractIconsA: [ UINT, { szFileName: LPCSTR, nIconIndex: int, cxIcon: int, cyIcon: int, phicon: PTR(VOIDPTR), piconid: PTR(uint), nIcons: UINT, flags: UINT } ],
  PrivateExtractIconsW: [ UINT, { szFileName: LPCWSTR, nIconIndex: int, cxIcon: int, cyIcon: int, phicon: PTR(VOIDPTR), piconid: PTR(uint), nIcons: UINT, flags: UINT } ],
  CreateIcon: [ HICON, { hInstance: HINSTANCE, nWidth: int, nHeight: int, cPlanes: BYTE, cBitsPixel: BYTE, lpbANDbits: PTR(uchar), lpbXORbits: PTR(uchar) } ],
  DestroyIcon: [ BOOL, { hIcon: HICON } ],
  LookupIconIdFromDirectory: [ VOID, { presbits: PBYTE, fIcon: BOOL } ],
  LookupIconIdFromDirectoryEx: [ VOID, { presbits: PBYTE, fIcon: BOOL, cxDesired: int, cyDesired: int, Flags: UINT } ],
  CreateIconFromResource: [ HICON, { presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD } ],
  CreateIconFromResourceEx: [ HICON, { presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD, cxDesired: int, cyDesired: int, Flags: UINT } ],
  LoadImageA: [ HANDLE, { hInst: HINSTANCE, name: LPCSTR, type: UINT, cx: int, cy: int, fuLoad: UINT } ],
  LoadImageW: [ HANDLE, { hInst: HINSTANCE, name: LPCWSTR, type: UINT, cx: int, cy: int, fuLoad: UINT } ],
  CopyImage: [ HANDLE, { h: HANDLE, type: UINT, cx: int, cy: int, flags: UINT } ],
  DrawIconEx: [ BOOL, { hdc: HDC, xLeft: int, yTop: int, hIcon: HICON, cxWidth: int, cyWidth: int, istepIfAniCur: UINT, hbrFlickerFreeDraw: HBRUSH, diFlags: UINT } ],
  CreateIconIndirect: [ HICON, { piconinfo: PICONINFO } ],
  CopyIcon: [ HICON, { hIcon: HICON } ],
  GetIconInfo: [ BOOL, { hIcon: HICON, piconinfo: PICONINFO } ],
  GetIconInfoExA: [ BOOL, { hicon: HICON, piconinfo: PICONINFOEXA } ],
  GetIconInfoExW: [ BOOL, { hicon: HICON, piconinfo: PICONINFOEXW } ],
  LoadStringA: [ VOID, { hInstance: HINSTANCE, uID: UINT, lpBuffer: LPSTR, cchBufferMax: int } ],
  LoadStringW: [ VOID, { hInstance: HINSTANCE, uID: UINT, lpBuffer: LPWSTR, cchBufferMax: int } ],
  IsDialogMessageA: [ BOOL, { hDlg: HWND, lpMsg: LPMSG } ],
  IsDialogMessageW: [ BOOL, { hDlg: HWND, lpMsg: LPMSG } ],
  MapDialogRect: [ BOOL, { hDlg: HWND, lpRect: LPRECT } ],
  DlgDirListA: [ VOID, { hDlg: HWND, lpPathSpec: LPSTR, nIDListBox: int, nIDStaticPath: int, uFileType: UINT } ],
  DlgDirListW: [ VOID, { hDlg: HWND, lpPathSpec: LPWSTR, nIDListBox: int, nIDStaticPath: int, uFileType: UINT } ],
  DlgDirSelectExA: [ BOOL, { hwndDlg: HWND, lpString: LPSTR, chCount: int, idListBox: int } ],
  DlgDirSelectExW: [ BOOL, { hwndDlg: HWND, lpString: LPWSTR, chCount: int, idListBox: int } ],
  DlgDirListComboBoxA: [ VOID, { hDlg: HWND, lpPathSpec: LPSTR, nIDComboBox: int, nIDStaticPath: int, uFiletype: UINT } ],
  DlgDirListComboBoxW: [ VOID, { hDlg: HWND, lpPathSpec: LPWSTR, nIDComboBox: int, nIDStaticPath: int, uFiletype: UINT } ],
  DlgDirSelectComboBoxExA: [ BOOL, { hwndDlg: HWND, lpString: LPSTR, cchOut: int, idComboBox: int } ],
  DlgDirSelectComboBoxExW: [ BOOL, { hwndDlg: HWND, lpString: LPWSTR, cchOut: int, idComboBox: int } ],
  SetScrollInfo: [ VOID, { hwnd: HWND, nBar: int, lpsi: LPCSCROLLINFO, redraw: BOOL } ],
  GetScrollInfo: [ BOOL, { hwnd: HWND, nBar: int, lpsi: LPSCROLLINFO } ],
  DefFrameProcA: [ LRESULT, { hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  DefFrameProcW: [ LRESULT, { hWnd: HWND, hWndMDIClient: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  DefMDIChildProcA: [ LRESULT, { hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  DefMDIChildProcW: [ LRESULT, { hWnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM } ],
  TranslateMDISysAccel: [ BOOL, { hWndClient: HWND, lpMsg: LPMSG } ],
  ArrangeIconicWindows: [ UINT, { hWnd: HWND } ],
  CreateMDIWindowA: [ HWND, { lpClassName: LPCSTR, lpWindowName: LPCSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM } ],
  CreateMDIWindowW: [ HWND, { lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hInstance: HINSTANCE, lParam: LPARAM } ],
  TileWindows: [ WORD, { hwndParent: HWND, wHow: UINT, lpRect: PTR(uint), cKids: UINT, lpKids: PTR(VOIDPTR) } ],
  CascadeWindows: [ WORD, { hwndParent: HWND, wHow: UINT, lpRect: PTR(uint), cKids: UINT, lpKids: PTR(VOIDPTR) } ],
  WinHelpA: [ BOOL, { hWndMain: HWND, lpszHelp: LPCSTR, uCommand: UINT, dwData: ULONG_PTR } ],
  WinHelpW: [ BOOL, { hWndMain: HWND, lpszHelp: LPCWSTR, uCommand: UINT, dwData: ULONG_PTR } ],
  GetGuiResources: [ DWORD, { hProcess: HANDLE, uiFlags: DWORD } ],
  ChangeDisplaySettingsA: [ LONG, { lpDevMode: PTR(uint), dwFlags: DWORD } ],
  ChangeDisplaySettingsW: [ LONG, { lpDevMode: PTR(uint), dwFlags: DWORD } ],
  ChangeDisplaySettingsExA: [ LONG, { lpszDeviceName: LPCSTR, lpDevMode: PTR(uint), hwnd: HWND, dwflags: DWORD, lParam: LPVOID } ],
  ChangeDisplaySettingsExW: [ LONG, { lpszDeviceName: LPCWSTR, lpDevMode: PTR(uint), hwnd: HWND, dwflags: DWORD, lParam: LPVOID } ],
  EnumDisplaySettingsA: [ BOOL, { lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: PTR(uint) } ],
  EnumDisplaySettingsW: [ BOOL, { lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: PTR(uint) } ],
  EnumDisplaySettingsExA: [ BOOL, { lpszDeviceName: LPCSTR, iModeNum: DWORD, lpDevMode: PTR(uint), dwFlags: DWORD } ],
  EnumDisplaySettingsExW: [ BOOL, { lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: PTR(uint), dwFlags: DWORD } ],
  EnumDisplayDevicesA: [ BOOL, { lpDevice: LPCSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEA, dwFlags: DWORD } ],
  EnumDisplayDevicesW: [ BOOL, { lpDevice: LPCWSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEW, dwFlags: DWORD } ],
  GetDisplayConfigBufferSizes: [ LONG, { flags: UINT32, numPathArrayElements: PTR(uint), numModeInfoArrayElements: PTR(uint) } ],
  SetDisplayConfig: [ LONG, { numPathArrayElements: UINT32, pathArray: PTR(uint), numModeInfoArrayElements: UINT32, modeInfoArray: PTR(uint), flags: UINT32 } ],
  QueryDisplayConfig: [ LONG, { flags: UINT32, numPathArrayElements: PTR(uint), pathArray: PTR(uint), numModeInfoArrayElements: PTR(uint), modeInfoArray: PTR(uint), currentTopologyId: PTR(uint) } ],
  DisplayConfigGetDeviceInfo: [ LONG, { requestPacket: PTR(uint) } ],
  DisplayConfigSetDeviceInfo: [ LONG, { setPacket: PTR(uint) } ],
  SystemParametersInfoA: [ BOOL, { uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT } ],
  SystemParametersInfoW: [ BOOL, { uiAction: UINT, uiParam: UINT, pvParam: PVOID, fWinIni: UINT } ],
  SoundSentry: [ BOOL, {  } ],
  SetDebugErrorLevel: [ VOID, { dwLevel: DWORD } ],
  SetLastErrorEx: [ VOID, { dwErrCode: DWORD, dwType: DWORD } ],
  InternalGetWindowText: [ VOID, { hWnd: HWND, pString: LPWSTR, cchMaxCount: int } ],
  CancelShutdown: [ BOOL, {  } ],
  MonitorFromPoint: [ HMONITOR, { pt: POINT, dwFlags: DWORD } ],
  MonitorFromRect: [ HMONITOR, { lprc: LPCRECT, dwFlags: DWORD } ],
  MonitorFromWindow: [ HMONITOR, { hwnd: HWND, dwFlags: DWORD } ],
  GetMonitorInfoA: [ BOOL, { hMonitor: HMONITOR, lpmi: LPMONITORINFO } ],
  GetMonitorInfoW: [ BOOL, { hMonitor: HMONITOR, lpmi: LPMONITORINFO } ],
  EnumDisplayMonitors: [ BOOL, { hdc: HDC, lprcClip: LPCRECT, lpfnEnum: MONITORENUMPROC, dwData: LPARAM } ],
  NotifyWinEvent: [ VOID, { event: DWORD, hwnd: HWND, idObject: LONG, idChild: LONG } ],
  SetWinEventHook: [ HWINEVENTHOOK, { eventMin: DWORD, eventMax: DWORD, hmodWinEventProc: HMODULE, pfnWinEventProc: WINEVENTPROC, idProcess: DWORD, idThread: DWORD, dwFlags: DWORD } ],
  IsWinEventHookInstalled: [ BOOL, { event: DWORD } ],
  UnhookWinEvent: [ BOOL, { hWinEventHook: HWINEVENTHOOK } ],
  GetGUIThreadInfo: [ BOOL, { idThread: DWORD, pgui: PGUITHREADINFO } ],
  BlockInput: [ BOOL, { fBlockIt: BOOL } ],
  SetProcessDPIAware: [ BOOL, {  } ],
  IsProcessDPIAware: [ BOOL, {  } ],
  GetWindowModuleFileNameA: [ UINT, { hwnd: HWND, pszFileName: LPSTR, cchFileNameMax: UINT } ],
  GetWindowModuleFileNameW: [ UINT, { hwnd: HWND, pszFileName: LPWSTR, cchFileNameMax: UINT } ],
  GetCursorInfo: [ BOOL, { pci: PCURSORINFO } ],
  GetWindowInfo: [ BOOL, { hwnd: HWND, pwi: PWINDOWINFO } ],
  GetTitleBarInfo: [ BOOL, { hwnd: HWND, pti: PTITLEBARINFO } ],
  GetMenuBarInfo: [ BOOL, { hwnd: HWND, idObject: LONG, idItem: LONG, pmbi: PMENUBARINFO } ],
  GetScrollBarInfo: [ BOOL, { hwnd: HWND, idObject: LONG, psbi: PSCROLLBARINFO } ],
  GetComboBoxInfo: [ BOOL, { hwndCombo: HWND, pcbi: PCOMBOBOXINFO } ],
  GetAncestor: [ HWND, { hwnd: HWND, gaFlags: UINT } ],
  RealChildWindowFromPoint: [ HWND, { hwndParent: HWND, ptParentClientCoords: POINT } ],
  RealGetWindowClassA: [ UINT, { hwnd: HWND, ptszClassName: LPSTR, cchClassNameMax: UINT } ],
  RealGetWindowClassW: [ UINT, { hwnd: HWND, ptszClassName: LPWSTR, cchClassNameMax: UINT } ],
  GetAltTabInfoA: [ BOOL, { hwnd: HWND, iItem: int, pati: PALTTABINFO, pszItemText: LPSTR, cchItemText: UINT } ],
  GetAltTabInfoW: [ BOOL, { hwnd: HWND, iItem: int, pati: PALTTABINFO, pszItemText: LPWSTR, cchItemText: UINT } ],
  GetListBoxInfo: [ DWORD, { hwnd: HWND } ],
  LockWorkStation: [ BOOL, {  } ],
  UserHandleGrantAccess: [ BOOL, { hUserHandle: HANDLE, hJob: HANDLE, bGrant: BOOL } ],
  GetRawInputData: [ UINT, { hRawInput: HRAWINPUT, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT, cbSizeHeader: UINT } ],
  GetRawInputDeviceInfoA: [ UINT, { hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT } ],
  GetRawInputDeviceInfoW: [ UINT, { hDevice: HANDLE, uiCommand: UINT, pData: LPVOID, pcbSize: PUINT } ],
  GetRawInputBuffer: [ UINT, { pData: PRAWINPUT, pcbSize: PUINT, cbSizeHeader: UINT } ],
  RegisterRawInputDevices: [ BOOL, { pRawInputDevices: PCRAWINPUTDEVICE, uiNumDevices: UINT, cbSize: UINT } ],
  GetRegisteredRawInputDevices: [ UINT, { pRawInputDevices: PRAWINPUTDEVICE, puiNumDevices: PUINT, cbSize: UINT } ],
  GetRawInputDeviceList: [ UINT, { pRawInputDeviceList: PRAWINPUTDEVICELIST, puiNumDevices: PUINT, cbSize: UINT } ],
  DefRawInputProc: [ LRESULT, { paRawInput: PTR(VOIDPTR), nInput: INT, cbSizeHeader: UINT } ],
  ChangeWindowMessageFilter: [ BOOL, { message: UINT, dwFlag: DWORD } ],
  ChangeWindowMessageFilterEx: [ BOOL, { hwnd: HWND, message: UINT, action: DWORD, pChangeFilterStruct: PCHANGEFILTERSTRUCT } ],
  GetGestureInfo: [ BOOL, { hGestureInfo: HGESTUREINFO, pGestureInfo: PGESTUREINFO } ],
  GetGestureExtraArgs: [ BOOL, { hGestureInfo: HGESTUREINFO, cbExtraArgs: UINT, pExtraArgs: PBYTE } ],
  CloseGestureInfoHandle: [ BOOL, { hGestureInfo: HGESTUREINFO } ],
  SetGestureConfig: [ BOOL, { hwnd: HWND, dwReserved: DWORD, cIDs: UINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT } ],
  GetGestureConfig: [ BOOL, { hwnd: HWND, dwReserved: DWORD, dwFlags: DWORD, pcIDs: PUINT, pGestureConfig: PGESTURECONFIG, cbSize: UINT } ],
  ShutdownBlockReasonCreate: [ BOOL, { hWnd: HWND, pwszReason: LPCWSTR } ],
  ShutdownBlockReasonQuery: [ BOOL, { hWnd: HWND, pwszBuff: LPWSTR, pcchBuff: PTR(ulong) } ],
  ShutdownBlockReasonDestroy: [ BOOL, { hWnd: HWND } ],
  IsValidCodePage: [ BOOL, { CodePage: UINT } ],
  GetACP: [ UINT, {  } ],
  GetOEMCP: [ UINT, {  } ],
  GetCPInfo: [ BOOL, { CodePage: UINT, lpCPInfo: LPCPINFO } ],
  GetCPInfoExA: [ BOOL, { CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA } ],
  GetCPInfoExW: [ BOOL, { CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW } ],
  IsDBCSLeadByte: [ BOOL, { TestChar: BYTE } ],
  IsDBCSLeadByteEx: [ BOOL, { CodePage: UINT, TestChar: BYTE } ],
  MultiByteToWideChar: [ VOID, { CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCSTR, cbMultiByte: int, lpWideCharStr: LPWSTR, cchWideChar: int } ],
  WideCharToMultiByte: [ VOID, { CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: int, lpMultiByteStr: LPSTR, cbMultiByte: int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL } ],
  CompareStringA: [ VOID, { Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: int, lpString2: PCNZCH, cchCount2: int } ],
  CompareStringW: [ VOID, { Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: int, lpString2: PCNZWCH, cchCount2: int } ],
  FindNLSString: [ VOID, { Locale: LCID, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, pcchFound: LPINT } ],
  FindStringOrdinal: [ VOID, { dwFindStringOrdinalFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, bIgnoreCase: BOOL } ],
  LCMapStringA: [ VOID, { Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpDestStr: LPSTR, cchDest: int } ],
  LCMapStringW: [ VOID, { Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int } ],
  GetLocaleInfoA: [ VOID, { Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: int } ],
  GetLocaleInfoW: [ VOID, { Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int } ],
  SetLocaleInfoA: [ BOOL, { Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR } ],
  SetLocaleInfoW: [ BOOL, { Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR } ],
  GetCalendarInfoA: [ VOID, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: int, lpValue: LPDWORD } ],
  GetCalendarInfoW: [ VOID, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int, lpValue: LPDWORD } ],
  SetCalendarInfoA: [ BOOL, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR } ],
  SetCalendarInfoW: [ BOOL, { Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR } ],
  LCIDToLocaleName: [ VOID, { Locale: LCID, lpName: LPWSTR, cchName: int, dwFlags: DWORD } ],
  LocaleNameToLCID: [ LCID, { lpName: LPCWSTR, dwFlags: DWORD } ],
  GetTimeFormatA: [ VOID, { Locale: LCID, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCSTR, lpTimeStr: LPSTR, cchTime: int } ],
  GetTimeFormatW: [ VOID, { Locale: LCID, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int } ],
  GetDurationFormat: [ VOID, { Locale: LCID, dwFlags: DWORD, lpDuration: PTR(uint), ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int } ],
  GetDateFormatA: [ VOID, { Locale: LCID, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCSTR, lpDateStr: LPSTR, cchDate: int } ],
  GetDateFormatW: [ VOID, { Locale: LCID, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int } ],
  GetNumberFormatA: [ VOID, { Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: PTR(uint), lpNumberStr: LPSTR, cchNumber: int } ],
  GetNumberFormatW: [ VOID, { Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpNumberStr: LPWSTR, cchNumber: int } ],
  GetCurrencyFormatA: [ VOID, { Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: PTR(uint), lpCurrencyStr: LPSTR, cchCurrency: int } ],
  GetCurrencyFormatW: [ VOID, { Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpCurrencyStr: LPWSTR, cchCurrency: int } ],
  EnumCalendarInfoA: [ BOOL, { lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE } ],
  EnumCalendarInfoW: [ BOOL, { lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE } ],
  EnumCalendarInfoExA: [ BOOL, { lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE } ],
  EnumCalendarInfoExW: [ BOOL, { lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE } ],
  EnumTimeFormatsA: [ BOOL, { lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD } ],
  EnumTimeFormatsW: [ BOOL, { lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD } ],
  EnumDateFormatsA: [ BOOL, { lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD } ],
  EnumDateFormatsW: [ BOOL, { lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD } ],
  EnumDateFormatsExA: [ BOOL, { lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD } ],
  EnumDateFormatsExW: [ BOOL, { lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD } ],
  IsValidLanguageGroup: [ BOOL, { LanguageGroup: LGRPID, dwFlags: DWORD } ],
  GetNLSVersion: [ BOOL, { Function: NLS_FUNCTION, Locale: LCID, lpVersionInformation: LPNLSVERSIONINFO } ],
  IsNLSDefinedString: [ BOOL, { Function: NLS_FUNCTION, dwFlags: DWORD, lpVersionInformation: LPNLSVERSIONINFO, lpString: LPCWSTR, cchStr: INT } ],
  IsValidLocale: [ BOOL, { Locale: LCID, dwFlags: DWORD } ],
  GetGeoInfoA: [ VOID, { Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: int, LangId: LANGID } ],
  GetGeoInfoW: [ VOID, { Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: int, LangId: LANGID } ],
  EnumSystemGeoID: [ BOOL, { GeoClass: GEOCLASS, ParentGeoId: GEOID, lpGeoEnumProc: GEO_ENUMPROC } ],
  GetUserGeoID: [ GEOID, { GeoClass: GEOCLASS } ],
  SetUserGeoID: [ BOOL, { GeoId: GEOID } ],
  ConvertDefaultLocale: [ LCID, { Locale: LCID } ],
  GetThreadLocale: [ LCID, {  } ],
  SetThreadLocale: [ BOOL, { Locale: LCID } ],
  GetSystemDefaultUILanguage: [ LANGID, {  } ],
  GetUserDefaultUILanguage: [ LANGID, {  } ],
  GetSystemDefaultLangID: [ LANGID, {  } ],
  GetUserDefaultLangID: [ LANGID, {  } ],
  GetSystemDefaultLCID: [ LCID, {  } ],
  GetUserDefaultLCID: [ LCID, {  } ],
  SetThreadUILanguage: [ LANGID, { LangId: LANGID } ],
  GetThreadUILanguage: [ LANGID, {  } ],
  GetProcessPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG } ],
  SetProcessPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG } ],
  GetUserPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG } ],
  GetSystemPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG } ],
  GetThreadPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR, pcchLanguagesBuffer: PULONG } ],
  SetThreadPreferredUILanguages: [ BOOL, { dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG } ],
  GetFileMUIInfo: [ BOOL, { dwFlags: DWORD, pcwszFilePath: PCWSTR, pFileMUIInfo: PFILEMUIINFO, pcbFileMUIInfo: PTR(ulong) } ],
  GetFileMUIPath: [ BOOL, { dwFlags: DWORD, pcwszFilePath: PCWSTR, pwszLanguage: PWSTR, pcchLanguage: PULONG, pwszFileMUIPath: PWSTR, pcchFileMUIPath: PULONG, pululEnumerator: PULONGLONG } ],
  GetUILanguageInfo: [ BOOL, { dwFlags: DWORD, pwmszLanguage: PCZZWSTR, pwszFallbackLanguages: PZZWSTR, pcchFallbackLanguages: PDWORD, pAttributes: PDWORD } ],
  NotifyUILanguageChange: [ BOOL, { dwFlags: DWORD, pcwstrNewLanguage: PCWSTR, pcwstrPreviousLanguage: PCWSTR, dwReserved: DWORD, pdwStatusRtrn: PDWORD } ],
  GetStringTypeExA: [ BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpCharType: LPWORD } ],
  GetStringTypeExW: [ BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpCharType: LPWORD } ],
  GetStringTypeA: [ BOOL, { Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpCharType: LPWORD } ],
  GetStringTypeW: [ BOOL, { dwInfoType: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpCharType: LPWORD } ],
  FoldStringA: [ VOID, { dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: int, lpDestStr: LPSTR, cchDest: int } ],
  FoldStringW: [ VOID, { dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int } ],
  EnumSystemLanguageGroupsA: [ BOOL, { lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumSystemLanguageGroupsW: [ BOOL, { lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumLanguageGroupLocalesA: [ BOOL, { lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumLanguageGroupLocalesW: [ BOOL, { lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumUILanguagesA: [ BOOL, { lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumUILanguagesW: [ BOOL, { lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR } ],
  EnumSystemLocalesA: [ BOOL, { lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD } ],
  EnumSystemLocalesW: [ BOOL, { lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD } ],
  EnumSystemCodePagesA: [ BOOL, { lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD } ],
  EnumSystemCodePagesW: [ BOOL, { lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD } ],
  NormalizeString: [ VOID, { NormForm: NORM_FORM, lpSrcString: LPCWSTR, cwSrcLength: int, lpDstString: LPWSTR, cwDstLength: int } ],
  IsNormalizedString: [ BOOL, { NormForm: NORM_FORM, lpString: LPCWSTR, cwLength: int } ],
  IdnToAscii: [ VOID, { dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int, lpASCIICharStr: LPWSTR, cchASCIIChar: int } ],
  IdnToNameprepUnicode: [ VOID, { dwFlags: DWORD, lpUnicodeCharStr: LPCWSTR, cchUnicodeChar: int, lpNameprepCharStr: LPWSTR, cchNameprepChar: int } ],
  IdnToUnicode: [ VOID, { dwFlags: DWORD, lpASCIICharStr: LPCWSTR, cchASCIIChar: int, lpUnicodeCharStr: LPWSTR, cchUnicodeChar: int } ],
  VerifyScripts: [ BOOL, { dwFlags: DWORD, lpLocaleScripts: LPCWSTR, cchLocaleScripts: int, lpTestScripts: LPCWSTR, cchTestScripts: int } ],
  GetStringScripts: [ VOID, { dwFlags: DWORD, lpString: LPCWSTR, cchString: int, lpScripts: LPWSTR, cchScripts: int } ],
  GetLocaleInfoEx: [ VOID, { lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: int } ],
  GetCalendarInfoEx: [ VOID, { lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lpCalData: LPWSTR, cchData: int, lpValue: LPDWORD } ],
  GetTimeFormatEx: [ VOID, { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpTime: PTR(uint), lpFormat: LPCWSTR, lpTimeStr: LPWSTR, cchTime: int } ],
  GetDateFormatEx: [ VOID, { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDate: PTR(uint), lpFormat: LPCWSTR, lpDateStr: LPWSTR, cchDate: int, lpCalendar: LPCWSTR } ],
  GetDurationFormatEx: [ VOID, { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDuration: PTR(uint), ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: int } ],
  GetNumberFormatEx: [ VOID, { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpNumberStr: LPWSTR, cchNumber: int } ],
  GetCurrencyFormatEx: [ VOID, { lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: PTR(uint), lpCurrencyStr: LPWSTR, cchCurrency: int } ],
  GetUserDefaultLocaleName: [ VOID, { lpLocaleName: LPWSTR, cchLocaleName: int } ],
  GetSystemDefaultLocaleName: [ VOID, { lpLocaleName: LPWSTR, cchLocaleName: int } ],
  GetNLSVersionEx: [ BOOL, { function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX } ],
  CompareStringEx: [ VOID, { lpLocaleName: LPCWSTR, dwCmpFlags: DWORD, lpString1: LPCWSTR, cchCount1: int, lpString2: LPCWSTR, cchCount2: int, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM } ],
  FindNLSStringEx: [ VOID, { lpLocaleName: LPCWSTR, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: int, lpStringValue: LPCWSTR, cchValue: int, pcchFound: LPINT, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM } ],
  LCMapStringEx: [ VOID, { lpLocaleName: LPCWSTR, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: int, lpDestStr: LPWSTR, cchDest: int, lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, lParam: LPARAM } ],
  CompareStringOrdinal: [ VOID, { lpString1: LPCWSTR, cchCount1: int, lpString2: LPCWSTR, cchCount2: int, bIgnoreCase: BOOL } ],
  IsValidLocaleName: [ BOOL, { lpLocaleName: LPCWSTR } ],
  EnumCalendarInfoExEx: [ BOOL, { pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX, lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE, lParam: LPARAM } ],
  EnumDateFormatsExEx: [ BOOL, { lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM } ],
  EnumTimeFormatsEx: [ BOOL, { lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX, lpLocaleName: LPCWSTR, dwFlags: DWORD, lParam: LPARAM } ],
  EnumSystemLocalesEx: [ BOOL, { lpLocaleEnumProcEx: LOCALE_ENUMPROCEX, dwFlags: DWORD, lParam: LPARAM, lpReserved: LPVOID } ],
  ResolveLocaleName: [ VOID, { lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: int } ],
  PeekConsoleInputA: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD } ],
  PeekConsoleInputW: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD } ],
  ReadConsoleInputA: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD } ],
  ReadConsoleInputW: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD, lpNumberOfEventsRead: LPDWORD } ],
  WriteConsoleInputA: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PTR(uint), nLength: DWORD, lpNumberOfEventsWritten: LPDWORD } ],
  WriteConsoleInputW: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: PTR(uint), nLength: DWORD, lpNumberOfEventsWritten: LPDWORD } ],
  ReadConsoleOutputA: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT } ],
  ReadConsoleOutputW: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD, lpReadRegion: PSMALL_RECT } ],
  WriteConsoleOutputA: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(uint), dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT } ],
  WriteConsoleOutputW: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(uint), dwBufferSize: COORD, dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT } ],
  ReadConsoleOutputCharacterA: [ BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD } ],
  ReadConsoleOutputCharacterW: [ BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD, lpNumberOfCharsRead: LPDWORD } ],
  ReadConsoleOutputAttribute: [ BOOL, { hConsoleOutput: HANDLE, lpAttribute: LPWORD, nLength: DWORD, dwReadCoord: COORD, lpNumberOfAttrsRead: LPDWORD } ],
  WriteConsoleOutputCharacterA: [ BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD } ],
  WriteConsoleOutputCharacterW: [ BOOL, { hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD } ],
  WriteConsoleOutputAttribute: [ BOOL, { hConsoleOutput: HANDLE, lpAttribute: PTR(ushort), nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD } ],
  FillConsoleOutputCharacterA: [ BOOL, { hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD } ],
  FillConsoleOutputCharacterW: [ BOOL, { hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD } ],
  FillConsoleOutputAttribute: [ BOOL, { hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD } ],
  GetConsoleMode: [ BOOL, { hConsoleHandle: HANDLE, lpMode: LPDWORD } ],
  GetNumberOfConsoleInputEvents: [ BOOL, { hConsoleInput: HANDLE, lpNumberOfEvents: LPDWORD } ],
  GetConsoleScreenBufferInfo: [ BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO } ],
  GetConsoleScreenBufferInfoEx: [ BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX } ],
  SetConsoleScreenBufferInfoEx: [ BOOL, { hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX } ],
  GetLargestConsoleWindowSize: [ COORD, { hConsoleOutput: HANDLE } ],
  GetConsoleCursorInfo: [ BOOL, { hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO } ],
  GetCurrentConsoleFont: [ BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFont: PCONSOLE_FONT_INFO } ],
  GetCurrentConsoleFontEx: [ BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX } ],
  SetCurrentConsoleFontEx: [ BOOL, { hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX } ],
  GetConsoleHistoryInfo: [ BOOL, { lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO } ],
  SetConsoleHistoryInfo: [ BOOL, { lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO } ],
  GetConsoleFontSize: [ COORD, { hConsoleOutput: HANDLE, nFont: DWORD } ],
  GetConsoleSelectionInfo: [ BOOL, { lpConsoleSelectionInfo: PCONSOLE_SELECTION_INFO } ],
  GetNumberOfConsoleMouseButtons: [ BOOL, { lpNumberOfMouseButtons: LPDWORD } ],
  SetConsoleMode: [ BOOL, { hConsoleHandle: HANDLE, dwMode: DWORD } ],
  SetConsoleActiveScreenBuffer: [ BOOL, { hConsoleOutput: HANDLE } ],
  FlushConsoleInputBuffer: [ BOOL, { hConsoleInput: HANDLE } ],
  SetConsoleScreenBufferSize: [ BOOL, { hConsoleOutput: HANDLE, dwSize: COORD } ],
  SetConsoleCursorPosition: [ BOOL, { hConsoleOutput: HANDLE, dwCursorPosition: COORD } ],
  SetConsoleCursorInfo: [ BOOL, { hConsoleOutput: HANDLE, lpConsoleCursorInfo: PTR(uint) } ],
  ScrollConsoleScreenBufferA: [ BOOL, { hConsoleOutput: HANDLE, lpScrollRectangle: PTR(uint), lpClipRectangle: PTR(uint), dwDestinationOrigin: COORD, lpFill: PTR(uint) } ],
  ScrollConsoleScreenBufferW: [ BOOL, { hConsoleOutput: HANDLE, lpScrollRectangle: PTR(uint), lpClipRectangle: PTR(uint), dwDestinationOrigin: COORD, lpFill: PTR(uint) } ],
  SetConsoleWindowInfo: [ BOOL, { hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: PTR(uint) } ],
  SetConsoleTextAttribute: [ BOOL, { hConsoleOutput: HANDLE, wAttributes: WORD } ],
  SetConsoleCtrlHandler: [ BOOL, { HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL } ],
  GenerateConsoleCtrlEvent: [ BOOL, { dwCtrlEvent: DWORD, dwProcessGroupId: DWORD } ],
  AllocConsole: [ BOOL, {  } ],
  FreeConsole: [ BOOL, {  } ],
  AttachConsole: [ BOOL, { dwProcessId: DWORD } ],
  GetConsoleTitleA: [ DWORD, { lpConsoleTitle: LPSTR, nSize: DWORD } ],
  GetConsoleTitleW: [ DWORD, { lpConsoleTitle: LPWSTR, nSize: DWORD } ],
  GetConsoleOriginalTitleA: [ DWORD, { lpConsoleTitle: LPSTR, nSize: DWORD } ],
  GetConsoleOriginalTitleW: [ DWORD, { lpConsoleTitle: LPWSTR, nSize: DWORD } ],
  SetConsoleTitleA: [ BOOL, { lpConsoleTitle: LPCSTR } ],
  SetConsoleTitleW: [ BOOL, { lpConsoleTitle: LPCWSTR } ],
  ReadConsoleA: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL } ],
  ReadConsoleW: [ BOOL, { hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL } ],
  WriteConsoleA: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(VOID), nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID } ],
  WriteConsoleW: [ BOOL, { hConsoleOutput: HANDLE, lpBuffer: PTR(VOID), nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID } ],
  CreateConsoleScreenBuffer: [ HANDLE, { dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: PTR(uint), dwFlags: DWORD, lpScreenBufferData: LPVOID } ],
  GetConsoleCP: [ UINT, {  } ],
  SetConsoleCP: [ BOOL, { wCodePageID: UINT } ],
  GetConsoleOutputCP: [ UINT, {  } ],
  SetConsoleOutputCP: [ BOOL, { wCodePageID: UINT } ],
  GetConsoleDisplayMode: [ BOOL, { lpModeFlags: LPDWORD } ],
  SetConsoleDisplayMode: [ BOOL, { hConsoleOutput: HANDLE, dwFlags: DWORD, lpNewScreenBufferDimensions: PCOORD } ],
  GetConsoleWindow: [ HWND, {  } ],
  GetConsoleProcessList: [ DWORD, { lpdwProcessList: LPDWORD, dwProcessCount: DWORD } ],
  AddConsoleAliasA: [ BOOL, { Source: LPSTR, Target: LPSTR, ExeName: LPSTR } ],
  AddConsoleAliasW: [ BOOL, { Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR } ],
  GetConsoleAliasA: [ DWORD, { Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR } ],
  GetConsoleAliasW: [ DWORD, { Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR } ],
  GetConsoleAliasesLengthA: [ DWORD, { ExeName: LPSTR } ],
  GetConsoleAliasesLengthW: [ DWORD, { ExeName: LPWSTR } ],
  GetConsoleAliasExesLengthA: [ DWORD, {  } ],
  GetConsoleAliasExesLengthW: [ DWORD, {  } ],
  GetConsoleAliasesA: [ DWORD, { AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR } ],
  GetConsoleAliasesW: [ DWORD, { AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR } ],
  GetConsoleAliasExesA: [ DWORD, { ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD } ],
  GetConsoleAliasExesW: [ DWORD, { ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD } ],
  VerFindFileA: [ DWORD, { uFlags: DWORD, szFileName: LPCSTR, szWinDir: LPCSTR, szAppDir: LPCSTR, szCurDir: LPSTR, lpuCurDirLen: PUINT, szDestDir: LPSTR, lpuDestDirLen: PUINT } ],
  VerFindFileW: [ DWORD, { uFlags: DWORD, szFileName: LPCWSTR, szWinDir: LPCWSTR, szAppDir: LPCWSTR, szCurDir: LPWSTR, lpuCurDirLen: PUINT, szDestDir: LPWSTR, lpuDestDirLen: PUINT } ],
  VerInstallFileA: [ DWORD, { uFlags: DWORD, szSrcFileName: LPCSTR, szDestFileName: LPCSTR, szSrcDir: LPCSTR, szDestDir: LPCSTR, szCurDir: LPCSTR, szTmpFile: LPSTR, lpuTmpFileLen: PUINT } ],
  VerInstallFileW: [ DWORD, { uFlags: DWORD, szSrcFileName: LPCWSTR, szDestFileName: LPCWSTR, szSrcDir: LPCWSTR, szDestDir: LPCWSTR, szCurDir: LPCWSTR, szTmpFile: LPWSTR, lpuTmpFileLen: PUINT } ],
  GetFileVersionInfoSizeA: [ DWORD, { lptstrFilename: LPCSTR, lpdwHandle: LPDWORD } ],
  GetFileVersionInfoSizeW: [ DWORD, { lptstrFilename: LPCWSTR, lpdwHandle: LPDWORD } ],
  GetFileVersionInfoA: [ BOOL, { lptstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID } ],
  GetFileVersionInfoW: [ BOOL, { lptstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID } ],
  GetFileVersionInfoSizeExA: [ DWORD, { dwFlags: DWORD, lpwstrFilename: LPCSTR, lpdwHandle: LPDWORD } ],
  GetFileVersionInfoSizeExW: [ DWORD, { dwFlags: DWORD, lpwstrFilename: LPCWSTR, lpdwHandle: LPDWORD } ],
  GetFileVersionInfoExA: [ BOOL, { dwFlags: DWORD, lpwstrFilename: LPCSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID } ],
  GetFileVersionInfoExW: [ BOOL, { dwFlags: DWORD, lpwstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID } ],
  VerLanguageNameA: [ DWORD, { wLang: DWORD, szLang: LPSTR, cchLang: DWORD } ],
  VerLanguageNameW: [ DWORD, { wLang: DWORD, szLang: LPWSTR, cchLang: DWORD } ],
  VerQueryValueA: [ BOOL, { pBlock: LPCVOID, lpSubBlock: LPCSTR, lplpBuffer: PTR(PTR(VOID)), puLen: PUINT } ],
  VerQueryValueW: [ BOOL, { pBlock: LPCVOID, lpSubBlock: LPCWSTR, lplpBuffer: PTR(PTR(VOID)), puLen: PUINT } ],
  RegCloseKey: [ LSTATUS, { hKey: HKEY } ],
  RegOverridePredefKey: [ LSTATUS, { hKey: HKEY, hNewHKey: HKEY } ],
  RegOpenUserClassesRoot: [ LSTATUS, { hToken: HANDLE, dwOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY } ],
  RegOpenCurrentUser: [ LSTATUS, { samDesired: REGSAM, phkResult: PHKEY } ],
  RegDisablePredefinedCache: [ LSTATUS, {  } ],
  RegDisablePredefinedCacheEx: [ LSTATUS, {  } ],
  RegConnectRegistryA: [ LSTATUS, { lpMachineName: LPCSTR, hKey: HKEY, phkResult: PHKEY } ],
  RegConnectRegistryW: [ LSTATUS, { lpMachineName: LPCWSTR, hKey: HKEY, phkResult: PHKEY } ],
  RegConnectRegistryExA: [ LSTATUS, { lpMachineName: LPCSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY } ],
  RegConnectRegistryExW: [ LSTATUS, { lpMachineName: LPCWSTR, hKey: HKEY, Flags: ULONG, phkResult: PHKEY } ],
  RegCreateKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY } ],
  RegCreateKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY } ],
  RegCreateKeyExA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, Reserved: DWORD, lpClass: LPSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD } ],
  RegCreateKeyExW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, Reserved: DWORD, lpClass: LPWSTR, dwOptions: DWORD, samDesired: REGSAM, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, phkResult: PHKEY, lpdwDisposition: LPDWORD } ],
  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 } ],
  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 } ],
  RegDeleteKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR } ],
  RegDeleteKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR } ],
  RegDeleteKeyExA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD } ],
  RegDeleteKeyExW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD } ],
  RegDeleteKeyTransactedA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID } ],
  RegDeleteKeyTransactedW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, samDesired: REGSAM, Reserved: DWORD, hTransaction: HANDLE, pExtendedParameter: PVOID } ],
  RegDisableReflectionKey: [ LONG, { hBase: HKEY } ],
  RegEnableReflectionKey: [ LONG, { hBase: HKEY } ],
  RegQueryReflectionKey: [ LONG, { hBase: HKEY, bIsReflectionDisabled: PTR(int) } ],
  RegDeleteValueA: [ LSTATUS, { hKey: HKEY, lpValueName: LPCSTR } ],
  RegDeleteValueW: [ LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR } ],
  RegEnumKeyA: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, cchName: DWORD } ],
  RegEnumKeyW: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, cchName: DWORD } ],
  RegEnumKeyExA: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME } ],
  RegEnumKeyExW: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpName: LPWSTR, lpcchName: LPDWORD, lpReserved: LPDWORD, lpClass: LPWSTR, lpcchClass: LPDWORD, lpftLastWriteTime: PFILETIME } ],
  RegEnumValueA: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpValueName: LPSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD } ],
  RegEnumValueW: [ LSTATUS, { hKey: HKEY, dwIndex: DWORD, lpValueName: LPWSTR, lpcchValueName: LPDWORD, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD } ],
  RegFlushKey: [ LSTATUS, { hKey: HKEY } ],
  RegGetKeySecurity: [ LSTATUS, { hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor: LPDWORD } ],
  RegLoadKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpFile: LPCSTR } ],
  RegLoadKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpFile: LPCWSTR } ],
  RegNotifyChangeKeyValue: [ LSTATUS, { hKey: HKEY, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, hEvent: HANDLE, fAsynchronous: BOOL } ],
  RegOpenKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, phkResult: PHKEY } ],
  RegOpenKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, phkResult: PHKEY } ],
  RegOpenKeyExA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY } ],
  RegOpenKeyExW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY } ],
  RegOpenKeyTransactedA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParemeter: PVOID } ],
  RegOpenKeyTransactedW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, ulOptions: DWORD, samDesired: REGSAM, phkResult: PHKEY, hTransaction: HANDLE, pExtendedParemeter: PVOID } ],
  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 } ],
  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 } ],
  RegQueryValueA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpData: LPSTR, lpcbData: PLONG } ],
  RegQueryValueW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpData: LPWSTR, lpcbData: PLONG } ],
  RegQueryMultipleValuesA: [ LSTATUS, { hKey: HKEY, val_list: PVALENTA, num_vals: DWORD, lpValueBuf: LPSTR, ldwTotsize: LPDWORD } ],
  RegQueryMultipleValuesW: [ LSTATUS, { hKey: HKEY, val_list: PVALENTW, num_vals: DWORD, lpValueBuf: LPWSTR, ldwTotsize: LPDWORD } ],
  RegQueryValueExA: [ LSTATUS, { hKey: HKEY, lpValueName: LPCSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD } ],
  RegQueryValueExW: [ LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR, lpReserved: LPDWORD, lpType: LPDWORD, lpData: LPBYTE, lpcbData: LPDWORD } ],
  RegReplaceKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpNewFile: LPCSTR, lpOldFile: LPCSTR } ],
  RegReplaceKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpNewFile: LPCWSTR, lpOldFile: LPCWSTR } ],
  RegRestoreKeyA: [ LSTATUS, { hKey: HKEY, lpFile: LPCSTR, dwFlags: DWORD } ],
  RegRestoreKeyW: [ LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, dwFlags: DWORD } ],
  RegRenameKey: [ LSTATUS, { hKey: HKEY, lpSubKeyName: LPCWSTR, lpNewKeyName: LPCWSTR } ],
  RegSaveKeyA: [ LSTATUS, { hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  RegSaveKeyW: [ LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  RegSetKeySecurity: [ LSTATUS, { hKey: HKEY, SecurityInformation: SECURITY_INFORMATION, pSecurityDescriptor: PSECURITY_DESCRIPTOR } ],
  RegSetValueA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, dwType: DWORD, lpData: LPCSTR, cbData: DWORD } ],
  RegSetValueW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, dwType: DWORD, lpData: LPCWSTR, cbData: DWORD } ],
  RegSetValueExA: [ LSTATUS, { hKey: HKEY, lpValueName: LPCSTR, Reserved: DWORD, dwType: DWORD, lpData: PTR(uchar), cbData: DWORD } ],
  RegSetValueExW: [ LSTATUS, { hKey: HKEY, lpValueName: LPCWSTR, Reserved: DWORD, dwType: DWORD, lpData: PTR(uchar), cbData: DWORD } ],
  RegUnLoadKeyA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR } ],
  RegUnLoadKeyW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR } ],
  RegDeleteKeyValueA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR } ],
  RegDeleteKeyValueW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR } ],
  RegSetKeyValueA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR, lpValueName: LPCSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD } ],
  RegSetKeyValueW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR, lpValueName: LPCWSTR, dwType: DWORD, lpData: LPCVOID, cbData: DWORD } ],
  RegDeleteTreeA: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCSTR } ],
  RegDeleteTreeW: [ LSTATUS, { hKey: HKEY, lpSubKey: LPCWSTR } ],
  RegCopyTreeA: [ LSTATUS, { hKeySrc: HKEY, lpSubKey: LPCSTR, hKeyDest: HKEY } ],
  RegCopyTreeW: [ LSTATUS, { hKeySrc: HKEY, lpSubKey: LPCWSTR, hKeyDest: HKEY } ],
  RegGetValueA: [ LSTATUS, { hkey: HKEY, lpSubKey: LPCSTR, lpValue: LPCSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD } ],
  RegGetValueW: [ LSTATUS, { hkey: HKEY, lpSubKey: LPCWSTR, lpValue: LPCWSTR, dwFlags: DWORD, pdwType: LPDWORD, pvData: PVOID, pcbData: LPDWORD } ],
  RegLoadMUIStringA: [ LSTATUS, { hKey: HKEY, pszValue: LPCSTR, pszOutBuf: LPSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCSTR } ],
  RegLoadMUIStringW: [ LSTATUS, { hKey: HKEY, pszValue: LPCWSTR, pszOutBuf: LPWSTR, cbOutBuf: DWORD, pcbData: LPDWORD, Flags: DWORD, pszDirectory: LPCWSTR } ],
  RegLoadAppKeyA: [ LSTATUS, { lpFile: LPCSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD } ],
  RegLoadAppKeyW: [ LSTATUS, { lpFile: LPCWSTR, phkResult: PHKEY, samDesired: REGSAM, dwOptions: DWORD, Reserved: DWORD } ],
  InitiateSystemShutdownA: [ BOOL, { lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL } ],
  InitiateSystemShutdownW: [ BOOL, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL } ],
  AbortSystemShutdownA: [ BOOL, { lpMachineName: LPSTR } ],
  AbortSystemShutdownW: [ BOOL, { lpMachineName: LPWSTR } ],
  InitiateSystemShutdownExA: [ BOOL, { lpMachineName: LPSTR, lpMessage: LPSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL, dwReason: DWORD } ],
  InitiateSystemShutdownExW: [ BOOL, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwTimeout: DWORD, bForceAppsClosed: BOOL, bRebootAfterShutdown: BOOL, dwReason: DWORD } ],
  InitiateShutdownA: [ DWORD, { lpMachineName: LPSTR, lpMessage: LPSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD } ],
  InitiateShutdownW: [ DWORD, { lpMachineName: LPWSTR, lpMessage: LPWSTR, dwGracePeriod: DWORD, dwShutdownFlags: DWORD, dwReason: DWORD } ],
  RegSaveKeyExA: [ LSTATUS, { hKey: HKEY, lpFile: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD } ],
  RegSaveKeyExW: [ LSTATUS, { hKey: HKEY, lpFile: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, Flags: DWORD } ],
  WNetAddConnectionA: [ DWORD, { lpRemoteName: LPCSTR, lpPassword: LPCSTR, lpLocalName: LPCSTR } ],
  WNetAddConnectionW: [ DWORD, { lpRemoteName: LPCWSTR, lpPassword: LPCWSTR, lpLocalName: LPCWSTR } ],
  WNetAddConnection2A: [ DWORD, { lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD } ],
  WNetAddConnection2W: [ DWORD, { lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD } ],
  WNetAddConnection3A: [ DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserName: LPCSTR, dwFlags: DWORD } ],
  WNetAddConnection3W: [ DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserName: LPCWSTR, dwFlags: DWORD } ],
  WNetCancelConnectionA: [ DWORD, { lpName: LPCSTR, fForce: BOOL } ],
  WNetCancelConnectionW: [ DWORD, { lpName: LPCWSTR, fForce: BOOL } ],
  WNetCancelConnection2A: [ DWORD, { lpName: LPCSTR, dwFlags: DWORD, fForce: BOOL } ],
  WNetCancelConnection2W: [ DWORD, { lpName: LPCWSTR, dwFlags: DWORD, fForce: BOOL } ],
  WNetGetConnectionA: [ DWORD, { lpLocalName: LPCSTR, lpRemoteName: LPSTR, lpnLength: LPDWORD } ],
  WNetGetConnectionW: [ DWORD, { lpLocalName: LPCWSTR, lpRemoteName: LPWSTR, lpnLength: LPDWORD } ],
  WNetRestoreSingleConnectionW: [ DWORD, { hwndParent: HWND, lpDevice: LPCWSTR, fUseUI: BOOL } ],
  WNetUseConnectionA: [ DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEA, lpPassword: LPCSTR, lpUserId: LPCSTR, dwFlags: DWORD, lpAccessName: LPSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD } ],
  WNetUseConnectionW: [ DWORD, { hwndOwner: HWND, lpNetResource: LPNETRESOURCEW, lpPassword: LPCWSTR, lpUserId: LPCWSTR, dwFlags: DWORD, lpAccessName: LPWSTR, lpBufferSize: LPDWORD, lpResult: LPDWORD } ],
  WNetConnectionDialog: [ DWORD, { hwnd: HWND, dwType: DWORD } ],
  WNetDisconnectDialog: [ DWORD, { hwnd: HWND, dwType: DWORD } ],
  WNetConnectionDialog1A: [ DWORD, { lpConnDlgStruct: LPCONNECTDLGSTRUCTA } ],
  WNetConnectionDialog1W: [ DWORD, { lpConnDlgStruct: LPCONNECTDLGSTRUCTW } ],
  WNetDisconnectDialog1A: [ DWORD, { lpConnDlgStruct: LPDISCDLGSTRUCTA } ],
  WNetDisconnectDialog1W: [ DWORD, { lpConnDlgStruct: LPDISCDLGSTRUCTW } ],
  WNetOpenEnumA: [ DWORD, { dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEA, lphEnum: LPHANDLE } ],
  WNetOpenEnumW: [ DWORD, { dwScope: DWORD, dwType: DWORD, dwUsage: DWORD, lpNetResource: LPNETRESOURCEW, lphEnum: LPHANDLE } ],
  WNetEnumResourceA: [ DWORD, { hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD } ],
  WNetEnumResourceW: [ DWORD, { hEnum: HANDLE, lpcCount: LPDWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD } ],
  WNetCloseEnum: [ DWORD, { hEnum: HANDLE } ],
  WNetGetResourceParentA: [ DWORD, { lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD } ],
  WNetGetResourceParentW: [ DWORD, { lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD } ],
  WNetGetResourceInformationA: [ DWORD, { lpNetResource: LPNETRESOURCEA, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: PTR(PTR(int8)) } ],
  WNetGetResourceInformationW: [ DWORD, { lpNetResource: LPNETRESOURCEW, lpBuffer: LPVOID, lpcbBuffer: LPDWORD, lplpSystem: PTR(PTR(ushort)) } ],
  WNetGetUniversalNameA: [ DWORD, { lpLocalPath: LPCSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD } ],
  WNetGetUniversalNameW: [ DWORD, { lpLocalPath: LPCWSTR, dwInfoLevel: DWORD, lpBuffer: LPVOID, lpBufferSize: LPDWORD } ],
  WNetGetUserA: [ DWORD, { lpName: LPCSTR, lpUserName: LPSTR, lpnLength: LPDWORD } ],
  WNetGetUserW: [ DWORD, { lpName: LPCWSTR, lpUserName: LPWSTR, lpnLength: LPDWORD } ],
  WNetGetProviderNameA: [ DWORD, { dwNetType: DWORD, lpProviderName: LPSTR, lpBufferSize: LPDWORD } ],
  WNetGetProviderNameW: [ DWORD, { dwNetType: DWORD, lpProviderName: LPWSTR, lpBufferSize: LPDWORD } ],
  WNetGetNetworkInformationA: [ DWORD, { lpProvider: LPCSTR, lpNetInfoStruct: LPNETINFOSTRUCT } ],
  WNetGetNetworkInformationW: [ DWORD, { lpProvider: LPCWSTR, lpNetInfoStruct: LPNETINFOSTRUCT } ],
  WNetGetLastErrorA: [ DWORD, { lpError: LPDWORD, lpErrorBuf: LPSTR, nErrorBufSize: DWORD, lpNameBuf: LPSTR, nNameBufSize: DWORD } ],
  WNetGetLastErrorW: [ DWORD, { lpError: LPDWORD, lpErrorBuf: LPWSTR, nErrorBufSize: DWORD, lpNameBuf: LPWSTR, nNameBufSize: DWORD } ],
  MultinetGetConnectionPerformanceA: [ DWORD, { lpNetResource: LPNETRESOURCEA, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT } ],
  MultinetGetConnectionPerformanceW: [ DWORD, { lpNetResource: LPNETRESOURCEW, lpNetConnectInfoStruct: LPNETCONNECTINFOSTRUCT } ],
  DdeSetQualityOfService: [ BOOL, { hwndClient: HWND, pqosNew: PTR(uint), pqosPrev: PSECURITY_QUALITY_OF_SERVICE } ],
  ImpersonateDdeClientWindow: [ BOOL, { hWndClient: HWND, hWndServer: HWND } ],
  PackDDElParam: [ LPARAM, { msg: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR } ],
  UnpackDDElParam: [ BOOL, { msg: UINT, lParam: LPARAM, puiLo: PUINT_PTR, puiHi: PUINT_PTR } ],
  FreeDDElParam: [ BOOL, { msg: UINT, lParam: LPARAM } ],
  ReuseDDElParam: [ LPARAM, { lParam: LPARAM, msgIn: UINT, msgOut: UINT, uiLo: UINT_PTR, uiHi: UINT_PTR } ],
  DdeInitializeA: [ UINT, { pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD } ],
  DdeInitializeW: [ UINT, { pidInst: LPDWORD, pfnCallback: PFNCALLBACK, afCmd: DWORD, ulRes: DWORD } ],
  DdeUninitialize: [ BOOL, { idInst: DWORD } ],
  DdeConnectList: [ HCONVLIST, { idInst: DWORD, hszService: HSZ, hszTopic: HSZ, hConvList: HCONVLIST, pCC: PCONVCONTEXT } ],
  DdeQueryNextServer: [ HCONV, { hConvList: HCONVLIST, hConvPrev: HCONV } ],
  DdeDisconnectList: [ BOOL, { hConvList: HCONVLIST } ],
  DdeConnect: [ HCONV, { idInst: DWORD, hszService: HSZ, hszTopic: HSZ, pCC: PCONVCONTEXT } ],
  DdeDisconnect: [ BOOL, { hConv: HCONV } ],
  DdeReconnect: [ HCONV, { hConv: HCONV } ],
  DdeQueryConvInfo: [ UINT, { hConv: HCONV, idTransaction: DWORD, pConvInfo: PCONVINFO } ],
  DdeSetUserHandle: [ BOOL, { hConv: HCONV, id: DWORD, hUser: DWORD_PTR } ],
  DdeAbandonTransaction: [ BOOL, { idInst: DWORD, hConv: HCONV, idTransaction: DWORD } ],
  DdePostAdvise: [ BOOL, { idInst: DWORD, hszTopic: HSZ, hszItem: HSZ } ],
  DdeEnableCallback: [ BOOL, { idInst: DWORD, hConv: HCONV, wCmd: UINT } ],
  DdeImpersonateClient: [ BOOL, { hConv: HCONV } ],
  DdeNameService: [ HDDEDATA, { idInst: DWORD, hsz1: HSZ, hsz2: HSZ, afCmd: UINT } ],
  DdeClientTransaction: [ HDDEDATA, { pData: LPBYTE, cbData: DWORD, hConv: HCONV, hszItem: HSZ, wFmt: UINT, wType: UINT, dwTimeout: DWORD, pdwResult: LPDWORD } ],
  DdeCreateDataHandle: [ HDDEDATA, { idInst: DWORD, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD, hszItem: HSZ, wFmt: UINT, afCmd: UINT } ],
  DdeAddData: [ HDDEDATA, { hData: HDDEDATA, pSrc: LPBYTE, cb: DWORD, cbOff: DWORD } ],
  DdeGetData: [ DWORD, { hData: HDDEDATA, pDst: LPBYTE, cbMax: DWORD, cbOff: DWORD } ],
  DdeAccessData: [ LPBYTE, { hData: HDDEDATA, pcbDataSize: LPDWORD } ],
  DdeUnaccessData: [ BOOL, { hData: HDDEDATA } ],
  DdeFreeDataHandle: [ BOOL, { hData: HDDEDATA } ],
  DdeGetLastError: [ UINT, { idInst: DWORD } ],
  DdeCreateStringHandleA: [ HSZ, { idInst: DWORD, psz: LPCSTR, iCodePage: int } ],
  DdeCreateStringHandleW: [ HSZ, { idInst: DWORD, psz: LPCWSTR, iCodePage: int } ],
  DdeQueryStringA: [ DWORD, { idInst: DWORD, hsz: HSZ, psz: LPSTR, cchMax: DWORD, iCodePage: int } ],
  DdeQueryStringW: [ DWORD, { idInst: DWORD, hsz: HSZ, psz: LPWSTR, cchMax: DWORD, iCodePage: int } ],
  DdeFreeStringHandle: [ BOOL, { idInst: DWORD, hsz: HSZ } ],
  DdeKeepStringHandle: [ BOOL, { idInst: DWORD, hsz: HSZ } ],
  DdeCmpStringHandles: [ VOID, { hsz1: HSZ, hsz2: HSZ } ],
  LZStart: [ INT, {  } ],
  LZDone: [ VOID, {  } ],
  CopyLZFile: [ LONG, { hfSource: INT, hfDest: INT } ],
  LZCopy: [ LONG, { hfSource: INT, hfDest: INT } ],
  LZInit: [ INT, { hfSource: INT } ],
  GetExpandedNameA: [ INT, { lpszSource: LPSTR, lpszBuffer: LPSTR } ],
  GetExpandedNameW: [ INT, { lpszSource: LPWSTR, lpszBuffer: LPWSTR } ],
  LZOpenFileA: [ INT, { lpFileName: LPSTR, lpReOpenBuf: LPOFSTRUCT, wStyle: WORD } ],
  LZOpenFileW: [ INT, { lpFileName: LPWSTR, lpReOpenBuf: LPOFSTRUCT, wStyle: WORD } ],
  LZSeek: [ LONG, { hFile: INT, lOffset: LONG, iOrigin: INT } ],
  LZRead: [ INT, { hFile: INT, lpBuffer: PTR(int8), cbRead: INT } ],
  LZClose: [ VOID, { hFile: INT } ],
  CloseDriver: [ LRESULT, { hDriver: HDRVR, lParam1: LPARAM, lParam2: LPARAM } ],
  OpenDriver: [ HDRVR, { szDriverName: LPCWSTR, szSectionName: LPCWSTR, lParam2: LPARAM } ],
  SendDriverMessage: [ LRESULT, { hDriver: HDRVR, message: UINT, lParam1: LPARAM, lParam2: LPARAM } ],
  DrvGetModuleHandle: [ HMODULE, { hDriver: HDRVR } ],
  GetDriverModuleHandle: [ HMODULE, { hDriver: HDRVR } ],
  DefDriverProc: [ LRESULT, { dwDriverIdentifier: DWORD_PTR, hdrvr: HDRVR, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM } ],
  sndPlaySoundA: [ BOOL, { pszSound: LPCSTR, fuSound: UINT } ],
  sndPlaySoundW: [ BOOL, { pszSound: LPCWSTR, fuSound: UINT } ],
  PlaySoundA: [ BOOL, { pszSound: LPCSTR, hmod: HMODULE, fdwSound: DWORD } ],
  PlaySoundW: [ BOOL, { pszSound: LPCWSTR, hmod: HMODULE, fdwSound: DWORD } ],
  waveOutGetNumDevs: [ UINT, {  } ],
  waveOutGetDevCapsA: [ MMRESULT, { uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSA, cbwoc: UINT } ],
  waveOutGetDevCapsW: [ MMRESULT, { uDeviceID: UINT_PTR, pwoc: LPWAVEOUTCAPSW, cbwoc: UINT } ],
  waveOutGetVolume: [ MMRESULT, { hwo: HWAVEOUT, pdwVolume: LPDWORD } ],
  waveOutSetVolume: [ MMRESULT, { hwo: HWAVEOUT, dwVolume: DWORD } ],
  waveOutGetErrorTextA: [ MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT } ],
  waveOutGetErrorTextW: [ MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT } ],
  waveOutOpen: [ MMRESULT, { phwo: LPHWAVEOUT, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  waveOutClose: [ MMRESULT, { hwo: HWAVEOUT } ],
  waveOutPrepareHeader: [ MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveOutUnprepareHeader: [ MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveOutWrite: [ MMRESULT, { hwo: HWAVEOUT, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveOutPause: [ MMRESULT, { hwo: HWAVEOUT } ],
  waveOutRestart: [ MMRESULT, { hwo: HWAVEOUT } ],
  waveOutReset: [ MMRESULT, { hwo: HWAVEOUT } ],
  waveOutBreakLoop: [ MMRESULT, { hwo: HWAVEOUT } ],
  waveOutGetPosition: [ MMRESULT, { hwo: HWAVEOUT, pmmt: LPMMTIME, cbmmt: UINT } ],
  waveOutGetPitch: [ MMRESULT, { hwo: HWAVEOUT, pdwPitch: LPDWORD } ],
  waveOutSetPitch: [ MMRESULT, { hwo: HWAVEOUT, dwPitch: DWORD } ],
  waveOutGetPlaybackRate: [ MMRESULT, { hwo: HWAVEOUT, pdwRate: LPDWORD } ],
  waveOutSetPlaybackRate: [ MMRESULT, { hwo: HWAVEOUT, dwRate: DWORD } ],
  waveOutGetID: [ MMRESULT, { hwo: HWAVEOUT, puDeviceID: LPUINT } ],
  waveOutMessage: [ MMRESULT, { hwo: HWAVEOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR } ],
  waveInGetNumDevs: [ UINT, {  } ],
  waveInGetDevCapsA: [ MMRESULT, { uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSA, cbwic: UINT } ],
  waveInGetDevCapsW: [ MMRESULT, { uDeviceID: UINT_PTR, pwic: LPWAVEINCAPSW, cbwic: UINT } ],
  waveInGetErrorTextA: [ MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT } ],
  waveInGetErrorTextW: [ MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT } ],
  waveInOpen: [ MMRESULT, { phwi: LPHWAVEIN, uDeviceID: UINT, pwfx: LPCWAVEFORMATEX, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  waveInClose: [ MMRESULT, { hwi: HWAVEIN } ],
  waveInPrepareHeader: [ MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveInUnprepareHeader: [ MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveInAddBuffer: [ MMRESULT, { hwi: HWAVEIN, pwh: LPWAVEHDR, cbwh: UINT } ],
  waveInStart: [ MMRESULT, { hwi: HWAVEIN } ],
  waveInStop: [ MMRESULT, { hwi: HWAVEIN } ],
  waveInReset: [ MMRESULT, { hwi: HWAVEIN } ],
  waveInGetPosition: [ MMRESULT, { hwi: HWAVEIN, pmmt: LPMMTIME, cbmmt: UINT } ],
  waveInGetID: [ MMRESULT, { hwi: HWAVEIN, puDeviceID: LPUINT } ],
  waveInMessage: [ MMRESULT, { hwi: HWAVEIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR } ],
  midiOutGetNumDevs: [ UINT, {  } ],
  midiStreamOpen: [ MMRESULT, { phms: LPHMIDISTRM, puDeviceID: LPUINT, cMidi: DWORD, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  midiStreamClose: [ MMRESULT, { hms: HMIDISTRM } ],
  midiStreamProperty: [ MMRESULT, { hms: HMIDISTRM, lppropdata: LPBYTE, dwProperty: DWORD } ],
  midiStreamPosition: [ MMRESULT, { hms: HMIDISTRM, lpmmt: LPMMTIME, cbmmt: UINT } ],
  midiStreamOut: [ MMRESULT, { hms: HMIDISTRM, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiStreamPause: [ MMRESULT, { hms: HMIDISTRM } ],
  midiStreamRestart: [ MMRESULT, { hms: HMIDISTRM } ],
  midiStreamStop: [ MMRESULT, { hms: HMIDISTRM } ],
  midiConnect: [ MMRESULT, { hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID } ],
  midiDisconnect: [ MMRESULT, { hmi: HMIDI, hmo: HMIDIOUT, pReserved: LPVOID } ],
  midiOutGetDevCapsA: [ MMRESULT, { uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSA, cbmoc: UINT } ],
  midiOutGetDevCapsW: [ MMRESULT, { uDeviceID: UINT_PTR, pmoc: LPMIDIOUTCAPSW, cbmoc: UINT } ],
  midiOutGetVolume: [ MMRESULT, { hmo: HMIDIOUT, pdwVolume: LPDWORD } ],
  midiOutSetVolume: [ MMRESULT, { hmo: HMIDIOUT, dwVolume: DWORD } ],
  midiOutGetErrorTextA: [ MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT } ],
  midiOutGetErrorTextW: [ MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT } ],
  midiOutOpen: [ MMRESULT, { phmo: LPHMIDIOUT, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  midiOutClose: [ MMRESULT, { hmo: HMIDIOUT } ],
  midiOutPrepareHeader: [ MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiOutUnprepareHeader: [ MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiOutShortMsg: [ MMRESULT, { hmo: HMIDIOUT, dwMsg: DWORD } ],
  midiOutLongMsg: [ MMRESULT, { hmo: HMIDIOUT, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiOutReset: [ MMRESULT, { hmo: HMIDIOUT } ],
  midiOutCachePatches: [ MMRESULT, { hmo: HMIDIOUT, uBank: UINT, pwpa: LPWORD, fuCache: UINT } ],
  midiOutCacheDrumPatches: [ MMRESULT, { hmo: HMIDIOUT, uPatch: UINT, pwkya: LPWORD, fuCache: UINT } ],
  midiOutGetID: [ MMRESULT, { hmo: HMIDIOUT, puDeviceID: LPUINT } ],
  midiOutMessage: [ MMRESULT, { hmo: HMIDIOUT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR } ],
  midiInGetNumDevs: [ UINT, {  } ],
  midiInGetDevCapsA: [ MMRESULT, { uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSA, cbmic: UINT } ],
  midiInGetDevCapsW: [ MMRESULT, { uDeviceID: UINT_PTR, pmic: LPMIDIINCAPSW, cbmic: UINT } ],
  midiInGetErrorTextA: [ MMRESULT, { mmrError: MMRESULT, pszText: LPSTR, cchText: UINT } ],
  midiInGetErrorTextW: [ MMRESULT, { mmrError: MMRESULT, pszText: LPWSTR, cchText: UINT } ],
  midiInOpen: [ MMRESULT, { phmi: LPHMIDIIN, uDeviceID: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  midiInClose: [ MMRESULT, { hmi: HMIDIIN } ],
  midiInPrepareHeader: [ MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiInUnprepareHeader: [ MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiInAddBuffer: [ MMRESULT, { hmi: HMIDIIN, pmh: LPMIDIHDR, cbmh: UINT } ],
  midiInStart: [ MMRESULT, { hmi: HMIDIIN } ],
  midiInStop: [ MMRESULT, { hmi: HMIDIIN } ],
  midiInReset: [ MMRESULT, { hmi: HMIDIIN } ],
  midiInGetID: [ MMRESULT, { hmi: HMIDIIN, puDeviceID: LPUINT } ],
  midiInMessage: [ MMRESULT, { hmi: HMIDIIN, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR } ],
  auxGetNumDevs: [ UINT, {  } ],
  auxGetDevCapsA: [ MMRESULT, { uDeviceID: UINT_PTR, pac: LPAUXCAPSA, cbac: UINT } ],
  auxGetDevCapsW: [ MMRESULT, { uDeviceID: UINT_PTR, pac: LPAUXCAPSW, cbac: UINT } ],
  auxSetVolume: [ MMRESULT, { uDeviceID: UINT, dwVolume: DWORD } ],
  auxGetVolume: [ MMRESULT, { uDeviceID: UINT, pdwVolume: LPDWORD } ],
  auxOutMessage: [ MMRESULT, { uDeviceID: UINT, uMsg: UINT, dw1: DWORD_PTR, dw2: DWORD_PTR } ],
  mixerGetNumDevs: [ UINT, {  } ],
  mixerGetDevCapsA: [ MMRESULT, { uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSA, cbmxcaps: UINT } ],
  mixerGetDevCapsW: [ MMRESULT, { uMxId: UINT_PTR, pmxcaps: LPMIXERCAPSW, cbmxcaps: UINT } ],
  mixerOpen: [ MMRESULT, { phmx: LPHMIXER, uMxId: UINT, dwCallback: DWORD_PTR, dwInstance: DWORD_PTR, fdwOpen: DWORD } ],
  mixerClose: [ MMRESULT, { hmx: HMIXER } ],
  mixerMessage: [ DWORD, { hmx: HMIXER, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR } ],
  mixerGetLineInfoA: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEA, fdwInfo: DWORD } ],
  mixerGetLineInfoW: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxl: LPMIXERLINEW, fdwInfo: DWORD } ],
  mixerGetID: [ MMRESULT, { hmxobj: HMIXEROBJ, puMxId: PTR(uint), fdwId: DWORD } ],
  mixerGetLineControlsA: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSA, fdwControls: DWORD } ],
  mixerGetLineControlsW: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxlc: LPMIXERLINECONTROLSW, fdwControls: DWORD } ],
  mixerGetControlDetailsA: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD } ],
  mixerGetControlDetailsW: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD } ],
  mixerSetControlDetails: [ MMRESULT, { hmxobj: HMIXEROBJ, pmxcd: LPMIXERCONTROLDETAILS, fdwDetails: DWORD } ],
  timeGetSystemTime: [ MMRESULT, { pmmt: LPMMTIME, cbmmt: UINT } ],
  timeGetTime: [ DWORD, {  } ],
  timeSetEvent: [ MMRESULT, { uDelay: UINT, uResolution: UINT, fptc: LPTIMECALLBACK, dwUser: DWORD_PTR, fuEvent: UINT } ],
  timeKillEvent: [ MMRESULT, { uTimerID: UINT } ],
  timeGetDevCaps: [ MMRESULT, { ptc: LPTIMECAPS, cbtc: UINT } ],
  timeBeginPeriod: [ MMRESULT, { uPeriod: UINT } ],
  timeEndPeriod: [ MMRESULT, { uPeriod: UINT } ],
  joyGetNumDevs: [ UINT, {  } ],
  joyGetDevCapsA: [ MMRESULT, { uJoyID: UINT_PTR, pjc: LPJOYCAPSA, cbjc: UINT } ],
  joyGetDevCapsW: [ MMRESULT, { uJoyID: UINT_PTR, pjc: LPJOYCAPSW, cbjc: UINT } ],
  joyGetPos: [ MMRESULT, { uJoyID: UINT, pji: LPJOYINFO } ],
  joyGetPosEx: [ MMRESULT, { uJoyID: UINT, pji: LPJOYINFOEX } ],
  joyGetThreshold: [ MMRESULT, { uJoyID: UINT, puThreshold: LPUINT } ],
  joyReleaseCapture: [ MMRESULT, { uJoyID: UINT } ],
  joySetCapture: [ MMRESULT, { hwnd: HWND, uJoyID: UINT, uPeriod: UINT, fChanged: BOOL } ],
  joySetThreshold: [ MMRESULT, { uJoyID: UINT, uThreshold: UINT } ],
  mmioStringToFOURCCA: [ FOURCC, { sz: LPCSTR, uFlags: UINT } ],
  mmioStringToFOURCCW: [ FOURCC, { sz: LPCWSTR, uFlags: UINT } ],
  mmioInstallIOProcA: [ LPMMIOPROC, { fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD } ],
  mmioInstallIOProcW: [ LPMMIOPROC, { fccIOProc: FOURCC, pIOProc: LPMMIOPROC, dwFlags: DWORD } ],
  mmioOpenA: [ HMMIO, { pszFileName: LPSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD } ],
  mmioOpenW: [ HMMIO, { pszFileName: LPWSTR, pmmioinfo: LPMMIOINFO, fdwOpen: DWORD } ],
  mmioRenameA: [ MMRESULT, { pszFileName: LPCSTR, pszNewFileName: LPCSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD } ],
  mmioRenameW: [ MMRESULT, { pszFileName: LPCWSTR, pszNewFileName: LPCWSTR, pmmioinfo: LPCMMIOINFO, fdwRename: DWORD } ],
  mmioClose: [ MMRESULT, { hmmio: HMMIO, fuClose: UINT } ],
  mmioRead: [ LONG, { hmmio: HMMIO, pch: HPSTR, cch: LONG } ],
  mmioWrite: [ LONG, { hmmio: HMMIO, pch: PTR(int8), cch: LONG } ],
  mmioSeek: [ LONG, { hmmio: HMMIO, lOffset: LONG, iOrigin: int } ],
  mmioGetInfo: [ MMRESULT, { hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuInfo: UINT } ],
  mmioSetInfo: [ MMRESULT, { hmmio: HMMIO, pmmioinfo: LPCMMIOINFO, fuInfo: UINT } ],
  mmioSetBuffer: [ MMRESULT, { hmmio: HMMIO, pchBuffer: LPSTR, cchBuffer: LONG, fuBuffer: UINT } ],
  mmioFlush: [ MMRESULT, { hmmio: HMMIO, fuFlush: UINT } ],
  mmioAdvance: [ MMRESULT, { hmmio: HMMIO, pmmioinfo: LPMMIOINFO, fuAdvance: UINT } ],
  mmioSendMessage: [ LRESULT, { hmmio: HMMIO, uMsg: UINT, lParam1: LPARAM, lParam2: LPARAM } ],
  mmioDescend: [ MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, pmmckiParent: PTR(uint), fuDescend: UINT } ],
  mmioAscend: [ MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, fuAscend: UINT } ],
  mmioCreateChunk: [ MMRESULT, { hmmio: HMMIO, pmmcki: LPMMCKINFO, fuCreate: UINT } ],
  mciSendCommandA: [ MCIERROR, { mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR } ],
  mciSendCommandW: [ MCIERROR, { mciId: MCIDEVICEID, uMsg: UINT, dwParam1: DWORD_PTR, dwParam2: DWORD_PTR } ],
  mciSendStringA: [ MCIERROR, { lpstrCommand: LPCSTR, lpstrReturnString: LPSTR, uReturnLength: UINT, hwndCallback: HWND } ],
  mciSendStringW: [ MCIERROR, { lpstrCommand: LPCWSTR, lpstrReturnString: LPWSTR, uReturnLength: UINT, hwndCallback: HWND } ],
  mciGetDeviceIDA: [ MCIDEVICEID, { pszDevice: LPCSTR } ],
  mciGetDeviceIDW: [ MCIDEVICEID, { pszDevice: LPCWSTR } ],
  mciGetDeviceIDFromElementIDA: [ MCIDEVICEID, { dwElementID: DWORD, lpstrType: LPCSTR } ],
  mciGetDeviceIDFromElementIDW: [ MCIDEVICEID, { dwElementID: DWORD, lpstrType: LPCWSTR } ],
  mciGetErrorStringA: [ BOOL, { mcierr: MCIERROR, pszText: LPSTR, cchText: UINT } ],
  mciGetErrorStringW: [ BOOL, { mcierr: MCIERROR, pszText: LPWSTR, cchText: UINT } ],
  mciSetYieldProc: [ BOOL, { mciId: MCIDEVICEID, fpYieldProc: YIELDPROC, dwYieldData: DWORD } ],
  mciGetCreatorTask: [ HTASK, { mciId: MCIDEVICEID } ],
  mciGetYieldProc: [ YIELDPROC, { mciId: MCIDEVICEID, pdwYieldData: LPDWORD } ],
  Netbios: [ UCHAR, { pncb: PNCB } ],
  RpcBindingCopy: [ RPC_STATUS, { SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: PTR(PTR(VOID)) } ],
  RpcBindingFree: [ RPC_STATUS, { Binding: PTR(PTR(VOID)) } ],
  RpcBindingSetOption: [ RPC_STATUS, { hBinding: RPC_BINDING_HANDLE, option: ulong, optionValue: ULONG_PTR } ],
  RpcBindingInqOption: [ RPC_STATUS, { hBinding: RPC_BINDING_HANDLE, option: ulong, pOptionValue: PTR(ulong) } ],
  RpcBindingFromStringBindingA: [ RPC_STATUS, { StringBinding: RPC_CSTR, Binding: PTR(PTR(VOID)) } ],
  RpcBindingFromStringBindingW: [ RPC_STATUS, { StringBinding: RPC_WSTR, Binding: PTR(PTR(VOID)) } ],
  RpcSsGetContextBinding: [ RPC_STATUS, { ContextHandle: PTR(VOID), Binding: PTR(PTR(VOID)) } ],
  RpcBindingInqObject: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) } ],
  RpcBindingReset: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE } ],
  RpcBindingSetObject: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) } ],
  RpcMgmtInqDefaultProtectLevel: [ RPC_STATUS, { AuthnSvc: ulong, AuthnLevel: PTR(ulong) } ],
  RpcBindingToStringBindingA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(uchar)) } ],
  RpcBindingToStringBindingW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(ushort)) } ],
  RpcBindingVectorFree: [ RPC_STATUS, { BindingVector: PTR(PTR(uint)) } ],
  RpcStringBindingComposeA: [ RPC_STATUS, { ObjUuid: RPC_CSTR, ProtSeq: RPC_CSTR, NetworkAddr: RPC_CSTR, Endpoint: RPC_CSTR, Options: RPC_CSTR, StringBinding: PTR(PTR(uchar)) } ],
  RpcStringBindingComposeW: [ RPC_STATUS, { ObjUuid: RPC_WSTR, ProtSeq: RPC_WSTR, NetworkAddr: RPC_WSTR, Endpoint: RPC_WSTR, Options: RPC_WSTR, StringBinding: PTR(PTR(ushort)) } ],
  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)) } ],
  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)) } ],
  RpcStringFreeA: [ RPC_STATUS, { String: PTR(PTR(uchar)) } ],
  RpcStringFreeW: [ RPC_STATUS, { String: PTR(PTR(ushort)) } ],
  RpcIfInqId: [ RPC_STATUS, { RpcIfHandle: RPC_IF_HANDLE, RpcIfId: PTR(uint) } ],
  RpcNetworkIsProtseqValidA: [ RPC_STATUS, { Protseq: RPC_CSTR } ],
  RpcNetworkIsProtseqValidW: [ RPC_STATUS, { Protseq: RPC_WSTR } ],
  RpcMgmtInqComTimeout: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Timeout: PTR(uint) } ],
  RpcMgmtSetComTimeout: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Timeout: uint } ],
  RpcMgmtSetCancelTimeout: [ RPC_STATUS, { Timeout: long } ],
  RpcNetworkInqProtseqsA: [ RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) } ],
  RpcNetworkInqProtseqsW: [ RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) } ],
  RpcObjectInqType: [ RPC_STATUS, { ObjUuid: PTR(uint), TypeUuid: PTR(uint) } ],
  RpcObjectSetInqFn: [ RPC_STATUS, { InquiryFn: PTR(CALLBACK(VOID, [PTR(UUID), PTR(UUID), PTR(long)])) } ],
  RpcObjectSetType: [ RPC_STATUS, { ObjUuid: PTR(uint), TypeUuid: PTR(uint) } ],
  RpcProtseqVectorFreeA: [ RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) } ],
  RpcProtseqVectorFreeW: [ RPC_STATUS, { ProtseqVector: PTR(PTR(uint)) } ],
  RpcServerInqBindings: [ RPC_STATUS, { BindingVector: PTR(PTR(uint)) } ],
  RpcServerInqIf: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR(PTR(VOID)) } ],
  RpcServerListen: [ RPC_STATUS, { MinimumCallThreads: uint, MaxCalls: uint, DontWait: uint } ],
  RpcServerRegisterIf: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), MgrEpv: PTR(VOID) } ],
  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)])) } ],
  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)])) } ],
  RpcServerUnregisterIf: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), WaitForCallsToComplete: uint } ],
  RpcServerUnregisterIfEx: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, MgrTypeUuid: PTR(uint), RundownContextHandles: int } ],
  RpcServerUseAllProtseqs: [ RPC_STATUS, { MaxCalls: uint, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseAllProtseqsEx: [ RPC_STATUS, { MaxCalls: uint, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseAllProtseqsIf: [ RPC_STATUS, { MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseAllProtseqsIfEx: [ RPC_STATUS, { MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqExA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqExW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqEpA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqEpExA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqEpW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqEpExW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqIfA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqIfExA: [ RPC_STATUS, { Protseq: RPC_CSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerUseProtseqIfW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID) } ],
  RpcServerUseProtseqIfExW: [ RPC_STATUS, { Protseq: RPC_WSTR, MaxCalls: uint, IfSpec: RPC_IF_HANDLE, SecurityDescriptor: PTR(VOID), Policy: PRPC_POLICY } ],
  RpcServerYield: [ VOID, {  } ],
  RpcMgmtStatsVectorFree: [ RPC_STATUS, { StatsVector: PTR(PTR(uint)) } ],
  RpcMgmtInqStats: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Statistics: PTR(PTR(uint)) } ],
  RpcMgmtIsServerListening: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE } ],
  RpcMgmtStopServerListening: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE } ],
  RpcMgmtWaitServerListen: [ RPC_STATUS, {  } ],
  RpcMgmtSetServerStackSize: [ RPC_STATUS, { ThreadStackSize: ulong } ],
  RpcSsDontSerializeContext: [ VOID, {  } ],
  RpcMgmtEnableIdleCleanup: [ RPC_STATUS, {  } ],
  RpcMgmtInqIfIds: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, IfIdVector: PTR(PTR(uint)) } ],
  RpcIfIdVectorFree: [ RPC_STATUS, { IfIdVector: PTR(PTR(uint)) } ],
  RpcMgmtInqServerPrincNameA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AuthnSvc: ulong, ServerPrincName: PTR(PTR(uchar)) } ],
  RpcMgmtInqServerPrincNameW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AuthnSvc: ulong, ServerPrincName: PTR(PTR(ushort)) } ],
  RpcServerInqDefaultPrincNameA: [ RPC_STATUS, { AuthnSvc: ulong, PrincName: PTR(PTR(uchar)) } ],
  RpcServerInqDefaultPrincNameW: [ RPC_STATUS, { AuthnSvc: ulong, PrincName: PTR(PTR(ushort)) } ],
  RpcEpResolveBinding: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE } ],
  RpcNsBindingInqEntryNameA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: PTR(PTR(uchar)) } ],
  RpcNsBindingInqEntryNameW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: PTR(PTR(ushort)) } ],
  RpcBindingCreateA: [ RPC_STATUS, { Template: PTR(uint), Security: PTR(uint), Options: PTR(uint), Binding: PTR(PTR(VOID)) } ],
  RpcBindingCreateW: [ RPC_STATUS, { Template: PTR(uint), Security: PTR(uint), Options: PTR(uint), Binding: PTR(PTR(VOID)) } ],
  RpcBindingGetTrainingContextHandle: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ContextHandle: PTR(PTR(VOID)) } ],
  RpcServerInqBindingHandle: [ RPC_STATUS, { Binding: PTR(PTR(VOID)) } ],
  RpcImpersonateClient: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE } ],
  RpcRevertToSelfEx: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE } ],
  RpcRevertToSelf: [ RPC_STATUS, {  } ],
  RpcBindingInqAuthClientA: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR(VOID)), ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong) } ],
  RpcBindingInqAuthClientW: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, Privs: PTR(PTR(VOID)), ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthzSvc: PTR(ulong) } ],
  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 } ],
  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 } ],
  RpcBindingInqAuthInfoA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(uchar)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR(VOID)), AuthzSvc: PTR(ulong) } ],
  RpcBindingInqAuthInfoW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: PTR(PTR(ushort)), AuthnLevel: PTR(ulong), AuthnSvc: PTR(ulong), AuthIdentity: PTR(PTR(VOID)), AuthzSvc: PTR(ulong) } ],
  RpcBindingSetAuthInfoA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong } ],
  RpcBindingSetAuthInfoExA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_CSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong, SecurityQos: PTR(uint) } ],
  RpcBindingSetAuthInfoW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong } ],
  RpcBindingSetAuthInfoExW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ServerPrincName: RPC_WSTR, AuthnLevel: ulong, AuthnSvc: ulong, AuthIdentity: RPC_AUTH_IDENTITY_HANDLE, AuthzSvc: ulong, SecurityQOS: PTR(uint) } ],
  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) } ],
  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) } ],
  RpcServerCompleteSecurityCallback: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, Status: RPC_STATUS } ],
  RpcServerRegisterAuthInfoA: [ RPC_STATUS, { ServerPrincName: RPC_CSTR, AuthnSvc: ulong, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: PTR(VOID) } ],
  RpcServerRegisterAuthInfoW: [ RPC_STATUS, { ServerPrincName: RPC_WSTR, AuthnSvc: ulong, GetKeyFn: RPC_AUTH_KEY_RETRIEVAL_FN, Arg: PTR(VOID) } ],
  RpcBindingServerFromClient: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, ServerBinding: PTR(PTR(VOID)) } ],
  RpcRaiseException: [ VOID, { exception: RPC_STATUS } ],
  RpcTestCancel: [ RPC_STATUS, {  } ],
  RpcServerTestCancel: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE } ],
  RpcCancelThread: [ RPC_STATUS, { Thread: PTR(VOID) } ],
  RpcCancelThreadEx: [ RPC_STATUS, { Thread: PTR(VOID), Timeout: long } ],
  UuidCreate: [ RPC_STATUS, { Uuid: PTR(uint) } ],
  UuidCreateSequential: [ RPC_STATUS, { Uuid: PTR(uint) } ],
  UuidToStringA: [ RPC_STATUS, { Uuid: PTR(uint), StringUuid: PTR(PTR(uchar)) } ],
  UuidFromStringA: [ RPC_STATUS, { StringUuid: RPC_CSTR, Uuid: PTR(uint) } ],
  UuidToStringW: [ RPC_STATUS, { Uuid: PTR(uint), StringUuid: PTR(PTR(ushort)) } ],
  UuidFromStringW: [ RPC_STATUS, { StringUuid: RPC_WSTR, Uuid: PTR(uint) } ],
  UuidCompare: [ VOID, { Uuid1: PTR(uint), Uuid2: PTR(uint), Status: PTR(long) } ],
  UuidCreateNil: [ RPC_STATUS, { NilUuid: PTR(uint) } ],
  UuidEqual: [ VOID, { Uuid1: PTR(uint), Uuid2: PTR(uint), Status: PTR(long) } ],
  UuidHash: [ VOID, { Uuid: PTR(uint), Status: PTR(long) } ],
  UuidIsNil: [ VOID, { Uuid: PTR(uint), Status: PTR(long) } ],
  RpcEpRegisterNoReplaceA: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_CSTR } ],
  RpcEpRegisterNoReplaceW: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_WSTR } ],
  RpcEpRegisterA: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_CSTR } ],
  RpcEpRegisterW: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint), Annotation: RPC_WSTR } ],
  RpcEpUnregister: [ RPC_STATUS, { IfSpec: RPC_IF_HANDLE, BindingVector: PTR(uint), UuidVector: PTR(uint) } ],
  DceErrorInqTextA: [ RPC_STATUS, { RpcStatus: RPC_STATUS, ErrorText: RPC_CSTR } ],
  DceErrorInqTextW: [ RPC_STATUS, { RpcStatus: RPC_STATUS, ErrorText: RPC_WSTR } ],
  RpcMgmtEpEltInqBegin: [ RPC_STATUS, { EpBinding: RPC_BINDING_HANDLE, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, ObjectUuid: PTR(uint), InquiryContext: PTR(VOIDPTR) } ],
  RpcMgmtEpEltInqDone: [ RPC_STATUS, { InquiryContext: PTR(VOIDPTR) } ],
  RpcMgmtEpEltInqNextA: [ RPC_STATUS, { InquiryContext: RPC_EP_INQ_HANDLE, IfId: PTR(uint), Binding: PTR(PTR(VOID)), ObjectUuid: PTR(uint), Annotation: PTR(PTR(uchar)) } ],
  RpcMgmtEpEltInqNextW: [ RPC_STATUS, { InquiryContext: RPC_EP_INQ_HANDLE, IfId: PTR(uint), Binding: PTR(PTR(VOID)), ObjectUuid: PTR(uint), Annotation: PTR(PTR(ushort)) } ],
  RpcMgmtEpUnregister: [ RPC_STATUS, { EpBinding: RPC_BINDING_HANDLE, IfId: PTR(uint), Binding: RPC_BINDING_HANDLE, ObjectUuid: PTR(uint) } ],
  RpcMgmtSetAuthorizationFn: [ RPC_STATUS, { AuthorizationFn: RPC_MGMT_AUTHORIZATION_FN } ],
  RpcExceptionFilter: [ VOID, { ExceptionCode: ulong } ],
  I_RpcNegotiateTransferSyntax: [ RPC_STATUS, { Message: PTR(uint) } ],
  I_RpcGetBuffer: [ RPC_STATUS, { Message: PTR(uint) } ],
  I_RpcGetBufferWithObject: [ RPC_STATUS, { Message: PTR(uint), ObjectUuid: PTR(uint) } ],
  I_RpcSendReceive: [ RPC_STATUS, { Message: PTR(uint) } ],
  I_RpcFreeBuffer: [ RPC_STATUS, { Message: PTR(uint) } ],
  I_RpcSend: [ RPC_STATUS, { Message: PRPC_MESSAGE } ],
  I_RpcReceive: [ RPC_STATUS, { Message: PRPC_MESSAGE, Size: uint } ],
  I_RpcFreePipeBuffer: [ RPC_STATUS, { Message: PTR(uint) } ],
  I_RpcReallocPipeBuffer: [ RPC_STATUS, { Message: PRPC_MESSAGE, NewSize: uint } ],
  I_RpcRequestMutex: [ VOID, { Mutex: PTR(PTR(VOID)) } ],
  I_RpcClearMutex: [ VOID, { Mutex: I_RPC_MUTEX } ],
  I_RpcDeleteMutex: [ VOID, { Mutex: I_RPC_MUTEX } ],
  I_RpcAllocate: [ VOID, { Size: uint } ],
  I_RpcFree: [ VOID, { Object: PTR(VOID) } ],
  I_RpcPauseExecution: [ VOID, { Milliseconds: ulong } ],
  I_RpcGetExtendedError: [ RPC_STATUS, {  } ],
  I_RpcMonitorAssociation: [ RPC_STATUS, { Handle: RPC_BINDING_HANDLE, RundownRoutine: PRPC_RUNDOWN, Context: PTR(VOID) } ],
  I_RpcStopMonitorAssociation: [ RPC_STATUS, { Handle: RPC_BINDING_HANDLE } ],
  I_RpcGetCurrentCallHandle: [ RPC_BINDING_HANDLE, {  } ],
  I_RpcGetAssociationContext: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, AssociationContext: PTR(PTR(VOID)) } ],
  I_RpcGetServerContextList: [ VOID, { BindingHandle: RPC_BINDING_HANDLE } ],
  I_RpcSetServerContextList: [ VOID, { BindingHandle: RPC_BINDING_HANDLE, ServerContextList: PTR(VOID) } ],
  I_RpcNsInterfaceExported: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: PTR(ushort), RpcInterfaceInformation: PTR(uint) } ],
  I_RpcNsInterfaceUnexported: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: PTR(ushort), RpcInterfaceInformation: PTR(uint) } ],
  I_RpcBindingToStaticStringBindingW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, StringBinding: PTR(PTR(ushort)) } ],
  I_RpcBindingInqSecurityContext: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, SecurityContextHandle: PTR(PTR(VOID)) } ],
  I_RpcBindingInqSecurityContextKeyInfo: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, KeyInfo: PTR(VOID) } ],
  I_RpcBindingInqWireIdForSnego: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, WireId: RPC_CSTR } ],
  I_RpcBindingInqMarshalledTargetInfo: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, MarshalledTargetInfoSize: PTR(ulong), MarshalledTargetInfo: PTR(PTR(uchar)) } ],
  I_RpcBindingInqLocalClientPID: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Pid: PTR(ulong) } ],
  I_RpcBindingHandleToAsyncHandle: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, AsyncHandle: PTR(PTR(VOID)) } ],
  I_RpcNsBindingSetEntryNameW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: RPC_WSTR } ],
  I_RpcNsBindingSetEntryNameA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, EntryNameSyntax: ulong, EntryName: RPC_CSTR } ],
  I_RpcServerUseProtseqEp2A: [ RPC_STATUS, { NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: uint, Endpoint: RPC_CSTR, SecurityDescriptor: PTR(VOID), Policy: PTR(VOID) } ],
  I_RpcServerUseProtseqEp2W: [ RPC_STATUS, { NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: uint, Endpoint: RPC_WSTR, SecurityDescriptor: PTR(VOID), Policy: PTR(VOID) } ],
  I_RpcServerUseProtseq2W: [ RPC_STATUS, { NetworkAddress: RPC_WSTR, Protseq: RPC_WSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID), Policy: PTR(VOID) } ],
  I_RpcServerUseProtseq2A: [ RPC_STATUS, { NetworkAddress: RPC_CSTR, Protseq: RPC_CSTR, MaxCalls: uint, SecurityDescriptor: PTR(VOID), Policy: PTR(VOID) } ],
  I_RpcServerStartService: [ RPC_STATUS, { Protseq: RPC_WSTR, Endpoint: RPC_WSTR, IfSpec: RPC_IF_HANDLE } ],
  I_RpcBindingInqDynamicEndpointW: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, DynamicEndpoint: PTR(PTR(ushort)) } ],
  I_RpcBindingInqDynamicEndpointA: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, DynamicEndpoint: PTR(PTR(uchar)) } ],
  I_RpcServerCheckClientRestriction: [ RPC_STATUS, { Context: RPC_BINDING_HANDLE } ],
  I_RpcBindingInqTransportType: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Type: PTR(uint) } ],
  I_RpcIfInqTransferSyntaxes: [ RPC_STATUS, { RpcIfHandle: RPC_IF_HANDLE, TransferSyntaxes: PTR(uint), TransferSyntaxSize: uint, TransferSyntaxCount: PTR(uint) } ],
  I_UuidCreate: [ RPC_STATUS, { Uuid: PTR(uint) } ],
  I_RpcBindingCopy: [ RPC_STATUS, { SourceBinding: RPC_BINDING_HANDLE, DestinationBinding: PTR(PTR(VOID)) } ],
  I_RpcBindingIsClientLocal: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, ClientLocalFlag: PTR(uint) } ],
  I_RpcBindingInqConnId: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, ConnId: PTR(PTR(VOID)), pfFirstCall: PTR(int) } ],
  I_RpcBindingCreateNP: [ RPC_STATUS, { ServerName: RPC_WSTR, ServiceName: RPC_WSTR, NetworkOptions: RPC_WSTR, Binding: PTR(PTR(VOID)) } ],
  I_RpcSsDontSerializeContext: [ VOID, {  } ],
  I_RpcLaunchDatagramReceiveThread: [ RPC_STATUS, { pAddress: PTR(VOID) } ],
  I_RpcServerRegisterForwardFunction: [ RPC_STATUS, { pForwardFunction: PTR(CALLBACK(long, [PTR(UUID), PTR(RPC_VERSION), PTR(UUID), PTR(uchar), PTR(PTR(VOID))])) } ],
  I_RpcServerInqAddressChangeFn: [ RPC_ADDRESS_CHANGE_FN, {  } ],
  I_RpcServerSetAddressChangeFn: [ RPC_STATUS, { pAddressChangeFn: PTR(CALLBACK(VOID, [PTR(VOID)])) } ],
  I_RpcServerInqLocalConnAddress: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Buffer: PTR(VOID), BufferSize: PTR(ulong), AddressFormat: PTR(ulong) } ],
  I_RpcServerInqRemoteConnAddress: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Buffer: PTR(VOID), BufferSize: PTR(ulong), AddressFormat: PTR(ulong) } ],
  I_RpcSessionStrictContextHandle: [ VOID, {  } ],
  I_RpcTurnOnEEInfoPropagation: [ RPC_STATUS, {  } ],
  I_RpcConnectionInqSockBuffSize: [ RPC_STATUS, { RecvBuffSize: PTR(ulong), SendBuffSize: PTR(ulong) } ],
  I_RpcConnectionSetSockBuffSize: [ RPC_STATUS, { RecvBuffSize: ulong, SendBuffSize: ulong } ],
  I_RpcServerStartListening: [ RPC_STATUS, { hWnd: PTR(VOID) } ],
  I_RpcServerStopListening: [ RPC_STATUS, {  } ],
  I_RpcBindingSetAsync: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, BlockingFn: RPC_BLOCKING_FN, ServerTid: ulong } ],
  I_RpcSetThreadParams: [ RPC_STATUS, { fClientFree: int, Context: PTR(VOID), hWndClient: PTR(VOID) } ],
  I_RpcWindowProc: [ VOID, { hWnd: PTR(VOID), Message: uint, wParam: uint, lParam: ulong } ],
  I_RpcServerUnregisterEndpointA: [ RPC_STATUS, { Protseq: RPC_CSTR, Endpoint: RPC_CSTR } ],
  I_RpcServerUnregisterEndpointW: [ RPC_STATUS, { Protseq: RPC_WSTR, Endpoint: RPC_WSTR } ],
  I_RpcServerInqTransportType: [ RPC_STATUS, { Type: PTR(uint) } ],
  I_RpcMapWin32Status: [ VOID, { Status: RPC_STATUS } ],
  I_RpcProxyNewConnection: [ RPC_STATUS, { ConnectionType: ulong, ServerAddress: PTR(ushort), ServerPort: PTR(ushort), MinConnTimeout: PTR(ushort), ConnectionParameter: PTR(VOID), CallOutState: PTR(uint), ProxyCallbackInterface: PTR(uint) } ],
  I_RpcReplyToClientWithStatus: [ RPC_STATUS, { ConnectionParameter: PTR(VOID), RpcStatus: RPC_STATUS } ],
  I_RpcRecordCalloutFailure: [ VOID, { RpcStatus: RPC_STATUS, CallOutState: PTR(uint), DllName: PTR(ushort) } ],
  I_RpcMgmtEnableDedicatedThreadPool: [ RPC_STATUS, {  } ],
  RpcNsBindingExportA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, BindingVec: PTR(uint), ObjectUuidVec: PTR(uint) } ],
  RpcNsBindingUnexportA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: PTR(uint) } ],
  RpcNsBindingExportW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, BindingVec: PTR(uint), ObjectUuidVec: PTR(uint) } ],
  RpcNsBindingUnexportW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectUuidVec: PTR(uint) } ],
  RpcNsBindingExportPnPA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) } ],
  RpcNsBindingUnexportPnPA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) } ],
  RpcNsBindingExportPnPW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) } ],
  RpcNsBindingUnexportPnPW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjectVector: PTR(uint) } ],
  RpcNsBindingLookupBeginA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), BindingMaxCount: ulong, LookupContext: PTR(PTR(VOID)) } ],
  RpcNsBindingLookupBeginW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), BindingMaxCount: ulong, LookupContext: PTR(PTR(VOID)) } ],
  RpcNsBindingLookupNext: [ RPC_STATUS, { LookupContext: RPC_NS_HANDLE, BindingVec: PTR(PTR(uint)) } ],
  RpcNsBindingLookupDone: [ RPC_STATUS, { LookupContext: PTR(PTR(VOID)) } ],
  RpcNsGroupDeleteA: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR } ],
  RpcNsGroupMbrAddA: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, MemberName: RPC_CSTR } ],
  RpcNsGroupMbrRemoveA: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, MemberName: RPC_CSTR } ],
  RpcNsGroupMbrInqBeginA: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_CSTR, MemberNameSyntax: ulong, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsGroupMbrInqNextA: [ RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, MemberName: PTR(PTR(uchar)) } ],
  RpcNsGroupDeleteW: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR } ],
  RpcNsGroupMbrAddW: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, MemberName: RPC_WSTR } ],
  RpcNsGroupMbrRemoveW: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, MemberName: RPC_WSTR } ],
  RpcNsGroupMbrInqBeginW: [ RPC_STATUS, { GroupNameSyntax: ulong, GroupName: RPC_WSTR, MemberNameSyntax: ulong, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsGroupMbrInqNextW: [ RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, MemberName: PTR(PTR(ushort)) } ],
  RpcNsGroupMbrInqDone: [ RPC_STATUS, { InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsProfileDeleteA: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR } ],
  RpcNsProfileEltAddA: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_CSTR, Priority: ulong, Annotation: RPC_CSTR } ],
  RpcNsProfileEltRemoveA: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_CSTR } ],
  RpcNsProfileEltInqBeginA: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_CSTR, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, MemberNameSyntax: ulong, MemberName: RPC_CSTR, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsProfileEltInqNextA: [ RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, IfId: PTR(uint), MemberName: PTR(PTR(uchar)), Priority: PTR(ulong), Annotation: PTR(PTR(uchar)) } ],
  RpcNsProfileDeleteW: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR } ],
  RpcNsProfileEltAddW: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_WSTR, Priority: ulong, Annotation: RPC_WSTR } ],
  RpcNsProfileEltRemoveW: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, IfId: PTR(uint), MemberNameSyntax: ulong, MemberName: RPC_WSTR } ],
  RpcNsProfileEltInqBeginW: [ RPC_STATUS, { ProfileNameSyntax: ulong, ProfileName: RPC_WSTR, InquiryType: ulong, IfId: PTR(uint), VersOption: ulong, MemberNameSyntax: ulong, MemberName: RPC_WSTR, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsProfileEltInqNextW: [ RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, IfId: PTR(uint), MemberName: PTR(PTR(ushort)), Priority: PTR(ulong), Annotation: PTR(PTR(ushort)) } ],
  RpcNsProfileEltInqDone: [ RPC_STATUS, { InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsEntryObjectInqBeginA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsEntryObjectInqBeginW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsEntryObjectInqNext: [ RPC_STATUS, { InquiryContext: RPC_NS_HANDLE, ObjUuid: PTR(uint) } ],
  RpcNsEntryObjectInqDone: [ RPC_STATUS, { InquiryContext: PTR(PTR(VOID)) } ],
  RpcNsEntryExpandNameA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, ExpandedName: PTR(PTR(uchar)) } ],
  RpcNsMgmtBindingUnexportA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfId: PTR(uint), VersOption: ulong, ObjectUuidVec: PTR(uint) } ],
  RpcNsMgmtEntryCreateA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR } ],
  RpcNsMgmtEntryDeleteA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR } ],
  RpcNsMgmtEntryInqIfIdsA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfIdVec: PTR(PTR(uint)) } ],
  RpcNsMgmtHandleSetExpAge: [ RPC_STATUS, { NsHandle: RPC_NS_HANDLE, ExpirationAge: ulong } ],
  RpcNsMgmtInqExpAge: [ RPC_STATUS, { ExpirationAge: PTR(ulong) } ],
  RpcNsMgmtSetExpAge: [ RPC_STATUS, { ExpirationAge: ulong } ],
  RpcNsEntryExpandNameW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, ExpandedName: PTR(PTR(ushort)) } ],
  RpcNsMgmtBindingUnexportW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfId: PTR(uint), VersOption: ulong, ObjectUuidVec: PTR(uint) } ],
  RpcNsMgmtEntryCreateW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR } ],
  RpcNsMgmtEntryDeleteW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR } ],
  RpcNsMgmtEntryInqIfIdsW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfIdVec: PTR(PTR(uint)) } ],
  RpcNsBindingImportBeginA: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_CSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), ImportContext: PTR(PTR(VOID)) } ],
  RpcNsBindingImportBeginW: [ RPC_STATUS, { EntryNameSyntax: ulong, EntryName: RPC_WSTR, IfSpec: RPC_IF_HANDLE, ObjUuid: PTR(uint), ImportContext: PTR(PTR(VOID)) } ],
  RpcNsBindingImportNext: [ RPC_STATUS, { ImportContext: RPC_NS_HANDLE, Binding: PTR(PTR(VOID)) } ],
  RpcNsBindingImportDone: [ RPC_STATUS, { ImportContext: PTR(PTR(VOID)) } ],
  RpcNsBindingSelect: [ RPC_STATUS, { BindingVec: PTR(uint), Binding: PTR(PTR(VOID)) } ],
  RpcAsyncInitializeHandle: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Size: uint } ],
  RpcAsyncRegisterInfo: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE } ],
  RpcAsyncGetCallStatus: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE } ],
  RpcAsyncCompleteCall: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Reply: PTR(VOID) } ],
  RpcAsyncAbortCall: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, ExceptionCode: ulong } ],
  RpcAsyncCancelCall: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, fAbort: BOOL } ],
  RpcErrorStartEnumeration: [ RPC_STATUS, { EnumHandle: PTR(uint) } ],
  RpcErrorGetNextRecord: [ RPC_STATUS, { EnumHandle: PTR(uint), CopyStrings: BOOL, ErrorInfo: PTR(uint) } ],
  RpcErrorEndEnumeration: [ RPC_STATUS, { EnumHandle: PTR(uint) } ],
  RpcErrorResetEnumeration: [ RPC_STATUS, { EnumHandle: PTR(uint) } ],
  RpcErrorGetNumberOfRecords: [ RPC_STATUS, { EnumHandle: PTR(uint), Records: PTR(int) } ],
  RpcErrorSaveErrorInfo: [ RPC_STATUS, { EnumHandle: PTR(uint), ErrorBlob: PTR(PTR(VOID)), BlobSize: PTR(uint) } ],
  RpcErrorLoadErrorInfo: [ RPC_STATUS, { ErrorBlob: PVOID, BlobSize: size_t, EnumHandle: PTR(uint) } ],
  RpcErrorAddRecord: [ RPC_STATUS, { ErrorInfo: PTR(uint) } ],
  RpcErrorClearInformation: [ VOID, {  } ],
  RpcAsyncCleanupThread: [ RPC_STATUS, { dwTimeout: DWORD } ],
  RpcGetAuthorizationContextForClient: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, ImpersonateOnReturn: BOOL, Reserved1: PVOID, pExpirationTime: PLARGE_INTEGER, Reserved2: LUID, Reserved3: DWORD, Reserved4: PVOID, pAuthzClientContext: PTR(PTR(VOID)) } ],
  RpcFreeAuthorizationContext: [ RPC_STATUS, { pAuthzClientContext: PTR(PTR(VOID)) } ],
  RpcSsContextLockExclusive: [ RPC_STATUS, { ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID } ],
  RpcSsContextLockShared: [ RPC_STATUS, { ServerBindingHandle: RPC_BINDING_HANDLE, UserContext: PVOID } ],
  RpcServerInqCallAttributesW: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: PTR(VOID) } ],
  RpcServerInqCallAttributesA: [ RPC_STATUS, { ClientBinding: RPC_BINDING_HANDLE, RpcCallAttributes: PTR(VOID) } ],
  RpcServerSubscribeForNotification: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Notification: RPC_NOTIFICATIONS, NotificationType: RPC_NOTIFICATION_TYPES, NotificationInfo: PTR(uint) } ],
  RpcServerUnsubscribeForNotification: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE, Notification: RPC_NOTIFICATIONS, NotificationsQueued: PTR(ulong) } ],
  RpcBindingBind: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, Binding: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE } ],
  RpcBindingUnbind: [ RPC_STATUS, { Binding: RPC_BINDING_HANDLE } ],
  RpcDiagnoseError: [ RPC_STATUS, { BindingHandle: RPC_BINDING_HANDLE, IfSpec: RPC_IF_HANDLE, RpcStatus: RPC_STATUS, EnumHandle: PTR(uint), Options: ULONG, ParentWindow: HWND } ],
  I_RpcAsyncSetHandle: [ RPC_STATUS, { Message: PRPC_MESSAGE, pAsync: PRPC_ASYNC_STATE } ],
  I_RpcAsyncAbortCall: [ RPC_STATUS, { pAsync: PRPC_ASYNC_STATE, ExceptionCode: ulong } ],
  I_RpcExceptionFilter: [ VOID, { ExceptionCode: ulong } ],
  DragQueryFileA: [ UINT, { hDrop: HDROP, iFile: UINT, lpszFile: LPSTR, cch: UINT } ],
  DragQueryFileW: [ UINT, { hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT } ],
  DragQueryPoint: [ BOOL, { hDrop: HDROP, lppt: LPPOINT } ],
  DragFinish: [ VOID, { hDrop: HDROP } ],
  DragAcceptFiles: [ VOID, { hWnd: HWND, fAccept: BOOL } ],
  ShellExecuteA: [ HINSTANCE, { hwnd: HWND, lpOperation: LPCSTR, lpFile: LPCSTR, lpParameters: LPCSTR, lpDirectory: LPCSTR, nShowCmd: INT } ],
  ShellExecuteW: [ HINSTANCE, { hwnd: HWND, lpOperation: LPCWSTR, lpFile: LPCWSTR, lpParameters: LPCWSTR, lpDirectory: LPCWSTR, nShowCmd: INT } ],
  FindExecutableA: [ HINSTANCE, { lpFile: LPCSTR, lpDirectory: LPCSTR, lpResult: LPSTR } ],
  FindExecutableW: [ HINSTANCE, { lpFile: LPCWSTR, lpDirectory: LPCWSTR, lpResult: LPWSTR } ],
  CommandLineToArgvW: [ LPWSTR, { lpCmdLine: LPCWSTR, pNumArgs: PTR(int) } ],
  ShellAboutA: [ INT, { hWnd: HWND, szApp: LPCSTR, szOtherStuff: LPCSTR, hIcon: HICON } ],
  ShellAboutW: [ INT, { hWnd: HWND, szApp: LPCWSTR, szOtherStuff: LPCWSTR, hIcon: HICON } ],
  DuplicateIcon: [ HICON, { hInst: HINSTANCE, hIcon: HICON } ],
  ExtractAssociatedIconA: [ HICON, { hInst: HINSTANCE, pszIconPath: LPSTR, piIcon: PTR(ushort) } ],
  ExtractAssociatedIconW: [ HICON, { hInst: HINSTANCE, pszIconPath: LPWSTR, piIcon: PTR(ushort) } ],
  ExtractAssociatedIconExA: [ HICON, { hInst: HINSTANCE, pszIconPath: LPSTR, piIconIndex: PTR(ushort), piIconId: PTR(ushort) } ],
  ExtractAssociatedIconExW: [ HICON, { hInst: HINSTANCE, pszIconPath: LPWSTR, piIconIndex: PTR(ushort), piIconId: PTR(ushort) } ],
  ExtractIconA: [ HICON, { hInst: HINSTANCE, lpszExeFileName: LPCSTR, nIconIndex: UINT } ],
  ExtractIconW: [ HICON, { hInst: HINSTANCE, lpszExeFileName: LPCWSTR, nIconIndex: UINT } ],
  SHAppBarMessage: [ UINT_PTR, { dwMessage: DWORD, pData: PAPPBARDATA } ],
  DoEnvironmentSubstA: [ DWORD, { szString: LPSTR, cchString: UINT } ],
  DoEnvironmentSubstW: [ DWORD, { szString: LPWSTR, cchString: UINT } ],
  ExtractIconExA: [ UINT, { lpszFile: LPCSTR, nIconIndex: int, phiconLarge: PTR(VOIDPTR), phiconSmall: PTR(VOIDPTR), nIcons: UINT } ],
  ExtractIconExW: [ UINT, { lpszFile: LPCWSTR, nIconIndex: int, phiconLarge: PTR(VOIDPTR), phiconSmall: PTR(VOIDPTR), nIcons: UINT } ],
  SHFileOperationA: [ VOID, { lpFileOp: LPSHFILEOPSTRUCTA } ],
  SHFileOperationW: [ VOID, { lpFileOp: LPSHFILEOPSTRUCTW } ],
  SHFreeNameMappings: [ VOID, { hNameMappings: HANDLE } ],
  ShellExecuteExA: [ BOOL, { pExecInfo: PTR(uint) } ],
  ShellExecuteExW: [ BOOL, { pExecInfo: PTR(uint) } ],
  SHCreateProcessAsUserW: [ BOOL, { pscpi: PSHCREATEPROCESSINFOW } ],
  SHEvaluateSystemCommandTemplate: [ HRESULT, { pszCmdTemplate: PCWSTR, ppszApplication: PTR(PTR(ushort)), ppszCommandLine: PTR(PTR(ushort)), ppszParameters: PTR(PTR(ushort)) } ],
  AssocCreateForClasses: [ HRESULT, { rgClasses: PTR(uint), cClasses: ULONG, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  SHQueryRecycleBinA: [ HRESULT, { pszRootPath: LPCSTR, pSHQueryRBInfo: LPSHQUERYRBINFO } ],
  SHQueryRecycleBinW: [ HRESULT, { pszRootPath: LPCWSTR, pSHQueryRBInfo: LPSHQUERYRBINFO } ],
  SHEmptyRecycleBinA: [ HRESULT, { hwnd: HWND, pszRootPath: LPCSTR, dwFlags: DWORD } ],
  SHEmptyRecycleBinW: [ HRESULT, { hwnd: HWND, pszRootPath: LPCWSTR, dwFlags: DWORD } ],
  SHQueryUserNotificationState: [ HRESULT, { pquns: PTR(uint) } ],
  SHGetPropertyStoreForWindow: [ HRESULT, { hwnd: HWND, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  Shell_NotifyIconA: [ BOOL, { dwMessage: DWORD, lpData: PNOTIFYICONDATAA } ],
  Shell_NotifyIconW: [ BOOL, { dwMessage: DWORD, lpData: PNOTIFYICONDATAW } ],
  Shell_NotifyIconGetRect: [ HRESULT, { identifier: PTR(uint), iconLocation: PTR(uint) } ],
  SHGetFileInfoA: [ DWORD_PTR, { pszPath: LPCSTR, dwFileAttributes: DWORD, psfi: PTR(uint), cbFileInfo: UINT, uFlags: UINT } ],
  SHGetFileInfoW: [ DWORD_PTR, { pszPath: LPCWSTR, dwFileAttributes: DWORD, psfi: PTR(uint), cbFileInfo: UINT, uFlags: UINT } ],
  SHGetStockIconInfo: [ HRESULT, { siid: SHSTOCKICONID, uFlags: UINT, psii: PTR(uint) } ],
  SHGetDiskFreeSpaceExA: [ BOOL, { pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: PTR(uint), pulTotalNumberOfBytes: PTR(uint), pulTotalNumberOfFreeBytes: PTR(uint) } ],
  SHGetDiskFreeSpaceExW: [ BOOL, { pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: PTR(uint), pulTotalNumberOfBytes: PTR(uint), pulTotalNumberOfFreeBytes: PTR(uint) } ],
  SHGetNewLinkInfoA: [ BOOL, { pszLinkTo: LPCSTR, pszDir: LPCSTR, pszName: LPSTR, pfMustCopy: PTR(int), uFlags: UINT } ],
  SHGetNewLinkInfoW: [ BOOL, { pszLinkTo: LPCWSTR, pszDir: LPCWSTR, pszName: LPWSTR, pfMustCopy: PTR(int), uFlags: UINT } ],
  SHInvokePrinterCommandA: [ BOOL, { hwnd: HWND, uAction: UINT, lpBuf1: LPCSTR, lpBuf2: LPCSTR, fModal: BOOL } ],
  SHInvokePrinterCommandW: [ BOOL, { hwnd: HWND, uAction: UINT, lpBuf1: LPCWSTR, lpBuf2: LPCWSTR, fModal: BOOL } ],
  SHLoadNonloadedIconOverlayIdentifiers: [ HRESULT, {  } ],
  SHIsFileAvailableOffline: [ HRESULT, { pwszPath: LPCWSTR, pdwStatus: LPDWORD } ],
  SHSetLocalizedName: [ HRESULT, { pszPath: LPCWSTR, pszResModule: LPCWSTR, idsRes: int } ],
  SHRemoveLocalizedName: [ HRESULT, { pszPath: LPCWSTR } ],
  SHGetLocalizedName: [ HRESULT, { pszPath: LPCWSTR, pszResModule: LPWSTR, cch: UINT, pidsRes: PTR(int) } ],
  ShellMessageBoxA: [ VOID, { hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCSTR, lpcTitle: LPCSTR, fuStyle: UINT } ],
  ShellMessageBoxW: [ VOID, { hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCWSTR, lpcTitle: LPCWSTR, fuStyle: UINT } ],
  IsLFNDriveA: [ BOOL, { pszPath: LPCSTR } ],
  IsLFNDriveW: [ BOOL, { pszPath: LPCWSTR } ],
  SHEnumerateUnreadMailAccountsA: [ HRESULT, { hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPSTR, cchMailAddress: int } ],
  SHEnumerateUnreadMailAccountsW: [ HRESULT, { hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPWSTR, cchMailAddress: int } ],
  SHGetUnreadMailCountA: [ HRESULT, { hKeyUser: HKEY, pszMailAddress: LPCSTR, pdwCount: PTR(ulong), pFileTime: PTR(uint), pszShellExecuteCommand: LPSTR, cchShellExecuteCommand: int } ],
  SHGetUnreadMailCountW: [ HRESULT, { hKeyUser: HKEY, pszMailAddress: LPCWSTR, pdwCount: PTR(ulong), pFileTime: PTR(uint), pszShellExecuteCommand: LPWSTR, cchShellExecuteCommand: int } ],
  SHSetUnreadMailCountA: [ HRESULT, { pszMailAddress: LPCSTR, dwCount: DWORD, pszShellExecuteCommand: LPCSTR } ],
  SHSetUnreadMailCountW: [ HRESULT, { pszMailAddress: LPCWSTR, dwCount: DWORD, pszShellExecuteCommand: LPCWSTR } ],
  SHTestTokenMembership: [ BOOL, { hToken: HANDLE, ulRID: ULONG } ],
  SHGetImageList: [ HRESULT, { iImageList: int, riid: PTR(uint), ppvObj: PTR(PTR(VOID)) } ],
  InitNetworkAddressControl: [ BOOL, {  } ],
  SHGetDriveMedia: [ HRESULT, { pszDrive: LPCWSTR, pdwMediaContent: PTR(ulong) } ],
  __WSAFDIsSet: [ VOID, { PTR(uint): PTR(uint) } ],
  accept: [ SOCKET, { s: SOCKET, addr: PTR(sockaddr), addrlen: PTR(int) } ],
  bind: [ VOID, { s: SOCKET, addr: PTR(sockaddr), namelen: int } ],
  closesocket: [ VOID, { s: SOCKET } ],
  connect: [ VOID, { s: SOCKET, name: PTR(sockaddr), namelen: int } ],
  ioctlsocket: [ VOID, { s: SOCKET, cmd: long, argp: PTR(ulong) } ],
  getpeername: [ VOID, { s: SOCKET, name: PTR(sockaddr), namelen: PTR(int) } ],
  getsockname: [ VOID, { s: SOCKET, name: PTR(sockaddr), namelen: PTR(int) } ],
  getsockopt: [ VOID, { s: SOCKET, level: int, optname: int, optval: PTR(int8), optlen: PTR(int) } ],
  htonl: [ u_long, { hostlong: u_long } ],
  htons: [ u_short, { hostshort: u_short } ],
  inet_addr: [ VOID, { cp: PTR(int8) } ],
  inet_ntoa: [ VOID, { in: IN_ADDR } ],
  listen: [ VOID, { s: SOCKET, backlog: int } ],
  ntohl: [ u_long, { netlong: u_long } ],
  ntohs: [ u_short, { netshort: u_short } ],
  recv: [ VOID, { s: SOCKET, buf: PTR(int8), len: int, flags: int } ],
  recvfrom: [ VOID, { s: SOCKET, buf: PTR(int8), len: int, flags: int, from: PTR(sockaddr), fromlen: PTR(int) } ],
  select: [ VOID, { nfds: int, readfds: PTR(uint), writefds: PTR(uint), exceptfds: PTR(uint), timeout: PTR(timeval) } ],
  send: [ VOID, { s: SOCKET, buf: PTR(int8), len: int, flags: int } ],
  sendto: [ VOID, { s: SOCKET, buf: PTR(int8), len: int, flags: int, to: PTR(sockaddr), tolen: int } ],
  setsockopt: [ VOID, { s: SOCKET, level: int, optname: int, optval: PTR(int8), optlen: int } ],
  shutdown: [ VOID, { s: SOCKET, how: int } ],
  socket: [ SOCKET, { af: int, type: int, protocol: int } ],
  gethostbyaddr: [ HOSTENT, { addr: PTR(int8), len: int, type: int } ],
  gethostbyname: [ HOSTENT, { name: PTR(int8) } ],
  gethostname: [ VOID, { name: PTR(int8), namelen: int } ],
  getservbyport: [ SERVENT, { port: int, proto: PTR(int8) } ],
  getservbyname: [ SERVENT, { name: PTR(int8), proto: PTR(int8) } ],
  getprotobynumber: [ PROTOENT, { proto: int } ],
  getprotobyname: [ PROTOENT, { name: PTR(int8) } ],
  WSAStartup: [ VOID, { wVersionRequired: WORD, lpWSAData: LPWSADATA } ],
  WSACleanup: [ VOID, {  } ],
  WSASetLastError: [ VOID, { iError: int } ],
  WSAGetLastError: [ VOID, {  } ],
  WSAIsBlocking: [ BOOL, {  } ],
  WSAUnhookBlockingHook: [ VOID, {  } ],
  WSASetBlockingHook: [ FARPROC, { lpBlockFunc: FARPROC } ],
  WSACancelBlockingCall: [ VOID, {  } ],
  WSAAsyncGetServByName: [ HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), proto: PTR(int8), buf: PTR(int8), buflen: int } ],
  WSAAsyncGetServByPort: [ HANDLE, { hWnd: HWND, wMsg: u_int, port: int, proto: PTR(int8), buf: PTR(int8), buflen: int } ],
  WSAAsyncGetProtoByName: [ HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), buf: PTR(int8), buflen: int } ],
  WSAAsyncGetProtoByNumber: [ HANDLE, { hWnd: HWND, wMsg: u_int, number: int, buf: PTR(int8), buflen: int } ],
  WSAAsyncGetHostByName: [ HANDLE, { hWnd: HWND, wMsg: u_int, name: PTR(int8), buf: PTR(int8), buflen: int } ],
  WSAAsyncGetHostByAddr: [ HANDLE, { hWnd: HWND, wMsg: u_int, addr: PTR(int8), len: int, type: int, buf: PTR(int8), buflen: int } ],
  WSACancelAsyncRequest: [ VOID, { hAsyncTaskHandle: HANDLE } ],
  WSAAsyncSelect: [ VOID, { s: SOCKET, hWnd: HWND, wMsg: u_int, lEvent: long } ],
  WSARecvEx: [ VOID, { s: SOCKET, buf: PTR(int8), len: int, flags: PTR(int) } ],
  TransmitFile: [ BOOL, { hSocket: SOCKET, hFile: HANDLE, nNumberOfBytesToWrite: DWORD, nNumberOfBytesPerSend: DWORD, lpOverlapped: LPOVERLAPPED, lpTransmitBuffers: LPTRANSMIT_FILE_BUFFERS, dwReserved: DWORD } ],
  AcceptEx: [ BOOL, { sListenSocket: SOCKET, sAcceptSocket: SOCKET, lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, lpdwBytesReceived: LPDWORD, lpOverlapped: LPOVERLAPPED } ],
  GetAcceptExSockaddrs: [ VOID, { lpOutputBuffer: PVOID, dwReceiveDataLength: DWORD, dwLocalAddressLength: DWORD, dwRemoteAddressLength: DWORD, LocalSockaddr: PTR(PTR(sockaddr)), LocalSockaddrLength: LPINT, RemoteSockaddr: PTR(PTR(sockaddr)), RemoteSockaddrLength: LPINT } ],
  CryptAcquireContextA: [ BOOL, { phProv: PTR(ulong), szContainer: LPCSTR, szProvider: LPCSTR, dwProvType: DWORD, dwFlags: DWORD } ],
  CryptAcquireContextW: [ BOOL, { phProv: PTR(ulong), szContainer: LPCWSTR, szProvider: LPCWSTR, dwProvType: DWORD, dwFlags: DWORD } ],
  CryptReleaseContext: [ BOOL, { hProv: HCRYPTPROV, dwFlags: DWORD } ],
  CryptGenKey: [ BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, dwFlags: DWORD, phKey: PTR(ulong) } ],
  CryptDeriveKey: [ BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, hBaseData: HCRYPTHASH, dwFlags: DWORD, phKey: PTR(ulong) } ],
  CryptDestroyKey: [ BOOL, { hKey: HCRYPTKEY } ],
  CryptSetKeyParam: [ BOOL, { hKey: HCRYPTKEY, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD } ],
  CryptGetKeyParam: [ BOOL, { hKey: HCRYPTKEY, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD } ],
  CryptSetHashParam: [ BOOL, { hHash: HCRYPTHASH, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD } ],
  CryptGetHashParam: [ BOOL, { hHash: HCRYPTHASH, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD } ],
  CryptSetProvParam: [ BOOL, { hProv: HCRYPTPROV, dwParam: DWORD, pbData: PTR(uchar), dwFlags: DWORD } ],
  CryptGetProvParam: [ BOOL, { hProv: HCRYPTPROV, dwParam: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwFlags: DWORD } ],
  CryptGenRandom: [ BOOL, { hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: PTR(uchar) } ],
  CryptGetUserKey: [ BOOL, { hProv: HCRYPTPROV, dwKeySpec: DWORD, phUserKey: PTR(ulong) } ],
  CryptExportKey: [ BOOL, { hKey: HCRYPTKEY, hExpKey: HCRYPTKEY, dwBlobType: DWORD, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong) } ],
  CryptImportKey: [ BOOL, { hProv: HCRYPTPROV, pbData: PTR(uchar), dwDataLen: DWORD, hPubKey: HCRYPTKEY, dwFlags: DWORD, phKey: PTR(ulong) } ],
  CryptEncrypt: [ BOOL, { hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: BOOL, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong), dwBufLen: DWORD } ],
  CryptDecrypt: [ BOOL, { hKey: HCRYPTKEY, hHash: HCRYPTHASH, Final: BOOL, dwFlags: DWORD, pbData: PTR(uchar), pdwDataLen: PTR(ulong) } ],
  CryptCreateHash: [ BOOL, { hProv: HCRYPTPROV, Algid: ALG_ID, hKey: HCRYPTKEY, dwFlags: DWORD, phHash: PTR(ulong) } ],
  CryptHashData: [ BOOL, { hHash: HCRYPTHASH, pbData: PTR(uchar), dwDataLen: DWORD, dwFlags: DWORD } ],
  CryptHashSessionKey: [ BOOL, { hHash: HCRYPTHASH, hKey: HCRYPTKEY, dwFlags: DWORD } ],
  CryptDestroyHash: [ BOOL, { hHash: HCRYPTHASH } ],
  CryptSignHashA: [ BOOL, { hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCSTR, dwFlags: DWORD, pbSignature: PTR(uchar), pdwSigLen: PTR(ulong) } ],
  CryptSignHashW: [ BOOL, { hHash: HCRYPTHASH, dwKeySpec: DWORD, szDescription: LPCWSTR, dwFlags: DWORD, pbSignature: PTR(uchar), pdwSigLen: PTR(ulong) } ],
  CryptVerifySignatureA: [ BOOL, { hHash: HCRYPTHASH, pbSignature: PTR(uchar), dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCSTR, dwFlags: DWORD } ],
  CryptVerifySignatureW: [ BOOL, { hHash: HCRYPTHASH, pbSignature: PTR(uchar), dwSigLen: DWORD, hPubKey: HCRYPTKEY, szDescription: LPCWSTR, dwFlags: DWORD } ],
  CryptSetProviderA: [ BOOL, { pszProvName: LPCSTR, dwProvType: DWORD } ],
  CryptSetProviderW: [ BOOL, { pszProvName: LPCWSTR, dwProvType: DWORD } ],
  CryptSetProviderExA: [ BOOL, { pszProvName: LPCSTR, dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD } ],
  CryptSetProviderExW: [ BOOL, { pszProvName: LPCWSTR, dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD } ],
  CryptGetDefaultProviderA: [ BOOL, { dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pszProvName: LPSTR, pcbProvName: PTR(ulong) } ],
  CryptGetDefaultProviderW: [ BOOL, { dwProvType: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pszProvName: LPWSTR, pcbProvName: PTR(ulong) } ],
  CryptEnumProviderTypesA: [ BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szTypeName: LPSTR, pcbTypeName: PTR(ulong) } ],
  CryptEnumProviderTypesW: [ BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szTypeName: LPWSTR, pcbTypeName: PTR(ulong) } ],
  CryptEnumProvidersA: [ BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szProvName: LPSTR, pcbProvName: PTR(ulong) } ],
  CryptEnumProvidersW: [ BOOL, { dwIndex: DWORD, pdwReserved: PTR(ulong), dwFlags: DWORD, pdwProvType: PTR(ulong), szProvName: LPWSTR, pcbProvName: PTR(ulong) } ],
  CryptContextAddRef: [ BOOL, { hProv: HCRYPTPROV, pdwReserved: PTR(ulong), dwFlags: DWORD } ],
  CryptDuplicateKey: [ BOOL, { hKey: HCRYPTKEY, pdwReserved: PTR(ulong), dwFlags: DWORD, phKey: PTR(ulong) } ],
  CryptDuplicateHash: [ BOOL, { hHash: HCRYPTHASH, pdwReserved: PTR(ulong), dwFlags: DWORD, phHash: PTR(ulong) } ],
  GetEncSChannel: [ BOOL, { pData: PTR(PTR(uchar)), dwDecSize: PTR(ulong) } ],
  BCryptOpenAlgorithmProvider: [ NTSTATUS, { phAlgorithm: PTR(PTR(VOID)), pszAlgId: LPCWSTR, pszImplementation: LPCWSTR, dwFlags: ULONG } ],
  BCryptEnumAlgorithms: [ NTSTATUS, { dwAlgOperations: ULONG, pAlgCount: PTR(ulong), ppAlgList: PTR(PTR(uint)), dwFlags: ULONG } ],
  BCryptEnumProviders: [ NTSTATUS, { pszAlgId: LPCWSTR, pImplCount: PTR(ulong), ppImplList: PTR(PTR(uint)), dwFlags: ULONG } ],
  BCryptGetProperty: [ NTSTATUS, { hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG } ],
  BCryptSetProperty: [ NTSTATUS, { hObject: BCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG } ],
  BCryptCloseAlgorithmProvider: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, dwFlags: ULONG } ],
  BCryptFreeBuffer: [ VOID, { pvBuffer: PVOID } ],
  BCryptGenerateSymmetricKey: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phKey: PTR(PTR(VOID)), pbKeyObject: PUCHAR, cbKeyObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG } ],
  BCryptGenerateKeyPair: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phKey: PTR(PTR(VOID)), dwLength: ULONG, dwFlags: ULONG } ],
  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 } ],
  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 } ],
  BCryptExportKey: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, hExportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG } ],
  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 } ],
  BCryptImportKeyPair: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, hImportKey: BCRYPT_KEY_HANDLE, pszBlobType: LPCWSTR, phKey: PTR(PTR(VOID)), pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG } ],
  BCryptDuplicateKey: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, phNewKey: PTR(PTR(VOID)), pbKeyObject: PUCHAR, cbKeyObject: ULONG, dwFlags: ULONG } ],
  BCryptFinalizeKeyPair: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, dwFlags: ULONG } ],
  BCryptDestroyKey: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE } ],
  BCryptDestroySecret: [ NTSTATUS, { hSecret: BCRYPT_SECRET_HANDLE } ],
  BCryptSignHash: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: PTR(VOID), pbInput: PUCHAR, cbInput: ULONG, pbOutput: PUCHAR, cbOutput: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG } ],
  BCryptVerifySignature: [ NTSTATUS, { hKey: BCRYPT_KEY_HANDLE, pPaddingInfo: PTR(VOID), pbHash: PUCHAR, cbHash: ULONG, pbSignature: PUCHAR, cbSignature: ULONG, dwFlags: ULONG } ],
  BCryptSecretAgreement: [ NTSTATUS, { hPrivKey: BCRYPT_KEY_HANDLE, hPubKey: BCRYPT_KEY_HANDLE, phAgreedSecret: PTR(PTR(VOID)), dwFlags: ULONG } ],
  BCryptDeriveKey: [ NTSTATUS, { hSharedSecret: BCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: PTR(uint), pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, pcbResult: PTR(ulong), dwFlags: ULONG } ],
  BCryptCreateHash: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, phHash: PTR(PTR(VOID)), pbHashObject: PUCHAR, cbHashObject: ULONG, pbSecret: PUCHAR, cbSecret: ULONG, dwFlags: ULONG } ],
  BCryptHashData: [ NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, pbInput: PUCHAR, cbInput: ULONG, dwFlags: ULONG } ],
  BCryptFinishHash: [ NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, pbOutput: PUCHAR, cbOutput: ULONG, dwFlags: ULONG } ],
  BCryptDuplicateHash: [ NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, phNewHash: PTR(PTR(VOID)), pbHashObject: PUCHAR, cbHashObject: ULONG, dwFlags: ULONG } ],
  BCryptDestroyHash: [ NTSTATUS, { hHash: BCRYPT_HASH_HANDLE } ],
  BCryptGenRandom: [ NTSTATUS, { hAlgorithm: BCRYPT_ALG_HANDLE, pbBuffer: PUCHAR, cbBuffer: ULONG, dwFlags: ULONG } ],
  BCryptDeriveKeyCapi: [ NTSTATUS, { hHash: BCRYPT_HASH_HANDLE, hTargetAlg: BCRYPT_ALG_HANDLE, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG } ],
  BCryptDeriveKeyPBKDF2: [ NTSTATUS, { hPrf: BCRYPT_ALG_HANDLE, pbPassword: PUCHAR, cbPassword: ULONG, pbSalt: PUCHAR, cbSalt: ULONG, cIterations: ULONGLONG, pbDerivedKey: PUCHAR, cbDerivedKey: ULONG, dwFlags: ULONG } ],
  BCryptQueryProviderRegistration: [ NTSTATUS, { pszProvider: LPCWSTR, dwMode: ULONG, dwInterface: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptEnumRegisteredProviders: [ NTSTATUS, { pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptCreateContext: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG } ],
  BCryptDeleteContext: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR } ],
  BCryptEnumContexts: [ NTSTATUS, { dwTable: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptConfigureContext: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pConfig: PCRYPT_CONTEXT_CONFIG } ],
  BCryptQueryContextConfiguration: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptAddContextFunction: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, dwPosition: ULONG } ],
  BCryptRemoveContextFunction: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR } ],
  BCryptEnumContextFunctions: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptConfigureContextFunction: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pConfig: PCRYPT_CONTEXT_FUNCTION_CONFIG } ],
  BCryptQueryContextFunctionConfiguration: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptEnumContextFunctionProviders: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptSetContextFunctionProperty: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, cbValue: ULONG, pbValue: PUCHAR } ],
  BCryptQueryContextFunctionProperty: [ NTSTATUS, { dwTable: ULONG, pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProperty: LPCWSTR, pcbValue: PTR(ulong), ppbValue: PTR(PTR(uchar)) } ],
  BCryptRegisterConfigChangeNotify: [ NTSTATUS, { phEvent: PTR(PTR(VOID)) } ],
  BCryptUnregisterConfigChangeNotify: [ NTSTATUS, { hEvent: HANDLE } ],
  BCryptResolveProviders: [ NTSTATUS, { pszContext: LPCWSTR, dwInterface: ULONG, pszFunction: LPCWSTR, pszProvider: LPCWSTR, dwMode: ULONG, dwFlags: ULONG, pcbBuffer: PTR(ulong), ppBuffer: PTR(VOIDPTR) } ],
  BCryptGetFipsAlgorithmMode: [ NTSTATUS, { pfEnabled: PTR(uchar) } ],
  NCryptOpenStorageProvider: [ SECURITY_STATUS, { phProvider: PTR(ulong), pszProviderName: LPCWSTR, dwFlags: DWORD } ],
  NCryptEnumAlgorithms: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, dwAlgOperations: DWORD, pdwAlgCount: PTR(ulong), ppAlgList: PTR(PTR(uint)), dwFlags: DWORD } ],
  NCryptIsAlgSupported: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, pszAlgId: LPCWSTR, dwFlags: DWORD } ],
  NCryptEnumKeys: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, pszScope: LPCWSTR, ppKeyName: PTR(PTR(uint)), ppEnumState: PTR(PTR(VOID)), dwFlags: DWORD } ],
  NCryptEnumStorageProviders: [ SECURITY_STATUS, { pdwProviderCount: PTR(ulong), ppProviderList: PTR(PTR(uint)), dwFlags: DWORD } ],
  NCryptFreeBuffer: [ SECURITY_STATUS, { pvInput: PVOID } ],
  NCryptOpenKey: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phKey: PTR(ulong), pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD } ],
  NCryptCreatePersistedKey: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phKey: PTR(ulong), pszAlgId: LPCWSTR, pszKeyName: LPCWSTR, dwLegacyKeySpec: DWORD, dwFlags: DWORD } ],
  NCryptGetProperty: [ SECURITY_STATUS, { hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD } ],
  NCryptSetProperty: [ SECURITY_STATUS, { hObject: NCRYPT_HANDLE, pszProperty: LPCWSTR, pbInput: PBYTE, cbInput: DWORD, dwFlags: DWORD } ],
  NCryptFinalizeKey: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD } ],
  NCryptEncrypt: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: PTR(VOID), pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD } ],
  NCryptDecrypt: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pbInput: PBYTE, cbInput: DWORD, pPaddingInfo: PTR(VOID), pbOutput: PBYTE, cbOutput: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD } ],
  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 } ],
  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 } ],
  NCryptSignHash: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: PTR(VOID), pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, pcbResult: PTR(ulong), dwFlags: DWORD } ],
  NCryptVerifySignature: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, pPaddingInfo: PTR(VOID), pbHashValue: PBYTE, cbHashValue: DWORD, pbSignature: PBYTE, cbSignature: DWORD, dwFlags: DWORD } ],
  NCryptDeleteKey: [ SECURITY_STATUS, { hKey: NCRYPT_KEY_HANDLE, dwFlags: DWORD } ],
  NCryptFreeObject: [ SECURITY_STATUS, { hObject: NCRYPT_HANDLE } ],
  NCryptIsKeyHandle: [ BOOL, { hKey: NCRYPT_KEY_HANDLE } ],
  NCryptTranslateHandle: [ SECURITY_STATUS, { phProvider: PTR(ulong), phKey: PTR(ulong), hLegacyProv: HCRYPTPROV, hLegacyKey: HCRYPTKEY, dwLegacyKeySpec: DWORD, dwFlags: DWORD } ],
  NCryptNotifyChangeKey: [ SECURITY_STATUS, { hProvider: NCRYPT_PROV_HANDLE, phEvent: PTR(PTR(VOID)), dwFlags: DWORD } ],
  NCryptSecretAgreement: [ SECURITY_STATUS, { hPrivKey: NCRYPT_KEY_HANDLE, hPubKey: NCRYPT_KEY_HANDLE, phAgreedSecret: PTR(ulong), dwFlags: DWORD } ],
  NCryptDeriveKey: [ SECURITY_STATUS, { hSharedSecret: NCRYPT_SECRET_HANDLE, pwszKDF: LPCWSTR, pParameterList: PTR(uint), pbDerivedKey: PBYTE, cbDerivedKey: DWORD, pcbResult: PTR(ulong), dwFlags: ULONG } ],
  CryptFormatObject: [ BOOL, { dwCertEncodingType: DWORD, dwFormatType: DWORD, dwFormatStrType: DWORD, pFormatStruct: PTR(VOID), lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbFormat: PTR(VOID), pcbFormat: PTR(ulong) } ],
  CryptEncodeObjectEx: [ BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: PTR(VOID), dwFlags: DWORD, pEncodePara: PCRYPT_ENCODE_PARA, pvEncoded: PTR(VOID), pcbEncoded: PTR(ulong) } ],
  CryptEncodeObject: [ BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: PTR(VOID), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) } ],
  CryptDecodeObjectEx: [ BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pDecodePara: PCRYPT_DECODE_PARA, pvStructInfo: PTR(VOID), pcbStructInfo: PTR(ulong) } ],
  CryptDecodeObject: [ BOOL, { dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pvStructInfo: PTR(VOID), pcbStructInfo: PTR(ulong) } ],
  CryptInstallOIDFunctionAddress: [ BOOL, { hModule: HMODULE, dwEncodingType: DWORD, pszFuncName: LPCSTR, cFuncEntry: DWORD, rgFuncEntry: PTR(uint), dwFlags: DWORD } ],
  CryptInitOIDFunctionSet: [ HCRYPTOIDFUNCSET, { pszFuncName: LPCSTR, dwFlags: DWORD } ],
  CryptGetOIDFunctionAddress: [ BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pszOID: LPCSTR, dwFlags: DWORD, ppvFuncAddr: PTR(PTR(VOID)), phFuncAddr: PTR(PTR(VOID)) } ],
  CryptGetDefaultOIDDllList: [ BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDllList: PTR(ushort), pcchDllList: PTR(ulong) } ],
  CryptGetDefaultOIDFunctionAddress: [ BOOL, { hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDll: LPCWSTR, dwFlags: DWORD, ppvFuncAddr: PTR(PTR(VOID)), phFuncAddr: PTR(PTR(VOID)) } ],
  CryptFreeOIDFunctionAddress: [ BOOL, { hFuncAddr: HCRYPTOIDFUNCADDR, dwFlags: DWORD } ],
  CryptRegisterOIDFunction: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszDll: LPCWSTR, pszOverrideFuncName: LPCSTR } ],
  CryptUnregisterOIDFunction: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR } ],
  CryptRegisterDefaultOIDFunction: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, dwIndex: DWORD, pwszDll: LPCWSTR } ],
  CryptUnregisterDefaultOIDFunction: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pwszDll: LPCWSTR } ],
  CryptSetOIDFunctionValue: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, dwValueType: DWORD, pbValueData: PTR(uchar), cbValueData: DWORD } ],
  CryptGetOIDFunctionValue: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR, pdwValueType: PTR(ulong), pbValueData: PTR(uchar), pcbValueData: PTR(ulong) } ],
  CryptEnumOIDFunction: [ BOOL, { dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, dwFlags: DWORD, pvArg: PTR(VOID), pfnEnumOIDFunc: PFN_CRYPT_ENUM_OID_FUNC } ],
  CryptFindOIDInfo: [ PCCRYPT_OID_INFO, { dwKeyType: DWORD, pvKey: PTR(VOID), dwGroupId: DWORD } ],
  CryptRegisterOIDInfo: [ BOOL, { pInfo: PCCRYPT_OID_INFO, dwFlags: DWORD } ],
  CryptUnregisterOIDInfo: [ BOOL, { pInfo: PCCRYPT_OID_INFO } ],
  CryptEnumOIDInfo: [ BOOL, { dwGroupId: DWORD, dwFlags: DWORD, pvArg: PTR(VOID), pfnEnumOIDInfo: PFN_CRYPT_ENUM_OID_INFO } ],
  CryptFindLocalizedName: [ LPCWSTR, { pwszCryptName: LPCWSTR } ],
  CryptMsgOpenToEncode: [ HCRYPTMSG, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: PTR(VOID), pszInnerContentObjID: LPSTR, pStreamInfo: PCMSG_STREAM_INFO } ],
  CryptMsgCalculateEncodedLength: [ DWORD, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: PTR(VOID), pszInnerContentObjID: LPSTR, cbData: DWORD } ],
  CryptMsgOpenToDecode: [ HCRYPTMSG, { dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, pRecipientInfo: PCERT_INFO, pStreamInfo: PCMSG_STREAM_INFO } ],
  CryptMsgDuplicate: [ HCRYPTMSG, { hCryptMsg: HCRYPTMSG } ],
  CryptMsgClose: [ BOOL, { hCryptMsg: HCRYPTMSG } ],
  CryptMsgUpdate: [ BOOL, { hCryptMsg: HCRYPTMSG, pbData: PTR(uchar), cbData: DWORD, fFinal: BOOL } ],
  CryptMsgGetParam: [ BOOL, { hCryptMsg: HCRYPTMSG, dwParamType: DWORD, dwIndex: DWORD, pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CryptMsgControl: [ BOOL, { hCryptMsg: HCRYPTMSG, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: PTR(VOID) } ],
  CryptMsgVerifyCountersignatureEncoded: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE, cbSignerInfoCountersignature: DWORD, pciCountersigner: PCERT_INFO } ],
  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) } ],
  CryptMsgCountersign: [ BOOL, { hCryptMsg: HCRYPTMSG, dwIndex: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO } ],
  CryptMsgCountersignEncoded: [ BOOL, { dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, cCountersigners: DWORD, rgCountersigners: PCMSG_SIGNER_ENCODE_INFO, pbCountersignature: PBYTE, pcbCountersignature: PDWORD } ],
  CertOpenStore: [ HCERTSTORE, { lpszStoreProvider: LPCSTR, dwEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pvPara: PTR(VOID) } ],
  CertDuplicateStore: [ HCERTSTORE, { hCertStore: HCERTSTORE } ],
  CertSaveStore: [ BOOL, { hCertStore: HCERTSTORE, dwEncodingType: DWORD, dwSaveAs: DWORD, dwSaveTo: DWORD, pvSaveToPara: PTR(VOID), dwFlags: DWORD } ],
  CertCloseStore: [ BOOL, { hCertStore: HCERTSTORE, dwFlags: DWORD } ],
  CertGetSubjectCertificateFromStore: [ PCCERT_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pCertId: PCERT_INFO } ],
  CertEnumCertificatesInStore: [ PCCERT_CONTEXT, { hCertStore: HCERTSTORE, pPrevCertContext: PCCERT_CONTEXT } ],
  CertFindCertificateInStore: [ PCCERT_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR(VOID), pPrevCertContext: PCCERT_CONTEXT } ],
  CertGetIssuerCertificateFromStore: [ PCCERT_CONTEXT, { hCertStore: HCERTSTORE, pSubjectContext: PCCERT_CONTEXT, pPrevIssuerContext: PCCERT_CONTEXT, pdwFlags: PTR(ulong) } ],
  CertVerifySubjectCertificateContext: [ BOOL, { pSubject: PCCERT_CONTEXT, pIssuer: PCCERT_CONTEXT, pdwFlags: PTR(ulong) } ],
  CertDuplicateCertificateContext: [ PCCERT_CONTEXT, { pCertContext: PCCERT_CONTEXT } ],
  CertCreateCertificateContext: [ PCCERT_CONTEXT, { dwCertEncodingType: DWORD, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD } ],
  CertFreeCertificateContext: [ BOOL, { pCertContext: PCCERT_CONTEXT } ],
  CertSetCertificateContextProperty: [ BOOL, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR(VOID) } ],
  CertGetCertificateContextProperty: [ BOOL, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CertEnumCertificateContextProperties: [ DWORD, { pCertContext: PCCERT_CONTEXT, dwPropId: DWORD } ],
  CertCreateCTLEntryFromCertificateContextProperties: [ BOOL, { pCertContext: PCCERT_CONTEXT, cOptAttr: DWORD, rgOptAttr: PCRYPT_ATTRIBUTE, dwFlags: DWORD, pvReserved: PTR(VOID), pCtlEntry: PCTL_ENTRY, pcbCtlEntry: PTR(ulong) } ],
  CertSetCertificateContextPropertiesFromCTLEntry: [ BOOL, { pCertContext: PCCERT_CONTEXT, pCtlEntry: PCTL_ENTRY, dwFlags: DWORD } ],
  CertGetCRLFromStore: [ PCCRL_CONTEXT, { hCertStore: HCERTSTORE, pIssuerContext: PCCERT_CONTEXT, pPrevCrlContext: PCCRL_CONTEXT, pdwFlags: PTR(ulong) } ],
  CertEnumCRLsInStore: [ PCCRL_CONTEXT, { hCertStore: HCERTSTORE, pPrevCrlContext: PCCRL_CONTEXT } ],
  CertFindCRLInStore: [ PCCRL_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR(VOID), pPrevCrlContext: PCCRL_CONTEXT } ],
  CertDuplicateCRLContext: [ PCCRL_CONTEXT, { pCrlContext: PCCRL_CONTEXT } ],
  CertCreateCRLContext: [ PCCRL_CONTEXT, { dwCertEncodingType: DWORD, pbCrlEncoded: PTR(uchar), cbCrlEncoded: DWORD } ],
  CertFreeCRLContext: [ BOOL, { pCrlContext: PCCRL_CONTEXT } ],
  CertSetCRLContextProperty: [ BOOL, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR(VOID) } ],
  CertGetCRLContextProperty: [ BOOL, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CertEnumCRLContextProperties: [ DWORD, { pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD } ],
  CertFindCertificateInCRL: [ BOOL, { pCert: PCCERT_CONTEXT, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID), ppCrlEntry: PTR(VOIDPTR) } ],
  CertIsValidCRLForCertificate: [ BOOL, { pCert: PCCERT_CONTEXT, pCrl: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CertAddEncodedCertificateToStore: [ BOOL, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD, dwAddDisposition: DWORD, ppCertContext: PTR(VOIDPTR) } ],
  CertAddCertificateContextToStore: [ BOOL, { hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertAddSerializedElementToStore: [ BOOL, { hCertStore: HCERTSTORE, pbElement: PTR(uchar), cbElement: DWORD, dwAddDisposition: DWORD, dwFlags: DWORD, dwContextTypeFlags: DWORD, pdwContextType: PTR(ulong), ppvContext: PTR(PTR(VOID)) } ],
  CertDeleteCertificateFromStore: [ BOOL, { pCertContext: PCCERT_CONTEXT } ],
  CertAddEncodedCRLToStore: [ BOOL, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCrlEncoded: PTR(uchar), cbCrlEncoded: DWORD, dwAddDisposition: DWORD, ppCrlContext: PTR(VOIDPTR) } ],
  CertAddCRLContextToStore: [ BOOL, { hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertDeleteCRLFromStore: [ BOOL, { pCrlContext: PCCRL_CONTEXT } ],
  CertSerializeCertificateStoreElement: [ BOOL, { pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) } ],
  CertSerializeCRLStoreElement: [ BOOL, { pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) } ],
  CertDuplicateCTLContext: [ PCCTL_CONTEXT, { pCtlContext: PCCTL_CONTEXT } ],
  CertCreateCTLContext: [ PCCTL_CONTEXT, { dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: PTR(uchar), cbCtlEncoded: DWORD } ],
  CertFreeCTLContext: [ BOOL, { pCtlContext: PCCTL_CONTEXT } ],
  CertSetCTLContextProperty: [ BOOL, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR(VOID) } ],
  CertGetCTLContextProperty: [ BOOL, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CertEnumCTLContextProperties: [ DWORD, { pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD } ],
  CertEnumCTLsInStore: [ PCCTL_CONTEXT, { hCertStore: HCERTSTORE, pPrevCtlContext: PCCTL_CONTEXT } ],
  CertFindSubjectInCTL: [ PCTL_ENTRY, { dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR(VOID), pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD } ],
  CertFindCTLInStore: [ PCCTL_CONTEXT, { hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR(VOID), pPrevCtlContext: PCCTL_CONTEXT } ],
  CertAddEncodedCTLToStore: [ BOOL, { hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: PTR(uchar), cbCtlEncoded: DWORD, dwAddDisposition: DWORD, ppCtlContext: PTR(VOIDPTR) } ],
  CertAddCTLContextToStore: [ BOOL, { hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertSerializeCTLStoreElement: [ BOOL, { pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pbElement: PTR(uchar), pcbElement: PTR(ulong) } ],
  CertDeleteCTLFromStore: [ BOOL, { pCtlContext: PCCTL_CONTEXT } ],
  CertAddCertificateLinkToStore: [ BOOL, { hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertAddCRLLinkToStore: [ BOOL, { hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertAddCTLLinkToStore: [ BOOL, { hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD, ppStoreContext: PTR(VOIDPTR) } ],
  CertAddStoreToCollection: [ BOOL, { hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE, dwUpdateFlags: DWORD, dwPriority: DWORD } ],
  CertRemoveStoreFromCollection: [ VOID, { hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE } ],
  CertControlStore: [ BOOL, { hCertStore: HCERTSTORE, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: PTR(VOID) } ],
  CertSetStoreProperty: [ BOOL, { hCertStore: HCERTSTORE, dwPropId: DWORD, dwFlags: DWORD, pvData: PTR(VOID) } ],
  CertGetStoreProperty: [ BOOL, { hCertStore: HCERTSTORE, dwPropId: DWORD, pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CertCreateContext: [ VOID, { dwContextType: DWORD, dwEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, dwFlags: DWORD, pCreatePara: PCERT_CREATE_CONTEXT_PARA } ],
  CertRegisterSystemStore: [ BOOL, { pvSystemStore: PTR(VOID), dwFlags: DWORD, pStoreInfo: PCERT_SYSTEM_STORE_INFO, pvReserved: PTR(VOID) } ],
  CertRegisterPhysicalStore: [ BOOL, { pvSystemStore: PTR(VOID), dwFlags: DWORD, pwszStoreName: LPCWSTR, pStoreInfo: PCERT_PHYSICAL_STORE_INFO, pvReserved: PTR(VOID) } ],
  CertUnregisterSystemStore: [ BOOL, { pvSystemStore: PTR(VOID), dwFlags: DWORD } ],
  CertUnregisterPhysicalStore: [ BOOL, { pvSystemStore: PTR(VOID), dwFlags: DWORD, pwszStoreName: LPCWSTR } ],
  CertEnumSystemStoreLocation: [ BOOL, { dwFlags: DWORD, pvArg: PTR(VOID), pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE_LOCATION } ],
  CertEnumSystemStore: [ BOOL, { dwFlags: DWORD, pvSystemStoreLocationPara: PTR(VOID), pvArg: PTR(VOID), pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE } ],
  CertEnumPhysicalStore: [ BOOL, { pvSystemStore: PTR(VOID), dwFlags: DWORD, pvArg: PTR(VOID), pfnEnum: PFN_CERT_ENUM_PHYSICAL_STORE } ],
  CertGetEnhancedKeyUsage: [ BOOL, { pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pUsage: PCERT_ENHKEY_USAGE, pcbUsage: PTR(ulong) } ],
  CertSetEnhancedKeyUsage: [ BOOL, { pCertContext: PCCERT_CONTEXT, pUsage: PCERT_ENHKEY_USAGE } ],
  CertAddEnhancedKeyUsageIdentifier: [ BOOL, { pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR } ],
  CertRemoveEnhancedKeyUsageIdentifier: [ BOOL, { pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR } ],
  CertGetValidUsages: [ BOOL, { cCerts: DWORD, rghCerts: PTR(VOIDPTR), cNumOIDs: PTR(int), rghOIDs: PTR(PTR(int8)), pcbOIDs: PTR(ulong) } ],
  CryptMsgGetAndVerifySigner: [ BOOL, { hCryptMsg: HCRYPTMSG, cSignerStore: DWORD, rghSignerStore: PTR(PTR(VOID)), dwFlags: DWORD, ppSigner: PTR(VOIDPTR), pdwSignerIndex: PTR(ulong) } ],
  CryptMsgSignCTL: [ BOOL, { dwMsgEncodingType: DWORD, pbCtlContent: PTR(uchar), cbCtlContent: DWORD, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) } ],
  CryptMsgEncodeAndSignCTL: [ BOOL, { dwMsgEncodingType: DWORD, pCtlInfo: PCTL_INFO, pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong) } ],
  CertFindSubjectInSortedCTL: [ BOOL, { pSubjectIdentifier: PCRYPT_DATA_BLOB, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID), pEncodedAttributes: PCRYPT_DER_BLOB } ],
  CertEnumSubjectInSortedCTL: [ BOOL, { pCtlContext: PCCTL_CONTEXT, ppvNextSubject: PTR(PTR(VOID)), pSubjectIdentifier: PCRYPT_DER_BLOB, pEncodedAttributes: PCRYPT_DER_BLOB } ],
  CertVerifyCTLUsage: [ BOOL, { dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR(VOID), pSubjectUsage: PCTL_USAGE, dwFlags: DWORD, pVerifyUsagePara: PCTL_VERIFY_USAGE_PARA, pVerifyUsageStatus: PCTL_VERIFY_USAGE_STATUS } ],
  CertVerifyRevocation: [ BOOL, { dwEncodingType: DWORD, dwRevType: DWORD, cContext: DWORD, rgpvContext: PTR(PTR(VOID)), dwFlags: DWORD, pRevPara: PCERT_REVOCATION_PARA, pRevStatus: PCERT_REVOCATION_STATUS } ],
  CertCompareIntegerBlob: [ BOOL, { pInt1: PCRYPT_INTEGER_BLOB, pInt2: PCRYPT_INTEGER_BLOB } ],
  CertCompareCertificate: [ BOOL, { dwCertEncodingType: DWORD, pCertId1: PCERT_INFO, pCertId2: PCERT_INFO } ],
  CertCompareCertificateName: [ BOOL, { dwCertEncodingType: DWORD, pCertName1: PCERT_NAME_BLOB, pCertName2: PCERT_NAME_BLOB } ],
  CertIsRDNAttrsInCertificateName: [ BOOL, { dwCertEncodingType: DWORD, dwFlags: DWORD, pCertName: PCERT_NAME_BLOB, pRDN: PCERT_RDN } ],
  CertComparePublicKeyInfo: [ BOOL, { dwCertEncodingType: DWORD, pPublicKey1: PCERT_PUBLIC_KEY_INFO, pPublicKey2: PCERT_PUBLIC_KEY_INFO } ],
  CertGetPublicKeyLength: [ DWORD, { dwCertEncodingType: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO } ],
  CryptVerifyCertificateSignature: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO } ],
  CryptVerifyCertificateSignatureEx: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: PTR(VOID), dwIssuerType: DWORD, pvIssuer: PTR(VOID), dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CryptHashToBeSigned: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) } ],
  CryptHashCertificate: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) } ],
  CryptHashCertificate2: [ BOOL, { pwszCNGHashAlgid: LPCWSTR, dwFlags: DWORD, pvReserved: PTR(VOID), pbEncoded: PTR(uchar), cbEncoded: DWORD, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) } ],
  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) } ],
  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) } ],
  CertVerifyTimeValidity: [ LONG, { pTimeToVerify: LPFILETIME, pCertInfo: PCERT_INFO } ],
  CertVerifyCRLTimeValidity: [ LONG, { pTimeToVerify: LPFILETIME, pCrlInfo: PCRL_INFO } ],
  CertVerifyValidityNesting: [ BOOL, { pSubjectInfo: PCERT_INFO, pIssuerInfo: PCERT_INFO } ],
  CertVerifyCRLRevocation: [ BOOL, { dwCertEncodingType: DWORD, pCertId: PCERT_INFO, cCrlInfo: DWORD, rgpCrlInfo: PTR(VOIDPTR) } ],
  CertAlgIdToOID: [ LPCSTR, { dwAlgId: DWORD } ],
  CertOIDToAlgId: [ DWORD, { pszObjId: LPCSTR } ],
  CertFindExtension: [ PCERT_EXTENSION, { pszObjId: LPCSTR, cExtensions: DWORD, rgExtensions: PTR(uint) } ],
  CertFindAttribute: [ PCRYPT_ATTRIBUTE, { pszObjId: LPCSTR, cAttr: DWORD, rgAttr: PTR(uint) } ],
  CertFindRDNAttr: [ PCERT_RDN_ATTR, { pszObjId: LPCSTR, pName: PCERT_NAME_INFO } ],
  CertGetIntendedKeyUsage: [ BOOL, { dwCertEncodingType: DWORD, pCertInfo: PCERT_INFO, pbKeyUsage: PTR(uchar), cbKeyUsage: DWORD } ],
  CryptInstallDefaultContext: [ BOOL, { hCryptProv: HCRYPTPROV, dwDefaultType: DWORD, pvDefaultPara: PTR(VOID), dwFlags: DWORD, pvReserved: PTR(VOID), phDefaultContext: PTR(PTR(VOID)) } ],
  CryptUninstallDefaultContext: [ BOOL, { hDefaultContext: HCRYPTDEFAULTCONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CryptExportPublicKeyInfo: [ BOOL, { hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: PTR(ulong) } ],
  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) } ],
  CryptExportPublicKeyInfoFromBCryptKeyHandle: [ BOOL, { hBCryptKey: BCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: PTR(VOID), pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: PTR(ulong) } ],
  CryptImportPublicKeyInfo: [ BOOL, { hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, phKey: PTR(ulong) } ],
  CryptImportPublicKeyInfoEx: [ BOOL, { hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, aiKeyAlg: ALG_ID, dwFlags: DWORD, pvAuxInfo: PTR(VOID), phKey: PTR(ulong) } ],
  CryptImportPublicKeyInfoEx2: [ BOOL, { dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, dwFlags: DWORD, pvAuxInfo: PTR(VOID), phKey: PTR(PTR(VOID)) } ],
  CryptAcquireCertificatePrivateKey: [ BOOL, { pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID), phCryptProvOrNCryptKey: PTR(ulong), pdwKeySpec: PTR(ulong), pfCallerFreeProvOrNCryptKey: PTR(int) } ],
  CryptFindCertificateKeyProvInfo: [ BOOL, { pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CryptImportPKCS8: [ BOOL, { sPrivateKeyAndParams: CRYPT_PKCS8_IMPORT_PARAMS, dwFlags: DWORD, phCryptProv: PTR(ulong), pvAuxInfo: PTR(VOID) } ],
  CryptExportPKCS8: [ BOOL, { hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, pszPrivateKeyObjId: LPSTR, dwFlags: DWORD, pvAuxInfo: PTR(VOID), pbPrivateKeyBlob: PTR(uchar), pcbPrivateKeyBlob: PTR(ulong) } ],
  CryptExportPKCS8Ex: [ BOOL, { psExportParams: PTR(uint), dwFlags: DWORD, pvAuxInfo: PTR(VOID), pbPrivateKeyBlob: PTR(uchar), pcbPrivateKeyBlob: PTR(ulong) } ],
  CryptHashPublicKeyInfo: [ BOOL, { hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) } ],
  CertRDNValueToStrA: [ DWORD, { dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPSTR, csz: DWORD } ],
  CertRDNValueToStrW: [ DWORD, { dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPWSTR, csz: DWORD } ],
  CertNameToStrA: [ DWORD, { dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPSTR, csz: DWORD } ],
  CertNameToStrW: [ DWORD, { dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPWSTR, csz: DWORD } ],
  CertStrToNameA: [ BOOL, { dwCertEncodingType: DWORD, pszX500: LPCSTR, dwStrType: DWORD, pvReserved: PTR(VOID), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong), ppszError: PTR(PTR(int8)) } ],
  CertStrToNameW: [ BOOL, { dwCertEncodingType: DWORD, pszX500: LPCWSTR, dwStrType: DWORD, pvReserved: PTR(VOID), pbEncoded: PTR(uchar), pcbEncoded: PTR(ulong), ppszError: PTR(PTR(ushort)) } ],
  CertGetNameStringA: [ DWORD, { pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: PTR(VOID), pszNameString: LPSTR, cchNameString: DWORD } ],
  CertGetNameStringW: [ DWORD, { pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: PTR(VOID), pszNameString: LPWSTR, cchNameString: DWORD } ],
  CryptSignMessage: [ BOOL, { pSignPara: PCRYPT_SIGN_MESSAGE_PARA, fDetachedSignature: BOOL, cToBeSigned: DWORD, rgpbToBeSigned: PTR(PTR(uchar)), rgcbToBeSigned: PTR(ulong), pbSignedBlob: PTR(uchar), pcbSignedBlob: PTR(ulong) } ],
  CryptVerifyMessageSignature: [ BOOL, { pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD, pbDecoded: PTR(uchar), pcbDecoded: PTR(ulong), ppSignerCert: PTR(VOIDPTR) } ],
  CryptGetMessageSignerCount: [ LONG, { dwMsgEncodingType: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD } ],
  CryptGetMessageCertificates: [ HCERTSTORE, { dwMsgAndCertEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD } ],
  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(VOIDPTR) } ],
  CryptEncryptMessage: [ BOOL, { pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: PTR(VOIDPTR), pbToBeEncrypted: PTR(uchar), cbToBeEncrypted: DWORD, pbEncryptedBlob: PTR(uchar), pcbEncryptedBlob: PTR(ulong) } ],
  CryptDecryptMessage: [ BOOL, { pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pbEncryptedBlob: PTR(uchar), cbEncryptedBlob: DWORD, pbDecrypted: PTR(uchar), pcbDecrypted: PTR(ulong), ppXchgCert: PTR(VOIDPTR) } ],
  CryptSignAndEncryptMessage: [ BOOL, { pSignPara: PCRYPT_SIGN_MESSAGE_PARA, pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD, rgpRecipientCert: PTR(VOIDPTR), pbToBeSignedAndEncrypted: PTR(uchar), cbToBeSignedAndEncrypted: DWORD, pbSignedAndEncryptedBlob: PTR(uchar), pcbSignedAndEncryptedBlob: PTR(ulong) } ],
  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(VOIDPTR), ppSignerCert: PTR(VOIDPTR) } ],
  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(VOIDPTR), ppSignerCert: PTR(VOIDPTR) } ],
  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) } ],
  CryptVerifyMessageHash: [ BOOL, { pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbHashedBlob: PTR(uchar), cbHashedBlob: DWORD, pbToBeHashed: PTR(uchar), pcbToBeHashed: PTR(ulong), pbComputedHash: PTR(uchar), pcbComputedHash: PTR(ulong) } ],
  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) } ],
  CryptSignMessageWithKey: [ BOOL, { pSignPara: PCRYPT_KEY_SIGN_MESSAGE_PARA, pbToBeSigned: PTR(uchar), cbToBeSigned: DWORD, pbSignedBlob: PTR(uchar), pcbSignedBlob: PTR(ulong) } ],
  CryptVerifyMessageSignatureWithKey: [ BOOL, { pVerifyPara: PCRYPT_KEY_VERIFY_MESSAGE_PARA, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO, pbSignedBlob: PTR(uchar), cbSignedBlob: DWORD, pbDecoded: PTR(uchar), pcbDecoded: PTR(ulong) } ],
  CertOpenSystemStoreA: [ HCERTSTORE, { hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCSTR } ],
  CertOpenSystemStoreW: [ HCERTSTORE, { hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCWSTR } ],
  CertAddEncodedCertificateToSystemStoreA: [ BOOL, { szCertStoreName: LPCSTR, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD } ],
  CertAddEncodedCertificateToSystemStoreW: [ BOOL, { szCertStoreName: LPCWSTR, pbCertEncoded: PTR(uchar), cbCertEncoded: DWORD } ],
  FindCertsByIssuer: [ HRESULT, { pCertChains: PCERT_CHAIN, pcbCertChains: PTR(ulong), pcCertChains: PTR(ulong), pbEncodedIssuerName: PTR(uchar), cbEncodedIssuerName: DWORD, pwszPurpose: LPCWSTR, dwKeySpec: DWORD } ],
  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)) } ],
  CryptMemAlloc: [ LPVOID, { cbSize: ULONG } ],
  CryptMemRealloc: [ LPVOID, { pv: LPVOID, cbSize: ULONG } ],
  CryptMemFree: [ VOID, { pv: LPVOID } ],
  CryptCreateAsyncHandle: [ BOOL, { dwFlags: DWORD, phAsync: PHCRYPTASYNC } ],
  CryptSetAsyncParam: [ BOOL, { hAsync: HCRYPTASYNC, pszParamOid: LPSTR, pvParam: LPVOID, pfnFree: PFN_CRYPT_ASYNC_PARAM_FREE_FUNC } ],
  CryptGetAsyncParam: [ BOOL, { hAsync: HCRYPTASYNC, pszParamOid: LPSTR, ppvParam: PTR(PTR(VOID)), ppfnFree: PTR(PFN_CRYPT_ASYNC_PARAM_FREE_FUNC) } ],
  CryptCloseAsyncHandle: [ BOOL, { hAsync: HCRYPTASYNC } ],
  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 } ],
  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 } ],
  CryptInstallCancelRetrieval: [ BOOL, { pfnCancel: PFN_CRYPT_CANCEL_RETRIEVAL, pvArg: PTR(VOID), dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CryptUninstallCancelRetrieval: [ BOOL, { dwFlags: DWORD, pvReserved: PTR(VOID) } ],
  CryptCancelAsyncRetrieval: [ BOOL, { hAsyncRetrieval: HCRYPTASYNC } ],
  CryptGetObjectUrl: [ BOOL, { pszUrlOid: LPCSTR, pvPara: LPVOID, dwFlags: DWORD, pUrlArray: PCRYPT_URL_ARRAY, pcbUrlArray: PTR(ulong), pUrlInfo: PCRYPT_URL_INFO, pcbUrlInfo: PTR(ulong), pvReserved: LPVOID } ],
  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 } ],
  CryptFlushTimeValidObject: [ BOOL, { pszFlushTimeValidOid: LPCSTR, pvPara: LPVOID, pIssuer: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID } ],
  CryptProtectData: [ BOOL, { pDataIn: PTR(uint), szDataDescr: LPCWSTR, pOptionalEntropy: PTR(uint), pvReserved: PVOID, pPromptStruct: PTR(uint), dwFlags: DWORD, pDataOut: PTR(uint) } ],
  CryptUnprotectData: [ BOOL, { pDataIn: PTR(uint), ppszDataDescr: PTR(PTR(ushort)), pOptionalEntropy: PTR(uint), pvReserved: PVOID, pPromptStruct: PTR(uint), dwFlags: DWORD, pDataOut: PTR(uint) } ],
  CryptUpdateProtectedState: [ BOOL, { pOldSid: PSID, pwszOldPassword: LPCWSTR, dwFlags: DWORD, pdwSuccessCount: PTR(ulong), pdwFailureCount: PTR(ulong) } ],
  CryptProtectMemory: [ BOOL, { pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD } ],
  CryptUnprotectMemory: [ BOOL, { pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD } ],
  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 } ],
  CryptGetKeyIdentifierProperty: [ BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR(VOID), pvData: PTR(VOID), pcbData: PTR(ulong) } ],
  CryptSetKeyIdentifierProperty: [ BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR(VOID), pvData: PTR(VOID) } ],
  CryptEnumKeyIdentifierProperties: [ BOOL, { pKeyIdentifier: PTR(uint), dwPropId: DWORD, dwFlags: DWORD, pwszComputerName: LPCWSTR, pvReserved: PTR(VOID), pvArg: PTR(VOID), pfnEnum: PFN_CRYPT_ENUM_KEYID_PROP } ],
  CryptCreateKeyIdentifierFromCSP: [ BOOL, { dwCertEncodingType: DWORD, pszPubKeyOID: LPCSTR, pPubKeyStruc: PTR(uint), cbPubKeyStruc: DWORD, dwFlags: DWORD, pvReserved: PTR(VOID), pbHash: PTR(uchar), pcbHash: PTR(ulong) } ],
  CertCreateCertificateChainEngine: [ BOOL, { pConfig: PCERT_CHAIN_ENGINE_CONFIG, phChainEngine: PTR(PTR(VOID)) } ],
  CertFreeCertificateChainEngine: [ VOID, { hChainEngine: HCERTCHAINENGINE } ],
  CertResyncCertificateChainEngine: [ BOOL, { hChainEngine: HCERTCHAINENGINE } ],
  CertGetCertificateChain: [ BOOL, { hChainEngine: HCERTCHAINENGINE, pCertContext: PCCERT_CONTEXT, pTime: LPFILETIME, hAdditionalStore: HCERTSTORE, pChainPara: PCERT_CHAIN_PARA, dwFlags: DWORD, pvReserved: LPVOID, ppChainContext: PTR(VOIDPTR) } ],
  CertFreeCertificateChain: [ VOID, { pChainContext: PCCERT_CHAIN_CONTEXT } ],
  CertDuplicateCertificateChain: [ PCCERT_CHAIN_CONTEXT, { pChainContext: PCCERT_CHAIN_CONTEXT } ],
  CertFindChainInStore: [ PCCERT_CHAIN_CONTEXT, { hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD, pvFindPara: PTR(VOID), pPrevChainContext: PCCERT_CHAIN_CONTEXT } ],
  CertVerifyCertificateChainPolicy: [ BOOL, { pszPolicyOID: LPCSTR, pChainContext: PCCERT_CHAIN_CONTEXT, pPolicyPara: PCERT_CHAIN_POLICY_PARA, pPolicyStatus: PCERT_CHAIN_POLICY_STATUS } ],
  CryptStringToBinaryA: [ BOOL, { pszString: LPCSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: PTR(uchar), pcbBinary: PTR(ulong), pdwSkip: PTR(ulong), pdwFlags: PTR(ulong) } ],
  CryptStringToBinaryW: [ BOOL, { pszString: LPCWSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: PTR(uchar), pcbBinary: PTR(ulong), pdwSkip: PTR(ulong), pdwFlags: PTR(ulong) } ],
  CryptBinaryToStringA: [ BOOL, { pbBinary: PTR(uchar), cbBinary: DWORD, dwFlags: DWORD, pszString: LPSTR, pcchString: PTR(ulong) } ],
  CryptBinaryToStringW: [ BOOL, { pbBinary: PTR(uchar), cbBinary: DWORD, dwFlags: DWORD, pszString: LPWSTR, pcchString: PTR(ulong) } ],
  PFXImportCertStore: [ HCERTSTORE, { pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD } ],
  PFXIsPFXBlob: [ BOOL, { pPFX: PTR(uint) } ],
  PFXVerifyPassword: [ BOOL, { pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD } ],
  PFXExportCertStoreEx: [ BOOL, { hStore: HCERTSTORE, pPFX: PTR(uint), szPassword: LPCWSTR, pvReserved: PTR(VOID), dwFlags: DWORD } ],
  PFXExportCertStore: [ BOOL, { hStore: HCERTSTORE, pPFX: PTR(uint), szPassword: LPCWSTR, dwFlags: DWORD } ],
  CertOpenServerOcspResponse: [ HCERT_SERVER_OCSP_RESPONSE, { pChainContext: PCCERT_CHAIN_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID } ],
  CertAddRefServerOcspResponse: [ VOID, { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE } ],
  CertCloseServerOcspResponse: [ VOID, { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD } ],
  CertGetServerOcspResponseContext: [ PCCERT_SERVER_OCSP_RESPONSE_CONTEXT, { hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD, pvReserved: LPVOID } ],
  CertAddRefServerOcspResponseContext: [ VOID, { pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT } ],
  CertFreeServerOcspResponseContext: [ VOID, { pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT } ],
  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)) } ],
  CertSelectCertificateChains: [ BOOL, { pSelectionContext: LPCGUID, dwFlags: DWORD, pChainParameters: PCCERT_SELECT_CHAIN_PARA, cCriteria: DWORD, rgpCriteria: PCCERT_SELECT_CRITERIA, hStore: HCERTSTORE, pcSelection: PDWORD, pprgpSelection: PTR(PTR(VOIDPTR)) } ],
  CertFreeCertificateChainList: [ VOID, { prgpSelection: PTR(VOIDPTR) } ],
  CryptRetrieveTimeStamp: [ BOOL, { wszUrl: LPCWSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, pszHashId: LPCSTR, pPara: PTR(uint), pbData: PTR(uchar), cbData: DWORD, ppTsContext: PTR(VOIDPTR), ppTsSigner: PTR(VOIDPTR), phStore: PTR(PTR(VOID)) } ],
  CryptVerifyTimeStampSignature: [ BOOL, { pbTSContentInfo: PTR(uchar), cbTSContentInfo: DWORD, pbData: PTR(uchar), cbData: DWORD, hAdditionalStore: HCERTSTORE, ppTsContext: PTR(VOIDPTR), ppTsSigner: PTR(VOIDPTR), phStore: PTR(PTR(VOID)) } ],
  QueryUsersOnEncryptedFile: [ DWORD, { lpFileName: LPCWSTR, pUsers: PTR(VOIDPTR) } ],
  QueryRecoveryAgentsOnEncryptedFile: [ DWORD, { lpFileName: LPCWSTR, pRecoveryAgents: PTR(VOIDPTR) } ],
  RemoveUsersFromEncryptedFile: [ DWORD, { lpFileName: LPCWSTR, pHashes: PENCRYPTION_CERTIFICATE_HASH_LIST } ],
  AddUsersToEncryptedFile: [ DWORD, { lpFileName: LPCWSTR, pEncryptionCertificates: PENCRYPTION_CERTIFICATE_LIST } ],
  SetUserFileEncryptionKey: [ DWORD, { pEncryptionCertificate: PENCRYPTION_CERTIFICATE } ],
  SetUserFileEncryptionKeyEx: [ DWORD, { pEncryptionCertificate: PENCRYPTION_CERTIFICATE, dwCapabilities: DWORD, dwFlags: DWORD, pvReserved: LPVOID } ],
  FreeEncryptionCertificateHashList: [ VOID, { pUsers: PENCRYPTION_CERTIFICATE_HASH_LIST } ],
  EncryptionDisable: [ BOOL, { DirPath: LPCWSTR, Disable: BOOL } ],
  DuplicateEncryptionInfoFile: [ DWORD, { SrcFileName: LPCWSTR, DstFileName: LPCWSTR, dwCreationDistribution: DWORD, dwAttributes: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES } ],
  GetEncryptedFileMetadata: [ DWORD, { lpFileName: LPCWSTR, pcbMetadata: PDWORD, ppbMetadata: PTR(PTR(uchar)) } ],
  SetEncryptedFileMetadata: [ DWORD, { lpFileName: LPCWSTR, pbOldMetadata: PBYTE, pbNewMetadata: PBYTE, pOwnerHash: PENCRYPTION_CERTIFICATE_HASH, dwOperation: DWORD, pCertificatesAdded: PENCRYPTION_CERTIFICATE_HASH_LIST } ],
  FreeEncryptedFileMetadata: [ VOID, { pbMetadata: PBYTE } ],
  I_RpcNsGetBuffer: [ RPC_STATUS, { Message: PRPC_MESSAGE } ],
  I_RpcNsSendReceive: [ RPC_STATUS, { Message: PRPC_MESSAGE, Handle: PTR(PTR(VOID)) } ],
  I_RpcNsRaiseException: [ VOID, { Message: PRPC_MESSAGE, Status: RPC_STATUS } ],
  I_RpcReBindBuffer: [ RPC_STATUS, { Message: PRPC_MESSAGE } ],
  I_NsServerBindSearch: [ RPC_STATUS, {  } ],
  I_NsClientBindSearch: [ RPC_STATUS, {  } ],
  I_NsClientBindDone: [ VOID, {  } ],
  MIDL_user_allocate: [ VOID, { size: size_t } ],
  MIDL_user_free: [ VOID, { PTR(VOID): PTR(VOID) } ],
  I_RpcDefaultAllocate: [ VOID, { bh: handle_t, size: size_t, RealAlloc: PTR(UNEXPOSED) } ],
  I_RpcDefaultFree: [ VOID, { bh: handle_t, PTR(VOID): PTR(VOID), RealFree: PTR(UNEXPOSED) } ],
  NDRCContextBinding: [ RPC_BINDING_HANDLE, { CContext: NDR_CCONTEXT } ],
  NDRCContextMarshall: [ VOID, { CContext: NDR_CCONTEXT, pBuff: PTR(VOID) } ],
  NDRCContextUnmarshall: [ VOID, { pCContext: PTR(PTR(VOID)), hBinding: RPC_BINDING_HANDLE, pBuff: PTR(VOID), DataRepresentation: ulong } ],
  NDRCContextUnmarshall2: [ VOID, { pCContext: PTR(PTR(VOID)), hBinding: RPC_BINDING_HANDLE, pBuff: PTR(VOID), DataRepresentation: ulong } ],
  NDRSContextMarshall: [ VOID, { CContext: NDR_SCONTEXT, pBuff: PTR(VOID), userRunDownIn: NDR_RUNDOWN } ],
  NDRSContextUnmarshall: [ NDR_SCONTEXT, { pBuff: PTR(VOID), DataRepresentation: ulong } ],
  NDRSContextMarshallEx: [ VOID, { BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: PTR(VOID), userRunDownIn: NDR_RUNDOWN } ],
  NDRSContextMarshall2: [ VOID, { BindingHandle: RPC_BINDING_HANDLE, CContext: NDR_SCONTEXT, pBuff: PTR(VOID), userRunDownIn: NDR_RUNDOWN, CtxGuard: PTR(VOID), Flags: ulong } ],
  NDRSContextUnmarshallEx: [ NDR_SCONTEXT, { BindingHandle: RPC_BINDING_HANDLE, pBuff: PTR(VOID), DataRepresentation: ulong } ],
  NDRSContextUnmarshall2: [ NDR_SCONTEXT, { BindingHandle: RPC_BINDING_HANDLE, pBuff: PTR(VOID), DataRepresentation: ulong, CtxGuard: PTR(VOID), Flags: ulong } ],
  RpcSsDestroyClientContext: [ VOID, { ContextHandle: PTR(PTR(VOID)) } ],
  RpcCsGetTags: [ VOID, { hBinding: RPC_BINDING_HANDLE, fServerSide: int, pulSendingTag: PTR(ulong), pulDesiredReceivingTag: PTR(ulong), pulReceivingTag: PTR(ulong), pStatus: PTR(ulong) } ],
  NdrClientGetSupportedSyntaxes: [ RPC_STATUS, { pInf: PTR(uint), pCount: PTR(ulong), pArr: PTR(PTR(uint)) } ],
  NdrServerGetSupportedSyntaxes: [ RPC_STATUS, { pInf: PTR(uint), pCount: PTR(ulong), pArr: PTR(PTR(uint)), pPreferSyntaxIndex: PTR(ulong) } ],
  NdrSimpleTypeMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), FormatChar: uchar } ],
  NdrPointerMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrCsArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrCsTagMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrSimpleStructMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantStructMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingStructMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexStructMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrFixedArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrVaryingArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexArrayMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrNonConformantStringMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantStringMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrEncapsulatedUnionMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrNonEncapsulatedUnionMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrByteCountPointerMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrXmitOrRepAsMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrUserMarshalMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrInterfacePointerMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrClientContextMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_CCONTEXT, fCheck: int } ],
  NdrServerContextMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN } ],
  NdrServerContextNewMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ContextHandle: NDR_SCONTEXT, RundownRoutine: NDR_RUNDOWN, pFormat: PFORMAT_STRING } ],
  NdrSimpleTypeUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), FormatChar: uchar } ],
  NdrCsArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrCsTagUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrRangeUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrCorrelationInitialize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(VOID), CacheSize: ulong, flags: ulong } ],
  NdrCorrelationPass: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE } ],
  NdrCorrelationFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE } ],
  NdrPointerUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrSimpleStructUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrConformantStructUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrConformantVaryingStructUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrComplexStructUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrFixedArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrConformantArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrConformantVaryingArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrVaryingArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrComplexArrayUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrNonConformantStringUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrConformantStringUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrEncapsulatedUnionUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrNonEncapsulatedUnionUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrByteCountPointerUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrXmitOrRepAsUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrUserMarshalUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrInterfacePointerUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(uchar)), pFormat: PFORMAT_STRING, fMustAlloc: uchar } ],
  NdrClientContextUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pContextHandle: PTR(PTR(VOID)), BindHandle: RPC_BINDING_HANDLE } ],
  NdrServerContextUnmarshall: [ NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE } ],
  NdrContextHandleInitialize: [ NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrServerContextNewUnmarshall: [ NDR_SCONTEXT, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrPointerBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrCsArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrCsTagBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrSimpleStructBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantStructBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingStructBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexStructBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrFixedArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrVaryingArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexArrayBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantStringBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrNonConformantStringBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrEncapsulatedUnionBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrNonEncapsulatedUnionBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrByteCountPointerBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrXmitOrRepAsBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrUserMarshalBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrInterfacePointerBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrContextHandleSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrPointerMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrContextHandleMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrCsArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrCsTagMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrSimpleStructMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrConformantStructMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingStructMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrComplexStructMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrFixedArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrConformantArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrVaryingArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrComplexArrayMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrConformantStringMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrNonConformantStringMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrEncapsulatedUnionMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrNonEncapsulatedUnionMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrXmitOrRepAsMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrUserMarshalMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrInterfacePointerMemorySize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrPointerFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrCsArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrSimpleStructFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantStructFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingStructFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexStructFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrFixedArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConformantVaryingArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrVaryingArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrComplexArrayFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrEncapsulatedUnionFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrNonEncapsulatedUnionFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrByteCountPointerFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrXmitOrRepAsFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrUserMarshalFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrInterfacePointerFree: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(uchar), pFormat: PFORMAT_STRING } ],
  NdrConvert2: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, NumberParams: long } ],
  NdrConvert: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrUserMarshalSimpleTypeConvert: [ VOID, { pFlags: PTR(ulong), pBuffer: PTR(uchar), FormatChar: uchar } ],
  NdrClientInitializeNew: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: uint } ],
  NdrServerInitializeNew: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC } ],
  NdrServerInitializePartial: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, RequestedBufferSize: ulong } ],
  NdrClientInitialize: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, ProcNum: uint } ],
  NdrServerInitialize: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC } ],
  NdrServerInitializeUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pRpcMsg: PRPC_MESSAGE } ],
  NdrServerInitializeMarshall: [ VOID, { pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE } ],
  NdrGetBuffer: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: ulong, Handle: RPC_BINDING_HANDLE } ],
  NdrNsGetBuffer: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, BufferLength: ulong, Handle: RPC_BINDING_HANDLE } ],
  NdrSendReceive: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: PTR(uchar) } ],
  NdrNsSendReceive: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pBufferEnd: PTR(uchar), pAutoHandle: PTR(PTR(VOID)) } ],
  NdrFreeBuffer: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE } ],
  NdrGetDcomProtocolVersion: [ RPC_STATUS, { pStubMsg: PMIDL_STUB_MESSAGE, pVersion: PTR(uint) } ],
  NdrClientCall2: [ CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING } ],
  NdrClientCall: [ CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING } ],
  NdrAsyncClientCall: [ CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING } ],
  NdrDcomAsyncClientCall: [ CLIENT_CALL_RETURN, { pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING } ],
  NdrAsyncServerCall: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrAsyncStubCall: [ VOID, { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrDcomAsyncStubCall: [ VOID, { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrStubCall2: [ VOID, { pThis: PTR(VOID), pChannel: PTR(VOID), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrServerCall2: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrStubCall: [ VOID, { pThis: PTR(VOID), pChannel: PTR(VOID), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrServerCall: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrServerUnmarshall: [ VOID, { pChannel: PTR(VOID), pRpcMsg: PRPC_MESSAGE, pStubMsg: PMIDL_STUB_MESSAGE, pStubDescriptor: PMIDL_STUB_DESC, pFormat: PFORMAT_STRING, pParamList: PTR(VOID) } ],
  NdrServerMarshall: [ VOID, { pThis: PTR(VOID), pChannel: PTR(VOID), pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING } ],
  NdrMapCommAndFaultStatus: [ RPC_STATUS, { pStubMsg: PMIDL_STUB_MESSAGE, pCommStatus: PTR(ulong), pFaultStatus: PTR(ulong), Status: RPC_STATUS } ],
  RpcSsAllocate: [ VOID, { Size: size_t } ],
  RpcSsDisableAllocate: [ VOID, {  } ],
  RpcSsEnableAllocate: [ VOID, {  } ],
  RpcSsFree: [ VOID, { NodeToFree: PTR(VOID) } ],
  RpcSsGetThreadHandle: [ RPC_SS_THREAD_HANDLE, {  } ],
  RpcSsSetClientAllocFree: [ VOID, { ClientAlloc: PTR(CALLBACK(PTR(VOID), [uint])), ClientFree: PTR(CALLBACK(VOID, [PTR(VOID)])) } ],
  RpcSsSetThreadHandle: [ VOID, { Id: RPC_SS_THREAD_HANDLE } ],
  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)]))) } ],
  RpcSmAllocate: [ VOID, { Size: size_t, pStatus: PTR(long) } ],
  RpcSmClientFree: [ RPC_STATUS, { pNodeToFree: PTR(VOID) } ],
  RpcSmDestroyClientContext: [ RPC_STATUS, { ContextHandle: PTR(PTR(VOID)) } ],
  RpcSmDisableAllocate: [ RPC_STATUS, {  } ],
  RpcSmEnableAllocate: [ RPC_STATUS, {  } ],
  RpcSmFree: [ RPC_STATUS, { NodeToFree: PTR(VOID) } ],
  RpcSmGetThreadHandle: [ RPC_SS_THREAD_HANDLE, { pStatus: PTR(long) } ],
  RpcSmSetClientAllocFree: [ RPC_STATUS, { ClientAlloc: PTR(CALLBACK(PTR(VOID), [uint])), ClientFree: PTR(CALLBACK(VOID, [PTR(VOID)])) } ],
  RpcSmSetThreadHandle: [ RPC_STATUS, { Id: RPC_SS_THREAD_HANDLE } ],
  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)]))) } ],
  NdrRpcSsEnableAllocate: [ VOID, { pMessage: PMIDL_STUB_MESSAGE } ],
  NdrRpcSsDisableAllocate: [ VOID, { pMessage: PMIDL_STUB_MESSAGE } ],
  NdrRpcSmSetClientToOsf: [ VOID, { pMessage: PMIDL_STUB_MESSAGE } ],
  NdrRpcSmClientAllocate: [ VOID, { Size: size_t } ],
  NdrRpcSmClientFree: [ VOID, { NodeToFree: PTR(VOID) } ],
  NdrRpcSsDefaultAllocate: [ VOID, { Size: size_t } ],
  NdrRpcSsDefaultFree: [ VOID, { NodeToFree: PTR(VOID) } ],
  NdrFullPointerXlatInit: [ PFULL_PTR_XLAT_TABLES, { NumberOfPointers: ulong, XlatSide: XLAT_SIDE } ],
  NdrFullPointerXlatFree: [ VOID, { pXlatTables: PFULL_PTR_XLAT_TABLES } ],
  NdrAllocate: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, Len: size_t } ],
  NdrClearOutParameters: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pFormat: PFORMAT_STRING, ArgAddr: PTR(VOID) } ],
  NdrOleAllocate: [ VOID, { Size: size_t } ],
  NdrOleFree: [ VOID, { NodeToFree: PTR(VOID) } ],
  NdrGetUserMarshalInfo: [ RPC_STATUS, { pFlags: PTR(ulong), InformationLevel: ulong, pMarshalInfo: PTR(uint) } ],
  NdrCreateServerInterfaceFromStub: [ RPC_STATUS, { pStub: PTR(IRpcStubBuffer), pServerIf: PTR(uint) } ],
  NdrClientCall3: [ CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR(VOID) } ],
  Ndr64AsyncClientCall: [ CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR(VOID) } ],
  Ndr64DcomAsyncClientCall: [ CLIENT_CALL_RETURN, { pProxyInfo: PTR(uint), nProcNum: ulong, pReturnValue: PTR(VOID) } ],
  Ndr64AsyncServerCall: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  Ndr64AsyncServerCall64: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  Ndr64AsyncServerCallAll: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  Ndr64AsyncStubCall: [ VOID, { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  Ndr64DcomAsyncStubCall: [ VOID, { pThis: PTR(IRpcStubBuffer), pChannel: PTR(IRpcChannelBuffer), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrStubCall3: [ VOID, { pThis: PTR(VOID), pChannel: PTR(VOID), pRpcMsg: PRPC_MESSAGE, pdwStubPhase: PTR(ulong) } ],
  NdrServerCallAll: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrServerCallNdr64: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrServerCall3: [ VOID, { pRpcMsg: PRPC_MESSAGE } ],
  NdrPartialIgnoreClientMarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(VOID) } ],
  NdrPartialIgnoreServerUnmarshall: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(VOID)) } ],
  NdrPartialIgnoreClientBufferSize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, pMemory: PTR(VOID) } ],
  NdrPartialIgnoreServerInitialize: [ VOID, { pStubMsg: PMIDL_STUB_MESSAGE, ppMemory: PTR(PTR(VOID)), pFormat: PFORMAT_STRING } ],
  RpcUserFree: [ VOID, { AsyncHandle: handle_t, pBuffer: PTR(VOID) } ],
  SCardEstablishContext: [ LONG, { dwScope: DWORD, pvReserved1: LPCVOID, pvReserved2: LPCVOID, phContext: LPSCARDCONTEXT } ],
  SCardReleaseContext: [ LONG, { hContext: SCARDCONTEXT } ],
  SCardIsValidContext: [ LONG, { hContext: SCARDCONTEXT } ],
  SCardListReaderGroupsA: [ LONG, { hContext: SCARDCONTEXT, mszGroups: LPSTR, pcchGroups: LPDWORD } ],
  SCardListReaderGroupsW: [ LONG, { hContext: SCARDCONTEXT, mszGroups: LPWSTR, pcchGroups: LPDWORD } ],
  SCardListReadersA: [ LONG, { hContext: SCARDCONTEXT, mszGroups: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD } ],
  SCardListReadersW: [ LONG, { hContext: SCARDCONTEXT, mszGroups: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD } ],
  SCardListCardsA: [ LONG, { hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPSTR, pcchCards: LPDWORD } ],
  SCardListCardsW: [ LONG, { hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: LPWSTR, pcchCards: LPDWORD } ],
  SCardListInterfacesA: [ LONG, { hContext: SCARDCONTEXT, szCard: LPCSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD } ],
  SCardListInterfacesW: [ LONG, { hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD } ],
  SCardGetProviderIdA: [ LONG, { hContext: SCARDCONTEXT, szCard: LPCSTR, pguidProviderId: LPGUID } ],
  SCardGetProviderIdW: [ LONG, { hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidProviderId: LPGUID } ],
  SCardGetCardTypeProviderNameA: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPSTR, pcchProvider: LPDWORD } ],
  SCardGetCardTypeProviderNameW: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPWSTR, pcchProvider: LPDWORD } ],
  SCardIntroduceReaderGroupA: [ LONG, { hContext: SCARDCONTEXT, szGroupName: LPCSTR } ],
  SCardIntroduceReaderGroupW: [ LONG, { hContext: SCARDCONTEXT, szGroupName: LPCWSTR } ],
  SCardForgetReaderGroupA: [ LONG, { hContext: SCARDCONTEXT, szGroupName: LPCSTR } ],
  SCardForgetReaderGroupW: [ LONG, { hContext: SCARDCONTEXT, szGroupName: LPCWSTR } ],
  SCardIntroduceReaderA: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceName: LPCSTR } ],
  SCardIntroduceReaderW: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceName: LPCWSTR } ],
  SCardForgetReaderA: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR } ],
  SCardForgetReaderW: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR } ],
  SCardAddReaderToGroupA: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR } ],
  SCardAddReaderToGroupW: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR } ],
  SCardRemoveReaderFromGroupA: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR } ],
  SCardRemoveReaderFromGroupW: [ LONG, { hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR } ],
  SCardIntroduceCardTypeA: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD } ],
  SCardIntroduceCardTypeW: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD } ],
  SCardSetCardTypeProviderNameA: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPCSTR } ],
  SCardSetCardTypeProviderNameW: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPCWSTR } ],
  SCardForgetCardTypeA: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCSTR } ],
  SCardForgetCardTypeW: [ LONG, { hContext: SCARDCONTEXT, szCardName: LPCWSTR } ],
  SCardFreeMemory: [ LONG, { hContext: SCARDCONTEXT, pvMem: LPCVOID } ],
  SCardAccessStartedEvent: [ HANDLE, {  } ],
  SCardReleaseStartedEvent: [ VOID, {  } ],
  SCardLocateCardsA: [ LONG, { hContext: SCARDCONTEXT, mszCards: LPCSTR, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD } ],
  SCardLocateCardsW: [ LONG, { hContext: SCARDCONTEXT, mszCards: LPCWSTR, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD } ],
  SCardLocateCardsByATRA: [ LONG, { hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD } ],
  SCardLocateCardsByATRW: [ LONG, { hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD } ],
  SCardGetStatusChangeA: [ LONG, { hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD } ],
  SCardGetStatusChangeW: [ LONG, { hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD } ],
  SCardCancel: [ LONG, { hContext: SCARDCONTEXT } ],
  SCardConnectA: [ LONG, { hContext: SCARDCONTEXT, szReader: LPCSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD } ],
  SCardConnectW: [ LONG, { hContext: SCARDCONTEXT, szReader: LPCWSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD } ],
  SCardReconnect: [ LONG, { hCard: SCARDHANDLE, dwShareMode: DWORD, dwPreferredProtocols: DWORD, dwInitialization: DWORD, pdwActiveProtocol: LPDWORD } ],
  SCardDisconnect: [ LONG, { hCard: SCARDHANDLE, dwDisposition: DWORD } ],
  SCardBeginTransaction: [ LONG, { hCard: SCARDHANDLE } ],
  SCardEndTransaction: [ LONG, { hCard: SCARDHANDLE, dwDisposition: DWORD } ],
  SCardCancelTransaction: [ LONG, { hCard: SCARDHANDLE } ],
  SCardState: [ LONG, { hCard: SCARDHANDLE, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD } ],
  SCardStatusA: [ LONG, { hCard: SCARDHANDLE, mszReaderNames: LPSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD } ],
  SCardStatusW: [ LONG, { hCard: SCARDHANDLE, mszReaderNames: LPWSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD } ],
  SCardTransmit: [ LONG, { hCard: SCARDHANDLE, pioSendPci: LPCSCARD_IO_REQUEST, pbSendBuffer: LPCBYTE, cbSendLength: DWORD, pioRecvPci: LPSCARD_IO_REQUEST, pbRecvBuffer: LPBYTE, pcbRecvLength: LPDWORD } ],
  SCardGetTransmitCount: [ LONG, { hCard: SCARDHANDLE, pcTransmitCount: LPDWORD } ],
  SCardControl: [ LONG, { hCard: SCARDHANDLE, dwControlCode: DWORD, lpInBuffer: LPCVOID, cbInBufferSize: DWORD, lpOutBuffer: LPVOID, cbOutBufferSize: DWORD, lpBytesReturned: LPDWORD } ],
  SCardGetAttrib: [ LONG, { hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPBYTE, pcbAttrLen: LPDWORD } ],
  SCardSetAttrib: [ LONG, { hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPCBYTE, cbAttrLen: DWORD } ],
  SCardUIDlgSelectCardA: [ LONG, { LPOPENCARDNAME_EXA: LPOPENCARDNAME_EXA } ],
  SCardUIDlgSelectCardW: [ LONG, { LPOPENCARDNAME_EXW: LPOPENCARDNAME_EXW } ],
  GetOpenCardNameA: [ LONG, { LPOPENCARDNAMEA: LPOPENCARDNAMEA } ],
  GetOpenCardNameW: [ LONG, { LPOPENCARDNAMEW: LPOPENCARDNAMEW } ],
  SCardDlgExtendedError: [ LONG, {  } ],
  SCardReadCacheA: [ LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: PTR(ulong) } ],
  SCardReadCacheW: [ LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: PTR(ulong) } ],
  SCardWriteCacheA: [ LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: DWORD } ],
  SCardWriteCacheW: [ LONG, { hContext: SCARDCONTEXT, CardIdentifier: PTR(uint), FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: DWORD } ],
  CreatePropertySheetPageA: [ HPROPSHEETPAGE, { constPropSheetPagePointer: LPCPROPSHEETPAGEA } ],
  CreatePropertySheetPageW: [ HPROPSHEETPAGE, { constPropSheetPagePointer: LPCPROPSHEETPAGEW } ],
  DestroyPropertySheetPage: [ BOOL, { HPROPSHEETPAGE: HPROPSHEETPAGE } ],
  PropertySheetA: [ INT_PTR, { LPCPROPSHEETHEADERA: LPCPROPSHEETHEADERA } ],
  PropertySheetW: [ INT_PTR, { LPCPROPSHEETHEADERW: LPCPROPSHEETHEADERW } ],
  EnumPrintersA: [ BOOL, { Flags: DWORD, Name: LPSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumPrintersW: [ BOOL, { Flags: DWORD, Name: LPWSTR, Level: DWORD, pPrinterEnum: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  GetSpoolFileHandle: [ HANDLE, { hPrinter: HANDLE } ],
  CommitSpoolData: [ HANDLE, { hPrinter: HANDLE, hSpoolFile: HANDLE, cbCommit: DWORD } ],
  CloseSpoolFileHandle: [ BOOL, { hPrinter: HANDLE, hSpoolFile: HANDLE } ],
  OpenPrinterA: [ BOOL, { pPrinterName: LPSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSA } ],
  OpenPrinterW: [ BOOL, { pPrinterName: LPWSTR, phPrinter: LPHANDLE, pDefault: LPPRINTER_DEFAULTSW } ],
  ResetPrinterA: [ BOOL, { hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSA } ],
  ResetPrinterW: [ BOOL, { hPrinter: HANDLE, pDefault: LPPRINTER_DEFAULTSW } ],
  SetJobA: [ BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD } ],
  SetJobW: [ BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, Command: DWORD } ],
  GetJobA: [ BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetJobW: [ BOOL, { hPrinter: HANDLE, JobId: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  EnumJobsA: [ BOOL, { hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumJobsW: [ BOOL, { hPrinter: HANDLE, FirstJob: DWORD, NoJobs: DWORD, Level: DWORD, pJob: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  AddPrinterA: [ HANDLE, { pName: LPSTR, Level: DWORD, pPrinter: LPBYTE } ],
  AddPrinterW: [ HANDLE, { pName: LPWSTR, Level: DWORD, pPrinter: LPBYTE } ],
  DeletePrinter: [ BOOL, { hPrinter: HANDLE } ],
  SetPrinterA: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD } ],
  SetPrinterW: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, Command: DWORD } ],
  GetPrinterA: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterW: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pPrinter: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  AddPrinterDriverA: [ BOOL, { pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE } ],
  AddPrinterDriverW: [ BOOL, { pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE } ],
  AddPrinterDriverExA: [ BOOL, { pName: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD } ],
  AddPrinterDriverExW: [ BOOL, { pName: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, dwFileCopyFlags: DWORD } ],
  EnumPrinterDriversA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumPrinterDriversW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  GetPrinterDriverA: [ BOOL, { hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDriverW: [ BOOL, { hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDriverDirectoryA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDriverDirectoryW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pDriverDirectory: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  DeletePrinterDriverA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR } ],
  DeletePrinterDriverW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR } ],
  DeletePrinterDriverExA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pDriverName: LPSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD } ],
  DeletePrinterDriverExW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pDriverName: LPWSTR, dwDeleteFlag: DWORD, dwVersionFlag: DWORD } ],
  AddPrintProcessorA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPathName: LPSTR, pPrintProcessorName: LPSTR } ],
  AddPrintProcessorW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPathName: LPWSTR, pPrintProcessorName: LPWSTR } ],
  EnumPrintProcessorsA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumPrintProcessorsW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  GetPrintProcessorDirectoryA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrintProcessorDirectoryW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, Level: DWORD, pPrintProcessorInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  EnumPrintProcessorDatatypesA: [ BOOL, { pName: LPSTR, pPrintProcessorName: LPSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumPrintProcessorDatatypesW: [ BOOL, { pName: LPWSTR, pPrintProcessorName: LPWSTR, Level: DWORD, pDatatypes: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  DeletePrintProcessorA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPrintProcessorName: LPSTR } ],
  DeletePrintProcessorW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPrintProcessorName: LPWSTR } ],
  StartDocPrinterA: [ DWORD, { hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE } ],
  StartDocPrinterW: [ DWORD, { hPrinter: HANDLE, Level: DWORD, pDocInfo: LPBYTE } ],
  StartPagePrinter: [ BOOL, { hPrinter: HANDLE } ],
  WritePrinter: [ BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD } ],
  FlushPrinter: [ BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pcWritten: LPDWORD, cSleep: DWORD } ],
  EndPagePrinter: [ BOOL, { hPrinter: HANDLE } ],
  AbortPrinter: [ BOOL, { hPrinter: HANDLE } ],
  ReadPrinter: [ BOOL, { hPrinter: HANDLE, pBuf: LPVOID, cbBuf: DWORD, pNoBytesRead: LPDWORD } ],
  EndDocPrinter: [ BOOL, { hPrinter: HANDLE } ],
  AddJobA: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  AddJobW: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pData: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  ScheduleJob: [ BOOL, { hPrinter: HANDLE, JobId: DWORD } ],
  PrinterProperties: [ BOOL, { hWnd: HWND, hPrinter: HANDLE } ],
  DocumentPropertiesA: [ LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA, fMode: DWORD } ],
  DocumentPropertiesW: [ LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW, fMode: DWORD } ],
  AdvancedDocumentPropertiesA: [ LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPSTR, pDevModeOutput: PDEVMODEA, pDevModeInput: PDEVMODEA } ],
  AdvancedDocumentPropertiesW: [ LONG, { hWnd: HWND, hPrinter: HANDLE, pDeviceName: LPWSTR, pDevModeOutput: PDEVMODEW, pDevModeInput: PDEVMODEW } ],
  ExtDeviceMode: [ LONG, { hWnd: HWND, hInst: HANDLE, pDevModeOutput: LPDEVMODEA, pDeviceName: LPSTR, pPort: LPSTR, pDevModeInput: LPDEVMODEA, pProfile: LPSTR, fMode: DWORD } ],
  GetPrinterDataA: [ DWORD, { hPrinter: HANDLE, pValueName: LPSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDataW: [ DWORD, { hPrinter: HANDLE, pValueName: LPWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDataExA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDataExW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, pType: LPDWORD, pData: LPBYTE, nSize: DWORD, pcbNeeded: LPDWORD } ],
  EnumPrinterDataA: [ DWORD, { hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD } ],
  EnumPrinterDataW: [ DWORD, { hPrinter: HANDLE, dwIndex: DWORD, pValueName: LPWSTR, cbValueName: DWORD, pcbValueName: LPDWORD, pType: LPDWORD, pData: LPBYTE, cbData: DWORD, pcbData: LPDWORD } ],
  EnumPrinterDataExA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD } ],
  EnumPrinterDataExW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pEnumValues: LPBYTE, cbEnumValues: DWORD, pcbEnumValues: LPDWORD, pnEnumValues: LPDWORD } ],
  EnumPrinterKeyA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pSubkey: LPSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD } ],
  EnumPrinterKeyW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pSubkey: LPWSTR, cbSubkey: DWORD, pcbSubkey: LPDWORD } ],
  SetPrinterDataA: [ DWORD, { hPrinter: HANDLE, pValueName: LPSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD } ],
  SetPrinterDataW: [ DWORD, { hPrinter: HANDLE, pValueName: LPWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD } ],
  SetPrinterDataExA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD } ],
  SetPrinterDataExW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR, Type: DWORD, pData: LPBYTE, cbData: DWORD } ],
  DeletePrinterDataA: [ DWORD, { hPrinter: HANDLE, pValueName: LPSTR } ],
  DeletePrinterDataW: [ DWORD, { hPrinter: HANDLE, pValueName: LPWSTR } ],
  DeletePrinterDataExA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR, pValueName: LPCSTR } ],
  DeletePrinterDataExW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR, pValueName: LPCWSTR } ],
  DeletePrinterKeyA: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCSTR } ],
  DeletePrinterKeyW: [ DWORD, { hPrinter: HANDLE, pKeyName: LPCWSTR } ],
  WaitForPrinterChange: [ DWORD, { hPrinter: HANDLE, Flags: DWORD } ],
  FindFirstPrinterChangeNotification: [ HANDLE, { hPrinter: HANDLE, fdwFilter: DWORD, fdwOptions: DWORD, pPrinterNotifyOptions: PVOID } ],
  FindNextPrinterChangeNotification: [ BOOL, { hChange: HANDLE, pdwChange: PDWORD, pvReserved: LPVOID, ppPrinterNotifyInfo: PTR(PTR(VOID)) } ],
  FreePrinterNotifyInfo: [ BOOL, { pPrinterNotifyInfo: PPRINTER_NOTIFY_INFO } ],
  FindClosePrinterChangeNotification: [ BOOL, { hChange: HANDLE } ],
  PrinterMessageBoxA: [ DWORD, { hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPSTR, pCaption: LPSTR, dwType: DWORD } ],
  PrinterMessageBoxW: [ DWORD, { hPrinter: HANDLE, Error: DWORD, hWnd: HWND, pText: LPWSTR, pCaption: LPWSTR, dwType: DWORD } ],
  ClosePrinter: [ BOOL, { hPrinter: HANDLE } ],
  AddFormA: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE } ],
  AddFormW: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE } ],
  DeleteFormA: [ BOOL, { hPrinter: HANDLE, pFormName: LPSTR } ],
  DeleteFormW: [ BOOL, { hPrinter: HANDLE, pFormName: LPWSTR } ],
  GetFormA: [ BOOL, { hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetFormW: [ BOOL, { hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  SetFormA: [ BOOL, { hPrinter: HANDLE, pFormName: LPSTR, Level: DWORD, pForm: LPBYTE } ],
  SetFormW: [ BOOL, { hPrinter: HANDLE, pFormName: LPWSTR, Level: DWORD, pForm: LPBYTE } ],
  EnumFormsA: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumFormsW: [ BOOL, { hPrinter: HANDLE, Level: DWORD, pForm: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumMonitorsA: [ BOOL, { pName: LPSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumMonitorsW: [ BOOL, { pName: LPWSTR, Level: DWORD, pMonitor: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  AddMonitorA: [ BOOL, { pName: LPSTR, Level: DWORD, pMonitors: LPBYTE } ],
  AddMonitorW: [ BOOL, { pName: LPWSTR, Level: DWORD, pMonitors: LPBYTE } ],
  DeleteMonitorA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pMonitorName: LPSTR } ],
  DeleteMonitorW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pMonitorName: LPWSTR } ],
  EnumPortsA: [ BOOL, { pName: LPSTR, Level: DWORD, pPort: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  EnumPortsW: [ BOOL, { pName: LPWSTR, Level: DWORD, pPort: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD, pcReturned: LPDWORD } ],
  AddPortA: [ BOOL, { pName: LPSTR, hWnd: HWND, pMonitorName: LPSTR } ],
  AddPortW: [ BOOL, { pName: LPWSTR, hWnd: HWND, pMonitorName: LPWSTR } ],
  ConfigurePortA: [ BOOL, { pName: LPSTR, hWnd: HWND, pPortName: LPSTR } ],
  ConfigurePortW: [ BOOL, { pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR } ],
  DeletePortA: [ BOOL, { pName: LPSTR, hWnd: HWND, pPortName: LPSTR } ],
  DeletePortW: [ BOOL, { pName: LPWSTR, hWnd: HWND, pPortName: LPWSTR } ],
  XcvDataW: [ BOOL, { hXcv: HANDLE, pszDataName: PCWSTR, pInputData: PBYTE, cbInputData: DWORD, pOutputData: PBYTE, cbOutputData: DWORD, pcbOutputNeeded: PDWORD, pdwStatus: PDWORD } ],
  GetDefaultPrinterA: [ BOOL, { pszBuffer: LPSTR, pcchBuffer: LPDWORD } ],
  GetDefaultPrinterW: [ BOOL, { pszBuffer: LPWSTR, pcchBuffer: LPDWORD } ],
  SetDefaultPrinterA: [ BOOL, { pszPrinter: LPCSTR } ],
  SetDefaultPrinterW: [ BOOL, { pszPrinter: LPCWSTR } ],
  SetPortA: [ BOOL, { pName: LPSTR, pPortName: LPSTR, dwLevel: DWORD, pPortInfo: LPBYTE } ],
  SetPortW: [ BOOL, { pName: LPWSTR, pPortName: LPWSTR, dwLevel: DWORD, pPortInfo: LPBYTE } ],
  AddPrinterConnectionA: [ BOOL, { pName: LPSTR } ],
  AddPrinterConnectionW: [ BOOL, { pName: LPWSTR } ],
  DeletePrinterConnectionA: [ BOOL, { pName: LPSTR } ],
  DeletePrinterConnectionW: [ BOOL, { pName: LPWSTR } ],
  ConnectToPrinterDlg: [ HANDLE, { hwnd: HWND, Flags: DWORD } ],
  AddPrintProvidorA: [ BOOL, { pName: LPSTR, level: DWORD, pProvidorInfo: LPBYTE } ],
  AddPrintProvidorW: [ BOOL, { pName: LPWSTR, level: DWORD, pProvidorInfo: LPBYTE } ],
  DeletePrintProvidorA: [ BOOL, { pName: LPSTR, pEnvironment: LPSTR, pPrintProvidorName: LPSTR } ],
  DeletePrintProvidorW: [ BOOL, { pName: LPWSTR, pEnvironment: LPWSTR, pPrintProvidorName: LPWSTR } ],
  IsValidDevmodeA: [ BOOL, { pDevmode: PDEVMODEA, DevmodeSize: size_t } ],
  IsValidDevmodeW: [ BOOL, { pDevmode: PDEVMODEW, DevmodeSize: size_t } ],
  OpenPrinter2A: [ BOOL, { pPrinterName: LPCSTR, phPrinter: LPHANDLE, pDefault: PPRINTER_DEFAULTSA, pOptions: PPRINTER_OPTIONSA } ],
  OpenPrinter2W: [ BOOL, { pPrinterName: LPCWSTR, phPrinter: LPHANDLE, pDefault: PPRINTER_DEFAULTSW, pOptions: PPRINTER_OPTIONSW } ],
  AddPrinterConnection2A: [ BOOL, { hWnd: HWND, pszName: LPCSTR, dwLevel: DWORD, pConnectionInfo: PVOID } ],
  AddPrinterConnection2W: [ BOOL, { hWnd: HWND, pszName: LPCWSTR, dwLevel: DWORD, pConnectionInfo: PVOID } ],
  InstallPrinterDriverFromPackageA: [ HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszDriverName: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD } ],
  InstallPrinterDriverFromPackageW: [ HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszDriverName: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD } ],
  UploadPrinterDriverPackageA: [ HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPSTR, pcchDestInfPath: PULONG } ],
  UploadPrinterDriverPackageW: [ HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR, dwFlags: DWORD, hwnd: HWND, pszDestInfPath: LPWSTR, pcchDestInfPath: PULONG } ],
  GetCorePrinterDriversA: [ HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, pszzCoreDriverDependencies: LPCSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERA } ],
  GetCorePrinterDriversW: [ HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszzCoreDriverDependencies: LPCWSTR, cCorePrinterDrivers: DWORD, pCorePrinterDrivers: PCORE_PRINTER_DRIVERW } ],
  CorePrinterDriverInstalledA: [ HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, CoreDriverGUID: GUID, ftDriverDate: FILETIME, dwlDriverVersion: DWORDLONG, pbDriverInstalled: PTR(int) } ],
  CorePrinterDriverInstalledW: [ HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, CoreDriverGUID: GUID, ftDriverDate: FILETIME, dwlDriverVersion: DWORDLONG, pbDriverInstalled: PTR(int) } ],
  GetPrinterDriverPackagePathA: [ HRESULT, { pszServer: LPCSTR, pszEnvironment: LPCSTR, pszLanguage: LPCSTR, pszPackageID: LPCSTR, pszDriverPackageCab: LPSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD } ],
  GetPrinterDriverPackagePathW: [ HRESULT, { pszServer: LPCWSTR, pszEnvironment: LPCWSTR, pszLanguage: LPCWSTR, pszPackageID: LPCWSTR, pszDriverPackageCab: LPWSTR, cchDriverPackageCab: DWORD, pcchRequiredSize: LPDWORD } ],
  DeletePrinterDriverPackageA: [ HRESULT, { pszServer: LPCSTR, pszInfPath: LPCSTR, pszEnvironment: LPCSTR } ],
  DeletePrinterDriverPackageW: [ HRESULT, { pszServer: LPCWSTR, pszInfPath: LPCWSTR, pszEnvironment: LPCWSTR } ],
  ReportJobProcessingProgress: [ HRESULT, { printerHandle: HANDLE, jobId: ULONG, jobOperation: EPrintXPSJobOperation, jobProgress: EPrintXPSJobProgress } ],
  GetPrinterDriver2A: [ BOOL, { hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrinterDriver2W: [ BOOL, { hWnd: HWND, hPrinter: HANDLE, pEnvironment: LPWSTR, Level: DWORD, pDriverInfo: LPBYTE, cbBuf: DWORD, pcbNeeded: LPDWORD } ],
  GetPrintExecutionData: [ BOOL, { pData: PTR(uint) } ],
  _set_purecall_handler: [ _purecall_handler, { _Handler: _purecall_handler } ],
  _get_purecall_handler: [ _purecall_handler, {  } ],
  _set_invalid_parameter_handler: [ _invalid_parameter_handler, { _Handler: _invalid_parameter_handler } ],
  _get_invalid_parameter_handler: [ _invalid_parameter_handler, {  } ],
  _errno: [ VOID, {  } ],
  _set_errno: [ errno_t, { _Value: int } ],
  _get_errno: [ errno_t, { _Value: PTR(int) } ],
  __doserrno: [ VOID, {  } ],
  _set_doserrno: [ errno_t, { _Value: ulong } ],
  _get_doserrno: [ errno_t, { _Value: PTR(ulong) } ],
  __sys_errlist: [ VOID, {  } ],
  __sys_nerr: [ VOID, {  } ],
  _get_pgmptr: [ errno_t, { _Value: PTR(PTR(int8)) } ],
  _get_wpgmptr: [ errno_t, { _Value: PTR(PTR(ushort)) } ],
  _set_fmode: [ errno_t, { _Mode: int } ],
  _get_fmode: [ errno_t, { _PMode: PTR(int) } ],
  exit: [ VOID, { _Code: int } ],
  _exit: [ VOID, { _Code: int } ],
  abort: [ VOID, {  } ],
  _set_abort_behavior: [ VOID, { _Flags: uint, _Mask: uint } ],
  abs: [ VOID, { _X: int } ],
  labs: [ VOID, { _X: long } ],
  llabs: [ VOID, { _X: longlong } ],
  _abs64: [ VOID, { longlong: longlong } ],
  atexit: [ VOID, { PTR(UNEXPOSED): PTR(UNEXPOSED) } ],
  atof: [ VOID, { _String: PTR(int8) } ],
  _atof_l: [ VOID, { _String: PTR(int8), _Locale: _locale_t } ],
  atoi: [ VOID, { _Str: PTR(int8) } ],
  _atoi_l: [ VOID, { _Str: PTR(int8), _Locale: _locale_t } ],
  atol: [ VOID, { _Str: PTR(int8) } ],
  _atol_l: [ VOID, { _Str: PTR(int8), _Locale: _locale_t } ],
  bsearch_s: [ VOID, { _Key: PTR(VOID), _Base: PTR(VOID), _NumOfElements: rsize_t, _SizeOfElements: rsize_t, _PtFuncCompare: PTR(UNEXPOSED), _Context: PTR(VOID) } ],
  bsearch: [ VOID, { _Key: PTR(VOID), _Base: PTR(VOID), _NumOfElements: size_t, _SizeOfElements: size_t, _PtFuncCompare: PTR(UNEXPOSED) } ],
  qsort_s: [ VOID, { _Base: PTR(VOID), _NumOfElements: rsize_t, _SizeOfElements: rsize_t, _PtFuncCompare: PTR(UNEXPOSED), _Context: PTR(VOID) } ],
  qsort: [ VOID, { _Base: PTR(VOID), _NumOfElements: size_t, _SizeOfElements: size_t, _PtFuncCompare: PTR(UNEXPOSED) } ],
  _byteswap_ushort: [ VOID, { _Short: ushort } ],
  _byteswap_ulong: [ VOID, { _Long: ulong } ],
  _byteswap_uint64: [ VOID, { _Int64: ulonglong } ],
  div: [ div_t, { _Numerator: int, _Denominator: int } ],
  getenv: [ VOID, { _VarName: PTR(int8) } ],
  getenv_s: [ errno_t, { _ReturnSize: PTR(uint), _DstBuf: PTR(int8), _DstSize: rsize_t, _VarName: PTR(int8) } ],
  _dupenv_s: [ errno_t, { _PBuffer: PTR(PTR(int8)), _PBufferSizeInBytes: PTR(uint), _VarName: PTR(int8) } ],
  _itoa_s: [ errno_t, { _Value: int, _DstBuf: PTR(int8), _Size: size_t, _Radix: int } ],
  _itoa: [ VOID, { _Value: int, _Dest: PTR(int8), _Radix: int } ],
  _i64toa_s: [ errno_t, { _Val: longlong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int } ],
  _i64toa: [ VOID, { _Val: longlong, _DstBuf: PTR(int8), _Radix: int } ],
  _ui64toa_s: [ errno_t, { _Val: ulonglong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int } ],
  _ui64toa: [ VOID, { _Val: ulonglong, _DstBuf: PTR(int8), _Radix: int } ],
  _atoi64: [ VOID, { _String: PTR(int8) } ],
  _atoi64_l: [ VOID, { _String: PTR(int8), _Locale: _locale_t } ],
  _strtoi64: [ VOID, { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int } ],
  _strtoi64_l: [ VOID, { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t } ],
  _strtoui64: [ VOID, { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int } ],
  _strtoui64_l: [ VOID, { _String: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t } ],
  ldiv: [ ldiv_t, { _Numerator: long, _Denominator: long } ],
  lldiv: [ lldiv_t, { _Numerator: longlong, _Denominator: longlong } ],
  _ltoa_s: [ errno_t, { _Val: long, _DstBuf: PTR(int8), _Size: size_t, _Radix: int } ],
  _ltoa: [ VOID, { _Value: long, _Dest: PTR(int8), _Radix: int } ],
  mblen: [ VOID, { _Ch: PTR(int8), _MaxCount: size_t } ],
  _mblen_l: [ VOID, { _Ch: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  _mbstrlen: [ size_t, { _Str: PTR(int8) } ],
  _mbstrlen_l: [ size_t, { _Str: PTR(int8), _Locale: _locale_t } ],
  _mbstrnlen: [ size_t, { _Str: PTR(int8), _MaxCount: size_t } ],
  _mbstrnlen_l: [ size_t, { _Str: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  mbtowc: [ VOID, { _DstCh: PTR(ushort), _SrcCh: PTR(int8), _SrcSizeInBytes: size_t } ],
  _mbtowc_l: [ VOID, { _DstCh: PTR(ushort), _SrcCh: PTR(int8), _SrcSizeInBytes: size_t, _Locale: _locale_t } ],
  mbstowcs_s: [ errno_t, { _PtNumOfCharConverted: PTR(uint), _DstBuf: PTR(ushort), _SizeInWords: size_t, _SrcBuf: PTR(int8), _MaxCount: size_t } ],
  mbstowcs: [ size_t, { _Dest: PTR(ushort), _Source: PTR(int8), _MaxCount: size_t } ],
  _mbstowcs_s_l: [ errno_t, { _PtNumOfCharConverted: PTR(uint), _DstBuf: PTR(ushort), _SizeInWords: size_t, _SrcBuf: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  _mbstowcs_l: [ size_t, { _Dest: PTR(ushort), _Source: PTR(int8), _MaxCount: size_t, _Locale: _locale_t } ],
  rand: [ VOID, {  } ],
  _set_error_mode: [ VOID, { _Mode: int } ],
  srand: [ VOID, { _Seed: uint } ],
  strtod: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)) } ],
  _strtod_l: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Locale: _locale_t } ],
  strtol: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int } ],
  _strtol_l: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t } ],
  strtoul: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int } ],
  _strtoul_l: [ VOID, { _Str: PTR(int8), _EndPtr: PTR(PTR(int8)), _Radix: int, _Locale: _locale_t } ],
  system: [ VOID, { _Command: PTR(int8) } ],
  _ultoa_s: [ errno_t, { _Val: ulong, _DstBuf: PTR(int8), _Size: size_t, _Radix: int } ],
  _ultoa: [ VOID, { _Value: ulong, _Dest: PTR(int8), _Radix: int } ],
  wctomb: [ VOID, { _MbCh: PTR(int8), _WCh: wchar_t } ],
  _wctomb_l: [ VOID, { _MbCh: PTR(int8), _WCh: wchar_t, _Locale: _locale_t } ],
  wctomb_s: [ errno_t, { _SizeConverted: PTR(int), _MbCh: PTR(int8), _SizeInBytes: rsize_t, _WCh: wchar_t } ],
  _wctomb_s_l: [ errno_t, { _SizeConverted: PTR(int), _MbCh: PTR(int8), _SizeInBytes: size_t, _WCh: wchar_t, _Locale: _locale_t } ],
  wcstombs_s: [ errno_t, { _PtNumOfCharConverted: PTR(uint), _Dst: PTR(int8), _DstSizeInBytes: size_t, _Src: PTR(ushort), _MaxCountInBytes: size_t } ],
  wcstombs: [ size_t, { _Dest: PTR(int8), _Source: PTR(ushort), _MaxCount: size_t } ],
  _wcstombs_s_l: [ errno_t, { _PtNumOfCharConverted: PTR(uint), _Dst: PTR(int8), _DstSizeInBytes: size_t, _Src: PTR(ushort), _MaxCountInBytes: size_t, _Locale: _locale_t } ],
  _wcstombs_l: [ size_t, { _Dest: PTR(int8), _Source: PTR(ushort), _MaxCount: size_t, _Locale: _locale_t } ],
  calloc: [ VOID, { _Count: size_t, _Size: size_t } ],
  free: [ VOID, { _Memory: PTR(VOID) } ],
  malloc: [ VOID, { _Size: size_t } ],
  realloc: [ VOID, { _Memory: PTR(VOID), _NewSize: size_t } ],
  _recalloc: [ VOID, { _Memory: PTR(VOID), _Count: size_t, _Size: size_t } ],
  _aligned_free: [ VOID, { _Memory: PTR(VOID) } ],
  _aligned_malloc: [ VOID, { _Size: size_t, _Alignment: size_t } ],
  _aligned_offset_malloc: [ VOID, { _Size: size_t, _Alignment: size_t, _Offset: size_t } ],
  _aligned_realloc: [ VOID, { _Memory: PTR(VOID), _NewSize: size_t, _Alignment: size_t } ],
  _aligned_recalloc: [ VOID, { _Memory: PTR(VOID), _Count: size_t, _Size: size_t, _Alignment: size_t } ],
  _aligned_offset_realloc: [ VOID, { _Memory: PTR(VOID), _NewSize: size_t, _Alignment: size_t, _Offset: size_t } ],
  _aligned_offset_recalloc: [ VOID, { _Memory: PTR(VOID), _Count: size_t, _Size: size_t, _Alignment: size_t, _Offset: size_t } ],
  _aligned_msize: [ size_t, { _Memory: PTR(VOID), _Alignment: size_t, _Offset: size_t } ],
  _itow_s: [ errno_t, { _Val: int, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int } ],
  _itow: [ wchar_t, { _Value: int, _Dest: PTR(ushort), _Radix: int } ],
  _ltow_s: [ errno_t, { _Val: long, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int } ],
  _ltow: [ wchar_t, { _Value: long, _Dest: PTR(ushort), _Radix: int } ],
  _ultow_s: [ errno_t, { _Val: ulong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int } ],
  _ultow: [ wchar_t, { _Value: ulong, _Dest: PTR(ushort), _Radix: int } ],
  wcstod: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)) } ],
  _wcstod_l: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Locale: _locale_t } ],
  wcstol: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int } ],
  _wcstol_l: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t } ],
  wcstoul: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int } ],
  _wcstoul_l: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t } ],
  _wgetenv: [ wchar_t, { _VarName: PTR(ushort) } ],
  _wgetenv_s: [ errno_t, { _ReturnSize: PTR(uint), _DstBuf: PTR(ushort), _DstSizeInWords: size_t, _VarName: PTR(ushort) } ],
  _wdupenv_s: [ errno_t, { _Buffer: PTR(PTR(ushort)), _BufferSizeInWords: PTR(uint), _VarName: PTR(ushort) } ],
  _wsystem: [ VOID, { _Command: PTR(ushort) } ],
  _wtof: [ VOID, { _Str: PTR(ushort) } ],
  _wtof_l: [ VOID, { _Str: PTR(ushort), _Locale: _locale_t } ],
  _wtoi: [ VOID, { _Str: PTR(ushort) } ],
  _wtoi_l: [ VOID, { _Str: PTR(ushort), _Locale: _locale_t } ],
  _wtol: [ VOID, { _Str: PTR(ushort) } ],
  _wtol_l: [ VOID, { _Str: PTR(ushort), _Locale: _locale_t } ],
  _i64tow_s: [ errno_t, { _Val: longlong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int } ],
  _i64tow: [ wchar_t, { _Val: longlong, _DstBuf: PTR(ushort), _Radix: int } ],
  _ui64tow_s: [ errno_t, { _Val: ulonglong, _DstBuf: PTR(ushort), _SizeInWords: size_t, _Radix: int } ],
  _ui64tow: [ wchar_t, { _Val: ulonglong, _DstBuf: PTR(ushort), _Radix: int } ],
  _wtoi64: [ VOID, { _Str: PTR(ushort) } ],
  _wtoi64_l: [ VOID, { _Str: PTR(ushort), _Locale: _locale_t } ],
  _wcstoi64: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int } ],
  _wcstoi64_l: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t } ],
  _wcstoui64: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int } ],
  _wcstoui64_l: [ VOID, { _Str: PTR(ushort), _EndPtr: PTR(PTR(ushort)), _Radix: int, _Locale: _locale_t } ],
  _fullpath: [ VOID, { _FullPath: PTR(int8), _Path: PTR(int8), _SizeInBytes: size_t } ],
  _ecvt_s: [ errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDights: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  _ecvt: [ VOID, { _Val: double, _NumOfDigits: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  _fcvt_s: [ errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  _fcvt: [ VOID, { _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  _gcvt_s: [ errno_t, { _DstBuf: PTR(int8), _Size: size_t, _Val: double, _NumOfDigits: int } ],
  _gcvt: [ VOID, { _Val: double, _NumOfDigits: int, _DstBuf: PTR(int8) } ],
  _atodbl: [ VOID, { _Result: PTR(uint), _Str: PTR(int8) } ],
  _atoldbl: [ VOID, { _Result: PTR(uint), _Str: PTR(int8) } ],
  _atoflt: [ VOID, { _Result: PTR(uint), _Str: PTR(int8) } ],
  _atodbl_l: [ VOID, { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t } ],
  _atoldbl_l: [ VOID, { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t } ],
  _atoflt_l: [ VOID, { _Result: PTR(uint), _Str: PTR(int8), _Locale: _locale_t } ],
  _lrotl: [ VOID, { _Val: ulong, _Shift: int } ],
  _lrotr: [ VOID, { _Val: ulong, _Shift: int } ],
  _makepath_s: [ errno_t, { _PathResult: PTR(int8), _SizeInWords: size_t, _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) } ],
  _makepath: [ VOID, { _Path: PTR(int8), _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) } ],
  _onexit: [ _onexit_t, { _Func: _onexit_t } ],
  perror: [ VOID, { _ErrMsg: PTR(int8) } ],
  _putenv: [ VOID, { _EnvString: PTR(int8) } ],
  _putenv_s: [ errno_t, { _Name: PTR(int8), _Value: PTR(int8) } ],
  _searchenv_s: [ errno_t, { _Filename: PTR(int8), _EnvVar: PTR(int8), _ResultPath: PTR(int8), _SizeInBytes: size_t } ],
  _searchenv: [ VOID, { _Filename: PTR(int8), _EnvVar: PTR(int8), _ResultPath: PTR(int8) } ],
  _splitpath: [ VOID, { _FullPath: PTR(int8), _Drive: PTR(int8), _Dir: PTR(int8), _Filename: PTR(int8), _Ext: PTR(int8) } ],
  _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 } ],
  _swab: [ VOID, { _Buf1: PTR(int8), _Buf2: PTR(int8), _SizeInBytes: int } ],
  _wfullpath: [ wchar_t, { _FullPath: PTR(ushort), _Path: PTR(ushort), _SizeInWords: size_t } ],
  _wmakepath_s: [ errno_t, { _PathResult: PTR(ushort), _SIZE: size_t, _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) } ],
  _wmakepath: [ VOID, { _ResultPath: PTR(ushort), _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) } ],
  _wperror: [ VOID, { _ErrMsg: PTR(ushort) } ],
  _wputenv: [ VOID, { _EnvString: PTR(ushort) } ],
  _wputenv_s: [ errno_t, { _Name: PTR(ushort), _Value: PTR(ushort) } ],
  _wsearchenv_s: [ errno_t, { _Filename: PTR(ushort), _EnvVar: PTR(ushort), _ResultPath: PTR(ushort), _SizeInWords: size_t } ],
  _wsearchenv: [ VOID, { _Filename: PTR(ushort), _EnvVar: PTR(ushort), _ResultPath: PTR(ushort) } ],
  _wsplitpath: [ VOID, { _FullPath: PTR(ushort), _Drive: PTR(ushort), _Dir: PTR(ushort), _Filename: PTR(ushort), _Ext: PTR(ushort) } ],
  _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 } ],
  _seterrormode: [ VOID, { _Mode: int } ],
  _beep: [ VOID, { _Frequency: uint, _Duration: uint } ],
  _sleep: [ VOID, { _Duration: ulong } ],
  ecvt: [ VOID, { _Val: double, _NumOfDigits: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  fcvt: [ VOID, { _Val: double, _NumOfDec: int, _PtDec: PTR(int), _PtSign: PTR(int) } ],
  gcvt: [ VOID, { _Val: double, _NumOfDigits: int, _DstBuf: PTR(int8) } ],
  itoa: [ VOID, { _Val: int, _DstBuf: PTR(int8), _Radix: int } ],
  ltoa: [ VOID, { _Val: long, _DstBuf: PTR(int8), _Radix: int } ],
  putenv: [ VOID, { _EnvString: PTR(int8) } ],
  swab: [ VOID, { _Buf1: PTR(int8), _Buf2: PTR(int8), _SizeInBytes: int } ],
  ultoa: [ VOID, { _Val: ulong, _Dstbuf: PTR(int8), _Radix: int } ],
  onexit: [ _onexit_t, { _Func: _onexit_t } ],
  IUnknown_QueryInterface_Proxy: [ HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(VOID)) } ],
  IUnknown_QueryInterface_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IUnknown_AddRef_Proxy: [ ULONG, { This: PTR(uint) } ],
  IUnknown_AddRef_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IUnknown_Release_Proxy: [ ULONG, { This: PTR(uint) } ],
  IUnknown_Release_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IClassFactory_RemoteCreateInstance_Proxy: [ HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) } ],
  IClassFactory_RemoteCreateInstance_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IClassFactory_RemoteLockServer_Proxy: [ HRESULT, { This: PTR(uint), fLock: BOOL } ],
  IClassFactory_RemoteLockServer_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IClassFactory_CreateInstance_Proxy: [ HRESULT, { This: PTR(uint), pUnkOuter: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(VOID)) } ],
  IClassFactory_CreateInstance_Stub: [ HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) } ],
  IClassFactory_LockServer_Proxy: [ HRESULT, { This: PTR(uint), fLock: BOOL } ],
  IClassFactory_LockServer_Stub: [ HRESULT, { This: PTR(uint), fLock: BOOL } ],
  IEnumUnknown_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IEnumUnknown_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindCtx_RemoteSetBindOptions_Proxy: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IBindCtx_RemoteSetBindOptions_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindCtx_RemoteGetBindOptions_Proxy: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IBindCtx_RemoteGetBindOptions_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumMoniker_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IEnumMoniker_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IRunnableObject_RemoteIsRunning_Proxy: [ HRESULT, { This: PTR(uint) } ],
  IRunnableObject_RemoteIsRunning_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IMoniker_RemoteBindToObject_Proxy: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riidResult: PTR(uint), ppvResult: PTR(PTR(uint)) } ],
  IMoniker_RemoteBindToObject_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IMoniker_RemoteBindToStorage_Proxy: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IMoniker_RemoteBindToStorage_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumString_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(ushort)), pceltFetched: PTR(ulong) } ],
  IEnumString_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ISequentialStream_RemoteRead_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbRead: PTR(ulong) } ],
  ISequentialStream_RemoteRead_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ISequentialStream_RemoteWrite_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  ISequentialStream_RemoteWrite_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IStream_RemoteSeek_Proxy: [ HRESULT, { This: PTR(uint), dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: PTR(uint) } ],
  IStream_RemoteSeek_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IStream_RemoteCopyTo_Proxy: [ HRESULT, { This: PTR(uint), pstm: PTR(uint), cb: ULARGE_INTEGER, pcbRead: PTR(uint), pcbWritten: PTR(uint) } ],
  IStream_RemoteCopyTo_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumSTATSTG_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATSTG_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IStorage_RemoteOpenStream_Proxy: [ HRESULT, { This: PTR(uint), pwcsName: PTR(ushort), cbReserved1: ulong, reserved1: PTR(uchar), grfMode: DWORD, reserved2: DWORD, ppstm: PTR(PTR(uint)) } ],
  IStorage_RemoteOpenStream_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IStorage_RemoteCopyTo_Proxy: [ HRESULT, { This: PTR(uint), ciidExclude: DWORD, rgiidExclude: PTR(uint), snbExclude: SNB, pstgDest: PTR(uint) } ],
  IStorage_RemoteCopyTo_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IStorage_RemoteEnumElements_Proxy: [ HRESULT, { This: PTR(uint), reserved1: DWORD, cbReserved2: ulong, reserved2: PTR(uchar), reserved3: DWORD, ppenum: PTR(PTR(uint)) } ],
  IStorage_RemoteEnumElements_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ILockBytes_RemoteReadAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbRead: PTR(ulong) } ],
  ILockBytes_RemoteReadAt_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ILockBytes_RemoteWriteAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  ILockBytes_RemoteWriteAt_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumFORMATETC_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumFORMATETC_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumSTATDATA_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATDATA_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink_RemoteOnDataChange_Proxy: [ HRESULT, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  IAdviseSink_RemoteOnDataChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink_RemoteOnViewChange_Proxy: [ HRESULT, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  IAdviseSink_RemoteOnViewChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink_RemoteOnRename_Proxy: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  IAdviseSink_RemoteOnRename_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink_RemoteOnSave_Proxy: [ HRESULT, { This: PTR(uint) } ],
  IAdviseSink_RemoteOnSave_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink_RemoteOnClose_Proxy: [ HRESULT, { This: PTR(uint) } ],
  IAdviseSink_RemoteOnClose_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy: [ HRESULT, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Finish_RemoteOnDataChange_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_RemoteOnViewChange_Proxy: [ HRESULT, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Finish_RemoteOnViewChange_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_RemoteOnRename_Proxy: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink_Begin_RemoteOnRename_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Finish_RemoteOnRename_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_RemoteOnRename_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_RemoteOnSave_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_RemoteOnSave_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Finish_RemoteOnSave_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_RemoteOnSave_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_RemoteOnClose_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_RemoteOnClose_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink_Finish_RemoteOnClose_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_RemoteOnClose_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IAdviseSink2_RemoteOnLinkSrcChange_Proxy: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  IAdviseSink2_RemoteOnLinkSrcChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Proxy: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Proxy: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IDataObject_RemoteGetData_Proxy: [ HRESULT, { This: PTR(uint), pformatetcIn: PTR(uint), pRemoteMedium: PTR(uint) } ],
  IDataObject_RemoteGetData_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IDataObject_RemoteGetDataHere_Proxy: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pRemoteMedium: PTR(uint) } ],
  IDataObject_RemoteGetDataHere_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IDataObject_RemoteSetData_Proxy: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pmedium: PTR(uint), fRelease: BOOL } ],
  IDataObject_RemoteSetData_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IFillLockBytes_RemoteFillAppend_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IFillLockBytes_RemoteFillAppend_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IFillLockBytes_RemoteFillAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IFillLockBytes_RemoteFillAt_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ASYNC_STGMEDIUM_UserSize: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserMarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserUnmarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserFree: [ VOID, { PTR(uint): PTR(uint) } ],
  CLIPFORMAT_UserSize: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserMarshal: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserUnmarshal: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserFree: [ VOID, { PTR(ushort): PTR(ushort) } ],
  FLAG_STGMEDIUM_UserSize: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserMarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserUnmarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserFree: [ VOID, { PTR(uint): PTR(uint) } ],
  HBITMAP_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  STGMEDIUM_UserSize: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserMarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserUnmarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserFree: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserSize64: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserMarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserUnmarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  ASYNC_STGMEDIUM_UserFree64: [ VOID, { PTR(uint): PTR(uint) } ],
  CLIPFORMAT_UserSize64: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserMarshal64: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserUnmarshal64: [ VOID, { PTR(ushort): PTR(ushort) } ],
  CLIPFORMAT_UserFree64: [ VOID, { PTR(ushort): PTR(ushort) } ],
  FLAG_STGMEDIUM_UserSize64: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserMarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserUnmarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  FLAG_STGMEDIUM_UserFree64: [ VOID, { PTR(uint): PTR(uint) } ],
  HBITMAP_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HBITMAP_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HDC_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HICON_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  SNB_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  STGMEDIUM_UserSize64: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserMarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserUnmarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  STGMEDIUM_UserFree64: [ VOID, { PTR(uint): PTR(uint) } ],
  IEnumUnknown_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IEnumUnknown_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IBindCtx_SetBindOptions_Proxy: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IBindCtx_SetBindOptions_Stub: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IBindCtx_GetBindOptions_Proxy: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IBindCtx_GetBindOptions_Stub: [ HRESULT, { This: PTR(uint), pbindopts: PTR(uint) } ],
  IEnumMoniker_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IEnumMoniker_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(uint)), pceltFetched: PTR(ulong) } ],
  IRunnableObject_IsRunning_Proxy: [ BOOL, { This: PTR(uint) } ],
  IRunnableObject_IsRunning_Stub: [ HRESULT, { This: PTR(uint) } ],
  IMoniker_BindToObject_Proxy: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riidResult: PTR(uint), ppvResult: PTR(PTR(VOID)) } ],
  IMoniker_BindToObject_Stub: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riidResult: PTR(uint), ppvResult: PTR(PTR(uint)) } ],
  IMoniker_BindToStorage_Proxy: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(VOID)) } ],
  IMoniker_BindToStorage_Stub: [ HRESULT, { This: PTR(uint), pbc: PTR(uint), pmkToLeft: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IEnumString_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(ushort)), pceltFetched: PTR(ulong) } ],
  IEnumString_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(PTR(ushort)), pceltFetched: PTR(ulong) } ],
  ISequentialStream_Read_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(VOID), cb: ULONG, pcbRead: PTR(ulong) } ],
  ISequentialStream_Read_Stub: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbRead: PTR(ulong) } ],
  ISequentialStream_Write_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(VOID), cb: ULONG, pcbWritten: PTR(ulong) } ],
  ISequentialStream_Write_Stub: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IStream_Seek_Proxy: [ HRESULT, { This: PTR(uint), dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: PTR(uint) } ],
  IStream_Seek_Stub: [ HRESULT, { This: PTR(uint), dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: PTR(uint) } ],
  IStream_CopyTo_Proxy: [ HRESULT, { This: PTR(uint), pstm: PTR(uint), cb: ULARGE_INTEGER, pcbRead: PTR(uint), pcbWritten: PTR(uint) } ],
  IStream_CopyTo_Stub: [ HRESULT, { This: PTR(uint), pstm: PTR(uint), cb: ULARGE_INTEGER, pcbRead: PTR(uint), pcbWritten: PTR(uint) } ],
  IEnumSTATSTG_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATSTG_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IStorage_OpenStream_Proxy: [ HRESULT, { This: PTR(uint), pwcsName: PTR(ushort), reserved1: PTR(VOID), grfMode: DWORD, reserved2: DWORD, ppstm: PTR(PTR(uint)) } ],
  IStorage_OpenStream_Stub: [ HRESULT, { This: PTR(uint), pwcsName: PTR(ushort), cbReserved1: ulong, reserved1: PTR(uchar), grfMode: DWORD, reserved2: DWORD, ppstm: PTR(PTR(uint)) } ],
  IStorage_CopyTo_Proxy: [ HRESULT, { This: PTR(uint), ciidExclude: DWORD, rgiidExclude: PTR(uint), snbExclude: SNB, pstgDest: PTR(uint) } ],
  IStorage_CopyTo_Stub: [ HRESULT, { This: PTR(uint), ciidExclude: DWORD, rgiidExclude: PTR(uint), snbExclude: SNB, pstgDest: PTR(uint) } ],
  IStorage_EnumElements_Proxy: [ HRESULT, { This: PTR(uint), reserved1: DWORD, reserved2: PTR(VOID), reserved3: DWORD, ppenum: PTR(PTR(uint)) } ],
  IStorage_EnumElements_Stub: [ HRESULT, { This: PTR(uint), reserved1: DWORD, cbReserved2: ulong, reserved2: PTR(uchar), reserved3: DWORD, ppenum: PTR(PTR(uint)) } ],
  ILockBytes_ReadAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(VOID), cb: ULONG, pcbRead: PTR(ulong) } ],
  ILockBytes_ReadAt_Stub: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbRead: PTR(ulong) } ],
  ILockBytes_WriteAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(VOID), cb: ULONG, pcbWritten: PTR(ulong) } ],
  ILockBytes_WriteAt_Stub: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IEnumFORMATETC_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumFORMATETC_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATDATA_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATDATA_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IAdviseSink_OnDataChange_Proxy: [ VOID, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  IAdviseSink_OnDataChange_Stub: [ HRESULT, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  IAdviseSink_OnViewChange_Proxy: [ VOID, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  IAdviseSink_OnViewChange_Stub: [ HRESULT, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  IAdviseSink_OnRename_Proxy: [ VOID, { This: PTR(uint), pmk: PTR(uint) } ],
  IAdviseSink_OnRename_Stub: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  IAdviseSink_OnSave_Proxy: [ VOID, { This: PTR(uint) } ],
  IAdviseSink_OnSave_Stub: [ HRESULT, { This: PTR(uint) } ],
  IAdviseSink_OnClose_Proxy: [ VOID, { This: PTR(uint) } ],
  IAdviseSink_OnClose_Stub: [ HRESULT, { This: PTR(uint) } ],
  IAdviseSink2_OnLinkSrcChange_Proxy: [ VOID, { This: PTR(uint), pmk: PTR(uint) } ],
  IAdviseSink2_OnLinkSrcChange_Stub: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  IDataObject_GetData_Proxy: [ HRESULT, { This: PTR(uint), pformatetcIn: PTR(uint), pmedium: PTR(uint) } ],
  IDataObject_GetData_Stub: [ HRESULT, { This: PTR(uint), pformatetcIn: PTR(uint), pRemoteMedium: PTR(uint) } ],
  IDataObject_GetDataHere_Proxy: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pmedium: PTR(uint) } ],
  IDataObject_GetDataHere_Stub: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pRemoteMedium: PTR(uint) } ],
  IDataObject_SetData_Proxy: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pmedium: PTR(uint), fRelease: BOOL } ],
  IDataObject_SetData_Stub: [ HRESULT, { This: PTR(uint), pformatetc: PTR(uint), pmedium: PTR(uint), fRelease: BOOL } ],
  IFillLockBytes_FillAppend_Proxy: [ HRESULT, { This: PTR(uint), pv: PTR(VOID), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IFillLockBytes_FillAppend_Stub: [ HRESULT, { This: PTR(uint), pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IFillLockBytes_FillAt_Proxy: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(VOID), cb: ULONG, pcbWritten: PTR(ulong) } ],
  IFillLockBytes_FillAt_Stub: [ HRESULT, { This: PTR(uint), ulOffset: ULARGE_INTEGER, pv: PTR(uchar), cb: ULONG, pcbWritten: PTR(ulong) } ],
  AsyncIAdviseSink_Begin_OnDataChange_Proxy: [ VOID, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnDataChange_Stub: [ HRESULT, { This: PTR(uint), pFormatetc: PTR(uint), pStgmed: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnDataChange_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnDataChange_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnViewChange_Proxy: [ VOID, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  AsyncIAdviseSink_Begin_OnViewChange_Stub: [ HRESULT, { This: PTR(uint), dwAspect: DWORD, lindex: LONG } ],
  AsyncIAdviseSink_Finish_OnViewChange_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnViewChange_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnRename_Proxy: [ VOID, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnRename_Stub: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnRename_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnRename_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnSave_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnSave_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnSave_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnSave_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnClose_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Begin_OnClose_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnClose_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink_Finish_OnClose_Stub: [ HRESULT, { This: PTR(uint) } ],
  AsyncIAdviseSink2_Begin_OnLinkSrcChange_Proxy: [ VOID, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink2_Begin_OnLinkSrcChange_Stub: [ HRESULT, { This: PTR(uint), pmk: PTR(uint) } ],
  AsyncIAdviseSink2_Finish_OnLinkSrcChange_Proxy: [ VOID, { This: PTR(uint) } ],
  AsyncIAdviseSink2_Finish_OnLinkSrcChange_Stub: [ HRESULT, { This: PTR(uint) } ],
  CoBuildVersion: [ DWORD, {  } ],
  CoInitialize: [ HRESULT, { pvReserved: LPVOID } ],
  CoUninitialize: [ VOID, {  } ],
  CoGetMalloc: [ HRESULT, { dwMemContext: DWORD, ppMalloc: PTR(VOIDPTR) } ],
  CoGetCurrentProcess: [ DWORD, {  } ],
  CoRegisterMallocSpy: [ HRESULT, { pMallocSpy: LPMALLOCSPY } ],
  CoRevokeMallocSpy: [ HRESULT, {  } ],
  CoCreateStandardMalloc: [ HRESULT, { memctx: DWORD, ppMalloc: PTR(PTR(uint)) } ],
  CoInitializeEx: [ HRESULT, { pvReserved: LPVOID, dwCoInit: DWORD } ],
  CoGetCallerTID: [ HRESULT, { lpdwTID: LPDWORD } ],
  CoGetCurrentLogicalThreadId: [ HRESULT, { pguid: PTR(uint) } ],
  CoRegisterInitializeSpy: [ HRESULT, { pSpy: LPINITIALIZESPY, puliCookie: PTR(uint) } ],
  CoRevokeInitializeSpy: [ HRESULT, { uliCookie: ULARGE_INTEGER } ],
  CoGetContextToken: [ HRESULT, { pToken: PTR(ulong) } ],
  CoGetSystemSecurityPermissions: [ HRESULT, { comSDType: COMSD, ppSD: PTR(PTR(VOID)) } ],
  CoGetApartmentType: [ HRESULT, { pAptType: PTR(uint), pAptQualifier: PTR(uint) } ],
  CoGetObjectContext: [ HRESULT, { riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  CoGetClassObject: [ HRESULT, { rclsid: PTR(uint), dwClsContext: DWORD, pvReserved: LPVOID, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  CoRegisterClassObject: [ HRESULT, { rclsid: PTR(uint), pUnk: LPUNKNOWN, dwClsContext: DWORD, flags: DWORD, lpdwRegister: LPDWORD } ],
  CoRevokeClassObject: [ HRESULT, { dwRegister: DWORD } ],
  CoResumeClassObjects: [ HRESULT, {  } ],
  CoSuspendClassObjects: [ HRESULT, {  } ],
  CoAddRefServerProcess: [ ULONG, {  } ],
  CoReleaseServerProcess: [ ULONG, {  } ],
  CoGetPSClsid: [ HRESULT, { riid: PTR(uint), pClsid: PTR(uint) } ],
  CoRegisterPSClsid: [ HRESULT, { riid: PTR(uint), rclsid: PTR(uint) } ],
  CoRegisterSurrogate: [ HRESULT, { pSurrogate: LPSURROGATE } ],
  CoGetMarshalSizeMax: [ HRESULT, { pulSize: PTR(ulong), riid: PTR(uint), pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD } ],
  CoMarshalInterface: [ HRESULT, { pStm: LPSTREAM, riid: PTR(uint), pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD } ],
  CoUnmarshalInterface: [ HRESULT, { pStm: LPSTREAM, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  CoMarshalHresult: [ HRESULT, { pstm: LPSTREAM, hresult: HRESULT } ],
  CoUnmarshalHresult: [ HRESULT, { pstm: LPSTREAM, phresult: PTR(long) } ],
  CoReleaseMarshalData: [ HRESULT, { pStm: LPSTREAM } ],
  CoDisconnectObject: [ HRESULT, { pUnk: LPUNKNOWN, dwReserved: DWORD } ],
  CoLockObjectExternal: [ HRESULT, { pUnk: LPUNKNOWN, fLock: BOOL, fLastUnlockReleases: BOOL } ],
  CoGetStandardMarshal: [ HRESULT, { riid: PTR(uint), pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD, ppMarshal: PTR(VOIDPTR) } ],
  CoGetStdMarshalEx: [ HRESULT, { pUnkOuter: LPUNKNOWN, smexflags: DWORD, ppUnkInner: PTR(VOIDPTR) } ],
  CoIsHandlerConnected: [ BOOL, { pUnk: LPUNKNOWN } ],
  CoMarshalInterThreadInterfaceInStream: [ HRESULT, { riid: PTR(uint), pUnk: LPUNKNOWN, ppStm: PTR(VOIDPTR) } ],
  CoGetInterfaceAndReleaseStream: [ HRESULT, { pStm: LPSTREAM, iid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  CoCreateFreeThreadedMarshaler: [ HRESULT, { punkOuter: LPUNKNOWN, ppunkMarshal: PTR(VOIDPTR) } ],
  CoLoadLibrary: [ HINSTANCE, { lpszLibName: LPOLESTR, bAutoFree: BOOL } ],
  CoFreeLibrary: [ VOID, { hInst: HINSTANCE } ],
  CoFreeAllLibraries: [ VOID, {  } ],
  CoFreeUnusedLibraries: [ VOID, {  } ],
  CoFreeUnusedLibrariesEx: [ VOID, { dwUnloadDelay: DWORD, dwReserved: DWORD } ],
  CoDisconnectContext: [ HRESULT, { dwTimeout: DWORD } ],
  CoInitializeSecurity: [ HRESULT, { pSecDesc: PSECURITY_DESCRIPTOR, cAuthSvc: LONG, asAuthSvc: PTR(uint), pReserved1: PTR(VOID), dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthList: PTR(VOID), dwCapabilities: DWORD, pReserved3: PTR(VOID) } ],
  CoGetCallContext: [ HRESULT, { riid: PTR(uint), ppInterface: PTR(PTR(VOID)) } ],
  CoQueryProxyBlanket: [ HRESULT, { pProxy: PTR(uint), pwAuthnSvc: PTR(ulong), pAuthzSvc: PTR(ulong), pServerPrincName: PTR(PTR(ushort)), pAuthnLevel: PTR(ulong), pImpLevel: PTR(ulong), pAuthInfo: PTR(PTR(VOID)), pCapabilites: PTR(ulong) } ],
  CoSetProxyBlanket: [ HRESULT, { pProxy: PTR(uint), dwAuthnSvc: DWORD, dwAuthzSvc: DWORD, pServerPrincName: PTR(ushort), dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthInfo: RPC_AUTH_IDENTITY_HANDLE, dwCapabilities: DWORD } ],
  CoCopyProxy: [ HRESULT, { pProxy: PTR(uint), ppCopy: PTR(PTR(uint)) } ],
  CoQueryClientBlanket: [ HRESULT, { pAuthnSvc: PTR(ulong), pAuthzSvc: PTR(ulong), pServerPrincName: PTR(PTR(ushort)), pAuthnLevel: PTR(ulong), pImpLevel: PTR(ulong), pPrivs: PTR(PTR(VOID)), pCapabilities: PTR(ulong) } ],
  CoImpersonateClient: [ HRESULT, {  } ],
  CoRevertToSelf: [ HRESULT, {  } ],
  CoQueryAuthenticationServices: [ HRESULT, { pcAuthSvc: PTR(ulong), asAuthSvc: PTR(PTR(uint)) } ],
  CoSwitchCallContext: [ HRESULT, { pNewObject: PTR(uint), ppOldObject: PTR(PTR(uint)) } ],
  CoCreateInstance: [ HRESULT, { rclsid: PTR(uint), pUnkOuter: LPUNKNOWN, dwClsContext: DWORD, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  CoGetInstanceFromFile: [ HRESULT, { pServerInfo: PTR(uint), pClsid: PTR(uint), punkOuter: PTR(uint), dwClsCtx: DWORD, grfMode: DWORD, pwszName: PTR(ushort), dwCount: DWORD, pResults: PTR(uint) } ],
  CoGetInstanceFromIStorage: [ HRESULT, { pServerInfo: PTR(uint), pClsid: PTR(uint), punkOuter: PTR(uint), dwClsCtx: DWORD, pstg: PTR(IStorage), dwCount: DWORD, pResults: PTR(uint) } ],
  CoCreateInstanceEx: [ HRESULT, { Clsid: PTR(uint), punkOuter: PTR(uint), dwClsCtx: DWORD, pServerInfo: PTR(uint), dwCount: DWORD, pResults: PTR(uint) } ],
  CoGetCancelObject: [ HRESULT, { dwThreadId: DWORD, iid: PTR(uint), ppUnk: PTR(PTR(VOID)) } ],
  CoSetCancelObject: [ HRESULT, { pUnk: PTR(uint) } ],
  CoCancelCall: [ HRESULT, { dwThreadId: DWORD, ulTimeout: ULONG } ],
  CoTestCancel: [ HRESULT, {  } ],
  CoEnableCallCancellation: [ HRESULT, { pReserved: LPVOID } ],
  CoDisableCallCancellation: [ HRESULT, { pReserved: LPVOID } ],
  CoAllowSetForegroundWindow: [ HRESULT, { pUnk: PTR(uint), lpvReserved: LPVOID } ],
  DcomChannelSetHResult: [ HRESULT, { pvReserved: LPVOID, pulReserved: PTR(ulong), appsHR: HRESULT } ],
  StringFromCLSID: [ HRESULT, { rclsid: PTR(uint), lplpsz: PTR(PTR(ushort)) } ],
  CLSIDFromString: [ HRESULT, { lpsz: LPCOLESTR, pclsid: LPCLSID } ],
  StringFromIID: [ HRESULT, { rclsid: PTR(uint), lplpsz: PTR(PTR(ushort)) } ],
  IIDFromString: [ HRESULT, { lpsz: LPCOLESTR, lpiid: LPIID } ],
  CoIsOle1Class: [ BOOL, { rclsid: PTR(uint) } ],
  ProgIDFromCLSID: [ HRESULT, { clsid: PTR(uint), lplpszProgID: PTR(PTR(ushort)) } ],
  CLSIDFromProgID: [ HRESULT, { lpszProgID: LPCOLESTR, lpclsid: LPCLSID } ],
  CLSIDFromProgIDEx: [ HRESULT, { lpszProgID: LPCOLESTR, lpclsid: LPCLSID } ],
  StringFromGUID2: [ VOID, { rguid: PTR(uint), lpsz: LPOLESTR, cchMax: int } ],
  CoCreateGuid: [ HRESULT, { pguid: PTR(uint) } ],
  CoFileTimeToDosDateTime: [ BOOL, { lpFileTime: PTR(uint), lpDosDate: LPWORD, lpDosTime: LPWORD } ],
  CoDosDateTimeToFileTime: [ BOOL, { nDosDate: WORD, nDosTime: WORD, lpFileTime: PTR(uint) } ],
  CoFileTimeNow: [ HRESULT, { lpFileTime: PTR(uint) } ],
  CoRegisterMessageFilter: [ HRESULT, { lpMessageFilter: LPMESSAGEFILTER, lplpMessageFilter: PTR(VOIDPTR) } ],
  CoRegisterChannelHook: [ HRESULT, { ExtensionUuid: PTR(uint), pChannelHook: PTR(uint) } ],
  CoWaitForMultipleHandles: [ HRESULT, { dwFlags: DWORD, dwTimeout: DWORD, cHandles: ULONG, pHandles: LPHANDLE, lpdwindex: LPDWORD } ],
  CoInvalidateRemoteMachineBindings: [ HRESULT, { pszMachineName: LPOLESTR } ],
  CoGetTreatAsClass: [ HRESULT, { clsidOld: PTR(uint), pClsidNew: LPCLSID } ],
  CoTreatAsClass: [ HRESULT, { clsidOld: PTR(uint), clsidNew: PTR(uint) } ],
  DllGetClassObject: [ HRESULT, { rclsid: PTR(uint), riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  DllCanUnloadNow: [ HRESULT, {  } ],
  CoTaskMemAlloc: [ LPVOID, { cb: SIZE_T } ],
  CoTaskMemRealloc: [ LPVOID, { pv: LPVOID, cb: SIZE_T } ],
  CoTaskMemFree: [ VOID, { pv: LPVOID } ],
  CreateDataAdviseHolder: [ HRESULT, { ppDAHolder: PTR(VOIDPTR) } ],
  CreateDataCache: [ HRESULT, { pUnkOuter: LPUNKNOWN, rclsid: PTR(uint), iid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  StgCreateDocfile: [ HRESULT, { pwcsName: PTR(ushort), grfMode: DWORD, reserved: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgCreateDocfileOnILockBytes: [ HRESULT, { plkbyt: PTR(uint), grfMode: DWORD, reserved: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgOpenStorage: [ HRESULT, { pwcsName: PTR(ushort), pstgPriority: PTR(uint), grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgOpenStorageOnILockBytes: [ HRESULT, { plkbyt: PTR(uint), pstgPriority: PTR(uint), grfMode: DWORD, snbExclude: SNB, reserved: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgIsStorageFile: [ HRESULT, { pwcsName: PTR(ushort) } ],
  StgIsStorageILockBytes: [ HRESULT, { plkbyt: PTR(uint) } ],
  StgSetTimes: [ HRESULT, { lpszName: PTR(ushort), pctime: PTR(uint), patime: PTR(uint), pmtime: PTR(uint) } ],
  StgOpenAsyncDocfileOnIFillLockBytes: [ HRESULT, { pflb: PTR(uint), grfMode: DWORD, asyncFlags: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgGetIFillLockBytesOnILockBytes: [ HRESULT, { pilb: PTR(uint), ppflb: PTR(PTR(uint)) } ],
  StgGetIFillLockBytesOnFile: [ HRESULT, { pwcsName: PTR(ushort), ppflb: PTR(PTR(uint)) } ],
  StgOpenLayoutDocfile: [ HRESULT, { pwcsDfName: PTR(ushort), grfMode: DWORD, reserved: DWORD, ppstgOpen: PTR(PTR(uint)) } ],
  StgCreateStorageEx: [ HRESULT, { pwcsName: PTR(ushort), grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, pStgOptions: PTR(uint), pSecurityDescriptor: PSECURITY_DESCRIPTOR, riid: PTR(uint), ppObjectOpen: PTR(PTR(VOID)) } ],
  StgOpenStorageEx: [ HRESULT, { pwcsName: PTR(ushort), grfMode: DWORD, stgfmt: DWORD, grfAttrs: DWORD, pStgOptions: PTR(uint), pSecurityDescriptor: PSECURITY_DESCRIPTOR, riid: PTR(uint), ppObjectOpen: PTR(PTR(VOID)) } ],
  BindMoniker: [ HRESULT, { pmk: LPMONIKER, grfOpt: DWORD, iidResult: PTR(uint), ppvResult: PTR(PTR(VOID)) } ],
  CoInstall: [ HRESULT, { pbc: PTR(uint), dwFlags: DWORD, pClassSpec: PTR(uint), pQuery: PTR(uint), pszCodeBase: LPWSTR } ],
  CoGetObject: [ HRESULT, { pszName: LPCWSTR, pBindOptions: PTR(uint), riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  MkParseDisplayName: [ HRESULT, { pbc: LPBC, szUserName: LPCOLESTR, pchEaten: PTR(ulong), ppmk: PTR(VOIDPTR) } ],
  MonikerRelativePathTo: [ HRESULT, { pmkSrc: LPMONIKER, pmkDest: LPMONIKER, ppmkRelPath: PTR(VOIDPTR), dwReserved: BOOL } ],
  MonikerCommonPrefixWith: [ HRESULT, { pmkThis: LPMONIKER, pmkOther: LPMONIKER, ppmkCommon: PTR(VOIDPTR) } ],
  CreateBindCtx: [ HRESULT, { reserved: DWORD, ppbc: PTR(VOIDPTR) } ],
  CreateGenericComposite: [ HRESULT, { pmkFirst: LPMONIKER, pmkRest: LPMONIKER, ppmkComposite: PTR(VOIDPTR) } ],
  GetClassFile: [ HRESULT, { szFilename: LPCOLESTR, pclsid: PTR(uint) } ],
  CreateClassMoniker: [ HRESULT, { rclsid: PTR(uint), ppmk: PTR(VOIDPTR) } ],
  CreateFileMoniker: [ HRESULT, { lpszPathName: LPCOLESTR, ppmk: PTR(VOIDPTR) } ],
  CreateItemMoniker: [ HRESULT, { lpszDelim: LPCOLESTR, lpszItem: LPCOLESTR, ppmk: PTR(VOIDPTR) } ],
  CreateAntiMoniker: [ HRESULT, { ppmk: PTR(VOIDPTR) } ],
  CreatePointerMoniker: [ HRESULT, { punk: LPUNKNOWN, ppmk: PTR(VOIDPTR) } ],
  CreateObjrefMoniker: [ HRESULT, { punk: LPUNKNOWN, ppmk: PTR(VOIDPTR) } ],
  GetRunningObjectTable: [ HRESULT, { reserved: DWORD, pprot: PTR(VOIDPTR) } ],
  IOleCache2_RemoteUpdateCache_Proxy: [ HRESULT, { This: PTR(uint), pDataObject: LPDATAOBJECT, grfUpdf: DWORD, pReserved: LONG_PTR } ],
  IOleCache2_RemoteUpdateCache_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IOleInPlaceActiveObject_RemoteTranslateAccelerator_Proxy: [ HRESULT, { This: PTR(uint) } ],
  IOleInPlaceActiveObject_RemoteTranslateAccelerator_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IOleInPlaceActiveObject_RemoteResizeBorder_Proxy: [ HRESULT, { This: PTR(uint), prcBorder: LPCRECT, riid: PTR(uint), pUIWindow: PTR(uint), fFrameWindow: BOOL } ],
  IOleInPlaceActiveObject_RemoteResizeBorder_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IViewObject_RemoteDraw_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, ptd: PTR(uint), hdcTargetDev: HDC, hdcDraw: HDC, lprcBounds: LPCRECTL, lprcWBounds: LPCRECTL, pContinue: PTR(uint) } ],
  IViewObject_RemoteDraw_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IViewObject_RemoteGetColorSet_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, ptd: PTR(uint), hicTargetDev: ULONG_PTR, ppColorSet: PTR(PTR(uint)) } ],
  IViewObject_RemoteGetColorSet_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IViewObject_RemoteFreeze_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, pdwFreeze: PTR(ulong) } ],
  IViewObject_RemoteFreeze_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IViewObject_RemoteGetAdvise_Proxy: [ HRESULT, { This: PTR(uint), pAspects: PTR(ulong), pAdvf: PTR(ulong), ppAdvSink: PTR(PTR(uint)) } ],
  IViewObject_RemoteGetAdvise_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumOLEVERB_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: LPOLEVERB, pceltFetched: PTR(ulong) } ],
  IEnumOLEVERB_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  HACCEL_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HGLOBAL_UserSize: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserMarshal: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserUnmarshal: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserFree: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HMENU_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HACCEL_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HGLOBAL_UserSize64: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserMarshal64: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserUnmarshal64: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HGLOBAL_UserFree64: [ VOID, { PTR(PTR(VOID)): PTR(PTR(VOID)) } ],
  HMENU_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HMENU_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  HWND_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  IOleCache2_UpdateCache_Proxy: [ HRESULT, { This: PTR(uint), pDataObject: LPDATAOBJECT, grfUpdf: DWORD, pReserved: LPVOID } ],
  IOleCache2_UpdateCache_Stub: [ HRESULT, { This: PTR(uint), pDataObject: LPDATAOBJECT, grfUpdf: DWORD, pReserved: LONG_PTR } ],
  IOleInPlaceActiveObject_TranslateAccelerator_Proxy: [ HRESULT, { This: PTR(uint), lpmsg: LPMSG } ],
  IOleInPlaceActiveObject_TranslateAccelerator_Stub: [ HRESULT, { This: PTR(uint) } ],
  IOleInPlaceActiveObject_ResizeBorder_Proxy: [ HRESULT, { This: PTR(uint), prcBorder: LPCRECT, pUIWindow: PTR(uint), fFrameWindow: BOOL } ],
  IOleInPlaceActiveObject_ResizeBorder_Stub: [ HRESULT, { This: PTR(uint), prcBorder: LPCRECT, riid: PTR(uint), pUIWindow: PTR(uint), fFrameWindow: BOOL } ],
  IViewObject_Draw_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: PTR(VOID), ptd: PTR(uint), hdcTargetDev: HDC, hdcDraw: HDC, lprcBounds: LPCRECTL, lprcWBounds: LPCRECTL, pfnContinue: PTR(UNEXPOSED), dwContinue: ULONG_PTR } ],
  IViewObject_Draw_Stub: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, ptd: PTR(uint), hdcTargetDev: HDC, hdcDraw: HDC, lprcBounds: LPCRECTL, lprcWBounds: LPCRECTL, pContinue: PTR(uint) } ],
  IViewObject_GetColorSet_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: PTR(VOID), ptd: PTR(uint), hicTargetDev: HDC, ppColorSet: PTR(PTR(uint)) } ],
  IViewObject_GetColorSet_Stub: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, ptd: PTR(uint), hicTargetDev: ULONG_PTR, ppColorSet: PTR(PTR(uint)) } ],
  IViewObject_Freeze_Proxy: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: PTR(VOID), pdwFreeze: PTR(ulong) } ],
  IViewObject_Freeze_Stub: [ HRESULT, { This: PTR(uint), dwDrawAspect: DWORD, lindex: LONG, pvAspect: ULONG_PTR, pdwFreeze: PTR(ulong) } ],
  IViewObject_GetAdvise_Proxy: [ HRESULT, { This: PTR(uint), pAspects: PTR(ulong), pAdvf: PTR(ulong), ppAdvSink: PTR(PTR(uint)) } ],
  IViewObject_GetAdvise_Stub: [ HRESULT, { This: PTR(uint), pAspects: PTR(ulong), pAdvf: PTR(ulong), ppAdvSink: PTR(PTR(uint)) } ],
  IEnumOLEVERB_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: LPOLEVERB, pceltFetched: PTR(ulong) } ],
  IEnumOLEVERB_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: LPOLEVERB, pceltFetched: PTR(ulong) } ],
  IServiceProvider_RemoteQueryService_Proxy: [ HRESULT, { This: PTR(uint), guidService: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) } ],
  IServiceProvider_RemoteQueryService_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IServiceProvider_QueryService_Proxy: [ HRESULT, { This: PTR(uint), guidService: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(VOID)) } ],
  IServiceProvider_QueryService_Stub: [ HRESULT, { This: PTR(uint), guidService: PTR(uint), riid: PTR(uint), ppvObject: PTR(PTR(uint)) } ],
  IDispatch_RemoteInvoke_Proxy: [ HRESULT, { This: PTR(uint), dispIdMember: DISPID, riid: PTR(uint), lcid: LCID, dwFlags: DWORD, pDispParams: PTR(uint), pVarResult: PTR(uint), pExcepInfo: PTR(uint), pArgErr: PTR(uint), cVarRef: UINT, rgVarRefIdx: PTR(uint), rgVarRef: PTR(uint) } ],
  IDispatch_RemoteInvoke_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumVARIANT_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgVar: PTR(uint), pCeltFetched: PTR(ulong) } ],
  IEnumVARIANT_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeComp_RemoteBind_Proxy: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, wFlags: WORD, ppTInfo: PTR(PTR(uint)), pDescKind: PTR(uint), ppFuncDesc: PTR(VOIDPTR), ppVarDesc: PTR(VOIDPTR), ppTypeComp: PTR(PTR(uint)), pDummy: PTR(uint) } ],
  ITypeComp_RemoteBind_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeComp_RemoteBindType_Proxy: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)) } ],
  ITypeComp_RemoteBindType_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetTypeAttr_Proxy: [ HRESULT, { This: PTR(uint), ppTypeAttr: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_RemoteGetTypeAttr_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetFuncDesc_Proxy: [ HRESULT, { This: PTR(uint), index: UINT, ppFuncDesc: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_RemoteGetFuncDesc_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetVarDesc_Proxy: [ HRESULT, { This: PTR(uint), index: UINT, ppVarDesc: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_RemoteGetVarDesc_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetNames_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, rgBstrNames: PTR(PTR(ushort)), cMaxNames: UINT, pcNames: PTR(uint) } ],
  ITypeInfo_RemoteGetNames_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalGetIDsOfNames_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalGetIDsOfNames_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalInvoke_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalInvoke_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetDocumentation_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, refPtrFlags: DWORD, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeInfo_RemoteGetDocumentation_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetDllEntry_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, invKind: INVOKEKIND, refPtrFlags: DWORD, pBstrDllName: PTR(PTR(ushort)), pBstrName: PTR(PTR(ushort)), pwOrdinal: PTR(ushort) } ],
  ITypeInfo_RemoteGetDllEntry_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalAddressOfMember_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalAddressOfMember_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteCreateInstance_Proxy: [ HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  ITypeInfo_RemoteCreateInstance_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_RemoteGetContainingTypeLib_Proxy: [ HRESULT, { This: PTR(uint), ppTLib: PTR(PTR(uint)), pIndex: PTR(uint) } ],
  ITypeInfo_RemoteGetContainingTypeLib_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalReleaseTypeAttr_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalReleaseTypeAttr_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalReleaseFuncDesc_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalReleaseFuncDesc_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo_LocalReleaseVarDesc_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_LocalReleaseVarDesc_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeInfo2_RemoteGetDocumentation2_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, lcid: LCID, refPtrFlags: DWORD, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  ITypeInfo2_RemoteGetDocumentation2_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_RemoteGetTypeInfoCount_Proxy: [ HRESULT, { This: PTR(uint), pcTInfo: PTR(uint) } ],
  ITypeLib_RemoteGetTypeInfoCount_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_RemoteGetLibAttr_Proxy: [ HRESULT, { This: PTR(uint), ppTLibAttr: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeLib_RemoteGetLibAttr_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_RemoteGetDocumentation_Proxy: [ HRESULT, { This: PTR(uint), index: INT, refPtrFlags: DWORD, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeLib_RemoteGetDocumentation_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_RemoteIsName_Proxy: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, pfName: PTR(int), pBstrLibName: PTR(PTR(ushort)) } ],
  ITypeLib_RemoteIsName_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_RemoteFindName_Proxy: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)), rgMemId: PTR(long), pcFound: PTR(ushort), pBstrLibName: PTR(PTR(ushort)) } ],
  ITypeLib_RemoteFindName_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib_LocalReleaseTLibAttr_Proxy: [ HRESULT, { This: PTR(uint) } ],
  ITypeLib_LocalReleaseTLibAttr_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib2_RemoteGetLibStatistics_Proxy: [ HRESULT, { This: PTR(uint), pcUniqueNames: PTR(ulong), pcchUniqueNames: PTR(ulong) } ],
  ITypeLib2_RemoteGetLibStatistics_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  ITypeLib2_RemoteGetDocumentation2_Proxy: [ HRESULT, { This: PTR(uint), index: INT, lcid: LCID, refPtrFlags: DWORD, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  ITypeLib2_RemoteGetDocumentation2_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IPropertyBag_RemoteRead_Proxy: [ HRESULT, { This: PTR(uint), pszPropName: LPCOLESTR, pVar: PTR(uint), pErrorLog: PTR(uint), varType: DWORD, pUnkObj: PTR(uint) } ],
  IPropertyBag_RemoteRead_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  BSTR_UserSize: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserMarshal: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserUnmarshal: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserFree: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  CLEANLOCALSTORAGE_UserSize: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserMarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserUnmarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserFree: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserSize: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserMarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserUnmarshal: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserFree: [ VOID, { PTR(uint): PTR(uint) } ],
  BSTR_UserSize64: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserMarshal64: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserUnmarshal64: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  BSTR_UserFree64: [ VOID, { PTR(PTR(ushort)): PTR(PTR(ushort)) } ],
  CLEANLOCALSTORAGE_UserSize64: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserMarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserUnmarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  CLEANLOCALSTORAGE_UserFree64: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserSize64: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserMarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserUnmarshal64: [ VOID, { PTR(uint): PTR(uint) } ],
  VARIANT_UserFree64: [ VOID, { PTR(uint): PTR(uint) } ],
  IDispatch_Invoke_Proxy: [ HRESULT, { This: PTR(uint), dispIdMember: DISPID, riid: PTR(uint), lcid: LCID, wFlags: WORD, pDispParams: PTR(uint), pVarResult: PTR(uint), pExcepInfo: PTR(uint), puArgErr: PTR(uint) } ],
  IDispatch_Invoke_Stub: [ HRESULT, { This: PTR(uint), dispIdMember: DISPID, riid: PTR(uint), lcid: LCID, dwFlags: DWORD, pDispParams: PTR(uint), pVarResult: PTR(uint), pExcepInfo: PTR(uint), pArgErr: PTR(uint), cVarRef: UINT, rgVarRefIdx: PTR(uint), rgVarRef: PTR(uint) } ],
  IEnumVARIANT_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgVar: PTR(uint), pCeltFetched: PTR(ulong) } ],
  IEnumVARIANT_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgVar: PTR(uint), pCeltFetched: PTR(ulong) } ],
  ITypeComp_Bind_Proxy: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, wFlags: WORD, ppTInfo: PTR(PTR(uint)), pDescKind: PTR(uint), pBindPtr: PTR(uint) } ],
  ITypeComp_Bind_Stub: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, wFlags: WORD, ppTInfo: PTR(PTR(uint)), pDescKind: PTR(uint), ppFuncDesc: PTR(VOIDPTR), ppVarDesc: PTR(VOIDPTR), ppTypeComp: PTR(PTR(uint)), pDummy: PTR(uint) } ],
  ITypeComp_BindType_Proxy: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)), ppTComp: PTR(PTR(uint)) } ],
  ITypeComp_BindType_Stub: [ HRESULT, { This: PTR(uint), szName: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)) } ],
  ITypeInfo_GetTypeAttr_Proxy: [ HRESULT, { This: PTR(uint), ppTypeAttr: PTR(PTR(uint)) } ],
  ITypeInfo_GetTypeAttr_Stub: [ HRESULT, { This: PTR(uint), ppTypeAttr: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_GetFuncDesc_Proxy: [ HRESULT, { This: PTR(uint), index: UINT, ppFuncDesc: PTR(PTR(uint)) } ],
  ITypeInfo_GetFuncDesc_Stub: [ HRESULT, { This: PTR(uint), index: UINT, ppFuncDesc: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_GetVarDesc_Proxy: [ HRESULT, { This: PTR(uint), index: UINT, ppVarDesc: PTR(PTR(uint)) } ],
  ITypeInfo_GetVarDesc_Stub: [ HRESULT, { This: PTR(uint), index: UINT, ppVarDesc: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeInfo_GetNames_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, rgBstrNames: PTR(PTR(ushort)), cMaxNames: UINT, pcNames: PTR(uint) } ],
  ITypeInfo_GetNames_Stub: [ HRESULT, { This: PTR(uint), memid: MEMBERID, rgBstrNames: PTR(PTR(ushort)), cMaxNames: UINT, pcNames: PTR(uint) } ],
  ITypeInfo_GetIDsOfNames_Proxy: [ HRESULT, { This: PTR(uint), rgszNames: PTR(PTR(ushort)), cNames: UINT, pMemId: PTR(long) } ],
  ITypeInfo_GetIDsOfNames_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_Invoke_Proxy: [ HRESULT, { This: PTR(uint), pvInstance: PVOID, memid: MEMBERID, wFlags: WORD, pDispParams: PTR(uint), pVarResult: PTR(uint), pExcepInfo: PTR(uint), puArgErr: PTR(uint) } ],
  ITypeInfo_Invoke_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_GetDocumentation_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeInfo_GetDocumentation_Stub: [ HRESULT, { This: PTR(uint), memid: MEMBERID, refPtrFlags: DWORD, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeInfo_GetDllEntry_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, invKind: INVOKEKIND, pBstrDllName: PTR(PTR(ushort)), pBstrName: PTR(PTR(ushort)), pwOrdinal: PTR(ushort) } ],
  ITypeInfo_GetDllEntry_Stub: [ HRESULT, { This: PTR(uint), memid: MEMBERID, invKind: INVOKEKIND, refPtrFlags: DWORD, pBstrDllName: PTR(PTR(ushort)), pBstrName: PTR(PTR(ushort)), pwOrdinal: PTR(ushort) } ],
  ITypeInfo_AddressOfMember_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, invKind: INVOKEKIND, ppv: PTR(PTR(VOID)) } ],
  ITypeInfo_AddressOfMember_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_CreateInstance_Proxy: [ HRESULT, { This: PTR(uint), pUnkOuter: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(VOID)) } ],
  ITypeInfo_CreateInstance_Stub: [ HRESULT, { This: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  ITypeInfo_GetContainingTypeLib_Proxy: [ HRESULT, { This: PTR(uint), ppTLib: PTR(PTR(uint)), pIndex: PTR(uint) } ],
  ITypeInfo_GetContainingTypeLib_Stub: [ HRESULT, { This: PTR(uint), ppTLib: PTR(PTR(uint)), pIndex: PTR(uint) } ],
  ITypeInfo_ReleaseTypeAttr_Proxy: [ VOID, { This: PTR(uint), pTypeAttr: PTR(uint) } ],
  ITypeInfo_ReleaseTypeAttr_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_ReleaseFuncDesc_Proxy: [ VOID, { This: PTR(uint), pFuncDesc: PTR(uint) } ],
  ITypeInfo_ReleaseFuncDesc_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo_ReleaseVarDesc_Proxy: [ VOID, { This: PTR(uint), pVarDesc: PTR(uint) } ],
  ITypeInfo_ReleaseVarDesc_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeInfo2_GetDocumentation2_Proxy: [ HRESULT, { This: PTR(uint), memid: MEMBERID, lcid: LCID, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  ITypeInfo2_GetDocumentation2_Stub: [ HRESULT, { This: PTR(uint), memid: MEMBERID, lcid: LCID, refPtrFlags: DWORD, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  ITypeLib_GetTypeInfoCount_Proxy: [ UINT, { This: PTR(uint) } ],
  ITypeLib_GetTypeInfoCount_Stub: [ HRESULT, { This: PTR(uint), pcTInfo: PTR(uint) } ],
  ITypeLib_GetLibAttr_Proxy: [ HRESULT, { This: PTR(uint), ppTLibAttr: PTR(PTR(uint)) } ],
  ITypeLib_GetLibAttr_Stub: [ HRESULT, { This: PTR(uint), ppTLibAttr: PTR(VOIDPTR), pDummy: PTR(uint) } ],
  ITypeLib_GetDocumentation_Proxy: [ HRESULT, { This: PTR(uint), index: INT, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeLib_GetDocumentation_Stub: [ HRESULT, { This: PTR(uint), index: INT, refPtrFlags: DWORD, pBstrName: PTR(PTR(ushort)), pBstrDocString: PTR(PTR(ushort)), pdwHelpContext: PTR(ulong), pBstrHelpFile: PTR(PTR(ushort)) } ],
  ITypeLib_IsName_Proxy: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, pfName: PTR(int) } ],
  ITypeLib_IsName_Stub: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, pfName: PTR(int), pBstrLibName: PTR(PTR(ushort)) } ],
  ITypeLib_FindName_Proxy: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)), rgMemId: PTR(long), pcFound: PTR(ushort) } ],
  ITypeLib_FindName_Stub: [ HRESULT, { This: PTR(uint), szNameBuf: LPOLESTR, lHashVal: ULONG, ppTInfo: PTR(PTR(uint)), rgMemId: PTR(long), pcFound: PTR(ushort), pBstrLibName: PTR(PTR(ushort)) } ],
  ITypeLib_ReleaseTLibAttr_Proxy: [ VOID, { This: PTR(uint), pTLibAttr: PTR(uint) } ],
  ITypeLib_ReleaseTLibAttr_Stub: [ HRESULT, { This: PTR(uint) } ],
  ITypeLib2_GetLibStatistics_Proxy: [ HRESULT, { This: PTR(uint), pcUniqueNames: PTR(ulong), pcchUniqueNames: PTR(ulong) } ],
  ITypeLib2_GetLibStatistics_Stub: [ HRESULT, { This: PTR(uint), pcUniqueNames: PTR(ulong), pcchUniqueNames: PTR(ulong) } ],
  ITypeLib2_GetDocumentation2_Proxy: [ HRESULT, { This: PTR(uint), index: INT, lcid: LCID, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  ITypeLib2_GetDocumentation2_Stub: [ HRESULT, { This: PTR(uint), index: INT, lcid: LCID, refPtrFlags: DWORD, pbstrHelpString: PTR(PTR(ushort)), pdwHelpStringContext: PTR(ulong), pbstrHelpStringDll: PTR(PTR(ushort)) } ],
  IPropertyBag_Read_Proxy: [ HRESULT, { This: PTR(uint), pszPropName: LPCOLESTR, pVar: PTR(uint), pErrorLog: PTR(uint) } ],
  IPropertyBag_Read_Stub: [ HRESULT, { This: PTR(uint), pszPropName: LPCOLESTR, pVar: PTR(uint), pErrorLog: PTR(uint), varType: DWORD, pUnkObj: PTR(uint) } ],
  CreateURLMoniker: [ HRESULT, { pMkCtx: LPMONIKER, szURL: LPCWSTR, ppmk: PTR(VOIDPTR) } ],
  CreateURLMonikerEx: [ HRESULT, { pMkCtx: LPMONIKER, szURL: LPCWSTR, ppmk: PTR(VOIDPTR), dwFlags: DWORD } ],
  GetClassURL: [ HRESULT, { szURL: LPCWSTR, pClsID: PTR(uint) } ],
  CreateAsyncBindCtx: [ HRESULT, { reserved: DWORD, pBSCb: PTR(uint), pEFetc: PTR(uint), ppBC: PTR(PTR(uint)) } ],
  CreateURLMonikerEx2: [ HRESULT, { pMkCtx: LPMONIKER, pUri: PTR(uint), ppmk: PTR(VOIDPTR), dwFlags: DWORD } ],
  CreateAsyncBindCtxEx: [ HRESULT, { pbc: PTR(uint), dwOptions: DWORD, pBSCb: PTR(uint), pEnum: PTR(uint), ppBC: PTR(PTR(uint)), reserved: DWORD } ],
  MkParseDisplayNameEx: [ HRESULT, { pbc: PTR(uint), szDisplayName: LPCWSTR, pchEaten: PTR(ulong), ppmk: PTR(VOIDPTR) } ],
  RegisterBindStatusCallback: [ HRESULT, { pBC: LPBC, pBSCb: PTR(uint), ppBSCBPrev: PTR(PTR(uint)), dwReserved: DWORD } ],
  RevokeBindStatusCallback: [ HRESULT, { pBC: LPBC, pBSCb: PTR(uint) } ],
  GetClassFileOrMime: [ HRESULT, { pBC: LPBC, szFilename: LPCWSTR, pBuffer: LPVOID, cbSize: DWORD, szMime: LPCWSTR, dwReserved: DWORD, pclsid: PTR(uint) } ],
  IsValidURL: [ HRESULT, { pBC: LPBC, szURL: LPCWSTR, dwReserved: DWORD } ],
  CoGetClassObjectFromURL: [ HRESULT, { rCLASSID: PTR(uint), szCODE: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, szTYPE: LPCWSTR, pBindCtx: LPBINDCTX, dwClsContext: DWORD, pvReserved: LPVOID, riid: PTR(uint), ppv: PTR(PTR(VOID)) } ],
  IEInstallScope: [ HRESULT, { pdwScope: LPDWORD } ],
  FaultInIEFeature: [ HRESULT, { hWnd: HWND, pClassSpec: PTR(uint), pQuery: PTR(uint), dwFlags: DWORD } ],
  GetComponentIDFromCLSSPEC: [ HRESULT, { pClassspec: PTR(uint), ppszComponentID: PTR(PTR(int8)) } ],
  IsAsyncMoniker: [ HRESULT, { pmk: PTR(uint) } ],
  CreateURLBinding: [ HRESULT, { lpszUrl: LPCWSTR, pbc: PTR(uint), ppBdg: PTR(PTR(uint)) } ],
  RegisterMediaTypes: [ HRESULT, { ctypes: UINT, rgszTypes: PTR(PTR(int8)), rgcfTypes: PTR(ushort) } ],
  FindMediaType: [ HRESULT, { rgszTypes: LPCSTR, rgcfTypes: PTR(ushort) } ],
  CreateFormatEnumerator: [ HRESULT, { cfmtetc: UINT, rgfmtetc: PTR(uint), ppenumfmtetc: PTR(PTR(uint)) } ],
  RegisterFormatEnumerator: [ HRESULT, { pBC: LPBC, pEFetc: PTR(uint), reserved: DWORD } ],
  RevokeFormatEnumerator: [ HRESULT, { pBC: LPBC, pEFetc: PTR(uint) } ],
  RegisterMediaTypeClass: [ HRESULT, { pBC: LPBC, ctypes: UINT, rgszTypes: PTR(PTR(int8)), rgclsID: PTR(uint), reserved: DWORD } ],
  FindMediaTypeClass: [ HRESULT, { pBC: LPBC, szType: LPCSTR, pclsID: PTR(uint), reserved: DWORD } ],
  UrlMkSetSessionOption: [ HRESULT, { dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, dwReserved: DWORD } ],
  UrlMkGetSessionOption: [ HRESULT, { dwOption: DWORD, pBuffer: LPVOID, dwBufferLength: DWORD, pdwBufferLengthOut: PTR(ulong), dwReserved: DWORD } ],
  FindMimeFromData: [ HRESULT, { pBC: LPBC, pwzUrl: LPCWSTR, pBuffer: LPVOID, cbSize: DWORD, pwzMimeProposed: LPCWSTR, dwMimeFlags: DWORD, ppwzMimeOut: PTR(PTR(ushort)), dwReserved: DWORD } ],
  ObtainUserAgentString: [ HRESULT, { dwOption: DWORD, pszUAOut: LPSTR, cbSize: PTR(ulong) } ],
  CompareSecurityIds: [ HRESULT, { pbSecurityId1: PTR(uchar), dwLen1: DWORD, pbSecurityId2: PTR(uchar), dwLen2: DWORD, dwReserved: DWORD } ],
  CompatFlagsFromClsid: [ HRESULT, { pclsid: PTR(uint), pdwCompatFlags: LPDWORD, pdwMiscStatusFlags: LPDWORD } ],
  IBinding_RemoteGetBindResult_Proxy: [ HRESULT, { This: PTR(uint), pclsidProtocol: PTR(uint), pdwResult: PTR(ulong), pszResult: PTR(PTR(ushort)), dwReserved: DWORD } ],
  IBinding_RemoteGetBindResult_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindStatusCallback_RemoteGetBindInfo_Proxy: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint), pstgmed: PTR(uint) } ],
  IBindStatusCallback_RemoteGetBindInfo_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindStatusCallback_RemoteOnDataAvailable_Proxy: [ HRESULT, { This: PTR(uint), grfBSCF: DWORD, dwSize: DWORD, pformatetc: PTR(uint), pstgmed: PTR(uint) } ],
  IBindStatusCallback_RemoteOnDataAvailable_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindStatusCallbackEx_RemoteGetBindInfoEx_Proxy: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint), pstgmed: PTR(uint), grfBINDF2: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IBindStatusCallbackEx_RemoteGetBindInfoEx_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  CreateUri: [ HRESULT, { pwzURI: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR, ppURI: PTR(PTR(uint)) } ],
  CreateUriWithFragment: [ HRESULT, { pwzURI: LPCWSTR, pwzFragment: LPCWSTR, dwFlags: DWORD, dwReserved: DWORD_PTR, ppURI: PTR(PTR(uint)) } ],
  CreateUriFromMultiByteString: [ HRESULT, { pszANSIInputUri: LPCSTR, dwEncodingFlags: DWORD, dwCodePage: DWORD, dwCreateFlags: DWORD, dwReserved: DWORD_PTR, ppUri: PTR(PTR(uint)) } ],
  CreateIUriBuilder: [ HRESULT, { pIUri: PTR(uint), dwFlags: DWORD, dwReserved: DWORD_PTR, ppIUriBuilder: PTR(PTR(uint)) } ],
  IWinInetInfo_RemoteQueryOption_Proxy: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: PTR(uchar), pcbBuf: PTR(ulong) } ],
  IWinInetInfo_RemoteQueryOption_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IWinInetHttpInfo_RemoteQueryInfo_Proxy: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: PTR(uchar), pcbBuf: PTR(ulong), pdwFlags: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IWinInetHttpInfo_RemoteQueryInfo_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindHost_RemoteMonikerBindToStorage_Proxy: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IBindHost_RemoteMonikerBindToStorage_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IBindHost_RemoteMonikerBindToObject_Proxy: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IBindHost_RemoteMonikerBindToObject_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  HlinkSimpleNavigateToString: [ HRESULT, { szTarget: LPCWSTR, szLocation: LPCWSTR, szTargetFrameName: LPCWSTR, pUnk: PTR(uint), pbc: PTR(uint), PTR(uint): PTR(uint), grfHLNF: DWORD, dwReserved: DWORD } ],
  HlinkSimpleNavigateToMoniker: [ HRESULT, { pmkTarget: PTR(uint), szLocation: LPCWSTR, szTargetFrameName: LPCWSTR, pUnk: PTR(uint), pbc: PTR(uint), PTR(uint): PTR(uint), grfHLNF: DWORD, dwReserved: DWORD } ],
  URLOpenStreamA: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLOpenStreamW: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLOpenPullStreamA: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLOpenPullStreamW: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLDownloadToFileA: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLDownloadToFileW: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLDownloadToCacheFileA: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK, cchFileName: DWORD } ],
  URLDownloadToCacheFileW: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK, cchFileName: DWORD } ],
  URLOpenBlockingStreamA: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  URLOpenBlockingStreamW: [ HRESULT, { LPBINDSTATUSCALLBACK: LPBINDSTATUSCALLBACK } ],
  HlinkGoBack: [ HRESULT, { pUnk: PTR(uint) } ],
  HlinkGoForward: [ HRESULT, { pUnk: PTR(uint) } ],
  HlinkNavigateString: [ HRESULT, { pUnk: PTR(uint), szTarget: LPCWSTR } ],
  HlinkNavigateMoniker: [ HRESULT, { pUnk: PTR(uint), pmkTarget: PTR(uint) } ],
  CoInternetParseUrl: [ HRESULT, { pwzUrl: LPCWSTR, ParseAction: PARSEACTION, dwFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: PTR(ulong), dwReserved: DWORD } ],
  CoInternetParseIUri: [ HRESULT, { pIUri: PTR(uint), ParseAction: PARSEACTION, dwFlags: DWORD, pwzResult: LPWSTR, cchResult: DWORD, pcchResult: PTR(ulong), dwReserved: DWORD_PTR } ],
  CoInternetCombineUrl: [ HRESULT, { pwzBaseUrl: LPCWSTR, pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, pszResult: LPWSTR, cchResult: DWORD, pcchResult: PTR(ulong), dwReserved: DWORD } ],
  CoInternetCombineUrlEx: [ HRESULT, { pBaseUri: PTR(uint), pwzRelativeUrl: LPCWSTR, dwCombineFlags: DWORD, ppCombinedUri: PTR(PTR(uint)), dwReserved: DWORD_PTR } ],
  CoInternetCombineIUri: [ HRESULT, { pBaseUri: PTR(uint), pRelativeUri: PTR(uint), dwCombineFlags: DWORD, ppCombinedUri: PTR(PTR(uint)), dwReserved: DWORD_PTR } ],
  CoInternetCompareUrl: [ HRESULT, { pwzUrl1: LPCWSTR, pwzUrl2: LPCWSTR, dwFlags: DWORD } ],
  CoInternetGetProtocolFlags: [ HRESULT, { pwzUrl: LPCWSTR, pdwFlags: PTR(ulong), dwReserved: DWORD } ],
  CoInternetQueryInfo: [ HRESULT, { pwzUrl: LPCWSTR, QueryOptions: QUERYOPTION, dwQueryFlags: DWORD, pvBuffer: LPVOID, cbBuffer: DWORD, pcbBuffer: PTR(ulong), dwReserved: DWORD } ],
  CoInternetGetSession: [ HRESULT, { dwSessionMode: DWORD, ppIInternetSession: PTR(PTR(uint)), dwReserved: DWORD } ],
  CoInternetGetSecurityUrl: [ HRESULT, { pwszUrl: LPCWSTR, ppwszSecUrl: PTR(PTR(ushort)), psuAction: PSUACTION, dwReserved: DWORD } ],
  AsyncInstallDistributionUnit: [ HRESULT, { szDistUnit: LPCWSTR, szTYPE: LPCWSTR, szExt: LPCWSTR, dwFileVersionMS: DWORD, dwFileVersionLS: DWORD, szURL: LPCWSTR, pbc: PTR(uint), pvReserved: LPVOID, flags: DWORD } ],
  CoInternetGetSecurityUrlEx: [ HRESULT, { pUri: PTR(uint), ppSecUri: PTR(PTR(uint)), psuAction: PSUACTION, dwReserved: DWORD_PTR } ],
  CoInternetSetFeatureEnabled: [ HRESULT, { FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, fEnable: BOOL } ],
  CoInternetIsFeatureEnabled: [ HRESULT, { FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD } ],
  CoInternetIsFeatureEnabledForUrl: [ HRESULT, { FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, szURL: LPCWSTR, pSecMgr: PTR(uint) } ],
  CoInternetIsFeatureEnabledForIUri: [ HRESULT, { FeatureEntry: INTERNETFEATURELIST, dwFlags: DWORD, pIUri: PTR(uint), pSecMgr: PTR(uint) } ],
  CoInternetIsFeatureZoneElevationEnabled: [ HRESULT, { szFromURL: LPCWSTR, szToURL: LPCWSTR, pSecMgr: PTR(uint), dwFlags: DWORD } ],
  CopyStgMedium: [ HRESULT, { pcstgmedSrc: PTR(uint), pstgmedDest: PTR(uint) } ],
  CopyBindInfo: [ HRESULT, { pcbiSrc: PTR(uint), pbiDest: PTR(uint) } ],
  ReleaseBindInfo: [ VOID, { pbindinfo: PTR(uint) } ],
  CoInternetCreateSecurityManager: [ HRESULT, { pSP: PTR(uint), ppSM: PTR(PTR(uint)), dwReserved: DWORD } ],
  CoInternetCreateZoneManager: [ HRESULT, { pSP: PTR(uint), ppZM: PTR(PTR(uint)), dwReserved: DWORD } ],
  GetSoftwareUpdateInfo: [ HRESULT, { szDistUnit: LPCWSTR, psdi: LPSOFTDISTINFO } ],
  SetSoftwareUpdateAdvertisementState: [ HRESULT, { szDistUnit: LPCWSTR, dwAdState: DWORD, dwAdvertisedVersionMS: DWORD, dwAdvertisedVersionLS: DWORD } ],
  IsLoggingEnabledA: [ BOOL, { pszUrl: LPCSTR } ],
  IsLoggingEnabledW: [ BOOL, { pwszUrl: LPCWSTR } ],
  WriteHitLogging: [ BOOL, { lpLogginginfo: LPHIT_LOGGING_INFO } ],
  IBinding_GetBindResult_Proxy: [ HRESULT, { This: PTR(uint), pclsidProtocol: PTR(uint), pdwResult: PTR(ulong), pszResult: PTR(PTR(ushort)), pdwReserved: PTR(ulong) } ],
  IBinding_GetBindResult_Stub: [ HRESULT, { This: PTR(uint), pclsidProtocol: PTR(uint), pdwResult: PTR(ulong), pszResult: PTR(PTR(ushort)), dwReserved: DWORD } ],
  IBindStatusCallback_GetBindInfo_Proxy: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint) } ],
  IBindStatusCallback_GetBindInfo_Stub: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint), pstgmed: PTR(uint) } ],
  IBindStatusCallback_OnDataAvailable_Proxy: [ HRESULT, { This: PTR(uint), grfBSCF: DWORD, dwSize: DWORD, pformatetc: PTR(uint), pstgmed: PTR(uint) } ],
  IBindStatusCallback_OnDataAvailable_Stub: [ HRESULT, { This: PTR(uint), grfBSCF: DWORD, dwSize: DWORD, pformatetc: PTR(uint), pstgmed: PTR(uint) } ],
  IBindStatusCallbackEx_GetBindInfoEx_Proxy: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint), grfBINDF2: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IBindStatusCallbackEx_GetBindInfoEx_Stub: [ HRESULT, { This: PTR(uint), grfBINDF: PTR(ulong), pbindinfo: PTR(uint), pstgmed: PTR(uint), grfBINDF2: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IWinInetInfo_QueryOption_Proxy: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: LPVOID, pcbBuf: PTR(ulong) } ],
  IWinInetInfo_QueryOption_Stub: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: PTR(uchar), pcbBuf: PTR(ulong) } ],
  IWinInetHttpInfo_QueryInfo_Proxy: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: LPVOID, pcbBuf: PTR(ulong), pdwFlags: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IWinInetHttpInfo_QueryInfo_Stub: [ HRESULT, { This: PTR(uint), dwOption: DWORD, pBuffer: PTR(uchar), pcbBuf: PTR(ulong), pdwFlags: PTR(ulong), pdwReserved: PTR(ulong) } ],
  IBindHost_MonikerBindToStorage_Proxy: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(VOID)) } ],
  IBindHost_MonikerBindToStorage_Stub: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IBindHost_MonikerBindToObject_Proxy: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(VOID)) } ],
  IBindHost_MonikerBindToObject_Stub: [ HRESULT, { This: PTR(uint), pMk: PTR(uint), pBC: PTR(uint), pBSC: PTR(uint), riid: PTR(uint), ppvObj: PTR(PTR(uint)) } ],
  IEnumSTATPROPSTG_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATPROPSTG_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  IEnumSTATPROPSETSTG_RemoteNext_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATPROPSETSTG_RemoteNext_Stub: [ VOID, { This: PTR(uint), _pRpcChannelBuffer: PTR(uint), _pRpcMessage: PRPC_MESSAGE, _pdwStubPhase: PTR(ulong) } ],
  PropVariantCopy: [ HRESULT, { pvarDest: PTR(uint), pvarSrc: PTR(uint) } ],
  PropVariantClear: [ HRESULT, { pvar: PTR(uint) } ],
  FreePropVariantArray: [ HRESULT, { cVariants: ULONG, rgvars: PTR(uint) } ],
  StgCreatePropStg: [ HRESULT, { pUnk: PTR(uint), fmtid: PTR(uint), pclsid: PTR(uint), grfFlags: DWORD, dwReserved: DWORD, ppPropStg: PTR(PTR(uint)) } ],
  StgOpenPropStg: [ HRESULT, { pUnk: PTR(uint), fmtid: PTR(uint), grfFlags: DWORD, dwReserved: DWORD, ppPropStg: PTR(PTR(uint)) } ],
  StgCreatePropSetStg: [ HRESULT, { pStorage: PTR(uint), dwReserved: DWORD, ppPropSetStg: PTR(PTR(uint)) } ],
  FmtIdToPropStgName: [ HRESULT, { pfmtid: PTR(uint), oszName: LPOLESTR } ],
  PropStgNameToFmtId: [ HRESULT, { oszName: LPOLESTR, pfmtid: PTR(uint) } ],
  StgConvertVariantToProperty: [ SERIALIZEDPROPERTYVALUE, { pvar: PTR(uint), CodePage: USHORT, pprop: PTR(uint), pcb: PTR(ulong), pid: PROPID, fReserved: BOOLEAN, pcIndirect: PTR(ulong) } ],
  LPSAFEARRAY_UserSize: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserMarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserUnmarshal: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserFree: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserSize64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserMarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserUnmarshal64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  LPSAFEARRAY_UserFree64: [ VOID, { PTR(VOIDPTR): PTR(VOIDPTR) } ],
  IEnumSTATPROPSTG_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATPROPSTG_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATPROPSETSTG_Next_Proxy: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  IEnumSTATPROPSETSTG_Next_Stub: [ HRESULT, { This: PTR(uint), celt: ULONG, rgelt: PTR(uint), pceltFetched: PTR(ulong) } ],
  CreateStdProgressIndicator: [ HRESULT, { hwndParent: HWND, pszTitle: LPCOLESTR, pIbscCaller: PTR(uint), ppIbsc: PTR(PTR(uint)) } ],
  SysAllocString: [ BSTR, { psz: PTR(ushort) } ],
  SysReAllocString: [ INT, { pbstr: PTR(PTR(ushort)), psz: PTR(ushort) } ],
  SysAllocStringLen: [ BSTR, { strIn: PTR(ushort), ui: UINT } ],
  SysReAllocStringLen: [ INT, { pbstr: PTR(PTR(ushort)), psz: PTR(ushort), len: uint } ],
  SysFreeString: [ VOID, { bstrString: BSTR } ],
  SysStringLen: [ UINT, { BSTR: BSTR } ],
  SysStringByteLen: [ UINT, { bstr: BSTR } ],
  SysAllocStringByteLen: [ BSTR, { psz: LPCSTR, len: UINT } ],
  DosDateTimeToVariantTime: [ INT, { wDosDate: USHORT, wDosTime: USHORT, pvtime: PTR(double) } ],
  VariantTimeToDosDateTime: [ INT, { vtime: DOUBLE, pwDosDate: PTR(ushort), pwDosTime: PTR(ushort) } ],
  SystemTimeToVariantTime: [ INT, { lpSystemTime: LPSYSTEMTIME, pvtime: PTR(double) } ],
  VariantTimeToSystemTime: [ INT, { vtime: DOUBLE, lpSystemTime: LPSYSTEMTIME } ],
  SafeArrayAllocDescriptor: [ HRESULT, { cDims: UINT, ppsaOut: PTR(PTR(uint)) } ],
  SafeArrayAllocDescriptorEx: [ HRESULT, { vt: VARTYPE, cDims: UINT, ppsaOut: PTR(PTR(uint)) } ],
  SafeArrayAllocData: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayCreate: [ SAFEARRAY, { vt: VARTYPE, cDims: UINT, rgsabound: PTR(uint) } ],
  SafeArrayCreateEx: [ SAFEARRAY, { vt: VARTYPE, cDims: UINT, rgsabound: PTR(uint), pvExtra: PVOID } ],
  SafeArrayCopyData: [ HRESULT, { psaSource: PTR(uint), psaTarget: PTR(uint) } ],
  SafeArrayDestroyDescriptor: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayDestroyData: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayDestroy: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayRedim: [ HRESULT, { psa: PTR(uint), psaboundNew: PTR(uint) } ],
  SafeArrayGetDim: [ UINT, { psa: PTR(uint) } ],
  SafeArrayGetElemsize: [ UINT, { psa: PTR(uint) } ],
  SafeArrayGetUBound: [ HRESULT, { psa: PTR(uint), nDim: UINT, plUbound: PTR(long) } ],
  SafeArrayGetLBound: [ HRESULT, { psa: PTR(uint), nDim: UINT, plLbound: PTR(long) } ],
  SafeArrayLock: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayUnlock: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayAccessData: [ HRESULT, { psa: PTR(uint), ppvData: PTR(PTR(VOID)) } ],
  SafeArrayUnaccessData: [ HRESULT, { psa: PTR(uint) } ],
  SafeArrayGetElement: [ HRESULT, { psa: PTR(uint), rgIndices: PTR(long), pv: PTR(VOID) } ],
  SafeArrayPutElement: [ HRESULT, { psa: PTR(uint), rgIndices: PTR(long), pv: PTR(VOID) } ],
  SafeArrayCopy: [ HRESULT, { psa: PTR(uint), ppsaOut: PTR(PTR(uint)) } ],
  SafeArrayPtrOfIndex: [ HRESULT, { psa: PTR(uint), rgIndices: PTR(long), ppvData: PTR(PTR(VOID)) } ],
  SafeArraySetRecordInfo: [ HRESULT, { psa: PTR(uint), prinfo: PTR(uint) } ],
  SafeArrayGetRecordInfo: [ HRESULT, { psa: PTR(uint), prinfo: PTR(PTR(uint)) } ],
  SafeArraySetIID: [ HRESULT, { psa: PTR(uint), guid: PTR(uint) } ],
  SafeArrayGetIID: [ HRESULT, { psa: PTR(uint), pguid: PTR(uint) } ],
  SafeArrayGetVartype: [ HRESULT, { psa: PTR(uint), pvt: PTR(ushort) } ],
  SafeArrayCreateVector: [ SAFEARRAY, { vt: VARTYPE, lLbound: LONG, cElements: ULONG } ],
  SafeArrayCreateVectorEx: [ SAFEARRAY, { vt: VARTYPE, lLbound: LONG, cElements: ULONG, pvExtra: PVOID } ],
  VariantInit: [ VOID, { pvarg: PTR(uint) } ],
  VariantClear: [ HRESULT, { pvarg: PTR(uint) } ],
  VariantCopy: [ HRESULT, { pvargDest: PTR(uint), pvargSrc: PTR(uint) } ],
  VariantCopyInd: [ HRESULT, { pvarDest: PTR(uint), pvargSrc: PTR(uint) } ],
  VariantChangeType: [ HRESULT, { pvargDest: PTR(uint), pvarSrc: PTR(uint), wFlags: USHORT, vt: VARTYPE } ],
  VariantChangeTypeEx: [ HRESULT, { pvargDest: PTR(uint), pvarSrc: PTR(uint), lcid: LCID, wFlags: USHORT, vt: VARTYPE } ],
  VectorFromBstr: [ HRESULT, { bstr: BSTR, ppsa: PTR(PTR(uint)) } ],
  BstrFromVector: [ HRESULT, { psa: PTR(uint), pbstr: PTR(PTR(ushort)) } ],
  VarUI1FromI2: [ HRESULT, { sIn: SHORT, pbOut: PTR(uchar) } ],
  VarUI1FromI4: [ HRESULT, { lIn: LONG, pbOut: PTR(uchar) } ],
  VarUI1FromI8: [ HRESULT, { i64In: LONG64, pbOut: PTR(uchar) } ],
  VarUI1FromR4: [ HRESULT, { fltIn: FLOAT, pbOut: PTR(uchar) } ],
  VarUI1FromR8: [ HRESULT, { dblIn: DOUBLE, pbOut: PTR(uchar) } ],
  VarUI1FromCy: [ HRESULT, { cyIn: CY, pbOut: PTR(uchar) } ],
  VarUI1FromDate: [ HRESULT, { dateIn: DATE, pbOut: PTR(uchar) } ],
  VarUI1FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pbOut: PTR(uchar) } ],
  VarUI1FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pbOut: PTR(uchar) } ],
  VarUI1FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pbOut: PTR(uchar) } ],
  VarUI1FromI1: [ HRESULT, { cIn: CHAR, pbOut: PTR(uchar) } ],
  VarUI1FromUI2: [ HRESULT, { uiIn: USHORT, pbOut: PTR(uchar) } ],
  VarUI1FromUI4: [ HRESULT, { ulIn: ULONG, pbOut: PTR(uchar) } ],
  VarUI1FromUI8: [ HRESULT, { ui64In: ULONG64, pbOut: PTR(uchar) } ],
  VarUI1FromDec: [ HRESULT, { pdecIn: PTR(uint), pbOut: PTR(uchar) } ],
  VarI2FromUI1: [ HRESULT, { bIn: BYTE, psOut: PTR(short) } ],
  VarI2FromI4: [ HRESULT, { lIn: LONG, psOut: PTR(short) } ],
  VarI2FromI8: [ HRESULT, { i64In: LONG64, psOut: PTR(short) } ],
  VarI2FromR4: [ HRESULT, { fltIn: FLOAT, psOut: PTR(short) } ],
  VarI2FromR8: [ HRESULT, { dblIn: DOUBLE, psOut: PTR(short) } ],
  VarI2FromCy: [ HRESULT, { cyIn: CY, psOut: PTR(short) } ],
  VarI2FromDate: [ HRESULT, { dateIn: DATE, psOut: PTR(short) } ],
  VarI2FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, psOut: PTR(short) } ],
  VarI2FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, psOut: PTR(short) } ],
  VarI2FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, psOut: PTR(short) } ],
  VarI2FromI1: [ HRESULT, { cIn: CHAR, psOut: PTR(short) } ],
  VarI2FromUI2: [ HRESULT, { uiIn: USHORT, psOut: PTR(short) } ],
  VarI2FromUI4: [ HRESULT, { ulIn: ULONG, psOut: PTR(short) } ],
  VarI2FromUI8: [ HRESULT, { ui64In: ULONG64, psOut: PTR(short) } ],
  VarI2FromDec: [ HRESULT, { pdecIn: PTR(uint), psOut: PTR(short) } ],
  VarI4FromUI1: [ HRESULT, { bIn: BYTE, plOut: PTR(long) } ],
  VarI4FromI2: [ HRESULT, { sIn: SHORT, plOut: PTR(long) } ],
  VarI4FromI8: [ HRESULT, { i64In: LONG64, plOut: PTR(long) } ],
  VarI4FromR4: [ HRESULT, { fltIn: FLOAT, plOut: PTR(long) } ],
  VarI4FromR8: [ HRESULT, { dblIn: DOUBLE, plOut: PTR(long) } ],
  VarI4FromCy: [ HRESULT, { cyIn: CY, plOut: PTR(long) } ],
  VarI4FromDate: [ HRESULT, { dateIn: DATE, plOut: PTR(long) } ],
  VarI4FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, plOut: PTR(long) } ],
  VarI4FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, plOut: PTR(long) } ],
  VarI4FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, plOut: PTR(long) } ],
  VarI4FromI1: [ HRESULT, { cIn: CHAR, plOut: PTR(long) } ],
  VarI4FromUI2: [ HRESULT, { uiIn: USHORT, plOut: PTR(long) } ],
  VarI4FromUI4: [ HRESULT, { ulIn: ULONG, plOut: PTR(long) } ],
  VarI4FromUI8: [ HRESULT, { ui64In: ULONG64, plOut: PTR(long) } ],
  VarI4FromDec: [ HRESULT, { pdecIn: PTR(uint), plOut: PTR(long) } ],
  VarI4FromInt: [ HRESULT, { intIn: INT, plOut: PTR(long) } ],
  VarI8FromUI1: [ HRESULT, { bIn: BYTE, pi64Out: PTR(longlong) } ],
  VarI8FromI2: [ HRESULT, { sIn: SHORT, pi64Out: PTR(longlong) } ],
  VarI8FromI4: [ HRESULT, { lIn: LONG, pi64Out: PTR(longlong) } ],
  VarI8FromR4: [ HRESULT, { fltIn: FLOAT, pi64Out: PTR(longlong) } ],
  VarI8FromR8: [ HRESULT, { dblIn: DOUBLE, pi64Out: PTR(longlong) } ],
  VarI8FromCy: [ HRESULT, { cyIn: CY, pi64Out: PTR(longlong) } ],
  VarI8FromDate: [ HRESULT, { dateIn: DATE, pi64Out: PTR(longlong) } ],
  VarI8FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ulong, pi64Out: PTR(longlong) } ],
  VarI8FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pi64Out: PTR(longlong) } ],
  VarI8FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pi64Out: PTR(longlong) } ],
  VarI8FromI1: [ HRESULT, { cIn: CHAR, pi64Out: PTR(longlong) } ],
  VarI8FromUI2: [ HRESULT, { uiIn: USHORT, pi64Out: PTR(longlong) } ],
  VarI8FromUI4: [ HRESULT, { ulIn: ULONG, pi64Out: PTR(longlong) } ],
  VarI8FromUI8: [ HRESULT, { ui64In: ULONG64, pi64Out: PTR(longlong) } ],
  VarI8FromDec: [ HRESULT, { pdecIn: PTR(uint), pi64Out: PTR(longlong) } ],
  VarI8FromInt: [ HRESULT, { intIn: INT, pi64Out: PTR(longlong) } ],
  VarR4FromUI1: [ HRESULT, { bIn: BYTE, pfltOut: PTR(float) } ],
  VarR4FromI2: [ HRESULT, { sIn: SHORT, pfltOut: PTR(float) } ],
  VarR4FromI4: [ HRESULT, { lIn: LONG, pfltOut: PTR(float) } ],
  VarR4FromI8: [ HRESULT, { i64In: LONG64, pfltOut: PTR(float) } ],
  VarR4FromR8: [ HRESULT, { dblIn: DOUBLE, pfltOut: PTR(float) } ],
  VarR4FromCy: [ HRESULT, { cyIn: CY, pfltOut: PTR(float) } ],
  VarR4FromDate: [ HRESULT, { dateIn: DATE, pfltOut: PTR(float) } ],
  VarR4FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pfltOut: PTR(float) } ],
  VarR4FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pfltOut: PTR(float) } ],
  VarR4FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pfltOut: PTR(float) } ],
  VarR4FromI1: [ HRESULT, { cIn: CHAR, pfltOut: PTR(float) } ],
  VarR4FromUI2: [ HRESULT, { uiIn: USHORT, pfltOut: PTR(float) } ],
  VarR4FromUI4: [ HRESULT, { ulIn: ULONG, pfltOut: PTR(float) } ],
  VarR4FromUI8: [ HRESULT, { ui64In: ULONG64, pfltOut: PTR(float) } ],
  VarR4FromDec: [ HRESULT, { pdecIn: PTR(uint), pfltOut: PTR(float) } ],
  VarR8FromUI1: [ HRESULT, { bIn: BYTE, pdblOut: PTR(double) } ],
  VarR8FromI2: [ HRESULT, { sIn: SHORT, pdblOut: PTR(double) } ],
  VarR8FromI4: [ HRESULT, { lIn: LONG, pdblOut: PTR(double) } ],
  VarR8FromI8: [ HRESULT, { i64In: LONG64, pdblOut: PTR(double) } ],
  VarR8FromR4: [ HRESULT, { fltIn: FLOAT, pdblOut: PTR(double) } ],
  VarR8FromCy: [ HRESULT, { cyIn: CY, pdblOut: PTR(double) } ],
  VarR8FromDate: [ HRESULT, { dateIn: DATE, pdblOut: PTR(double) } ],
  VarR8FromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pdblOut: PTR(double) } ],
  VarR8FromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pdblOut: PTR(double) } ],
  VarR8FromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pdblOut: PTR(double) } ],
  VarR8FromI1: [ HRESULT, { cIn: CHAR, pdblOut: PTR(double) } ],
  VarR8FromUI2: [ HRESULT, { uiIn: USHORT, pdblOut: PTR(double) } ],
  VarR8FromUI4: [ HRESULT, { ulIn: ULONG, pdblOut: PTR(double) } ],
  VarR8FromUI8: [ HRESULT, { ui64In: ULONG64, pdblOut: PTR(double) } ],
  VarR8FromDec: [ HRESULT, { pdecIn: PTR(uint), pdblOut: PTR(double) } ],
  VarDateFromUI1: [ HRESULT, { bIn: BYTE, pdateOut: PTR(double) } ],
  VarDateFromI2: [ HRESULT, { sIn: SHORT, pdateOut: PTR(double) } ],
  VarDateFromI4: [ HRESULT, { lIn: LONG, pdateOut: PTR(double) } ],
  VarDateFromI8: [ HRESULT, { i64In: LONG64, pdateOut: PTR(double) } ],
  VarDateFromR4: [ HRESULT, { fltIn: FLOAT, pdateOut: PTR(double) } ],
  VarDateFromR8: [ HRESULT, { dblIn: DOUBLE, pdateOut: PTR(double) } ],
  VarDateFromCy: [ HRESULT, { cyIn: CY, pdateOut: PTR(double) } ],
  VarDateFromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pdateOut: PTR(double) } ],
  VarDateFromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pdateOut: PTR(double) } ],
  VarDateFromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pdateOut: PTR(double) } ],
  VarDateFromI1: [ HRESULT, { cIn: CHAR, pdateOut: PTR(double) } ],
  VarDateFromUI2: [ HRESULT, { uiIn: USHORT, pdateOut: PTR(double) } ],
  VarDateFromUI4: [ HRESULT, { ulIn: ULONG, pdateOut: PTR(double) } ],
  VarDateFromUI8: [ HRESULT, { ui64In: ULONG64, pdateOut: PTR(double) } ],
  VarDateFromDec: [ HRESULT, { pdecIn: PTR(uint), pdateOut: PTR(double) } ],
  VarCyFromUI1: [ HRESULT, { bIn: BYTE, pcyOut: PTR(uint) } ],
  VarCyFromI2: [ HRESULT, { sIn: SHORT, pcyOut: PTR(uint) } ],
  VarCyFromI4: [ HRESULT, { lIn: LONG, pcyOut: PTR(uint) } ],
  VarCyFromI8: [ HRESULT, { i64In: LONG64, pcyOut: PTR(uint) } ],
  VarCyFromR4: [ HRESULT, { fltIn: FLOAT, pcyOut: PTR(uint) } ],
  VarCyFromR8: [ HRESULT, { dblIn: DOUBLE, pcyOut: PTR(uint) } ],
  VarCyFromDate: [ HRESULT, { dateIn: DATE, pcyOut: PTR(uint) } ],
  VarCyFromStr: [ HRESULT, { strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pcyOut: PTR(uint) } ],
  VarCyFromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, pcyOut: PTR(uint) } ],
  VarCyFromBool: [ HRESULT, { boolIn: VARIANT_BOOL, pcyOut: PTR(uint) } ],
  VarCyFromI1: [ HRESULT, { cIn: CHAR, pcyOut: PTR(uint) } ],
  VarCyFromUI2: [ HRESULT, { uiIn: USHORT, pcyOut: PTR(uint) } ],
  VarCyFromUI4: [ HRESULT, { ulIn: ULONG, pcyOut: PTR(uint) } ],
  VarCyFromUI8: [ HRESULT, { ui64In: ULONG64, pcyOut: PTR(uint) } ],
  VarCyFromDec: [ HRESULT, { pdecIn: PTR(uint), pcyOut: PTR(uint) } ],
  VarBstrFromUI1: [ HRESULT, { bVal: BYTE, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromI2: [ HRESULT, { iVal: SHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromI4: [ HRESULT, { lIn: LONG, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromI8: [ HRESULT, { i64In: LONG64, lcid: LCID, dwFlags: ulong, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromR4: [ HRESULT, { fltIn: FLOAT, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromR8: [ HRESULT, { dblIn: DOUBLE, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromCy: [ HRESULT, { cyIn: CY, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromDate: [ HRESULT, { dateIn: DATE, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromDisp: [ HRESULT, { pdispIn: PTR(uint), lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromBool: [ HRESULT, { boolIn: VARIANT_BOOL, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromI1: [ HRESULT, { cIn: CHAR, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromUI2: [ HRESULT, { uiIn: USHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromUI4: [ HRESULT, { ulIn: ULONG, lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromUI8: [ HRESULT, { ui64In: ULONG64, lcid: LCID, dwFlags: ulong, pbstrOut: PTR(PTR(ushort)) } ],
  VarBstrFromDec: [ HRESULT, { pdecIn: PTR(uint), lcid: LCID, dwFlags: ULONG, pbstrOut: PTR(PTR(ushort)) } ],
  VarBoolFromUI1: [ HRESULT, { bIn: BYTE, pboolOut: PTR(short) } ],
  VarBoolFromI2: [ HRESULT, { sIn: SHORT, pboolOut: PTR(short) } ],
  VarBoolFromI4: [ HRESULT, { lIn: LONG, pboolOut: PTR(short) } ],
  VarBoolFromI8: [ HRESULT, { i64In: LONG64, pboolOut: PTR(short) } ],
  VarBoolFromR4: [ HRESULT, { fltIn: FLOAT, pboolOut: PTR(short) } ],
  VarBoolFromR8: [ HRESULT, { dblIn: DOUBLE, pboolOut: PTR(short) } ],
  VarBoolFro