thread.h

#pragma once
// @todo: requires "kernel.h"; used: KERNEL_USER_TIMES, KPRIORITY, KAFFINITY, KHETERO_CPU_POLICY
// @todo: requires "system.h"; used: SYSTEM_THREAD_INFORMATION, @todo: SUBSYSTEM_INFORMATION_TYPE

#pragma pack(push, 8)
#pragma region thread_environment_block
#define ACTIVATION_CONTEXT_STACK_FLAG_QUERIES_DISABLED (0x00000001)

_Q_NT_BIT_TEMPLATE struct ACTIVATION_CONTEXT_STACK
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<struct RTL_ACTIVATION_CONTEXT_STACK_FRAME*> ActiveFrame; // 0x00
	LIST_ENTRY<nBitness> FrameListCache; // 0x04 / 0x08
	std::uint32_t Flags; // 0x0C / 0x18 // ACTIVATION_CONTEXT_STACK_FLAG_*
	std::uint32_t NextCookieSequenceNumber; // 0x10 / 0x1C
	std::uint32_t StackId; // 0x14 / 0x20
};
_Q_NT_BIT_ASSERT(ACTIVATION_CONTEXT_STACK, 0x18, 0x28);

#define GDI_BATCH_BUFFER_SIZE 310

// @todo: is it good place? or move to "gdi.h"?
_Q_NT_BIT_TEMPLATE struct GDI_TEB_BATCH
{
private:
	_Q_NT_BIT_TYPE
public:
#if Q_NT_VERSION >= Q_NT_WINBLUE
	std::uint32_t Offset : 31; // 0x0
	std::uint32_t HasRenderingCommand : 1; // 0x0
#else
	std::uint32_t Offset; // 0x0
#endif
	BitnessType_t<std::uintptr_t> HDC; // 0x4
	std::uint32_t Buffer[GDI_BATCH_BUFFER_SIZE]; // 0x8 / 0xC
};
_Q_NT_BIT_ASSERT(GDI_TEB_BATCH, 0x4E0, 0x4E8);

_Q_NT_BIT_TEMPLATE struct NT_TIB
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<struct _EXCEPTION_REGISTRATION_RECORD*> ExceptionsList; // 0x00
	BitnessType_t<void*> StackBase; // 0x04 / 0x08
	BitnessType_t<void*> StackLimit; // 0x08 / 0x10
	BitnessType_t<void*> SubSystemTib; // 0x0C / 0x18
	union
	{
		BitnessType_t<void*> FiberData;
		std::uint32_t Version;
	}; // 0x10 / 0x20
	BitnessType_t<void*> ArbitraryUserPointer; // 0x14 / 0x28
	BitnessType_t<NT_TIB*> Self; // 0x18 / 0x30
};
_Q_NT_BIT_ASSERT(NT_TIB, 0x1C, 0x38);

#define WIN32_CLIENT_INFO_LENGTH 62
#define STATIC_UNICODE_BUFFER_LENGTH (MAX_PATH + 1)
#define TLS_MINIMUM_AVAILABLE 64

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

template <>
struct TEB<32U>
{
private:
	template <typename T>
	using BitnessType_t = DETAIL::BitnessConditional_t<32U, T>;

public:
	NT_TIB<32U> NtTib; // 0x0000
	BitnessType_t<void*> EnvironmentPointer; // 0x001C
	CLIENT_ID<32U> ClientId; // 0x0020
	BitnessType_t<void*> ActiveRpcHandle; // 0x0028
	BitnessType_t<void*> ThreadLocalStoragePointer; // 0x002C
	BitnessType_t<PEB<32U>*> ProcessEnvironmentBlock; // 0x0030
	std::uint32_t LastErrorValue; // 0x0034
	std::uint32_t CountOfOwnedCriticalSections; // 0x0038
	BitnessType_t<void*> CsrClientThread; // 0x003C
	BitnessType_t<void*> Win32ThreadInfo; // 0x0040
	std::uint32_t User32Reserved[26]; // 0x0044
	std::uint32_t UserReserved[5]; // 0x00AC
	BitnessType_t<void*> WOW32Reserved; // 0x00C0
	LCID CurrentLocale; // 0x00C4
	std::uint32_t FpSoftwareStatusRegister; // 0x00C8
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<void*> ReservedForDebuggerInstrumentation[16]; // 0x00CC
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	BitnessType_t<void*> SystemReserved1[21]; // 0x010C
	BitnessType_t<void*> HeapFlsData; // 0x0160
	BitnessType_t<std::uintptr_t> RngState[4]; // 0x0164
	std::int8_t PlaceholderCompatibilityMode; // 0x0174
	bool PlaceholderHydrationAlwaysExplicit; // 0x0175
	std::uint8_t PlaceholderReserved[10]; // 0x0176
	std::uint32_t ProxiedProcessId; // 0x0180
	ACTIVATION_CONTEXT_STACK<32U> _ActivationStack; // 0x0184
	std::uint8_t WorkingOnBehalfTicket[8]; // 0x019C
#else
	BitnessType_t<void*> SystemReserved1[38]; // 0x010C
#endif
#else
	BitnessType_t<void*> SystemReserved1[54]; // 0x010C
#endif
	NTSTATUS ExceptionCode; // 0x01A4
	BitnessType_t<ACTIVATION_CONTEXT_STACK<32U>*> ActivationContextStackPointer; // 0x01A8
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<void*> InstrumentationCallbackSp; // 0x01AC
	BitnessType_t<void*> InstrumentationCallbackPreviousPc; // 0x01B0
	BitnessType_t<void*> InstrumentationCallbackPreviousSp; // 0x01B4
	bool InstrumentationCallbackDisabled; // 0x01B8
	std::uint8_t SpareBytes[23]; // 0x1B9
#else
	std::uint8_t SpareBytes[36]; // 0x1AC
#endif
	std::uint32_t TxFsContext; // 0x01D0
	GDI_TEB_BATCH<32U> GdiTebBatch; // 0x01D4
	CLIENT_ID<32U> RealClientId; // 0x06E4
	BitnessType_t<HANDLE> GdiCachedProcessHandle; // 0x06BC
	std::uint32_t GdiClientPID; // 0x06C0
	std::uint32_t GdiClientTID; // 0x06C4
	BitnessType_t<void*> GdiThreadLocalInfo; // 0x06C8
	BitnessType_t<std::uintptr_t> Win32ClientInfo[WIN32_CLIENT_INFO_LENGTH]; // 0x06CC
	BitnessType_t<void*> glDispatchTable[233]; // 0x07C4
	BitnessType_t<std::uintptr_t> glReserved1[29]; // 0x0B68
	BitnessType_t<void*> glReserved2; // 0x0BDC
	BitnessType_t<void*> glSectionInfo; // 0x0BE0
	BitnessType_t<void*> glSection; // 0x0BE4
	BitnessType_t<void*> glTable; // 0x0BE8
	BitnessType_t<void*> glCurrentRC; // 0x0BEC
	BitnessType_t<void*> glContext; // 0x0BF0
	NTSTATUS LastStatusValue; // 0x0BF4
	UNICODE_STRING<32U> StaticUnicodeString; // 0x0BF8
	wchar_t StaticUnicodeBuffer[STATIC_UNICODE_BUFFER_LENGTH]; // 0x0C00
	BitnessType_t<void*> DeallocationStack; // 0x0E0C
	BitnessType_t<void*> TlsSlots[TLS_MINIMUM_AVAILABLE]; // 0x0E10
	LIST_ENTRY<32U> TlsLinks; // 0x0F10
	BitnessType_t<void*> Vdm; // 0x0F18
	BitnessType_t<void*> ReservedForNtRpc; // 0x0F1C
	BitnessType_t<HANDLE> DbgSsReserved[2]; // 0x0F20
	std::uint32_t HardErrorMode; // 0x0F28
	BitnessType_t<void*> Instrumentation[9]; // 0x0F2C
	GUID ActivityId; // 0x0F50
	BitnessType_t<void*> SubProcessTag; // 0x0F60
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<void*> PerflibData; // 0x0F64
#else
	BitnessType_t<void*> EtwLocalData; // 0x0F64
#endif
	BitnessType_t<void*> EtwTraceData; // 0x0F68
	BitnessType_t<void*> WinSockData; // 0x0F6C
	std::uint32_t GdiBatchCount; // 0x0F70
	PROCESSOR_NUMBER CurrentIdealProcessor; // 0x0F74
	std::uint32_t GuaranteedStackBytes; // 0x0F78
	BitnessType_t<void*> ReservedForPerf; // 0x0F7C
	BitnessType_t<void*> ReservedForOle; // 0x0F80
	std::uint32_t WaitingOnLoaderLock; // 0x0F84
	BitnessType_t<void*> SavedPriorityState; // 0x0F88
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<std::uintptr_t> ReservedForCodeCoverage; // 0x0F8C
#else
	BitnessType_t<std::uintptr_t> SoftPatchPtr1; // 0x0F8C
#endif
	BitnessType_t<void*> ThreadPoolData; // 0x0F90
	BitnessType_t<void**> TlsExpansionSlots; // 0x0F94
#if Q_NT_VERSION >= Q_NT_WIN7
	std::uint32_t MuiGeneration; // 0x0F98
#else
	LCID ImpersonationLocale; // 0x0F98
#endif
	std::uint32_t IsImpersonating; // 0x0F9C
	BitnessType_t<void*> NlsCache; // 0x0FA0
	BitnessType_t<void*> pShimData; // 0x0FA4
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	std::uint32_t HeapData; // 0x0FA8
#elif Q_NT_VERSION >= Q_NT_WIN8
	std::uint16_t HeapVirtualAffinity; // 0x0FA8
	std::uint16_t LowFragHeapDataSlot; // 0x0FAA
#else
	std::uint32_t HeapVirtualAffinity; // 0x0FA8
#endif
	BitnessType_t<HANDLE> CurrentTransactionHandle; // 0x0FAC
	BitnessType_t<struct TEB_ACTIVE_FRAME*> ActiveFrame; // 0x0FB0
	BitnessType_t<void*> FlsData; // 0x0FB4
	BitnessType_t<void*> PreferredLanguages; // 0x0FB8
	BitnessType_t<void*> UserPrefLanguages; // 0x0FBC
	BitnessType_t<void*> MergedPrefLanguages; // 0x0FC0
	std::uint32_t MuiImpersonation; // 0x0FC4
	union
	{
		volatile std::uint16_t CrossTebFlags;
		std::uint16_t SpareCrossTebBits : 16;
	}; // 0x0FC8
	union
	{
		std::uint16_t SameTebFlags;
		struct
		{
			std::uint16_t SafeThunkCall : 1;
			std::uint16_t InDebugPrint : 1;
			std::uint16_t HasFiberData : 1;
			std::uint16_t SkipThreadAttach : 1;
			std::uint16_t WerInShipAssertCode : 1;
			std::uint16_t RanProcessInit : 1;
			std::uint16_t ClonedThread : 1;
			std::uint16_t SuppressDebugMsg : 1;
#if Q_NT_VERSION >= Q_NT_VISTA_SP1
			std::uint16_t DisableUserStackWalk : 1;
			std::uint16_t RtlExceptionAttached : 1;
#if Q_NT_VERSION >= Q_NT_WIN7
			std::uint16_t InitialThread : 1;
#if Q_NT_VERSION >= Q_NT_WIN8
			std::uint16_t SessionAware : 1;
#if Q_NT_VERSION >= Q_NT_WIN10
			std::uint16_t LoadOwner : 1;
			std::uint16_t LoaderWorker : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
			std::uint16_t SkipLoaderInit : 1;
#if Q_NT_VERSION >= Q_NT_WIN11
			std::uint16_t SkipFileAPIBrokering : 1;
#else
			std::uint16_t SpareSameTebBits : 1;
#endif
#else
			std::uint16_t SpareSameTebBits : 2;
#endif
#else
			std::uint16_t SpareSameTebBits : 4;
#endif
#else
			std::uint16_t SpareSameTebBits : 5;
#endif
#else
			std::uint16_t SpareSameTebBits : 6;
#endif
#else
			std::uint16_t SpareSameTebBits : 8;
#endif
		};
	}; // 0x0FCA
	BitnessType_t<void*> TxnScopeEnterCallback; // 0x0FCC
	BitnessType_t<void*> TxnScopeExitCallback; // 0x0FD0
	BitnessType_t<void*> TxnScopeContext; // 0x0FD4
	std::uint32_t LockCount; // 0x0FD8
#if Q_NT_VERSION >= Q_NT_WIN7
#if Q_NT_VERSION >= Q_NT_WIN10
	std::int32_t WowTebOffset; // 0x0FDC
#else
	std::uint32_t SpareUlong0; // 0x0FDC
#endif
	BitnessType_t<void*> ResourceRetValue; // 0x0FE0
#else
	std::uint32_t ProcessRundown; // 0x0FDC
	std::uint64_t LastSwitchTime; // 0x0FE0
	std::uint64_t TotalSwitchOutTime; // 0x0FE8
	LARGE_INTEGER WaitReasonBitMap; // 0x0FF0
#endif
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<void*> ReservedForWdf; // 0x0FE4
#endif
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<std::uintptr_t> ReservedForCrt; // 0x0FE8
	GUID EffectiveContainerId; // 0x0FF0
#endif
#if Q_NT_VERSION >= Q_NT_WIN11
	std::uint64_t LastSleepCounter; // 0x1000
	std::uint32_t SpinCallCount; // 0x1008
	std::uint64_t ExtendedFeatureDisableMask; // 0x1010
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	BitnessType_t<void*> SchedulerSharedDataSlot; // 0x1018
	BitnessType_t<void*> HeapWalkContext; // 0x101C
	GROUP_AFFINITY<32U> PrimaryGroupAffinity; // 0x1020
	std::uint32_t Rcu[2]; // 0x102C
#endif
};

template <>
struct TEB<64U>
{
private:
	template <typename T>
	using BitnessType_t = DETAIL::BitnessConditional_t<64U, T>;

public:
	NT_TIB<64U> NtTib; // 0x0000
	BitnessType_t<void*> EnvironmentPointer; // 0x0038
	CLIENT_ID<64U> ClientId; // 0x0040
	BitnessType_t<void*> ActiveRpcHandle; // 0x0050
	BitnessType_t<void*> ThreadLocalStoragePointer; // 0x0058
	BitnessType_t<PEB<64U>*> ProcessEnvironmentBlock; // 0x0060
	std::uint32_t LastErrorValue; // 0x0068
	std::uint32_t CountOfOwnedCriticalSections; // 0x006C
	BitnessType_t<void*> CsrClientThread; // 0x0070
	BitnessType_t<void*> Win32ThreadInfo; // 0x0078
	std::uint32_t User32Reserved[26]; // 0x0080
	std::uint32_t UserReserved[5]; // 0x00E8
	BitnessType_t<void*> WOW32Reserved; // 0x0100
	LCID CurrentLocale; // 0x0108
	std::uint32_t FpSoftwareStatusRegister; // 0x010C
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<void*> ReservedForDebuggerInstrumentation[16]; // 0x0110
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	BitnessType_t<void*> SystemReserved1[25]; // 0x0190
	BitnessType_t<void*> HeapFlsData; // 0x0258
	BitnessType_t<std::uintptr_t> RngState[4]; // 0x0260
	std::int8_t PlaceholderCompatibilityMode; // 0x0280
	bool PlaceholderHydrationAlwaysExplicit; // 0x0281
	std::uint8_t PlaceholderReserved[10]; // 0x0282
	std::uint32_t ProxiedProcessId; // 0x028C
	ACTIVATION_CONTEXT_STACK<64U> _ActivationStack; // 0x0290
	std::uint8_t WorkingOnBehalfTicket[8]; // 0x02B8
#else
	BitnessType_t<void*> SystemReserved1[38]; // 0x0190
#endif
#else
	BitnessType_t<void*> SystemReserved1[54]; // 0x0110
#endif
	NTSTATUS ExceptionCode; // 0x02C0
	BitnessType_t<ACTIVATION_CONTEXT_STACK<64U>*> ActivationContextStackPointer; // 0x02C8
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<void*> InstrumentationCallbackSp; // 0x02D0
	BitnessType_t<void*> InstrumentationCallbackPreviousPc; // 0x02D8
	BitnessType_t<void*> InstrumentationCallbackPreviousSp; // 0x02E0
#else
	std::uint8_t SpareBytes[24]; // 0x02D0
#endif
	std::uint32_t TxFsContext; // 0x02E8
#if Q_NT_VERSION >= Q_NT_WIN10
	bool InstrumentationCallbackDisabled; // 0x02EC
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	bool UnalignedLoadStoreExceptions; // 0x02ED
#endif
	GDI_TEB_BATCH<64U> GdiTebBatch; // 0x02F0
	CLIENT_ID<64U> RealClientId; // 0x07D8
	BitnessType_t<HANDLE> GdiCachedProcessHandle; // 0x07E8
	std::uint32_t GdiClientPID; // 0x07F0
	std::uint32_t GdiClientTID; // 0x07F4
	BitnessType_t<void*> GdiThreadLocalInfo; // 0x07F8
	BitnessType_t<std::uintptr_t> Win32ClientInfo[WIN32_CLIENT_INFO_LENGTH]; // 0x0800
	BitnessType_t<void*> glDispatchTable[233]; // 0x09F0
	BitnessType_t<std::uintptr_t> glReserved1[29]; // 0x1138
	BitnessType_t<void*> glReserved2; // 0x1220
	BitnessType_t<void*> glSectionInfo; // 0x1228
	BitnessType_t<void*> glSection; // 0x1230
	BitnessType_t<void*> glTable; // 0x1238
	BitnessType_t<void*> glCurrentRC; // 0x1240
	BitnessType_t<void*> glContext; // 0x1248
	NTSTATUS LastStatusValue; // 0x1250
	UNICODE_STRING<64U> StaticUnicodeString; // 0x1258
	wchar_t StaticUnicodeBuffer[STATIC_UNICODE_BUFFER_LENGTH]; // 0x1268
	BitnessType_t<void*> DeallocationStack; // 0x1478
	BitnessType_t<void*> TlsSlots[TLS_MINIMUM_AVAILABLE]; // 0x1480
	LIST_ENTRY<64U> TlsLinks; // 0x1680
	BitnessType_t<void*> Vdm; // 0x1690
	BitnessType_t<void*> ReservedForNtRpc; // 0x1698
	BitnessType_t<HANDLE> DbgSsReserved[2]; // 0x16A0
	std::uint32_t HardErrorMode; // 0x16B0
	BitnessType_t<void*> Instrumentation[11]; //0x16B8
	GUID ActivityId; // 0x1710
	BitnessType_t<void*> SubProcessTag; // 0x1720
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<void*> PerflibData; // 0x1728
#else
	BitnessType_t<void*> EtwLocalData; // 0x1728
#endif
	BitnessType_t<void*> EtwTraceData; // 0x1730
	BitnessType_t<void*> WinSockData; // 0x1738
	std::uint32_t GdiBatchCount; // 0x1740
	PROCESSOR_NUMBER CurrentIdealProcessor; // 0x1744
	std::uint32_t GuaranteedStackBytes; // 0x1748
	BitnessType_t<void*> ReservedForPerf; // 0x1750
	BitnessType_t<void*> ReservedForOle; // 0x1758
	std::uint32_t WaitingOnLoaderLock; // 0x1760
	BitnessType_t<void*> SavedPriorityState; // 0x1768
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<std::uintptr_t> ReservedForCodeCoverage; // 0x1770
#else
	BitnessType_t<std::uintptr_t> SoftPatchPtr1; // 0x1770
#endif
	BitnessType_t<void*> ThreadPoolData; // 0x1778
	BitnessType_t<void**> TlsExpansionSlots; // 0x1780
#if Q_NT_VERSION >= Q_NT_WIN11
	BitnessType_t<struct CHPEV2_CPUAREA_INFO*> ChpeV2CpuAreaInfo; // 0x1788
	BitnessType_t<void*> Unused; // 0x1790
#else
	BitnessType_t<void*> DeallocationBStore; // 0x1788
	BitnessType_t<void*> BStoreLimit; // 0x1790
#endif
#if Q_NT_VERSION >= Q_NT_WIN7
	std::uint32_t MuiGeneration; // 0x1798
#else
	LCID ImpersonationLocale; // 0x1798
#endif
	std::uint32_t IsImpersonating; // 0x179C
	BitnessType_t<void*> NlsCache; // 0x17A0
	BitnessType_t<void*> pShimData; // 0x17A8
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	std::uint32_t HeapData; // 0x17B0
#elif Q_NT_VERSION >= Q_NT_WIN8
	std::uint16_t HeapVirtualAffinity; // 0x17B0
	std::uint16_t LowFragHeapDataSlot; // 0x17B2
#else
	std::uint32_t HeapVirtualAffinity; // 0x17B0
#endif
	BitnessType_t<HANDLE> CurrentTransactionHandle; // 0x17B8
	BitnessType_t<struct TEB_ACTIVE_FRAME*> ActiveFrame; // 0x17C0
	BitnessType_t<void*> FlsData; // 0x17C8
	BitnessType_t<void*> PreferredLanguages; // 0x17D0
	BitnessType_t<void*> UserPrefLanguages; // 0x17D8
	BitnessType_t<void*> MergedPrefLanguages; // 0x17E0
	std::uint32_t MuiImpersonation; // 0x17E8
	union
	{
		volatile std::uint16_t CrossTebFlags;
		std::uint16_t SpareCrossTebBits : 16;
	}; // 0x17EC
	union
	{
		std::uint16_t SameTebFlags;
		struct
		{
			std::uint16_t SafeThunkCall : 1;
			std::uint16_t InDebugPrint : 1;
			std::uint16_t HasFiberData : 1;
			std::uint16_t SkipThreadAttach : 1;
			std::uint16_t WerInShipAssertCode : 1;
			std::uint16_t RanProcessInit : 1;
			std::uint16_t ClonedThread : 1;
			std::uint16_t SuppressDebugMsg : 1;
#if Q_NT_VERSION >= Q_NT_VISTA_SP1
			std::uint16_t DisableUserStackWalk : 1;
			std::uint16_t RtlExceptionAttached : 1;
#if Q_NT_VERSION >= Q_NT_WIN7
			std::uint16_t InitialThread : 1;
#if Q_NT_VERSION >= Q_NT_WIN8
			std::uint16_t SessionAware : 1;
#if Q_NT_VERSION >= Q_NT_WIN10
			std::uint16_t LoadOwner : 1;
			std::uint16_t LoaderWorker : 1;
#if Q_NT_VERSION >= Q_NT_WIN10_RS1
			std::uint16_t SkipLoaderInit : 1;
#if Q_NT_VERSION >= Q_NT_WIN11
			std::uint16_t SkipFileAPIBrokering : 1;
#else
			std::uint16_t SpareSameTebBits : 1;
#endif
#else
			std::uint16_t SpareSameTebBits : 2;
#endif
#else
			std::uint16_t SpareSameTebBits : 4;
#endif
#else
			std::uint16_t SpareSameTebBits : 5;
#endif
#else
			std::uint16_t SpareSameTebBits : 6;
#endif
#else
			std::uint16_t SpareSameTebBits : 8;
#endif
		};
	}; // 0x17EE
	BitnessType_t<void*> TxnScopeEnterCallback; // 0x17F0
	BitnessType_t<void*> TxnScopeExitCallback; // 0x17F8
	BitnessType_t<void*> TxnScopeContext; // 0x1800
	std::uint32_t LockCount; // 0x1808

#if Q_NT_VERSION >= Q_NT_WIN7
#if Q_NT_VERSION >= Q_NT_WIN10
	std::int32_t WowTebOffset; // 0x180C
#else
	std::uint32_t SpareUlong0; // 0x180C
#endif
	BitnessType_t<void*> ResourceRetValue; // 0x1810
#else
	std::uint32_t ProcessRundown; // 0x180C
	std::uint64_t LastSwitchTime; // 0x1810
	std::uint64_t TotalSwitchOutTime; // 0x1818
	LARGE_INTEGER WaitReasonBitMap; // 0x1820
#endif
#if Q_NT_VERSION >= Q_NT_WIN8
	BitnessType_t<void*> ReservedForWdf; // 0x1818
#endif
#if Q_NT_VERSION >= Q_NT_WIN10
	BitnessType_t<std::uintptr_t> ReservedForCrt; // 0x1820
	GUID EffectiveContainerId; // 0x1828
#endif
#if Q_NT_VERSION >= Q_NT_WIN11
	std::uint64_t LastSleepCounter; // 0x1838
	std::uint32_t SpinCallCount; // 0x1840
	std::uint64_t ExtendedFeatureDisableMask; // 0x1848
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	BitnessType_t<void*> SchedulerSharedDataSlot; // 0x1850
	BitnessType_t<void*> HeapWalkContext; // 0x1858
	GROUP_AFFINITY<64U> PrimaryGroupAffinity; // 0x1860
	std::uint32_t Rcu[2]; // 0x1870
#endif
};
_Q_NT_BIT_ASSERT(TEB, 0x1038, 0x1878);
#pragma endregion

#pragma region thread_information
// @note: originally "_THREADINFOCLASS"
using THREAD_INFORMATION_CLASS = enum _THREAD_INFORMATION_CLASS : std::uint32_t
{
	ThreadBasicInformation = 0,
	ThreadTimes = 1,
	ThreadPriority = 2, // requires 'SeIncreaseBasePriorityPrivilege'
	ThreadBasePriority = 3,
	ThreadAffinityMask = 4,
	ThreadImpersonationToken = 5,
	ThreadDescriptorTableEntry = 6,
	ThreadEnableAlignmentFaultFixup = 7,
	ThreadEventPair_Reusable = 8,
	ThreadQuerySetWin32StartAddress = 9,
	ThreadZeroTlsCell = 10,
	ThreadPerformanceCount = 11,
	ThreadAmILastThread = 12,
	ThreadIdealProcessor = 13,
	ThreadPriorityBoost = 14,
	ThreadSetTlsArrayAddress = 15,
	ThreadIsIoPending = 16,
	ThreadHideFromDebugger = 17,
	ThreadBreakOnTermination = 18,
	ThreadSwitchLegacyState = 19,
	ThreadIsTerminated = 20,
#if Q_NT_VERSION >= Q_NT_VISTA
	ThreadLastSystemCall = 21,
	ThreadIoPriority = 22, // requires 'SeIncreaseBasePriorityPrivilege'
	ThreadCycleTime = 23,
	ThreadPagePriority = 24,
	ThreadActualBasePriority = 25, // requires 'SeIncreaseBasePriorityPrivilege'
	ThreadTebInformation = 26, // requires 'THREAD_GET_CONTEXT' or 'THREAD_SET_CONTEXT'
	ThreadCSwitchMon = 27,
#endif
#if Q_NT_VERSION >= Q_NT_WIN7
	ThreadCSwitchPmu = 28,
	ThreadWow64Context = 29,
	ThreadGroupInformation = 30,
	ThreadUmsInformation = 31,
	ThreadCounterProfiling = 32,
	ThreadIdealProcessorEx = 33,
#endif
#if Q_NT_VERSION >= Q_NT_WIN8
	ThreadCpuAccountingInformation = 34,
#endif
#if Q_NT_VERSION >= Q_NT_WINBLUE
	ThreadSuspendCount = 35,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10
	ThreadHeterogeneousCpuPolicy = 36,
	ThreadContainerId = 37,
	ThreadNameInformation = 38, // requires 'THREAD_SET_LIMITED_INFORMATION'
	ThreadSelectedCpuSets = 39,
	ThreadSystemThreadInformation = 40,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_TH2
	ThreadActualGroupAffinity = 41,
	ThreadDynamicCodePolicyInfo = 42,
	ThreadExplicitCaseSensitivity = 43, // requires 'SeDebugPrivilege' and 'PsProtectedSignerAntimalware'
	ThreadWorkOnBehalfTicket = 44,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS2
	ThreadSubsystemInformation = 45,
	ThreadDbgkWerReportActive = 46,
	ThreadAttachContainer = 47,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS3
	ThreadManageWritesToExecutableMemory = 48,
	ThreadPowerThrottlingState = 49,
#endif
#if Q_NT_VERSION >= Q_NT_WIN10_RS5
	ThreadWorkloadClass = 50,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11
	ThreadCreateStateChange = 51,
	ThreadApplyStateChange = 52,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_22H2
	ThreadStrongerBadHandleChecks = 53,
	ThreadEffectiveIoPriority = 54,
	ThreadEffectivePagePriority = 55,
#endif
#if Q_NT_VERSION >= Q_NT_WIN11_24H2
	ThreadUpdateLockOwnership = 56,
	ThreadSchedulerSharedDataSlot = 57,
	ThreadTebInformationAtomic = 58, // requires 'THREAD_GET_CONTEXT' and 'THREAD_QUERY_INFORMATION'
	ThreadIndexInformation = 59,
#endif
	MaxThreadInfoClass
};

_Q_NT_BIT_TEMPLATE struct THREAD_BASIC_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	NTSTATUS ExitStatus; // 0x00
	BitnessType_t<TEB<nBitness>*> TebBaseAddress; // 0x04 / 0x08
	CLIENT_ID<nBitness> ClientId; // 0x08 / 0x10
	BitnessType_t<KAFFINITY> AffinityMask; // 0x10 / 0x20
	KPRIORITY Priority; // 0x14 / 0x28
	KPRIORITY BasePriority; // 0x18 / 0x2C
};
_Q_NT_BIT_ASSERT(THREAD_BASIC_INFORMATION, 0x1C, 0x30);

#if Q_NT_VERSION >= Q_NT_VISTA
_Q_NT_BIT_TEMPLATE struct THREAD_LAST_SYSCALL_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> FirstArgument; // 0x00
	std::uint16_t SystemCallNumber; // 0x04 / 0x08
#if Q_NT_VERSION >= Q_NT_WINBLUE
	std::uint64_t WaitTime; // 0x08 / 0x10
#endif
};
_Q_NT_BIT_ASSERT(THREAD_LAST_SYSCALL_INFORMATION, 0x10, 0x18);

struct THREAD_CYCLE_TIME_INFORMATION
{
	std::uint64_t AccumulatedCycles; // 0x0
	std::uint64_t CurrentCycleCount; // 0x8
};
static_assert(sizeof(THREAD_CYCLE_TIME_INFORMATION) == 0x10);

_Q_NT_BIT_TEMPLATE struct THREAD_TEB_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	BitnessType_t<void*> TebInformation; // 0x00
	std::uint32_t TebOffset; // 0x04 / 0x08
	std::uint32_t BytesToRead; // 0x08 / 0x0C
};
_Q_NT_BIT_ASSERT(THREAD_TEB_INFORMATION, 0xC, 0x10);
#endif

#if Q_NT_VERSION >= Q_NT_WIN7
using THREAD_UMS_INFORMATION_COMMAND = enum _THREAD_UMS_INFORMATION_COMMAND : std::int32_t
{
	UmsInformationCommandInvalid = 0,
	UmsInformationCommandAttach = 1,
	UmsInformationCommandDetach = 2,
#if Q_NT_VERSION >= Q_NT_WIN8
	UmsInformationCommandQuery = 3
#endif
};

_Q_NT_BIT_TEMPLATE struct THREAD_UMS_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	THREAD_UMS_INFORMATION_COMMAND Command; // 0x00
#if Q_NT_VERSION >= Q_NT_WIN8
	union
	{
		struct
		{
			BitnessType_t<struct RTL_UMS_COMPLETION_LIST*> CompletionList;
			BitnessType_t<struct RTL_UMS_CONTEXT*> UmsContext;
		};
		std::uint32_t Flags;
		struct
		{
			std::uint32_t IsUmsSchedulerThread : 1;
			std::uint32_t IsUmsWorkerThread : 1;
			std::uint32_t SpareBits : 30;
		};
	}; // 0x04 / 0x08
#else
	BitnessType_t<struct RTL_UMS_COMPLETION_LIST*> CompletionList; // 0x04 / 0x08
	BitnessType_t<struct RTL_UMS_CONTEXT*> UmsContext; // 0x08 / 0x10
#endif
};
_Q_NT_BIT_ASSERT(THREAD_UMS_INFORMATION, 0xC, 0x18);

// @todo: move to ntapi.h? or kernel.h?
using HARDWARE_COUNTER_TYPE = enum _HARDWARE_COUNTER_TYPE
{
	PMCCounter = 0,
	MaxHardwareCounterType = 1
};

// @todo: move to ntapi.h? or kernel.h?
struct COUNTER_READING
{
	HARDWARE_COUNTER_TYPE Type; // 0x00
	std::uint32_t Index; // 0x04
	std::uint64_t Start; // 0x08
	std::uint64_t Total; // 0x10
};
static_assert(sizeof(COUNTER_READING) == 0x18);

struct THREAD_PERFORMANCE_DATA
{
	std::uint16_t Size; // 0x00
	std::uint16_t Version; // 0x02
	PROCESSOR_NUMBER ProcessorNumber; // 0x04
	std::uint32_t ContextSwitches; // 0x08
	std::uint32_t HwCountersCount; // 0x0C
	std::uint64_t UpdateCount; // 0x10
	std::uint64_t WaitReasonBitMap; // 0x18
	std::uint64_t HardwareCounters; // 0x20
	COUNTER_READING CycleTime; // 0x28
	COUNTER_READING HwCounters[MAX_HW_COUNTERS]; // 0x40
};
static_assert(sizeof(THREAD_PERFORMANCE_DATA) == 0x1C0);

_Q_NT_BIT_TEMPLATE struct THREAD_PROFILING_INFORMATION
{
private:
	_Q_NT_BIT_TYPE
public:
	std::uint64_t HardwareCounters; // 0x00
	std::uint32_t Flags; // 0x08
	std::uint32_t Enable; // 0x0C
	BitnessType_t<THREAD_PERFORMANCE_DATA*> PerformanceData; // 0x10
};
_Q_NT_BIT_ASSERT(THREAD_PROFILING_INFORMATION, 0x18, 0x18);
#endif

#if Q_NT_VERSION >= Q_NT_WIN10
_Q_NT_BIT_TEMPLATE struct THREAD_NAME_INFORMATION
{
	UNICODE_STRING<nBitness> ThreadName;
};
_Q_NT_BIT_ASSERT(THREAD_NAME_INFORMATION, 0x8, 0x10);
#endif

#if Q_NT_VERSION >= Q_NT_WIN11_24H2
struct THREAD_LOCK_OWNERSHIP
{
	std::uint32_t SrwLock[ANYSIZE_ARRAY];
};

struct THREAD_INDEX_INFORMATION
{
	std::uint32_t Index; // 0x0
	std::uint32_t Sequence; // 0x4
};
static_assert(sizeof(THREAD_INDEX_INFORMATION) == 0x8);
#endif
#pragma endregion
#pragma pack(pop)