system.h

#pragma once
// @todo: requires "object.h"
// @todo: requires "process.h"; used: "_PROCESS_ENERGY_VALUES"
// @todo: requires "kernel.h"; used: "_KAFFINITY_EX"
// @todo: requires "wnf.h"; used: "_WNF_STATE_NAME"

#pragma pack(push, 8)
using SYSTEM_INFORMATION_CLASS = enum _SYSTEM_INFORMATION_CLASS
{
	SystemBasicInformation = 0,
	SystemProcessorInformation = 1,
	SystemPerformanceInformation = 2,
	SystemTimeOfDayInformation = 3,
	SystemPathInformation = 4,
	SystemProcessInformation = 5,
	SystemCallCountInformation = 6,
	SystemDeviceInformation = 7,
	SystemProcessorPerformanceInformation = 8,
	SystemFlagsInformation = 9,
	SystemCallTimeInformation = 10,
	SystemModuleInformation = 11,
	SystemLocksInformation = 12,
	SystemStackTraceInformation = 13,
	SystemPagedPoolInformation = 14,
	SystemNonPagedPoolInformation = 15,
	SystemHandleInformation = 16,
	SystemObjectInformation = 17,
	SystemPageFileInformation = 18,
	SystemVdmInstemulInformation = 19,
	SystemVdmBopInformation = 20,
	SystemFileCacheInformation = 21,
	SystemPoolTagInformation = 22,
	SystemInterruptInformation = 23,
	SystemDpcBehaviorInformation = 24,
	SystemFullMemoryInformation = 25,
	SystemLoadGdiDriverInformation = 26,
	SystemUnloadGdiDriverInformation = 27,
	SystemTimeAdjustmentInformation = 28,
	SystemSummaryMemoryInformation = 29,
	SystemMirrorMemoryInformation = 30,
#if Q_NT_VERSION >= Q_NT_VISTA
	SystemPerformanceTraceInformation = 31,
#endif
	SystemObsolete0 = 32,
	SystemExceptionInformation = 33,
	SystemCrashDumpStateInformation = 34,
	SystemKernelDebuggerInformation = 35,
	SystemContextSwitchInformation = 36,
	SystemRegistryQuotaInformation = 37,
	SystemExtendServiceTableInformation = 38,
	SystemPrioritySeperation = 39,
	SystemVerifierAddDriverInformation = 40,
	SystemVerifierRemoveDriverInformation = 41,
	SystemProcessorIdleInformation = 42,
	SystemLegacyDriverInformation = 43,
	SystemCurrentTimeZoneInformation = 44,
	SystemLookasideInformation = 45,
	SystemTimeSlipNotification = 46,
	SystemSessionCreate = 47,
	SystemSessionDetach = 48,
	SystemSessionInformation = 49,
	SystemRangeStartInformation = 50,
	SystemVerifierInformation = 51,
	SystemVerifierThunkExtend = 52,
	SystemSessionProcessInformation = 53,
	SystemLoadGdiDriverInSystemSpace = 54,
	SystemNumaProcessorMap = 55,
	SystemPrefetcherInformation = 56,
	SystemExtendedProcessInformation = 57,
	SystemRecommendedSharedDataAlignment = 58,
	SystemComPlusPackage = 59,
	SystemNumaAvailableMemory = 60,
	SystemProcessorPowerInformation = 61,
	SystemEmulationBasicInformation = 62,
	SystemEmulationProcessorInformation = 63,
	SystemExtendedHandleInformation = 64,
	SystemLostDelayedWriteInformation = 65,
	SystemBigPoolInformation = 66,
	SystemSessionPoolTagInformation = 67,
	SystemSessionMappedViewInformation = 68,
	SystemHotpatchInformation = 69,
	SystemObjectSecurityMode = 70,
	SystemWatchdogTimerHandler = 71,
	SystemWatchdogTimerInformation = 72,
	SystemLogicalProcessorInformation = 73,
	SystemWow64SharedInformationObsolete = 74,
	SystemRegisterFirmwareTableInformationHandler = 75,
	SystemFirmwareTableInformation = 76,
#if Q_NT_VERSION >= Q_NT_VISTA
	SystemModuleInformationEx = 77,
	SystemVerifierTriageInformation = 78,
	SystemSuperfetchInformation = 79,
	SystemMemoryListInformation = 80,
	SystemFileCacheInformationEx = 81, // @todo: since Q_NT_WS03_SP1/2/3/4 idk
	SystemThreadPriorityClientIdInformation = 82,
	SystemProcessorIdleCycleTimeInformation = 83,
	SystemVerifierCancellationInformation = 84,
	SystemProcessorPowerInformationEx = 85,
	SystemRefTraceInformation = 86,
	SystemSpecialPoolInformation = 87,
	SystemProcessIdInformation = 88,
	SystemErrorPortInformation = 89,
	SystemBootEnvironmentInformation = 90,
	SystemHypervisorInformation = 91,
	SystemVerifierInformationEx = 92,
	SystemTimeZoneInformation = 93,
	SystemImageFileExecutionOptionsInformation = 94,
	SystemCoverageInformation = 95,
	SystemPrefetchPatchInformation = 96,
	SystemVerifierFaultsInformation = 97,
	SystemSystemPartitionInformation = 98,
	SystemSystemDiskInformation = 99,
	SystemProcessorPerformanceDistribution = 100,
	SystemNumaProximityNodeInformation = 101,
	SystemDynamicTimeZoneInformation = 102,
	SystemCodeIntegrityInformation = 103,
	SystemProcessorMicrocodeUpdateInformation = 104,
#endif
#if Q_NT_VERSION >= Q_NT_VISTA_SP1
	SystemProcessorBrandString = 105,
	SystemVirtualAddressInformation = 106,
#endif
#if Q_NT_VERSION >= Q_NT_WIN7
	SystemLogicalProcessorAndGroupInformation = 107,
	SystemProcessorCycleTimeInformation = 108,
	SystemStoreInformation = 109,
	SystemRegistryAppendString = 110,
	SystemAitSamplingValue = 111,
	SystemVhdBootInformation = 112,
	SystemCpuQuotaInformation = 113,
#if Q_NT_VERSION >= Q_NT_WIN8
	SystemNativeBasicInformation = 114,
	SystemErrorPortTimeouts = 115,
#endif
	SystemLowPriorityIoInformation = 116,
	SystemBootEntropyInformation = 117,
	SystemVerifierCountersInformation = 118,
	SystemPagedPoolInformationEx = 119,
	SystemSystemPtesInformationEx = 120,
	SystemNodeDistanceInformation = 121,
	SystemAcpiAuditInformation = 122,
	SystemBasicPerformanceInformation = 123,
#endif
#if Q_NT_VERSION >= Q_NT_WIN7_SP1
	SystemQueryPerformanceCounterInformation = 124,
#endif
#if Q_NT_VERSION >= Q_NT_WIN8
	SystemSessionBigPoolInformation = 125,
	SystemBootGraphicsInformation = 126,
	SystemScrubPhysicalMemoryInformation = 127,
	SystemBadPageInformation = 128,
	SystemProcessorProfileControlArea = 129,
	SystemCombinePhysicalMemoryInformation = 130,
	SystemEntropyInterruptTimingInformation = 131,
	SystemConsoleInformation = 132,
	SystemPlatformBinaryInformation = 133,
#if Q_NT_VERSION >= Q_NT_WINBLUE
	SystemPolicyInformation = 134,
#else
	SystemThrottleNotificationInformation = 134,
#endif
	SystemHypervisorProcessorCountInformation = 135,
	SystemDeviceDataInformation = 136,
	SystemDeviceDataEnumerationInformation = 137,
	SystemMemoryTopologyInformation = 138,
	SystemMemoryChannelInformation = 139,
	SystemBootLogoInformation = 140,
	SystemProcessorPerformanceInformationEx = 141,
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	SystemCriticalProcessErrorLogInformation = 142,
#endif
	SystemSecureBootPolicyInformation = 143,
	SystemPageFileInformationEx = 144,
	SystemSecureBootInformation = 145,
	SystemEntropyInterruptTimingRawInformation = 146,
	SystemPortableWorkspaceEfiLauncherInformation = 147,
#endif
#if Q_NT_VERSION >= Q_NT_WINBLUE
	SystemFullProcessInformation = 148,
	SystemKernelDebuggerInformationEx = 149,
	SystemBootMetadataInformation = 150,
	SystemSoftRebootInformation = 151,
	SystemElamCertificateInformation = 152,
	SystemOfflineDumpConfigInformation = 153,
	SystemProcessorFeaturesInformation = 154,
	SystemRegistryReconciliationInformation = 155,
	SystemEdidInformation = 156,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10
	SystemManufacturingInformation = 157,
	SystemEnergyEstimationConfigInformation = 158,
	SystemHypervisorDetailInformation = 159,
	SystemProcessorCycleStatsInformation = 160,
	SystemVmGenerationCountInformation = 161,
	SystemTrustedPlatformModuleInformation = 162,
	SystemKernelDebuggerFlags = 163,
	SystemCodeIntegrityPolicyInformation = 164,
	SystemIsolatedUserModeInformation = 165,
	SystemHardwareSecurityTestInterfaceResultsInformation = 166,
	SystemSingleModuleInformation = 167,
	SystemAllowedCpuSetsInformation = 168,
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
	SystemVsmProtectionInformation = 169,
#else
	SystemDmaProtectionInformation = 169,
#endif
	SystemInterruptCpuSetsInformation = 170,
	SystemSecureBootPolicyFullInformation = 171,
	SystemCodeIntegrityPolicyFullInformation = 172,
	SystemAffinitizedInterruptProcessorInformation = 173,
	SystemRootSiloInformation = 174,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_TH2
	SystemCpuSetInformation = 175,
	SystemCpuSetTagInformation = 176,
	SystemWin32WerStartCallout = 177,
	SystemSecureKernelProfileInformation = 178,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	SystemCodeIntegrityPlatformManifestInformation = 179,
	SystemInterruptSteeringInformation = 180,
	SystemSupportedProcessorArchitectures = 181,
	SystemMemoryUsageInformation = 182,
	SystemCodeIntegrityCertificateInformation = 183,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS2
	SystemPhysicalMemoryInformation = 184,
	SystemControlFlowTransition = 185,
	SystemKernelDebuggingAllowed = 186,
	SystemActivityModerationExeState = 187,
	SystemActivityModerationUserSettings = 188,
	SystemCodeIntegrityPoliciesFullInformation = 189,
	SystemCodeIntegrityUnlockInformation = 190,
	SystemIntegrityQuotaInformation = 191,
	SystemFlushInformation = 192,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS3
	SystemProcessorIdleMaskInformation = 193,
	SystemSecureDumpEncryptionInformation = 194,
	SystemWriteConstraintInformation = 195,
	SystemKernelVaShadowInformation = 196,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
	SystemHypervisorSharedPageInformation = 197,
	SystemFirmwareBootPerformanceInformation = 198,
	SystemCodeIntegrityVerificationInformation = 199,
	SystemFirmwarePartitionInformation = 200,
	SystemSpeculationControlInformation = 201,
	SystemDmaGuardPolicyInformation = 202,
	SystemEnclaveLaunchControlInformation = 203,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	SystemWorkloadAllowedCpuSetsInformation = 204,
	SystemCodeIntegrityUnlockModeInformation = 205,
	SystemLeapSecondInformation = 206,
	SystemFlags2Information = 207,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_19H1
	SystemSecurityModelInformation = 208,
	SystemCodeIntegritySyntheticCacheInformation = 209,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_20H1
	SystemFeatureConfigurationInformation = 210,
	SystemFeatureConfigurationSectionInformation = 211,
	SystemFeatureUsageSubscriptionInformation = 212,
	SystemSecureSpeculationControlInformation = 213,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_20H2
	SystemSpacesBootInformation = 214,
	SystemFwRamdiskInformation = 215,
	SystemWheaIpmiHardwareInformation = 216,
	SystemDifSetRuleClassInformation = 217,
	SystemDifClearRuleClassInformation = 218,
	SystemDifApplyPluginVerificationOnDriver = 219,
	SystemDifRemovePluginVerificationOnDriver = 220,
	SystemShadowStackInformation = 221,
	SystemBuildVersionInformation = 222,
	SystemPoolLimitInformation = 223,
	SystemCodeIntegrityAddDynamicStore = 224,
	SystemCodeIntegrityClearDynamicStores = 225,
	SystemPoolZeroingInformation = 227,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11
	SystemDpcWatchdogInformation = 228,
	SystemDpcWatchdogInformation2 = 229,
	SystemSupportedProcessorArchitectures2 = 230,
	SystemSingleProcessorRelationshipInformation = 231,
	SystemXfgCheckFailureInformation = 232,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_22H2
	SystemIommuStateInformation = 233,
	SystemHypervisorMinrootInformation = 234,
	SystemHypervisorBootPagesInformation = 235,
	SystemPointerAuthInformation = 236,
	SystemSecureKernelDebuggerInformation = 237,
	SystemOriginalImageFeatureInformation = 238,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	SystemMemoryNumaInformation = 239,
	SystemMemoryNumaPerformanceInformation = 240,
	SystemCodeIntegritySignedPoliciesFullInformation = 241,
	SystemSecureCoreInformation = 242,
	SystemTrustedAppsRuntimeInformation = 243,
	SystemBadPageInformationEx = 244,
	SystemResourceDeadlockTimeout = 245,
	SystemBreakOnContextUnwindFailureInformation = 246, // requires 'SeDebugPrivilege'
	SystemOslRamdiskInformation = 247,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_25H2
	SystemCodeIntegrityPolicyManagementInformation = 248,
	SystemMemoryNumaCacheInformation = 249,
	SystemProcessorFeaturesBitMapInformation = 250,
#endif
	MaxSystemInfoClass
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_BASIC_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t Reserved; // 0x00
	std::uint32_t TimerResolution; // 0x04
	std::uint32_t PageSize; // 0x08
	std::uint32_t NumberOfPhysicalPages; // 0x0C
	std::uint32_t LowestPhysicalPageNumber; // 0x10
	std::uint32_t HighestPhysicalPageNumber; // 0x14
	std::uint32_t AllocationGranularity; // 0x18
	BitnessType_t<std::uintptr_t> MinimumUserModeAddress; // 0x1C / 0x20
	BitnessType_t<std::uintptr_t> MaximumUserModeAddress; // 0x20 / 0x28
	BitnessType_t<KAFFINITY> ActiveProcessorsAffinityMask; // 0x24 / 0x30
	std::int8_t NumberOfProcessors; // 0x28 / 0x38
};
_Q_NT_BIT_ASSERT(SYSTEM_BASIC_INFORMATION, 0x2C, 0x40);

// @todo: find better place?
// software feature bits
#define KF_V86_VIS		0x00000001
#define KF_RDTSC		0x00000002
#define KF_CR4			0x00000004
#define KF_CMOV			0x00000008
#define KF_GLOBAL_PAGE	0x00000010
#define KF_LARGE_PAGE	0x00000020
#define KF_MTRR			0x00000040
#define KF_CMPXCHG8B	0x00000080
#define KF_MMX			0x00000100
#define KF_WORKING_PTE	0x00000200
#define KF_PAT			0x00000400
#define KF_FXSR			0x00000800
#define KF_FAST_SYSCALL	0x00001000
#define KF_XMMI			0x00002000
#define KF_3DNOW		0x00004000
#define KF_AMDK6MTRR	0x00008000
#define KF_XMMI64		0x00010000
#define KF_DTS			0x00020000
#define KF_SMT			0x00040000
#define KF_NOEXECUTE	0x20000000

// @todo: find better place?
// hardware feature bits
#define HF_FPU			0x00000001 // FPU is on chip
#define HF_VME			0x00000002 // virtual 8086 mode enhancement
#define HF_DE			0x00000004 // debugging extension
#define HF_PSE			0x00000008 // page size extension
#define HF_TSC			0x00000010 // time stamp counter
#define HF_MSR			0x00000020 // rdmsr and wrmsr support
#define HF_PAE			0x00000040 // physical address extension
#define HF_MCE			0x00000080 // machine check exception
#define HF_CXS			0x00000100 // cmpxchg8b instruction supported
#define HF_APIC			0x00000200 // APIC on chip
#define HF_UNUSED0		0x00000400 // unused bit
#define HF_SYSCALL		0x00000800 // fast system call
#define HF_MTRR			0x00001000 // memory type range registers
#define HF_PGE			0x00002000 // global page TB support
#define HF_MCA			0x00004000 // machine check architecture
#define HF_CMOV			0x00008000 // cmov instruction supported
#define HF_PAT			0x00010000 // physical attributes table
#define HF_PSE2			0x00020000 // page size extension (2)
#define HF_PSN			0x00040000 // processor serial number
#define HF_CFLUSH		0x00080000 // cache line flush
#define HF_UNUSED1		0x00100000 // unused bit
#define HF_DS			0x00200000 // debug store
#define HF_ACPI_THMON	0x00400000 // ACPI thermal monitor
#define HF_MMX			0x00800000 // MMX technology supported
#define HF_FXSR			0x01000000 // fxsr instruction supported
#define HF_XMMI			0x02000000 // xmm (SSE) registers supported
#define HF_XMMI64		0x04000000 // xmm (SSE2) registers supported
#define HF_SS			0x08000000 // self snoop
#define HF_SMT			0x10000000 // symmetric multithreading
#define HF_THERMMON		0x20000000 // thermal monitor
#define HF_UNUSED2		0x40000000 // unused bit
#define HF_PBE			0x80000000 // pending break enable

// @todo: find better place?
// extended hardware feature bits
#define XHF_NOEXECUTE   0x00100000 // no execute protection
#define XHF_MMX_EXT     0x00400000 // MMX extensions
#define XHF_FFXSR       0x02000000 // fast floating save/restore
#define XHF_LONGMODE    0x20000000 // long mode supported
#define XHF_3DNOW_EXT	0x40000000 // 3DNOW extensions
#define XHF_3DNOW		0x80000000 // 3DNOW supported

struct SYSTEM_PROCESSOR_INFORMATION
{
	std::uint16_t ProcessorArchitecture; // 0x0
	std::uint16_t ProcessorLevel; // 0x2
	std::uint16_t ProcessorRevision; // 0x4
#if Q_NT_VERSION >= Q_NT_WIN8
	std::uint16_t MaximumProcessors; // 0x6
#else
	std::uint16_t Reserved; // 0x6
#endif
	std::uint32_t ProcessorFeatureBits; // 0x8 // KF_*
};
static_assert(sizeof(SYSTEM_PROCESSOR_INFORMATION) == 0xC);

struct SYSTEM_PERFORMANCE_INFORMATION
{
	LARGE_INTEGER IdleProcessTime; // 0x0000
	LARGE_INTEGER IoReadTransferCount; // 0x0008
	LARGE_INTEGER IoWriteTransferCount; // 0x0010
	LARGE_INTEGER IoOtherTransferCount; // 0x0018
	std::uint32_t IoReadOperationCount; // 0x0020
	std::uint32_t IoWriteOperationCount; // 0x0024
	std::uint32_t IoOtherOperationCount; // 0x0028
	std::uint32_t AvailablePages; // 0x002C
	std::uint32_t CommittedPages; // 0x0030
	std::uint32_t CommitLimit; // 0x0034
	std::uint32_t PeakCommitment; // 0x0038
	std::uint32_t PageFaultCount; // 0x003C
	std::uint32_t CopyOnWriteCount; // 0x0040
	std::uint32_t TransitionCount; // 0x0044
	std::uint32_t CacheTransitionCount; // 0x0048
	std::uint32_t DemandZeroCount; // 0x004C
	std::uint32_t PageReadCount; // 0x0050
	std::uint32_t PageReadIoCount; // 0x0054
	std::uint32_t CacheReadCount; // 0x0058
	std::uint32_t CacheIoCount; // 0x005C
	std::uint32_t DirtyPagesWriteCount; // 0x0060
	std::uint32_t DirtyWriteIoCount; // 0x0064
	std::uint32_t MappedPagesWriteCount; // 0x0068
	std::uint32_t MappedWriteIoCount; // 0x006C
	std::uint32_t PagedPoolPages; // 0x0070
	std::uint32_t NonPagedPoolPages; // 0x0074
	std::uint32_t PagedPoolAllocs; // 0x0078
	std::uint32_t PagedPoolFrees; // 0x007C
	std::uint32_t NonPagedPoolAllocs; // 0x0080
	std::uint32_t NonPagedPoolFrees; // 0x0084
	std::uint32_t FreeSystemPtes; // 0x0088
	std::uint32_t ResidentSystemCodePage; // 0x008C
	std::uint32_t TotalSystemDriverPages; // 0x0090
	std::uint32_t TotalSystemCodePages; // 0x0094
	std::uint32_t NonPagedPoolLookasideHits; // 0x0098
	std::uint32_t PagedPoolLookasideHits; // 0x009C
	std::uint32_t AvailablePagedPoolPages; // 0x00A0
	std::uint32_t ResidentSystemCachePage; // 0x00A4
	std::uint32_t ResidentPagedPoolPage; // 0x00A8
	std::uint32_t ResidentSystemDriverPage; // 0x00AC
	std::uint32_t CcFastReadNoWait; // 0x00B0
	std::uint32_t CcFastReadWait; // 0x00B4
	std::uint32_t CcFastReadResourceMiss; // 0x00B8
	std::uint32_t CcFastReadNotPossible; // 0x00BC
	std::uint32_t CcFastMdlReadNoWait; // 0x00C0
	std::uint32_t CcFastMdlReadWait; // 0x00C4
	std::uint32_t CcFastMdlReadResourceMiss; // 0x00C8
	std::uint32_t CcFastMdlReadNotPossible; // 0x00CC
	std::uint32_t CcMapDataNoWait; // 0x00D0
	std::uint32_t CcMapDataWait; // 0x00D4
	std::uint32_t CcMapDataNoWaitMiss; // 0x00D8
	std::uint32_t CcMapDataWaitMiss; // 0x00DC
	std::uint32_t CcPinMappedDataCount; // 0x00E0
	std::uint32_t CcPinReadNoWait; // 0x00E4
	std::uint32_t CcPinReadWait; // 0x00E8
	std::uint32_t CcPinReadNoWaitMiss; // 0x00EC
	std::uint32_t CcPinReadWaitMiss; // 0x00F0
	std::uint32_t CcCopyReadNoWait; // 0x00F4
	std::uint32_t CcCopyReadWait; // 0x00F8
	std::uint32_t CcCopyReadNoWaitMiss; // 0x00FC
	std::uint32_t CcCopyReadWaitMiss; // 0x0100
	std::uint32_t CcMdlReadNoWait; // 0x0104
	std::uint32_t CcMdlReadWait; // 0x0108
	std::uint32_t CcMdlReadNoWaitMiss; // 0x010C
	std::uint32_t CcMdlReadWaitMiss; // 0x0110
	std::uint32_t CcReadAheadIos; // 0x0114
	std::uint32_t CcLazyWriteIos; // 0x0118
	std::uint32_t CcLazyWritePages; // 0x011C
	std::uint32_t CcDataFlushes; // 0x0120
	std::uint32_t CcDataPages; // 0x0124
	std::uint32_t ContextSwitches; // 0x0128
	std::uint32_t FirstLevelTbFills; // 0x012C
	std::uint32_t SecondLevelTbFills; // 0x0130
	std::uint32_t SystemCalls; // 0x0134
#if Q_NT_VERSION >= Q_NT_WIN7
	std::uint64_t CcTotalDirtyPages; // 0x0138
	std::uint64_t CcDirtyPageThreshold; // 0x0140
#endif
#if Q_NT_VERSION >= Q_NT_WIN8
	std::int64_t ResidentAvailablePages; // 0x0148
	std::uint64_t SharedCommittedPages; // 0x0150
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	std::uint64_t MdlPagesAllocated; // 0x0158
	std::uint64_t PfnDatabaseCommittedPages; // 0x0160
	std::uint64_t SystemPageTableCommittedPages; // 0x0168
	std::uint64_t ContiguousPagesAllocated; // 0x0170
#endif
};
static_assert(sizeof(SYSTEM_PERFORMANCE_INFORMATION) == 0x178);

struct SYSTEM_TIMEOFDAY_INFORMATION
{
	LARGE_INTEGER BootTime; // 0x00
	LARGE_INTEGER CurrentTime; // 0x08
	LARGE_INTEGER TimeZoneBias; // 0x10
	std::uint32_t TimeZoneId; // 0x18
	std::uint32_t Reserved; // 0x1C
	std::uint64_t BootTimeBias; // 0x20
	std::uint64_t SleepTimeBias; // 0x28
};
static_assert(sizeof(SYSTEM_TIMEOFDAY_INFORMATION) == 0x30);

_Q_NT_BIT_TEMPLATE struct SYSTEM_THREAD_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	LARGE_INTEGER KernelTime; // 0x00
	LARGE_INTEGER UserTime; // 0x08
	LARGE_INTEGER CreateTime; // 0x10
	std::uint32_t WaitTime; // 0x18
	BitnessType_t<void*> StartAddress; // 0x1C / 0x20
	CLIENT_ID<nBitness> ClientId; // 0x20 / 0x28
	KPRIORITY Priority; // 0x28 / 0x38
	KPRIORITY BasePriority; // 0x2C / 0x3C
	std::uint32_t ContextSwitches; // 0x30 / 0x40
	KTHREAD_STATE ThreadState; // 0x34 / 0x44
	KWAIT_REASON WaitReason; // 0x38 / 0x48
};
_Q_NT_BIT_ASSERT(SYSTEM_THREAD_INFORMATION, 0x40, 0x50);

_Q_NT_BIT_TEMPLATE struct SYSTEM_EXTENDED_THREAD_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	SYSTEM_THREAD_INFORMATION<nBitness> ThreadInfo; // 0x00
	BitnessType_t<std::uintptr_t> StackBase; // 0x40 / 0x50
	BitnessType_t<std::uintptr_t> StackLimit; // 0x44 / 0x58
	BitnessType_t<void*> Win32StartAddress; // 0x48 / 0x60
#if Q_NT_VERSION >= Q_NT_VISTA
	BitnessType_t<void*> TebBase; // 0x4C / 0x68
#else
	BitnessType_t<std::uintptr_t> Reserved1; // 0x4C / 0x68
#endif
	BitnessType_t<std::uintptr_t> Reserved2; // 0x50 / 0x70
	BitnessType_t<std::uintptr_t> Reserved3; // 0x54 / 0x78
	BitnessType_t<std::uintptr_t> Reserved4; // 0x58 / 0x80
};
_Q_NT_BIT_ASSERT(SYSTEM_EXTENDED_THREAD_INFORMATION, 0x60, 0x88);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PROCESS_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t NextEntryOffset; // 0x00
	std::uint32_t NumberOfThreads; // 0x04
#if Q_NT_VERSION >= Q_NT_VISTA
	LARGE_INTEGER WorkingSetPrivateSize; // 0x08
#else
	LARGE_INTEGER SpareLi1; // 0x08
#endif
#if Q_NT_VERSION >= Q_NT_WIN7
	std::uint32_t HardFaultCount; // 0x10
	std::uint32_t NumberOfThreadsHighWatermark; // 0x14
	LARGE_INTEGER CycleTime; // 0x18
#else
	LARGE_INTEGER SpareLi2; // 0x10
	LARGE_INTEGER SpareLi3; // 0x18
#endif
	LARGE_INTEGER CreateTime; // 0x20
	LARGE_INTEGER UserTime; // 0x28
	LARGE_INTEGER KernelTime; // 0x30
	UNICODE_STRING<nBitness> ImageName; // 0x38
	KPRIORITY BasePriority; // 0x40 / 0x48
	BitnessType_t<std::uintptr_t> UniqueProcessId; // 0x44 / 0x50
	BitnessType_t<std::uintptr_t> InheritedFromUniqueProcessId; // 0x48 / 0x58
	std::uint32_t HandleCount; // 0x4C / 0x60
	std::uint32_t SessionId; // 0x50 / 0x64
	BitnessType_t<HANDLE> UniqueProcessKey; // 0x54 / 0x68 // requires 'SystemExtendedProcessInformation'
	BitnessType_t<std::size_t> PeakVirtualSize; // 0x58 / 0x70
	BitnessType_t<std::size_t> VirtualSize; // 0x5C / 0x78
	std::uint32_t PageFaultCount; // 0x60 / 0x80
	BitnessType_t<std::size_t> PeakWorkingSetSize; // 0x64 / 0x88
	BitnessType_t<std::size_t> WorkingSetSize; // 0x68 / 0x90
	BitnessType_t<std::size_t> QuotaPeakPagedPoolUsage; // 0x6C / 0x98
	BitnessType_t<std::size_t> QuotaPagedPoolUsage; // 0x70 / 0xA0
	BitnessType_t<std::size_t> QuotaPeakNonPagedPoolUsage; // 0x74 / 0xA8
	BitnessType_t<std::size_t> QuotaNonPagedPoolUsage; // 0x78 / 0xB0
	BitnessType_t<std::size_t> PagefileUsage; // 0x7C / 0xB8
	BitnessType_t<std::size_t> PeakPagefileUsage; // 0x80 / 0xC0
	BitnessType_t<std::size_t> PrivatePageCount; // 0x84 / 0xC8
	LARGE_INTEGER ReadOperationCount; // 0x88 / 0xD0
	LARGE_INTEGER WriteOperationCount; // 0x90 / 0xD8
	LARGE_INTEGER OtherOperationCount; // 0x98 / 0xE0
	LARGE_INTEGER ReadTransferCount; // 0xA0 / 0xE8
	LARGE_INTEGER WriteTransferCount; // 0xA8 / 0xF0
	LARGE_INTEGER OtherTransferCount; // 0xB0 / 0xF8
	//_SYSTEM_THREAD_INFORMATION<nBitness> Threads[ANYSIZE_ARRAY]; // requires 'SystemProcessInformation'
	//_SYSTEM_EXTENDED_THREAD_INFORMATION Threads[ANYSIZE_ARRAY]; // requires 'SystemExtendedProcessInformation'
	//_SYSTEM_PROCESS_INFORMATION_EXTENSION Extension; // requires 'SystemFullProcessInformation'
};
_Q_NT_BIT_ASSERT(SYSTEM_PROCESS_INFORMATION, 0xB8, 0x100);

struct SYSTEM_CALL_COUNT_INFORMATION
{
	std::uint32_t Length; // 0x0
	std::uint32_t NumberOfTables; // 0x4
};
static_assert(sizeof(SYSTEM_CALL_COUNT_INFORMATION) == 0x8);

struct SYSTEM_DEVICE_INFORMATION
{
	std::uint32_t NumberOfDisks; // 0x00
	std::uint32_t NumberOfFloppies; // 0x04
	std::uint32_t NumberOfCdRoms; // 0x08
	std::uint32_t NumberOfTapes; // 0x0C
	std::uint32_t NumberOfSerialPorts; // 0x10
	std::uint32_t NumberOfParallelPorts; // 0x14
};
static_assert(sizeof(SYSTEM_DEVICE_INFORMATION) == 0x18);

struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
{
	LARGE_INTEGER IdleTime; // 0x00
	LARGE_INTEGER KernelTime; // 0x08
	LARGE_INTEGER UserTime; // 0x10
	LARGE_INTEGER DpcTime; // 0x18
	LARGE_INTEGER InterruptTime; // 0x20
	std::uint32_t InterruptCount; // 0x28
};
static_assert(sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) == 0x30);

// global flags that can be set to control system behavior
#define FLG_STOP_ON_EXCEPTION			0x00000001 // user and kernel mode
#define FLG_SHOW_LDR_SNAPS				0x00000002 // user and kernel mode
#define FLG_DEBUG_INITIAL_COMMAND		0x00000004 // kernel mode only up until WINLOGON started
#define FLG_STOP_ON_HUNG_GUI			0x00000008 // kernel mode only while running
#define FLG_HEAP_ENABLE_TAIL_CHECK		0x00000010 // user mode only
#define FLG_HEAP_ENABLE_FREE_CHECK		0x00000020 // user mode only
#define FLG_HEAP_VALIDATE_PARAMETERS	0x00000040 // user mode only
#define FLG_HEAP_VALIDATE_ALL			0x00000080 // user mode only
#define FLG_APPLICATION_VERIFIER		0x00000100 // user mode only
#define FLG_POOL_ENABLE_TAGGING			0x00000400 // kernel mode only
#define FLG_HEAP_ENABLE_TAGGING			0x00000800 // user mode only
#define FLG_USER_STACK_TRACE_DB			0x00001000 // x86 user mode only
#define FLG_KERNEL_STACK_TRACE_DB		0x00002000 // x86 kernel mode only at boot time
#define FLG_MAINTAIN_OBJECT_TYPELIST	0x00004000 // kernel mode only at boot time
#define FLG_HEAP_ENABLE_TAG_BY_DLL		0x00008000 // user mode only
#define FLG_DISABLE_STACK_EXTENSION		0x00010000 // user mode only
#define FLG_ENABLE_CSRDEBUG				0x00020000 // kernel mode only at boot time
#define FLG_ENABLE_KDEBUG_SYMBOL_LOAD	0x00040000 // kernel mode only
#define FLG_DISABLE_PAGE_KERNEL_STACKS	0x00080000 // kernel mode only at boot time
#define FLG_ENABLE_SYSTEM_CRIT_BREAKS	0x00100000 // user mode only
#define FLG_HEAP_DISABLE_COALESCING		0x00200000 // user mode only
#define FLG_ENABLE_CLOSE_EXCEPTIONS		0x00400000 // kernel mode only
#define FLG_ENABLE_EXCEPTION_LOGGING	0x00800000 // kernel mode only
#define FLG_ENABLE_HANDLE_TYPE_TAGGING	0x01000000 // kernel mode only
#define FLG_HEAP_PAGE_ALLOCS			0x02000000 // user mode only
#define FLG_DEBUG_INITIAL_COMMAND_EX	0x04000000 // kernel mode only up until WINLOGON started
#define FLG_DISABLE_DBGPRINT			0x08000000 // kernel mode only
#define FLG_CRITSEC_EVENT_CREATION		0x10000000 // user mode only, force early creation of resource events
#define FLG_LDR_TOP_DOWN				0x20000000 // user mode only, win64 only
#define FLG_ENABLE_HANDLE_EXCEPTIONS	0x40000000 // kernel mode only
#define FLG_DISABLE_PROTDLLS			0x80000000 // user mode only (smss/winlogon)

struct SYSTEM_FLAGS_INFORMATION
{
	std::uint32_t Flags; // FLG_*
};
static_assert(sizeof(SYSTEM_FLAGS_INFORMATION) == 0x4);

struct SYSTEM_CALL_TIME_INFORMATION
{
	std::uint32_t Length; // 0x0
	std::uint32_t TotalCalls; // 0x4
	LARGE_INTEGER TimeOfCalls[ANYSIZE_ARRAY]; // 0x8
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_HANDLE_TABLE_ENTRY_INFO
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint16_t UniqueProcessId; // 0x00
	std::uint16_t CreatorBackTraceIndex; // 0x02
	std::uint8_t ObjectTypeIndex; // 0x04
	std::uint8_t HandleAttributes; // 0x05
	std::uint16_t HandleValue; // 0x06
	BitnessType_t<void*> Object; // 0x08
	ACCESS_MASK GrantedAccess; // 0x0C / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_HANDLE_TABLE_ENTRY_INFO, 0x10, 0x18);

_Q_NT_BIT_TEMPLATE struct SYSTEM_HANDLE_INFORMATION
{
	std::uint32_t NumberOfHandles; // 0x0
	SYSTEM_HANDLE_TABLE_ENTRY_INFO<nBitness> Handles[ANYSIZE_ARRAY]; // 0x4 / 0x8
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_OBJECT_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t NextEntryOffset; // 0x00
	BitnessType_t<void*> Object; // 0x04 / 0x08
	BitnessType_t<HANDLE> CreatorUniqueProcess; // 0x08 / 0x10
	std::uint16_t CreatorBackTraceIndex; // 0x0C / 0x18
	std::uint16_t Flags; // 0x0E / 0x1A
	std::int32_t PointerCount; // 0x10 / 0x1C
	std::int32_t HandleCount; // 0x14 / 0x20
	std::uint32_t PagedPoolCharge; // 0x18 / 0x24
	std::uint32_t NonPagedPoolCharge; // 0x1C / 0x28
	BitnessType_t<HANDLE> ExclusiveProcessId; // 0x20 / 0x30
	BitnessType_t<void*> SecurityDescriptor; // 0x24 / 0x38
	OBJECT_NAME_INFORMATION<nBitness> NameInfo; // 0x28 / 0x40
};
_Q_NT_BIT_ASSERT(SYSTEM_OBJECT_INFORMATION, 0x30, 0x50);

_Q_NT_BIT_TEMPLATE struct SYSTEM_OBJECTTYPE_INFORMATION
{
	std::uint32_t NextEntryOffset; // 0x00
	std::uint32_t NumberOfObjects; // 0x04
	std::uint32_t NumberOfHandles; // 0x08
	std::uint32_t TypeIndex; // 0x0C
	std::uint32_t InvalidAttributes; // 0x10
	GENERIC_MAPPING GenericMapping; // 0x14
	ACCESS_MASK ValidAccessMask; // 0x24
	std::uint32_t PoolType; // 0x28
	bool SecurityRequired; // 0x2C
	bool WaitableObject; // 0x2D
	UNICODE_STRING<nBitness> TypeName; // 0x30
};
_Q_NT_BIT_ASSERT(SYSTEM_OBJECTTYPE_INFORMATION, 0x38, 0x40);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PAGEFILE_INFORMATION
{
	std::uint32_t NextEntryOffset; // 0x00
	std::uint32_t TotalSize; // 0x04
	std::uint32_t TotalInUse; // 0x08
	std::uint32_t PeakUsage; // 0x0C
	UNICODE_STRING<nBitness> PageFileName; // 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_PAGEFILE_INFORMATION, 0x18, 0x20);

struct SYSTEM_VDM_INSTEMUL_INFO
{
	std::uint32_t SegmentNotPresent; // 0x00
	std::uint32_t VdmOpcode0F; // 0x04
	std::uint32_t OpcodeESPrefix; // 0x08
	std::uint32_t OpcodeCSPrefix; // 0x0C
	std::uint32_t OpcodeSSPrefix; // 0x10
	std::uint32_t OpcodeDSPrefix; // 0x14
	std::uint32_t OpcodeFSPrefix; // 0x18
	std::uint32_t OpcodeGSPrefix; // 0x1C
	std::uint32_t OpcodeOPER32Prefix; // 0x20
	std::uint32_t OpcodeADDR32Prefix; // 0x24
	std::uint32_t OpcodeINSB; // 0x28
	std::uint32_t OpcodeINSW; // 0x2C
	std::uint32_t OpcodeOUTSB; // 0x30
	std::uint32_t OpcodeOUTSW; // 0x34
	std::uint32_t OpcodePUSHF; // 0x38
	std::uint32_t OpcodePOPF; // 0x3C
	std::uint32_t OpcodeINTnn; // 0x40
	std::uint32_t OpcodeINTO; // 0x44
	std::uint32_t OpcodeIRET; // 0x48
	std::uint32_t OpcodeINBimm; // 0x4C
	std::uint32_t OpcodeINWimm; // 0x50
	std::uint32_t OpcodeOUTBimm; // 0x54
	std::uint32_t OpcodeOUTWimm; // 0x58
	std::uint32_t OpcodeINB; // 0x5C
	std::uint32_t OpcodeINW; // 0x60
	std::uint32_t OpcodeOUTB; // 0x64
	std::uint32_t OpcodeOUTW; // 0x68
	std::uint32_t OpcodeLOCKPrefix; // 0x6C
	std::uint32_t OpcodeREPNEPrefix; // 0x70
	std::uint32_t OpcodeREPPrefix; // 0x74
	std::uint32_t OpcodeHLT; // 0x78
	std::uint32_t OpcodeCLI; // 0x7C
	std::uint32_t OpcodeSTI; // 0x80
	std::uint32_t BopCount; // 0x84
};
static_assert(sizeof(SYSTEM_VDM_INSTEMUL_INFO) == 0x88);

_Q_NT_BIT_TEMPLATE struct SYSTEM_FILECACHE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::size_t> CurrentSize; // 0x00
	BitnessType_t<std::size_t> PeakSize; // 0x04 / 0x08
	std::uint32_t PageFaultCount; // 0x08 / 0x10
	BitnessType_t<std::size_t> MinimumWorkingSet; // 0x0C / 0x18
	BitnessType_t<std::size_t> MaximumWorkingSet; // 0x10 / 0x20
	BitnessType_t<std::size_t> CurrentSizeIncludingTransitionInPages; // 0x14 / 0x28
	BitnessType_t<std::size_t> PeakSizeIncludingTransitionInPages; // 0x18 / 0x30
	std::uint32_t TransitionRePurposeCount; // 0x1C / 0x38
	std::uint32_t Flags; // 0x20 / 0x3C
};
_Q_NT_BIT_ASSERT(SYSTEM_FILECACHE_INFORMATION, 0x24, 0x40);

_Q_NT_BIT_TEMPLATE struct SYSTEM_POOLTAG
{
private:
	_Q_NT_BIT_TYPE
public:
	union
	{
		std::uint8_t Tag[4];
		std::uint32_t TagUlong;
	}; // 0x00
	std::uint32_t PagedAllocs; // 0x04
	std::uint32_t PagedFrees; // 0x08
	BitnessType_t<std::size_t> PagedUsed; // 0x0C / 0x10
	std::uint32_t NonPagedAllocs; // 0x10 / 0x18
	std::uint32_t NonPagedFrees; // 0x14 / 0x1C
	BitnessType_t<std::size_t> NonPagedUsed; // 0x18 / 0x20
};
_Q_NT_BIT_ASSERT(SYSTEM_POOLTAG, 0x1C, 0x28);

_Q_NT_BIT_TEMPLATE struct SYSTEM_POOLTAG_INFORMATION
{
	std::uint32_t Count; // 0x0
	SYSTEM_POOLTAG<nBitness> TagInfo[ANYSIZE_ARRAY]; // 0x4
};

struct SYSTEM_INTERRUPT_INFORMATION
{
	std::uint32_t ContextSwitches; // 0x00
	std::uint32_t DpcCount; // 0x04
	std::uint32_t DpcRate; // 0x08
	std::uint32_t TimeIncrement; // 0x0C
	std::uint32_t DpcBypassCount; // 0x10
	std::uint32_t ApcBypassCount; // 0x14
};
static_assert(sizeof(SYSTEM_INTERRUPT_INFORMATION) == 0x18);

struct SYSTEM_DPC_BEHAVIOR_INFORMATION
{
	std::uint32_t Spare; // 0x00
	std::uint32_t DpcQueueDepth; // 0x04
	std::uint32_t MinimumDpcRate; // 0x08
	std::uint32_t AdjustDpcThreshold; // 0x0C
	std::uint32_t IdealDpcRate; // 0x10
};
static_assert(sizeof(SYSTEM_DPC_BEHAVIOR_INFORMATION) == 0x14);

struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION
{
	std::uint32_t TimeAdjustment; // 0x0
	std::uint32_t TimeIncrement; // 0x4
	bool Enable; // 0x8
};
static_assert(sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) == 0xC);

#if Q_NT_VERSION >= Q_NT_WIN10_RS3
struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE
{
	std::uint64_t TimeAdjustment; // 0x00
	std::uint64_t TimeIncrement; // 0x08
	bool Enable; // 0x10
};
static_assert(sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE) == 0x18);
#endif

struct SYSTEM_SET_TIME_ADJUST_INFORMATION
{
	std::uint32_t TimeAdjustment; // 0x0
	bool Enable; // 0x4
};
static_assert(sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) == 0x8);

#if Q_NT_VERSION >= Q_NT_WIN10_RS3
struct SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE
{
	std::uint64_t TimeAdjustment; // 0x0
	bool Enable; // 0x8
};
static_assert(sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE) == 0x10);
#endif

struct SYSTEM_EXCEPTION_INFORMATION
{
	std::uint32_t AlignmentFixupCount; // 0x0
	std::uint32_t ExceptionDispatchCount; // 0x4
	std::uint32_t FloatingEmulationCount; // 0x8
	std::uint32_t ByteWordEmulationCount; // 0xC
};
static_assert(sizeof(SYSTEM_EXCEPTION_INFORMATION) == 0x10);

using SYSTEM_CRASH_DUMP_CONFIGURATION_CLASS = enum _SYSTEM_CRASH_DUMP_CONFIGURATION_CLASS : std::uint32_t
{
	SystemCrashDumpDisable = 0,
	SystemCrashDumpReconfigure = 1,
#if Q_NT_VERSION >= Q_NT_WIN7
	SystemCrashDumpInitializationComplete = 2
#endif
};

struct SYSTEM_CRASH_DUMP_STATE_INFORMATION
{
	SYSTEM_CRASH_DUMP_CONFIGURATION_CLASS CrashDumpConfigurationClass;
};
static_assert(sizeof(SYSTEM_CRASH_DUMP_STATE_INFORMATION) == 0x4);

struct SYSTEM_KERNEL_DEBUGGER_INFORMATION
{
	bool KernelDebuggerEnabled; // 0x0
	bool KernelDebuggerNotPresent; // 0x1
};
static_assert(sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION) == 0x2);

struct SYSTEM_CONTEXT_SWITCH_INFORMATION
{
	std::uint32_t ContextSwitches; // 0x00
	std::uint32_t FindAny; // 0x04
	std::uint32_t FindLast; // 0x08
	std::uint32_t FindIdeal; // 0x0C
	std::uint32_t IdleAny; // 0x10
	std::uint32_t IdleCurrent; // 0x14
	std::uint32_t IdleLast; // 0x18
	std::uint32_t IdleIdeal; // 0x1C
	std::uint32_t PreemptAny; // 0x20
	std::uint32_t PreemptCurrent; // 0x24
	std::uint32_t PreemptLast; // 0x28
	std::uint32_t SwitchToIdle; // 0x2C
};
static_assert(sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) == 0x30);

_Q_NT_BIT_TEMPLATE struct SYSTEM_REGISTRY_QUOTA_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t RegistryQuotaAllowed; // 0x0
	std::uint32_t RegistryQuotaUsed; // 0x4
	BitnessType_t<std::size_t> PagedPoolSize; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_REGISTRY_QUOTA_INFORMATION, 0xC, 0x10);

struct SYSTEM_PROCESSOR_IDLE_INFORMATION
{
	std::uint64_t IdleTime; // 0x00
	std::uint64_t C1Time; // 0x08
	std::uint64_t C2Time; // 0x10
	std::uint64_t C3Time; // 0x18
	std::uint32_t C1Transitions; // 0x20
	std::uint32_t C2Transitions; // 0x24
	std::uint32_t C3Transitions; // 0x28
	std::uint32_t Padding; // 0x2C
};
static_assert(sizeof(SYSTEM_PROCESSOR_IDLE_INFORMATION) == 0x30);

_Q_NT_BIT_TEMPLATE struct SYSTEM_LEGACY_DRIVER_INFORMATION
{
	std::uint32_t VetoType; // 0x0
	UNICODE_STRING<nBitness> VetoList; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_LEGACY_DRIVER_INFORMATION, 0xC, 0x18);

struct SYSTEM_LOOKASIDE_INFORMATION
{
	std::uint16_t CurrentDepth; // 0x00
	std::uint16_t MaximumDepth; // 0x02
	std::uint32_t TotalAllocates; // 0x04
	std::uint32_t AllocateMisses; // 0x08
	std::uint32_t TotalFrees; // 0x0C
	std::uint32_t FreeMisses; // 0x10
	std::uint32_t Type; // 0x14
	std::uint32_t Tag; // 0x18
	std::uint32_t Size; // 0x1C
};
static_assert(sizeof(SYSTEM_LOOKASIDE_INFORMATION) == 0x20);

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t NextEntryOffset; // 0x00
	std::uint32_t Level; // 0x04
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	std::uint32_t RuleClasses[2]; // 0x08
	std::uint32_t TriageContext; // 0x10
	std::uint32_t AreAllDriversBeingVerified; // 0x14
#endif
	UNICODE_STRING<nBitness> DriverName; // 0x18
	std::uint32_t RaiseIrqls; // 0x20 / 0x28
	std::uint32_t AcquireSpinLocks; // 0x24 / 0x2C
	std::uint32_t SynchronizeExecutions; // 0x28 / 0x30
	std::uint32_t AllocationsAttempted; // 0x2C / 0x34
	std::uint32_t AllocationsSucceeded; // 0x30 / 0x38
	std::uint32_t AllocationsSucceededSpecialPool; // 0x34 / 0x3C
	std::uint32_t AllocationsWithNoTag; // 0x38 / 0x40
	std::uint32_t TrimRequests; // 0x3C / 0x44
	std::uint32_t Trims; // 0x40 / 0x48
	std::uint32_t AllocationsFailed; // 0x44 / 0x4C
	std::uint32_t AllocationsFailedDeliberately; // 0x48 / 0x50
	std::uint32_t Loads; // 0x4C / 0x54
	std::uint32_t Unloads; // 0x50 / 0x58
	std::uint32_t UnTrackedPool; // 0x54 / 0x5C
	std::uint32_t CurrentPagedPoolAllocations; // 0x58 / 0x60
	std::uint32_t CurrentNonPagedPoolAllocations; // 0x5C / 0x64
	std::uint32_t PeakPagedPoolAllocations; // 0x60 / 0x68
	std::uint32_t PeakNonPagedPoolAllocations; // 0x64 / 0x6C
	BitnessType_t<std::size_t> PagedPoolUsageInBytes; // 0x68 / 0x70
	BitnessType_t<std::size_t> NonPagedPoolUsageInBytes; // 0x6C / 0x78
	BitnessType_t<std::size_t> PeakPagedPoolUsageInBytes; // 0x70 / 0x80
	BitnessType_t<std::size_t> PeakNonPagedPoolUsageInBytes; // 0x74 / 0x88
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_INFORMATION, 0x78, 0x90);

_Q_NT_BIT_TEMPLATE struct SYSTEM_SESSION_PROCESS_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t SessionId; // 0x0
	std::uint32_t SizeOfBuf; // 0x4
	BitnessType_t<void*> Buffer; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_SESSION_PROCESS_INFORMATION, 0xC, 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_GDI_DRIVER_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	UNICODE_STRING<nBitness> DriverName; // 0x00
	BitnessType_t<void*> ImageAddress; // 0x08 / 0x10
	BitnessType_t<void*> SectionPointer; // 0x0C / 0x18
	BitnessType_t<void*> EntryPoint; // 0x10 / 0x20
	BitnessType_t<IMAGE_EXPORT_DIRECTORY*> ExportSectionPointer; // 0x14 / 0x28
	std::uint32_t ImageLength; // 0x18 / 0x30
};
_Q_NT_BIT_ASSERT(SYSTEM_GDI_DRIVER_INFORMATION, 0x1C, 0x38);

_Q_NT_BIT_TEMPLATE struct SYSTEM_NUMA_INFORMATION
{
private:
	static constexpr std::size_t MAXIMUM_NODE_COUNT = (nBitness == 32U ? 0x10 : 0x40);
public:
	std::uint32_t HighestNodeNumber; // 0x0
	std::uint32_t Reserved; // 0x4
	union
	{
		GROUP_AFFINITY<nBitness> ActiveProcessorsGroupAffinity[MAXIMUM_NODE_COUNT];
		std::uint64_t AvailableMemory[MAXIMUM_NODE_COUNT];
#if Q_NT_VERSION >= Q_NT_WIN7
		std::uint64_t Pad[MAXIMUM_NODE_COUNT * 2U];
#endif
	}; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_NUMA_INFORMATION, 0x108, 0x408);

struct SYSTEM_PROCESSOR_POWER_INFORMATION
{
	std::uint8_t CurrentFrequency; // 0x00
	std::uint8_t ThermalLimitFrequency; // 0x01
	std::uint8_t ConstantThrottleFrequency; // 0x02
	std::uint8_t DegradedThrottleFrequency; // 0x03
	std::uint8_t LastBusyFrequency; // 0x04
	std::uint8_t LastC3Frequency; // 0x05
	std::uint8_t LastAdjustedBusyFrequency; // 0x06
	std::uint8_t ProcessorMinThrottle; // 0x07
	std::uint8_t ProcessorMaxThrottle; // 0x08
	std::uint32_t NumberOfFrequencies; // 0x0C
	std::uint32_t PromotionCount; // 0x10
	std::uint32_t DemotionCount; // 0x14
	std::uint32_t ErrorCount; // 0x18
	std::uint32_t RetryCount; // 0x1C
	std::uint64_t CurrentFrequencyTime; // 0x20
	std::uint64_t CurrentProcessorTime; // 0x28
	std::uint64_t CurrentProcessorIdleTime; // 0x30
	std::uint64_t LastProcessorTime; // 0x38
	std::uint64_t LastProcessorIdleTime; // 0x40
#if Q_NT_VERSION >= Q_NT_WIN10
	std::uint64_t Energy; // 0x48
#endif
};
static_assert(sizeof(SYSTEM_PROCESSOR_POWER_INFORMATION) == 0x50);

_Q_NT_BIT_TEMPLATE struct SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> Object; // 0x00
	BitnessType_t<std::uintptr_t> UniqueProcessId; // 0x04 / 0x08
	BitnessType_t<HANDLE> HandleValue; // 0x08 / 0x10
	ACCESS_MASK GrantedAccess; // 0x0C / 0x18
	std::uint16_t CreatorBackTraceIndex; // 0x10 / 0x1C
	std::uint16_t ObjectTypeIndex; // 0x12 / 0x1E
	std::uint32_t HandleAttributes; // 0x14 / 0x20
	std::uint32_t Reserved; // 0x18 / 0x24
};
_Q_NT_BIT_ASSERT(SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX, 0x1C, 0x28);

_Q_NT_BIT_TEMPLATE struct SYSTEM_HANDLE_INFORMATION_EX
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::uintptr_t> NumberOfHandles; // 0x00
	BitnessType_t<std::uintptr_t> Reserved; // 0x04 / 0x08
	SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX<nBitness> Handles[ANYSIZE_ARRAY]; // 0x08 / 0x10
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_BIGPOOL_ENTRY
{
private:
	_Q_NT_BIT_TYPE
public:
	union
	{
		BitnessType_t<void*> VirtualAddress;
		BitnessType_t<std::uintptr_t> NonPaged : 1;
	}; // 0x00
	BitnessType_t<std::size_t> SizeInBytes; // 0x04 / 0x08
	union
	{
		std::uint8_t Tag[4];
		std::uint32_t TagUlong;
	}; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_BIGPOOL_ENTRY, 0xC, 0x18);

_Q_NT_BIT_TEMPLATE struct SYSTEM_BIGPOOL_INFORMATION
{
	std::uint32_t Count; // 0x0
	SYSTEM_BIGPOOL_ENTRY<nBitness> AllocatedInfo[ANYSIZE_ARRAY]; // 0x4
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_POOL_ENTRY
{
private:
	_Q_NT_BIT_TYPE
public:
	bool Allocated; // 0x0
	bool Spare0; // 0x1
	std::uint16_t AllocatorBackTraceIndex; // 0x2
	std::uint32_t Size; // 0x4
	union
	{
		std::uint8_t Tag[4];
		std::uint32_t TagUlong;
		BitnessType_t<void*> ProcessChargedQuota;
	}; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_POOL_ENTRY, 0xC, 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_POOL_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::size_t> TotalSize; // 0x00
	BitnessType_t<void*> FirstEntry; // 0x04 / 0x08
	std::uint16_t EntryOverhead; // 0x08 / 0x10
	bool PoolTagPresent; // 0x0A / 0x12
	bool Spare0; // 0x0B / 0x13
	std::uint32_t NumberOfEntries; // 0x0C / 0x14
	SYSTEM_POOL_ENTRY<nBitness> Entries[ANYSIZE_ARRAY]; // 0x10 / 0x18
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_SESSION_POOLTAG_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::uintptr_t> NextEntryOffset; // 0x00
	std::uint32_t SessionId; // 0x04 / 0x08
	std::uint32_t Count; // 0x08 / 0x0C
	SYSTEM_POOLTAG<nBitness> TagInfo[ANYSIZE_ARRAY]; // 0x0C / 0x10
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_SESSION_MAPPED_VIEW_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::uintptr_t> NextEntryOffset; // 0x00
	std::uint32_t SessionId; // 0x04
	std::uint32_t ViewFailures; // 0x08
	BitnessType_t<std::size_t> NumberOfBytesAvailable; // 0x0C / 0x10
	BitnessType_t<std::size_t> NumberOfBytesAvailableContiguous; // 0x10 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_SESSION_MAPPED_VIEW_INFORMATION, 0x14, 0x20);

using WATCHDOG_INFORMATION_CLASS = enum _WATCHDOG_INFORMATION_CLASS
{
	WdInfoTimeoutValue = 0,
	WdInfoResetTimer = 1,
	WdInfoStopTimer = 2,
	WdInfoStartTimer = 3,
	WdInfoTriggerAction = 4,
	WdInfoState = 5,
#if Q_NT_VERSION >= Q_NT_WINBLUE
	WdInfoTriggerReset = 6,
	WdInfoNop = 7,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS2
	WdInfoGeneratedLastReset = 8,
	WdInfoInvalid = 9
#endif
};

using WATCHDOG_HANDLER_ACTION = enum _WATCHDOG_HANDLER_ACTION
{
	WdActionSetTimeoutValue = 0,
	WdActionQueryTimeoutValue = 1,
	WdActionResetTimer = 2,
	WdActionStopTimer = 3,
	WdActionStartTimer = 4,
	WdActionSetTriggerAction = 5,
	WdActionQueryTriggerAction = 6,
	WdActionQueryState = 7,
	WdActionSleep = 8,
	WdActionWake = 9,
#if Q_NT_VERSION >= Q_NT_WIN8
	WdActionMarkHiberPhase = 10
#endif
};
using PSYSTEM_WATCHDOG_HANDLER = NTSTATUS(NTAPI*)(WATCHDOG_HANDLER_ACTION Action, void* Context, std::uint32_t* DataValue, bool NoLocks);

// @todo: removed/renamed since WINBLUE, just verify
_Q_NT_BIT_TEMPLATE struct SYSTEM_WATCHDOG_HANDLER_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<PSYSTEM_WATCHDOG_HANDLER> WdHandler; // 0x0
	BitnessType_t<void*> Context; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_WATCHDOG_HANDLER_INFORMATION, 0x8, 0x10);

struct SYSTEM_WATCHDOG_TIMER_INFORMATION
{
	WATCHDOG_INFORMATION_CLASS WdInfoClass; // 0x0
	std::uint32_t DataValue; // 0x4
};
static_assert(sizeof(SYSTEM_WATCHDOG_TIMER_INFORMATION) == 0x8);

using SYSTEM_FIRMWARE_TABLE_ACTION = enum _SYSTEM_FIRMWARE_TABLE_ACTION
{
	SystemFirmwareTable_Enumerate = 0,
	SystemFirmwareTable_Get = 1
};

struct SYSTEM_FIRMWARE_TABLE_INFORMATION
{
	std::uint32_t ProviderSignature; // 0x00
	SYSTEM_FIRMWARE_TABLE_ACTION Action; // 0x04
	std::uint32_t TableID; // 0x08
	std::uint32_t TableBufferLength; // 0x0C
	std::uint8_t TableBuffer[ANYSIZE_ARRAY]; // 0x10
};

using PFIRMWARE_TABLE_HANDLER = NTSTATUS(NTAPI*)(SYSTEM_FIRMWARE_TABLE_INFORMATION* SystemFirmwareTableInfo);

_Q_NT_BIT_TEMPLATE struct SYSTEM_FIRMWARE_TABLE_HANDLER
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t ProviderSignature; // 0x00
	bool Register; // 0x04
	BitnessType_t<PFIRMWARE_TABLE_HANDLER> FirmwareTableHandler; // 0x08
	BitnessType_t<void*> DriverObject; // 0x0C / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_FIRMWARE_TABLE_HANDLER, 0x10, 0x18);

#if Q_NT_VERSION >= Q_NT_VISTA
_Q_NT_BIT_TEMPLATE struct SYSTEM_MEMORY_LIST_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::size_t> ZeroPageCount; // 0x00
	BitnessType_t<std::size_t> FreePageCount; // 0x04 / 0x08
	BitnessType_t<std::size_t> ModifiedPageCount; // 0x08 / 0x10
	BitnessType_t<std::size_t> ModifiedNoWritePageCount; // 0x0C / 0x18
	BitnessType_t<std::size_t> BadPageCount; // 0x10 / 0x20
	BitnessType_t<std::size_t> PageCountByPriority[8]; // 0x14 / 0x28
	BitnessType_t<std::size_t> RepurposedPagesByPriority[8]; // 0x34 / 0x68
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<std::size_t> ModifiedPageCountPageFile; // 0x54 / 0xA8
#endif
};
_Q_NT_BIT_ASSERT(SYSTEM_MEMORY_LIST_INFORMATION, 0x58, 0xB0);

using SYSTEM_MEMORY_LIST_COMMAND = enum _SYSTEM_MEMORY_LIST_COMMAND
{
	MemoryCaptureAccessedBits = 0,
	MemoryCaptureAndResetAccessedBits = 1,
	MemoryEmptyWorkingSets = 2,
	MemoryFlushModifiedList = 3,
	MemoryPurgeStandbyList = 4,
	MemoryPurgeLowPriorityStandbyList = 5,
	MemoryCommandMax = 6
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_THREAD_CID_PRIORITY_INFORMATION
{
	CLIENT_ID<nBitness> ClientId; // 0x00
	KPRIORITY Priority; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_THREAD_CID_PRIORITY_INFORMATION, 0xC, 0x18);

struct SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION
{
	std::uint64_t CycleTime;
};
static_assert(sizeof(SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION) == 0x8);

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_ISSUE
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::uintptr_t> IssueType; // 0x00
	BitnessType_t<void*> Address; // 0x04 / 0x08
	BitnessType_t<std::uintptr_t> Parameters[2]; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_ISSUE, 0x10, 0x20);

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_CANCELLATION_INFORMATION
{
	std::uint32_t CancelProbability; // 0x00
	std::uint32_t CancelThreshold; // 0x04
	std::uint32_t CompletionThreshold; // 0x08
	std::uint32_t CancellationVerifierDisabled; // 0x0C
	std::uint32_t AvailableIssues; // 0x10
	SYSTEM_VERIFIER_ISSUE<nBitness> Issues[128]; // 0x14 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_CANCELLATION_INFORMATION, 0x814, 0x1018);

_Q_NT_BIT_TEMPLATE struct SYSTEM_REF_TRACE_INFORMATION
{
	bool TraceEnable; // 0x00
	bool TracePermanent; // 0x01
	UNICODE_STRING<nBitness> TraceProcessName; // 0x04 / 0x08
	UNICODE_STRING<nBitness> TracePoolTags; // 0x0C / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_REF_TRACE_INFORMATION, 0x14, 0x28);

struct SYSTEM_SPECIAL_POOL_INFORMATION
{
	std::uint32_t PoolTag; // 0x0
	std::uint32_t Flags; // 0x4
};
static_assert(sizeof(SYSTEM_SPECIAL_POOL_INFORMATION) == 0x8);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PROCESS_ID_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::uintptr_t> ProcessId; // 0x0
	UNICODE_STRING<nBitness> ImageName; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_PROCESS_ID_INFORMATION, 0xC, 0x18);

struct SYSTEM_HYPERVISOR_QUERY_INFORMATION
{
	bool HypervisorConnected; // 0x0
#if Q_NT_VERSION >= Q_NT_WINBLUE
	bool HypervisorDebuggingEnabled; // 0x1
#if Q_NT_VERSION >= Q_NT_WIN10
	bool HypervisorPresent; // 0x2
#if Q_NT_VERSION >= Q_NT_WIN10_19H1
	bool HypervisorSchedulerType; // 0x3
	bool Spare0[4]; // 0x4
#else
	bool Spare0[5]; // 0x3
#endif
#else
	bool Spare0[6]; // 0x2
#endif
#else
	bool Spare0[7]; // 0x1
#endif
	std::uint64_t EnabledEnlightenments; // 0x8
};
static_assert(sizeof(SYSTEM_HYPERVISOR_QUERY_INFORMATION) == 0x10);

using FIRMWARE_TYPE = enum _FIRMWARE_TYPE
{
	FirmwareTypeUnknown = 0,
	FirmwareTypeBios = 1,
#if Q_NT_VERSION >= Q_NT_WIN8
	FirmwareTypeUefi = 2,
#else
	FirmwareTypeEfi = 2,
#endif
	FirmwareTypeMax = 3
};

struct SYSTEM_BOOT_ENVIRONMENT_INFORMATION
{
	GUID BootIdentifier; // 0x00
	FIRMWARE_TYPE FirmwareType; // 0x10
#if Q_NT_VERSION >= Q_NT_WIN8
	union
	{
		std::uint64_t BootFlags;
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
		struct
		{
			std::uint64_t DbgMenuOsSelection : 1;
			std::uint64_t DbgHiberBoot : 1;
			std::uint64_t DbgSoftBoot : 1;
			std::uint64_t DbgMeasuredLaunch : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
			std::uint64_t DbgMeasuredLaunchCapable : 1;
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_19H1
			std::uint64_t DbgSystemHiveReplace : 1;
			std::uint64_t DbgMeasuredLaunchSmmProtections : 1;
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_20H1
			std::uint64_t DbgMeasuredLaunchSmmLevel : 7;
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
			std::uint64_t DbgBugCheckRecovery : 1;
			std::uint64_t DbgFASR : 1;
			std::uint64_t DbgUseCachedBcd : 1;
#endif
		};
#endif
	}; // 0x18
#endif
};
static_assert(sizeof(SYSTEM_BOOT_ENVIRONMENT_INFORMATION) == 0x20);

struct SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION
{
	std::uint32_t FlagsToEnable; // 0x0
	std::uint32_t FlagsToDisable; // 0x4
};
static_assert(sizeof(SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION) == 0x8);

using COVERAGE_REQUEST_CODES = enum _COVERAGE_REQUEST_CODES
{
	CoverageAllModules = 0,
	CoverageSearchByHash = 1,
	CoverageSearchByName = 2
};

_Q_NT_BIT_TEMPLATE struct COVERAGE_MODULE_REQUEST
{
	COVERAGE_REQUEST_CODES RequestType; // 0x0
	union
	{
		std::uint8_t MD5Hash[16];
		UNICODE_STRING<nBitness> ModuleName;
	} SearchInfo; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(COVERAGE_MODULE_REQUEST, 0x14, 0x18);

_Q_NT_BIT_TEMPLATE struct COVERAGE_MODULE_INFO
{
	std::uint32_t ModuleInfoSize; // 0x00
	std::uint32_t IsBinaryLoaded; // 0x04
	UNICODE_STRING<nBitness> ModulePathName; // 0x08
	std::uint32_t CoverageSectionSize; // 0x10 / 0x18
	std::uint8_t CoverageSection[ANYSIZE_ARRAY]; // 0x14 / 0x1C
};

_Q_NT_BIT_TEMPLATE struct COVERAGE_MODULES
{
	std::uint32_t ListAndReset; // 0x00
	std::uint32_t NumberOfModules; // 0x04
	COVERAGE_MODULE_REQUEST<nBitness> ModuleRequestInfo; // 0x08
	COVERAGE_MODULE_INFO<nBitness> Modules[ANYSIZE_ARRAY]; // 0x1C / 0x20
};

struct SYSTEM_PREFETCH_PATCH_INFORMATION
{
	std::uint32_t PrefetchPatchCount;
};
static_assert(sizeof(SYSTEM_PREFETCH_PATCH_INFORMATION) == 0x4);

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_FAULTS_INFORMATION
{
	std::uint32_t Probability; // 0x00
	std::uint32_t MaxProbability; // 0x4
	UNICODE_STRING<nBitness> PoolTags; // 0x08
	UNICODE_STRING<nBitness> Applications; // 0x10 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_FAULTS_INFORMATION, 0x18, 0x28);

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_INFORMATION_EX
{
	std::uint32_t VerifyMode; // 0x00
	std::uint32_t OptionChanges; // 0x04
#if Q_NT_VERSION >= Q_NT_VISTA_SP1
	UNICODE_STRING<nBitness> PreviousBucketName; // 0x08
#if Q_NT_VERSION >= Q_NT_WIN7
	std::uint32_t IrpCancelTimeoutMsec; // 0x10 / 0x18
#if Q_NT_VERSION >= Q_NT_WIN8
	std::uint32_t VerifierExtensionEnabled; // 0x14 / 0x1C
#endif
	std::uint32_t Reserved[nBitness == 32U ? 3 : 1]; // 0x18 / 0x20
#else
	std::uint32_t Reserved[nBitness == 32U ? 4 : 2]; // 0x18 / 0x20
#endif
#endif
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_INFORMATION_EX, 0x24, 0x28);

_Q_NT_BIT_TEMPLATE struct SYSTEM_SYSTEM_PARTITION_INFORMATION
{
	UNICODE_STRING<nBitness> SystemPartition;
};
_Q_NT_BIT_ASSERT(SYSTEM_SYSTEM_PARTITION_INFORMATION, 0x8, 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_SYSTEM_DISK_INFORMATION
{
	UNICODE_STRING<nBitness> SystemDisk;
};
_Q_NT_BIT_ASSERT(SYSTEM_SYSTEM_DISK_INFORMATION, 0x8, 0x10);

struct SYSTEM_NUMA_PROXIMITY_MAP
{
	std::uint32_t NodeProximityId; // 0x0
	std::uint16_t NodeNumber; // 0x4
};
static_assert(sizeof(SYSTEM_NUMA_PROXIMITY_MAP) == 0x8);

struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT
{
	std::uint64_t Hits; // 0x0
	std::uint8_t PercentFrequency; // 0x8
};
static_assert(sizeof(SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT) == 0x10);

struct SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION
{
	std::uint32_t ProcessorNumber; // 0x0
	std::uint32_t StateCount; // 0x4
	SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT States[ANYSIZE_ARRAY]; // 0x8
};

struct SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION
{
	std::uint32_t ProcessorCount; // 0x0
	std::uint32_t Offsets[ANYSIZE_ARRAY]; // 0x4
};

// code integrity options
#define CODEINTEGRITY_OPTION_ENABLED 0x01
#define CODEINTEGRITY_OPTION_TESTSIGN 0x02
#define CODEINTEGRITY_OPTION_UMCI_ENABLED 0x04
#define CODEINTEGRITY_OPTION_UMCI_AUDITMODE_ENABLED 0x08
#define CODEINTEGRITY_OPTION_UMCI_EXCLUSIONPATHS_ENABLED 0x10
#define CODEINTEGRITY_OPTION_TEST_BUILD 0x20
#define CODEINTEGRITY_OPTION_PREPRODUCTION_BUILD 0x40
#define CODEINTEGRITY_OPTION_DEBUGMODE_ENABLED 0x80
#define CODEINTEGRITY_OPTION_FLIGHT_BUILD 0x100
#define CODEINTEGRITY_OPTION_FLIGHTING_ENABLED 0x200
#define CODEINTEGRITY_OPTION_HVCI_KMCI_ENABLED 0x400
#define CODEINTEGRITY_OPTION_HVCI_KMCI_AUDITMODE_ENABLED 0x800
#define CODEINTEGRITY_OPTION_HVCI_KMCI_STRICTMODE_ENABLED 0x1000
#define CODEINTEGRITY_OPTION_HVCI_IUM_ENABLED 0x2000
#define CODEINTEGRITY_OPTION_WHQL_ENFORCEMENT_ENABLED 0x4000
#define CODEINTEGRITY_OPTION_WHQL_AUDITMODE_ENABLED 0x8000

struct SYSTEM_CODEINTEGRITY_INFORMATION
{
	std::uint32_t Length; // 0x0
	std::uint32_t CodeIntegrityOptions; // 0x4 // CODEINTEGRITY_OPTION_*
};
static_assert(sizeof(SYSTEM_CODEINTEGRITY_INFORMATION) == 0x8);

struct SYSTEM_PROCESSOR_MICROCODE_UPDATE_INFORMATION
{
	std::uint32_t Operation;
};
static_assert(sizeof(SYSTEM_PROCESSOR_MICROCODE_UPDATE_INFORMATION) == 0x4);
#endif

#if Q_NT_VERSION >= Q_NT_VISTA_SP1
using SYSTEM_VA_TYPE = enum _SYSTEM_VA_TYPE
{
	SystemVaTypeAll = 0,
	SystemVaTypeNonPagedPool = 1,
	SystemVaTypePagedPool = 2,
	SystemVaTypeSystemCache = 3,
	SystemVaTypeSystemPtes = 4,
	SystemVaTypeSessionSpace = 5,
	SystemVaTypeMax = 6
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_VA_LIST_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::size_t> VirtualSize; // 0x00
	BitnessType_t<std::size_t> VirtualPeak; // 0x04 / 0x08
	BitnessType_t<std::size_t> VirtualLimit; // 0x08 / 0x10
	BitnessType_t<std::size_t> AllocationFailures; // 0x0C / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_VA_LIST_INFORMATION, 0x10, 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN7
// @todo: SYSTEM_STORE_INFORMATION

_Q_NT_BIT_TEMPLATE struct SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> KeyHandle; // 0x00
	BitnessType_t<UNICODE_STRING<nBitness>*> ValueNamePointer; // 0x04 / 0x08
	BitnessType_t<std::uint32_t*> RequiredLengthPointer; // 0x08 / 0x10
	BitnessType_t<std::uint8_t*> Buffer; // 0x0C / 0x18
	std::uint32_t BufferLength; // 0x10 / 0x20
	std::uint32_t Type; // 0x14 / 0x24
	BitnessType_t<std::uint8_t*> AppendBuffer; // 0x18 / 0x28
	std::uint32_t AppendBufferLength; // 0x1C / 0x30
	bool CreateIfDoesntExist; // 0x20 / 0x34
	bool TruncateExistingValue; // 0x21 / 0x35
};
_Q_NT_BIT_ASSERT(SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS, 0x24, 0x38);

struct SYSTEM_VHD_BOOT_INFORMATION
{
	bool OsDiskIsVhd; // 0x0
	std::uint32_t OsVhdFilePathOffset; // 0x4
	wchar_t OsVhdParentVolume[ANYSIZE_ARRAY]; // 0x8
};

#if Q_NT_VERSION >= Q_NT_WIN8
struct SYSTEM_ERROR_PORT_TIMEOUTS
{
	std::uint32_t StartTimeout; // 0x0
	std::uint32_t CommTimeout; // 0x4
};
static_assert(sizeof(SYSTEM_ERROR_PORT_TIMEOUTS) == 0x8);
#endif

struct SYSTEM_LOW_PRIORITY_IO_INFORMATION
{
	std::uint32_t LowPriReadOperations; // 0x00
	std::uint32_t LowPriWriteOperations; // 0x04
	std::uint32_t KernelBumpedToNormalOperations; // 0x08
	std::uint32_t LowPriPagingReadOperations; // 0x0C
	std::uint32_t KernelPagingReadsBumpedToNormal; // 0x10
	std::uint32_t LowPriPagingWriteOperations; // 0x14
	std::uint32_t KernelPagingWritesBumpedToNormal; // 0x18
	std::uint32_t BoostedIrpCount; // 0x1C
	std::uint32_t BoostedPagingIrpCount; // 0x20
	std::uint32_t BlanketBoostCount; // 0x24
};
static_assert(sizeof(SYSTEM_LOW_PRIORITY_IO_INFORMATION) == 0x28);

#if Q_NT_VERSION <= Q_NT_WIN7_SP1
using TPM_BOOT_ENTROPY_RESULT_CODE = enum _TPM_BOOT_ENTROPY_RESULT_CODE : std::int32_t
{
	TpmBootEntropyStructureUninitialized = 0,
	TpmBootEntropyDisabledByPolicy = 1,
	TpmBootEntropyNoTpmFound = 2,
	TpmBootEntropyTpmError = 3,
	TpmBootEntropySuccess = 4
}

struct TPM_BOOT_ENTROPY_NT_RESULT
{
	std::uint64_t Policy; // 0x00
	TPM_BOOT_ENTROPY_RESULT_CODE ResultCode; // 0x08
	NTSTATUS ResultStatus; // 0x0C
	std::uint64_t Time; // 0x10
	std::uint32_t EntropyLength; // 0x18
	std::uint8_t EntropyData[40]; // 0x1C
};
static_assert(sizeof(TPM_BOOT_ENTROPY_NT_RESULT) == 0x48);
#elif Q_NT_VERSION >= Q_NT_WIN8
#define BOOT_ENTROPY_SOURCE_DATA_SIZE 0x40
#define BOOT_SEED_BYTES_FOR_CNG 0x30

using BOOT_ENTROPY_SOURCE_RESULT_CODE = enum _BOOT_ENTROPY_SOURCE_RESULT_CODE : std::int32_t
{
	BootEntropySourceStructureUninitialized = 0,
	BootEntropySourceDisabledByPolicy = 1,
	BootEntropySourceNotPresent = 2,
	BootEntropySourceError = 3,
	BootEntropySourceSuccess = 4
};

using BOOT_ENTROPY_SOURCE_ID = enum _BOOT_ENTROPY_SOURCE_ID : std::uint32_t
{
	BootEntropySourceNone = 0,
	BootEntropySourceSeedfile = 1,
	BootEntropySourceExternal = 2,
	BootEntropySourceTpm = 3,
	BootEntropySourceRdrand = 4,
	BootEntropySourceTime = 5,
	BootEntropySourceAcpiOem0 = 6,
	BootEntropySourceUefi = 7,
#if Q_NT_VERSION >= Q_NT_WINBLUE
	BootEntropySourceCng = 8,
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	BootEntropySourceTcbTpm = 9,
	BootEntropySourceTcbRdrand = 10,
	BootMaxEntropySources = 10
#else
	BootMaxEntropySources = 8
#endif
#else
	BootMaxEntropySources = 7
#endif
};

struct BOOT_ENTROPY_SOURCE_NT_RESULT
{
	BOOT_ENTROPY_SOURCE_ID SourceId; // 0x00
	std::uint64_t Policy; // 0x08
	BOOT_ENTROPY_SOURCE_RESULT_CODE ResultCode; // 0x10
	NTSTATUS ResultStatus; // 0x14
	std::uint64_t Time; // 0x18
	std::uint32_t EntropyLength; // 0x20
	std::uint8_t EntropyData[BOOT_ENTROPY_SOURCE_DATA_SIZE]; // 0x24
};
static_assert(sizeof(BOOT_ENTROPY_SOURCE_NT_RESULT) == 0x68);

struct BOOT_ENTROPY_NT_RESULT
{
	std::uint32_t MaxEntropySources; // 0x0000 // @note: originally "maxEntropySources"
	BOOT_ENTROPY_SOURCE_NT_RESULT EntropySourceResult[BootMaxEntropySources]; // 0x0008
	std::uint8_t SeedBytesForCng[BOOT_SEED_BYTES_FOR_CNG]; // 0x0418
};
static_assert(sizeof(BOOT_ENTROPY_NT_RESULT) == 0x448);
#endif

_Q_NT_BIT_TEMPLATE struct SYSTEM_VERIFIER_COUNTERS_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	SYSTEM_VERIFIER_INFORMATION<nBitness> Legacy; // 0x0000
	std::uint32_t RaiseIrqls; // 0x0078 / 0x0090
	std::uint32_t AcquireSpinLocks; // 0x007C / 0x0094
	std::uint32_t SynchronizeExecutions; // 0x0080 / 0x0098
	std::uint32_t AllocationsWithNoTag; // 0x0084 / 0x009C
	std::uint32_t AllocationsFailed; // 0x0088 / 0x00A0
	std::uint32_t AllocationsFailedDeliberately; // 0x008C / 0x00A4
	BitnessType_t<std::size_t> LockedBytes; // 0x0090 / 0x00A8
	BitnessType_t<std::size_t> PeakLockedBytes; // 0x0094 / 0x00B0
	BitnessType_t<std::size_t> MappedLockedBytes; // 0x0098 / 0x00B8
	BitnessType_t<std::size_t> PeakMappedLockedBytes; // 0x009C / 0x00C0
	BitnessType_t<std::size_t> MappedIoSpaceBytes; // 0x00A0 / 0x00C8
	BitnessType_t<std::size_t> PeakMappedIoSpaceBytes; // 0x00A4 / 0x00D0
	BitnessType_t<std::size_t> PagesForMdlBytes; // 0x00A8 / 0x00D8
	BitnessType_t<std::size_t> PeakPagesForMdlBytes; // 0x00AC / 0x00E0
	BitnessType_t<std::size_t> ContiguousMemoryBytes; // 0x00B0 / 0x00E8
	BitnessType_t<std::size_t> PeakContiguousMemoryBytes; // 0x00B4 / 0x00F0
#if Q_NT_VERSION >= Q_NT_WIN10
	std::uint32_t ExecutePoolTypes; // 0x00B8 / 0x00F8
	std::uint32_t ExecutePageProtections; // 0x00BC / 0x00FC
	std::uint32_t ExecutePageMappings; // 0x00C0 / 0x0100
	std::uint32_t ExecuteWriteSections; // 0x00C4 / 0x0104
	std::uint32_t SectionAlignmentFailures; // 0x00C8 / 0x0108
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint32_t UnsupportedRelocs; // 0x00CC / 0x010C
	std::uint32_t IATInExecutableSection; // 0x00D0 / 0x0110
#endif
};
_Q_NT_BIT_ASSERT(SYSTEM_VERIFIER_COUNTERS_INFORMATION, 0xD4, 0x118);

struct SYSTEM_ACPI_AUDIT_INFORMATION
{
	std::uint32_t RsdpCount; // 0x0
	struct
	{
		std::uint32_t SameRsdt : 1;
		std::uint32_t SlicPresent : 1;
		std::uint32_t SlicDifferent : 1;
	}; // 0x4
};
static_assert(sizeof(SYSTEM_ACPI_AUDIT_INFORMATION) == 0x8);

_Q_NT_BIT_TEMPLATE struct SYSTEM_BASIC_PERFORMANCE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<std::size_t> AvailablePages; // 0x00
	BitnessType_t<std::size_t> CommittedPages; // 0x04 / 0x08
	BitnessType_t<std::size_t> CommitLimit; // 0x08 / 0x10
	BitnessType_t<std::size_t> PeakCommitment; // 0x0C / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_BASIC_PERFORMANCE_INFORMATION, 0x10, 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN7_SP1
struct QUERY_PERFORMANCE_COUNTER_FLAGS
{
	union
	{
		std::uint32_t Value; // @note: originally "ul"
		struct
		{
			std::uint32_t KernelTransition : 1;
			std::uint32_t Reserved : 31;
		};
	};
};
static_assert(sizeof(QUERY_PERFORMANCE_COUNTER_FLAGS) == 0x4);

struct SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION
{
	std::uint32_t Version; // 0x0
	QUERY_PERFORMANCE_COUNTER_FLAGS Flags; // 0x4
	QUERY_PERFORMANCE_COUNTER_FLAGS ValidFlags; // 0x8
};
static_assert(sizeof(SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION) == 0xC);
#endif

#if Q_NT_VERSION >= Q_NT_WIN8
using SYSTEM_PIXEL_FORMAT = enum _SYSTEM_PIXEL_FORMAT
{
	SystemPixelFormatUnknown = 0,
	SystemPixelFormatR8G8B8 = 1,
	SystemPixelFormatR8G8B8X8 = 2,
	SystemPixelFormatB8G8R8 = 3,
	SystemPixelFormatB8G8R8X8 = 4
};

struct SYSTEM_BOOT_GRAPHICS_INFORMATION
{
	LARGE_INTEGER FrameBuffer; // 0x00
	std::uint32_t Width; // 0x08
	std::uint32_t Height; // 0x0C
	std::uint32_t PixelStride; // 0x10
	std::uint32_t Flags; // 0x14
	SYSTEM_PIXEL_FORMAT Format; // 0x18
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint32_t DisplayRotation; // 0x1C
#endif
};
static_assert(sizeof(SYSTEM_BOOT_GRAPHICS_INFORMATION) == 0x20);

// @todo: move to mem?
_Q_NT_BIT_TEMPLATE struct MEMORY_SCRUB_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> Handle; // 0x0
	BitnessType_t<std::size_t> PagesScrubbed; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(MEMORY_SCRUB_INFORMATION, 0x8, 0x10);

// @todo: move to mem?
_Q_NT_BIT_TEMPLATE struct MEMORY_COMBINE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> Handle; // 0x0
	BitnessType_t<std::size_t> PagesCombined; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(MEMORY_COMBINE_INFORMATION, 0x8, 0x10);

#if Q_NT_VERSION >= Q_NT_WIN10_RS1
_Q_NT_BIT_TEMPLATE struct MEMORY_COMBINE_INFORMATION_EX : MEMORY_COMBINE_INFORMATION<nBitness>
{
	std::uint32_t Flags; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(MEMORY_COMBINE_INFORMATION_EX, 0xC, 0x18);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS2
_Q_NT_BIT_TEMPLATE struct MEMORY_COMBINE_INFORMATION_EX2 : MEMORY_COMBINE_INFORMATION_EX<nBitness>
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> ProcessHandle; // 0x0C / 0x18
};
_Q_NT_BIT_ASSERT(MEMORY_COMBINE_INFORMATION_EX2, 0x10, 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_19H1
struct PEBS_DS_SAVE_AREA32
{
	std::uint32_t BtsBufferBase; // 0x00
	std::uint32_t BtsIndex; // 0x04
	std::uint32_t BtsAbsoluteMaximum; // 0x08
	std::uint32_t BtsInterruptThreshold; // 0x0C
	std::uint32_t PebsBufferBase; // 0x10
	std::uint32_t PebsIndex; // 0x14
	std::uint32_t PebsAbsoluteMaximum; // 0x18
	std::uint32_t PebsInterruptThreshold; // 0x1C
	std::uint32_t PebsGpCounterReset[8]; // 0x20
	std::uint32_t PebsFixedCounterReset[4]; // 0x40
};
static_assert(sizeof(PEBS_DS_SAVE_AREA32) == 0x50);

struct PEBS_DS_SAVE_AREA64
{
	std::uint64_t BtsBufferBase; // 0x00
	std::uint64_t BtsIndex; // 0x08
	std::uint64_t BtsAbsoluteMaximum; // 0x10
	std::uint64_t BtsInterruptThreshold; // 0x18
	std::uint64_t PebsBufferBase; // 0x20
	std::uint64_t PebsIndex; // 0x28
	std::uint64_t PebsAbsoluteMaximum; // 0x30
	std::uint64_t PebsInterruptThreshold; // 0x40
	std::uint64_t PebsGpCounterReset[8]; // 0x48
	std::uint64_t PebsFixedCounterReset[4]; // 0x88
};
static_assert(sizeof(PEBS_DS_SAVE_AREA64) == 0xA0);

using PEBS_DS_SAVE_AREA = union _PEBS_DS_SAVE_AREA
{
	PEBS_DS_SAVE_AREA32 As32Bit;
	PEBS_DS_SAVE_AREA64 As64Bit;
};
static_assert(sizeof(PEBS_DS_SAVE_AREA) == 0xA0);
#else
struct PEBS_DS_SAVE_AREA
{
	std::uint64_t BtsBufferBase; // 0x00
	std::uint64_t BtsIndex; // 0x08
	std::uint64_t BtsAbsoluteMaximum; // 0x10
	std::uint64_t BtsInterruptThreshold; // 0x18
	std::uint64_t PebsBufferBase; // 0x20
	std::uint64_t PebsIndex; // 0x28
	std::uint64_t PebsAbsoluteMaximum; // 0x30
	std::uint64_t PebsInterruptThreshold; // 0x38
	std::uint64_t PebsCounterReset0; // 0x40
	std::uint64_t PebsCounterReset1; // 0x48
	std::uint64_t PebsCounterReset2; // 0x50
	std::uint64_t PebsCounterReset3; // 0x58
};
static_assert(sizeof(PEBS_DS_SAVE_AREA) == 0x60);
#endif

struct PROCESSOR_PROFILE_CONTROL_AREA
{
	PEBS_DS_SAVE_AREA PebsDsSaveArea;
};
static_assert(sizeof(PROCESSOR_PROFILE_CONTROL_AREA) == 0xA0);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<PROCESSOR_PROFILE_CONTROL_AREA*> ProcessorProfileControlArea; // 0x00
	bool Allocate; // 0x04 / 0x08
};
_Q_NT_BIT_ASSERT(SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA, 0x8, 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_ENTROPY_TIMING_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void(NTAPI*)(void*, std::uint32_t)> EntropyRoutine; // 0x00
	BitnessType_t<void(NTAPI*)(void*, std::uint32_t, void*)> InitializationRoutine; // 0x04 / 0x08
	BitnessType_t<void*> InitializationContext; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_ENTROPY_TIMING_INFORMATION, 0xC, 0x18);

struct SYSTEM_CONSOLE_INFORMATION
{
	std::uint32_t DriverLoaded : 1;
	std::uint32_t Spare : 31;
};
static_assert(sizeof(SYSTEM_CONSOLE_INFORMATION) == 0x4);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PLATFORM_BINARY_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint64_t PhysicalAddress; // 0x00
	BitnessType_t<void*> HandoffBuffer; // 0x08
	BitnessType_t<void*> CommandLineBuffer; // 0x0C / 0x10
	std::uint32_t HandoffBufferSize; // 0x10 / 0x18
	std::uint32_t CommandLineBufferSize; // 0x14 / 0x1C
};
_Q_NT_BIT_ASSERT(SYSTEM_PLATFORM_BINARY_INFORMATION, 0x18, 0x20);

#if Q_NT_VERSION >= Q_NT_WINBLUE
_Q_NT_BIT_TEMPLATE struct SYSTEM_POLICY_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> InputData; // 0x00
	BitnessType_t<void*> OutputData; // 0x04 / 0x08
	std::uint32_t InputDataSize; // 0x08 / 0x10
	std::uint32_t OutputDataSize; // 0x0C / 0x14
	std::uint32_t Version; // 0x10 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_POLICY_INFORMATION, 0x14, 0x20);
#endif

struct SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION
{
	std::uint32_t NumberOfLogicalProcessors; // 0x0
	std::uint32_t NumberOfCores; // 0x4
};
static_assert(sizeof(SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION) == 0x8);

_Q_NT_BIT_TEMPLATE struct SYSTEM_DEVICE_DATA_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	UNICODE_STRING<nBitness> DeviceId; // 0x00
	UNICODE_STRING<nBitness> DataName; // 0x08 / 0x10
	std::uint32_t DataType; // 0x10 / 0x20
	std::uint32_t DataBufferLength; // 0x14 / 0x24
	BitnessType_t<void*> DataBuffer; // 0x18 / 0x28
};
_Q_NT_BIT_ASSERT(SYSTEM_DEVICE_DATA_INFORMATION, 0x1C, 0x30);

struct PHYSICAL_CHANNEL_RUN
{
	std::uint32_t NodeNumber; // 0x00
	std::uint32_t ChannelNumber; // 0x04
	std::uint64_t BasePage; // 0x08
	std::uint64_t PageCount; // 0x10
	std::uint32_t Flags; // 0x18
};
static_assert(sizeof(PHYSICAL_CHANNEL_RUN) == 0x20);

struct SYSTEM_MEMORY_TOPOLOGY_INFORMATION
{
	std::uint64_t NumberOfRuns; // 0x00
	std::uint32_t NumberOfNodes; // 0x08
	std::uint32_t NumberOfChannels; // 0x0C
	PHYSICAL_CHANNEL_RUN Run[ANYSIZE_ARRAY]; // 0x10
};

struct SYSTEM_MEMORY_CHANNEL_INFORMATION
{
	std::uint32_t ChannelNumber; // 0x00
	std::uint32_t ChannelHeatIndex; // 0x04
	std::uint64_t TotalPageCount; // 0x08
	std::uint64_t ZeroPageCount; // 0x10
	std::uint64_t FreePageCount; // 0x18
	std::uint64_t StandbyPageCount; // 0x20
};
static_assert(sizeof(SYSTEM_MEMORY_CHANNEL_INFORMATION) == 0x28);

struct SYSTEM_BOOT_LOGO_INFORMATION
{
	std::uint32_t Flags; // 0x0
	std::uint32_t BitmapOffset; // 0x4
};
static_assert(sizeof(SYSTEM_BOOT_LOGO_INFORMATION) == 0x8);

struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX
{
	LARGE_INTEGER IdleTime; // 0x00
	LARGE_INTEGER KernelTime; // 0x08
	LARGE_INTEGER UserTime; // 0x10
	LARGE_INTEGER DpcTime; // 0x18
	LARGE_INTEGER InterruptTime; // 0x20
	std::uint32_t InterruptCount; // 0x28
	std::uint32_t Spare0; // 0x2C
	LARGE_INTEGER AvailableTime; // 0x30
	LARGE_INTEGER Spare1; // 0x38
	LARGE_INTEGER Spare2; // 0x40
};
static_assert(sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX) == 0x48);

#if Q_NT_VERSION >= Q_NT_WIN10_RS1
_Q_NT_BIT_TEMPLATE struct CRITICAL_PROCESS_EXCEPTION_DATA
{
private:
	_Q_NT_BIT_TYPE
public:
	GUID ReportId; // 0x00
	UNICODE_STRING<nBitness> ModuleName; // 0x10
	std::uint32_t ModuleTimestamp; // 0x18 / 0x20
	std::uint32_t ModuleSize; // 0x1C / 0x24
	BitnessType_t<std::uintptr_t> Offset; // 0x20 / 0x28
};
_Q_NT_BIT_ASSERT(CRITICAL_PROCESS_EXCEPTION_DATA, 0x24, 0x30);
#endif

struct SYSTEM_SECUREBOOT_POLICY_INFORMATION
{
	GUID PolicyPublisher; // 0x00
	std::uint32_t PolicyVersion; // 0x10
	std::uint32_t PolicyOptions; // 0x14
};
static_assert(sizeof(SYSTEM_SECUREBOOT_POLICY_INFORMATION) == 0x18);

_Q_NT_BIT_TEMPLATE struct SYSTEM_PAGEFILE_INFORMATION_EX
{
	SYSTEM_PAGEFILE_INFORMATION<nBitness> Info; // 0x00
	std::uint32_t MinimumSize; // 0x18 / 0x20
	std::uint32_t MaximumSize; // 0x1C / 0x24
};
_Q_NT_BIT_ASSERT(SYSTEM_PAGEFILE_INFORMATION_EX, 0x20, 0x28);

struct SYSTEM_SECUREBOOT_INFORMATION
{
	bool SecureBootEnabled; // 0x0
	bool SecureBootCapable; // 0x1
};
static_assert(sizeof(SYSTEM_SECUREBOOT_INFORMATION) == 0x2);

struct PROCESS_DISK_COUNTERS
{
	std::uint64_t BytesRead; // 0x00
	std::uint64_t BytesWritten; // 0x08
	std::uint64_t ReadOperationCount; // 0x10
	std::uint64_t WriteOperationCount; // 0x18
	std::uint64_t FlushOperationCount; // 0x20
};
static_assert(sizeof(PROCESS_DISK_COUNTERS) == 0x28);

#if Q_NT_VERSION >= Q_NT_WIN10_RS1
using SYSTEM_PROCESS_CLASSIFICATION = enum _SYSTEM_PROCESS_CLASSIFICATION : std::uint8_t
{
	SystemProcessClassificationNormal = 0,
	SystemProcessClassificationSystem = 1,
	SystemProcessClassificationSecureSystem = 2,
	SystemProcessClassificationMemCompression = 3,
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
	SystemProcessClassificationRegistry = 4,
#endif
	SystemProcessClassificationMaximum
};
#endif

_Q_NT_BIT_TEMPLATE struct SYSTEM_PROCESS_INFORMATION_EXTENSION
{
private:
	_Q_NT_BIT_TYPE
public:
	PROCESS_DISK_COUNTERS DiskCounters; // 0x0000
	std::uint64_t ContextSwitches; // 0x0028
	union
	{
		std::uint32_t Flags;
		struct
		{
			std::uint32_t HasStrongId : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
			std::uint32_t Classification : 4; // SYSTEM_PROCESS_CLASSIFICATION
#if Q_NT_VERSION >= Q_NT_WIN10_RS2
			std::uint32_t BackgroundActivityModerated : 1;
			std::uint32_t Spare : 26;
#else
			std::uint32_t Spare : 27;
#endif
#else
			std::uint32_t Spare : 31;
#endif
		};
	}; // 0x0030
	std::uint32_t UserSidOffset; // 0x0034
#if Q_NT_VERSION >= Q_NT_WIN10
	std::uint32_t PackageFullNameOffset; // 0x0038
	PROCESS_ENERGY_VALUES EnergyValues; // 0x0040
	std::uint32_t AppIdOffset; // 0x0150
	BitnessType_t<std::size_t> SharedCommitCharge; // 0x0154 / 0x0158
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint32_t JobObjectId; // 0x0158 / 0x160
	std::uint32_t SpareUlong; // 0x015C / 0x164
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint64_t ProcessSequenceNumber; // 0x0160 / 0x168
#endif
};
_Q_NT_BIT_ASSERT(SYSTEM_PROCESS_INFORMATION_EXTENSION, 0x168, 0x170);

struct SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION
{
	bool EfiLauncherEnabled;
};
static_assert(sizeof(SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION) == 0x1);
#endif

#if Q_NT_VERSION >= Q_NT_WINBLUE
struct SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX
{
	bool DebuggerAllowed; // 0x0
	bool DebuggerEnabled; // 0x1
	bool DebuggerPresent; // 0x2
};
static_assert(sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX) == 0x3);

_Q_NT_BIT_TEMPLATE struct SYSTEM_ELAM_CERTIFICATE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> ElamDriverFile;
};
_Q_NT_BIT_ASSERT(SYSTEM_ELAM_CERTIFICATE_INFORMATION, 0x4, 0x8);

struct OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V1
{
	std::uint32_t Version; // 0x0
	std::uint32_t AbnormalResetOccurred; // 0x4
	std::uint32_t OfflineMemoryDumpCapable; // 0x8
};
static_assert(sizeof(OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V1) == 0xC);

// @todo: since WIN10_RS4, but listed since WINBLUE
_Q_NT_BIT_TEMPLATE struct OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V2 : OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V1
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> ResetDataAddress; // 0x0C / 0x10
	std::uint32_t ResetDataSize; // 0x10 / 0x18
};
_Q_NT_BIT_ASSERT(OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V2, 0x14, 0x20);

// processor feature bits
#define KF_BRANCH	0x0000000000020000
#define KF_XSTATE	0x0000000000800000
#define KF_RDTSCP	0x0000000400000000
#define KF_CET_SS	0x0000400000000000
#define KF_XFD		0x0080000000000000

struct SYSTEM_PROCESSOR_FEATURES_INFORMATION
{
	std::uint64_t ProcessorFeatureBits; // 0x0
	std::uint64_t Reserved[3]; // 0x8
};
static_assert(sizeof(SYSTEM_PROCESSOR_FEATURES_INFORMATION) == 0x20);

struct SYSTEM_EDID_INFORMATION
{
	std::uint8_t Edid[128];
};
static_assert(sizeof(SYSTEM_EDID_INFORMATION) == 0x80);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10
_Q_NT_BIT_TEMPLATE struct SYSTEM_MANUFACTURING_INFORMATION
{
	std::uint32_t Options; // 0x0
	UNICODE_STRING<nBitness> ProfileName; // 0x4
};
_Q_NT_BIT_ASSERT(SYSTEM_MANUFACTURING_INFORMATION, 0xC, 0x18);

struct SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION
{
	bool Enabled;
};
static_assert(sizeof(SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION) == 0x1);

struct HV_DETAILS
{
	std::uint32_t Data[4];
};
static_assert(sizeof(HV_DETAILS) == 0x10);

struct SYSTEM_HYPERVISOR_DETAIL_INFORMATION
{
	HV_DETAILS HvVendorAndMaxFunction; // 0x00
	HV_DETAILS HypervisorInterface; // 0x10
	HV_DETAILS HypervisorVersion; // 0x20
	HV_DETAILS HvFeatures; // 0x30
	HV_DETAILS HwFeatures; // 0x40
	HV_DETAILS EnlightenmentInfo; // 0x50
	HV_DETAILS ImplementationLimits; // 0x60
};
static_assert(sizeof(SYSTEM_HYPERVISOR_DETAIL_INFORMATION) == 0x70);

struct SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION
{
	std::uint64_t Cycles[4][2];
};
static_assert(sizeof(SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION) == 0x40);

struct SYSTEM_TPM_INFORMATION
{
	std::uint32_t Flags;
};
static_assert(sizeof(SYSTEM_TPM_INFORMATION) == 0x4);

#if Q_NT_VERSION >= Q_NT_WIN10_RS4
struct SYSTEM_VSM_PROTECTION_INFORMATION
#else
struct SYSTEM_DMA_PROTECTION_INFORMATION
#endif
{
	bool DmaProtectionsAvailable; // 0x0
	bool DmaProtectionsInUse; // 0x1
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
	bool HardwareMbecAvailable; // 0x2
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_20H1
	bool ApicVirtualizationAvailable; // 0x3
#endif
};
#if Q_NT_VERSION >= Q_NT_WIN10_RS4
static_assert(sizeof(SYSTEM_VSM_PROTECTION_INFORMATION) == 0x4);
#else
static_assert(sizeof(SYSTEM_DMA_PROTECTION_INFORMATION) == 0x2);
#endif

struct SYSTEM_KERNEL_DEBUGGER_FLAGS
{
	bool KernelDebuggerIgnoreUmExceptions;
};
static_assert(sizeof(SYSTEM_KERNEL_DEBUGGER_FLAGS) == 0x1);

#define CODEINTEGRITYPOLICY_OPTION_ENABLED 0x01
#define CODEINTEGRITYPOLICY_OPTION_AUDIT 0x02
#define CODEINTEGRITYPOLICY_OPTION_REQUIRE_WHQL 0x04
#define CODEINTEGRITYPOLICY_OPTION_DISABLED_FLIGHTSIGNING 0x08
#define CODEINTEGRITYPOLICY_OPTION_ENABLED_UMCI 0x10
#define CODEINTEGRITYPOLICY_OPTION_ENABLED_UPDATE_POLICY_NOREBOOT 0x20
#define CODEINTEGRITYPOLICY_OPTION_ENABLED_SECURE_SETTING_POLICY 0x40
#define CODEINTEGRITYPOLICY_OPTION_ENABLED_UNSIGNED_SYSTEMINTEGRITY_POLICY 0x80
#define CODEINTEGRITYPOLICY_OPTION_DYNAMIC_CODE_POLICY_ENABLED 0x100
#define CODEINTEGRITYPOLICY_OPTION_RELOAD_POLICY_NO_REBOOT 0x10000000
#define CODEINTEGRITYPOLICY_OPTION_CONDITIONAL_LOCKDOWN 0x20000000
#define CODEINTEGRITYPOLICY_OPTION_NOLOCKDOWN 0x40000000
#define CODEINTEGRITYPOLICY_OPTION_LOCKDOWN 0x80000000

#define CODEINTEGRITYPOLICY_HVCIOPTION_ENABLED 0x01
#define CODEINTEGRITYPOLICY_HVCIOPTION_STRICT 0x02
#define CODEINTEGRITYPOLICY_HVCIOPTION_DEBUG 0x04

struct SYSTEM_CODEINTEGRITYPOLICY_INFORMATION
{
	union
	{
		std::uint32_t Options; // CODEINTEGRITYPOLICY_OPTION_*
		struct
		{
			std::uint32_t Enabled : 1;
			std::uint32_t Audit : 1;
			std::uint32_t RequireWHQL : 1;
			std::uint32_t DisabledFlightSigning : 1;
			std::uint32_t EnabledUMCI : 1;
			std::uint32_t EnabledUpdatePolicyNoReboot : 1;
			std::uint32_t EnabledSecureSettingPolicy : 1;
			std::uint32_t EnabledUnsignedSystemIntegrityPolicy : 1;
			std::uint32_t DynamicCodePolicyEnabled : 1;
			std::uint32_t Spare : 19;
			std::uint32_t ReloadPolicyNoReboot : 1;
			std::uint32_t ConditionalLockdown : 1;
			std::uint32_t NoLockdown : 1;
			std::uint32_t Lockdown : 1;
		};
	}; // 0x00
	union
	{
		std::uint32_t HVCIOptions; // CODEINTEGRITYPOLICY_HVCIOPTION_*
		struct
		{
			std::uint32_t HVCIEnabled : 1;
			std::uint32_t HVCIStrict : 1;
			std::uint32_t HVCIDebug : 1;
			std::uint32_t HVCISpare : 29;
		};
	}; // 0x04
	std::uint64_t Version; // 0x08
	GUID PolicyGuid; // 0x10
};
static_assert(sizeof(SYSTEM_CODEINTEGRITYPOLICY_INFORMATION) == 0x20);

struct SYSTEM_ISOLATED_USER_MODE_INFORMATION
{
	struct
	{
		std::uint8_t SecureKernelRunning : 1;
		std::uint8_t HvciEnabled : 1;
		std::uint8_t HvciStrictMode : 1;
		std::uint8_t DebugEnabled : 1;
		std::uint8_t FirmwarePageProtection : 1;
		std::uint8_t EncryptionKeyAvailable : 1;
		std::uint8_t SpareFlags : 2;
		std::uint8_t TrustletRunning : 1;
		std::uint8_t HvciDisableAllowed : 1;
		std::uint8_t HardwareEnforcedVbs : 1;
		std::uint8_t NoSecrets : 1;
		std::uint8_t EncryptionKeyPersistent : 1;
		std::uint8_t HardwareEnforcedHvpt : 1;
		std::uint8_t HardwareHvptAvailable : 1;
		std::uint8_t SpareFlags2 : 1;
	}; // 0x0
	std::uint8_t Spare0[6]; // 0x2
	std::uint64_t Spare1; // 0x8
};
static_assert(sizeof(SYSTEM_ISOLATED_USER_MODE_INFORMATION) == 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_SINGLE_MODULE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> TargetModuleAddress; // 0x0
	RTL_PROCESS_MODULE_INFORMATION_EX<nBitness> ExInfo; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_SINGLE_MODULE_INFORMATION, 0x130, 0x148);

struct SYSTEM_INTERRUPT_CPU_SET_INFORMATION
{
	std::uint32_t Gsiv; // 0x0
	std::uint16_t Group; // 0x4
	std::uint64_t CpuSets; // 0x8
};
static_assert(sizeof(SYSTEM_INTERRUPT_CPU_SET_INFORMATION) == 0x10);

struct SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION
{
	SYSTEM_SECUREBOOT_POLICY_INFORMATION PolicyInformation; // 0x00
	std::uint32_t PolicySize; // 0x18
	std::uint8_t Policy[ANYSIZE_ARRAY]; // 0x1C
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_ROOT_SILO_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t NumberOfSilos; // 0x0
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint32_t SiloIdList[ANYSIZE_ARRAY]; // 0x4
#elif Q_NT_VERSION >= Q_NT_WIN10_TH2
	GUID SiloIdList[ANYSIZE_ARRAY]; // 0x4
#else
	BitnessType_t<void*> SiloIdList[ANYSIZE_ARRAY]; // 0x4 / 0x8
#endif
};

struct SYSTEM_CPU_SET_TAG_INFORMATION
{
	std::uint64_t Tag; // 0x0
	std::uint64_t CpuSets[ANYSIZE_ARRAY]; // 0x8
};
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_TH2
struct SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION
{
	std::uint32_t ExtentCount; // 0x00
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint32_t ValidStructureSize; // 0x04
#else
	std::uint32_t Reserved0; // 0x04
#endif
	std::uint32_t NextExtentIndex; // 0x08
	std::uint32_t ExtentRestart; // 0x0C
	std::uint32_t CycleCount; // 0x10
	std::uint32_t TimeoutCount; // 0x14
	std::uint64_t CycleTime; // 0x18
	std::uint64_t CycleTimeMax; // 0x20
	std::uint64_t ExtentTime; // 0x28
	std::uint32_t ExtentTimeIndex; // 0x30
	std::uint32_t ExtentTimeMaxIndex; // 0x34
	std::uint64_t ExtentTimeMax; // 0x38
	std::uint64_t HyperFlushTimeMax; // 0x40
	std::uint64_t TranslateVaTimeMax; // 0x48
	std::uint64_t DebugExemptionCount; // 0x50
	std::uint64_t TbHitCount; // 0x58
	std::uint64_t TbMissCount; // 0x60
	std::uint64_t VinaPendingYield; // 0x68
	std::uint64_t HashCycles; // 0x70
	std::uint32_t HistogramOffset; // 0x78
	std::uint32_t HistogramBuckets; // 0x7C
	std::uint32_t HistogramShift; // 0x80
	std::uint32_t Reserved1; // 0x84
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
	std::uint64_t PageNotPresentCount; // 0x88
#endif
};
static_assert(sizeof(SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION) == 0x90);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS1
struct SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION
{
	std::uint32_t PlatformManifestSize; // 0x0
	std::uint8_t PlatformManifest[ANYSIZE_ARRAY]; // 0x4
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_INTERRUPT_STEERING_INFORMATION_INPUT
{
	std::uint32_t Gsiv; // 0x0
	std::uint8_t ControllerInterrupt; // 0x4
	std::uint8_t EdgeInterrupt; // 0x5
	std::uint8_t IsPrimaryInterrupt; // 0x6
	GROUP_AFFINITY<nBitness> TargetAffinity; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_INTERRUPT_STEERING_INFORMATION_INPUT, 0x14, 0x18);

using SYSTEM_INTERRUPT_STEERING_INFORMATION_OUTPUT = union _SYSTEM_INTERRUPT_STEERING_INFORMATION_OUTPUT
{
	std::uint32_t AsULONG;
	struct
	{
		std::uint32_t Enabled : 1;
		std::uint32_t Reserved : 31;
	};
};
static_assert(sizeof(SYSTEM_INTERRUPT_STEERING_INFORMATION_OUTPUT) == 0x4);

// @todo: since WIN11_21H2, but listed since WIN10_RS1
struct SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION
{
	std::uint32_t Machine : 16;
	std::uint32_t KernelMode : 1;
	std::uint32_t UserMode : 1;
	std::uint32_t Native : 1;
	std::uint32_t Process : 1;
	std::uint32_t WoW64Container : 1;
	std::uint32_t ReservedZero0 : 11;
};
static_assert(sizeof(SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION) == 0x4);

struct SYSTEM_MEMORY_USAGE_INFORMATION
{
	std::uint64_t TotalPhysicalBytes; // 0x00
	std::uint64_t AvailableBytes; // 0x08
	std::int64_t ResidentAvailableBytes; // 0x10
	std::uint64_t CommittedBytes; // 0x18
	std::uint64_t SharedCommittedBytes; // 0x20
	std::uint64_t CommitLimitBytes; // 0x28
	std::uint64_t PeakCommitmentBytes; // 0x30
};
static_assert(sizeof(SYSTEM_MEMORY_USAGE_INFORMATION) == 0x38);

_Q_NT_BIT_TEMPLATE struct SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> ImageFile; // 0x0
#if Q_NT_VERSION >= Q_NT_WIN10_RS3
	std::uint32_t Type; // 0x4 / 0x8
#endif
};
_Q_NT_BIT_ASSERT(SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION, 0x8, 0x10);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS2
struct SYSTEM_PHYSICAL_MEMORY_INFORMATION
{
	std::uint64_t TotalPhysicalBytes; // 0x00
	std::uint64_t LowestPhysicalAddress; // 0x08
	std::uint64_t HighestPhysicalAddress; // 0x10
};
static_assert(sizeof(SYSTEM_PHYSICAL_MEMORY_INFORMATION) == 0x18);

using SYSTEM_ACTIVITY_MODERATION_STATE = enum _SYSTEM_ACTIVITY_MODERATION_STATE
{
	SystemActivityModerationStateSystemManaged = 0,
	SystemActivityModerationStateUserManagedAllowThrottling = 1,
	SystemActivityModerationStateUserManagedDisableThrottling = 2,
	MaxSystemActivityModerationState = 3
};

#if Q_NT_VERSION >= Q_NT_WIN10_RS3
using SYSTEM_ACTIVITY_MODERATION_APP_TYPE = enum _SYSTEM_ACTIVITY_MODERATION_APP_TYPE
{
	SystemActivityModerationAppTypeClassic = 0,
	SystemActivityModerationAppTypePackaged = 1,
	MaxSystemActivityModerationAppType = 2
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_ACTIVITY_MODERATION_INFO
{
	UNICODE_STRING<nBitness> Identifier; // 0x00
	SYSTEM_ACTIVITY_MODERATION_STATE ModerationState; // 0x08 / 0x10
	SYSTEM_ACTIVITY_MODERATION_APP_TYPE AppType; // 0x0C / 0x14
};
_Q_NT_BIT_ASSERT(SYSTEM_ACTIVITY_MODERATION_INFO, 0x10, 0x18);
#else
_Q_NT_BIT_TEMPLATE struct SYSTEM_ACTIVITY_MODERATION_EXE_STATE
{
	UNICODE_STRING<nBitness> ExePathNt; // 0x00
	SYSTEM_ACTIVITY_MODERATION_STATE ModerationState; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_ACTIVITY_MODERATION_EXE_STATE, 0xC, 0x18);
#endif

_Q_NT_BIT_TEMPLATE struct SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> UserKeyHandle;
};
_Q_NT_BIT_ASSERT(SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS, 0x4, 0x8);

struct SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION
{
	union
	{
		std::uint32_t Flags;
		struct
		{
			std::uint32_t Locked : 1;
#if Q_NT_VERSION <= Q_NT_WIN10_RS4
			std::uint32_t Unlockable : 1;
#endif
			std::uint32_t UnlockApplied : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS3
			std::uint32_t UnlockIdValid : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
			std::uint32_t Reserved : 29;
#else
			std::uint32_t Reserved : 28;
#endif
#endif
		};
	}; // 0x0
#if Q_NT_VERSION >= Q_NT_WIN10_RS3
	std::uint8_t UnlockId[32]; // 0x4
#endif
};
static_assert(sizeof(SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION) == 0x24);

struct SYSTEM_FLUSH_INFORMATION
{
	std::uint32_t SupportedFlushMethods; // 0x00
	std::uint32_t ProcessorCacheFlushSize; // 0x04
	std::uint64_t SystemFlushCapabilities; // 0x08
	std::uint64_t Reserved[2]; // 0x10
};
static_assert(sizeof(SYSTEM_FLUSH_INFORMATION) == 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS3
struct SYSTEM_WRITE_CONSTRAINT_INFORMATION
{
	std::uint32_t WriteConstraintPolicy; // 0x0
	std::uint32_t Reserved; // 0x4
};
static_assert(sizeof(SYSTEM_WRITE_CONSTRAINT_INFORMATION) == 0x8);

// @todo: since WIN10_RS4, but listed since WIN10_RS3
struct SYSTEM_KERNEL_VA_SHADOW_INFORMATION
{
	union
	{
		std::uint32_t KvaShadowFlags;
		struct
		{
			std::uint32_t KvaShadowEnabled : 1;
			std::uint32_t KvaShadowUserGlobal : 1;
			std::uint32_t KvaShadowPcid : 1;
			std::uint32_t KvaShadowInvpcid : 1;
			std::uint32_t KvaShadowRequired : 1; // below since RS4
			std::uint32_t KvaShadowRequiredAvailable : 1;
			std::uint32_t InvalidPteBit : 6;
			std::uint32_t L1DataCacheFlushSupported : 1;
			std::uint32_t L1TerminalFaultMitigationPresent : 1;
			std::uint32_t Reserved : 18;
		};
	};
};
static_assert(sizeof(SYSTEM_KERNEL_VA_SHADOW_INFORMATION) == 0x4);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS4
_Q_NT_BIT_TEMPLATE struct SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<HANDLE> FileHandle; // 0x00
	std::uint32_t ImageSize; // 0x04 / 0x08
	BitnessType_t<void*> Image; // 0x8 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION, 0xC, 0x18);

// @todo: since WIN10_RS5, but listed since WIN10_RS4
_Q_NT_BIT_TEMPLATE struct SYSTEM_FIRMWARE_PARTITION_INFORMATION
{
	UNICODE_STRING<nBitness> FirmwarePartition;
};
_Q_NT_BIT_ASSERT(SYSTEM_FIRMWARE_PARTITION_INFORMATION, 0x8, 0x10);

struct SYSTEM_SPECULATION_CONTROL_INFORMATION
{
	union
	{
		std::uint32_t Flags;
		struct
		{
			std::uint32_t BpbEnabled : 1;
			std::uint32_t BpbDisabledSystemPolicy : 1;
			std::uint32_t BpbDisabledNoHardwareSupport : 1;
			std::uint32_t SpecCtrlEnumerated : 1;
			std::uint32_t SpecCmdEnumerated : 1;
			std::uint32_t IbrsPresent : 1;
			std::uint32_t StibpPresent : 1;
			std::uint32_t SmepPresent : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
			std::uint32_t SpeculativeStoreBypassDisableAvailable : 1;
			std::uint32_t SpeculativeStoreBypassDisableSupported : 1;
			std::uint32_t SpeculativeStoreBypassDisabledSystemWide : 1;
			std::uint32_t SpeculativeStoreBypassDisabledKernel : 1;
			std::uint32_t SpeculativeStoreBypassDisableRequired : 1;
			std::uint32_t BpbDisabledKernelToUser : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_19H1
			std::uint32_t SpecCtrlRetpolineEnabled : 1;
			std::uint32_t SpecCtrlImportOptimizationEnabled : 1;
			std::uint32_t EnhancedIbrs : 1;
			std::uint32_t HvL1tfStatusAvailable : 1;
			std::uint32_t HvL1tfProcessorNotAffected : 1;
			std::uint32_t HvL1tfMigitationEnabled : 1;
			std::uint32_t HvL1tfMigitationNotEnabled_Hardware : 1;
			std::uint32_t HvL1tfMigitationNotEnabled_LoadOption : 1;
			std::uint32_t HvL1tfMigitationNotEnabled_CoreScheduler : 1;
			std::uint32_t EnhancedIbrsReported : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_19H2
			std::uint32_t MdsHardwareProtected : 1;
			std::uint32_t MbClearEnabled : 1;
			std::uint32_t MbClearReported : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_22H2
			std::uint32_t ReservedTaa : 4;
			std::uint32_t Reserved : 1;
#else
			std::uint32_t Reserved : 5;
#endif
#else
			std::uint32_t Reserved : 8;
#endif
#else
			std::uint32_t Reserved : 18;
#endif
#else
			std::uint32_t Reserved : 24;
#endif
		};
	} SpeculationControlFlags; // 0x0
#if Q_NT_VERSION >= Q_NT_WIN10_22H2
	union
	{
		std::uint32_t Flags;
		struct
		{
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
			std::uint32_t SbdrSsdpHardwareProtected : 1;
			std::uint32_t FbsdpHardwareProtected : 1;
			std::uint32_t PsdpHardwareProtected : 1;
			std::uint32_t FbClearEnabled : 1;
			std::uint32_t FbClearReported : 1;
#else
			std::uint32_t Reserved1 : 5;
#endif
			std::uint32_t BhbEnabled : 1;
			std::uint32_t BhbDisabledSystemPolicy : 1;
			std::uint32_t BhbDisabledNoHardwareSupport : 1;
#if Q_NT_VERSION >= Q_NT_WIN11_23H2
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
			std::uint32_t BranchConfusionStatus : 2;
			std::uint32_t BranchConfusionReported : 1;
#else
			std::uint32_t Reserved2 : 3;
#endif
			std::uint32_t RdclHardwareProtectedReported : 1;
			std::uint32_t RdclHardwareProtected : 1;
			std::uint32_t Reserved3 : 4;
			std::uint32_t Reserved4 : 3;
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
			std::uint32_t DivideByZeroReported : 1;
			std::uint32_t DivideByZeroStatus : 1;
			std::uint32_t Reserved5 : 3;
			std::uint32_t Reserved : 7;
#else
			std::uint32_t Reserved : 12;
#endif
#else
			std::uint32_t Reserved : 24;
#endif
		};
	} SpeculationControlFlags2; // 0x4
#endif
};
static_assert(sizeof(SYSTEM_SPECULATION_CONTROL_INFORMATION) == 0x8);

struct SYSTEM_DMA_GUARD_POLICY_INFORMATION
{
	bool DmaGuardPolicyEnabled;
};
static_assert(sizeof(SYSTEM_DMA_GUARD_POLICY_INFORMATION) == 0x1);

struct SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION
{
	std::uint8_t EnclaveLaunchSigner[32];
};
static_assert(sizeof(SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION) == 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_RS5
struct SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION
{
	std::uint64_t WorkloadClass; // 0x0
	std::uint64_t CpuSets[ANYSIZE_ARRAY]; // 0x8
};
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_19H1
struct SYSTEM_SECURITY_MODEL_INFORMATION
{
	union
	{
		std::uint32_t SecurityModelFlags;
		struct
		{
#if Q_NT_VERSION >= Q_NT_WIN11
			std::uint32_t ReservedFlag : 1;
#else
			std::uint32_t SModeAdminlessEnabled : 1;
#endif
			std::uint32_t AllowDeviceOwnerProtectionDowngrade : 1;
			std::uint32_t Reserved : 30;
		};
	};
};
static_assert(sizeof(SYSTEM_SECURITY_MODEL_INFORMATION) == 0x4);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_20H1
struct SECURE_SPECULATION_CONTROL_INFORMATION
{
	std::uint32_t KvaShadowSupported : 1;
	std::uint32_t KvaShadowEnabled : 1;
	std::uint32_t KvaShadowUserGlobal : 1;
	std::uint32_t KvaShadowPcid : 1;
	std::uint32_t MbClearEnabled : 1;
#if Q_NT_VERSION >= Q_NT_WIN11
	std::uint32_t L1TFMitigated : 1;
	std::uint32_t BpbEnabled : 1;
	std::uint32_t IbrsPresent : 1;
	std::uint32_t EnhancedIbrs : 1;
	std::uint32_t StibpPresent : 1;
	std::uint32_t SsbdSupported : 1;
	std::uint32_t SsbdRequired : 1;
	std::uint32_t BpbKernelToUser : 1;
	std::uint32_t BpbUserToKernel : 1;
#if Q_NT_VERSION >= Q_NT_WIN11_23H2
	std::uint32_t ReturnSpeculate : 1;
	std::uint32_t BranchConfusionSafe : 1;
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	std::uint32_t SsbsEnabledAlways : 1;
	std::uint32_t SsbsEnabledKernel : 1;
	std::uint32_t Reserved : 14;
#else
	std::uint32_t Reserved : 16;
#endif
#else
	std::uint32_t Reserved : 18;
#endif
#else
	std::uint32_t Reserved : 27;
#endif
}; // @note: flattened nested struct "SecureSpeculationFlags"
static_assert(sizeof(SECURE_SPECULATION_CONTROL_INFORMATION) == 0x4);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10_20H2
// @todo: since WIN11_21H2, but listed since WIN10_20H2
_Q_NT_BIT_TEMPLATE struct SYSTEM_FIRMWARE_RAMDISK_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t Version; // 0x00
	std::uint32_t BlockSize; // 0x04
	BitnessType_t<std::uintptr_t> BaseAddress; // 0x08
	BitnessType_t<std::size_t> Size; // 0x0C / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_FIRMWARE_RAMDISK_INFORMATION, 0x10, 0x18);

// @todo: since WIN10_21H1, but listed since WIN10_20H2
struct SYSTEM_SHADOW_STACK_INFORMATION
{
	union
	{
		std::uint32_t Flags;
		struct
		{
			std::uint32_t CetCapable : 1;
			std::uint32_t UserCetAllowed : 1;
			std::uint32_t ReservedForUserCet : 6;
			std::uint32_t KernelCetEnabled : 1;
#if Q_NT_VERSION >= Q_NT_WIN11
			std::uint32_t KernelCetAuditModeEnabled : 1;
			std::uint32_t ReservedForKernelCet : 6;
#else
			std::uint32_t ReservedForKernelCet : 7;
#endif
			std::uint32_t Reserved : 16;
		};
	};
};
static_assert(sizeof(SYSTEM_SHADOW_STACK_INFORMATION) == 0x4);

// @todo: since WIN11_21H2, but listed since WIN10_20H2
struct SYSTEM_BUILD_VERSION_INFORMATION
{
	std::uint16_t LayerNumber; // 0x0000
	std::uint16_t LayerCount; // 0x0002
	std::uint32_t OsMajorVersion; // 0x0004
	std::uint32_t OsMinorVersion; // 0x0008
	std::uint32_t NtBuildNumber; // 0x000C
	std::uint32_t NtBuildQfe; // 0x0010
	std::uint8_t LayerName[128]; // 0x0014
	std::uint8_t NtBuildBranch[128]; // 0x0094
	std::uint8_t NtBuildLab[128]; // 0x0114
	std::uint8_t NtBuildLabEx[128]; // 0x0194
	std::uint8_t NtBuildStamp[26]; // 0x0214
	std::uint8_t NtBuildArch[16]; // 0x022E
	union
	{
		std::uint32_t Value; // @note: originally "Value32"
		struct
		{
			std::uint32_t IsTopLevel : 1;
			std::uint32_t IsChecked : 1;
		};
	} Flags; // 0x240
};
static_assert(sizeof(SYSTEM_BUILD_VERSION_INFORMATION) == 0x244);

// @todo: since WIN11_21H2, but listed since WIN10_20H2
struct SYSTEM_POOL_LIMIT_MEM_INFO
{
	std::uint64_t MemoryLimit; // 0x0
	std::uint64_t NotificationLimit; // 0x8
};
static_assert(sizeof(SYSTEM_POOL_LIMIT_MEM_INFO) == 0x10);

// @todo: since WIN11_21H2, but listed since WIN10_20H2
struct SYSTEM_POOL_LIMIT_INFO
{
	std::uint32_t PoolTag; // 0x00
	SYSTEM_POOL_LIMIT_MEM_INFO MemLimits[2]; // 0x04
	WNF_STATE_NAME NotificationHandle; // 0x28
};
static_assert(sizeof(SYSTEM_POOL_LIMIT_INFO) == 0x30);

// @todo: since WIN11_21H2, but listed since WIN10_20H2
struct SYSTEM_POOL_LIMIT_INFORMATION
{
	std::uint32_t Version; // 0x0
	std::uint32_t EntryCount; // 0x4
	SYSTEM_POOL_LIMIT_INFO LimitEntries[ANYSIZE_ARRAY]; // 0x8
};
#endif

#if Q_NT_VERSION >= Q_NT_WIN11
struct SYSTEM_DPC_WATCHDOG_CONFIGURATION_INFORMATION
{
	union
	{
		struct
		{
			std::uint32_t Version : 8;
			std::uint32_t AllFlags : 24;
		};
		struct
		{
			struct
			{
				std::uint32_t Dummy : 8;
				std::uint32_t SingleDpcTimeLimitPresent : 1;
				std::uint32_t CumulativeDpcTimeLimitPresent : 1;
				std::uint32_t SingleDpcSoftTimeLimitPresent : 1;
				std::uint32_t CumulativeDpcSoftTimeLimitPresent : 1;

				std::uint32_t Reserved : 20;
			};
		} Flags;
	}; // 0x00
	std::uint32_t SingleDpcTimeLimitMs; // 0x04
	std::uint32_t CumulativeDpcTimeLimitMs; // 0x08
	std::uint32_t SingleDpcSoftTimeLimitMs; // 0x0C
	std::uint32_t CumulativeDpcSoftTimeLimitMs; // 0x10
};
static_assert(sizeof(SYSTEM_DPC_WATCHDOG_CONFIGURATION_INFORMATION) == 0x14);

struct SYSTEM_DPC_WATCHDOG_CONFIGURATION_INFORMATION_V2
{
	union
	{
		struct
		{
			std::uint32_t Version : 8;
			std::uint32_t AllFlags : 24;
		};
		struct
		{
			struct
			{
				std::uint32_t Dummy : 8;
				std::uint32_t SingleDpcTimeLimitPresent : 1;
				std::uint32_t CumulativeDpcTimeLimitPresent : 1;
				std::uint32_t SingleDpcSoftTimeLimitPresent : 1;
				std::uint32_t CumulativeDpcSoftTimeLimitPresent : 1;
				std::uint32_t SingleDpcProfileThresholdPresent : 1;
				std::uint32_t CumulativeDpcProfileThresholdPresent : 1;
				std::uint32_t ProfileBufferSizePresent : 1;
				std::uint32_t Reserved : 17;
			};
		} Flags;
	}; // 0x00
	std::uint32_t SingleDpcTimeLimitMs; // 0x04
	std::uint32_t CumulativeDpcTimeLimitMs; // 0x08
	std::uint32_t SingleDpcSoftTimeLimitMs; // 0x0C
	std::uint32_t CumulativeDpcSoftTimeLimitMs; // 0x10
	std::uint32_t SingleDpcProfileThresholdMs; // 0x14
	std::uint32_t CumulativeDpcProfileThresholdMs; // 0x18
	std::uint32_t ProfileBufferSizeBytes; // 0x1C
};
static_assert(sizeof(SYSTEM_DPC_WATCHDOG_CONFIGURATION_INFORMATION_V2) == 0x20);

_Q_NT_BIT_TEMPLATE struct SYSTEM_XFG_FAILURE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> ReturnAddress; // 0x00
	BitnessType_t<void*> TargetAddress; // 0x04 / 0x08
	std::uint32_t DispatchMode; // 0x08 / 0x10
	std::uint64_t XfgValue; // 0x10 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_XFG_FAILURE_INFORMATION, 0x18, 0x20);
#endif

#if Q_NT_VERSION >= Q_NT_WIN11_22H2
using SYSTEM_IOMMU_STATE = enum _SYSTEM_IOMMU_STATE : std::int32_t
{
	IommuStateBlock = 0,
	IommuStateUnblock = 1
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_IOMMU_STATE_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	SYSTEM_IOMMU_STATE State; // 0x0
	BitnessType_t<void*> Pdo; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_IOMMU_STATE_INFORMATION, 0x8, 0x10);

_Q_NT_BIT_TEMPLATE struct HV_MINROOT_NUMA_LPS
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t NodeIndex; // 0x0
	BitnessType_t<std::uintptr_t> Mask[
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
		32
#else
		16
#endif
	]; // 0x4 / 0x8
};
_Q_NT_BIT_ASSERT(HV_MINROOT_NUMA_LPS, 0x84, 0x108);

_Q_NT_BIT_TEMPLATE struct SYSTEM_HYPERVISOR_MINROOT_INFORMATION
{
	std::uint32_t NumProc; // 0x00
	std::uint32_t RootProc; // 0x04
	std::uint32_t RootProcNumaNodesSpecified; // 0x08
	std::uint16_t RootProcNumaNodes[64]; // 0x0C
	std::uint32_t RootProcPerCore; // 0x8C
	std::uint32_t RootProcPerNode; // 0x90
	std::uint32_t RootProcNumaNodesLpsSpecified; // 0x94
	HV_MINROOT_NUMA_LPS<nBitness> RootProcNumaNodeLps[64]; // 0x98
};
_Q_NT_BIT_ASSERT(SYSTEM_HYPERVISOR_MINROOT_INFORMATION, 0x2198, 0x4298);

_Q_NT_BIT_TEMPLATE struct SYSTEM_HYPERVISOR_BOOT_PAGES_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t RangeCount; // 0x0
	BitnessType_t<std::uintptr_t> RangeArray[ANYSIZE_ARRAY]; // 0x4 / 0x8
};

struct SYSTEM_POINTER_AUTH_INFORMATION
{
	union
	{
		std::uint16_t SupportedFlags;
		struct
		{
			std::uint16_t AddressAuthSupported : 1;
			std::uint16_t AddressAuthQarma : 1;
			std::uint16_t GenericAuthSupported : 1;
			std::uint16_t GenericAuthQarma : 1;
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
			std::uint16_t AddressAuthFaulting : 1;
			std::uint16_t SupportedReserved : 11;
#else
			std::uint16_t SupportedReserved : 12;
#endif
		};
	}; // 0x0
	union
	{
		std::uint16_t EnabledFlags;
		struct
		{
			std::uint16_t UserPerProcessIpAuthEnabled : 1;
			std::uint16_t UserGlobalIpAuthEnabled : 1;
			std::uint16_t UserEnabledReserved : 6;
			std::uint16_t KernelIpAuthEnabled : 1;
			std::uint16_t KernelEnabledReserved : 7;
		};
	}; // 0x2
};
static_assert(sizeof(SYSTEM_POINTER_AUTH_INFORMATION) == 0x4);

_Q_NT_BIT_TEMPLATE struct SYSTEM_ORIGINAL_IMAGE_FEATURE_INFORMATION_INPUT
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t Version; // 0x00
	BitnessType_t<wchar_t*> FeatureName; // 0x04 / 0x08
	std::uint32_t BornOnVersion; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_ORIGINAL_IMAGE_FEATURE_INFORMATION_INPUT, 0xC, 0x18);

struct SYSTEM_ORIGINAL_IMAGE_FEATURE_INFORMATION_OUTPUT
{
	std::uint32_t Version; // 0x0
	bool FeatureIsEnabled; // 0x4
};
static_assert(sizeof(SYSTEM_ORIGINAL_IMAGE_FEATURE_INFORMATION_OUTPUT) == 0x8);
#endif

#if Q_NT_VERSION >= Q_NT_WIN11_24H2
struct SYSTEM_MEMORY_NUMA_INFORMATION_INPUT
{
	std::uint32_t Version; // 0x0
	std::uint32_t TargetNodeNumber; // 0x4
	std::uint32_t Flags; // 0x8
};
static_assert(sizeof(SYSTEM_MEMORY_NUMA_INFORMATION_INPUT) == 0xC);

struct SYSTEM_MEMORY_NUMA_INFORMATION_OUTPUT
{
	std::uint32_t Version; // 0x0
	std::uint32_t Size; // 0x4
	std::uint32_t InitiatorNode; // 0x8
	union
	{
		std::uint32_t Flags;
		struct
		{
			std::uint32_t IsAttached : 1;
			std::uint32_t Reserved : 31;
		};
	}; // 0xC
};
static_assert(sizeof(SYSTEM_MEMORY_NUMA_INFORMATION_OUTPUT) == 0x10);

using SYSTEM_MEMORY_NUMA_PERFORMANCE_QUERY_DATA_TYPES = enum _SYSTEM_MEMORY_NUMA_PERFORMANCE_QUERY_DATA_TYPES
{
	SystemMemoryNumaPerformanceQuery_ReadLatency = 0,
	SystemMemoryNumaPerformanceQuery_ReadBandwidth = 1,
	SystemMemoryNumaPerformanceQuery_WriteLatency = 2,
	SystemMemoryNumaPerformanceQuery_WriteBandwidth = 3,
	SystemMemoryNumaPerformanceQuery_Latency = 4,
	SystemMemoryNumaPerformanceQuery_Bandwidth = 5,
	SystemMemoryNumaPerformanceQuery_AllDataTypes = 6,
	SystemMemoryNumaPerformanceQuery_MaxDataType = 7
};

struct SYSTEM_MEMORY_NUMA_PERFORMANCE_INFORMATION_INPUT
{
	std::uint32_t Version; // 0x0
	std::uint32_t TargetNodeNumber; // 0x4
	SYSTEM_MEMORY_NUMA_PERFORMANCE_QUERY_DATA_TYPES QueryDataType; // 0x8
	std::uint32_t Flags; // 0xC
};
static_assert(sizeof(SYSTEM_MEMORY_NUMA_PERFORMANCE_INFORMATION_INPUT) == 0x10);

_Q_NT_BIT_TEMPLATE struct SYSTEM_MEMORY_NUMA_PERFORMANCE_ENTRY
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t InitiatorNodeNumber; // 0x00
	std::uint32_t TargetNodeNumber; // 0x04
	SYSTEM_MEMORY_NUMA_PERFORMANCE_QUERY_DATA_TYPES DataType; // 0x08
	union
	{
		bool Flags;
		struct
		{
			bool MinTransferSizeToAchieveValues : 1;
			bool NonSequentialTransfers : 1;
			bool Reserved : 6;
		};
	}; // 0x0C
	BitnessType_t<std::size_t> MinTransferSizeInBytes; // 0x10
	BitnessType_t<std::uintptr_t> EntryValue; // 0x14 / 0x18
};
_Q_NT_BIT_ASSERT(SYSTEM_MEMORY_NUMA_PERFORMANCE_ENTRY, 0x18, 0x20);

_Q_NT_BIT_TEMPLATE struct SYSTEM_MEMORY_NUMA_PERFORMANCE_INFORMATION_OUTPUT
{
	std::uint32_t Version; // 0x0
	std::uint32_t Size; // 0x4
	std::uint32_t EntryCount; // 0x8
	SYSTEM_MEMORY_NUMA_PERFORMANCE_ENTRY<nBitness> PerformanceEntries[ANYSIZE_ARRAY]; // 0xC
};

_Q_NT_BIT_TEMPLATE struct SYSTEM_OSL_RAMDISK_ENTRY
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint32_t BlockSize; // 0x00
	BitnessType_t<std::uintptr_t> BaseAddress; // 0x04 / 0x08
	BitnessType_t<std::size_t> Size; // 0x08 / 0x10
};
_Q_NT_BIT_ASSERT(SYSTEM_OSL_RAMDISK_ENTRY, 0xC, 0x18);

_Q_NT_BIT_TEMPLATE struct SYSTEM_TRUSTEDAPPS_RUNTIME_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	union
	{
		std::uint64_t Flags;
		struct
		{
			std::uint64_t Supported : 1;
			std::uint64_t Spare : 63;
		};
	}; // 0x0
	BitnessType_t<void*> RemoteBreakingRoutine; // 0x8
};
_Q_NT_BIT_ASSERT(SYSTEM_TRUSTEDAPPS_RUNTIME_INFORMATION, 0x10, 0x10);

template <std::size_t>
struct SYSTEM_BAD_PAGE_INFORMATION { };

template <>
struct SYSTEM_BAD_PAGE_INFORMATION<32U>
{
	std::uint32_t PhysicalPageNumber : 20;
	std::uint32_t Reserved : 10;
	std::uint32_t Pending : 1;
	std::uint32_t Poisoned : 1;
};
static_assert(sizeof(SYSTEM_BAD_PAGE_INFORMATION<32U>) == 0x4);

template <>
struct SYSTEM_BAD_PAGE_INFORMATION<64U>
{
	std::uint64_t PhysicalPageNumber : 52;
	std::uint64_t Reserved : 10;
	std::uint64_t Pending : 1;
	std::uint64_t Poisoned : 1;
};
static_assert(sizeof(SYSTEM_BAD_PAGE_INFORMATION<64U>) == 0x8);

_Q_NT_BIT_TEMPLATE struct SYSTEM_OSL_RAMDISK_INFORMATION
{
	std::uint32_t Version; // 0x0
	std::uint32_t Count; // 0x4
	SYSTEM_OSL_RAMDISK_ENTRY<nBitness> Entries[ANYSIZE_ARRAY]; // 0x8
};
#endif
#pragma pack(pop)