Win Apis

typedef DWORD(__stdcall* GetEffectiveRightsFromAclA)(PACL pacl, PTRUSTEE_A pTrustee, PACCESS_MASK pAccessRights);
typedef DWORD(__stdcall* GetEffectiveRightsFromAclW)(PACL pacl, PTRUSTEE_W pTrustee, PACCESS_MASK pAccessRights);
typedef DWORD(__stdcall* GetAuditedPermissionsFromAclA)(PACL pacl, PTRUSTEE_A pTrustee, PACCESS_MASK pSuccessfulAuditedRights, PACCESS_MASK pFailedAuditRights);
typedef DWORD(__stdcall* GetAuditedPermissionsFromAclW)(PACL pacl, PTRUSTEE_W pTrustee, PACCESS_MASK pSuccessfulAuditedRights, PACCESS_MASK pFailedAuditRights);
typedef DWORD(__stdcall* SetNamedSecurityInfoA)(LPSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl);
typedef DWORD(__stdcall* SetNamedSecurityInfoW)(LPWSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl);
typedef DWORD(__stdcall* SetSecurityInfo)(HANDLE handle, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl);
typedef DWORD(__stdcall* FreeInheritedFromArray)(PINHERITED_FROMW pInheritArray, USHORT AceCnt, PFN_OBJECT_MGR_FUNCTS pfnArray);
typedef DWORD(__stdcall* TreeResetNamedSecurityInfoA)(LPSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID pOwner, PSID pGroup, PACL pDacl, PACL pSacl, BOOL KeepExplicit, FN_PROGRESS fnProgress, PROG_INVOKE_SETTING ProgressInvokeSetting, PVOID Args);
typedef DWORD(__stdcall* TreeResetNamedSecurityInfoW)(LPWSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID pOwner, PSID pGroup, PACL pDacl, PACL pSacl, BOOL KeepExplicit, FN_PROGRESS fnProgress, PROG_INVOKE_SETTING ProgressInvokeSetting, PVOID Args);
typedef DWORD(__stdcall* TreeSetNamedSecurityInfoA)(LPSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID pOwner, PSID pGroup, PACL pDacl, PACL pSacl, DWORD dwAction, FN_PROGRESS fnProgress, PROG_INVOKE_SETTING ProgressInvokeSetting, PVOID Args);
typedef DWORD(__stdcall* TreeSetNamedSecurityInfoW)(LPWSTR pObjectName, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo, PSID pOwner, PSID pGroup, PACL pDacl, PACL pSacl, DWORD dwAction, FN_PROGRESS fnProgress, PROG_INVOKE_SETTING ProgressInvokeSetting, PVOID Args);
typedef void(__stdcall* BuildExplicitAccessWithNameA)(PEXPLICIT_ACCESS_A pExplicitAccess, LPSTR pTrusteeName, DWORD AccessPermissions, ACCESS_MODE AccessMode, DWORD Inheritance);
typedef void(__stdcall* BuildExplicitAccessWithNameW)(PEXPLICIT_ACCESS_W pExplicitAccess, LPWSTR pTrusteeName, DWORD AccessPermissions, ACCESS_MODE AccessMode, DWORD Inheritance);
typedef void(__stdcall* BuildTrusteeWithNameA)(PTRUSTEE_A pTrustee, LPSTR pName);
typedef void(__stdcall* BuildTrusteeWithNameW)(PTRUSTEE_W pTrustee, LPWSTR pName);
typedef void(__stdcall* BuildTrusteeWithSidA)(PTRUSTEE_A pTrustee, PSID pSid);
typedef void(__stdcall* BuildTrusteeWithSidW)(PTRUSTEE_W pTrustee, PSID pSid);
typedef void(__stdcall* BuildTrusteeWithObjectsAndNameA)(PTRUSTEE_A pTrustee, POBJECTS_AND_NAME_A pObjName, SE_OBJECT_TYPE ObjectType, LPSTR ObjectTypeName, LPSTR InheritedObjectTypeName, LPSTR Name);
typedef void(__stdcall* BuildTrusteeWithObjectsAndNameW)(PTRUSTEE_W pTrustee, POBJECTS_AND_NAME_W pObjName, SE_OBJECT_TYPE ObjectType, LPWSTR ObjectTypeName, LPWSTR InheritedObjectTypeName, LPWSTR Name);
typedef LPSTR(__stdcall* GetTrusteeNameA)(PTRUSTEE_A pTrustee);
typedef LPWSTR(__stdcall* GetTrusteeNameW)(PTRUSTEE_W pTrustee);
typedef TRUSTEE_TYPE(__stdcall* GetTrusteeTypeA)(PTRUSTEE_A pTrustee);
typedef TRUSTEE_TYPE(__stdcall* GetTrusteeTypeW)(PTRUSTEE_W pTrustee);
typedef TRUSTEE_FORM(__stdcall* GetTrusteeFormA)(PTRUSTEE_A pTrustee);
typedef TRUSTEE_FORM(__stdcall* GetTrusteeFormW)(PTRUSTEE_W pTrustee);
typedef HPROPSHEETPAGE(__stdcall* CreateSecurityPage)(LPSECURITYINFO psi);
typedef BOOL(__stdcall* EditSecurity)(HWND hwndOwner, LPSECURITYINFO psi);
typedef HRESULT(__stdcall* EditSecurityAdvanced)(HWND hwndOwner, LPSECURITYINFO psi, SI_PAGE_TYPE uSIPage);
typedef void(__stdcall* AmsiUninitialize)(HAMSICONTEXT amsiContext);
typedef void(__stdcall* AmsiCloseSession)(HAMSICONTEXT amsiContext, HAMSISESSION amsiSession);
typedef DWORD(__stdcall* InstallApplication)(PINSTALLDATA pInstallInfo);
typedef DWORD(__stdcall* UninstallApplication)(LPWSTR ProductCode, DWORD dwStatus);
typedef LONG(__stdcall* ClosePackageInfo)(PACKAGE_INFO_REFERENCE packageInfoReference);
typedef HRESULT(__stdcall* SetNetScheduleAccountInformation)(LPCWSTR pwszServerName, LPCWSTR pwszAccount, LPCWSTR pwszPassword);
typedef BOOL(__stdcall* AuthzCachedAccessCheck)(DWORD Flags, AUTHZ_ACCESS_CHECK_RESULTS_HANDLE hAccessCheckResults, PAUTHZ_ACCESS_REQUEST pRequest, AUTHZ_AUDIT_EVENT_HANDLE hAuditEvent, PAUTHZ_ACCESS_REPLY pReply);
typedef BOOL(__stdcall* AuthzFreeHandle)(AUTHZ_ACCESS_CHECK_RESULTS_HANDLE hAccessCheckResults);
typedef BOOL(__stdcall* AuthzInitializeResourceManager)(DWORD Flags, PFN_AUTHZ_DYNAMIC_ACCESS_CHECK pfnDynamicAccessCheck, PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS pfnComputeDynamicGroups, PFN_AUTHZ_FREE_DYNAMIC_GROUPS pfnFreeDynamicGroups, PCWSTR szResourceManagerName, PAUTHZ_RESOURCE_MANAGER_HANDLE phAuthzResourceManager);
typedef BOOL(__stdcall* AuthzInitializeResourceManagerEx)(DWORD Flags, PAUTHZ_INIT_INFO pAuthzInitInfo, PAUTHZ_RESOURCE_MANAGER_HANDLE phAuthzResourceManager);
typedef BOOL(__stdcall* AuthzInitializeRemoteResourceManager)(PAUTHZ_RPC_INIT_INFO_CLIENT pRpcInitInfo, PAUTHZ_RESOURCE_MANAGER_HANDLE phAuthzResourceManager);
typedef BOOL(__stdcall* AuthzFreeResourceManager)(AUTHZ_RESOURCE_MANAGER_HANDLE hAuthzResourceManager);
typedef BOOL(__stdcall* AuthzInitializeContextFromToken)(DWORD Flags, HANDLE TokenHandle, AUTHZ_RESOURCE_MANAGER_HANDLE hAuthzResourceManager, PLARGE_INTEGER pExpirationTime, LUID Identifier, PVOID DynamicGroupArgs, PAUTHZ_CLIENT_CONTEXT_HANDLE phAuthzClientContext);
typedef BOOL(__stdcall* AuthzInitializeContextFromSid)(DWORD Flags, PSID UserSid, AUTHZ_RESOURCE_MANAGER_HANDLE hAuthzResourceManager, PLARGE_INTEGER pExpirationTime, LUID Identifier, PVOID DynamicGroupArgs, PAUTHZ_CLIENT_CONTEXT_HANDLE phAuthzClientContext);
typedef BOOL(__stdcall* AuthzInitializeContextFromAuthzContext)(DWORD Flags, AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, PLARGE_INTEGER pExpirationTime, LUID Identifier, PVOID DynamicGroupArgs, PAUTHZ_CLIENT_CONTEXT_HANDLE phNewAuthzClientContext);
typedef BOOL(__stdcall* AuthzInitializeCompoundContext)(AUTHZ_CLIENT_CONTEXT_HANDLE UserContext, AUTHZ_CLIENT_CONTEXT_HANDLE DeviceContext, PAUTHZ_CLIENT_CONTEXT_HANDLE phCompoundContext);
typedef BOOL(__stdcall* AuthzAddSidsToContext)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, PSID_AND_ATTRIBUTES Sids, DWORD SidCount, PSID_AND_ATTRIBUTES RestrictedSids, DWORD RestrictedSidCount, PAUTHZ_CLIENT_CONTEXT_HANDLE phNewAuthzClientContext);
typedef BOOL(__stdcall* AuthzModifySecurityAttributes)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, PAUTHZ_SECURITY_ATTRIBUTE_OPERATION pOperations, PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION pAttributes);
typedef BOOL(__stdcall* AuthzModifyClaims)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, AUTHZ_CONTEXT_INFORMATION_CLASS ClaimClass, PAUTHZ_SECURITY_ATTRIBUTE_OPERATION pClaimOperations, PAUTHZ_SECURITY_ATTRIBUTES_INFORMATION pClaims);
typedef BOOL(__stdcall* AuthzModifySids)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, AUTHZ_CONTEXT_INFORMATION_CLASS SidClass, PAUTHZ_SID_OPERATION pSidOperations, PTOKEN_GROUPS pSids);
typedef BOOL(__stdcall* AuthzSetAppContainerInformation)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, PSID pAppContainerSid, DWORD CapabilityCount, PSID_AND_ATTRIBUTES pCapabilitySids);
typedef BOOL(__stdcall* AuthzGetInformationFromContext)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext, AUTHZ_CONTEXT_INFORMATION_CLASS InfoClass, DWORD BufferSize, PDWORD pSizeRequired, PVOID Buffer);
typedef BOOL(__stdcall* AuthzFreeContext)(AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext);
typedef BOOL(__stdcall* AuthzInitializeObjectAccessAuditEvent)(DWORD Flags, AUTHZ_AUDIT_EVENT_TYPE_HANDLE hAuditEventType, PWSTR szOperationType, PWSTR szObjectType, PWSTR szObjectName, PWSTR szAdditionalInfo, PAUTHZ_AUDIT_EVENT_HANDLE phAuditEvent, DWORD dwAdditionalParameterCount);
typedef BOOL(__stdcall* AuthzInitializeObjectAccessAuditEvent2)(DWORD Flags, AUTHZ_AUDIT_EVENT_TYPE_HANDLE hAuditEventType, PWSTR szOperationType, PWSTR szObjectType, PWSTR szObjectName, PWSTR szAdditionalInfo, PWSTR szAdditionalInfo2, PAUTHZ_AUDIT_EVENT_HANDLE phAuditEvent, DWORD dwAdditionalParameterCount);
typedef BOOL(__stdcall* AuthzFreeAuditEvent)(AUTHZ_AUDIT_EVENT_HANDLE hAuditEvent);
typedef BOOL(__stdcall* AuthzInstallSecurityEventSource)(DWORD dwFlags, PAUTHZ_SOURCE_SCHEMA_REGISTRATION pRegistration);
typedef BOOL(__stdcall* AuthzUninstallSecurityEventSource)(DWORD dwFlags, PCWSTR szEventSourceName);
typedef BOOL(__stdcall* AuthzEnumerateSecurityEventSources)(DWORD dwFlags, PAUTHZ_SOURCE_SCHEMA_REGISTRATION Buffer, PDWORD pdwCount, PDWORD pdwLength);
typedef BOOL(__stdcall* AuthzRegisterSecurityEventSource)(DWORD dwFlags, PCWSTR szEventSourceName, PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider);
typedef BOOL(__stdcall* AuthzUnregisterSecurityEventSource)(DWORD dwFlags, PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider);
typedef BOOL(__stdcall* AuthzReportSecurityEvent)(DWORD dwFlags, AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider, DWORD dwAuditId, PSID pUserSid, DWORD dwCount);
typedef BOOL(__stdcall* AuthzReportSecurityEventFromParams)(DWORD dwFlags, AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider, DWORD dwAuditId, PSID pUserSid, PAUDIT_PARAMS pParams);
typedef BOOL(__stdcall* AuthzRegisterCapChangeNotification)(PAUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE phCapChangeSubscription, LPTHREAD_START_ROUTINE pfnCapChangeCallback, PVOID pCallbackContext);
typedef BOOL(__stdcall* AuthzUnregisterCapChangeNotification)(AUTHZ_CAP_CHANGE_SUBSCRIPTION_HANDLE hCapChangeSubscription);
typedef ULONG(__stdcall* VerifierEnumerateResource)(HANDLE Process, ULONG Flags, ULONG ResourceType, AVRF_RESOURCE_ENUMERATE_CALLBACK ResourceCallback, PVOID EnumerationContext);
typedef HANDLE(__stdcall* AvSetMmThreadCharacteristicsA)(LPCSTR TaskName, LPDWORD TaskIndex);
typedef HANDLE(__stdcall* AvSetMmThreadCharacteristicsW)(LPCWSTR TaskName, LPDWORD TaskIndex);
typedef HANDLE(__stdcall* AvSetMmMaxThreadCharacteristicsA)(LPCSTR FirstTask, LPCSTR SecondTask, LPDWORD TaskIndex);
typedef HANDLE(__stdcall* AvSetMmMaxThreadCharacteristicsW)(LPCWSTR FirstTask, LPCWSTR SecondTask, LPDWORD TaskIndex);
typedef BOOL(__stdcall* AvRevertMmThreadCharacteristics)(HANDLE AvrtHandle);
typedef BOOL(__stdcall* AvSetMmThreadPriority)(HANDLE AvrtHandle, AVRT_PRIORITY Priority);
typedef BOOL(__stdcall* AvRtWaitOnThreadOrderingGroup)(HANDLE Context);
typedef BOOL(__stdcall* AvRtLeaveThreadOrderingGroup)(HANDLE Context);
typedef BOOL(__stdcall* AvRtDeleteThreadOrderingGroup)(HANDLE Context);
typedef BOOL(__stdcall* AvQuerySystemResponsiveness)(HANDLE AvrtHandle, PULONG SystemResponsivenessValue);
typedef NTSTATUS(__stdcall* BCryptSetProperty)(BCRYPT_HANDLE hObject, LPCWSTR pszProperty, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptCloseAlgorithmProvider)(BCRYPT_ALG_HANDLE hAlgorithm, ULONG dwFlags);
typedef void(__stdcall* BCryptFreeBuffer)(PVOID pvBuffer);
typedef NTSTATUS(__stdcall* BCryptFinalizeKeyPair)(BCRYPT_KEY_HANDLE hKey, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptDestroyKey)(BCRYPT_KEY_HANDLE hKey);
typedef NTSTATUS(__stdcall* BCryptDestroySecret)(BCRYPT_SECRET_HANDLE hSecret);
typedef NTSTATUS(__stdcall* BCryptHashData)(BCRYPT_HASH_HANDLE hHash, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptFinishHash)(BCRYPT_HASH_HANDLE hHash, PUCHAR pbOutput, ULONG cbOutput, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptProcessMultiOperations)(BCRYPT_HANDLE hObject, BCRYPT_MULTI_OPERATION_TYPE operationType, PVOID pOperations, ULONG cbOperations, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptDestroyHash)(BCRYPT_HASH_HANDLE hHash);
typedef NTSTATUS(__stdcall* BCryptHash)(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbSecret, ULONG cbSecret, PUCHAR pbInput, ULONG cbInput, PUCHAR pbOutput, ULONG cbOutput);
typedef NTSTATUS(__stdcall* BCryptGenRandom)(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbBuffer, ULONG cbBuffer, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptDeriveKeyCapi)(BCRYPT_HASH_HANDLE hHash, BCRYPT_ALG_HANDLE hTargetAlg, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptDeriveKeyPBKDF2)(BCRYPT_ALG_HANDLE hPrf, PUCHAR pbPassword, ULONG cbPassword, PUCHAR pbSalt, ULONG cbSalt, ULONGLONG cIterations, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
typedef NTSTATUS(__stdcall* BCryptCreateContext)(ULONG dwTable, LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
typedef NTSTATUS(__stdcall* BCryptDeleteContext)(ULONG dwTable, LPCWSTR pszContext);
typedef NTSTATUS(__stdcall* BCryptConfigureContext)(ULONG dwTable, LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
typedef NTSTATUS(__stdcall* BCryptAddContextFunction)(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, ULONG dwPosition);
typedef NTSTATUS(__stdcall* BCryptRemoveContextFunction)(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction);
typedef NTSTATUS(__stdcall* BCryptConfigureContextFunction)(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, PCRYPT_CONTEXT_FUNCTION_CONFIG pConfig);
typedef NTSTATUS(__stdcall* BCryptSetContextFunctionProperty)(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, LPCWSTR pszProperty, ULONG cbValue, PUCHAR pbValue);
typedef NTSTATUS(__stdcall* BCryptUnregisterConfigChangeNotify)(HANDLE hEvent);
typedef BOOL(__stdcall* BluetoothFindRadioClose)(HBLUETOOTH_RADIO_FIND hFind);
typedef DWORD(__stdcall* BluetoothGetRadioInfo)(HANDLE hRadio, PBLUETOOTH_RADIO_INFO pRadioInfo);
typedef BOOL(__stdcall* BluetoothFindDeviceClose)(HBLUETOOTH_DEVICE_FIND hFind);
typedef BOOL(__stdcall* BluetoothEnableDiscovery)(HANDLE hRadio, BOOL fEnabled);
typedef BOOL(__stdcall* BluetoothIsDiscoverable)(HANDLE hRadio);
typedef BOOL(__stdcall* BluetoothEnableIncomingConnections)(HANDLE hRadio, BOOL fEnabled);
typedef BOOL(__stdcall* BluetoothIsConnectable)(HANDLE hRadio);
typedef BOOL(__stdcall* BluetoothUnregisterAuthentication)(HBLUETOOTH_AUTHENTICATION_REGISTRATION hRegHandle);
typedef DWORD(__stdcall* BluetoothSendAuthenticationResponseEx)(HANDLE hRadioIn, PBLUETOOTH_AUTHENTICATE_RESPONSE pauthResponse);
typedef DWORD(__stdcall* BluetoothSdpGetElementData)(LPBYTE pSdpStream, ULONG cbSdpStreamLength, PSDP_ELEMENT_DATA pData);
typedef DWORD(__stdcall* BluetoothSdpGetAttributeValue)(LPBYTE pRecordStream, ULONG cbRecordLength, USHORT usAttributeId, PSDP_ELEMENT_DATA pAttributeData);
typedef DWORD(__stdcall* BluetoothSdpGetString)(LPBYTE pRecordStream, ULONG cbRecordLength, PSDP_STRING_TYPE_DATA pStringData, USHORT usStringOffset, PWSTR pszString, PULONG pcchStringLength);
typedef BOOL(__stdcall* BluetoothSdpEnumAttributes)(LPBYTE pSDPStream, ULONG cbStreamSize, PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK pfnCallback, LPVOID pvParam);
typedef BOOL(__stdcall* BluetoothIsVersionAvailable)(UCHAR MajorVersion, UCHAR MinorVersion);
typedef HRESULT(__stdcall* BluetoothGATTBeginReliableWrite)(HANDLE hDevice, PBTH_LE_GATT_RELIABLE_WRITE_CONTEXT ReliableWriteContext, ULONG Flags);
typedef HRESULT(__stdcall* BluetoothGATTSetCharacteristicValue)(HANDLE hDevice, PBTH_LE_GATT_CHARACTERISTIC Characteristic, PBTH_LE_GATT_CHARACTERISTIC_VALUE CharacteristicValue, BTH_LE_GATT_RELIABLE_WRITE_CONTEXT ReliableWriteContext, ULONG Flags);
typedef HRESULT(__stdcall* BluetoothGATTEndReliableWrite)(HANDLE hDevice, BTH_LE_GATT_RELIABLE_WRITE_CONTEXT ReliableWriteContext, ULONG Flags);
typedef HRESULT(__stdcall* BluetoothGATTAbortReliableWrite)(HANDLE hDevice, BTH_LE_GATT_RELIABLE_WRITE_CONTEXT ReliableWriteContext, ULONG Flags);
typedef HRESULT(__stdcall* BluetoothGATTSetDescriptorValue)(HANDLE hDevice, PBTH_LE_GATT_DESCRIPTOR Descriptor, PBTH_LE_GATT_DESCRIPTOR_VALUE DescriptorValue, ULONG Flags);
typedef HRESULT(__stdcall* BluetoothGATTUnregisterEvent)(BLUETOOTH_GATT_EVENT_HANDLE EventHandle, ULONG Flags);
typedef HRESULT(__stdcall* CertSrvBackupClose)(HCSBC hbc);
typedef HRESULT(__stdcall* CertSrvBackupTruncateLogs)(HCSBC hbc);
typedef HRESULT(__stdcall* CertSrvBackupEnd)(HCSBC hbc);
typedef HRESULT(__stdcall* CertSrvRestoreRegisterComplete)(HCSBC hbc, HRESULT hrRestoreState);
typedef HRESULT(__stdcall* CertSrvRestoreEnd)(HCSBC hbc);
typedef HRESULT(__stdcall* CfUnregisterSyncRoot)(LPCWSTR SyncRootPath);
typedef HRESULT(__stdcall* CfDisconnectSyncRoot)(CF_CONNECTION_KEY ConnectionKey);
typedef HRESULT(__stdcall* CfUpdateSyncProviderStatus)(CF_CONNECTION_KEY ConnectionKey, CF_SYNC_PROVIDER_STATUS ProviderStatus);
typedef HRESULT(__stdcall* CfOpenFileWithOplock)(LPCWSTR FilePath, CF_OPEN_FILE_FLAGS Flags, PHANDLE ProtectedHandle);
typedef BOOLEAN(__stdcall* CfReferenceProtectedHandle)(HANDLE ProtectedHandle);
typedef HANDLE(__stdcall* CfGetWin32HandleFromProtectedHandle)(HANDLE ProtectedHandle);
typedef void(__stdcall* CfReleaseProtectedHandle)(HANDLE ProtectedHandle);
typedef void(__stdcall* CfCloseHandle)(HANDLE FileHandle);
typedef HRESULT(__stdcall* CfRevertPlaceholder)(HANDLE FileHandle, CF_REVERT_FLAGS RevertFlags, LPOVERLAPPED Overlapped);
typedef HRESULT(__stdcall* CfHydratePlaceholder)(HANDLE FileHandle, LARGE_INTEGER StartingOffset, LARGE_INTEGER Length, CF_HYDRATE_FLAGS HydrateFlags, LPOVERLAPPED Overlapped);
typedef HRESULT(__stdcall* CfSetPinState)(HANDLE FileHandle, CF_PIN_STATE PinState, CF_SET_PIN_FLAGS PinFlags, LPOVERLAPPED Overlapped);
typedef HRESULT(__stdcall* CfSetCorrelationVector)(HANDLE FileHandle, PCORRELATION_VECTOR CorrelationVector);
typedef HRESULT(__stdcall* CfGetCorrelationVector)(HANDLE FileHandle, PCORRELATION_VECTOR CorrelationVector);
typedef CF_PLACEHOLDER_STATE(__stdcall* CfGetPlaceholderStateFromAttributeTag)(DWORD FileAttributes, DWORD ReparseTag);
typedef CF_PLACEHOLDER_STATE(__stdcall* CfGetPlaceholderStateFromFileInfo)(LPCVOID InfoBuffer, FILE_INFO_BY_HANDLE_CLASS InfoClass);
typedef HRESULT(__stdcall* CfGetPlaceholderInfo)(HANDLE FileHandle, CF_PLACEHOLDER_INFO_CLASS InfoClass, PVOID InfoBuffer, DWORD InfoBufferLength, PDWORD ReturnedLength);
typedef HRESULT(__stdcall* CfGetPlaceholderRangeInfo)(HANDLE FileHandle, CF_PLACEHOLDER_RANGE_INFO_CLASS InfoClass, LARGE_INTEGER StartingOffset, LARGE_INTEGER Length, PVOID InfoBuffer, DWORD InfoBufferLength, PDWORD ReturnedLength);
typedef HRESULT(__stdcall* CfReportProviderProgress)(CF_CONNECTION_KEY ConnectionKey, CF_TRANSFER_KEY TransferKey, LARGE_INTEGER ProviderProgressTotal, LARGE_INTEGER ProviderProgressCompleted);
typedef CONFIGRET(__stdcall* CM_Add_Empty_Log_Conf)(PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Add_Empty_Log_Conf_Ex)(PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Add_Res_Des)(PRES_DES prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Add_Res_Des_Ex)(PRES_DES prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Delete_Class_Key)(LPGUID ClassGuid, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Delete_DevNode_Key)(DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Disable_DevNode)(DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Disconnect_Machine)(HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Enable_DevNode)(DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Enumerate_Classes)(ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Enumerate_Classes_Ex)(ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Free_Log_Conf)(LOG_CONF lcLogConfToBeFreed, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Free_Log_Conf_Ex)(LOG_CONF lcLogConfToBeFreed, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Free_Log_Conf_Handle)(LOG_CONF lcLogConf);
typedef CONFIGRET(__stdcall* CM_Free_Res_Des)(PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Free_Res_Des_Ex)(PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Free_Res_Des_Handle)(RES_DES rdResDes);
typedef CONFIGRET(__stdcall* CM_Get_Child)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Child_Ex)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Depth)(PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Depth_Ex)(PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Device_IDW)(DEVINST dnDevInst, PWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_ListA)(PCSTR pszFilter, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_ListW)(PCWSTR pszFilter, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_List_SizeA)(PULONG pulLen, PCSTR pszFilter, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_List_SizeW)(PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_Size)(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_ID_Size_Ex)(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_DevNode_Registry_PropertyW)(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_DevNode_Status)(PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_DevNode_Status_Ex)(PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_First_Log_Conf)(PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_First_Log_Conf_Ex)(PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_ListA)(LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_ListW)(LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_List_SizeA)(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_List_SizeW)(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Log_Conf_Priority)(LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Log_Conf_Priority_Ex)(LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Next_Log_Conf)(PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Next_Log_Conf_Ex)(PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Parent)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Parent_Ex)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Res_Des_Data)(RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Res_Des_Data_Ex)(RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Res_Des_Data_Size)(PULONG pulSize, RES_DES rdResDes, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Res_Des_Data_Size_Ex)(PULONG pulSize, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Sibling)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Sibling_Ex)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef WORD(__stdcall* CM_Get_Version_Ex)(HMACHINE hMachine);
typedef BOOL(__stdcall* CM_Is_Version_Available)(WORD wVersion);
typedef BOOL(__stdcall* CM_Is_Version_Available_Ex)(WORD wVersion, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Locate_DevNodeA)(PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Locate_DevNodeW)(PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Modify_Res_Des)(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Modify_Res_Des_Ex)(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Get_Next_Res_Des)(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Get_Next_Res_Des_Ex)(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Open_Class_KeyW)(LPGUID ClassGuid, LPCWSTR pszClassName, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Open_DevNode_Key)(DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Open_Device_Interface_KeyA)(LPCSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkDeviceInterface, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Open_Device_Interface_KeyW)(LPCWSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkDeviceInterface, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Open_Device_Interface_Key_ExA)(LPCSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Open_Device_Interface_Key_ExW)(LPCWSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Delete_Device_Interface_KeyW)(LPCWSTR pszDeviceInterface, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Query_And_Remove_SubTreeW)(DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Reenumerate_DevNode)(DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Reenumerate_DevNode_Ex)(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Set_DevNode_Problem_Ex)(DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Set_DevNode_Problem)(DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Set_DevNode_Registry_PropertyW)(DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Is_Dock_Station_Present)(PBOOL pbPresent);
typedef CONFIGRET(__stdcall* CM_Is_Dock_Station_Present_Ex)(PBOOL pbPresent, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Request_Eject_PC_Ex)(HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Setup_DevNode)(DEVINST dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Uninstall_DevNode)(DEVNODE dnDevInst, ULONG ulFlags);
typedef CONFIGRET(__stdcall* CM_Query_Resource_Conflict_List)(PCONFLICT_LIST pclConflictList, DEVINST dnDevInst, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Free_Resource_Conflict_Handle)(CONFLICT_LIST clConflictList);
typedef CONFIGRET(__stdcall* CM_Get_Resource_Conflict_Count)(CONFLICT_LIST clConflictList, PULONG pulCount);
typedef CONFIGRET(__stdcall* CM_Get_Class_Registry_PropertyW)(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Set_Class_Registry_PropertyW)(LPGUID ClassGuid, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE hMachine);
typedef CONFIGRET(__stdcall* CM_Register_Notification)(PCM_NOTIFY_FILTER pFilter, PVOID pContext, PCM_NOTIFY_CALLBACK pCallback, PHCMNOTIFICATION pNotifyContext);
typedef CONFIGRET(__stdcall* CM_Unregister_Notification)(HCMNOTIFICATION NotifyContext);
typedef DWORD(__stdcall* CM_MapCrToWin32Err)(CONFIGRET CmReturnCode, DWORD DefaultErr);
typedef CLFS_LSN(__stdcall* LsnCreate)(CLFS_CONTAINER_ID cidContainer, ULONG offBlock, ULONG cRecord);
typedef HANDLE(__stdcall* CreateLogFile)(LPCWSTR pszLogFileName, ACCESS_MASK fDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES psaLogFile, ULONG fCreateDisposition, ULONG fFlagsAndAttributes);
typedef BOOL(__stdcall* DeleteLogByHandle)(HANDLE hLog);
typedef BOOL(__stdcall* DeleteLogFile)(LPCWSTR pszLogFileName, PVOID pvReserved);
typedef BOOL(__stdcall* AddLogContainer)(HANDLE hLog, PULONGLONG pcbContainer, LPWSTR pwszContainerPath, LPVOID pReserved);
typedef BOOL(__stdcall* RemoveLogContainer)(HANDLE hLog, LPWSTR pwszContainerPath, BOOL fForce, LPVOID pReserved);
typedef BOOL(__stdcall* SetLogArchiveTail)(HANDLE hLog, PCLFS_LSN plsnArchiveTail, LPVOID pReserved);
typedef BOOL(__stdcall* SetEndOfLog)(HANDLE hLog, PCLFS_LSN plsnEnd, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* TruncateLog)(PVOID pvMarshal, PCLFS_LSN plsnEnd, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* CreateLogContainerScanContext)(HANDLE hLog, ULONG cFromContainer, ULONG cContainers, CLFS_SCAN_MODE eScanMode, PCLFS_SCAN_CONTEXT pcxScan, LPOVERLAPPED pOverlapped);
typedef BOOL(__stdcall* ScanLogContainers)(PCLFS_SCAN_CONTEXT pcxScan, CLFS_SCAN_MODE eScanMode, LPVOID pReserved);
typedef BOOL(__stdcall* AllocReservedLog)(PVOID pvMarshal, ULONG cReservedRecords, PLONGLONG pcbAdjustment);
typedef BOOL(__stdcall* FreeReservedLog)(PVOID pvMarshal, ULONG cReservedRecords, PLONGLONG pcbAdjustment);
typedef BOOL(__stdcall* GetLogFileInformation)(HANDLE hLog, PCLFS_INFORMATION pinfoBuffer, PULONG cbBuffer);
typedef BOOL(__stdcall* SetLogArchiveMode)(HANDLE hLog, CLFS_LOG_ARCHIVE_MODE eMode);
typedef BOOL(__stdcall* WriteLogRestartArea)(PVOID pvMarshal, PVOID pvRestartBuffer, ULONG cbRestartBuffer, PCLFS_LSN plsnBase, ULONG fFlags, PULONG pcbWritten, PCLFS_LSN plsnNext, LPOVERLAPPED pOverlapped);
typedef BOOL(__stdcall* AdvanceLogBase)(PVOID pvMarshal, PCLFS_LSN plsnBase, ULONG fFlags, LPOVERLAPPED pOverlapped);
typedef BOOL(__stdcall* CloseAndResetLogFile)(HANDLE hLog);
typedef BOOL(__stdcall* DeleteLogMarshallingArea)(PVOID pvMarshal);
typedef BOOL(__stdcall* FlushLogBuffers)(PVOID pvMarshal, LPOVERLAPPED pOverlapped);
typedef BOOL(__stdcall* FlushLogToLsn)(PVOID pvMarshalContext, PCLFS_LSN plsnFlush, PCLFS_LSN plsnLastFlushed, LPOVERLAPPED pOverlapped);
typedef BOOL(__stdcall* TerminateReadLog)(PVOID pvCursorContext);
typedef BOOL(__stdcall* DumpLogRecords)(PWSTR pwszLogFileName, CLFS_RECORD_TYPE fRecordType, PCLFS_LSN plsnStart, PCLFS_LSN plsnEnd, PFILE pstrmOut, CLFS_PRINT_RECORD_ROUTINE pfnPrintRecord, CLFS_BLOCK_ALLOCATION pfnAllocBlock, CLFS_BLOCK_DEALLOCATION pfnFreeBlock, PVOID pvBlockAllocContext, ULONG cbBlock, ULONG cMaxBlocks);
typedef BOOL(__stdcall* PrepareLogArchive)(HANDLE hLog, PWSTR pszBaseLogFileName, ULONG cLen, PCLFS_LSN plsnLow, PCLFS_LSN plsnHigh, PULONG pcActualLength, PULONGLONG poffBaseLogFileData, PULONGLONG pcbBaseLogFileLength, PCLFS_LSN plsnBase, PCLFS_LSN plsnLast, PCLFS_LSN plsnCurrentArchiveTail, PCLFS_LOG_ARCHIVE_CONTEXT ppvArchiveContext);
typedef BOOL(__stdcall* ReadLogArchiveMetadata)(CLFS_LOG_ARCHIVE_CONTEXT pvArchiveContext, ULONG cbOffset, ULONG cbBytesToRead, PBYTE pbReadBuffer, PULONG pcbBytesRead);
typedef BOOL(__stdcall* TerminateLogArchive)(CLFS_LOG_ARCHIVE_CONTEXT pvArchiveContext);
typedef BOOL(__stdcall* ValidateLog)(LPCWSTR pszLogFileName, LPSECURITY_ATTRIBUTES psaLogFile, PCLFS_INFORMATION pinfoBuffer, PULONG pcbBuffer);
typedef BOOL(__stdcall* GetLogContainerName)(HANDLE hLog, CLFS_CONTAINER_ID cidLogicalContainer, LPCWSTR pwstrContainerName, ULONG cLenContainerName, PULONG pcActualLenContainerName);
typedef BOOL(__stdcall* GetLogIoStatistics)(HANDLE hLog, PVOID pvStatsBuffer, ULONG cbStatsBuffer, CLFS_IOSTATS_CLASS eStatsClass, PULONG pcbStatsWritten);
typedef DWORD(__stdcall* GetNodeClusterState)(LPCWSTR lpszNodeName, LPDWORD pdwClusterState);
typedef HCLUSTER(__stdcall* OpenCluster)(LPCWSTR lpszClusterName);
typedef BOOL(__stdcall* CloseCluster)(HCLUSTER hCluster);
typedef DWORD(__stdcall* SetClusterName)(HCLUSTER hCluster, LPCWSTR lpszNewClusterName);
typedef DWORD(__stdcall* GetClusterInformation)(HCLUSTER hCluster, LPWSTR lpszClusterName, LPDWORD lpcchClusterName, LPCLUSTERVERSIONINFO lpClusterInfo);
typedef DWORD(__stdcall* GetClusterQuorumResource)(HCLUSTER hCluster, LPWSTR lpszResourceName, LPDWORD lpcchResourceName, LPWSTR lpszDeviceName, LPDWORD lpcchDeviceName, LPDWORD lpdwMaxQuorumLogSize);
typedef DWORD(__stdcall* SetClusterQuorumResource)(HRESOURCE hResource, LPCWSTR lpszDeviceName, DWORD dwMaxQuoLogSize);
typedef DWORD(__stdcall* BackupClusterDatabase)(HCLUSTER hCluster, LPCWSTR lpszPathName);
typedef DWORD(__stdcall* RestoreClusterDatabase)(LPCWSTR lpszPathName, BOOL bForce, LPCWSTR lpszQuorumDriveLetter);
typedef DWORD(__stdcall* SetClusterServiceAccountPassword)(LPCWSTR lpszClusterName, LPCWSTR lpszNewPassword, DWORD dwFlags, PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer, LPDWORD lpcbReturnStatusBufferSize);
typedef DWORD(__stdcall* ClusterControl)(HCLUSTER hCluster, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterUpgradeFunctionalLevel)(HCLUSTER hCluster, BOOL perform, PCLUSTER_UPGRADE_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg);
typedef DWORD(__stdcall* RegisterClusterNotifyV2)(HCHANGE hChange, NOTIFY_FILTER_AND_TYPE Filter, HANDLE hObject, DWORD_PTR dwNotifyKey);
typedef DWORD(__stdcall* GetNotifyEventHandle)(HCHANGE hChange, LPHANDLE lphTargetEvent);
typedef HCHANGE(__stdcall* CreateClusterNotifyPort)(HCHANGE hChange, HCLUSTER hCluster, DWORD dwFilter, DWORD_PTR dwNotifyKey);
typedef DWORD(__stdcall* RegisterClusterNotify)(HCHANGE hChange, DWORD dwFilterType, HANDLE hObject, DWORD_PTR dwNotifyKey);
typedef BOOL(__stdcall* CloseClusterNotifyPort)(HCHANGE hChange);
typedef HCLUSENUM(__stdcall* ClusterOpenEnum)(HCLUSTER hCluster, DWORD dwType);
typedef DWORD(__stdcall* ClusterGetEnumCount)(HCLUSENUM hEnum);
typedef DWORD(__stdcall* ClusterEnum)(HCLUSENUM hEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterCloseEnum)(HCLUSENUM hEnum);
typedef DWORD(__stdcall* ClusterGetEnumCountEx)(HCLUSENUMEX hClusterEnum);
typedef DWORD(__stdcall* ClusterEnumEx)(HCLUSENUMEX hClusterEnum, DWORD dwIndex, PCLUSTER_ENUM_ITEM pItem, LPDWORD cbItem);
typedef DWORD(__stdcall* ClusterCloseEnumEx)(HCLUSENUMEX hClusterEnum);
typedef HGROUPSET(__stdcall* CreateClusterGroupSet)(HCLUSTER hCluster, LPCWSTR groupSetName);
typedef HGROUPSET(__stdcall* OpenClusterGroupSet)(HCLUSTER hCluster, LPCWSTR lpszGroupSetName);
typedef BOOL(__stdcall* CloseClusterGroupSet)(HGROUPSET hGroupSet);
typedef DWORD(__stdcall* DeleteClusterGroupSet)(HGROUPSET hGroupSet);
typedef DWORD(__stdcall* ClusterAddGroupToGroupSet)(HGROUPSET hGroupSet, HGROUP hGroup);
typedef DWORD(__stdcall* ClusterRemoveGroupFromGroupSet)(HGROUP hGroup);
typedef DWORD(__stdcall* ClusterGroupSetControl)(HGROUPSET hGroupSet, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* AddClusterGroupDependency)(HGROUP hDependentGroup, HGROUP hProviderGroup);
typedef DWORD(__stdcall* SetGroupDependencyExpression)(HGROUP hGroup, LPCWSTR lpszDependencyExpression);
typedef DWORD(__stdcall* RemoveClusterGroupDependency)(HGROUP hGroup, HGROUP hDependsOn);
typedef DWORD(__stdcall* AddClusterGroupSetDependency)(HGROUPSET hDependentGroupSet, HGROUPSET hProviderGroupSet);
typedef DWORD(__stdcall* SetClusterGroupSetDependencyExpression)(HGROUPSET hGroupSet, LPCWSTR lpszDependencyExprssion);
typedef DWORD(__stdcall* RemoveClusterGroupSetDependency)(HGROUPSET hGroupSet, HGROUPSET hDependsOn);
typedef DWORD(__stdcall* AddClusterGroupToGroupSetDependency)(HGROUP hDependentGroup, HGROUPSET hProviderGroupSet);
typedef DWORD(__stdcall* RemoveClusterGroupToGroupSetDependency)(HGROUP hGroup, HGROUPSET hDependsOn);
typedef HGROUPSETENUM(__stdcall* ClusterGroupSetOpenEnum)(HCLUSTER hCluster);
typedef DWORD(__stdcall* ClusterGroupSetGetEnumCount)(HGROUPSETENUM hGroupSetEnum);
typedef DWORD(__stdcall* ClusterGroupSetCloseEnum)(HGROUPSETENUM hGroupSetEnum);
typedef HNODE(__stdcall* OpenClusterNode)(HCLUSTER hCluster, LPCWSTR lpszNodeName);
typedef BOOL(__stdcall* CloseClusterNode)(HNODE hNode);
typedef CLUSTER_NODE_STATE(__stdcall* GetClusterNodeState)(HNODE hNode);
typedef DWORD(__stdcall* GetClusterNodeId)(HNODE hNode, LPWSTR lpszNodeId, LPDWORD lpcchName);
typedef HCLUSTER(__stdcall* GetClusterFromNode)(HNODE hNode);
typedef DWORD(__stdcall* PauseClusterNode)(HNODE hNode);
typedef DWORD(__stdcall* ResumeClusterNode)(HNODE hNode);
typedef DWORD(__stdcall* EvictClusterNode)(HNODE hNode);
typedef HNETINTERFACEENUM(__stdcall* ClusterNetInterfaceOpenEnum)(HCLUSTER hCluster, LPCWSTR lpszNodeName, LPCWSTR lpszNetworkName);
typedef DWORD(__stdcall* ClusterNetInterfaceEnum)(HNETINTERFACEENUM hNetInterfaceEnum, DWORD dwIndex, LPWSTR lpszName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterNetInterfaceCloseEnum)(HNETINTERFACEENUM hNetInterfaceEnum);
typedef HNODEENUM(__stdcall* ClusterNodeOpenEnum)(HNODE hNode, DWORD dwType);
typedef DWORD(__stdcall* ClusterNodeGetEnumCountEx)(HNODEENUMEX hNodeEnum);
typedef DWORD(__stdcall* ClusterNodeEnumEx)(HNODEENUMEX hNodeEnum, DWORD dwIndex, PCLUSTER_ENUM_ITEM pItem, LPDWORD cbItem);
typedef DWORD(__stdcall* ClusterNodeCloseEnumEx)(HNODEENUMEX hNodeEnum);
typedef DWORD(__stdcall* ClusterNodeGetEnumCount)(HNODEENUM hNodeEnum);
typedef DWORD(__stdcall* ClusterNodeCloseEnum)(HNODEENUM hNodeEnum);
typedef DWORD(__stdcall* ClusterNodeEnum)(HNODEENUM hNodeEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszName, LPDWORD lpcchName);
typedef HKEY(__stdcall* GetClusterResourceTypeKey)(HCLUSTER hCluster, LPCWSTR lpszTypeName, REGSAM samDesired);
typedef HGROUP(__stdcall* CreateClusterGroup)(HCLUSTER hCluster, LPCWSTR lpszGroupName);
typedef HGROUP(__stdcall* OpenClusterGroup)(HCLUSTER hCluster, LPCWSTR lpszGroupName);
typedef DWORD(__stdcall* ResumeClusterNodeEx)(HNODE hNode, CLUSTER_NODE_RESUME_FAILBACK_TYPE eResumeFailbackType, DWORD dwResumeFlagsReserved);
typedef HGROUP(__stdcall* CreateClusterGroupEx)(HCLUSTER hCluster, LPCWSTR lpszGroupName, PCLUSTER_CREATE_GROUP_INFO pGroupInfo);
typedef HGROUPENUMEX(__stdcall* ClusterGroupOpenEnumEx)(HCLUSTER hCluster, LPCWSTR lpszProperties, DWORD cbProperties, LPCWSTR lpszRoProperties, DWORD cbRoProperties, DWORD dwFlags);
typedef DWORD(__stdcall* ClusterGroupGetEnumCountEx)(HGROUPENUMEX hGroupEnumEx);
typedef DWORD(__stdcall* ClusterGroupEnumEx)(HGROUPENUMEX hGroupEnumEx, DWORD dwIndex, PCLUSTER_GROUP_ENUM_ITEM pItem, LPDWORD cbItem);
typedef DWORD(__stdcall* ClusterGroupCloseEnumEx)(HGROUPENUMEX hGroupEnumEx);
typedef HRESENUMEX(__stdcall* ClusterResourceOpenEnumEx)(HCLUSTER hCluster, LPCWSTR lpszProperties, DWORD cbProperties, LPCWSTR lpszRoProperties, DWORD cbRoProperties, DWORD dwFlags);
typedef DWORD(__stdcall* ClusterResourceGetEnumCountEx)(HRESENUMEX hResourceEnumEx);
typedef DWORD(__stdcall* ClusterResourceEnumEx)(HRESENUMEX hResourceEnumEx, DWORD dwIndex, PCLUSTER_RESOURCE_ENUM_ITEM pItem, LPDWORD cbItem);
typedef DWORD(__stdcall* ClusterResourceCloseEnumEx)(HRESENUMEX hResourceEnumEx);
typedef DWORD(__stdcall* OnlineClusterGroupEx)(HGROUP hGroup, HNODE hDestinationNode, DWORD dwOnlineFlags, PBYTE lpInBuffer, DWORD cbInBufferSize);
typedef DWORD(__stdcall* OfflineClusterGroupEx)(HGROUP hGroup, DWORD dwOfflineFlags, PBYTE lpInBuffer, DWORD cbInBufferSize);
typedef DWORD(__stdcall* OnlineClusterResourceEx)(HRESOURCE hResource, DWORD dwOnlineFlags, PBYTE lpInBuffer, DWORD cbInBufferSize);
typedef DWORD(__stdcall* OfflineClusterResourceEx)(HRESOURCE hResource, DWORD dwOfflineFlags, PBYTE lpInBuffer, DWORD cbInBufferSize);
typedef DWORD(__stdcall* MoveClusterGroupEx)(HGROUP hGroup, HNODE hDestinationNode, DWORD dwMoveFlags, PBYTE lpInBuffer, DWORD cbInBufferSize);
typedef DWORD(__stdcall* CancelClusterGroupOperation)(HGROUP hGroup, DWORD dwCancelFlags_RESERVED);
typedef BOOL(__stdcall* CloseClusterGroup)(HGROUP hGroup);
typedef HCLUSTER(__stdcall* GetClusterFromGroup)(HGROUP hGroup);
typedef CLUSTER_GROUP_STATE(__stdcall* GetClusterGroupState)(HGROUP hGroup, LPWSTR lpszNodeName, LPDWORD lpcchNodeName);
typedef DWORD(__stdcall* SetClusterGroupName)(HGROUP hGroup, LPCWSTR lpszGroupName);
typedef DWORD(__stdcall* OnlineClusterGroup)(HGROUP hGroup, HNODE hDestinationNode);
typedef DWORD(__stdcall* MoveClusterGroup)(HGROUP hGroup, HNODE hDestinationNode);
typedef DWORD(__stdcall* OfflineClusterGroup)(HGROUP hGroup);
typedef DWORD(__stdcall* DeleteClusterGroup)(HGROUP hGroup);
typedef DWORD(__stdcall* DestroyClusterGroup)(HGROUP hGroup);
typedef HGROUPENUM(__stdcall* ClusterGroupOpenEnum)(HGROUP hGroup, DWORD dwType);
typedef DWORD(__stdcall* ClusterGroupGetEnumCount)(HGROUPENUM hGroupEnum);
typedef DWORD(__stdcall* ClusterGroupEnum)(HGROUPENUM hGroupEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszResourceName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterGroupCloseEnum)(HGROUPENUM hGroupEnum);
typedef HRESOURCE(__stdcall* CreateClusterResource)(HGROUP hGroup, LPCWSTR lpszResourceName, LPCWSTR lpszResourceType, DWORD dwFlags);
typedef HRESOURCE(__stdcall* OpenClusterResource)(HCLUSTER hCluster, LPCWSTR lpszResourceName);
typedef BOOL(__stdcall* CloseClusterResource)(HRESOURCE hResource);
typedef HCLUSTER(__stdcall* GetClusterFromResource)(HRESOURCE hResource);
typedef DWORD(__stdcall* DeleteClusterResource)(HRESOURCE hResource);
typedef CLUSTER_RESOURCE_STATE(__stdcall* GetClusterResourceState)(HRESOURCE hResource, LPWSTR lpszNodeName, LPDWORD lpcchNodeName, LPWSTR lpszGroupName, LPDWORD lpcchGroupName);
typedef DWORD(__stdcall* SetClusterResourceName)(HRESOURCE hResource, LPCWSTR lpszResourceName);
typedef DWORD(__stdcall* FailClusterResource)(HRESOURCE hResource);
typedef DWORD(__stdcall* OnlineClusterResource)(HRESOURCE hResource);
typedef DWORD(__stdcall* OfflineClusterResource)(HRESOURCE hResource);
typedef DWORD(__stdcall* ChangeClusterResourceGroup)(HRESOURCE hResource, HGROUP hGroup);
typedef DWORD(__stdcall* AddClusterResourceNode)(HRESOURCE hResource, HNODE hNode);
typedef DWORD(__stdcall* RemoveClusterResourceNode)(HRESOURCE hResource, HNODE hNode);
typedef DWORD(__stdcall* AddClusterResourceDependency)(HRESOURCE hResource, HRESOURCE hDependsOn);
typedef DWORD(__stdcall* RemoveClusterResourceDependency)(HRESOURCE hResource, HRESOURCE hDependsOn);
typedef DWORD(__stdcall* SetClusterResourceDependencyExpression)(HRESOURCE hResource, LPCWSTR lpszDependencyExpression);
typedef DWORD(__stdcall* GetClusterResourceDependencyExpression)(HRESOURCE hResource, LPWSTR lpszDependencyExpression, LPDWORD lpcchDependencyExpression);
typedef DWORD(__stdcall* AddResourceToClusterSharedVolumes)(HRESOURCE hResource);
typedef DWORD(__stdcall* RemoveResourceFromClusterSharedVolumes)(HRESOURCE hResource);
typedef DWORD(__stdcall* IsFileOnClusterSharedVolume)(LPCWSTR lpszPathName, PBOOL pbFileIsOnSharedVolume);
typedef DWORD(__stdcall* ClusterSharedVolumeSetSnapshotState)(GUID guidSnapshotSet, LPCWSTR lpszVolumeName, CLUSTER_SHARED_VOLUME_SNAPSHOT_STATE state);
typedef BOOL(__stdcall* CanResourceBeDependent)(HRESOURCE hResource, HRESOURCE hResourceDependent);
typedef DWORD(__stdcall* ClusterResourceControl)(HRESOURCE hResource, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterResourceControlAsUser)(HRESOURCE hResource, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterResourceTypeControl)(HCLUSTER hCluster, LPCWSTR lpszResourceTypeName, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterResourceTypeControlAsUser)(HCLUSTER hCluster, LPCWSTR lpszResourceTypeName, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterGroupControl)(HGROUP hGroup, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef DWORD(__stdcall* ClusterNodeControl)(HNODE hNode, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef BOOL(__stdcall* GetClusterResourceNetworkName)(HRESOURCE hResource, LPWSTR lpBuffer, LPDWORD nSize);
typedef HRESENUM(__stdcall* ClusterResourceOpenEnum)(HRESOURCE hResource, DWORD dwType);
typedef DWORD(__stdcall* ClusterResourceGetEnumCount)(HRESENUM hResEnum);
typedef DWORD(__stdcall* ClusterResourceEnum)(HRESENUM hResEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterResourceCloseEnum)(HRESENUM hResEnum);
typedef DWORD(__stdcall* CreateClusterResourceType)(HCLUSTER hCluster, LPCWSTR lpszResourceTypeName, LPCWSTR lpszDisplayName, LPCWSTR lpszResourceTypeDll, DWORD dwLooksAlivePollInterval, DWORD dwIsAlivePollInterval);
typedef DWORD(__stdcall* DeleteClusterResourceType)(HCLUSTER hCluster, LPCWSTR lpszResourceTypeName);
typedef HRESTYPEENUM(__stdcall* ClusterResourceTypeOpenEnum)(HCLUSTER hCluster, LPCWSTR lpszResourceTypeName, DWORD dwType);
typedef DWORD(__stdcall* ClusterResourceTypeGetEnumCount)(HRESTYPEENUM hResTypeEnum);
typedef DWORD(__stdcall* ClusterResourceTypeEnum)(HRESTYPEENUM hResTypeEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterResourceTypeCloseEnum)(HRESTYPEENUM hResTypeEnum);
typedef HNETWORK(__stdcall* OpenClusterNetwork)(HCLUSTER hCluster, LPCWSTR lpszNetworkName);
typedef BOOL(__stdcall* CloseClusterNetwork)(HNETWORK hNetwork);
typedef HCLUSTER(__stdcall* GetClusterFromNetwork)(HNETWORK hNetwork);
typedef HNETWORKENUM(__stdcall* ClusterNetworkOpenEnum)(HNETWORK hNetwork, DWORD dwType);
typedef DWORD(__stdcall* ClusterNetworkGetEnumCount)(HNETWORKENUM hNetworkEnum);
typedef DWORD(__stdcall* ClusterNetworkEnum)(HNETWORKENUM hNetworkEnum, DWORD dwIndex, LPDWORD lpdwType, LPWSTR lpszName, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterNetworkCloseEnum)(HNETWORKENUM hNetworkEnum);
typedef CLUSTER_NETWORK_STATE(__stdcall* GetClusterNetworkState)(HNETWORK hNetwork);
typedef DWORD(__stdcall* SetClusterNetworkName)(HNETWORK hNetwork, LPCWSTR lpszName);
typedef DWORD(__stdcall* GetClusterNetworkId)(HNETWORK hNetwork, LPWSTR lpszNetworkId, LPDWORD lpcchName);
typedef DWORD(__stdcall* ClusterNetworkControl)(HNETWORK hNetwork, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef HNETINTERFACE(__stdcall* OpenClusterNetInterface)(HCLUSTER hCluster, LPCWSTR lpszInterfaceName);
typedef DWORD(__stdcall* GetClusterNetInterface)(HCLUSTER hCluster, LPCWSTR lpszNodeName, LPCWSTR lpszNetworkName, LPWSTR lpszInterfaceName, LPDWORD lpcchInterfaceName);
typedef BOOL(__stdcall* CloseClusterNetInterface)(HNETINTERFACE hNetInterface);
typedef HCLUSTER(__stdcall* GetClusterFromNetInterface)(HNETINTERFACE hNetInterface);
typedef CLUSTER_NETINTERFACE_STATE(__stdcall* GetClusterNetInterfaceState)(HNETINTERFACE hNetInterface);
typedef DWORD(__stdcall* ClusterNetInterfaceControl)(HNETINTERFACE hNetInterface, HNODE hHostNode, DWORD dwControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned);
typedef HKEY(__stdcall* GetClusterKey)(HCLUSTER hCluster, REGSAM samDesired);
typedef HKEY(__stdcall* GetClusterGroupKey)(HGROUP hGroup, REGSAM samDesired);
typedef HKEY(__stdcall* GetClusterResourceKey)(HRESOURCE hResource, REGSAM samDesired);
typedef HKEY(__stdcall* GetClusterNodeKey)(HNODE hNode, REGSAM samDesired);
typedef HKEY(__stdcall* GetClusterNetworkKey)(HNETWORK hNetwork, REGSAM samDesired);
typedef HKEY(__stdcall* GetClusterNetInterfaceKey)(HNETINTERFACE hNetInterface, REGSAM samDesired);
typedef LONG(__stdcall* ClusterRegCreateKey)(HKEY hKey, LPCWSTR lpszSubKey, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
typedef LONG(__stdcall* ClusterRegOpenKey)(HKEY hKey, LPCWSTR lpszSubKey, REGSAM samDesired, PHKEY phkResult);
typedef LONG(__stdcall* ClusterRegDeleteKey)(HKEY hKey, LPCWSTR lpszSubKey);
typedef LONG(__stdcall* ClusterRegCloseKey)(HKEY hKey);
typedef LONG(__stdcall* ClusterRegEnumKey)(HKEY hKey, DWORD dwIndex, LPWSTR lpszName, LPDWORD lpcchName, PFILETIME lpftLastWriteTime);
typedef DWORD(__stdcall* ClusterRegDeleteValue)(HKEY hKey, LPCWSTR lpszValueName);
typedef LONG(__stdcall* ClusterRegQueryValue)(HKEY hKey, LPCWSTR lpszValueName, LPDWORD lpdwValueType, LPBYTE lpData, LPDWORD lpcbData);
typedef DWORD(__stdcall* ClusterRegEnumValue)(HKEY hKey, DWORD dwIndex, LPWSTR lpszValueName, LPDWORD lpcchValueName, LPDWORD lpdwType, LPBYTE lpData, LPDWORD lpcbData);
typedef LONG(__stdcall* ClusterRegQueryInfoKey)(HKEY hKey, LPDWORD lpcSubKeys, LPDWORD lpcchMaxSubKeyLen, LPDWORD lpcValues, LPDWORD lpcchMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
typedef LONG(__stdcall* ClusterRegGetKeySecurity)(HKEY hKey, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, LPDWORD lpcbSecurityDescriptor);
typedef LONG(__stdcall* ClusterRegSetKeySecurity)(HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef LONG(__stdcall* ClusterRegSyncDatabase)(HCLUSTER hCluster, DWORD flags);
typedef LONG(__stdcall* ClusterRegBatchCloseNotification)(HREGBATCHNOTIFICATION hBatchNotification);
typedef LONG(__stdcall* ClusterRegCloseBatchNotifyPort)(HREGBATCHPORT hBatchNotifyPort);
typedef LONG(__stdcall* ClusterRegReadBatchAddCommand)(HREGREADBATCH hRegReadBatch, LPCWSTR wzSubkeyName, LPCWSTR wzValueName);
typedef LONG(__stdcall* ClusterRegCloseReadBatchReply)(HREGREADBATCHREPLY hRegReadBatchReply);
typedef DWORD(__stdcall* ClusterSetAccountAccess)(HCLUSTER hCluster, LPCWSTR szAccountSID, DWORD dwAccess, DWORD dwControlType);
typedef HCLUSTER(__stdcall* CreateCluster)(PCREATE_CLUSTER_CONFIG pConfig, PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg);
typedef HCLUSTER(__stdcall* CreateClusterCNOless)(PCREATE_CLUSTER_CONFIG pConfig, PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg);
typedef DWORD(__stdcall* CreateClusterNameAccount)(HCLUSTER hCluster, PCREATE_CLUSTER_NAME_ACCOUNT pConfig, PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg);
typedef DWORD(__stdcall* RegisterClusterResourceTypeNotifyV2)(HCHANGE hChange, HCLUSTER hCluster, LONGLONG Flags, LPCWSTR resTypeName, DWORD_PTR dwNotifyKey);
typedef HNODE(__stdcall* AddClusterNode)(HCLUSTER hCluster, PCWSTR lpszNodeName, PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg);
typedef DWORD(__stdcall* DestroyCluster)(HCLUSTER hCluster, PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, PVOID pvCallbackArg, BOOL fdeleteVirtualComputerObjects);
typedef HRESULT(__stdcall* CoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
typedef HRESULT(__stdcall* CoGetCallerTID)(LPDWORD lpdwTID);
typedef HRESULT(__stdcall* CoDecodeProxy)(DWORD dwClientPid, UINT64 ui64ProxyAddress, PServerInformation pServerInformation);
typedef HRESULT(__stdcall* CoDecrementMTAUsage)(CO_MTA_USAGE_COOKIE Cookie);
typedef HRESULT(__stdcall* CoRevokeClassObject)(DWORD dwRegister);
typedef HRESULT(__stdcall* CoRegisterSurrogate)(LPSURROGATE pSurrogate);
typedef HRESULT(__stdcall* CoMarshalHresult)(LPSTREAM pstm, HRESULT hresult);
typedef HRESULT(__stdcall* CoReleaseMarshalData)(LPSTREAM pStm);
typedef HRESULT(__stdcall* CoDisconnectObject)(LPUNKNOWN pUnk, DWORD dwReserved);
typedef HRESULT(__stdcall* CoLockObjectExternal)(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
typedef BOOL(__stdcall* CoIsHandlerConnected)(LPUNKNOWN pUnk);
typedef void(__stdcall* CoFreeUnusedLibrariesEx)(DWORD dwUnloadDelay, DWORD dwReserved);
typedef HRESULT(__stdcall* CoDisconnectContext)(DWORD dwTimeout);
typedef HRESULT(__stdcall* CoCancelCall)(DWORD dwThreadId, ULONG ulTimeout);
typedef HRESULT(__stdcall* CoEnableCallCancellation)(LPVOID pReserved);
typedef HRESULT(__stdcall* CoDisableCallCancellation)(LPVOID pReserved);
typedef HRESULT(__stdcall* CLSIDFromString)(LPCOLESTR lpsz, LPCLSID pclsid);
typedef HRESULT(__stdcall* IIDFromString)(LPCOLESTR lpsz, LPIID lpiid);
typedef HRESULT(__stdcall* CLSIDFromProgID)(LPCOLESTR lpszProgID, LPCLSID lpclsid);
typedef HRESULT(__stdcall* CoWaitForMultipleHandles)(DWORD dwFlags, DWORD dwTimeout, ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex);
typedef HRESULT(__stdcall* CoInvalidateRemoteMachineBindings)(LPOLESTR pszMachineName);
typedef LPVOID(__stdcall* CoTaskMemAlloc)(SIZE_T cb);
typedef LPVOID(__stdcall* CoTaskMemRealloc)(LPVOID pv, SIZE_T cb);
typedef void(__stdcall* CoTaskMemFree)(LPVOID pv);
typedef HRESULT(__stdcall* CLSIDFromProgIDEx)(LPCOLESTR lpszProgID, LPCLSID lpclsid);
typedef HRESULT(__stdcall* GetConvertStg)(LPSTORAGE pStg);
typedef HIMAGELIST(__stdcall* ImageList_Create)(int cx, int cy, UINT flags, int cInitial, int cGrow);
typedef BOOL(__stdcall* ImageList_Destroy)(HIMAGELIST himl);
typedef int(__stdcall* ImageList_GetImageCount)(HIMAGELIST himl);
typedef BOOL(__stdcall* ImageList_SetImageCount)(HIMAGELIST himl, UINT uNewCount);
typedef int(__stdcall* ImageList_Add)(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);
typedef int(__stdcall* ImageList_ReplaceIcon)(HIMAGELIST himl, int i, HICON hicon);
typedef COLORREF(__stdcall* ImageList_SetBkColor)(HIMAGELIST himl, COLORREF clrBk);
typedef COLORREF(__stdcall* ImageList_GetBkColor)(HIMAGELIST himl);
typedef BOOL(__stdcall* ImageList_SetOverlayImage)(HIMAGELIST himl, int iImage, int iOverlay);
typedef BOOL(__stdcall* ImageList_Draw)(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, UINT fStyle);
typedef BOOL(__stdcall* ImageList_Replace)(HIMAGELIST himl, int i, HBITMAP hbmImage, HBITMAP hbmMask);
typedef int(__stdcall* ImageList_AddMasked)(HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask);
typedef BOOL(__stdcall* ImageList_DrawEx)(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle);
typedef BOOL(__stdcall* ImageList_Remove)(HIMAGELIST himl, int i);
typedef HICON(__stdcall* ImageList_GetIcon)(HIMAGELIST himl, int i, UINT flags);
typedef HIMAGELIST(__stdcall* ImageList_LoadImageA)(HINSTANCE hi, LPCSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
typedef HIMAGELIST(__stdcall* ImageList_LoadImageW)(HINSTANCE hi, LPCWSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
typedef BOOL(__stdcall* ImageList_Copy)(HIMAGELIST himlDst, int iDst, HIMAGELIST himlSrc, int iSrc, UINT uFlags);
typedef BOOL(__stdcall* ImageList_BeginDrag)(HIMAGELIST himlTrack, int iTrack, int dxHotspot, int dyHotspot);
typedef BOOL(__stdcall* ImageList_DragEnter)(HWND hwndLock, int x, int y);
typedef BOOL(__stdcall* ImageList_DragLeave)(HWND hwndLock);
typedef BOOL(__stdcall* ImageList_DragMove)(int x, int y);
typedef BOOL(__stdcall* ImageList_SetDragCursorImage)(HIMAGELIST himlDrag, int iDrag, int dxHotspot, int dyHotspot);
typedef BOOL(__stdcall* ImageList_DragShowNolock)(BOOL fShow);
typedef BOOL(__stdcall* ImageList_SetIconSize)(HIMAGELIST himl, int cx, int cy);
typedef HIMAGELIST(__stdcall* ImageList_Merge)(HIMAGELIST himl1, int i1, HIMAGELIST himl2, int i2, int dx, int dy);
typedef HIMAGELIST(__stdcall* ImageList_Duplicate)(HIMAGELIST himl);
typedef HWND(__stdcall* CreateToolbarEx)(HWND hwnd, DWORD ws, UINT wID, int nBitmaps, HINSTANCE hBMInst, UINT_PTR wBMID, LPCTBBUTTON lpButtons, int iNumButtons, int dxButton, int dyButton, int dxBitmap, int dyBitmap, UINT uStructSize);
typedef HBITMAP(__stdcall* CreateMappedBitmap)(HINSTANCE hInstance, INT_PTR idBitmap, UINT wFlags, LPCOLORMAP lpColorMap, int iNumMaps);
typedef void(__stdcall* DrawStatusTextA)(HDC hDC, LPCRECT lprc, LPCSTR pszText, UINT uFlags);
typedef void(__stdcall* DrawStatusTextW)(HDC hDC, LPCRECT lprc, LPCWSTR pszText, UINT uFlags);
typedef HWND(__stdcall* CreateStatusWindowA)(LONG style, LPCSTR lpszText, HWND hwndParent, UINT wID);
typedef HWND(__stdcall* CreateStatusWindowW)(LONG style, LPCWSTR lpszText, HWND hwndParent, UINT wID);
typedef BOOL(__stdcall* ShowHideMenuCtl)(HWND hWnd, UINT_PTR uFlags, LPINT lpInfo);
typedef BOOL(__stdcall* MakeDragList)(HWND hLB);
typedef void(__stdcall* DrawInsert)(HWND handParent, HWND hLB, int nItem);
typedef int(__stdcall* LBItemFromPt)(HWND hLB, POINT pt, BOOL bAutoScroll);
typedef HWND(__stdcall* CreateUpDownControl)(DWORD dwStyle, int x, int y, int cx, int cy, HWND hParent, int nID, HINSTANCE hInst, HWND hBuddy, int nUpper, int nLower, int nPos);
typedef void(__stdcall* InitMUILanguage)(LANGID uiLang);
typedef BOOL(__stdcall* _TrackMouseEvent)(LPTRACKMOUSEEVENT lpEventTrack);
typedef BOOL(__stdcall* SetWindowSubclass)(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
typedef BOOL(__stdcall* RemoveWindowSubclass)(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass);
typedef LRESULT(__stdcall* DefSubclassProc)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* CreateCompressor)(DWORD Algorithm, PCOMPRESS_ALLOCATION_ROUTINES AllocationRoutines, PCOMPRESSOR_HANDLE CompressorHandle);
typedef BOOL(__stdcall* SetCompressorInformation)(COMPRESSOR_HANDLE CompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, LPCVOID CompressInformation, SIZE_T CompressInformationSize);
typedef BOOL(__stdcall* QueryCompressorInformation)(COMPRESSOR_HANDLE CompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, PVOID CompressInformation, SIZE_T CompressInformationSize);
typedef BOOL(__stdcall* Compress)(COMPRESSOR_HANDLE CompressorHandle, LPCVOID UncompressedData, SIZE_T UncompressedDataSize, PVOID CompressedBuffer, SIZE_T CompressedBufferSize, PSIZE_T CompressedDataSize);
typedef BOOL(__stdcall* ResetCompressor)(COMPRESSOR_HANDLE CompressorHandle);
typedef BOOL(__stdcall* CloseCompressor)(COMPRESSOR_HANDLE CompressorHandle);
typedef BOOL(__stdcall* CreateDecompressor)(DWORD Algorithm, PCOMPRESS_ALLOCATION_ROUTINES AllocationRoutines, PDECOMPRESSOR_HANDLE DecompressorHandle);
typedef BOOL(__stdcall* SetDecompressorInformation)(DECOMPRESSOR_HANDLE DecompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, LPCVOID CompressInformation, SIZE_T CompressInformationSize);
typedef BOOL(__stdcall* QueryDecompressorInformation)(DECOMPRESSOR_HANDLE DecompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, PVOID CompressInformation, SIZE_T CompressInformationSize);
typedef BOOL(__stdcall* Decompress)(DECOMPRESSOR_HANDLE DecompressorHandle, LPCVOID CompressedData, SIZE_T CompressedDataSize, PVOID UncompressedBuffer, SIZE_T UncompressedBufferSize, PSIZE_T UncompressedDataSize);
typedef BOOL(__stdcall* ResetDecompressor)(DECOMPRESSOR_HANDLE DecompressorHandle);
typedef BOOL(__stdcall* CloseDecompressor)(DECOMPRESSOR_HANDLE DecompressorHandle);
typedef HRESULT(__stdcall* RecycleSurrogate)(long lReasonCode);
typedef BOOL(__stdcall* CryptUIDlgCertMgr)(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr);
typedef BOOL(__stdcall* CryptUIWizFreeDigitalSignContext)(PCCRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT pSignContext);
typedef BOOL(__stdcall* CryptUIWizImport)(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore);
typedef HRESULT(__stdcall* CryptXmlClose)(HCRYPTXML hCryptXml);
typedef HRESULT(__stdcall* CryptXmlVerifySignature)(HCRYPTXML hSignature, BCRYPT_KEY_HANDLE hKey, DWORD dwFlags);
typedef DWORD(__stdcall* OfflineFilesStart)();
typedef BOOL(__stdcall* Ellipse)(HDC hdc, int left, int top, int right, int bottom);
typedef FLOAT(__stdcall* D2D1Tan)(FLOAT angle);
typedef FLOAT(__stdcall* D2D1Vec3Length)(FLOAT x, FLOAT y, FLOAT z);
typedef {'name': 'Direct3DCreate9', 'type': 'IDirect3D9'}(__stdcall* Direct3DCreate9)(UINT SDKVersion);
typedef {'name': 'Direct3DCreate9', 'type': 'IDirect3D9'}(__stdcall* Direct3DCreate9)(UINT SDKVersion);
typedef DWORD(__stdcall* DavDeleteConnection)(HANDLE ConnectionHandle);
typedef DWORD(__stdcall* DavGetUNCFromHTTPPath)(LPCWSTR Url, LPWSTR UncPath, LPDWORD lpSize);
typedef DWORD(__stdcall* DavGetHTTPFromUNCPath)(LPCWSTR UncPath, LPWSTR Url, LPDWORD lpSize);
typedef DWORD(__stdcall* DavGetTheLockOwnerOfTheFile)(LPCWSTR FileName, PWSTR LockOwnerName, PULONG LockOwnerNameLengthInBytes);
typedef DWORD(__stdcall* DavFlushFile)(HANDLE hFile);
typedef DWORD(__stdcall* DavInvalidateCache)(LPCWSTR URLName);
typedef DWORD(__stdcall* DavCancelConnectionsToServer)(LPWSTR lpName, BOOL fForce);
typedef DWORD(__stdcall* DavRegisterAuthCallback)(PFNDAVAUTHCALLBACK CallBack, ULONG Version);
typedef void(__stdcall* DavUnregisterAuthCallback)(DWORD hCallback);
typedef HANDLE(__stdcall* SymFindDebugInfoFile)(HANDLE hProcess, PCSTR FileName, PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData);
typedef HANDLE(__stdcall* SymFindDebugInfoFileW)(HANDLE hProcess, PCWSTR FileName, PWSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACKW Callback, PVOID CallerData);
typedef HANDLE(__stdcall* FindDebugInfoFile)(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath);
typedef HANDLE(__stdcall* FindDebugInfoFileEx)(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData);
typedef HANDLE(__stdcall* FindDebugInfoFileExW)(PCWSTR FileName, PCWSTR SymbolPath, PWSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACKW Callback, PVOID CallerData);
typedef BOOL(__stdcall* SymFindFileInPath)(HANDLE hprocess, PCSTR SearchPathA, PCSTR FileName, PVOID id, DWORD two, DWORD three, DWORD flags, PSTR FoundFile, PFINDFILEINPATHCALLBACK callback, PVOID context);
typedef BOOL(__stdcall* SymFindFileInPathW)(HANDLE hprocess, PCWSTR SearchPathA, PCWSTR FileName, PVOID id, DWORD two, DWORD three, DWORD flags, PWSTR FoundFile, PFINDFILEINPATHCALLBACKW callback, PVOID context);
typedef HANDLE(__stdcall* SymFindExecutableImage)(HANDLE hProcess, PCSTR FileName, PSTR ImageFilePath, PFIND_EXE_FILE_CALLBACK Callback, PVOID CallerData);
typedef HANDLE(__stdcall* SymFindExecutableImageW)(HANDLE hProcess, PCWSTR FileName, PWSTR ImageFilePath, PFIND_EXE_FILE_CALLBACKW Callback, PVOID CallerData);
typedef HANDLE(__stdcall* FindExecutableImage)(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath);
typedef HANDLE(__stdcall* FindExecutableImageEx)(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath, PFIND_EXE_FILE_CALLBACK Callback, PVOID CallerData);
typedef HANDLE(__stdcall* FindExecutableImageExW)(PCWSTR FileName, PCWSTR SymbolPath, PWSTR ImageFilePath, PFIND_EXE_FILE_CALLBACKW Callback, PVOID CallerData);
typedef PIMAGE_NT_HEADERS(__stdcall* ImageNtHeader)(PVOID Base);
typedef PVOID(__stdcall* ImageDirectoryEntryToData)(PVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
typedef PIMAGE_SECTION_HEADER(__stdcall* ImageRvaToSection)(PIMAGE_NT_HEADERS NtHeaders, PVOID Base, ULONG Rva);
typedef BOOL(__stdcall* SearchTreeForFile)(PCSTR RootPath, PCSTR InputPathName, PSTR OutputPathBuffer);
typedef BOOL(__stdcall* SearchTreeForFileW)(PCWSTR RootPath, PCWSTR InputPathName, PWSTR OutputPathBuffer);
typedef BOOL(__stdcall* EnumDirTree)(HANDLE hProcess, PCSTR RootPath, PCSTR InputPathName, PSTR OutputPathBuffer, PENUMDIRTREE_CALLBACK cb, PVOID data);
typedef BOOL(__stdcall* EnumDirTreeW)(HANDLE hProcess, PCWSTR RootPath, PCWSTR InputPathName, PWSTR OutputPathBuffer, PENUMDIRTREE_CALLBACKW cb, PVOID data);
typedef BOOL(__stdcall* MakeSureDirectoryPathExists)(PCSTR DirPath);
typedef DWORD(__stdcall* UnDecorateSymbolName)(PCSTR name, PSTR outputString, DWORD maxStringLength, DWORD flags);
typedef DWORD(__stdcall* UnDecorateSymbolNameW)(PCWSTR name, PWSTR outputString, DWORD maxStringLength, DWORD flags);
typedef BOOL(__stdcall* StackWalk64)(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
typedef BOOL(__stdcall* StackWalkEx)(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME_EX StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress, DWORD Flags);
typedef LPAPI_VERSION(__stdcall* ImagehlpApiVersionEx)(LPAPI_VERSION AppVersion);
typedef DWORD(__stdcall* GetTimestampForLoadedLibrary)(HMODULE Module);
typedef BOOL(__stdcall* SymSetParentWindow)(HWND hwnd);
typedef PCHAR(__stdcall* SymSetHomeDirectory)(HANDLE hProcess, PCSTR dir);
typedef PWSTR(__stdcall* SymSetHomeDirectoryW)(HANDLE hProcess, PCWSTR dir);
typedef PCHAR(__stdcall* SymGetHomeDirectory)(DWORD type, PSTR dir, size_t size);
typedef PWSTR(__stdcall* SymGetHomeDirectoryW)(DWORD type, PWSTR dir, size_t size);
typedef DWORD(__stdcall* SymSetOptions)(DWORD SymOptions);
typedef BOOL(__stdcall* SymCleanup)(HANDLE hProcess);
typedef BOOL(__stdcall* SymGetExtendedOption)(IMAGEHLP_EXTENDED_OPTIONS option);
typedef BOOL(__stdcall* SymSetExtendedOption)(IMAGEHLP_EXTENDED_OPTIONS option, BOOL value);
typedef BOOL(__stdcall* SymMatchString)(PCSTR string, PCSTR expression, BOOL fCase);
typedef BOOL(__stdcall* SymMatchStringW)(PCWSTR string, PCWSTR expression, BOOL fCase);
typedef BOOL(__stdcall* SymEnumSourceFiles)(HANDLE hProcess, ULONG64 ModBase, PCSTR Mask, PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumSourceFilesW)(HANDLE hProcess, ULONG64 ModBase, PCWSTR Mask, PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumerateModules64)(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumerateModulesW64)(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext);
typedef BOOL(__stdcall* EnumerateLoadedModulesEx)(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, PVOID UserContext);
typedef BOOL(__stdcall* EnumerateLoadedModulesExW)(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext);
typedef BOOL(__stdcall* EnumerateLoadedModules64)(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, PVOID UserContext);
typedef BOOL(__stdcall* EnumerateLoadedModulesW64)(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext);
typedef PVOID(__stdcall* SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
typedef PVOID(__stdcall* SymFunctionTableAccess64AccessRoutines)(HANDLE hProcess, DWORD64 AddrBase, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine);
typedef BOOL(__stdcall* SymGetModuleInfo64)(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULE64 ModuleInfo);
typedef BOOL(__stdcall* SymGetModuleInfoW64)(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULEW64 ModuleInfo);
typedef DWORD64(__stdcall* SymGetModuleBase64)(HANDLE hProcess, DWORD64 qwAddr);
typedef BOOL(__stdcall* SymEnumLines)(HANDLE hProcess, ULONG64 Base, PCSTR Obj, PCSTR File, PSYM_ENUMLINES_CALLBACK EnumLinesCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumLinesW)(HANDLE hProcess, ULONG64 Base, PCWSTR Obj, PCWSTR File, PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymGetLineFromAddr64)(HANDLE hProcess, DWORD64 qwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line64);
typedef BOOL(__stdcall* SymGetLineFromAddrW64)(HANDLE hProcess, DWORD64 dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line);
typedef BOOL(__stdcall* SymGetLineFromInlineContext)(HANDLE hProcess, DWORD64 qwAddr, ULONG InlineContext, DWORD64 qwModuleBaseAddress, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line64);
typedef BOOL(__stdcall* SymGetLineFromInlineContextW)(HANDLE hProcess, DWORD64 dwAddr, ULONG InlineContext, DWORD64 qwModuleBaseAddress, PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line);
typedef BOOL(__stdcall* SymEnumSourceLines)(HANDLE hProcess, ULONG64 Base, PCSTR Obj, PCSTR File, DWORD Line, DWORD Flags, PSYM_ENUMLINES_CALLBACK EnumLinesCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumSourceLinesW)(HANDLE hProcess, ULONG64 Base, PCWSTR Obj, PCWSTR File, DWORD Line, DWORD Flags, PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, PVOID UserContext);
typedef DWORD(__stdcall* SymAddrIncludeInlineTrace)(HANDLE hProcess, DWORD64 Address);
typedef DWORD(__stdcall* SymCompareInlineTrace)(HANDLE hProcess, DWORD64 Address1, DWORD InlineContext1, DWORD64 RetAddress1, DWORD64 Address2, DWORD64 RetAddress2);
typedef BOOL(__stdcall* SymQueryInlineTrace)(HANDLE hProcess, DWORD64 StartAddress, DWORD StartContext, DWORD64 StartRetAddress, DWORD64 CurAddress, LPDWORD CurContext, LPDWORD CurFrameIndex);
typedef BOOL(__stdcall* SymGetLineFromName64)(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName, DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINE64 Line);
typedef BOOL(__stdcall* SymGetLineFromNameW64)(HANDLE hProcess, PCWSTR ModuleName, PCWSTR FileName, DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINEW64 Line);
typedef BOOL(__stdcall* SymGetLineNext64)(HANDLE hProcess, PIMAGEHLP_LINE64 Line);
typedef BOOL(__stdcall* SymGetLineNextW64)(HANDLE hProcess, PIMAGEHLP_LINEW64 Line);
typedef BOOL(__stdcall* SymGetLinePrev64)(HANDLE hProcess, PIMAGEHLP_LINE64 Line);
typedef BOOL(__stdcall* SymGetLinePrevW64)(HANDLE hProcess, PIMAGEHLP_LINEW64 Line);
typedef ULONG(__stdcall* SymGetFileLineOffsets64)(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName, PDWORD64 Buffer, ULONG BufferLines);
typedef BOOL(__stdcall* SymGetSourceFile)(HANDLE hProcess, ULONG64 Base, PCSTR Params, PCSTR FileSpec, PSTR FilePath, DWORD Size);
typedef BOOL(__stdcall* SymGetSourceFileW)(HANDLE hProcess, ULONG64 Base, PCWSTR Params, PCWSTR FileSpec, PWSTR FilePath, DWORD Size);
typedef BOOL(__stdcall* SymGetSourceFileFromToken)(HANDLE hProcess, PVOID Token, PCSTR Params, PSTR FilePath, DWORD Size);
typedef BOOL(__stdcall* SymGetSourceFileFromTokenW)(HANDLE hProcess, PVOID Token, PCWSTR Params, PWSTR FilePath, DWORD Size);
typedef BOOL(__stdcall* SymGetSourceVarFromToken)(HANDLE hProcess, PVOID Token, PCSTR Params, PCSTR VarName, PSTR Value, DWORD Size);
typedef BOOL(__stdcall* SymGetSourceVarFromTokenW)(HANDLE hProcess, PVOID Token, PCWSTR Params, PCWSTR VarName, PWSTR Value, DWORD Size);
typedef BOOL(__stdcall* SymEnumSourceFileTokens)(HANDLE hProcess, ULONG64 Base, PENUMSOURCEFILETOKENSCALLBACK Callback);
typedef BOOL(__stdcall* SymInitialize)(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess);
typedef BOOL(__stdcall* SymInitializeW)(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess);
typedef BOOL(__stdcall* SymGetSearchPath)(HANDLE hProcess, PSTR SearchPathA, DWORD SearchPathLength);
typedef BOOL(__stdcall* SymGetSearchPathW)(HANDLE hProcess, PWSTR SearchPathA, DWORD SearchPathLength);
typedef BOOL(__stdcall* SymSetSearchPath)(HANDLE hProcess, PCSTR SearchPathA);
typedef BOOL(__stdcall* SymSetSearchPathW)(HANDLE hProcess, PCWSTR SearchPathA);
typedef DWORD64(__stdcall* SymLoadModuleEx)(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags);
typedef DWORD64(__stdcall* SymLoadModuleExW)(HANDLE hProcess, HANDLE hFile, PCWSTR ImageName, PCWSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags);
typedef BOOL(__stdcall* SymUnloadModule64)(HANDLE hProcess, DWORD64 BaseOfDll);
typedef BOOL(__stdcall* SymUnDName64)(PIMAGEHLP_SYMBOL64 sym, PSTR UnDecName, DWORD UnDecNameLength);
typedef BOOL(__stdcall* SymRegisterCallback64)(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext);
typedef BOOL(__stdcall* SymRegisterCallbackW64)(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext);
typedef BOOL(__stdcall* SymRegisterFunctionEntryCallback64)(HANDLE hProcess, PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction, ULONG64 UserContext);
typedef BOOL(__stdcall* SymSetContext)(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame, PIMAGEHLP_CONTEXT Context);
typedef BOOL(__stdcall* SymSetScopeFromAddr)(HANDLE hProcess, ULONG64 Address);
typedef BOOL(__stdcall* SymSetScopeFromInlineContext)(HANDLE hProcess, ULONG64 Address, ULONG InlineContext);
typedef BOOL(__stdcall* SymSetScopeFromIndex)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index);
typedef BOOL(__stdcall* SymEnumProcesses)(PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymFromAddr)(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymFromAddrW)(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymFromInlineContext)(HANDLE hProcess, DWORD64 Address, ULONG InlineContext, PDWORD64 Displacement, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymFromInlineContextW)(HANDLE hProcess, DWORD64 Address, ULONG InlineContext, PDWORD64 Displacement, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymFromToken)(HANDLE hProcess, DWORD64 Base, DWORD Token, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymFromTokenW)(HANDLE hProcess, DWORD64 Base, DWORD Token, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymNext)(HANDLE hProcess, PSYMBOL_INFO si);
typedef BOOL(__stdcall* SymNextW)(HANDLE hProcess, PSYMBOL_INFOW siw);
typedef BOOL(__stdcall* SymPrev)(HANDLE hProcess, PSYMBOL_INFO si);
typedef BOOL(__stdcall* SymPrevW)(HANDLE hProcess, PSYMBOL_INFOW siw);
typedef BOOL(__stdcall* SymFromName)(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymFromNameW)(HANDLE hProcess, PCWSTR Name, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymEnumSymbols)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumSymbolsEx)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext, DWORD Options);
typedef BOOL(__stdcall* SymEnumSymbolsW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumSymbolsExW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext, DWORD Options);
typedef BOOL(__stdcall* SymEnumSymbolsForAddr)(HANDLE hProcess, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumSymbolsForAddrW)(HANDLE hProcess, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymSearch)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, DWORD SymTag, PCSTR Mask, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext, DWORD Options);
typedef BOOL(__stdcall* SymSearchW)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, DWORD SymTag, PCWSTR Mask, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext, DWORD Options);
typedef BOOL(__stdcall* SymGetScope)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymGetScopeW)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymFromIndex)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymFromIndexW)(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymGetTypeInfo)(HANDLE hProcess, DWORD64 ModBase, ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType, PVOID pInfo);
typedef BOOL(__stdcall* SymGetTypeInfoEx)(HANDLE hProcess, DWORD64 ModBase, PIMAGEHLP_GET_TYPE_INFO_PARAMS Params);
typedef BOOL(__stdcall* SymEnumTypes)(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumTypesW)(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumTypesByName)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumTypesByNameW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymGetTypeFromName)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* SymGetTypeFromNameW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, PSYMBOL_INFOW Symbol);
typedef BOOL(__stdcall* SymAddSymbol)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, DWORD64 Address, DWORD Size, DWORD Flags);
typedef BOOL(__stdcall* SymAddSymbolW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, DWORD64 Address, DWORD Size, DWORD Flags);
typedef BOOL(__stdcall* SymDeleteSymbol)(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, DWORD64 Address, DWORD Flags);
typedef BOOL(__stdcall* SymDeleteSymbolW)(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, DWORD64 Address, DWORD Flags);
typedef BOOL(__stdcall* SymRefreshModuleList)(HANDLE hProcess);
typedef BOOL(__stdcall* SymAddSourceStream)(HANDLE hProcess, ULONG64 Base, PCSTR StreamFile, PBYTE Buffer, size_t Size);
typedef BOOL(__stdcall* SymAddSourceStreamW)(HANDLE hProcess, ULONG64 Base, PCWSTR FileSpec, PBYTE Buffer, size_t Size);
typedef BOOL(__stdcall* SymSrvIsStoreW)(HANDLE hProcess, PCWSTR path);
typedef BOOL(__stdcall* SymSrvIsStore)(HANDLE hProcess, PCSTR path);
typedef PCSTR(__stdcall* SymSrvDeltaName)(HANDLE hProcess, PCSTR SymPath, PCSTR Type, PCSTR File1, PCSTR File2);
typedef PCWSTR(__stdcall* SymSrvDeltaNameW)(HANDLE hProcess, PCWSTR SymPath, PCWSTR Type, PCWSTR File1, PCWSTR File2);
typedef PCSTR(__stdcall* SymSrvGetSupplement)(HANDLE hProcess, PCSTR SymPath, PCSTR Node, PCSTR File);
typedef PCWSTR(__stdcall* SymSrvGetSupplementW)(HANDLE hProcess, PCWSTR SymPath, PCWSTR Node, PCWSTR File);
typedef BOOL(__stdcall* SymSrvGetFileIndexStringW)(HANDLE hProcess, PCWSTR SrvPath, PCWSTR File, PWSTR Index, size_t Size, DWORD Flags);
typedef BOOL(__stdcall* SymSrvGetFileIndexString)(HANDLE hProcess, PCSTR SrvPath, PCSTR File, PSTR Index, size_t Size, DWORD Flags);
typedef BOOL(__stdcall* SymSrvGetFileIndexInfo)(PCSTR File, PSYMSRV_INDEX_INFO Info, DWORD Flags);
typedef BOOL(__stdcall* SymSrvGetFileIndexInfoW)(PCWSTR File, PSYMSRV_INDEX_INFOW Info, DWORD Flags);
typedef PCSTR(__stdcall* SymSrvStoreSupplement)(HANDLE hProcess, PCSTR SrvPath, PCSTR Node, PCSTR File, DWORD Flags);
typedef PCWSTR(__stdcall* SymSrvStoreSupplementW)(HANDLE hProcess, PCWSTR SymPath, PCWSTR Node, PCWSTR File, DWORD Flags);
typedef PCSTR(__stdcall* SymSrvStoreFile)(HANDLE hProcess, PCSTR SrvPath, PCSTR File, DWORD Flags);
typedef PCWSTR(__stdcall* SymSrvStoreFileW)(HANDLE hProcess, PCWSTR SrvPath, PCWSTR File, DWORD Flags);
typedef BOOL(__stdcall* SymGetSymbolFile)(HANDLE hProcess, PCSTR SymPath, PCSTR ImageFile, DWORD Type, PSTR SymbolFile, size_t cSymbolFile, PSTR DbgFile, size_t cDbgFile);
typedef BOOL(__stdcall* SymGetSymbolFileW)(HANDLE hProcess, PCWSTR SymPath, PCWSTR ImageFile, DWORD Type, PWSTR SymbolFile, size_t cSymbolFile, PWSTR DbgFile, size_t cDbgFile);
typedef BOOL(__stdcall* SymGetSymFromAddr64)(HANDLE hProcess, DWORD64 qwAddr, PDWORD64 pdwDisplacement, PIMAGEHLP_SYMBOL64 Symbol);
typedef BOOL(__stdcall* SymGetSymFromName64)(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL64 Symbol);
typedef BOOL(__stdcall* SymEnumerateSymbols64)(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback, PVOID UserContext);
typedef BOOL(__stdcall* SymEnumerateSymbolsW64)(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback, PVOID UserContext);
typedef DWORD64(__stdcall* SymLoadModule64)(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll);
typedef BOOL(__stdcall* SymGetSymNext64)(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol);
typedef BOOL(__stdcall* SymGetSymPrev64)(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol);
typedef void(__stdcall* SetSymLoadError)(DWORD error);
typedef void(__stdcall* DCICloseProvider)(HDC hdc);
typedef void(__stdcall* DCIEndAccess)(LPDCISURFACEINFO pdci);
typedef DCIRVAL(__stdcall* DCIBeginAccess)(LPDCISURFACEINFO pdci, int x, int y, int dx, int dy);
typedef void(__stdcall* DCIDestroy)(LPDCISURFACEINFO pdci);
typedef BOOL(__stdcall* ImpersonateDdeClientWindow)(HWND hWndClient, HWND hWndServer);
typedef LPARAM(__stdcall* PackDDElParam)(UINT msg, UINT_PTR uiLo, UINT_PTR uiHi);
typedef BOOL(__stdcall* UnpackDDElParam)(UINT msg, LPARAM lParam, PUINT_PTR puiLo, PUINT_PTR puiHi);
typedef BOOL(__stdcall* FreeDDElParam)(UINT msg, LPARAM lParam);
typedef LPARAM(__stdcall* ReuseDDElParam)(LPARAM lParam, UINT msgIn, UINT msgOut, UINT_PTR uiLo, UINT_PTR uiHi);
typedef UINT(__stdcall* DdeInitializeA)(LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes);
typedef UINT(__stdcall* DdeInitializeW)(LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes);
typedef BOOL(__stdcall* DdeUninitialize)(DWORD idInst);
typedef HCONVLIST(__stdcall* DdeConnectList)(DWORD idInst, HSZ hszService, HSZ hszTopic, HCONVLIST hConvList, PCONVCONTEXT pCC);
typedef HCONV(__stdcall* DdeQueryNextServer)(HCONVLIST hConvList, HCONV hConvPrev);
typedef BOOL(__stdcall* DdeDisconnectList)(HCONVLIST hConvList);
typedef HCONV(__stdcall* DdeConnect)(DWORD idInst, HSZ hszService, HSZ hszTopic, PCONVCONTEXT pCC);
typedef BOOL(__stdcall* DdeDisconnect)(HCONV hConv);
typedef HCONV(__stdcall* DdeReconnect)(HCONV hConv);
typedef UINT(__stdcall* DdeQueryConvInfo)(HCONV hConv, DWORD idTransaction, PCONVINFO pConvInfo);
typedef BOOL(__stdcall* DdeSetUserHandle)(HCONV hConv, DWORD id, DWORD_PTR hUser);
typedef BOOL(__stdcall* DdeAbandonTransaction)(DWORD idInst, HCONV hConv, DWORD idTransaction);
typedef BOOL(__stdcall* DdePostAdvise)(DWORD idInst, HSZ hszTopic, HSZ hszItem);
typedef BOOL(__stdcall* DdeEnableCallback)(DWORD idInst, HCONV hConv, UINT wCmd);
typedef BOOL(__stdcall* DdeImpersonateClient)(HCONV hConv);
typedef HDDEDATA(__stdcall* DdeNameService)(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd);
typedef HDDEDATA(__stdcall* DdeClientTransaction)(LPBYTE pData, DWORD cbData, HCONV hConv, HSZ hszItem, UINT wFmt, UINT wType, DWORD dwTimeout, LPDWORD pdwResult);
typedef HDDEDATA(__stdcall* DdeCreateDataHandle)(DWORD idInst, LPBYTE pSrc, DWORD cb, DWORD cbOff, HSZ hszItem, UINT wFmt, UINT afCmd);
typedef HDDEDATA(__stdcall* DdeAddData)(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff);
typedef DWORD(__stdcall* DdeGetData)(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff);
typedef LPBYTE(__stdcall* DdeAccessData)(HDDEDATA hData, LPDWORD pcbDataSize);
typedef BOOL(__stdcall* DdeUnaccessData)(HDDEDATA hData);
typedef BOOL(__stdcall* DdeFreeDataHandle)(HDDEDATA hData);
typedef UINT(__stdcall* DdeGetLastError)(DWORD idInst);
typedef HSZ(__stdcall* DdeCreateStringHandleA)(DWORD idInst, LPCSTR psz, int iCodePage);
typedef HSZ(__stdcall* DdeCreateStringHandleW)(DWORD idInst, LPCWSTR psz, int iCodePage);
typedef DWORD(__stdcall* DdeQueryStringA)(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, int iCodePage);
typedef DWORD(__stdcall* DdeQueryStringW)(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, int iCodePage);
typedef BOOL(__stdcall* DdeFreeStringHandle)(DWORD idInst, HSZ hsz);
typedef BOOL(__stdcall* DdeKeepStringHandle)(DWORD idInst, HSZ hsz);
typedef int(__stdcall* DdeCmpStringHandles)(HSZ hsz1, HSZ hsz2);
typedef HRESULT(__stdcall* DirectDrawEnumerateW)(LPDDENUMCALLBACKW lpCallback, LPVOID lpContext);
typedef HRESULT(__stdcall* DirectDrawEnumerateExW)(LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags);
typedef HRESULT(__stdcall* DirectDrawEnumerateExA)(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
typedef void(__stdcall* OutputDebugStringA)(LPCSTR lpOutputString);
typedef void(__stdcall* OutputDebugStringW)(LPCWSTR lpOutputString);
typedef BOOL(__stdcall* ContinueDebugEvent)(DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus);
typedef BOOL(__stdcall* WaitForDebugEvent)(LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds);
typedef BOOL(__stdcall* DebugActiveProcess)(DWORD dwProcessId);
typedef BOOL(__stdcall* DebugActiveProcessStop)(DWORD dwProcessId);
typedef BOOL(__stdcall* CheckRemoteDebuggerPresent)(HANDLE hProcess, PBOOL pbDebuggerPresent);
typedef BOOL(__stdcall* WaitForDebugEventEx)(LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds);
typedef DWORD(__stdcall* DhcpCApiInitialize)(LPDWORD Version);
typedef DWORD(__stdcall* DhcpRequestParams)(DWORD Flags, LPVOID Reserved, LPWSTR AdapterName, LPDHCPCAPI_CLASSID ClassId, DHCPCAPI_PARAMS_ARRAY SendParams, DHCPCAPI_PARAMS_ARRAY RecdParams, LPBYTE Buffer, LPDWORD pSize, LPWSTR RequestIdStr);
typedef DWORD(__stdcall* DhcpUndoRequestParams)(DWORD Flags, LPVOID Reserved, LPWSTR AdapterName, LPWSTR RequestIdStr);
typedef DWORD(__stdcall* DhcpRegisterParamChange)(DWORD Flags, LPVOID Reserved, LPWSTR AdapterName, LPDHCPCAPI_CLASSID ClassId, DHCPCAPI_PARAMS_ARRAY Params, LPVOID Handle);
typedef DWORD(__stdcall* DhcpDeRegisterParamChange)(DWORD Flags, LPVOID Reserved, LPVOID Event);
typedef void(__stdcall* DhcpRpcFreeMemory)(PVOID BufferPointer);
typedef DWORD(__stdcall* DhcpGetVersion)(LPWSTR ServerIpAddress, LPDWORD MajorVersion, LPDWORD MinorVersion);
typedef DWORD(__stdcall* DhcpCreateOptionV5)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionId, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION OptionInfo);
typedef DWORD(__stdcall* DhcpSetOptionInfoV5)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION OptionInfo);
typedef DWORD(__stdcall* DhcpRemoveOptionV5)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName);
typedef DWORD(__stdcall* DhcpSetOptionValueV5)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionId, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo, LPDHCP_OPTION_DATA OptionValue);
typedef DWORD(__stdcall* DhcpSetOptionValuesV5)(LPWSTR ServerIpAddress, DWORD Flags, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo, LPDHCP_OPTION_VALUE_ARRAY OptionValues);
typedef DWORD(__stdcall* DhcpRemoveOptionValueV5)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo);
typedef DWORD(__stdcall* DhcpCreateClass)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPDHCP_CLASS_INFO ClassInfo);
typedef DWORD(__stdcall* DhcpModifyClass)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPDHCP_CLASS_INFO ClassInfo);
typedef DWORD(__stdcall* DhcpDeleteClass)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPWSTR ClassName);
typedef DWORD(__stdcall* DhcpAddServer)(DWORD Flags, LPVOID IdInfo, LPDHCP_SERVER_INFO NewServer, LPVOID CallbackFn, LPVOID CallbackData);
typedef DWORD(__stdcall* DhcpDeleteServer)(DWORD Flags, LPVOID IdInfo, LPDHCP_SERVER_INFO NewServer, LPVOID CallbackFn, LPVOID CallbackData);
typedef DWORD(__stdcall* DhcpCreateOptionV6)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionId, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION OptionInfo);
typedef DWORD(__stdcall* DhcpRemoveOptionV6)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName);
typedef DWORD(__stdcall* DhcpRemoveOptionValueV6)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO6 ScopeInfo);
typedef DWORD(__stdcall* DhcpSetOptionInfoV6)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION OptionInfo);
typedef DWORD(__stdcall* DhcpSetOptionValueV6)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionId, LPWSTR ClassName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO6 ScopeInfo, LPDHCP_OPTION_DATA OptionValue);
typedef DWORD(__stdcall* DhcpSetThreadOptions)(DWORD Flags, LPVOID Reserved);
typedef DWORD(__stdcall* DhcpGetThreadOptions)(LPDWORD pFlags, LPVOID Reserved);
typedef DWORD(__stdcall* DhcpServerRedoAuthorization)(LPWSTR ServerIpAddr, ULONG dwReserved);
typedef DWORD(__stdcall* DhcpAuditLogSetParams)(LPWSTR ServerIpAddress, DWORD Flags, LPWSTR AuditLogDir, DWORD DiskCheckInterval, DWORD MaxLogFilesSize, DWORD MinSpaceOnDisk);
typedef DWORD(__stdcall* DhcpServerQueryDnsRegCredentials)(LPWSTR ServerIpAddress, ULONG UnameSize, LPWSTR Uname, ULONG DomainSize, LPWSTR Domain);
typedef DWORD(__stdcall* DhcpServerSetDnsRegCredentialsV5)(LPWSTR ServerIpAddress, LPWSTR Uname, LPWSTR Domain, LPWSTR Passwd);
typedef DWORD(__stdcall* DhcpServerBackupDatabase)(LPWSTR ServerIpAddress, LPWSTR Path);
typedef DWORD(__stdcall* DhcpServerRestoreDatabase)(LPWSTR ServerIpAddress, LPWSTR Path);
typedef DWORD(__stdcall* DhcpCreateSubnetV6)(LPWSTR ServerIpAddress, DHCP_IPV6_ADDRESS SubnetAddress, LPDHCP_SUBNET_INFO_V6 SubnetInfo);
typedef DWORD(__stdcall* DhcpDeleteSubnetV6)(LPWSTR ServerIpAddress, DHCP_IPV6_ADDRESS SubnetAddress, DHCP_FORCE_FLAG ForceFlag);
typedef DWORD(__stdcall* DhcpAddSubnetElementV6)(LPWSTR ServerIpAddress, DHCP_IPV6_ADDRESS SubnetAddress, LPDHCP_SUBNET_ELEMENT_DATA_V6 AddElementInfo);
typedef DWORD(__stdcall* DhcpRemoveSubnetElementV6)(LPWSTR ServerIpAddress, DHCP_IPV6_ADDRESS SubnetAddress, LPDHCP_SUBNET_ELEMENT_DATA_V6 RemoveElementInfo, DHCP_FORCE_FLAG ForceFlag);
typedef DWORD(__stdcall* DhcpCreateClassV6)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPDHCP_CLASS_INFO_V6 ClassInfo);
typedef DWORD(__stdcall* DhcpModifyClassV6)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPDHCP_CLASS_INFO_V6 ClassInfo);
typedef DWORD(__stdcall* DhcpDeleteClassV6)(LPWSTR ServerIpAddress, DWORD ReservedMustBeZero, LPWSTR ClassName);
typedef DWORD(__stdcall* DhcpSetSubnetDelayOffer)(LPWSTR ServerIpAddress, DHCP_IP_ADDRESS SubnetAddress, USHORT TimeDelayInMilliseconds);
typedef DWORD(__stdcall* DhcpV4SetOptionValue)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionId, LPWSTR PolicyName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo, LPDHCP_OPTION_DATA OptionValue);
typedef DWORD(__stdcall* DhcpV4SetOptionValues)(LPWSTR ServerIpAddress, DWORD Flags, LPWSTR PolicyName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo, LPDHCP_OPTION_VALUE_ARRAY OptionValues);
typedef DWORD(__stdcall* DhcpV4RemoveOptionValue)(LPWSTR ServerIpAddress, DWORD Flags, DHCP_OPTION_ID OptionID, LPWSTR PolicyName, LPWSTR VendorName, LPDHCP_OPTION_SCOPE_INFO ScopeInfo);
typedef DWORD(__stdcall* DhcpV4FailoverCreateRelationship)(LPWSTR ServerIpAddress, LPDHCP_FAILOVER_RELATIONSHIP pRelationship);
typedef DWORD(__stdcall* DhcpV4FailoverSetRelationship)(LPWSTR ServerIpAddress, DWORD Flags, LPDHCP_FAILOVER_RELATIONSHIP pRelationship);
typedef DWORD(__stdcall* DhcpV4FailoverDeleteRelationship)(LPWSTR ServerIpAddress, LPWSTR pRelationshipName);
typedef DWORD(__stdcall* DhcpV4FailoverAddScopeToRelationship)(LPWSTR ServerIpAddress, LPDHCP_FAILOVER_RELATIONSHIP pRelationship);
typedef DWORD(__stdcall* DhcpV4FailoverDeleteScopeFromRelationship)(LPWSTR ServerIpAddress, LPDHCP_FAILOVER_RELATIONSHIP pRelationship);
typedef DWORD(__stdcall* DhcpV4FailoverGetSystemTime)(LPWSTR ServerIpAddress, LPDWORD pTime, LPDWORD pMaxAllowedDeltaTime);
typedef DWORD(__stdcall* DhcpV4FailoverGetAddressStatus)(LPWSTR ServerIpAddress, DHCP_IP_ADDRESS SubnetAddress, LPDWORD pStatus);
typedef DWORD(__stdcall* DhcpV4FailoverTriggerAddrAllocation)(LPWSTR ServerIpAddress, LPWSTR pFailRelName);
typedef DWORD(__stdcall* DhcpHlprAddV4PolicyRange)(LPDHCP_POLICY Policy, LPDHCP_IP_RANGE Range);
typedef DWORD(__stdcall* DhcpHlprResetV4PolicyExpr)(LPDHCP_POLICY Policy);
typedef DWORD(__stdcall* DhcpHlprModifyV4PolicyExpr)(LPDHCP_POLICY Policy, DHCP_POL_LOGIC_OPER Operator);
typedef void(__stdcall* DhcpHlprFreeV4Policy)(LPDHCP_POLICY Policy);
typedef BOOL(__stdcall* DhcpHlprIsV4PolicySingleUC)(LPDHCP_POLICY Policy);
typedef DWORD(__stdcall* DhcpV4SetPolicyEnforcement)(LPWSTR ServerIpAddress, BOOL fGlobalPolicy, DHCP_IP_ADDRESS SubnetAddress, BOOL Enable);
typedef BOOL(__stdcall* DhcpHlprIsV4PolicyWellFormed)(LPDHCP_POLICY pPolicy);
typedef DWORD(__stdcall* DhcpHlprIsV4PolicyValid)(LPDHCP_POLICY pPolicy);
typedef DWORD(__stdcall* DhcpV4CreatePolicy)(LPWSTR ServerIpAddress, LPDHCP_POLICY pPolicy);
typedef DWORD(__stdcall* DhcpV4SetPolicy)(LPWSTR ServerIpAddress, DWORD FieldsModified, BOOL fGlobalPolicy, DHCP_IP_ADDRESS SubnetAddress, LPWSTR PolicyName, LPDHCP_POLICY Policy);
typedef DWORD(__stdcall* DhcpV4DeletePolicy)(LPWSTR ServerIpAddress, BOOL fGlobalPolicy, DHCP_IP_ADDRESS SubnetAddress, LPWSTR PolicyName);
typedef DWORD(__stdcall* DhcpV4AddPolicyRange)(LPWSTR ServerIpAddress, DHCP_IP_ADDRESS SubnetAddress, LPWSTR PolicyName, LPDHCP_IP_RANGE Range);
typedef DWORD(__stdcall* DhcpV4RemovePolicyRange)(LPWSTR ServerIpAddress, DHCP_IP_ADDRESS SubnetAddress, LPWSTR PolicyName, LPDHCP_IP_RANGE Range);
typedef DWORD(__stdcall* DhcpV6SetStatelessStoreParams)(LPWSTR ServerIpAddress, BOOL fServerLevel, DHCP_IPV6_ADDRESS SubnetAddress, DWORD FieldModified, LPDHCPV6_STATELESS_PARAMS Params);
typedef DWORD(__stdcall* Dhcpv6RequestParams)(BOOL forceNewInform, LPVOID reserved, LPWSTR adapterName, LPDHCPV6CAPI_CLASSID classId, DHCPV6CAPI_PARAMS_ARRAY recdParams, LPBYTE buffer, LPDWORD pSize);
typedef DWORD(__stdcall* Dhcpv6ReleasePrefix)(LPWSTR adapterName, LPDHCPV6CAPI_CLASSID classId, LPDHCPV6PrefixLeaseInformation leaseInfo);
typedef HDSA(__stdcall* DSA_Create)(int cbItem, int cItemGrow);
typedef BOOL(__stdcall* DSA_Destroy)(HDSA hdsa);
typedef BOOL(__stdcall* DSA_DeleteItem)(HDSA hdsa, int i);
typedef BOOL(__stdcall* DSA_DeleteAllItems)(HDSA hdsa);
typedef PVOID(__stdcall* DSA_GetItemPtr)(HDSA hdsa, int i);
typedef HDSA(__stdcall* DSA_Clone)(HDSA hdsa);
typedef ULONGLONG(__stdcall* DSA_GetSize)(HDSA hdsa);
typedef BOOL(__stdcall* DSA_Sort)(HDSA pdsa, PFNDACOMPARE pfnCompare, LPARAM lParam);
typedef HDPA(__stdcall* DPA_Create)(int cItemGrow);
typedef HDPA(__stdcall* DPA_CreateEx)(int cpGrow, HANDLE hheap);
typedef HDPA(__stdcall* DPA_Clone)(HDPA hdpa, HDPA hdpaNew);
typedef BOOL(__stdcall* DPA_Destroy)(HDPA hdpa);
typedef PVOID(__stdcall* DPA_DeletePtr)(HDPA hdpa, int i);
typedef BOOL(__stdcall* DPA_DeleteAllPtrs)(HDPA hdpa);
typedef BOOL(__stdcall* DPA_Grow)(HDPA pdpa, int cp);
typedef PVOID(__stdcall* DPA_GetPtr)(HDPA hdpa, INT_PTR i);
typedef ULONGLONG(__stdcall* DPA_GetSize)(HDPA hdpa);
typedef BOOL(__stdcall* DPA_Sort)(HDPA hdpa, PFNDACOMPARE pfnCompare, LPARAM lParam);
typedef BOOL(__stdcall* DPA_Merge)(HDPA hdpaDest, HDPA hdpaSrc, DWORD dwFlags, PFNDACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam);
typedef HRESULT(__stdcall* DrtDeleteIpv6UdpTransport)(HDRT_TRANSPORT hTransport);
typedef void(__stdcall* DrtClose)(HDRT hDrt);
typedef void(__stdcall* DrtUnregisterKey)(HDRT_REGISTRATION_CONTEXT hKeyRegistration);
typedef HRESULT(__stdcall* DrtContinueSearch)(HDRT_SEARCH_CONTEXT hSearchContext);
typedef HRESULT(__stdcall* DrtEndSearch)(HDRT_SEARCH_CONTEXT hSearchContext);
typedef HRESULT(__stdcall* DrtGetInstanceName)(HDRT hDrt, ULONG ulcbInstanceNameSize, PWSTR pwzDrtInstanceName);
typedef DWORD(__stdcall* DsValidateSubnetNameW)(LPCWSTR SubnetName);
typedef DWORD(__stdcall* DsValidateSubnetNameA)(LPCSTR SubnetName);
typedef BOOL(__stdcall* DsIsMangledRdnValueW)(LPCWSTR pszRdn, DWORD cRdn, DS_MANGLE_FOR eDsMangleForDesired);
typedef BOOL(__stdcall* DsIsMangledRdnValueA)(LPCSTR pszRdn, DWORD cRdn, DS_MANGLE_FOR eDsMangleForDesired);
typedef BOOL(__stdcall* DsIsMangledDnA)(LPCSTR pszDn, DS_MANGLE_FOR eDsMangleFor);
typedef BOOL(__stdcall* DsIsMangledDnW)(LPCWSTR pszDn, DS_MANGLE_FOR eDsMangleFor);
typedef void(__stdcall* DsRoleFreeMemory)(PVOID Buffer);
typedef HRESULT(__stdcall* DSEditSecurity)(HWND hwndOwner, LPCWSTR pwszObjectPath, LPCWSTR pwszObjectClass, DWORD dwFlags, LPCWSTR pwszCaption, PFNREADOBJECTSECURITY pfnReadSD, PFNWRITEOBJECTSECURITY pfnWriteSD, LPARAM lpContext);
typedef HRESULT(__stdcall* DwmEnableComposition)(UINT uCompositionAction);
typedef HRESULT(__stdcall* DwmEnableMMCSS)(BOOL fEnableMMCSS);
typedef HRESULT(__stdcall* DwmGetWindowAttribute)(HWND hwnd, DWORD dwAttribute, PVOID pvAttribute, DWORD cbAttribute);
typedef HRESULT(__stdcall* DwmModifyPreviousDxFrameDuration)(HWND hwnd, INT cRefreshes, BOOL fRelative);
typedef HRESULT(__stdcall* DwmQueryThumbnailSourceSize)(HTHUMBNAIL hThumbnail, PSIZE pSize);
typedef HRESULT(__stdcall* DwmRegisterThumbnail)(HWND hwndDestination, HWND hwndSource, PHTHUMBNAIL phThumbnailId);
typedef HRESULT(__stdcall* DwmSetDxFrameDuration)(HWND hwnd, INT cRefreshes);
typedef HRESULT(__stdcall* DwmSetWindowAttribute)(HWND hwnd, DWORD dwAttribute, LPCVOID pvAttribute, DWORD cbAttribute);
typedef HRESULT(__stdcall* DwmUnregisterThumbnail)(HTHUMBNAIL hThumbnailId);
typedef HRESULT(__stdcall* DwmSetIconicThumbnail)(HWND hwnd, HBITMAP hbmp, DWORD dwSITFlags);
typedef HRESULT(__stdcall* DwmInvalidateIconicBitmaps)(HWND hwnd);
typedef HRESULT(__stdcall* DwmAttachMilContent)(HWND hwnd);
typedef HRESULT(__stdcall* DwmDetachMilContent)(HWND hwnd);
typedef HRESULT(__stdcall* DwmFlush)();
typedef HRESULT(__stdcall* DwmTransitionOwnedWindow)(HWND hwnd, {'data_type': 'Enum', 'enumerators': []} target);
typedef HRESULT(__stdcall* DwmTetherContact)(DWORD dwPointerID, BOOL fEnable, POINT ptTether);
typedef HRESULT(__stdcall* DwmShowContact)(DWORD dwPointerID, {'data_type': 'Enum', 'enumerators': []} eShowContact);
typedef HRESULT(__stdcall* DXGIDeclareAdapterRemovalSupport)();
typedef HRESULT(__stdcall* MappingFreeServices)(PMAPPING_SERVICE_INFO pServiceInfo);
typedef HRESULT(__stdcall* MappingRecognizeText)(PMAPPING_SERVICE_INFO pServiceInfo, LPCWSTR pszText, DWORD dwLength, DWORD dwIndex, PMAPPING_OPTIONS pOptions, PMAPPING_PROPERTY_BAG pbag);
typedef HRESULT(__stdcall* MappingDoAction)(PMAPPING_PROPERTY_BAG pBag, DWORD dwRangeIndex, LPCWSTR pszActionId);
typedef HRESULT(__stdcall* MappingFreePropertyBag)(PMAPPING_PROPERTY_BAG pBag);
typedef BOOL(__stdcall* IsEnclaveTypeSupported)(DWORD flEnclaveType);
typedef LPVOID(__stdcall* CreateEnclave)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, SIZE_T dwInitialCommitment, DWORD flEnclaveType, LPCVOID lpEnclaveInformation, DWORD dwInfoLength, LPDWORD lpEnclaveError);
typedef BOOL(__stdcall* LoadEnclaveData)(HANDLE hProcess, LPVOID lpAddress, LPCVOID lpBuffer, SIZE_T nSize, DWORD flProtect, LPCVOID lpPageInformation, DWORD dwInfoLength, PSIZE_T lpNumberOfBytesWritten, LPDWORD lpEnclaveError);
typedef BOOL(__stdcall* InitializeEnclave)(HANDLE hProcess, LPVOID lpAddress, LPCVOID lpEnclaveInformation, DWORD dwInfoLength, LPDWORD lpEnclaveError);
typedef BOOL(__stdcall* LoadEnclaveImageW)(LPVOID lpEnclaveAddress, LPCWSTR lpImageName);
typedef BOOL(__stdcall* TerminateEnclave)(LPVOID lpAddress, BOOL fWait);
typedef BOOL(__stdcall* DeleteEnclave)(LPVOID lpAddress);
typedef LPTOP_LEVEL_EXCEPTION_FILTER(__stdcall* SetUnhandledExceptionFilter)(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
typedef void(__stdcall* SetLastError)(DWORD dwErrCode);
typedef UINT(__stdcall* SetErrorMode)(UINT uMode);
typedef PVOID(__stdcall* AddVectoredExceptionHandler)(ULONG First, PVECTORED_EXCEPTION_HANDLER Handler);
typedef ULONG(__stdcall* RemoveVectoredExceptionHandler)(PVOID Handle);
typedef PVOID(__stdcall* AddVectoredContinueHandler)(ULONG First, PVECTORED_EXCEPTION_HANDLER Handler);
typedef ULONG(__stdcall* RemoveVectoredContinueHandler)(PVOID Handle);
typedef void(__stdcall* RaiseFailFastException)(PEXCEPTION_RECORD pExceptionRecord, PCONTEXT pContextRecord, DWORD dwFlags);
typedef void(__stdcall* FatalAppExitA)(UINT uAction, LPCSTR lpMessageText);
typedef void(__stdcall* FatalAppExitW)(UINT uAction, LPCWSTR lpMessageText);
typedef BOOL(__stdcall* SetThreadErrorMode)(DWORD dwNewMode, LPDWORD lpOldMode);
typedef EFaultRepRetVal(__stdcall* ReportFault)(LPEXCEPTION_POINTERS pep, DWORD dwOpt);
typedef BOOL(__stdcall* AddERExcludedApplicationA)(LPCSTR szApplication);
typedef BOOL(__stdcall* AddERExcludedApplicationW)(LPCWSTR wszApplication);
typedef HRESULT(__stdcall* WerReportHang)(HWND hwndHungApp, PCWSTR pwzHungApplicationName);
typedef EC_HANDLE(__stdcall* EcOpenSubscriptionEnum)(DWORD Flags);
typedef BOOL(__stdcall* EcEnumNextSubscription)(EC_HANDLE SubscriptionEnum, DWORD SubscriptionNameBufferSize, LPWSTR SubscriptionNameBuffer, PDWORD SubscriptionNameBufferUsed);
typedef EC_HANDLE(__stdcall* EcOpenSubscription)(LPCWSTR SubscriptionName, DWORD AccessMask, DWORD Flags);
typedef BOOL(__stdcall* EcSetSubscriptionProperty)(EC_HANDLE Subscription, EC_SUBSCRIPTION_PROPERTY_ID PropertyId, DWORD Flags, PEC_VARIANT PropertyValue);
typedef BOOL(__stdcall* EcGetSubscriptionProperty)(EC_HANDLE Subscription, EC_SUBSCRIPTION_PROPERTY_ID PropertyId, DWORD Flags, DWORD PropertyValueBufferSize, PEC_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef BOOL(__stdcall* EcSaveSubscription)(EC_HANDLE Subscription, DWORD Flags);
typedef BOOL(__stdcall* EcDeleteSubscription)(LPCWSTR SubscriptionName, DWORD Flags);
typedef BOOL(__stdcall* EcGetObjectArraySize)(EC_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, PDWORD ObjectArraySize);
typedef BOOL(__stdcall* EcSetObjectArrayProperty)(EC_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, EC_SUBSCRIPTION_PROPERTY_ID PropertyId, DWORD ArrayIndex, DWORD Flags, PEC_VARIANT PropertyValue);
typedef BOOL(__stdcall* EcGetObjectArrayProperty)(EC_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, EC_SUBSCRIPTION_PROPERTY_ID PropertyId, DWORD ArrayIndex, DWORD Flags, DWORD PropertyValueBufferSize, PEC_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef BOOL(__stdcall* EcInsertObjectArrayElement)(EC_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, DWORD ArrayIndex);
typedef BOOL(__stdcall* EcRemoveObjectArrayElement)(EC_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, DWORD ArrayIndex);
typedef BOOL(__stdcall* EcGetSubscriptionRunTimeStatus)(LPCWSTR SubscriptionName, EC_SUBSCRIPTION_RUNTIME_STATUS_INFO_ID StatusInfoId, LPCWSTR EventSourceName, DWORD Flags, DWORD StatusValueBufferSize, PEC_VARIANT StatusValueBuffer, PDWORD StatusValueBufferUsed);
typedef BOOL(__stdcall* EcRetrySubscription)(LPCWSTR SubscriptionName, LPCWSTR EventSourceName, DWORD Flags);
typedef BOOL(__stdcall* EcClose)(EC_HANDLE Object);
typedef ULONG(__stdcall* EventAccessControl)(LPGUID Guid, ULONG Operation, PSID Sid, ULONG Rights, BOOLEAN AllowOrDeny);
typedef ULONG(__stdcall* EventAccessQuery)(LPGUID Guid, PSECURITY_DESCRIPTOR Buffer, PULONG BufferSize);
typedef ULONG(__stdcall* EventAccessRemove)(LPGUID Guid);
typedef ULONG(__stdcall* EventRegister)(LPCGUID ProviderId, PENABLECALLBACK EnableCallback, PVOID CallbackContext, PREGHANDLE RegHandle);
typedef ULONG(__stdcall* EventUnregister)(REGHANDLE RegHandle);
typedef ULONG(__stdcall* EventSetInformation)(REGHANDLE RegHandle, EVENT_INFO_CLASS InformationClass, PVOID EventInformation, ULONG InformationLength);
typedef BOOLEAN(__stdcall* EventEnabled)(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor);
typedef BOOLEAN(__stdcall* EventProviderEnabled)(REGHANDLE RegHandle, UCHAR Level, ULONGLONG Keyword);
typedef ULONG(__stdcall* EventWrite)(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
typedef ULONG(__stdcall* EventWriteTransfer)(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, LPCGUID ActivityId, LPCGUID RelatedActivityId, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
typedef ULONG(__stdcall* EventWriteEx)(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG64 Filter, ULONG Flags, LPCGUID ActivityId, LPCGUID RelatedActivityId, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
typedef ULONG(__stdcall* EventWriteString)(REGHANDLE RegHandle, UCHAR Level, ULONGLONG Keyword, PCWSTR String);
typedef ULONG(__stdcall* EventActivityIdControl)(ULONG ControlCode, LPGUID ActivityId);
typedef HRESULT(__stdcall* ReleaseExclusiveCpuSets)();
typedef BOOL(__stdcall* FCIAddFile)(HFCI hfci, LPSTR pszSourceFile, LPSTR pszFileName, BOOL fExecute, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis, PFNFCIGETOPENINFO pfnfcigoi, TCOMP typeCompress);
typedef BOOL(__stdcall* FCIFlushCabinet)(HFCI hfci, BOOL fGetNextCab, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis);
typedef BOOL(__stdcall* FCIFlushFolder)(HFCI hfci, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis);
typedef BOOL(__stdcall* FCIDestroy)(HFCI hfci);
typedef HFDI(__stdcall* FDICreate)(PFNALLOC pfnalloc, PFNFREE pfnfree, PFNOPEN pfnopen, PFNREAD pfnread, PFNWRITE pfnwrite, PFNCLOSE pfnclose, PFNSEEK pfnseek, int cpuType, PERF perf);
typedef BOOL(__stdcall* FDIIsCabinet)(HFDI hfdi, INT_PTR hf, PFDICABINETINFO pfdici);
typedef BOOL(__stdcall* FDIDestroy)(HFDI hfdi);
typedef BOOL(__stdcall* FDITruncateCabinet)(HFDI hfdi, LPSTR pszCabinetName, USHORT iFolderToDelete);
typedef FEATURE_ENABLED_STATE(__stdcall* GetFeatureEnabledState)(UINT32 featureId, FEATURE_CHANGE_TIME changeTime);
typedef void(__stdcall* RecordFeatureUsage)(UINT32 featureId, UINT32 kind, UINT32 addend, PCSTR originName);
typedef void(__stdcall* UnsubscribeFeatureStateChangeNotification)(FEATURE_STATE_CHANGE_SUBSCRIPTION subscription);
typedef DWORD(__stdcall* FlsAlloc)(PFLS_CALLBACK_FUNCTION lpCallback);
typedef PVOID(__stdcall* FlsGetValue)(DWORD dwFlsIndex);
typedef BOOL(__stdcall* FlsSetValue)(DWORD dwFlsIndex, PVOID lpFlsData);
typedef BOOL(__stdcall* FlsFree)(DWORD dwFlsIndex);
typedef HANDLE(__stdcall* CreateFileA)(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
typedef HANDLE(__stdcall* CreateFileW)(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
typedef BOOL(__stdcall* FindClose)(HANDLE hFindFile);
typedef BOOL(__stdcall* FindCloseChangeNotification)(HANDLE hChangeHandle);
typedef HANDLE(__stdcall* FindFirstChangeNotificationA)(LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter);
typedef HANDLE(__stdcall* FindFirstChangeNotificationW)(LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter);
typedef HANDLE(__stdcall* FindFirstFileA)(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData);
typedef HANDLE(__stdcall* FindFirstFileW)(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData);
typedef HANDLE(__stdcall* FindFirstFileExA)(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags);
typedef HANDLE(__stdcall* FindFirstFileExW)(LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags);
typedef BOOL(__stdcall* FindNextChangeNotification)(HANDLE hChangeHandle);
typedef BOOL(__stdcall* FindNextFileA)(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData);
typedef BOOL(__stdcall* FindNextFileW)(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData);
typedef BOOL(__stdcall* FindVolumeClose)(HANDLE hFindVolume);
typedef BOOL(__stdcall* FlushFileBuffers)(HANDLE hFile);
typedef BOOL(__stdcall* GetDiskFreeSpaceA)(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters);
typedef BOOL(__stdcall* GetDiskFreeSpaceW)(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters);
typedef BOOL(__stdcall* GetDiskFreeSpaceExA)(LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
typedef BOOL(__stdcall* GetDiskFreeSpaceExW)(LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
typedef UINT(__stdcall* GetDriveTypeA)(LPCSTR lpRootPathName);
typedef UINT(__stdcall* GetDriveTypeW)(LPCWSTR lpRootPathName);
typedef DWORD(__stdcall* GetFileAttributesA)(LPCSTR lpFileName);
typedef DWORD(__stdcall* GetFileAttributesW)(LPCWSTR lpFileName);
typedef BOOL(__stdcall* GetFileAttributesExA)(LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation);
typedef BOOL(__stdcall* GetFileAttributesExW)(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation);
typedef BOOL(__stdcall* GetFileInformationByHandle)(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
typedef DWORD(__stdcall* GetFileSize)(HANDLE hFile, LPDWORD lpFileSizeHigh);
typedef BOOL(__stdcall* GetFileSizeEx)(HANDLE hFile, PLARGE_INTEGER lpFileSize);
typedef DWORD(__stdcall* GetFileType)(HANDLE hFile);
typedef DWORD(__stdcall* GetFinalPathNameByHandleA)(HANDLE hFile, LPSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags);
typedef DWORD(__stdcall* GetFinalPathNameByHandleW)(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags);
typedef BOOL(__stdcall* GetFileTime)(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime);
typedef DWORD(__stdcall* GetLongPathNameA)(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer);
typedef DWORD(__stdcall* GetLongPathNameW)(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer);
typedef BOOL(__stdcall* GetVolumeInformationByHandleW)(HANDLE hFile, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
typedef BOOL(__stdcall* GetVolumeInformationW)(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
typedef BOOL(__stdcall* LockFile)(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh);
typedef BOOL(__stdcall* LockFileEx)(HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* ReadFile)(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* ReadFileEx)(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef BOOL(__stdcall* RemoveDirectoryA)(LPCSTR lpPathName);
typedef BOOL(__stdcall* RemoveDirectoryW)(LPCWSTR lpPathName);
typedef BOOL(__stdcall* SetEndOfFile)(HANDLE hFile);
typedef BOOL(__stdcall* SetFileAttributesA)(LPCSTR lpFileName, DWORD dwFileAttributes);
typedef BOOL(__stdcall* SetFileAttributesW)(LPCWSTR lpFileName, DWORD dwFileAttributes);
typedef BOOL(__stdcall* SetFileInformationByHandle)(HANDLE hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, LPVOID lpFileInformation, DWORD dwBufferSize);
typedef DWORD(__stdcall* SetFilePointer)(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);
typedef BOOL(__stdcall* SetFilePointerEx)(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod);
typedef BOOL(__stdcall* SetFileValidData)(HANDLE hFile, LONGLONG ValidDataLength);
typedef BOOL(__stdcall* UnlockFile)(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh);
typedef BOOL(__stdcall* UnlockFileEx)(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* WriteFile)(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* WriteFileEx)(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef DWORD(__stdcall* GetTempPathW)(DWORD nBufferLength, LPWSTR lpBuffer);
typedef HANDLE(__stdcall* CreateFile2)(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCreationDisposition, LPCREATEFILE2_EXTENDED_PARAMETERS pCreateExParams);
typedef BOOL(__stdcall* SetFileIoOverlappedRange)(HANDLE FileHandle, PUCHAR OverlappedRangeStart, ULONG Length);
typedef DWORD(__stdcall* GetCompressedFileSizeA)(LPCSTR lpFileName, LPDWORD lpFileSizeHigh);
typedef DWORD(__stdcall* GetCompressedFileSizeW)(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh);
typedef HANDLE(__stdcall* FindFirstStreamW)(LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags);
typedef BOOL(__stdcall* FindNextStreamW)(HANDLE hFindStream, LPVOID lpFindStreamData);
typedef DWORD(__stdcall* GetTempPathA)(DWORD nBufferLength, LPSTR lpBuffer);
typedef HANDLE(__stdcall* FindFirstFileNameW)(LPCWSTR lpFileName, DWORD dwFlags, LPDWORD StringLength, PWSTR LinkName);
typedef BOOL(__stdcall* FindNextFileNameW)(HANDLE hFindStream, LPDWORD StringLength, PWSTR LinkName);
typedef BOOL(__stdcall* GetVolumeInformationA)(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
typedef DWORD(__stdcall* FwpmEngineClose0)(HANDLE engineHandle);
typedef DWORD(__stdcall* FwpmSessionDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmTransactionBegin0)(HANDLE engineHandle, UINT32 flags);
typedef DWORD(__stdcall* FwpmTransactionCommit0)(HANDLE engineHandle);
typedef DWORD(__stdcall* FwpmTransactionAbort0)(HANDLE engineHandle);
typedef DWORD(__stdcall* FwpmProviderDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmProviderUnsubscribeChanges0)(HANDLE engineHandle, HANDLE changeHandle);
typedef DWORD(__stdcall* FwpmProviderContextDeleteById0)(HANDLE engineHandle, UINT64 id);
typedef DWORD(__stdcall* FwpmProviderContextDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmProviderContextUnsubscribeChanges0)(HANDLE engineHandle, HANDLE changeHandle);
typedef DWORD(__stdcall* FwpmSubLayerDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmSubLayerUnsubscribeChanges0)(HANDLE engineHandle, HANDLE changeHandle);
typedef DWORD(__stdcall* FwpmLayerDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmCalloutDeleteById0)(HANDLE engineHandle, UINT32 id);
typedef DWORD(__stdcall* FwpmCalloutDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmCalloutUnsubscribeChanges0)(HANDLE engineHandle, HANDLE changeHandle);
typedef DWORD(__stdcall* FwpmFilterDeleteById0)(HANDLE engineHandle, UINT64 id);
typedef DWORD(__stdcall* FwpmFilterDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmFilterUnsubscribeChanges0)(HANDLE engineHandle, HANDLE changeHandle);
typedef DWORD(__stdcall* IPsecSaContextDeleteById0)(HANDLE engineHandle, UINT64 id);
typedef DWORD(__stdcall* IPsecSaContextExpire0)(HANDLE engineHandle, UINT64 id);
typedef DWORD(__stdcall* IPsecSaContextDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* IPsecSaContextUnsubscribe0)(HANDLE engineHandle, HANDLE eventsHandle);
typedef DWORD(__stdcall* IPsecSaDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* IPsecDospStateDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* IPsecKeyManagerUnregisterAndDelete0)(HANDLE engineHandle, HANDLE keyMgmtHandle);
typedef DWORD(__stdcall* IkeextSaDeleteById0)(HANDLE engineHandle, UINT64 id);
typedef DWORD(__stdcall* IkeextSaDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmNetEventDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmNetEventUnsubscribe0)(HANDLE engineHandle, HANDLE eventsHandle);
typedef DWORD(__stdcall* FwpmSystemPortsUnsubscribe0)(HANDLE engineHandle, HANDLE sysPortsHandle);
typedef DWORD(__stdcall* FwpmConnectionDestroyEnumHandle0)(HANDLE engineHandle, HANDLE enumHandle);
typedef DWORD(__stdcall* FwpmConnectionUnsubscribe0)(HANDLE engineHandle, HANDLE eventsHandle);
typedef DWORD(__stdcall* FwpmvSwitchEventUnsubscribe0)(HANDLE engineHandle, HANDLE subscriptionHandle);
typedef BOOL(__stdcall* CanSendToFaxRecipient)();
typedef DWORD(__stdcall* SendToFaxRecipient)(SendToMode sndMode, LPCWSTR lpFileName);
typedef DWORD(__stdcall* NlsDllCodePageTranslation)(DWORD CodePage, DWORD dwFlags, LPSTR lpMultiByteStr, int cchMultiByte, LPWSTR lpWideCharStr, int cchWideChar, LPCPINFO lpCPInfo);
typedef HRESULT(__stdcall* CreateGPOLink)(LPOLESTR lpGPO, LPOLESTR lpContainer, BOOL fHighPriority);
typedef HRESULT(__stdcall* DeleteGPOLink)(LPOLESTR lpGPO, LPOLESTR lpContainer);
typedef HRESULT(__stdcall* DeleteAllGPOLinks)(LPOLESTR lpContainer);
typedef HRESULT(__stdcall* BrowseForGPO)(LPGPOBROWSEINFO lpBrowseInfo);
typedef HRESULT(__stdcall* ImportRSoPData)(LPOLESTR lpNameSpace, LPOLESTR lpFileName);
typedef HRESULT(__stdcall* ExportRSoPData)(LPOLESTR lpNameSpace, LPOLESTR lpFileName);
typedef BOOL(__stdcall* CloseHandle)(HANDLE hObject);
typedef BOOL(__stdcall* DuplicateHandle)(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions);
typedef BOOL(__stdcall* CompareObjectHandles)(HANDLE hFirstObjectHandle, HANDLE hSecondObjectHandle);
typedef BOOL(__stdcall* GetHandleInformation)(HANDLE hObject, LPDWORD lpdwFlags);
typedef BOOL(__stdcall* SetHandleInformation)(HANDLE hObject, DWORD dwMask, DWORD dwFlags);
typedef HANDLE(__stdcall* HeapCreate)(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize);
typedef BOOL(__stdcall* HeapDestroy)(HANDLE hHeap);
typedef LPVOID(__stdcall* HeapAlloc)(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes);
typedef LPVOID(__stdcall* HeapReAlloc)(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes);
typedef BOOL(__stdcall* HeapFree)(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
typedef SIZE_T(__stdcall* HeapSize)(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
typedef SIZE_T(__stdcall* HeapCompact)(HANDLE hHeap, DWORD dwFlags);
typedef BOOL(__stdcall* HeapSetInformation)(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength);
typedef BOOL(__stdcall* HeapValidate)(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
typedef BOOL(__stdcall* HeapSummary)(HANDLE hHeap, DWORD dwFlags, LPHEAP_SUMMARY lpSummary);
typedef DWORD(__stdcall* GetProcessHeaps)(DWORD NumberOfHeaps, PHANDLE ProcessHeaps);
typedef BOOL(__stdcall* HeapLock)(HANDLE hHeap);
typedef BOOL(__stdcall* HeapUnlock)(HANDLE hHeap);
typedef BOOL(__stdcall* HeapWalk)(HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry);
typedef BOOL(__stdcall* HeapQueryInformation)(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength);
typedef _BOOL(__stdcall* GetMonitorCapabilities)(HANDLE hMonitor, LPDWORD pdwMonitorCapabilities, LPDWORD pdwSupportedColorTemperatures);
typedef _BOOL(__stdcall* SaveCurrentMonitorSettings)(HANDLE hMonitor);
typedef _BOOL(__stdcall* GetMonitorTechnologyType)(HANDLE hMonitor, LPMC_DISPLAY_TECHNOLOGY_TYPE pdtyDisplayTechnologyType);
typedef _BOOL(__stdcall* GetMonitorBrightness)(HANDLE hMonitor, LPDWORD pdwMinimumBrightness, LPDWORD pdwCurrentBrightness, LPDWORD pdwMaximumBrightness);
typedef _BOOL(__stdcall* GetMonitorContrast)(HANDLE hMonitor, LPDWORD pdwMinimumContrast, LPDWORD pdwCurrentContrast, LPDWORD pdwMaximumContrast);
typedef _BOOL(__stdcall* GetMonitorColorTemperature)(HANDLE hMonitor, LPMC_COLOR_TEMPERATURE pctCurrentColorTemperature);
typedef _BOOL(__stdcall* GetMonitorRedGreenOrBlueDrive)(HANDLE hMonitor, MC_DRIVE_TYPE dtDriveType, LPDWORD pdwMinimumDrive, LPDWORD pdwCurrentDrive, LPDWORD pdwMaximumDrive);
typedef _BOOL(__stdcall* GetMonitorRedGreenOrBlueGain)(HANDLE hMonitor, MC_GAIN_TYPE gtGainType, LPDWORD pdwMinimumGain, LPDWORD pdwCurrentGain, LPDWORD pdwMaximumGain);
typedef _BOOL(__stdcall* SetMonitorBrightness)(HANDLE hMonitor, DWORD dwNewBrightness);
typedef _BOOL(__stdcall* SetMonitorContrast)(HANDLE hMonitor, DWORD dwNewContrast);
typedef _BOOL(__stdcall* SetMonitorColorTemperature)(HANDLE hMonitor, MC_COLOR_TEMPERATURE ctCurrentColorTemperature);
typedef _BOOL(__stdcall* SetMonitorRedGreenOrBlueDrive)(HANDLE hMonitor, MC_DRIVE_TYPE dtDriveType, DWORD dwNewDrive);
typedef _BOOL(__stdcall* SetMonitorRedGreenOrBlueGain)(HANDLE hMonitor, MC_GAIN_TYPE gtGainType, DWORD dwNewGain);
typedef _BOOL(__stdcall* DegaussMonitor)(HANDLE hMonitor);
typedef _BOOL(__stdcall* GetMonitorDisplayAreaSize)(HANDLE hMonitor, MC_SIZE_TYPE stSizeType, LPDWORD pdwMinimumWidthOrHeight, LPDWORD pdwCurrentWidthOrHeight, LPDWORD pdwMaximumWidthOrHeight);
typedef _BOOL(__stdcall* GetMonitorDisplayAreaPosition)(HANDLE hMonitor, MC_POSITION_TYPE ptPositionType, LPDWORD pdwMinimumPosition, LPDWORD pdwCurrentPosition, LPDWORD pdwMaximumPosition);
typedef _BOOL(__stdcall* SetMonitorDisplayAreaSize)(HANDLE hMonitor, MC_SIZE_TYPE stSizeType, DWORD dwNewDisplayAreaWidthOrHeight);
typedef _BOOL(__stdcall* SetMonitorDisplayAreaPosition)(HANDLE hMonitor, MC_POSITION_TYPE ptPositionType, DWORD dwNewPosition);
typedef _BOOL(__stdcall* RestoreMonitorFactoryColorDefaults)(HANDLE hMonitor);
typedef _BOOL(__stdcall* RestoreMonitorFactoryDefaults)(HANDLE hMonitor);
typedef HWND(__stdcall* HtmlHelpA)(HWND hwndCaller, LPCSTR pszFile, UINT uCommand, DWORD_PTR dwData);
typedef HWND(__stdcall* HtmlHelpW)(HWND hwndCaller, LPCWSTR pszFile, UINT uCommand, DWORD_PTR dwData);
typedef DWORD(__stdcall* SetShellNext)(PSTR szShellNext);
typedef BOOL(__stdcall* BindImage)(PCSTR ImageName, PCSTR DllPath, PCSTR SymbolPath);
typedef BOOL(__stdcall* BindImageEx)(DWORD Flags, PCSTR ImageName, PCSTR DllPath, PCSTR SymbolPath, PIMAGEHLP_STATUS_ROUTINE StatusRoutine);
typedef PIMAGE_NT_HEADERS(__stdcall* CheckSumMappedFile)(PVOID BaseAddress, DWORD FileLength, PDWORD HeaderSum, PDWORD CheckSum);
typedef DWORD(__stdcall* MapFileAndCheckSumA)(PCSTR Filename, PDWORD HeaderSum, PDWORD CheckSum);
typedef DWORD(__stdcall* MapFileAndCheckSumW)(PCWSTR Filename, PDWORD HeaderSum, PDWORD CheckSum);
typedef BOOL(__stdcall* GetImageConfigInformation)(PLOADED_IMAGE LoadedImage, PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation);
typedef DWORD(__stdcall* GetImageUnusedHeaderBytes)(PLOADED_IMAGE LoadedImage, PDWORD SizeUnusedHeaderBytes);
typedef BOOL(__stdcall* SetImageConfigInformation)(PLOADED_IMAGE LoadedImage, PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation);
typedef BOOL(__stdcall* ImageGetDigestStream)(HANDLE FileHandle, DWORD DigestLevel, DIGEST_FUNCTION DigestFunction, DIGEST_HANDLE DigestHandle);
typedef BOOL(__stdcall* ImageAddCertificate)(HANDLE FileHandle, LPWIN_CERTIFICATE Certificate, PDWORD Index);
typedef BOOL(__stdcall* ImageRemoveCertificate)(HANDLE FileHandle, DWORD Index);
typedef BOOL(__stdcall* ImageEnumerateCertificates)(HANDLE FileHandle, WORD TypeFilter, PDWORD CertificateCount, PDWORD Indices, DWORD IndexCount);
typedef BOOL(__stdcall* ImageGetCertificateData)(HANDLE FileHandle, DWORD CertificateIndex, LPWIN_CERTIFICATE Certificate, PDWORD RequiredLength);
typedef BOOL(__stdcall* ImageGetCertificateHeader)(HANDLE FileHandle, DWORD CertificateIndex, LPWIN_CERTIFICATE Certificateheader);
typedef PLOADED_IMAGE(__stdcall* ImageLoad)(PCSTR DllName, PCSTR DllPath);
typedef BOOL(__stdcall* ImageUnload)(PLOADED_IMAGE LoadedImage);
typedef BOOL(__stdcall* MapAndLoad)(PCSTR ImageName, PCSTR DllPath, PLOADED_IMAGE LoadedImage, BOOL DotDll, BOOL ReadOnly);
typedef BOOL(__stdcall* UnMapAndLoad)(PLOADED_IMAGE LoadedImage);
typedef BOOL(__stdcall* TouchFileTimes)(HANDLE FileHandle, PSYSTEMTIME pSystemTime);
typedef BOOL(__stdcall* SplitSymbols)(PSTR ImageName, PCSTR SymbolsPath, PSTR SymbolFilePath, ULONG Flags);
typedef BOOL(__stdcall* UpdateDebugInfoFile)(PCSTR ImageFileName, PCSTR SymbolPath, PSTR DebugFilePath, PIMAGE_NT_HEADERS32 NtHeaders);
typedef BOOL(__stdcall* UpdateDebugInfoFileEx)(PCSTR ImageFileName, PCSTR SymbolPath, PSTR DebugFilePath, PIMAGE_NT_HEADERS32 NtHeaders, DWORD OldCheckSum);
typedef HKL(__stdcall* ImmInstallIMEA)(LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText);
typedef HKL(__stdcall* ImmInstallIMEW)(LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText);
typedef BOOL(__stdcall* ImmEnumInputContext)(DWORD idThread, IMCENUMPROC lpfn, LPARAM lParam);
typedef BOOL(__stdcall* ImmDisableTextFrameService)(DWORD idThread);
typedef HRESULT(__stdcall* SetInputScope)(HWND hwnd, InputScope inputscope);
typedef HRESULT(__stdcall* SetInputScopeXML)(HWND hwnd, PWSTR pszXML);
typedef HRESULT(__stdcall* DestroyInteractionContext)(HINTERACTIONCONTEXT interactionContext);
typedef HRESULT(__stdcall* SetPropertyInteractionContext)(HINTERACTIONCONTEXT interactionContext, INTERACTION_CONTEXT_PROPERTY contextProperty, UINT32 value);
typedef HRESULT(__stdcall* SetInertiaParameterInteractionContext)(HINTERACTIONCONTEXT interactionContext, INERTIA_PARAMETER inertiaParameter, float value);
typedef HRESULT(__stdcall* SetMouseWheelParameterInteractionContext)(HINTERACTIONCONTEXT interactionContext, MOUSE_WHEEL_PARAMETER parameter, float value);
typedef HRESULT(__stdcall* ResetInteractionContext)(HINTERACTIONCONTEXT interactionContext);
typedef HRESULT(__stdcall* AddPointerInteractionContext)(HINTERACTIONCONTEXT interactionContext, UINT32 pointerId);
typedef HRESULT(__stdcall* RemovePointerInteractionContext)(HINTERACTIONCONTEXT interactionContext, UINT32 pointerId);
typedef HRESULT(__stdcall* ProcessBufferedPacketsInteractionContext)(HINTERACTIONCONTEXT interactionContext);
typedef HRESULT(__stdcall* ProcessInertiaInteractionContext)(HINTERACTIONCONTEXT interactionContext);
typedef HRESULT(__stdcall* StopInteractionContext)(HINTERACTIONCONTEXT interactionContext);
typedef HRESULT(__stdcall* SetPivotInteractionContext)(HINTERACTIONCONTEXT interactionContext, float x, float y, float radius);
typedef void(__stdcall* InitializeSListHead)(PSLIST_HEADER ListHead);
typedef PSLIST_ENTRY(__stdcall* InterlockedPopEntrySList)(PSLIST_HEADER ListHead);
typedef PSLIST_ENTRY(__stdcall* InterlockedPushEntrySList)(PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry);
typedef PSLIST_ENTRY(__stdcall* InterlockedPushListSListEx)(PSLIST_HEADER ListHead, PSLIST_ENTRY List, PSLIST_ENTRY ListEnd, ULONG Count);
typedef PSLIST_ENTRY(__stdcall* InterlockedFlushSList)(PSLIST_HEADER ListHead);
typedef USHORT(__stdcall* QueryDepthSList)(PSLIST_HEADER ListHead);
typedef HRESULT(__stdcall* URLAssociationDialogA)(HWND hwndParent, DWORD dwInFlags, PCSTR pcszFile, PCSTR pcszURL, PSTR pszAppBuf, UINT ucAppBufLen);
typedef HRESULT(__stdcall* URLAssociationDialogW)(HWND hwndParent, DWORD dwInFlags, PCWSTR pcszFile, PCWSTR pcszURL, PWSTR pszAppBuf, UINT ucAppBufLen);
typedef HRESULT(__stdcall* MIMEAssociationDialogA)(HWND hwndParent, DWORD dwInFlags, PCSTR pcszFile, PCSTR pcszMIMEContentType, PSTR pszAppBuf, UINT ucAppBufLen);
typedef HRESULT(__stdcall* MIMEAssociationDialogW)(HWND hwndParent, DWORD dwInFlags, PCWSTR pcszFile, PCWSTR pcszMIMEContentType, PWSTR pszAppBuf, UINT ucAppBufLen);
typedef BOOL(__stdcall* InetIsOffline)(DWORD dwFlags);
typedef HANDLE(__stdcall* CreateIoCompletionPort)(HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads);
typedef BOOL(__stdcall* GetQueuedCompletionStatusEx)(HANDLE CompletionPort, LPOVERLAPPED_ENTRY lpCompletionPortEntries, ULONG ulCount, PULONG ulNumEntriesRemoved, DWORD dwMilliseconds, BOOL fAlertable);
typedef BOOL(__stdcall* PostQueuedCompletionStatus)(HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* DeviceIoControl)(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* GetOverlappedResult)(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait);
typedef BOOL(__stdcall* CancelIoEx)(HANDLE hFile, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* CancelIo)(HANDLE hFile);
typedef BOOL(__stdcall* GetOverlappedResultEx)(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, DWORD dwMilliseconds, BOOL bAlertable);
typedef BOOL(__stdcall* CancelSynchronousIo)(HANDLE hThread);
typedef DWORD(__stdcall* GetNumberOfInterfaces)(PDWORD pdwNumIf);
typedef DWORD(__stdcall* GetIfEntry)(PMIB_IFROW pIfRow);
typedef DWORD(__stdcall* GetIfTable)(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder);
typedef DWORD(__stdcall* GetIpAddrTable)(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder);
typedef ULONG(__stdcall* GetIpNetTable)(PMIB_IPNETTABLE IpNetTable, PULONG SizePointer, BOOL Order);
typedef DWORD(__stdcall* GetIpForwardTable)(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder);
typedef ULONG(__stdcall* GetTcpTable)(PMIB_TCPTABLE TcpTable, PULONG SizePointer, BOOL Order);
typedef DWORD(__stdcall* GetExtendedTcpTable)(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved);
typedef DWORD(__stdcall* GetOwnerModuleFromTcpEntry)(PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID pBuffer, PDWORD pdwSize);
typedef ULONG(__stdcall* GetUdpTable)(PMIB_UDPTABLE UdpTable, PULONG SizePointer, BOOL Order);
typedef DWORD(__stdcall* GetExtendedUdpTable)(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved);
typedef DWORD(__stdcall* GetOwnerModuleFromUdpEntry)(PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID pBuffer, PDWORD pdwSize);
typedef ULONG(__stdcall* GetTcpTable2)(PMIB_TCPTABLE2 TcpTable, PULONG SizePointer, BOOL Order);
typedef ULONG(__stdcall* GetIpStatistics)(PMIB_IPSTATS Statistics);
typedef ULONG(__stdcall* GetIcmpStatistics)(PMIB_ICMP Statistics);
typedef ULONG(__stdcall* GetTcpStatistics)(PMIB_TCPSTATS Statistics);
typedef ULONG(__stdcall* GetUdpStatistics)(PMIB_UDPSTATS Stats);
typedef ULONG(__stdcall* SetIpStatisticsEx)(PMIB_IPSTATS Statistics, ULONG Family);
typedef ULONG(__stdcall* GetIpStatisticsEx)(PMIB_IPSTATS Statistics, ULONG Family);
typedef ULONG(__stdcall* GetIcmpStatisticsEx)(PMIB_ICMP_EX Statistics, ULONG Family);
typedef ULONG(__stdcall* GetTcpStatisticsEx)(PMIB_TCPSTATS Statistics, ULONG Family);
typedef ULONG(__stdcall* GetUdpStatisticsEx)(PMIB_UDPSTATS Statistics, ULONG Family);
typedef ULONG(__stdcall* GetTcpStatisticsEx2)(PMIB_TCPSTATS2 Statistics, ULONG Family);
typedef ULONG(__stdcall* GetUdpStatisticsEx2)(PMIB_UDPSTATS2 Statistics, ULONG Family);
typedef DWORD(__stdcall* SetIfEntry)(PMIB_IFROW pIfRow);
typedef DWORD(__stdcall* CreateIpForwardEntry)(PMIB_IPFORWARDROW pRoute);
typedef DWORD(__stdcall* SetIpForwardEntry)(PMIB_IPFORWARDROW pRoute);
typedef DWORD(__stdcall* DeleteIpForwardEntry)(PMIB_IPFORWARDROW pRoute);
typedef DWORD(__stdcall* SetIpStatistics)(PMIB_IPSTATS pIpStats);
typedef DWORD(__stdcall* SetIpTTL)(UINT nTTL);
typedef DWORD(__stdcall* CreateIpNetEntry)(PMIB_IPNETROW pArpEntry);
typedef DWORD(__stdcall* SetIpNetEntry)(PMIB_IPNETROW pArpEntry);
typedef DWORD(__stdcall* DeleteIpNetEntry)(PMIB_IPNETROW pArpEntry);
typedef DWORD(__stdcall* FlushIpNetTable)(DWORD dwIfIndex);
typedef DWORD(__stdcall* CreateProxyArpEntry)(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex);
typedef DWORD(__stdcall* DeleteProxyArpEntry)(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex);
typedef DWORD(__stdcall* SetTcpEntry)(PMIB_TCPROW pTcpRow);
typedef DWORD(__stdcall* GetInterfaceInfo)(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen);
typedef DWORD(__stdcall* GetUniDirectionalAdapterInfo)(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen);
typedef DWORD(__stdcall* GetBestInterface)(IPAddr dwDestAddr, PDWORD pdwBestIfIndex);
typedef DWORD(__stdcall* GetBestRoute)(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute);
typedef DWORD(__stdcall* NotifyAddrChange)(PHANDLE Handle, LPOVERLAPPED overlapped);
typedef DWORD(__stdcall* NotifyRouteChange)(PHANDLE Handle, LPOVERLAPPED overlapped);
typedef BOOL(__stdcall* CancelIPChangeNotify)(LPOVERLAPPED notifyOverlapped);
typedef DWORD(__stdcall* GetAdapterIndex)(LPWSTR AdapterName, PULONG IfIndex);
typedef DWORD(__stdcall* AddIPAddress)(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance);
typedef DWORD(__stdcall* DeleteIPAddress)(ULONG NTEContext);
typedef DWORD(__stdcall* GetNetworkParams)(PFIXED_INFO pFixedInfo, PULONG pOutBufLen);
typedef ULONG(__stdcall* GetAdaptersInfo)(PIP_ADAPTER_INFO AdapterInfo, PULONG SizePointer);
typedef DWORD(__stdcall* GetPerAdapterInfo)(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen);
typedef void(__stdcall* CancelIfTimestampConfigChange)(HIFTIMESTAMPCHANGE NotificationHandle);
typedef DWORD(__stdcall* IpReleaseAddress)(PIP_ADAPTER_INDEX_MAP AdapterInfo);
typedef DWORD(__stdcall* IpRenewAddress)(PIP_ADAPTER_INDEX_MAP AdapterInfo);
typedef DWORD(__stdcall* SendARP)(IPAddr DestIP, IPAddr SrcIP, PVOID pMacAddr, PULONG PhyAddrLen);
typedef BOOL(__stdcall* GetRTTAndHopCount)(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT);
typedef DWORD(__stdcall* GetFriendlyIfIndex)(DWORD IfIndex);
typedef DWORD(__stdcall* GetIpErrorString)(IP_STATUS ErrorCode, PWSTR Buffer, PDWORD Size);
typedef ULONG(__stdcall* CreatePersistentTcpPortReservation)(USHORT StartPort, USHORT NumberOfPorts, PULONG64 Token);
typedef ULONG(__stdcall* CreatePersistentUdpPortReservation)(USHORT StartPort, USHORT NumberOfPorts, PULONG64 Token);
typedef ULONG(__stdcall* DeletePersistentTcpPortReservation)(USHORT StartPort, USHORT NumberOfPorts);
typedef ULONG(__stdcall* DeletePersistentUdpPortReservation)(USHORT StartPort, USHORT NumberOfPorts);
typedef ULONG(__stdcall* LookupPersistentTcpPortReservation)(USHORT StartPort, USHORT NumberOfPorts, PULONG64 Token);
typedef ULONG(__stdcall* LookupPersistentUdpPortReservation)(USHORT StartPort, USHORT NumberOfPorts, PULONG64 Token);
typedef BOOL(__stdcall* IsProcessInJob)(HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result);
typedef BOOL(__stdcall* AssignProcessToJobObject)(HANDLE hJob, HANDLE hProcess);
typedef BOOL(__stdcall* TerminateJobObject)(HANDLE hJob, UINT uExitCode);
typedef BOOL(__stdcall* SetInformationJobObject)(HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength);
typedef BOOL(__stdcall* QueryInformationJobObject)(HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength);
typedef MMRESULT(__stdcall* joyGetPosEx)(UINT uJoyID, LPJOYINFOEX pji);
typedef MMRESULT(__stdcall* joyGetDevCapsW)(UINT_PTR uJoyID, LPJOYCAPSW pjc, UINT cbjc);
typedef MMRESULT(__stdcall* joyGetPos)(UINT uJoyID, LPJOYINFO pji);
typedef MMRESULT(__stdcall* joyGetThreshold)(UINT uJoyID, LPUINT puThreshold);
typedef MMRESULT(__stdcall* joyReleaseCapture)(UINT uJoyID);
typedef MMRESULT(__stdcall* joySetCapture)(HWND hwnd, UINT uJoyID, UINT uPeriod, BOOL fChanged);
typedef MMRESULT(__stdcall* joySetThreshold)(UINT uJoyID, UINT uThreshold);
typedef MMRESULT(__stdcall* joyConfigChanged)(DWORD dwFlags);
typedef HANDLE(__stdcall* CreateTransaction)(LPSECURITY_ATTRIBUTES lpTransactionAttributes, LPGUID UOW, DWORD CreateOptions, DWORD IsolationLevel, DWORD IsolationFlags, DWORD Timeout, LPWSTR Description);
typedef HANDLE(__stdcall* OpenTransaction)(DWORD dwDesiredAccess, LPGUID TransactionId);
typedef BOOL(__stdcall* CommitTransaction)(HANDLE TransactionHandle);
typedef BOOL(__stdcall* CommitTransactionAsync)(HANDLE TransactionHandle);
typedef BOOL(__stdcall* RollbackTransaction)(HANDLE TransactionHandle);
typedef BOOL(__stdcall* RollbackTransactionAsync)(HANDLE TransactionHandle);
typedef BOOL(__stdcall* GetTransactionId)(HANDLE TransactionHandle, LPGUID TransactionId);
typedef BOOL(__stdcall* GetTransactionInformation)(HANDLE TransactionHandle, PDWORD Outcome, PDWORD IsolationLevel, PDWORD IsolationFlags, PDWORD Timeout, DWORD BufferLength, LPWSTR Description);
typedef BOOL(__stdcall* SetTransactionInformation)(HANDLE TransactionHandle, DWORD IsolationLevel, DWORD IsolationFlags, DWORD Timeout, LPWSTR Description);
typedef HANDLE(__stdcall* CreateTransactionManager)(LPSECURITY_ATTRIBUTES lpTransactionAttributes, LPWSTR LogFileName, ULONG CreateOptions, ULONG CommitStrength);
typedef HANDLE(__stdcall* OpenTransactionManager)(LPWSTR LogFileName, ACCESS_MASK DesiredAccess, ULONG OpenOptions);
typedef HANDLE(__stdcall* OpenTransactionManagerById)(LPGUID TransactionManagerId, ACCESS_MASK DesiredAccess, ULONG OpenOptions);
typedef BOOL(__stdcall* RenameTransactionManager)(LPWSTR LogFileName, LPGUID ExistingTransactionManagerGuid);
typedef BOOL(__stdcall* RollforwardTransactionManager)(HANDLE TransactionManagerHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* RecoverTransactionManager)(HANDLE TransactionManagerHandle);
typedef BOOL(__stdcall* GetCurrentClockTransactionManager)(HANDLE TransactionManagerHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* GetTransactionManagerId)(HANDLE TransactionManagerHandle, LPGUID TransactionManagerId);
typedef HANDLE(__stdcall* CreateResourceManager)(LPSECURITY_ATTRIBUTES lpResourceManagerAttributes, LPGUID ResourceManagerId, DWORD CreateOptions, HANDLE TmHandle, LPWSTR Description);
typedef HANDLE(__stdcall* OpenResourceManager)(DWORD dwDesiredAccess, HANDLE TmHandle, LPGUID ResourceManagerId);
typedef BOOL(__stdcall* RecoverResourceManager)(HANDLE ResourceManagerHandle);
typedef BOOL(__stdcall* GetNotificationResourceManager)(HANDLE ResourceManagerHandle, PTRANSACTION_NOTIFICATION TransactionNotification, ULONG NotificationLength, DWORD dwMilliseconds, PULONG ReturnLength);
typedef BOOL(__stdcall* GetNotificationResourceManagerAsync)(HANDLE ResourceManagerHandle, PTRANSACTION_NOTIFICATION TransactionNotification, ULONG TransactionNotificationLength, PULONG ReturnLength, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* SetResourceManagerCompletionPort)(HANDLE ResourceManagerHandle, HANDLE IoCompletionPortHandle, ULONG_PTR CompletionKey);
typedef HANDLE(__stdcall* CreateEnlistment)(LPSECURITY_ATTRIBUTES lpEnlistmentAttributes, HANDLE ResourceManagerHandle, HANDLE TransactionHandle, NOTIFICATION_MASK NotificationMask, DWORD CreateOptions, PVOID EnlistmentKey);
typedef HANDLE(__stdcall* OpenEnlistment)(DWORD dwDesiredAccess, HANDLE ResourceManagerHandle, LPGUID EnlistmentId);
typedef BOOL(__stdcall* RecoverEnlistment)(HANDLE EnlistmentHandle, PVOID EnlistmentKey);
typedef BOOL(__stdcall* GetEnlistmentRecoveryInformation)(HANDLE EnlistmentHandle, ULONG BufferSize, PVOID Buffer, PULONG BufferUsed);
typedef BOOL(__stdcall* GetEnlistmentId)(HANDLE EnlistmentHandle, LPGUID EnlistmentId);
typedef BOOL(__stdcall* SetEnlistmentRecoveryInformation)(HANDLE EnlistmentHandle, ULONG BufferSize, PVOID Buffer);
typedef BOOL(__stdcall* PrepareEnlistment)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* PrePrepareEnlistment)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* CommitEnlistment)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* RollbackEnlistment)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* PrePrepareComplete)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* PrepareComplete)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* ReadOnlyEnlistment)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* CommitComplete)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* RollbackComplete)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* SinglePhaseReject)(HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock);
typedef BOOL(__stdcall* DisableThreadLibraryCalls)(HMODULE hLibModule);
typedef int(__stdcall* FindStringOrdinal)(DWORD dwFindStringOrdinalFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, BOOL bIgnoreCase);
typedef BOOL(__stdcall* FreeLibrary)(HMODULE hLibModule);
typedef void(__stdcall* FreeLibraryAndExitThread)(HMODULE hLibModule, DWORD dwExitCode);
typedef BOOL(__stdcall* FreeResource)(HGLOBAL hResData);
typedef DWORD(__stdcall* GetModuleFileNameA)(HMODULE hModule, LPSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* GetModuleFileNameW)(HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
typedef HMODULE(__stdcall* GetModuleHandleA)(LPCSTR lpModuleName);
typedef HMODULE(__stdcall* GetModuleHandleW)(LPCWSTR lpModuleName);
typedef FARPROC(__stdcall* GetProcAddress)(HMODULE hModule, LPCSTR lpProcName);
typedef HMODULE(__stdcall* LoadLibraryExA)(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
typedef HMODULE(__stdcall* LoadLibraryExW)(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
typedef HGLOBAL(__stdcall* LoadResource)(HMODULE hModule, HRSRC hResInfo);
typedef LPVOID(__stdcall* LockResource)(HGLOBAL hResData);
typedef DWORD(__stdcall* SizeofResource)(HMODULE hModule, HRSRC hResInfo);
typedef DLL_DIRECTORY_COOKIE(__stdcall* AddDllDirectory)(PCWSTR NewDirectory);
typedef BOOL(__stdcall* RemoveDllDirectory)(DLL_DIRECTORY_COOKIE Cookie);
typedef BOOL(__stdcall* SetDefaultDllDirectories)(DWORD DirectoryFlags);
typedef BOOL(__stdcall* EnumResourceLanguagesExA)(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef BOOL(__stdcall* EnumResourceLanguagesExW)(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef BOOL(__stdcall* EnumResourceNamesExA)(HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef BOOL(__stdcall* EnumResourceNamesExW)(HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef BOOL(__stdcall* EnumResourceTypesExA)(HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef BOOL(__stdcall* EnumResourceTypesExW)(HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
typedef HMODULE(__stdcall* LoadLibraryA)(LPCSTR lpLibFileName);
typedef HMODULE(__stdcall* LoadLibraryW)(LPCWSTR lpLibFileName);
typedef BOOL(__stdcall* QueryOptionalDelayLoadedAPI)(HMODULE hParentModule, LPCSTR lpDllName, LPCSTR lpProcName, DWORD Reserved);
typedef DWORD(__stdcall* NetUserAdd)(LPCWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetUserSetInfo)(LPCWSTR servername, LPCWSTR username, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetUserDel)(LPCWSTR servername, LPCWSTR username);
typedef DWORD(__stdcall* NetUserSetGroups)(LPCWSTR servername, LPCWSTR username, DWORD level, LPBYTE buf, DWORD num_entries);
typedef DWORD(__stdcall* NetUserModalsSet)(LPCWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetUserChangePassword)(LPCWSTR domainname, LPCWSTR username, LPCWSTR oldpassword, LPCWSTR newpassword);
typedef DWORD(__stdcall* NetGroupAdd)(LPCWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetGroupAddUser)(LPCWSTR servername, LPCWSTR GroupName, LPCWSTR username);
typedef DWORD(__stdcall* NetGroupSetInfo)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetGroupDel)(LPCWSTR servername, LPCWSTR groupname);
typedef DWORD(__stdcall* NetGroupDelUser)(LPCWSTR servername, LPCWSTR GroupName, LPCWSTR Username);
typedef DWORD(__stdcall* NetGroupSetUsers)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, DWORD totalentries);
typedef DWORD(__stdcall* NetLocalGroupAdd)(LPCWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetLocalGroupSetInfo)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetLocalGroupDel)(LPCWSTR servername, LPCWSTR groupname);
typedef DWORD(__stdcall* NetLocalGroupSetMembers)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, DWORD totalentries);
typedef DWORD(__stdcall* NetLocalGroupAddMembers)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, DWORD totalentries);
typedef DWORD(__stdcall* NetLocalGroupDelMembers)(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE buf, DWORD totalentries);
typedef DWORD(__stdcall* NetGetDisplayInformationIndex)(LPCWSTR ServerName, DWORD Level, LPCWSTR Prefix, LPDWORD Index);
typedef DWORD(__stdcall* NetAccessAdd)(LPCWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetAccessSetInfo)(LPCWSTR servername, LPCWSTR resource, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetAccessDel)(LPCWSTR servername, LPCWSTR resource);
typedef DWORD(__stdcall* NetAccessGetUserPerms)(LPCWSTR servername, LPCWSTR UGname, LPCWSTR resource, LPDWORD Perms);
typedef NTSTATUS(__stdcall* NetAddServiceAccount)(LPWSTR ServerName, LPWSTR AccountName, LPWSTR Password, DWORD Flags);
typedef NTSTATUS(__stdcall* NetRemoveServiceAccount)(LPWSTR ServerName, LPWSTR AccountName, DWORD Flags);
typedef DWORD(__stdcall* NetServerSetInfo)(LPWSTR servername, DWORD level, LPBYTE buf, LPDWORD ParmError);
typedef DWORD(__stdcall* NetServerComputerNameAdd)(LPWSTR ServerName, LPWSTR EmulatedDomainName, LPWSTR EmulatedServerName);
typedef DWORD(__stdcall* NetServerComputerNameDel)(LPWSTR ServerName, LPWSTR EmulatedServerName);
typedef DWORD(__stdcall* NetServerTransportAdd)(LPWSTR servername, DWORD level, LPBYTE bufptr);
typedef DWORD(__stdcall* NetServerTransportAddEx)(LPWSTR servername, DWORD level, LPBYTE bufptr);
typedef DWORD(__stdcall* NetServerTransportDel)(LPWSTR servername, DWORD level, LPBYTE bufptr);
typedef BOOL(__stdcall* SetServiceBits)(SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwServiceBits, BOOL bSetBitsOn, BOOL bUpdateImmediately);
typedef DWORD(__stdcall* NetShareAdd)(LPWSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetShareSetInfo)(LPWSTR servername, LPWSTR netname, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetShareDel)(LPWSTR servername, LPWSTR netname, DWORD reserved);
typedef DWORD(__stdcall* NetShareCheck)(LPWSTR servername, LPWSTR device, LPDWORD type);
typedef DWORD(__stdcall* NetShareDelEx)(LPWSTR servername, DWORD level, LPBYTE buf);
typedef DWORD(__stdcall* NetSessionDel)(LPWSTR servername, LPWSTR UncClientName, LPWSTR username);
typedef DWORD(__stdcall* NetFileClose)(LPWSTR servername, DWORD fileid);
typedef DWORD(__stdcall* NetUseAdd)(LPTSTR servername, DWORD LevelFlags, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetUseDel)(LPWSTR UncServerName, LPWSTR UseName, DWORD ForceLevelFlags);
typedef DWORD(__stdcall* NetWkstaSetInfo)(LPWSTR servername, DWORD level, LPBYTE buffer, LPDWORD parm_err);
typedef DWORD(__stdcall* NetWkstaUserSetInfo)(LPWSTR reserved, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetWkstaTransportAdd)(LPTSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err);
typedef DWORD(__stdcall* NetWkstaTransportDel)(LPWSTR servername, LPWSTR transportname, DWORD ucond);
typedef DWORD(__stdcall* InstallPerfDllW)(LPCWSTR szComputerName, LPCWSTR lpIniFile, ULONG_PTR dwFlags);
typedef DWORD(__stdcall* InstallPerfDllA)(LPCSTR szComputerName, LPCSTR lpIniFile, ULONG_PTR dwFlags);
typedef DWORD(__stdcall* LoadPerfCounterTextStringsA)(LPSTR lpCommandLine, BOOL bQuietModeArg);
typedef DWORD(__stdcall* LoadPerfCounterTextStringsW)(LPWSTR lpCommandLine, BOOL bQuietModeArg);
typedef DWORD(__stdcall* UnloadPerfCounterTextStringsW)(LPWSTR lpCommandLine, BOOL bQuietModeArg);
typedef DWORD(__stdcall* UnloadPerfCounterTextStringsA)(LPSTR lpCommandLine, BOOL bQuietModeArg);
typedef _BOOL(__stdcall* GetVCPFeatureAndVCPFeatureReply)(HANDLE hMonitor, BYTE bVCPCode, LPMC_VCP_CODE_TYPE pvct, LPDWORD pdwCurrentValue, LPDWORD pdwMaximumValue);
typedef _BOOL(__stdcall* SetVCPFeature)(HANDLE hMonitor, BYTE bVCPCode, DWORD dwNewValue);
typedef _BOOL(__stdcall* SaveCurrentSettings)(HANDLE hMonitor);
typedef _BOOL(__stdcall* GetCapabilitiesStringLength)(HANDLE hMonitor, LPDWORD pdwCapabilitiesStringLengthInCharacters);
typedef _BOOL(__stdcall* CapabilitiesRequestAndCapabilitiesReply)(HANDLE hMonitor, LPSTR pszASCIICapabilitiesString, DWORD dwCapabilitiesStringLengthInCharacters);
typedef _BOOL(__stdcall* GetTimingReport)(HANDLE hMonitor, LPMC_TIMING_REPORT pmtrMonitorTimingReport);
typedef LONG(__stdcall* LZCopy)(INT hfSource, INT hfDest);
typedef INT(__stdcall* LZInit)(INT hfSource);
typedef INT(__stdcall* GetExpandedNameA)(LPSTR lpszSource, LPSTR lpszBuffer);
typedef INT(__stdcall* GetExpandedNameW)(LPWSTR lpszSource, LPWSTR lpszBuffer);
typedef INT(__stdcall* LZOpenFileA)(LPSTR lpFileName, LPOFSTRUCT lpReOpenBuf, WORD wStyle);
typedef INT(__stdcall* LZOpenFileW)(LPWSTR lpFileName, LPOFSTRUCT lpReOpenBuf, WORD wStyle);
typedef LONG(__stdcall* LZSeek)(INT hFile, LONG lOffset, INT iOrigin);
typedef void(__stdcall* LZClose)(INT hFile);
typedef HRESULT(__stdcall* SetManagedExternally)(BOOL IsManagedExternally);
typedef HRESULT(__stdcall* RegisterDeviceWithManagementUsingAADCredentials)(HANDLE UserToken);
typedef HRESULT(__stdcall* RegisterDeviceWithManagementUsingAADDeviceCredentials)();
typedef HRESULT(__stdcall* RegisterDeviceWithManagement)(LPCWSTR pszUPN, LPCWSTR ppszMDMServiceUri, LPCWSTR ppzsAccessToken);
typedef HRESULT(__stdcall* UnregisterDeviceWithManagement)(LPCWSTR enrollmentID);
typedef HRESULT(__stdcall* GetManagementAppHyperlink)(DWORD cchHyperlink, LPWSTR pszHyperlink);
typedef LPVOID(__stdcall* VirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
typedef BOOL(__stdcall* VirtualProtect)(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
typedef BOOL(__stdcall* VirtualFree)(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
typedef SIZE_T(__stdcall* VirtualQuery)(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
typedef LPVOID(__stdcall* VirtualAllocEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
typedef BOOL(__stdcall* VirtualProtectEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
typedef SIZE_T(__stdcall* VirtualQueryEx)(HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
typedef LPVOID(__stdcall* MapViewOfFile)(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap);
typedef LPVOID(__stdcall* MapViewOfFileEx)(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress);
typedef BOOL(__stdcall* VirtualFreeEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
typedef BOOL(__stdcall* FlushViewOfFile)(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush);
typedef BOOL(__stdcall* UnmapViewOfFile)(LPCVOID lpBaseAddress);
typedef BOOL(__stdcall* GetProcessWorkingSetSizeEx)(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags);
typedef BOOL(__stdcall* SetProcessWorkingSetSizeEx)(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags);
typedef BOOL(__stdcall* VirtualLock)(LPVOID lpAddress, SIZE_T dwSize);
typedef BOOL(__stdcall* VirtualUnlock)(LPVOID lpAddress, SIZE_T dwSize);
typedef UINT(__stdcall* ResetWriteWatch)(LPVOID lpBaseAddress, SIZE_T dwRegionSize);
typedef HANDLE(__stdcall* CreateMemoryResourceNotification)(MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType);
typedef BOOL(__stdcall* QueryMemoryResourceNotification)(HANDLE ResourceNotificationHandle, PBOOL ResourceState);
typedef BOOL(__stdcall* GetSystemFileCacheSize)(PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags);
typedef BOOL(__stdcall* SetSystemFileCacheSize)(SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags);
typedef BOOL(__stdcall* PrefetchVirtualMemory)(HANDLE hProcess, ULONG_PTR NumberOfEntries, PWIN32_MEMORY_RANGE_ENTRY VirtualAddresses, ULONG Flags);
typedef HANDLE(__stdcall* CreateFileMappingFromApp)(HANDLE hFile, PSECURITY_ATTRIBUTES SecurityAttributes, ULONG PageProtection, ULONG64 MaximumSize, PCWSTR Name);
typedef PVOID(__stdcall* MapViewOfFileFromApp)(HANDLE hFileMappingObject, ULONG DesiredAccess, ULONG64 FileOffset, SIZE_T NumberOfBytesToMap);
typedef BOOL(__stdcall* UnmapViewOfFileEx)(PVOID BaseAddress, ULONG UnmapFlags);
typedef BOOL(__stdcall* AllocateUserPhysicalPages)(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray);
typedef BOOL(__stdcall* FreeUserPhysicalPages)(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray);
typedef BOOL(__stdcall* MapUserPhysicalPages)(PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray);
typedef BOOL(__stdcall* AllocateUserPhysicalPagesNuma)(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray, DWORD nndPreferred);
typedef LPVOID(__stdcall* VirtualAllocExNuma)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect, DWORD nndPreferred);
typedef BOOL(__stdcall* GetMemoryErrorHandlingCapabilities)(PULONG Capabilities);
typedef PVOID(__stdcall* RegisterBadMemoryNotification)(PBAD_MEMORY_CALLBACK_ROUTINE Callback);
typedef BOOL(__stdcall* UnregisterBadMemoryNotification)(PVOID RegistrationHandle);
typedef DWORD(__stdcall* OfferVirtualMemory)(PVOID VirtualAddress, SIZE_T Size, OFFER_PRIORITY Priority);
typedef DWORD(__stdcall* DiscardVirtualMemory)(PVOID VirtualAddress, SIZE_T Size);
typedef BOOL(__stdcall* SetProcessValidCallTargets)(HANDLE hProcess, PVOID VirtualAddress, SIZE_T RegionSize, ULONG NumberOfOffsets, PCFG_CALL_TARGET_INFO OffsetInformation);
typedef PVOID(__stdcall* VirtualAllocFromApp)(PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG Protection);
typedef BOOL(__stdcall* VirtualProtectFromApp)(PVOID Address, SIZE_T Size, ULONG NewProtection, PULONG OldProtection);
typedef HANDLE(__stdcall* OpenFileMappingFromApp)(ULONG DesiredAccess, BOOL InheritHandle, PCWSTR Name);
typedef PVOID(__stdcall* MapViewOfFileNuma2)(HANDLE FileMappingHandle, HANDLE ProcessHandle, ULONG64 Offset, PVOID BaseAddress, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, ULONG PreferredNode);
typedef PVOID(__stdcall* MapViewOfFile2)(HANDLE FileMappingHandle, HANDLE ProcessHandle, ULONG64 Offset, PVOID BaseAddress, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection);
typedef BOOL(__stdcall* UnmapViewOfFile2)(HANDLE Process, PVOID BaseAddress, ULONG UnmapFlags);
typedef void(__stdcall* CoHandlePriorityEventsFromMessagePump)();
typedef HRESULT(__stdcall* MFStartup)(ULONG Version, DWORD dwFlags);
typedef HRESULT(__stdcall* MFShutdown)();
typedef HRESULT(__stdcall* MFLockPlatform)();
typedef HRESULT(__stdcall* MFUnlockPlatform)();
typedef HRESULT(__stdcall* MFCancelWorkItem)(MFWORKITEM_KEY Key);
typedef HRESULT(__stdcall* MFRemovePeriodicCallback)(DWORD dwKey);
typedef HRESULT(__stdcall* MFLockWorkQueue)(DWORD dwWorkQueue);
typedef HRESULT(__stdcall* MFUnlockWorkQueue)(DWORD dwWorkQueue);
typedef HRESULT(__stdcall* MFGetWorkQueueMMCSSTaskId)(DWORD dwWorkQueueId, LPDWORD pdwTaskId);
typedef HRESULT(__stdcall* MFUnregisterPlatformFromMMCSS)();
typedef DXGI_FORMAT(__stdcall* MFMapDX9FormatToDXGIFormat)(DWORD dx9);
typedef DWORD(__stdcall* MFMapDXGIFormatToDX9Format)(DXGI_FORMAT dx11);
typedef HRESULT(__stdcall* MFUnlockDXGIDeviceManager)();
typedef HRESULT(__stdcall* MFTUnregister)(CLSID clsidMFT);
typedef HRESULT(__stdcall* MFTUnregisterLocalByCLSID)(CLSID clsidMFT);
typedef BOOL(__stdcall* MFIsFormatYUV)(DWORD Format);
typedef LONGLONG(__stdcall* MFllMulDiv)(LONGLONG a, LONGLONG b, LONGLONG c, LONGLONG d);
typedef MFTIME(__stdcall* MFGetSystemTime)();
typedef LPSNMP_MGR_SESSION(__stdcall* SnmpMgrOpen)(LPSTR lpAgentAddress, LPSTR lpAgentCommunity, INT nTimeOut, INT nRetries);
typedef BOOL(__stdcall* SnmpMgrCtl)(LPSNMP_MGR_SESSION session, DWORD dwCtlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOUTBuffer, DWORD cbOUTBuffer, LPDWORD lpcbBytesReturned);
typedef BOOL(__stdcall* SnmpMgrClose)(LPSNMP_MGR_SESSION session);
typedef RPC_STATUS(__stdcall* MesHandleFree)(handle_t Handle);
typedef void(__stdcall* mmTaskBlock)(DWORD h);
typedef BOOL(__stdcall* mmTaskSignal)(DWORD h);
typedef MMRESULT(__stdcall* waveOutGetVolume)(HWAVEOUT hwo, LPDWORD pdwVolume);
typedef MMRESULT(__stdcall* waveOutSetVolume)(HWAVEOUT hwo, DWORD dwVolume);
typedef MMRESULT(__stdcall* waveOutOpen)(LPHWAVEOUT phwo, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* waveOutClose)(HWAVEOUT hwo);
typedef MMRESULT(__stdcall* waveOutPrepareHeader)(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveOutUnprepareHeader)(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveOutWrite)(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveOutPause)(HWAVEOUT hwo);
typedef MMRESULT(__stdcall* waveOutRestart)(HWAVEOUT hwo);
typedef MMRESULT(__stdcall* waveOutReset)(HWAVEOUT hwo);
typedef MMRESULT(__stdcall* waveOutBreakLoop)(HWAVEOUT hwo);
typedef MMRESULT(__stdcall* waveOutGetPosition)(HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt);
typedef MMRESULT(__stdcall* waveOutGetPitch)(HWAVEOUT hwo, LPDWORD pdwPitch);
typedef MMRESULT(__stdcall* waveOutSetPitch)(HWAVEOUT hwo, DWORD dwPitch);
typedef MMRESULT(__stdcall* waveOutGetPlaybackRate)(HWAVEOUT hwo, LPDWORD pdwRate);
typedef MMRESULT(__stdcall* waveOutSetPlaybackRate)(HWAVEOUT hwo, DWORD dwRate);
typedef MMRESULT(__stdcall* waveOutGetID)(HWAVEOUT hwo, LPUINT puDeviceID);
typedef MMRESULT(__stdcall* waveOutMessage)(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef MMRESULT(__stdcall* waveInOpen)(LPHWAVEIN phwi, UINT uDeviceID, LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* waveInClose)(HWAVEIN hwi);
typedef MMRESULT(__stdcall* waveInPrepareHeader)(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveInUnprepareHeader)(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveInAddBuffer)(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh);
typedef MMRESULT(__stdcall* waveInStart)(HWAVEIN hwi);
typedef MMRESULT(__stdcall* waveInStop)(HWAVEIN hwi);
typedef MMRESULT(__stdcall* waveInReset)(HWAVEIN hwi);
typedef MMRESULT(__stdcall* waveInGetPosition)(HWAVEIN hwi, LPMMTIME pmmt, UINT cbmmt);
typedef MMRESULT(__stdcall* waveInGetID)(HWAVEIN hwi, LPUINT puDeviceID);
typedef MMRESULT(__stdcall* waveInMessage)(HWAVEIN hwi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef MMRESULT(__stdcall* midiStreamOpen)(LPHMIDISTRM phms, LPUINT puDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* midiStreamClose)(HMIDISTRM hms);
typedef MMRESULT(__stdcall* midiStreamProperty)(HMIDISTRM hms, LPBYTE lppropdata, DWORD dwProperty);
typedef MMRESULT(__stdcall* midiStreamPosition)(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
typedef MMRESULT(__stdcall* midiStreamOut)(HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiStreamPause)(HMIDISTRM hms);
typedef MMRESULT(__stdcall* midiStreamRestart)(HMIDISTRM hms);
typedef MMRESULT(__stdcall* midiStreamStop)(HMIDISTRM hms);
typedef MMRESULT(__stdcall* midiConnect)(HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved);
typedef MMRESULT(__stdcall* midiDisconnect)(HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved);
typedef MMRESULT(__stdcall* midiOutGetDevCapsA)(UINT_PTR uDeviceID, LPMIDIOUTCAPSA pmoc, UINT cbmoc);
typedef MMRESULT(__stdcall* midiOutGetDevCapsW)(UINT_PTR uDeviceID, LPMIDIOUTCAPSW pmoc, UINT cbmoc);
typedef MMRESULT(__stdcall* midiOutGetVolume)(HMIDIOUT hmo, LPDWORD pdwVolume);
typedef MMRESULT(__stdcall* midiOutSetVolume)(HMIDIOUT hmo, DWORD dwVolume);
typedef MMRESULT(__stdcall* midiOutGetErrorTextA)(MMRESULT mmrError, LPSTR pszText, UINT cchText);
typedef MMRESULT(__stdcall* midiOutGetErrorTextW)(MMRESULT mmrError, LPWSTR pszText, UINT cchText);
typedef MMRESULT(__stdcall* midiOutOpen)(LPHMIDIOUT phmo, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* midiOutClose)(HMIDIOUT hmo);
typedef MMRESULT(__stdcall* midiOutPrepareHeader)(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiOutUnprepareHeader)(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiOutShortMsg)(HMIDIOUT hmo, DWORD dwMsg);
typedef MMRESULT(__stdcall* midiOutLongMsg)(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiOutReset)(HMIDIOUT hmo);
typedef MMRESULT(__stdcall* midiOutCachePatches)(HMIDIOUT hmo, UINT uBank, LPWORD pwpa, UINT fuCache);
typedef MMRESULT(__stdcall* midiOutCacheDrumPatches)(HMIDIOUT hmo, UINT uPatch, LPWORD pwkya, UINT fuCache);
typedef MMRESULT(__stdcall* midiOutGetID)(HMIDIOUT hmo, LPUINT puDeviceID);
typedef MMRESULT(__stdcall* midiOutMessage)(HMIDIOUT hmo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef MMRESULT(__stdcall* midiInGetDevCapsA)(UINT_PTR uDeviceID, LPMIDIINCAPSA pmic, UINT cbmic);
typedef MMRESULT(__stdcall* midiInGetDevCapsW)(UINT_PTR uDeviceID, LPMIDIINCAPSW pmic, UINT cbmic);
typedef MMRESULT(__stdcall* midiInGetErrorTextA)(MMRESULT mmrError, LPSTR pszText, UINT cchText);
typedef MMRESULT(__stdcall* midiInGetErrorTextW)(MMRESULT mmrError, LPWSTR pszText, UINT cchText);
typedef MMRESULT(__stdcall* midiInOpen)(LPHMIDIIN phmi, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* midiInClose)(HMIDIIN hmi);
typedef MMRESULT(__stdcall* midiInPrepareHeader)(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiInUnprepareHeader)(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiInAddBuffer)(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh);
typedef MMRESULT(__stdcall* midiInStart)(HMIDIIN hmi);
typedef MMRESULT(__stdcall* midiInStop)(HMIDIIN hmi);
typedef MMRESULT(__stdcall* midiInReset)(HMIDIIN hmi);
typedef MMRESULT(__stdcall* midiInGetID)(HMIDIIN hmi, LPUINT puDeviceID);
typedef MMRESULT(__stdcall* midiInMessage)(HMIDIIN hmi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef MMRESULT(__stdcall* auxGetDevCapsA)(UINT_PTR uDeviceID, LPAUXCAPSA pac, UINT cbac);
typedef MMRESULT(__stdcall* auxGetDevCapsW)(UINT_PTR uDeviceID, LPAUXCAPSW pac, UINT cbac);
typedef MMRESULT(__stdcall* auxSetVolume)(UINT uDeviceID, DWORD dwVolume);
typedef MMRESULT(__stdcall* auxGetVolume)(UINT uDeviceID, LPDWORD pdwVolume);
typedef MMRESULT(__stdcall* auxOutMessage)(UINT uDeviceID, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef MMRESULT(__stdcall* mixerGetDevCapsA)(UINT_PTR uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps);
typedef MMRESULT(__stdcall* mixerGetDevCapsW)(UINT_PTR uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps);
typedef MMRESULT(__stdcall* mixerOpen)(LPHMIXER phmx, UINT uMxId, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
typedef MMRESULT(__stdcall* mixerClose)(HMIXER hmx);
typedef DWORD(__stdcall* mixerMessage)(HMIXER hmx, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
typedef MMRESULT(__stdcall* mixerGetLineInfoA)(HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo);
typedef MMRESULT(__stdcall* mixerGetLineInfoW)(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo);
typedef MMRESULT(__stdcall* mixerGetLineControlsA)(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls);
typedef MMRESULT(__stdcall* mixerGetLineControlsW)(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls);
typedef MMRESULT(__stdcall* mixerGetControlDetailsA)(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
typedef MMRESULT(__stdcall* mixerGetControlDetailsW)(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
typedef MMRESULT(__stdcall* mixerSetControlDetails)(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails);
typedef LRESULT(__stdcall* CloseDriver)(HDRVR hDriver, LPARAM lParam1, LPARAM lParam2);
typedef HDRVR(__stdcall* OpenDriver)(LPCWSTR szDriverName, LPCWSTR szSectionName, LPARAM lParam2);
typedef LRESULT(__stdcall* SendDriverMessage)(HDRVR hDriver, UINT message, LPARAM lParam1, LPARAM lParam2);
typedef HMODULE(__stdcall* DrvGetModuleHandle)(HDRVR hDriver);
typedef HMODULE(__stdcall* GetDriverModuleHandle)(HDRVR hDriver);
typedef LRESULT(__stdcall* DefDriverProc)(DWORD_PTR dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
typedef BOOL(__stdcall* DriverCallback)(DWORD_PTR dwCallback, DWORD dwFlags, HDRVR hDevice, DWORD dwMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
typedef LONG(__stdcall* sndOpenSound)(LPCWSTR EventName, LPCWSTR AppName, INT32 Flags, PHANDLE FileHandle);
typedef FOURCC(__stdcall* mmioStringToFOURCCA)(LPCSTR sz, UINT uFlags);
typedef FOURCC(__stdcall* mmioStringToFOURCCW)(LPCWSTR sz, UINT uFlags);
typedef LPMMIOPROC(__stdcall* mmioInstallIOProcA)(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags);
typedef LPMMIOPROC(__stdcall* mmioInstallIOProcW)(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags);
typedef HMMIO(__stdcall* mmioOpenA)(LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen);
typedef HMMIO(__stdcall* mmioOpenW)(LPWSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen);
typedef MMRESULT(__stdcall* mmioRenameA)(LPCSTR pszFileName, LPCSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename);
typedef MMRESULT(__stdcall* mmioRenameW)(LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename);
typedef MMRESULT(__stdcall* mmioClose)(HMMIO hmmio, UINT fuClose);
typedef LONG(__stdcall* mmioRead)(HMMIO hmmio, HPSTR pch, LONG cch);
typedef LONG(__stdcall* mmioSeek)(HMMIO hmmio, LONG lOffset, int iOrigin);
typedef MMRESULT(__stdcall* mmioGetInfo)(HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuInfo);
typedef MMRESULT(__stdcall* mmioSetInfo)(HMMIO hmmio, LPCMMIOINFO pmmioinfo, UINT fuInfo);
typedef MMRESULT(__stdcall* mmioSetBuffer)(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT fuBuffer);
typedef MMRESULT(__stdcall* mmioFlush)(HMMIO hmmio, UINT fuFlush);
typedef MMRESULT(__stdcall* mmioAdvance)(HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuAdvance);
typedef LRESULT(__stdcall* mmioSendMessage)(HMMIO hmmio, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
typedef MMRESULT(__stdcall* mmioAscend)(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuAscend);
typedef MMRESULT(__stdcall* mmioCreateChunk)(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuCreate);
typedef DWORD(__stdcall* MprAdminConnectionGetInfoEx)(RAS_SERVER_HANDLE hRasServer, HANDLE hRasConnection, PRAS_CONNECTION_EX pRasConnection);
typedef DWORD(__stdcall* MprAdminInterfaceSetCustomInfoEx)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, PMPR_IF_CUSTOMINFOEX2 pCustomInfo);
typedef DWORD(__stdcall* MprAdminInterfaceGetCustomInfoEx)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, PMPR_IF_CUSTOMINFOEX2 pCustomInfo);
typedef DWORD(__stdcall* MprConfigInterfaceGetCustomInfoEx)(HANDLE hMprConfig, HANDLE hRouterInterface, PMPR_IF_CUSTOMINFOEX2 pCustomInfo);
typedef DWORD(__stdcall* MprConfigInterfaceSetCustomInfoEx)(HANDLE hMprConfig, HANDLE hRouterInterface, PMPR_IF_CUSTOMINFOEX2 pCustomInfo);
typedef DWORD(__stdcall* MprAdminConnectionClearStats)(RAS_SERVER_HANDLE hRasServer, HANDLE hRasConnection);
typedef DWORD(__stdcall* MprAdminPortClearStats)(RAS_SERVER_HANDLE hRasServer, HANDLE hPort);
typedef DWORD(__stdcall* MprAdminPortReset)(RAS_SERVER_HANDLE hRasServer, HANDLE hPort);
typedef DWORD(__stdcall* MprAdminPortDisconnect)(RAS_SERVER_HANDLE hRasServer, HANDLE hPort);
typedef DWORD(__stdcall* MprAdminConnectionRemoveQuarantine)(HANDLE hRasServer, HANDLE hRasConnection, BOOL fIsIpAddress);
typedef DWORD(__stdcall* MprAdminUserGetInfo)(LPCWSTR lpszServer, LPCWSTR lpszUser, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminUserSetInfo)(LPCWSTR lpszServer, LPCWSTR lpszUser, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminSendUserMessage)(MPR_SERVER_HANDLE hMprServer, HANDLE hConnection, LPWSTR lpwszMessage);
typedef DWORD(__stdcall* MprAdminGetPDCServer)(LPCWSTR lpszDomain, LPCWSTR lpszServer, LPWSTR lpszPDCServer);
typedef BOOL(__stdcall* MprAdminIsServiceRunning)(LPWSTR lpwsServerName);
typedef void(__stdcall* MprAdminServerDisconnect)(MPR_SERVER_HANDLE hMprServer);
typedef DWORD(__stdcall* MprAdminServerSetCredentials)(MPR_SERVER_HANDLE hMprServer, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminBufferFree)(LPVOID pBuffer);
typedef DWORD(__stdcall* MprAdminServerSetInfo)(MPR_SERVER_HANDLE hMprServer, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminEstablishDomainRasServer)(LPWSTR pszDomain, LPWSTR pszMachine, BOOL bEnable);
typedef DWORD(__stdcall* MprAdminIsDomainRasServer)(LPWSTR pszDomain, LPWSTR pszMachine, PBOOL pbIsRasServer);
typedef DWORD(__stdcall* MprAdminTransportCreate)(MPR_SERVER_HANDLE hMprServer, DWORD dwTransportId, LPWSTR lpwsTransportName, LPBYTE pGlobalInfo, DWORD dwGlobalInfoSize, LPBYTE pClientInterfaceInfo, DWORD dwClientInterfaceInfoSize, LPWSTR lpwsDLLPath);
typedef DWORD(__stdcall* MprAdminTransportSetInfo)(MPR_SERVER_HANDLE hMprServer, DWORD dwTransportId, LPBYTE pGlobalInfo, DWORD dwGlobalInfoSize, LPBYTE pClientInterfaceInfo, DWORD dwClientInterfaceInfoSize);
typedef DWORD(__stdcall* MprAdminInterfaceSetInfo)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminInterfaceDelete)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface);
typedef DWORD(__stdcall* MprAdminInterfaceDeviceSetInfo)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwIndex, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminInterfaceTransportRemove)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwTransportId);
typedef DWORD(__stdcall* MprAdminInterfaceTransportAdd)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwTransportId, LPBYTE pInterfaceInfo, DWORD dwInterfaceInfoSize);
typedef DWORD(__stdcall* MprAdminInterfaceTransportSetInfo)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwTransportId, LPBYTE pInterfaceInfo, DWORD dwInterfaceInfoSize);
typedef DWORD(__stdcall* MprAdminInterfaceSetCredentials)(LPWSTR lpwsServer, LPWSTR lpwsInterfaceName, LPWSTR lpwsUserName, LPWSTR lpwsDomainName, LPWSTR lpwsPassword);
typedef DWORD(__stdcall* MprAdminInterfaceGetCredentials)(LPWSTR lpwsServer, LPWSTR lpwsInterfaceName, LPWSTR lpwsUserName, LPWSTR lpwsPassword, LPWSTR lpwsDomainName);
typedef DWORD(__stdcall* MprAdminInterfaceSetCredentialsEx)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprAdminInterfaceConnect)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, HANDLE hEvent, BOOL fSynchronous);
typedef DWORD(__stdcall* MprAdminInterfaceDisconnect)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface);
typedef DWORD(__stdcall* MprAdminInterfaceUpdateRoutes)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwProtocolId, HANDLE hEvent);
typedef DWORD(__stdcall* MprAdminInterfaceQueryUpdateResult)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface, DWORD dwProtocolId, LPDWORD lpdwUpdateResult);
typedef DWORD(__stdcall* MprAdminInterfaceUpdatePhonebookInfo)(MPR_SERVER_HANDLE hMprServer, HANDLE hInterface);
typedef DWORD(__stdcall* MprAdminRegisterConnectionNotification)(MPR_SERVER_HANDLE hMprServer, HANDLE hEventNotification);
typedef DWORD(__stdcall* MprAdminDeregisterConnectionNotification)(MPR_SERVER_HANDLE hMprServer, HANDLE hEventNotification);
typedef void(__stdcall* MprAdminMIBServerDisconnect)(MIB_SERVER_HANDLE hMibServer);
typedef DWORD(__stdcall* MprAdminMIBEntryCreate)(MIB_SERVER_HANDLE hMibServer, DWORD dwPid, DWORD dwRoutingPid, LPVOID lpEntry, DWORD dwEntrySize);
typedef DWORD(__stdcall* MprAdminMIBEntryDelete)(MIB_SERVER_HANDLE hMibServer, DWORD dwProtocolId, DWORD dwRoutingPid, LPVOID lpEntry, DWORD dwEntrySize);
typedef DWORD(__stdcall* MprAdminMIBEntrySet)(MIB_SERVER_HANDLE hMibServer, DWORD dwProtocolId, DWORD dwRoutingPid, LPVOID lpEntry, DWORD dwEntrySize);
typedef DWORD(__stdcall* MprAdminMIBBufferFree)(LPVOID pBuffer);
typedef DWORD(__stdcall* MprConfigServerInstall)(DWORD dwLevel, PVOID pBuffer);
typedef void(__stdcall* MprConfigServerDisconnect)(HANDLE hMprConfig);
typedef DWORD(__stdcall* MprConfigBufferFree)(LPVOID pBuffer);
typedef DWORD(__stdcall* MprConfigServerSetInfo)(MPR_SERVER_HANDLE hMprServer, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprConfigServerBackup)(HANDLE hMprConfig, LPWSTR lpwsPath);
typedef DWORD(__stdcall* MprConfigServerRestore)(HANDLE hMprConfig, LPWSTR lpwsPath);
typedef DWORD(__stdcall* MprConfigTransportDelete)(HANDLE hMprConfig, HANDLE hRouterTransport);
typedef DWORD(__stdcall* MprConfigTransportSetInfo)(HANDLE hMprConfig, HANDLE hRouterTransport, LPBYTE pGlobalInfo, DWORD dwGlobalInfoSize, LPBYTE pClientInterfaceInfo, DWORD dwClientInterfaceInfoSize, LPWSTR lpwsDLLPath);
typedef DWORD(__stdcall* MprConfigInterfaceDelete)(HANDLE hMprConfig, HANDLE hRouterInterface);
typedef DWORD(__stdcall* MprConfigInterfaceSetInfo)(HANDLE hMprConfig, HANDLE hRouterInterface, DWORD dwLevel, LPBYTE lpbBuffer);
typedef DWORD(__stdcall* MprConfigInterfaceTransportRemove)(HANDLE hMprConfig, HANDLE hRouterInterface, HANDLE hRouterIfTransport);
typedef DWORD(__stdcall* MprConfigInterfaceTransportSetInfo)(HANDLE hMprConfig, HANDLE hRouterInterface, HANDLE hRouterIfTransport, LPBYTE pInterfaceInfo, DWORD dwInterfaceInfoSize);
typedef DWORD(__stdcall* MprConfigGetFriendlyName)(HANDLE hMprConfig, PWSTR pszGuidName, PWCHAR pszBuffer, DWORD dwBufferSize);
typedef DWORD(__stdcall* MprConfigGetGuidName)(HANDLE hMprConfig, PWSTR pszFriendlyName, PWCHAR pszBuffer, DWORD dwBufferSize);
typedef DWORD(__stdcall* MprConfigFilterGetInfo)(HANDLE hMprConfig, DWORD dwLevel, DWORD dwTransportId, LPBYTE lpBuffer);
typedef DWORD(__stdcall* MprConfigFilterSetInfo)(HANDLE hMprConfig, DWORD dwLevel, DWORD dwTransportId, LPBYTE lpBuffer);
typedef DWORD(__stdcall* MprInfoDelete)(LPVOID lpHeader);
typedef DWORD(__stdcall* MprInfoBlockQuerySize)(LPVOID lpHeader);
typedef HANDLE(__stdcall* CryptCATOpen)(LPWSTR pwszFileName, DWORD fdwOpenFlags, HCRYPTPROV hProv, DWORD dwPublicVersion, DWORD dwEncodingType);
typedef BOOL(__stdcall* CryptCATClose)(HANDLE hCatalog);
typedef {'name': 'CryptCATStoreFromHandle', 'type': 'CRYPTCATSTORE'}(__stdcall* CryptCATStoreFromHandle)(HANDLE hCatalog);
typedef BOOL(__stdcall* CryptCATPersistStore)(HANDLE hCatalog);
typedef {'name': 'CryptCATGetMemberInfo', 'type': 'CRYPTCATMEMBER'}(__stdcall* CryptCATGetMemberInfo)(HANDLE hCatalog, LPWSTR pwszReferenceTag);
typedef {'name': 'CryptCATCDFOpen', 'type': 'CRYPTCATCDF'}(__stdcall* CryptCATCDFOpen)(LPWSTR pwszFilePath, PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError);
typedef BOOL(__stdcall* CryptCATAdminReleaseContext)(HCATADMIN hCatAdmin, DWORD dwFlags);
typedef BOOL(__stdcall* CryptCATAdminReleaseCatalogContext)(HCATADMIN hCatAdmin, HCATINFO hCatInfo, DWORD dwFlags);
typedef HCATINFO(__stdcall* CryptCATAdminAddCatalog)(HCATADMIN hCatAdmin, PWSTR pwszCatalogFile, PWSTR pwszSelectBaseName, DWORD dwFlags);
typedef BOOL(__stdcall* CryptCATAdminRemoveCatalog)(HCATADMIN hCatAdmin, LPCWSTR pwszCatalogFile, DWORD dwFlags);
typedef DWORD(__stdcall* MSChapSrvChangePassword)(PWSTR ServerName, PWSTR UserName, BOOLEAN LmOldPresent, PLM_OWF_PASSWORD LmOldOwfPassword, PLM_OWF_PASSWORD LmNewOwfPassword, PNT_OWF_PASSWORD NtOldOwfPassword, PNT_OWF_PASSWORD NtNewOwfPassword);
typedef DWORD(__stdcall* MSChapSrvChangePassword2)(PWSTR ServerName, PWSTR UserName, PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldNt, PENCRYPTED_NT_OWF_PASSWORD OldNtOwfPasswordEncryptedWithNewNt, BOOLEAN LmPresent, PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm, PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewLmOrNt);
typedef HRESULT(__stdcall* DRMSetGlobalOptions)(DRMGLOBALOPTIONS eGlobalOptions, LPVOID pvdata, DWORD dwlen);
typedef HRESULT(__stdcall* DRMCloseHandle)(DRMHANDLE handle);
typedef HRESULT(__stdcall* DRMCloseEnvironmentHandle)(DRMENVHANDLE hEnv);
typedef HRESULT(__stdcall* DRMRegisterRevocationList)(DRMENVHANDLE hEnv, PWSTR wszRevocationList);
typedef HRESULT(__stdcall* DRMCheckSecurity)(DRMENVHANDLE hEnv, UINT cLevel);
typedef HRESULT(__stdcall* DRMRegisterContent)(BOOL fRegister);
typedef HRESULT(__stdcall* DRMAddLicense)(DRMHSESSION hLicenseStorage, UINT uFlags, PWSTR wszLicense);
typedef HRESULT(__stdcall* DRMDeleteLicense)(DRMHSESSION hSession, PWSTR wszLicenseId);
typedef HRESULT(__stdcall* DRMCloseSession)(DRMHSESSION hSession);
typedef HRESULT(__stdcall* DRMCloseQueryHandle)(DRMQUERYHANDLE hQuery);
typedef HRESULT(__stdcall* DRMAddRightWithUser)(DRMPUBHANDLE hIssuanceLicense, DRMPUBHANDLE hRight, DRMPUBHANDLE hUser);
typedef HRESULT(__stdcall* DRMClearAllRights)(DRMPUBHANDLE hIssuanceLicense);
typedef HRESULT(__stdcall* DRMSetMetaData)(DRMPUBHANDLE hIssuanceLicense, PWSTR wszContentId, PWSTR wszContentIdType, PWSTR wszSKUId, PWSTR wszSKUIdType, PWSTR wszContentType, PWSTR wszContentName);
typedef HRESULT(__stdcall* DRMSetApplicationSpecificData)(DRMPUBHANDLE hIssuanceLicense, BOOL fDelete, PWSTR wszName, PWSTR wszValue);
typedef HRESULT(__stdcall* DRMSetNameAndDescription)(DRMPUBHANDLE hIssuanceLicense, BOOL fDelete, UINT lcid, PWSTR wszName, PWSTR wszDescription);
typedef HRESULT(__stdcall* DRMSetIntervalTime)(DRMPUBHANDLE hIssuanceLicense, UINT cDays);
typedef HRESULT(__stdcall* DRMClosePubHandle)(DRMPUBHANDLE hPub);
typedef HRESULT(__stdcall* DRMRepair)();
typedef HRESULT(__stdcall* DRMRegisterProtectedWindow)(DRMENVHANDLE hEnv, HWND hwnd);
typedef UINT(__stdcall* MsiCloseHandle)(MSIHANDLE hAny);
typedef UINT(__stdcall* MsiCloseAllHandles)();
typedef INSTALLUI_HANDLERA(__stdcall* MsiSetExternalUIA)(INSTALLUI_HANDLERA puiHandler, DWORD dwMessageFilter, LPVOID pvContext);
typedef INSTALLUI_HANDLERW(__stdcall* MsiSetExternalUIW)(INSTALLUI_HANDLERW puiHandler, DWORD dwMessageFilter, LPVOID pvContext);
typedef UINT(__stdcall* MsiSetExternalUIRecord)(INSTALLUI_HANDLER_RECORD puiHandler, DWORD dwMessageFilter, LPVOID pvContext, PINSTALLUI_HANDLER_RECORD ppuiPrevHandler);
typedef UINT(__stdcall* MsiEnableLogA)(DWORD dwLogMode, LPCSTR szLogFile, DWORD dwLogAttributes);
typedef UINT(__stdcall* MsiEnableLogW)(DWORD dwLogMode, LPCWSTR szLogFile, DWORD dwLogAttributes);
typedef INSTALLSTATE(__stdcall* MsiQueryProductStateA)(LPCSTR szProduct);
typedef INSTALLSTATE(__stdcall* MsiQueryProductStateW)(LPCWSTR szProduct);
typedef UINT(__stdcall* MsiGetProductInfoA)(LPCSTR szProduct, LPCSTR szAttribute, LPSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiGetProductInfoW)(LPCWSTR szProduct, LPCWSTR szAttribute, LPWSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiGetProductInfoExA)(LPCSTR szProductCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPCSTR szProperty, LPSTR szValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiGetProductInfoExW)(LPCWSTR szProductCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty, LPWSTR szValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiInstallProductA)(LPCSTR szPackagePath, LPCSTR szCommandLine);
typedef UINT(__stdcall* MsiInstallProductW)(LPCWSTR szPackagePath, LPCWSTR szCommandLine);
typedef UINT(__stdcall* MsiConfigureProductA)(LPCSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiConfigureProductW)(LPCWSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiConfigureProductExA)(LPCSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState, LPCSTR szCommandLine);
typedef UINT(__stdcall* MsiConfigureProductExW)(LPCWSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState, LPCWSTR szCommandLine);
typedef UINT(__stdcall* MsiReinstallProductA)(LPCSTR szProduct, DWORD szReinstallMode);
typedef UINT(__stdcall* MsiReinstallProductW)(LPCWSTR szProduct, DWORD szReinstallMode);
typedef UINT(__stdcall* MsiAdvertiseProductExA)(LPCSTR szPackagePath, LPCSTR szScriptfilePath, LPCSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions);
typedef UINT(__stdcall* MsiAdvertiseProductExW)(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath, LPCWSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions);
typedef UINT(__stdcall* MsiAdvertiseProductA)(LPCSTR szPackagePath, LPCSTR szScriptfilePath, LPCSTR szTransforms, LANGID lgidLanguage);
typedef UINT(__stdcall* MsiAdvertiseProductW)(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath, LPCWSTR szTransforms, LANGID lgidLanguage);
typedef UINT(__stdcall* MsiProcessAdvertiseScriptA)(LPCSTR szScriptFile, LPCSTR szIconFolder, HKEY hRegData, BOOL fShortcuts, BOOL fRemoveItems);
typedef UINT(__stdcall* MsiProcessAdvertiseScriptW)(LPCWSTR szScriptFile, LPCWSTR szIconFolder, HKEY hRegData, BOOL fShortcuts, BOOL fRemoveItems);
typedef UINT(__stdcall* MsiAdvertiseScriptA)(LPCSTR szScriptFile, DWORD dwFlags, PHKEY phRegData, BOOL fRemoveItems);
typedef UINT(__stdcall* MsiAdvertiseScriptW)(LPCWSTR szScriptFile, DWORD dwFlags, PHKEY phRegData, BOOL fRemoveItems);
typedef UINT(__stdcall* MsiGetProductCodeA)(LPCSTR szComponent, LPSTR lpBuf39);
typedef UINT(__stdcall* MsiGetProductCodeW)(LPCWSTR szComponent, LPWSTR lpBuf39);
typedef USERINFOSTATE(__stdcall* MsiGetUserInfoA)(LPCSTR szProduct, LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf, LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf, LPSTR lpSerialBuf, LPDWORD pcchSerialBuf);
typedef USERINFOSTATE(__stdcall* MsiGetUserInfoW)(LPCWSTR szProduct, LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf, LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf, LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf);
typedef UINT(__stdcall* MsiCollectUserInfoA)(LPCSTR szProduct);
typedef UINT(__stdcall* MsiCollectUserInfoW)(LPCWSTR szProduct);
typedef UINT(__stdcall* MsiApplyPatchA)(LPCSTR szPatchPackage, LPCSTR szInstallPackage, INSTALLTYPE eInstallType, LPCSTR szCommandLine);
typedef UINT(__stdcall* MsiApplyPatchW)(LPCWSTR szPatchPackage, LPCWSTR szInstallPackage, INSTALLTYPE eInstallType, LPCWSTR szCommandLine);
typedef UINT(__stdcall* MsiGetPatchInfoA)(LPCSTR szPatch, LPCSTR szAttribute, LPSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiGetPatchInfoW)(LPCWSTR szPatch, LPCWSTR szAttribute, LPWSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiEnumPatchesA)(LPCSTR szProduct, DWORD iPatchIndex, LPSTR lpPatchBuf, LPSTR lpTransformsBuf, LPDWORD pcchTransformsBuf);
typedef UINT(__stdcall* MsiEnumPatchesW)(LPCWSTR szProduct, DWORD iPatchIndex, LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf);
typedef UINT(__stdcall* MsiRemovePatchesA)(LPCSTR szPatchList, LPCSTR szProductCode, INSTALLTYPE eUninstallType, LPCSTR szPropertyList);
typedef UINT(__stdcall* MsiRemovePatchesW)(LPCWSTR szPatchList, LPCWSTR szProductCode, INSTALLTYPE eUninstallType, LPCWSTR szPropertyList);
typedef UINT(__stdcall* MsiExtractPatchXMLDataA)(LPCSTR szPatchPath, DWORD dwReserved, LPSTR szXMLData, LPDWORD pcchXMLData);
typedef UINT(__stdcall* MsiExtractPatchXMLDataW)(LPCWSTR szPatchPath, DWORD dwReserved, LPWSTR szXMLData, LPDWORD pcchXMLData);
typedef UINT(__stdcall* MsiGetPatchInfoExA)(LPCSTR szPatchCode, LPCSTR szProductCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPCSTR szProperty, LPSTR lpValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiGetPatchInfoExW)(LPCWSTR szPatchCode, LPCWSTR szProductCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty, LPWSTR lpValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiApplyMultiplePatchesA)(LPCSTR szPatchPackages, LPCSTR szProductCode, LPCSTR szPropertiesList);
typedef UINT(__stdcall* MsiApplyMultiplePatchesW)(LPCWSTR szPatchPackages, LPCWSTR szProductCode, LPCWSTR szPropertiesList);
typedef UINT(__stdcall* MsiDeterminePatchSequenceA)(LPCSTR szProductCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOA pPatchInfo);
typedef UINT(__stdcall* MsiDeterminePatchSequenceW)(LPCWSTR szProductCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOW pPatchInfo);
typedef UINT(__stdcall* MsiDetermineApplicablePatchesA)(LPCSTR szProductPackagePath, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOA pPatchInfo);
typedef UINT(__stdcall* MsiDetermineApplicablePatchesW)(LPCWSTR szProductPackagePath, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOW pPatchInfo);
typedef INSTALLSTATE(__stdcall* MsiQueryFeatureStateA)(LPCSTR szProduct, LPCSTR szFeature);
typedef INSTALLSTATE(__stdcall* MsiQueryFeatureStateW)(LPCWSTR szProduct, LPCWSTR szFeature);
typedef INSTALLSTATE(__stdcall* MsiUseFeatureA)(LPCSTR szProduct, LPCSTR szFeature);
typedef INSTALLSTATE(__stdcall* MsiUseFeatureW)(LPCWSTR szProduct, LPCWSTR szFeature);
typedef INSTALLSTATE(__stdcall* MsiUseFeatureExA)(LPCSTR szProduct, LPCSTR szFeature, DWORD dwInstallMode, DWORD dwReserved);
typedef INSTALLSTATE(__stdcall* MsiUseFeatureExW)(LPCWSTR szProduct, LPCWSTR szFeature, DWORD dwInstallMode, DWORD dwReserved);
typedef UINT(__stdcall* MsiGetFeatureUsageA)(LPCSTR szProduct, LPCSTR szFeature, LPDWORD pdwUseCount, LPWORD pwDateUsed);
typedef UINT(__stdcall* MsiGetFeatureUsageW)(LPCWSTR szProduct, LPCWSTR szFeature, LPDWORD pdwUseCount, LPWORD pwDateUsed);
typedef UINT(__stdcall* MsiConfigureFeatureA)(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiConfigureFeatureW)(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiReinstallFeatureA)(LPCSTR szProduct, LPCSTR szFeature, DWORD dwReinstallMode);
typedef UINT(__stdcall* MsiReinstallFeatureW)(LPCWSTR szProduct, LPCWSTR szFeature, DWORD dwReinstallMode);
typedef UINT(__stdcall* MsiProvideComponentA)(LPCSTR szProduct, LPCSTR szFeature, LPCSTR szComponent, DWORD dwInstallMode, LPSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideComponentW)(LPCWSTR szProduct, LPCWSTR szFeature, LPCWSTR szComponent, DWORD dwInstallMode, LPWSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideQualifiedComponentA)(LPCSTR szCategory, LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideQualifiedComponentW)(LPCWSTR szCategory, LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideQualifiedComponentExA)(LPCSTR szCategory, LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct, DWORD dwUnused1, DWORD dwUnused2, LPSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideQualifiedComponentExW)(LPCWSTR szCategory, LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct, DWORD dwUnused1, DWORD dwUnused2, LPWSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef INSTALLSTATE(__stdcall* MsiGetComponentPathA)(LPCSTR szProduct, LPCSTR szComponent, LPSTR lpPathBuf, LPDWORD pcchBuf);
typedef INSTALLSTATE(__stdcall* MsiGetComponentPathW)(LPCWSTR szProduct, LPCWSTR szComponent, LPWSTR lpPathBuf, LPDWORD pcchBuf);
typedef INSTALLSTATE(__stdcall* MsiGetComponentPathExA)(LPCSTR szProductCode, LPCSTR szComponentCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPSTR lpOutPathBuffer, LPDWORD pcchOutPathBuffer);
typedef INSTALLSTATE(__stdcall* MsiGetComponentPathExW)(LPCWSTR szProductCode, LPCWSTR szComponentCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, LPWSTR lpOutPathBuffer, LPDWORD pcchOutPathBuffer);
typedef UINT(__stdcall* MsiProvideAssemblyA)(LPCSTR szAssemblyName, LPCSTR szAppContext, DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiProvideAssemblyW)(LPCWSTR szAssemblyName, LPCWSTR szAppContext, DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiEnumProductsA)(DWORD iProductIndex, LPSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumProductsW)(DWORD iProductIndex, LPWSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumRelatedProductsA)(LPCSTR lpUpgradeCode, DWORD dwReserved, DWORD iProductIndex, LPSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumRelatedProductsW)(LPCWSTR lpUpgradeCode, DWORD dwReserved, DWORD iProductIndex, LPWSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumFeaturesA)(LPCSTR szProduct, DWORD iFeatureIndex, LPSTR lpFeatureBuf, LPSTR lpParentBuf);
typedef UINT(__stdcall* MsiEnumFeaturesW)(LPCWSTR szProduct, DWORD iFeatureIndex, LPWSTR lpFeatureBuf, LPWSTR lpParentBuf);
typedef UINT(__stdcall* MsiEnumComponentsA)(DWORD iComponentIndex, LPSTR lpComponentBuf);
typedef UINT(__stdcall* MsiEnumComponentsW)(DWORD iComponentIndex, LPWSTR lpComponentBuf);
typedef UINT(__stdcall* MsiEnumClientsA)(LPCSTR szComponent, DWORD iProductIndex, LPSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumClientsW)(LPCWSTR szComponent, DWORD iProductIndex, LPWSTR lpProductBuf);
typedef UINT(__stdcall* MsiEnumComponentQualifiersA)(LPCSTR szComponent, DWORD iIndex, LPSTR lpQualifierBuf, LPDWORD pcchQualifierBuf, LPSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf);
typedef UINT(__stdcall* MsiEnumComponentQualifiersW)(LPCWSTR szComponent, DWORD iIndex, LPWSTR lpQualifierBuf, LPDWORD pcchQualifierBuf, LPWSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf);
typedef UINT(__stdcall* MsiGetProductPropertyA)(MSIHANDLE hProduct, LPCSTR szProperty, LPSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiGetProductPropertyW)(MSIHANDLE hProduct, LPCWSTR szProperty, LPWSTR lpValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiVerifyPackageA)(LPCSTR szPackagePath);
typedef UINT(__stdcall* MsiVerifyPackageW)(LPCWSTR szPackagePath);
typedef UINT(__stdcall* MsiGetFeatureInfoA)(MSIHANDLE hProduct, LPCSTR szFeature, LPDWORD lpAttributes, LPSTR lpTitleBuf, LPDWORD pcchTitleBuf, LPSTR lpHelpBuf, LPDWORD pcchHelpBuf);
typedef UINT(__stdcall* MsiGetFeatureInfoW)(MSIHANDLE hProduct, LPCWSTR szFeature, LPDWORD lpAttributes, LPWSTR lpTitleBuf, LPDWORD pcchTitleBuf, LPWSTR lpHelpBuf, LPDWORD pcchHelpBuf);
typedef UINT(__stdcall* MsiInstallMissingComponentA)(LPCSTR szProduct, LPCSTR szComponent, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiInstallMissingComponentW)(LPCWSTR szProduct, LPCWSTR szComponent, INSTALLSTATE eInstallState);
typedef UINT(__stdcall* MsiInstallMissingFileA)(LPCSTR szProduct, LPCSTR szFile);
typedef UINT(__stdcall* MsiInstallMissingFileW)(LPCWSTR szProduct, LPCWSTR szFile);
typedef INSTALLSTATE(__stdcall* MsiLocateComponentA)(LPCSTR szComponent, LPSTR lpPathBuf, LPDWORD pcchBuf);
typedef INSTALLSTATE(__stdcall* MsiLocateComponentW)(LPCWSTR szComponent, LPWSTR lpPathBuf, LPDWORD pcchBuf);
typedef UINT(__stdcall* MsiSourceListClearAllA)(LPCSTR szProduct, LPCSTR szUserName, DWORD dwReserved);
typedef UINT(__stdcall* MsiSourceListClearAllW)(LPCWSTR szProduct, LPCWSTR szUserName, DWORD dwReserved);
typedef UINT(__stdcall* MsiSourceListAddSourceA)(LPCSTR szProduct, LPCSTR szUserName, DWORD dwReserved, LPCSTR szSource);
typedef UINT(__stdcall* MsiSourceListAddSourceW)(LPCWSTR szProduct, LPCWSTR szUserName, DWORD dwReserved, LPCWSTR szSource);
typedef UINT(__stdcall* MsiSourceListForceResolutionA)(LPCSTR szProduct, LPCSTR szUserName, DWORD dwReserved);
typedef UINT(__stdcall* MsiSourceListForceResolutionW)(LPCWSTR szProduct, LPCWSTR szUserName, DWORD dwReserved);
typedef UINT(__stdcall* MsiSourceListAddSourceExA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szSource, DWORD dwIndex);
typedef UINT(__stdcall* MsiSourceListAddSourceExW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szSource, DWORD dwIndex);
typedef UINT(__stdcall* MsiSourceListAddMediaDiskA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId, LPCSTR szVolumeLabel, LPCSTR szDiskPrompt);
typedef UINT(__stdcall* MsiSourceListAddMediaDiskW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId, LPCWSTR szVolumeLabel, LPCWSTR szDiskPrompt);
typedef UINT(__stdcall* MsiSourceListClearSourceA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szSource);
typedef UINT(__stdcall* MsiSourceListClearSourceW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szSource);
typedef UINT(__stdcall* MsiSourceListClearMediaDiskA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId);
typedef UINT(__stdcall* MsiSourceListClearMediaDiskW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId);
typedef UINT(__stdcall* MsiSourceListClearAllExA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions);
typedef UINT(__stdcall* MsiSourceListClearAllExW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions);
typedef UINT(__stdcall* MsiSourceListForceResolutionExA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions);
typedef UINT(__stdcall* MsiSourceListForceResolutionExW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions);
typedef UINT(__stdcall* MsiSourceListSetInfoA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szProperty, LPCSTR szValue);
typedef UINT(__stdcall* MsiSourceListSetInfoW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szProperty, LPCWSTR szValue);
typedef UINT(__stdcall* MsiSourceListGetInfoA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szProperty, LPSTR szValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiSourceListGetInfoW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szProperty, LPWSTR szValue, LPDWORD pcchValue);
typedef UINT(__stdcall* MsiSourceListEnumSourcesA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwIndex, LPSTR szSource, LPDWORD pcchSource);
typedef UINT(__stdcall* MsiSourceListEnumSourcesW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwIndex, LPWSTR szSource, LPDWORD pcchSource);
typedef UINT(__stdcall* MsiSourceListEnumMediaDisksA)(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwIndex, LPDWORD pdwDiskId, LPSTR szVolumeLabel, LPDWORD pcchVolumeLabel, LPSTR szDiskPrompt, LPDWORD pcchDiskPrompt);
typedef UINT(__stdcall* MsiSourceListEnumMediaDisksW)(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwIndex, LPDWORD pdwDiskId, LPWSTR szVolumeLabel, LPDWORD pcchVolumeLabel, LPWSTR szDiskPrompt, LPDWORD pcchDiskPrompt);
typedef UINT(__stdcall* MsiGetFileVersionA)(LPCSTR szFilePath, LPSTR lpVersionBuf, LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf);
typedef UINT(__stdcall* MsiGetFileVersionW)(LPCWSTR szFilePath, LPWSTR lpVersionBuf, LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf);
typedef UINT(__stdcall* MsiGetFileHashA)(LPCSTR szFilePath, DWORD dwOptions, PMSIFILEHASHINFO pHash);
typedef UINT(__stdcall* MsiGetFileHashW)(LPCWSTR szFilePath, DWORD dwOptions, PMSIFILEHASHINFO pHash);
typedef UINT(__stdcall* MsiGetShortcutTargetA)(LPCSTR szShortcutPath, LPSTR szProductCode, LPSTR szFeatureId, LPSTR szComponentCode);
typedef UINT(__stdcall* MsiGetShortcutTargetW)(LPCWSTR szShortcutPath, LPWSTR szProductCode, LPWSTR szFeatureId, LPWSTR szComponentCode);
typedef UINT(__stdcall* MsiNotifySidChangeA)(LPCSTR pOldSid, LPCSTR pNewSid);
typedef UINT(__stdcall* MsiNotifySidChangeW)(LPCWSTR pOldSid, LPCWSTR pNewSid);
typedef UINT(__stdcall* MsiEndTransaction)(DWORD dwTransactionState);
typedef MSIDBERROR(__stdcall* MsiViewGetErrorA)(MSIHANDLE hView, LPSTR szColumnNameBuffer, LPDWORD pcchBuf);
typedef MSIDBERROR(__stdcall* MsiViewGetErrorW)(MSIHANDLE hView, LPWSTR szColumnNameBuffer, LPDWORD pcchBuf);
typedef UINT(__stdcall* MsiViewExecute)(MSIHANDLE hView, MSIHANDLE hRecord);
typedef UINT(__stdcall* MsiViewModify)(MSIHANDLE hView, MSIMODIFY eModifyMode, MSIHANDLE hRecord);
typedef UINT(__stdcall* MsiViewClose)(MSIHANDLE hView);
typedef MSICONDITION(__stdcall* MsiDatabaseIsTablePersistentA)(MSIHANDLE hDatabase, LPCSTR szTableName);
typedef MSICONDITION(__stdcall* MsiDatabaseIsTablePersistentW)(MSIHANDLE hDatabase, LPCWSTR szTableName);
typedef UINT(__stdcall* MsiSummaryInfoGetPropertyCount)(MSIHANDLE hSummaryInfo, PUINT puiPropertyCount);
typedef UINT(__stdcall* MsiSummaryInfoPersist)(MSIHANDLE hSummaryInfo);
typedef UINT(__stdcall* MsiDatabaseImportA)(MSIHANDLE hDatabase, LPCSTR szFolderPath, LPCSTR szFileName);
typedef UINT(__stdcall* MsiDatabaseImportW)(MSIHANDLE hDatabase, LPCWSTR szFolderPath, LPCWSTR szFileName);
typedef UINT(__stdcall* MsiDatabaseExportA)(MSIHANDLE hDatabase, LPCSTR szTableName, LPCSTR szFolderPath, LPCSTR szFileName);
typedef UINT(__stdcall* MsiDatabaseExportW)(MSIHANDLE hDatabase, LPCWSTR szTableName, LPCWSTR szFolderPath, LPCWSTR szFileName);
typedef UINT(__stdcall* MsiDatabaseMergeA)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseMerge, LPCSTR szTableName);
typedef UINT(__stdcall* MsiDatabaseMergeW)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseMerge, LPCWSTR szTableName);
typedef UINT(__stdcall* MsiDatabaseGenerateTransformA)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseReference, LPCSTR szTransformFile, int iReserved1, int iReserved2);
typedef UINT(__stdcall* MsiDatabaseGenerateTransformW)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseReference, LPCWSTR szTransformFile, int iReserved1, int iReserved2);
typedef UINT(__stdcall* MsiDatabaseApplyTransformA)(MSIHANDLE hDatabase, LPCSTR szTransformFile, int iErrorConditions);
typedef UINT(__stdcall* MsiDatabaseApplyTransformW)(MSIHANDLE hDatabase, LPCWSTR szTransformFile, int iErrorConditions);
typedef UINT(__stdcall* MsiCreateTransformSummaryInfoA)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseReference, LPCSTR szTransformFile, int iErrorConditions, int iValidation);
typedef UINT(__stdcall* MsiCreateTransformSummaryInfoW)(MSIHANDLE hDatabase, MSIHANDLE hDatabaseReference, LPCWSTR szTransformFile, int iErrorConditions, int iValidation);
typedef UINT(__stdcall* MsiDatabaseCommit)(MSIHANDLE hDatabase);
typedef MSIDBSTATE(__stdcall* MsiGetDatabaseState)(MSIHANDLE hDatabase);
typedef MSIHANDLE(__stdcall* MsiCreateRecord)(UINT cParams);
typedef BOOL(__stdcall* MsiRecordIsNull)(MSIHANDLE hRecord, UINT iField);
typedef UINT(__stdcall* MsiRecordDataSize)(MSIHANDLE hRecord, UINT iField);
typedef UINT(__stdcall* MsiRecordSetInteger)(MSIHANDLE hRecord, UINT iField, int iValue);
typedef UINT(__stdcall* MsiRecordSetStringA)(MSIHANDLE hRecord, UINT iField, LPCSTR szValue);
typedef UINT(__stdcall* MsiRecordSetStringW)(MSIHANDLE hRecord, UINT iField, LPCWSTR szValue);
typedef int(__stdcall* MsiRecordGetInteger)(MSIHANDLE hRecord, UINT iField);
typedef UINT(__stdcall* MsiRecordGetStringA)(MSIHANDLE hRecord, UINT iField, LPSTR szValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiRecordGetStringW)(MSIHANDLE hRecord, UINT iField, LPWSTR szValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiRecordGetFieldCount)(MSIHANDLE hRecord);
typedef UINT(__stdcall* MsiRecordSetStreamA)(MSIHANDLE hRecord, UINT iField, LPCSTR szFilePath);
typedef UINT(__stdcall* MsiRecordSetStreamW)(MSIHANDLE hRecord, UINT iField, LPCWSTR szFilePath);
typedef UINT(__stdcall* MsiRecordClearData)(MSIHANDLE hRecord);
typedef MSIHANDLE(__stdcall* MsiGetActiveDatabase)(MSIHANDLE hInstall);
typedef UINT(__stdcall* MsiSetPropertyA)(MSIHANDLE hInstall, LPCSTR szName, LPCSTR szValue);
typedef UINT(__stdcall* MsiSetPropertyW)(MSIHANDLE hInstall, LPCWSTR szName, LPCWSTR szValue);
typedef UINT(__stdcall* MsiGetPropertyA)(MSIHANDLE hInstall, LPCSTR szName, LPSTR szValueBuf, LPDWORD pcchValueBuf);
typedef UINT(__stdcall* MsiGetPropertyW)(MSIHANDLE hInstall, LPCWSTR szName, LPWSTR szValueBuf, LPDWORD pcchValueBuf);
typedef LANGID(__stdcall* MsiGetLanguage)(MSIHANDLE hInstall);
typedef BOOL(__stdcall* MsiGetMode)(MSIHANDLE hInstall, MSIRUNMODE eRunMode);
typedef UINT(__stdcall* MsiSetMode)(MSIHANDLE hInstall, MSIRUNMODE eRunMode, BOOL fState);
typedef UINT(__stdcall* MsiFormatRecordA)(MSIHANDLE hInstall, MSIHANDLE hRecord, LPSTR szResultBuf, LPDWORD pcchResultBuf);
typedef UINT(__stdcall* MsiFormatRecordW)(MSIHANDLE hInstall, MSIHANDLE hRecord, LPWSTR szResultBuf, LPDWORD pcchResultBuf);
typedef UINT(__stdcall* MsiDoActionA)(MSIHANDLE hInstall, LPCSTR szAction);
typedef UINT(__stdcall* MsiDoActionW)(MSIHANDLE hInstall, LPCWSTR szAction);
typedef UINT(__stdcall* MsiSequenceA)(MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode);
typedef UINT(__stdcall* MsiSequenceW)(MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode);
typedef int(__stdcall* MsiProcessMessage)(MSIHANDLE hInstall, INSTALLMESSAGE eMessageType, MSIHANDLE hRecord);
typedef MSICONDITION(__stdcall* MsiEvaluateConditionA)(MSIHANDLE hInstall, LPCSTR szCondition);
typedef MSICONDITION(__stdcall* MsiEvaluateConditionW)(MSIHANDLE hInstall, LPCWSTR szCondition);
typedef UINT(__stdcall* MsiSetFeatureStateA)(MSIHANDLE hInstall, LPCSTR szFeature, INSTALLSTATE iState);
typedef UINT(__stdcall* MsiSetFeatureStateW)(MSIHANDLE hInstall, LPCWSTR szFeature, INSTALLSTATE iState);
typedef UINT(__stdcall* MsiSetFeatureAttributesA)(MSIHANDLE hInstall, LPCSTR szFeature, DWORD dwAttributes);
typedef UINT(__stdcall* MsiSetFeatureAttributesW)(MSIHANDLE hInstall, LPCWSTR szFeature, DWORD dwAttributes);
typedef UINT(__stdcall* MsiSetComponentStateA)(MSIHANDLE hInstall, LPCSTR szComponent, INSTALLSTATE iState);
typedef UINT(__stdcall* MsiSetComponentStateW)(MSIHANDLE hInstall, LPCWSTR szComponent, INSTALLSTATE iState);
typedef UINT(__stdcall* MsiGetFeatureCostA)(MSIHANDLE hInstall, LPCSTR szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost);
typedef UINT(__stdcall* MsiGetFeatureCostW)(MSIHANDLE hInstall, LPCWSTR szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost);
typedef UINT(__stdcall* MsiEnumComponentCostsA)(MSIHANDLE hInstall, LPCSTR szComponent, DWORD dwIndex, INSTALLSTATE iState, LPSTR szDriveBuf, LPDWORD pcchDriveBuf, LPINT piCost, LPINT piTempCost);
typedef UINT(__stdcall* MsiEnumComponentCostsW)(MSIHANDLE hInstall, LPCWSTR szComponent, DWORD dwIndex, INSTALLSTATE iState, LPWSTR szDriveBuf, LPDWORD pcchDriveBuf, LPINT piCost, LPINT piTempCost);
typedef UINT(__stdcall* MsiSetInstallLevel)(MSIHANDLE hInstall, int iInstallLevel);
typedef UINT(__stdcall* MsiGetFeatureValidStatesA)(MSIHANDLE hInstall, LPCSTR szFeature, LPDWORD lpInstallStates);
typedef UINT(__stdcall* MsiGetFeatureValidStatesW)(MSIHANDLE hInstall, LPCWSTR szFeature, LPDWORD lpInstallStates);
typedef UINT(__stdcall* MsiGetSourcePathA)(MSIHANDLE hInstall, LPCSTR szFolder, LPSTR szPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiGetSourcePathW)(MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR szPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiGetTargetPathA)(MSIHANDLE hInstall, LPCSTR szFolder, LPSTR szPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiGetTargetPathW)(MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR szPathBuf, LPDWORD pcchPathBuf);
typedef UINT(__stdcall* MsiSetTargetPathA)(MSIHANDLE hInstall, LPCSTR szFolder, LPCSTR szFolderPath);
typedef UINT(__stdcall* MsiSetTargetPathW)(MSIHANDLE hInstall, LPCWSTR szFolder, LPCWSTR szFolderPath);
typedef UINT(__stdcall* MsiVerifyDiskSpace)(MSIHANDLE hInstall);
typedef UINT(__stdcall* MsiPreviewDialogA)(MSIHANDLE hPreview, LPCSTR szDialogName);
typedef UINT(__stdcall* MsiPreviewDialogW)(MSIHANDLE hPreview, LPCWSTR szDialogName);
typedef UINT(__stdcall* MsiPreviewBillboardA)(MSIHANDLE hPreview, LPCSTR szControlName, LPCSTR szBillboard);
typedef UINT(__stdcall* MsiPreviewBillboardW)(MSIHANDLE hPreview, LPCWSTR szControlName, LPCWSTR szBillboard);
typedef MSIHANDLE(__stdcall* MsiGetLastErrorRecord)();
typedef LONG(__stdcall* ComDBOpen)(PHCOMDB PHComDB);
typedef LONG(__stdcall* ComDBClose)(HCOMDB HComDB);
typedef LONG(__stdcall* ComDBGetCurrentPortUsage)(HCOMDB HComDB, PBYTE Buffer, DWORD BufferSize, ULONG ReportType, LPDWORD MaxPortsReported);
typedef LONG(__stdcall* ComDBClaimNextFreePort)(HCOMDB HComDB, LPDWORD ComNumber);
typedef LONG(__stdcall* ComDBClaimPort)(HCOMDB HComDB, DWORD ComNumber, BOOL ForceClaim, PBOOL Forced);
typedef LONG(__stdcall* ComDBReleasePort)(HCOMDB HComDB, DWORD ComNumber);
typedef LONG(__stdcall* ComDBResizeDatabase)(HCOMDB HComDB, DWORD NewSize);
typedef BOOL(__stdcall* CreatePipe)(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize);
typedef BOOL(__stdcall* ConnectNamedPipe)(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* DisconnectNamedPipe)(HANDLE hNamedPipe);
typedef BOOL(__stdcall* SetNamedPipeHandleState)(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout);
typedef BOOL(__stdcall* PeekNamedPipe)(HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage);
typedef BOOL(__stdcall* TransactNamedPipe)(HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped);
typedef BOOL(__stdcall* ImpersonateNamedPipeClient)(HANDLE hNamedPipe);
typedef BOOL(__stdcall* GetNamedPipeInfo)(HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances);
typedef BOOLEAN(__stdcall* ClosePrivateNamespace)(HANDLE Handle, ULONG Flags);
typedef void(__stdcall* DeleteBoundaryDescriptor)(HANDLE BoundaryDescriptor);
typedef UCHAR(__stdcall* Netbios)(PNCB pncb);
typedef SECURITY_STATUS(__stdcall* NCryptIsAlgSupported)(NCRYPT_PROV_HANDLE hProvider, LPCWSTR pszAlgId, DWORD dwFlags);
typedef SECURITY_STATUS(__stdcall* NCryptFreeBuffer)(PVOID pvInput);
typedef SECURITY_STATUS(__stdcall* NCryptSetProperty)(NCRYPT_HANDLE hObject, LPCWSTR pszProperty, PBYTE pbInput, DWORD cbInput, DWORD dwFlags);
typedef SECURITY_STATUS(__stdcall* NCryptFinalizeKey)(NCRYPT_KEY_HANDLE hKey, DWORD dwFlags);
typedef SECURITY_STATUS(__stdcall* NCryptDeleteKey)(NCRYPT_KEY_HANDLE hKey, DWORD dwFlags);
typedef SECURITY_STATUS(__stdcall* NCryptFreeObject)(NCRYPT_HANDLE hObject);
typedef BOOL(__stdcall* NCryptIsKeyHandle)(NCRYPT_KEY_HANDLE hKey);
typedef SECURITY_STATUS(__stdcall* NCryptRegisterProtectionDescriptorName)(LPCWSTR pwszName, LPCWSTR pwszDescriptorString, DWORD dwFlags);
typedef SECURITY_STATUS(__stdcall* NCryptCloseProtectionDescriptor)(NCRYPT_DESCRIPTOR_HANDLE hDescriptor);
typedef SECURITY_STATUS(__stdcall* NCryptStreamClose)(NCRYPT_STREAM_HANDLE hStream);
typedef BOOL(__stdcall* NcIsValidConnectionName)(PCWSTR pszwName);
typedef DWORD(__stdcall* NetworkIsolationUnregisterForAppContainerChanges)(HANDLE registrationObject);
typedef DWORD(__stdcall* NetworkIsolationFreeAppContainers)(PINET_FIREWALL_APP_CONTAINER pPublicAppCs);
typedef DWORD(__stdcall* NetworkIsolationSetAppContainerConfig)(DWORD dwNumPublicAppCs, PSID_AND_ATTRIBUTES appContainerSids);
typedef DWORD(__stdcall* NetworkIsolationGetEnterpriseIdClose)(HANDLE hOperation, BOOL bWaitForOperation);
typedef BOOL(__stdcall* MatchToken)(LPCWSTR pwszUserToken, LPCWSTR pwszCmdToken);
typedef DWORD(__stdcall* PrintError)(HANDLE hModule, DWORD dwErrId);
typedef DWORD(__stdcall* PrintMessageFromModule)(HANDLE hModule, DWORD dwMsgId);
typedef DWORD(__stdcall* PrintMessage)(LPCWSTR pwszFormat);
typedef DWORD(__stdcall* NetworkIsolationUnregisterForAppContainerChanges)(HANDLE registrationObject);
typedef DWORD(__stdcall* NetworkIsolationFreeAppContainers)(PINET_FIREWALL_APP_CONTAINER pPublicAppCs);
typedef DWORD(__stdcall* NetworkIsolationSetAppContainerConfig)(DWORD dwNumPublicAppCs, PSID_AND_ATTRIBUTES appContainerSids);
typedef BOOL(__stdcall* DiInstallDevice)(HWND hwndParent, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PSP_DRVINFO_DATA DriverInfoData, DWORD Flags, PBOOL NeedReboot);
typedef BOOL(__stdcall* DiUninstallDevice)(HWND hwndParent, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Flags, PBOOL NeedReboot);
typedef BOOL(__stdcall* DiShowUpdateDevice)(HWND hwndParent, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Flags, PBOOL NeedReboot);
typedef BOOL(__stdcall* DiRollbackDriver)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, HWND hwndParent, DWORD Flags, PBOOL NeedReboot);
typedef void(__stdcall* WNetSetLastErrorA)(DWORD err, LPSTR lpError, LPSTR lpProviders);
typedef INT(__stdcall* EnumProtocolsA)(LPINT lpiProtocols, LPVOID lpProtocolBuffer, LPDWORD lpdwBufferLength);
typedef INT(__stdcall* EnumProtocolsW)(LPINT lpiProtocols, LPVOID lpProtocolBuffer, LPDWORD lpdwBufferLength);
typedef INT(__stdcall* GetAddressByNameA)(DWORD dwNameSpace, LPGUID lpServiceType, LPSTR lpServiceName, LPINT lpiProtocols, DWORD dwResolution, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPVOID lpCsaddrBuffer, LPDWORD lpdwBufferLength, LPSTR lpAliasBuffer, LPDWORD lpdwAliasBufferLength);
typedef INT(__stdcall* GetAddressByNameW)(DWORD dwNameSpace, LPGUID lpServiceType, LPWSTR lpServiceName, LPINT lpiProtocols, DWORD dwResolution, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPVOID lpCsaddrBuffer, LPDWORD lpdwBufferLength, LPWSTR lpAliasBuffer, LPDWORD lpdwAliasBufferLength);
typedef INT(__stdcall* GetTypeByNameA)(LPSTR lpServiceName, LPGUID lpServiceType);
typedef INT(__stdcall* GetTypeByNameW)(LPWSTR lpServiceName, LPGUID lpServiceType);
typedef INT(__stdcall* GetNameByTypeA)(LPGUID lpServiceType, LPSTR lpServiceName, DWORD dwNameLength);
typedef INT(__stdcall* GetNameByTypeW)(LPGUID lpServiceType, LPWSTR lpServiceName, DWORD dwNameLength);
typedef INT(__stdcall* SetServiceA)(DWORD dwNameSpace, DWORD dwOperation, DWORD dwFlags, LPSERVICE_INFOA lpServiceInfo, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPDWORD lpdwStatusFlags);
typedef INT(__stdcall* SetServiceW)(DWORD dwNameSpace, DWORD dwOperation, DWORD dwFlags, LPSERVICE_INFOW lpServiceInfo, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPDWORD lpdwStatusFlags);
typedef INT(__stdcall* GetServiceA)(DWORD dwNameSpace, LPGUID lpGuid, LPSTR lpServiceName, DWORD dwProperties, LPVOID lpBuffer, LPDWORD lpdwBufferSize, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo);
typedef INT(__stdcall* GetServiceW)(DWORD dwNameSpace, LPGUID lpGuid, LPWSTR lpServiceName, DWORD dwProperties, LPVOID lpBuffer, LPDWORD lpdwBufferSize, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo);
typedef DWORD(__stdcall* DsBindingSetTimeout)(HANDLE hDS, ULONG cTimeoutSecs);
typedef void(__stdcall* DsFreePasswordCredentials)(RPC_AUTH_IDENTITY_HANDLE AuthIdentity);
typedef DWORD(__stdcall* DsServerRegisterSpnA)(DS_SPN_WRITE_OP Operation, LPCSTR ServiceClass, LPCSTR UserObjectDN);
typedef DWORD(__stdcall* DsServerRegisterSpnW)(DS_SPN_WRITE_OP Operation, LPCWSTR ServiceClass, LPCWSTR UserObjectDN);
typedef DWORD(__stdcall* DsReplicaAddA)(HANDLE hDS, LPCSTR NameContext, LPCSTR SourceDsaDn, LPCSTR TransportDn, LPCSTR SourceDsaAddress, PSCHEDULE pSchedule, DWORD Options);
typedef DWORD(__stdcall* DsReplicaAddW)(HANDLE hDS, LPCWSTR NameContext, LPCWSTR SourceDsaDn, LPCWSTR TransportDn, LPCWSTR SourceDsaAddress, PSCHEDULE pSchedule, DWORD Options);
typedef DWORD(__stdcall* DsReplicaDelA)(HANDLE hDS, LPCSTR NameContext, LPCSTR DsaSrc, ULONG Options);
typedef DWORD(__stdcall* DsReplicaDelW)(HANDLE hDS, LPCWSTR NameContext, LPCWSTR DsaSrc, ULONG Options);
typedef DWORD(__stdcall* DsRemoveDsDomainW)(HANDLE hDs, LPWSTR DomainDN);
typedef DWORD(__stdcall* DsRemoveDsDomainA)(HANDLE hDs, LPSTR DomainDN);
typedef void(__stdcall* DsQuerySitesFree)(PDS_SITE_COST_INFO rgSiteInfo);
typedef void(__stdcall* DsFreeSchemaGuidMapA)(PDS_SCHEMA_GUID_MAPA pGuidMap);
typedef void(__stdcall* DsFreeSchemaGuidMapW)(PDS_SCHEMA_GUID_MAPW pGuidMap);
typedef DWORD(__stdcall* DsReplicaConsistencyCheck)(HANDLE hDS, DS_KCC_TASKID TaskID, DWORD dwFlags);
typedef DWORD(__stdcall* DsAddSidHistoryW)(HANDLE hDS, DWORD Flags, LPCWSTR SrcDomain, LPCWSTR SrcPrincipal, LPCWSTR SrcDomainController, RPC_AUTH_IDENTITY_HANDLE SrcDomainCreds, LPCWSTR DstDomain, LPCWSTR DstPrincipal);
typedef DWORD(__stdcall* DsAddSidHistoryA)(HANDLE hDS, DWORD Flags, LPCSTR SrcDomain, LPCSTR SrcPrincipal, LPCSTR SrcDomainController, RPC_AUTH_IDENTITY_HANDLE SrcDomainCreds, LPCSTR DstDomain, LPCSTR DstPrincipal);
typedef DWORD(__stdcall* DsInheritSecurityIdentityW)(HANDLE hDS, DWORD Flags, LPCWSTR SrcPrincipal, LPCWSTR DstPrincipal);
typedef DWORD(__stdcall* DsInheritSecurityIdentityA)(HANDLE hDS, DWORD Flags, LPCSTR SrcPrincipal, LPCSTR DstPrincipal);
typedef HANDLE(__stdcall* OpenNtmsSessionW)(LPCWSTR lpServer, LPCWSTR lpApplication, DWORD dwOptions);
typedef HANDLE(__stdcall* OpenNtmsSessionA)(LPCSTR lpServer, LPCSTR lpApplication, DWORD dwOptions);
typedef DWORD(__stdcall* CloseNtmsSession)(HANDLE hSession);
typedef DWORD(__stdcall* MountNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId, LPNTMS_GUID lpDriveId, DWORD dwCount, DWORD dwOptions, int dwPriority, DWORD dwTimeout, LPNTMS_MOUNT_INFORMATION lpMountInformation);
typedef DWORD(__stdcall* DismountNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId, DWORD dwCount, DWORD dwOptions);
typedef DWORD(__stdcall* AllocateNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaPool, LPNTMS_GUID lpPartition, LPNTMS_GUID lpMediaId, DWORD dwOptions, DWORD dwTimeout, LPNTMS_ALLOCATION_INFORMATION lpAllocateInformation);
typedef DWORD(__stdcall* DeallocateNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId, DWORD dwOptions);
typedef DWORD(__stdcall* SwapNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId1, LPNTMS_GUID lpMediaId2);
typedef DWORD(__stdcall* AddNtmsMediaType)(HANDLE hSession, LPNTMS_GUID lpMediaTypeId, LPNTMS_GUID lpLibId);
typedef DWORD(__stdcall* DeleteNtmsMediaType)(HANDLE hSession, LPNTMS_GUID lpMediaTypeId, LPNTMS_GUID lpLibId);
typedef DWORD(__stdcall* ChangeNtmsMediaType)(HANDLE hSession, LPNTMS_GUID lpMediaId, LPNTMS_GUID lpPoolId);
typedef DWORD(__stdcall* DecommissionNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId);
typedef DWORD(__stdcall* SetNtmsMediaComplete)(HANDLE hSession, LPNTMS_GUID lpMediaId);
typedef DWORD(__stdcall* DeleteNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId);
typedef DWORD(__stdcall* CreateNtmsMediaPoolA)(HANDLE hSession, LPCSTR lpPoolName, LPNTMS_GUID lpMediaType, DWORD dwAction, LPSECURITY_ATTRIBUTES lpSecurityAttributes, LPNTMS_GUID lpPoolId);
typedef DWORD(__stdcall* CreateNtmsMediaPoolW)(HANDLE hSession, LPCWSTR lpPoolName, LPNTMS_GUID lpMediaType, DWORD dwAction, LPSECURITY_ATTRIBUTES lpSecurityAttributes, LPNTMS_GUID lpPoolId);
typedef DWORD(__stdcall* GetNtmsMediaPoolNameA)(HANDLE hSession, LPNTMS_GUID lpPoolId, LPSTR lpNameBuf, LPDWORD lpdwBufSize);
typedef DWORD(__stdcall* GetNtmsMediaPoolNameW)(HANDLE hSession, LPNTMS_GUID lpPoolId, LPWSTR lpNameBuf, LPDWORD lpdwBufSize);
typedef DWORD(__stdcall* MoveToNtmsMediaPool)(HANDLE hSession, LPNTMS_GUID lpMediaId, LPNTMS_GUID lpPoolId);
typedef DWORD(__stdcall* DeleteNtmsMediaPool)(HANDLE hSession, LPNTMS_GUID lpPoolId);
typedef DWORD(__stdcall* DeleteNtmsLibrary)(HANDLE hSession, LPNTMS_GUID lpLibraryId);
typedef DWORD(__stdcall* DeleteNtmsDrive)(HANDLE hSession, LPNTMS_GUID lpDriveId);
typedef DWORD(__stdcall* GetNtmsObjectInformationA)(HANDLE hSession, LPNTMS_GUID lpObjectId, LPNTMS_OBJECTINFORMATIONA lpInfo);
typedef DWORD(__stdcall* GetNtmsObjectInformationW)(HANDLE hSession, LPNTMS_GUID lpObjectId, LPNTMS_OBJECTINFORMATIONW lpInfo);
typedef DWORD(__stdcall* SetNtmsObjectInformationA)(HANDLE hSession, LPNTMS_GUID lpObjectId, LPNTMS_OBJECTINFORMATIONA lpInfo);
typedef DWORD(__stdcall* SetNtmsObjectInformationW)(HANDLE hSession, LPNTMS_GUID lpObjectId, LPNTMS_OBJECTINFORMATIONW lpInfo);
typedef DWORD(__stdcall* CreateNtmsMediaA)(HANDLE hSession, LPNTMS_OBJECTINFORMATIONA lpMedia, LPNTMS_OBJECTINFORMATIONA lpList, DWORD dwOptions);
typedef DWORD(__stdcall* CreateNtmsMediaW)(HANDLE hSession, LPNTMS_OBJECTINFORMATIONW lpMedia, LPNTMS_OBJECTINFORMATIONW lpList, DWORD dwOptions);
typedef DWORD(__stdcall* EnumerateNtmsObject)(HANDLE hSession, LPNTMS_GUID lpContainerId, LPNTMS_GUID lpList, LPDWORD lpdwListSize, DWORD dwType, DWORD dwOptions);
typedef DWORD(__stdcall* DisableNtmsObject)(HANDLE hSession, DWORD dwType, LPNTMS_GUID lpObjectId);
typedef DWORD(__stdcall* EnableNtmsObject)(HANDLE hSession, DWORD dwType, LPNTMS_GUID lpObjectId);
typedef DWORD(__stdcall* EjectNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpMediaId, LPNTMS_GUID lpEjectOperation, DWORD dwAction);
typedef DWORD(__stdcall* InjectNtmsMedia)(HANDLE hSession, LPNTMS_GUID lpLibraryId, LPNTMS_GUID lpInjectOperation, DWORD dwAction);
typedef DWORD(__stdcall* AccessNtmsLibraryDoor)(HANDLE hSession, LPNTMS_GUID lpLibraryId, DWORD dwAction);
typedef DWORD(__stdcall* CleanNtmsDrive)(HANDLE hSession, LPNTMS_GUID lpDriveId);
typedef DWORD(__stdcall* DismountNtmsDrive)(HANDLE hSession, LPNTMS_GUID lpDriveId);
typedef DWORD(__stdcall* InventoryNtmsLibrary)(HANDLE hSession, LPNTMS_GUID lpLibraryId, DWORD dwAction);
typedef DWORD(__stdcall* IdentifyNtmsSlot)(HANDLE hSession, LPNTMS_GUID lpSlotId, DWORD dwOption);
typedef DWORD(__stdcall* UpdateNtmsOmidInfo)(HANDLE hSession, LPNTMS_GUID lpMediaId, DWORD labelType, DWORD numberOfBytes, LPVOID lpBuffer);
typedef DWORD(__stdcall* CancelNtmsLibraryRequest)(HANDLE hSession, LPNTMS_GUID lpRequestId);
typedef DWORD(__stdcall* GetNtmsRequestOrder)(HANDLE hSession, LPNTMS_GUID lpRequestId, LPDWORD lpdwOrderNumber);
typedef DWORD(__stdcall* SetNtmsRequestOrder)(HANDLE hSession, LPNTMS_GUID lpRequestId, DWORD dwOrderNumber);
typedef DWORD(__stdcall* DeleteNtmsRequests)(HANDLE hSession, LPNTMS_GUID lpRequestId, DWORD dwType, DWORD dwCount);
typedef DWORD(__stdcall* ReserveNtmsCleanerSlot)(HANDLE hSession, LPNTMS_GUID lpLibrary, LPNTMS_GUID lpSlot);
typedef DWORD(__stdcall* ReleaseNtmsCleanerSlot)(HANDLE hSession, LPNTMS_GUID lpLibrary);
typedef DWORD(__stdcall* InjectNtmsCleaner)(HANDLE hSession, LPNTMS_GUID lpLibrary, LPNTMS_GUID lpInjectOperation, DWORD dwNumberOfCleansLeft, DWORD dwAction);
typedef DWORD(__stdcall* EjectNtmsCleaner)(HANDLE hSession, LPNTMS_GUID lpLibrary, LPNTMS_GUID lpEjectOperation, DWORD dwAction);
typedef DWORD(__stdcall* BeginNtmsDeviceChangeDetection)(HANDLE hSession, LPHANDLE lpDetectHandle);
typedef DWORD(__stdcall* SetNtmsDeviceChangeDetection)(HANDLE hSession, HANDLE DetectHandle, LPNTMS_GUID lpRequestId, DWORD dwType, DWORD dwCount);
typedef DWORD(__stdcall* EndNtmsDeviceChangeDetection)(HANDLE hSession, HANDLE DetectHandle);
typedef DWORD(__stdcall* GetNtmsObjectSecurity)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef DWORD(__stdcall* SetNtmsObjectSecurity)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor);
typedef DWORD(__stdcall* GetNtmsObjectAttributeA)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPCSTR lpAttributeName, LPVOID lpAttributeData, LPDWORD lpAttributeSize);
typedef DWORD(__stdcall* GetNtmsObjectAttributeW)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPCWSTR lpAttributeName, LPVOID lpAttributeData, LPDWORD lpAttributeSize);
typedef DWORD(__stdcall* SetNtmsObjectAttributeA)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPCSTR lpAttributeName, LPVOID lpAttributeData, DWORD dwAttributeSize);
typedef DWORD(__stdcall* SetNtmsObjectAttributeW)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPCWSTR lpAttributeName, LPVOID lpAttributeData, DWORD AttributeSize);
typedef DWORD(__stdcall* GetNtmsUIOptionsA)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPSTR lpszDestination, LPDWORD lpdwBufSize);
typedef DWORD(__stdcall* GetNtmsUIOptionsW)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, LPWSTR lpszDestination, LPDWORD lpdwBufSize);
typedef DWORD(__stdcall* SetNtmsUIOptionsA)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, DWORD dwOperation, LPCSTR lpszDestination);
typedef DWORD(__stdcall* SetNtmsUIOptionsW)(HANDLE hSession, LPNTMS_GUID lpObjectId, DWORD dwType, DWORD dwOperation, LPCWSTR lpszDestination);
typedef DWORD(__stdcall* SubmitNtmsOperatorRequestW)(HANDLE hSession, DWORD dwRequest, LPCWSTR lpMessage, LPNTMS_GUID lpArg1Id, LPNTMS_GUID lpArg2Id, LPNTMS_GUID lpRequestId);
typedef DWORD(__stdcall* SubmitNtmsOperatorRequestA)(HANDLE hSession, DWORD dwRequest, LPCSTR lpMessage, LPNTMS_GUID lpArg1Id, LPNTMS_GUID lpArg2Id, LPNTMS_GUID lpRequestId);
typedef DWORD(__stdcall* WaitForNtmsOperatorRequest)(HANDLE hSession, LPNTMS_GUID lpRequestId, DWORD dwTimeout);
typedef DWORD(__stdcall* CancelNtmsOperatorRequest)(HANDLE hSession, LPNTMS_GUID lpRequestId);
typedef DWORD(__stdcall* SatisfyNtmsOperatorRequest)(HANDLE hSession, LPNTMS_GUID lpRequestId);
typedef DWORD(__stdcall* ImportNtmsDatabase)(HANDLE hSession);
typedef DWORD(__stdcall* ExportNtmsDatabase)(HANDLE hSession);
typedef HANDLE(__stdcall* OpenNtmsNotification)(HANDLE hSession, DWORD dwType);
typedef DWORD(__stdcall* WaitForNtmsNotification)(HANDLE hNotification, LPNTMS_NOTIFICATIONINFORMATION lpNotificationInformation, DWORD dwTimeout);
typedef DWORD(__stdcall* CloseNtmsNotification)(HANDLE hNotification);
typedef DWORD(__stdcall* EjectDiskFromSADriveW)(LPCWSTR lpComputerName, LPCWSTR lpAppName, LPCWSTR lpDeviceName, HWND hWnd, LPCWSTR lpTitle, LPCWSTR lpMessage, DWORD dwOptions);
typedef DWORD(__stdcall* EjectDiskFromSADriveA)(LPCSTR lpComputerName, LPCSTR lpAppName, LPCSTR lpDeviceName, HWND hWnd, LPCSTR lpTitle, LPCSTR lpMessage, DWORD dwOptions);
typedef NTSTATUS(__stdcall* LsaRegisterLogonProcess)(PLSA_STRING LogonProcessName, PHANDLE LsaHandle, PLSA_OPERATIONAL_MODE SecurityMode);
typedef NTSTATUS(__stdcall* LsaLookupAuthenticationPackage)(HANDLE LsaHandle, PLSA_STRING PackageName, PULONG AuthenticationPackage);
typedef NTSTATUS(__stdcall* LsaFreeReturnBuffer)(PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaDeregisterLogonProcess)(HANDLE LsaHandle);
typedef NTSTATUS(__stdcall* LsaConnectUntrusted)(PHANDLE LsaHandle);
typedef NTSTATUS(__stdcall* LsaFreeMemory)(PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaClose)(LSA_HANDLE ObjectHandle);
typedef NTSTATUS(__stdcall* LsaOpenPolicy)(PLSA_UNICODE_STRING SystemName, PLSA_OBJECT_ATTRIBUTES ObjectAttributes, ACCESS_MASK DesiredAccess, PLSA_HANDLE PolicyHandle);
typedef NTSTATUS(__stdcall* LsaSetInformationPolicy)(LSA_HANDLE PolicyHandle, POLICY_INFORMATION_CLASS InformationClass, PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaSetDomainInformationPolicy)(LSA_HANDLE PolicyHandle, POLICY_DOMAIN_INFORMATION_CLASS InformationClass, PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaRegisterPolicyChangeNotification)(POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass, HANDLE NotificationEventHandle);
typedef NTSTATUS(__stdcall* LsaUnregisterPolicyChangeNotification)(POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass, HANDLE NotificationEventHandle);
typedef NTSTATUS(__stdcall* LsaAddAccountRights)(LSA_HANDLE PolicyHandle, PSID AccountSid, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights);
typedef NTSTATUS(__stdcall* LsaRemoveAccountRights)(LSA_HANDLE PolicyHandle, PSID AccountSid, BOOLEAN AllRights, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights);
typedef NTSTATUS(__stdcall* LsaOpenTrustedDomainByName)(LSA_HANDLE PolicyHandle, PLSA_UNICODE_STRING TrustedDomainName, ACCESS_MASK DesiredAccess, PLSA_HANDLE TrustedDomainHandle);
typedef NTSTATUS(__stdcall* LsaSetTrustedDomainInformation)(LSA_HANDLE PolicyHandle, PSID TrustedDomainSid, TRUSTED_INFORMATION_CLASS InformationClass, PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaDeleteTrustedDomain)(LSA_HANDLE PolicyHandle, PSID TrustedDomainSid);
typedef NTSTATUS(__stdcall* LsaSetTrustedDomainInfoByName)(LSA_HANDLE PolicyHandle, PLSA_UNICODE_STRING TrustedDomainName, TRUSTED_INFORMATION_CLASS InformationClass, PVOID Buffer);
typedef NTSTATUS(__stdcall* LsaCreateTrustedDomainEx)(LSA_HANDLE PolicyHandle, PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation, PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation, ACCESS_MASK DesiredAccess, PLSA_HANDLE TrustedDomainHandle);
typedef NTSTATUS(__stdcall* LsaStorePrivateData)(LSA_HANDLE PolicyHandle, PLSA_UNICODE_STRING KeyName, PLSA_UNICODE_STRING PrivateData);
typedef ULONG(__stdcall* LsaNtStatusToWinError)(NTSTATUS Status);
typedef BOOLEAN(__stdcall* AuditSetSystemPolicy)(PCAUDIT_POLICY_INFORMATION pAuditPolicy, ULONG dwPolicyCount);
typedef BOOLEAN(__stdcall* AuditSetPerUserPolicy)(PSID pSid, PCAUDIT_POLICY_INFORMATION pAuditPolicy, ULONG dwPolicyCount);
typedef BOOLEAN(__stdcall* AuditSetSecurity)(SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef BOOLEAN(__stdcall* AuditSetGlobalSaclW)(PCWSTR ObjectTypeName, PACL Acl);
typedef BOOLEAN(__stdcall* AuditSetGlobalSaclA)(PCSTR ObjectTypeName, PACL Acl);
typedef void(__stdcall* AuditFree)(PVOID Buffer);
typedef HRESULT(__stdcall* CLSIDFromProgIDEx)(LPCOLESTR lpszProgID, LPCLSID lpclsid);
typedef HRESULT(__stdcall* CoInitialize)(LPVOID pvReserved);
typedef HRESULT(__stdcall* CoRegisterMallocSpy)(LPMALLOCSPY pMallocSpy);
typedef HRESULT(__stdcall* CoRevokeInitializeSpy)(ULARGE_INTEGER uliCookie);
typedef HINSTANCE(__stdcall* CoLoadLibrary)(LPOLESTR lpszLibName, BOOL bAutoFree);
typedef void(__stdcall* CoFreeLibrary)(HINSTANCE hInst);
typedef HRESULT(__stdcall* OleSaveToStream)(LPPERSISTSTREAM pPStm, LPSTREAM pStm);
typedef HRESULT(__stdcall* OleDraw)(LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw, LPCRECT lprcBounds);
typedef HRESULT(__stdcall* WriteFmtUserTypeStg)(LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType);
typedef HRESULT(__stdcall* OleInitialize)(LPVOID pvReserved);
typedef HRESULT(__stdcall* OleQueryLinkFromData)(LPDATAOBJECT pSrcDataObject);
typedef HRESULT(__stdcall* OleQueryCreateFromData)(LPDATAOBJECT pSrcDataObject);
typedef HRESULT(__stdcall* OleSave)(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad);
typedef HRESULT(__stdcall* OleSaveToStream)(LPPERSISTSTREAM pPStm, LPSTREAM pStm);
typedef HRESULT(__stdcall* OleSetContainedObject)(LPUNKNOWN pUnknown, BOOL fContained);
typedef HRESULT(__stdcall* OleNoteObjectVisible)(LPUNKNOWN pUnknown, BOOL fVisible);
typedef HRESULT(__stdcall* RegisterDragDrop)(HWND hwnd, LPDROPTARGET pDropTarget);
typedef HRESULT(__stdcall* RevokeDragDrop)(HWND hwnd);
typedef HRESULT(__stdcall* DoDragDrop)(LPDATAOBJECT pDataObj, LPDROPSOURCE pDropSource, DWORD dwOKEffects, LPDWORD pdwEffect);
typedef HRESULT(__stdcall* OleSetClipboard)(LPDATAOBJECT pDataObj);
typedef HRESULT(__stdcall* OleIsCurrentClipboard)(LPDATAOBJECT pDataObj);
typedef HOLEMENU(__stdcall* OleCreateMenuDescriptor)(HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths);
typedef HRESULT(__stdcall* OleSetMenuDescriptor)(HOLEMENU holemenu, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObj);
typedef HRESULT(__stdcall* OleDestroyMenuDescriptor)(HOLEMENU holemenu);
typedef HRESULT(__stdcall* OleTranslateAccelerator)(LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg);
typedef HANDLE(__stdcall* OleDuplicateData)(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags);
typedef HRESULT(__stdcall* OleDraw)(LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw, LPCRECT lprcBounds);
typedef HRESULT(__stdcall* OleRun)(LPUNKNOWN pUnknown);
typedef BOOL(__stdcall* OleIsRunning)(LPOLEOBJECT pObject);
typedef HRESULT(__stdcall* OleLockRunning)(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses);
typedef HGLOBAL(__stdcall* OleGetIconOfFile)(LPOLESTR lpszPath, BOOL fUseFileAsLabel);
typedef HGLOBAL(__stdcall* OleMetafilePictFromIconAndLabel)(HICON hIcon, LPOLESTR lpszLabel, LPOLESTR lpszSourceFile, UINT iIconIndex);
typedef HRESULT(__stdcall* OleConvertIStorageToOLESTREAM)(LPSTORAGE pstg, LPOLESTREAM lpolestream);
typedef HRESULT(__stdcall* OleDoAutoConvert)(LPSTORAGE pStg, LPCLSID pClsidNew);
typedef HRESULT(__stdcall* SetConvertStg)(LPSTORAGE pStg, BOOL fConvert);
typedef HRESULT(__stdcall* OleConvertIStorageToOLESTREAMEx)(LPSTORAGE pstg, CLIPFORMAT cfFormat, LONG lWidth, LONG lHeight, DWORD dwSize, LPSTGMEDIUM pmedium, LPOLESTREAM polestm);
typedef UINT(__stdcall* GetRoleTextA)(DWORD lRole, LPSTR lpszRole, UINT cchRoleMax);
typedef UINT(__stdcall* GetRoleTextW)(DWORD lRole, LPWSTR lpszRole, UINT cchRoleMax);
typedef UINT(__stdcall* GetStateTextA)(DWORD lStateBit, LPSTR lpszState, UINT cchState);
typedef UINT(__stdcall* GetStateTextW)(DWORD lStateBit, LPWSTR lpszState, UINT cchState);
typedef HRESULT(__stdcall* AccSetRunningUtilityState)(HWND hwndApp, DWORD dwUtilityStateMask, DWORD dwUtilityState);
typedef HRESULT(__stdcall* AccNotifyTouchInteraction)(HWND hwndApp, HWND hwndTarget, POINT ptTarget);
typedef HRESULT(__stdcall* SysAddRefString)(BSTR bstrString);
typedef void(__stdcall* SysReleaseString)(BSTR bstrString);
typedef void(__stdcall* SysFreeString)(BSTR bstrString);
typedef UINT(__stdcall* SysStringLen)(BSTR pbstr);
typedef UINT(__stdcall* SysStringByteLen)(BSTR bstr);
typedef BSTR(__stdcall* SysAllocStringByteLen)(LPCSTR psz, UINT len);
typedef INT(__stdcall* VariantTimeToSystemTime)(DOUBLE vtime, LPSYSTEMTIME lpSystemTime);
typedef void(__stdcall* SafeArrayReleaseData)(PVOID pData);
typedef {'name': 'SafeArrayCreateVector', 'type': 'SAFEARRAY'}(__stdcall* SafeArrayCreateVector)(VARTYPE vt, LONG lLbound, ULONG cElements);
typedef {'name': 'SafeArrayCreateVectorEx', 'type': 'SAFEARRAY'}(__stdcall* SafeArrayCreateVectorEx)(VARTYPE vt, LONG lLbound, ULONG cElements, PVOID pvExtra);
typedef HRESULT(__stdcall* VarAdd)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarAnd)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarCat)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarDiv)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarEqv)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarIdiv)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarImp)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarMod)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarMul)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarOr)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarPow)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarSub)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarXor)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarAbs)(LPVARIANT pvarIn, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarFix)(LPVARIANT pvarIn, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarInt)(LPVARIANT pvarIn, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarNeg)(LPVARIANT pvarIn, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarNot)(LPVARIANT pvarIn, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarRound)(LPVARIANT pvarIn, int cDecimals, LPVARIANT pvarResult);
typedef HRESULT(__stdcall* VarCmp)(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, ULONG dwFlags);
typedef HRESULT(__stdcall* VarDecAdd)(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecDiv)(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecMul)(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecSub)(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecAbs)(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecFix)(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecInt)(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecNeg)(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecRound)(LPDECIMAL pdecIn, int cDecimals, LPDECIMAL pdecResult);
typedef HRESULT(__stdcall* VarDecCmp)(LPDECIMAL pdecLeft, LPDECIMAL pdecRight);
typedef HRESULT(__stdcall* VarDecCmpR8)(LPDECIMAL pdecLeft, double dblRight);
typedef HRESULT(__stdcall* VarCyAdd)(CY cyLeft, CY cyRight, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyMul)(CY cyLeft, CY cyRight, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyMulI4)(CY cyLeft, LONG lRight, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyMulI8)(CY cyLeft, LONG64 lRight, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCySub)(CY cyLeft, CY cyRight, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyAbs)(CY cyIn, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyFix)(CY cyIn, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyInt)(CY cyIn, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyNeg)(CY cyIn, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyRound)(CY cyIn, int cDecimals, LPCY pcyResult);
typedef HRESULT(__stdcall* VarCyCmp)(CY cyLeft, CY cyRight);
typedef HRESULT(__stdcall* VarCyCmpR8)(CY cyLeft, double dblRight);
typedef HRESULT(__stdcall* VarBstrCat)(BSTR bstrLeft, BSTR bstrRight, LPBSTR pbstrResult);
typedef HRESULT(__stdcall* VarBstrCmp)(BSTR bstrLeft, BSTR bstrRight, LCID lcid, ULONG dwFlags);
typedef HRESULT(__stdcall* VarR4CmpR8)(float fltLeft, double dblRight);
typedef ULONG(__stdcall* LHashValOfNameSysA)(SYSKIND syskind, LCID lcid, LPCSTR szName);
typedef void(__stdcall* ClearCustData)(LPCUSTDATA pCustData);
typedef HRESULT(__stdcall* OleCreatePropertyFrameIndirect)(LPOCPFIPARAMS lpParams);
typedef HRESULT(__stdcall* OleSavePictureFile)(LPDISPATCH lpdispPicture, BSTR bstrFileName);
typedef HCURSOR(__stdcall* OleIconToCursor)(HINSTANCE hinstExe, HICON hIcon);
typedef int(__stdcall* OleUIPromptUserW)(int nTemplate, HWND hwndParent);
typedef int(__stdcall* OleUIPromptUserA)(int nTemplate, HWND hwndParent);
typedef BOOL(__stdcall* OleUIUpdateLinksW)(LPOLEUILINKCONTAINERW lpOleUILinkCntr, HWND hwndParent, LPWSTR lpszTitle, int cLinks);
typedef BOOL(__stdcall* OleUIUpdateLinksA)(LPOLEUILINKCONTAINERA lpOleUILinkCntr, HWND hwndParent, LPSTR lpszTitle, int cLinks);
typedef HRESULT(__stdcall* PeerGraphStartup)(WORD wVersionRequested, PPEER_VERSION_DATA pVersionData);
typedef HRESULT(__stdcall* PeerGraphShutdown)();
typedef void(__stdcall* PeerGraphFreeData)(PVOID pvData);
typedef HRESULT(__stdcall* PeerGraphEndEnumeration)(HPEERENUM hPeerEnum);
typedef HRESULT(__stdcall* PeerGraphListen)(HGRAPH hGraph, DWORD dwScope, DWORD dwScopeId, WORD wPort);
typedef HRESULT(__stdcall* PeerGraphClose)(HGRAPH hGraph);
typedef HRESULT(__stdcall* PeerGraphDelete)(PCWSTR pwzGraphId, PCWSTR pwzPeerId, PCWSTR pwzDatabaseName);
typedef HRESULT(__stdcall* PeerGraphSetProperties)(HGRAPH hGraph, PPEER_GRAPH_PROPERTIES pGraphProperties);
typedef HRESULT(__stdcall* PeerGraphUnregisterEvent)(HPEEREVENT hPeerEvent);
typedef HRESULT(__stdcall* PeerGraphUpdateRecord)(HGRAPH hGraph, PPEER_RECORD pRecord);
typedef HRESULT(__stdcall* PeerGraphExportDatabase)(HGRAPH hGraph, PCWSTR pwzFilePath);
typedef HRESULT(__stdcall* PeerGraphImportDatabase)(HGRAPH hGraph, PCWSTR pwzFilePath);
typedef HRESULT(__stdcall* PeerGraphCloseDirectConnection)(HGRAPH hGraph, ULONGLONG ullConnectionId);
typedef HRESULT(__stdcall* PeerGraphSetPresence)(HGRAPH hGraph, BOOL fPresent);
typedef HRESULT(__stdcall* PeerGraphSetNodeAttributes)(HGRAPH hGraph, PCWSTR pwzAttributes);
typedef void(__stdcall* PeerFreeData)(LPCVOID pvData);
typedef HRESULT(__stdcall* PeerEndEnumeration)(HPEERENUM hPeerEnum);
typedef HRESULT(__stdcall* PeerGroupStartup)(WORD wVersionRequested, PPEER_VERSION_DATA pVersionData);
typedef HRESULT(__stdcall* PeerGroupShutdown)();
typedef HRESULT(__stdcall* PeerGroupConnect)(HGROUP hGroup);
typedef HRESULT(__stdcall* PeerGroupConnectByAddress)(HGROUP hGroup, ULONG cAddresses, PPEER_ADDRESS pAddresses);
typedef HRESULT(__stdcall* PeerGroupClose)(HGROUP hGroup);
typedef HRESULT(__stdcall* PeerGroupDelete)(PCWSTR pwzIdentity, PCWSTR pwzGroupPeerName);
typedef HRESULT(__stdcall* PeerGroupSetProperties)(HGROUP hGroup, PPEER_GROUP_PROPERTIES pProperties);
typedef HRESULT(__stdcall* PeerGroupCloseDirectConnection)(HGROUP hGroup, ULONGLONG ullConnectionId);
typedef HRESULT(__stdcall* PeerGroupUnregisterEvent)(HPEEREVENT hPeerEvent);
typedef HRESULT(__stdcall* PeerGroupUpdateRecord)(HGROUP hGroup, PPEER_RECORD pRecord);
typedef HRESULT(__stdcall* PeerGroupExportDatabase)(HGROUP hGroup, PCWSTR pwzFilePath);
typedef HRESULT(__stdcall* PeerGroupImportDatabase)(HGROUP hGroup, PCWSTR pwzFilePath);
typedef HRESULT(__stdcall* PeerIdentitySetFriendlyName)(PCWSTR pwzIdentity, PCWSTR pwzFriendlyName);
typedef HRESULT(__stdcall* PeerIdentityDelete)(PCWSTR pwzIdentity);
typedef HRESULT(__stdcall* PeerCollabStartup)(WORD wVersionRequested);
typedef HRESULT(__stdcall* PeerCollabShutdown)();
typedef HRESULT(__stdcall* PeerCollabSignin)(HWND hwndParent, DWORD dwSigninOptions);
typedef HRESULT(__stdcall* PeerCollabSignout)(DWORD dwSigninOptions);
typedef HRESULT(__stdcall* PeerCollabCancelInvitation)(HANDLE hInvitation);
typedef HRESULT(__stdcall* PeerCollabCloseHandle)(HANDLE hInvitation);
typedef HRESULT(__stdcall* PeerCollabRegisterApplication)(PCPEER_APPLICATION_REGISTRATION_INFO pcApplication, PEER_APPLICATION_REGISTRATION_TYPE registrationType);
typedef HRESULT(__stdcall* PeerCollabRefreshEndpointData)(PCPEER_ENDPOINT pcEndpoint);
typedef HRESULT(__stdcall* PeerCollabDeleteEndpointData)(PCPEER_ENDPOINT pcEndpoint);
typedef HRESULT(__stdcall* PeerCollabSubscribeEndpointData)(PCPEER_ENDPOINT pcEndpoint);
typedef HRESULT(__stdcall* PeerCollabUnsubscribeEndpointData)(PCPEER_ENDPOINT pcEndpoint);
typedef HRESULT(__stdcall* PeerCollabSetPresenceInfo)(PCPEER_PRESENCE_INFO pcPresenceInfo);
typedef HRESULT(__stdcall* PeerCollabSetEndpointName)(PCWSTR pwzEndpointName);
typedef HRESULT(__stdcall* PeerCollabSetObject)(PCPEER_OBJECT pcObject);
typedef HRESULT(__stdcall* PeerCollabUnregisterEvent)(HPEEREVENT hPeerEvent);
typedef HRESULT(__stdcall* PeerCollabDeleteContact)(PCWSTR pwzPeerName);
typedef HRESULT(__stdcall* PeerCollabUpdateContact)(PCPEER_CONTACT pContact);
typedef HRESULT(__stdcall* PeerPnrpStartup)(WORD wVersionRequested);
typedef HRESULT(__stdcall* PeerPnrpShutdown)();
typedef HRESULT(__stdcall* PeerPnrpUpdateRegistration)(HREGISTRATION hRegistration, PPEER_PNRP_REGISTRATION_INFO pRegistrationInfo);
typedef HRESULT(__stdcall* PeerPnrpUnregister)(HREGISTRATION hRegistration);
typedef HRESULT(__stdcall* PeerPnrpEndResolve)(HRESOLUTION hResolve);
typedef BOOL(__stdcall* PathCchIsRoot)(PCWSTR pszPath);
typedef HRESULT(__stdcall* PathCchAddBackslash)(PWSTR pszPath, size_t cchPath);
typedef HRESULT(__stdcall* PathCchRemoveBackslash)(PWSTR pszPath, size_t cchPath);
typedef HRESULT(__stdcall* PathCchStripToRoot)(PWSTR pszPath, size_t cchPath);
typedef HRESULT(__stdcall* PathCchRemoveFileSpec)(PWSTR pszPath, size_t cchPath);
typedef HRESULT(__stdcall* PathCchAddExtension)(PWSTR pszPath, size_t cchPath, PCWSTR pszExt);
typedef HRESULT(__stdcall* PathCchRenameExtension)(PWSTR pszPath, size_t cchPath, PCWSTR pszExt);
typedef HRESULT(__stdcall* PathCchRemoveExtension)(PWSTR pszPath, size_t cchPath);
typedef HRESULT(__stdcall* PathCchCanonicalizeEx)(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, ULONG dwFlags);
typedef HRESULT(__stdcall* PathCchCanonicalize)(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn);
typedef HRESULT(__stdcall* PathCchCombineEx)(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, PCWSTR pszMore, ULONG dwFlags);
typedef HRESULT(__stdcall* PathCchCombine)(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, PCWSTR pszMore);
typedef HRESULT(__stdcall* PathCchAppendEx)(PWSTR pszPath, size_t cchPath, PCWSTR pszMore, ULONG dwFlags);
typedef HRESULT(__stdcall* PathCchAppend)(PWSTR pszPath, size_t cchPath, PCWSTR pszMore);
typedef HRESULT(__stdcall* PathCchStripPrefix)(PWSTR pszPath, size_t cchPath);
typedef PDH_STATUS(__stdcall* PdhGetDllVersion)(LPDWORD lpdwVersion);
typedef PDH_STATUS(__stdcall* PdhValidatePathExW)(PDH_HLOG hDataSource, LPCWSTR szFullPathBuffer);
typedef PDH_STATUS(__stdcall* PdhValidatePathExA)(PDH_HLOG hDataSource, LPCSTR szFullPathBuffer);
typedef PDH_STATUS(__stdcall* PdhRemoveCounter)(PDH_HCOUNTER hCounter);
typedef PDH_STATUS(__stdcall* PdhCollectQueryData)(PDH_HQUERY hQuery);
typedef PDH_STATUS(__stdcall* PdhCloseQuery)(PDH_HQUERY hQuery);
typedef PDH_STATUS(__stdcall* PdhGetFormattedCounterValue)(PDH_HCOUNTER hCounter, DWORD dwFormat, LPDWORD lpdwType, PPDH_FMT_COUNTERVALUE pValue);
typedef PDH_STATUS(__stdcall* PdhGetFormattedCounterArrayA)(PDH_HCOUNTER hCounter, DWORD dwFormat, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount, PPDH_FMT_COUNTERVALUE_ITEM_A ItemBuffer);
typedef PDH_STATUS(__stdcall* PdhGetFormattedCounterArrayW)(PDH_HCOUNTER hCounter, DWORD dwFormat, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount, PPDH_FMT_COUNTERVALUE_ITEM_W ItemBuffer);
typedef PDH_STATUS(__stdcall* PdhGetRawCounterValue)(PDH_HCOUNTER hCounter, LPDWORD lpdwType, PPDH_RAW_COUNTER pValue);
typedef PDH_STATUS(__stdcall* PdhGetRawCounterArrayA)(PDH_HCOUNTER hCounter, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount, PPDH_RAW_COUNTER_ITEM_A ItemBuffer);
typedef PDH_STATUS(__stdcall* PdhGetRawCounterArrayW)(PDH_HCOUNTER hCounter, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount, PPDH_RAW_COUNTER_ITEM_W ItemBuffer);
typedef PDH_STATUS(__stdcall* PdhCalculateCounterFromRawValue)(PDH_HCOUNTER hCounter, DWORD dwFormat, PPDH_RAW_COUNTER rawValue1, PPDH_RAW_COUNTER rawValue2, PPDH_FMT_COUNTERVALUE fmtValue);
typedef PDH_STATUS(__stdcall* PdhComputeCounterStatistics)(PDH_HCOUNTER hCounter, DWORD dwFormat, DWORD dwFirstEntry, DWORD dwNumEntries, PPDH_RAW_COUNTER lpRawValueArray, PPDH_STATISTICS data);
typedef PDH_STATUS(__stdcall* PdhGetCounterInfoW)(PDH_HCOUNTER hCounter, BOOLEAN bRetrieveExplainText, LPDWORD pdwBufferSize, PPDH_COUNTER_INFO_W lpBuffer);
typedef PDH_STATUS(__stdcall* PdhGetCounterInfoA)(PDH_HCOUNTER hCounter, BOOLEAN bRetrieveExplainText, LPDWORD pdwBufferSize, PPDH_COUNTER_INFO_A lpBuffer);
typedef PDH_STATUS(__stdcall* PdhSetCounterScaleFactor)(PDH_HCOUNTER hCounter, LONG lFactor);
typedef PDH_STATUS(__stdcall* PdhConnectMachineW)(LPCWSTR szMachineName);
typedef PDH_STATUS(__stdcall* PdhConnectMachineA)(LPCSTR szMachineName);
typedef PDH_STATUS(__stdcall* PdhEnumMachinesW)(LPCWSTR szDataSource, PZZWSTR mszMachineList, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhEnumMachinesA)(LPCSTR szDataSource, PZZSTR mszMachineList, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhEnumObjectsW)(LPCWSTR szDataSource, LPCWSTR szMachineName, PZZWSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh);
typedef PDH_STATUS(__stdcall* PdhEnumObjectsA)(LPCSTR szDataSource, LPCSTR szMachineName, PZZSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh);
typedef PDH_STATUS(__stdcall* PdhEnumObjectItemsW)(LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, PZZWSTR mszCounterList, LPDWORD pcchCounterListLength, PZZWSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhEnumObjectItemsA)(LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, PZZSTR mszCounterList, LPDWORD pcchCounterListLength, PZZSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhMakeCounterPathW)(PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements, LPWSTR szFullPathBuffer, LPDWORD pcchBufferSize, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhMakeCounterPathA)(PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements, LPSTR szFullPathBuffer, LPDWORD pcchBufferSize, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhParseCounterPathW)(LPCWSTR szFullPathBuffer, PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements, LPDWORD pdwBufferSize, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhParseCounterPathA)(LPCSTR szFullPathBuffer, PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements, LPDWORD pdwBufferSize, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhParseInstanceNameW)(LPCWSTR szInstanceString, LPWSTR szInstanceName, LPDWORD pcchInstanceNameLength, LPWSTR szParentName, LPDWORD pcchParentNameLength, LPDWORD lpIndex);
typedef PDH_STATUS(__stdcall* PdhParseInstanceNameA)(LPCSTR szInstanceString, LPSTR szInstanceName, LPDWORD pcchInstanceNameLength, LPSTR szParentName, LPDWORD pcchParentNameLength, LPDWORD lpIndex);
typedef PDH_STATUS(__stdcall* PdhValidatePathW)(LPCWSTR szFullPathBuffer);
typedef PDH_STATUS(__stdcall* PdhValidatePathA)(LPCSTR szFullPathBuffer);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfObjectW)(LPCWSTR szDataSource, LPCWSTR szMachineName, LPWSTR szDefaultObjectName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfObjectA)(LPCSTR szDataSource, LPCSTR szMachineName, LPSTR szDefaultObjectName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfCounterW)(LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, LPWSTR szDefaultCounterName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfCounterA)(LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR szDefaultCounterName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhBrowseCountersW)(PPDH_BROWSE_DLG_CONFIG_W pBrowseDlgData);
typedef PDH_STATUS(__stdcall* PdhBrowseCountersA)(PPDH_BROWSE_DLG_CONFIG_A pBrowseDlgData);
typedef PDH_STATUS(__stdcall* PdhExpandCounterPathW)(LPCWSTR szWildCardPath, PZZWSTR mszExpandedPathList, LPDWORD pcchPathListLength);
typedef PDH_STATUS(__stdcall* PdhExpandCounterPathA)(LPCSTR szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength);
typedef PDH_STATUS(__stdcall* PdhLookupPerfNameByIndexW)(LPCWSTR szMachineName, DWORD dwNameIndex, LPWSTR szNameBuffer, LPDWORD pcchNameBufferSize);
typedef PDH_STATUS(__stdcall* PdhLookupPerfNameByIndexA)(LPCSTR szMachineName, DWORD dwNameIndex, LPSTR szNameBuffer, LPDWORD pcchNameBufferSize);
typedef PDH_STATUS(__stdcall* PdhLookupPerfIndexByNameW)(LPCWSTR szMachineName, LPCWSTR szNameBuffer, LPDWORD pdwIndex);
typedef PDH_STATUS(__stdcall* PdhLookupPerfIndexByNameA)(LPCSTR szMachineName, LPCSTR szNameBuffer, LPDWORD pdwIndex);
typedef PDH_STATUS(__stdcall* PdhExpandWildCardPathA)(LPCSTR szDataSource, LPCSTR szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhExpandWildCardPathW)(LPCWSTR szDataSource, LPCWSTR szWildCardPath, PZZWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhUpdateLogW)(PDH_HLOG hLog, LPCWSTR szUserString);
typedef PDH_STATUS(__stdcall* PdhUpdateLogA)(PDH_HLOG hLog, LPCSTR szUserString);
typedef PDH_STATUS(__stdcall* PdhUpdateLogFileCatalog)(PDH_HLOG hLog);
typedef PDH_STATUS(__stdcall* PdhCloseLog)(PDH_HLOG hLog, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhSelectDataSourceW)(HWND hWndOwner, DWORD dwFlags, LPWSTR szDataSource, LPDWORD pcchBufferLength);
typedef PDH_STATUS(__stdcall* PdhSelectDataSourceA)(HWND hWndOwner, DWORD dwFlags, LPSTR szDataSource, LPDWORD pcchBufferLength);
typedef BOOL(__stdcall* PdhIsRealTimeQuery)(PDH_HQUERY hQuery);
typedef PDH_STATUS(__stdcall* PdhSetQueryTimeRange)(PDH_HQUERY hQuery, PPDH_TIME_INFO pInfo);
typedef PDH_STATUS(__stdcall* PdhGetDataSourceTimeRangeW)(LPCWSTR szDataSource, LPDWORD pdwNumEntries, PPDH_TIME_INFO pInfo, LPDWORD pdwBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDataSourceTimeRangeA)(LPCSTR szDataSource, LPDWORD pdwNumEntries, PPDH_TIME_INFO pInfo, LPDWORD pdwBufferSize);
typedef PDH_STATUS(__stdcall* PdhCollectQueryDataEx)(PDH_HQUERY hQuery, DWORD dwIntervalTime, HANDLE hNewDataEvent);
typedef PDH_STATUS(__stdcall* PdhReadRawLogRecord)(PDH_HLOG hLog, FILETIME ftRecord, PPDH_RAW_LOG_RECORD pRawLogRecord, LPDWORD pdwBufferLength);
typedef PDH_STATUS(__stdcall* PdhSetDefaultRealTimeDataSource)(DWORD dwDataSourceId);
typedef PDH_STATUS(__stdcall* PdhEnumMachinesHW)(PDH_HLOG hDataSource, PZZWSTR mszMachineList, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhEnumMachinesHA)(PDH_HLOG hDataSource, PZZSTR mszMachineList, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhEnumObjectsHW)(PDH_HLOG hDataSource, LPCWSTR szMachineName, PZZWSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh);
typedef PDH_STATUS(__stdcall* PdhEnumObjectsHA)(PDH_HLOG hDataSource, LPCSTR szMachineName, PZZSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh);
typedef PDH_STATUS(__stdcall* PdhEnumObjectItemsHW)(PDH_HLOG hDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, PZZWSTR mszCounterList, LPDWORD pcchCounterListLength, PZZWSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhEnumObjectItemsHA)(PDH_HLOG hDataSource, LPCSTR szMachineName, LPCSTR szObjectName, PZZSTR mszCounterList, LPDWORD pcchCounterListLength, PZZSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhExpandWildCardPathHW)(PDH_HLOG hDataSource, LPCWSTR szWildCardPath, PZZWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhExpandWildCardPathHA)(PDH_HLOG hDataSource, LPCSTR szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags);
typedef PDH_STATUS(__stdcall* PdhGetDataSourceTimeRangeH)(PDH_HLOG hDataSource, LPDWORD pdwNumEntries, PPDH_TIME_INFO pInfo, LPDWORD pdwBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfObjectHW)(PDH_HLOG hDataSource, LPCWSTR szMachineName, LPWSTR szDefaultObjectName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfObjectHA)(PDH_HLOG hDataSource, LPCSTR szMachineName, LPSTR szDefaultObjectName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfCounterHW)(PDH_HLOG hDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, LPWSTR szDefaultCounterName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhGetDefaultPerfCounterHA)(PDH_HLOG hDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR szDefaultCounterName, LPDWORD pcchBufferSize);
typedef PDH_STATUS(__stdcall* PdhBrowseCountersHW)(PPDH_BROWSE_DLG_CONFIG_HW pBrowseDlgData);
typedef PDH_STATUS(__stdcall* PdhBrowseCountersHA)(PPDH_BROWSE_DLG_CONFIG_HA pBrowseDlgData);
typedef PDH_STATUS(__stdcall* PdhEnumLogSetNamesW)(LPCWSTR szDataSource, PZZWSTR mszDataSetNameList, LPDWORD pcchBufferLength);
typedef PDH_STATUS(__stdcall* PdhEnumLogSetNamesA)(LPCSTR szDataSource, PZZSTR mszDataSetNameList, LPDWORD pcchBufferLength);
typedef DWORD(__stdcall* PeerDistStartup)(DWORD dwVersionRequested, PPEERDIST_INSTANCE_HANDLE phPeerDist, PDWORD pdwSupportedVersion);
typedef DWORD(__stdcall* PeerDistShutdown)(PEERDIST_INSTANCE_HANDLE hPeerDist);
typedef DWORD(__stdcall* PeerDistUnregisterForStatusChangeNotification)(PEERDIST_INSTANCE_HANDLE hPeerDist);
typedef DWORD(__stdcall* PeerDistServerPublishStream)(PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, ULONGLONG cbContentLength, PCPEERDIST_PUBLICATION_OPTIONS pPublishOptions, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, PPEERDIST_STREAM_HANDLE phStream);
typedef DWORD(__stdcall* PeerDistServerPublishAddToStream)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, DWORD cbNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistServerPublishCompleteStream)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistServerCloseStreamHandle)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream);
typedef DWORD(__stdcall* PeerDistServerUnpublish)(PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier);
typedef DWORD(__stdcall* PeerDistServerOpenContentInformation)(PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, ULONGLONG ullContentOffset, ULONGLONG cbContentLength, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, PPEERDIST_CONTENTINFO_HANDLE phContentInfo);
typedef DWORD(__stdcall* PeerDistServerRetrieveContentInformation)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo, DWORD cbMaxNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistServerCloseContentInformation)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo);
typedef DWORD(__stdcall* PeerDistServerCancelAsyncOperation)(PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, LPOVERLAPPED pOverlapped);
typedef DWORD(__stdcall* PeerDistClientOpenContent)(PEERDIST_INSTANCE_HANDLE hPeerDist, PCPEERDIST_CONTENT_TAG pContentTag, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, PPEERDIST_CONTENT_HANDLE phContentHandle);
typedef DWORD(__stdcall* PeerDistClientCloseContent)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle);
typedef DWORD(__stdcall* PeerDistClientAddContentInformation)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientCompleteContentInformation)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientAddData)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientBlockRead)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbMaxNumberOfBytes, PBYTE pBuffer, DWORD dwTimeoutInMilliseconds, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientStreamRead)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbMaxNumberOfBytes, PBYTE pBuffer, DWORD dwTimeoutInMilliseconds, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientFlushContent)(PEERDIST_INSTANCE_HANDLE hPeerDist, PCPEERDIST_CONTENT_TAG pContentTag, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, LPOVERLAPPED lpOverlapped);
typedef DWORD(__stdcall* PeerDistClientCancelAsyncOperation)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, LPOVERLAPPED pOverlapped);
typedef DWORD(__stdcall* PeerDistClientGetInformationByHandle)(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS PeerDistClientInfoClass, DWORD dwBufferSize, LPVOID lpInformation);
typedef ULONG(__stdcall* PerfStartProvider)(LPGUID ProviderGuid, PERFLIBREQUEST ControlCallback, PHANDLE Provider);
typedef ULONG(__stdcall* PerfStartProviderEx)(LPGUID ProviderGuid, PPERF_PROVIDER_CONTEXT ProviderContext, PHANDLE Provider);
typedef ULONG(__stdcall* PerfStopProvider)(HANDLE ProviderHandle);
typedef ULONG(__stdcall* PerfSetCounterSetInfo)(HANDLE ProviderHandle, PPERF_COUNTERSET_INFO Template, ULONG TemplateSize);
typedef PPERF_COUNTERSET_INSTANCE(__stdcall* PerfCreateInstance)(HANDLE ProviderHandle, LPCGUID CounterSetGuid, PCWSTR Name, ULONG Id);
typedef ULONG(__stdcall* PerfDeleteInstance)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE InstanceBlock);
typedef PPERF_COUNTERSET_INSTANCE(__stdcall* PerfQueryInstance)(HANDLE ProviderHandle, LPCGUID CounterSetGuid, PCWSTR Name, ULONG Id);
typedef ULONG(__stdcall* PerfSetCounterRefValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, PVOID Address);
typedef ULONG(__stdcall* PerfSetULongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONG Value);
typedef ULONG(__stdcall* PerfSetULongLongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONGLONG Value);
typedef ULONG(__stdcall* PerfIncrementULongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONG Value);
typedef ULONG(__stdcall* PerfIncrementULongLongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONGLONG Value);
typedef ULONG(__stdcall* PerfDecrementULongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONG Value);
typedef ULONG(__stdcall* PerfDecrementULongLongCounterValue)(HANDLE Provider, PPERF_COUNTERSET_INSTANCE Instance, ULONG CounterId, ULONGLONG Value);
typedef ULONG(__stdcall* PerfEnumerateCounterSet)(LPCWSTR szMachine, LPGUID pCounterSetIds, DWORD cCounterSetIds, LPDWORD pcCounterSetIdsActual);
typedef ULONG(__stdcall* PerfEnumerateCounterSetInstances)(LPCWSTR szMachine, LPCGUID pCounterSetId, PPERF_INSTANCE_HEADER pInstances, DWORD cbInstances, LPDWORD pcbInstancesActual);
typedef ULONG(__stdcall* PerfQueryCounterSetRegistrationInfo)(LPCWSTR szMachine, LPCGUID pCounterSetId, PerfRegInfoType requestCode, DWORD requestLangId, LPBYTE pbRegInfo, DWORD cbRegInfo, LPDWORD pcbRegInfoActual);
typedef ULONG(__stdcall* PerfCloseQueryHandle)(HANDLE hQuery);
typedef ULONG(__stdcall* PerfQueryCounterInfo)(HANDLE hQuery, PPERF_COUNTER_IDENTIFIER pCounters, DWORD cbCounters, LPDWORD pcbCountersActual);
typedef ULONG(__stdcall* PerfQueryCounterData)(HANDLE hQuery, PPERF_DATA_HEADER pCounterBlock, DWORD cbCounterBlock, LPDWORD pcbCounterBlockActual);
typedef ULONG(__stdcall* PerfAddCounters)(HANDLE hQuery, PPERF_COUNTER_IDENTIFIER pCounters, DWORD cbCounters);
typedef ULONG(__stdcall* PerfDeleteCounters)(HANDLE hQuery, PPERF_COUNTER_IDENTIFIER pCounters, DWORD cbCounters);
typedef _BOOL(__stdcall* GetNumberOfPhysicalMonitorsFromHMONITOR)(HMONITOR hMonitor, LPDWORD pdwNumberOfPhysicalMonitors);
typedef _BOOL(__stdcall* GetPhysicalMonitorsFromHMONITOR)(HMONITOR hMonitor, DWORD dwPhysicalMonitorArraySize, LPPHYSICAL_MONITOR pPhysicalMonitorArray);
typedef _BOOL(__stdcall* DestroyPhysicalMonitor)(HANDLE hMonitor);
typedef _BOOL(__stdcall* DestroyPhysicalMonitors)(DWORD dwPhysicalMonitorArraySize, LPPHYSICAL_MONITOR pPhysicalMonitorArray);
typedef BOOLEAN(__stdcall* GetPwrDiskSpindownRange)(PUINT puiMax, PUINT puiMin);
typedef BOOLEAN(__stdcall* EnumPwrSchemes)(PWRSCHEMESENUMPROC lpfn, LPARAM lParam);
typedef BOOLEAN(__stdcall* ReadGlobalPwrPolicy)(PGLOBAL_POWER_POLICY pGlobalPowerPolicy);
typedef BOOLEAN(__stdcall* ReadPwrScheme)(UINT uiID, PPOWER_POLICY pPowerPolicy);
typedef BOOLEAN(__stdcall* WritePwrScheme)(PUINT puiID, LPCWSTR lpszSchemeName, LPCWSTR lpszDescription, PPOWER_POLICY lpScheme);
typedef BOOLEAN(__stdcall* WriteGlobalPwrPolicy)(PGLOBAL_POWER_POLICY pGlobalPowerPolicy);
typedef BOOLEAN(__stdcall* DeletePwrScheme)(UINT uiID);
typedef BOOLEAN(__stdcall* GetActivePwrScheme)(PUINT puiID);
typedef BOOLEAN(__stdcall* SetActivePwrScheme)(UINT uiID, PGLOBAL_POWER_POLICY pGlobalPowerPolicy, PPOWER_POLICY pPowerPolicy);
typedef BOOLEAN(__stdcall* SetSuspendState)(BOOLEAN bHibernate, BOOLEAN bForce, BOOLEAN bWakeupEventsDisabled);
typedef BOOLEAN(__stdcall* GetCurrentPowerPolicies)(PGLOBAL_POWER_POLICY pGlobalPowerPolicy, PPOWER_POLICY pPowerPolicy);
typedef BOOLEAN(__stdcall* ReadProcessorPwrScheme)(UINT uiID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy);
typedef BOOLEAN(__stdcall* WriteProcessorPwrScheme)(UINT uiID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy);
typedef BOOLEAN(__stdcall* DevicePowerEnumDevices)(ULONG QueryIndex, ULONG QueryInterpretationFlags, ULONG QueryFlags, PBYTE pReturnBuffer, PULONG pBufferSize);
typedef DWORD(__stdcall* DevicePowerSetDeviceState)(LPCWSTR DeviceDescription, ULONG SetFlags, PVOID SetData);
typedef BOOLEAN(__stdcall* DevicePowerOpen)(ULONG DebugMask);
typedef DWORD(__stdcall* PowerReportThermalEvent)(PTHERMAL_EVENT Event);
typedef HRESULT(__stdcall* PTCloseProvider)(HPTPROVIDER hProvider);
typedef HRESULT(__stdcall* PTReleaseMemory)(PVOID pBuffer);
typedef BOOL(__stdcall* SetEnvironmentStringsW)(LPWCH NewEnvironment);
typedef BOOL(__stdcall* SetStdHandleEx)(DWORD nStdHandle, HANDLE hHandle, PHANDLE phPrevValue);
typedef BOOL(__stdcall* FreeEnvironmentStringsA)(LPCH penv);
typedef BOOL(__stdcall* FreeEnvironmentStringsW)(LPWCH penv);
typedef DWORD(__stdcall* ExpandEnvironmentStringsA)(LPCSTR lpSrc, LPSTR lpDst, DWORD nSize);
typedef DWORD(__stdcall* ExpandEnvironmentStringsW)(LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize);
typedef BOOL(__stdcall* NeedCurrentDirectoryForExePathA)(LPCSTR ExeName);
typedef BOOL(__stdcall* NeedCurrentDirectoryForExePathW)(LPCWSTR ExeName);
typedef DWORD(__stdcall* PssFreeSnapshot)(HANDLE ProcessHandle, HPSS SnapshotHandle);
typedef DWORD(__stdcall* PssWalkMarkerFree)(HPSSWALK WalkMarkerHandle);
typedef DWORD(__stdcall* PssWalkMarkerSetPosition)(HPSSWALK WalkMarkerHandle, ULONG_PTR Position);
typedef DWORD(__stdcall* PssWalkMarkerSeekToBeginning)(HPSSWALK WalkMarkerHandle);
typedef DWORD(__stdcall* QueueUserAPC)(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
typedef BOOL(__stdcall* GetProcessTimes)(HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
typedef void(__stdcall* ExitProcess)(UINT uExitCode);
typedef BOOL(__stdcall* TerminateProcess)(HANDLE hProcess, UINT uExitCode);
typedef BOOL(__stdcall* GetExitCodeProcess)(HANDLE hProcess, LPDWORD lpExitCode);
typedef HANDLE(__stdcall* CreateThread)(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
typedef HANDLE(__stdcall* CreateRemoteThread)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
typedef HANDLE(__stdcall* OpenThread)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId);
typedef BOOL(__stdcall* SetThreadPriority)(HANDLE hThread, int nPriority);
typedef BOOL(__stdcall* SetThreadPriorityBoost)(HANDLE hThread, BOOL bDisablePriorityBoost);
typedef BOOL(__stdcall* GetThreadPriorityBoost)(HANDLE hThread, PBOOL pDisablePriorityBoost);
typedef int(__stdcall* GetThreadPriority)(HANDLE hThread);
typedef void(__stdcall* ExitThread)(DWORD dwExitCode);
typedef BOOL(__stdcall* TerminateThread)(HANDLE hThread, DWORD dwExitCode);
typedef BOOL(__stdcall* GetExitCodeThread)(HANDLE hThread, LPDWORD lpExitCode);
typedef DWORD(__stdcall* SuspendThread)(HANDLE hThread);
typedef DWORD(__stdcall* ResumeThread)(HANDLE hThread);
typedef LPVOID(__stdcall* TlsGetValue)(DWORD dwTlsIndex);
typedef BOOL(__stdcall* TlsSetValue)(DWORD dwTlsIndex, LPVOID lpTlsValue);
typedef BOOL(__stdcall* TlsFree)(DWORD dwTlsIndex);
typedef BOOL(__stdcall* CreateProcessA)(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* CreateProcessW)(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* SetProcessShutdownParameters)(DWORD dwLevel, DWORD dwFlags);
typedef DWORD(__stdcall* GetProcessVersion)(DWORD ProcessId);
typedef void(__stdcall* GetStartupInfoW)(LPSTARTUPINFOW lpStartupInfo);
typedef BOOL(__stdcall* CreateProcessAsUserW)(HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* SetThreadToken)(PHANDLE Thread, HANDLE Token);
typedef BOOL(__stdcall* OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
typedef BOOL(__stdcall* OpenThreadToken)(HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle);
typedef BOOL(__stdcall* SetPriorityClass)(HANDLE hProcess, DWORD dwPriorityClass);
typedef DWORD(__stdcall* GetPriorityClass)(HANDLE hProcess);
typedef BOOL(__stdcall* SetThreadStackGuarantee)(PULONG StackSizeInBytes);
typedef DWORD(__stdcall* GetProcessId)(HANDLE Process);
typedef DWORD(__stdcall* GetThreadId)(HANDLE Thread);
typedef DWORD(__stdcall* GetProcessIdOfThread)(HANDLE Thread);
typedef BOOL(__stdcall* InitializeProcThreadAttributeList)(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, DWORD dwAttributeCount, DWORD dwFlags, PSIZE_T lpSize);
typedef void(__stdcall* DeleteProcThreadAttributeList)(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList);
typedef BOOL(__stdcall* UpdateProcThreadAttribute)(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, DWORD dwFlags, DWORD_PTR Attribute, PVOID lpValue, SIZE_T cbSize, PVOID lpPreviousValue, PSIZE_T lpReturnSize);
typedef BOOL(__stdcall* SetProcessAffinityUpdateMode)(HANDLE hProcess, DWORD dwFlags);
typedef BOOL(__stdcall* QueryProcessAffinityUpdateMode)(HANDLE hProcess, LPDWORD lpdwFlags);
typedef HANDLE(__stdcall* CreateRemoteThreadEx)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, LPDWORD lpThreadId);
typedef void(__stdcall* GetCurrentThreadStackLimits)(PULONG_PTR LowLimit, PULONG_PTR HighLimit);
typedef BOOL(__stdcall* GetThreadContext)(HANDLE hThread, LPCONTEXT lpContext);
typedef BOOL(__stdcall* GetProcessMitigationPolicy)(HANDLE hProcess, PROCESS_MITIGATION_POLICY MitigationPolicy, PVOID lpBuffer, SIZE_T dwLength);
typedef BOOL(__stdcall* SetProcessMitigationPolicy)(PROCESS_MITIGATION_POLICY MitigationPolicy, PVOID lpBuffer, SIZE_T dwLength);
typedef BOOL(__stdcall* FlushInstructionCache)(HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize);
typedef BOOL(__stdcall* GetThreadTimes)(HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
typedef HANDLE(__stdcall* OpenProcess)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId);
typedef BOOL(__stdcall* IsProcessorFeaturePresent)(DWORD ProcessorFeature);
typedef BOOL(__stdcall* GetProcessHandleCount)(HANDLE hProcess, PDWORD pdwHandleCount);
typedef BOOL(__stdcall* SetThreadIdealProcessorEx)(HANDLE hThread, PPROCESSOR_NUMBER lpIdealProcessor, PPROCESSOR_NUMBER lpPreviousIdealProcessor);
typedef BOOL(__stdcall* GetThreadIdealProcessorEx)(HANDLE hThread, PPROCESSOR_NUMBER lpIdealProcessor);
typedef void(__stdcall* GetCurrentProcessorNumberEx)(PPROCESSOR_NUMBER ProcNumber);
typedef BOOL(__stdcall* GetProcessPriorityBoost)(HANDLE hProcess, PBOOL pDisablePriorityBoost);
typedef BOOL(__stdcall* SetProcessPriorityBoost)(HANDLE hProcess, BOOL bDisablePriorityBoost);
typedef BOOL(__stdcall* GetThreadIOPendingFlag)(HANDLE hThread, PBOOL lpIOIsPending);
typedef BOOL(__stdcall* GetSystemTimes)(PFILETIME lpIdleTime, PFILETIME lpKernelTime, PFILETIME lpUserTime);
typedef BOOL(__stdcall* GetThreadInformation)(HANDLE hThread, THREAD_INFORMATION_CLASS ThreadInformationClass, LPVOID ThreadInformation, DWORD ThreadInformationSize);
typedef BOOL(__stdcall* SetThreadInformation)(HANDLE hThread, THREAD_INFORMATION_CLASS ThreadInformationClass, LPVOID ThreadInformation, DWORD ThreadInformationSize);
typedef BOOL(__stdcall* IsProcessCritical)(HANDLE hProcess, PBOOL Critical);
typedef BOOL(__stdcall* SetProtectedPolicy)(LPCGUID PolicyGuid, ULONG_PTR PolicyValue, PULONG_PTR OldPolicyValue);
typedef BOOL(__stdcall* QueryProtectedPolicy)(LPCGUID PolicyGuid, PULONG_PTR PolicyValue);
typedef DWORD(__stdcall* SetThreadIdealProcessor)(HANDLE hThread, DWORD dwIdealProcessor);
typedef BOOL(__stdcall* SetProcessInformation)(HANDLE hProcess, PROCESS_INFORMATION_CLASS ProcessInformationClass, LPVOID ProcessInformation, DWORD ProcessInformationSize);
typedef BOOL(__stdcall* GetProcessInformation)(HANDLE hProcess, PROCESS_INFORMATION_CLASS ProcessInformationClass, LPVOID ProcessInformation, DWORD ProcessInformationSize);
typedef BOOL(__stdcall* CreateProcessAsUserA)(HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* GetProcessShutdownParameters)(LPDWORD lpdwLevel, LPDWORD lpdwFlags);
typedef HRESULT(__stdcall* SetThreadDescription)(HANDLE hThread, PCWSTR lpThreadDescription);
typedef BOOL(__stdcall* GetProcessGroupAffinity)(HANDLE hProcess, PUSHORT GroupCount, PUSHORT GroupArray);
typedef BOOL(__stdcall* GetThreadGroupAffinity)(HANDLE hThread, PGROUP_AFFINITY GroupAffinity);
typedef HRESULT(__stdcall* PSRegisterPropertySchema)(PCWSTR pszPath);
typedef HRESULT(__stdcall* PSUnregisterPropertySchema)(PCWSTR pszPath);
typedef HPROPSHEETPAGE(__stdcall* CreatePropertySheetPageA)(LPCPROPSHEETPAGEA constPropSheetPagePointer);
typedef HPROPSHEETPAGE(__stdcall* CreatePropertySheetPageW)(LPCPROPSHEETPAGEW constPropSheetPagePointer);
typedef DWORD(__stdcall* K32GetModuleBaseNameA)(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
typedef DWORD(__stdcall* K32GetModuleBaseNameW)(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize);
typedef DWORD(__stdcall* K32GetModuleFileNameExA)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* K32GetModuleFileNameExW)(HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
typedef BOOL(__stdcall* K32GetModuleInformation)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb);
typedef BOOL(__stdcall* K32EmptyWorkingSet)(HANDLE hProcess);
typedef BOOL(__stdcall* K32QueryWorkingSet)(HANDLE hProcess, PVOID pv, DWORD cb);
typedef BOOL(__stdcall* K32QueryWorkingSetEx)(HANDLE hProcess, PVOID pv, DWORD cb);
typedef BOOL(__stdcall* K32InitializeProcessForWsWatch)(HANDLE hProcess);
typedef BOOL(__stdcall* K32GetWsChanges)(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb);
typedef BOOL(__stdcall* K32GetWsChangesEx)(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION_EX lpWatchInfoEx, PDWORD cb);
typedef DWORD(__stdcall* K32GetMappedFileNameW)(HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* K32GetMappedFileNameA)(HANDLE hProcess, LPVOID lpv, LPSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* K32GetDeviceDriverBaseNameA)(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* K32GetDeviceDriverBaseNameW)(LPVOID ImageBase, LPWSTR lpBaseName, DWORD nSize);
typedef DWORD(__stdcall* K32GetDeviceDriverFileNameA)(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
typedef DWORD(__stdcall* K32GetDeviceDriverFileNameW)(LPVOID ImageBase, LPWSTR lpFilename, DWORD nSize);
typedef BOOL(__stdcall* K32GetProcessMemoryInfo)(HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
typedef BOOL(__stdcall* K32GetPerformanceInfo)(PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb);
typedef BOOL(__stdcall* K32EnumPageFilesW)(PENUM_PAGE_FILE_CALLBACKW pCallBackRoutine, LPVOID pContext);
typedef BOOL(__stdcall* K32EnumPageFilesA)(PENUM_PAGE_FILE_CALLBACKA pCallBackRoutine, LPVOID pContext);
typedef DWORD(__stdcall* RasGetErrorStringA)(UINT ResourceId, LPSTR lpszString, DWORD InBufSize);
typedef DWORD(__stdcall* RasGetErrorStringW)(UINT ResourceId, LPWSTR lpszString, DWORD InBufSize);
typedef DWORD(__stdcall* RasClearLinkStatistics)(HRASCONN hRasConn, DWORD dwSubEntry);
typedef DWORD(__stdcall* RasClearConnectionStatistics)(HRASCONN hRasConn);
typedef DWORD(__stdcall* RasDeleteSubEntryA)(LPCSTR pszPhonebook, LPCSTR pszEntry, DWORD dwSubentryId);
typedef DWORD(__stdcall* RasDeleteSubEntryW)(LPCWSTR pszPhonebook, LPCWSTR pszEntry, DWORD dwSubEntryId);
typedef DWORD(__stdcall* RasGetProjectionInfoEx)(HRASCONN hrasconn, PRAS_PROJECTION_INFO pRasProjection, LPDWORD lpdwSize);
typedef DWORD(__stdcall* RasSecurityDialogSend)(HPORT hPort, PBYTE pBuffer, WORD BufferLength);
typedef DWORD(__stdcall* RasSecurityDialogReceive)(HPORT hPort, PBYTE pBuffer, PWORD pBufferLength, DWORD Timeout, HANDLE hEvent);
typedef BOOL(__stdcall* QueryThreadCycleTime)(HANDLE ThreadHandle, PULONG64 CycleTime);
typedef BOOL(__stdcall* QueryProcessCycleTime)(HANDLE ProcessHandle, PULONG64 CycleTime);
typedef BOOL(__stdcall* QueryIdleProcessorCycleTime)(PULONG BufferLength, PULONG64 ProcessorIdleCycleTime);
typedef BOOL(__stdcall* QueryIdleProcessorCycleTimeEx)(USHORT Group, PULONG BufferLength, PULONG64 ProcessorIdleCycleTime);
typedef void(__stdcall* QueryInterruptTimePrecise)(PULONGLONG lpInterruptTimePrecise);
typedef void(__stdcall* QueryUnbiasedInterruptTimePrecise)(PULONGLONG lpUnbiasedInterruptTimePrecise);
typedef void(__stdcall* QueryInterruptTime)(PULONGLONG lpInterruptTime);
typedef BOOL(__stdcall* QueryUnbiasedInterruptTime)(PULONGLONG UnbiasedTime);
typedef HRESULT(__stdcall* QueryAuxiliaryCounterFrequency)(PULONGLONG lpAuxiliaryCounterFrequency);
typedef HRESULT(__stdcall* ConvertAuxiliaryCounterToPerformanceCounter)(ULONGLONG ullAuxiliaryCounterValue, PULONGLONG lpPerformanceCounterValue, PULONGLONG lpConversionError);
typedef HRESULT(__stdcall* ConvertPerformanceCounterToAuxiliaryCounter)(ULONGLONG ullPerformanceCounterValue, PULONGLONG lpAuxiliaryCounterValue, PULONGLONG lpConversionError);
typedef void(__stdcall* DestroyResourceIndexer)(PVOID resourceIndexer);
typedef DWORD(__stdcall* RmEndSession)(DWORD dwSessionHandle);
typedef DWORD(__stdcall* RmShutdown)(DWORD dwSessionHandle, ULONG lActionFlags, RM_WRITE_STATUS_CALLBACK fnStatus);
typedef DWORD(__stdcall* RmRestart)(DWORD dwSessionHandle, DWORD dwRestartFlags, RM_WRITE_STATUS_CALLBACK fnStatus);
typedef DWORD(__stdcall* RmCancelCurrentTask)(DWORD dwSessionHandle);
typedef DWORD(__stdcall* RmGetFilterList)(DWORD dwSessionHandle, PBYTE pbFilterBuf, DWORD cbFilterBuf, LPDWORD cbFilterBufNeeded);
typedef HRESULT(__stdcall* RoSetErrorReportingFlags)(UINT32 flags);
typedef BOOL(__stdcall* RoOriginateErrorW)(HRESULT error, UINT cchMax, PCWSTR message);
typedef BOOL(__stdcall* RoOriginateError)(HRESULT error, HSTRING message);
typedef BOOL(__stdcall* RoTransformErrorW)(HRESULT oldError, HRESULT newError, UINT cchMax, PCWSTR message);
typedef BOOL(__stdcall* RoTransformError)(HRESULT oldError, HRESULT newError, HSTRING message);
typedef HRESULT(__stdcall* RoCaptureErrorContext)(HRESULT hr);
typedef void(__stdcall* RoFailFastWithErrorContext)(HRESULT hrError);
typedef RPC_STATUS(__stdcall* RpcAsyncRegisterInfo)(PRPC_ASYNC_STATE pAsync);
typedef RPC_STATUS(__stdcall* RpcAsyncInitializeHandle)(PRPC_ASYNC_STATE pAsync, unsigned int Size);
typedef RPC_STATUS(__stdcall* RpcAsyncGetCallStatus)(PRPC_ASYNC_STATE pAsync);
typedef RPC_STATUS(__stdcall* RpcAsyncAbortCall)(PRPC_ASYNC_STATE pAsync, unsigned long ExceptionCode);
typedef RPC_STATUS(__stdcall* RpcAsyncCancelCall)(PRPC_ASYNC_STATE pAsync, BOOL fAbort);
typedef RPC_STATUS(__stdcall* RpcSsContextLockExclusive)(RPC_BINDING_HANDLE ServerBindingHandle, PVOID UserContext);
typedef RPC_STATUS(__stdcall* RpcSsContextLockShared)(RPC_BINDING_HANDLE ServerBindingHandle, PVOID UserContext);
typedef RPC_STATUS(__stdcall* RpcBindingBind)(PRPC_ASYNC_STATE pAsync, RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec);
typedef RPC_STATUS(__stdcall* RpcBindingUnbind)(RPC_BINDING_HANDLE Binding);
typedef int(__stdcall* I_RpcExceptionFilter)(unsigned long ExceptionCode);
typedef RPC_STATUS(__stdcall* RpcBindingSetOption)(RPC_BINDING_HANDLE hBinding, unsigned long option, ULONG_PTR optionValue);
typedef RPC_STATUS(__stdcall* RpcBindingReset)(RPC_BINDING_HANDLE Binding);
typedef RPC_STATUS(__stdcall* RpcNetworkIsProtseqValidA)(RPC_CSTR Protseq);
typedef RPC_STATUS(__stdcall* RpcNetworkIsProtseqValidW)(RPC_WSTR Protseq);
typedef RPC_STATUS(__stdcall* RpcMgmtSetComTimeout)(RPC_BINDING_HANDLE Binding, unsigned int Timeout);
typedef RPC_STATUS(__stdcall* RpcMgmtSetCancelTimeout)(long Timeout);
typedef RPC_STATUS(__stdcall* RpcServerListen)(unsigned int MinimumCallThreads, unsigned int MaxCalls, unsigned int DontWait);
typedef RPC_STATUS(__stdcall* RpcMgmtIsServerListening)(RPC_BINDING_HANDLE Binding);
typedef RPC_STATUS(__stdcall* RpcMgmtStopServerListening)(RPC_BINDING_HANDLE Binding);
typedef RPC_STATUS(__stdcall* RpcMgmtSetServerStackSize)(unsigned long ThreadStackSize);
typedef RPC_STATUS(__stdcall* RpcEpResolveBinding)(RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec);
typedef RPC_STATUS(__stdcall* RpcImpersonateClient)(RPC_BINDING_HANDLE BindingHandle);
typedef RPC_STATUS(__stdcall* RpcRevertToSelfEx)(RPC_BINDING_HANDLE BindingHandle);
typedef RPC_STATUS(__stdcall* RpcImpersonateClientContainer)(RPC_BINDING_HANDLE BindingHandle);
typedef RPC_STATUS(__stdcall* RpcBindingSetAuthInfoA)(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, unsigned long AuthnLevel, unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc);
typedef RPC_STATUS(__stdcall* RpcBindingSetAuthInfoW)(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, unsigned long AuthnLevel, unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc);
typedef RPC_STATUS(__stdcall* RpcServerCompleteSecurityCallback)(RPC_BINDING_HANDLE BindingHandle, RPC_STATUS Status);
typedef void(__stdcall* RpcRaiseException)(RPC_STATUS exception);
typedef RPC_STATUS(__stdcall* RpcServerTestCancel)(RPC_BINDING_HANDLE BindingHandle);
typedef RPC_STATUS(__stdcall* DceErrorInqTextA)(RPC_STATUS RpcStatus, RPC_CSTR ErrorText);
typedef RPC_STATUS(__stdcall* DceErrorInqTextW)(RPC_STATUS RpcStatus, RPC_WSTR ErrorText);
typedef RPC_STATUS(__stdcall* RpcMgmtSetAuthorizationFn)(RPC_MGMT_AUTHORIZATION_FN AuthorizationFn);
typedef int(__stdcall* RpcExceptionFilter)(unsigned long ExceptionCode);
typedef RPC_STATUS(__stdcall* RpcServerInterfaceGroupClose)(RPC_INTERFACE_GROUP IfGroup);
typedef RPC_STATUS(__stdcall* RpcServerInterfaceGroupActivate)(RPC_INTERFACE_GROUP IfGroup);
typedef RPC_STATUS(__stdcall* RpcServerInterfaceGroupDeactivate)(RPC_INTERFACE_GROUP IfGroup, unsigned long ForceDeactivation);
typedef NDR_SCONTEXT(__stdcall* NdrContextHandleInitialize)(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat);
typedef unsigned long(__stdcall* NdrContextHandleMemorySize)(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat);
typedef void(__stdcall* NdrConvert)(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat);
typedef CLIENT_CALL_RETURN(__stdcall* NdrClientCall2)(PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat);
typedef CLIENT_CALL_RETURN(__stdcall* NdrClientCall)(PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat);
typedef CLIENT_CALL_RETURN(__stdcall* NdrAsyncClientCall)(PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat);
typedef CLIENT_CALL_RETURN(__stdcall* NdrDcomAsyncClientCall)(PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat);
typedef void(__stdcall* NdrAsyncServerCall)(PRPC_MESSAGE pRpcMsg);
typedef void(__stdcall* NdrServerCall2)(PRPC_MESSAGE pRpcMsg);
typedef {'name': 'RpcSsAllocate', 'type': 'void'}(__stdcall* RpcSsAllocate)(size_t Size);
typedef void(__stdcall* RpcSsSetThreadHandle)(RPC_SS_THREAD_HANDLE Id);
typedef RPC_STATUS(__stdcall* RpcSmSetThreadHandle)(RPC_SS_THREAD_HANDLE Id);
typedef {'name': 'NdrOleAllocate', 'type': 'void'}(__stdcall* NdrOleAllocate)(size_t Size);
typedef void(__stdcall* Ndr64AsyncServerCallAll)(PRPC_MESSAGE pRpcMsg);
typedef void(__stdcall* NdrServerCallAll)(PRPC_MESSAGE pRpcMsg);
typedef RPC_STATUS(__stdcall* RpcNsGroupDeleteA)(unsigned long GroupNameSyntax, RPC_CSTR GroupName);
typedef RPC_STATUS(__stdcall* RpcNsGroupMbrAddA)(unsigned long GroupNameSyntax, RPC_CSTR GroupName, unsigned long MemberNameSyntax, RPC_CSTR MemberName);
typedef RPC_STATUS(__stdcall* RpcNsGroupMbrRemoveA)(unsigned long GroupNameSyntax, RPC_CSTR GroupName, unsigned long MemberNameSyntax, RPC_CSTR MemberName);
typedef RPC_STATUS(__stdcall* RpcNsGroupDeleteW)(unsigned long GroupNameSyntax, RPC_WSTR GroupName);
typedef RPC_STATUS(__stdcall* RpcNsGroupMbrAddW)(unsigned long GroupNameSyntax, RPC_WSTR GroupName, unsigned long MemberNameSyntax, RPC_WSTR MemberName);
typedef RPC_STATUS(__stdcall* RpcNsGroupMbrRemoveW)(unsigned long GroupNameSyntax, RPC_WSTR GroupName, unsigned long MemberNameSyntax, RPC_WSTR MemberName);
typedef RPC_STATUS(__stdcall* RpcNsProfileDeleteA)(unsigned long ProfileNameSyntax, RPC_CSTR ProfileName);
typedef RPC_STATUS(__stdcall* RpcNsProfileDeleteW)(unsigned long ProfileNameSyntax, RPC_WSTR ProfileName);
typedef RPC_STATUS(__stdcall* RpcNsMgmtEntryCreateA)(unsigned long EntryNameSyntax, RPC_CSTR EntryName);
typedef RPC_STATUS(__stdcall* RpcNsMgmtEntryDeleteA)(unsigned long EntryNameSyntax, RPC_CSTR EntryName);
typedef RPC_STATUS(__stdcall* RpcNsMgmtHandleSetExpAge)(RPC_NS_HANDLE NsHandle, unsigned long ExpirationAge);
typedef RPC_STATUS(__stdcall* RpcNsMgmtSetExpAge)(unsigned long ExpirationAge);
typedef RPC_STATUS(__stdcall* RpcNsMgmtEntryCreateW)(unsigned long EntryNameSyntax, RPC_WSTR EntryName);
typedef RPC_STATUS(__stdcall* RpcNsMgmtEntryDeleteW)(unsigned long EntryNameSyntax, RPC_WSTR EntryName);
typedef HRESULT(__stdcall* NdrProxyErrorHandler)(DWORD dwExceptionCode);
typedef DWORD(__stdcall* RtmRegisterEntity)(PRTM_ENTITY_INFO RtmEntityInfo, PRTM_ENTITY_EXPORT_METHODS ExportMethods, RTM_EVENT_CALLBACK EventCallback, BOOL ReserveOpaquePointer, PRTM_REGN_PROFILE RtmRegProfile, PRTM_ENTITY_HANDLE RtmRegHandle);
typedef DWORD(__stdcall* RtmDeregisterEntity)(RTM_ENTITY_HANDLE RtmRegHandle);
typedef DWORD(__stdcall* RtmGetRegisteredEntities)(RTM_ENTITY_HANDLE RtmRegHandle, PUINT NumEntities, PRTM_ENTITY_HANDLE EntityHandles, PRTM_ENTITY_INFO EntityInfos);
typedef DWORD(__stdcall* RtmReleaseEntities)(RTM_ENTITY_HANDLE RtmRegHandle, UINT NumEntities, PRTM_ENTITY_HANDLE EntityHandles);
typedef DWORD(__stdcall* RtmLockDestination)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_DEST_HANDLE DestHandle, BOOL Exclusive, BOOL LockDest);
typedef DWORD(__stdcall* RtmGetEntityMethods)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENTITY_HANDLE EntityHandle, PUINT NumMethods, PRTM_ENTITY_EXPORT_METHOD ExptMethods);
typedef DWORD(__stdcall* RtmInvokeMethod)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENTITY_HANDLE EntityHandle, PRTM_ENTITY_METHOD_INPUT Input, PUINT OutputSize, PRTM_ENTITY_METHOD_OUTPUT Output);
typedef DWORD(__stdcall* RtmBlockMethods)(RTM_ENTITY_HANDLE RtmRegHandle, HANDLE TargetHandle, UCHAR TargetType, DWORD BlockingFlag);
typedef DWORD(__stdcall* RtmGetEntityInfo)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENTITY_HANDLE EntityHandle, PRTM_ENTITY_INFO EntityInfo);
typedef DWORD(__stdcall* RtmGetDestInfo)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_DEST_HANDLE DestHandle, ULONG ProtocolId, RTM_VIEW_SET TargetViews, PRTM_DEST_INFO DestInfo);
typedef DWORD(__stdcall* RtmGetRouteInfo)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_HANDLE RouteHandle, PRTM_ROUTE_INFO RouteInfo, PRTM_NET_ADDRESS DestAddress);
typedef DWORD(__stdcall* RtmGetNextHopInfo)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NEXTHOP_HANDLE NextHopHandle, PRTM_NEXTHOP_INFO NextHopInfo);
typedef DWORD(__stdcall* RtmReleaseEntityInfo)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_ENTITY_INFO EntityInfo);
typedef DWORD(__stdcall* RtmReleaseDestInfo)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_DEST_INFO DestInfo);
typedef DWORD(__stdcall* RtmReleaseRouteInfo)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_ROUTE_INFO RouteInfo);
typedef DWORD(__stdcall* RtmReleaseNextHopInfo)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_NEXTHOP_INFO NextHopInfo);
typedef DWORD(__stdcall* RtmAddRouteToDest)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_ROUTE_HANDLE RouteHandle, PRTM_NET_ADDRESS DestAddress, PRTM_ROUTE_INFO RouteInfo, ULONG TimeToLive, RTM_ROUTE_LIST_HANDLE RouteListHandle, RTM_NOTIFY_FLAGS NotifyType, RTM_NOTIFY_HANDLE NotifyHandle, PRTM_ROUTE_CHANGE_FLAGS ChangeFlags);
typedef DWORD(__stdcall* RtmDeleteRouteToDest)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_HANDLE RouteHandle, PRTM_ROUTE_CHANGE_FLAGS ChangeFlags);
typedef DWORD(__stdcall* RtmHoldDestination)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_DEST_HANDLE DestHandle, RTM_VIEW_SET TargetViews, ULONG HoldTime);
typedef DWORD(__stdcall* RtmUpdateAndUnlockRoute)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_HANDLE RouteHandle, ULONG TimeToLive, RTM_ROUTE_LIST_HANDLE RouteListHandle, RTM_NOTIFY_FLAGS NotifyType, RTM_NOTIFY_HANDLE NotifyHandle, PRTM_ROUTE_CHANGE_FLAGS ChangeFlags);
typedef DWORD(__stdcall* RtmGetExactMatchDestination)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_NET_ADDRESS DestAddress, ULONG ProtocolId, RTM_VIEW_SET TargetViews, PRTM_DEST_INFO DestInfo);
typedef DWORD(__stdcall* RtmGetMostSpecificDestination)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_NET_ADDRESS DestAddress, ULONG ProtocolId, RTM_VIEW_SET TargetViews, PRTM_DEST_INFO DestInfo);
typedef DWORD(__stdcall* RtmGetLessSpecificDestination)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_DEST_HANDLE DestHandle, ULONG ProtocolId, RTM_VIEW_SET TargetViews, PRTM_DEST_INFO DestInfo);
typedef DWORD(__stdcall* RtmGetExactMatchRoute)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_NET_ADDRESS DestAddress, RTM_MATCH_FLAGS MatchingFlags, PRTM_ROUTE_INFO RouteInfo, ULONG InterfaceIndex, RTM_VIEW_SET TargetViews, PRTM_ROUTE_HANDLE RouteHandle);
typedef DWORD(__stdcall* RtmIsBestRoute)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_HANDLE RouteHandle, PRTM_VIEW_SET BestInViews);
typedef DWORD(__stdcall* RtmAddNextHop)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_NEXTHOP_INFO NextHopInfo, PRTM_NEXTHOP_HANDLE NextHopHandle, PRTM_NEXTHOP_CHANGE_FLAGS ChangeFlags);
typedef DWORD(__stdcall* RtmDeleteNextHop)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NEXTHOP_HANDLE NextHopHandle, PRTM_NEXTHOP_INFO NextHopInfo);
typedef DWORD(__stdcall* RtmCreateDestEnum)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_VIEW_SET TargetViews, RTM_ENUM_FLAGS EnumFlags, PRTM_NET_ADDRESS NetAddress, ULONG ProtocolId, PRTM_ENUM_HANDLE RtmEnumHandle);
typedef DWORD(__stdcall* RtmGetEnumDests)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_HANDLE EnumHandle, PUINT NumDests, PRTM_DEST_INFO DestInfos);
typedef DWORD(__stdcall* RtmReleaseDests)(RTM_ENTITY_HANDLE RtmRegHandle, UINT NumDests, PRTM_DEST_INFO DestInfos);
typedef DWORD(__stdcall* RtmCreateRouteEnum)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_DEST_HANDLE DestHandle, RTM_VIEW_SET TargetViews, RTM_ENUM_FLAGS EnumFlags, PRTM_NET_ADDRESS StartDest, RTM_MATCH_FLAGS MatchingFlags, PRTM_ROUTE_INFO CriteriaRoute, ULONG CriteriaInterface, PRTM_ENUM_HANDLE RtmEnumHandle);
typedef DWORD(__stdcall* RtmGetEnumRoutes)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_HANDLE EnumHandle, PUINT NumRoutes, PRTM_ROUTE_HANDLE RouteHandles);
typedef DWORD(__stdcall* RtmReleaseRoutes)(RTM_ENTITY_HANDLE RtmRegHandle, UINT NumRoutes, PRTM_ROUTE_HANDLE RouteHandles);
typedef DWORD(__stdcall* RtmCreateNextHopEnum)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_FLAGS EnumFlags, PRTM_NET_ADDRESS NetAddress, PRTM_ENUM_HANDLE RtmEnumHandle);
typedef DWORD(__stdcall* RtmGetEnumNextHops)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_HANDLE EnumHandle, PUINT NumNextHops, PRTM_NEXTHOP_HANDLE NextHopHandles);
typedef DWORD(__stdcall* RtmReleaseNextHops)(RTM_ENTITY_HANDLE RtmRegHandle, UINT NumNextHops, PRTM_NEXTHOP_HANDLE NextHopHandles);
typedef DWORD(__stdcall* RtmDeleteEnumHandle)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_HANDLE EnumHandle);
typedef DWORD(__stdcall* RtmRegisterForChangeNotification)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_VIEW_SET TargetViews, RTM_NOTIFY_FLAGS NotifyFlags, PVOID NotifyContext, PRTM_NOTIFY_HANDLE NotifyHandle);
typedef DWORD(__stdcall* RtmGetChangedDests)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, PUINT NumDests, PRTM_DEST_INFO ChangedDests);
typedef DWORD(__stdcall* RtmReleaseChangedDests)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, UINT NumDests, PRTM_DEST_INFO ChangedDests);
typedef DWORD(__stdcall* RtmIgnoreChangedDests)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, UINT NumDests, PRTM_DEST_HANDLE ChangedDests);
typedef DWORD(__stdcall* RtmGetChangeStatus)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, RTM_DEST_HANDLE DestHandle, PBOOL ChangeStatus);
typedef DWORD(__stdcall* RtmMarkDestForChangeNotification)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, RTM_DEST_HANDLE DestHandle, BOOL MarkDest);
typedef DWORD(__stdcall* RtmIsMarkedForChangeNotification)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle, RTM_DEST_HANDLE DestHandle, PBOOL DestMarked);
typedef DWORD(__stdcall* RtmDeregisterFromChangeNotification)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_NOTIFY_HANDLE NotifyHandle);
typedef DWORD(__stdcall* RtmCreateRouteList)(RTM_ENTITY_HANDLE RtmRegHandle, PRTM_ROUTE_LIST_HANDLE RouteListHandle);
typedef DWORD(__stdcall* RtmInsertInRouteList)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_LIST_HANDLE RouteListHandle, UINT NumRoutes, PRTM_ROUTE_HANDLE RouteHandles);
typedef DWORD(__stdcall* RtmCreateRouteListEnum)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_LIST_HANDLE RouteListHandle, PRTM_ENUM_HANDLE RtmEnumHandle);
typedef DWORD(__stdcall* RtmGetListEnumRoutes)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ENUM_HANDLE EnumHandle, PUINT NumRoutes, PRTM_ROUTE_HANDLE RouteHandles);
typedef DWORD(__stdcall* RtmDeleteRouteList)(RTM_ENTITY_HANDLE RtmRegHandle, RTM_ROUTE_LIST_HANDLE RouteListHandle);
typedef void(__stdcall* SendSAS)(BOOL AsUser);
typedef BOOL(__stdcall* SslEmptyCacheA)(LPSTR pszTargetName, DWORD dwFlags);
typedef BOOL(__stdcall* SslEmptyCacheW)(LPWSTR pszTargetName, DWORD dwFlags);
typedef void(__stdcall* SslFreeCertificate)(PX509Certificate pCertificate);
typedef LRESULT(__stdcall* ScreenSaverProc)(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* DefScreenSaverProc)(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* ScreenSaverConfigureDialog)(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* RegisterDialogClasses)(HANDLE hInst);
typedef BOOL(__stdcall* GetAppContainerNamedObjectPath)(HANDLE Token, PSID AppContainerSid, ULONG ObjectPathLength, LPWSTR ObjectPath, PULONG ReturnLength);
typedef BOOL(__stdcall* AccessCheck)(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus);
typedef BOOL(__stdcall* AccessCheckByType)(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus);
typedef BOOL(__stdcall* AccessCheckByTypeResultList)(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList);
typedef BOOL(__stdcall* AddAccessAllowedAce)(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid);
typedef BOOL(__stdcall* AddAccessAllowedAceEx)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
typedef BOOL(__stdcall* AddAccessDeniedAce)(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid);
typedef BOOL(__stdcall* AddAccessDeniedAceEx)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
typedef BOOL(__stdcall* AddAce)(PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength);
typedef BOOL(__stdcall* AddAuditAccessAce)(PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure);
typedef BOOL(__stdcall* AddAuditAccessAceEx)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure);
typedef BOOL(__stdcall* AddMandatoryAce)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD MandatoryPolicy, PSID pLabelSid);
typedef BOOL(__stdcall* AddResourceAttributeAce)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid, PCLAIM_SECURITY_ATTRIBUTES_INFORMATION pAttributeInfo, PDWORD pReturnLength);
typedef BOOL(__stdcall* AddScopedPolicyIDAce)(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
typedef BOOL(__stdcall* AdjustTokenGroups)(HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength);
typedef BOOL(__stdcall* AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
typedef BOOL(__stdcall* AllocateLocallyUniqueId)(PLUID Luid);
typedef BOOL(__stdcall* AreAllAccessesGranted)(DWORD GrantedAccess, DWORD DesiredAccess);
typedef BOOL(__stdcall* AreAnyAccessesGranted)(DWORD GrantedAccess, DWORD DesiredAccess);
typedef BOOL(__stdcall* CheckTokenMembership)(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember);
typedef BOOL(__stdcall* CheckTokenCapability)(HANDLE TokenHandle, PSID CapabilitySidToCheck, PBOOL HasCapability);
typedef BOOL(__stdcall* CheckTokenMembershipEx)(HANDLE TokenHandle, PSID SidToCheck, DWORD Flags, PBOOL IsMember);
typedef BOOL(__stdcall* CopySid)(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid);
typedef BOOL(__stdcall* CreateRestrictedToken)(HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle);
typedef BOOL(__stdcall* DeleteAce)(PACL pAcl, DWORD dwAceIndex);
typedef BOOL(__stdcall* DuplicateToken)(HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle);
typedef BOOL(__stdcall* DuplicateTokenEx)(HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken);
typedef BOOL(__stdcall* EqualPrefixSid)(PSID pSid1, PSID pSid2);
typedef BOOL(__stdcall* EqualSid)(PSID pSid1, PSID pSid2);
typedef PVOID(__stdcall* FreeSid)(PSID pSid);
typedef BOOL(__stdcall* GetAclInformation)(PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass);
typedef BOOL(__stdcall* GetKernelObjectSecurity)(HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef DWORD(__stdcall* GetLengthSid)(PSID pSid);
typedef BOOL(__stdcall* GetPrivateObjectSecurity)(PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength);
typedef BOOL(__stdcall* GetSecurityDescriptorControl)(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision);
typedef DWORD(__stdcall* GetSecurityDescriptorLength)(PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef DWORD(__stdcall* GetSecurityDescriptorRMControl)(PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl);
typedef PSID_IDENTIFIER_AUTHORITY(__stdcall* GetSidIdentifierAuthority)(PSID pSid);
typedef DWORD(__stdcall* GetSidLengthRequired)(UCHAR nSubAuthorityCount);
typedef PDWORD(__stdcall* GetSidSubAuthority)(PSID pSid, DWORD nSubAuthority);
typedef PUCHAR(__stdcall* GetSidSubAuthorityCount)(PSID pSid);
typedef BOOL(__stdcall* GetTokenInformation)(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength);
typedef BOOL(__stdcall* ImpersonateAnonymousToken)(HANDLE ThreadHandle);
typedef BOOL(__stdcall* ImpersonateLoggedOnUser)(HANDLE hToken);
typedef BOOL(__stdcall* ImpersonateSelf)(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
typedef BOOL(__stdcall* InitializeAcl)(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision);
typedef BOOL(__stdcall* InitializeSecurityDescriptor)(PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision);
typedef BOOL(__stdcall* InitializeSid)(PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount);
typedef BOOL(__stdcall* IsTokenRestricted)(HANDLE TokenHandle);
typedef BOOL(__stdcall* IsValidAcl)(PACL pAcl);
typedef BOOL(__stdcall* IsValidSecurityDescriptor)(PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef BOOL(__stdcall* IsValidSid)(PSID pSid);
typedef BOOL(__stdcall* IsWellKnownSid)(PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType);
typedef BOOL(__stdcall* MakeAbsoluteSD)(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize);
typedef BOOL(__stdcall* MakeSelfRelativeSD)(PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength);
typedef void(__stdcall* MapGenericMask)(PDWORD AccessMask, PGENERIC_MAPPING GenericMapping);
typedef BOOL(__stdcall* PrivilegeCheck)(HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult);
typedef void(__stdcall* QuerySecurityAccessMask)(SECURITY_INFORMATION SecurityInformation, LPDWORD DesiredAccess);
typedef BOOL(__stdcall* SetAclInformation)(PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass);
typedef BOOL(__stdcall* SetKernelObjectSecurity)(HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor);
typedef void(__stdcall* SetSecurityAccessMask)(SECURITY_INFORMATION SecurityInformation, LPDWORD DesiredAccess);
typedef BOOL(__stdcall* SetSecurityDescriptorControl)(PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);
typedef BOOL(__stdcall* SetSecurityDescriptorDacl)(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted);
typedef BOOL(__stdcall* SetSecurityDescriptorGroup)(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted);
typedef BOOL(__stdcall* SetSecurityDescriptorOwner)(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted);
typedef DWORD(__stdcall* SetSecurityDescriptorRMControl)(PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl);
typedef BOOL(__stdcall* SetSecurityDescriptorSacl)(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted);
typedef BOOL(__stdcall* SetTokenInformation)(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength);
typedef LONG(__stdcall* CveEventWrite)(PCWSTR CveId, PCWSTR AdditionalDetails);
typedef BOOL(__stdcall* IsDestinationReachableA)(LPCSTR lpszDestination, LPQOCINFO lpQOCInfo);
typedef BOOL(__stdcall* IsDestinationReachableW)(LPCWSTR lpszDestination, LPQOCINFO lpQOCInfo);
typedef BOOL(__stdcall* IsNetworkAlive)(LPDWORD lpdwFlags);
typedef BOOL(__stdcall* SetupGetInfInformationA)(LPCVOID InfSpec, DWORD SearchControl, PSP_INF_INFORMATION ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetInfInformationW)(LPCVOID InfSpec, DWORD SearchControl, PSP_INF_INFORMATION ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryInfFileInformationA)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryInfFileInformationW)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryInfOriginalFileInformationA)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PSP_ALTPLATFORM_INFO AlternatePlatformInfo, PSP_ORIGINAL_FILE_INFO_A OriginalFileInfo);
typedef BOOL(__stdcall* SetupQueryInfOriginalFileInformationW)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PSP_ALTPLATFORM_INFO AlternatePlatformInfo, PSP_ORIGINAL_FILE_INFO_W OriginalFileInfo);
typedef BOOL(__stdcall* SetupQueryInfVersionInformationA)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PCSTR Key, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryInfVersionInformationW)(PSP_INF_INFORMATION InfInformation, UINT InfIndex, PCWSTR Key, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetInfFileListA)(PCSTR DirectoryPath, DWORD InfStyle, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetInfFileListW)(PCWSTR DirectoryPath, DWORD InfStyle, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef HINF(__stdcall* SetupOpenInfFileW)(PCWSTR FileName, PCWSTR InfClass, DWORD InfStyle, PUINT ErrorLine);
typedef HINF(__stdcall* SetupOpenInfFileA)(PCSTR FileName, PCSTR InfClass, DWORD InfStyle, PUINT ErrorLine);
typedef BOOL(__stdcall* SetupOpenAppendInfFileW)(PCWSTR FileName, HINF InfHandle, PUINT ErrorLine);
typedef BOOL(__stdcall* SetupOpenAppendInfFileA)(PCSTR FileName, HINF InfHandle, PUINT ErrorLine);
typedef void(__stdcall* SetupCloseInfFile)(HINF InfHandle);
typedef BOOL(__stdcall* SetupFindFirstLineA)(HINF InfHandle, PCSTR Section, PCSTR Key, PINFCONTEXT Context);
typedef BOOL(__stdcall* SetupFindFirstLineW)(HINF InfHandle, PCWSTR Section, PCWSTR Key, PINFCONTEXT Context);
typedef BOOL(__stdcall* SetupFindNextLine)(PINFCONTEXT ContextIn, PINFCONTEXT ContextOut);
typedef BOOL(__stdcall* SetupFindNextMatchLineA)(PINFCONTEXT ContextIn, PCSTR Key, PINFCONTEXT ContextOut);
typedef BOOL(__stdcall* SetupFindNextMatchLineW)(PINFCONTEXT ContextIn, PCWSTR Key, PINFCONTEXT ContextOut);
typedef BOOL(__stdcall* SetupGetLineByIndexA)(HINF InfHandle, PCSTR Section, DWORD Index, PINFCONTEXT Context);
typedef BOOL(__stdcall* SetupGetLineByIndexW)(HINF InfHandle, PCWSTR Section, DWORD Index, PINFCONTEXT Context);
typedef LONG(__stdcall* SetupGetLineCountA)(HINF InfHandle, PCSTR Section);
typedef LONG(__stdcall* SetupGetLineCountW)(HINF InfHandle, PCWSTR Section);
typedef BOOL(__stdcall* SetupGetLineTextA)(PINFCONTEXT Context, HINF InfHandle, PCSTR Section, PCSTR Key, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetLineTextW)(PINFCONTEXT Context, HINF InfHandle, PCWSTR Section, PCWSTR Key, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef DWORD(__stdcall* SetupGetFieldCount)(PINFCONTEXT Context);
typedef BOOL(__stdcall* SetupGetStringFieldA)(PINFCONTEXT Context, DWORD FieldIndex, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetStringFieldW)(PINFCONTEXT Context, DWORD FieldIndex, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetIntField)(PINFCONTEXT Context, DWORD FieldIndex, PINT IntegerValue);
typedef BOOL(__stdcall* SetupGetMultiSzFieldA)(PINFCONTEXT Context, DWORD FieldIndex, PSTR ReturnBuffer, DWORD ReturnBufferSize, LPDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetMultiSzFieldW)(PINFCONTEXT Context, DWORD FieldIndex, PWSTR ReturnBuffer, DWORD ReturnBufferSize, LPDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetBinaryField)(PINFCONTEXT Context, DWORD FieldIndex, PBYTE ReturnBuffer, DWORD ReturnBufferSize, LPDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetFileCompressionInfoExA)(PCSTR SourceFileName, PSTR ActualSourceFileNameBuffer, DWORD ActualSourceFileNameBufferLen, PDWORD RequiredBufferLen, PDWORD SourceFileSize, PDWORD TargetFileSize, PUINT CompressionType);
typedef BOOL(__stdcall* SetupGetFileCompressionInfoExW)(PCWSTR SourceFileName, PWSTR ActualSourceFileNameBuffer, DWORD ActualSourceFileNameBufferLen, PDWORD RequiredBufferLen, PDWORD SourceFileSize, PDWORD TargetFileSize, PUINT CompressionType);
typedef DWORD(__stdcall* SetupDecompressOrCopyFileA)(PCSTR SourceFileName, PCSTR TargetFileName, PUINT CompressionType);
typedef DWORD(__stdcall* SetupDecompressOrCopyFileW)(PCWSTR SourceFileName, PCWSTR TargetFileName, PUINT CompressionType);
typedef BOOL(__stdcall* SetupGetSourceFileLocationA)(HINF InfHandle, PINFCONTEXT InfContext, PCSTR FileName, PUINT SourceId, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetSourceFileLocationW)(HINF InfHandle, PINFCONTEXT InfContext, PCWSTR FileName, PUINT SourceId, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetSourceFileSizeA)(HINF InfHandle, PINFCONTEXT InfContext, PCSTR FileName, PCSTR Section, PDWORD FileSize, UINT RoundingFactor);
typedef BOOL(__stdcall* SetupGetSourceFileSizeW)(HINF InfHandle, PINFCONTEXT InfContext, PCWSTR FileName, PCWSTR Section, PDWORD FileSize, UINT RoundingFactor);
typedef BOOL(__stdcall* SetupGetTargetPathA)(HINF InfHandle, PINFCONTEXT InfContext, PCSTR Section, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetTargetPathW)(HINF InfHandle, PINFCONTEXT InfContext, PCWSTR Section, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupAddToSourceListA)(DWORD Flags, PCSTR Source);
typedef BOOL(__stdcall* SetupAddToSourceListW)(DWORD Flags, PCWSTR Source);
typedef BOOL(__stdcall* SetupRemoveFromSourceListA)(DWORD Flags, PCSTR Source);
typedef BOOL(__stdcall* SetupRemoveFromSourceListW)(DWORD Flags, PCWSTR Source);
typedef UINT(__stdcall* SetupPromptForDiskA)(HWND hwndParent, PCSTR DialogTitle, PCSTR DiskName, PCSTR PathToSource, PCSTR FileSought, PCSTR TagFile, DWORD DiskPromptStyle, PSTR PathBuffer, DWORD PathBufferSize, PDWORD PathRequiredSize);
typedef UINT(__stdcall* SetupPromptForDiskW)(HWND hwndParent, PCWSTR DialogTitle, PCWSTR DiskName, PCWSTR PathToSource, PCWSTR FileSought, PCWSTR TagFile, DWORD DiskPromptStyle, PWSTR PathBuffer, DWORD PathBufferSize, PDWORD PathRequiredSize);
typedef UINT(__stdcall* SetupCopyErrorA)(HWND hwndParent, PCSTR DialogTitle, PCSTR DiskName, PCSTR PathToSource, PCSTR SourceFile, PCSTR TargetPathFile, UINT Win32ErrorCode, DWORD Style, PSTR PathBuffer, DWORD PathBufferSize, PDWORD PathRequiredSize);
typedef UINT(__stdcall* SetupCopyErrorW)(HWND hwndParent, PCWSTR DialogTitle, PCWSTR DiskName, PCWSTR PathToSource, PCWSTR SourceFile, PCWSTR TargetPathFile, UINT Win32ErrorCode, DWORD Style, PWSTR PathBuffer, DWORD PathBufferSize, PDWORD PathRequiredSize);
typedef UINT(__stdcall* SetupRenameErrorA)(HWND hwndParent, PCSTR DialogTitle, PCSTR SourceFile, PCSTR TargetFile, UINT Win32ErrorCode, DWORD Style);
typedef UINT(__stdcall* SetupRenameErrorW)(HWND hwndParent, PCWSTR DialogTitle, PCWSTR SourceFile, PCWSTR TargetFile, UINT Win32ErrorCode, DWORD Style);
typedef UINT(__stdcall* SetupDeleteErrorA)(HWND hwndParent, PCSTR DialogTitle, PCSTR File, UINT Win32ErrorCode, DWORD Style);
typedef UINT(__stdcall* SetupDeleteErrorW)(HWND hwndParent, PCWSTR DialogTitle, PCWSTR File, UINT Win32ErrorCode, DWORD Style);
typedef UINT(__stdcall* SetupBackupErrorA)(HWND hwndParent, PCSTR DialogTitle, PCSTR SourceFile, PCSTR TargetFile, UINT Win32ErrorCode, DWORD Style);
typedef UINT(__stdcall* SetupBackupErrorW)(HWND hwndParent, PCWSTR DialogTitle, PCWSTR SourceFile, PCWSTR TargetFile, UINT Win32ErrorCode, DWORD Style);
typedef BOOL(__stdcall* SetupSetDirectoryIdA)(HINF InfHandle, DWORD Id, PCSTR Directory);
typedef BOOL(__stdcall* SetupSetDirectoryIdW)(HINF InfHandle, DWORD Id, PCWSTR Directory);
typedef BOOL(__stdcall* SetupSetDirectoryIdExA)(HINF InfHandle, DWORD Id, PCSTR Directory, DWORD Flags, DWORD Reserved1, PVOID Reserved2);
typedef BOOL(__stdcall* SetupSetDirectoryIdExW)(HINF InfHandle, DWORD Id, PCWSTR Directory, DWORD Flags, DWORD Reserved1, PVOID Reserved2);
typedef BOOL(__stdcall* SetupGetSourceInfoA)(HINF InfHandle, UINT SourceId, UINT InfoDesired, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupGetSourceInfoW)(HINF InfHandle, UINT SourceId, UINT InfoDesired, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupInstallFileA)(HINF InfHandle, PINFCONTEXT InfContext, PCSTR SourceFile, PCSTR SourcePathRoot, PCSTR DestinationName, DWORD CopyStyle, PSP_FILE_CALLBACK_A CopyMsgHandler, PVOID Context);
typedef BOOL(__stdcall* SetupInstallFileW)(HINF InfHandle, PINFCONTEXT InfContext, PCWSTR SourceFile, PCWSTR SourcePathRoot, PCWSTR DestinationName, DWORD CopyStyle, PSP_FILE_CALLBACK_W CopyMsgHandler, PVOID Context);
typedef BOOL(__stdcall* SetupInstallFileExA)(HINF InfHandle, PINFCONTEXT InfContext, PCSTR SourceFile, PCSTR SourcePathRoot, PCSTR DestinationName, DWORD CopyStyle, PSP_FILE_CALLBACK_A CopyMsgHandler, PVOID Context, PBOOL FileWasInUse);
typedef BOOL(__stdcall* SetupInstallFileExW)(HINF InfHandle, PINFCONTEXT InfContext, PCWSTR SourceFile, PCWSTR SourcePathRoot, PCWSTR DestinationName, DWORD CopyStyle, PSP_FILE_CALLBACK_W CopyMsgHandler, PVOID Context, PBOOL FileWasInUse);
typedef BOOL(__stdcall* SetupCloseFileQueue)(HSPFILEQ QueueHandle);
typedef BOOL(__stdcall* SetupSetFileQueueAlternatePlatformA)(HSPFILEQ QueueHandle, PSP_ALTPLATFORM_INFO AlternatePlatformInfo, PCSTR AlternateDefaultCatalogFile);
typedef BOOL(__stdcall* SetupSetFileQueueAlternatePlatformW)(HSPFILEQ QueueHandle, PSP_ALTPLATFORM_INFO AlternatePlatformInfo, PCWSTR AlternateDefaultCatalogFile);
typedef BOOL(__stdcall* SetupSetPlatformPathOverrideA)(PCSTR Override);
typedef BOOL(__stdcall* SetupSetPlatformPathOverrideW)(PCWSTR Override);
typedef BOOL(__stdcall* SetupQueueCopyA)(HSPFILEQ QueueHandle, PCSTR SourceRootPath, PCSTR SourcePath, PCSTR SourceFilename, PCSTR SourceDescription, PCSTR SourceTagfile, PCSTR TargetDirectory, PCSTR TargetFilename, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueCopyW)(HSPFILEQ QueueHandle, PCWSTR SourceRootPath, PCWSTR SourcePath, PCWSTR SourceFilename, PCWSTR SourceDescription, PCWSTR SourceTagfile, PCWSTR TargetDirectory, PCWSTR TargetFilename, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueCopyIndirectA)(PSP_FILE_COPY_PARAMS_A CopyParams);
typedef BOOL(__stdcall* SetupQueueCopyIndirectW)(PSP_FILE_COPY_PARAMS_W CopyParams);
typedef BOOL(__stdcall* SetupQueueDefaultCopyA)(HSPFILEQ QueueHandle, HINF InfHandle, PCSTR SourceRootPath, PCSTR SourceFilename, PCSTR TargetFilename, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueDefaultCopyW)(HSPFILEQ QueueHandle, HINF InfHandle, PCWSTR SourceRootPath, PCWSTR SourceFilename, PCWSTR TargetFilename, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueCopySectionA)(HSPFILEQ QueueHandle, PCSTR SourceRootPath, HINF InfHandle, HINF ListInfHandle, PCSTR Section, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueCopySectionW)(HSPFILEQ QueueHandle, PCWSTR SourceRootPath, HINF InfHandle, HINF ListInfHandle, PCWSTR Section, DWORD CopyStyle);
typedef BOOL(__stdcall* SetupQueueDeleteA)(HSPFILEQ QueueHandle, PCSTR PathPart1, PCSTR PathPart2);
typedef BOOL(__stdcall* SetupQueueDeleteW)(HSPFILEQ QueueHandle, PCWSTR PathPart1, PCWSTR PathPart2);
typedef BOOL(__stdcall* SetupQueueDeleteSectionA)(HSPFILEQ QueueHandle, HINF InfHandle, HINF ListInfHandle, PCSTR Section);
typedef BOOL(__stdcall* SetupQueueDeleteSectionW)(HSPFILEQ QueueHandle, HINF InfHandle, HINF ListInfHandle, PCWSTR Section);
typedef BOOL(__stdcall* SetupQueueRenameA)(HSPFILEQ QueueHandle, PCSTR SourcePath, PCSTR SourceFilename, PCSTR TargetPath, PCSTR TargetFilename);
typedef BOOL(__stdcall* SetupQueueRenameW)(HSPFILEQ QueueHandle, PCWSTR SourcePath, PCWSTR SourceFilename, PCWSTR TargetPath, PCWSTR TargetFilename);
typedef BOOL(__stdcall* SetupQueueRenameSectionA)(HSPFILEQ QueueHandle, HINF InfHandle, HINF ListInfHandle, PCSTR Section);
typedef BOOL(__stdcall* SetupQueueRenameSectionW)(HSPFILEQ QueueHandle, HINF InfHandle, HINF ListInfHandle, PCWSTR Section);
typedef BOOL(__stdcall* SetupCommitFileQueueA)(HWND Owner, HSPFILEQ QueueHandle, PSP_FILE_CALLBACK_A MsgHandler, PVOID Context);
typedef BOOL(__stdcall* SetupCommitFileQueueW)(HWND Owner, HSPFILEQ QueueHandle, PSP_FILE_CALLBACK_W MsgHandler, PVOID Context);
typedef BOOL(__stdcall* SetupScanFileQueueA)(HSPFILEQ FileQueue, DWORD Flags, HWND Window, PSP_FILE_CALLBACK_A CallbackRoutine, PVOID CallbackContext, PDWORD Result);
typedef BOOL(__stdcall* SetupScanFileQueueW)(HSPFILEQ FileQueue, DWORD Flags, HWND Window, PSP_FILE_CALLBACK_W CallbackRoutine, PVOID CallbackContext, PDWORD Result);
typedef BOOL(__stdcall* SetupGetFileQueueCount)(HSPFILEQ FileQueue, UINT SubQueueFileOp, PUINT NumOperations);
typedef BOOL(__stdcall* SetupGetFileQueueFlags)(HSPFILEQ FileQueue, PDWORD Flags);
typedef BOOL(__stdcall* SetupSetFileQueueFlags)(HSPFILEQ FileQueue, DWORD FlagMask, DWORD Flags);
typedef BOOL(__stdcall* SetupUninstallOEMInfA)(PCSTR InfFileName, DWORD Flags, PVOID Reserved);
typedef BOOL(__stdcall* SetupUninstallOEMInfW)(PCWSTR InfFileName, DWORD Flags, PVOID Reserved);
typedef BOOL(__stdcall* SetupUninstallNewlyCopiedInfs)(HSPFILEQ FileQueue, DWORD Flags, PVOID Reserved);
typedef HDSKSPC(__stdcall* SetupCreateDiskSpaceListA)(PVOID Reserved1, DWORD Reserved2, UINT Flags);
typedef HDSKSPC(__stdcall* SetupCreateDiskSpaceListW)(PVOID Reserved1, DWORD Reserved2, UINT Flags);
typedef HDSKSPC(__stdcall* SetupDuplicateDiskSpaceListA)(HDSKSPC DiskSpace, PVOID Reserved1, DWORD Reserved2, UINT Flags);
typedef HDSKSPC(__stdcall* SetupDuplicateDiskSpaceListW)(HDSKSPC DiskSpace, PVOID Reserved1, DWORD Reserved2, UINT Flags);
typedef BOOL(__stdcall* SetupDestroyDiskSpaceList)(HDSKSPC DiskSpace);
typedef BOOL(__stdcall* SetupQueryDrivesInDiskSpaceListA)(HDSKSPC DiskSpace, PSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryDrivesInDiskSpaceListW)(HDSKSPC DiskSpace, PWSTR ReturnBuffer, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupAdjustDiskSpaceListA)(HDSKSPC DiskSpace, LPCSTR DriveRoot, LONGLONG Amount, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAdjustDiskSpaceListW)(HDSKSPC DiskSpace, LPCWSTR DriveRoot, LONGLONG Amount, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddToDiskSpaceListA)(HDSKSPC DiskSpace, PCSTR TargetFilespec, LONGLONG FileSize, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddToDiskSpaceListW)(HDSKSPC DiskSpace, PCWSTR TargetFilespec, LONGLONG FileSize, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddSectionToDiskSpaceListA)(HDSKSPC DiskSpace, HINF InfHandle, HINF ListInfHandle, PCSTR SectionName, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddSectionToDiskSpaceListW)(HDSKSPC DiskSpace, HINF InfHandle, HINF ListInfHandle, PCWSTR SectionName, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddInstallSectionToDiskSpaceListA)(HDSKSPC DiskSpace, HINF InfHandle, HINF LayoutInfHandle, PCSTR SectionName, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupAddInstallSectionToDiskSpaceListW)(HDSKSPC DiskSpace, HINF InfHandle, HINF LayoutInfHandle, PCWSTR SectionName, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveFromDiskSpaceListA)(HDSKSPC DiskSpace, PCSTR TargetFilespec, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveFromDiskSpaceListW)(HDSKSPC DiskSpace, PCWSTR TargetFilespec, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveSectionFromDiskSpaceListA)(HDSKSPC DiskSpace, HINF InfHandle, HINF ListInfHandle, PCSTR SectionName, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveSectionFromDiskSpaceListW)(HDSKSPC DiskSpace, HINF InfHandle, HINF ListInfHandle, PCWSTR SectionName, UINT Operation, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveInstallSectionFromDiskSpaceListA)(HDSKSPC DiskSpace, HINF InfHandle, HINF LayoutInfHandle, PCSTR SectionName, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupRemoveInstallSectionFromDiskSpaceListW)(HDSKSPC DiskSpace, HINF InfHandle, HINF LayoutInfHandle, PCWSTR SectionName, PVOID Reserved1, UINT Reserved2);
typedef BOOL(__stdcall* SetupIterateCabinetA)(PCSTR CabinetFile, DWORD Reserved, PSP_FILE_CALLBACK_A MsgHandler, PVOID Context);
typedef BOOL(__stdcall* SetupIterateCabinetW)(PCWSTR CabinetFile, DWORD Reserved, PSP_FILE_CALLBACK_W MsgHandler, PVOID Context);
typedef INT(__stdcall* SetupPromptReboot)(HSPFILEQ FileQueue, HWND Owner, BOOL ScanOnly);
typedef PVOID(__stdcall* SetupInitDefaultQueueCallback)(HWND OwnerWindow);
typedef PVOID(__stdcall* SetupInitDefaultQueueCallbackEx)(HWND OwnerWindow, HWND AlternateProgressWindow, UINT ProgressMessage, DWORD Reserved1, PVOID Reserved2);
typedef void(__stdcall* SetupTermDefaultQueueCallback)(PVOID Context);
typedef UINT(__stdcall* SetupDefaultQueueCallbackA)(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2);
typedef UINT(__stdcall* SetupDefaultQueueCallbackW)(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2);
typedef BOOL(__stdcall* SetupInstallFromInfSectionA)(HWND Owner, HINF InfHandle, PCSTR SectionName, UINT Flags, HKEY RelativeKeyRoot, PCSTR SourceRootPath, UINT CopyFlags, PSP_FILE_CALLBACK_A MsgHandler, PVOID Context, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupInstallFromInfSectionW)(HWND Owner, HINF InfHandle, PCWSTR SectionName, UINT Flags, HKEY RelativeKeyRoot, PCWSTR SourceRootPath, UINT CopyFlags, PSP_FILE_CALLBACK_W MsgHandler, PVOID Context, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupInstallFilesFromInfSectionA)(HINF InfHandle, HINF LayoutInfHandle, HSPFILEQ FileQueue, PCSTR SectionName, PCSTR SourceRootPath, UINT CopyFlags);
typedef BOOL(__stdcall* SetupInstallFilesFromInfSectionW)(HINF InfHandle, HINF LayoutInfHandle, HSPFILEQ FileQueue, PCWSTR SectionName, PCWSTR SourceRootPath, UINT CopyFlags);
typedef BOOL(__stdcall* SetupInstallServicesFromInfSectionA)(HINF InfHandle, PCSTR SectionName, DWORD Flags);
typedef BOOL(__stdcall* SetupInstallServicesFromInfSectionW)(HINF InfHandle, PCWSTR SectionName, DWORD Flags);
typedef BOOL(__stdcall* SetupInstallServicesFromInfSectionExA)(HINF InfHandle, PCSTR SectionName, DWORD Flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID Reserved1, PVOID Reserved2);
typedef BOOL(__stdcall* SetupInstallServicesFromInfSectionExW)(HINF InfHandle, PCWSTR SectionName, DWORD Flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID Reserved1, PVOID Reserved2);
typedef void(__stdcall* InstallHinfSectionA)(HWND Window, HINSTANCE ModuleHandle, PCSTR CommandLine, INT ShowCommand);
typedef void(__stdcall* InstallHinfSectionW)(HWND Window, HINSTANCE ModuleHandle, PCWSTR CommandLine, INT ShowCommand);
typedef HSPFILELOG(__stdcall* SetupInitializeFileLogA)(PCSTR LogFileName, DWORD Flags);
typedef HSPFILELOG(__stdcall* SetupInitializeFileLogW)(PCWSTR LogFileName, DWORD Flags);
typedef BOOL(__stdcall* SetupTerminateFileLog)(HSPFILELOG FileLogHandle);
typedef BOOL(__stdcall* SetupLogFileA)(HSPFILELOG FileLogHandle, PCSTR LogSectionName, PCSTR SourceFilename, PCSTR TargetFilename, DWORD Checksum, PCSTR DiskTagfile, PCSTR DiskDescription, PCSTR OtherInfo, DWORD Flags);
typedef BOOL(__stdcall* SetupLogFileW)(HSPFILELOG FileLogHandle, PCWSTR LogSectionName, PCWSTR SourceFilename, PCWSTR TargetFilename, DWORD Checksum, PCWSTR DiskTagfile, PCWSTR DiskDescription, PCWSTR OtherInfo, DWORD Flags);
typedef BOOL(__stdcall* SetupRemoveFileLogEntryA)(HSPFILELOG FileLogHandle, PCSTR LogSectionName, PCSTR TargetFilename);
typedef BOOL(__stdcall* SetupRemoveFileLogEntryW)(HSPFILELOG FileLogHandle, PCWSTR LogSectionName, PCWSTR TargetFilename);
typedef BOOL(__stdcall* SetupQueryFileLogA)(HSPFILELOG FileLogHandle, PCSTR LogSectionName, PCSTR TargetFilename, SetupFileLogInfo DesiredInfo, PSTR DataOut, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupQueryFileLogW)(HSPFILELOG FileLogHandle, PCWSTR LogSectionName, PCWSTR TargetFilename, SetupFileLogInfo DesiredInfo, PWSTR DataOut, DWORD ReturnBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupOpenLog)(BOOL Erase);
typedef BOOL(__stdcall* SetupLogErrorA)(LPCSTR MessageString, DWORD Severity);
typedef BOOL(__stdcall* SetupLogErrorW)(LPCWSTR MessageString, DWORD Severity);
typedef void(__stdcall* SetupWriteTextLog)(SP_LOG_TOKEN LogToken, DWORD Category, DWORD Flags, PCSTR MessageStr);
typedef void(__stdcall* SetupWriteTextLogInfLine)(SP_LOG_TOKEN LogToken, DWORD Flags, HINF InfHandle, PINFCONTEXT Context);
typedef BOOL(__stdcall* SetupSetNonInteractiveMode)(BOOL NonInteractiveFlag);
typedef BOOL(__stdcall* SetupDiGetDeviceInfoListClass)(HDEVINFO DeviceInfoSet, LPGUID ClassGuid);
typedef BOOL(__stdcall* SetupDiDeleteDeviceInfo)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiEnumDeviceInfo)(HDEVINFO DeviceInfoSet, DWORD MemberIndex, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiDestroyDeviceInfoList)(HDEVINFO DeviceInfoSet);
typedef BOOL(__stdcall* SetupDiDeleteDeviceInterfaceData)(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData);
typedef BOOL(__stdcall* SetupDiRemoveDeviceInterface)(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData);
typedef BOOL(__stdcall* SetupDiInstallDeviceInterfaces)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiSetDeviceInterfaceDefault)(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Flags, PVOID Reserved);
typedef BOOL(__stdcall* SetupDiRegisterDeviceInfo)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Flags, PSP_DETSIG_CMPPROC CompareProc, PVOID CompareContext, PSP_DEVINFO_DATA DupDeviceInfoData);
typedef BOOL(__stdcall* SetupDiBuildDriverInfoList)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD DriverType);
typedef BOOL(__stdcall* SetupDiCancelDriverInfoSearch)(HDEVINFO DeviceInfoSet);
typedef BOOL(__stdcall* SetupDiDestroyDriverInfoList)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD DriverType);
typedef BOOL(__stdcall* SetupDiBuildClassInfoList)(DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupDiCallClassInstaller)(DI_FUNCTION InstallFunction, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiSelectDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiSelectBestCompatDrv)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiInstallDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiInstallDriverFiles)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiRegisterCoDeviceInstallers)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiRemoveDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiUnremoveDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiRestartDevices)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiChangeState)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef HKEY(__stdcall* SetupDiOpenDeviceInterfaceRegKey)(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Reserved, REGSAM samDesired);
typedef BOOL(__stdcall* SetupDiDeleteDeviceInterfaceRegKey)(HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Reserved);
typedef HKEY(__stdcall* SetupDiOpenDevRegKey)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, REGSAM samDesired);
typedef BOOL(__stdcall* SetupDiDeleteDevRegKey)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType);
typedef BOOL(__stdcall* SetupDiGetHwProfileList)(PDWORD HwProfileList, DWORD HwProfileListSize, PDWORD RequiredSize, PDWORD CurrentlyActiveIndex);
typedef INT(__stdcall* SetupDiDrawMiniIcon)(HDC hdc, RECT rc, INT MiniIconIndex, DWORD Flags);
typedef BOOL(__stdcall* SetupDiGetClassImageList)(PSP_CLASSIMAGELIST_DATA ClassImageListData);
typedef BOOL(__stdcall* SetupDiDestroyClassImageList)(PSP_CLASSIMAGELIST_DATA ClassImageListData);
typedef BOOL(__stdcall* SetupDiAskForOEMDisk)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiSelectOEMDrv)(HWND hwndParent, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiGetSelectedDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupDiSetSelectedDevice)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData);
typedef BOOL(__stdcall* SetupVerifyInfFileA)(PCSTR InfName, PSP_ALTPLATFORM_INFO AltPlatformInfo, PSP_INF_SIGNER_INFO_A InfSignerInfo);
typedef BOOL(__stdcall* SetupVerifyInfFileW)(PCWSTR InfName, PSP_ALTPLATFORM_INFO AltPlatformInfo, PSP_INF_SIGNER_INFO_W InfSignerInfo);
typedef BOOL(__stdcall* SetupDiGetCustomDevicePropertyA)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PCSTR CustomPropertyName, DWORD Flags, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupDiGetCustomDevicePropertyW)(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PCWSTR CustomPropertyName, DWORD Flags, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize);
typedef BOOL(__stdcall* SetupConfigureWmiFromInfSectionA)(HINF InfHandle, PCSTR SectionName, DWORD Flags);
typedef BOOL(__stdcall* SetupConfigureWmiFromInfSectionW)(HINF InfHandle, PCWSTR SectionName, DWORD Flags);
typedef BOOL(__stdcall* SfcGetNextProtectedFile)(HANDLE RpcHandle, PPROTECTED_FILE_DATA ProtFileData);
typedef BOOL(__stdcall* SfcIsFileProtected)(HANDLE RpcHandle, LPCWSTR ProtFileName);
typedef BOOL(__stdcall* SfcIsKeyProtected)(HKEY KeyHandle, LPCWSTR SubKeyName, REGSAM KeySam);
typedef UINT(__stdcall* DragQueryFileA)(HDROP hDrop, UINT iFile, LPSTR lpszFile, UINT cch);
typedef UINT(__stdcall* DragQueryFileW)(HDROP hDrop, UINT iFile, LPWSTR lpszFile, UINT cch);
typedef void(__stdcall* DragFinish)(HDROP hDrop);
typedef void(__stdcall* DragAcceptFiles)(HWND hWnd, BOOL fAccept);
typedef HINSTANCE(__stdcall* ShellExecuteA)(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);
typedef HINSTANCE(__stdcall* ShellExecuteW)(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
typedef HINSTANCE(__stdcall* FindExecutableA)(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult);
typedef HINSTANCE(__stdcall* FindExecutableW)(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult);
typedef INT(__stdcall* ShellAboutA)(HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon);
typedef INT(__stdcall* ShellAboutW)(HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon);
typedef HICON(__stdcall* DuplicateIcon)(HINSTANCE hInst, HICON hIcon);
typedef HICON(__stdcall* ExtractIconA)(HINSTANCE hInst, LPCSTR pszExeFileName, UINT nIconIndex);
typedef HICON(__stdcall* ExtractIconW)(HINSTANCE hInst, LPCWSTR pszExeFileName, UINT nIconIndex);
typedef UINT_PTR(__stdcall* SHAppBarMessage)(DWORD dwMessage, PAPPBARDATA pData);
typedef DWORD(__stdcall* DoEnvironmentSubstA)(LPSTR pszSrc, UINT cchSrc);
typedef DWORD(__stdcall* DoEnvironmentSubstW)(LPWSTR pszSrc, UINT cchSrc);
typedef int(__stdcall* SHFileOperationA)(LPSHFILEOPSTRUCTA lpFileOp);
typedef int(__stdcall* SHFileOperationW)(LPSHFILEOPSTRUCTW lpFileOp);
typedef void(__stdcall* SHFreeNameMappings)(HANDLE hNameMappings);
typedef BOOL(__stdcall* SHCreateProcessAsUserW)(PSHCREATEPROCESSINFOW pscpi);
typedef HRESULT(__stdcall* SHQueryRecycleBinA)(LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo);
typedef HRESULT(__stdcall* SHQueryRecycleBinW)(LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo);
typedef HRESULT(__stdcall* SHEmptyRecycleBinA)(HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags);
typedef HRESULT(__stdcall* SHEmptyRecycleBinW)(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags);
typedef BOOL(__stdcall* Shell_NotifyIconA)(DWORD dwMessage, PNOTIFYICONDATAA lpData);
typedef BOOL(__stdcall* Shell_NotifyIconW)(DWORD dwMessage, PNOTIFYICONDATAW lpData);
typedef BOOL(__stdcall* SHInvokePrinterCommandA)(HWND hwnd, UINT uAction, LPCSTR lpBuf1, LPCSTR lpBuf2, BOOL fModal);
typedef BOOL(__stdcall* SHInvokePrinterCommandW)(HWND hwnd, UINT uAction, LPCWSTR lpBuf1, LPCWSTR lpBuf2, BOOL fModal);
typedef HRESULT(__stdcall* SHSetLocalizedName)(PCWSTR pszPath, PCWSTR pszResModule, int idsRes);
typedef HRESULT(__stdcall* SHRemoveLocalizedName)(PCWSTR pszPath);
typedef int(__stdcall* ShellMessageBoxA)(HINSTANCE hAppInst, HWND hWnd, LPCSTR lpcText, LPCSTR lpcTitle, UINT fuStyle);
typedef int(__stdcall* ShellMessageBoxW)(HINSTANCE hAppInst, HWND hWnd, LPCWSTR lpcText, LPCWSTR lpcTitle, UINT fuStyle);
typedef HRESULT(__stdcall* SHEnumerateUnreadMailAccountsA)(HKEY hKeyUser, DWORD dwIndex, LPSTR pszMailAddress, int cchMailAddress);
typedef HRESULT(__stdcall* SHEnumerateUnreadMailAccountsW)(HKEY hKeyUser, DWORD dwIndex, LPWSTR pszMailAddress, int cchMailAddress);
typedef HRESULT(__stdcall* SHSetUnreadMailCountW)(LPCWSTR pszMailAddress, DWORD dwCount, LPCWSTR pszShellExecuteCommand);
typedef BOOL(__stdcall* SHTestTokenMembership)(HANDLE hToken, ULONG ulRID);
typedef DEVICE_SCALE_FACTOR(__stdcall* GetScaleFactorForDevice)(DISPLAY_DEVICE_TYPE deviceType);
typedef HRESULT(__stdcall* RevokeScaleChangeNotifications)(DISPLAY_DEVICE_TYPE displayDevice, DWORD dwCookie);
typedef HRESULT(__stdcall* UnregisterScaleChangeEvent)(DWORD_PTR dwCookie);
typedef HRESULT(__stdcall* SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS value);
typedef BOOL(__stdcall* GetFileNameFromBrowse)(HWND hwnd, PWSTR pszFilePath, UINT cchFilePath, PCWSTR pszWorkingDir, PCWSTR pszDefExt, PCWSTR pszFilters, PCWSTR pszTitle);
typedef int(__stdcall* DriveType)(int iDrive);
typedef void(__stdcall* SHChangeNotifyRegisterThread)(SCNRT_STATUS status);
typedef BOOL(__stdcall* PathIsSlowA)(LPCSTR pszFile, DWORD dwAttr);
typedef BOOL(__stdcall* PathIsSlowW)(LPCWSTR pszFile, DWORD dwAttr);
typedef HPSXA(__stdcall* SHCreatePropSheetExtArray)(HKEY hKey, PCWSTR pszSubKey, UINT max_iface);
typedef DWORD(__stdcall* SoftwareUpdateMessageBox)(HWND hWnd, PCWSTR pszDistUnit, DWORD dwFlags, LPSOFTDISTINFO psdi);
typedef BOOL(__stdcall* SHRunControlPanel)(PCWSTR lpcszCmdLine, HWND hwndMsgParent);
typedef {'name': 'SHAlloc', 'type': 'void'}(__stdcall* SHAlloc)(SIZE_T cb);
typedef int(__stdcall* SHGetIconOverlayIndexA)(LPCSTR pszIconPath, int iIconIndex);
typedef int(__stdcall* SHGetIconOverlayIndexW)(LPCWSTR pszIconPath, int iIconIndex);
typedef LPITEMIDLIST(__stdcall* ILClone)(LPCITEMIDLIST pidl);
typedef LPITEMIDLIST(__stdcall* ILCloneFirst)(LPCITEMIDLIST pidl);
typedef LPITEMIDLIST(__stdcall* ILCombine)(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
typedef void(__stdcall* ILFree)(LPITEMIDLIST pidl);
typedef LPITEMIDLIST(__stdcall* ILGetNext)(LPCITEMIDLIST pidl);
typedef UINT(__stdcall* ILGetSize)(LPCITEMIDLIST pidl);
typedef LPITEMIDLIST(__stdcall* ILFindChild)(LPITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild);
typedef LPITEMIDLIST(__stdcall* ILFindLastID)(LPCITEMIDLIST pidl);
typedef BOOL(__stdcall* ILRemoveLastID)(LPITEMIDLIST pidl);
typedef BOOL(__stdcall* ILIsEqual)(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
typedef BOOL(__stdcall* ILIsParent)(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, BOOL fImmediate);
typedef LPITEMIDLIST(__stdcall* ILCreateFromPathA)(PCSTR pszPath);
typedef LPITEMIDLIST(__stdcall* ILCreateFromPathW)(PCWSTR pszPath);
typedef LPITEMIDLIST(__stdcall* ILAppendID)(LPITEMIDLIST pidl, LPCSHITEMID pmkid, BOOL fAppend);
typedef BOOL(__stdcall* SHGetPathFromIDListEx)(LPCITEMIDLIST pidl, PWSTR pszPath, DWORD cchPath, GPFIDL_FLAGS uOpts);
typedef BOOL(__stdcall* SHGetPathFromIDListA)(LPCITEMIDLIST pidl, LPSTR pszPath);
typedef BOOL(__stdcall* SHGetPathFromIDListW)(LPCITEMIDLIST pidl, LPWSTR pszPath);
typedef int(__stdcall* SHCreateDirectory)(HWND hwnd, PCWSTR pszPath);
typedef LPITEMIDLIST(__stdcall* SHCloneSpecialIDList)(HWND hwnd, int csidl, BOOL fCreate);
typedef BOOL(__stdcall* SHGetSpecialFolderPathA)(HWND hwnd, LPSTR pszPath, int csidl, BOOL fCreate);
typedef BOOL(__stdcall* SHGetSpecialFolderPathW)(HWND hwnd, LPWSTR pszPath, int csidl, BOOL fCreate);
typedef HRESULT(__stdcall* SHGetFolderPathA)(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPSTR pszPath);
typedef HRESULT(__stdcall* SHGetFolderPathW)(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
typedef HRESULT(__stdcall* SHSetFolderPathA)(int csidl, HANDLE hToken, DWORD dwFlags, LPCSTR pszPath);
typedef HRESULT(__stdcall* SHSetFolderPathW)(int csidl, HANDLE hToken, DWORD dwFlags, LPCWSTR pszPath);
typedef HRESULT(__stdcall* SHGetFolderPathAndSubDirA)(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubDir, LPSTR pszPath);
typedef HRESULT(__stdcall* SHGetFolderPathAndSubDirW)(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubDir, LPWSTR pszPath);
typedef HRESULT(__stdcall* SHGetSetFolderCustomSettings)(LPSHFOLDERCUSTOMSETTINGS pfcs, PCWSTR pszPath, DWORD dwReadWrite);
typedef LPITEMIDLIST(__stdcall* SHBrowseForFolderA)(LPBROWSEINFOA lpbi);
typedef LPITEMIDLIST(__stdcall* SHBrowseForFolderW)(LPBROWSEINFOW lpbi);
typedef void(__stdcall* SHChangeNotify)(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2);
typedef void(__stdcall* SHAddToRecentDocs)(UINT uFlags, LPCVOID pv);
typedef int(__stdcall* SHHandleUpdateImage)(LPCITEMIDLIST pidlExtra);
typedef void(__stdcall* SHUpdateImageA)(LPCSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex);
typedef void(__stdcall* SHUpdateImageW)(LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex);
typedef BOOL(__stdcall* SHChangeNotifyDeregister)(ULONG ulID);
typedef BOOL(__stdcall* SHChangeNotification_Unlock)(HANDLE hLock);
typedef int(__stdcall* RestartDialog)(HWND hwnd, PCWSTR pszPrompt, DWORD dwReturn);
typedef int(__stdcall* RestartDialogEx)(HWND hwnd, PCWSTR pszPrompt, DWORD dwReturn, DWORD dwReasonCode);
typedef BOOL(__stdcall* DAD_DragEnterEx)(HWND hwndTarget, POINT ptStart);
typedef BOOL(__stdcall* DAD_ShowDragImage)(BOOL fShow);
typedef BOOL(__stdcall* DAD_DragMove)(POINT pt);
typedef BOOL(__stdcall* PathMakeUniqueName)(PWSTR pszUniqueName, UINT cchMax, PCWSTR pszTemplate, PCWSTR pszLongPlate, PCWSTR pszDir);
typedef BOOL(__stdcall* PathIsExe)(PCWSTR pszPath);
typedef int(__stdcall* PathCleanupSpec)(PCWSTR pszDir, PWSTR pszSpec);
typedef int(__stdcall* PathResolve)(PWSTR pszPath, PZPCWSTR dirs, UINT fFlags);
typedef BOOL(__stdcall* GetFileNameFromBrowse)(HWND hwnd, PWSTR pszFilePath, UINT cchFilePath, PCWSTR pszWorkingDir, PCWSTR pszDefExt, PCWSTR pszFilters, PCWSTR pszTitle);
typedef int(__stdcall* DriveType)(int iDrive);
typedef int(__stdcall* RealDriveType)(int iDrive, BOOL fOKToHitNet);
typedef int(__stdcall* IsNetDrive)(int iDrive);
typedef UINT(__stdcall* Shell_MergeMenus)(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags);
typedef BOOL(__stdcall* SHObjectProperties)(HWND hwnd, DWORD shopObjectType, PCWSTR pszObjectName, PCWSTR pszPropertyPage);
typedef DWORD(__stdcall* SHFormatDrive)(HWND hwnd, UINT drive, UINT fmtID, UINT options);
typedef void(__stdcall* SHDestroyPropSheetExtArray)(HPSXA hpsxa);
typedef UINT(__stdcall* SHAddFromPropSheetExtArray)(HPSXA hpsxa, LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam);
typedef UINT(__stdcall* SHReplaceFromPropSheetExtArray)(HPSXA hpsxa, UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam);
typedef {'name': 'OpenRegStream', 'type': 'IStream'}(__stdcall* OpenRegStream)(HKEY hkey, PCWSTR pszSubkey, PCWSTR pszValue, DWORD grfMode);
typedef BOOL(__stdcall* SHFindFiles)(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlSaveFile);
typedef void(__stdcall* PathGetShortPath)(PWSTR pszLongPath);
typedef BOOL(__stdcall* PathYetAnotherMakeUniqueName)(PWSTR pszUniqueName, PCWSTR pszPath, PCWSTR pszShort, PCWSTR pszFileSpec);
typedef BOOL(__stdcall* Win32DeleteFile)(PCWSTR pszPath);
typedef DWORD(__stdcall* SHRestricted)(RESTRICTIONS rest);
typedef BOOL(__stdcall* SignalFileOpen)(LPCITEMIDLIST pidl);
typedef HRESULT(__stdcall* SHStartNetConnectionDialogA)(HWND hwnd, LPCSTR pszRemoteName, DWORD dwType);
typedef HRESULT(__stdcall* SHStartNetConnectionDialogW)(HWND hwnd, LPCWSTR pszRemoteName, DWORD dwType);
typedef int(__stdcall* Shell_GetCachedImageIndex)(PCWSTR pwszIconPath, int iIconIndex, UINT uIconFlags);
typedef int(__stdcall* Shell_GetCachedImageIndexA)(LPCSTR pszIconPath, int iIconIndex, UINT uIconFlags);
typedef int(__stdcall* Shell_GetCachedImageIndexW)(LPCWSTR pszIconPath, int iIconIndex, UINT uIconFlags);
typedef BOOL(__stdcall* SHValidateUNC)(HWND hwndOwner, PWSTR pszFile, UINT fConnect);
typedef HANDLE(__stdcall* PifMgr_OpenProperties)(PCWSTR pszApp, PCWSTR pszPIF, UINT hInf, UINT flOpt);
typedef HANDLE(__stdcall* PifMgr_CloseProperties)(HANDLE hProps, UINT flOpt);
typedef LRESULT(__stdcall* SHShellFolderView_Message)(HWND hwndMain, UINT uMsg, LPARAM lParam);
typedef {'name': 'SHFind_InitMenuPopup', 'type': 'IContextMenu'}(__stdcall* SHFind_InitMenuPopup)(HMENU hmenu, HWND hwndOwner, UINT idCmdFirst, UINT idCmdLast);
typedef void(__stdcall* SHGetSetSettings)(LPSHELLSTATEA lpss, DWORD dwMask, BOOL bSet);
typedef PSTR(__stdcall* StrChrA)(PCSTR pszStart, WORD wMatch);
typedef PWSTR(__stdcall* StrChrW)(PCWSTR pszStart, WCHAR wMatch);
typedef PSTR(__stdcall* StrChrIA)(PCSTR pszStart, WORD wMatch);
typedef PWSTR(__stdcall* StrChrIW)(PCWSTR pszStart, WCHAR wMatch);
typedef PWSTR(__stdcall* StrChrNW)(PCWSTR pszStart, WCHAR wMatch, UINT cchMax);
typedef PWSTR(__stdcall* StrChrNIW)(PCWSTR pszStart, WCHAR wMatch, UINT cchMax);
typedef int(__stdcall* StrCmpNA)(PCSTR psz1, PCSTR psz2, int nChar);
typedef int(__stdcall* StrCmpNW)(PCWSTR psz1, PCWSTR psz2, int nChar);
typedef int(__stdcall* StrCmpNIA)(PCSTR psz1, PCSTR psz2, int nChar);
typedef int(__stdcall* StrCmpNIW)(PCWSTR psz1, PCWSTR psz2, int nChar);
typedef int(__stdcall* StrCSpnA)(PCSTR pszStr, PCSTR pszSet);
typedef int(__stdcall* StrCSpnW)(PCWSTR pszStr, PCWSTR pszSet);
typedef int(__stdcall* StrCSpnIA)(PCSTR pszStr, PCSTR pszSet);
typedef int(__stdcall* StrCSpnIW)(PCWSTR pszStr, PCWSTR pszSet);
typedef PSTR(__stdcall* StrDupA)(PCSTR pszSrch);
typedef PWSTR(__stdcall* StrDupW)(PCWSTR pszSrch);
typedef HRESULT(__stdcall* StrFormatByteSizeEx)(ULONGLONG ull, SFBS_FLAGS flags, PWSTR pszBuf, UINT cchBuf);
typedef PSTR(__stdcall* StrFormatByteSizeA)(DWORD dw, PSTR pszBuf, UINT cchBuf);
typedef PSTR(__stdcall* StrFormatByteSize64A)(LONGLONG qdw, PSTR pszBuf, UINT cchBuf);
typedef PWSTR(__stdcall* StrFormatByteSizeW)(LONGLONG qdw, PWSTR pszBuf, UINT cchBuf);
typedef PWSTR(__stdcall* StrFormatKBSizeW)(LONGLONG qdw, PWSTR pszBuf, UINT cchBuf);
typedef PSTR(__stdcall* StrFormatKBSizeA)(LONGLONG qdw, PSTR pszBuf, UINT cchBuf);
typedef int(__stdcall* StrFromTimeIntervalA)(PSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);
typedef int(__stdcall* StrFromTimeIntervalW)(PWSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);
typedef BOOL(__stdcall* StrIsIntlEqualA)(BOOL fCaseSens, PCSTR pszString1, PCSTR pszString2, int nChar);
typedef BOOL(__stdcall* StrIsIntlEqualW)(BOOL fCaseSens, PCWSTR pszString1, PCWSTR pszString2, int nChar);
typedef PSTR(__stdcall* StrNCatA)(PSTR psz1, PCSTR psz2, int cchMax);
typedef PWSTR(__stdcall* StrNCatW)(PWSTR psz1, PCWSTR psz2, int cchMax);
typedef PSTR(__stdcall* StrPBrkA)(PCSTR psz, PCSTR pszSet);
typedef PWSTR(__stdcall* StrPBrkW)(PCWSTR psz, PCWSTR pszSet);
typedef PSTR(__stdcall* StrRChrA)(PCSTR pszStart, PCSTR pszEnd, WORD wMatch);
typedef PWSTR(__stdcall* StrRChrW)(PCWSTR pszStart, PCWSTR pszEnd, WCHAR wMatch);
typedef PSTR(__stdcall* StrRChrIA)(PCSTR pszStart, PCSTR pszEnd, WORD wMatch);
typedef PWSTR(__stdcall* StrRChrIW)(PCWSTR pszStart, PCWSTR pszEnd, WCHAR wMatch);
typedef PSTR(__stdcall* StrRStrIA)(PCSTR pszSource, PCSTR pszLast, PCSTR pszSrch);
typedef PWSTR(__stdcall* StrRStrIW)(PCWSTR pszSource, PCWSTR pszLast, PCWSTR pszSrch);
typedef int(__stdcall* StrSpnA)(PCSTR psz, PCSTR pszSet);
typedef int(__stdcall* StrSpnW)(PCWSTR psz, PCWSTR pszSet);
typedef PSTR(__stdcall* StrStrA)(PCSTR pszFirst, PCSTR pszSrch);
typedef PWSTR(__stdcall* StrStrW)(PCWSTR pszFirst, PCWSTR pszSrch);
typedef PSTR(__stdcall* StrStrIA)(PCSTR pszFirst, PCSTR pszSrch);
typedef PWSTR(__stdcall* StrStrIW)(PCWSTR pszFirst, PCWSTR pszSrch);
typedef PWSTR(__stdcall* StrStrNW)(PCWSTR pszFirst, PCWSTR pszSrch, UINT cchMax);
typedef PWSTR(__stdcall* StrStrNIW)(PCWSTR pszFirst, PCWSTR pszSrch, UINT cchMax);
typedef int(__stdcall* StrToIntA)(PCSTR pszSrc);
typedef int(__stdcall* StrToIntW)(PCWSTR pszSrc);
typedef BOOL(__stdcall* StrTrimA)(PSTR psz, PCSTR pszTrimChars);
typedef BOOL(__stdcall* StrTrimW)(PWSTR psz, PCWSTR pszTrimChars);
typedef PWSTR(__stdcall* StrCatW)(PWSTR psz1, PCWSTR psz2);
typedef int(__stdcall* StrCmpW)(PCWSTR psz1, PCWSTR psz2);
typedef int(__stdcall* StrCmpIW)(PCWSTR psz1, PCWSTR psz2);
typedef PWSTR(__stdcall* StrCpyW)(PWSTR psz1, PCWSTR psz2);
typedef PWSTR(__stdcall* StrCpyNW)(PWSTR pszDst, PCWSTR pszSrc, int cchMax);
typedef PWSTR(__stdcall* StrCatBuffW)(PWSTR pszDest, PCWSTR pszSrc, int cchDestBuffSize);
typedef PSTR(__stdcall* StrCatBuffA)(PSTR pszDest, PCSTR pszSrc, int cchDestBuffSize);
typedef BOOL(__stdcall* ChrCmpIA)(WORD w1, WORD w2);
typedef BOOL(__stdcall* ChrCmpIW)(WCHAR w1, WCHAR w2);
typedef int(__stdcall* wvnsprintfA)(PSTR pszDest, int cchDest, PCSTR pszFmt, va_list arglist);
typedef int(__stdcall* wvnsprintfW)(PWSTR pszDest, int cchDest, PCWSTR pszFmt, va_list arglist);
typedef int(__stdcall* wnsprintfA)(PSTR pszDest, int cchDest, PCSTR pszFmt);
typedef int(__stdcall* wnsprintfW)(PWSTR pszDest, int cchDest, PCWSTR pszFmt);
typedef int(__stdcall* StrCmpLogicalW)(PCWSTR psz1, PCWSTR psz2);
typedef DWORD(__stdcall* StrCatChainW)(PWSTR pszDst, DWORD cchDst, DWORD ichAt, PCWSTR pszSrc);
typedef BOOL(__stdcall* IsCharSpaceA)(CHAR wch);
typedef BOOL(__stdcall* IsCharSpaceW)(WCHAR wch);
typedef int(__stdcall* StrCmpCA)(LPCSTR pszStr1, LPCSTR pszStr2);
typedef int(__stdcall* StrCmpCW)(LPCWSTR pszStr1, LPCWSTR pszStr2);
typedef int(__stdcall* StrCmpICA)(LPCSTR pszStr1, LPCSTR pszStr2);
typedef int(__stdcall* StrCmpICW)(LPCWSTR pszStr1, LPCWSTR pszStr2);
typedef int(__stdcall* StrCmpNCA)(LPCSTR pszStr1, LPCSTR pszStr2, int nChar);
typedef int(__stdcall* StrCmpNCW)(LPCWSTR pszStr1, LPCWSTR pszStr2, int nChar);
typedef int(__stdcall* StrCmpNICA)(LPCSTR pszStr1, LPCSTR pszStr2, int nChar);
typedef int(__stdcall* StrCmpNICW)(LPCWSTR pszStr1, LPCWSTR pszStr2, int nChar);
typedef BOOL(__stdcall* IntlStrEqWorkerA)(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lpString2, int nChar);
typedef BOOL(__stdcall* IntlStrEqWorkerW)(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR lpString2, int nChar);
typedef LPSTR(__stdcall* PathAddBackslashA)(LPSTR pszPath);
typedef LPWSTR(__stdcall* PathAddBackslashW)(LPWSTR pszPath);
typedef LPSTR(__stdcall* PathBuildRootA)(LPSTR pszRoot, int iDrive);
typedef LPWSTR(__stdcall* PathBuildRootW)(LPWSTR pszRoot, int iDrive);
typedef LPSTR(__stdcall* PathCombineA)(LPSTR pszDest, LPCSTR pszDir, LPCSTR pszFile);
typedef LPWSTR(__stdcall* PathCombineW)(LPWSTR pszDest, LPCWSTR pszDir, LPCWSTR pszFile);
typedef BOOL(__stdcall* PathCompactPathA)(HDC hDC, LPSTR pszPath, UINT dx);
typedef BOOL(__stdcall* PathCompactPathW)(HDC hDC, LPWSTR pszPath, UINT dx);
typedef BOOL(__stdcall* PathCompactPathExA)(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD dwFlags);
typedef BOOL(__stdcall* PathCompactPathExW)(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD dwFlags);
typedef int(__stdcall* PathCommonPrefixA)(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR achPath);
typedef int(__stdcall* PathCommonPrefixW)(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR achPath);
typedef BOOL(__stdcall* PathFileExistsA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathFileExistsW)(LPCWSTR pszPath);
typedef LPSTR(__stdcall* PathFindExtensionA)(LPCSTR pszPath);
typedef LPWSTR(__stdcall* PathFindExtensionW)(LPCWSTR pszPath);
typedef LPSTR(__stdcall* PathFindFileNameA)(LPCSTR pszPath);
typedef LPWSTR(__stdcall* PathFindFileNameW)(LPCWSTR pszPath);
typedef LPSTR(__stdcall* PathFindNextComponentA)(LPCSTR pszPath);
typedef LPWSTR(__stdcall* PathFindNextComponentW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathFindOnPathA)(LPSTR pszPath, PZPCSTR ppszOtherDirs);
typedef BOOL(__stdcall* PathFindOnPathW)(LPWSTR pszPath, PZPCWSTR ppszOtherDirs);
typedef LPSTR(__stdcall* PathGetArgsA)(LPCSTR pszPath);
typedef LPWSTR(__stdcall* PathGetArgsW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsLFNFileSpecA)(LPCSTR pszName);
typedef BOOL(__stdcall* PathIsLFNFileSpecW)(LPCWSTR pszName);
typedef UINT(__stdcall* PathGetCharTypeA)(UCHAR ch);
typedef UINT(__stdcall* PathGetCharTypeW)(WCHAR ch);
typedef int(__stdcall* PathGetDriveNumberA)(LPCSTR pszPath);
typedef int(__stdcall* PathGetDriveNumberW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsDirectoryA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsDirectoryW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsDirectoryEmptyA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsDirectoryEmptyW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsFileSpecA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsFileSpecW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsPrefixA)(LPCSTR pszPrefix, LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsPrefixW)(LPCWSTR pszPrefix, LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsRelativeA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsRelativeW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsRootA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsRootW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsSameRootA)(LPCSTR pszPath1, LPCSTR pszPath2);
typedef BOOL(__stdcall* PathIsSameRootW)(LPCWSTR pszPath1, LPCWSTR pszPath2);
typedef BOOL(__stdcall* PathIsUNCA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsUNCW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsNetworkPathA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsNetworkPathW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsUNCServerA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsUNCServerW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsUNCServerShareA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsUNCServerShareW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsContentTypeA)(LPCSTR pszPath, LPCSTR pszContentType);
typedef BOOL(__stdcall* PathIsContentTypeW)(LPCWSTR pszPath, LPCWSTR pszContentType);
typedef BOOL(__stdcall* PathIsURLA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathIsURLW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathMakePrettyA)(LPSTR pszPath);
typedef BOOL(__stdcall* PathMakePrettyW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathMatchSpecA)(LPCSTR pszFile, LPCSTR pszSpec);
typedef BOOL(__stdcall* PathMatchSpecW)(LPCWSTR pszFile, LPCWSTR pszSpec);
typedef HRESULT(__stdcall* PathMatchSpecExA)(LPCSTR pszFile, LPCSTR pszSpec, DWORD dwFlags);
typedef HRESULT(__stdcall* PathMatchSpecExW)(LPCWSTR pszFile, LPCWSTR pszSpec, DWORD dwFlags);
typedef int(__stdcall* PathParseIconLocationA)(LPSTR pszIconFile);
typedef int(__stdcall* PathParseIconLocationW)(LPWSTR pszIconFile);
typedef BOOL(__stdcall* PathQuoteSpacesA)(LPSTR lpsz);
typedef BOOL(__stdcall* PathQuoteSpacesW)(LPWSTR lpsz);
typedef BOOL(__stdcall* PathRelativePathToA)(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo);
typedef BOOL(__stdcall* PathRelativePathToW)(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo);
typedef void(__stdcall* PathRemoveArgsA)(LPSTR pszPath);
typedef void(__stdcall* PathRemoveArgsW)(LPWSTR pszPath);
typedef LPSTR(__stdcall* PathRemoveBackslashA)(LPSTR pszPath);
typedef LPWSTR(__stdcall* PathRemoveBackslashW)(LPWSTR pszPath);
typedef void(__stdcall* PathRemoveBlanksA)(LPSTR pszPath);
typedef void(__stdcall* PathRemoveBlanksW)(LPWSTR pszPath);
typedef void(__stdcall* PathRemoveExtensionA)(LPSTR pszPath);
typedef void(__stdcall* PathRemoveExtensionW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathRemoveFileSpecA)(LPSTR pszPath);
typedef BOOL(__stdcall* PathRemoveFileSpecW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathRenameExtensionA)(LPSTR pszPath, LPCSTR pszExt);
typedef BOOL(__stdcall* PathRenameExtensionW)(LPWSTR pszPath, LPCWSTR pszExt);
typedef BOOL(__stdcall* PathSearchAndQualifyA)(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf);
typedef BOOL(__stdcall* PathSearchAndQualifyW)(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf);
typedef void(__stdcall* PathSetDlgItemPathA)(HWND hDlg, int id, LPCSTR pszPath);
typedef void(__stdcall* PathSetDlgItemPathW)(HWND hDlg, int id, LPCWSTR pszPath);
typedef LPSTR(__stdcall* PathSkipRootA)(LPCSTR pszPath);
typedef LPWSTR(__stdcall* PathSkipRootW)(LPCWSTR pszPath);
typedef void(__stdcall* PathStripPathA)(LPSTR pszPath);
typedef void(__stdcall* PathStripPathW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathStripToRootA)(LPSTR pszPath);
typedef BOOL(__stdcall* PathStripToRootW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathUnquoteSpacesA)(LPSTR lpsz);
typedef BOOL(__stdcall* PathUnquoteSpacesW)(LPWSTR lpsz);
typedef BOOL(__stdcall* PathMakeSystemFolderA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathMakeSystemFolderW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathUnmakeSystemFolderA)(LPCSTR pszPath);
typedef BOOL(__stdcall* PathUnmakeSystemFolderW)(LPCWSTR pszPath);
typedef BOOL(__stdcall* PathIsSystemFolderA)(LPCSTR pszPath, DWORD dwAttrb);
typedef BOOL(__stdcall* PathIsSystemFolderW)(LPCWSTR pszPath, DWORD dwAttrb);
typedef void(__stdcall* PathUndecorateA)(LPSTR pszPath);
typedef void(__stdcall* PathUndecorateW)(LPWSTR pszPath);
typedef BOOL(__stdcall* PathUnExpandEnvStringsA)(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf);
typedef BOOL(__stdcall* PathUnExpandEnvStringsW)(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf);
typedef int(__stdcall* UrlCompareA)(PCSTR psz1, PCSTR psz2, BOOL fIgnoreSlash);
typedef int(__stdcall* UrlCompareW)(PCWSTR psz1, PCWSTR psz2, BOOL fIgnoreSlash);
typedef BOOL(__stdcall* UrlIsOpaqueA)(PCSTR pszURL);
typedef BOOL(__stdcall* UrlIsOpaqueW)(PCWSTR pszURL);
typedef BOOL(__stdcall* UrlIsNoHistoryA)(PCSTR pszURL);
typedef BOOL(__stdcall* UrlIsNoHistoryW)(PCWSTR pszURL);
typedef BOOL(__stdcall* UrlIsA)(PCSTR pszUrl, URLIS UrlIs);
typedef BOOL(__stdcall* UrlIsW)(PCWSTR pszUrl, URLIS UrlIs);
typedef LPCSTR(__stdcall* UrlGetLocationA)(PCSTR pszURL);
typedef LPCWSTR(__stdcall* UrlGetLocationW)(PCWSTR pszURL);
typedef HRESULT(__stdcall* UrlFixupW)(PCWSTR pcszUrl, PWSTR pszTranslatedUrl, DWORD cchMax);
typedef LSTATUS(__stdcall* SHDeleteEmptyKeyA)(HKEY hkey, LPCSTR pszSubKey);
typedef LSTATUS(__stdcall* SHDeleteEmptyKeyW)(HKEY hkey, LPCWSTR pszSubKey);
typedef LSTATUS(__stdcall* SHDeleteKeyA)(HKEY hkey, LPCSTR pszSubKey);
typedef LSTATUS(__stdcall* SHDeleteKeyW)(HKEY hkey, LPCWSTR pszSubKey);
typedef HKEY(__stdcall* SHRegDuplicateHKey)(HKEY hkey);
typedef LSTATUS(__stdcall* SHDeleteValueA)(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue);
typedef LSTATUS(__stdcall* SHDeleteValueW)(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue);
typedef LSTATUS(__stdcall* SHSetValueA)(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);
typedef LSTATUS(__stdcall* SHSetValueW)(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);
typedef LSTATUS(__stdcall* SHRegSetValue)(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, SRRF srrfFlags, DWORD dwType, LPCVOID pvData, DWORD cbData);
typedef BOOL(__stdcall* SHRegGetBoolValueFromHKCUHKLM)(PCWSTR pszKey, PCWSTR pszValue, BOOL fDefault);
typedef LSTATUS(__stdcall* SHEnumKeyExA)(HKEY hkey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName);
typedef LSTATUS(__stdcall* SHEnumKeyExW)(HKEY hkey, DWORD dwIndex, LPWSTR pszName, LPDWORD pcchName);
typedef LSTATUS(__stdcall* SHQueryInfoKeyA)(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);
typedef LSTATUS(__stdcall* SHQueryInfoKeyW)(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);
typedef LSTATUS(__stdcall* SHCopyKeyA)(HKEY hkeySrc, LPCSTR pszSrcSubKey, HKEY hkeyDest, DWORD fReserved);
typedef LSTATUS(__stdcall* SHCopyKeyW)(HKEY hkeySrc, LPCWSTR pszSrcSubKey, HKEY hkeyDest, DWORD fReserved);
typedef LSTATUS(__stdcall* SHRegGetPathA)(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPSTR pszPath, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegGetPathW)(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPWSTR pszPath, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegSetPathA)(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPCSTR pcszPath, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegSetPathW)(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPCWSTR pcszPath, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegCreateUSKeyA)(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegCreateUSKeyW)(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);
typedef LSTATUS(__stdcall* SHRegOpenUSKeyA)(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);
typedef LSTATUS(__stdcall* SHRegOpenUSKeyW)(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);
typedef LSTATUS(__stdcall* SHRegDeleteUSValueA)(HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags);
typedef LSTATUS(__stdcall* SHRegDeleteUSValueW)(HUSKEY hUSKey, LPCWSTR pwzValue, SHREGDEL_FLAGS delRegFlags);
typedef LSTATUS(__stdcall* SHRegDeleteEmptyUSKeyW)(HUSKEY hUSKey, LPCWSTR pwzSubKey, SHREGDEL_FLAGS delRegFlags);
typedef LSTATUS(__stdcall* SHRegDeleteEmptyUSKeyA)(HUSKEY hUSKey, LPCSTR pszSubKey, SHREGDEL_FLAGS delRegFlags);
typedef LSTATUS(__stdcall* SHRegEnumUSKeyA)(HUSKEY hUSKey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags);
typedef LSTATUS(__stdcall* SHRegEnumUSKeyW)(HUSKEY hUSKey, DWORD dwIndex, LPWSTR pwzName, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags);
typedef LSTATUS(__stdcall* SHRegQueryInfoUSKeyA)(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags);
typedef LSTATUS(__stdcall* SHRegQueryInfoUSKeyW)(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags);
typedef LSTATUS(__stdcall* SHRegCloseUSKey)(HUSKEY hUSKey);
typedef int(__stdcall* SHRegGetIntW)(HKEY hk, PCWSTR pwzKey, int iDefault);
typedef BOOL(__stdcall* SHRegGetBoolUSValueA)(LPCSTR pszSubKey, LPCSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);
typedef BOOL(__stdcall* SHRegGetBoolUSValueW)(LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);
typedef BOOL(__stdcall* AssocIsDangerous)(PCWSTR pszAssoc);
typedef {'name': 'SHOpenRegStreamA', 'type': 'IStream'}(__stdcall* SHOpenRegStreamA)(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD grfMode);
typedef {'name': 'SHOpenRegStreamW', 'type': 'IStream'}(__stdcall* SHOpenRegStreamW)(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD grfMode);
typedef {'name': 'SHOpenRegStream2A', 'type': 'IStream'}(__stdcall* SHOpenRegStream2A)(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD grfMode);
typedef {'name': 'SHOpenRegStream2W', 'type': 'IStream'}(__stdcall* SHOpenRegStream2W)(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD grfMode);
typedef int(__stdcall* SHAnsiToUnicode)(PCSTR pszSrc, PWSTR pwszDst, int cwchBuf);
typedef int(__stdcall* SHAnsiToAnsi)(PCSTR pszSrc, PSTR pszDst, int cchBuf);
typedef int(__stdcall* SHUnicodeToAnsi)(PCWSTR pwszSrc, PSTR pszDst, int cchBuf);
typedef int(__stdcall* SHUnicodeToUnicode)(PCWSTR pwzSrc, PWSTR pwzDst, int cwchBuf);
typedef int(__stdcall* SHMessageBoxCheckA)(HWND hwnd, LPCSTR pszText, LPCSTR pszCaption, UINT uType, int iDefault, LPCSTR pszRegVal);
typedef int(__stdcall* SHMessageBoxCheckW)(HWND hwnd, LPCWSTR pszText, LPCWSTR pszCaption, UINT uType, int iDefault, LPCWSTR pszRegVal);
typedef LRESULT(__stdcall* SHSendMessageBroadcastA)(UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* SHSendMessageBroadcastW)(UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef CHAR(__stdcall* SHStripMneumonicA)(LPSTR pszMenu);
typedef WCHAR(__stdcall* SHStripMneumonicW)(LPWSTR pszMenu);
typedef BOOL(__stdcall* IsOS)(DWORD dwOS);
typedef long(__stdcall* SHGlobalCounterGetValue)(SHGLOBALCOUNTER id);
typedef long(__stdcall* SHGlobalCounterIncrement)(SHGLOBALCOUNTER id);
typedef long(__stdcall* SHGlobalCounterDecrement)(SHGLOBALCOUNTER id);
typedef BOOL(__stdcall* SHFreeShared)(HANDLE hData, DWORD dwProcessId);
typedef {'name': 'SHLockShared', 'type': 'void'}(__stdcall* SHLockShared)(HANDLE hData, DWORD dwProcessId);
typedef BOOL(__stdcall* SHIsLowMemoryMachine)(DWORD dwType);
typedef int(__stdcall* GetMenuPosFromID)(HMENU hmenu, UINT id);
typedef HRESULT(__stdcall* SHAutoComplete)(HWND hwndEdit, DWORD dwFlags);
typedef HPALETTE(__stdcall* SHCreateShellPalette)(HDC hdc);
typedef COLORREF(__stdcall* ColorHLSToRGB)(WORD wHue, WORD wLuminance, WORD wSaturation);
typedef COLORREF(__stdcall* ColorAdjustLuma)(COLORREF clrRGB, int n, BOOL fScale);
typedef HRESULT(__stdcall* DllInstall)(BOOL bInstall, PCWSTR pszCmdLine);
typedef LPITEMIDLIST(__stdcall* SHSimpleIDListFromPath)(PCWSTR pszPath);
typedef HRESULT(__stdcall* SetCurrentProcessExplicitAppUserModelID)(PCWSTR AppID);
typedef HRESULT(__stdcall* SLClose)(HSLC hSLC);
typedef HRESULT(__stdcall* SLUnloadApplicationPolicies)(HSLP hPolicyContext, DWORD dwFlags);
typedef HRESULT(__stdcall* SLGatherMigrationBlob)(BOOL bMigratableOnly, LPCWSTR pwszEncryptorUri, HANDLE hFile);
typedef HRESULT(__stdcall* SLDepositMigrationBlob)(HANDLE hFile);
typedef DWORD(__stdcall* SetAppInstanceCsvFlags)(HANDLE ProcessHandle, ULONG Mask, ULONG Flags);
typedef void(__stdcall* SnmpUtilMemFree)(LPVOID pMem);
typedef LPVOID(__stdcall* SnmpUtilMemAlloc)(UINT nBytes);
typedef LPVOID(__stdcall* SnmpUtilMemReAlloc)(LPVOID pMem, UINT nBytes);
typedef DWORD(__stdcall* SnmpSvcGetUptime)();
typedef void(__stdcall* SnmpSvcSetLogLevel)(INT nLogLevel);
typedef void(__stdcall* SnmpSvcSetLogType)(INT nLogType);
typedef void(__stdcall* SnmpUtilDbgPrint)(INT nLogLevel, LPSTR szFormat);
typedef HRESULT(__stdcall* SetSocketMediaStreamingMode)(BOOL value);
typedef HRESULT(__stdcall* SrpSetTokenEnterpriseId)(HANDLE tokenHandle, PCWSTR enterpriseId);
typedef HRESULT(__stdcall* SrpEnablePermissiveModeFileEncryption)(PCWSTR enterpriseId);
typedef BOOL(__stdcall* SRSetRestorePointA)(PRESTOREPOINTINFOA pRestorePtSpec, PSTATEMGRSTATUS pSMgrStatus);
typedef BOOL(__stdcall* SRSetRestorePointW)(PRESTOREPOINTINFOW pRestorePtSpec, PSTATEMGRSTATUS pSMgrStatus);
typedef DWORD(__stdcall* SRRemoveRestorePoint)(DWORD dwRPNum);
typedef BOOL(__stdcall* CdromKnownGoodDigitalPlayback)(HDEVINFO HDevInfo, PSP_DEVINFO_DATA DevInfoData);
typedef LONG(__stdcall* CdromEnableDigitalPlayback)(HDEVINFO DevInfo, PSP_DEVINFO_DATA DevInfoData, BOOLEAN ForceUnknown);
typedef LONG(__stdcall* CdromDisableDigitalPlayback)(HDEVINFO DevInfo, PSP_DEVINFO_DATA DevInfoData);
typedef LONG(__stdcall* CdromIsDigitalPlaybackEnabled)(HDEVINFO DevInfo, PSP_DEVINFO_DATA DevInfoData, PBOOLEAN Enabled);
typedef size_t(__stdcall* uaw_wcslen)(PCUWSTR String);
typedef int(__stdcall* CompareStringA)(LCID Locale, DWORD dwCmpFlags, PCNZCH lpString1, int cchCount1, PCNZCH lpString2, int cchCount2);
typedef BOOL(__stdcall* GetStringTypeExA)(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType);
typedef int(__stdcall* FoldStringA)(DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
typedef int(__stdcall* CompareStringEx)(LPCWSTR lpLocaleName, DWORD dwCmpFlags, LPCWCH lpString1, int cchCount1, LPCWCH lpString2, int cchCount2, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM lParam);
typedef int(__stdcall* CompareStringOrdinal)(LPCWCH lpString1, int cchCount1, LPCWCH lpString2, int cchCount2, BOOL bIgnoreCase);
typedef int(__stdcall* CompareStringW)(LCID Locale, DWORD dwCmpFlags, PCNZWCH lpString1, int cchCount1, PCNZWCH lpString2, int cchCount2);
typedef int(__stdcall* FoldStringW)(DWORD dwMapFlags, LPCWCH lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
typedef BOOL(__stdcall* GetStringTypeExW)(LCID Locale, DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType);
typedef BOOL(__stdcall* GetStringTypeW)(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType);
typedef int(__stdcall* MultiByteToWideChar)(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
typedef int(__stdcall* WideCharToMultiByte)(UINT CodePage, DWORD dwFlags, LPCWCH lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCCH lpDefaultChar, LPBOOL lpUsedDefaultChar);
typedef void(__stdcall* SwDeviceClose)(HSWDEVICE hSwDevice);
typedef HRESULT(__stdcall* SwDeviceSetLifetime)(HSWDEVICE hSwDevice, SW_DEVICE_LIFETIME Lifetime);
typedef HRESULT(__stdcall* SwDeviceGetLifetime)(HSWDEVICE hSwDevice, PSW_DEVICE_LIFETIME pLifetime);
typedef void(__stdcall* SwMemFree)(PVOID pMem);
typedef HRESULT(__stdcall* SwDeviceInterfaceSetState)(HSWDEVICE hSwDevice, PCWSTR pszDeviceInterfaceId, BOOL fEnabled);
typedef void(__stdcall* InitializeSRWLock)(PSRWLOCK SRWLock);
typedef void(__stdcall* ReleaseSRWLockExclusive)(PSRWLOCK SRWLock);
typedef void(__stdcall* ReleaseSRWLockShared)(PSRWLOCK SRWLock);
typedef void(__stdcall* AcquireSRWLockExclusive)(PSRWLOCK SRWLock);
typedef void(__stdcall* AcquireSRWLockShared)(PSRWLOCK SRWLock);
typedef BOOLEAN(__stdcall* TryAcquireSRWLockExclusive)(PSRWLOCK SRWLock);
typedef BOOLEAN(__stdcall* TryAcquireSRWLockShared)(PSRWLOCK SRWLock);
typedef void(__stdcall* InitializeCriticalSection)(LPCRITICAL_SECTION lpCriticalSection);
typedef void(__stdcall* EnterCriticalSection)(LPCRITICAL_SECTION lpCriticalSection);
typedef void(__stdcall* LeaveCriticalSection)(LPCRITICAL_SECTION lpCriticalSection);
typedef BOOL(__stdcall* InitializeCriticalSectionAndSpinCount)(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);
typedef BOOL(__stdcall* InitializeCriticalSectionEx)(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount, DWORD Flags);
typedef DWORD(__stdcall* SetCriticalSectionSpinCount)(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);
typedef BOOL(__stdcall* TryEnterCriticalSection)(LPCRITICAL_SECTION lpCriticalSection);
typedef void(__stdcall* DeleteCriticalSection)(LPCRITICAL_SECTION lpCriticalSection);
typedef void(__stdcall* InitOnceInitialize)(PINIT_ONCE InitOnce);
typedef BOOL(__stdcall* InitOnceComplete)(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext);
typedef void(__stdcall* InitializeConditionVariable)(PCONDITION_VARIABLE ConditionVariable);
typedef void(__stdcall* WakeConditionVariable)(PCONDITION_VARIABLE ConditionVariable);
typedef void(__stdcall* WakeAllConditionVariable)(PCONDITION_VARIABLE ConditionVariable);
typedef BOOL(__stdcall* SleepConditionVariableCS)(PCONDITION_VARIABLE ConditionVariable, PCRITICAL_SECTION CriticalSection, DWORD dwMilliseconds);
typedef BOOL(__stdcall* SleepConditionVariableSRW)(PCONDITION_VARIABLE ConditionVariable, PSRWLOCK SRWLock, DWORD dwMilliseconds, ULONG Flags);
typedef BOOL(__stdcall* SetEvent)(HANDLE hEvent);
typedef BOOL(__stdcall* ResetEvent)(HANDLE hEvent);
typedef BOOL(__stdcall* ReleaseSemaphore)(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
typedef BOOL(__stdcall* ReleaseMutex)(HANDLE hMutex);
typedef DWORD(__stdcall* WaitForSingleObject)(HANDLE hHandle, DWORD dwMilliseconds);
typedef DWORD(__stdcall* SleepEx)(DWORD dwMilliseconds, BOOL bAlertable);
typedef DWORD(__stdcall* WaitForSingleObjectEx)(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable);
typedef HANDLE(__stdcall* CreateMutexA)(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName);
typedef HANDLE(__stdcall* CreateMutexW)(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenMutexW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
typedef HANDLE(__stdcall* CreateEventA)(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName);
typedef HANDLE(__stdcall* CreateEventW)(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenEventA)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
typedef HANDLE(__stdcall* OpenEventW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenSemaphoreW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenWaitableTimerW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName);
typedef BOOL(__stdcall* CancelWaitableTimer)(HANDLE hTimer);
typedef HANDLE(__stdcall* CreateMutexExA)(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateMutexExW)(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateEventExA)(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateEventExW)(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateWaitableTimerExW)(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCWSTR lpTimerName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef BOOL(__stdcall* EnterSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier, DWORD dwFlags);
typedef BOOL(__stdcall* InitializeSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier, LONG lTotalThreads, LONG lSpinCount);
typedef BOOL(__stdcall* DeleteSynchronizationBarrier)(LPSYNCHRONIZATION_BARRIER lpBarrier);
typedef void(__stdcall* Sleep)(DWORD dwMilliseconds);
typedef void(__stdcall* WakeByAddressSingle)(PVOID Address);
typedef void(__stdcall* WakeByAddressAll)(PVOID Address);
typedef DWORD(__stdcall* SignalObjectAndWait)(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable);
typedef HANDLE(__stdcall* CreateWaitableTimerW)(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName);
typedef BOOL(__stdcall* GlobalMemoryStatusEx)(LPMEMORYSTATUSEX lpBuffer);
typedef void(__stdcall* GetSystemInfo)(LPSYSTEM_INFO lpSystemInfo);
typedef void(__stdcall* GetSystemTime)(LPSYSTEMTIME lpSystemTime);
typedef void(__stdcall* GetSystemTimeAsFileTime)(LPFILETIME lpSystemTimeAsFileTime);
typedef void(__stdcall* GetLocalTime)(LPSYSTEMTIME lpSystemTime);
typedef BOOL(__stdcall* GetSystemTimeAdjustment)(PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled);
typedef BOOL(__stdcall* GetSystemTimeAdjustmentPrecise)(PDWORD64 lpTimeAdjustment, PDWORD64 lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled);
typedef UINT(__stdcall* GetSystemDirectoryA)(LPSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetSystemDirectoryW)(LPWSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetWindowsDirectoryA)(LPSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetWindowsDirectoryW)(LPWSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetSystemWindowsDirectoryA)(LPSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetSystemWindowsDirectoryW)(LPWSTR lpBuffer, UINT uSize);
typedef BOOL(__stdcall* GetComputerNameExA)(COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize);
typedef BOOL(__stdcall* GetComputerNameExW)(COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize);
typedef BOOL(__stdcall* SetComputerNameExW)(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer);
typedef BOOL(__stdcall* GetVersionExA)(LPOSVERSIONINFOA lpVersionInformation);
typedef BOOL(__stdcall* GetVersionExW)(LPOSVERSIONINFOW lpVersionInformation);
typedef BOOL(__stdcall* GetLogicalProcessorInformation)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength);
typedef BOOL(__stdcall* GetLogicalProcessorInformationEx)(LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Buffer, PDWORD ReturnedLength);
typedef void(__stdcall* GetNativeSystemInfo)(LPSYSTEM_INFO lpSystemInfo);
typedef void(__stdcall* GetSystemTimePreciseAsFileTime)(LPFILETIME lpSystemTimeAsFileTime);
typedef BOOL(__stdcall* GetProductInfo)(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion, DWORD dwSpMinorVersion, PDWORD pdwReturnedProductType);
typedef UINT(__stdcall* EnumSystemFirmwareTables)(DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize);
typedef UINT(__stdcall* GetSystemFirmwareTable)(DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize);
typedef BOOL(__stdcall* GetPhysicallyInstalledSystemMemory)(PULONGLONG TotalMemoryInKilobytes);
typedef BOOL(__stdcall* SetSystemTimeAdjustment)(DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled);
typedef BOOL(__stdcall* SetSystemTimeAdjustmentPrecise)(DWORD64 dwTimeAdjustment, BOOL bTimeAdjustmentDisabled);
typedef BOOL(__stdcall* InstallELAMCertificateInfo)(HANDLE ELAMFile);
typedef BOOL(__stdcall* GetProcessorSystemCycleTime)(USHORT Group, PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION Buffer, PDWORD ReturnedLength);
typedef BOOL(__stdcall* SetComputerNameA)(LPCSTR lpComputerName);
typedef BOOL(__stdcall* SetComputerNameW)(LPCWSTR lpComputerName);
typedef BOOL(__stdcall* SetComputerNameExA)(COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer);
typedef BOOL(__stdcall* GetNumaHighestNodeNumber)(PULONG HighestNodeNumber);
typedef BOOL(__stdcall* GetNumaNodeProcessorMaskEx)(USHORT Node, PGROUP_AFFINITY ProcessorMask);
typedef BOOL(__stdcall* GetNumaProximityNodeEx)(ULONG ProximityId, PUSHORT NodeNumber);
typedef LONG(__stdcall* TTEnableEmbeddingForFacename)(LPCSTR lpszFacename, BOOL bEnable);
typedef TBS_RESULT(__stdcall* Tbsi_Context_Create)(PCTBS_CONTEXT_PARAMS pContextParams, PTBS_HCONTEXT phContext);
typedef TBS_RESULT(__stdcall* Tbsip_Context_Close)(TBS_HCONTEXT hContext);
typedef TBS_RESULT(__stdcall* Tbsip_Submit_Command)(TBS_HCONTEXT hContext, TBS_COMMAND_LOCALITY Locality, TBS_COMMAND_PRIORITY Priority, PCBYTE pabCommand, UINT32 cbCommand, PBYTE pabResult, PUINT32 pcbResult);
typedef TBS_RESULT(__stdcall* Tbsip_Cancel_Commands)(TBS_HCONTEXT hContext);
typedef TBS_RESULT(__stdcall* Tbsi_Physical_Presence_Command)(TBS_HCONTEXT hContext, PCBYTE pabInput, UINT32 cbInput, PBYTE pabOutput, PUINT32 pcbOutput);
typedef TBS_RESULT(__stdcall* Tbsi_Get_TCG_Log)(TBS_HCONTEXT hContext, PBYTE pOutputBuf, PUINT32 pOutputBufLen);
typedef TBS_RESULT(__stdcall* Tbsi_GetDeviceInfo)(UINT32 Size, PVOID Info);
typedef TBS_RESULT(__stdcall* Tbsi_Get_OwnerAuth)(TBS_HCONTEXT hContext, TBS_OWNERAUTH_TYPE ownerauthType, PBYTE pOutputBuf, PUINT32 pOutputBufLen);
typedef TBS_RESULT(__stdcall* Tbsi_Revoke_Attestation)();
typedef TBS_RESULT(__stdcall* Tbsi_Get_TCG_Log_Ex)(UINT32 logType, PBYTE pbOutput, PUINT32 pcbOutput);
typedef TDHSTATUS(__stdcall* TdhCleanupPayloadEventFilterDescriptor)(PEVENT_FILTER_DESCRIPTOR EventFilterDescriptor);
typedef TDHSTATUS(__stdcall* TdhGetEventInformation)(PEVENT_RECORD Event, ULONG TdhContextCount, PTDH_CONTEXT TdhContext, PTRACE_EVENT_INFO Buffer, PULONG BufferSize);
typedef TDHSTATUS(__stdcall* TdhGetProperty)(PEVENT_RECORD pEvent, ULONG TdhContextCount, PTDH_CONTEXT pTdhContext, ULONG PropertyDataCount, PPROPERTY_DATA_DESCRIPTOR pPropertyData, ULONG BufferSize, PBYTE pBuffer);
typedef TDHSTATUS(__stdcall* TdhLoadManifest)(PWSTR Manifest);
typedef TDHSTATUS(__stdcall* TdhUnloadManifest)(PWSTR Manifest);
typedef TDHSTATUS(__stdcall* TdhFormatProperty)(PTRACE_EVENT_INFO EventInfo, PEVENT_MAP_INFO MapInfo, ULONG PointerSize, USHORT PropertyInType, USHORT PropertyOutType, USHORT PropertyLength, USHORT UserDataLength, PBYTE UserData, PULONG BufferSize, PWCHAR Buffer, PUSHORT UserDataConsumed);
typedef TDHSTATUS(__stdcall* TdhOpenDecodingHandle)(PTDH_HANDLE Handle);
typedef TDHSTATUS(__stdcall* TdhSetDecodingParameter)(TDH_HANDLE Handle, PTDH_CONTEXT TdhContext);
typedef TDHSTATUS(__stdcall* TdhGetDecodingParameter)(TDH_HANDLE Handle, PTDH_CONTEXT TdhContext);
typedef TDHSTATUS(__stdcall* TdhGetWppProperty)(TDH_HANDLE Handle, PEVENT_RECORD EventRecord, PWSTR PropertyName, PULONG BufferSize, PBYTE Buffer);
typedef TDHSTATUS(__stdcall* TdhGetWppMessage)(TDH_HANDLE Handle, PEVENT_RECORD EventRecord, PULONG BufferSize, PBYTE Buffer);
typedef TDHSTATUS(__stdcall* TdhCloseDecodingHandle)(TDH_HANDLE Handle);
typedef TDHSTATUS(__stdcall* TdhLoadManifestFromBinary)(PWSTR BinaryPath);
typedef PTP_POOL(__stdcall* CreateThreadpool)(PVOID reserved);
typedef void(__stdcall* SetThreadpoolThreadMaximum)(PTP_POOL ptpp, DWORD cthrdMost);
typedef BOOL(__stdcall* SetThreadpoolThreadMinimum)(PTP_POOL ptpp, DWORD cthrdMic);
typedef BOOL(__stdcall* SetThreadpoolStackInformation)(PTP_POOL ptpp, PTP_POOL_STACK_INFORMATION ptpsi);
typedef BOOL(__stdcall* QueryThreadpoolStackInformation)(PTP_POOL ptpp, PTP_POOL_STACK_INFORMATION ptpsi);
typedef void(__stdcall* CloseThreadpool)(PTP_POOL ptpp);
typedef void(__stdcall* CloseThreadpoolCleanupGroupMembers)(PTP_CLEANUP_GROUP ptpcg, BOOL fCancelPendingCallbacks, PVOID pvCleanupContext);
typedef void(__stdcall* CloseThreadpoolCleanupGroup)(PTP_CLEANUP_GROUP ptpcg);
typedef void(__stdcall* SetEventWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE evt);
typedef void(__stdcall* ReleaseSemaphoreWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE sem, DWORD crel);
typedef void(__stdcall* ReleaseMutexWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE mut);
typedef void(__stdcall* LeaveCriticalSectionWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, PCRITICAL_SECTION pcs);
typedef void(__stdcall* FreeLibraryWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HMODULE mod);
typedef BOOL(__stdcall* CallbackMayRunLong)(PTP_CALLBACK_INSTANCE pci);
typedef void(__stdcall* DisassociateCurrentThreadFromCallback)(PTP_CALLBACK_INSTANCE pci);
typedef BOOL(__stdcall* TrySubmitThreadpoolCallback)(PTP_SIMPLE_CALLBACK pfns, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
typedef PTP_WORK(__stdcall* CreateThreadpoolWork)(PTP_WORK_CALLBACK pfnwk, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
typedef void(__stdcall* SubmitThreadpoolWork)(PTP_WORK pwk);
typedef void(__stdcall* WaitForThreadpoolWorkCallbacks)(PTP_WORK pwk, BOOL fCancelPendingCallbacks);
typedef void(__stdcall* CloseThreadpoolWork)(PTP_WORK pwk);
typedef PTP_TIMER(__stdcall* CreateThreadpoolTimer)(PTP_TIMER_CALLBACK pfnti, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
typedef void(__stdcall* SetThreadpoolTimer)(PTP_TIMER pti, PFILETIME pftDueTime, DWORD msPeriod, DWORD msWindowLength);
typedef BOOL(__stdcall* IsThreadpoolTimerSet)(PTP_TIMER pti);
typedef void(__stdcall* WaitForThreadpoolTimerCallbacks)(PTP_TIMER pti, BOOL fCancelPendingCallbacks);
typedef void(__stdcall* CloseThreadpoolTimer)(PTP_TIMER pti);
typedef PTP_WAIT(__stdcall* CreateThreadpoolWait)(PTP_WAIT_CALLBACK pfnwa, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
typedef void(__stdcall* SetThreadpoolWait)(PTP_WAIT pwa, HANDLE h, PFILETIME pftTimeout);
typedef void(__stdcall* WaitForThreadpoolWaitCallbacks)(PTP_WAIT pwa, BOOL fCancelPendingCallbacks);
typedef void(__stdcall* CloseThreadpoolWait)(PTP_WAIT pwa);
typedef PTP_IO(__stdcall* CreateThreadpoolIo)(HANDLE fl, PTP_WIN32_IO_CALLBACK pfnio, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
typedef void(__stdcall* StartThreadpoolIo)(PTP_IO pio);
typedef void(__stdcall* CancelThreadpoolIo)(PTP_IO pio);
typedef void(__stdcall* WaitForThreadpoolIoCallbacks)(PTP_IO pio, BOOL fCancelPendingCallbacks);
typedef void(__stdcall* CloseThreadpoolIo)(PTP_IO pio);
typedef BOOL(__stdcall* SetThreadpoolTimerEx)(PTP_TIMER pti, PFILETIME pftDueTime, DWORD msPeriod, DWORD msWindowLength);
typedef BOOL(__stdcall* SetThreadpoolWaitEx)(PTP_WAIT pwa, HANDLE h, PFILETIME pftTimeout, PVOID Reserved);
typedef BOOL(__stdcall* QueueUserWorkItem)(LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags);
typedef BOOL(__stdcall* UnregisterWaitEx)(HANDLE WaitHandle, HANDLE CompletionEvent);
typedef BOOL(__stdcall* CreateTimerQueueTimer)(PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags);
typedef BOOL(__stdcall* ChangeTimerQueueTimer)(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period);
typedef BOOL(__stdcall* DeleteTimerQueueTimer)(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent);
typedef BOOL(__stdcall* DeleteTimerQueueEx)(HANDLE TimerQueue, HANDLE CompletionEvent);
typedef MMRESULT(__stdcall* timeGetSystemTime)(LPMMTIME pmmt, UINT cbmmt);
typedef MMRESULT(__stdcall* timeGetDevCaps)(LPTIMECAPS ptc, UINT cbtc);
typedef MMRESULT(__stdcall* timeBeginPeriod)(UINT uPeriod);
typedef MMRESULT(__stdcall* timeEndPeriod)(UINT uPeriod);
typedef DWORD(__stdcall* GetTimeZoneInformation)(LPTIME_ZONE_INFORMATION lpTimeZoneInformation);
typedef DWORD(__stdcall* GetDynamicTimeZoneInformation)(PDYNAMIC_TIME_ZONE_INFORMATION pTimeZoneInformation);
typedef BOOL(__stdcall* GetTimeZoneInformationForYear)(USHORT wYear, PDYNAMIC_TIME_ZONE_INFORMATION pdtzi, LPTIME_ZONE_INFORMATION ptzi);
typedef DWORD(__stdcall* EnumDynamicTimeZoneInformation)(DWORD dwIndex, PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation);
typedef DWORD(__stdcall* GetDynamicTimeZoneInformationEffectiveYears)(PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation, LPDWORD FirstYear, LPDWORD LastYear);
typedef HANDLE(__stdcall* CreateToolhelp32Snapshot)(DWORD dwFlags, DWORD th32ProcessID);
typedef BOOL(__stdcall* Heap32ListFirst)(HANDLE hSnapshot, LPHEAPLIST32 lphl);
typedef BOOL(__stdcall* Heap32ListNext)(HANDLE hSnapshot, LPHEAPLIST32 lphl);
typedef BOOL(__stdcall* Heap32First)(LPHEAPENTRY32 lphe, DWORD th32ProcessID, ULONG_PTR th32HeapID);
typedef BOOL(__stdcall* Heap32Next)(LPHEAPENTRY32 lphe);
typedef BOOL(__stdcall* Process32FirstW)(HANDLE hSnapshot, LPPROCESSENTRY32W lppe);
typedef BOOL(__stdcall* Process32NextW)(HANDLE hSnapshot, LPPROCESSENTRY32W lppe);
typedef BOOL(__stdcall* Process32First)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
typedef BOOL(__stdcall* Process32Next)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
typedef BOOL(__stdcall* Thread32First)(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
typedef BOOL(__stdcall* Thread32Next)(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
typedef BOOL(__stdcall* Module32FirstW)(HANDLE hSnapshot, LPMODULEENTRY32W lpme);
typedef BOOL(__stdcall* Module32NextW)(HANDLE hSnapshot, LPMODULEENTRY32W lpme);
typedef BOOL(__stdcall* Module32First)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
typedef BOOL(__stdcall* Module32Next)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
typedef SECURITY_STATUS(__stdcall* TokenBindingDeleteBinding)(PCWSTR targetURL);
typedef SECURITY_STATUS(__stdcall* TokenBindingDeleteAllBindings)();
typedef BOOL(__stdcall* TxfLogDestroyReadContext)(PVOID TxfLogContext);
typedef BOOL(__stdcall* TxfLogReadRecords)(PVOID TxfLogContext, ULONG BufferLength, PVOID Buffer, PULONG BytesUsed, PULONG RecordCount);
typedef void(__stdcall* TxfSetThreadMiniVersionForCreate)(USHORT MiniVersion);
typedef void(__stdcall* TxfGetThreadMiniVersionForCreate)(PUSHORT MiniVersion);
typedef HRESULT(__stdcall* UalStart)(PUAL_DATA_BLOB Data);
typedef HRESULT(__stdcall* UalStop)(PUAL_DATA_BLOB Data);
typedef HRESULT(__stdcall* UalInstrument)(PUAL_DATA_BLOB Data);
typedef BOOL(__stdcall* LoadUserProfileA)(HANDLE hToken, LPPROFILEINFOA lpProfileInfo);
typedef BOOL(__stdcall* LoadUserProfileW)(HANDLE hToken, LPPROFILEINFOW lpProfileInfo);
typedef BOOL(__stdcall* UnloadUserProfile)(HANDLE hToken, HANDLE hProfile);
typedef BOOL(__stdcall* GetProfilesDirectoryA)(LPSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetProfilesDirectoryW)(LPWSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* DeleteProfileA)(LPCSTR lpSidString, LPCSTR lpProfilePath, LPCSTR lpComputerName);
typedef BOOL(__stdcall* DeleteProfileW)(LPCWSTR lpSidString, LPCWSTR lpProfilePath, LPCWSTR lpComputerName);
typedef HRESULT(__stdcall* CreateProfile)(LPCWSTR pszUserSid, LPCWSTR pszUserName, LPWSTR pszProfilePath, DWORD cchProfilePath);
typedef BOOL(__stdcall* GetDefaultUserProfileDirectoryA)(LPSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetDefaultUserProfileDirectoryW)(LPWSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetAllUsersProfileDirectoryA)(LPSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetAllUsersProfileDirectoryW)(LPWSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetUserProfileDirectoryA)(HANDLE hToken, LPSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* GetUserProfileDirectoryW)(HANDLE hToken, LPWSTR lpProfileDir, LPDWORD lpcchSize);
typedef BOOL(__stdcall* DestroyEnvironmentBlock)(LPVOID lpEnvironment);
typedef BOOL(__stdcall* ExpandEnvironmentStringsForUserA)(HANDLE hToken, LPCSTR lpSrc, LPSTR lpDest, DWORD dwSize);
typedef BOOL(__stdcall* ExpandEnvironmentStringsForUserW)(HANDLE hToken, LPCWSTR lpSrc, LPWSTR lpDest, DWORD dwSize);
typedef BOOL(__stdcall* RefreshPolicy)(BOOL bMachine);
typedef BOOL(__stdcall* RefreshPolicyEx)(BOOL bMachine, DWORD dwOptions);
typedef HANDLE(__stdcall* EnterCriticalPolicySection)(BOOL bMachine);
typedef BOOL(__stdcall* LeaveCriticalPolicySection)(HANDLE hSection);
typedef BOOL(__stdcall* RegisterGPNotification)(HANDLE hEvent, BOOL bMachine);
typedef BOOL(__stdcall* UnregisterGPNotification)(HANDLE hEvent);
typedef BOOL(__stdcall* FreeGPOListA)(PGROUP_POLICY_OBJECTA pGPOList);
typedef BOOL(__stdcall* FreeGPOListW)(PGROUP_POLICY_OBJECTW pGPOList);
typedef DWORD(__stdcall* ProcessGroupPolicyCompleted)(REFGPEXTENSIONID extensionId, ASYNCCOMPLETIONHANDLE pAsyncHandle, DWORD dwStatus);
typedef DWORD(__stdcall* ProcessGroupPolicyCompletedEx)(REFGPEXTENSIONID extensionId, ASYNCCOMPLETIONHANDLE pAsyncHandle, DWORD dwStatus, HRESULT RsopStatus);
typedef HRESULT(__stdcall* DeleteAppContainerProfile)(PCWSTR pszAppContainerName);
typedef HRESULT(__stdcall* GetAppContainerRegistryLocation)(REGSAM desiredAccess, PHKEY phAppContainerKey);
typedef {'name': 'ScriptString_pSize', 'type': 'SIZE'}(__stdcall* ScriptString_pSize)(SCRIPT_STRING_ANALYSIS ssa);
typedef {'name': 'ScriptString_pcOutChars', 'type': 'int'}(__stdcall* ScriptString_pcOutChars)(SCRIPT_STRING_ANALYSIS ssa);
typedef {'name': 'ScriptString_pLogAttr', 'type': 'SCRIPT_LOGATTR'}(__stdcall* ScriptString_pLogAttr)(SCRIPT_STRING_ANALYSIS ssa);
typedef HRESULT(__stdcall* ScriptStringValidate)(SCRIPT_STRING_ANALYSIS ssa);
typedef BOOL(__stdcall* Beep)(DWORD dwFreq, DWORD dwDuration);
typedef BOOL(__stdcall* BeginPanningFeedback)(HWND hwnd);
typedef BOOL(__stdcall* UpdatePanningFeedback)(HWND hwnd, LONG lTotalOverpanOffsetX, LONG lTotalOverpanOffsetY, BOOL fInInertia);
typedef BOOL(__stdcall* EndPanningFeedback)(HWND hwnd, BOOL fAnimateBack);
typedef HTHEME(__stdcall* OpenThemeData)(HWND hwnd, LPCWSTR pszClassList);
typedef HTHEME(__stdcall* OpenThemeDataForDpi)(HWND hwnd, LPCWSTR pszClassList, UINT dpi);
typedef HTHEME(__stdcall* OpenThemeDataEx)(HWND hwnd, LPCWSTR pszClassList, DWORD dwFlags);
typedef HRESULT(__stdcall* CloseThemeData)(HTHEME hTheme);
typedef HRESULT(__stdcall* DrawThemeBackground)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pRect, LPCRECT pClipRect);
typedef HRESULT(__stdcall* DrawThemeText)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int cchText, DWORD dwTextFlags, DWORD dwTextFlags2, LPCRECT pRect);
typedef HRESULT(__stdcall* GetThemeBackgroundContentRect)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pBoundingRect, LPRECT pContentRect);
typedef HRESULT(__stdcall* GetThemeBackgroundExtent)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pContentRect, LPRECT pExtentRect);
typedef HRESULT(__stdcall* GetThemeTextExtent)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int cchCharCount, DWORD dwTextFlags, LPCRECT pBoundingRect, LPRECT pExtentRect);
typedef HRESULT(__stdcall* DrawThemeEdge)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pDestRect, UINT uEdge, UINT uFlags, LPRECT pContentRect);
typedef HRESULT(__stdcall* DrawThemeIcon)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pRect, HIMAGELIST himl, int iImageIndex);
typedef BOOL(__stdcall* IsThemePartDefined)(HTHEME hTheme, int iPartId, int iStateId);
typedef BOOL(__stdcall* IsThemeBackgroundPartiallyTransparent)(HTHEME hTheme, int iPartId, int iStateId);
typedef HRESULT(__stdcall* GetThemeString)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, LPWSTR pszBuff, int cchMaxBuffChars);
typedef HRESULT(__stdcall* GetThemeRect)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, LPRECT pRect);
typedef HRESULT(__stdcall* SetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);
typedef HRESULT(__stdcall* GetThemeFilename)(HTHEME hTheme, int iPartId, int iStateId, int iPropId, LPWSTR pszThemeFileName, int cchMaxBuffChars);
typedef COLORREF(__stdcall* GetThemeSysColor)(HTHEME hTheme, int iColorId);
typedef HBRUSH(__stdcall* GetThemeSysColorBrush)(HTHEME hTheme, int iColorId);
typedef BOOL(__stdcall* GetThemeSysBool)(HTHEME hTheme, int iBoolId);
typedef int(__stdcall* GetThemeSysSize)(HTHEME hTheme, int iSizeId);
typedef HRESULT(__stdcall* GetThemeSysString)(HTHEME hTheme, int iStringId, LPWSTR pszStringBuff, int cchMaxStringChars);
typedef HTHEME(__stdcall* GetWindowTheme)(HWND hwnd);
typedef HRESULT(__stdcall* EnableThemeDialogTexture)(HWND hwnd, DWORD dwFlags);
typedef BOOL(__stdcall* IsThemeDialogTextureEnabled)(HWND hwnd);
typedef void(__stdcall* SetThemeAppProperties)(DWORD dwFlags);
typedef HRESULT(__stdcall* GetCurrentThemeName)(LPWSTR pszThemeFileName, int cchMaxNameChars, LPWSTR pszColorBuff, int cchMaxColorChars, LPWSTR pszSizeBuff, int cchMaxSizeChars);
typedef HRESULT(__stdcall* GetThemeDocumentationProperty)(LPCWSTR pszThemeName, LPCWSTR pszPropertyName, LPWSTR pszValueBuff, int cchMaxValChars);
typedef HRESULT(__stdcall* EnableTheming)(BOOL fEnable);
typedef HRESULT(__stdcall* SetWindowThemeAttribute)(HWND hwnd, {'data_type': 'Enum', 'enumerators': []} eAttribute, PVOID pvAttribute, DWORD cbAttribute);
typedef HRESULT(__stdcall* SetWindowThemeNonClientAttributes)(HWND hwnd, DWORD dwMask, DWORD dwAttributes);
typedef HRESULT(__stdcall* EndBufferedPaint)(HPAINTBUFFER hBufferedPaint, BOOL fUpdateTarget);
typedef HDC(__stdcall* GetBufferedPaintTargetDC)(HPAINTBUFFER hBufferedPaint);
typedef HDC(__stdcall* GetBufferedPaintDC)(HPAINTBUFFER hBufferedPaint);
typedef HRESULT(__stdcall* BufferedPaintStopAllAnimations)(HWND hwnd);
typedef HRESULT(__stdcall* EndBufferedAnimation)(HANIMATIONBUFFER hbpAnimation, BOOL fUpdateTarget);
typedef BOOL(__stdcall* BufferedPaintRenderAnimation)(HWND hwnd, HDC hdcTarget);
typedef BOOL(__stdcall* IsCompositionActive)();
typedef INT(__stdcall* VDMEnumProcessWOW)(PROCESSENUMPROC fp, LPARAM lparam);
typedef INT(__stdcall* VDMEnumTaskWOWEx)(DWORD dwProcessId, TASKENUMPROCEX fp, LPARAM lparam);
typedef BOOL(__stdcall* IsWindowsXPOrGreater)();
typedef BOOL(__stdcall* IsWindowsXPSP1OrGreater)();
typedef BOOL(__stdcall* IsWindowsXPSP2OrGreater)();
typedef BOOL(__stdcall* IsWindowsXPSP3OrGreater)();
typedef BOOL(__stdcall* IsWindowsVistaOrGreater)();
typedef BOOL(__stdcall* IsWindowsVistaSP1OrGreater)();
typedef BOOL(__stdcall* IsWindowsVistaSP2OrGreater)();
typedef BOOL(__stdcall* IsWindows7OrGreater)();
typedef BOOL(__stdcall* IsWindows7SP1OrGreater)();
typedef BOOL(__stdcall* IsWindows8OrGreater)();
typedef BOOL(__stdcall* IsWindows8Point1OrGreater)();
typedef BOOL(__stdcall* IsWindows10OrGreater)();
typedef BOOL(__stdcall* IsWindowsServer)();
typedef BOOL(__stdcall* ICInstall)(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
typedef BOOL(__stdcall* ICRemove)(DWORD fccType, DWORD fccHandler, UINT wFlags);
typedef HIC(__stdcall* ICOpen)(DWORD fccType, DWORD fccHandler, UINT wMode);
typedef HIC(__stdcall* ICOpenFunction)(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
typedef LRESULT(__stdcall* ICClose)(HIC hic);
typedef LRESULT(__stdcall* ICSendMessage)(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2);
typedef DWORD(__stdcall* ICCompress)(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData, LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid, LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev);
typedef DWORD(__stdcall* ICDecompress)(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits);
typedef DWORD(__stdcall* ICDrawBegin)(HIC hic, DWORD dwFlags, HPALETTE hpal, HWND hwnd, HDC hdc, int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, int xSrc, int ySrc, int dxSrc, int dySrc, DWORD dwRate, DWORD dwScale);
typedef DWORD(__stdcall* ICDraw)(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime);
typedef HIC(__stdcall* ICLocate)(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
typedef HIC(__stdcall* ICGetDisplayFormat)(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
typedef HANDLE(__stdcall* ICImageDecompress)(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut);
typedef BOOL(__stdcall* ICCompressorChoose)(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData, PCOMPVARS pc, LPSTR lpszTitle);
typedef BOOL(__stdcall* ICSeqCompressFrameStart)(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
typedef void(__stdcall* ICSeqCompressFrameEnd)(PCOMPVARS pc);
typedef void(__stdcall* ICCompressorFree)(PCOMPVARS pc);
typedef BOOL(__stdcall* DrawDibClose)(HDRAWDIB hdd);
typedef LPVOID(__stdcall* DrawDibGetBuffer)(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
typedef HPALETTE(__stdcall* DrawDibGetPalette)(HDRAWDIB hdd);
typedef BOOL(__stdcall* DrawDibSetPalette)(HDRAWDIB hdd, HPALETTE hpal);
typedef BOOL(__stdcall* DrawDibChangePalette)(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
typedef UINT(__stdcall* DrawDibRealize)(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
typedef BOOL(__stdcall* DrawDibStart)(HDRAWDIB hdd, DWORD rate);
typedef BOOL(__stdcall* DrawDibStop)(HDRAWDIB hdd);
typedef BOOL(__stdcall* DrawDibBegin)(HDRAWDIB hdd, HDC hdc, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, int dxSrc, int dySrc, UINT wFlags);
typedef BOOL(__stdcall* DrawDibDraw)(HDRAWDIB hdd, HDC hdc, int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, LPVOID lpBits, int xSrc, int ySrc, int dxSrc, int dySrc, UINT wFlags);
typedef BOOL(__stdcall* DrawDibEnd)(HDRAWDIB hdd);
typedef BOOL(__stdcall* DrawDibTime)(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime);
typedef LRESULT(__stdcall* DrawDibProfileDisplay)(LPBITMAPINFOHEADER lpbi);
typedef ULONG(__stdcall* AVIFileAddRef)(PAVIFILE pfile);
typedef ULONG(__stdcall* AVIFileRelease)(PAVIFILE pfile);
typedef HRESULT(__stdcall* AVIFileInfoW)(PAVIFILE pfile, LPAVIFILEINFOW pfi, LONG lSize);
typedef HRESULT(__stdcall* AVIFileInfoA)(PAVIFILE pfile, LPAVIFILEINFOA pfi, LONG lSize);
typedef HRESULT(__stdcall* AVIFileWriteData)(PAVIFILE pfile, DWORD ckid, LPVOID lpData, LONG cbData);
typedef HRESULT(__stdcall* AVIFileEndRecord)(PAVIFILE pfile);
typedef ULONG(__stdcall* AVIStreamAddRef)(PAVISTREAM pavi);
typedef ULONG(__stdcall* AVIStreamRelease)(PAVISTREAM pavi);
typedef HRESULT(__stdcall* AVIStreamInfoW)(PAVISTREAM pavi, LPAVISTREAMINFOW psi, LONG lSize);
typedef HRESULT(__stdcall* AVIStreamInfoA)(PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize);
typedef LONG(__stdcall* AVIStreamFindSample)(PAVISTREAM pavi, LONG lPos, LONG lFlags);
typedef HRESULT(__stdcall* AVIStreamSetFormat)(PAVISTREAM pavi, LONG lPos, LPVOID lpFormat, LONG cbFormat);
typedef HRESULT(__stdcall* AVIStreamWriteData)(PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG cb);
typedef LONG(__stdcall* AVIStreamStart)(PAVISTREAM pavi);
typedef LONG(__stdcall* AVIStreamLength)(PAVISTREAM pavi);
typedef LONG(__stdcall* AVIStreamTimeToSample)(PAVISTREAM pavi, LONG lTime);
typedef LONG(__stdcall* AVIStreamSampleToTime)(PAVISTREAM pavi, LONG lSample);
typedef HRESULT(__stdcall* AVIStreamBeginStreaming)(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
typedef HRESULT(__stdcall* AVIStreamEndStreaming)(PAVISTREAM pavi);
typedef PGETFRAME(__stdcall* AVIStreamGetFrameOpen)(PAVISTREAM pavi, LPBITMAPINFOHEADER lpbiWanted);
typedef LPVOID(__stdcall* AVIStreamGetFrame)(PGETFRAME pg, LONG lPos);
typedef HRESULT(__stdcall* AVIStreamGetFrameClose)(PGETFRAME pg);
typedef HRESULT(__stdcall* AVIBuildFilterW)(LPWSTR lpszFilter, LONG cbFilter, BOOL fSaving);
typedef HRESULT(__stdcall* AVIBuildFilterA)(LPSTR lpszFilter, LONG cbFilter, BOOL fSaving);
typedef HRESULT(__stdcall* AVIPutFileOnClipboard)(PAVIFILE pf);
typedef HRESULT(__stdcall* EditStreamSetNameA)(PAVISTREAM pavi, LPCSTR lpszName);
typedef HRESULT(__stdcall* EditStreamSetNameW)(PAVISTREAM pavi, LPCWSTR lpszName);
typedef HRESULT(__stdcall* EditStreamSetInfoW)(PAVISTREAM pavi, LPAVISTREAMINFOW lpInfo, LONG cbInfo);
typedef HRESULT(__stdcall* EditStreamSetInfoA)(PAVISTREAM pavi, LPAVISTREAMINFOA lpInfo, LONG cbInfo);
typedef HWND(__stdcall* MCIWndCreateA)(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
typedef HWND(__stdcall* MCIWndCreateW)(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile);
typedef HWND(__stdcall* capCreateCaptureWindowA)(LPCSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
typedef BOOL(__stdcall* capGetDriverDescriptionA)(UINT wDriverIndex, LPSTR lpszName, int cbName, LPSTR lpszVer, int cbVer);
typedef HWND(__stdcall* capCreateCaptureWindowW)(LPCWSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
typedef BOOL(__stdcall* capGetDriverDescriptionW)(UINT wDriverIndex, LPWSTR lpszName, int cbName, LPWSTR lpszVer, int cbVer);
typedef BOOL(__stdcall* GetOpenFileNamePreviewA)(LPOPENFILENAMEA lpofn);
typedef BOOL(__stdcall* GetSaveFileNamePreviewA)(LPOPENFILENAMEA lpofn);
typedef BOOL(__stdcall* GetOpenFileNamePreviewW)(LPOPENFILENAMEW lpofn);
typedef BOOL(__stdcall* GetSaveFileNamePreviewW)(LPOPENFILENAMEW lpofn);
typedef DWORD(__stdcall* OpenVirtualDisk)(PVIRTUAL_STORAGE_TYPE VirtualStorageType, PCWSTR Path, VIRTUAL_DISK_ACCESS_MASK VirtualDiskAccessMask, OPEN_VIRTUAL_DISK_FLAG Flags, POPEN_VIRTUAL_DISK_PARAMETERS Parameters, PHANDLE Handle);
typedef DWORD(__stdcall* CreateVirtualDisk)(PVIRTUAL_STORAGE_TYPE VirtualStorageType, PCWSTR Path, VIRTUAL_DISK_ACCESS_MASK VirtualDiskAccessMask, PSECURITY_DESCRIPTOR SecurityDescriptor, CREATE_VIRTUAL_DISK_FLAG Flags, ULONG ProviderSpecificFlags, PCREATE_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped, PHANDLE Handle);
typedef DWORD(__stdcall* AttachVirtualDisk)(HANDLE VirtualDiskHandle, PSECURITY_DESCRIPTOR SecurityDescriptor, ATTACH_VIRTUAL_DISK_FLAG Flags, ULONG ProviderSpecificFlags, PATTACH_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* DetachVirtualDisk)(HANDLE VirtualDiskHandle, DETACH_VIRTUAL_DISK_FLAG Flags, ULONG ProviderSpecificFlags);
typedef DWORD(__stdcall* GetVirtualDiskPhysicalPath)(HANDLE VirtualDiskHandle, PULONG DiskPathSizeInBytes, PWSTR DiskPath);
typedef DWORD(__stdcall* GetStorageDependencyInformation)(HANDLE ObjectHandle, GET_STORAGE_DEPENDENCY_FLAG Flags, ULONG StorageDependencyInfoSize, PSTORAGE_DEPENDENCY_INFO StorageDependencyInfo, PULONG SizeUsed);
typedef DWORD(__stdcall* GetVirtualDiskInformation)(HANDLE VirtualDiskHandle, PULONG VirtualDiskInfoSize, PGET_VIRTUAL_DISK_INFO VirtualDiskInfo, PULONG SizeUsed);
typedef DWORD(__stdcall* SetVirtualDiskInformation)(HANDLE VirtualDiskHandle, PSET_VIRTUAL_DISK_INFO VirtualDiskInfo);
typedef DWORD(__stdcall* GetVirtualDiskOperationProgress)(HANDLE VirtualDiskHandle, LPOVERLAPPED Overlapped, PVIRTUAL_DISK_PROGRESS Progress);
typedef DWORD(__stdcall* CompactVirtualDisk)(HANDLE VirtualDiskHandle, COMPACT_VIRTUAL_DISK_FLAG Flags, PCOMPACT_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* MergeVirtualDisk)(HANDLE VirtualDiskHandle, MERGE_VIRTUAL_DISK_FLAG Flags, PMERGE_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* ExpandVirtualDisk)(HANDLE VirtualDiskHandle, EXPAND_VIRTUAL_DISK_FLAG Flags, PEXPAND_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* ResizeVirtualDisk)(HANDLE VirtualDiskHandle, RESIZE_VIRTUAL_DISK_FLAG Flags, PRESIZE_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* MirrorVirtualDisk)(HANDLE VirtualDiskHandle, MIRROR_VIRTUAL_DISK_FLAG Flags, PMIRROR_VIRTUAL_DISK_PARAMETERS Parameters, LPOVERLAPPED Overlapped);
typedef DWORD(__stdcall* BreakMirrorVirtualDisk)(HANDLE VirtualDiskHandle);
typedef DWORD(__stdcall* AddVirtualDiskParent)(HANDLE VirtualDiskHandle, PCWSTR ParentPath);
typedef DWORD(__stdcall* QueryChangesVirtualDisk)(HANDLE VirtualDiskHandle, PCWSTR ChangeTrackingId, ULONG64 ByteOffset, ULONG64 ByteLength, QUERY_CHANGES_VIRTUAL_DISK_FLAG Flags, PQUERY_CHANGES_VIRTUAL_DISK_RANGE Ranges, PULONG RangeCount, PULONG64 ProcessedLength);
typedef DWORD(__stdcall* TakeSnapshotVhdSet)(HANDLE VirtualDiskHandle, PTAKE_SNAPSHOT_VHDSET_PARAMETERS Parameters, TAKE_SNAPSHOT_VHDSET_FLAG Flags);
typedef DWORD(__stdcall* DeleteSnapshotVhdSet)(HANDLE VirtualDiskHandle, PDELETE_SNAPSHOT_VHDSET_PARAMETERS Parameters, DELETE_SNAPSHOT_VHDSET_FLAG Flags);
typedef DWORD(__stdcall* ModifyVhdSet)(HANDLE VirtualDiskHandle, PMODIFY_VHDSET_PARAMETERS Parameters, MODIFY_VHDSET_FLAG Flags);
typedef DWORD(__stdcall* ApplySnapshotVhdSet)(HANDLE VirtualDiskHandle, PAPPLY_SNAPSHOT_VHDSET_PARAMETERS Parameters, APPLY_SNAPSHOT_VHDSET_FLAG Flags);
typedef DWORD(__stdcall* RawSCSIVirtualDisk)(HANDLE VirtualDiskHandle, PRAW_SCSI_VIRTUAL_DISK_PARAMETERS Parameters, RAW_SCSI_VIRTUAL_DISK_FLAG Flags, PRAW_SCSI_VIRTUAL_DISK_RESPONSE Response);
typedef void(__stdcall* WcmFreeMemory)(PVOID pMemory);
typedef HWCT(__stdcall* OpenThreadWaitChainSession)(DWORD Flags, PWAITCHAINCALLBACK callback);
typedef void(__stdcall* CloseThreadWaitChainSession)(HWCT WctHandle);
typedef BOOL(__stdcall* GetThreadWaitChain)(HWCT WctHandle, DWORD_PTR Context, DWORD Flags, DWORD ThreadId, LPDWORD NodeCount, PWAITCHAIN_NODE_INFO NodeInfoArray, LPBOOL IsCycle);
typedef void(__stdcall* RegisterWaitChainCOMCallback)(PCOGETCALLSTATE CallStateCallback, PCOGETACTIVATIONSTATE ActivationStateCallback);
typedef DWORD(__stdcall* WdsBpCloseHandle)(HANDLE hHandle);
typedef DWORD(__stdcall* WdsBpQueryOption)(HANDLE hHandle, ULONG uOption, ULONG uValueLen, PVOID pValue, PULONG puBytes);
typedef DWORD(__stdcall* WdsBpAddOption)(HANDLE hHandle, ULONG uOption, ULONG uValueLen, PVOID pValue);
typedef DWORD(__stdcall* WdsBpGetOptionBuffer)(HANDLE hHandle, ULONG uBufferLen, PVOID pBuffer, PULONG puBytes);
typedef HRESULT(__stdcall* WdsCliClose)(HANDLE Handle);
typedef HRESULT(__stdcall* WdsCliRegisterTrace)(PFN_WdsCliTraceFunction pfn);
typedef HRESULT(__stdcall* WdsCliFindFirstImage)(HANDLE hSession, PHANDLE phFindHandle);
typedef HRESULT(__stdcall* WdsCliFindNextImage)(HANDLE Handle);
typedef HRESULT(__stdcall* WdsCliGetEnumerationFlags)(HANDLE Handle, PDWORD pdwFlags);
typedef HRESULT(__stdcall* WdsCliGetImageHandleFromFindHandle)(HANDLE FindHandle, PHANDLE phImageHandle);
typedef HRESULT(__stdcall* WdsCliGetImageHandleFromTransferHandle)(HANDLE hTransfer, PHANDLE phImageHandle);
typedef HRESULT(__stdcall* WdsCliCreateSession)(PWSTR pwszServer, PWDS_CLI_CRED pCred, PHANDLE phSession);
typedef HRESULT(__stdcall* WdsCliAuthorizeSession)(HANDLE hSession, PWDS_CLI_CRED pCred);
typedef HRESULT(__stdcall* WdsCliInitializeLog)(HANDLE hSession, ULONG ulClientArchitecture, PWSTR pwszClientId, PWSTR pwszClientAddress);
typedef HRESULT(__stdcall* WdsCliLog)(HANDLE hSession, ULONG ulLogLevel, ULONG ulMessageCode);
typedef HRESULT(__stdcall* WdsCliGetImageIndex)(HANDLE hIfh, PDWORD pdwValue);
typedef HRESULT(__stdcall* WdsCliGetImageArchitecture)(HANDLE hIfh, PDWORD pdwValue);
typedef HRESULT(__stdcall* WdsCliGetImageSize)(HANDLE hIfh, PULONGLONG pullValue);
typedef HRESULT(__stdcall* WdsCliGetTransferSize)(HANDLE hIfh, PULONGLONG pullValue);
typedef HRESULT(__stdcall* WdsCliTransferImage)(HANDLE hImage, PWSTR pwszLocalPath, DWORD dwFlags, DWORD dwReserved, PFN_WdsCliCallback pfnWdsCliCallback, PVOID pvUserData, PHANDLE phTransfer);
typedef HRESULT(__stdcall* WdsCliTransferFile)(PCWSTR pwszServer, PCWSTR pwszNamespace, PCWSTR pwszRemoteFilePath, PCWSTR pwszLocalFilePath, DWORD dwFlags, DWORD dwReserved, PFN_WdsCliCallback pfnWdsCliCallback, PVOID pvUserData, PHANDLE phTransfer);
typedef HRESULT(__stdcall* WdsCliCancelTransfer)(HANDLE hTransfer);
typedef HRESULT(__stdcall* WdsCliWaitForTransfer)(HANDLE hTransfer);
typedef DWORD(__stdcall* PxeProviderRegister)(LPCWSTR pszProviderName, LPCWSTR pszModulePath, PXE_REG_INDEX Index, BOOL bIsCritical, PHKEY phProviderKey);
typedef DWORD(__stdcall* PxeProviderUnRegister)(LPCWSTR pszProviderName);
typedef DWORD(__stdcall* PxeProviderQueryIndex)(LPCWSTR pszProviderName, PULONG puIndex);
typedef DWORD(__stdcall* PxeProviderEnumClose)(HANDLE hEnum);
typedef DWORD(__stdcall* PxeProviderFreeInfo)(PPXE_PROVIDER pProvider);
typedef DWORD(__stdcall* PxeRegisterCallback)(HANDLE hProvider, PXE_CALLBACK_TYPE CallbackType, PVOID pCallbackFunction, PVOID pContext);
typedef DWORD(__stdcall* PxeAsyncRecvDone)(HANDLE hClientRequest, PXE_BOOT_ACTION Action);
typedef DWORD(__stdcall* PxeTrace)(HANDLE hProvider, PXE_SEVERITY Severity, LPCWSTR pszFormat);
typedef PVOID(__stdcall* PxePacketAllocate)(HANDLE hProvider, HANDLE hClientRequest, ULONG uSize);
typedef DWORD(__stdcall* PxePacketFree)(HANDLE hProvider, HANDLE hClientRequest, PVOID pPacket);
typedef DWORD(__stdcall* PxeProviderSetAttribute)(HANDLE hProvider, PXE_PROVIDER_ATTRIBUTE Attribute, PVOID pParameterBuffer, ULONG uParamLen);
typedef DWORD(__stdcall* PxeDhcpInitialize)(PVOID pRecvPacket, ULONG uRecvPacketLen, PVOID pReplyPacket, ULONG uMaxReplyPacketLen, PULONG puReplyPacketLen);
typedef DWORD(__stdcall* PxeDhcpv6Initialize)(PVOID pRequest, ULONG cbRequest, PVOID pReply, ULONG cbReply, PULONG pcbReplyUsed);
typedef DWORD(__stdcall* PxeDhcpAppendOption)(PVOID pReplyPacket, ULONG uMaxReplyPacketLen, PULONG puReplyPacketLen, BYTE bOption, BYTE bOptionLen, PVOID pValue);
typedef DWORD(__stdcall* PxeDhcpv6AppendOption)(PVOID pReply, ULONG cbReply, PULONG pcbReplyUsed, WORD wOptionType, WORD cbOption, PVOID pOption);
typedef DWORD(__stdcall* PxeDhcpAppendOptionRaw)(PVOID pReplyPacket, ULONG uMaxReplyPacketLen, PULONG puReplyPacketLen, USHORT uBufferLen, PVOID pBuffer);
typedef DWORD(__stdcall* PxeDhcpv6AppendOptionRaw)(PVOID pReply, ULONG cbReply, PULONG pcbReplyUsed, USHORT cbBuffer, PVOID pBuffer);
typedef DWORD(__stdcall* PxeDhcpIsValid)(PVOID pPacket, ULONG uPacketLen, BOOL bRequestPacket, PBOOL pbPxeOptionPresent);
typedef DWORD(__stdcall* PxeDhcpv6IsValid)(PVOID pPacket, ULONG uPacketLen, BOOL bRequestPacket, PBOOL pbPxeOptionPresent);
typedef DWORD(__stdcall* PxeDhcpv6CreateRelayRepl)(PPXE_DHCPV6_NESTED_RELAY_MESSAGE pRelayMessages, ULONG nRelayMessages, PBYTE pInnerPacket, ULONG cbInnerPacket, PVOID pReplyBuffer, ULONG cbReplyBuffer, PULONG pcbReplyBuffer);
typedef DWORD(__stdcall* PxeGetServerInfo)(PXE_GSI_TYPE uInfoType, PVOID pBuffer, ULONG uBufferLen);
typedef DWORD(__stdcall* PxeGetServerInfoEx)(PXE_GSI_TYPE uInfoType, PVOID pBuffer, ULONG uBufferLen, PULONG puBufferUsed);
typedef DWORD(__stdcall* WdsTransportClientInitializeSession)(PWDS_TRANSPORTCLIENT_REQUEST pSessionRequest, PVOID pCallerData, PHANDLE hSessionKey);
typedef DWORD(__stdcall* WdsTransportClientRegisterCallback)(HANDLE hSessionKey, TRANSPORTCLIENT_CALLBACK_ID CallbackId, PVOID pfnCallback);
typedef DWORD(__stdcall* WdsTransportClientStartSession)(HANDLE hSessionKey);
typedef DWORD(__stdcall* WdsTransportClientCompleteReceive)(HANDLE hSessionKey, ULONG ulSize, PULARGE_INTEGER pullOffset);
typedef DWORD(__stdcall* WdsTransportClientCancelSession)(HANDLE hSessionKey);
typedef DWORD(__stdcall* WdsTransportClientWaitForCompletion)(HANDLE hSessionKey, ULONG uTimeout);
typedef DWORD(__stdcall* WdsTransportClientQueryStatus)(HANDLE hSessionKey, PULONG puStatus, PULONG puErrorCode);
typedef DWORD(__stdcall* WdsTransportClientCloseSession)(HANDLE hSessionKey);
typedef DWORD(__stdcall* WdsTransportClientAddRefBuffer)(PVOID pvBuffer);
typedef DWORD(__stdcall* WdsTransportClientReleaseBuffer)(PVOID pvBuffer);
typedef HRESULT(__stdcall* WdsTransportServerRegisterCallback)(HANDLE hProvider, TRANSPORTPROVIDER_CALLBACK_ID CallbackId, PVOID pfnCallback);
typedef HRESULT(__stdcall* WdsTransportServerCompleteRead)(HANDLE hProvider, ULONG ulBytesRead, PVOID pvUserData, HRESULT hReadResult);
typedef HRESULT(__stdcall* WdsTransportServerTrace)(HANDLE hProvider, WDS_MC_SEVERITY Severity, LPCWSTR pwszFormat);
typedef HRESULT(__stdcall* WdsTransportServerTraceV)(HANDLE hProvider, WDS_MC_SEVERITY Severity, LPCWSTR pwszFormat, va_list Params);
typedef PVOID(__stdcall* WdsTransportServerAllocateBuffer)(HANDLE hProvider, ULONG ulBufferSize);
typedef HRESULT(__stdcall* WdsTransportServerFreeBuffer)(HANDLE hProvider, PVOID pvBuffer);
typedef HRESULT(__stdcall* WebSocketEndServerHandshake)(WEB_SOCKET_HANDLE hWebSocket);
typedef void(__stdcall* WebSocketCompleteAction)(WEB_SOCKET_HANDLE hWebSocket, PVOID pvActionContext, ULONG ulBytesTransferred);
typedef void(__stdcall* WebSocketAbortHandle)(WEB_SOCKET_HANDLE hWebSocket);
typedef void(__stdcall* WebSocketDeleteHandle)(WEB_SOCKET_HANDLE hWebSocket);
typedef HRESULT(__stdcall* WerReportSetParameter)(HREPORT hReportHandle, DWORD dwparamID, PCWSTR pwzName, PCWSTR pwzValue);
typedef HRESULT(__stdcall* WerReportAddFile)(HREPORT hReportHandle, PCWSTR pwzPath, WER_FILE_TYPE repFileType, DWORD dwFileFlags);
typedef HRESULT(__stdcall* WerReportSetUIOption)(HREPORT hReportHandle, WER_REPORT_UI repUITypeID, PCWSTR pwzValue);
typedef HRESULT(__stdcall* WerReportSubmit)(HREPORT hReportHandle, WER_CONSENT consent, DWORD dwFlags, PWER_SUBMIT_RESULT pSubmitResult);
typedef HRESULT(__stdcall* WerReportAddDump)(HREPORT hReportHandle, HANDLE hProcess, HANDLE hThread, WER_DUMP_TYPE dumpType, PWER_EXCEPTION_INFORMATION pExceptionParam, PWER_DUMP_CUSTOM_OPTIONS pDumpCustomOptions, DWORD dwFlags);
typedef HRESULT(__stdcall* WerReportCloseHandle)(HREPORT hReportHandle);
typedef HRESULT(__stdcall* WerRegisterFile)(PCWSTR pwzFile, WER_REGISTER_FILE_TYPE regFileType, DWORD dwFlags);
typedef HRESULT(__stdcall* WerUnregisterFile)(PCWSTR pwzFilePath);
typedef HRESULT(__stdcall* WerRegisterMemoryBlock)(PVOID pvAddress, DWORD dwSize);
typedef HRESULT(__stdcall* WerUnregisterMemoryBlock)(PVOID pvAddress);
typedef HRESULT(__stdcall* WerRegisterCustomMetadata)(PCWSTR key, PCWSTR value);
typedef HRESULT(__stdcall* WerRegisterAdditionalProcess)(DWORD processId, DWORD captureExtraInfoForThreadId);
typedef HRESULT(__stdcall* WerUnregisterAdditionalProcess)(DWORD processId);
typedef HRESULT(__stdcall* WerRegisterAppLocalDump)(PCWSTR localAppDataRelativePath);
typedef HRESULT(__stdcall* WerUnregisterAppLocalDump)();
typedef HRESULT(__stdcall* WerSetFlags)(DWORD dwFlags);
typedef HRESULT(__stdcall* WerGetFlags)(HANDLE hProcess, PDWORD pdwFlags);
typedef HRESULT(__stdcall* WerAddExcludedApplication)(PCWSTR pwzExeName, BOOL bAllUsers);
typedef HRESULT(__stdcall* WerRemoveExcludedApplication)(PCWSTR pwzExeName, BOOL bAllUsers);
typedef HRESULT(__stdcall* WerRegisterRuntimeExceptionModule)(PCWSTR pwszOutOfProcessCallbackDll, PVOID pContext);
typedef HRESULT(__stdcall* WerUnregisterRuntimeExceptionModule)(PCWSTR pwszOutOfProcessCallbackDll, PVOID pContext);
typedef HRESULT(__stdcall* WerStoreOpen)(REPORT_STORE_TYPES repStoreType, PHREPORTSTORE phReportStore);
typedef void(__stdcall* WerStoreClose)(HREPORTSTORE hReportStore);
typedef HRESULT(__stdcall* WerStoreQueryReportMetadataV2)(HREPORTSTORE hReportStore, PCWSTR pszReportKey, PWER_REPORT_METADATA_V2 pReportMetadata);
typedef void(__stdcall* WerFreeString)(PCWSTR pwszStr);
typedef DWORD(__stdcall* GetEnvironmentVariableA)(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize);
typedef DWORD(__stdcall* GetEnvironmentVariableW)(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize);
typedef BOOL(__stdcall* SetEnvironmentVariableA)(LPCSTR lpName, LPCSTR lpValue);
typedef BOOL(__stdcall* SetEnvironmentVariableW)(LPCWSTR lpName, LPCWSTR lpValue);
typedef BOOL(__stdcall* SetCurrentDirectoryA)(LPCSTR lpPathName);
typedef BOOL(__stdcall* SetCurrentDirectoryW)(LPCWSTR lpPathName);
typedef DWORD(__stdcall* GetCurrentDirectoryA)(DWORD nBufferLength, LPSTR lpBuffer);
typedef DWORD(__stdcall* GetCurrentDirectoryW)(DWORD nBufferLength, LPWSTR lpBuffer);
typedef BOOL(__stdcall* CreateDirectoryA)(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* CreateDirectoryW)(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* DefineDosDeviceW)(DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath);
typedef BOOL(__stdcall* DeleteFileA)(LPCSTR lpFileName);
typedef BOOL(__stdcall* DeleteFileW)(LPCWSTR lpFileName);
typedef BOOL(__stdcall* DeleteVolumeMountPointW)(LPCWSTR lpszVolumeMountPoint);
typedef HANDLE(__stdcall* FindFirstVolumeW)(LPWSTR lpszVolumeName, DWORD cchBufferLength);
typedef BOOL(__stdcall* FindNextVolumeW)(HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength);
typedef DWORD(__stdcall* GetLogicalDriveStringsW)(DWORD nBufferLength, LPWSTR lpBuffer);
typedef DWORD(__stdcall* GetShortPathNameW)(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer);
typedef UINT(__stdcall* GetTempFileNameW)(LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName);
typedef BOOL(__stdcall* GetVolumePathNameW)(LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength);
typedef DWORD(__stdcall* QueryDosDeviceW)(LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax);
typedef BOOL(__stdcall* GetVolumeNameForVolumeMountPointW)(LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength);
typedef BOOL(__stdcall* GetVolumePathNamesForVolumeNameW)(LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength);
typedef UINT(__stdcall* GetTempFileNameA)(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName);
typedef HANDLE(__stdcall* CreateNamedPipeW)(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* WaitNamedPipeW)(LPCWSTR lpNamedPipeName, DWORD nTimeOut);
typedef BOOL(__stdcall* GetNamedPipeClientComputerNameW)(HANDLE Pipe, LPWSTR ClientComputerName, ULONG ClientComputerNameLength);
typedef BOOL(__stdcall* GetNamedPipeHandleStateW)(HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize);
typedef BOOL(__stdcall* CallNamedPipeW)(LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut);
typedef HANDLE(__stdcall* CreateSemaphoreExW)(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateSemaphoreW)(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName);
typedef HANDLE(__stdcall* CreateFileMappingW)(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenFileMappingW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
typedef HANDLE(__stdcall* CreateFileMappingNumaW)(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName, DWORD nndPreferred);
typedef HANDLE(__stdcall* CreateJobObjectW)(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName);
typedef HANDLE(__stdcall* OpenJobObjectW)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
typedef BOOL(__stdcall* Wow64GetThreadContext)(HANDLE hThread, PWOW64_CONTEXT lpContext);
typedef DWORD(__stdcall* Wow64SuspendThread)(HANDLE hThread);
typedef HRSRC(__stdcall* FindResourceExW)(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage);
typedef HRSRC(__stdcall* FindResourceW)(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType);
typedef BOOL(__stdcall* EnumResourceNamesW)(HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam);
typedef BOOL(__stdcall* AccessCheckAndAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeAndAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeResultListAndAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccessList, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeResultListAndAuditAlarmByHandleW)(LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccessList, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* GetFileSecurityW)(LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* ObjectCloseAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
typedef BOOL(__stdcall* ObjectDeleteAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
typedef BOOL(__stdcall* ObjectOpenAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose);
typedef BOOL(__stdcall* ObjectPrivilegeAuditAlarmW)(LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
typedef BOOL(__stdcall* PrivilegedServiceAuditAlarmW)(LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
typedef BOOL(__stdcall* SetFileSecurityW)(LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef HANDLE(__stdcall* CreatePrivateNamespaceW)(LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes, LPVOID lpBoundaryDescriptor, LPCWSTR lpAliasPrefix);
typedef HANDLE(__stdcall* OpenPrivateNamespaceW)(LPVOID lpBoundaryDescriptor, LPCWSTR lpAliasPrefix);
typedef HANDLE(__stdcall* CreateBoundaryDescriptorW)(LPCWSTR Name, ULONG Flags);
typedef HGLOBAL(__stdcall* GlobalAlloc)(UINT uFlags, SIZE_T dwBytes);
typedef HGLOBAL(__stdcall* GlobalReAlloc)(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags);
typedef SIZE_T(__stdcall* GlobalSize)(HGLOBAL hMem);
typedef BOOL(__stdcall* GlobalUnlock)(HGLOBAL hMem);
typedef LPVOID(__stdcall* GlobalLock)(HGLOBAL hMem);
typedef UINT(__stdcall* GlobalFlags)(HGLOBAL hMem);
typedef HGLOBAL(__stdcall* GlobalHandle)(LPCVOID pMem);
typedef HGLOBAL(__stdcall* GlobalFree)(HGLOBAL hMem);
typedef void(__stdcall* GlobalMemoryStatus)(LPMEMORYSTATUS lpBuffer);
typedef HLOCAL(__stdcall* LocalAlloc)(UINT uFlags, SIZE_T uBytes);
typedef HLOCAL(__stdcall* LocalReAlloc)(HLOCAL hMem, SIZE_T uBytes, UINT uFlags);
typedef LPVOID(__stdcall* LocalLock)(HLOCAL hMem);
typedef HLOCAL(__stdcall* LocalHandle)(LPCVOID pMem);
typedef BOOL(__stdcall* LocalUnlock)(HLOCAL hMem);
typedef SIZE_T(__stdcall* LocalSize)(HLOCAL hMem);
typedef UINT(__stdcall* LocalFlags)(HLOCAL hMem);
typedef HLOCAL(__stdcall* LocalFree)(HLOCAL hMem);
typedef BOOL(__stdcall* GetBinaryTypeA)(LPCSTR lpApplicationName, LPDWORD lpBinaryType);
typedef BOOL(__stdcall* GetBinaryTypeW)(LPCWSTR lpApplicationName, LPDWORD lpBinaryType);
typedef DWORD(__stdcall* GetShortPathNameA)(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer);
typedef DWORD(__stdcall* GetLongPathNameTransactedA)(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer, HANDLE hTransaction);
typedef DWORD(__stdcall* GetLongPathNameTransactedW)(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer, HANDLE hTransaction);
typedef BOOL(__stdcall* GetProcessAffinityMask)(HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask);
typedef BOOL(__stdcall* SetProcessAffinityMask)(HANDLE hProcess, DWORD_PTR dwProcessAffinityMask);
typedef BOOL(__stdcall* GetProcessIoCounters)(HANDLE hProcess, PIO_COUNTERS lpIoCounters);
typedef BOOL(__stdcall* GetProcessWorkingSetSize)(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize);
typedef BOOL(__stdcall* SetProcessWorkingSetSize)(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize);
typedef void(__stdcall* FatalExit)(int ExitCode);
typedef void(__stdcall* SwitchToFiber)(LPVOID lpFiber);
typedef void(__stdcall* DeleteFiber)(LPVOID lpFiber);
typedef LPVOID(__stdcall* CreateFiberEx)(SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);
typedef LPVOID(__stdcall* ConvertThreadToFiberEx)(LPVOID lpParameter, DWORD dwFlags);
typedef LPVOID(__stdcall* CreateFiber)(SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);
typedef LPVOID(__stdcall* ConvertThreadToFiber)(LPVOID lpParameter);
typedef BOOL(__stdcall* GetUmsCompletionListEvent)(PUMS_COMPLETION_LIST UmsCompletionList, PHANDLE UmsCompletionEvent);
typedef BOOL(__stdcall* ExecuteUmsThread)(PUMS_CONTEXT UmsThread);
typedef BOOL(__stdcall* UmsThreadYield)(PVOID SchedulerParam);
typedef BOOL(__stdcall* DeleteUmsCompletionList)(PUMS_COMPLETION_LIST UmsCompletionList);
typedef PUMS_CONTEXT(__stdcall* GetNextUmsListItem)(PUMS_CONTEXT UmsContext);
typedef BOOL(__stdcall* QueryUmsThreadInformation)(PUMS_CONTEXT UmsThread, UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, ULONG UmsThreadInformationLength, PULONG ReturnLength);
typedef BOOL(__stdcall* SetUmsThreadInformation)(PUMS_CONTEXT UmsThread, UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, ULONG UmsThreadInformationLength);
typedef BOOL(__stdcall* DeleteUmsThreadContext)(PUMS_CONTEXT UmsThread);
typedef BOOL(__stdcall* EnterUmsSchedulingMode)(PUMS_SCHEDULER_STARTUP_INFO SchedulerStartupInfo);
typedef BOOL(__stdcall* GetUmsSystemThreadInformation)(HANDLE ThreadHandle, PUMS_SYSTEM_THREAD_INFORMATION SystemThreadInfo);
typedef DWORD_PTR(__stdcall* SetThreadAffinityMask)(HANDLE hThread, DWORD_PTR dwThreadAffinityMask);
typedef BOOL(__stdcall* SetProcessDEPPolicy)(DWORD dwFlags);
typedef BOOL(__stdcall* GetProcessDEPPolicy)(HANDLE hProcess, LPDWORD lpFlags, PBOOL lpPermanent);
typedef BOOL(__stdcall* RequestWakeupLatency)(LATENCY_TIME latency);
typedef BOOL(__stdcall* GetThreadSelectorEntry)(HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry);
typedef EXECUTION_STATE(__stdcall* SetThreadExecutionState)(EXECUTION_STATE esFlags);
typedef HANDLE(__stdcall* PowerCreateRequest)(PREASON_CONTEXT Context);
typedef BOOL(__stdcall* PowerSetRequest)(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);
typedef BOOL(__stdcall* PowerClearRequest)(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);
typedef BOOL(__stdcall* SetFileCompletionNotificationModes)(HANDLE FileHandle, UCHAR Flags);
typedef BOOL(__stdcall* Wow64GetThreadSelectorEntry)(HANDLE hThread, DWORD dwSelector, PWOW64_LDT_ENTRY lpSelectorEntry);
typedef BOOL(__stdcall* DebugSetProcessKillOnExit)(BOOL KillOnExit);
typedef BOOL(__stdcall* DebugBreakProcess)(HANDLE Process);
typedef BOOL(__stdcall* PulseEvent)(HANDLE hEvent);
typedef ATOM(__stdcall* GlobalDeleteAtom)(ATOM nAtom);
typedef BOOL(__stdcall* InitAtomTable)(DWORD nSize);
typedef ATOM(__stdcall* DeleteAtom)(ATOM nAtom);
typedef UINT(__stdcall* SetHandleCount)(UINT uNumber);
typedef BOOL(__stdcall* SetFileShortNameA)(HANDLE hFile, LPCSTR lpShortName);
typedef BOOL(__stdcall* SetFileShortNameW)(HANDLE hFile, LPCWSTR lpShortName);
typedef DWORD(__stdcall* LoadModule)(LPCSTR lpModuleName, LPVOID lpParameterBlock);
typedef UINT(__stdcall* WinExec)(LPCSTR lpCmdLine, UINT uCmdShow);
typedef BOOL(__stdcall* ClearCommBreak)(HANDLE hFile);
typedef BOOL(__stdcall* ClearCommError)(HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat);
typedef BOOL(__stdcall* SetupComm)(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue);
typedef BOOL(__stdcall* EscapeCommFunction)(HANDLE hFile, DWORD dwFunc);
typedef BOOL(__stdcall* GetCommConfig)(HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
typedef BOOL(__stdcall* GetCommMask)(HANDLE hFile, LPDWORD lpEvtMask);
typedef BOOL(__stdcall* GetCommProperties)(HANDLE hFile, LPCOMMPROP lpCommProp);
typedef BOOL(__stdcall* GetCommModemStatus)(HANDLE hFile, LPDWORD lpModemStat);
typedef BOOL(__stdcall* GetCommState)(HANDLE hFile, LPDCB lpDCB);
typedef BOOL(__stdcall* GetCommTimeouts)(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts);
typedef BOOL(__stdcall* PurgeComm)(HANDLE hFile, DWORD dwFlags);
typedef BOOL(__stdcall* SetCommBreak)(HANDLE hFile);
typedef BOOL(__stdcall* SetCommConfig)(HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize);
typedef BOOL(__stdcall* SetCommMask)(HANDLE hFile, DWORD dwEvtMask);
typedef BOOL(__stdcall* SetCommState)(HANDLE hFile, LPDCB lpDCB);
typedef BOOL(__stdcall* SetCommTimeouts)(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts);
typedef BOOL(__stdcall* TransmitCommChar)(HANDLE hFile, char cChar);
typedef BOOL(__stdcall* WaitCommEvent)(HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped);
typedef HANDLE(__stdcall* OpenCommPort)(ULONG uPortNumber, DWORD dwDesiredAccess, DWORD dwFlagsAndAttributes);
typedef ULONG(__stdcall* GetCommPorts)(PULONG lpPortNumbers, ULONG uPortNumbersCount, PULONG puPortNumbersFound);
typedef DWORD(__stdcall* SetTapePosition)(HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate);
typedef DWORD(__stdcall* GetTapePosition)(HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh);
typedef DWORD(__stdcall* PrepareTape)(HANDLE hDevice, DWORD dwOperation, BOOL bImmediate);
typedef DWORD(__stdcall* EraseTape)(HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate);
typedef DWORD(__stdcall* CreateTapePartition)(HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize);
typedef DWORD(__stdcall* WriteTapemark)(HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate);
typedef DWORD(__stdcall* GetTapeStatus)(HANDLE hDevice);
typedef DWORD(__stdcall* GetTapeParameters)(HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation);
typedef DWORD(__stdcall* SetTapeParameters)(HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation);
typedef int(__stdcall* MulDiv)(int nNumber, int nNumerator, int nDenominator);
typedef BOOL(__stdcall* GetSystemRegistryQuota)(PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed);
typedef BOOL(__stdcall* DosDateTimeToFileTime)(WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime);
typedef HANDLE(__stdcall* CreateMailslotA)(LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef HANDLE(__stdcall* CreateMailslotW)(LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* GetMailslotInfo)(HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout);
typedef BOOL(__stdcall* SetMailslotInfo)(HANDLE hMailslot, DWORD lReadTimeout);
typedef BOOL(__stdcall* EncryptFileA)(LPCSTR lpFileName);
typedef BOOL(__stdcall* EncryptFileW)(LPCWSTR lpFileName);
typedef BOOL(__stdcall* DecryptFileA)(LPCSTR lpFileName, DWORD dwReserved);
typedef BOOL(__stdcall* DecryptFileW)(LPCWSTR lpFileName, DWORD dwReserved);
typedef BOOL(__stdcall* FileEncryptionStatusA)(LPCSTR lpFileName, LPDWORD lpStatus);
typedef BOOL(__stdcall* FileEncryptionStatusW)(LPCWSTR lpFileName, LPDWORD lpStatus);
typedef DWORD(__stdcall* ReadEncryptedFileRaw)(PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext);
typedef DWORD(__stdcall* WriteEncryptedFileRaw)(PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext);
typedef void(__stdcall* CloseEncryptedFileRaw)(PVOID pvContext);
typedef int(__stdcall* lstrcmpA)(LPCSTR lpString1, LPCSTR lpString2);
typedef int(__stdcall* lstrcmpW)(LPCWSTR lpString1, LPCWSTR lpString2);
typedef int(__stdcall* lstrcmpiA)(LPCSTR lpString1, LPCSTR lpString2);
typedef int(__stdcall* lstrcmpiW)(LPCWSTR lpString1, LPCWSTR lpString2);
typedef LPSTR(__stdcall* lstrcpynA)(LPSTR lpString1, LPCSTR lpString2, int iMaxLength);
typedef LPWSTR(__stdcall* lstrcpynW)(LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength);
typedef LPSTR(__stdcall* lstrcpyA)(LPSTR lpString1, LPCSTR lpString2);
typedef LPWSTR(__stdcall* lstrcpyW)(LPWSTR lpString1, LPCWSTR lpString2);
typedef LPSTR(__stdcall* lstrcatA)(LPSTR lpString1, LPCSTR lpString2);
typedef LPWSTR(__stdcall* lstrcatW)(LPWSTR lpString1, LPCWSTR lpString2);
typedef int(__stdcall* lstrlenA)(LPCSTR lpString);
typedef int(__stdcall* lstrlenW)(LPCWSTR lpString);
typedef HFILE(__stdcall* OpenFile)(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle);
typedef HFILE(__stdcall* _lopen)(LPCSTR lpPathName, int iReadWrite);
typedef HFILE(__stdcall* _lcreat)(LPCSTR lpPathName, int iAttribute);
typedef UINT(__stdcall* _lread)(HFILE hFile, LPVOID lpBuffer, UINT uBytes);
typedef UINT(__stdcall* _lwrite)(HFILE hFile, LPCCH lpBuffer, UINT uBytes);
typedef HFILE(__stdcall* _lclose)(HFILE hFile);
typedef LONG(__stdcall* _llseek)(HFILE hFile, LONG lOffset, int iOrigin);
typedef HANDLE(__stdcall* CreateSemaphoreA)(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName);
typedef HANDLE(__stdcall* CreateSemaphoreExA)(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
typedef HANDLE(__stdcall* CreateFileMappingA)(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName);
typedef HANDLE(__stdcall* CreateFileMappingNumaA)(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName, DWORD nndPreferred);
typedef HANDLE(__stdcall* OpenFileMappingA)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
typedef DWORD(__stdcall* GetLogicalDriveStringsA)(DWORD nBufferLength, LPSTR lpBuffer);
typedef HMODULE(__stdcall* LoadPackagedLibrary)(LPCWSTR lpwLibFileName, DWORD Reserved);
typedef BOOL(__stdcall* QueryFullProcessImageNameA)(HANDLE hProcess, DWORD dwFlags, LPSTR lpExeName, PDWORD lpdwSize);
typedef BOOL(__stdcall* QueryFullProcessImageNameW)(HANDLE hProcess, DWORD dwFlags, LPWSTR lpExeName, PDWORD lpdwSize);
typedef DWORD(__stdcall* GetFirmwareEnvironmentVariableA)(LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize);
typedef DWORD(__stdcall* GetFirmwareEnvironmentVariableW)(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize);
typedef DWORD(__stdcall* GetFirmwareEnvironmentVariableExA)(LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize, PDWORD pdwAttribubutes);
typedef DWORD(__stdcall* GetFirmwareEnvironmentVariableExW)(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize, PDWORD pdwAttribubutes);
typedef BOOL(__stdcall* SetFirmwareEnvironmentVariableA)(LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize);
typedef BOOL(__stdcall* SetFirmwareEnvironmentVariableW)(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize);
typedef BOOL(__stdcall* SetFirmwareEnvironmentVariableExA)(LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize, DWORD dwAttributes);
typedef BOOL(__stdcall* SetFirmwareEnvironmentVariableExW)(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize, DWORD dwAttributes);
typedef BOOL(__stdcall* GetFirmwareType)(PFIRMWARE_TYPE FirmwareType);
typedef BOOL(__stdcall* IsNativeVhdBoot)(PBOOL NativeVhdBoot);
typedef HRSRC(__stdcall* FindResourceA)(HMODULE hModule, LPCSTR lpName, LPCSTR lpType);
typedef HRSRC(__stdcall* FindResourceExA)(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage);
typedef BOOL(__stdcall* EnumResourceTypesA)(HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumResourceTypesW)(HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumResourceNamesA)(HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumResourceLanguagesA)(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumResourceLanguagesW)(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam);
typedef HANDLE(__stdcall* BeginUpdateResourceA)(LPCSTR pFileName, BOOL bDeleteExistingResources);
typedef HANDLE(__stdcall* BeginUpdateResourceW)(LPCWSTR pFileName, BOOL bDeleteExistingResources);
typedef BOOL(__stdcall* UpdateResourceA)(HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb);
typedef BOOL(__stdcall* UpdateResourceW)(HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb);
typedef BOOL(__stdcall* EndUpdateResourceA)(HANDLE hUpdate, BOOL fDiscard);
typedef BOOL(__stdcall* EndUpdateResourceW)(HANDLE hUpdate, BOOL fDiscard);
typedef ATOM(__stdcall* GlobalAddAtomA)(LPCSTR lpString);
typedef ATOM(__stdcall* GlobalAddAtomW)(LPCWSTR lpString);
typedef ATOM(__stdcall* GlobalAddAtomExA)(LPCSTR lpString, DWORD Flags);
typedef ATOM(__stdcall* GlobalAddAtomExW)(LPCWSTR lpString, DWORD Flags);
typedef ATOM(__stdcall* GlobalFindAtomA)(LPCSTR lpString);
typedef ATOM(__stdcall* GlobalFindAtomW)(LPCWSTR lpString);
typedef UINT(__stdcall* GlobalGetAtomNameA)(ATOM nAtom, LPSTR lpBuffer, int nSize);
typedef UINT(__stdcall* GlobalGetAtomNameW)(ATOM nAtom, LPWSTR lpBuffer, int nSize);
typedef ATOM(__stdcall* AddAtomA)(LPCSTR lpString);
typedef ATOM(__stdcall* AddAtomW)(LPCWSTR lpString);
typedef ATOM(__stdcall* FindAtomA)(LPCSTR lpString);
typedef ATOM(__stdcall* FindAtomW)(LPCWSTR lpString);
typedef UINT(__stdcall* GetAtomNameA)(ATOM nAtom, LPSTR lpBuffer, int nSize);
typedef UINT(__stdcall* GetAtomNameW)(ATOM nAtom, LPWSTR lpBuffer, int nSize);
typedef UINT(__stdcall* GetProfileIntA)(LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault);
typedef UINT(__stdcall* GetProfileIntW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault);
typedef DWORD(__stdcall* GetProfileStringA)(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize);
typedef DWORD(__stdcall* GetProfileStringW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize);
typedef BOOL(__stdcall* WriteProfileStringA)(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString);
typedef BOOL(__stdcall* WriteProfileStringW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString);
typedef DWORD(__stdcall* GetProfileSectionA)(LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize);
typedef DWORD(__stdcall* GetProfileSectionW)(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize);
typedef BOOL(__stdcall* WriteProfileSectionA)(LPCSTR lpAppName, LPCSTR lpString);
typedef BOOL(__stdcall* WriteProfileSectionW)(LPCWSTR lpAppName, LPCWSTR lpString);
typedef UINT(__stdcall* GetPrivateProfileIntA)(LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName);
typedef UINT(__stdcall* GetPrivateProfileIntW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileStringA)(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileStringW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName);
typedef BOOL(__stdcall* WritePrivateProfileStringA)(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName);
typedef BOOL(__stdcall* WritePrivateProfileStringW)(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileSectionA)(LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileSectionW)(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName);
typedef BOOL(__stdcall* WritePrivateProfileSectionA)(LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName);
typedef BOOL(__stdcall* WritePrivateProfileSectionW)(LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileSectionNamesA)(LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName);
typedef DWORD(__stdcall* GetPrivateProfileSectionNamesW)(LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName);
typedef BOOL(__stdcall* GetPrivateProfileStructA)(LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile);
typedef BOOL(__stdcall* GetPrivateProfileStructW)(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);
typedef BOOL(__stdcall* WritePrivateProfileStructA)(LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile);
typedef BOOL(__stdcall* WritePrivateProfileStructW)(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);
typedef BOOLEAN(__stdcall* Wow64EnableWow64FsRedirection)(BOOLEAN Wow64FsEnableRedirection);
typedef BOOL(__stdcall* SetDllDirectoryA)(LPCSTR lpPathName);
typedef BOOL(__stdcall* SetDllDirectoryW)(LPCWSTR lpPathName);
typedef DWORD(__stdcall* GetDllDirectoryA)(DWORD nBufferLength, LPSTR lpBuffer);
typedef DWORD(__stdcall* GetDllDirectoryW)(DWORD nBufferLength, LPWSTR lpBuffer);
typedef BOOL(__stdcall* SetSearchPathMode)(DWORD Flags);
typedef BOOL(__stdcall* CreateDirectoryExA)(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* CreateDirectoryExW)(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* CreateDirectoryTransactedA)(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
typedef BOOL(__stdcall* CreateDirectoryTransactedW)(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
typedef BOOL(__stdcall* RemoveDirectoryTransactedA)(LPCSTR lpPathName, HANDLE hTransaction);
typedef BOOL(__stdcall* RemoveDirectoryTransactedW)(LPCWSTR lpPathName, HANDLE hTransaction);
typedef BOOL(__stdcall* DefineDosDeviceA)(DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath);
typedef DWORD(__stdcall* QueryDosDeviceA)(LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax);
typedef HANDLE(__stdcall* CreateFileTransactedA)(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, HANDLE hTransaction, PUSHORT pusMiniVersion, PVOID lpExtendedParameter);
typedef HANDLE(__stdcall* CreateFileTransactedW)(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, HANDLE hTransaction, PUSHORT pusMiniVersion, PVOID lpExtendedParameter);
typedef HANDLE(__stdcall* ReOpenFile)(HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes);
typedef BOOL(__stdcall* SetFileAttributesTransactedA)(LPCSTR lpFileName, DWORD dwFileAttributes, HANDLE hTransaction);
typedef BOOL(__stdcall* SetFileAttributesTransactedW)(LPCWSTR lpFileName, DWORD dwFileAttributes, HANDLE hTransaction);
typedef BOOL(__stdcall* GetFileAttributesTransactedA)(LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation, HANDLE hTransaction);
typedef BOOL(__stdcall* GetFileAttributesTransactedW)(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation, HANDLE hTransaction);
typedef DWORD(__stdcall* GetCompressedFileSizeTransactedA)(LPCSTR lpFileName, LPDWORD lpFileSizeHigh, HANDLE hTransaction);
typedef DWORD(__stdcall* GetCompressedFileSizeTransactedW)(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh, HANDLE hTransaction);
typedef BOOL(__stdcall* DeleteFileTransactedA)(LPCSTR lpFileName, HANDLE hTransaction);
typedef BOOL(__stdcall* DeleteFileTransactedW)(LPCWSTR lpFileName, HANDLE hTransaction);
typedef BOOL(__stdcall* CheckNameLegalDOS8Dot3A)(LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces, PBOOL pbNameLegal);
typedef BOOL(__stdcall* CheckNameLegalDOS8Dot3W)(LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces, PBOOL pbNameLegal);
typedef HANDLE(__stdcall* FindFirstFileTransactedA)(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags, HANDLE hTransaction);
typedef HANDLE(__stdcall* FindFirstFileTransactedW)(LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* CopyFileA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists);
typedef BOOL(__stdcall* CopyFileW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists);
typedef BOOL(__stdcall* CopyFileExA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags);
typedef BOOL(__stdcall* CopyFileExW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags);
typedef BOOL(__stdcall* CopyFileTransactedA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* CopyFileTransactedW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* MoveFileA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName);
typedef BOOL(__stdcall* MoveFileW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName);
typedef BOOL(__stdcall* MoveFileExA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags);
typedef BOOL(__stdcall* MoveFileExW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags);
typedef BOOL(__stdcall* MoveFileWithProgressA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags);
typedef BOOL(__stdcall* MoveFileWithProgressW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags);
typedef BOOL(__stdcall* MoveFileTransactedA)(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* MoveFileTransactedW)(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* ReplaceFileA)(LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved);
typedef BOOL(__stdcall* ReplaceFileW)(LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved);
typedef BOOL(__stdcall* CreateHardLinkA)(LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* CreateHardLinkW)(LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* CreateHardLinkTransactedA)(LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
typedef BOOL(__stdcall* CreateHardLinkTransactedW)(LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
typedef HANDLE(__stdcall* FindFirstStreamTransactedW)(LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags, HANDLE hTransaction);
typedef HANDLE(__stdcall* FindFirstFileNameTransactedW)(LPCWSTR lpFileName, DWORD dwFlags, LPDWORD StringLength, PWSTR LinkName, HANDLE hTransaction);
typedef HANDLE(__stdcall* CreateNamedPipeA)(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef BOOL(__stdcall* GetNamedPipeHandleStateA)(HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize);
typedef BOOL(__stdcall* CallNamedPipeA)(LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut);
typedef BOOL(__stdcall* WaitNamedPipeA)(LPCSTR lpNamedPipeName, DWORD nTimeOut);
typedef BOOL(__stdcall* GetNamedPipeClientComputerNameA)(HANDLE Pipe, LPSTR ClientComputerName, ULONG ClientComputerNameLength);
typedef BOOL(__stdcall* GetNamedPipeClientProcessId)(HANDLE Pipe, PULONG ClientProcessId);
typedef BOOL(__stdcall* GetNamedPipeClientSessionId)(HANDLE Pipe, PULONG ClientSessionId);
typedef BOOL(__stdcall* GetNamedPipeServerProcessId)(HANDLE Pipe, PULONG ServerProcessId);
typedef BOOL(__stdcall* GetNamedPipeServerSessionId)(HANDLE Pipe, PULONG ServerSessionId);
typedef BOOL(__stdcall* SetVolumeLabelA)(LPCSTR lpRootPathName, LPCSTR lpVolumeName);
typedef BOOL(__stdcall* SetVolumeLabelW)(LPCWSTR lpRootPathName, LPCWSTR lpVolumeName);
typedef BOOL(__stdcall* SetFileBandwidthReservation)(HANDLE hFile, DWORD nPeriodMilliseconds, DWORD nBytesPerPeriod, BOOL bDiscardable, LPDWORD lpTransferSize, LPDWORD lpNumOutstandingRequests);
typedef BOOL(__stdcall* GetFileBandwidthReservation)(HANDLE hFile, LPDWORD lpPeriodMilliseconds, LPDWORD lpBytesPerPeriod, LPBOOL pDiscardable, LPDWORD lpTransferSize, LPDWORD lpNumOutstandingRequests);
typedef BOOL(__stdcall* ClearEventLogA)(HANDLE hEventLog, LPCSTR lpBackupFileName);
typedef BOOL(__stdcall* ClearEventLogW)(HANDLE hEventLog, LPCWSTR lpBackupFileName);
typedef BOOL(__stdcall* BackupEventLogA)(HANDLE hEventLog, LPCSTR lpBackupFileName);
typedef BOOL(__stdcall* BackupEventLogW)(HANDLE hEventLog, LPCWSTR lpBackupFileName);
typedef BOOL(__stdcall* CloseEventLog)(HANDLE hEventLog);
typedef BOOL(__stdcall* DeregisterEventSource)(HANDLE hEventLog);
typedef BOOL(__stdcall* NotifyChangeEventLog)(HANDLE hEventLog, HANDLE hEvent);
typedef BOOL(__stdcall* GetNumberOfEventLogRecords)(HANDLE hEventLog, PDWORD NumberOfRecords);
typedef BOOL(__stdcall* GetOldestEventLogRecord)(HANDLE hEventLog, PDWORD OldestRecord);
typedef HANDLE(__stdcall* OpenEventLogA)(LPCSTR lpUNCServerName, LPCSTR lpSourceName);
typedef HANDLE(__stdcall* OpenEventLogW)(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName);
typedef HANDLE(__stdcall* RegisterEventSourceA)(LPCSTR lpUNCServerName, LPCSTR lpSourceName);
typedef HANDLE(__stdcall* RegisterEventSourceW)(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName);
typedef HANDLE(__stdcall* OpenBackupEventLogA)(LPCSTR lpUNCServerName, LPCSTR lpFileName);
typedef HANDLE(__stdcall* OpenBackupEventLogW)(LPCWSTR lpUNCServerName, LPCWSTR lpFileName);
typedef BOOL(__stdcall* GetEventLogInformation)(HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* AccessCheckAndAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeAndAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeResultListAndAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* AccessCheckByTypeResultListAndAuditAlarmByHandleA)(LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
typedef BOOL(__stdcall* ObjectOpenAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose);
typedef BOOL(__stdcall* ObjectPrivilegeAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
typedef BOOL(__stdcall* ObjectCloseAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
typedef BOOL(__stdcall* ObjectDeleteAuditAlarmA)(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
typedef BOOL(__stdcall* PrivilegedServiceAuditAlarmA)(LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
typedef BOOL(__stdcall* SetFileSecurityA)(LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef BOOL(__stdcall* GetFileSecurityA)(LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* ReadDirectoryChangesW)(HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef BOOL(__stdcall* ReadDirectoryChangesExW)(HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, READ_DIRECTORY_NOTIFY_INFORMATION_CLASS ReadDirectoryNotifyInformationClass);
typedef LPVOID(__stdcall* MapViewOfFileExNuma)(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress, DWORD nndPreferred);
typedef BOOL(__stdcall* IsBadWritePtr)(LPVOID lp, UINT_PTR ucb);
typedef BOOL(__stdcall* IsBadCodePtr)(FARPROC lpfn);
typedef BOOL(__stdcall* IsBadStringPtrA)(LPCSTR lpsz, UINT_PTR ucchMax);
typedef BOOL(__stdcall* IsBadStringPtrW)(LPCWSTR lpsz, UINT_PTR ucchMax);
typedef BOOL(__stdcall* LookupAccountSidA)(LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupAccountSidW)(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupAccountNameA)(LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupAccountNameW)(LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupAccountSidLocalA)(PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupAccountSidLocalW)(PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
typedef BOOL(__stdcall* LookupPrivilegeValueA)(LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid);
typedef BOOL(__stdcall* LookupPrivilegeValueW)(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid);
typedef BOOL(__stdcall* LookupPrivilegeNameA)(LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName);
typedef BOOL(__stdcall* LookupPrivilegeNameW)(LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName);
typedef BOOL(__stdcall* LookupPrivilegeDisplayNameA)(LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId);
typedef BOOL(__stdcall* LookupPrivilegeDisplayNameW)(LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId);
typedef BOOL(__stdcall* BuildCommDCBA)(LPCSTR lpDef, LPDCB lpDCB);
typedef BOOL(__stdcall* BuildCommDCBW)(LPCWSTR lpDef, LPDCB lpDCB);
typedef BOOL(__stdcall* BuildCommDCBAndTimeoutsA)(LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts);
typedef BOOL(__stdcall* BuildCommDCBAndTimeoutsW)(LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts);
typedef BOOL(__stdcall* CommConfigDialogA)(LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC);
typedef BOOL(__stdcall* CommConfigDialogW)(LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC);
typedef BOOL(__stdcall* GetDefaultCommConfigA)(LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
typedef BOOL(__stdcall* GetDefaultCommConfigW)(LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
typedef BOOL(__stdcall* SetDefaultCommConfigA)(LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize);
typedef BOOL(__stdcall* SetDefaultCommConfigW)(LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize);
typedef BOOL(__stdcall* GetComputerNameA)(LPSTR lpBuffer, LPDWORD nSize);
typedef BOOL(__stdcall* GetComputerNameW)(LPWSTR lpBuffer, LPDWORD nSize);
typedef BOOL(__stdcall* DnsHostnameToComputerNameA)(LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize);
typedef BOOL(__stdcall* DnsHostnameToComputerNameW)(LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize);
typedef BOOL(__stdcall* GetUserNameA)(LPSTR lpBuffer, LPDWORD pcbBuffer);
typedef BOOL(__stdcall* GetUserNameW)(LPWSTR lpBuffer, LPDWORD pcbBuffer);
typedef BOOL(__stdcall* LogonUserA)(LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken);
typedef BOOL(__stdcall* LogonUserW)(LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken);
typedef BOOL(__stdcall* CreateProcessWithLogonW)(LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* CreateProcessWithTokenW)(HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL(__stdcall* RegisterWaitForSingleObject)(PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags);
typedef BOOL(__stdcall* UnregisterWait)(HANDLE WaitHandle);
typedef BOOL(__stdcall* BindIoCompletionCallback)(HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags);
typedef BOOL(__stdcall* DeleteTimerQueue)(HANDLE TimerQueue);
typedef HANDLE(__stdcall* CreatePrivateNamespaceA)(LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes, LPVOID lpBoundaryDescriptor, LPCSTR lpAliasPrefix);
typedef HANDLE(__stdcall* OpenPrivateNamespaceA)(LPVOID lpBoundaryDescriptor, LPCSTR lpAliasPrefix);
typedef HANDLE(__stdcall* CreateBoundaryDescriptorA)(LPCSTR Name, ULONG Flags);
typedef BOOL(__stdcall* GetCurrentHwProfileA)(LPHW_PROFILE_INFOA lpHwProfileInfo);
typedef BOOL(__stdcall* GetCurrentHwProfileW)(LPHW_PROFILE_INFOW lpHwProfileInfo);
typedef BOOL(__stdcall* VerifyVersionInfoA)(LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
typedef BOOL(__stdcall* VerifyVersionInfoW)(LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
typedef BOOL(__stdcall* SetSystemPowerState)(BOOL fSuspend, BOOL fForce);
typedef BOOL(__stdcall* GetSystemPowerStatus)(LPSYSTEM_POWER_STATUS lpSystemPowerStatus);
typedef HANDLE(__stdcall* CreateJobObjectA)(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName);
typedef HANDLE(__stdcall* OpenJobObjectA)(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
typedef HANDLE(__stdcall* FindFirstVolumeA)(LPSTR lpszVolumeName, DWORD cchBufferLength);
typedef BOOL(__stdcall* FindNextVolumeA)(HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength);
typedef HANDLE(__stdcall* FindFirstVolumeMountPointA)(LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength);
typedef HANDLE(__stdcall* FindFirstVolumeMountPointW)(LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength);
typedef BOOL(__stdcall* FindNextVolumeMountPointA)(HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength);
typedef BOOL(__stdcall* FindNextVolumeMountPointW)(HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength);
typedef BOOL(__stdcall* FindVolumeMountPointClose)(HANDLE hFindVolumeMountPoint);
typedef BOOL(__stdcall* SetVolumeMountPointA)(LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName);
typedef BOOL(__stdcall* SetVolumeMountPointW)(LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName);
typedef BOOL(__stdcall* DeleteVolumeMountPointA)(LPCSTR lpszVolumeMountPoint);
typedef BOOL(__stdcall* GetVolumeNameForVolumeMountPointA)(LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength);
typedef BOOL(__stdcall* GetVolumePathNameA)(LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength);
typedef BOOL(__stdcall* GetVolumePathNamesForVolumeNameA)(LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength);
typedef HANDLE(__stdcall* CreateActCtxA)(PCACTCTXA pActCtx);
typedef HANDLE(__stdcall* CreateActCtxW)(PCACTCTXW pActCtx);
typedef void(__stdcall* AddRefActCtx)(HANDLE hActCtx);
typedef void(__stdcall* ReleaseActCtx)(HANDLE hActCtx);
typedef BOOL(__stdcall* ZombifyActCtx)(HANDLE hActCtx);
typedef BOOL(__stdcall* DeactivateActCtx)(DWORD dwFlags, ULONG_PTR ulCookie);
typedef DWORD(__stdcall* GetActiveProcessorCount)(WORD GroupNumber);
typedef DWORD(__stdcall* GetMaximumProcessorCount)(WORD GroupNumber);
typedef BOOL(__stdcall* GetNumaProcessorNode)(UCHAR Processor, PUCHAR NodeNumber);
typedef BOOL(__stdcall* GetNumaNodeNumberFromHandle)(HANDLE hFile, PUSHORT NodeNumber);
typedef BOOL(__stdcall* GetNumaProcessorNodeEx)(PPROCESSOR_NUMBER Processor, PUSHORT NodeNumber);
typedef BOOL(__stdcall* GetNumaNodeProcessorMask)(UCHAR Node, PULONGLONG ProcessorMask);
typedef BOOL(__stdcall* GetNumaAvailableMemoryNode)(UCHAR Node, PULONGLONG AvailableBytes);
typedef BOOL(__stdcall* GetNumaAvailableMemoryNodeEx)(USHORT Node, PULONGLONG AvailableBytes);
typedef BOOL(__stdcall* GetNumaProximityNode)(ULONG ProximityId, PUCHAR NodeNumber);
typedef HRESULT(__stdcall* RegisterApplicationRecoveryCallback)(APPLICATION_RECOVERY_CALLBACK pRecoveyCallback, PVOID pvParameter, DWORD dwPingInterval, DWORD dwFlags);
typedef HRESULT(__stdcall* RegisterApplicationRestart)(PCWSTR pwzCommandline, DWORD dwFlags);
typedef HRESULT(__stdcall* GetApplicationRestartSettings)(HANDLE hProcess, PWSTR pwzCommandline, PDWORD pcchSize, PDWORD pdwFlags);
typedef HRESULT(__stdcall* ApplicationRecoveryInProgress)(PBOOL pbCancelled);
typedef void(__stdcall* ApplicationRecoveryFinished)(BOOL bSuccess);
typedef BOOL(__stdcall* GetFileInformationByHandleEx)(HANDLE hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, LPVOID lpFileInformation, DWORD dwBufferSize);
typedef HANDLE(__stdcall* OpenFileById)(HANDLE hVolumeHint, LPFILE_ID_DESCRIPTOR lpFileId, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwFlagsAndAttributes);
typedef BOOLEAN(__stdcall* CreateSymbolicLinkA)(LPCSTR lpSymlinkFileName, LPCSTR lpTargetFileName, DWORD dwFlags);
typedef BOOLEAN(__stdcall* CreateSymbolicLinkW)(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags);
typedef BOOLEAN(__stdcall* CreateSymbolicLinkTransactedA)(LPCSTR lpSymlinkFileName, LPCSTR lpTargetFileName, DWORD dwFlags, HANDLE hTransaction);
typedef BOOLEAN(__stdcall* CreateSymbolicLinkTransactedW)(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags, HANDLE hTransaction);
typedef BOOL(__stdcall* AddSecureMemoryCacheCallback)(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
typedef BOOL(__stdcall* RemoveSecureMemoryCacheCallback)(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
typedef BOOL(__stdcall* CopyContext)(PCONTEXT Destination, DWORD ContextFlags, PCONTEXT Source);
typedef BOOL(__stdcall* GetXStateFeaturesMask)(PCONTEXT Context, PDWORD64 FeatureMask);
typedef PVOID(__stdcall* LocateXStateFeature)(PCONTEXT Context, DWORD FeatureId, PDWORD Length);
typedef BOOL(__stdcall* SetXStateFeaturesMask)(PCONTEXT Context, DWORD64 FeatureMask);
typedef DWORD(__stdcall* DisableThreadProfiling)(HANDLE PerformanceDataHandle);
typedef DWORD(__stdcall* QueryThreadProfiling)(HANDLE ThreadHandle, PBOOLEAN Enabled);
typedef DWORD(__stdcall* ReadThreadProfilingData)(HANDLE PerformanceDataHandle, DWORD Flags, PPERFORMANCE_DATA PerformanceData);
typedef HRESULT(__stdcall* WinBioCloseFramework)(WINBIO_FRAMEWORK_HANDLE FrameworkHandle);
typedef HRESULT(__stdcall* WinBioAsyncEnumServiceProviders)(WINBIO_FRAMEWORK_HANDLE FrameworkHandle, WINBIO_BIOMETRIC_TYPE Factor);
typedef HRESULT(__stdcall* WinBioAsyncEnumBiometricUnits)(WINBIO_FRAMEWORK_HANDLE FrameworkHandle, WINBIO_BIOMETRIC_TYPE Factor);
typedef HRESULT(__stdcall* WinBioAsyncEnumDatabases)(WINBIO_FRAMEWORK_HANDLE FrameworkHandle, WINBIO_BIOMETRIC_TYPE Factor);
typedef HRESULT(__stdcall* WinBioAsyncMonitorFrameworkChanges)(WINBIO_FRAMEWORK_HANDLE FrameworkHandle, WINBIO_FRAMEWORK_CHANGE_TYPE ChangeTypes);
typedef HRESULT(__stdcall* WinBioCloseSession)(WINBIO_SESSION_HANDLE SessionHandle);
typedef HRESULT(__stdcall* WinBioIdentifyWithCallback)(WINBIO_SESSION_HANDLE SessionHandle, PWINBIO_IDENTIFY_CALLBACK IdentifyCallback, PVOID IdentifyCallbackContext);
typedef HRESULT(__stdcall* WinBioWait)(WINBIO_SESSION_HANDLE SessionHandle);
typedef HRESULT(__stdcall* WinBioCancel)(WINBIO_SESSION_HANDLE SessionHandle);
typedef HRESULT(__stdcall* WinBioLocateSensorWithCallback)(WINBIO_SESSION_HANDLE SessionHandle, PWINBIO_LOCATE_SENSOR_CALLBACK LocateCallback, PVOID LocateCallbackContext);
typedef HRESULT(__stdcall* WinBioEnrollBegin)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_BIOMETRIC_SUBTYPE SubFactor, WINBIO_UNIT_ID UnitId);
typedef HRESULT(__stdcall* WinBioEnrollSelect)(WINBIO_SESSION_HANDLE SessionHandle, ULONGLONG SelectorValue);
typedef HRESULT(__stdcall* WinBioEnrollCaptureWithCallback)(WINBIO_SESSION_HANDLE SessionHandle, PWINBIO_ENROLL_CAPTURE_CALLBACK EnrollCallback, PVOID EnrollCallbackContext);
typedef HRESULT(__stdcall* WinBioEnrollDiscard)(WINBIO_SESSION_HANDLE SessionHandle);
typedef HRESULT(__stdcall* WinBioRegisterEventMonitor)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_EVENT_TYPE EventMask, PWINBIO_EVENT_CALLBACK EventCallback, PVOID EventCallbackContext);
typedef HRESULT(__stdcall* WinBioUnregisterEventMonitor)(WINBIO_SESSION_HANDLE SessionHandle);
typedef HRESULT(__stdcall* WinBioMonitorPresence)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_UNIT_ID UnitId);
typedef HRESULT(__stdcall* WinBioCaptureSampleWithCallback)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_BIR_PURPOSE Purpose, WINBIO_BIR_DATA_FLAGS Flags, PWINBIO_CAPTURE_CALLBACK CaptureCallback, PVOID CaptureCallbackContext);
typedef HRESULT(__stdcall* WinBioLockUnit)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_UNIT_ID UnitId);
typedef HRESULT(__stdcall* WinBioUnlockUnit)(WINBIO_SESSION_HANDLE SessionHandle, WINBIO_UNIT_ID UnitId);
typedef HRESULT(__stdcall* WinBioFree)(PVOID Address);
typedef HRESULT(__stdcall* WinBioSetCredential)(WINBIO_CREDENTIAL_TYPE Type, PUCHAR Credential, SIZE_T CredentialSize, WINBIO_CREDENTIAL_FORMAT Format);
typedef HRESULT(__stdcall* WinBioRemoveCredential)(WINBIO_IDENTITY Identity, WINBIO_CREDENTIAL_TYPE Type);
typedef HRESULT(__stdcall* WinBioLogonIdentifiedUser)(WINBIO_SESSION_HANDLE SessionHandle);
typedef BOOL(__stdcall* CredWriteW)(PCREDENTIALW Credential, DWORD Flags);
typedef BOOL(__stdcall* CredWriteA)(PCREDENTIALA Credential, DWORD Flags);
typedef BOOL(__stdcall* CredWriteDomainCredentialsW)(PCREDENTIAL_TARGET_INFORMATIONW TargetInfo, PCREDENTIALW Credential, DWORD Flags);
typedef BOOL(__stdcall* CredWriteDomainCredentialsA)(PCREDENTIAL_TARGET_INFORMATIONA TargetInfo, PCREDENTIALA Credential, DWORD Flags);
typedef BOOL(__stdcall* CredDeleteW)(LPCWSTR TargetName, DWORD Type, DWORD Flags);
typedef BOOL(__stdcall* CredDeleteA)(LPCSTR TargetName, DWORD Type, DWORD Flags);
typedef BOOL(__stdcall* CredRenameW)(LPCWSTR OldTargetName, LPCWSTR NewTargetName, DWORD Type, DWORD Flags);
typedef BOOL(__stdcall* CredRenameA)(LPCSTR OldTargetName, LPCSTR NewTargetName, DWORD Type, DWORD Flags);
typedef BOOL(__stdcall* CredIsMarshaledCredentialW)(LPCWSTR MarshaledCredential);
typedef BOOL(__stdcall* CredIsMarshaledCredentialA)(LPCSTR MarshaledCredential);
typedef BOOL(__stdcall* CredGetSessionTypes)(DWORD MaximumPersistCount, LPDWORD MaximumPersist);
typedef void(__stdcall* CredFree)(PVOID Buffer);
typedef DWORD(__stdcall* CredUICmdLinePromptForCredentialsW)(PCWSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PWSTR UserName, ULONG ulUserBufferSize, PWSTR pszPassword, ULONG ulPasswordBufferSize, PBOOL pfSave, DWORD dwFlags);
typedef DWORD(__stdcall* CredUICmdLinePromptForCredentialsA)(PCSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PSTR UserName, ULONG ulUserBufferSize, PSTR pszPassword, ULONG ulPasswordBufferSize, PBOOL pfSave, DWORD dwFlags);
typedef DWORD(__stdcall* CredUIConfirmCredentialsW)(PCWSTR pszTargetName, BOOL bConfirm);
typedef DWORD(__stdcall* CredUIConfirmCredentialsA)(PCSTR pszTargetName, BOOL bConfirm);
typedef DWORD(__stdcall* CredUIStoreSSOCredW)(PCWSTR pszRealm, PCWSTR pszUsername, PCWSTR pszPassword, BOOL bPersist);
typedef BOOL(__stdcall* CryptReleaseContext)(HCRYPTPROV hProv, DWORD dwFlags);
typedef BOOL(__stdcall* CryptDestroyKey)(HCRYPTKEY hKey);
typedef BOOL(__stdcall* CryptHashSessionKey)(HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags);
typedef BOOL(__stdcall* CryptDestroyHash)(HCRYPTHASH hHash);
typedef BOOL(__stdcall* CryptSetProviderA)(LPCSTR pszProvName, DWORD dwProvType);
typedef BOOL(__stdcall* CryptSetProviderW)(LPCWSTR pszProvName, DWORD dwProvType);
typedef HCRYPTOIDFUNCSET(__stdcall* CryptInitOIDFunctionSet)(LPCSTR pszFuncName, DWORD dwFlags);
typedef BOOL(__stdcall* CryptFreeOIDFunctionAddress)(HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags);
typedef BOOL(__stdcall* CryptRegisterOIDFunction)(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName);
typedef BOOL(__stdcall* CryptUnregisterOIDFunction)(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID);
typedef BOOL(__stdcall* CryptRegisterDefaultOIDFunction)(DWORD dwEncodingType, LPCSTR pszFuncName, DWORD dwIndex, LPCWSTR pwszDll);
typedef BOOL(__stdcall* CryptUnregisterDefaultOIDFunction)(DWORD dwEncodingType, LPCSTR pszFuncName, LPCWSTR pwszDll);
typedef BOOL(__stdcall* CryptRegisterOIDInfo)(PCCRYPT_OID_INFO pInfo, DWORD dwFlags);
typedef BOOL(__stdcall* CryptUnregisterOIDInfo)(PCCRYPT_OID_INFO pInfo);
typedef LPCWSTR(__stdcall* CryptFindLocalizedName)(LPCWSTR pwszCryptName);
typedef HCRYPTMSG(__stdcall* CryptMsgOpenToDecode)(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo);
typedef HCRYPTMSG(__stdcall* CryptMsgDuplicate)(HCRYPTMSG hCryptMsg);
typedef BOOL(__stdcall* CryptMsgClose)(HCRYPTMSG hCryptMsg);
typedef BOOL(__stdcall* CryptMsgVerifyCountersignatureEncoded)(HCRYPTPROV_LEGACY hCryptProv, DWORD dwEncodingType, PBYTE pbSignerInfo, DWORD cbSignerInfo, PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature, PCERT_INFO pciCountersigner);
typedef BOOL(__stdcall* CryptMsgCountersign)(HCRYPTMSG hCryptMsg, DWORD dwIndex, DWORD cCountersigners, PCMSG_SIGNER_ENCODE_INFO rgCountersigners);
typedef BOOL(__stdcall* CryptMsgCountersignEncoded)(DWORD dwEncodingType, PBYTE pbSignerInfo, DWORD cbSignerInfo, DWORD cCountersigners, PCMSG_SIGNER_ENCODE_INFO rgCountersigners, PBYTE pbCountersignature, PDWORD pcbCountersignature);
typedef HCERTSTORE(__stdcall* CertDuplicateStore)(HCERTSTORE hCertStore);
typedef BOOL(__stdcall* CertCloseStore)(HCERTSTORE hCertStore, DWORD dwFlags);
typedef PCCERT_CONTEXT(__stdcall* CertGetSubjectCertificateFromStore)(HCERTSTORE hCertStore, DWORD dwCertEncodingType, PCERT_INFO pCertId);
typedef PCCERT_CONTEXT(__stdcall* CertEnumCertificatesInStore)(HCERTSTORE hCertStore, PCCERT_CONTEXT pPrevCertContext);
typedef PCCERT_CONTEXT(__stdcall* CertDuplicateCertificateContext)(PCCERT_CONTEXT pCertContext);
typedef BOOL(__stdcall* CertFreeCertificateContext)(PCCERT_CONTEXT pCertContext);
typedef DWORD(__stdcall* CertEnumCertificateContextProperties)(PCCERT_CONTEXT pCertContext, DWORD dwPropId);
typedef BOOL(__stdcall* CertSetCertificateContextPropertiesFromCTLEntry)(PCCERT_CONTEXT pCertContext, PCTL_ENTRY pCtlEntry, DWORD dwFlags);
typedef PCCRL_CONTEXT(__stdcall* CertEnumCRLsInStore)(HCERTSTORE hCertStore, PCCRL_CONTEXT pPrevCrlContext);
typedef PCCRL_CONTEXT(__stdcall* CertDuplicateCRLContext)(PCCRL_CONTEXT pCrlContext);
typedef BOOL(__stdcall* CertFreeCRLContext)(PCCRL_CONTEXT pCrlContext);
typedef DWORD(__stdcall* CertEnumCRLContextProperties)(PCCRL_CONTEXT pCrlContext, DWORD dwPropId);
typedef BOOL(__stdcall* CertDeleteCertificateFromStore)(PCCERT_CONTEXT pCertContext);
typedef BOOL(__stdcall* CertDeleteCRLFromStore)(PCCRL_CONTEXT pCrlContext);
typedef PCCTL_CONTEXT(__stdcall* CertDuplicateCTLContext)(PCCTL_CONTEXT pCtlContext);
typedef BOOL(__stdcall* CertFreeCTLContext)(PCCTL_CONTEXT pCtlContext);
typedef DWORD(__stdcall* CertEnumCTLContextProperties)(PCCTL_CONTEXT pCtlContext, DWORD dwPropId);
typedef PCCTL_CONTEXT(__stdcall* CertEnumCTLsInStore)(HCERTSTORE hCertStore, PCCTL_CONTEXT pPrevCtlContext);
typedef BOOL(__stdcall* CertDeleteCTLFromStore)(PCCTL_CONTEXT pCtlContext);
typedef BOOL(__stdcall* CertAddStoreToCollection)(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority);
typedef void(__stdcall* CertRemoveStoreFromCollection)(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore);
typedef BOOL(__stdcall* CertSetEnhancedKeyUsage)(PCCERT_CONTEXT pCertContext, PCERT_ENHKEY_USAGE pUsage);
typedef BOOL(__stdcall* CertAddEnhancedKeyUsageIdentifier)(PCCERT_CONTEXT pCertContext, LPCSTR pszUsageIdentifier);
typedef BOOL(__stdcall* CertRemoveEnhancedKeyUsageIdentifier)(PCCERT_CONTEXT pCertContext, LPCSTR pszUsageIdentifier);
typedef BOOL(__stdcall* CertCompareIntegerBlob)(PCRYPT_INTEGER_BLOB pInt1, PCRYPT_INTEGER_BLOB pInt2);
typedef BOOL(__stdcall* CertCompareCertificate)(DWORD dwCertEncodingType, PCERT_INFO pCertId1, PCERT_INFO pCertId2);
typedef BOOL(__stdcall* CertCompareCertificateName)(DWORD dwCertEncodingType, PCERT_NAME_BLOB pCertName1, PCERT_NAME_BLOB pCertName2);
typedef BOOL(__stdcall* CertIsRDNAttrsInCertificateName)(DWORD dwCertEncodingType, DWORD dwFlags, PCERT_NAME_BLOB pCertName, PCERT_RDN pRDN);
typedef BOOL(__stdcall* CertComparePublicKeyInfo)(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pPublicKey1, PCERT_PUBLIC_KEY_INFO pPublicKey2);
typedef DWORD(__stdcall* CertGetPublicKeyLength)(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pPublicKey);
typedef BOOL(__stdcall* CertIsStrongHashToSign)(PCCERT_STRONG_SIGN_PARA pStrongSignPara, LPCWSTR pwszCNGHashAlgid, PCCERT_CONTEXT pSigningCert);
typedef LONG(__stdcall* CertVerifyTimeValidity)(LPFILETIME pTimeToVerify, PCERT_INFO pCertInfo);
typedef LONG(__stdcall* CertVerifyCRLTimeValidity)(LPFILETIME pTimeToVerify, PCRL_INFO pCrlInfo);
typedef BOOL(__stdcall* CertVerifyValidityNesting)(PCERT_INFO pSubjectInfo, PCERT_INFO pIssuerInfo);
typedef LPCSTR(__stdcall* CertAlgIdToOID)(DWORD dwAlgId);
typedef DWORD(__stdcall* CertOIDToAlgId)(LPCSTR pszObjId);
typedef PCERT_RDN_ATTR(__stdcall* CertFindRDNAttr)(LPCSTR pszObjId, PCERT_NAME_INFO pName);
typedef DWORD(__stdcall* CertRDNValueToStrA)(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue, LPSTR psz, DWORD csz);
typedef DWORD(__stdcall* CertRDNValueToStrW)(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue, LPWSTR psz, DWORD csz);
typedef DWORD(__stdcall* CertNameToStrA)(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName, DWORD dwStrType, LPSTR psz, DWORD csz);
typedef DWORD(__stdcall* CertNameToStrW)(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName, DWORD dwStrType, LPWSTR psz, DWORD csz);
typedef HCERTSTORE(__stdcall* CertOpenSystemStoreA)(HCRYPTPROV_LEGACY hProv, LPCSTR szSubsystemProtocol);
typedef HCERTSTORE(__stdcall* CertOpenSystemStoreW)(HCRYPTPROV_LEGACY hProv, LPCWSTR szSubsystemProtocol);
typedef LPVOID(__stdcall* CryptMemAlloc)(ULONG cbSize);
typedef LPVOID(__stdcall* CryptMemRealloc)(LPVOID pv, ULONG cbSize);
typedef void(__stdcall* CryptMemFree)(LPVOID pv);
typedef BOOL(__stdcall* CryptCreateAsyncHandle)(DWORD dwFlags, PHCRYPTASYNC phAsync);
typedef BOOL(__stdcall* CryptCloseAsyncHandle)(HCRYPTASYNC hAsync);
typedef PCCERT_CONTEXT(__stdcall* CertCreateSelfSignCertificate)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey, PCERT_NAME_BLOB pSubjectIssuerBlob, DWORD dwFlags, PCRYPT_KEY_PROV_INFO pKeyProvInfo, PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm, PSYSTEMTIME pStartTime, PSYSTEMTIME pEndTime, PCERT_EXTENSIONS pExtensions);
typedef void(__stdcall* CertFreeCertificateChainEngine)(HCERTCHAINENGINE hChainEngine);
typedef BOOL(__stdcall* CertResyncCertificateChainEngine)(HCERTCHAINENGINE hChainEngine);
typedef void(__stdcall* CertFreeCertificateChain)(PCCERT_CHAIN_CONTEXT pChainContext);
typedef PCCERT_CHAIN_CONTEXT(__stdcall* CertDuplicateCertificateChain)(PCCERT_CHAIN_CONTEXT pChainContext);
typedef BOOL(__stdcall* CertVerifyCertificateChainPolicy)(LPCSTR pszPolicyOID, PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara, PCERT_CHAIN_POLICY_STATUS pPolicyStatus);
typedef HCERT_SERVER_OCSP_RESPONSE(__stdcall* CertOpenServerOcspResponse)(PCCERT_CHAIN_CONTEXT pChainContext, DWORD dwFlags, PCERT_SERVER_OCSP_RESPONSE_OPEN_PARA pOpenPara);
typedef void(__stdcall* CertAddRefServerOcspResponse)(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse);
typedef void(__stdcall* CertCloseServerOcspResponse)(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse, DWORD dwFlags);
typedef PCCERT_SERVER_OCSP_RESPONSE_CONTEXT(__stdcall* CertGetServerOcspResponseContext)(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse, DWORD dwFlags, LPVOID pvReserved);
typedef void(__stdcall* CertAddRefServerOcspResponseContext)(PCCERT_SERVER_OCSP_RESPONSE_CONTEXT pServerOcspResponseContext);
typedef void(__stdcall* CertFreeServerOcspResponseContext)(PCCERT_SERVER_OCSP_RESPONSE_CONTEXT pServerOcspResponseContext);
typedef void(__stdcall* __security_check_cookie)(uintptr_t _StackCookie);
typedef void(__stdcall* __report_gsfailure)(uintptr_t _StackCookie);
typedef int(__stdcall* iswalnum)(wint_t _C);
typedef int(__stdcall* iswalpha)(wint_t _C);
typedef int(__stdcall* iswascii)(wint_t _C);
typedef int(__stdcall* iswblank)(wint_t _C);
typedef int(__stdcall* iswcntrl)(wint_t _C);
typedef int(__stdcall* iswdigit)(wint_t _C);
typedef int(__stdcall* iswgraph)(wint_t _C);
typedef int(__stdcall* iswlower)(wint_t _C);
typedef int(__stdcall* iswprint)(wint_t _C);
typedef int(__stdcall* iswpunct)(wint_t _C);
typedef int(__stdcall* iswspace)(wint_t _C);
typedef int(__stdcall* iswupper)(wint_t _C);
typedef int(__stdcall* iswxdigit)(wint_t _C);
typedef int(__stdcall* __iswcsymf)(wint_t _C);
typedef int(__stdcall* __iswcsym)(wint_t _C);
typedef int(__stdcall* _iswalnum_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswalpha_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswblank_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswcntrl_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswdigit_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswgraph_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswlower_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswprint_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswpunct_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswspace_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswupper_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswxdigit_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswcsymf_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswcsym_l)(wint_t _C, _locale_t _Locale);
typedef wint_t(__stdcall* towupper)(wint_t _C);
typedef wint_t(__stdcall* towlower)(wint_t _C);
typedef int(__stdcall* iswctype)(wint_t _C, wctype_t _Type);
typedef wint_t(__stdcall* _towupper_l)(wint_t _C, _locale_t _Locale);
typedef wint_t(__stdcall* _towlower_l)(wint_t _C, _locale_t _Locale);
typedef int(__stdcall* _iswctype_l)(wint_t _C, wctype_t _Type, _locale_t _Locale);
typedef int(__stdcall* isleadbyte)(int _C);
typedef int(__stdcall* _isleadbyte_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* is_wctype)(wint_t _C, wctype_t _Type);
typedef int(__stdcall* _isctype)(int _C, int _Type);
typedef int(__stdcall* _isctype_l)(int _C, int _Type, _locale_t _Locale);
typedef int(__stdcall* isalpha)(int _C);
typedef int(__stdcall* _isalpha_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isupper)(int _C);
typedef int(__stdcall* _isupper_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* islower)(int _C);
typedef int(__stdcall* _islower_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isdigit)(int _C);
typedef int(__stdcall* _isdigit_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isxdigit)(int _C);
typedef int(__stdcall* _isxdigit_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isspace)(int _C);
typedef int(__stdcall* _isspace_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* ispunct)(int _C);
typedef int(__stdcall* _ispunct_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isblank)(int _C);
typedef int(__stdcall* _isblank_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isalnum)(int _C);
typedef int(__stdcall* _isalnum_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isprint)(int _C);
typedef int(__stdcall* _isprint_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* isgraph)(int _C);
typedef int(__stdcall* _isgraph_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* iscntrl)(int _C);
typedef int(__stdcall* _iscntrl_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* toupper)(int _C);
typedef int(__stdcall* tolower)(int _C);
typedef int(__stdcall* _tolower)(int _C);
typedef int(__stdcall* _tolower_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* _toupper)(int _C);
typedef int(__stdcall* _toupper_l)(int _C, _locale_t _Locale);
typedef int(__stdcall* __isascii)(int _C);
typedef int(__stdcall* __toascii)(int _C);
typedef int(__stdcall* __iscsymf)(int _C);
typedef int(__stdcall* __iscsym)(int _C);
typedef int(__stdcall* ___mb_cur_max_l_func)(_locale_t _Locale);
typedef int(__stdcall* __ascii_tolower)(int _C);
typedef int(__stdcall* __ascii_toupper)(int _C);
typedef int(__stdcall* __ascii_iswalpha)(int _C);
typedef int(__stdcall* __ascii_iswdigit)(int _C);
typedef int(__stdcall* __ascii_towlower)(int _C);
typedef int(__stdcall* __ascii_towupper)(int _C);
typedef int(__stdcall* _chvalidchk_l)(int _C, int _Mask, _locale_t _Locale);
typedef int(__stdcall* _ischartype_l)(int _C, int _Mask, _locale_t _Locale);
typedef {'name': 'ULongToHandle', 'type': 'void'}(__stdcall* ULongToHandle)(unsigned long h);
typedef {'name': 'LongToHandle', 'type': 'void'}(__stdcall* LongToHandle)(long h);
typedef {'name': 'IntToPtr', 'type': 'void'}(__stdcall* IntToPtr)(int i);
typedef {'name': 'UIntToPtr', 'type': 'void'}(__stdcall* UIntToPtr)(unsigned int ui);
typedef {'name': 'LongToPtr', 'type': 'void'}(__stdcall* LongToPtr)(long l);
typedef {'name': 'ULongToPtr', 'type': 'void'}(__stdcall* ULongToPtr)(unsigned long ul);
typedef unsigned char(__stdcall* _rotl8)(unsigned char Value, unsigned char Shift);
typedef unsigned short(__stdcall* _rotl16)(unsigned short Value, unsigned char Shift);
typedef unsigned char(__stdcall* _rotr8)(unsigned char Value, unsigned char Shift);
typedef unsigned short(__stdcall* _rotr16)(unsigned short Value, unsigned char Shift);
typedef unsigned int(__stdcall* _rotl)(unsigned int Value, int Shift);
typedef unsigned long long int(__stdcall* _rotl64)(unsigned long long int Value, int Shift);
typedef unsigned int(__stdcall* _rotr)(unsigned int Value, int Shift);
typedef unsigned long long int(__stdcall* _rotr64)(unsigned long long int Value, int Shift);
typedef errno_t(__stdcall* _set_errno)(int _Value);
typedef errno_t(__stdcall* _set_doserrno)(unsigned long _Value);
typedef {'name': '_wcserror', 'type': 'wchar_t'}(__stdcall* _wcserror)(int _ErrorNumber);
typedef {'name': 'strerror', 'type': 'char'}(__stdcall* strerror)(int _ErrorMessage);
typedef void(__stdcall* _mm_setcsr)(unsigned int MxCsr);
typedef DWORD(__stdcall* __segmentlimit)(DWORD Selector);
typedef DWORD64(__stdcall* __readpmc)(DWORD Counter);
typedef void(__stdcall* __stosb)(PBYTE Destination, BYTE Value, SIZE_T Count);
typedef void(__stdcall* __stosw)(PWORD Destination, WORD Value, SIZE_T Count);
typedef void(__stdcall* __stosd)(PDWORD Destination, DWORD Value, SIZE_T Count);
typedef void(__stdcall* __stosq)(PDWORD64 Destination, DWORD64 Value, SIZE_T Count);
typedef LONGLONG(__stdcall* __mulh)(LONG64 Multiplier, LONG64 Multiplicand);
typedef ULONGLONG(__stdcall* __umulh)(DWORD64 Multiplier, DWORD64 Multiplicand);
typedef DWORD64(__stdcall* __popcnt64)(DWORD64 operand);
typedef DWORD64(__stdcall* __shiftleft128)(DWORD64 LowPart, DWORD64 HighPart, BYTE Shift);
typedef DWORD64(__stdcall* __shiftright128)(DWORD64 LowPart, DWORD64 HighPart, BYTE Shift);
typedef LONG64(__stdcall* MultiplyExtract128)(LONG64 Multiplier, LONG64 Multiplicand, BYTE Shift);
typedef DWORD64(__stdcall* UnsignedMultiplyExtract128)(DWORD64 Multiplier, DWORD64 Multiplicand, BYTE Shift);
typedef BYTE(__stdcall* __readgsbyte)(DWORD Offset);
typedef WORD(__stdcall* __readgsword)(DWORD Offset);
typedef DWORD(__stdcall* __readgsdword)(DWORD Offset);
typedef DWORD64(__stdcall* __readgsqword)(DWORD Offset);
typedef void(__stdcall* __writegsbyte)(DWORD Offset, BYTE Data);
typedef void(__stdcall* __writegsword)(DWORD Offset, WORD Data);
typedef void(__stdcall* __writegsdword)(DWORD Offset, DWORD Data);
typedef void(__stdcall* __writegsqword)(DWORD Offset, DWORD64 Data);
typedef void(__stdcall* __incgsbyte)(DWORD Offset);
typedef void(__stdcall* __addgsbyte)(DWORD Offset, BYTE Value);
typedef void(__stdcall* __incgsword)(DWORD Offset);
typedef void(__stdcall* __addgsword)(DWORD Offset, WORD Value);
typedef void(__stdcall* __incgsdword)(DWORD Offset);
typedef void(__stdcall* __addgsdword)(DWORD Offset, DWORD Value);
typedef void(__stdcall* __incgsqword)(DWORD Offset);
typedef void(__stdcall* __addgsqword)(DWORD Offset, DWORD64 Value);
typedef PRUNTIME_FUNCTION(__stdcall* GET_RUNTIME_FUNCTION_CALLBACK)(DWORD64 ControlPc, PVOID Context);
typedef void(__stdcall* RtlCaptureContext)(PCONTEXT ContextRecord);
typedef void(__stdcall* RtlCaptureContext2)(PCONTEXT ContextRecord);
typedef void(__stdcall* RtlUnwind)(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue);
typedef BOOLEAN(__stdcall* RtlAddFunctionTable)(PRUNTIME_FUNCTION FunctionTable, DWORD EntryCount, DWORD64 BaseAddress);
typedef BOOLEAN(__stdcall* RtlDeleteFunctionTable)(PRUNTIME_FUNCTION FunctionTable);
typedef BOOLEAN(__stdcall* RtlInstallFunctionTableCallback)(DWORD64 TableIdentifier, DWORD64 BaseAddress, DWORD Length, PGET_RUNTIME_FUNCTION_CALLBACK Callback, PVOID Context, PCWSTR OutOfProcessCallbackDll);
typedef void(__stdcall* RtlGrowFunctionTable)(PVOID DynamicTable, DWORD NewEntryCount);
typedef void(__stdcall* RtlDeleteGrowableFunctionTable)(PVOID DynamicTable);
typedef PRUNTIME_FUNCTION(__stdcall* RtlLookupFunctionEntry)(DWORD64 ControlPc, PDWORD64 ImageBase, PUNWIND_HISTORY_TABLE HistoryTable);
typedef void(__stdcall* RtlUnwindEx)(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PUNWIND_HISTORY_TABLE HistoryTable);
typedef void(__stdcall* RtlRaiseException)(PEXCEPTION_RECORD ExceptionRecord);
typedef void(__stdcall* RtlInitializeSListHead)(PSLIST_HEADER ListHead);
typedef PSLIST_ENTRY(__stdcall* RtlInterlockedPopEntrySList)(PSLIST_HEADER ListHead);
typedef PSLIST_ENTRY(__stdcall* RtlInterlockedPushEntrySList)(PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry);
typedef PSLIST_ENTRY(__stdcall* RtlInterlockedPushListSListEx)(PSLIST_HEADER ListHead, PSLIST_ENTRY List, PSLIST_ENTRY ListEnd, DWORD Count);
typedef PSLIST_ENTRY(__stdcall* RtlInterlockedFlushSList)(PSLIST_HEADER ListHead);
typedef WORD(__stdcall* RtlQueryDepthSList)(PSLIST_HEADER ListHead);
typedef void(__stdcall* __fastfail)(unsigned int Code);
typedef DWORD(__stdcall* HEAP_MAKE_TAG_FLAGS)(DWORD TagBase, DWORD Tag);
typedef PVOID(__stdcall* RtlSecureZeroMemory)(PVOID ptr, SIZE_T cnt);
typedef ULONGLONG(__stdcall* VerSetConditionMask)(ULONGLONG ConditionMask, DWORD TypeMask, BYTE Condition);
typedef BOOLEAN(__stdcall* RtlGetProductInfo)(DWORD OSMajorVersion, DWORD OSMinorVersion, DWORD SpMajorVersion, DWORD SpMinorVersion, PDWORD ReturnedProductType);
typedef void(__stdcall* RTL_UMS_SCHEDULER_ENTRY_POINT)(RTL_UMS_SCHEDULER_REASON Reason, ULONG_PTR ActivationPayload, PVOID SchedulerParam);
typedef OS_DEPLOYEMENT_STATE_VALUES(__stdcall* RtlOsDeploymentState)(DWORD Flags);
typedef DWORD(__stdcall* RtlFreeNonVolatileToken)(PVOID NvToken);
typedef DWORD(__stdcall* RtlFlushNonVolatileMemory)(PVOID NvToken, PVOID NvBuffer, SIZE_T Size, DWORD Flags);
typedef DWORD(__stdcall* RtlDrainNonVolatileFlush)(PVOID NvToken);
typedef DWORD(__stdcall* RtlFlushNonVolatileMemoryRanges)(PVOID NvToken, PNV_MEMORY_RANGE NvRanges, SIZE_T NumRanges, DWORD Flags);
typedef DWORD(__stdcall* RtlIncrementCorrelationVector)(PCORRELATION_VECTOR CorrelationVector);
typedef DWORD(__stdcall* RtlExtendCorrelationVector)(PCORRELATION_VECTOR CorrelationVector);
typedef DWORD(__stdcall* RtlValidateCorrelationVector)(PCORRELATION_VECTOR Vector);
typedef void(__stdcall* CUSTOM_SYSTEM_EVENT_TRIGGER_INIT)(PCUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG Config, PCWSTR TriggerId);
typedef DWORD(__stdcall* RtlRaiseCustomSystemEventTrigger)(PCUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG TriggerConfig);
typedef BOOLEAN(__stdcall* RtlIsZeroMemory)(PVOID Buffer, SIZE_T Length);
typedef DWORD(__stdcall* RtlConvertDeviceFamilyInfoToString)(PDWORD pulDeviceFamilyBufferSize, PDWORD pulDeviceFormBufferSize, PWSTR DeviceFamily, PWSTR DeviceForm);
typedef DWORD(__stdcall* RtlSwitchedVVI)(PRTL_OSVERSIONINFOEXW VersionInfo, DWORD TypeMask, ULONGLONG ConditionMask);
typedef void(__stdcall* TpInitializeCallbackEnviron)(PTP_CALLBACK_ENVIRON CallbackEnviron);
typedef void(__stdcall* TpSetCallbackThreadpool)(PTP_CALLBACK_ENVIRON CallbackEnviron, PTP_POOL Pool);
typedef void(__stdcall* TpSetCallbackCleanupGroup)(PTP_CALLBACK_ENVIRON CallbackEnviron, PTP_CLEANUP_GROUP CleanupGroup, PTP_CLEANUP_GROUP_CANCEL_CALLBACK CleanupGroupCancelCallback);
typedef void(__stdcall* TpSetCallbackNoActivationContext)(PTP_CALLBACK_ENVIRON CallbackEnviron);
typedef void(__stdcall* TpSetCallbackLongFunction)(PTP_CALLBACK_ENVIRON CallbackEnviron);
typedef void(__stdcall* TpSetCallbackRaceWithDll)(PTP_CALLBACK_ENVIRON CallbackEnviron, PVOID DllHandle);
typedef void(__stdcall* TpSetCallbackFinalizationCallback)(PTP_CALLBACK_ENVIRON CallbackEnviron, PTP_SIMPLE_CALLBACK FinalizationCallback);
typedef void(__stdcall* TpSetCallbackPriority)(PTP_CALLBACK_ENVIRON CallbackEnviron, TP_CALLBACK_PRIORITY Priority);
typedef void(__stdcall* TpSetCallbackPersistent)(PTP_CALLBACK_ENVIRON CallbackEnviron);
typedef void(__stdcall* TpDestroyCallbackEnviron)(PTP_CALLBACK_ENVIRON CallbackEnviron);
typedef DNS_STATUS(__stdcall* DnsQueryConfig)(DNS_CONFIG_TYPE Config, DWORD Flag, PCWSTR pwsAdapterName, PVOID pReserved, PVOID pBuffer, PDWORD pBufLen);
typedef PDNS_RECORD(__stdcall* DnsRecordCopyEx)(PDNS_RECORD pRecord, DNS_CHARSET CharSetIn, DNS_CHARSET CharSetOut);
typedef PDNS_RECORD(__stdcall* DnsRecordSetCopyEx)(PDNS_RECORD pRecordSet, DNS_CHARSET CharSetIn, DNS_CHARSET CharSetOut);
typedef BOOL(__stdcall* DnsRecordCompare)(PDNS_RECORD pRecord1, PDNS_RECORD pRecord2);
typedef PDNS_RECORD(__stdcall* DnsRecordSetDetach)(PDNS_RECORD pRecordList);
typedef void(__stdcall* DnsFree)(PVOID pData, DNS_FREE_TYPE FreeType);
typedef DNS_STATUS(__stdcall* DnsQueryEx)(PDNS_QUERY_REQUEST pQueryRequest, PDNS_QUERY_RESULT pQueryResults, PDNS_QUERY_CANCEL pCancelHandle);
typedef DNS_STATUS(__stdcall* DnsCancelQuery)(PDNS_QUERY_CANCEL pCancelHandle);
typedef DNS_STATUS(__stdcall* DnsAcquireContextHandle_W)(DWORD CredentialFlags, PVOID Credentials, PHANDLE pContext);
typedef DNS_STATUS(__stdcall* DnsAcquireContextHandle_A)(DWORD CredentialFlags, PVOID Credentials, PHANDLE pContext);
typedef void(__stdcall* DnsReleaseContextHandle)(HANDLE hContext);
typedef DNS_STATUS(__stdcall* DnsModifyRecordsInSet_W)(PDNS_RECORD pAddRecords, PDNS_RECORD pDeleteRecords, DWORD Options, HANDLE hCredentials, PVOID pExtraList, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsModifyRecordsInSet_A)(PDNS_RECORD pAddRecords, PDNS_RECORD pDeleteRecords, DWORD Options, HANDLE hCredentials, PVOID pExtraList, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsModifyRecordsInSet_UTF8)(PDNS_RECORD pAddRecords, PDNS_RECORD pDeleteRecords, DWORD Options, HANDLE hCredentials, PVOID pExtraList, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsReplaceRecordSetW)(PDNS_RECORD pReplaceSet, DWORD Options, HANDLE hContext, PVOID pExtraInfo, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsReplaceRecordSetA)(PDNS_RECORD pReplaceSet, DWORD Options, HANDLE hContext, PVOID pExtraInfo, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsReplaceRecordSetUTF8)(PDNS_RECORD pReplaceSet, DWORD Options, HANDLE hContext, PVOID pExtraInfo, PVOID pReserved);
typedef DNS_STATUS(__stdcall* DnsValidateName_W)(PCWSTR pszName, DNS_NAME_FORMAT Format);
typedef DNS_STATUS(__stdcall* DnsValidateName_A)(PCSTR pszName, DNS_NAME_FORMAT Format);
typedef DNS_STATUS(__stdcall* DnsValidateName_UTF8)(PCSTR pszName, DNS_NAME_FORMAT Format);
typedef BOOL(__stdcall* DnsNameCompare_A)(PCSTR pName1, PCSTR pName2);
typedef BOOL(__stdcall* DnsNameCompare_W)(PCWSTR pName1, PCWSTR pName2);
typedef BOOL(__stdcall* DnsWriteQuestionToBuffer_W)(PDNS_MESSAGE_BUFFER pDnsBuffer, PDWORD pdwBufferSize, PCWSTR pszName, WORD wType, WORD Xid, BOOL fRecursionDesired);
typedef BOOL(__stdcall* DnsWriteQuestionToBuffer_UTF8)(PDNS_MESSAGE_BUFFER pDnsBuffer, PDWORD pdwBufferSize, PCSTR pszName, WORD wType, WORD Xid, BOOL fRecursionDesired);
typedef void(__stdcall* DnsFreeProxyName)(PWSTR proxyName);
typedef BOOL(__stdcall* CeipIsOptedIn)();
typedef HRESULT(__stdcall* WDEnable)(BOOL fEnable);
typedef DWORD(__stdcall* RemoveUsersFromEncryptedFile)(LPCWSTR lpFileName, PENCRYPTION_CERTIFICATE_HASH_LIST pHashes);
typedef DWORD(__stdcall* AddUsersToEncryptedFile)(LPCWSTR lpFileName, PENCRYPTION_CERTIFICATE_LIST pEncryptionCertificates);
typedef DWORD(__stdcall* SetUserFileEncryptionKey)(PENCRYPTION_CERTIFICATE pEncryptionCertificate);
typedef void(__stdcall* FreeEncryptionCertificateHashList)(PENCRYPTION_CERTIFICATE_HASH_LIST pUsers);
typedef BOOL(__stdcall* EncryptionDisable)(LPCWSTR DirPath, BOOL Disable);
typedef DWORD(__stdcall* DuplicateEncryptionInfoFile)(LPCWSTR SrcFileName, LPCWSTR DstFileName, DWORD dwCreationDistribution, DWORD dwAttributes, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef EVT_HANDLE(__stdcall* EvtOpenSession)(EVT_LOGIN_CLASS LoginClass, PVOID Login, DWORD Timeout, DWORD Flags);
typedef BOOL(__stdcall* EvtClose)(EVT_HANDLE Object);
typedef BOOL(__stdcall* EvtCancel)(EVT_HANDLE Object);
typedef DWORD(__stdcall* EvtGetExtendedStatus)(DWORD BufferSize, LPWSTR Buffer, PDWORD BufferUsed);
typedef EVT_HANDLE(__stdcall* EvtQuery)(EVT_HANDLE Session, LPCWSTR Path, LPCWSTR Query, DWORD Flags);
typedef BOOL(__stdcall* EvtNext)(EVT_HANDLE ResultSet, DWORD EventsSize, PEVT_HANDLE Events, DWORD Timeout, DWORD Flags, PDWORD Returned);
typedef BOOL(__stdcall* EvtSeek)(EVT_HANDLE ResultSet, LONGLONG Position, EVT_HANDLE Bookmark, DWORD Timeout, DWORD Flags);
typedef EVT_HANDLE(__stdcall* EvtSubscribe)(EVT_HANDLE Session, HANDLE SignalEvent, LPCWSTR ChannelPath, LPCWSTR Query, EVT_HANDLE Bookmark, PVOID Context, EVT_SUBSCRIBE_CALLBACK Callback, DWORD Flags);
typedef BOOL(__stdcall* EvtRender)(EVT_HANDLE Context, EVT_HANDLE Fragment, DWORD Flags, DWORD BufferSize, PVOID Buffer, PDWORD BufferUsed, PDWORD PropertyCount);
typedef BOOL(__stdcall* EvtFormatMessage)(EVT_HANDLE PublisherMetadata, EVT_HANDLE Event, DWORD MessageId, DWORD ValueCount, PEVT_VARIANT Values, DWORD Flags, DWORD BufferSize, LPWSTR Buffer, PDWORD BufferUsed);
typedef EVT_HANDLE(__stdcall* EvtOpenLog)(EVT_HANDLE Session, LPCWSTR Path, DWORD Flags);
typedef BOOL(__stdcall* EvtGetLogInfo)(EVT_HANDLE Log, EVT_LOG_PROPERTY_ID PropertyId, DWORD PropertyValueBufferSize, PEVT_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef BOOL(__stdcall* EvtClearLog)(EVT_HANDLE Session, LPCWSTR ChannelPath, LPCWSTR TargetFilePath, DWORD Flags);
typedef BOOL(__stdcall* EvtExportLog)(EVT_HANDLE Session, LPCWSTR Path, LPCWSTR Query, LPCWSTR TargetFilePath, DWORD Flags);
typedef BOOL(__stdcall* EvtArchiveExportedLog)(EVT_HANDLE Session, LPCWSTR LogFilePath, LCID Locale, DWORD Flags);
typedef EVT_HANDLE(__stdcall* EvtOpenChannelEnum)(EVT_HANDLE Session, DWORD Flags);
typedef BOOL(__stdcall* EvtNextChannelPath)(EVT_HANDLE ChannelEnum, DWORD ChannelPathBufferSize, LPWSTR ChannelPathBuffer, PDWORD ChannelPathBufferUsed);
typedef EVT_HANDLE(__stdcall* EvtOpenChannelConfig)(EVT_HANDLE Session, LPCWSTR ChannelPath, DWORD Flags);
typedef BOOL(__stdcall* EvtSaveChannelConfig)(EVT_HANDLE ChannelConfig, DWORD Flags);
typedef BOOL(__stdcall* EvtSetChannelConfigProperty)(EVT_HANDLE ChannelConfig, EVT_CHANNEL_CONFIG_PROPERTY_ID PropertyId, DWORD Flags, PEVT_VARIANT PropertyValue);
typedef BOOL(__stdcall* EvtGetChannelConfigProperty)(EVT_HANDLE ChannelConfig, EVT_CHANNEL_CONFIG_PROPERTY_ID PropertyId, DWORD Flags, DWORD PropertyValueBufferSize, PEVT_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef EVT_HANDLE(__stdcall* EvtOpenPublisherEnum)(EVT_HANDLE Session, DWORD Flags);
typedef BOOL(__stdcall* EvtNextPublisherId)(EVT_HANDLE PublisherEnum, DWORD PublisherIdBufferSize, LPWSTR PublisherIdBuffer, PDWORD PublisherIdBufferUsed);
typedef EVT_HANDLE(__stdcall* EvtOpenPublisherMetadata)(EVT_HANDLE Session, LPCWSTR PublisherId, LPCWSTR LogFilePath, LCID Locale, DWORD Flags);
typedef BOOL(__stdcall* EvtGetPublisherMetadataProperty)(EVT_HANDLE PublisherMetadata, EVT_PUBLISHER_METADATA_PROPERTY_ID PropertyId, DWORD Flags, DWORD PublisherMetadataPropertyBufferSize, PEVT_VARIANT PublisherMetadataPropertyBuffer, PDWORD PublisherMetadataPropertyBufferUsed);
typedef EVT_HANDLE(__stdcall* EvtOpenEventMetadataEnum)(EVT_HANDLE PublisherMetadata, DWORD Flags);
typedef EVT_HANDLE(__stdcall* EvtNextEventMetadata)(EVT_HANDLE EventMetadataEnum, DWORD Flags);
typedef BOOL(__stdcall* EvtGetEventMetadataProperty)(EVT_HANDLE EventMetadata, EVT_EVENT_METADATA_PROPERTY_ID PropertyId, DWORD Flags, DWORD EventMetadataPropertyBufferSize, PEVT_VARIANT EventMetadataPropertyBuffer, PDWORD EventMetadataPropertyBufferUsed);
typedef BOOL(__stdcall* EvtGetObjectArraySize)(EVT_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, PDWORD ObjectArraySize);
typedef BOOL(__stdcall* EvtGetObjectArrayProperty)(EVT_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray, DWORD PropertyId, DWORD ArrayIndex, DWORD Flags, DWORD PropertyValueBufferSize, PEVT_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef BOOL(__stdcall* EvtGetQueryInfo)(EVT_HANDLE QueryOrSubscription, EVT_QUERY_PROPERTY_ID PropertyId, DWORD PropertyValueBufferSize, PEVT_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef EVT_HANDLE(__stdcall* EvtCreateBookmark)(LPCWSTR BookmarkXml);
typedef BOOL(__stdcall* EvtUpdateBookmark)(EVT_HANDLE Bookmark, EVT_HANDLE Event);
typedef BOOL(__stdcall* EvtGetEventInfo)(EVT_HANDLE Event, EVT_EVENT_PROPERTY_ID PropertyId, DWORD PropertyValueBufferSize, PEVT_VARIANT PropertyValueBuffer, PDWORD PropertyValueBufferUsed);
typedef BOOL(__stdcall* Arc)(HDC hdc, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
typedef BOOL(__stdcall* BitBlt)(HDC hdc, int x, int y, int cx, int cy, HDC hdcSrc, int x1, int y1, DWORD rop);
typedef BOOL(__stdcall* CancelDC)(HDC hdc);
typedef BOOL(__stdcall* Chord)(HDC hdc, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
typedef HMETAFILE(__stdcall* CloseMetaFile)(HDC hdc);
typedef int(__stdcall* CombineRgn)(HRGN hrgnDst, HRGN hrgnSrc1, HRGN hrgnSrc2, int iMode);
typedef HBITMAP(__stdcall* CreateCompatibleBitmap)(HDC hdc, int cx, int cy);
typedef HBITMAP(__stdcall* CreateDiscardableBitmap)(HDC hdc, int cx, int cy);
typedef HDC(__stdcall* CreateCompatibleDC)(HDC hdc);
typedef HBRUSH(__stdcall* CreateDIBPatternBrush)(HGLOBAL h, UINT iUsage);
typedef HRGN(__stdcall* CreateEllipticRgn)(int x1, int y1, int x2, int y2);
typedef HFONT(__stdcall* CreateFontA)(int cHeight, int cWidth, int cEscapement, int cOrientation, int cWeight, DWORD bItalic, DWORD bUnderline, DWORD bStrikeOut, DWORD iCharSet, DWORD iOutPrecision, DWORD iClipPrecision, DWORD iQuality, DWORD iPitchAndFamily, LPCSTR pszFaceName);
typedef HFONT(__stdcall* CreateFontW)(int cHeight, int cWidth, int cEscapement, int cOrientation, int cWeight, DWORD bItalic, DWORD bUnderline, DWORD bStrikeOut, DWORD iCharSet, DWORD iOutPrecision, DWORD iClipPrecision, DWORD iQuality, DWORD iPitchAndFamily, LPCWSTR pszFaceName);
typedef HBRUSH(__stdcall* CreateHatchBrush)(int iHatch, COLORREF color);
typedef HDC(__stdcall* CreateMetaFileA)(LPCSTR pszFile);
typedef HDC(__stdcall* CreateMetaFileW)(LPCWSTR pszFile);
typedef HPEN(__stdcall* CreatePen)(int iStyle, int cWidth, COLORREF color);
typedef HBRUSH(__stdcall* CreatePatternBrush)(HBITMAP hbm);
typedef HRGN(__stdcall* CreateRectRgn)(int x1, int y1, int x2, int y2);
typedef HRGN(__stdcall* CreateRoundRectRgn)(int x1, int y1, int x2, int y2, int w, int h);
typedef BOOL(__stdcall* CreateScalableFontResourceA)(DWORD fdwHidden, LPCSTR lpszFont, LPCSTR lpszFile, LPCSTR lpszPath);
typedef BOOL(__stdcall* CreateScalableFontResourceW)(DWORD fdwHidden, LPCWSTR lpszFont, LPCWSTR lpszFile, LPCWSTR lpszPath);
typedef HBRUSH(__stdcall* CreateSolidBrush)(COLORREF color);
typedef BOOL(__stdcall* DeleteDC)(HDC hdc);
typedef BOOL(__stdcall* DeleteMetaFile)(HMETAFILE hmf);
typedef BOOL(__stdcall* DeleteObject)(HGDIOBJ ho);
typedef int(__stdcall* DescribePixelFormat)(HDC hdc, int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd);
typedef int(__stdcall* DrawEscape)(HDC hdc, int iEscape, int cjIn, LPCSTR lpIn);
typedef BOOL(__stdcall* Ellipse)(HDC hdc, int left, int top, int right, int bottom);
typedef int(__stdcall* EnumFontFamiliesExA)(HDC hdc, LPLOGFONTA lpLogfont, FONTENUMPROCA lpProc, LPARAM lParam, DWORD dwFlags);
typedef int(__stdcall* EnumFontFamiliesExW)(HDC hdc, LPLOGFONTW lpLogfont, FONTENUMPROCW lpProc, LPARAM lParam, DWORD dwFlags);
typedef int(__stdcall* EnumFontFamiliesA)(HDC hdc, LPCSTR lpLogfont, FONTENUMPROCA lpProc, LPARAM lParam);
typedef int(__stdcall* EnumFontFamiliesW)(HDC hdc, LPCWSTR lpLogfont, FONTENUMPROCW lpProc, LPARAM lParam);
typedef int(__stdcall* EnumFontsA)(HDC hdc, LPCSTR lpLogfont, FONTENUMPROCA lpProc, LPARAM lParam);
typedef int(__stdcall* EnumFontsW)(HDC hdc, LPCWSTR lpLogfont, FONTENUMPROCW lpProc, LPARAM lParam);
typedef int(__stdcall* EnumObjects)(HDC hdc, int nType, GOBJENUMPROC lpFunc, LPARAM lParam);
typedef BOOL(__stdcall* EqualRgn)(HRGN hrgn1, HRGN hrgn2);
typedef int(__stdcall* Escape)(HDC hdc, int iEscape, int cjIn, LPCSTR pvIn, LPVOID pvOut);
typedef int(__stdcall* ExtEscape)(HDC hdc, int iEscape, int cjInput, LPCSTR lpInData, int cjOutput, LPSTR lpOutData);
typedef int(__stdcall* ExcludeClipRect)(HDC hdc, int left, int top, int right, int bottom);
typedef BOOL(__stdcall* ExtFloodFill)(HDC hdc, int x, int y, COLORREF color, UINT type);
typedef BOOL(__stdcall* FillRgn)(HDC hdc, HRGN hrgn, HBRUSH hbr);
typedef BOOL(__stdcall* FloodFill)(HDC hdc, int x, int y, COLORREF color);
typedef BOOL(__stdcall* FrameRgn)(HDC hdc, HRGN hrgn, HBRUSH hbr, int w, int h);
typedef int(__stdcall* GetROP2)(HDC hdc);
typedef BOOL(__stdcall* GetAspectRatioFilterEx)(HDC hdc, LPSIZE lpsize);
typedef COLORREF(__stdcall* GetBkColor)(HDC hdc);
typedef COLORREF(__stdcall* GetDCBrushColor)(HDC hdc);
typedef COLORREF(__stdcall* GetDCPenColor)(HDC hdc);
typedef int(__stdcall* GetBkMode)(HDC hdc);
typedef LONG(__stdcall* GetBitmapBits)(HBITMAP hbit, LONG cb, LPVOID lpvBits);
typedef BOOL(__stdcall* GetBitmapDimensionEx)(HBITMAP hbit, LPSIZE lpsize);
typedef UINT(__stdcall* GetBoundsRect)(HDC hdc, LPRECT lprect, UINT flags);
typedef BOOL(__stdcall* GetBrushOrgEx)(HDC hdc, LPPOINT lppt);
typedef BOOL(__stdcall* GetCharWidthA)(HDC hdc, UINT iFirst, UINT iLast, LPINT lpBuffer);
typedef BOOL(__stdcall* GetCharWidthW)(HDC hdc, UINT iFirst, UINT iLast, LPINT lpBuffer);
typedef BOOL(__stdcall* GetCharWidth32A)(HDC hdc, UINT iFirst, UINT iLast, LPINT lpBuffer);
typedef BOOL(__stdcall* GetCharWidth32W)(HDC hdc, UINT iFirst, UINT iLast, LPINT lpBuffer);
typedef BOOL(__stdcall* GetCharWidthFloatA)(HDC hdc, UINT iFirst, UINT iLast, PFLOAT lpBuffer);
typedef BOOL(__stdcall* GetCharWidthFloatW)(HDC hdc, UINT iFirst, UINT iLast, PFLOAT lpBuffer);
typedef BOOL(__stdcall* GetCharABCWidthsA)(HDC hdc, UINT wFirst, UINT wLast, LPABC lpABC);
typedef BOOL(__stdcall* GetCharABCWidthsW)(HDC hdc, UINT wFirst, UINT wLast, LPABC lpABC);
typedef BOOL(__stdcall* GetCharABCWidthsFloatA)(HDC hdc, UINT iFirst, UINT iLast, LPABCFLOAT lpABC);
typedef BOOL(__stdcall* GetCharABCWidthsFloatW)(HDC hdc, UINT iFirst, UINT iLast, LPABCFLOAT lpABC);
typedef int(__stdcall* GetClipBox)(HDC hdc, LPRECT lprect);
typedef int(__stdcall* GetClipRgn)(HDC hdc, HRGN hrgn);
typedef int(__stdcall* GetMetaRgn)(HDC hdc, HRGN hrgn);
typedef HGDIOBJ(__stdcall* GetCurrentObject)(HDC hdc, UINT type);
typedef BOOL(__stdcall* GetCurrentPositionEx)(HDC hdc, LPPOINT lppt);
typedef int(__stdcall* GetDeviceCaps)(HDC hdc, int index);
typedef int(__stdcall* GetDIBits)(HDC hdc, HBITMAP hbm, UINT start, UINT cLines, LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT usage);
typedef DWORD(__stdcall* GetFontData)(HDC hdc, DWORD dwTable, DWORD dwOffset, PVOID pvBuffer, DWORD cjBuffer);
typedef int(__stdcall* GetGraphicsMode)(HDC hdc);
typedef int(__stdcall* GetMapMode)(HDC hdc);
typedef UINT(__stdcall* GetMetaFileBitsEx)(HMETAFILE hMF, UINT cbBuffer, LPVOID lpData);
typedef HMETAFILE(__stdcall* GetMetaFileA)(LPCSTR lpName);
typedef HMETAFILE(__stdcall* GetMetaFileW)(LPCWSTR lpName);
typedef COLORREF(__stdcall* GetNearestColor)(HDC hdc, COLORREF color);
typedef UINT(__stdcall* GetNearestPaletteIndex)(HPALETTE h, COLORREF color);
typedef DWORD(__stdcall* GetObjectType)(HGDIOBJ h);
typedef UINT(__stdcall* GetOutlineTextMetricsA)(HDC hdc, UINT cjCopy, LPOUTLINETEXTMETRICA potm);
typedef UINT(__stdcall* GetOutlineTextMetricsW)(HDC hdc, UINT cjCopy, LPOUTLINETEXTMETRICW potm);
typedef UINT(__stdcall* GetPaletteEntries)(HPALETTE hpal, UINT iStart, UINT cEntries, LPPALETTEENTRY pPalEntries);
typedef COLORREF(__stdcall* GetPixel)(HDC hdc, int x, int y);
typedef int(__stdcall* GetPixelFormat)(HDC hdc);
typedef int(__stdcall* GetPolyFillMode)(HDC hdc);
typedef BOOL(__stdcall* GetRasterizerCaps)(LPRASTERIZER_STATUS lpraststat, UINT cjBytes);
typedef int(__stdcall* GetRandomRgn)(HDC hdc, HRGN hrgn, INT i);
typedef DWORD(__stdcall* GetRegionData)(HRGN hrgn, DWORD nCount, LPRGNDATA lpRgnData);
typedef int(__stdcall* GetRgnBox)(HRGN hrgn, LPRECT lprc);
typedef HGDIOBJ(__stdcall* GetStockObject)(int i);
typedef int(__stdcall* GetStretchBltMode)(HDC hdc);
typedef UINT(__stdcall* GetSystemPaletteEntries)(HDC hdc, UINT iStart, UINT cEntries, LPPALETTEENTRY pPalEntries);
typedef UINT(__stdcall* GetSystemPaletteUse)(HDC hdc);
typedef int(__stdcall* GetTextCharacterExtra)(HDC hdc);
typedef UINT(__stdcall* GetTextAlign)(HDC hdc);
typedef COLORREF(__stdcall* GetTextColor)(HDC hdc);
typedef BOOL(__stdcall* GetTextExtentPointA)(HDC hdc, LPCSTR lpString, int c, LPSIZE lpsz);
typedef BOOL(__stdcall* GetTextExtentPointW)(HDC hdc, LPCWSTR lpString, int c, LPSIZE lpsz);
typedef BOOL(__stdcall* GetTextExtentPoint32A)(HDC hdc, LPCSTR lpString, int c, LPSIZE psizl);
typedef BOOL(__stdcall* GetTextExtentPoint32W)(HDC hdc, LPCWSTR lpString, int c, LPSIZE psizl);
typedef BOOL(__stdcall* GetTextExtentExPointA)(HDC hdc, LPCSTR lpszString, int cchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize);
typedef BOOL(__stdcall* GetTextExtentExPointW)(HDC hdc, LPCWSTR lpszString, int cchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize);
typedef int(__stdcall* GetTextCharset)(HDC hdc);
typedef int(__stdcall* GetTextCharsetInfo)(HDC hdc, LPFONTSIGNATURE lpSig, DWORD dwFlags);
typedef DWORD(__stdcall* GetFontLanguageInfo)(HDC hdc);
typedef DWORD(__stdcall* GetCharacterPlacementA)(HDC hdc, LPCSTR lpString, int nCount, int nMexExtent, LPGCP_RESULTSA lpResults, DWORD dwFlags);
typedef DWORD(__stdcall* GetCharacterPlacementW)(HDC hdc, LPCWSTR lpString, int nCount, int nMexExtent, LPGCP_RESULTSW lpResults, DWORD dwFlags);
typedef DWORD(__stdcall* GetFontUnicodeRanges)(HDC hdc, LPGLYPHSET lpgs);
typedef DWORD(__stdcall* GetGlyphIndicesA)(HDC hdc, LPCSTR lpstr, int c, LPWORD pgi, DWORD fl);
typedef DWORD(__stdcall* GetGlyphIndicesW)(HDC hdc, LPCWSTR lpstr, int c, LPWORD pgi, DWORD fl);
typedef BOOL(__stdcall* GetTextExtentPointI)(HDC hdc, LPWORD pgiIn, int cgi, LPSIZE psize);
typedef BOOL(__stdcall* GetTextExtentExPointI)(HDC hdc, LPWORD lpwszString, int cwchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize);
typedef BOOL(__stdcall* GetCharWidthI)(HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, LPINT piWidths);
typedef BOOL(__stdcall* GetCharABCWidthsI)(HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, LPABC pabc);
typedef int(__stdcall* AddFontResourceExA)(LPCSTR name, DWORD fl, PVOID res);
typedef int(__stdcall* AddFontResourceExW)(LPCWSTR name, DWORD fl, PVOID res);
typedef BOOL(__stdcall* RemoveFontResourceExA)(LPCSTR name, DWORD fl, PVOID pdv);
typedef BOOL(__stdcall* RemoveFontResourceExW)(LPCWSTR name, DWORD fl, PVOID pdv);
typedef BOOL(__stdcall* RemoveFontMemResourceEx)(HANDLE h);
typedef BOOL(__stdcall* GetViewportExtEx)(HDC hdc, LPSIZE lpsize);
typedef BOOL(__stdcall* GetViewportOrgEx)(HDC hdc, LPPOINT lppoint);
typedef BOOL(__stdcall* GetWindowExtEx)(HDC hdc, LPSIZE lpsize);
typedef BOOL(__stdcall* GetWindowOrgEx)(HDC hdc, LPPOINT lppoint);
typedef int(__stdcall* IntersectClipRect)(HDC hdc, int left, int top, int right, int bottom);
typedef BOOL(__stdcall* InvertRgn)(HDC hdc, HRGN hrgn);
typedef BOOL(__stdcall* LineDDA)(int xStart, int yStart, int xEnd, int yEnd, LINEDDAPROC lpProc, LPARAM data);
typedef BOOL(__stdcall* LineTo)(HDC hdc, int x, int y);
typedef BOOL(__stdcall* MaskBlt)(HDC hdcDest, int xDest, int yDest, int width, int height, HDC hdcSrc, int xSrc, int ySrc, HBITMAP hbmMask, int xMask, int yMask, DWORD rop);
typedef int(__stdcall* OffsetClipRgn)(HDC hdc, int x, int y);
typedef int(__stdcall* OffsetRgn)(HRGN hrgn, int x, int y);
typedef BOOL(__stdcall* PatBlt)(HDC hdc, int x, int y, int w, int h, DWORD rop);
typedef BOOL(__stdcall* Pie)(HDC hdc, int left, int top, int right, int bottom, int xr1, int yr1, int xr2, int yr2);
typedef BOOL(__stdcall* PlayMetaFile)(HDC hdc, HMETAFILE hmf);
typedef BOOL(__stdcall* PaintRgn)(HDC hdc, HRGN hrgn);
typedef BOOL(__stdcall* PtInRegion)(HRGN hrgn, int x, int y);
typedef BOOL(__stdcall* PtVisible)(HDC hdc, int x, int y);
typedef BOOL(__stdcall* Rectangle)(HDC hdc, int left, int top, int right, int bottom);
typedef BOOL(__stdcall* RestoreDC)(HDC hdc, int nSavedDC);
typedef UINT(__stdcall* RealizePalette)(HDC hdc);
typedef BOOL(__stdcall* RemoveFontResourceA)(LPCSTR lpFileName);
typedef BOOL(__stdcall* RemoveFontResourceW)(LPCWSTR lpFileName);
typedef BOOL(__stdcall* RoundRect)(HDC hdc, int left, int top, int right, int bottom, int width, int height);
typedef BOOL(__stdcall* ResizePalette)(HPALETTE hpal, UINT n);
typedef int(__stdcall* SaveDC)(HDC hdc);
typedef int(__stdcall* SelectClipRgn)(HDC hdc, HRGN hrgn);
typedef int(__stdcall* ExtSelectClipRgn)(HDC hdc, HRGN hrgn, int mode);
typedef int(__stdcall* SetMetaRgn)(HDC hdc);
typedef HGDIOBJ(__stdcall* SelectObject)(HDC hdc, HGDIOBJ h);
typedef HPALETTE(__stdcall* SelectPalette)(HDC hdc, HPALETTE hPal, BOOL bForceBkgd);
typedef COLORREF(__stdcall* SetBkColor)(HDC hdc, COLORREF color);
typedef COLORREF(__stdcall* SetDCBrushColor)(HDC hdc, COLORREF color);
typedef COLORREF(__stdcall* SetDCPenColor)(HDC hdc, COLORREF color);
typedef int(__stdcall* SetBkMode)(HDC hdc, int mode);
typedef DWORD(__stdcall* SetMapperFlags)(HDC hdc, DWORD flags);
typedef int(__stdcall* SetGraphicsMode)(HDC hdc, int iMode);
typedef int(__stdcall* SetMapMode)(HDC hdc, int iMode);
typedef DWORD(__stdcall* SetLayout)(HDC hdc, DWORD l);
typedef DWORD(__stdcall* GetLayout)(HDC hdc);
typedef COLORREF(__stdcall* SetPixel)(HDC hdc, int x, int y, COLORREF color);
typedef BOOL(__stdcall* SetPixelV)(HDC hdc, int x, int y, COLORREF color);
typedef int(__stdcall* SetPolyFillMode)(HDC hdc, int mode);
typedef BOOL(__stdcall* StretchBlt)(HDC hdcDest, int xDest, int yDest, int wDest, int hDest, HDC hdcSrc, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rop);
typedef BOOL(__stdcall* SetRectRgn)(HRGN hrgn, int left, int top, int right, int bottom);
typedef int(__stdcall* SetROP2)(HDC hdc, int rop2);
typedef int(__stdcall* SetStretchBltMode)(HDC hdc, int mode);
typedef UINT(__stdcall* SetSystemPaletteUse)(HDC hdc, UINT use);
typedef int(__stdcall* SetTextCharacterExtra)(HDC hdc, int extra);
typedef COLORREF(__stdcall* SetTextColor)(HDC hdc, COLORREF color);
typedef UINT(__stdcall* SetTextAlign)(HDC hdc, UINT align);
typedef BOOL(__stdcall* SetTextJustification)(HDC hdc, int extra, int count);
typedef BOOL(__stdcall* UpdateColors)(HDC hdc);
typedef BOOL(__stdcall* AlphaBlend)(HDC hdcDest, int xoriginDest, int yoriginDest, int wDest, int hDest, HDC hdcSrc, int xoriginSrc, int yoriginSrc, int wSrc, int hSrc, BLENDFUNCTION ftn);
typedef BOOL(__stdcall* TransparentBlt)(HDC hdcDest, int xoriginDest, int yoriginDest, int wDest, int hDest, HDC hdcSrc, int xoriginSrc, int yoriginSrc, int wSrc, int hSrc, UINT crTransparent);
typedef BOOL(__stdcall* GradientFill)(HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode);
typedef BOOL(__stdcall* GdiAlphaBlend)(HDC hdcDest, int xoriginDest, int yoriginDest, int wDest, int hDest, HDC hdcSrc, int xoriginSrc, int yoriginSrc, int wSrc, int hSrc, BLENDFUNCTION ftn);
typedef BOOL(__stdcall* GdiTransparentBlt)(HDC hdcDest, int xoriginDest, int yoriginDest, int wDest, int hDest, HDC hdcSrc, int xoriginSrc, int yoriginSrc, int wSrc, int hSrc, UINT crTransparent);
typedef BOOL(__stdcall* GdiGradientFill)(HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nCount, ULONG ulMode);
typedef BOOL(__stdcall* PlayMetaFileRecord)(HDC hdc, LPHANDLETABLE lpHandleTable, LPMETARECORD lpMR, UINT noObjs);
typedef BOOL(__stdcall* EnumMetaFile)(HDC hdc, HMETAFILE hmf, MFENUMPROC proc, LPARAM param);
typedef HENHMETAFILE(__stdcall* CloseEnhMetaFile)(HDC hdc);
typedef HENHMETAFILE(__stdcall* CopyEnhMetaFileA)(HENHMETAFILE hEnh, LPCSTR lpFileName);
typedef HENHMETAFILE(__stdcall* CopyEnhMetaFileW)(HENHMETAFILE hEnh, LPCWSTR lpFileName);
typedef BOOL(__stdcall* DeleteEnhMetaFile)(HENHMETAFILE hmf);
typedef HENHMETAFILE(__stdcall* GetEnhMetaFileA)(LPCSTR lpName);
typedef HENHMETAFILE(__stdcall* GetEnhMetaFileW)(LPCWSTR lpName);
typedef UINT(__stdcall* GetEnhMetaFileBits)(HENHMETAFILE hEMF, UINT nSize, LPBYTE lpData);
typedef UINT(__stdcall* GetEnhMetaFileDescriptionA)(HENHMETAFILE hemf, UINT cchBuffer, LPSTR lpDescription);
typedef UINT(__stdcall* GetEnhMetaFileDescriptionW)(HENHMETAFILE hemf, UINT cchBuffer, LPWSTR lpDescription);
typedef UINT(__stdcall* GetEnhMetaFileHeader)(HENHMETAFILE hemf, UINT nSize, LPENHMETAHEADER lpEnhMetaHeader);
typedef UINT(__stdcall* GetEnhMetaFilePaletteEntries)(HENHMETAFILE hemf, UINT nNumEntries, LPPALETTEENTRY lpPaletteEntries);
typedef UINT(__stdcall* GetWinMetaFileBits)(HENHMETAFILE hemf, UINT cbData16, LPBYTE pData16, INT iMapMode, HDC hdcRef);
typedef BOOL(__stdcall* GetTextMetricsA)(HDC hdc, LPTEXTMETRICA lptm);
typedef BOOL(__stdcall* GetTextMetricsW)(HDC hdc, LPTEXTMETRICW lptm);
typedef BOOL(__stdcall* AngleArc)(HDC hdc, int x, int y, DWORD r, FLOAT StartAngle, FLOAT SweepAngle);
typedef BOOL(__stdcall* GetWorldTransform)(HDC hdc, LPXFORM lpxf);
typedef BOOL(__stdcall* GetColorAdjustment)(HDC hdc, LPCOLORADJUSTMENT lpca);
typedef HPALETTE(__stdcall* CreateHalftonePalette)(HDC hdc);
typedef int(__stdcall* EndDoc)(HDC hdc);
typedef int(__stdcall* StartPage)(HDC hdc);
typedef int(__stdcall* EndPage)(HDC hdc);
typedef int(__stdcall* AbortDoc)(HDC hdc);
typedef int(__stdcall* SetAbortProc)(HDC hdc, ABORTPROC proc);
typedef BOOL(__stdcall* AbortPath)(HDC hdc);
typedef BOOL(__stdcall* ArcTo)(HDC hdc, int left, int top, int right, int bottom, int xr1, int yr1, int xr2, int yr2);
typedef BOOL(__stdcall* BeginPath)(HDC hdc);
typedef BOOL(__stdcall* CloseFigure)(HDC hdc);
typedef BOOL(__stdcall* EndPath)(HDC hdc);
typedef BOOL(__stdcall* FillPath)(HDC hdc);
typedef BOOL(__stdcall* FlattenPath)(HDC hdc);
typedef int(__stdcall* GetPath)(HDC hdc, LPPOINT apt, LPBYTE aj, int cpt);
typedef HRGN(__stdcall* PathToRegion)(HDC hdc);
typedef BOOL(__stdcall* SelectClipPath)(HDC hdc, int mode);
typedef int(__stdcall* SetArcDirection)(HDC hdc, int dir);
typedef BOOL(__stdcall* SetMiterLimit)(HDC hdc, FLOAT limit, PFLOAT old);
typedef BOOL(__stdcall* StrokeAndFillPath)(HDC hdc);
typedef BOOL(__stdcall* StrokePath)(HDC hdc);
typedef BOOL(__stdcall* WidenPath)(HDC hdc);
typedef BOOL(__stdcall* GetMiterLimit)(HDC hdc, PFLOAT plimit);
typedef int(__stdcall* GetArcDirection)(HDC hdc);
typedef int(__stdcall* GetObjectA)(HANDLE h, int c, LPVOID pv);
typedef int(__stdcall* GetObjectW)(HANDLE h, int c, LPVOID pv);
typedef BOOL(__stdcall* MoveToEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef BOOL(__stdcall* TextOutA)(HDC hdc, int x, int y, LPCSTR lpString, int c);
typedef BOOL(__stdcall* TextOutW)(HDC hdc, int x, int y, LPCWSTR lpString, int c);
typedef BOOL(__stdcall* DPtoLP)(HDC hdc, LPPOINT lppt, int c);
typedef BOOL(__stdcall* LPtoDP)(HDC hdc, LPPOINT lppt, int c);
typedef BOOL(__stdcall* SetViewportExtEx)(HDC hdc, int x, int y, LPSIZE lpsz);
typedef BOOL(__stdcall* SetViewportOrgEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef BOOL(__stdcall* SetWindowExtEx)(HDC hdc, int x, int y, LPSIZE lpsz);
typedef BOOL(__stdcall* SetWindowOrgEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef BOOL(__stdcall* OffsetViewportOrgEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef BOOL(__stdcall* OffsetWindowOrgEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef BOOL(__stdcall* ScaleViewportExtEx)(HDC hdc, int xn, int dx, int yn, int yd, LPSIZE lpsz);
typedef BOOL(__stdcall* ScaleWindowExtEx)(HDC hdc, int xn, int xd, int yn, int yd, LPSIZE lpsz);
typedef BOOL(__stdcall* SetBitmapDimensionEx)(HBITMAP hbm, int w, int h, LPSIZE lpsz);
typedef BOOL(__stdcall* SetBrushOrgEx)(HDC hdc, int x, int y, LPPOINT lppt);
typedef int(__stdcall* GetTextFaceA)(HDC hdc, int c, LPSTR lpName);
typedef int(__stdcall* GetTextFaceW)(HDC hdc, int c, LPWSTR lpName);
typedef DWORD(__stdcall* GetKerningPairsA)(HDC hdc, DWORD nPairs, LPKERNINGPAIR lpKernPair);
typedef DWORD(__stdcall* GetKerningPairsW)(HDC hdc, DWORD nPairs, LPKERNINGPAIR lpKernPair);
typedef BOOL(__stdcall* GetDCOrgEx)(HDC hdc, LPPOINT lppt);
typedef BOOL(__stdcall* UnrealizeObject)(HGDIOBJ h);
typedef DWORD(__stdcall* GdiSetBatchLimit)(DWORD dw);
typedef int(__stdcall* SetICMMode)(HDC hdc, int mode);
typedef BOOL(__stdcall* CheckColorsInGamut)(HDC hdc, LPRGBTRIPLE lpRGBTriple, LPVOID dlpBuffer, DWORD nCount);
typedef HCOLORSPACE(__stdcall* GetColorSpace)(HDC hdc);
typedef BOOL(__stdcall* GetLogColorSpaceA)(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEA lpBuffer, DWORD nSize);
typedef BOOL(__stdcall* GetLogColorSpaceW)(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEW lpBuffer, DWORD nSize);
typedef HCOLORSPACE(__stdcall* CreateColorSpaceA)(LPLOGCOLORSPACEA lplcs);
typedef HCOLORSPACE(__stdcall* CreateColorSpaceW)(LPLOGCOLORSPACEW lplcs);
typedef HCOLORSPACE(__stdcall* SetColorSpace)(HDC hdc, HCOLORSPACE hcs);
typedef BOOL(__stdcall* DeleteColorSpace)(HCOLORSPACE hcs);
typedef BOOL(__stdcall* GetICMProfileA)(HDC hdc, LPDWORD pBufSize, LPSTR pszFilename);
typedef BOOL(__stdcall* GetICMProfileW)(HDC hdc, LPDWORD pBufSize, LPWSTR pszFilename);
typedef BOOL(__stdcall* SetICMProfileA)(HDC hdc, LPSTR lpFileName);
typedef BOOL(__stdcall* SetICMProfileW)(HDC hdc, LPWSTR lpFileName);
typedef BOOL(__stdcall* GetDeviceGammaRamp)(HDC hdc, LPVOID lpRamp);
typedef BOOL(__stdcall* SetDeviceGammaRamp)(HDC hdc, LPVOID lpRamp);
typedef BOOL(__stdcall* ColorMatchToTarget)(HDC hdc, HDC hdcTarget, DWORD action);
typedef int(__stdcall* EnumICMProfilesA)(HDC hdc, ICMENUMPROCA proc, LPARAM param);
typedef int(__stdcall* EnumICMProfilesW)(HDC hdc, ICMENUMPROCW proc, LPARAM param);
typedef BOOL(__stdcall* UpdateICMRegKeyA)(DWORD reserved, LPSTR lpszCMID, LPSTR lpszFileName, UINT command);
typedef BOOL(__stdcall* UpdateICMRegKeyW)(DWORD reserved, LPWSTR lpszCMID, LPWSTR lpszFileName, UINT command);
typedef BOOL(__stdcall* ColorCorrectPalette)(HDC hdc, HPALETTE hPal, DWORD deFirst, DWORD num);
typedef WINHTTP_STATUS_CALLBACK(__stdcall* WinHttpSetStatusCallback)(HINTERNET hInternet, WINHTTP_STATUS_CALLBACK lpfnInternetCallback, DWORD dwNotificationFlags, DWORD_PTR dwReserved);
typedef BOOL(__stdcall* WinHttpCrackUrl)(LPCWSTR pwszUrl, DWORD dwUrlLength, DWORD dwFlags, LPURL_COMPONENTS lpUrlComponents);
typedef BOOL(__stdcall* WinHttpCreateUrl)(LPURL_COMPONENTS lpUrlComponents, DWORD dwFlags, LPWSTR pwszUrl, LPDWORD pdwUrlLength);
typedef HINTERNET(__stdcall* WinHttpOpen)(LPCWSTR pszAgentW, DWORD dwAccessType, LPCWSTR pszProxyW, LPCWSTR pszProxyBypassW, DWORD dwFlags);
typedef BOOL(__stdcall* WinHttpCloseHandle)(HINTERNET hInternet);
typedef HINTERNET(__stdcall* WinHttpConnect)(HINTERNET hSession, LPCWSTR pswzServerName, INTERNET_PORT nServerPort, DWORD dwReserved);
typedef BOOL(__stdcall* WinHttpReadData)(HINTERNET hRequest, LPVOID lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD lpdwNumberOfBytesRead);
typedef BOOL(__stdcall* WinHttpWriteData)(HINTERNET hRequest, LPCVOID lpBuffer, DWORD dwNumberOfBytesToWrite, LPDWORD lpdwNumberOfBytesWritten);
typedef BOOL(__stdcall* WinHttpQueryDataAvailable)(HINTERNET hRequest, LPDWORD lpdwNumberOfBytesAvailable);
typedef BOOL(__stdcall* WinHttpQueryOption)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* WinHttpSetOption)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
typedef BOOL(__stdcall* WinHttpSetTimeouts)(HINTERNET hInternet, int nResolveTimeout, int nConnectTimeout, int nSendTimeout, int nReceiveTimeout);
typedef BOOL(__stdcall* WinHttpAddRequestHeaders)(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwModifiers);
typedef BOOL(__stdcall* WinHttpSendRequest)(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, LPVOID lpOptional, DWORD dwOptionalLength, DWORD dwTotalLength, DWORD_PTR dwContext);
typedef BOOL(__stdcall* WinHttpSetCredentials)(HINTERNET hRequest, DWORD AuthTargets, DWORD AuthScheme, LPCWSTR pwszUserName, LPCWSTR pwszPassword, LPVOID pAuthParams);
typedef BOOL(__stdcall* WinHttpQueryAuthSchemes)(HINTERNET hRequest, LPDWORD lpdwSupportedSchemes, LPDWORD lpdwFirstScheme, LPDWORD pdwAuthTarget);
typedef BOOL(__stdcall* WinHttpReceiveResponse)(HINTERNET hRequest, LPVOID lpReserved);
typedef BOOL(__stdcall* WinHttpQueryHeaders)(HINTERNET hRequest, DWORD dwInfoLevel, LPCWSTR pwszName, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex);
typedef DWORD(__stdcall* WinHttpResetAutoProxy)(HINTERNET hSession, DWORD dwFlags);
typedef HINTERNET(__stdcall* WinHttpWebSocketCompleteUpgrade)(HINTERNET hRequest, DWORD_PTR pContext);
typedef DWORD(__stdcall* WinHttpWebSocketSend)(HINTERNET hWebSocket, WINHTTP_WEB_SOCKET_BUFFER_TYPE eBufferType, PVOID pvBuffer, DWORD dwBufferLength);
typedef DWORD(__stdcall* WinHttpWebSocketShutdown)(HINTERNET hWebSocket, USHORT usStatus, PVOID pvReason, DWORD dwReasonLength);
typedef DWORD(__stdcall* WinHttpWebSocketClose)(HINTERNET hWebSocket, USHORT usStatus, PVOID pvReason, DWORD dwReasonLength);
typedef BOOL(__stdcall* InternetCrackUrlA)(LPCSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags, LPURL_COMPONENTSA lpUrlComponents);
typedef BOOL(__stdcall* InternetCrackUrlW)(LPCWSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags, LPURL_COMPONENTSW lpUrlComponents);
typedef BOOL(__stdcall* InternetCreateUrlA)(LPURL_COMPONENTSA lpUrlComponents, DWORD dwFlags, LPSTR lpszUrl, LPDWORD lpdwUrlLength);
typedef BOOL(__stdcall* InternetCreateUrlW)(LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags, LPWSTR lpszUrl, LPDWORD lpdwUrlLength);
typedef BOOL(__stdcall* InternetCanonicalizeUrlA)(LPCSTR lpszUrl, LPSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags);
typedef BOOL(__stdcall* InternetCanonicalizeUrlW)(LPCWSTR lpszUrl, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags);
typedef BOOL(__stdcall* InternetCombineUrlA)(LPCSTR lpszBaseUrl, LPCSTR lpszRelativeUrl, LPSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags);
typedef BOOL(__stdcall* InternetCombineUrlW)(LPCWSTR lpszBaseUrl, LPCWSTR lpszRelativeUrl, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags);
typedef HINTERNET(__stdcall* InternetOpenA)(LPCSTR lpszAgent, DWORD dwAccessType, LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags);
typedef HINTERNET(__stdcall* InternetOpenW)(LPCWSTR lpszAgent, DWORD dwAccessType, LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags);
typedef BOOL(__stdcall* InternetCloseHandle)(HINTERNET hInternet);
typedef HINTERNET(__stdcall* InternetConnectA)(HINTERNET hInternet, LPCSTR lpszServerName, INTERNET_PORT nServerPort, LPCSTR lpszUserName, LPCSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* InternetConnectW)(HINTERNET hInternet, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* InternetOpenUrlA)(HINTERNET hInternet, LPCSTR lpszUrl, LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* InternetOpenUrlW)(HINTERNET hInternet, LPCWSTR lpszUrl, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* InternetReadFile)(HINTERNET hFile, LPVOID lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD lpdwNumberOfBytesRead);
typedef BOOL(__stdcall* InternetReadFileExA)(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* InternetReadFileExW)(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef DWORD(__stdcall* InternetSetFilePointer)(HINTERNET hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod, DWORD_PTR dwContext);
typedef BOOL(__stdcall* InternetWriteFile)(HINTERNET hFile, LPCVOID lpBuffer, DWORD dwNumberOfBytesToWrite, LPDWORD lpdwNumberOfBytesWritten);
typedef BOOL(__stdcall* InternetQueryDataAvailable)(HINTERNET hFile, LPDWORD lpdwNumberOfBytesAvailable, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* InternetFindNextFileA)(HINTERNET hFind, LPVOID lpvFindData);
typedef BOOL(__stdcall* InternetFindNextFileW)(HINTERNET hFind, LPVOID lpvFindData);
typedef BOOL(__stdcall* InternetQueryOptionA)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* InternetQueryOptionW)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* InternetSetOptionA)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
typedef BOOL(__stdcall* InternetSetOptionW)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
typedef BOOL(__stdcall* InternetSetOptionExA)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags);
typedef BOOL(__stdcall* InternetSetOptionExW)(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags);
typedef BOOL(__stdcall* InternetUnlockRequestFile)(HANDLE hLockRequestInfo);
typedef BOOL(__stdcall* InternetGetLastResponseInfoA)(LPDWORD lpdwError, LPSTR lpszBuffer, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* InternetGetLastResponseInfoW)(LPDWORD lpdwError, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength);
typedef INTERNET_STATUS_CALLBACK(__stdcall* InternetSetStatusCallbackA)(HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnInternetCallback);
typedef INTERNET_STATUS_CALLBACK(__stdcall* InternetSetStatusCallbackW)(HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnInternetCallback);
typedef INTERNET_STATUS_CALLBACK(__stdcall* InternetSetStatusCallback)(HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnInternetCallback);
typedef HINTERNET(__stdcall* FtpFindFirstFileA)(HINTERNET hConnect, LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* FtpFindFirstFileW)(HINTERNET hConnect, LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpGetFileA)(HINTERNET hConnect, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile, BOOL fFailIfExists, DWORD dwFlagsAndAttributes, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpGetFileW)(HINTERNET hConnect, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile, BOOL fFailIfExists, DWORD dwFlagsAndAttributes, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpPutFileA)(HINTERNET hConnect, LPCSTR lpszLocalFile, LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpPutFileW)(HINTERNET hConnect, LPCWSTR lpszLocalFile, LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpDeleteFileA)(HINTERNET hConnect, LPCSTR lpszFileName);
typedef BOOL(__stdcall* FtpDeleteFileW)(HINTERNET hConnect, LPCWSTR lpszFileName);
typedef BOOL(__stdcall* FtpRenameFileA)(HINTERNET hConnect, LPCSTR lpszExisting, LPCSTR lpszNew);
typedef BOOL(__stdcall* FtpRenameFileW)(HINTERNET hConnect, LPCWSTR lpszExisting, LPCWSTR lpszNew);
typedef HINTERNET(__stdcall* FtpOpenFileA)(HINTERNET hConnect, LPCSTR lpszFileName, DWORD dwAccess, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* FtpOpenFileW)(HINTERNET hConnect, LPCWSTR lpszFileName, DWORD dwAccess, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* FtpCreateDirectoryA)(HINTERNET hConnect, LPCSTR lpszDirectory);
typedef BOOL(__stdcall* FtpCreateDirectoryW)(HINTERNET hConnect, LPCWSTR lpszDirectory);
typedef BOOL(__stdcall* FtpRemoveDirectoryA)(HINTERNET hConnect, LPCSTR lpszDirectory);
typedef BOOL(__stdcall* FtpRemoveDirectoryW)(HINTERNET hConnect, LPCWSTR lpszDirectory);
typedef BOOL(__stdcall* FtpSetCurrentDirectoryA)(HINTERNET hConnect, LPCSTR lpszDirectory);
typedef BOOL(__stdcall* FtpSetCurrentDirectoryW)(HINTERNET hConnect, LPCWSTR lpszDirectory);
typedef BOOL(__stdcall* FtpGetCurrentDirectoryA)(HINTERNET hConnect, LPSTR lpszCurrentDirectory, LPDWORD lpdwCurrentDirectory);
typedef BOOL(__stdcall* FtpGetCurrentDirectoryW)(HINTERNET hConnect, LPWSTR lpszCurrentDirectory, LPDWORD lpdwCurrentDirectory);
typedef DWORD(__stdcall* FtpGetFileSize)(HINTERNET hFile, LPDWORD lpdwFileSizeHigh);
typedef BOOL(__stdcall* GopherCreateLocatorA)(LPCSTR lpszHost, INTERNET_PORT nServerPort, LPCSTR lpszDisplayString, LPCSTR lpszSelectorString, DWORD dwGopherType, LPSTR lpszLocator, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* GopherCreateLocatorW)(LPCWSTR lpszHost, INTERNET_PORT nServerPort, LPCWSTR lpszDisplayString, LPCWSTR lpszSelectorString, DWORD dwGopherType, LPWSTR lpszLocator, LPDWORD lpdwBufferLength);
typedef BOOL(__stdcall* GopherGetLocatorTypeA)(LPCSTR lpszLocator, LPDWORD lpdwGopherType);
typedef BOOL(__stdcall* GopherGetLocatorTypeW)(LPCWSTR lpszLocator, LPDWORD lpdwGopherType);
typedef HINTERNET(__stdcall* GopherFindFirstFileA)(HINTERNET hConnect, LPCSTR lpszLocator, LPCSTR lpszSearchString, LPGOPHER_FIND_DATAA lpFindData, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* GopherFindFirstFileW)(HINTERNET hConnect, LPCWSTR lpszLocator, LPCWSTR lpszSearchString, LPGOPHER_FIND_DATAW lpFindData, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* GopherOpenFileA)(HINTERNET hConnect, LPCSTR lpszLocator, LPCSTR lpszView, DWORD dwFlags, DWORD_PTR dwContext);
typedef HINTERNET(__stdcall* GopherOpenFileW)(HINTERNET hConnect, LPCWSTR lpszLocator, LPCWSTR lpszView, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* GopherGetAttributeA)(HINTERNET hConnect, LPCSTR lpszLocator, LPCSTR lpszAttributeName, LPBYTE lpBuffer, DWORD dwBufferLength, LPDWORD lpdwCharactersReturned, GOPHER_ATTRIBUTE_ENUMERATOR lpfnEnumerator, DWORD_PTR dwContext);
typedef BOOL(__stdcall* GopherGetAttributeW)(HINTERNET hConnect, LPCWSTR lpszLocator, LPCWSTR lpszAttributeName, LPBYTE lpBuffer, DWORD dwBufferLength, LPDWORD lpdwCharactersReturned, GOPHER_ATTRIBUTE_ENUMERATOR lpfnEnumerator, DWORD_PTR dwContext);
typedef BOOL(__stdcall* HttpAddRequestHeadersA)(HINTERNET hRequest, LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwModifiers);
typedef BOOL(__stdcall* HttpAddRequestHeadersW)(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwModifiers);
typedef BOOL(__stdcall* HttpSendRequestA)(HINTERNET hRequest, LPCSTR lpszHeaders, DWORD dwHeadersLength, LPVOID lpOptional, DWORD dwOptionalLength);
typedef BOOL(__stdcall* HttpSendRequestW)(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, LPVOID lpOptional, DWORD dwOptionalLength);
typedef BOOL(__stdcall* HttpSendRequestExA)(HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersIn, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* HttpSendRequestExW)(HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersIn, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* HttpEndRequestA)(HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* HttpEndRequestW)(HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext);
typedef BOOL(__stdcall* HttpQueryInfoA)(HINTERNET hRequest, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex);
typedef BOOL(__stdcall* HttpQueryInfoW)(HINTERNET hRequest, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex);
typedef BOOL(__stdcall* InternetSetCookieA)(LPCSTR lpszUrl, LPCSTR lpszCookieName, LPCSTR lpszCookieData);
typedef BOOL(__stdcall* InternetSetCookieW)(LPCWSTR lpszUrl, LPCWSTR lpszCookieName, LPCWSTR lpszCookieData);
typedef BOOL(__stdcall* InternetGetCookieA)(LPCSTR lpszUrl, LPCSTR lpszCookieName, LPSTR lpszCookieData, LPDWORD lpdwSize);
typedef BOOL(__stdcall* InternetGetCookieW)(LPCWSTR lpszUrl, LPCWSTR lpszCookieName, LPWSTR lpszCookieData, LPDWORD lpdwSize);
typedef DWORD(__stdcall* InternetSetCookieExA)(LPCSTR lpszUrl, LPCSTR lpszCookieName, LPCSTR lpszCookieData, DWORD dwFlags, DWORD_PTR dwReserved);
typedef DWORD(__stdcall* InternetSetCookieExW)(LPCWSTR lpszUrl, LPCWSTR lpszCookieName, LPCWSTR lpszCookieData, DWORD dwFlags, DWORD_PTR dwReserved);
typedef BOOL(__stdcall* InternetGetCookieExA)(LPCSTR lpszUrl, LPCSTR lpszCookieName, LPSTR lpszCookieData, LPDWORD lpdwSize, DWORD dwFlags, LPVOID lpReserved);
typedef BOOL(__stdcall* InternetGetCookieExW)(LPCWSTR lpszUrl, LPCWSTR lpszCookieName, LPWSTR lpszCookieData, LPDWORD lpdwSize, DWORD dwFlags, LPVOID lpReserved);
typedef DWORD(__stdcall* InternetAttemptConnect)(DWORD dwReserved);
typedef BOOL(__stdcall* InternetCheckConnectionA)(LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved);
typedef BOOL(__stdcall* InternetCheckConnectionW)(LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved);
typedef BOOL(__stdcall* ResumeSuspendedDownload)(HINTERNET hRequest, DWORD dwResultCode);
typedef DWORD(__stdcall* InternetConfirmZoneCrossingA)(HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost);
typedef DWORD(__stdcall* InternetConfirmZoneCrossingW)(HWND hWnd, LPWSTR szUrlPrev, LPWSTR szUrlNew, BOOL bPost);
typedef DWORD(__stdcall* InternetConfirmZoneCrossing)(HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost);
typedef BOOL(__stdcall* CreateUrlCacheEntryA)(LPCSTR lpszUrlName, DWORD dwExpectedFileSize, LPCSTR lpszFileExtension, LPSTR lpszFileName, DWORD dwReserved);
typedef BOOL(__stdcall* CreateUrlCacheEntryW)(LPCWSTR lpszUrlName, DWORD dwExpectedFileSize, LPCWSTR lpszFileExtension, LPWSTR lpszFileName, DWORD dwReserved);
typedef BOOL(__stdcall* CommitUrlCacheEntryA)(LPCSTR lpszUrlName, LPCSTR lpszLocalFileName, FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType, LPBYTE lpHeaderInfo, DWORD cchHeaderInfo, LPCSTR lpszFileExtension, LPCSTR lpszOriginalUrl);
typedef BOOL(__stdcall* CommitUrlCacheEntryW)(LPCWSTR lpszUrlName, LPCWSTR lpszLocalFileName, FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType, LPWSTR lpszHeaderInfo, DWORD cchHeaderInfo, LPCWSTR lpszFileExtension, LPCWSTR lpszOriginalUrl);
typedef BOOL(__stdcall* RetrieveUrlCacheEntryFileA)(LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, DWORD dwReserved);
typedef BOOL(__stdcall* RetrieveUrlCacheEntryFileW)(LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, DWORD dwReserved);
typedef BOOL(__stdcall* UnlockUrlCacheEntryFileA)(LPCSTR lpszUrlName, DWORD dwReserved);
typedef BOOL(__stdcall* UnlockUrlCacheEntryFileW)(LPCWSTR lpszUrlName, DWORD dwReserved);
typedef BOOL(__stdcall* UnlockUrlCacheEntryFile)(LPCSTR lpszUrlName, DWORD dwReserved);
typedef HANDLE(__stdcall* RetrieveUrlCacheEntryStreamA)(LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, BOOL fRandomRead, DWORD dwReserved);
typedef HANDLE(__stdcall* RetrieveUrlCacheEntryStreamW)(LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, BOOL fRandomRead, DWORD dwReserved);
typedef BOOL(__stdcall* ReadUrlCacheEntryStream)(HANDLE hUrlCacheStream, DWORD dwLocation, LPVOID lpBuffer, LPDWORD lpdwLen, DWORD Reserved);
typedef BOOL(__stdcall* UnlockUrlCacheEntryStream)(HANDLE hUrlCacheStream, DWORD Reserved);
typedef BOOL(__stdcall* GetUrlCacheEntryInfoA)(LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef BOOL(__stdcall* GetUrlCacheEntryInfoW)(LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef BOOL(__stdcall* GetUrlCacheGroupAttributeA)(GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPDWORD lpcbGroupInfo, LPVOID lpReserved);
typedef BOOL(__stdcall* GetUrlCacheGroupAttributeW)(GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPDWORD lpcbGroupInfo, LPVOID lpReserved);
typedef BOOL(__stdcall* SetUrlCacheGroupAttributeA)(GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPVOID lpReserved);
typedef BOOL(__stdcall* SetUrlCacheGroupAttributeW)(GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPVOID lpReserved);
typedef BOOL(__stdcall* GetUrlCacheEntryInfoExA)(LPCSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPSTR lpszRedirectUrl, LPDWORD lpcbRedirectUrl, LPVOID lpReserved, DWORD dwFlags);
typedef BOOL(__stdcall* GetUrlCacheEntryInfoExW)(LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPWSTR lpszRedirectUrl, LPDWORD lpcbRedirectUrl, LPVOID lpReserved, DWORD dwFlags);
typedef BOOL(__stdcall* SetUrlCacheEntryInfoA)(LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, DWORD dwFieldControl);
typedef BOOL(__stdcall* SetUrlCacheEntryInfoW)(LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, DWORD dwFieldControl);
typedef GROUPID(__stdcall* CreateUrlCacheGroup)(DWORD dwFlags, LPVOID lpReserved);
typedef BOOL(__stdcall* DeleteUrlCacheGroup)(GROUPID GroupId, DWORD dwFlags, LPVOID lpReserved);
typedef BOOL(__stdcall* SetUrlCacheEntryGroupA)(LPCSTR lpszUrlName, DWORD dwFlags, GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes, LPVOID lpReserved);
typedef BOOL(__stdcall* SetUrlCacheEntryGroupW)(LPCWSTR lpszUrlName, DWORD dwFlags, GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes, LPVOID lpReserved);
typedef BOOL(__stdcall* SetUrlCacheEntryGroup)(LPCSTR lpszUrlName, DWORD dwFlags, GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes, LPVOID lpReserved);
typedef HANDLE(__stdcall* FindFirstUrlCacheEntryExA)(LPCSTR lpszUrlSearchPattern, DWORD dwFlags, DWORD dwFilter, GROUPID GroupId, LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPVOID lpGroupAttributes, LPDWORD lpcbGroupAttributes, LPVOID lpReserved);
typedef HANDLE(__stdcall* FindFirstUrlCacheEntryExW)(LPCWSTR lpszUrlSearchPattern, DWORD dwFlags, DWORD dwFilter, GROUPID GroupId, LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPVOID lpGroupAttributes, LPDWORD lpcbGroupAttributes, LPVOID lpReserved);
typedef BOOL(__stdcall* FindNextUrlCacheEntryExA)(HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPVOID lpGroupAttributes, LPDWORD lpcbGroupAttributes, LPVOID lpReserved);
typedef BOOL(__stdcall* FindNextUrlCacheEntryExW)(HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOW lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo, LPVOID lpGroupAttributes, LPDWORD lpcbGroupAttributes, LPVOID lpReserved);
typedef HANDLE(__stdcall* FindFirstUrlCacheEntryA)(LPCSTR lpszUrlSearchPattern, LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef HANDLE(__stdcall* FindFirstUrlCacheEntryW)(LPCWSTR lpszUrlSearchPattern, LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef BOOL(__stdcall* FindNextUrlCacheEntryA)(HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef BOOL(__stdcall* FindNextUrlCacheEntryW)(HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOW lpNextCacheEntryInfo, LPDWORD lpcbCacheEntryInfo);
typedef BOOL(__stdcall* FindCloseUrlCache)(HANDLE hEnumHandle);
typedef BOOL(__stdcall* DeleteUrlCacheEntryA)(LPCSTR lpszUrlName);
typedef BOOL(__stdcall* DeleteUrlCacheEntryW)(LPCWSTR lpszUrlName);
typedef BOOL(__stdcall* DeleteUrlCacheEntry)(LPCSTR lpszUrlName);
typedef DWORD(__stdcall* InternetDial)(HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags, LPDWORD lpdwConnection, DWORD dwReserved);
typedef DWORD(__stdcall* InternetHangUp)(DWORD_PTR dwConnection, DWORD dwReserved);
typedef BOOL(__stdcall* InternetGoOnlineA)(LPCSTR lpszURL, HWND hwndParent, DWORD dwFlags);
typedef BOOL(__stdcall* InternetGoOnlineW)(LPCWSTR lpszURL, HWND hwndParent, DWORD dwFlags);
typedef BOOL(__stdcall* InternetGoOnline)(LPSTR lpszURL, HWND hwndParent, DWORD dwFlags);
typedef BOOL(__stdcall* InternetAutodial)(DWORD dwFlags, HWND hwndParent);
typedef BOOL(__stdcall* InternetAutodialHangup)(DWORD dwReserved);
typedef BOOL(__stdcall* InternetGetConnectedState)(LPDWORD lpdwFlags, DWORD dwReserved);
typedef BOOL(__stdcall* InternetGetConnectedStateExA)(LPDWORD lpdwFlags, LPSTR lpszConnectionName, DWORD cchNameLen, DWORD dwReserved);
typedef BOOL(__stdcall* InternetGetConnectedStateExW)(LPDWORD lpdwFlags, LPWSTR lpszConnectionName, DWORD cchNameLen, DWORD dwReserved);
typedef BOOL(__stdcall* InternetInitializeAutoProxyDll)(DWORD dwReserved);
typedef BOOL(__stdcall* DetectAutoProxyUrl)(PSTR pszAutoProxyUrl, DWORD cchAutoProxyUrl, DWORD dwDetectFlags);
typedef BOOL(__stdcall* CreateMD5SSOHash)(PWSTR pszChallengeInfo, PWSTR pwszRealm, PWSTR pwszTarget, PBYTE pbHexHash);
typedef BOOL(__stdcall* InternetGetConnectedStateEx)(LPDWORD lpdwFlags, LPSTR lpszConnectionName, DWORD dwNameLen, DWORD dwReserved);
typedef BOOL(__stdcall* InternetSetDialStateA)(LPCSTR lpszConnectoid, DWORD dwState, DWORD dwReserved);
typedef BOOL(__stdcall* InternetSetDialStateW)(LPCWSTR lpszConnectoid, DWORD dwState, DWORD dwReserved);
typedef BOOL(__stdcall* InternetSetDialState)(LPCSTR lpszConnectoid, DWORD dwState, DWORD dwReserved);
typedef BOOL(__stdcall* InternetSetPerSiteCookieDecisionA)(LPCSTR pchHostName, DWORD dwDecision);
typedef BOOL(__stdcall* InternetSetPerSiteCookieDecisionW)(LPCWSTR pchHostName, DWORD dwDecision);
typedef BOOL(__stdcall* InternetClearAllPerSiteCookieDecisions)();
typedef DWORD(__stdcall* PrivacySetZonePreferenceW)(DWORD dwZone, DWORD dwType, DWORD dwTemplate, LPCWSTR pszPreference);
typedef DWORD(__stdcall* PrivacyGetZonePreferenceW)(DWORD dwZone, DWORD dwType, LPDWORD pdwTemplate, LPWSTR pszBuffer, LPDWORD pdwBufferLength);
typedef DWORD(__stdcall* WNetAddConnectionA)(LPCSTR lpRemoteName, LPCSTR lpPassword, LPCSTR lpLocalName);
typedef DWORD(__stdcall* WNetAddConnectionW)(LPCWSTR lpRemoteName, LPCWSTR lpPassword, LPCWSTR lpLocalName);
typedef DWORD(__stdcall* WNetAddConnection2A)(LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserName, DWORD dwFlags);
typedef DWORD(__stdcall* WNetAddConnection2W)(LPNETRESOURCEW lpNetResource, LPCWSTR lpPassword, LPCWSTR lpUserName, DWORD dwFlags);
typedef DWORD(__stdcall* WNetAddConnection3A)(HWND hwndOwner, LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserName, DWORD dwFlags);
typedef DWORD(__stdcall* WNetAddConnection3W)(HWND hwndOwner, LPNETRESOURCEW lpNetResource, LPCWSTR lpPassword, LPCWSTR lpUserName, DWORD dwFlags);
typedef DWORD(__stdcall* WNetCancelConnectionA)(LPCSTR lpName, BOOL fForce);
typedef DWORD(__stdcall* WNetCancelConnectionW)(LPCWSTR lpName, BOOL fForce);
typedef DWORD(__stdcall* WNetCancelConnection2A)(LPCSTR lpName, DWORD dwFlags, BOOL fForce);
typedef DWORD(__stdcall* WNetCancelConnection2W)(LPCWSTR lpName, DWORD dwFlags, BOOL fForce);
typedef DWORD(__stdcall* WNetGetConnectionA)(LPCSTR lpLocalName, LPSTR lpRemoteName, LPDWORD lpnLength);
typedef DWORD(__stdcall* WNetGetConnectionW)(LPCWSTR lpLocalName, LPWSTR lpRemoteName, LPDWORD lpnLength);
typedef DWORD(__stdcall* WNetUseConnectionA)(HWND hwndOwner, LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserId, DWORD dwFlags, LPSTR lpAccessName, LPDWORD lpBufferSize, LPDWORD lpResult);
typedef DWORD(__stdcall* WNetUseConnectionW)(HWND hwndOwner, LPNETRESOURCEW lpNetResource, LPCWSTR lpPassword, LPCWSTR lpUserId, DWORD dwFlags, LPWSTR lpAccessName, LPDWORD lpBufferSize, LPDWORD lpResult);
typedef DWORD(__stdcall* WNetConnectionDialog)(HWND hwnd, DWORD dwType);
typedef DWORD(__stdcall* WNetDisconnectDialog)(HWND hwnd, DWORD dwType);
typedef DWORD(__stdcall* WNetConnectionDialog1A)(LPCONNECTDLGSTRUCTA lpConnDlgStruct);
typedef DWORD(__stdcall* WNetConnectionDialog1W)(LPCONNECTDLGSTRUCTW lpConnDlgStruct);
typedef DWORD(__stdcall* WNetDisconnectDialog1A)(LPDISCDLGSTRUCTA lpConnDlgStruct);
typedef DWORD(__stdcall* WNetDisconnectDialog1W)(LPDISCDLGSTRUCTW lpConnDlgStruct);
typedef DWORD(__stdcall* WNetOpenEnumA)(DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEA lpNetResource, LPHANDLE lphEnum);
typedef DWORD(__stdcall* WNetOpenEnumW)(DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEW lpNetResource, LPHANDLE lphEnum);
typedef DWORD(__stdcall* WNetEnumResourceA)(HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetEnumResourceW)(HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetCloseEnum)(HANDLE hEnum);
typedef DWORD(__stdcall* WNetGetResourceParentA)(LPNETRESOURCEA lpNetResource, LPVOID lpBuffer, LPDWORD lpcbBuffer);
typedef DWORD(__stdcall* WNetGetResourceParentW)(LPNETRESOURCEW lpNetResource, LPVOID lpBuffer, LPDWORD lpcbBuffer);
typedef DWORD(__stdcall* WNetGetUniversalNameA)(LPCSTR lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetGetUniversalNameW)(LPCWSTR lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetGetUserA)(LPCSTR lpName, LPSTR lpUserName, LPDWORD lpnLength);
typedef DWORD(__stdcall* WNetGetUserW)(LPCWSTR lpName, LPWSTR lpUserName, LPDWORD lpnLength);
typedef DWORD(__stdcall* WNetGetProviderNameA)(DWORD dwNetType, LPSTR lpProviderName, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetGetProviderNameW)(DWORD dwNetType, LPWSTR lpProviderName, LPDWORD lpBufferSize);
typedef DWORD(__stdcall* WNetGetNetworkInformationA)(LPCSTR lpProvider, LPNETINFOSTRUCT lpNetInfoStruct);
typedef DWORD(__stdcall* WNetGetNetworkInformationW)(LPCWSTR lpProvider, LPNETINFOSTRUCT lpNetInfoStruct);
typedef DWORD(__stdcall* WNetGetLastErrorA)(LPDWORD lpError, LPSTR lpErrorBuf, DWORD nErrorBufSize, LPSTR lpNameBuf, DWORD nNameBufSize);
typedef DWORD(__stdcall* WNetGetLastErrorW)(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize, LPWSTR lpNameBuf, DWORD nNameBufSize);
typedef DWORD(__stdcall* MultinetGetConnectionPerformanceA)(LPNETRESOURCEA lpNetResource, LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct);
typedef DWORD(__stdcall* MultinetGetConnectionPerformanceW)(LPNETRESOURCEW lpNetResource, LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct);
typedef int(__stdcall* CompareStringW)(LCID Locale, DWORD dwCmpFlags, PCNZWCH lpString1, int cchCount1, PCNZWCH lpString2, int cchCount2);
typedef int(__stdcall* FoldStringW)(DWORD dwMapFlags, LPCWCH lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
typedef BOOL(__stdcall* IsValidCodePage)(UINT CodePage);
typedef BOOL(__stdcall* GetCPInfo)(UINT CodePage, LPCPINFO lpCPInfo);
typedef BOOL(__stdcall* GetCPInfoExA)(UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx);
typedef BOOL(__stdcall* GetCPInfoExW)(UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx);
typedef int(__stdcall* CompareStringA)(LCID Locale, DWORD dwCmpFlags, PCNZCH lpString1, int cchCount1, PCNZCH lpString2, int cchCount2);
typedef int(__stdcall* FindNLSString)(LCID Locale, DWORD dwFindNLSStringFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, LPINT pcchFound);
typedef int(__stdcall* LCMapStringW)(LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
typedef int(__stdcall* LCMapStringA)(LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
typedef int(__stdcall* GetLocaleInfoW)(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData);
typedef int(__stdcall* GetLocaleInfoA)(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData);
typedef BOOL(__stdcall* SetLocaleInfoA)(LCID Locale, LCTYPE LCType, LPCSTR lpLCData);
typedef BOOL(__stdcall* SetLocaleInfoW)(LCID Locale, LCTYPE LCType, LPCWSTR lpLCData);
typedef int(__stdcall* GetCalendarInfoA)(LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue);
typedef int(__stdcall* GetCalendarInfoW)(LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue);
typedef BOOL(__stdcall* SetCalendarInfoA)(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData);
typedef BOOL(__stdcall* SetCalendarInfoW)(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData);
typedef BOOL(__stdcall* LoadStringByReference)(DWORD Flags, PCWSTR Language, PCWSTR SourceString, PWSTR Buffer, ULONG cchBuffer, PCWSTR Directory, PULONG pcchBufferOut);
typedef BOOL(__stdcall* IsDBCSLeadByte)(BYTE TestChar);
typedef BOOL(__stdcall* IsDBCSLeadByteEx)(UINT CodePage, BYTE TestChar);
typedef LCID(__stdcall* LocaleNameToLCID)(LPCWSTR lpName, DWORD dwFlags);
typedef int(__stdcall* LCIDToLocaleName)(LCID Locale, LPWSTR lpName, int cchName, DWORD dwFlags);
typedef BOOL(__stdcall* EnumCalendarInfoA)(CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType);
typedef BOOL(__stdcall* EnumCalendarInfoW)(CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType);
typedef BOOL(__stdcall* EnumCalendarInfoExA)(CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType);
typedef BOOL(__stdcall* EnumCalendarInfoExW)(CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType);
typedef BOOL(__stdcall* EnumTimeFormatsA)(TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* EnumTimeFormatsW)(TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* EnumDateFormatsA)(DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* EnumDateFormatsW)(DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* EnumDateFormatsExA)(DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* EnumDateFormatsExW)(DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags);
typedef BOOL(__stdcall* IsValidLanguageGroup)(LGRPID LanguageGroup, DWORD dwFlags);
typedef BOOL(__stdcall* GetNLSVersion)(NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation);
typedef BOOL(__stdcall* IsValidLocale)(LCID Locale, DWORD dwFlags);
typedef int(__stdcall* GetGeoInfoA)(GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId);
typedef int(__stdcall* GetGeoInfoW)(GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId);
typedef int(__stdcall* GetGeoInfoEx)(PWSTR location, GEOTYPE geoType, PWSTR geoData, int geoDataCount);
typedef BOOL(__stdcall* EnumSystemGeoID)(GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc);
typedef BOOL(__stdcall* EnumSystemGeoNames)(GEOCLASS geoClass, GEO_ENUMNAMEPROC geoEnumProc, LPARAM data);
typedef GEOID(__stdcall* GetUserGeoID)(GEOCLASS GeoClass);
typedef int(__stdcall* GetUserDefaultGeoName)(LPWSTR geoName, int geoNameCount);
typedef BOOL(__stdcall* SetUserGeoID)(GEOID GeoId);
typedef BOOL(__stdcall* SetUserGeoName)(PWSTR geoName);
typedef LCID(__stdcall* ConvertDefaultLocale)(LCID Locale);
typedef BOOL(__stdcall* SetThreadLocale)(LCID Locale);
typedef LANGID(__stdcall* SetThreadUILanguage)(LANGID LangId);
typedef BOOL(__stdcall* GetProcessPreferredUILanguages)(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
typedef BOOL(__stdcall* SetProcessPreferredUILanguages)(DWORD dwFlags, PCZZWSTR pwszLanguagesBuffer, PULONG pulNumLanguages);
typedef BOOL(__stdcall* GetUserPreferredUILanguages)(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
typedef BOOL(__stdcall* GetSystemPreferredUILanguages)(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
typedef BOOL(__stdcall* GetThreadPreferredUILanguages)(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
typedef BOOL(__stdcall* SetThreadPreferredUILanguages)(DWORD dwFlags, PCZZWSTR pwszLanguagesBuffer, PULONG pulNumLanguages);
typedef BOOL(__stdcall* GetFileMUIPath)(DWORD dwFlags, PCWSTR pcwszFilePath, PWSTR pwszLanguage, PULONG pcchLanguage, PWSTR pwszFileMUIPath, PULONG pcchFileMUIPath, PULONGLONG pululEnumerator);
typedef BOOL(__stdcall* GetUILanguageInfo)(DWORD dwFlags, PCZZWSTR pwmszLanguage, PZZWSTR pwszFallbackLanguages, PDWORD pcchFallbackLanguages, PDWORD pAttributes);
typedef BOOL(__stdcall* NotifyUILanguageChange)(DWORD dwFlags, PCWSTR pcwstrNewLanguage, PCWSTR pcwstrPreviousLanguage, DWORD dwReserved, PDWORD pdwStatusRtrn);
typedef BOOL(__stdcall* GetStringTypeA)(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType);
typedef int(__stdcall* FoldStringA)(DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
typedef BOOL(__stdcall* EnumSystemLocalesA)(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags);
typedef BOOL(__stdcall* EnumSystemLocalesW)(LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags);
typedef BOOL(__stdcall* EnumSystemLanguageGroupsA)(LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumSystemLanguageGroupsW)(LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumLanguageGroupLocalesW)(LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumUILanguagesA)(UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumUILanguagesW)(UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam);
typedef BOOL(__stdcall* EnumSystemCodePagesA)(CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags);
typedef BOOL(__stdcall* EnumSystemCodePagesW)(CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags);
typedef int(__stdcall* IdnToAscii)(DWORD dwFlags, LPCWSTR lpUnicodeCharStr, int cchUnicodeChar, LPWSTR lpASCIICharStr, int cchASCIIChar);
typedef int(__stdcall* IdnToUnicode)(DWORD dwFlags, LPCWSTR lpASCIICharStr, int cchASCIIChar, LPWSTR lpUnicodeCharStr, int cchUnicodeChar);
typedef int(__stdcall* IdnToNameprepUnicode)(DWORD dwFlags, LPCWSTR lpUnicodeCharStr, int cchUnicodeChar, LPWSTR lpNameprepCharStr, int cchNameprepChar);
typedef int(__stdcall* NormalizeString)(NORM_FORM NormForm, LPCWSTR lpSrcString, int cwSrcLength, LPWSTR lpDstString, int cwDstLength);
typedef BOOL(__stdcall* IsNormalizedString)(NORM_FORM NormForm, LPCWSTR lpString, int cwLength);
typedef BOOL(__stdcall* VerifyScripts)(DWORD dwFlags, LPCWSTR lpLocaleScripts, int cchLocaleScripts, LPCWSTR lpTestScripts, int cchTestScripts);
typedef int(__stdcall* GetStringScripts)(DWORD dwFlags, LPCWSTR lpString, int cchString, LPWSTR lpScripts, int cchScripts);
typedef int(__stdcall* GetLocaleInfoEx)(LPCWSTR lpLocaleName, LCTYPE LCType, LPWSTR lpLCData, int cchData);
typedef int(__stdcall* GetCalendarInfoEx)(LPCWSTR lpLocaleName, CALID Calendar, LPCWSTR lpReserved, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue);
typedef int(__stdcall* GetUserDefaultLocaleName)(LPWSTR lpLocaleName, int cchLocaleName);
typedef int(__stdcall* GetSystemDefaultLocaleName)(LPWSTR lpLocaleName, int cchLocaleName);
typedef BOOL(__stdcall* IsNLSDefinedString)(NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr);
typedef BOOL(__stdcall* GetNLSVersionEx)(NLS_FUNCTION function, LPCWSTR lpLocaleName, LPNLSVERSIONINFOEX lpVersionInformation);
typedef DWORD(__stdcall* IsValidNLSVersion)(NLS_FUNCTION function, LPCWSTR lpLocaleName, LPNLSVERSIONINFOEX lpVersionInformation);
typedef int(__stdcall* FindNLSStringEx)(LPCWSTR lpLocaleName, DWORD dwFindNLSStringFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, LPINT pcchFound, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM sortHandle);
typedef int(__stdcall* LCMapStringEx)(LPCWSTR lpLocaleName, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM sortHandle);
typedef BOOL(__stdcall* IsValidLocaleName)(LPCWSTR lpLocaleName);
typedef BOOL(__stdcall* EnumCalendarInfoExEx)(CALINFO_ENUMPROCEXEX pCalInfoEnumProcExEx, LPCWSTR lpLocaleName, CALID Calendar, LPCWSTR lpReserved, CALTYPE CalType, LPARAM lParam);
typedef BOOL(__stdcall* EnumDateFormatsExEx)(DATEFMT_ENUMPROCEXEX lpDateFmtEnumProcExEx, LPCWSTR lpLocaleName, DWORD dwFlags, LPARAM lParam);
typedef BOOL(__stdcall* EnumTimeFormatsEx)(TIMEFMT_ENUMPROCEX lpTimeFmtEnumProcEx, LPCWSTR lpLocaleName, DWORD dwFlags, LPARAM lParam);
typedef BOOL(__stdcall* EnumSystemLocalesEx)(LOCALE_ENUMPROCEX lpLocaleEnumProcEx, DWORD dwFlags, LPARAM lParam, LPVOID lpReserved);
typedef int(__stdcall* ResolveLocaleName)(LPCWSTR lpNameToResolve, LPWSTR lpLocaleName, int cchLocaleName);
typedef LSTATUS(__stdcall* RegCloseKey)(HKEY hKey);
typedef LSTATUS(__stdcall* RegOverridePredefKey)(HKEY hKey, HKEY hNewHKey);
typedef LSTATUS(__stdcall* RegOpenUserClassesRoot)(HANDLE hToken, DWORD dwOptions, REGSAM samDesired, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegOpenCurrentUser)(REGSAM samDesired, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegConnectRegistryA)(LPCSTR lpMachineName, HKEY hKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegConnectRegistryW)(LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegCreateKeyA)(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegCreateKeyW)(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegCreateKeyExA)(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
typedef LSTATUS(__stdcall* RegCreateKeyExW)(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
typedef LSTATUS(__stdcall* RegCreateKeyTransactedA)(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition, HANDLE hTransaction, PVOID pExtendedParemeter);
typedef LSTATUS(__stdcall* RegCreateKeyTransactedW)(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition, HANDLE hTransaction, PVOID pExtendedParemeter);
typedef LSTATUS(__stdcall* RegDeleteKeyA)(HKEY hKey, LPCSTR lpSubKey);
typedef LSTATUS(__stdcall* RegDeleteKeyW)(HKEY hKey, LPCWSTR lpSubKey);
typedef LSTATUS(__stdcall* RegDeleteKeyExA)(HKEY hKey, LPCSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
typedef LSTATUS(__stdcall* RegDeleteKeyExW)(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
typedef LSTATUS(__stdcall* RegDeleteKeyTransactedA)(HKEY hKey, LPCSTR lpSubKey, REGSAM samDesired, DWORD Reserved, HANDLE hTransaction, PVOID pExtendedParameter);
typedef LSTATUS(__stdcall* RegDeleteKeyTransactedW)(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved, HANDLE hTransaction, PVOID pExtendedParameter);
typedef LONG(__stdcall* RegDisableReflectionKey)(HKEY hBase);
typedef LONG(__stdcall* RegEnableReflectionKey)(HKEY hBase);
typedef LSTATUS(__stdcall* RegDeleteValueA)(HKEY hKey, LPCSTR lpValueName);
typedef LSTATUS(__stdcall* RegDeleteValueW)(HKEY hKey, LPCWSTR lpValueName);
typedef LSTATUS(__stdcall* RegEnumKeyA)(HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cchName);
typedef LSTATUS(__stdcall* RegEnumKeyW)(HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cchName);
typedef LSTATUS(__stdcall* RegEnumKeyExA)(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcchClass, PFILETIME lpftLastWriteTime);
typedef LSTATUS(__stdcall* RegEnumKeyExW)(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcchClass, PFILETIME lpftLastWriteTime);
typedef LSTATUS(__stdcall* RegEnumValueA)(HKEY hKey, DWORD dwIndex, LPSTR lpValueName, LPDWORD lpcchValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
typedef LSTATUS(__stdcall* RegEnumValueW)(HKEY hKey, DWORD dwIndex, LPWSTR lpValueName, LPDWORD lpcchValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
typedef LSTATUS(__stdcall* RegFlushKey)(HKEY hKey);
typedef LSTATUS(__stdcall* RegGetKeySecurity)(HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, LPDWORD lpcbSecurityDescriptor);
typedef LSTATUS(__stdcall* RegLoadKeyA)(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpFile);
typedef LSTATUS(__stdcall* RegLoadKeyW)(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpFile);
typedef LSTATUS(__stdcall* RegNotifyChangeKeyValue)(HKEY hKey, BOOL bWatchSubtree, DWORD dwNotifyFilter, HANDLE hEvent, BOOL fAsynchronous);
typedef LSTATUS(__stdcall* RegOpenKeyA)(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegOpenKeyW)(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegOpenKeyExA)(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegOpenKeyExW)(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
typedef LSTATUS(__stdcall* RegOpenKeyTransactedA)(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult, HANDLE hTransaction, PVOID pExtendedParemeter);
typedef LSTATUS(__stdcall* RegOpenKeyTransactedW)(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult, HANDLE hTransaction, PVOID pExtendedParemeter);
typedef LSTATUS(__stdcall* RegQueryInfoKeyA)(HKEY hKey, LPSTR lpClass, LPDWORD lpcchClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
typedef LSTATUS(__stdcall* RegQueryInfoKeyW)(HKEY hKey, LPWSTR lpClass, LPDWORD lpcchClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
typedef LSTATUS(__stdcall* RegQueryValueA)(HKEY hKey, LPCSTR lpSubKey, LPSTR lpData, PLONG lpcbData);
typedef LSTATUS(__stdcall* RegQueryValueW)(HKEY hKey, LPCWSTR lpSubKey, LPWSTR lpData, PLONG lpcbData);
typedef LSTATUS(__stdcall* RegQueryMultipleValuesA)(HKEY hKey, PVALENTA val_list, DWORD num_vals, LPSTR lpValueBuf, LPDWORD ldwTotsize);
typedef LSTATUS(__stdcall* RegQueryMultipleValuesW)(HKEY hKey, PVALENTW val_list, DWORD num_vals, LPWSTR lpValueBuf, LPDWORD ldwTotsize);
typedef LSTATUS(__stdcall* RegQueryValueExA)(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
typedef LSTATUS(__stdcall* RegQueryValueExW)(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
typedef LSTATUS(__stdcall* RegReplaceKeyA)(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpNewFile, LPCSTR lpOldFile);
typedef LSTATUS(__stdcall* RegReplaceKeyW)(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpNewFile, LPCWSTR lpOldFile);
typedef LSTATUS(__stdcall* RegRestoreKeyA)(HKEY hKey, LPCSTR lpFile, DWORD dwFlags);
typedef LSTATUS(__stdcall* RegRestoreKeyW)(HKEY hKey, LPCWSTR lpFile, DWORD dwFlags);
typedef LSTATUS(__stdcall* RegSaveKeyA)(HKEY hKey, LPCSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef LSTATUS(__stdcall* RegSaveKeyW)(HKEY hKey, LPCWSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
typedef LSTATUS(__stdcall* RegSetKeySecurity)(HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef LSTATUS(__stdcall* RegSetValueA)(HKEY hKey, LPCSTR lpSubKey, DWORD dwType, LPCSTR lpData, DWORD cbData);
typedef LSTATUS(__stdcall* RegSetValueW)(HKEY hKey, LPCWSTR lpSubKey, DWORD dwType, LPCWSTR lpData, DWORD cbData);
typedef LSTATUS(__stdcall* RegUnLoadKeyA)(HKEY hKey, LPCSTR lpSubKey);
typedef LSTATUS(__stdcall* RegUnLoadKeyW)(HKEY hKey, LPCWSTR lpSubKey);
typedef LSTATUS(__stdcall* RegDeleteKeyValueA)(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpValueName);
typedef LSTATUS(__stdcall* RegDeleteKeyValueW)(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName);
typedef LSTATUS(__stdcall* RegSetKeyValueA)(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpValueName, DWORD dwType, LPCVOID lpData, DWORD cbData);
typedef LSTATUS(__stdcall* RegSetKeyValueW)(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName, DWORD dwType, LPCVOID lpData, DWORD cbData);
typedef LSTATUS(__stdcall* RegDeleteTreeA)(HKEY hKey, LPCSTR lpSubKey);
typedef LSTATUS(__stdcall* RegDeleteTreeW)(HKEY hKey, LPCWSTR lpSubKey);
typedef LSTATUS(__stdcall* RegCopyTreeA)(HKEY hKeySrc, LPCSTR lpSubKey, HKEY hKeyDest);
typedef LSTATUS(__stdcall* RegGetValueA)(HKEY hkey, LPCSTR lpSubKey, LPCSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
typedef LSTATUS(__stdcall* RegGetValueW)(HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
typedef LSTATUS(__stdcall* RegCopyTreeW)(HKEY hKeySrc, LPCWSTR lpSubKey, HKEY hKeyDest);
typedef LSTATUS(__stdcall* RegLoadMUIStringA)(HKEY hKey, LPCSTR pszValue, LPSTR pszOutBuf, DWORD cbOutBuf, LPDWORD pcbData, DWORD Flags, LPCSTR pszDirectory);
typedef LSTATUS(__stdcall* RegLoadMUIStringW)(HKEY hKey, LPCWSTR pszValue, LPWSTR pszOutBuf, DWORD cbOutBuf, LPDWORD pcbData, DWORD Flags, LPCWSTR pszDirectory);
typedef LSTATUS(__stdcall* RegLoadAppKeyA)(LPCSTR lpFile, PHKEY phkResult, REGSAM samDesired, DWORD dwOptions, DWORD Reserved);
typedef LSTATUS(__stdcall* RegLoadAppKeyW)(LPCWSTR lpFile, PHKEY phkResult, REGSAM samDesired, DWORD dwOptions, DWORD Reserved);
typedef BOOL(__stdcall* InitiateSystemShutdownA)(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown);
typedef BOOL(__stdcall* InitiateSystemShutdownW)(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown);
typedef BOOL(__stdcall* AbortSystemShutdownA)(LPSTR lpMachineName);
typedef BOOL(__stdcall* AbortSystemShutdownW)(LPWSTR lpMachineName);
typedef BOOL(__stdcall* InitiateSystemShutdownExA)(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown, DWORD dwReason);
typedef BOOL(__stdcall* InitiateSystemShutdownExW)(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown, DWORD dwReason);
typedef DWORD(__stdcall* InitiateShutdownA)(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwGracePeriod, DWORD dwShutdownFlags, DWORD dwReason);
typedef DWORD(__stdcall* InitiateShutdownW)(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwGracePeriod, DWORD dwShutdownFlags, DWORD dwReason);
typedef LSTATUS(__stdcall* RegSaveKeyExA)(HKEY hKey, LPCSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags);
typedef LSTATUS(__stdcall* RegSaveKeyExW)(HKEY hKey, LPCWSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags);
typedef BOOL(__stdcall* SaferGetPolicyInformation)(DWORD dwScopeId, SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass, DWORD InfoBufferSize, PVOID InfoBuffer, PDWORD InfoBufferRetSize, LPVOID lpReserved);
typedef BOOL(__stdcall* SaferSetPolicyInformation)(DWORD dwScopeId, SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass, DWORD InfoBufferSize, PVOID InfoBuffer, LPVOID lpReserved);
typedef BOOL(__stdcall* SaferCloseLevel)(SAFER_LEVEL_HANDLE hLevelHandle);
typedef BOOL(__stdcall* SaferComputeTokenFromLevel)(SAFER_LEVEL_HANDLE LevelHandle, HANDLE InAccessToken, PHANDLE OutAccessToken, DWORD dwFlags, LPVOID lpReserved);
typedef BOOL(__stdcall* SaferGetLevelInformation)(SAFER_LEVEL_HANDLE LevelHandle, SAFER_OBJECT_INFO_CLASS dwInfoType, LPVOID lpQueryBuffer, DWORD dwInBufferSize, LPDWORD lpdwOutBufferSize);
typedef BOOL(__stdcall* SaferSetLevelInformation)(SAFER_LEVEL_HANDLE LevelHandle, SAFER_OBJECT_INFO_CLASS dwInfoType, LPVOID lpQueryBuffer, DWORD dwInBufferSize);
typedef BOOL(__stdcall* SaferRecordEventLogEntry)(SAFER_LEVEL_HANDLE hLevel, LPCWSTR szTargetPath, LPVOID lpReserved);
typedef BOOL(__stdcall* SaferiIsExecutableFileType)(LPCWSTR szFullPathname, BOOLEAN bFromShellExecute);
typedef LONG(__stdcall* SCardEstablishContext)(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext);
typedef LONG(__stdcall* SCardReleaseContext)(SCARDCONTEXT hContext);
typedef LONG(__stdcall* SCardIsValidContext)(SCARDCONTEXT hContext);
typedef LONG(__stdcall* SCardListReaderGroupsA)(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups);
typedef LONG(__stdcall* SCardListReaderGroupsW)(SCARDCONTEXT hContext, LPWSTR mszGroups, LPDWORD pcchGroups);
typedef LONG(__stdcall* SCardListReadersA)(SCARDCONTEXT hContext, LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders);
typedef LONG(__stdcall* SCardListReadersW)(SCARDCONTEXT hContext, LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders);
typedef LONG(__stdcall* SCardListInterfacesA)(SCARDCONTEXT hContext, LPCSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);
typedef LONG(__stdcall* SCardListInterfacesW)(SCARDCONTEXT hContext, LPCWSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);
typedef LONG(__stdcall* SCardGetProviderIdA)(SCARDCONTEXT hContext, LPCSTR szCard, LPGUID pguidProviderId);
typedef LONG(__stdcall* SCardGetProviderIdW)(SCARDCONTEXT hContext, LPCWSTR szCard, LPGUID pguidProviderId);
typedef LONG(__stdcall* SCardIntroduceReaderGroupA)(SCARDCONTEXT hContext, LPCSTR szGroupName);
typedef LONG(__stdcall* SCardIntroduceReaderGroupW)(SCARDCONTEXT hContext, LPCWSTR szGroupName);
typedef LONG(__stdcall* SCardForgetReaderGroupA)(SCARDCONTEXT hContext, LPCSTR szGroupName);
typedef LONG(__stdcall* SCardForgetReaderGroupW)(SCARDCONTEXT hContext, LPCWSTR szGroupName);
typedef LONG(__stdcall* SCardIntroduceReaderA)(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szDeviceName);
typedef LONG(__stdcall* SCardIntroduceReaderW)(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szDeviceName);
typedef LONG(__stdcall* SCardForgetReaderA)(SCARDCONTEXT hContext, LPCSTR szReaderName);
typedef LONG(__stdcall* SCardForgetReaderW)(SCARDCONTEXT hContext, LPCWSTR szReaderName);
typedef LONG(__stdcall* SCardAddReaderToGroupA)(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szGroupName);
typedef LONG(__stdcall* SCardAddReaderToGroupW)(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName);
typedef LONG(__stdcall* SCardRemoveReaderFromGroupA)(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szGroupName);
typedef LONG(__stdcall* SCardRemoveReaderFromGroupW)(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName);
typedef LONG(__stdcall* SCardIntroduceCardTypeA)(SCARDCONTEXT hContext, LPCSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen);
typedef LONG(__stdcall* SCardIntroduceCardTypeW)(SCARDCONTEXT hContext, LPCWSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen);
typedef LONG(__stdcall* SCardSetCardTypeProviderNameA)(SCARDCONTEXT hContext, LPCSTR szCardName, DWORD dwProviderId, LPCSTR szProvider);
typedef LONG(__stdcall* SCardSetCardTypeProviderNameW)(SCARDCONTEXT hContext, LPCWSTR szCardName, DWORD dwProviderId, LPCWSTR szProvider);
typedef LONG(__stdcall* SCardForgetCardTypeA)(SCARDCONTEXT hContext, LPCSTR szCardName);
typedef LONG(__stdcall* SCardForgetCardTypeW)(SCARDCONTEXT hContext, LPCWSTR szCardName);
typedef LONG(__stdcall* SCardFreeMemory)(SCARDCONTEXT hContext, LPCVOID pvMem);
typedef LONG(__stdcall* SCardLocateCardsA)(SCARDCONTEXT hContext, LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardLocateCardsW)(SCARDCONTEXT hContext, LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardLocateCardsByATRA)(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardLocateCardsByATRW)(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardGetStatusChangeA)(SCARDCONTEXT hContext, DWORD dwTimeout, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardGetStatusChangeW)(SCARDCONTEXT hContext, DWORD dwTimeout, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);
typedef LONG(__stdcall* SCardCancel)(SCARDCONTEXT hContext);
typedef LONG(__stdcall* SCardConnectA)(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol);
typedef LONG(__stdcall* SCardConnectW)(SCARDCONTEXT hContext, LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol);
typedef LONG(__stdcall* SCardReconnect)(SCARDHANDLE hCard, DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol);
typedef LONG(__stdcall* SCardDisconnect)(SCARDHANDLE hCard, DWORD dwDisposition);
typedef LONG(__stdcall* SCardBeginTransaction)(SCARDHANDLE hCard);
typedef LONG(__stdcall* SCardEndTransaction)(SCARDHANDLE hCard, DWORD dwDisposition);
typedef LONG(__stdcall* SCardStatusA)(SCARDHANDLE hCard, LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen);
typedef LONG(__stdcall* SCardStatusW)(SCARDHANDLE hCard, LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen);
typedef LONG(__stdcall* SCardTransmit)(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength);
typedef LONG(__stdcall* SCardGetTransmitCount)(SCARDHANDLE hCard, LPDWORD pcTransmitCount);
typedef LONG(__stdcall* SCardControl)(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned);
typedef LONG(__stdcall* SCardGetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen);
typedef LONG(__stdcall* SCardSetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen);
typedef LONG(__stdcall* SCardGetDeviceTypeIdA)(SCARDCONTEXT hContext, LPCSTR szReaderName, LPDWORD pdwDeviceTypeId);
typedef LONG(__stdcall* SCardGetDeviceTypeIdW)(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPDWORD pdwDeviceTypeId);
typedef LONG(__stdcall* SCardAudit)(SCARDCONTEXT hContext, DWORD dwEvent);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetTranslateMode)(smiLPUINT32 nTranslateMode);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetTranslateMode)(smiUINT32 nTranslateMode);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetRetransmitMode)(smiLPUINT32 nRetransmitMode);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetRetransmitMode)(smiUINT32 nRetransmitMode);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetTimeout)(HSNMP_ENTITY hEntity, smiLPTIMETICKS nPolicyTimeout, smiLPTIMETICKS nActualTimeout);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetTimeout)(HSNMP_ENTITY hEntity, smiTIMETICKS nPolicyTimeout);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetRetry)(HSNMP_ENTITY hEntity, smiLPUINT32 nPolicyRetry, smiLPUINT32 nActualRetry);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetRetry)(HSNMP_ENTITY hEntity, smiUINT32 nPolicyRetry);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetVendorInfo)(smiLPVENDORINFO vendorInfo);
typedef SNMPAPI_STATUS(__stdcall* SnmpStartup)(smiLPUINT32 nMajorVersion, smiLPUINT32 nMinorVersion, smiLPUINT32 nLevel, smiLPUINT32 nTranslateMode, smiLPUINT32 nRetransmitMode);
typedef HSNMP_SESSION(__stdcall* SnmpOpen)(HWND hWnd, UINT wMsg);
typedef SNMPAPI_STATUS(__stdcall* SnmpClose)(HSNMP_SESSION session);
typedef SNMPAPI_STATUS(__stdcall* SnmpSendMsg)(HSNMP_SESSION session, HSNMP_ENTITY srcEntity, HSNMP_ENTITY dstEntity, HSNMP_CONTEXT context, HSNMP_PDU PDU);
typedef SNMPAPI_STATUS(__stdcall* SnmpRecvMsg)(HSNMP_SESSION session, LPHSNMP_ENTITY srcEntity, LPHSNMP_ENTITY dstEntity, LPHSNMP_CONTEXT context, LPHSNMP_PDU PDU);
typedef SNMPAPI_STATUS(__stdcall* SnmpRegister)(HSNMP_SESSION session, HSNMP_ENTITY srcEntity, HSNMP_ENTITY dstEntity, HSNMP_CONTEXT context, smiLPCOID notification, smiUINT32 state);
typedef HSNMP_SESSION(__stdcall* SnmpCreateSession)(HWND hWnd, UINT wMsg, SNMPAPI_CALLBACK fCallBack, LPVOID lpClientData);
typedef SNMPAPI_STATUS(__stdcall* SnmpListen)(HSNMP_ENTITY hEntity, SNMPAPI_STATUS lStatus);
typedef SNMPAPI_STATUS(__stdcall* SnmpCancelMsg)(HSNMP_SESSION session, smiINT32 reqId);
typedef SNMPAPI_STATUS(__stdcall* SnmpStartupEx)(smiLPUINT32 nMajorVersion, smiLPUINT32 nMinorVersion, smiLPUINT32 nLevel, smiLPUINT32 nTranslateMode, smiLPUINT32 nRetransmitMode);
typedef HSNMP_ENTITY(__stdcall* SnmpStrToEntity)(HSNMP_SESSION session, LPCSTR string);
typedef SNMPAPI_STATUS(__stdcall* SnmpEntityToStr)(HSNMP_ENTITY entity, smiUINT32 size, LPSTR string);
typedef SNMPAPI_STATUS(__stdcall* SnmpFreeEntity)(HSNMP_ENTITY entity);
typedef HSNMP_CONTEXT(__stdcall* SnmpStrToContext)(HSNMP_SESSION session, smiLPCOCTETS string);
typedef SNMPAPI_STATUS(__stdcall* SnmpContextToStr)(HSNMP_CONTEXT context, smiLPOCTETS string);
typedef SNMPAPI_STATUS(__stdcall* SnmpFreeContext)(HSNMP_CONTEXT context);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetPort)(HSNMP_ENTITY hEntity, UINT nPort);
typedef HSNMP_PDU(__stdcall* SnmpCreatePdu)(HSNMP_SESSION session, smiINT PDU_type, smiINT32 request_id, smiINT error_status, smiINT error_index, HSNMP_VBL varbindlist);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetPduData)(HSNMP_PDU PDU, smiLPINT PDU_type, smiLPINT32 request_id, smiLPINT error_status, smiLPINT error_index, LPHSNMP_VBL varbindlist);
typedef HSNMP_PDU(__stdcall* SnmpDuplicatePdu)(HSNMP_SESSION session, HSNMP_PDU PDU);
typedef SNMPAPI_STATUS(__stdcall* SnmpFreePdu)(HSNMP_PDU PDU);
typedef HSNMP_VBL(__stdcall* SnmpCreateVbl)(HSNMP_SESSION session, smiLPCOID name, smiLPCVALUE value);
typedef HSNMP_VBL(__stdcall* SnmpDuplicateVbl)(HSNMP_SESSION session, HSNMP_VBL vbl);
typedef SNMPAPI_STATUS(__stdcall* SnmpFreeVbl)(HSNMP_VBL vbl);
typedef SNMPAPI_STATUS(__stdcall* SnmpCountVbl)(HSNMP_VBL vbl);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetVb)(HSNMP_VBL vbl, smiUINT32 index, smiLPOID name, smiLPVALUE value);
typedef SNMPAPI_STATUS(__stdcall* SnmpSetVb)(HSNMP_VBL vbl, smiUINT32 index, smiLPCOID name, smiLPCVALUE value);
typedef SNMPAPI_STATUS(__stdcall* SnmpDeleteVb)(HSNMP_VBL vbl, smiUINT32 index);
typedef SNMPAPI_STATUS(__stdcall* SnmpGetLastError)(HSNMP_SESSION session);
typedef SNMPAPI_STATUS(__stdcall* SnmpStrToOid)(LPCSTR string, smiLPOID dstOID);
typedef SNMPAPI_STATUS(__stdcall* SnmpOidToStr)(smiLPCOID srcOID, smiUINT32 size, LPSTR string);
typedef SNMPAPI_STATUS(__stdcall* SnmpOidCopy)(smiLPCOID srcOID, smiLPOID dstOID);
typedef SNMPAPI_STATUS(__stdcall* SnmpOidCompare)(smiLPCOID xOID, smiLPCOID yOID, smiUINT32 maxlen, smiLPINT result);
typedef SNMPAPI_STATUS(__stdcall* SnmpEncodeMsg)(HSNMP_SESSION session, HSNMP_ENTITY srcEntity, HSNMP_ENTITY dstEntity, HSNMP_CONTEXT context, HSNMP_PDU pdu, smiLPOCTETS msgBufDesc);
typedef SNMPAPI_STATUS(__stdcall* SnmpDecodeMsg)(HSNMP_SESSION session, LPHSNMP_ENTITY srcEntity, LPHSNMP_ENTITY dstEntity, LPHSNMP_CONTEXT context, LPHSNMP_PDU pdu, smiLPCOCTETS msgBufDesc);
typedef SNMPAPI_STATUS(__stdcall* SnmpFreeDescriptor)(smiUINT32 syntax, smiLPOPAQUE descriptor);
typedef int(__stdcall* closesocket)(SOCKET s);
typedef u_long(__stdcall* htonl)(u_long hostlong);
typedef u_short(__stdcall* htons)(u_short hostshort);
typedef {'name': 'inet_ntoa', 'type': 'char'}(__stdcall* inet_ntoa)({'data_type': 'Struct', 'name': 'in_addr', 'elements': []} in);
typedef u_long(__stdcall* ntohl)(u_long netlong);
typedef u_short(__stdcall* ntohs)(u_short netshort);
typedef int(__stdcall* shutdown)(SOCKET s, int how);
typedef {'name': 'getprotobynumber', 'type': {'data_type': 'Struct', 'name': 'protoent', 'elements': []}}(__stdcall* getprotobynumber)(int proto);
typedef int(__stdcall* WSAStartup)(WORD wVersionRequired, LPWSADATA lpWSAData);
typedef void(__stdcall* WSASetLastError)(int iError);
typedef int(__stdcall* WSACancelAsyncRequest)(HANDLE hAsyncTaskHandle);
typedef int(__stdcall* WSAAsyncSelect)(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
typedef BOOL(__stdcall* TransmitFile)(SOCKET hSocket, HANDLE hFile, DWORD nNumberOfBytesToWrite, DWORD nNumberOfBytesPerSend, LPOVERLAPPED lpOverlapped, LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers, DWORD dwReserved);
typedef BOOL(__stdcall* AcceptEx)(SOCKET sListenSocket, SOCKET sAcceptSocket, PVOID lpOutputBuffer, DWORD dwReceiveDataLength, DWORD dwLocalAddressLength, DWORD dwRemoteAddressLength, LPDWORD lpdwBytesReceived, LPOVERLAPPED lpOverlapped);
typedef int(__stdcall* closesocket)(SOCKET s);
typedef u_long(__stdcall* htonl)(u_long hostlong);
typedef u_short(__stdcall* htons)(u_short hostshort);
typedef {'name': 'inet_ntoa', 'type': 'char'}(__stdcall* inet_ntoa)({'data_type': 'Struct', 'name': 'in_addr', 'elements': []} in);
typedef int(__stdcall* listen)(SOCKET s, int backlog);
typedef u_long(__stdcall* ntohl)(u_long netlong);
typedef u_short(__stdcall* ntohs)(u_short netshort);
typedef int(__stdcall* shutdown)(SOCKET s, int how);
typedef SOCKET(__stdcall* socket)(int af, int type, int protocol);
typedef int(__stdcall* GetHostNameW)(PWSTR name, int namelen);
typedef {'name': 'getprotobynumber', 'type': {'data_type': 'Struct', 'name': 'protoent', 'elements': []}}(__stdcall* getprotobynumber)(int number);
typedef int(__stdcall* WSAStartup)(WORD wVersionRequested, LPWSADATA lpWSAData);
typedef void(__stdcall* WSASetLastError)(int iError);
typedef int(__stdcall* WSACancelAsyncRequest)(HANDLE hAsyncTaskHandle);
typedef int(__stdcall* WSAAsyncSelect)(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
typedef BOOL(__stdcall* WSACloseEvent)(HANDLE hEvent);
typedef int(__stdcall* WSADuplicateSocketA)(SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo);
typedef int(__stdcall* WSADuplicateSocketW)(SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo);
typedef int(__stdcall* WSAEnumNetworkEvents)(SOCKET s, HANDLE hEventObject, LPWSANETWORKEVENTS lpNetworkEvents);
typedef int(__stdcall* WSAEnumProtocolsA)(LPINT lpiProtocols, LPWSAPROTOCOL_INFOA lpProtocolBuffer, LPDWORD lpdwBufferLength);
typedef int(__stdcall* WSAEnumProtocolsW)(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength);
typedef int(__stdcall* WSAEventSelect)(SOCKET s, HANDLE hEventObject, long lNetworkEvents);
typedef BOOL(__stdcall* WSAGetOverlappedResult)(SOCKET s, LPWSAOVERLAPPED lpOverlapped, LPDWORD lpcbTransfer, BOOL fWait, LPDWORD lpdwFlags);
typedef BOOL(__stdcall* WSAGetQOSByName)(SOCKET s, LPWSABUF lpQOSName, LPQOS lpQOS);
typedef int(__stdcall* WSAIoctl)(SOCKET s, DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, LPDWORD lpcbBytesReturned, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef int(__stdcall* WSARecv)(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef int(__stdcall* WSARecvDisconnect)(SOCKET s, LPWSABUF lpInboundDisconnectData);
typedef BOOL(__stdcall* WSAResetEvent)(HANDLE hEvent);
typedef int(__stdcall* WSASend)(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef int(__stdcall* WSASendMsg)(SOCKET Handle, LPWSAMSG lpMsg, DWORD dwFlags, LPDWORD lpNumberOfBytesSent, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef int(__stdcall* WSASendDisconnect)(SOCKET s, LPWSABUF lpOutboundDisconnectData);
typedef BOOL(__stdcall* WSASetEvent)(HANDLE hEvent);
typedef SOCKET(__stdcall* WSASocketA)(int af, int type, int protocol, LPWSAPROTOCOL_INFOA lpProtocolInfo, GROUP g, DWORD dwFlags);
typedef SOCKET(__stdcall* WSASocketW)(int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags);
typedef INT(__stdcall* WSAAddressToStringA)(LPSOCKADDR lpsaAddress, DWORD dwAddressLength, LPWSAPROTOCOL_INFOA lpProtocolInfo, LPSTR lpszAddressString, LPDWORD lpdwAddressStringLength);
typedef INT(__stdcall* WSAAddressToStringW)(LPSOCKADDR lpsaAddress, DWORD dwAddressLength, LPWSAPROTOCOL_INFOW lpProtocolInfo, LPWSTR lpszAddressString, LPDWORD lpdwAddressStringLength);
typedef INT(__stdcall* WSAStringToAddressA)(LPSTR AddressString, INT AddressFamily, LPWSAPROTOCOL_INFOA lpProtocolInfo, LPSOCKADDR lpAddress, LPINT lpAddressLength);
typedef INT(__stdcall* WSAStringToAddressW)(LPWSTR AddressString, INT AddressFamily, LPWSAPROTOCOL_INFOW lpProtocolInfo, LPSOCKADDR lpAddress, LPINT lpAddressLength);
typedef INT(__stdcall* WSALookupServiceBeginA)(LPWSAQUERYSETA lpqsRestrictions, DWORD dwControlFlags, LPHANDLE lphLookup);
typedef INT(__stdcall* WSALookupServiceBeginW)(LPWSAQUERYSETW lpqsRestrictions, DWORD dwControlFlags, LPHANDLE lphLookup);
typedef INT(__stdcall* WSALookupServiceNextA)(HANDLE hLookup, DWORD dwControlFlags, LPDWORD lpdwBufferLength, LPWSAQUERYSETA lpqsResults);
typedef INT(__stdcall* WSALookupServiceNextW)(HANDLE hLookup, DWORD dwControlFlags, LPDWORD lpdwBufferLength, LPWSAQUERYSETW lpqsResults);
typedef INT(__stdcall* WSALookupServiceEnd)(HANDLE hLookup);
typedef INT(__stdcall* WSAInstallServiceClassA)(LPWSASERVICECLASSINFOA lpServiceClassInfo);
typedef INT(__stdcall* WSAInstallServiceClassW)(LPWSASERVICECLASSINFOW lpServiceClassInfo);
typedef INT(__stdcall* WSARemoveServiceClass)(LPGUID lpServiceClassId);
typedef INT(__stdcall* WSAGetServiceClassInfoA)(LPGUID lpProviderId, LPGUID lpServiceClassId, LPDWORD lpdwBufSize, LPWSASERVICECLASSINFOA lpServiceClassInfo);
typedef INT(__stdcall* WSAGetServiceClassInfoW)(LPGUID lpProviderId, LPGUID lpServiceClassId, LPDWORD lpdwBufSize, LPWSASERVICECLASSINFOW lpServiceClassInfo);
typedef INT(__stdcall* WSAEnumNameSpaceProvidersA)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOA lpnspBuffer);
typedef INT(__stdcall* WSAEnumNameSpaceProvidersW)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOW lpnspBuffer);
typedef INT(__stdcall* WSAEnumNameSpaceProvidersExA)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXA lpnspBuffer);
typedef INT(__stdcall* WSAEnumNameSpaceProvidersExW)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXW lpnspBuffer);
typedef INT(__stdcall* WSAGetServiceClassNameByClassIdA)(LPGUID lpServiceClassId, LPSTR lpszServiceClassName, LPDWORD lpdwBufferLength);
typedef INT(__stdcall* WSAGetServiceClassNameByClassIdW)(LPGUID lpServiceClassId, LPWSTR lpszServiceClassName, LPDWORD lpdwBufferLength);
typedef INT(__stdcall* WSASetServiceA)(LPWSAQUERYSETA lpqsRegInfo, WSAESETSERVICEOP essoperation, DWORD dwControlFlags);
typedef INT(__stdcall* WSASetServiceW)(LPWSAQUERYSETW lpqsRegInfo, WSAESETSERVICEOP essoperation, DWORD dwControlFlags);
typedef INT(__stdcall* WSAProviderConfigChange)(LPHANDLE lpNotificationHandle, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
typedef int(__stdcall* WSAPoll)(LPWSAPOLLFD fdArray, ULONG fds, INT timeout);
typedef HRESULT(__stdcall* WindowsDeleteString)(HSTRING string);
typedef UINT32(__stdcall* WindowsGetStringLen)(HSTRING string);
typedef BOOL(__stdcall* WindowsIsStringEmpty)(HSTRING string);
typedef HRESULT(__stdcall* WindowsDeleteStringBuffer)(HSTRING_BUFFER bufferHandle);
typedef BOOL(__stdcall* ChangeServiceConfigA)(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName);
typedef BOOL(__stdcall* ChangeServiceConfigW)(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName);
typedef BOOL(__stdcall* ChangeServiceConfig2A)(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo);
typedef BOOL(__stdcall* ChangeServiceConfig2W)(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo);
typedef BOOL(__stdcall* CloseServiceHandle)(SC_HANDLE hSCObject);
typedef BOOL(__stdcall* ControlService)(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus);
typedef SC_HANDLE(__stdcall* CreateServiceA)(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword);
typedef SC_HANDLE(__stdcall* CreateServiceW)(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword);
typedef BOOL(__stdcall* DeleteService)(SC_HANDLE hService);
typedef BOOL(__stdcall* EnumDependentServicesA)(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned);
typedef BOOL(__stdcall* EnumDependentServicesW)(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned);
typedef BOOL(__stdcall* EnumServicesStatusA)(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle);
typedef BOOL(__stdcall* EnumServicesStatusW)(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle);
typedef BOOL(__stdcall* EnumServicesStatusExA)(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName);
typedef BOOL(__stdcall* EnumServicesStatusExW)(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName);
typedef BOOL(__stdcall* GetServiceKeyNameA)(SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer);
typedef BOOL(__stdcall* GetServiceKeyNameW)(SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer);
typedef BOOL(__stdcall* GetServiceDisplayNameA)(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer);
typedef BOOL(__stdcall* GetServiceDisplayNameW)(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer);
typedef SC_LOCK(__stdcall* LockServiceDatabase)(SC_HANDLE hSCManager);
typedef BOOL(__stdcall* NotifyBootConfigStatus)(BOOL BootAcceptable);
typedef SC_HANDLE(__stdcall* OpenSCManagerA)(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess);
typedef SC_HANDLE(__stdcall* OpenSCManagerW)(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess);
typedef SC_HANDLE(__stdcall* OpenServiceA)(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess);
typedef SC_HANDLE(__stdcall* OpenServiceW)(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess);
typedef BOOL(__stdcall* QueryServiceConfigA)(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceConfigW)(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceConfig2A)(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceConfig2W)(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceLockStatusA)(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceLockStatusW)(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceObjectSecurity)(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef BOOL(__stdcall* QueryServiceStatus)(SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus);
typedef BOOL(__stdcall* QueryServiceStatusEx)(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
typedef SERVICE_STATUS_HANDLE(__stdcall* RegisterServiceCtrlHandlerA)(LPCSTR lpServiceName, LPHANDLER_FUNCTION lpHandlerProc);
typedef SERVICE_STATUS_HANDLE(__stdcall* RegisterServiceCtrlHandlerW)(LPCWSTR lpServiceName, LPHANDLER_FUNCTION lpHandlerProc);
typedef SERVICE_STATUS_HANDLE(__stdcall* RegisterServiceCtrlHandlerExA)(LPCSTR lpServiceName, LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext);
typedef SERVICE_STATUS_HANDLE(__stdcall* RegisterServiceCtrlHandlerExW)(LPCWSTR lpServiceName, LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext);
typedef BOOL(__stdcall* SetServiceObjectSecurity)(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor);
typedef BOOL(__stdcall* SetServiceStatus)(SERVICE_STATUS_HANDLE hServiceStatus, LPSERVICE_STATUS lpServiceStatus);
typedef BOOL(__stdcall* UnlockServiceDatabase)(SC_LOCK ScLock);
typedef DWORD(__stdcall* NotifyServiceStatusChangeA)(SC_HANDLE hService, DWORD dwNotifyMask, PSERVICE_NOTIFYA pNotifyBuffer);
typedef DWORD(__stdcall* NotifyServiceStatusChangeW)(SC_HANDLE hService, DWORD dwNotifyMask, PSERVICE_NOTIFYW pNotifyBuffer);
typedef BOOL(__stdcall* ControlServiceExA)(SC_HANDLE hService, DWORD dwControl, DWORD dwInfoLevel, PVOID pControlParams);
typedef BOOL(__stdcall* ControlServiceExW)(SC_HANDLE hService, DWORD dwControl, DWORD dwInfoLevel, PVOID pControlParams);
typedef BOOL(__stdcall* WintrustSetRegPolicyFlags)(DWORD dwPolicyFlags);
typedef {'name': 'WTHelperProvDataFromStateData', 'type': 'CRYPT_PROVIDER_DATA'}(__stdcall* WTHelperProvDataFromStateData)(HANDLE hStateData);
typedef BOOL(__stdcall* OpenPersonalTrustDBDialog)(HWND hwndParent);
typedef void(__stdcall* WintrustSetDefaultIncludePEPageHashes)(BOOL fIncludePEPageHashes);
typedef BOOL(__stdcall* WinUsb_Initialize)(HANDLE DeviceHandle, PWINUSB_INTERFACE_HANDLE InterfaceHandle);
typedef BOOL(__stdcall* WinUsb_Free)(WINUSB_INTERFACE_HANDLE InterfaceHandle);
typedef BOOL(__stdcall* WinUsb_GetAssociatedInterface)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AssociatedInterfaceIndex, PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle);
typedef BOOL(__stdcall* WinUsb_GetDescriptor)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR DescriptorType, UCHAR Index, USHORT LanguageID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred);
typedef BOOL(__stdcall* WinUsb_QueryInterfaceSettings)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateInterfaceNumber, PUSB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor);
typedef BOOL(__stdcall* WinUsb_QueryDeviceInformation)(WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG InformationType, PULONG BufferLength, PVOID Buffer);
typedef BOOL(__stdcall* WinUsb_SetCurrentAlternateSetting)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR SettingNumber);
typedef BOOL(__stdcall* WinUsb_GetCurrentAlternateSetting)(WINUSB_INTERFACE_HANDLE InterfaceHandle, PUCHAR SettingNumber);
typedef BOOL(__stdcall* WinUsb_QueryPipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateInterfaceNumber, UCHAR PipeIndex, PWINUSB_PIPE_INFORMATION PipeInformation);
typedef BOOL(__stdcall* WinUsb_QueryPipeEx)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateSettingNumber, UCHAR PipeIndex, PWINUSB_PIPE_INFORMATION_EX PipeInformationEx);
typedef BOOL(__stdcall* WinUsb_SetPipePolicy)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, ULONG ValueLength, PVOID Value);
typedef BOOL(__stdcall* WinUsb_GetPipePolicy)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, PULONG ValueLength, PVOID Value);
typedef BOOL(__stdcall* WinUsb_ReadPipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_WritePipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_ControlTransfer)(WINUSB_INTERFACE_HANDLE InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_ResetPipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
typedef BOOL(__stdcall* WinUsb_AbortPipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
typedef BOOL(__stdcall* WinUsb_FlushPipe)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
typedef BOOL(__stdcall* WinUsb_SetPowerPolicy)(WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG PolicyType, ULONG ValueLength, PVOID Value);
typedef BOOL(__stdcall* WinUsb_GetPowerPolicy)(WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG PolicyType, PULONG ValueLength, PVOID Value);
typedef BOOL(__stdcall* WinUsb_GetOverlappedResult)(WINUSB_INTERFACE_HANDLE InterfaceHandle, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait);
typedef BOOL(__stdcall* WinUsb_GetAdjustedFrameNumber)(PULONG CurrentFrameNumber, LARGE_INTEGER TimeStamp);
typedef BOOL(__stdcall* WinUsb_RegisterIsochBuffer)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PWINUSB_ISOCH_BUFFER_HANDLE IsochBufferHandle);
typedef BOOL(__stdcall* WinUsb_UnregisterIsochBuffer)(WINUSB_ISOCH_BUFFER_HANDLE IsochBufferHandle);
typedef BOOL(__stdcall* WinUsb_WriteIsochPipe)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, PULONG FrameNumber, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_ReadIsochPipe)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, PULONG FrameNumber, ULONG NumberOfPackets, PUSBD_ISO_PACKET_DESCRIPTOR IsoPacketDescriptors, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_WriteIsochPipeAsap)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, BOOL ContinueStream, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_ReadIsochPipeAsap)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, BOOL ContinueStream, ULONG NumberOfPackets, PUSBD_ISO_PACKET_DESCRIPTOR IsoPacketDescriptors, LPOVERLAPPED Overlapped);
typedef BOOL(__stdcall* WinUsb_StartTrackingForTimeSync)(WINUSB_INTERFACE_HANDLE InterfaceHandle, PUSB_START_TRACKING_FOR_TIME_SYNC_INFORMATION StartTrackingInfo);
typedef BOOL(__stdcall* WinUsb_GetCurrentFrameNumberAndQpc)(WINUSB_INTERFACE_HANDLE InterfaceHandle, PUSB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION FrameQpcInfo);
typedef BOOL(__stdcall* WinUsb_StopTrackingForTimeSync)(WINUSB_INTERFACE_HANDLE InterfaceHandle, PUSB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION StopTrackingInfo);
typedef int(__stdcall* LoadStringA)(HINSTANCE hInstance, UINT uID, LPSTR lpBuffer, int cchBufferMax);
typedef int(__stdcall* LoadStringW)(HINSTANCE hInstance, UINT uID, LPWSTR lpBuffer, int cchBufferMax);
typedef HKL(__stdcall* LoadKeyboardLayoutA)(LPCSTR pwszKLID, UINT Flags);
typedef HKL(__stdcall* LoadKeyboardLayoutW)(LPCWSTR pwszKLID, UINT Flags);
typedef HKL(__stdcall* ActivateKeyboardLayout)(HKL hkl, UINT Flags);
typedef BOOL(__stdcall* UnloadKeyboardLayout)(HKL hkl);
typedef BOOL(__stdcall* GetKeyboardLayoutNameA)(LPSTR pwszKLID);
typedef BOOL(__stdcall* GetKeyboardLayoutNameW)(LPWSTR pwszKLID);
typedef HKL(__stdcall* GetKeyboardLayout)(DWORD idThread);
typedef int(__stdcall* GetMouseMovePointsEx)(UINT cbSize, LPMOUSEMOVEPOINT lppt, LPMOUSEMOVEPOINT lpptBuf, int nBufPoints, DWORD resolution);
typedef HDESK(__stdcall* OpenDesktopA)(LPCSTR lpszDesktop, DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
typedef HDESK(__stdcall* OpenDesktopW)(LPCWSTR lpszDesktop, DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
typedef HDESK(__stdcall* OpenInputDesktop)(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
typedef BOOL(__stdcall* EnumDesktopsA)(HWINSTA hwinsta, DESKTOPENUMPROCA lpEnumFunc, LPARAM lParam);
typedef BOOL(__stdcall* EnumDesktopsW)(HWINSTA hwinsta, DESKTOPENUMPROCW lpEnumFunc, LPARAM lParam);
typedef BOOL(__stdcall* EnumDesktopWindows)(HDESK hDesktop, WNDENUMPROC lpfn, LPARAM lParam);
typedef BOOL(__stdcall* SwitchDesktop)(HDESK hDesktop);
typedef BOOL(__stdcall* SetThreadDesktop)(HDESK hDesktop);
typedef BOOL(__stdcall* CloseDesktop)(HDESK hDesktop);
typedef HDESK(__stdcall* GetThreadDesktop)(DWORD dwThreadId);
typedef HWINSTA(__stdcall* CreateWindowStationA)(LPCSTR lpwinsta, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
typedef HWINSTA(__stdcall* CreateWindowStationW)(LPCWSTR lpwinsta, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
typedef HWINSTA(__stdcall* OpenWindowStationA)(LPCSTR lpszWinSta, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
typedef HWINSTA(__stdcall* OpenWindowStationW)(LPCWSTR lpszWinSta, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
typedef BOOL(__stdcall* EnumWindowStationsA)(WINSTAENUMPROCA lpEnumFunc, LPARAM lParam);
typedef BOOL(__stdcall* EnumWindowStationsW)(WINSTAENUMPROCW lpEnumFunc, LPARAM lParam);
typedef BOOL(__stdcall* CloseWindowStation)(HWINSTA hWinSta);
typedef BOOL(__stdcall* SetProcessWindowStation)(HWINSTA hWinSta);
typedef BOOL(__stdcall* SetUserObjectSecurity)(HANDLE hObj, PSECURITY_INFORMATION pSIRequested, PSECURITY_DESCRIPTOR pSID);
typedef BOOL(__stdcall* GetUserObjectSecurity)(HANDLE hObj, PSECURITY_INFORMATION pSIRequested, PSECURITY_DESCRIPTOR pSID, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* GetUserObjectInformationA)(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* GetUserObjectInformationW)(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* SetUserObjectInformationA)(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength);
typedef BOOL(__stdcall* SetUserObjectInformationW)(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength);
typedef BOOL(__stdcall* IsHungAppWindow)(HWND hwnd);
typedef UINT(__stdcall* RegisterWindowMessageA)(LPCSTR lpString);
typedef UINT(__stdcall* RegisterWindowMessageW)(LPCWSTR lpString);
typedef BOOL(__stdcall* TrackMouseEvent)(LPTRACKMOUSEEVENT lpEventTrack);
typedef BOOL(__stdcall* DrawEdge)(HDC hdc, LPRECT qrc, UINT edge, UINT grfFlags);
typedef BOOL(__stdcall* GetMessageA)(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
typedef BOOL(__stdcall* GetMessageW)(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
typedef BOOL(__stdcall* PeekMessageA)(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
typedef BOOL(__stdcall* PeekMessageW)(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
typedef BOOL(__stdcall* RegisterHotKey)(HWND hWnd, int id, UINT fsModifiers, UINT vk);
typedef BOOL(__stdcall* UnregisterHotKey)(HWND hWnd, int id);
typedef BOOL(__stdcall* ExitWindowsEx)(UINT uFlags, DWORD dwReason);
typedef BOOL(__stdcall* SwapMouseButton)(BOOL fSwap);
typedef LPARAM(__stdcall* SetMessageExtraInfo)(LPARAM lParam);
typedef LRESULT(__stdcall* SendMessageA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* SendMessageW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* SendMessageTimeoutA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult);
typedef LRESULT(__stdcall* SendMessageTimeoutW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult);
typedef BOOL(__stdcall* SendNotifyMessageA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* SendNotifyMessageW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* SendMessageCallbackA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData);
typedef BOOL(__stdcall* SendMessageCallbackW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData);
typedef long(__stdcall* BroadcastSystemMessageExA)(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam, PBSMINFO pbsmInfo);
typedef long(__stdcall* BroadcastSystemMessageExW)(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam, PBSMINFO pbsmInfo);
typedef long(__stdcall* BroadcastSystemMessageW)(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef HDEVNOTIFY(__stdcall* RegisterDeviceNotificationA)(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
typedef HDEVNOTIFY(__stdcall* RegisterDeviceNotificationW)(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
typedef BOOL(__stdcall* UnregisterDeviceNotification)(HDEVNOTIFY Handle);
typedef HPOWERNOTIFY(__stdcall* RegisterPowerSettingNotification)(HANDLE hRecipient, LPCGUID PowerSettingGuid, DWORD Flags);
typedef BOOL(__stdcall* UnregisterPowerSettingNotification)(HPOWERNOTIFY Handle);
typedef HPOWERNOTIFY(__stdcall* RegisterSuspendResumeNotification)(HANDLE hRecipient, DWORD Flags);
typedef BOOL(__stdcall* UnregisterSuspendResumeNotification)(HPOWERNOTIFY Handle);
typedef BOOL(__stdcall* PostMessageA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* PostMessageW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* PostThreadMessageA)(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* PostThreadMessageW)(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* AttachThreadInput)(DWORD idAttach, DWORD idAttachTo, BOOL fAttach);
typedef BOOL(__stdcall* ReplyMessage)(LRESULT lResult);
typedef DWORD(__stdcall* WaitForInputIdle)(HANDLE hProcess, DWORD dwMilliseconds);
typedef LRESULT(__stdcall* DefWindowProcA)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* DefWindowProcW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef void(__stdcall* PostQuitMessage)(int nExitCode);
typedef LRESULT(__stdcall* CallWindowProcA)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* CallWindowProcW)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef DWORD(__stdcall* InSendMessageEx)(LPVOID lpReserved);
typedef BOOL(__stdcall* UnregisterClassA)(LPCSTR lpClassName, HINSTANCE hInstance);
typedef BOOL(__stdcall* UnregisterClassW)(LPCWSTR lpClassName, HINSTANCE hInstance);
typedef BOOL(__stdcall* GetClassInfoA)(HINSTANCE hInstance, LPCSTR lpClassName, LPWNDCLASSA lpWndClass);
typedef BOOL(__stdcall* GetClassInfoW)(HINSTANCE hInstance, LPCWSTR lpClassName, LPWNDCLASSW lpWndClass);
typedef BOOL(__stdcall* GetClassInfoExA)(HINSTANCE hInstance, LPCSTR lpszClass, LPWNDCLASSEXA lpwcx);
typedef BOOL(__stdcall* GetClassInfoExW)(HINSTANCE hInstance, LPCWSTR lpszClass, LPWNDCLASSEXW lpwcx);
typedef HWND(__stdcall* CreateWindowExA)(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam);
typedef HWND(__stdcall* CreateWindowExW)(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam);
typedef BOOL(__stdcall* IsWindow)(HWND hWnd);
typedef BOOL(__stdcall* IsMenu)(HMENU hMenu);
typedef BOOL(__stdcall* IsChild)(HWND hWndParent, HWND hWnd);
typedef BOOL(__stdcall* DestroyWindow)(HWND hWnd);
typedef BOOL(__stdcall* ShowWindow)(HWND hWnd, int nCmdShow);
typedef BOOL(__stdcall* AnimateWindow)(HWND hWnd, DWORD dwTime, DWORD dwFlags);
typedef BOOL(__stdcall* PrintWindow)(HWND hwnd, HDC hdcBlt, UINT nFlags);
typedef BOOL(__stdcall* SetLayeredWindowAttributes)(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
typedef BOOL(__stdcall* ShowWindowAsync)(HWND hWnd, int nCmdShow);
typedef BOOL(__stdcall* FlashWindow)(HWND hWnd, BOOL bInvert);
typedef BOOL(__stdcall* FlashWindowEx)(PFLASHWINFO pfwi);
typedef BOOL(__stdcall* ShowOwnedPopups)(HWND hWnd, BOOL fShow);
typedef BOOL(__stdcall* OpenIcon)(HWND hWnd);
typedef BOOL(__stdcall* CloseWindow)(HWND hWnd);
typedef BOOL(__stdcall* MoveWindow)(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint);
typedef BOOL(__stdcall* SetWindowPos)(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags);
typedef BOOL(__stdcall* SetWindowDisplayAffinity)(HWND hWnd, DWORD dwAffinity);
typedef HDWP(__stdcall* BeginDeferWindowPos)(int nNumWindows);
typedef HDWP(__stdcall* DeferWindowPos)(HDWP hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags);
typedef BOOL(__stdcall* EndDeferWindowPos)(HDWP hWinPosInfo);
typedef BOOL(__stdcall* IsWindowVisible)(HWND hWnd);
typedef BOOL(__stdcall* IsIconic)(HWND hWnd);
typedef BOOL(__stdcall* BringWindowToTop)(HWND hWnd);
typedef BOOL(__stdcall* IsZoomed)(HWND hWnd);
typedef HWND(__stdcall* CreateDialogParamA)(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef HWND(__stdcall* CreateDialogParamW)(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef HWND(__stdcall* CreateDialogIndirectParamA)(HINSTANCE hInstance, LPCDLGTEMPLATEA lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef HWND(__stdcall* CreateDialogIndirectParamW)(HINSTANCE hInstance, LPCDLGTEMPLATEW lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef INT_PTR(__stdcall* DialogBoxParamA)(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef INT_PTR(__stdcall* DialogBoxParamW)(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef INT_PTR(__stdcall* DialogBoxIndirectParamA)(HINSTANCE hInstance, LPCDLGTEMPLATEA hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef INT_PTR(__stdcall* DialogBoxIndirectParamW)(HINSTANCE hInstance, LPCDLGTEMPLATEW hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
typedef BOOL(__stdcall* EndDialog)(HWND hDlg, INT_PTR nResult);
typedef HWND(__stdcall* GetDlgItem)(HWND hDlg, int nIDDlgItem);
typedef BOOL(__stdcall* SetDlgItemInt)(HWND hDlg, int nIDDlgItem, UINT uValue, BOOL bSigned);
typedef BOOL(__stdcall* SetDlgItemTextA)(HWND hDlg, int nIDDlgItem, LPCSTR lpString);
typedef BOOL(__stdcall* SetDlgItemTextW)(HWND hDlg, int nIDDlgItem, LPCWSTR lpString);
typedef UINT(__stdcall* GetDlgItemTextA)(HWND hDlg, int nIDDlgItem, LPSTR lpString, int cchMax);
typedef UINT(__stdcall* GetDlgItemTextW)(HWND hDlg, int nIDDlgItem, LPWSTR lpString, int cchMax);
typedef BOOL(__stdcall* CheckDlgButton)(HWND hDlg, int nIDButton, UINT uCheck);
typedef BOOL(__stdcall* CheckRadioButton)(HWND hDlg, int nIDFirstButton, int nIDLastButton, int nIDCheckButton);
typedef UINT(__stdcall* IsDlgButtonChecked)(HWND hDlg, int nIDButton);
typedef LRESULT(__stdcall* SendDlgItemMessageA)(HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* SendDlgItemMessageW)(HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef HWND(__stdcall* GetNextDlgGroupItem)(HWND hDlg, HWND hCtl, BOOL bPrevious);
typedef HWND(__stdcall* GetNextDlgTabItem)(HWND hDlg, HWND hCtl, BOOL bPrevious);
typedef int(__stdcall* GetDlgCtrlID)(HWND hWnd);
typedef LRESULT(__stdcall* DefDlgProcW)(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
typedef DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS(__stdcall* GetDialogControlDpiChangeBehavior)(HWND hWnd);
typedef BOOL(__stdcall* SetDialogDpiChangeBehavior)(HWND hDlg, DIALOG_DPI_CHANGE_BEHAVIORS mask, DIALOG_DPI_CHANGE_BEHAVIORS values);
typedef DIALOG_DPI_CHANGE_BEHAVIORS(__stdcall* GetDialogDpiChangeBehavior)(HWND hDlg);
typedef BOOL(__stdcall* CallMsgFilterA)(LPMSG lpMsg, int nCode);
typedef BOOL(__stdcall* CallMsgFilterW)(LPMSG lpMsg, int nCode);
typedef BOOL(__stdcall* OpenClipboard)(HWND hWndNewOwner);
typedef HWND(__stdcall* SetClipboardViewer)(HWND hWndNewViewer);
typedef BOOL(__stdcall* ChangeClipboardChain)(HWND hWndRemove, HWND hWndNewNext);
typedef HANDLE(__stdcall* SetClipboardData)(UINT uFormat, HANDLE hMem);
typedef HANDLE(__stdcall* GetClipboardData)(UINT uFormat);
typedef UINT(__stdcall* RegisterClipboardFormatA)(LPCSTR lpszFormat);
typedef UINT(__stdcall* RegisterClipboardFormatW)(LPCWSTR lpszFormat);
typedef UINT(__stdcall* EnumClipboardFormats)(UINT format);
typedef int(__stdcall* GetClipboardFormatNameA)(UINT format, LPSTR lpszFormatName, int cchMaxCount);
typedef int(__stdcall* GetClipboardFormatNameW)(UINT format, LPWSTR lpszFormatName, int cchMaxCount);
typedef BOOL(__stdcall* IsClipboardFormatAvailable)(UINT format);
typedef BOOL(__stdcall* AddClipboardFormatListener)(HWND hwnd);
typedef BOOL(__stdcall* RemoveClipboardFormatListener)(HWND hwnd);
typedef BOOL(__stdcall* GetUpdatedClipboardFormats)(PUINT lpuiFormats, UINT cFormats, PUINT pcFormatsOut);
typedef BOOL(__stdcall* CharToOemA)(LPCSTR pSrc, LPSTR pDst);
typedef BOOL(__stdcall* CharToOemW)(LPCWSTR pSrc, LPSTR pDst);
typedef BOOL(__stdcall* OemToCharA)(LPCSTR pSrc, LPSTR pDst);
typedef BOOL(__stdcall* OemToCharW)(LPCSTR pSrc, LPWSTR pDst);
typedef BOOL(__stdcall* CharToOemBuffA)(LPCSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
typedef BOOL(__stdcall* CharToOemBuffW)(LPCWSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
typedef BOOL(__stdcall* OemToCharBuffA)(LPCSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
typedef BOOL(__stdcall* OemToCharBuffW)(LPCSTR lpszSrc, LPWSTR lpszDst, DWORD cchDstLength);
typedef LPSTR(__stdcall* CharUpperA)(LPSTR lpsz);
typedef LPWSTR(__stdcall* CharUpperW)(LPWSTR lpsz);
typedef DWORD(__stdcall* CharUpperBuffA)(LPSTR lpsz, DWORD cchLength);
typedef DWORD(__stdcall* CharUpperBuffW)(LPWSTR lpsz, DWORD cchLength);
typedef LPSTR(__stdcall* CharLowerA)(LPSTR lpsz);
typedef LPWSTR(__stdcall* CharLowerW)(LPWSTR lpsz);
typedef DWORD(__stdcall* CharLowerBuffA)(LPSTR lpsz, DWORD cchLength);
typedef DWORD(__stdcall* CharLowerBuffW)(LPWSTR lpsz, DWORD cchLength);
typedef LPSTR(__stdcall* CharNextA)(LPCSTR lpsz);
typedef LPWSTR(__stdcall* CharNextW)(LPCWSTR lpsz);
typedef LPSTR(__stdcall* CharPrevA)(LPCSTR lpszStart, LPCSTR lpszCurrent);
typedef LPWSTR(__stdcall* CharPrevW)(LPCWSTR lpszStart, LPCWSTR lpszCurrent);
typedef LPSTR(__stdcall* CharNextExA)(WORD CodePage, LPCSTR lpCurrentChar, DWORD dwFlags);
typedef LPSTR(__stdcall* CharPrevExA)(WORD CodePage, LPCSTR lpStart, LPCSTR lpCurrentChar, DWORD dwFlags);
typedef BOOL(__stdcall* IsCharAlphaA)(CHAR ch);
typedef BOOL(__stdcall* IsCharAlphaW)(WCHAR ch);
typedef BOOL(__stdcall* IsCharAlphaNumericA)(CHAR ch);
typedef BOOL(__stdcall* IsCharAlphaNumericW)(WCHAR ch);
typedef BOOL(__stdcall* IsCharUpperA)(CHAR ch);
typedef BOOL(__stdcall* IsCharUpperW)(WCHAR ch);
typedef BOOL(__stdcall* IsCharLowerA)(CHAR ch);
typedef BOOL(__stdcall* IsCharLowerW)(WCHAR ch);
typedef HWND(__stdcall* SetFocus)(HWND hWnd);
typedef SHORT(__stdcall* GetKeyState)(int nVirtKey);
typedef SHORT(__stdcall* GetAsyncKeyState)(int vKey);
typedef BOOL(__stdcall* GetKeyboardState)(PBYTE lpKeyState);
typedef BOOL(__stdcall* SetKeyboardState)(LPBYTE lpKeyState);
typedef int(__stdcall* GetKeyNameTextA)(LONG lParam, LPSTR lpString, int cchSize);
typedef int(__stdcall* GetKeyNameTextW)(LONG lParam, LPWSTR lpString, int cchSize);
typedef int(__stdcall* GetKeyboardType)(int nTypeFlag);
typedef DWORD(__stdcall* OemKeyScan)(WORD wOemChar);
typedef SHORT(__stdcall* VkKeyScanA)(CHAR ch);
typedef SHORT(__stdcall* VkKeyScanW)(WCHAR ch);
typedef SHORT(__stdcall* VkKeyScanExA)(CHAR ch, HKL dwhkl);
typedef SHORT(__stdcall* VkKeyScanExW)(WCHAR ch, HKL dwhkl);
typedef void(__stdcall* keybd_event)(BYTE bVk, BYTE bScan, DWORD dwFlags, ULONG_PTR dwExtraInfo);
typedef void(__stdcall* mouse_event)(DWORD dwFlags, DWORD dx, DWORD dy, DWORD dwData, ULONG_PTR dwExtraInfo);
typedef UINT(__stdcall* SendInput)(UINT cInputs, LPINPUT pInputs, int cbSize);
typedef BOOL(__stdcall* GetTouchInputInfo)(HTOUCHINPUT hTouchInput, UINT cInputs, PTOUCHINPUT pInputs, int cbSize);
typedef BOOL(__stdcall* CloseTouchInputHandle)(HTOUCHINPUT hTouchInput);
typedef BOOL(__stdcall* RegisterTouchWindow)(HWND hwnd, ULONG ulFlags);
typedef BOOL(__stdcall* UnregisterTouchWindow)(HWND hwnd);
typedef BOOL(__stdcall* IsTouchWindow)(HWND hwnd, PULONG pulFlags);
typedef BOOL(__stdcall* InitializeTouchInjection)(UINT32 maxCount, DWORD dwMode);
typedef BOOL(__stdcall* SkipPointerFrameMessages)(UINT32 pointerId);
typedef BOOL(__stdcall* RegisterPointerInputTarget)(HWND hwnd, POINTER_INPUT_TYPE pointerType);
typedef BOOL(__stdcall* UnregisterPointerInputTarget)(HWND hwnd, POINTER_INPUT_TYPE pointerType);
typedef BOOL(__stdcall* RegisterPointerInputTargetEx)(HWND hwnd, POINTER_INPUT_TYPE pointerType, BOOL fObserve);
typedef BOOL(__stdcall* UnregisterPointerInputTargetEx)(HWND hwnd, POINTER_INPUT_TYPE pointerType);
typedef HSYNTHETICPOINTERDEVICE(__stdcall* CreateSyntheticPointerDevice)(POINTER_INPUT_TYPE pointerType, ULONG maxCount, POINTER_FEEDBACK_MODE mode);
typedef void(__stdcall* DestroySyntheticPointerDevice)(HSYNTHETICPOINTERDEVICE device);
typedef BOOL(__stdcall* EnableMouseInPointer)(BOOL fEnable);
typedef BOOL(__stdcall* RegisterTouchHitTestingWindow)(HWND hwnd, ULONG value);
typedef BOOL(__stdcall* GetLastInputInfo)(PLASTINPUTINFO plii);
typedef UINT(__stdcall* MapVirtualKeyA)(UINT uCode, UINT uMapType);
typedef UINT(__stdcall* MapVirtualKeyW)(UINT uCode, UINT uMapType);
typedef UINT(__stdcall* MapVirtualKeyExA)(UINT uCode, UINT uMapType, HKL dwhkl);
typedef UINT(__stdcall* MapVirtualKeyExW)(UINT uCode, UINT uMapType, HKL dwhkl);
typedef DWORD(__stdcall* GetQueueStatus)(UINT flags);
typedef HWND(__stdcall* SetCapture)(HWND hWnd);
typedef UINT_PTR(__stdcall* SetTimer)(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc);
typedef UINT_PTR(__stdcall* SetCoalescableTimer)(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc, ULONG uToleranceDelay);
typedef BOOL(__stdcall* KillTimer)(HWND hWnd, UINT_PTR uIDEvent);
typedef BOOL(__stdcall* IsWindowUnicode)(HWND hWnd);
typedef BOOL(__stdcall* EnableWindow)(HWND hWnd, BOOL bEnable);
typedef BOOL(__stdcall* IsWindowEnabled)(HWND hWnd);
typedef HACCEL(__stdcall* LoadAcceleratorsA)(HINSTANCE hInstance, LPCSTR lpTableName);
typedef HACCEL(__stdcall* LoadAcceleratorsW)(HINSTANCE hInstance, LPCWSTR lpTableName);
typedef HACCEL(__stdcall* CreateAcceleratorTableA)(LPACCEL paccel, int cAccel);
typedef HACCEL(__stdcall* CreateAcceleratorTableW)(LPACCEL paccel, int cAccel);
typedef BOOL(__stdcall* DestroyAcceleratorTable)(HACCEL hAccel);
typedef int(__stdcall* CopyAcceleratorTableA)(HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries);
typedef int(__stdcall* CopyAcceleratorTableW)(HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries);
typedef int(__stdcall* TranslateAcceleratorA)(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg);
typedef int(__stdcall* TranslateAcceleratorW)(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg);
typedef int(__stdcall* GetSystemMetrics)(int nIndex);
typedef int(__stdcall* GetSystemMetricsForDpi)(int nIndex, UINT dpi);
typedef HMENU(__stdcall* LoadMenuA)(HINSTANCE hInstance, LPCSTR lpMenuName);
typedef HMENU(__stdcall* LoadMenuW)(HINSTANCE hInstance, LPCWSTR lpMenuName);
typedef HMENU(__stdcall* GetMenu)(HWND hWnd);
typedef BOOL(__stdcall* SetMenu)(HWND hWnd, HMENU hMenu);
typedef BOOL(__stdcall* HiliteMenuItem)(HWND hWnd, HMENU hMenu, UINT uIDHiliteItem, UINT uHilite);
typedef int(__stdcall* GetMenuStringA)(HMENU hMenu, UINT uIDItem, LPSTR lpString, int cchMax, UINT flags);
typedef int(__stdcall* GetMenuStringW)(HMENU hMenu, UINT uIDItem, LPWSTR lpString, int cchMax, UINT flags);
typedef UINT(__stdcall* GetMenuState)(HMENU hMenu, UINT uId, UINT uFlags);
typedef BOOL(__stdcall* DrawMenuBar)(HWND hWnd);
typedef HMENU(__stdcall* GetSystemMenu)(HWND hWnd, BOOL bRevert);
typedef BOOL(__stdcall* DestroyMenu)(HMENU hMenu);
typedef DWORD(__stdcall* CheckMenuItem)(HMENU hMenu, UINT uIDCheckItem, UINT uCheck);
typedef BOOL(__stdcall* EnableMenuItem)(HMENU hMenu, UINT uIDEnableItem, UINT uEnable);
typedef HMENU(__stdcall* GetSubMenu)(HMENU hMenu, int nPos);
typedef UINT(__stdcall* GetMenuItemID)(HMENU hMenu, int nPos);
typedef int(__stdcall* GetMenuItemCount)(HMENU hMenu);
typedef BOOL(__stdcall* InsertMenuA)(HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
typedef BOOL(__stdcall* InsertMenuW)(HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
typedef BOOL(__stdcall* AppendMenuA)(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
typedef BOOL(__stdcall* AppendMenuW)(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
typedef BOOL(__stdcall* ModifyMenuA)(HMENU hMnu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
typedef BOOL(__stdcall* ModifyMenuW)(HMENU hMnu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
typedef BOOL(__stdcall* RemoveMenu)(HMENU hMenu, UINT uPosition, UINT uFlags);
typedef BOOL(__stdcall* DeleteMenu)(HMENU hMenu, UINT uPosition, UINT uFlags);
typedef BOOL(__stdcall* SetMenuItemBitmaps)(HMENU hMenu, UINT uPosition, UINT uFlags, HBITMAP hBitmapUnchecked, HBITMAP hBitmapChecked);
typedef BOOL(__stdcall* TrackPopupMenuEx)(HMENU hMenu, UINT uFlags, int x, int y, HWND hwnd, LPTPMPARAMS lptpm);
typedef BOOL(__stdcall* InsertMenuItemA)(HMENU hmenu, UINT item, BOOL fByPosition, LPCMENUITEMINFOA lpmi);
typedef BOOL(__stdcall* InsertMenuItemW)(HMENU hmenu, UINT item, BOOL fByPosition, LPCMENUITEMINFOW lpmi);
typedef BOOL(__stdcall* GetMenuItemInfoA)(HMENU hmenu, UINT item, BOOL fByPosition, LPMENUITEMINFOA lpmii);
typedef BOOL(__stdcall* GetMenuItemInfoW)(HMENU hmenu, UINT item, BOOL fByPosition, LPMENUITEMINFOW lpmii);
typedef BOOL(__stdcall* SetMenuItemInfoA)(HMENU hmenu, UINT item, BOOL fByPositon, LPCMENUITEMINFOA lpmii);
typedef BOOL(__stdcall* SetMenuItemInfoW)(HMENU hmenu, UINT item, BOOL fByPositon, LPCMENUITEMINFOW lpmii);
typedef UINT(__stdcall* GetMenuDefaultItem)(HMENU hMenu, UINT fByPos, UINT gmdiFlags);
typedef BOOL(__stdcall* SetMenuDefaultItem)(HMENU hMenu, UINT uItem, UINT fByPos);
typedef BOOL(__stdcall* GetMenuItemRect)(HWND hWnd, HMENU hMenu, UINT uItem, LPRECT lprcItem);
typedef int(__stdcall* MenuItemFromPoint)(HWND hWnd, HMENU hMenu, POINT ptScreen);
typedef BOOL(__stdcall* DragDetect)(HWND hwnd, POINT pt);
typedef BOOL(__stdcall* DrawIcon)(HDC hDC, int X, int Y, HICON hIcon);
typedef int(__stdcall* DrawTextA)(HDC hdc, LPCSTR lpchText, int cchText, LPRECT lprc, UINT format);
typedef int(__stdcall* DrawTextW)(HDC hdc, LPCWSTR lpchText, int cchText, LPRECT lprc, UINT format);
typedef int(__stdcall* DrawTextExA)(HDC hdc, LPSTR lpchText, int cchText, LPRECT lprc, UINT format, LPDRAWTEXTPARAMS lpdtp);
typedef int(__stdcall* DrawTextExW)(HDC hdc, LPWSTR lpchText, int cchText, LPRECT lprc, UINT format, LPDRAWTEXTPARAMS lpdtp);
typedef BOOL(__stdcall* GrayStringA)(HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight);
typedef BOOL(__stdcall* GrayStringW)(HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight);
typedef BOOL(__stdcall* DrawStateA)(HDC hdc, HBRUSH hbrFore, DRAWSTATEPROC qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags);
typedef BOOL(__stdcall* DrawStateW)(HDC hdc, HBRUSH hbrFore, DRAWSTATEPROC qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags);
typedef BOOL(__stdcall* UpdateWindow)(HWND hWnd);
typedef HWND(__stdcall* SetActiveWindow)(HWND hWnd);
typedef BOOL(__stdcall* PaintDesktop)(HDC hdc);
typedef void(__stdcall* SwitchToThisWindow)(HWND hwnd, BOOL fUnknown);
typedef BOOL(__stdcall* SetForegroundWindow)(HWND hWnd);
typedef BOOL(__stdcall* AllowSetForegroundWindow)(DWORD dwProcessId);
typedef BOOL(__stdcall* LockSetForegroundWindow)(UINT uLockCode);
typedef HWND(__stdcall* WindowFromDC)(HDC hDC);
typedef HDC(__stdcall* GetDC)(HWND hWnd);
typedef HDC(__stdcall* GetDCEx)(HWND hWnd, HRGN hrgnClip, DWORD flags);
typedef HDC(__stdcall* GetWindowDC)(HWND hWnd);
typedef int(__stdcall* ReleaseDC)(HWND hWnd, HDC hDC);
typedef HDC(__stdcall* BeginPaint)(HWND hWnd, LPPAINTSTRUCT lpPaint);
typedef BOOL(__stdcall* GetUpdateRect)(HWND hWnd, LPRECT lpRect, BOOL bErase);
typedef int(__stdcall* GetUpdateRgn)(HWND hWnd, HRGN hRgn, BOOL bErase);
typedef int(__stdcall* SetWindowRgn)(HWND hWnd, HRGN hRgn, BOOL bRedraw);
typedef int(__stdcall* GetWindowRgn)(HWND hWnd, HRGN hRgn);
typedef int(__stdcall* GetWindowRgnBox)(HWND hWnd, LPRECT lprc);
typedef int(__stdcall* ExcludeUpdateRgn)(HDC hDC, HWND hWnd);
typedef BOOL(__stdcall* InvalidateRgn)(HWND hWnd, HRGN hRgn, BOOL bErase);
typedef BOOL(__stdcall* ValidateRgn)(HWND hWnd, HRGN hRgn);
typedef BOOL(__stdcall* LockWindowUpdate)(HWND hWndLock);
typedef int(__stdcall* SetScrollPos)(HWND hWnd, int nBar, int nPos, BOOL bRedraw);
typedef int(__stdcall* GetScrollPos)(HWND hWnd, int nBar);
typedef BOOL(__stdcall* SetScrollRange)(HWND hWnd, int nBar, int nMinPos, int nMaxPos, BOOL bRedraw);
typedef BOOL(__stdcall* GetScrollRange)(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos);
typedef BOOL(__stdcall* ShowScrollBar)(HWND hWnd, int wBar, BOOL bShow);
typedef BOOL(__stdcall* EnableScrollBar)(HWND hWnd, UINT wSBflags, UINT wArrows);
typedef BOOL(__stdcall* SetPropA)(HWND hWnd, LPCSTR lpString, HANDLE hData);
typedef BOOL(__stdcall* SetPropW)(HWND hWnd, LPCWSTR lpString, HANDLE hData);
typedef HANDLE(__stdcall* GetPropA)(HWND hWnd, LPCSTR lpString);
typedef HANDLE(__stdcall* GetPropW)(HWND hWnd, LPCWSTR lpString);
typedef HANDLE(__stdcall* RemovePropA)(HWND hWnd, LPCSTR lpString);
typedef HANDLE(__stdcall* RemovePropW)(HWND hWnd, LPCWSTR lpString);
typedef int(__stdcall* EnumPropsExA)(HWND hWnd, PROPENUMPROCEXA lpEnumFunc, LPARAM lParam);
typedef int(__stdcall* EnumPropsExW)(HWND hWnd, PROPENUMPROCEXW lpEnumFunc, LPARAM lParam);
typedef int(__stdcall* EnumPropsA)(HWND hWnd, PROPENUMPROCA lpEnumFunc);
typedef int(__stdcall* EnumPropsW)(HWND hWnd, PROPENUMPROCW lpEnumFunc);
typedef BOOL(__stdcall* SetWindowTextA)(HWND hWnd, LPCSTR lpString);
typedef BOOL(__stdcall* SetWindowTextW)(HWND hWnd, LPCWSTR lpString);
typedef int(__stdcall* GetWindowTextA)(HWND hWnd, LPSTR lpString, int nMaxCount);
typedef int(__stdcall* GetWindowTextW)(HWND hWnd, LPWSTR lpString, int nMaxCount);
typedef int(__stdcall* GetWindowTextLengthA)(HWND hWnd);
typedef int(__stdcall* GetWindowTextLengthW)(HWND hWnd);
typedef BOOL(__stdcall* GetClientRect)(HWND hWnd, LPRECT lpRect);
typedef BOOL(__stdcall* GetWindowRect)(HWND hWnd, LPRECT lpRect);
typedef BOOL(__stdcall* AdjustWindowRect)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu);
typedef BOOL(__stdcall* AdjustWindowRectEx)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle);
typedef BOOL(__stdcall* AdjustWindowRectExForDpi)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle, UINT dpi);
typedef int(__stdcall* MessageBoxA)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
typedef int(__stdcall* MessageBoxW)(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType);
typedef int(__stdcall* MessageBoxExA)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType, WORD wLanguageId);
typedef int(__stdcall* MessageBoxExW)(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId);
typedef BOOL(__stdcall* MessageBeep)(UINT uType);
typedef int(__stdcall* ShowCursor)(BOOL bShow);
typedef BOOL(__stdcall* SetCursorPos)(int X, int Y);
typedef BOOL(__stdcall* SetPhysicalCursorPos)(int X, int Y);
typedef HCURSOR(__stdcall* SetCursor)(HCURSOR hCursor);
typedef BOOL(__stdcall* GetCursorPos)(LPPOINT lpPoint);
typedef BOOL(__stdcall* GetPhysicalCursorPos)(LPPOINT lpPoint);
typedef BOOL(__stdcall* GetClipCursor)(LPRECT lpRect);
typedef BOOL(__stdcall* CreateCaret)(HWND hWnd, HBITMAP hBitmap, int nWidth, int nHeight);
typedef BOOL(__stdcall* SetCaretBlinkTime)(UINT uMSeconds);
typedef BOOL(__stdcall* HideCaret)(HWND hWnd);
typedef BOOL(__stdcall* ShowCaret)(HWND hWnd);
typedef BOOL(__stdcall* SetCaretPos)(int X, int Y);
typedef BOOL(__stdcall* GetCaretPos)(LPPOINT lpPoint);
typedef BOOL(__stdcall* ClientToScreen)(HWND hWnd, LPPOINT lpPoint);
typedef BOOL(__stdcall* ScreenToClient)(HWND hWnd, LPPOINT lpPoint);
typedef BOOL(__stdcall* LogicalToPhysicalPoint)(HWND hWnd, LPPOINT lpPoint);
typedef BOOL(__stdcall* PhysicalToLogicalPoint)(HWND hWnd, LPPOINT lpPoint);
typedef BOOL(__stdcall* LogicalToPhysicalPointForPerMonitorDPI)(HWND hWnd, LPPOINT lpPoint);
typedef BOOL(__stdcall* PhysicalToLogicalPointForPerMonitorDPI)(HWND hWnd, LPPOINT lpPoint);
typedef int(__stdcall* MapWindowPoints)(HWND hWndFrom, HWND hWndTo, LPPOINT lpPoints, UINT cPoints);
typedef HWND(__stdcall* WindowFromPoint)(POINT Point);
typedef HWND(__stdcall* WindowFromPhysicalPoint)(POINT Point);
typedef HWND(__stdcall* ChildWindowFromPoint)(HWND hWndParent, POINT Point);
typedef HWND(__stdcall* ChildWindowFromPointEx)(HWND hwnd, POINT pt, UINT flags);
typedef DWORD(__stdcall* GetSysColor)(int nIndex);
typedef HBRUSH(__stdcall* GetSysColorBrush)(int nIndex);
typedef BOOL(__stdcall* SetRect)(LPRECT lprc, int xLeft, int yTop, int xRight, int yBottom);
typedef BOOL(__stdcall* SetRectEmpty)(LPRECT lprc);
typedef BOOL(__stdcall* InflateRect)(LPRECT lprc, int dx, int dy);
typedef BOOL(__stdcall* OffsetRect)(LPRECT lprc, int dx, int dy);
typedef LONG(__stdcall* GetWindowLongA)(HWND hWnd, int nIndex);
typedef LONG(__stdcall* GetWindowLongW)(HWND hWnd, int nIndex);
typedef LONG(__stdcall* SetWindowLongA)(HWND hWnd, int nIndex, LONG dwNewLong);
typedef LONG(__stdcall* SetWindowLongW)(HWND hWnd, int nIndex, LONG dwNewLong);
typedef LONG_PTR(__stdcall* GetWindowLongPtrA)(HWND hWnd, int nIndex);
typedef LONG_PTR(__stdcall* GetWindowLongPtrW)(HWND hWnd, int nIndex);
typedef LONG_PTR(__stdcall* SetWindowLongPtrA)(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
typedef LONG_PTR(__stdcall* SetWindowLongPtrW)(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
typedef WORD(__stdcall* GetClassWord)(HWND hWnd, int nIndex);
typedef WORD(__stdcall* SetClassWord)(HWND hWnd, int nIndex, WORD wNewWord);
typedef DWORD(__stdcall* GetClassLongA)(HWND hWnd, int nIndex);
typedef DWORD(__stdcall* GetClassLongW)(HWND hWnd, int nIndex);
typedef DWORD(__stdcall* SetClassLongA)(HWND hWnd, int nIndex, LONG dwNewLong);
typedef DWORD(__stdcall* SetClassLongW)(HWND hWnd, int nIndex, LONG dwNewLong);
typedef ULONG_PTR(__stdcall* GetClassLongPtrA)(HWND hWnd, int nIndex);
typedef ULONG_PTR(__stdcall* GetClassLongPtrW)(HWND hWnd, int nIndex);
typedef ULONG_PTR(__stdcall* SetClassLongPtrA)(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
typedef ULONG_PTR(__stdcall* SetClassLongPtrW)(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
typedef BOOL(__stdcall* SetProcessDefaultLayout)(DWORD dwDefaultLayout);
typedef HWND(__stdcall* GetParent)(HWND hWnd);
typedef HWND(__stdcall* SetParent)(HWND hWndChild, HWND hWndNewParent);
typedef BOOL(__stdcall* EnumChildWindows)(HWND hWndParent, WNDENUMPROC lpEnumFunc, LPARAM lParam);
typedef HWND(__stdcall* FindWindowA)(LPCSTR lpClassName, LPCSTR lpWindowName);
typedef HWND(__stdcall* FindWindowW)(LPCWSTR lpClassName, LPCWSTR lpWindowName);
typedef HWND(__stdcall* FindWindowExA)(HWND hWndParent, HWND hWndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow);
typedef HWND(__stdcall* FindWindowExW)(HWND hWndParent, HWND hWndChildAfter, LPCWSTR lpszClass, LPCWSTR lpszWindow);
typedef BOOL(__stdcall* RegisterShellHookWindow)(HWND hwnd);
typedef BOOL(__stdcall* DeregisterShellHookWindow)(HWND hwnd);
typedef BOOL(__stdcall* EnumWindows)(WNDENUMPROC lpEnumFunc, LPARAM lParam);
typedef BOOL(__stdcall* EnumThreadWindows)(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam);
typedef int(__stdcall* GetClassNameA)(HWND hWnd, LPSTR lpClassName, int nMaxCount);
typedef int(__stdcall* GetClassNameW)(HWND hWnd, LPWSTR lpClassName, int nMaxCount);
typedef HWND(__stdcall* GetTopWindow)(HWND hWnd);
typedef DWORD(__stdcall* GetWindowThreadProcessId)(HWND hWnd, LPDWORD lpdwProcessId);
typedef BOOL(__stdcall* IsGUIThread)(BOOL bConvert);
typedef HWND(__stdcall* GetLastActivePopup)(HWND hWnd);
typedef HWND(__stdcall* GetWindow)(HWND hWnd, UINT uCmd);
typedef HHOOK(__stdcall* SetWindowsHookExA)(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId);
typedef HHOOK(__stdcall* SetWindowsHookExW)(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId);
typedef BOOL(__stdcall* UnhookWindowsHookEx)(HHOOK hhk);
typedef LRESULT(__stdcall* CallNextHookEx)(HHOOK hhk, int nCode, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* CheckMenuRadioItem)(HMENU hmenu, UINT first, UINT last, UINT check, UINT flags);
typedef HBITMAP(__stdcall* LoadBitmapA)(HINSTANCE hInstance, LPCSTR lpBitmapName);
typedef HBITMAP(__stdcall* LoadBitmapW)(HINSTANCE hInstance, LPCWSTR lpBitmapName);
typedef HCURSOR(__stdcall* LoadCursorA)(HINSTANCE hInstance, LPCSTR lpCursorName);
typedef HCURSOR(__stdcall* LoadCursorW)(HINSTANCE hInstance, LPCWSTR lpCursorName);
typedef HCURSOR(__stdcall* LoadCursorFromFileA)(LPCSTR lpFileName);
typedef HCURSOR(__stdcall* LoadCursorFromFileW)(LPCWSTR lpFileName);
typedef BOOL(__stdcall* DestroyCursor)(HCURSOR hCursor);
typedef BOOL(__stdcall* SetSystemCursor)(HCURSOR hcur, DWORD id);
typedef HICON(__stdcall* LoadIconA)(HINSTANCE hInstance, LPCSTR lpIconName);
typedef HICON(__stdcall* LoadIconW)(HINSTANCE hInstance, LPCWSTR lpIconName);
typedef BOOL(__stdcall* DestroyIcon)(HICON hIcon);
typedef int(__stdcall* LookupIconIdFromDirectory)(PBYTE presbits, BOOL fIcon);
typedef int(__stdcall* LookupIconIdFromDirectoryEx)(PBYTE presbits, BOOL fIcon, int cxDesired, int cyDesired, UINT Flags);
typedef HICON(__stdcall* CreateIconFromResource)(PBYTE presbits, DWORD dwResSize, BOOL fIcon, DWORD dwVer);
typedef HICON(__stdcall* CreateIconFromResourceEx)(PBYTE presbits, DWORD dwResSize, BOOL fIcon, DWORD dwVer, int cxDesired, int cyDesired, UINT Flags);
typedef HANDLE(__stdcall* LoadImageA)(HINSTANCE hInst, LPCSTR name, UINT type, int cx, int cy, UINT fuLoad);
typedef HANDLE(__stdcall* LoadImageW)(HINSTANCE hInst, LPCWSTR name, UINT type, int cx, int cy, UINT fuLoad);
typedef HANDLE(__stdcall* CopyImage)(HANDLE h, UINT type, int cx, int cy, UINT flags);
typedef BOOL(__stdcall* DrawIconEx)(HDC hdc, int xLeft, int yTop, HICON hIcon, int cxWidth, int cyWidth, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags);
typedef HICON(__stdcall* CreateIconIndirect)(PICONINFO piconinfo);
typedef HICON(__stdcall* CopyIcon)(HICON hIcon);
typedef BOOL(__stdcall* GetIconInfo)(HICON hIcon, PICONINFO piconinfo);
typedef BOOL(__stdcall* GetIconInfoExA)(HICON hicon, PICONINFOEXA piconinfo);
typedef BOOL(__stdcall* GetIconInfoExW)(HICON hicon, PICONINFOEXW piconinfo);
typedef BOOL(__stdcall* IsDialogMessageA)(HWND hDlg, LPMSG lpMsg);
typedef BOOL(__stdcall* IsDialogMessageW)(HWND hDlg, LPMSG lpMsg);
typedef BOOL(__stdcall* MapDialogRect)(HWND hDlg, LPRECT lpRect);
typedef int(__stdcall* DlgDirListA)(HWND hDlg, LPSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType);
typedef int(__stdcall* DlgDirListW)(HWND hDlg, LPWSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType);
typedef BOOL(__stdcall* DlgDirSelectExA)(HWND hwndDlg, LPSTR lpString, int chCount, int idListBox);
typedef BOOL(__stdcall* DlgDirSelectExW)(HWND hwndDlg, LPWSTR lpString, int chCount, int idListBox);
typedef int(__stdcall* DlgDirListComboBoxA)(HWND hDlg, LPSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype);
typedef int(__stdcall* DlgDirListComboBoxW)(HWND hDlg, LPWSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype);
typedef BOOL(__stdcall* DlgDirSelectComboBoxExA)(HWND hwndDlg, LPSTR lpString, int cchOut, int idComboBox);
typedef BOOL(__stdcall* DlgDirSelectComboBoxExW)(HWND hwndDlg, LPWSTR lpString, int cchOut, int idComboBox);
typedef int(__stdcall* SetScrollInfo)(HWND hwnd, int nBar, LPCSCROLLINFO lpsi, BOOL redraw);
typedef BOOL(__stdcall* GetScrollInfo)(HWND hwnd, int nBar, LPSCROLLINFO lpsi);
typedef LRESULT(__stdcall* DefFrameProcA)(HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* DefFrameProcW)(HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* DefMDIChildProcA)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef LRESULT(__stdcall* DefMDIChildProcW)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef BOOL(__stdcall* TranslateMDISysAccel)(HWND hWndClient, LPMSG lpMsg);
typedef UINT(__stdcall* ArrangeIconicWindows)(HWND hWnd);
typedef HWND(__stdcall* CreateMDIWindowA)(LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam);
typedef HWND(__stdcall* CreateMDIWindowW)(LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam);
typedef BOOL(__stdcall* WinHelpA)(HWND hWndMain, LPCSTR lpszHelp, UINT uCommand, ULONG_PTR dwData);
typedef BOOL(__stdcall* WinHelpW)(HWND hWndMain, LPCWSTR lpszHelp, UINT uCommand, ULONG_PTR dwData);
typedef DWORD(__stdcall* GetGuiResources)(HANDLE hProcess, DWORD uiFlags);
typedef BOOL(__stdcall* EnumDisplayDevicesA)(LPCSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEA lpDisplayDevice, DWORD dwFlags);
typedef BOOL(__stdcall* EnumDisplayDevicesW)(LPCWSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEW lpDisplayDevice, DWORD dwFlags);
typedef BOOL(__stdcall* SystemParametersInfoA)(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
typedef BOOL(__stdcall* SystemParametersInfoW)(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
typedef BOOL(__stdcall* SystemParametersInfoForDpi)(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni, UINT dpi);
typedef void(__stdcall* SetLastErrorEx)(DWORD dwErrCode, DWORD dwType);
typedef int(__stdcall* InternalGetWindowText)(HWND hWnd, LPWSTR pString, int cchMaxCount);
typedef HMONITOR(__stdcall* MonitorFromPoint)(POINT pt, DWORD dwFlags);
typedef HMONITOR(__stdcall* MonitorFromRect)(LPCRECT lprc, DWORD dwFlags);
typedef HMONITOR(__stdcall* MonitorFromWindow)(HWND hwnd, DWORD dwFlags);
typedef BOOL(__stdcall* GetMonitorInfoA)(HMONITOR hMonitor, LPMONITORINFO lpmi);
typedef BOOL(__stdcall* GetMonitorInfoW)(HMONITOR hMonitor, LPMONITORINFO lpmi);
typedef BOOL(__stdcall* EnumDisplayMonitors)(HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum, LPARAM dwData);
typedef void(__stdcall* NotifyWinEvent)(DWORD event, HWND hwnd, LONG idObject, LONG idChild);
typedef HWINEVENTHOOK(__stdcall* SetWinEventHook)(DWORD eventMin, DWORD eventMax, HMODULE hmodWinEventProc, WINEVENTPROC pfnWinEventProc, DWORD idProcess, DWORD idThread, DWORD dwFlags);
typedef BOOL(__stdcall* IsWinEventHookInstalled)(DWORD event);
typedef BOOL(__stdcall* UnhookWinEvent)(HWINEVENTHOOK hWinEventHook);
typedef BOOL(__stdcall* GetGUIThreadInfo)(DWORD idThread, PGUITHREADINFO pgui);
typedef BOOL(__stdcall* BlockInput)(BOOL fBlockIt);
typedef DPI_AWARENESS_CONTEXT(__stdcall* SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT dpiContext);
typedef DPI_AWARENESS_CONTEXT(__stdcall* GetWindowDpiAwarenessContext)(HWND hwnd);
typedef DPI_AWARENESS(__stdcall* GetAwarenessFromDpiAwarenessContext)(DPI_AWARENESS_CONTEXT value);
typedef UINT(__stdcall* GetDpiFromDpiAwarenessContext)(DPI_AWARENESS_CONTEXT value);
typedef BOOL(__stdcall* AreDpiAwarenessContextsEqual)(DPI_AWARENESS_CONTEXT dpiContextA, DPI_AWARENESS_CONTEXT dpiContextB);
typedef BOOL(__stdcall* IsValidDpiAwarenessContext)(DPI_AWARENESS_CONTEXT value);
typedef UINT(__stdcall* GetDpiForWindow)(HWND hwnd);
typedef UINT(__stdcall* GetSystemDpiForProcess)(HANDLE hProcess);
typedef BOOL(__stdcall* EnableNonClientDpiScaling)(HWND hwnd);
typedef BOOL(__stdcall* SetProcessDpiAwarenessContext)(DPI_AWARENESS_CONTEXT value);
typedef DPI_HOSTING_BEHAVIOR(__stdcall* SetThreadDpiHostingBehavior)(DPI_HOSTING_BEHAVIOR value);
typedef DPI_HOSTING_BEHAVIOR(__stdcall* GetWindowDpiHostingBehavior)(HWND hwnd);
typedef UINT(__stdcall* GetWindowModuleFileNameA)(HWND hwnd, LPSTR pszFileName, UINT cchFileNameMax);
typedef UINT(__stdcall* GetWindowModuleFileNameW)(HWND hwnd, LPWSTR pszFileName, UINT cchFileNameMax);
typedef BOOL(__stdcall* GetCursorInfo)(PCURSORINFO pci);
typedef BOOL(__stdcall* GetWindowInfo)(HWND hwnd, PWINDOWINFO pwi);
typedef BOOL(__stdcall* GetTitleBarInfo)(HWND hwnd, PTITLEBARINFO pti);
typedef BOOL(__stdcall* GetMenuBarInfo)(HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi);
typedef BOOL(__stdcall* GetScrollBarInfo)(HWND hwnd, LONG idObject, PSCROLLBARINFO psbi);
typedef BOOL(__stdcall* GetComboBoxInfo)(HWND hwndCombo, PCOMBOBOXINFO pcbi);
typedef HWND(__stdcall* GetAncestor)(HWND hwnd, UINT gaFlags);
typedef HWND(__stdcall* RealChildWindowFromPoint)(HWND hwndParent, POINT ptParentClientCoords);
typedef UINT(__stdcall* RealGetWindowClassW)(HWND hwnd, LPWSTR ptszClassName, UINT cchClassNameMax);
typedef BOOL(__stdcall* GetAltTabInfoA)(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText);
typedef BOOL(__stdcall* GetAltTabInfoW)(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText);
typedef DWORD(__stdcall* GetListBoxInfo)(HWND hwnd);
typedef BOOL(__stdcall* UserHandleGrantAccess)(HANDLE hUserHandle, HANDLE hJob, BOOL bGrant);
typedef UINT(__stdcall* GetRawInputData)(HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader);
typedef UINT(__stdcall* GetRawInputDeviceInfoA)(HANDLE hDevice, UINT uiCommand, LPVOID pData, PUINT pcbSize);
typedef UINT(__stdcall* GetRawInputDeviceInfoW)(HANDLE hDevice, UINT uiCommand, LPVOID pData, PUINT pcbSize);
typedef UINT(__stdcall* GetRawInputBuffer)(PRAWINPUT pData, PUINT pcbSize, UINT cbSizeHeader);
typedef BOOL(__stdcall* RegisterRawInputDevices)(PCRAWINPUTDEVICE pRawInputDevices, UINT uiNumDevices, UINT cbSize);
typedef UINT(__stdcall* GetRegisteredRawInputDevices)(PRAWINPUTDEVICE pRawInputDevices, PUINT puiNumDevices, UINT cbSize);
typedef UINT(__stdcall* GetRawInputDeviceList)(PRAWINPUTDEVICELIST pRawInputDeviceList, PUINT puiNumDevices, UINT cbSize);
typedef BOOL(__stdcall* RegisterPointerDeviceNotifications)(HWND window, BOOL notifyRange);
typedef BOOL(__stdcall* ChangeWindowMessageFilter)(UINT message, DWORD dwFlag);
typedef BOOL(__stdcall* ChangeWindowMessageFilterEx)(HWND hwnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
typedef BOOL(__stdcall* GetGestureInfo)(HGESTUREINFO hGestureInfo, PGESTUREINFO pGestureInfo);
typedef BOOL(__stdcall* GetGestureExtraArgs)(HGESTUREINFO hGestureInfo, UINT cbExtraArgs, PBYTE pExtraArgs);
typedef BOOL(__stdcall* CloseGestureInfoHandle)(HGESTUREINFO hGestureInfo);
typedef BOOL(__stdcall* SetGestureConfig)(HWND hwnd, DWORD dwReserved, UINT cIDs, PGESTURECONFIG pGestureConfig, UINT cbSize);
typedef BOOL(__stdcall* GetGestureConfig)(HWND hwnd, DWORD dwReserved, DWORD dwFlags, PUINT pcIDs, PGESTURECONFIG pGestureConfig, UINT cbSize);
typedef BOOL(__stdcall* ShutdownBlockReasonCreate)(HWND hWnd, LPCWSTR pwszReason);
typedef BOOL(__stdcall* ShutdownBlockReasonDestroy)(HWND hWnd);
typedef BOOL(__stdcall* GetAutoRotationState)(PAR_STATE pState);
typedef BOOL(__stdcall* SetDisplayAutoRotationPreferences)(ORIENTATION_PREFERENCE orientation);
typedef BOOL(__stdcall* IsImmersiveProcess)(HANDLE hProcess);
typedef BOOL(__stdcall* SetProcessRestrictionExemption)(BOOL fEnableExemption);
typedef DWORD(__stdcall* VerFindFileA)(DWORD uFlags, LPCSTR szFileName, LPCSTR szWinDir, LPCSTR szAppDir, LPSTR szCurDir, PUINT puCurDirLen, LPSTR szDestDir, PUINT puDestDirLen);
typedef DWORD(__stdcall* VerFindFileW)(DWORD uFlags, LPCWSTR szFileName, LPCWSTR szWinDir, LPCWSTR szAppDir, LPWSTR szCurDir, PUINT puCurDirLen, LPWSTR szDestDir, PUINT puDestDirLen);
typedef DWORD(__stdcall* VerInstallFileA)(DWORD uFlags, LPCSTR szSrcFileName, LPCSTR szDestFileName, LPCSTR szSrcDir, LPCSTR szDestDir, LPCSTR szCurDir, LPSTR szTmpFile, PUINT puTmpFileLen);
typedef DWORD(__stdcall* VerInstallFileW)(DWORD uFlags, LPCWSTR szSrcFileName, LPCWSTR szDestFileName, LPCWSTR szSrcDir, LPCWSTR szDestDir, LPCWSTR szCurDir, LPWSTR szTmpFile, PUINT puTmpFileLen);
typedef DWORD(__stdcall* GetFileVersionInfoSizeA)(LPCSTR lptstrFilename, LPDWORD lpdwHandle);
typedef DWORD(__stdcall* GetFileVersionInfoSizeW)(LPCWSTR lptstrFilename, LPDWORD lpdwHandle);
typedef BOOL(__stdcall* GetFileVersionInfoA)(LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
typedef BOOL(__stdcall* GetFileVersionInfoW)(LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
typedef DWORD(__stdcall* GetFileVersionInfoSizeExA)(DWORD dwFlags, LPCSTR lpwstrFilename, LPDWORD lpdwHandle);
typedef DWORD(__stdcall* GetFileVersionInfoSizeExW)(DWORD dwFlags, LPCWSTR lpwstrFilename, LPDWORD lpdwHandle);
typedef BOOL(__stdcall* GetFileVersionInfoExA)(DWORD dwFlags, LPCSTR lpwstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
typedef BOOL(__stdcall* GetFileVersionInfoExW)(DWORD dwFlags, LPCWSTR lpwstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
typedef DWORD(__stdcall* VerLanguageNameA)(DWORD wLang, LPSTR szLang, DWORD cchLang);
typedef DWORD(__stdcall* VerLanguageNameW)(DWORD wLang, LPWSTR szLang, DWORD cchLang);
typedef void(__stdcall* WlxReconnectNotify)(PVOID pWlxContext);
typedef void(__stdcall* WlxDisconnectNotify)(PVOID pWlxContext);
typedef DWORD(__stdcall* WlanOpenHandle)(DWORD dwClientVersion, PVOID pReserved, PDWORD pdwNegotiatedVersion, PHANDLE phClientHandle);
typedef DWORD(__stdcall* WlanCloseHandle)(HANDLE hClientHandle, PVOID pReserved);
typedef DWORD(__stdcall* WlanSetAutoConfigParameter)(HANDLE hClientHandle, WLAN_AUTOCONF_OPCODE OpCode, DWORD dwDataSize, PVOID pData, PVOID pReserved);
typedef DWORD(__stdcall* WlanRegisterNotification)(HANDLE hClientHandle, DWORD dwNotifSource, BOOL bIgnoreDuplicate, WLAN_NOTIFICATION_CALLBACK funcCallback, PVOID pCallbackContext, PVOID pReserved, PDWORD pdwPrevNotifSource);
typedef DWORD(__stdcall* WlanSetFilterList)(HANDLE hClientHandle, WLAN_FILTER_LIST_TYPE wlanFilterListType, PDOT11_NETWORK_LIST pNetworkList, PVOID pReserved);
typedef DWORD(__stdcall* WlanSetPsdIEDataList)(HANDLE hClientHandle, LPCWSTR strFormat, PWLAN_RAW_DATA_LIST pPsdIEDataList, PVOID pReserved);
typedef DWORD(__stdcall* WlanRegisterDeviceServiceNotification)(HANDLE hClientHandle, PWLAN_DEVICE_SERVICE_GUID_LIST pDevSvcGuidList);
typedef DWORD(__stdcall* WlanReasonCodeToString)(DWORD dwReasonCode, DWORD dwBufferSize, PWCHAR pStringBuffer, PVOID pReserved);
typedef PVOID(__stdcall* WlanAllocateMemory)(DWORD dwMemorySize);
typedef void(__stdcall* WlanFreeMemory)(PVOID pMemory);
typedef DWORD(__stdcall* WlanSetSecuritySettings)(HANDLE hClientHandle, WLAN_SECURABLE_OBJECT SecurableObject, LPCWSTR strModifiedSDDL);
typedef DWORD(__stdcall* WlanHostedNetworkStartUsing)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkStopUsing)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkForceStart)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkForceStop)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkSetProperty)(HANDLE hClientHandle, WLAN_HOSTED_NETWORK_OPCODE OpCode, DWORD dwDataSize, PVOID pvData, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkInitSettings)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkRefreshSecuritySettings)(HANDLE hClientHandle, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanHostedNetworkSetSecondaryKey)(HANDLE hClientHandle, DWORD dwKeyLength, PUCHAR pucKeyData, BOOL bIsPassPhrase, BOOL bPersistent, PWLAN_HOSTED_NETWORK_REASON pFailReason, PVOID pvReserved);
typedef DWORD(__stdcall* WlanRegisterVirtualStationNotification)(HANDLE hClientHandle, BOOL bRegister, PVOID pReserved);
typedef DWORD(__stdcall* WFDOpenHandle)(DWORD dwClientVersion, PDWORD pdwNegotiatedVersion, PHANDLE phClientHandle);
typedef DWORD(__stdcall* WFDCloseHandle)(HANDLE hClientHandle);
typedef DWORD(__stdcall* WFDStartOpenSession)(HANDLE hClientHandle, PDOT11_MAC_ADDRESS pDeviceAddress, PVOID pvContext, WFD_OPEN_SESSION_COMPLETE_CALLBACK pfnCallback, PHANDLE phSessionHandle);
typedef DWORD(__stdcall* WFDCancelOpenSession)(HANDLE hSessionHandle);
typedef DWORD(__stdcall* WFDCloseSession)(HANDLE hSessionHandle);
typedef DWORD(__stdcall* WFDUpdateDeviceVisibility)(PDOT11_MAC_ADDRESS pDeviceAddress);
typedef HRESULT(__stdcall* WMCheckURLExtension)(LPCWSTR pwszURL);
typedef HRESULT(__stdcall* WMCheckURLScheme)(LPCWSTR pwszURLScheme);
typedef BOOL(__stdcall* WofShouldCompressBinaries)(LPCWSTR Volume, PULONG Algorithm);
typedef HRESULT(__stdcall* WofGetDriverVersion)(HANDLE FileOrVolumeHandle, ULONG Provider, PULONG WofVersion);
typedef HRESULT(__stdcall* WofSetFileDataLocation)(HANDLE FileHandle, ULONG Provider, PVOID ExternalFileInfo, ULONG Length);
typedef HRESULT(__stdcall* WofIsExternalFile)(LPCWSTR FilePath, PBOOL IsExternalFile, PULONG Provider, PVOID ExternalFileInfo, PULONG BufferLength);
typedef HRESULT(__stdcall* WofEnumEntries)(PCWSTR VolumeName, ULONG Provider, WofEnumEntryProc EnumProc, PVOID UserData);
typedef HRESULT(__stdcall* WofWimAddEntry)(PCWSTR VolumeName, PCWSTR WimPath, DWORD WimType, DWORD WimIndex, PLARGE_INTEGER DataSourceId);
typedef HRESULT(__stdcall* WofWimEnumFiles)(PCWSTR VolumeName, LARGE_INTEGER DataSourceId, WofEnumFilesProc EnumProc, PVOID UserData);
typedef HRESULT(__stdcall* WofWimSuspendEntry)(PCWSTR VolumeName, LARGE_INTEGER DataSourceId);
typedef HRESULT(__stdcall* WofWimRemoveEntry)(PCWSTR VolumeName, LARGE_INTEGER DataSourceId);
typedef HRESULT(__stdcall* WofWimUpdateEntry)(PCWSTR VolumeName, LARGE_INTEGER DataSourceId, PCWSTR NewWimPath);
typedef HRESULT(__stdcall* WofFileEnumFiles)(PCWSTR VolumeName, ULONG Algorithm, WofEnumFilesProc EnumProc, PVOID UserData);
typedef BOOL(__stdcall* Wow64RevertWow64FsRedirection)(PVOID OlValue);
typedef BOOL(__stdcall* IsWow64Process)(HANDLE hProcess, PBOOL Wow64Process);
typedef UINT(__stdcall* GetSystemWow64DirectoryA)(LPSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetSystemWow64DirectoryW)(LPWSTR lpBuffer, UINT uSize);
typedef UINT(__stdcall* GetSystemWow64Directory2A)(LPSTR lpBuffer, UINT uSize, WORD ImageFileMachineType);
typedef UINT(__stdcall* GetSystemWow64Directory2W)(LPWSTR lpBuffer, UINT uSize, WORD ImageFileMachineType);
typedef int(__stdcall* WSCEnumProtocols)(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength, LPINT lpErrno);
typedef int(__stdcall* WSCEnumProtocols32)(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength, LPINT lpErrno);
typedef int(__stdcall* WSCDeinstallProvider)(LPGUID lpProviderId, LPINT lpErrno);
typedef int(__stdcall* WSCDeinstallProvider32)(LPGUID lpProviderId, LPINT lpErrno);
typedef int(__stdcall* WSCSetProviderInfo)(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t InfoSize, DWORD Flags, LPINT lpErrno);
typedef int(__stdcall* WSCSetProviderInfo32)(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t InfoSize, DWORD Flags, LPINT lpErrno);
typedef INT(__stdcall* WSCEnumNameSpaceProviders32)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOW lpnspBuffer);
typedef INT(__stdcall* WSCEnumNameSpaceProvidersEx32)(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXW lpnspBuffer);
typedef INT(__stdcall* WSCInstallNameSpace)(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId);
typedef INT(__stdcall* WSCUnInstallNameSpace)(LPGUID lpProviderId);
typedef INT(__stdcall* WSCInstallNameSpaceEx)(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId, LPBLOB lpProviderSpecific);
typedef INT(__stdcall* WSCInstallNameSpaceEx32)(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId, LPBLOB lpProviderSpecific);
typedef INT(__stdcall* WSCEnableNSProvider)(LPGUID lpProviderId, BOOL fEnable);
typedef INT(__stdcall* WSCEnableNSProvider32)(LPGUID lpProviderId, BOOL fEnable);
typedef int(__stdcall* WSCInstallProviderAndChains64_32)(LPGUID lpProviderId, LPWSTR lpszProviderDllPath, LPWSTR lpszProviderDllPath32, LPWSTR lpszLspName, DWORD dwServiceFlags, LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPDWORD lpdwCatalogEntryId, LPINT lpErrno);
typedef INT(__stdcall* WSAProviderCompleteAsyncCall)(HANDLE hAsyncCall, INT iRetCode);
typedef INT(__stdcall* GetAddrInfoExCancel)(LPHANDLE lpHandle);
typedef INT(__stdcall* GetAddrInfoExOverlappedResult)(LPOVERLAPPED lpOverlapped);
typedef void(__stdcall* freeaddrinfo)(PADDRINFOA pAddrInfo);
typedef void(__stdcall* FreeAddrInfoW)(PADDRINFOW pAddrInfo);
typedef void(__stdcall* FreeAddrInfoEx)(PADDRINFOEXA pAddrInfoEx);
typedef void(__stdcall* FreeAddrInfoExW)(PADDRINFOEXW pAddrInfoEx);
typedef INT(__stdcall* InetPtonW)(INT Family, PCWSTR pszAddrString, PVOID pAddrBuf);
typedef INT(__stdcall* WSASetIPUserMtu)(SOCKET Socket, DWORD Mtu);
typedef INT(__stdcall* WSASetFailConnectOnIcmpError)(SOCKET Socket, DWORD Enabled);
typedef INT(__stdcall* WSASetUdpSendMessageSize)(SOCKET Socket, DWORD MsgSize);
typedef INT(__stdcall* WSASetUdpRecvMaxCoalescedSize)(SOCKET Socket, DWORD MaxCoalescedMsgSize);
typedef HRESULT(__stdcall* DeregisterOnlineBackupFromWindowsServerBackup)(GUID guidSnapinId);
typedef HRESULT(__stdcall* RemoveDeveloperLicense)(HWND hwndParent);
typedef BOOL(__stdcall* WTSStopRemoteControlSession)(ULONG LogonId);
typedef BOOL(__stdcall* WTSStartRemoteControlSessionW)(LPWSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers);
typedef BOOL(__stdcall* WTSStartRemoteControlSessionA)(LPSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers);
typedef BOOL(__stdcall* WTSConnectSessionA)(ULONG LogonId, ULONG TargetLogonId, PSTR pPassword, BOOL bWait);
typedef BOOL(__stdcall* WTSConnectSessionW)(ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword, BOOL bWait);
typedef HANDLE(__stdcall* WTSOpenServerW)(LPWSTR pServerName);
typedef HANDLE(__stdcall* WTSOpenServerA)(LPSTR pServerName);
typedef HANDLE(__stdcall* WTSOpenServerExW)(LPWSTR pServerName);
typedef HANDLE(__stdcall* WTSOpenServerExA)(LPSTR pServerName);
typedef void(__stdcall* WTSCloseServer)(HANDLE hServer);
typedef BOOL(__stdcall* WTSTerminateProcess)(HANDLE hServer, DWORD ProcessId, DWORD ExitCode);
typedef BOOL(__stdcall* WTSSetUserConfigW)(LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer, DWORD DataLength);
typedef BOOL(__stdcall* WTSSetUserConfigA)(LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer, DWORD DataLength);
typedef BOOL(__stdcall* WTSDisconnectSession)(HANDLE hServer, DWORD SessionId, BOOL bWait);
typedef BOOL(__stdcall* WTSLogoffSession)(HANDLE hServer, DWORD SessionId, BOOL bWait);
typedef BOOL(__stdcall* WTSShutdownSystem)(HANDLE hServer, DWORD ShutdownFlag);
typedef HANDLE(__stdcall* WTSVirtualChannelOpen)(HANDLE hServer, DWORD SessionId, LPSTR pVirtualName);
typedef HANDLE(__stdcall* WTSVirtualChannelOpenEx)(DWORD SessionId, LPSTR pVirtualName, DWORD flags);
typedef BOOL(__stdcall* WTSVirtualChannelClose)(HANDLE hChannelHandle);
typedef BOOL(__stdcall* WTSVirtualChannelRead)(HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer, ULONG BufferSize, PULONG pBytesRead);
typedef BOOL(__stdcall* WTSVirtualChannelWrite)(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length, PULONG pBytesWritten);
typedef BOOL(__stdcall* WTSVirtualChannelPurgeInput)(HANDLE hChannelHandle);
typedef BOOL(__stdcall* WTSVirtualChannelPurgeOutput)(HANDLE hChannelHandle);
typedef void(__stdcall* WTSFreeMemory)(PVOID pMemory);
typedef BOOL(__stdcall* WTSRegisterSessionNotification)(HWND hWnd, DWORD dwFlags);
typedef BOOL(__stdcall* WTSUnRegisterSessionNotification)(HWND hWnd);
typedef BOOL(__stdcall* WTSRegisterSessionNotificationEx)(HANDLE hServer, HWND hWnd, DWORD dwFlags);
typedef BOOL(__stdcall* WTSUnRegisterSessionNotificationEx)(HANDLE hServer, HWND hWnd);
typedef BOOL(__stdcall* WTSQueryUserToken)(ULONG SessionId, PHANDLE phToken);
typedef BOOL(__stdcall* WTSFreeMemoryExW)(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory, ULONG NumberOfEntries);
typedef BOOL(__stdcall* WTSFreeMemoryExA)(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory, ULONG NumberOfEntries);
typedef BOOL(__stdcall* WTSQueryListenerConfigW)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPWSTR pListenerName, PWTSLISTENERCONFIGW pBuffer);
typedef BOOL(__stdcall* WTSQueryListenerConfigA)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer);
typedef BOOL(__stdcall* WTSCreateListenerW)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPWSTR pListenerName, PWTSLISTENERCONFIGW pBuffer, DWORD flag);
typedef BOOL(__stdcall* WTSCreateListenerA)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer, DWORD flag);
typedef BOOL(__stdcall* WTSSetListenerSecurityW)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPWSTR pListenerName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef BOOL(__stdcall* WTSSetListenerSecurityA)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
typedef BOOL(__stdcall* WTSGetListenerSecurityW)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPWSTR pListenerName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* WTSGetListenerSecurityA)(HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
typedef BOOL(__stdcall* WTSEnableChildSessions)(BOOL bEnable);
typedef BOOL(__stdcall* WTSIsChildSessionsEnabled)(PBOOL pbEnabled);
typedef BOOL(__stdcall* WTSGetChildSessionId)(PULONG pSessionId);
typedef HRESULT(__stdcall* InitializeXamlDiagnosticsEx)(LPCWSTR endPointName, DWORD pid, LPCWSTR wszDllXamlDiagnostics, LPCWSTR wszTAPDllName, CLSID tapClsid, LPCWSTR wszInitializationData);
typedef void(__stdcall* XInputEnable)(BOOL enable);
typedef DWORD(__stdcall* XInputGetKeystroke)(DWORD dwUserIndex, DWORD dwReserved, PXINPUT_KEYSTROKE pKeystroke);