Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 8648 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/winnt.rs b/vendor/winapi/src/um/winnt.rs
new file mode 100644
index 000000000..f687489bd
--- /dev/null
+++ b/vendor/winapi/src/um/winnt.rs
@@ -0,0 +1,8648 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! This module defines the 32-Bit Windows types and constants that are defined by NT, but exposed
+//! through the Win32 API.
+use ctypes::{__int64, __uint64, c_char, c_int, c_long, c_short, c_uint, c_ulong, c_void, wchar_t};
+use shared::basetsd::{
+    DWORD64, KAFFINITY, LONG64, LONG_PTR, PDWORD64, PLONG64, SIZE_T, ULONG64, ULONG_PTR,
+};
+use shared::guiddef::{CLSID, GUID};
+use shared::ktmtypes::UOW;
+use shared::minwindef::{BYTE, DWORD, FALSE, PDWORD, TRUE, ULONG, USHORT, WORD};
+#[cfg(target_arch = "aarch64")]
+use shared::minwindef::PBYTE;
+use vc::excpt::EXCEPTION_DISPOSITION;
+use vc::vcruntime::size_t;
+pub const ANYSIZE_ARRAY: usize = 1;
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub const MAX_NATURAL_ALIGNMENT: usize = 4;
+pub const MEMORY_ALLOCATION_ALIGNMENT: usize = 8;
+}
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub const MAX_NATURAL_ALIGNMENT: usize = 8;
+pub const MEMORY_ALLOCATION_ALIGNMENT: usize = 16;
+}
+pub const SYSTEM_CACHE_ALIGNMENT_SIZE: usize = 64;
+pub type PVOID = *mut c_void;
+pub type PVOID64 = u64; // This is a 64-bit pointer, even when in 32-bit
+pub type VOID = c_void;
+pub type CHAR = c_char;
+pub type SHORT = c_short;
+pub type LONG = c_long;
+pub type INT = c_int;
+pub type WCHAR = wchar_t;
+pub type PWCHAR = *mut WCHAR;
+pub type LPWCH = *mut WCHAR;
+pub type PWCH = *mut WCHAR;
+pub type LPCWCH = *const WCHAR;
+pub type PCWCH = *const WCHAR;
+pub type NWPSTR = *mut WCHAR;
+pub type LPWSTR = *mut WCHAR;
+pub type PWSTR = *mut WCHAR;
+pub type PZPWSTR = *mut PWSTR;
+pub type PCZPWSTR = *const PWSTR;
+pub type LPUWSTR = *mut WCHAR; // Unaligned pointer
+pub type PUWSTR = *mut WCHAR; // Unaligned pointer
+pub type LPCWSTR = *const WCHAR;
+pub type PCWSTR = *const WCHAR;
+pub type PZPCWSTR = *mut PCWSTR;
+pub type PCZPCWSTR = *const PCWSTR;
+pub type LPCUWSTR = *const WCHAR; // Unaligned pointer
+pub type PCUWSTR = *const WCHAR; // Unaligned pointer
+pub type PZZWSTR = *mut WCHAR;
+pub type PCZZWSTR = *const WCHAR;
+pub type PUZZWSTR = *mut WCHAR; // Unaligned pointer
+pub type PCUZZWSTR = *const WCHAR; // Unaligned pointer
+pub type PNZWCH = *mut WCHAR;
+pub type PCNZWCH = *const WCHAR;
+pub type PUNZWCH = *mut WCHAR; // Unaligned pointer
+pub type PCUNZWCH = *const WCHAR; // Unaligned pointer
+pub type LPCWCHAR = *const WCHAR;
+pub type PCWCHAR = *const WCHAR;
+pub type LPCUWCHAR = *const WCHAR; // Unaligned pointer
+pub type PCUWCHAR = *const WCHAR; // Unaligned pointer
+pub type UCSCHAR = c_ulong;
+pub const UCSCHAR_INVALID_CHARACTER: UCSCHAR = 0xffffffff;
+pub const MIN_UCSCHAR: UCSCHAR = 0;
+pub const MAX_UCSCHAR: UCSCHAR = 0x0010FFFF;
+pub type PUCSCHAR = *mut UCSCHAR;
+pub type PCUCSCHAR = *const UCSCHAR;
+pub type PUCSSTR = *mut UCSCHAR;
+pub type PUUCSSTR = *mut UCSCHAR; // Unaligned pointer
+pub type PCUCSSTR = *const UCSCHAR;
+pub type PCUUCSSTR = *const UCSCHAR; // Unaligned pointer
+pub type PUUCSCHAR = *mut UCSCHAR; // Unaligned pointer
+pub type PCUUCSCHAR = *const UCSCHAR; // Unaligned pointer
+pub type PCHAR = *mut CHAR;
+pub type LPCH = *mut CHAR;
+pub type PCH = *mut CHAR;
+pub type LPCCH = *const CHAR;
+pub type PCCH = *const CHAR;
+pub type NPSTR = *mut CHAR;
+pub type LPSTR = *mut CHAR;
+pub type PSTR = *mut CHAR;
+pub type PZPSTR = *mut PSTR;
+pub type PCZPSTR = *const PSTR;
+pub type LPCSTR = *const CHAR;
+pub type PCSTR = *const CHAR;
+pub type PZPCSTR = *mut PCSTR;
+pub type PCZPCSTR = *const PCSTR;
+pub type PZZSTR = *mut CHAR;
+pub type PCZZSTR = *const CHAR;
+pub type PNZCH = *mut CHAR;
+pub type PCNZCH = *const CHAR;
+// Skipping TCHAR things
+pub type PSHORT = *mut SHORT;
+pub type PLONG = *mut LONG;
+pub const ALL_PROCESSOR_GROUPS: WORD = 0xffff;
+STRUCT!{struct PROCESSOR_NUMBER {
+    Group: WORD,
+    Number: BYTE,
+    Reserved: BYTE,
+}}
+pub type PPROCESSOR_NUMBER = *mut PROCESSOR_NUMBER;
+STRUCT!{struct GROUP_AFFINITY {
+    Mask: KAFFINITY,
+    Group: WORD,
+    Reserved: [WORD; 3],
+}}
+pub type PGROUP_AFFINITY = *mut GROUP_AFFINITY;
+#[cfg(target_pointer_width = "32")]
+pub const MAXIMUM_PROC_PER_GROUP: BYTE = 32;
+#[cfg(target_pointer_width = "64")]
+pub const MAXIMUM_PROC_PER_GROUP: BYTE = 64;
+pub const MAXIMUM_PROCESSORS: BYTE = MAXIMUM_PROC_PER_GROUP;
+pub type HANDLE = *mut c_void;
+pub type PHANDLE = *mut HANDLE;
+pub type FCHAR = BYTE;
+pub type FSHORT = WORD;
+pub type FLONG = DWORD;
+pub type HRESULT = c_long;
+pub type CCHAR = c_char;
+pub type LCID = DWORD;
+pub type PLCID = PDWORD;
+pub type LANGID = WORD;
+ENUM!{enum COMPARTMENT_ID {
+    UNSPECIFIED_COMPARTMENT_ID = 0,
+    DEFAULT_COMPARTMENT_ID,
+}}
+pub type PCOMPARTMENT_ID = *mut COMPARTMENT_ID;
+pub const APPLICATION_ERROR_MASK: DWORD = 0x20000000;
+pub const ERROR_SEVERITY_SUCCESS: DWORD = 0x00000000;
+pub const ERROR_SEVERITY_INFORMATIONAL: DWORD = 0x40000000;
+pub const ERROR_SEVERITY_WARNING: DWORD = 0x80000000;
+pub const ERROR_SEVERITY_ERROR: DWORD = 0xC0000000;
+STRUCT!{struct FLOAT128 {
+    LowPart: __int64,
+    HighPart: __int64,
+}}
+pub type PFLOAT128 = *mut FLOAT128;
+pub type LONGLONG = __int64;
+pub type ULONGLONG = __uint64;
+pub const MAXLONGLONG: LONGLONG = 0x7fffffffffffffff;
+pub type PLONGLONG = *mut LONGLONG;
+pub type PULONGLONG = *mut ULONGLONG;
+pub type USN = LONGLONG;
+pub use shared::ntdef::LARGE_INTEGER;
+pub type PLARGE_INTEGER = *mut LARGE_INTEGER;
+pub use shared::ntdef::ULARGE_INTEGER;
+pub type PULARGE_INTEGER = *mut ULARGE_INTEGER;
+pub type RTL_REFERENCE_COUNT = LONG_PTR;
+pub type PRTL_REFERENCE_COUNT = *mut LONG_PTR;
+pub type RTL_REFERENCE_COUNT32 = LONG;
+pub type PRTL_REFERENCE_COUNT32 = *mut LONG;
+pub use shared::ntdef::LUID;
+pub type PLUID = *mut LUID;
+pub type DWORDLONG = ULONGLONG;
+pub type PDWORDLONG = *mut DWORDLONG;
+pub const ANSI_NULL: CHAR = 0;
+pub const UNICODE_NULL: WCHAR = 0;
+pub const UNICODE_STRING_MAX_BYTES: WORD = 65534;
+pub const UNICODE_STRING_MAX_CHARS: WORD = 32767;
+pub type BOOLEAN = BYTE;
+pub type PBOOLEAN = *mut BOOLEAN;
+STRUCT!{struct LIST_ENTRY {
+    Flink: *mut LIST_ENTRY,
+    Blink: *mut LIST_ENTRY,
+}}
+pub type PLIST_ENTRY = *mut LIST_ENTRY;
+pub type PRLIST_ENTRY = *mut LIST_ENTRY; // Restricted pointer
+STRUCT!{struct SINGLE_LIST_ENTRY {
+    Next: *mut SINGLE_LIST_ENTRY,
+}}
+pub type PSINGLE_LIST_ENTRY = *mut SINGLE_LIST_ENTRY;
+STRUCT!{struct LIST_ENTRY32 {
+    Flink: DWORD,
+    Blink: DWORD,
+}}
+pub type PLIST_ENTRY32 = *mut LIST_ENTRY32;
+STRUCT!{struct LIST_ENTRY64 {
+    Flink: ULONGLONG,
+    Blink: ULONGLONG,
+}}
+pub type PLIST_ENTRY64 = *mut LIST_ENTRY64;
+STRUCT!{struct OBJECTID {
+    Lineage: GUID,
+    Uniquifier: DWORD,
+}}
+pub const MINCHAR: CHAR = 0x80;
+pub const MAXCHAR: CHAR = 0x7f;
+pub const MINSHORT: SHORT = 0x8000;
+pub const MAXSHORT: SHORT = 0x7fff;
+pub const MINLONG: LONG = 0x80000000;
+pub const MAXLONG: LONG = 0x7fffffff;
+pub const MAXBYTE: BYTE = 0xff;
+pub const MAXWORD: WORD = 0xffff;
+pub const MAXDWORD: DWORD = 0xffffffff;
+FN!{stdcall PEXCEPTION_ROUTINE(
+    ExceptionRecord: *mut EXCEPTION_RECORD,
+    EstablisherFrame: PVOID,
+    ContextRecord: *mut CONTEXT,
+    DispatcherContext: PVOID,
+) -> EXCEPTION_DISPOSITION}
+pub const VER_SERVER_NT: DWORD = 0x80000000;
+pub const VER_WORKSTATION_NT: DWORD = 0x40000000;
+pub const VER_SUITE_SMALLBUSINESS: DWORD = 0x00000001;
+pub const VER_SUITE_ENTERPRISE: DWORD = 0x00000002;
+pub const VER_SUITE_BACKOFFICE: DWORD = 0x00000004;
+pub const VER_SUITE_COMMUNICATIONS: DWORD = 0x00000008;
+pub const VER_SUITE_TERMINAL: DWORD = 0x00000010;
+pub const VER_SUITE_SMALLBUSINESS_RESTRICTED: DWORD = 0x00000020;
+pub const VER_SUITE_EMBEDDEDNT: DWORD = 0x00000040;
+pub const VER_SUITE_DATACENTER: DWORD = 0x00000080;
+pub const VER_SUITE_SINGLEUSERTS: DWORD = 0x00000100;
+pub const VER_SUITE_PERSONAL: DWORD = 0x00000200;
+pub const VER_SUITE_BLADE: DWORD = 0x00000400;
+pub const VER_SUITE_EMBEDDED_RESTRICTED: DWORD = 0x00000800;
+pub const VER_SUITE_SECURITY_APPLIANCE: DWORD = 0x00001000;
+pub const VER_SUITE_STORAGE_SERVER: DWORD = 0x00002000;
+pub const VER_SUITE_COMPUTE_SERVER: DWORD = 0x00004000;
+pub const VER_SUITE_WH_SERVER: DWORD = 0x00008000;
+pub const PRODUCT_UNDEFINED: DWORD = 0x00000000;
+pub const PRODUCT_ULTIMATE: DWORD = 0x00000001;
+pub const PRODUCT_HOME_BASIC: DWORD = 0x00000002;
+pub const PRODUCT_HOME_PREMIUM: DWORD = 0x00000003;
+pub const PRODUCT_ENTERPRISE: DWORD = 0x00000004;
+pub const PRODUCT_HOME_BASIC_N: DWORD = 0x00000005;
+pub const PRODUCT_BUSINESS: DWORD = 0x00000006;
+pub const PRODUCT_STANDARD_SERVER: DWORD = 0x00000007;
+pub const PRODUCT_DATACENTER_SERVER: DWORD = 0x00000008;
+pub const PRODUCT_SMALLBUSINESS_SERVER: DWORD = 0x00000009;
+pub const PRODUCT_ENTERPRISE_SERVER: DWORD = 0x0000000A;
+pub const PRODUCT_STARTER: DWORD = 0x0000000B;
+pub const PRODUCT_DATACENTER_SERVER_CORE: DWORD = 0x0000000C;
+pub const PRODUCT_STANDARD_SERVER_CORE: DWORD = 0x0000000D;
+pub const PRODUCT_ENTERPRISE_SERVER_CORE: DWORD = 0x0000000E;
+pub const PRODUCT_ENTERPRISE_SERVER_IA64: DWORD = 0x0000000F;
+pub const PRODUCT_BUSINESS_N: DWORD = 0x00000010;
+pub const PRODUCT_WEB_SERVER: DWORD = 0x00000011;
+pub const PRODUCT_CLUSTER_SERVER: DWORD = 0x00000012;
+pub const PRODUCT_HOME_SERVER: DWORD = 0x00000013;
+pub const PRODUCT_STORAGE_EXPRESS_SERVER: DWORD = 0x00000014;
+pub const PRODUCT_STORAGE_STANDARD_SERVER: DWORD = 0x00000015;
+pub const PRODUCT_STORAGE_WORKGROUP_SERVER: DWORD = 0x00000016;
+pub const PRODUCT_STORAGE_ENTERPRISE_SERVER: DWORD = 0x00000017;
+pub const PRODUCT_SERVER_FOR_SMALLBUSINESS: DWORD = 0x00000018;
+pub const PRODUCT_SMALLBUSINESS_SERVER_PREMIUM: DWORD = 0x00000019;
+pub const PRODUCT_HOME_PREMIUM_N: DWORD = 0x0000001A;
+pub const PRODUCT_ENTERPRISE_N: DWORD = 0x0000001B;
+pub const PRODUCT_ULTIMATE_N: DWORD = 0x0000001C;
+pub const PRODUCT_WEB_SERVER_CORE: DWORD = 0x0000001D;
+pub const PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT: DWORD = 0x0000001E;
+pub const PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY: DWORD = 0x0000001F;
+pub const PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING: DWORD = 0x00000020;
+pub const PRODUCT_SERVER_FOUNDATION: DWORD = 0x00000021;
+pub const PRODUCT_HOME_PREMIUM_SERVER: DWORD = 0x00000022;
+pub const PRODUCT_SERVER_FOR_SMALLBUSINESS_V: DWORD = 0x00000023;
+pub const PRODUCT_STANDARD_SERVER_V: DWORD = 0x00000024;
+pub const PRODUCT_DATACENTER_SERVER_V: DWORD = 0x00000025;
+pub const PRODUCT_ENTERPRISE_SERVER_V: DWORD = 0x00000026;
+pub const PRODUCT_DATACENTER_SERVER_CORE_V: DWORD = 0x00000027;
+pub const PRODUCT_STANDARD_SERVER_CORE_V: DWORD = 0x00000028;
+pub const PRODUCT_ENTERPRISE_SERVER_CORE_V: DWORD = 0x00000029;
+pub const PRODUCT_HYPERV: DWORD = 0x0000002A;
+pub const PRODUCT_STORAGE_EXPRESS_SERVER_CORE: DWORD = 0x0000002B;
+pub const PRODUCT_STORAGE_STANDARD_SERVER_CORE: DWORD = 0x0000002C;
+pub const PRODUCT_STORAGE_WORKGROUP_SERVER_CORE: DWORD = 0x0000002D;
+pub const PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE: DWORD = 0x0000002E;
+pub const PRODUCT_STARTER_N: DWORD = 0x0000002F;
+pub const PRODUCT_PROFESSIONAL: DWORD = 0x00000030;
+pub const PRODUCT_PROFESSIONAL_N: DWORD = 0x00000031;
+pub const PRODUCT_SB_SOLUTION_SERVER: DWORD = 0x00000032;
+pub const PRODUCT_SERVER_FOR_SB_SOLUTIONS: DWORD = 0x00000033;
+pub const PRODUCT_STANDARD_SERVER_SOLUTIONS: DWORD = 0x00000034;
+pub const PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE: DWORD = 0x00000035;
+pub const PRODUCT_SB_SOLUTION_SERVER_EM: DWORD = 0x00000036;
+pub const PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM: DWORD = 0x00000037;
+pub const PRODUCT_SOLUTION_EMBEDDEDSERVER: DWORD = 0x00000038;
+pub const PRODUCT_SOLUTION_EMBEDDEDSERVER_CORE: DWORD = 0x00000039;
+pub const PRODUCT_PROFESSIONAL_EMBEDDED: DWORD = 0x0000003A;
+pub const PRODUCT_ESSENTIALBUSINESS_SERVER_MGMT: DWORD = 0x0000003B;
+pub const PRODUCT_ESSENTIALBUSINESS_SERVER_ADDL: DWORD = 0x0000003C;
+pub const PRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVC: DWORD = 0x0000003D;
+pub const PRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVC: DWORD = 0x0000003E;
+pub const PRODUCT_SMALLBUSINESS_SERVER_PREMIUM_CORE: DWORD = 0x0000003F;
+pub const PRODUCT_CLUSTER_SERVER_V: DWORD = 0x00000040;
+pub const PRODUCT_EMBEDDED: DWORD = 0x00000041;
+pub const PRODUCT_STARTER_E: DWORD = 0x00000042;
+pub const PRODUCT_HOME_BASIC_E: DWORD = 0x00000043;
+pub const PRODUCT_HOME_PREMIUM_E: DWORD = 0x00000044;
+pub const PRODUCT_PROFESSIONAL_E: DWORD = 0x00000045;
+pub const PRODUCT_ENTERPRISE_E: DWORD = 0x00000046;
+pub const PRODUCT_ULTIMATE_E: DWORD = 0x00000047;
+pub const PRODUCT_ENTERPRISE_EVALUATION: DWORD = 0x00000048;
+pub const PRODUCT_MULTIPOINT_STANDARD_SERVER: DWORD = 0x0000004C;
+pub const PRODUCT_MULTIPOINT_PREMIUM_SERVER: DWORD = 0x0000004D;
+pub const PRODUCT_STANDARD_EVALUATION_SERVER: DWORD = 0x0000004F;
+pub const PRODUCT_DATACENTER_EVALUATION_SERVER: DWORD = 0x00000050;
+pub const PRODUCT_ENTERPRISE_N_EVALUATION: DWORD = 0x00000054;
+pub const PRODUCT_EMBEDDED_AUTOMOTIVE: DWORD = 0x00000055;
+pub const PRODUCT_EMBEDDED_INDUSTRY_A: DWORD = 0x00000056;
+pub const PRODUCT_THINPC: DWORD = 0x00000057;
+pub const PRODUCT_EMBEDDED_A: DWORD = 0x00000058;
+pub const PRODUCT_EMBEDDED_INDUSTRY: DWORD = 0x00000059;
+pub const PRODUCT_EMBEDDED_E: DWORD = 0x0000005A;
+pub const PRODUCT_EMBEDDED_INDUSTRY_E: DWORD = 0x0000005B;
+pub const PRODUCT_EMBEDDED_INDUSTRY_A_E: DWORD = 0x0000005C;
+pub const PRODUCT_STORAGE_WORKGROUP_EVALUATION_SERVER: DWORD = 0x0000005F;
+pub const PRODUCT_STORAGE_STANDARD_EVALUATION_SERVER: DWORD = 0x00000060;
+pub const PRODUCT_CORE_ARM: DWORD = 0x00000061;
+pub const PRODUCT_CORE_N: DWORD = 0x00000062;
+pub const PRODUCT_CORE_COUNTRYSPECIFIC: DWORD = 0x00000063;
+pub const PRODUCT_CORE_SINGLELANGUAGE: DWORD = 0x00000064;
+pub const PRODUCT_CORE: DWORD = 0x00000065;
+pub const PRODUCT_PROFESSIONAL_WMC: DWORD = 0x00000067;
+pub const PRODUCT_MOBILE_CORE: DWORD = 0x00000068;
+pub const PRODUCT_EMBEDDED_INDUSTRY_EVAL: DWORD = 0x00000069;
+pub const PRODUCT_EMBEDDED_INDUSTRY_E_EVAL: DWORD = 0x0000006A;
+pub const PRODUCT_EMBEDDED_EVAL: DWORD = 0x0000006B;
+pub const PRODUCT_EMBEDDED_E_EVAL: DWORD = 0x0000006C;
+pub const PRODUCT_NANO_SERVER: DWORD = 0x0000006D;
+pub const PRODUCT_CLOUD_STORAGE_SERVER: DWORD = 0x0000006E;
+pub const PRODUCT_CORE_CONNECTED: DWORD = 0x0000006F;
+pub const PRODUCT_PROFESSIONAL_STUDENT: DWORD = 0x00000070;
+pub const PRODUCT_CORE_CONNECTED_N: DWORD = 0x00000071;
+pub const PRODUCT_PROFESSIONAL_STUDENT_N: DWORD = 0x00000072;
+pub const PRODUCT_CORE_CONNECTED_SINGLELANGUAGE: DWORD = 0x00000073;
+pub const PRODUCT_CORE_CONNECTED_COUNTRYSPECIFIC: DWORD = 0x00000074;
+pub const PRODUCT_CONNECTED_CAR: DWORD = 0x00000075;
+pub const PRODUCT_INDUSTRY_HANDHELD: DWORD = 0x00000076;
+pub const PRODUCT_PPI_PRO: DWORD = 0x00000077;
+pub const PRODUCT_ARM64_SERVER: DWORD = 0x00000078;
+pub const PRODUCT_EDUCATION: DWORD = 0x00000079;
+pub const PRODUCT_EDUCATION_N: DWORD = 0x0000007A;
+pub const PRODUCT_IOTUAP: DWORD = 0x0000007B;
+pub const PRODUCT_CLOUD_HOST_INFRASTRUCTURE_SERVER: DWORD = 0x0000007C;
+pub const PRODUCT_ENTERPRISE_S: DWORD = 0x0000007D;
+pub const PRODUCT_ENTERPRISE_S_N: DWORD = 0x0000007E;
+pub const PRODUCT_PROFESSIONAL_S: DWORD = 0x0000007F;
+pub const PRODUCT_PROFESSIONAL_S_N: DWORD = 0x00000080;
+pub const PRODUCT_ENTERPRISE_S_EVALUATION: DWORD = 0x00000081;
+pub const PRODUCT_ENTERPRISE_S_N_EVALUATION: DWORD = 0x00000082;
+pub const PRODUCT_HOLOGRAPHIC: DWORD = 0x00000087;
+pub const PRODUCT_PRO_SINGLE_LANGUAGE: DWORD = 0x0000008A;
+pub const PRODUCT_PRO_CHINA: DWORD = 0x0000008B;
+pub const PRODUCT_ENTERPRISE_SUBSCRIPTION: DWORD = 0x0000008C;
+pub const PRODUCT_ENTERPRISE_SUBSCRIPTION_N: DWORD = 0x0000008D;
+pub const PRODUCT_DATACENTER_NANO_SERVER: DWORD = 0x0000008F;
+pub const PRODUCT_STANDARD_NANO_SERVER: DWORD = 0x00000090;
+pub const PRODUCT_DATACENTER_A_SERVER_CORE: DWORD = 0x00000091;
+pub const PRODUCT_STANDARD_A_SERVER_CORE: DWORD = 0x00000092;
+pub const PRODUCT_DATACENTER_WS_SERVER_CORE: DWORD = 0x00000093;
+pub const PRODUCT_STANDARD_WS_SERVER_CORE: DWORD = 0x00000094;
+pub const PRODUCT_UTILITY_VM: DWORD = 0x00000095;
+pub const PRODUCT_DATACENTER_EVALUATION_SERVER_CORE: DWORD = 0x0000009F;
+pub const PRODUCT_STANDARD_EVALUATION_SERVER_CORE: DWORD = 0x000000A0;
+pub const PRODUCT_PRO_WORKSTATION: DWORD = 0x000000A1;
+pub const PRODUCT_PRO_WORKSTATION_N: DWORD = 0x000000A2;
+pub const PRODUCT_PRO_FOR_EDUCATION: DWORD = 0x000000A4;
+pub const PRODUCT_PRO_FOR_EDUCATION_N: DWORD = 0x000000A5;
+pub const PRODUCT_AZURE_SERVER_CORE: DWORD = 0x000000A8;
+pub const PRODUCT_AZURE_NANO_SERVER: DWORD = 0x000000A9;
+pub const PRODUCT_ENTERPRISEG: DWORD = 0x000000AB;
+pub const PRODUCT_ENTERPRISEGN: DWORD = 0x000000AC;
+pub const PRODUCT_CLOUD: DWORD = 0x000000B2;
+pub const PRODUCT_CLOUDN: DWORD = 0x000000B3;
+pub const PRODUCT_UNLICENSED: DWORD = 0xABCDABCD;
+pub const LANG_NEUTRAL: WORD = 0x00;
+pub const LANG_INVARIANT: WORD = 0x7f;
+pub const LANG_AFRIKAANS: WORD = 0x36;
+pub const LANG_ALBANIAN: WORD = 0x1c;
+pub const LANG_ALSATIAN: WORD = 0x84;
+pub const LANG_AMHARIC: WORD = 0x5e;
+pub const LANG_ARABIC: WORD = 0x01;
+pub const LANG_ARMENIAN: WORD = 0x2b;
+pub const LANG_ASSAMESE: WORD = 0x4d;
+pub const LANG_AZERI: WORD = 0x2c;
+pub const LANG_AZERBAIJANI: WORD = 0x2c;
+pub const LANG_BANGLA: WORD = 0x45;
+pub const LANG_BASHKIR: WORD = 0x6d;
+pub const LANG_BASQUE: WORD = 0x2d;
+pub const LANG_BELARUSIAN: WORD = 0x23;
+pub const LANG_BENGALI: WORD = 0x45;
+pub const LANG_BRETON: WORD = 0x7e;
+pub const LANG_BOSNIAN: WORD = 0x1a;
+pub const LANG_BOSNIAN_NEUTRAL: WORD = 0x781a;
+pub const LANG_BULGARIAN: WORD = 0x02;
+pub const LANG_CATALAN: WORD = 0x03;
+pub const LANG_CENTRAL_KURDISH: WORD = 0x92;
+pub const LANG_CHEROKEE: WORD = 0x5c;
+pub const LANG_CHINESE: WORD = 0x04;
+pub const LANG_CHINESE_SIMPLIFIED: WORD = 0x04;
+pub const LANG_CHINESE_TRADITIONAL: WORD = 0x7c04;
+pub const LANG_CORSICAN: WORD = 0x83;
+pub const LANG_CROATIAN: WORD = 0x1a;
+pub const LANG_CZECH: WORD = 0x05;
+pub const LANG_DANISH: WORD = 0x06;
+pub const LANG_DARI: WORD = 0x8c;
+pub const LANG_DIVEHI: WORD = 0x65;
+pub const LANG_DUTCH: WORD = 0x13;
+pub const LANG_ENGLISH: WORD = 0x09;
+pub const LANG_ESTONIAN: WORD = 0x25;
+pub const LANG_FAEROESE: WORD = 0x38;
+pub const LANG_FARSI: WORD = 0x29;
+pub const LANG_FILIPINO: WORD = 0x64;
+pub const LANG_FINNISH: WORD = 0x0b;
+pub const LANG_FRENCH: WORD = 0x0c;
+pub const LANG_FRISIAN: WORD = 0x62;
+pub const LANG_FULAH: WORD = 0x67;
+pub const LANG_GALICIAN: WORD = 0x56;
+pub const LANG_GEORGIAN: WORD = 0x37;
+pub const LANG_GERMAN: WORD = 0x07;
+pub const LANG_GREEK: WORD = 0x08;
+pub const LANG_GREENLANDIC: WORD = 0x6f;
+pub const LANG_GUJARATI: WORD = 0x47;
+pub const LANG_HAUSA: WORD = 0x68;
+pub const LANG_HAWAIIAN: WORD = 0x75;
+pub const LANG_HEBREW: WORD = 0x0d;
+pub const LANG_HINDI: WORD = 0x39;
+pub const LANG_HUNGARIAN: WORD = 0x0e;
+pub const LANG_ICELANDIC: WORD = 0x0f;
+pub const LANG_IGBO: WORD = 0x70;
+pub const LANG_INDONESIAN: WORD = 0x21;
+pub const LANG_INUKTITUT: WORD = 0x5d;
+pub const LANG_IRISH: WORD = 0x3c;
+pub const LANG_ITALIAN: WORD = 0x10;
+pub const LANG_JAPANESE: WORD = 0x11;
+pub const LANG_KANNADA: WORD = 0x4b;
+pub const LANG_KASHMIRI: WORD = 0x60;
+pub const LANG_KAZAK: WORD = 0x3f;
+pub const LANG_KHMER: WORD = 0x53;
+pub const LANG_KICHE: WORD = 0x86;
+pub const LANG_KINYARWANDA: WORD = 0x87;
+pub const LANG_KONKANI: WORD = 0x57;
+pub const LANG_KOREAN: WORD = 0x12;
+pub const LANG_KYRGYZ: WORD = 0x40;
+pub const LANG_LAO: WORD = 0x54;
+pub const LANG_LATVIAN: WORD = 0x26;
+pub const LANG_LITHUANIAN: WORD = 0x27;
+pub const LANG_LOWER_SORBIAN: WORD = 0x2e;
+pub const LANG_LUXEMBOURGISH: WORD = 0x6e;
+pub const LANG_MACEDONIAN: WORD = 0x2f;
+pub const LANG_MALAY: WORD = 0x3e;
+pub const LANG_MALAYALAM: WORD = 0x4c;
+pub const LANG_MALTESE: WORD = 0x3a;
+pub const LANG_MANIPURI: WORD = 0x58;
+pub const LANG_MAORI: WORD = 0x81;
+pub const LANG_MAPUDUNGUN: WORD = 0x7a;
+pub const LANG_MARATHI: WORD = 0x4e;
+pub const LANG_MOHAWK: WORD = 0x7c;
+pub const LANG_MONGOLIAN: WORD = 0x50;
+pub const LANG_NEPALI: WORD = 0x61;
+pub const LANG_NORWEGIAN: WORD = 0x14;
+pub const LANG_OCCITAN: WORD = 0x82;
+pub const LANG_ODIA: WORD = 0x48;
+pub const LANG_ORIYA: WORD = 0x48;
+pub const LANG_PASHTO: WORD = 0x63;
+pub const LANG_PERSIAN: WORD = 0x29;
+pub const LANG_POLISH: WORD = 0x15;
+pub const LANG_PORTUGUESE: WORD = 0x16;
+pub const LANG_PULAR: WORD = 0x67;
+pub const LANG_PUNJABI: WORD = 0x46;
+pub const LANG_QUECHUA: WORD = 0x6b;
+pub const LANG_ROMANIAN: WORD = 0x18;
+pub const LANG_ROMANSH: WORD = 0x17;
+pub const LANG_RUSSIAN: WORD = 0x19;
+pub const LANG_SAKHA: WORD = 0x85;
+pub const LANG_SAMI: WORD = 0x3b;
+pub const LANG_SANSKRIT: WORD = 0x4f;
+pub const LANG_SCOTTISH_GAELIC: WORD = 0x91;
+pub const LANG_SERBIAN: WORD = 0x1a;
+pub const LANG_SERBIAN_NEUTRAL: WORD = 0x7c1a;
+pub const LANG_SINDHI: WORD = 0x59;
+pub const LANG_SINHALESE: WORD = 0x5b;
+pub const LANG_SLOVAK: WORD = 0x1b;
+pub const LANG_SLOVENIAN: WORD = 0x24;
+pub const LANG_SOTHO: WORD = 0x6c;
+pub const LANG_SPANISH: WORD = 0x0a;
+pub const LANG_SWAHILI: WORD = 0x41;
+pub const LANG_SWEDISH: WORD = 0x1d;
+pub const LANG_SYRIAC: WORD = 0x5a;
+pub const LANG_TAJIK: WORD = 0x28;
+pub const LANG_TAMAZIGHT: WORD = 0x5f;
+pub const LANG_TAMIL: WORD = 0x49;
+pub const LANG_TATAR: WORD = 0x44;
+pub const LANG_TELUGU: WORD = 0x4a;
+pub const LANG_THAI: WORD = 0x1e;
+pub const LANG_TIBETAN: WORD = 0x51;
+pub const LANG_TIGRIGNA: WORD = 0x73;
+pub const LANG_TIGRINYA: WORD = 0x73;
+pub const LANG_TSWANA: WORD = 0x32;
+pub const LANG_TURKISH: WORD = 0x1f;
+pub const LANG_TURKMEN: WORD = 0x42;
+pub const LANG_UIGHUR: WORD = 0x80;
+pub const LANG_UKRAINIAN: WORD = 0x22;
+pub const LANG_UPPER_SORBIAN: WORD = 0x2e;
+pub const LANG_URDU: WORD = 0x20;
+pub const LANG_UZBEK: WORD = 0x43;
+pub const LANG_VALENCIAN: WORD = 0x03;
+pub const LANG_VIETNAMESE: WORD = 0x2a;
+pub const LANG_WELSH: WORD = 0x52;
+pub const LANG_WOLOF: WORD = 0x88;
+pub const LANG_XHOSA: WORD = 0x34;
+pub const LANG_YAKUT: WORD = 0x85;
+pub const LANG_YI: WORD = 0x78;
+pub const LANG_YORUBA: WORD = 0x6a;
+pub const LANG_ZULU: WORD = 0x35;
+pub const SUBLANG_NEUTRAL: WORD = 0x00;
+pub const SUBLANG_DEFAULT: WORD = 0x01;
+pub const SUBLANG_SYS_DEFAULT: WORD = 0x02;
+pub const SUBLANG_CUSTOM_DEFAULT: WORD = 0x03;
+pub const SUBLANG_CUSTOM_UNSPECIFIED: WORD = 0x04;
+pub const SUBLANG_UI_CUSTOM_DEFAULT: WORD = 0x05;
+pub const SUBLANG_AFRIKAANS_SOUTH_AFRICA: WORD = 0x01;
+pub const SUBLANG_ALBANIAN_ALBANIA: WORD = 0x01;
+pub const SUBLANG_ALSATIAN_FRANCE: WORD = 0x01;
+pub const SUBLANG_AMHARIC_ETHIOPIA: WORD = 0x01;
+pub const SUBLANG_ARABIC_SAUDI_ARABIA: WORD = 0x01;
+pub const SUBLANG_ARABIC_IRAQ: WORD = 0x02;
+pub const SUBLANG_ARABIC_EGYPT: WORD = 0x03;
+pub const SUBLANG_ARABIC_LIBYA: WORD = 0x04;
+pub const SUBLANG_ARABIC_ALGERIA: WORD = 0x05;
+pub const SUBLANG_ARABIC_MOROCCO: WORD = 0x06;
+pub const SUBLANG_ARABIC_TUNISIA: WORD = 0x07;
+pub const SUBLANG_ARABIC_OMAN: WORD = 0x08;
+pub const SUBLANG_ARABIC_YEMEN: WORD = 0x09;
+pub const SUBLANG_ARABIC_SYRIA: WORD = 0x0a;
+pub const SUBLANG_ARABIC_JORDAN: WORD = 0x0b;
+pub const SUBLANG_ARABIC_LEBANON: WORD = 0x0c;
+pub const SUBLANG_ARABIC_KUWAIT: WORD = 0x0d;
+pub const SUBLANG_ARABIC_UAE: WORD = 0x0e;
+pub const SUBLANG_ARABIC_BAHRAIN: WORD = 0x0f;
+pub const SUBLANG_ARABIC_QATAR: WORD = 0x10;
+pub const SUBLANG_ARMENIAN_ARMENIA: WORD = 0x01;
+pub const SUBLANG_ASSAMESE_INDIA: WORD = 0x01;
+pub const SUBLANG_AZERI_LATIN: WORD = 0x01;
+pub const SUBLANG_AZERI_CYRILLIC: WORD = 0x02;
+pub const SUBLANG_AZERBAIJANI_AZERBAIJAN_LATIN: WORD = 0x01;
+pub const SUBLANG_AZERBAIJANI_AZERBAIJAN_CYRILLIC: WORD = 0x02;
+pub const SUBLANG_BANGLA_INDIA: WORD = 0x01;
+pub const SUBLANG_BANGLA_BANGLADESH: WORD = 0x02;
+pub const SUBLANG_BASHKIR_RUSSIA: WORD = 0x01;
+pub const SUBLANG_BASQUE_BASQUE: WORD = 0x01;
+pub const SUBLANG_BELARUSIAN_BELARUS: WORD = 0x01;
+pub const SUBLANG_BENGALI_INDIA: WORD = 0x01;
+pub const SUBLANG_BENGALI_BANGLADESH: WORD = 0x02;
+pub const SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN: WORD = 0x05;
+pub const SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC: WORD = 0x08;
+pub const SUBLANG_BRETON_FRANCE: WORD = 0x01;
+pub const SUBLANG_BULGARIAN_BULGARIA: WORD = 0x01;
+pub const SUBLANG_CATALAN_CATALAN: WORD = 0x01;
+pub const SUBLANG_CENTRAL_KURDISH_IRAQ: WORD = 0x01;
+pub const SUBLANG_CHEROKEE_CHEROKEE: WORD = 0x01;
+pub const SUBLANG_CHINESE_TRADITIONAL: WORD = 0x01;
+pub const SUBLANG_CHINESE_SIMPLIFIED: WORD = 0x02;
+pub const SUBLANG_CHINESE_HONGKONG: WORD = 0x03;
+pub const SUBLANG_CHINESE_SINGAPORE: WORD = 0x04;
+pub const SUBLANG_CHINESE_MACAU: WORD = 0x05;
+pub const SUBLANG_CORSICAN_FRANCE: WORD = 0x01;
+pub const SUBLANG_CZECH_CZECH_REPUBLIC: WORD = 0x01;
+pub const SUBLANG_CROATIAN_CROATIA: WORD = 0x01;
+pub const SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN: WORD = 0x04;
+pub const SUBLANG_DANISH_DENMARK: WORD = 0x01;
+pub const SUBLANG_DARI_AFGHANISTAN: WORD = 0x01;
+pub const SUBLANG_DIVEHI_MALDIVES: WORD = 0x01;
+pub const SUBLANG_DUTCH: WORD = 0x01;
+pub const SUBLANG_DUTCH_BELGIAN: WORD = 0x02;
+pub const SUBLANG_ENGLISH_US: WORD = 0x01;
+pub const SUBLANG_ENGLISH_UK: WORD = 0x02;
+pub const SUBLANG_ENGLISH_AUS: WORD = 0x03;
+pub const SUBLANG_ENGLISH_CAN: WORD = 0x04;
+pub const SUBLANG_ENGLISH_NZ: WORD = 0x05;
+pub const SUBLANG_ENGLISH_EIRE: WORD = 0x06;
+pub const SUBLANG_ENGLISH_SOUTH_AFRICA: WORD = 0x07;
+pub const SUBLANG_ENGLISH_JAMAICA: WORD = 0x08;
+pub const SUBLANG_ENGLISH_CARIBBEAN: WORD = 0x09;
+pub const SUBLANG_ENGLISH_BELIZE: WORD = 0x0a;
+pub const SUBLANG_ENGLISH_TRINIDAD: WORD = 0x0b;
+pub const SUBLANG_ENGLISH_ZIMBABWE: WORD = 0x0c;
+pub const SUBLANG_ENGLISH_PHILIPPINES: WORD = 0x0d;
+pub const SUBLANG_ENGLISH_INDIA: WORD = 0x10;
+pub const SUBLANG_ENGLISH_MALAYSIA: WORD = 0x11;
+pub const SUBLANG_ENGLISH_SINGAPORE: WORD = 0x12;
+pub const SUBLANG_ESTONIAN_ESTONIA: WORD = 0x01;
+pub const SUBLANG_FAEROESE_FAROE_ISLANDS: WORD = 0x01;
+pub const SUBLANG_FILIPINO_PHILIPPINES: WORD = 0x01;
+pub const SUBLANG_FINNISH_FINLAND: WORD = 0x01;
+pub const SUBLANG_FRENCH: WORD = 0x01;
+pub const SUBLANG_FRENCH_BELGIAN: WORD = 0x02;
+pub const SUBLANG_FRENCH_CANADIAN: WORD = 0x03;
+pub const SUBLANG_FRENCH_SWISS: WORD = 0x04;
+pub const SUBLANG_FRENCH_LUXEMBOURG: WORD = 0x05;
+pub const SUBLANG_FRENCH_MONACO: WORD = 0x06;
+pub const SUBLANG_FRISIAN_NETHERLANDS: WORD = 0x01;
+pub const SUBLANG_FULAH_SENEGAL: WORD = 0x02;
+pub const SUBLANG_GALICIAN_GALICIAN: WORD = 0x01;
+pub const SUBLANG_GEORGIAN_GEORGIA: WORD = 0x01;
+pub const SUBLANG_GERMAN: WORD = 0x01;
+pub const SUBLANG_GERMAN_SWISS: WORD = 0x02;
+pub const SUBLANG_GERMAN_AUSTRIAN: WORD = 0x03;
+pub const SUBLANG_GERMAN_LUXEMBOURG: WORD = 0x04;
+pub const SUBLANG_GERMAN_LIECHTENSTEIN: WORD = 0x05;
+pub const SUBLANG_GREEK_GREECE: WORD = 0x01;
+pub const SUBLANG_GREENLANDIC_GREENLAND: WORD = 0x01;
+pub const SUBLANG_GUJARATI_INDIA: WORD = 0x01;
+pub const SUBLANG_HAUSA_NIGERIA_LATIN: WORD = 0x01;
+pub const SUBLANG_HAWAIIAN_US: WORD = 0x01;
+pub const SUBLANG_HEBREW_ISRAEL: WORD = 0x01;
+pub const SUBLANG_HINDI_INDIA: WORD = 0x01;
+pub const SUBLANG_HUNGARIAN_HUNGARY: WORD = 0x01;
+pub const SUBLANG_ICELANDIC_ICELAND: WORD = 0x01;
+pub const SUBLANG_IGBO_NIGERIA: WORD = 0x01;
+pub const SUBLANG_INDONESIAN_INDONESIA: WORD = 0x01;
+pub const SUBLANG_INUKTITUT_CANADA: WORD = 0x01;
+pub const SUBLANG_INUKTITUT_CANADA_LATIN: WORD = 0x02;
+pub const SUBLANG_IRISH_IRELAND: WORD = 0x02;
+pub const SUBLANG_ITALIAN: WORD = 0x01;
+pub const SUBLANG_ITALIAN_SWISS: WORD = 0x02;
+pub const SUBLANG_JAPANESE_JAPAN: WORD = 0x01;
+pub const SUBLANG_KANNADA_INDIA: WORD = 0x01;
+pub const SUBLANG_KASHMIRI_SASIA: WORD = 0x02;
+pub const SUBLANG_KASHMIRI_INDIA: WORD = 0x02;
+pub const SUBLANG_KAZAK_KAZAKHSTAN: WORD = 0x01;
+pub const SUBLANG_KHMER_CAMBODIA: WORD = 0x01;
+pub const SUBLANG_KICHE_GUATEMALA: WORD = 0x01;
+pub const SUBLANG_KINYARWANDA_RWANDA: WORD = 0x01;
+pub const SUBLANG_KONKANI_INDIA: WORD = 0x01;
+pub const SUBLANG_KOREAN: WORD = 0x01;
+pub const SUBLANG_KYRGYZ_KYRGYZSTAN: WORD = 0x01;
+pub const SUBLANG_LAO_LAO: WORD = 0x01;
+pub const SUBLANG_LATVIAN_LATVIA: WORD = 0x01;
+pub const SUBLANG_LITHUANIAN: WORD = 0x01;
+pub const SUBLANG_LOWER_SORBIAN_GERMANY: WORD = 0x02;
+pub const SUBLANG_LUXEMBOURGISH_LUXEMBOURG: WORD = 0x01;
+pub const SUBLANG_MACEDONIAN_MACEDONIA: WORD = 0x01;
+pub const SUBLANG_MALAY_MALAYSIA: WORD = 0x01;
+pub const SUBLANG_MALAY_BRUNEI_DARUSSALAM: WORD = 0x02;
+pub const SUBLANG_MALAYALAM_INDIA: WORD = 0x01;
+pub const SUBLANG_MALTESE_MALTA: WORD = 0x01;
+pub const SUBLANG_MAORI_NEW_ZEALAND: WORD = 0x01;
+pub const SUBLANG_MAPUDUNGUN_CHILE: WORD = 0x01;
+pub const SUBLANG_MARATHI_INDIA: WORD = 0x01;
+pub const SUBLANG_MOHAWK_MOHAWK: WORD = 0x01;
+pub const SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA: WORD = 0x01;
+pub const SUBLANG_MONGOLIAN_PRC: WORD = 0x02;
+pub const SUBLANG_NEPALI_INDIA: WORD = 0x02;
+pub const SUBLANG_NEPALI_NEPAL: WORD = 0x01;
+pub const SUBLANG_NORWEGIAN_BOKMAL: WORD = 0x01;
+pub const SUBLANG_NORWEGIAN_NYNORSK: WORD = 0x02;
+pub const SUBLANG_OCCITAN_FRANCE: WORD = 0x01;
+pub const SUBLANG_ODIA_INDIA: WORD = 0x01;
+pub const SUBLANG_ORIYA_INDIA: WORD = 0x01;
+pub const SUBLANG_PASHTO_AFGHANISTAN: WORD = 0x01;
+pub const SUBLANG_PERSIAN_IRAN: WORD = 0x01;
+pub const SUBLANG_POLISH_POLAND: WORD = 0x01;
+pub const SUBLANG_PORTUGUESE: WORD = 0x02;
+pub const SUBLANG_PORTUGUESE_BRAZILIAN: WORD = 0x01;
+pub const SUBLANG_PULAR_SENEGAL: WORD = 0x02;
+pub const SUBLANG_PUNJABI_INDIA: WORD = 0x01;
+pub const SUBLANG_PUNJABI_PAKISTAN: WORD = 0x02;
+pub const SUBLANG_QUECHUA_BOLIVIA: WORD = 0x01;
+pub const SUBLANG_QUECHUA_ECUADOR: WORD = 0x02;
+pub const SUBLANG_QUECHUA_PERU: WORD = 0x03;
+pub const SUBLANG_ROMANIAN_ROMANIA: WORD = 0x01;
+pub const SUBLANG_ROMANSH_SWITZERLAND: WORD = 0x01;
+pub const SUBLANG_RUSSIAN_RUSSIA: WORD = 0x01;
+pub const SUBLANG_SAKHA_RUSSIA: WORD = 0x01;
+pub const SUBLANG_SAMI_NORTHERN_NORWAY: WORD = 0x01;
+pub const SUBLANG_SAMI_NORTHERN_SWEDEN: WORD = 0x02;
+pub const SUBLANG_SAMI_NORTHERN_FINLAND: WORD = 0x03;
+pub const SUBLANG_SAMI_LULE_NORWAY: WORD = 0x04;
+pub const SUBLANG_SAMI_LULE_SWEDEN: WORD = 0x05;
+pub const SUBLANG_SAMI_SOUTHERN_NORWAY: WORD = 0x06;
+pub const SUBLANG_SAMI_SOUTHERN_SWEDEN: WORD = 0x07;
+pub const SUBLANG_SAMI_SKOLT_FINLAND: WORD = 0x08;
+pub const SUBLANG_SAMI_INARI_FINLAND: WORD = 0x09;
+pub const SUBLANG_SANSKRIT_INDIA: WORD = 0x01;
+pub const SUBLANG_SCOTTISH_GAELIC: WORD = 0x01;
+pub const SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATIN: WORD = 0x06;
+pub const SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLIC: WORD = 0x07;
+pub const SUBLANG_SERBIAN_MONTENEGRO_LATIN: WORD = 0x0b;
+pub const SUBLANG_SERBIAN_MONTENEGRO_CYRILLIC: WORD = 0x0c;
+pub const SUBLANG_SERBIAN_SERBIA_LATIN: WORD = 0x09;
+pub const SUBLANG_SERBIAN_SERBIA_CYRILLIC: WORD = 0x0a;
+pub const SUBLANG_SERBIAN_CROATIA: WORD = 0x01;
+pub const SUBLANG_SERBIAN_LATIN: WORD = 0x02;
+pub const SUBLANG_SERBIAN_CYRILLIC: WORD = 0x03;
+pub const SUBLANG_SINDHI_INDIA: WORD = 0x01;
+pub const SUBLANG_SINDHI_PAKISTAN: WORD = 0x02;
+pub const SUBLANG_SINDHI_AFGHANISTAN: WORD = 0x02;
+pub const SUBLANG_SINHALESE_SRI_LANKA: WORD = 0x01;
+pub const SUBLANG_SOTHO_NORTHERN_SOUTH_AFRICA: WORD = 0x01;
+pub const SUBLANG_SLOVAK_SLOVAKIA: WORD = 0x01;
+pub const SUBLANG_SLOVENIAN_SLOVENIA: WORD = 0x01;
+pub const SUBLANG_SPANISH: WORD = 0x01;
+pub const SUBLANG_SPANISH_MEXICAN: WORD = 0x02;
+pub const SUBLANG_SPANISH_MODERN: WORD = 0x03;
+pub const SUBLANG_SPANISH_GUATEMALA: WORD = 0x04;
+pub const SUBLANG_SPANISH_COSTA_RICA: WORD = 0x05;
+pub const SUBLANG_SPANISH_PANAMA: WORD = 0x06;
+pub const SUBLANG_SPANISH_DOMINICAN_REPUBLIC: WORD = 0x07;
+pub const SUBLANG_SPANISH_VENEZUELA: WORD = 0x08;
+pub const SUBLANG_SPANISH_COLOMBIA: WORD = 0x09;
+pub const SUBLANG_SPANISH_PERU: WORD = 0x0a;
+pub const SUBLANG_SPANISH_ARGENTINA: WORD = 0x0b;
+pub const SUBLANG_SPANISH_ECUADOR: WORD = 0x0c;
+pub const SUBLANG_SPANISH_CHILE: WORD = 0x0d;
+pub const SUBLANG_SPANISH_URUGUAY: WORD = 0x0e;
+pub const SUBLANG_SPANISH_PARAGUAY: WORD = 0x0f;
+pub const SUBLANG_SPANISH_BOLIVIA: WORD = 0x10;
+pub const SUBLANG_SPANISH_EL_SALVADOR: WORD = 0x11;
+pub const SUBLANG_SPANISH_HONDURAS: WORD = 0x12;
+pub const SUBLANG_SPANISH_NICARAGUA: WORD = 0x13;
+pub const SUBLANG_SPANISH_PUERTO_RICO: WORD = 0x14;
+pub const SUBLANG_SPANISH_US: WORD = 0x15;
+pub const SUBLANG_SWAHILI_KENYA: WORD = 0x01;
+pub const SUBLANG_SWEDISH: WORD = 0x01;
+pub const SUBLANG_SWEDISH_FINLAND: WORD = 0x02;
+pub const SUBLANG_SYRIAC_SYRIA: WORD = 0x01;
+pub const SUBLANG_TAJIK_TAJIKISTAN: WORD = 0x01;
+pub const SUBLANG_TAMAZIGHT_ALGERIA_LATIN: WORD = 0x02;
+pub const SUBLANG_TAMAZIGHT_MOROCCO_TIFINAGH: WORD = 0x04;
+pub const SUBLANG_TAMIL_INDIA: WORD = 0x01;
+pub const SUBLANG_TAMIL_SRI_LANKA: WORD = 0x02;
+pub const SUBLANG_TATAR_RUSSIA: WORD = 0x01;
+pub const SUBLANG_TELUGU_INDIA: WORD = 0x01;
+pub const SUBLANG_THAI_THAILAND: WORD = 0x01;
+pub const SUBLANG_TIBETAN_PRC: WORD = 0x01;
+pub const SUBLANG_TIGRIGNA_ERITREA: WORD = 0x02;
+pub const SUBLANG_TIGRINYA_ERITREA: WORD = 0x02;
+pub const SUBLANG_TIGRINYA_ETHIOPIA: WORD = 0x01;
+pub const SUBLANG_TSWANA_BOTSWANA: WORD = 0x02;
+pub const SUBLANG_TSWANA_SOUTH_AFRICA: WORD = 0x01;
+pub const SUBLANG_TURKISH_TURKEY: WORD = 0x01;
+pub const SUBLANG_TURKMEN_TURKMENISTAN: WORD = 0x01;
+pub const SUBLANG_UIGHUR_PRC: WORD = 0x01;
+pub const SUBLANG_UKRAINIAN_UKRAINE: WORD = 0x01;
+pub const SUBLANG_UPPER_SORBIAN_GERMANY: WORD = 0x01;
+pub const SUBLANG_URDU_PAKISTAN: WORD = 0x01;
+pub const SUBLANG_URDU_INDIA: WORD = 0x02;
+pub const SUBLANG_UZBEK_LATIN: WORD = 0x01;
+pub const SUBLANG_UZBEK_CYRILLIC: WORD = 0x02;
+pub const SUBLANG_VALENCIAN_VALENCIA: WORD = 0x02;
+pub const SUBLANG_VIETNAMESE_VIETNAM: WORD = 0x01;
+pub const SUBLANG_WELSH_UNITED_KINGDOM: WORD = 0x01;
+pub const SUBLANG_WOLOF_SENEGAL: WORD = 0x01;
+pub const SUBLANG_XHOSA_SOUTH_AFRICA: WORD = 0x01;
+pub const SUBLANG_YAKUT_RUSSIA: WORD = 0x01;
+pub const SUBLANG_YI_PRC: WORD = 0x01;
+pub const SUBLANG_YORUBA_NIGERIA: WORD = 0x01;
+pub const SUBLANG_ZULU_SOUTH_AFRICA: WORD = 0x01;
+pub const SORT_DEFAULT: WORD = 0x0;
+pub const SORT_INVARIANT_MATH: WORD = 0x1;
+pub const SORT_JAPANESE_XJIS: WORD = 0x0;
+pub const SORT_JAPANESE_UNICODE: WORD = 0x1;
+pub const SORT_JAPANESE_RADICALSTROKE: WORD = 0x4;
+pub const SORT_CHINESE_BIG5: WORD = 0x0;
+pub const SORT_CHINESE_PRCP: WORD = 0x0;
+pub const SORT_CHINESE_UNICODE: WORD = 0x1;
+pub const SORT_CHINESE_PRC: WORD = 0x2;
+pub const SORT_CHINESE_BOPOMOFO: WORD = 0x3;
+pub const SORT_CHINESE_RADICALSTROKE: WORD = 0x4;
+pub const SORT_KOREAN_KSC: WORD = 0x0;
+pub const SORT_KOREAN_UNICODE: WORD = 0x1;
+pub const SORT_GERMAN_PHONE_BOOK: WORD = 0x1;
+pub const SORT_HUNGARIAN_DEFAULT: WORD = 0x0;
+pub const SORT_HUNGARIAN_TECHNICAL: WORD = 0x1;
+pub const SORT_GEORGIAN_TRADITIONAL: WORD = 0x0;
+pub const SORT_GEORGIAN_MODERN: WORD = 0x1;
+macro_rules! MAKELANGID { ($p:expr, $s:expr) => (($s << 10) | $p) }
+#[inline]
+pub fn MAKELANGID(p: WORD, s: WORD) -> LANGID {
+    (s << 10) | p
+}
+#[inline]
+pub fn PRIMARYLANGID(lgid: LANGID) -> WORD {
+    lgid & 0x3ff
+}
+#[inline]
+pub fn SUBLANGID(lgid: LANGID) -> WORD {
+    lgid >> 10
+}
+pub const NLS_VALID_LOCALE_MASK: DWORD = 0x000fffff;
+macro_rules! MAKELCID {
+    ($lgid:expr, $srtid:expr) => ((($srtid as DWORD) << 16) | ($lgid as DWORD))
+}
+#[inline]
+pub fn MAKELCID(lgid: LANGID, srtid: WORD) -> LCID {
+    ((srtid as DWORD) << 16) | (lgid as DWORD)
+}
+#[inline]
+pub fn MAKESORTLCID(lgid: LANGID, srtid: WORD, ver: WORD) -> LCID {
+    MAKELCID(lgid, srtid) | ((ver as DWORD) << 20)
+}
+#[inline]
+pub fn LANGIDFROMLCID(lcid: LCID) -> LANGID {
+    lcid as LANGID
+}
+#[inline]
+pub fn SORTIDFROMLCID(lcid: LCID) -> WORD {
+    ((lcid >> 16) & 0xf) as WORD
+}
+#[inline]
+pub fn SORTVERSIONFROMLCID(lcid: LCID) -> WORD {
+    ((lcid >> 16) & 0xf) as WORD
+}
+pub const LOCALE_NAME_MAX_LENGTH: usize = 85;
+pub const LANG_SYSTEM_DEFAULT: LANGID = MAKELANGID!(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT);
+pub const LANG_USER_DEFAULT: LANGID = MAKELANGID!(LANG_NEUTRAL, SUBLANG_DEFAULT);
+pub const LOCALE_SYSTEM_DEFAULT: LCID = MAKELCID!(LANG_SYSTEM_DEFAULT, SORT_DEFAULT);
+pub const LOCALE_USER_DEFAULT: LCID = MAKELCID!(LANG_USER_DEFAULT, SORT_DEFAULT);
+pub const LOCALE_CUSTOM_DEFAULT: LCID
+    = MAKELCID!(MAKELANGID!(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT), SORT_DEFAULT);
+pub const LOCALE_CUSTOM_UNSPECIFIED: LCID
+    = MAKELCID!(MAKELANGID!(LANG_NEUTRAL, SUBLANG_CUSTOM_UNSPECIFIED), SORT_DEFAULT);
+pub const LOCALE_CUSTOM_UI_DEFAULT: LCID
+    = MAKELCID!(MAKELANGID!(LANG_NEUTRAL, SUBLANG_UI_CUSTOM_DEFAULT), SORT_DEFAULT);
+pub const LOCALE_NEUTRAL: LCID
+    = MAKELCID!(MAKELANGID!(LANG_NEUTRAL, SUBLANG_NEUTRAL), SORT_DEFAULT);
+pub const LOCALE_INVARIANT: LCID
+    = MAKELCID!(MAKELANGID!(LANG_INVARIANT, SUBLANG_NEUTRAL), SORT_DEFAULT);
+pub const LOCALE_TRANSIENT_KEYBOARD1: LCID = 0x2000;
+pub const LOCALE_TRANSIENT_KEYBOARD2: LCID = 0x2400;
+pub const LOCALE_TRANSIENT_KEYBOARD3: LCID = 0x2800;
+pub const LOCALE_TRANSIENT_KEYBOARD4: LCID = 0x2c00;
+pub const LOCALE_UNASSIGNED_LCID: LCID = LOCALE_CUSTOM_UNSPECIFIED;
+pub const STATUS_WAIT_0: DWORD = 0x00000000;
+pub const STATUS_ABANDONED_WAIT_0: DWORD = 0x00000080;
+pub const STATUS_USER_APC: DWORD = 0x000000C0;
+pub const STATUS_TIMEOUT: DWORD = 0x00000102;
+pub const STATUS_PENDING: DWORD = 0x00000103;
+pub const DBG_EXCEPTION_HANDLED: DWORD = 0x00010001;
+pub const DBG_CONTINUE: DWORD = 0x00010002;
+pub const STATUS_SEGMENT_NOTIFICATION: DWORD = 0x40000005;
+pub const STATUS_FATAL_APP_EXIT: DWORD = 0x40000015;
+pub const DBG_REPLY_LATER: DWORD = 0x40010001;
+pub const DBG_TERMINATE_THREAD: DWORD = 0x40010003;
+pub const DBG_TERMINATE_PROCESS: DWORD = 0x40010004;
+pub const DBG_CONTROL_C: DWORD = 0x40010005;
+pub const DBG_PRINTEXCEPTION_C: DWORD = 0x40010006;
+pub const DBG_RIPEXCEPTION: DWORD = 0x40010007;
+pub const DBG_CONTROL_BREAK: DWORD = 0x40010008;
+pub const DBG_COMMAND_EXCEPTION: DWORD = 0x40010009;
+pub const DBG_PRINTEXCEPTION_WIDE_C: DWORD = 0x4001000A;
+pub const STATUS_GUARD_PAGE_VIOLATION: DWORD = 0x80000001;
+pub const STATUS_DATATYPE_MISALIGNMENT: DWORD = 0x80000002;
+pub const STATUS_BREAKPOINT: DWORD = 0x80000003;
+pub const STATUS_SINGLE_STEP: DWORD = 0x80000004;
+pub const STATUS_LONGJUMP: DWORD = 0x80000026;
+pub const STATUS_UNWIND_CONSOLIDATE: DWORD = 0x80000029;
+pub const DBG_EXCEPTION_NOT_HANDLED: DWORD = 0x80010001;
+pub const STATUS_ACCESS_VIOLATION: DWORD = 0xC0000005;
+pub const STATUS_IN_PAGE_ERROR: DWORD = 0xC0000006;
+pub const STATUS_INVALID_HANDLE: DWORD = 0xC0000008;
+pub const STATUS_INVALID_PARAMETER: DWORD = 0xC000000D;
+pub const STATUS_NO_MEMORY: DWORD = 0xC0000017;
+pub const STATUS_ILLEGAL_INSTRUCTION: DWORD = 0xC000001D;
+pub const STATUS_NONCONTINUABLE_EXCEPTION: DWORD = 0xC0000025;
+pub const STATUS_INVALID_DISPOSITION: DWORD = 0xC0000026;
+pub const STATUS_ARRAY_BOUNDS_EXCEEDED: DWORD = 0xC000008C;
+pub const STATUS_FLOAT_DENORMAL_OPERAND: DWORD = 0xC000008D;
+pub const STATUS_FLOAT_DIVIDE_BY_ZERO: DWORD = 0xC000008E;
+pub const STATUS_FLOAT_INEXACT_RESULT: DWORD = 0xC000008F;
+pub const STATUS_FLOAT_INVALID_OPERATION: DWORD = 0xC0000090;
+pub const STATUS_FLOAT_OVERFLOW: DWORD = 0xC0000091;
+pub const STATUS_FLOAT_STACK_CHECK: DWORD = 0xC0000092;
+pub const STATUS_FLOAT_UNDERFLOW: DWORD = 0xC0000093;
+pub const STATUS_INTEGER_DIVIDE_BY_ZERO: DWORD = 0xC0000094;
+pub const STATUS_INTEGER_OVERFLOW: DWORD = 0xC0000095;
+pub const STATUS_PRIVILEGED_INSTRUCTION: DWORD = 0xC0000096;
+pub const STATUS_STACK_OVERFLOW: DWORD = 0xC00000FD;
+pub const STATUS_DLL_NOT_FOUND: DWORD = 0xC0000135;
+pub const STATUS_ORDINAL_NOT_FOUND: DWORD = 0xC0000138;
+pub const STATUS_ENTRYPOINT_NOT_FOUND: DWORD = 0xC0000139;
+pub const STATUS_CONTROL_C_EXIT: DWORD = 0xC000013A;
+pub const STATUS_DLL_INIT_FAILED: DWORD = 0xC0000142;
+pub const STATUS_FLOAT_MULTIPLE_FAULTS: DWORD = 0xC00002B4;
+pub const STATUS_FLOAT_MULTIPLE_TRAPS: DWORD = 0xC00002B5;
+pub const STATUS_REG_NAT_CONSUMPTION: DWORD = 0xC00002C9;
+pub const STATUS_HEAP_CORRUPTION: DWORD = 0xC0000374;
+pub const STATUS_STACK_BUFFER_OVERRUN: DWORD = 0xC0000409;
+pub const STATUS_INVALID_CRUNTIME_PARAMETER: DWORD = 0xC0000417;
+pub const STATUS_ASSERTION_FAILURE: DWORD = 0xC0000420;
+pub const STATUS_SXS_EARLY_DEACTIVATION: DWORD = 0xC015000F;
+pub const STATUS_SXS_INVALID_DEACTIVATION: DWORD = 0xC0150010;
+pub const MAXIMUM_WAIT_OBJECTS: DWORD = 64;
+pub const MAXIMUM_SUSPEND_COUNT: CHAR = MAXCHAR;
+pub type KSPIN_LOCK = ULONG_PTR;
+pub type PKSPIN_LOCK = *mut KSPIN_LOCK;
+STRUCT!{struct M128A { // FIXME align 16
+    Low: ULONGLONG,
+    High: LONGLONG,
+}}
+pub type PM128A = *mut M128A;
+#[cfg(target_pointer_width = "32")]
+STRUCT!{struct XSAVE_FORMAT { // FIXME align 16
+    ControlWord: WORD,
+    StatusWord: WORD,
+    TagWord: BYTE,
+    Reserved1: BYTE,
+    ErrorOpcode: WORD,
+    ErrorOffset: DWORD,
+    ErrorSelector: WORD,
+    Reserved2: WORD,
+    DataOffset: DWORD,
+    DataSelector: WORD,
+    Reserved3: WORD,
+    MxCsr: DWORD,
+    MxCsr_Mask: DWORD,
+    FloatRegisters: [M128A; 8],
+    XmmRegisters: [M128A; 8],
+    Reserved4: [BYTE; 224],
+}}
+#[cfg(target_pointer_width = "64")]
+STRUCT!{struct XSAVE_FORMAT { // FIXME align 16
+    ControlWord: WORD,
+    StatusWord: WORD,
+    TagWord: BYTE,
+    Reserved1: BYTE,
+    ErrorOpcode: WORD,
+    ErrorOffset: DWORD,
+    ErrorSelector: WORD,
+    Reserved2: WORD,
+    DataOffset: DWORD,
+    DataSelector: WORD,
+    Reserved3: WORD,
+    MxCsr: DWORD,
+    MxCsr_Mask: DWORD,
+    FloatRegisters: [M128A; 8],
+    XmmRegisters: [M128A; 16],
+    Reserved4: [BYTE; 96],
+}}
+#[cfg(target_arch = "x86")]
+STRUCT!{struct XSTATE_CONTEXT {
+    Mask: DWORD64,
+    Length: DWORD,
+    Reserved1: DWORD,
+    Area: PXSAVE_AREA,
+    Reserved2: DWORD,
+    Buffer: PVOID,
+    Reserved3: DWORD,
+}}
+#[cfg(not(target_arch = "x86"))]
+STRUCT!{struct XSTATE_CONTEXT {
+    Mask: DWORD64,
+    Length: DWORD,
+    Reserved1: DWORD,
+    Area: PXSAVE_AREA,
+    Buffer: PVOID,
+}}
+pub type PXSAVE_FORMAT = *mut XSAVE_FORMAT;
+STRUCT!{struct XSAVE_AREA_HEADER { // FIXME align 8
+    Mask: DWORD64,
+    CompactionMask: DWORD64,
+    Reserved2: [DWORD64; 6],
+}}
+pub type PXSAVE_AREA_HEADER = *mut XSAVE_AREA_HEADER;
+STRUCT!{struct XSAVE_AREA { // FIXME align 16
+    LegacyState: XSAVE_FORMAT,
+    Header: XSAVE_AREA_HEADER,
+}}
+pub type PXSAVE_AREA = *mut XSAVE_AREA;
+pub type PXSTATE_CONTEXT = *mut XSTATE_CONTEXT;
+STRUCT!{struct SCOPE_TABLE_AMD64 {
+    Count: DWORD,
+    ScopeRecord: [SCOPE_TABLE_AMD64_ScopeRecord; 1],
+}}
+STRUCT!{struct SCOPE_TABLE_AMD64_ScopeRecord {
+    BeginAddress: DWORD,
+    EndAddress: DWORD,
+    HandlerAddress: DWORD,
+    JumpTarget: DWORD,
+}}
+pub type PSCOPE_TABLE_AMD64 = *mut SCOPE_TABLE_AMD64;
+STRUCT!{struct SCOPE_TABLE_ARM64 {
+    Count: DWORD,
+    ScopeRecord: [SCOPE_TABLE_ARM64_ScopeRecord; 1],
+}}
+STRUCT!{struct SCOPE_TABLE_ARM64_ScopeRecord {
+    BeginAddress: DWORD,
+    EndAddress: DWORD,
+    HandlerAddress: DWORD,
+    JumpTarget: DWORD,
+}}
+pub type PSCOPE_TABLE_ARM64 = *mut SCOPE_TABLE_ARM64;
+// Skip interlocked and bit manipulation stuff because it is all intrinsics
+// Use the native Rust equivalents instead
+#[cfg(target_arch = "x86_64")]
+IFDEF!{
+pub const EXCEPTION_READ_FAULT: DWORD = 0;
+pub const EXCEPTION_WRITE_FAULT: DWORD = 1;
+pub const EXCEPTION_EXECUTE_FAULT: DWORD = 8;
+pub const CONTEXT_AMD64: DWORD = 0x00100000;
+pub const CONTEXT_CONTROL: DWORD = CONTEXT_AMD64 | 0x00000001;
+pub const CONTEXT_INTEGER: DWORD = CONTEXT_AMD64 | 0x00000002;
+pub const CONTEXT_SEGMENTS: DWORD = CONTEXT_AMD64 | 0x00000004;
+pub const CONTEXT_FLOATING_POINT: DWORD = CONTEXT_AMD64 | 0x00000008;
+pub const CONTEXT_DEBUG_REGISTERS: DWORD = CONTEXT_AMD64 | 0x00000010;
+pub const CONTEXT_FULL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT;
+pub const CONTEXT_ALL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS
+    | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS;
+pub const CONTEXT_XSTATE: DWORD = CONTEXT_AMD64 | 0x00000040;
+pub const CONTEXT_EXCEPTION_ACTIVE: DWORD = 0x08000000;
+pub const CONTEXT_SERVICE_ACTIVE: DWORD = 0x10000000;
+pub const CONTEXT_EXCEPTION_REQUEST: DWORD = 0x40000000;
+pub const CONTEXT_EXCEPTION_REPORTING: DWORD = 0x80000000;
+pub const INITIAL_MXCSR: DWORD = 0x1f80;
+pub const INITIAL_FPCSR: DWORD = 0x027f;
+pub type XMM_SAVE_AREA32 = XSAVE_FORMAT;
+pub type PXMM_SAVE_AREA32 = *mut XSAVE_FORMAT;
+STRUCT!{struct CONTEXT_u_s {
+    Header: [M128A; 2],
+    Legacy: [M128A; 8],
+    Xmm0: M128A,
+    Xmm1: M128A,
+    Xmm2: M128A,
+    Xmm3: M128A,
+    Xmm4: M128A,
+    Xmm5: M128A,
+    Xmm6: M128A,
+    Xmm7: M128A,
+    Xmm8: M128A,
+    Xmm9: M128A,
+    Xmm10: M128A,
+    Xmm11: M128A,
+    Xmm12: M128A,
+    Xmm13: M128A,
+    Xmm14: M128A,
+    Xmm15: M128A,
+}}
+UNION!{union CONTEXT_u {
+    [u64; 64],
+    FltSave FltSave_mut: XMM_SAVE_AREA32,
+    s s_mut: CONTEXT_u_s,
+}}
+STRUCT!{struct CONTEXT { // FIXME align 16
+    P1Home: DWORD64,
+    P2Home: DWORD64,
+    P3Home: DWORD64,
+    P4Home: DWORD64,
+    P5Home: DWORD64,
+    P6Home: DWORD64,
+    ContextFlags: DWORD,
+    MxCsr: DWORD,
+    SegCs: WORD,
+    SegDs: WORD,
+    SegEs: WORD,
+    SegFs: WORD,
+    SegGs: WORD,
+    SegSs: WORD,
+    EFlags: DWORD,
+    Dr0: DWORD64,
+    Dr1: DWORD64,
+    Dr2: DWORD64,
+    Dr3: DWORD64,
+    Dr6: DWORD64,
+    Dr7: DWORD64,
+    Rax: DWORD64,
+    Rcx: DWORD64,
+    Rdx: DWORD64,
+    Rbx: DWORD64,
+    Rsp: DWORD64,
+    Rbp: DWORD64,
+    Rsi: DWORD64,
+    Rdi: DWORD64,
+    R8: DWORD64,
+    R9: DWORD64,
+    R10: DWORD64,
+    R11: DWORD64,
+    R12: DWORD64,
+    R13: DWORD64,
+    R14: DWORD64,
+    R15: DWORD64,
+    Rip: DWORD64,
+    u: CONTEXT_u,
+    VectorRegister: [M128A; 26],
+    VectorControl: DWORD64,
+    DebugControl: DWORD64,
+    LastBranchToRip: DWORD64,
+    LastBranchFromRip: DWORD64,
+    LastExceptionToRip: DWORD64,
+    LastExceptionFromRip: DWORD64,
+}}
+pub type PCONTEXT = *mut CONTEXT;
+pub type RUNTIME_FUNCTION = IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type PRUNTIME_FUNCTION = *mut IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type SCOPE_TABLE = SCOPE_TABLE_AMD64;
+pub type PSCOPE_TABLE = *mut SCOPE_TABLE_AMD64;
+pub const RUNTIME_FUNCTION_INDIRECT: DWORD = 0x1;
+pub const UNW_FLAG_NHANDLER: DWORD = 0x0;
+pub const UNW_FLAG_EHANDLER: DWORD = 0x1;
+pub const UNW_FLAG_UHANDLER: DWORD = 0x2;
+pub const UNW_FLAG_CHAININFO: DWORD = 0x4;
+pub const UNW_FLAG_NO_EPILOGUE: DWORD = 0x80000000;
+pub const UNWIND_HISTORY_TABLE_SIZE: usize = 12;
+STRUCT!{struct UNWIND_HISTORY_TABLE_ENTRY {
+    ImageBase: DWORD64,
+    FunctionEntry: PRUNTIME_FUNCTION,
+}}
+pub type PUNWIND_HISTORY_TABLE_ENTRY = *mut UNWIND_HISTORY_TABLE_ENTRY;
+STRUCT!{struct UNWIND_HISTORY_TABLE {
+    Count: DWORD,
+    LocalHint: BYTE,
+    GlobalHint: BYTE,
+    Search: BYTE,
+    Once: BYTE,
+    LowAddress: DWORD64,
+    HighAddress: DWORD64,
+    Entry: [UNWIND_HISTORY_TABLE_ENTRY; UNWIND_HISTORY_TABLE_SIZE],
+}}
+pub type PUNWIND_HISTORY_TABLE = *mut UNWIND_HISTORY_TABLE;
+FN!{cdecl PGET_RUNTIME_FUNCTION_CALLBACK(
+    ControlPc: DWORD64,
+    Context: PVOID,
+) -> PRUNTIME_FUNCTION}
+FN!{cdecl POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK(
+    Process: HANDLE,
+    TableAddress: PVOID,
+    Entries: PDWORD,
+    Functions: *mut PRUNTIME_FUNCTION,
+) -> DWORD}
+pub const OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME: &'static str
+    = "OutOfProcessFunctionTableCallback";
+STRUCT!{struct DISPATCHER_CONTEXT {
+    ControlPc: DWORD64,
+    ImageBase: DWORD64,
+    FunctionEntry: PRUNTIME_FUNCTION,
+    EstablisherFrame: DWORD64,
+    TargetIp: DWORD64,
+    ContextRecord: PCONTEXT,
+    LanguageHandler: PEXCEPTION_ROUTINE,
+    HandlerData: PVOID,
+    HistoryTable: PUNWIND_HISTORY_TABLE,
+    ScopeIndex: DWORD,
+    Fill0: DWORD,
+}}
+pub type PDISPATCHER_CONTEXT = *mut DISPATCHER_CONTEXT;
+FN!{cdecl PEXCEPTION_FILTER(
+    ExceptionPointers: *mut EXCEPTION_POINTERS,
+    EstablisherFrame: PVOID,
+) -> LONG}
+FN!{cdecl PTERMINATION_HANDLER(
+    AbnormalTermination: BOOLEAN,
+    EstablisherFrame: PVOID,
+) -> ()}
+STRUCT!{struct KNONVOLATILE_CONTEXT_POINTERS_u1_s {
+    Xmm0: PM128A,
+    Xmm1: PM128A,
+    Xmm2: PM128A,
+    Xmm3: PM128A,
+    Xmm4: PM128A,
+    Xmm5: PM128A,
+    Xmm6: PM128A,
+    Xmm7: PM128A,
+    Xmm8: PM128A,
+    Xmm9: PM128A,
+    Xmm10: PM128A,
+    Xmm11: PM128A,
+    Xmm12: PM128A,
+    Xmm13: PM128A,
+    Xmm14: PM128A,
+    Xmm15: PM128A,
+}}
+UNION!{union KNONVOLATILE_CONTEXT_POINTERS_u1 {
+    [u64; 16],
+    FloatingContext FloatingContext_mut: [PM128A; 16],
+    s s_mut: KNONVOLATILE_CONTEXT_POINTERS_u1_s,
+}}
+STRUCT!{struct KNONVOLATILE_CONTEXT_POINTERS_u2_s {
+    Rax: PDWORD64,
+    Rcx: PDWORD64,
+    Rdx: PDWORD64,
+    Rbx: PDWORD64,
+    Rsp: PDWORD64,
+    Rbp: PDWORD64,
+    Rsi: PDWORD64,
+    Rdi: PDWORD64,
+    R8: PDWORD64,
+    R9: PDWORD64,
+    R10: PDWORD64,
+    R11: PDWORD64,
+    R12: PDWORD64,
+    R13: PDWORD64,
+    R14: PDWORD64,
+    R15: PDWORD64,
+}}
+UNION!{union KNONVOLATILE_CONTEXT_POINTERS_u2 {
+    [u64; 16],
+    IntegerContext IntegerContext_mut: [PDWORD64; 16],
+    s s_mut: KNONVOLATILE_CONTEXT_POINTERS_u2_s,
+}}
+STRUCT!{struct KNONVOLATILE_CONTEXT_POINTERS {
+    u1: KNONVOLATILE_CONTEXT_POINTERS_u1,
+    u2: KNONVOLATILE_CONTEXT_POINTERS_u2,
+}}
+pub type PKNONVOLATILE_CONTEXT_POINTERS = *mut KNONVOLATILE_CONTEXT_POINTERS;
+} // IFDEF(x86_64)
+#[cfg(target_arch = "x86")]
+IFDEF!{
+pub const EXCEPTION_READ_FAULT: DWORD = 0;
+pub const EXCEPTION_WRITE_FAULT: DWORD = 1;
+pub const EXCEPTION_EXECUTE_FAULT: DWORD = 8;
+pub const SIZE_OF_80387_REGISTERS: usize = 80;
+pub const CONTEXT_i386: DWORD = 0x00010000;
+pub const CONTEXT_i486: DWORD = 0x00010000;
+pub const CONTEXT_CONTROL: DWORD = CONTEXT_i386 | 0x00000001;
+pub const CONTEXT_INTEGER: DWORD = CONTEXT_i386 | 0x00000002;
+pub const CONTEXT_SEGMENTS: DWORD = CONTEXT_i386 | 0x00000004;
+pub const CONTEXT_FLOATING_POINT: DWORD = CONTEXT_i386 | 0x00000008;
+pub const CONTEXT_DEBUG_REGISTERS: DWORD = CONTEXT_i386 | 0x00000010;
+pub const CONTEXT_EXTENDED_REGISTERS: DWORD = CONTEXT_i386 | 0x00000020;
+pub const CONTEXT_FULL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
+pub const CONTEXT_ALL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS
+    | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS;
+pub const CONTEXT_XSTATE: DWORD = CONTEXT_i386 | 0x00000040;
+pub const CONTEXT_EXCEPTION_ACTIVE: DWORD = 0x08000000;
+pub const CONTEXT_SERVICE_ACTIVE: DWORD = 0x10000000;
+pub const CONTEXT_EXCEPTION_REQUEST: DWORD = 0x40000000;
+pub const CONTEXT_EXCEPTION_REPORTING: DWORD = 0x80000000;
+STRUCT!{struct FLOATING_SAVE_AREA {
+    ControlWord: DWORD,
+    StatusWord: DWORD,
+    TagWord: DWORD,
+    ErrorOffset: DWORD,
+    ErrorSelector: DWORD,
+    DataOffset: DWORD,
+    DataSelector: DWORD,
+    RegisterArea: [BYTE; SIZE_OF_80387_REGISTERS],
+    Spare0: DWORD,
+}}
+pub type PFLOATING_SAVE_AREA = *mut FLOATING_SAVE_AREA;
+pub const MAXIMUM_SUPPORTED_EXTENSION: usize = 512;
+STRUCT!{struct CONTEXT {
+    ContextFlags: DWORD,
+    Dr0: DWORD,
+    Dr1: DWORD,
+    Dr2: DWORD,
+    Dr3: DWORD,
+    Dr6: DWORD,
+    Dr7: DWORD,
+    FloatSave: FLOATING_SAVE_AREA,
+    SegGs: DWORD,
+    SegFs: DWORD,
+    SegEs: DWORD,
+    SegDs: DWORD,
+    Edi: DWORD,
+    Esi: DWORD,
+    Ebx: DWORD,
+    Edx: DWORD,
+    Ecx: DWORD,
+    Eax: DWORD,
+    Ebp: DWORD,
+    Eip: DWORD,
+    SegCs: DWORD,
+    EFlags: DWORD,
+    Esp: DWORD,
+    SegSs: DWORD,
+    ExtendedRegisters: [BYTE; MAXIMUM_SUPPORTED_EXTENSION],
+}}
+pub type PCONTEXT = *mut CONTEXT;
+} // IFDEF(x86)
+STRUCT!{struct LDT_ENTRY_Bytes {
+    BaseMid: BYTE,
+    Flags1: BYTE,
+    Flags2: BYTE,
+    BaseHi: BYTE,
+}}
+STRUCT!{struct LDT_ENTRY_Bits {
+    Bitfield: DWORD,
+}}
+BITFIELD!{LDT_ENTRY_Bits Bitfield: DWORD [
+    BaseMid set_BaseMid[0..8],
+    Type set_Type[8..13],
+    Dpl set_Dpl[13..15],
+    Pres set_Pres[15..16],
+    LimitHi set_LimitHi[16..20],
+    Sys set_Sys[20..21],
+    Reserved_0 set_Reserved_0[21..22],
+    Default_Big set_Default_Big[22..23],
+    Granularity set_Granularity[23..24],
+    BaseHi set_BaseHi[24..32],
+]}
+UNION!{union LDT_ENTRY_HighWord {
+    [u32; 1],
+    Bytes Bytes_mut: LDT_ENTRY_Bytes,
+    Bits Bits_mut: LDT_ENTRY_Bits,
+}}
+STRUCT!{struct LDT_ENTRY {
+    LimitLow: WORD,
+    BaseLow: WORD,
+    HighWord: LDT_ENTRY_HighWord,
+}}
+pub type PLDT_ENTRY = *mut LDT_ENTRY;
+#[cfg(target_arch = "aarch64")]
+IFDEF!{
+pub const ARM64_MAX_BREAKPOINTS: usize = 8;
+pub const ARM64_MAX_WATCHPOINTS: usize = 2;
+pub const EXCEPTION_READ_FAULT: DWORD = 0;
+pub const EXCEPTION_WRITE_FAULT: DWORD = 1;
+pub const EXCEPTION_EXECUTE_FAULT: DWORD = 8;
+pub const CONTEXT_ARM64: DWORD = 0x00400000;
+pub const CONTEXT_CONTROL: DWORD = CONTEXT_ARM64 | 0x00000001;
+pub const CONTEXT_INTEGER: DWORD = CONTEXT_ARM64 | 0x00000002;
+pub const CONTEXT_FLOATING_POINT: DWORD = CONTEXT_ARM64 | 0x00000004;
+pub const CONTEXT_DEBUG_REGISTERS: DWORD = CONTEXT_ARM64 | 0x00000008;
+pub const CONTEXT_X18: DWORD = CONTEXT_ARM64 | 0x00000010;
+pub const CONTEXT_FULL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT;
+pub const CONTEXT_ALL: DWORD = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT
+        | CONTEXT_DEBUG_REGISTERS | CONTEXT_X18;
+pub const CONTEXT_EXCEPTION_ACTIVE: DWORD = 0x08000000;
+pub const CONTEXT_SERVICE_ACTIVE: DWORD = 0x10000000;
+pub const CONTEXT_EXCEPTION_REQUEST: DWORD = 0x40000000;
+pub const CONTEXT_EXCEPTION_REPORTING: DWORD = 0x80000000;
+STRUCT!{struct CONTEXT_u_s {
+    X0: DWORD64,
+    X1: DWORD64,
+    X2: DWORD64,
+    X3: DWORD64,
+    X4: DWORD64,
+    X5: DWORD64,
+    X6: DWORD64,
+    X7: DWORD64,
+    X8: DWORD64,
+    X9: DWORD64,
+    X10: DWORD64,
+    X11: DWORD64,
+    X12: DWORD64,
+    X13: DWORD64,
+    X14: DWORD64,
+    X15: DWORD64,
+    X16: DWORD64,
+    X17: DWORD64,
+    X18: DWORD64,
+    X19: DWORD64,
+    X20: DWORD64,
+    X21: DWORD64,
+    X22: DWORD64,
+    X23: DWORD64,
+    X24: DWORD64,
+    X25: DWORD64,
+    X26: DWORD64,
+    X27: DWORD64,
+    X28: DWORD64,
+    Fp: DWORD64,
+    Lr: DWORD64,
+}}
+UNION!{union CONTEXT_u {
+    [u64; 31],
+    s s_mut: CONTEXT_u_s,
+}}
+STRUCT!{struct ARM64_NT_NEON128_s {
+    Low: ULONGLONG,
+    High: LONGLONG,
+}}
+UNION!{union ARM64_NT_NEON128 {
+    [u64; 2],
+    s s_mut: ARM64_NT_NEON128_s,
+    D D_mut: [f64; 2],
+    S S_mut: [f32; 4],
+    H H_mut: [WORD; 8],
+    B B_mut: [BYTE; 16],
+}}
+STRUCT!{struct CONTEXT { // FIXME align 16
+    ContextFlags: DWORD,
+    Cpsr: DWORD,
+    u: CONTEXT_u,
+    Sp: DWORD64,
+    Pc: DWORD64,
+    V: [ARM64_NT_NEON128; 32],
+    Fpcr: DWORD,
+    Fpsr: DWORD,
+    Bcr: [DWORD; ARM64_MAX_BREAKPOINTS],
+    Bvr: [DWORD64; ARM64_MAX_BREAKPOINTS],
+    Wcr: [DWORD; ARM64_MAX_WATCHPOINTS],
+    Wvr: [DWORD64; ARM64_MAX_WATCHPOINTS],
+}}
+pub type PCONTEXT = *mut CONTEXT;
+pub type RUNTIME_FUNCTION = IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type PRUNTIME_FUNCTION = *mut IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type SCOPE_TABLE = SCOPE_TABLE_ARM64;
+pub type PSCOPE_TABLE = *mut SCOPE_TABLE_ARM64;
+pub const RUNTIME_FUNCTION_INDIRECT: DWORD = 0x1;
+pub const UNW_FLAG_NHANDLER: DWORD = 0x0;
+pub const UNW_FLAG_EHANDLER: DWORD = 0x1;
+pub const UNW_FLAG_UHANDLER: DWORD = 0x2;
+pub const UNWIND_HISTORY_TABLE_SIZE: usize = 12;
+STRUCT!{struct UNWIND_HISTORY_TABLE_ENTRY {
+    ImageBase: DWORD64,
+    FunctionEntry: PRUNTIME_FUNCTION,
+}}
+pub type PUNWIND_HISTORY_TABLE_ENTRY = *mut UNWIND_HISTORY_TABLE_ENTRY;
+STRUCT!{struct UNWIND_HISTORY_TABLE {
+    Count: DWORD,
+    LocalHint: BYTE,
+    GlobalHint: BYTE,
+    Search: BYTE,
+    Once: BYTE,
+    LowAddress: DWORD64,
+    HighAddress: DWORD64,
+    Entry: [UNWIND_HISTORY_TABLE_ENTRY; UNWIND_HISTORY_TABLE_SIZE],
+}}
+pub type PUNWIND_HISTORY_TABLE = *mut UNWIND_HISTORY_TABLE;
+FN!{cdecl PGET_RUNTIME_FUNCTION_CALLBACK(
+    ControlPc: DWORD64,
+    Context: PVOID,
+) -> PRUNTIME_FUNCTION}
+FN!{cdecl POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK(
+    Process: HANDLE,
+    TableAddress: PVOID,
+    Entries: PDWORD,
+    Functions: *mut PRUNTIME_FUNCTION,
+) -> DWORD}
+pub const OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME: &'static str
+    = "OutOfProcessFunctionTableCallback";
+STRUCT!{struct DISPATCHER_CONTEXT {
+    ControlPc: ULONG_PTR,
+    ImageBase: ULONG_PTR,
+    FunctionEntry: PRUNTIME_FUNCTION,
+    EstablisherFrame: ULONG_PTR,
+    TargetPc: ULONG_PTR,
+    ContextRecord: PCONTEXT,
+    LanguageHandler: PEXCEPTION_ROUTINE,
+    HandlerData: PVOID,
+    HistoryTable: PUNWIND_HISTORY_TABLE,
+    ScopeIndex: DWORD,
+    ControlPcIsUnwound: BOOLEAN,
+    NonVolatileRegisters: PBYTE,
+}}
+pub type PDISPATCHER_CONTEXT = *mut DISPATCHER_CONTEXT;
+FN!{cdecl PEXCEPTION_FILTER(
+    ExceptionPointers: *mut EXCEPTION_POINTERS,
+    EstablisherFrame: DWORD64,
+) -> LONG}
+FN!{cdecl PTERMINATION_HANDLER(
+    AbnormalTermination: BOOLEAN,
+    EstablisherFrame: DWORD64,
+) -> ()}
+STRUCT!{struct KNONVOLATILE_CONTEXT_POINTERS {
+    X19: PDWORD64,
+    X20: PDWORD64,
+    X21: PDWORD64,
+    X22: PDWORD64,
+    X23: PDWORD64,
+    X24: PDWORD64,
+    X25: PDWORD64,
+    X26: PDWORD64,
+    X27: PDWORD64,
+    X28: PDWORD64,
+    Fp: PDWORD64,
+    Lr: PDWORD64,
+    D8: PDWORD64,
+    D9: PDWORD64,
+    D10: PDWORD64,
+    D11: PDWORD64,
+    D12: PDWORD64,
+    D13: PDWORD64,
+    D14: PDWORD64,
+    D15: PDWORD64,
+}}
+pub type PKNONVOLATILE_CONTEXT_POINTERS = *mut KNONVOLATILE_CONTEXT_POINTERS;
+} // IFDEF(aarch64)
+#[cfg(target_arch = "arm")]
+IFDEF!{
+pub const ARM_MAX_BREAKPOINTS: usize = 8;
+pub const ARM_MAX_WATCHPOINTS: usize = 1;
+STRUCT!{struct NEON128 {
+    Low: ULONGLONG,
+    High: LONGLONG,
+}}
+pub type PNEON128 = *mut NEON128;
+UNION!{union CONTEXT_u {
+    [u64; 32],
+    Q Q_mut: [NEON128; 16],
+    D D_mut: [ULONGLONG; 32],
+    S S_mut: [DWORD; 32],
+}}
+STRUCT!{struct CONTEXT {
+    ContextFlags: DWORD,
+    R0: DWORD,
+    R1: DWORD,
+    R2: DWORD,
+    R3: DWORD,
+    R4: DWORD,
+    R5: DWORD,
+    R6: DWORD,
+    R7: DWORD,
+    R8: DWORD,
+    R9: DWORD,
+    R10: DWORD,
+    R11: DWORD,
+    R12: DWORD,
+    Sp: DWORD,
+    Lr: DWORD,
+    Pc: DWORD,
+    Cpsr: DWORD,
+    Fpsrc: DWORD,
+    Padding: DWORD,
+    u: CONTEXT_u,
+    Bvr: [DWORD; ARM_MAX_BREAKPOINTS],
+    Bcr: [DWORD; ARM_MAX_BREAKPOINTS],
+    Wvr: [DWORD; ARM_MAX_WATCHPOINTS],
+    Wcr: [DWORD; ARM_MAX_WATCHPOINTS],
+    Padding2: [DWORD; 2],
+}}
+pub type PCONTEXT = *mut CONTEXT;
+} // IFDEF(arm)
+pub const WOW64_CONTEXT_i386: DWORD = 0x00010000;
+pub const WOW64_CONTEXT_i486: DWORD = 0x00010000;
+pub const WOW64_CONTEXT_CONTROL: DWORD = WOW64_CONTEXT_i386 | 0x00000001;
+pub const WOW64_CONTEXT_INTEGER: DWORD = WOW64_CONTEXT_i386 | 0x00000002;
+pub const WOW64_CONTEXT_SEGMENTS: DWORD = WOW64_CONTEXT_i386 | 0x00000004;
+pub const WOW64_CONTEXT_FLOATING_POINT: DWORD = WOW64_CONTEXT_i386 | 0x00000008;
+pub const WOW64_CONTEXT_DEBUG_REGISTERS: DWORD = WOW64_CONTEXT_i386 | 0x00000010;
+pub const WOW64_CONTEXT_EXTENDED_REGISTERS: DWORD = WOW64_CONTEXT_i386 | 0x00000020;
+pub const WOW64_CONTEXT_FULL: DWORD = WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER
+    | WOW64_CONTEXT_SEGMENTS;
+pub const WOW64_CONTEXT_ALL: DWORD = WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER
+    | WOW64_CONTEXT_SEGMENTS | WOW64_CONTEXT_FLOATING_POINT | WOW64_CONTEXT_DEBUG_REGISTERS
+    | WOW64_CONTEXT_EXTENDED_REGISTERS;
+pub const WOW64_CONTEXT_XSTATE: DWORD = WOW64_CONTEXT_i386 | 0x00000040;
+pub const WOW64_CONTEXT_EXCEPTION_ACTIVE: DWORD = 0x08000000;
+pub const WOW64_CONTEXT_SERVICE_ACTIVE: DWORD = 0x10000000;
+pub const WOW64_CONTEXT_EXCEPTION_REQUEST: DWORD = 0x40000000;
+pub const WOW64_CONTEXT_EXCEPTION_REPORTING: DWORD = 0x80000000;
+pub const WOW64_SIZE_OF_80387_REGISTERS: usize = 80;
+pub const WOW64_MAXIMUM_SUPPORTED_EXTENSION: usize = 512;
+STRUCT!{struct WOW64_FLOATING_SAVE_AREA {
+    ControlWord: DWORD,
+    StatusWord: DWORD,
+    TagWord: DWORD,
+    ErrorOffset: DWORD,
+    ErrorSelector: DWORD,
+    DataOffset: DWORD,
+    DataSelector: DWORD,
+    RegisterArea: [BYTE; WOW64_SIZE_OF_80387_REGISTERS],
+    Cr0NpxState: DWORD,
+}}
+pub type PWOW64_FLOATING_SAVE_AREA = *mut WOW64_FLOATING_SAVE_AREA;
+STRUCT!{struct WOW64_CONTEXT {
+    ContextFlags: DWORD,
+    Dr0: DWORD,
+    Dr1: DWORD,
+    Dr2: DWORD,
+    Dr3: DWORD,
+    Dr6: DWORD,
+    Dr7: DWORD,
+    FloatSave: WOW64_FLOATING_SAVE_AREA,
+    SegGs: DWORD,
+    SegFs: DWORD,
+    SegEs: DWORD,
+    SegDs: DWORD,
+    Edi: DWORD,
+    Esi: DWORD,
+    Ebx: DWORD,
+    Edx: DWORD,
+    Ecx: DWORD,
+    Eax: DWORD,
+    Ebp: DWORD,
+    Eip: DWORD,
+    SegCs: DWORD,
+    EFlags: DWORD,
+    Esp: DWORD,
+    SegSs: DWORD,
+    ExtendedRegisters: [BYTE; WOW64_MAXIMUM_SUPPORTED_EXTENSION],
+}}
+pub type PWOW64_CONTEXT = *mut WOW64_CONTEXT;
+STRUCT!{struct WOW64_LDT_ENTRY_Bytes {
+    BaseMid: BYTE,
+    Flags1: BYTE,
+    Flags2: BYTE,
+    BaseHi: BYTE,
+}}
+STRUCT!{struct WOW64_LDT_ENTRY_Bits {
+    BitFields: DWORD,
+}}
+BITFIELD!{WOW64_LDT_ENTRY_Bits BitFields: DWORD [
+    BaseMid set_BaseMid[0..8],
+    Type set_Type[8..13],
+    Dpl set_Dpl[13..15],
+    Pres set_Pres[15..16],
+    LimitHi set_LimitHi[16..20],
+    Sys set_Sys[20..21],
+    Reserved_0 set_Reserved_0[21..22],
+    Default_Big set_Default_Big[22..23],
+    Granularity set_Granularity[23..24],
+    BaseHi set_BaseHi[24..32],
+]}
+UNION!{union WOW64_LDT_ENTRY_HighWord {
+    [u32; 1],
+    Bytes Bytes_mut: WOW64_LDT_ENTRY_Bytes,
+    Bits Bits_mut: WOW64_LDT_ENTRY_Bits,
+}}
+STRUCT!{struct WOW64_LDT_ENTRY {
+    LimitLow: WORD,
+    BaseLow: WORD,
+    HighWord: WOW64_LDT_ENTRY_HighWord,
+}}
+pub type PWOW64_LDT_ENTRY = *mut WOW64_LDT_ENTRY;
+STRUCT!{struct WOW64_DESCRIPTOR_TABLE_ENTRY {
+    Selector: DWORD,
+    Descriptor: WOW64_LDT_ENTRY,
+}}
+pub type PWOW64_DESCRIPTOR_TABLE_ENTRY = *mut WOW64_DESCRIPTOR_TABLE_ENTRY;
+pub const EXCEPTION_NONCONTINUABLE: DWORD = 0x1;
+pub const EXCEPTION_UNWINDING: DWORD = 0x2;
+pub const EXCEPTION_EXIT_UNWIND: DWORD = 0x4;
+pub const EXCEPTION_STACK_INVALID: DWORD = 0x8;
+pub const EXCEPTION_NESTED_CALL: DWORD = 0x10;
+pub const EXCEPTION_TARGET_UNWIND: DWORD = 0x20;
+pub const EXCEPTION_COLLIDED_UNWIND: DWORD = 0x40;
+pub const EXCEPTION_UNWIND: DWORD = EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND
+    | EXCEPTION_TARGET_UNWIND | EXCEPTION_COLLIDED_UNWIND;
+#[inline]
+pub fn IS_UNWINDING(Flag: DWORD) -> bool {
+    (Flag & EXCEPTION_UNWIND) != 0
+}
+#[inline]
+pub fn IS_DISPATCHING(Flag: DWORD) -> bool {
+    (Flag & EXCEPTION_UNWIND) == 0
+}
+#[inline]
+pub fn IS_TARGET_UNWIND(Flag: DWORD) -> bool {
+    (Flag & EXCEPTION_TARGET_UNWIND) != 0
+}
+pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15;
+STRUCT!{struct EXCEPTION_RECORD {
+    ExceptionCode: DWORD,
+    ExceptionFlags: DWORD,
+    ExceptionRecord: *mut EXCEPTION_RECORD,
+    ExceptionAddress: PVOID,
+    NumberParameters: DWORD,
+    ExceptionInformation: [ULONG_PTR; EXCEPTION_MAXIMUM_PARAMETERS],
+}}
+pub type PEXCEPTION_RECORD = *mut EXCEPTION_RECORD;
+STRUCT!{struct EXCEPTION_RECORD32 {
+    ExceptionCode: DWORD,
+    ExceptionFlags: DWORD,
+    ExceptionRecord: DWORD,
+    ExceptionAddress: DWORD,
+    NumberParameters: DWORD,
+    ExceptionInformation: [DWORD; EXCEPTION_MAXIMUM_PARAMETERS],
+}}
+pub type PEXCEPTION_RECORD32 = *mut EXCEPTION_RECORD32;
+STRUCT!{struct EXCEPTION_RECORD64 {
+    ExceptionCode: DWORD,
+    ExceptionFlags: DWORD,
+    ExceptionRecord: DWORD64,
+    ExceptionAddress: DWORD64,
+    NumberParameters: DWORD,
+    __unusedAlignment: DWORD,
+    ExceptionInformation: [DWORD64; EXCEPTION_MAXIMUM_PARAMETERS],
+}}
+pub type PEXCEPTION_RECORD64 = *mut EXCEPTION_RECORD64;
+STRUCT!{struct EXCEPTION_POINTERS {
+    ExceptionRecord: PEXCEPTION_RECORD,
+    ContextRecord: PCONTEXT,
+}}
+pub type PEXCEPTION_POINTERS = *mut EXCEPTION_POINTERS;
+pub type PACCESS_TOKEN = PVOID;
+pub type PSECURITY_DESCRIPTOR = PVOID;
+pub type PSID = PVOID;
+pub type PCLAIMS_BLOB = PVOID;
+pub type ACCESS_MASK = DWORD;
+pub type PACCESS_MASK = *mut ACCESS_MASK;
+pub const DELETE: DWORD = 0x00010000;
+pub const READ_CONTROL: DWORD = 0x00020000;
+pub const WRITE_DAC: DWORD = 0x00040000;
+pub const WRITE_OWNER: DWORD = 0x00080000;
+pub const SYNCHRONIZE: DWORD = 0x00100000;
+pub const STANDARD_RIGHTS_REQUIRED: DWORD = 0x000F0000;
+pub const STANDARD_RIGHTS_READ: DWORD = READ_CONTROL;
+pub const STANDARD_RIGHTS_WRITE: DWORD = READ_CONTROL;
+pub const STANDARD_RIGHTS_EXECUTE: DWORD = READ_CONTROL;
+pub const STANDARD_RIGHTS_ALL: DWORD = 0x001F0000;
+pub const SPECIFIC_RIGHTS_ALL: DWORD = 0x0000FFFF;
+pub const ACCESS_SYSTEM_SECURITY: DWORD = 0x01000000;
+pub const MAXIMUM_ALLOWED: DWORD = 0x02000000;
+pub const GENERIC_READ: DWORD = 0x80000000;
+pub const GENERIC_WRITE: DWORD = 0x40000000;
+pub const GENERIC_EXECUTE: DWORD = 0x20000000;
+pub const GENERIC_ALL: DWORD = 0x10000000;
+STRUCT!{struct GENERIC_MAPPING {
+    GenericRead: ACCESS_MASK,
+    GenericWrite: ACCESS_MASK,
+    GenericExecute: ACCESS_MASK,
+    GenericAll: ACCESS_MASK,
+}}
+pub type PGENERIC_MAPPING = *mut GENERIC_MAPPING;
+STRUCT!{struct LUID_AND_ATTRIBUTES {
+    Luid: LUID,
+    Attributes: DWORD,
+}}
+pub type PLUID_AND_ATTRIBUTES = *mut LUID_AND_ATTRIBUTES;
+pub type LUID_AND_ATTRIBUTES_ARRAY = LUID_AND_ATTRIBUTES;
+pub type PLUID_AND_ATTRIBUTES_ARRAY = *mut LUID_AND_ATTRIBUTES;
+STRUCT!{struct SID_IDENTIFIER_AUTHORITY {
+    Value: [BYTE; 6],
+}}
+pub type PSID_IDENTIFIER_AUTHORITY = *mut SID_IDENTIFIER_AUTHORITY;
+STRUCT!{struct SID {
+    Revision: BYTE,
+    SubAuthorityCount: BYTE,
+    IdentifierAuthority: SID_IDENTIFIER_AUTHORITY,
+    SubAuthority: [DWORD; 1],
+}}
+pub type PISID = *mut SID;
+pub const SID_REVISION: BYTE = 1;
+pub const SID_MAX_SUB_AUTHORITIES: BYTE = 15;
+pub const SID_RECOMMENDED_SUB_AUTHORITIES: BYTE = 1;
+pub const SECURITY_MAX_SID_SIZE: usize = 12 - 4 + (SID_MAX_SUB_AUTHORITIES as usize * 4);
+pub const SECURITY_MAX_SID_STRING_CHARACTERS: BYTE = 2 + 4 + 15 + (11 * SID_MAX_SUB_AUTHORITIES)
+    + 1;
+UNION!{union SE_SID {
+    [u32; 17],
+    Sid Sid_mut: SID,
+    Buffer Buffer_mut: [BYTE; SECURITY_MAX_SID_SIZE],
+}}
+pub type PSE_SID = *mut SE_SID;
+ENUM!{enum SID_NAME_USE {
+    SidTypeUser = 1,
+    SidTypeGroup,
+    SidTypeDomain,
+    SidTypeAlias,
+    SidTypeWellKnownGroup,
+    SidTypeDeletedAccount,
+    SidTypeInvalid,
+    SidTypeUnknown,
+    SidTypeComputer,
+    SidTypeLabel,
+    SidTypeLogonSession,
+}}
+pub type PSID_NAME_USE = *mut SID_NAME_USE;
+STRUCT!{struct SID_AND_ATTRIBUTES {
+    Sid: PSID,
+    Attributes: DWORD,
+}}
+pub type PSID_AND_ATTRIBUTES = *mut SID_AND_ATTRIBUTES;
+pub type SID_AND_ATTRIBUTES_ARRAY = SID_AND_ATTRIBUTES;
+pub type PSID_AND_ATTRIBUTES_ARRAY = *mut SID_AND_ATTRIBUTES;
+pub const SID_HASH_SIZE: usize = 32;
+pub type SID_HASH_ENTRY = ULONG_PTR;
+pub type PSID_HASH_ENTRY = *mut ULONG_PTR;
+STRUCT!{struct SID_AND_ATTRIBUTES_HASH {
+    SidCount: DWORD,
+    SidAttr: PSID_AND_ATTRIBUTES,
+    Hash: [SID_HASH_ENTRY; SID_HASH_SIZE],
+}}
+pub type PSID_AND_ATTRIBUTES_HASH = *mut SID_AND_ATTRIBUTES_HASH;
+pub const SECURITY_NULL_SID_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 0];
+pub const SECURITY_WORLD_SID_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 1];
+pub const SECURITY_LOCAL_SID_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 2];
+pub const SECURITY_CREATOR_SID_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 3];
+pub const SECURITY_NON_UNIQUE_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 4];
+pub const SECURITY_RESOURCE_MANAGER_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 9];
+pub const SECURITY_NULL_RID: DWORD = 0x00000000;
+pub const SECURITY_WORLD_RID: DWORD = 0x00000000;
+pub const SECURITY_LOCAL_RID: DWORD = 0x00000000;
+pub const SECURITY_LOCAL_LOGON_RID: DWORD = 0x00000001;
+pub const SECURITY_CREATOR_OWNER_RID: DWORD = 0x00000000;
+pub const SECURITY_CREATOR_GROUP_RID: DWORD = 0x00000001;
+pub const SECURITY_CREATOR_OWNER_SERVER_RID: DWORD = 0x00000002;
+pub const SECURITY_CREATOR_GROUP_SERVER_RID: DWORD = 0x00000003;
+pub const SECURITY_CREATOR_OWNER_RIGHTS_RID: DWORD = 0x00000004;
+pub const SECURITY_NT_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 5];
+pub const SECURITY_DIALUP_RID: DWORD = 0x00000001;
+pub const SECURITY_NETWORK_RID: DWORD = 0x00000002;
+pub const SECURITY_BATCH_RID: DWORD = 0x00000003;
+pub const SECURITY_INTERACTIVE_RID: DWORD = 0x00000004;
+pub const SECURITY_LOGON_IDS_RID: DWORD = 0x00000005;
+pub const SECURITY_LOGON_IDS_RID_COUNT: DWORD = 3;
+pub const SECURITY_SERVICE_RID: DWORD = 0x00000006;
+pub const SECURITY_ANONYMOUS_LOGON_RID: DWORD = 0x00000007;
+pub const SECURITY_PROXY_RID: DWORD = 0x00000008;
+pub const SECURITY_ENTERPRISE_CONTROLLERS_RID: DWORD = 0x00000009;
+pub const SECURITY_SERVER_LOGON_RID: DWORD = SECURITY_ENTERPRISE_CONTROLLERS_RID;
+pub const SECURITY_PRINCIPAL_SELF_RID: DWORD = 0x0000000A;
+pub const SECURITY_AUTHENTICATED_USER_RID: DWORD = 0x0000000B;
+pub const SECURITY_RESTRICTED_CODE_RID: DWORD = 0x0000000C;
+pub const SECURITY_TERMINAL_SERVER_RID: DWORD = 0x0000000D;
+pub const SECURITY_REMOTE_LOGON_RID: DWORD = 0x0000000E;
+pub const SECURITY_THIS_ORGANIZATION_RID: DWORD = 0x0000000F;
+pub const SECURITY_IUSER_RID: DWORD = 0x00000011;
+pub const SECURITY_LOCAL_SYSTEM_RID: DWORD = 0x00000012;
+pub const SECURITY_LOCAL_SERVICE_RID: DWORD = 0x00000013;
+pub const SECURITY_NETWORK_SERVICE_RID: DWORD = 0x00000014;
+pub const SECURITY_NT_NON_UNIQUE: DWORD = 0x00000015;
+pub const SECURITY_NT_NON_UNIQUE_SUB_AUTH_COUNT: DWORD = 3;
+pub const SECURITY_ENTERPRISE_READONLY_CONTROLLERS_RID: DWORD = 0x00000016;
+pub const SECURITY_BUILTIN_DOMAIN_RID: DWORD = 0x00000020;
+pub const SECURITY_WRITE_RESTRICTED_CODE_RID: DWORD = 0x00000021;
+pub const SECURITY_PACKAGE_BASE_RID: DWORD = 0x00000040;
+pub const SECURITY_PACKAGE_RID_COUNT: DWORD = 2;
+pub const SECURITY_PACKAGE_NTLM_RID: DWORD = 0x0000000A;
+pub const SECURITY_PACKAGE_SCHANNEL_RID: DWORD = 0x0000000E;
+pub const SECURITY_PACKAGE_DIGEST_RID: DWORD = 0x00000015;
+pub const SECURITY_CRED_TYPE_BASE_RID: DWORD = 0x00000041;
+pub const SECURITY_CRED_TYPE_RID_COUNT: DWORD = 2;
+pub const SECURITY_CRED_TYPE_THIS_ORG_CERT_RID: DWORD = 0x00000001;
+pub const SECURITY_MIN_BASE_RID: DWORD = 0x00000050;
+pub const SECURITY_SERVICE_ID_BASE_RID: DWORD = 0x00000050;
+pub const SECURITY_SERVICE_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_RESERVED_ID_BASE_RID: DWORD = 0x00000051;
+pub const SECURITY_APPPOOL_ID_BASE_RID: DWORD = 0x00000052;
+pub const SECURITY_APPPOOL_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_VIRTUALSERVER_ID_BASE_RID: DWORD = 0x00000053;
+pub const SECURITY_VIRTUALSERVER_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_USERMODEDRIVERHOST_ID_BASE_RID: DWORD = 0x00000054;
+pub const SECURITY_USERMODEDRIVERHOST_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_BASE_RID: DWORD = 0x00000055;
+pub const SECURITY_CLOUD_INFRASTRUCTURE_SERVICES_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_WMIHOST_ID_BASE_RID: DWORD = 0x00000056;
+pub const SECURITY_WMIHOST_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_TASK_ID_BASE_RID: DWORD = 0x00000057;
+pub const SECURITY_NFS_ID_BASE_RID: DWORD = 0x00000058;
+pub const SECURITY_COM_ID_BASE_RID: DWORD = 0x00000059;
+pub const SECURITY_WINDOW_MANAGER_BASE_RID: DWORD = 0x0000005A;
+pub const SECURITY_RDV_GFX_BASE_RID: DWORD = 0x0000005B;
+pub const SECURITY_DASHOST_ID_BASE_RID: DWORD = 0x0000005C;
+pub const SECURITY_DASHOST_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_USERMANAGER_ID_BASE_RID: DWORD = 0x0000005D;
+pub const SECURITY_USERMANAGER_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_WINRM_ID_BASE_RID: DWORD = 0x0000005E;
+pub const SECURITY_WINRM_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_CCG_ID_BASE_RID: DWORD = 0x0000005F;
+pub const SECURITY_UMFD_BASE_RID: DWORD = 0x00000060;
+pub const SECURITY_VIRTUALACCOUNT_ID_RID_COUNT: DWORD = 6;
+pub const SECURITY_MAX_BASE_RID: DWORD = 0x0000006F;
+pub const SECURITY_MAX_ALWAYS_FILTERED: DWORD = 0x000003E7;
+pub const SECURITY_MIN_NEVER_FILTERED: DWORD = 0x000003E8;
+pub const SECURITY_OTHER_ORGANIZATION_RID: DWORD = 0x000003E8;
+pub const SECURITY_WINDOWSMOBILE_ID_BASE_RID: DWORD = 0x00000070;
+pub const SECURITY_INSTALLER_GROUP_CAPABILITY_BASE: DWORD = 0x20;
+pub const SECURITY_INSTALLER_GROUP_CAPABILITY_RID_COUNT: DWORD = 9;
+pub const SECURITY_INSTALLER_CAPABILITY_RID_COUNT: DWORD = 10;
+pub const SECURITY_LOCAL_ACCOUNT_RID: DWORD = 0x00000071;
+pub const SECURITY_LOCAL_ACCOUNT_AND_ADMIN_RID: DWORD = 0x00000072;
+pub const DOMAIN_GROUP_RID_AUTHORIZATION_DATA_IS_COMPOUNDED: DWORD = 0x000001F0;
+pub const DOMAIN_GROUP_RID_AUTHORIZATION_DATA_CONTAINS_CLAIMS: DWORD = 0x000001F1;
+pub const DOMAIN_GROUP_RID_ENTERPRISE_READONLY_DOMAIN_CONTROLLERS: DWORD = 0x000001F2;
+pub const FOREST_USER_RID_MAX: DWORD = 0x000001F3;
+pub const DOMAIN_USER_RID_ADMIN: DWORD = 0x000001F4;
+pub const DOMAIN_USER_RID_GUEST: DWORD = 0x000001F5;
+pub const DOMAIN_USER_RID_KRBTGT: DWORD = 0x000001F6;
+pub const DOMAIN_USER_RID_DEFAULT_ACCOUNT: DWORD = 0x000001F7;
+pub const DOMAIN_USER_RID_MAX: DWORD = 0x000003E7;
+pub const DOMAIN_GROUP_RID_ADMINS: DWORD = 0x00000200;
+pub const DOMAIN_GROUP_RID_USERS: DWORD = 0x00000201;
+pub const DOMAIN_GROUP_RID_GUESTS: DWORD = 0x00000202;
+pub const DOMAIN_GROUP_RID_COMPUTERS: DWORD = 0x00000203;
+pub const DOMAIN_GROUP_RID_CONTROLLERS: DWORD = 0x00000204;
+pub const DOMAIN_GROUP_RID_CERT_ADMINS: DWORD = 0x00000205;
+pub const DOMAIN_GROUP_RID_SCHEMA_ADMINS: DWORD = 0x00000206;
+pub const DOMAIN_GROUP_RID_ENTERPRISE_ADMINS: DWORD = 0x00000207;
+pub const DOMAIN_GROUP_RID_POLICY_ADMINS: DWORD = 0x00000208;
+pub const DOMAIN_GROUP_RID_READONLY_CONTROLLERS: DWORD = 0x00000209;
+pub const DOMAIN_GROUP_RID_CLONEABLE_CONTROLLERS: DWORD = 0x0000020A;
+pub const DOMAIN_GROUP_RID_CDC_RESERVED: DWORD = 0x0000020C;
+pub const DOMAIN_GROUP_RID_PROTECTED_USERS: DWORD = 0x0000020D;
+pub const DOMAIN_GROUP_RID_KEY_ADMINS: DWORD = 0x0000020E;
+pub const DOMAIN_GROUP_RID_ENTERPRISE_KEY_ADMINS: DWORD = 0x0000020F;
+pub const DOMAIN_ALIAS_RID_ADMINS: DWORD = 0x00000220;
+pub const DOMAIN_ALIAS_RID_USERS: DWORD = 0x00000221;
+pub const DOMAIN_ALIAS_RID_GUESTS: DWORD = 0x00000222;
+pub const DOMAIN_ALIAS_RID_POWER_USERS: DWORD = 0x00000223;
+pub const DOMAIN_ALIAS_RID_ACCOUNT_OPS: DWORD = 0x00000224;
+pub const DOMAIN_ALIAS_RID_SYSTEM_OPS: DWORD = 0x00000225;
+pub const DOMAIN_ALIAS_RID_PRINT_OPS: DWORD = 0x00000226;
+pub const DOMAIN_ALIAS_RID_BACKUP_OPS: DWORD = 0x00000227;
+pub const DOMAIN_ALIAS_RID_REPLICATOR: DWORD = 0x00000228;
+pub const DOMAIN_ALIAS_RID_RAS_SERVERS: DWORD = 0x00000229;
+pub const DOMAIN_ALIAS_RID_PREW2KCOMPACCESS: DWORD = 0x0000022A;
+pub const DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS: DWORD = 0x0000022B;
+pub const DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS: DWORD = 0x0000022C;
+pub const DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS: DWORD = 0x0000022D;
+pub const DOMAIN_ALIAS_RID_MONITORING_USERS: DWORD = 0x0000022E;
+pub const DOMAIN_ALIAS_RID_LOGGING_USERS: DWORD = 0x0000022F;
+pub const DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS: DWORD = 0x00000230;
+pub const DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS: DWORD = 0x00000231;
+pub const DOMAIN_ALIAS_RID_DCOM_USERS: DWORD = 0x00000232;
+pub const DOMAIN_ALIAS_RID_IUSERS: DWORD = 0x00000238;
+pub const DOMAIN_ALIAS_RID_CRYPTO_OPERATORS: DWORD = 0x00000239;
+pub const DOMAIN_ALIAS_RID_CACHEABLE_PRINCIPALS_GROUP: DWORD = 0x0000023B;
+pub const DOMAIN_ALIAS_RID_NON_CACHEABLE_PRINCIPALS_GROUP: DWORD = 0x0000023C;
+pub const DOMAIN_ALIAS_RID_EVENT_LOG_READERS_GROUP: DWORD = 0x0000023D;
+pub const DOMAIN_ALIAS_RID_CERTSVC_DCOM_ACCESS_GROUP: DWORD = 0x0000023E;
+pub const DOMAIN_ALIAS_RID_RDS_REMOTE_ACCESS_SERVERS: DWORD = 0x0000023F;
+pub const DOMAIN_ALIAS_RID_RDS_ENDPOINT_SERVERS: DWORD = 0x00000240;
+pub const DOMAIN_ALIAS_RID_RDS_MANAGEMENT_SERVERS: DWORD = 0x00000241;
+pub const DOMAIN_ALIAS_RID_HYPER_V_ADMINS: DWORD = 0x00000242;
+pub const DOMAIN_ALIAS_RID_ACCESS_CONTROL_ASSISTANCE_OPS: DWORD = 0x00000243;
+pub const DOMAIN_ALIAS_RID_REMOTE_MANAGEMENT_USERS: DWORD = 0x00000244;
+pub const DOMAIN_ALIAS_RID_DEFAULT_ACCOUNT: DWORD = 0x00000245;
+pub const DOMAIN_ALIAS_RID_STORAGE_REPLICA_ADMINS: DWORD = 0x00000246;
+pub const SECURITY_APP_PACKAGE_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 15];
+pub const SECURITY_APP_PACKAGE_BASE_RID: DWORD = 0x00000002;
+pub const SECURITY_BUILTIN_APP_PACKAGE_RID_COUNT: DWORD = 2;
+pub const SECURITY_APP_PACKAGE_RID_COUNT: DWORD = 8;
+pub const SECURITY_CAPABILITY_BASE_RID: DWORD = 0x00000003;
+pub const SECURITY_CAPABILITY_APP_RID: DWORD = 0x00000040;
+pub const SECURITY_BUILTIN_CAPABILITY_RID_COUNT: DWORD = 2;
+pub const SECURITY_CAPABILITY_RID_COUNT: DWORD = 5;
+pub const SECURITY_PARENT_PACKAGE_RID_COUNT: DWORD = SECURITY_APP_PACKAGE_RID_COUNT;
+pub const SECURITY_CHILD_PACKAGE_RID_COUNT: DWORD = 12;
+pub const SECURITY_BUILTIN_PACKAGE_ANY_PACKAGE: DWORD = 0x00000001;
+pub const SECURITY_BUILTIN_PACKAGE_ANY_RESTRICTED_PACKAGE: DWORD = 0x00000002;
+pub const SECURITY_CAPABILITY_INTERNET_CLIENT: DWORD = 0x00000001;
+pub const SECURITY_CAPABILITY_INTERNET_CLIENT_SERVER: DWORD = 0x00000002;
+pub const SECURITY_CAPABILITY_PRIVATE_NETWORK_CLIENT_SERVER: DWORD = 0x00000003;
+pub const SECURITY_CAPABILITY_PICTURES_LIBRARY: DWORD = 0x00000004;
+pub const SECURITY_CAPABILITY_VIDEOS_LIBRARY: DWORD = 0x00000005;
+pub const SECURITY_CAPABILITY_MUSIC_LIBRARY: DWORD = 0x00000006;
+pub const SECURITY_CAPABILITY_DOCUMENTS_LIBRARY: DWORD = 0x00000007;
+pub const SECURITY_CAPABILITY_ENTERPRISE_AUTHENTICATION: DWORD = 0x00000008;
+pub const SECURITY_CAPABILITY_SHARED_USER_CERTIFICATES: DWORD = 0x00000009;
+pub const SECURITY_CAPABILITY_REMOVABLE_STORAGE: DWORD = 0x0000000A;
+pub const SECURITY_CAPABILITY_APPOINTMENTS: DWORD = 0x0000000B;
+pub const SECURITY_CAPABILITY_CONTACTS: DWORD = 0x0000000C;
+pub const SECURITY_CAPABILITY_INTERNET_EXPLORER: DWORD = 0x00001000;
+pub const SECURITY_MANDATORY_LABEL_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 16];
+pub const SECURITY_MANDATORY_UNTRUSTED_RID: DWORD = 0x00000000;
+pub const SECURITY_MANDATORY_LOW_RID: DWORD = 0x00001000;
+pub const SECURITY_MANDATORY_MEDIUM_RID: DWORD = 0x00002000;
+pub const SECURITY_MANDATORY_MEDIUM_PLUS_RID: DWORD = SECURITY_MANDATORY_MEDIUM_RID + 0x10;
+pub const SECURITY_MANDATORY_HIGH_RID: DWORD = 0x00003000;
+pub const SECURITY_MANDATORY_SYSTEM_RID: DWORD = 0x00004000;
+pub const SECURITY_MANDATORY_MAXIMUM_USER_RID: DWORD = SECURITY_MANDATORY_SYSTEM_RID;
+#[inline]
+pub fn MANDATORY_LEVEL_TO_MANDATORY_RID(IL: DWORD) -> DWORD {
+    IL * 0x1000
+}
+pub const SECURITY_SCOPED_POLICY_ID_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 17];
+pub const SECURITY_AUTHENTICATION_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 18];
+pub const SECURITY_AUTHENTICATION_AUTHORITY_RID_COUNT: DWORD = 1;
+pub const SECURITY_AUTHENTICATION_AUTHORITY_ASSERTED_RID: DWORD = 0x00000001;
+pub const SECURITY_AUTHENTICATION_SERVICE_ASSERTED_RID: DWORD = 0x00000002;
+pub const SECURITY_AUTHENTICATION_FRESH_KEY_AUTH_RID: DWORD = 0x00000003;
+pub const SECURITY_AUTHENTICATION_KEY_TRUST_RID: DWORD = 0x00000004;
+pub const SECURITY_AUTHENTICATION_KEY_PROPERTY_MFA_RID: DWORD = 0x00000005;
+pub const SECURITY_AUTHENTICATION_KEY_PROPERTY_ATTESTATION_RID: DWORD = 0x00000006;
+pub const SECURITY_PROCESS_TRUST_AUTHORITY: [BYTE; 6] = [0, 0, 0, 0, 0, 19];
+pub const SECURITY_PROCESS_TRUST_AUTHORITY_RID_COUNT: DWORD = 2;
+pub const SECURITY_PROCESS_PROTECTION_TYPE_FULL_RID: DWORD = 0x00000400;
+pub const SECURITY_PROCESS_PROTECTION_TYPE_LITE_RID: DWORD = 0x00000200;
+pub const SECURITY_PROCESS_PROTECTION_TYPE_NONE_RID: DWORD = 0x00000000;
+pub const SECURITY_PROCESS_PROTECTION_LEVEL_WINTCB_RID: DWORD = 0x00002000;
+pub const SECURITY_PROCESS_PROTECTION_LEVEL_WINDOWS_RID: DWORD = 0x00001000;
+pub const SECURITY_PROCESS_PROTECTION_LEVEL_APP_RID: DWORD = 0x00000800;
+pub const SECURITY_PROCESS_PROTECTION_LEVEL_NONE_RID: DWORD = 0x00000000;
+pub const SECURITY_TRUSTED_INSTALLER_RID1: DWORD = 95600888;
+pub const SECURITY_TRUSTED_INSTALLER_RID2: DWORD = 341852264;
+pub const SECURITY_TRUSTED_INSTALLER_RID3: DWORD = 183103804;
+pub const SECURITY_TRUSTED_INSTALLER_RID4: DWORD = 185329263;
+pub const SECURITY_TRUSTED_INSTALLER_RID5: DWORD = 227147846;
+ENUM!{enum WELL_KNOWN_SID_TYPE {
+    WinNullSid = 0,
+    WinWorldSid = 1,
+    WinLocalSid = 2,
+    WinCreatorOwnerSid = 3,
+    WinCreatorGroupSid = 4,
+    WinCreatorOwnerServerSid = 5,
+    WinCreatorGroupServerSid = 6,
+    WinNtAuthoritySid = 7,
+    WinDialupSid = 8,
+    WinNetworkSid = 9,
+    WinBatchSid = 10,
+    WinInteractiveSid = 11,
+    WinServiceSid = 12,
+    WinAnonymousSid = 13,
+    WinProxySid = 14,
+    WinEnterpriseControllersSid = 15,
+    WinSelfSid = 16,
+    WinAuthenticatedUserSid = 17,
+    WinRestrictedCodeSid = 18,
+    WinTerminalServerSid = 19,
+    WinRemoteLogonIdSid = 20,
+    WinLogonIdsSid = 21,
+    WinLocalSystemSid = 22,
+    WinLocalServiceSid = 23,
+    WinNetworkServiceSid = 24,
+    WinBuiltinDomainSid = 25,
+    WinBuiltinAdministratorsSid = 26,
+    WinBuiltinUsersSid = 27,
+    WinBuiltinGuestsSid = 28,
+    WinBuiltinPowerUsersSid = 29,
+    WinBuiltinAccountOperatorsSid = 30,
+    WinBuiltinSystemOperatorsSid = 31,
+    WinBuiltinPrintOperatorsSid = 32,
+    WinBuiltinBackupOperatorsSid = 33,
+    WinBuiltinReplicatorSid = 34,
+    WinBuiltinPreWindows2000CompatibleAccessSid = 35,
+    WinBuiltinRemoteDesktopUsersSid = 36,
+    WinBuiltinNetworkConfigurationOperatorsSid = 37,
+    WinAccountAdministratorSid = 38,
+    WinAccountGuestSid = 39,
+    WinAccountKrbtgtSid = 40,
+    WinAccountDomainAdminsSid = 41,
+    WinAccountDomainUsersSid = 42,
+    WinAccountDomainGuestsSid = 43,
+    WinAccountComputersSid = 44,
+    WinAccountControllersSid = 45,
+    WinAccountCertAdminsSid = 46,
+    WinAccountSchemaAdminsSid = 47,
+    WinAccountEnterpriseAdminsSid = 48,
+    WinAccountPolicyAdminsSid = 49,
+    WinAccountRasAndIasServersSid = 50,
+    WinNTLMAuthenticationSid = 51,
+    WinDigestAuthenticationSid = 52,
+    WinSChannelAuthenticationSid = 53,
+    WinThisOrganizationSid = 54,
+    WinOtherOrganizationSid = 55,
+    WinBuiltinIncomingForestTrustBuildersSid = 56,
+    WinBuiltinPerfMonitoringUsersSid = 57,
+    WinBuiltinPerfLoggingUsersSid = 58,
+    WinBuiltinAuthorizationAccessSid = 59,
+    WinBuiltinTerminalServerLicenseServersSid = 60,
+    WinBuiltinDCOMUsersSid = 61,
+    WinBuiltinIUsersSid = 62,
+    WinIUserSid = 63,
+    WinBuiltinCryptoOperatorsSid = 64,
+    WinUntrustedLabelSid = 65,
+    WinLowLabelSid = 66,
+    WinMediumLabelSid = 67,
+    WinHighLabelSid = 68,
+    WinSystemLabelSid = 69,
+    WinWriteRestrictedCodeSid = 70,
+    WinCreatorOwnerRightsSid = 71,
+    WinCacheablePrincipalsGroupSid = 72,
+    WinNonCacheablePrincipalsGroupSid = 73,
+    WinEnterpriseReadonlyControllersSid = 74,
+    WinAccountReadonlyControllersSid = 75,
+    WinBuiltinEventLogReadersGroup = 76,
+    WinNewEnterpriseReadonlyControllersSid = 77,
+    WinBuiltinCertSvcDComAccessGroup = 78,
+    WinMediumPlusLabelSid = 79,
+    WinLocalLogonSid = 80,
+    WinConsoleLogonSid = 81,
+    WinThisOrganizationCertificateSid = 82,
+    WinApplicationPackageAuthoritySid = 83,
+    WinBuiltinAnyPackageSid = 84,
+    WinCapabilityInternetClientSid = 85,
+    WinCapabilityInternetClientServerSid = 86,
+    WinCapabilityPrivateNetworkClientServerSid = 87,
+    WinCapabilityPicturesLibrarySid = 88,
+    WinCapabilityVideosLibrarySid = 89,
+    WinCapabilityMusicLibrarySid = 90,
+    WinCapabilityDocumentsLibrarySid = 91,
+    WinCapabilitySharedUserCertificatesSid = 92,
+    WinCapabilityEnterpriseAuthenticationSid = 93,
+    WinCapabilityRemovableStorageSid = 94,
+    WinBuiltinRDSRemoteAccessServersSid = 95,
+    WinBuiltinRDSEndpointServersSid = 96,
+    WinBuiltinRDSManagementServersSid = 97,
+    WinUserModeDriversSid = 98,
+    WinBuiltinHyperVAdminsSid = 99,
+    WinAccountCloneableControllersSid = 100,
+    WinBuiltinAccessControlAssistanceOperatorsSid = 101,
+    WinBuiltinRemoteManagementUsersSid = 102,
+    WinAuthenticationAuthorityAssertedSid = 103,
+    WinAuthenticationServiceAssertedSid = 104,
+    WinLocalAccountSid = 105,
+    WinLocalAccountAndAdministratorSid = 106,
+    WinAccountProtectedUsersSid = 107,
+    WinCapabilityAppointmentsSid = 108,
+    WinCapabilityContactsSid = 109,
+    WinAccountDefaultSystemManagedSid = 110,
+    WinBuiltinDefaultSystemManagedGroupSid = 111,
+    WinBuiltinStorageReplicaAdminsSid = 112,
+    WinAccountKeyAdminsSid = 113,
+    WinAccountEnterpriseKeyAdminsSid = 114,
+    WinAuthenticationKeyTrustSid = 115,
+    WinAuthenticationKeyPropertyMFASid = 116,
+    WinAuthenticationKeyPropertyAttestationSid = 117,
+    WinAuthenticationFreshKeyAuthSid = 118,
+}}
+pub const SYSTEM_LUID: LUID = LUID { LowPart: 0x3e7, HighPart: 0x0 };
+pub const ANONYMOUS_LOGON_LUID: LUID = LUID { LowPart: 0x3e6, HighPart: 0x0 };
+pub const LOCALSERVICE_LUID: LUID = LUID { LowPart: 0x3e5, HighPart: 0x0 };
+pub const NETWORKSERVICE_LUID: LUID = LUID { LowPart: 0x3e4, HighPart: 0x0 };
+pub const IUSER_LUID: LUID = LUID { LowPart: 0x3e3, HighPart: 0x0 };
+pub const SE_GROUP_MANDATORY: DWORD = 0x00000001;
+pub const SE_GROUP_ENABLED_BY_DEFAULT: DWORD = 0x00000002;
+pub const SE_GROUP_ENABLED: DWORD = 0x00000004;
+pub const SE_GROUP_OWNER: DWORD = 0x00000008;
+pub const SE_GROUP_USE_FOR_DENY_ONLY: DWORD = 0x00000010;
+pub const SE_GROUP_INTEGRITY: DWORD = 0x00000020;
+pub const SE_GROUP_INTEGRITY_ENABLED: DWORD = 0x00000040;
+pub const SE_GROUP_LOGON_ID: DWORD = 0xC0000000;
+pub const SE_GROUP_RESOURCE: DWORD = 0x20000000;
+pub const SE_GROUP_VALID_ATTRIBUTES: DWORD = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT
+    | SE_GROUP_ENABLED | SE_GROUP_OWNER | SE_GROUP_USE_FOR_DENY_ONLY | SE_GROUP_LOGON_ID
+    | SE_GROUP_RESOURCE | SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED;
+pub const ACL_REVISION: BYTE = 2;
+pub const ACL_REVISION_DS: BYTE = 4;
+pub const ACL_REVISION1: BYTE = 1;
+pub const MIN_ACL_REVISION: BYTE = ACL_REVISION2;
+pub const ACL_REVISION2: BYTE = 2;
+pub const ACL_REVISION3: BYTE = 3;
+pub const ACL_REVISION4: BYTE = 4;
+pub const MAX_ACL_REVISION: BYTE = ACL_REVISION4;
+STRUCT!{struct ACL {
+    AclRevision: BYTE,
+    Sbz1: BYTE,
+    AclSize: WORD,
+    AceCount: WORD,
+    Sbz2: WORD,
+}}
+pub type PACL = *mut ACL;
+STRUCT!{struct ACE_HEADER {
+    AceType: BYTE,
+    AceFlags: BYTE,
+    AceSize: WORD,
+}}
+pub type PACE_HEADER = *mut ACE_HEADER;
+pub const ACCESS_MIN_MS_ACE_TYPE: BYTE = 0x0;
+pub const ACCESS_ALLOWED_ACE_TYPE: BYTE = 0x0;
+pub const ACCESS_DENIED_ACE_TYPE: BYTE = 0x1;
+pub const SYSTEM_AUDIT_ACE_TYPE: BYTE = 0x2;
+pub const SYSTEM_ALARM_ACE_TYPE: BYTE = 0x3;
+pub const ACCESS_MAX_MS_V2_ACE_TYPE: BYTE = 0x3;
+pub const ACCESS_ALLOWED_COMPOUND_ACE_TYPE: BYTE = 0x4;
+pub const ACCESS_MAX_MS_V3_ACE_TYPE: BYTE = 0x4;
+pub const ACCESS_MIN_MS_OBJECT_ACE_TYPE: BYTE = 0x5;
+pub const ACCESS_ALLOWED_OBJECT_ACE_TYPE: BYTE = 0x5;
+pub const ACCESS_DENIED_OBJECT_ACE_TYPE: BYTE = 0x6;
+pub const SYSTEM_AUDIT_OBJECT_ACE_TYPE: BYTE = 0x7;
+pub const SYSTEM_ALARM_OBJECT_ACE_TYPE: BYTE = 0x8;
+pub const ACCESS_MAX_MS_OBJECT_ACE_TYPE: BYTE = 0x8;
+pub const ACCESS_MAX_MS_V4_ACE_TYPE: BYTE = 0x8;
+pub const ACCESS_MAX_MS_ACE_TYPE: BYTE = 0x8;
+pub const ACCESS_ALLOWED_CALLBACK_ACE_TYPE: BYTE = 0x9;
+pub const ACCESS_DENIED_CALLBACK_ACE_TYPE: BYTE = 0xA;
+pub const ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE: BYTE = 0xB;
+pub const ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE: BYTE = 0xC;
+pub const SYSTEM_AUDIT_CALLBACK_ACE_TYPE: BYTE = 0xD;
+pub const SYSTEM_ALARM_CALLBACK_ACE_TYPE: BYTE = 0xE;
+pub const SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE: BYTE = 0xF;
+pub const SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE: BYTE = 0x10;
+pub const SYSTEM_MANDATORY_LABEL_ACE_TYPE: BYTE = 0x11;
+pub const SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE: BYTE = 0x12;
+pub const SYSTEM_SCOPED_POLICY_ID_ACE_TYPE: BYTE = 0x13;
+pub const SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE: BYTE = 0x14;
+pub const SYSTEM_ACCESS_FILTER_ACE_TYPE: BYTE = 0x15;
+pub const ACCESS_MAX_MS_V5_ACE_TYPE: BYTE = 0x15;
+pub const OBJECT_INHERIT_ACE: BYTE = 0x1;
+pub const CONTAINER_INHERIT_ACE: BYTE = 0x2;
+pub const NO_PROPAGATE_INHERIT_ACE: BYTE = 0x4;
+pub const INHERIT_ONLY_ACE: BYTE = 0x8;
+pub const INHERITED_ACE: BYTE = 0x10;
+pub const VALID_INHERIT_FLAGS: BYTE = 0x1F;
+pub const SUCCESSFUL_ACCESS_ACE_FLAG: BYTE = 0x40;
+pub const FAILED_ACCESS_ACE_FLAG: BYTE = 0x80;
+pub const TRUST_PROTECTED_FILTER_ACE_FLAG: BYTE = 0x40;
+STRUCT!{struct ACCESS_ALLOWED_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PACCESS_ALLOWED_ACE = *mut ACCESS_ALLOWED_ACE;
+STRUCT!{struct ACCESS_DENIED_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PACCESS_DENIED_ACE = *mut ACCESS_DENIED_ACE;
+STRUCT!{struct SYSTEM_AUDIT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_AUDIT_ACE = *mut SYSTEM_AUDIT_ACE;
+STRUCT!{struct SYSTEM_ALARM_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_ALARM_ACE = *mut SYSTEM_ALARM_ACE;
+STRUCT!{struct SYSTEM_RESOURCE_ATTRIBUTE_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_RESOURCE_ATTRIBUTE_ACE = *mut SYSTEM_RESOURCE_ATTRIBUTE_ACE;
+STRUCT!{struct SYSTEM_SCOPED_POLICY_ID_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_SCOPED_POLICY_ID_ACE = *mut SYSTEM_SCOPED_POLICY_ID_ACE;
+STRUCT!{struct SYSTEM_MANDATORY_LABEL_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_MANDATORY_LABEL_ACE = *mut SYSTEM_MANDATORY_LABEL_ACE;
+STRUCT!{struct SYSTEM_PROCESS_TRUST_LABEL_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_PROCESS_TRUST_LABEL_ACE = *mut SYSTEM_PROCESS_TRUST_LABEL_ACE;
+STRUCT!{struct SYSTEM_ACCESS_FILTER_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_ACCESS_FILTER_ACE = *mut SYSTEM_ACCESS_FILTER_ACE;
+pub const SYSTEM_MANDATORY_LABEL_NO_WRITE_UP: ACCESS_MASK = 0x1;
+pub const SYSTEM_MANDATORY_LABEL_NO_READ_UP: ACCESS_MASK = 0x2;
+pub const SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP: ACCESS_MASK = 0x4;
+pub const SYSTEM_MANDATORY_LABEL_VALID_MASK: ACCESS_MASK = SYSTEM_MANDATORY_LABEL_NO_WRITE_UP
+    | SYSTEM_MANDATORY_LABEL_NO_READ_UP | SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP;
+pub const SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK: ACCESS_MASK = 0x00ffffff;
+pub const SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK: ACCESS_MASK = 0xffffffff;
+pub const SYSTEM_ACCESS_FILTER_VALID_MASK: ACCESS_MASK = 0x00ffffff;
+pub const SYSTEM_ACCESS_FILTER_NOCONSTRAINT_MASK: ACCESS_MASK = 0xffffffff;
+STRUCT!{struct ACCESS_ALLOWED_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PACCESS_ALLOWED_OBJECT_ACE = *mut ACCESS_ALLOWED_OBJECT_ACE;
+STRUCT!{struct ACCESS_DENIED_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PACCESS_DENIED_OBJECT_ACE = *mut ACCESS_DENIED_OBJECT_ACE;
+STRUCT!{struct SYSTEM_AUDIT_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_AUDIT_OBJECT_ACE = *mut SYSTEM_AUDIT_OBJECT_ACE;
+STRUCT!{struct SYSTEM_ALARM_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_ALARM_OBJECT_ACE = *mut SYSTEM_ALARM_OBJECT_ACE;
+STRUCT!{struct ACCESS_ALLOWED_CALLBACK_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PACCESS_ALLOWED_CALLBACK_ACE = *mut ACCESS_ALLOWED_CALLBACK_ACE;
+STRUCT!{struct ACCESS_DENIED_CALLBACK_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PACCESS_DENIED_CALLBACK_ACE = *mut ACCESS_DENIED_CALLBACK_ACE;
+STRUCT!{struct SYSTEM_AUDIT_CALLBACK_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_AUDIT_CALLBACK_ACE = *mut SYSTEM_AUDIT_CALLBACK_ACE;
+STRUCT!{struct SYSTEM_ALARM_CALLBACK_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_ALARM_CALLBACK_ACE = *mut SYSTEM_ALARM_CALLBACK_ACE;
+STRUCT!{struct ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PACCESS_ALLOWED_CALLBACK_OBJECT_ACE = *mut ACCESS_ALLOWED_CALLBACK_OBJECT_ACE;
+STRUCT!{struct ACCESS_DENIED_CALLBACK_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PACCESS_DENIED_CALLBACK_OBJECT_ACE = *mut ACCESS_DENIED_CALLBACK_OBJECT_ACE;
+STRUCT!{struct SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = *mut SYSTEM_AUDIT_CALLBACK_OBJECT_ACE;
+STRUCT!{struct SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
+    Header: ACE_HEADER,
+    Mask: ACCESS_MASK,
+    Flags: DWORD,
+    ObjectType: GUID,
+    InheritedObjectType: GUID,
+    SidStart: DWORD,
+}}
+pub type PSYSTEM_ALARM_CALLBACK_OBJECT_ACE = *mut SYSTEM_ALARM_CALLBACK_OBJECT_ACE;
+pub const ACE_OBJECT_TYPE_PRESENT: DWORD = 0x1;
+pub const ACE_INHERITED_OBJECT_TYPE_PRESENT: DWORD = 0x2;
+ENUM!{enum ACL_INFORMATION_CLASS {
+    AclRevisionInformation = 1,
+    AclSizeInformation,
+}}
+STRUCT!{struct ACL_REVISION_INFORMATION {
+    AclRevision: DWORD,
+}}
+pub type PACL_REVISION_INFORMATION = *mut ACL_REVISION_INFORMATION;
+STRUCT!{struct ACL_SIZE_INFORMATION {
+    AceCount: DWORD,
+    AclBytesInUse: DWORD,
+    AclBytesFree: DWORD,
+}}
+pub type PACL_SIZE_INFORMATION = *mut ACL_SIZE_INFORMATION;
+pub const SECURITY_DESCRIPTOR_REVISION: DWORD = 1;
+pub const SECURITY_DESCRIPTOR_REVISION1: DWORD = 1;
+#[cfg(target_pointer_width = "64")]
+pub const SECURITY_DESCRIPTOR_MIN_LENGTH: usize = 40;
+#[cfg(target_pointer_width = "32")]
+pub const SECURITY_DESCRIPTOR_MIN_LENGTH: usize = 20;
+pub type SECURITY_DESCRIPTOR_CONTROL = WORD;
+pub type PSECURITY_DESCRIPTOR_CONTROL = *mut WORD;
+pub const SE_OWNER_DEFAULTED: SECURITY_DESCRIPTOR_CONTROL = 0x0001;
+pub const SE_GROUP_DEFAULTED: SECURITY_DESCRIPTOR_CONTROL = 0x0002;
+pub const SE_DACL_PRESENT: SECURITY_DESCRIPTOR_CONTROL = 0x0004;
+pub const SE_DACL_DEFAULTED: SECURITY_DESCRIPTOR_CONTROL = 0x0008;
+pub const SE_SACL_PRESENT: SECURITY_DESCRIPTOR_CONTROL = 0x0010;
+pub const SE_SACL_DEFAULTED: SECURITY_DESCRIPTOR_CONTROL = 0x0020;
+pub const SE_DACL_AUTO_INHERIT_REQ: SECURITY_DESCRIPTOR_CONTROL = 0x0100;
+pub const SE_SACL_AUTO_INHERIT_REQ: SECURITY_DESCRIPTOR_CONTROL = 0x0200;
+pub const SE_DACL_AUTO_INHERITED: SECURITY_DESCRIPTOR_CONTROL = 0x0400;
+pub const SE_SACL_AUTO_INHERITED: SECURITY_DESCRIPTOR_CONTROL = 0x0800;
+pub const SE_DACL_PROTECTED: SECURITY_DESCRIPTOR_CONTROL = 0x1000;
+pub const SE_SACL_PROTECTED: SECURITY_DESCRIPTOR_CONTROL = 0x2000;
+pub const SE_RM_CONTROL_VALID: SECURITY_DESCRIPTOR_CONTROL = 0x4000;
+pub const SE_SELF_RELATIVE: SECURITY_DESCRIPTOR_CONTROL = 0x8000;
+STRUCT!{struct SECURITY_DESCRIPTOR_RELATIVE {
+    Revision: BYTE,
+    Sbz1: BYTE,
+    Control: SECURITY_DESCRIPTOR_CONTROL,
+    Owner: DWORD,
+    Group: DWORD,
+    Sacl: DWORD,
+    Dacl: DWORD,
+}}
+pub type PISECURITY_DESCRIPTOR_RELATIVE = *mut SECURITY_DESCRIPTOR_RELATIVE;
+STRUCT!{struct SECURITY_DESCRIPTOR {
+    Revision: BYTE,
+    Sbz1: BYTE,
+    Control: SECURITY_DESCRIPTOR_CONTROL,
+    Owner: PSID,
+    Group: PSID,
+    Sacl: PACL,
+    Dacl: PACL,
+}}
+pub type PISECURITY_DESCRIPTOR = *mut SECURITY_DESCRIPTOR;
+STRUCT!{struct SECURITY_OBJECT_AI_PARAMS {
+    Size: DWORD,
+    ConstraintMask: DWORD,
+}}
+pub type PSECURITY_OBJECT_AI_PARAMS = *mut SECURITY_OBJECT_AI_PARAMS;
+STRUCT!{struct OBJECT_TYPE_LIST {
+    Level: WORD,
+    Sbz: WORD,
+    ObjectType: *mut GUID,
+}}
+pub type POBJECT_TYPE_LIST = *mut OBJECT_TYPE_LIST;
+pub const ACCESS_OBJECT_GUID: WORD = 0;
+pub const ACCESS_PROPERTY_SET_GUID: WORD = 1;
+pub const ACCESS_PROPERTY_GUID: WORD = 2;
+pub const ACCESS_MAX_LEVEL: WORD = 4;
+ENUM!{enum AUDIT_EVENT_TYPE {
+    AuditEventObjectAccess,
+    AuditEventDirectoryServiceAccess,
+}}
+pub const AUDIT_ALLOW_NO_PRIVILEGE: DWORD = 0x1;
+pub const ACCESS_DS_SOURCE: &'static str = "DS";
+pub const ACCESS_DS_OBJECT_TYPE_NAME: &'static str = "Directory Service Object";
+pub const SE_PRIVILEGE_ENABLED_BY_DEFAULT: DWORD = 0x00000001;
+pub const SE_PRIVILEGE_ENABLED: DWORD = 0x00000002;
+pub const SE_PRIVILEGE_REMOVED: DWORD = 0x00000004;
+pub const SE_PRIVILEGE_USED_FOR_ACCESS: DWORD = 0x80000000;
+pub const SE_PRIVILEGE_VALID_ATTRIBUTES: DWORD = SE_PRIVILEGE_ENABLED_BY_DEFAULT
+    | SE_PRIVILEGE_ENABLED | SE_PRIVILEGE_REMOVED | SE_PRIVILEGE_USED_FOR_ACCESS;
+pub const PRIVILEGE_SET_ALL_NECESSARY: DWORD = 1;
+STRUCT!{struct PRIVILEGE_SET {
+    PrivilegeCount: DWORD,
+    Control: DWORD,
+    Privilege: [LUID_AND_ATTRIBUTES; ANYSIZE_ARRAY],
+}}
+pub type PPRIVILEGE_SET = *mut PRIVILEGE_SET;
+pub const ACCESS_REASON_TYPE_MASK: ACCESS_REASON = 0x00ff0000;
+pub const ACCESS_REASON_DATA_MASK: ACCESS_REASON = 0x0000ffff;
+pub const ACCESS_REASON_STAGING_MASK: ACCESS_REASON = 0x80000000;
+pub const ACCESS_REASON_EXDATA_MASK: ACCESS_REASON = 0x7f000000;
+ENUM!{enum ACCESS_REASON_TYPE {
+    AccessReasonNone = 0x00000000,
+    AccessReasonAllowedAce = 0x00010000,
+    AccessReasonDeniedAce = 0x00020000,
+    AccessReasonAllowedParentAce = 0x00030000,
+    AccessReasonDeniedParentAce = 0x00040000,
+    AccessReasonNotGrantedByCape = 0x00050000,
+    AccessReasonNotGrantedByParentCape = 0x00060000,
+    AccessReasonNotGrantedToAppContainer = 0x00070000,
+    AccessReasonMissingPrivilege = 0x00100000,
+    AccessReasonFromPrivilege = 0x00200000,
+    AccessReasonIntegrityLevel = 0x00300000,
+    AccessReasonOwnership = 0x00400000,
+    AccessReasonNullDacl = 0x00500000,
+    AccessReasonEmptyDacl = 0x00600000,
+    AccessReasonNoSD = 0x00700000,
+    AccessReasonNoGrant = 0x00800000,
+    AccessReasonTrustLabel = 0x00900000,
+    AccessReasonFilterAce = 0x00a00000,
+}}
+pub type ACCESS_REASON = DWORD;
+STRUCT!{struct ACCESS_REASONS {
+    Data: [ACCESS_REASON; 32],
+}}
+pub type PACCESS_REASONS = *mut ACCESS_REASONS;
+pub const SE_SECURITY_DESCRIPTOR_FLAG_NO_OWNER_ACE: DWORD = 0x00000001;
+pub const SE_SECURITY_DESCRIPTOR_FLAG_NO_LABEL_ACE: DWORD = 0x00000002;
+pub const SE_SECURITY_DESCRIPTOR_FLAG_NO_ACCESS_FILTER_ACE: DWORD = 0x00000004;
+pub const SE_SECURITY_DESCRIPTOR_VALID_FLAGS: DWORD = 0x00000007;
+STRUCT!{struct SE_SECURITY_DESCRIPTOR {
+    Size: DWORD,
+    Flags: DWORD,
+    SecurityDescriptor: PSECURITY_DESCRIPTOR,
+}}
+pub type PSE_SECURITY_DESCRIPTOR = *mut SE_SECURITY_DESCRIPTOR;
+STRUCT!{struct SE_ACCESS_REQUEST {
+    Size: DWORD,
+    SeSecurityDescriptor: PSE_SECURITY_DESCRIPTOR,
+    DesiredAccess: ACCESS_MASK,
+    PreviouslyGrantedAccess: ACCESS_MASK,
+    PrincipalSelfSid: PSID,
+    GenericMapping: PGENERIC_MAPPING,
+    ObjectTypeListCount: DWORD,
+    ObjectTypeList: POBJECT_TYPE_LIST,
+}}
+pub type PSE_ACCESS_REQUEST = *mut SE_ACCESS_REQUEST;
+STRUCT!{struct SE_ACCESS_REPLY {
+    Size: DWORD,
+    ResultListCount: DWORD,
+    GrantedAccess: PACCESS_MASK,
+    AccessStatus: PDWORD,
+    AccessReason: PACCESS_REASONS,
+    Privileges: *mut PPRIVILEGE_SET,
+}}
+pub type PSE_ACCESS_REPLY = *mut SE_ACCESS_REPLY;
+pub const SE_CREATE_TOKEN_NAME: &'static str = "SeCreateTokenPrivilege";
+pub const SE_ASSIGNPRIMARYTOKEN_NAME: &'static str = "SeAssignPrimaryTokenPrivilege";
+pub const SE_LOCK_MEMORY_NAME: &'static str = "SeLockMemoryPrivilege";
+pub const SE_INCREASE_QUOTA_NAME: &'static str = "SeIncreaseQuotaPrivilege";
+pub const SE_UNSOLICITED_INPUT_NAME: &'static str = "SeUnsolicitedInputPrivilege";
+pub const SE_MACHINE_ACCOUNT_NAME: &'static str = "SeMachineAccountPrivilege";
+pub const SE_TCB_NAME: &'static str = "SeTcbPrivilege";
+pub const SE_SECURITY_NAME: &'static str = "SeSecurityPrivilege";
+pub const SE_TAKE_OWNERSHIP_NAME: &'static str = "SeTakeOwnershipPrivilege";
+pub const SE_LOAD_DRIVER_NAME: &'static str = "SeLoadDriverPrivilege";
+pub const SE_SYSTEM_PROFILE_NAME: &'static str = "SeSystemProfilePrivilege";
+pub const SE_SYSTEMTIME_NAME: &'static str = "SeSystemtimePrivilege";
+pub const SE_PROF_SINGLE_PROCESS_NAME: &'static str = "SeProfileSingleProcessPrivilege";
+pub const SE_INC_BASE_PRIORITY_NAME: &'static str = "SeIncreaseBasePriorityPrivilege";
+pub const SE_CREATE_PAGEFILE_NAME: &'static str = "SeCreatePagefilePrivilege";
+pub const SE_CREATE_PERMANENT_NAME: &'static str = "SeCreatePermanentPrivilege";
+pub const SE_BACKUP_NAME: &'static str = "SeBackupPrivilege";
+pub const SE_RESTORE_NAME: &'static str = "SeRestorePrivilege";
+pub const SE_SHUTDOWN_NAME: &'static str = "SeShutdownPrivilege";
+pub const SE_DEBUG_NAME: &'static str = "SeDebugPrivilege";
+pub const SE_AUDIT_NAME: &'static str = "SeAuditPrivilege";
+pub const SE_SYSTEM_ENVIRONMENT_NAME: &'static str = "SeSystemEnvironmentPrivilege";
+pub const SE_CHANGE_NOTIFY_NAME: &'static str = "SeChangeNotifyPrivilege";
+pub const SE_REMOTE_SHUTDOWN_NAME: &'static str = "SeRemoteShutdownPrivilege";
+pub const SE_UNDOCK_NAME: &'static str = "SeUndockPrivilege";
+pub const SE_SYNC_AGENT_NAME: &'static str = "SeSyncAgentPrivilege";
+pub const SE_ENABLE_DELEGATION_NAME: &'static str = "SeEnableDelegationPrivilege";
+pub const SE_MANAGE_VOLUME_NAME: &'static str = "SeManageVolumePrivilege";
+pub const SE_IMPERSONATE_NAME: &'static str = "SeImpersonatePrivilege";
+pub const SE_CREATE_GLOBAL_NAME: &'static str = "SeCreateGlobalPrivilege";
+pub const SE_TRUSTED_CREDMAN_ACCESS_NAME: &'static str = "SeTrustedCredManAccessPrivilege";
+pub const SE_RELABEL_NAME: &'static str = "SeRelabelPrivilege";
+pub const SE_INC_WORKING_SET_NAME: &'static str = "SeIncreaseWorkingSetPrivilege";
+pub const SE_TIME_ZONE_NAME: &'static str = "SeTimeZonePrivilege";
+pub const SE_CREATE_SYMBOLIC_LINK_NAME: &'static str = "SeCreateSymbolicLinkPrivilege";
+pub const SE_DELEGATE_SESSION_USER_IMPERSONATE_NAME: &'static str
+    = "SeDelegateSessionUserImpersonatePrivilege";
+pub const SE_ACTIVATE_AS_USER_CAPABILITY: &'static str = "activateAsUser";
+pub const SE_CONSTRAINED_IMPERSONATION_CAPABILITY: &'static str = "constrainedImpersonation";
+pub const SE_SESSION_IMPERSONATION_CAPABILITY: &'static str = "sessionImpersonation";
+pub const SE_MUMA_CAPABILITY: &'static str = "muma";
+pub const SE_DEVELOPMENT_MODE_NETWORK_CAPABILITY: &'static str = "developmentModeNetwork";
+ENUM!{enum SECURITY_IMPERSONATION_LEVEL {
+    SecurityAnonymous,
+    SecurityIdentification,
+    SecurityImpersonation,
+    SecurityDelegation,
+}}
+pub type PSECURITY_IMPERSONATION_LEVEL = *mut SECURITY_IMPERSONATION_LEVEL;
+pub const SECURITY_MAX_IMPERSONATION_LEVEL: SECURITY_IMPERSONATION_LEVEL = SecurityDelegation;
+pub const SECURITY_MIN_IMPERSONATION_LEVEL: SECURITY_IMPERSONATION_LEVEL = SecurityAnonymous;
+pub const DEFAULT_IMPERSONATION_LEVEL: SECURITY_IMPERSONATION_LEVEL = SecurityImpersonation;
+#[inline]
+pub fn VALID_IMPERSONATION_LEVEL(L: SECURITY_IMPERSONATION_LEVEL) -> bool {
+    (L >= SECURITY_MIN_IMPERSONATION_LEVEL) && (L <= SECURITY_MAX_IMPERSONATION_LEVEL)
+}
+pub const TOKEN_ASSIGN_PRIMARY: DWORD = 0x0001;
+pub const TOKEN_DUPLICATE: DWORD = 0x0002;
+pub const TOKEN_IMPERSONATE: DWORD = 0x0004;
+pub const TOKEN_QUERY: DWORD = 0x0008;
+pub const TOKEN_QUERY_SOURCE: DWORD = 0x0010;
+pub const TOKEN_ADJUST_PRIVILEGES: DWORD = 0x0020;
+pub const TOKEN_ADJUST_GROUPS: DWORD = 0x0040;
+pub const TOKEN_ADJUST_DEFAULT: DWORD = 0x0080;
+pub const TOKEN_ADJUST_SESSIONID: DWORD = 0x0100;
+pub const TOKEN_ALL_ACCESS_P: DWORD = STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY
+    | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE
+    | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT;
+pub const TOKEN_ALL_ACCESS: DWORD = TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID;
+pub const TOKEN_READ: DWORD = STANDARD_RIGHTS_READ | TOKEN_QUERY;
+pub const TOKEN_WRITE: DWORD = STANDARD_RIGHTS_WRITE | TOKEN_ADJUST_PRIVILEGES
+    | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT;
+pub const TOKEN_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE;
+pub const TOKEN_TRUST_CONSTRAINT_MASK: DWORD = STANDARD_RIGHTS_READ | TOKEN_QUERY
+    | TOKEN_QUERY_SOURCE;
+pub const TOKEN_ACCESS_PSEUDO_HANDLE_WIN8: DWORD = TOKEN_QUERY | TOKEN_QUERY_SOURCE;
+pub const TOKEN_ACCESS_PSEUDO_HANDLE: DWORD = TOKEN_ACCESS_PSEUDO_HANDLE_WIN8;
+ENUM!{enum TOKEN_TYPE {
+    TokenPrimary = 1,
+    TokenImpersonation,
+}}
+pub type PTOKEN_TYPE = *mut TOKEN_TYPE;
+ENUM!{enum TOKEN_ELEVATION_TYPE {
+    TokenElevationTypeDefault = 1,
+    TokenElevationTypeFull,
+    TokenElevationTypeLimited,
+}}
+pub type PTOKEN_ELEVATION_TYPE = *mut TOKEN_ELEVATION_TYPE;
+ENUM!{enum TOKEN_INFORMATION_CLASS {
+    TokenUser = 1,
+    TokenGroups,
+    TokenPrivileges,
+    TokenOwner,
+    TokenPrimaryGroup,
+    TokenDefaultDacl,
+    TokenSource,
+    TokenType,
+    TokenImpersonationLevel,
+    TokenStatistics,
+    TokenRestrictedSids,
+    TokenSessionId,
+    TokenGroupsAndPrivileges,
+    TokenSessionReference,
+    TokenSandBoxInert,
+    TokenAuditPolicy,
+    TokenOrigin,
+    TokenElevationType,
+    TokenLinkedToken,
+    TokenElevation,
+    TokenHasRestrictions,
+    TokenAccessInformation,
+    TokenVirtualizationAllowed,
+    TokenVirtualizationEnabled,
+    TokenIntegrityLevel,
+    TokenUIAccess,
+    TokenMandatoryPolicy,
+    TokenLogonSid,
+    TokenIsAppContainer,
+    TokenCapabilities,
+    TokenAppContainerSid,
+    TokenAppContainerNumber,
+    TokenUserClaimAttributes,
+    TokenDeviceClaimAttributes,
+    TokenRestrictedUserClaimAttributes,
+    TokenRestrictedDeviceClaimAttributes,
+    TokenDeviceGroups,
+    TokenRestrictedDeviceGroups,
+    TokenSecurityAttributes,
+    TokenIsRestricted,
+    TokenProcessTrustLevel,
+    TokenPrivateNameSpace,
+    TokenSingletonAttributes,
+    TokenBnoIsolation,
+    MaxTokenInfoClass,
+}}
+pub type PTOKEN_INFORMATION_CLASS = *mut TOKEN_INFORMATION_CLASS;
+STRUCT!{struct TOKEN_USER {
+    User: SID_AND_ATTRIBUTES,
+}}
+pub type PTOKEN_USER = *mut TOKEN_USER;
+UNION!{union SE_TOKEN_USER_u1 {
+    [usize; 2],
+    TokenUser TokenUser_mut: TOKEN_USER,
+    User User_mut: SID_AND_ATTRIBUTES,
+}}
+UNION!{union SE_TOKEN_USER_u2 {
+    [u32; 17],
+    Sid Sid_mut: SID,
+    Buffer Buffer_mut: [BYTE; SECURITY_MAX_SID_SIZE],
+}}
+STRUCT!{struct SE_TOKEN_USER {
+    u1: SE_TOKEN_USER_u1,
+    u2: SE_TOKEN_USER_u2,
+}}
+pub type PSE_TOKEN_USER = *mut SE_TOKEN_USER;
+STRUCT!{struct TOKEN_GROUPS {
+    GroupCount: DWORD,
+    Groups: [SID_AND_ATTRIBUTES; ANYSIZE_ARRAY],
+}}
+pub type PTOKEN_GROUPS = *mut TOKEN_GROUPS;
+STRUCT!{struct TOKEN_PRIVILEGES {
+    PrivilegeCount: DWORD,
+    Privileges: [LUID_AND_ATTRIBUTES; ANYSIZE_ARRAY],
+}}
+pub type PTOKEN_PRIVILEGES = *mut TOKEN_PRIVILEGES;
+STRUCT!{struct TOKEN_OWNER {
+    Owner: PSID,
+}}
+pub type PTOKEN_OWNER = *mut TOKEN_OWNER;
+STRUCT!{struct TOKEN_PRIMARY_GROUP {
+    PrimaryGroup: PSID,
+}}
+pub type PTOKEN_PRIMARY_GROUP = *mut TOKEN_PRIMARY_GROUP;
+STRUCT!{struct TOKEN_DEFAULT_DACL {
+    DefaultDacl: PACL,
+}}
+pub type PTOKEN_DEFAULT_DACL = *mut TOKEN_DEFAULT_DACL;
+STRUCT!{struct TOKEN_USER_CLAIMS {
+    UserClaims: PCLAIMS_BLOB,
+}}
+pub type PTOKEN_USER_CLAIMS = *mut TOKEN_USER_CLAIMS;
+STRUCT!{struct TOKEN_DEVICE_CLAIMS {
+    DeviceClaims: PCLAIMS_BLOB,
+}}
+pub type PTOKEN_DEVICE_CLAIMS = *mut TOKEN_DEVICE_CLAIMS;
+STRUCT!{struct TOKEN_GROUPS_AND_PRIVILEGES {
+    SidCount: DWORD,
+    SidLength: DWORD,
+    Sids: PSID_AND_ATTRIBUTES,
+    RestrictedSidCount: DWORD,
+    RestrictedSidLength: DWORD,
+    RestrictedSids: PSID_AND_ATTRIBUTES,
+    PrivilegeCount: DWORD,
+    PrivilegeLength: DWORD,
+    Privileges: PLUID_AND_ATTRIBUTES,
+    AuthenticationId: LUID,
+}}
+pub type PTOKEN_GROUPS_AND_PRIVILEGES = *mut TOKEN_GROUPS_AND_PRIVILEGES;
+STRUCT!{struct TOKEN_LINKED_TOKEN {
+    LinkedToken: HANDLE,
+}}
+pub type PTOKEN_LINKED_TOKEN = *mut TOKEN_LINKED_TOKEN;
+STRUCT!{struct TOKEN_ELEVATION {
+    TokenIsElevated: DWORD,
+}}
+pub type PTOKEN_ELEVATION = *mut TOKEN_ELEVATION;
+STRUCT!{struct TOKEN_MANDATORY_LABEL {
+    Label: SID_AND_ATTRIBUTES,
+}}
+pub type PTOKEN_MANDATORY_LABEL = *mut TOKEN_MANDATORY_LABEL;
+pub const TOKEN_MANDATORY_POLICY_OFF: DWORD = 0x0;
+pub const TOKEN_MANDATORY_POLICY_NO_WRITE_UP: DWORD = 0x1;
+pub const TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN: DWORD = 0x2;
+pub const TOKEN_MANDATORY_POLICY_VALID_MASK: DWORD = TOKEN_MANDATORY_POLICY_NO_WRITE_UP
+    | TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN;
+STRUCT!{struct TOKEN_MANDATORY_POLICY {
+    Policy: DWORD,
+}}
+pub type PTOKEN_MANDATORY_POLICY = *mut TOKEN_MANDATORY_POLICY;
+pub type PSECURITY_ATTRIBUTES_OPAQUE = PVOID;
+STRUCT!{struct TOKEN_ACCESS_INFORMATION {
+    SidHash: PSID_AND_ATTRIBUTES_HASH,
+    RestrictedSidHash: PSID_AND_ATTRIBUTES_HASH,
+    Privileges: PTOKEN_PRIVILEGES,
+    AuthenticationId: LUID,
+    TokenType: TOKEN_TYPE,
+    ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
+    MandatoryPolicy: TOKEN_MANDATORY_POLICY,
+    Flags: DWORD,
+    AppContainerNumber: DWORD,
+    PackageSid: PSID,
+    CapabilitiesHash: PSID_AND_ATTRIBUTES_HASH,
+    TrustLevelSid: PSID,
+    SecurityAttributes: PSECURITY_ATTRIBUTES_OPAQUE,
+}}
+pub type PTOKEN_ACCESS_INFORMATION = *mut TOKEN_ACCESS_INFORMATION;
+pub const POLICY_AUDIT_SUBCATEGORY_COUNT: usize = 59;
+STRUCT!{struct TOKEN_AUDIT_POLICY {
+    PerUserPolicy: [BYTE; (POLICY_AUDIT_SUBCATEGORY_COUNT >> 1) + 1],
+}}
+pub type PTOKEN_AUDIT_POLICY = *mut TOKEN_AUDIT_POLICY;
+pub const TOKEN_SOURCE_LENGTH: usize = 8;
+STRUCT!{struct TOKEN_SOURCE {
+    SourceName: [CHAR; TOKEN_SOURCE_LENGTH],
+    SourceIdentifier: LUID,
+}}
+pub type PTOKEN_SOURCE = *mut TOKEN_SOURCE;
+STRUCT!{struct TOKEN_STATISTICS {
+    TokenId: LUID,
+    AuthenticationId: LUID,
+    ExpirationTime: LARGE_INTEGER,
+    TokenType: TOKEN_TYPE,
+    ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
+    DynamicCharged: DWORD,
+    DynamicAvailable: DWORD,
+    GroupCount: DWORD,
+    PrivilegeCount: DWORD,
+    ModifiedId: LUID,
+}}
+pub type PTOKEN_STATISTICS = *mut TOKEN_STATISTICS;
+STRUCT!{struct TOKEN_CONTROL {
+    TokenId: LUID,
+    AuthenticationId: LUID,
+    ModifiedId: LUID,
+    TokenSource: TOKEN_SOURCE,
+}}
+pub type PTOKEN_CONTROL = *mut TOKEN_CONTROL;
+STRUCT!{struct TOKEN_ORIGIN {
+    OriginatingLogonSession: LUID,
+}}
+pub type PTOKEN_ORIGIN = *mut TOKEN_ORIGIN;
+ENUM!{enum MANDATORY_LEVEL {
+    MandatoryLevelUntrusted = 0,
+    MandatoryLevelLow,
+    MandatoryLevelMedium,
+    MandatoryLevelHigh,
+    MandatoryLevelSystem,
+    MandatoryLevelSecureProcess,
+    MandatoryLevelCount,
+}}
+pub type PMANDATORY_LEVEL = *mut MANDATORY_LEVEL;
+STRUCT!{struct TOKEN_APPCONTAINER_INFORMATION {
+    TokenAppContainer: PSID,
+}}
+pub type PTOKEN_APPCONTAINER_INFORMATION = *mut TOKEN_APPCONTAINER_INFORMATION;
+STRUCT!{struct TOKEN_SID_INFORMATION {
+    Sid: PSID,
+}}
+pub type PTOKEN_SID_INFORMATION = *mut TOKEN_SID_INFORMATION;
+STRUCT!{struct TOKEN_BNO_ISOLATION_INFORMATION {
+    IsolationPrefix: PWSTR,
+    IsolationEnabled: BOOLEAN,
+}}
+pub type PTOKEN_BNO_ISOLATION_INFORMATION = *mut TOKEN_BNO_ISOLATION_INFORMATION;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID: WORD = 0x00;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64: WORD = 0x01;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64: WORD = 0x02;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING: WORD = 0x03;
+STRUCT!{struct CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
+    Version: DWORD64,
+    Name: PWSTR,
+}}
+pub type PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = *mut CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN: WORD = 0x04;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_SID: WORD = 0x05;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN: WORD = 0x06;
+STRUCT!{struct CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
+    pValue: PVOID,
+    ValueLength: DWORD,
+}}
+pub type PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE =
+    *mut CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE;
+pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING: WORD = 0x10;
+pub const CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE: DWORD = 0x0001;
+pub const CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE: DWORD = 0x0002;
+pub const CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY: DWORD = 0x0004;
+pub const CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT: DWORD = 0x0008;
+pub const CLAIM_SECURITY_ATTRIBUTE_DISABLED: DWORD = 0x0010;
+pub const CLAIM_SECURITY_ATTRIBUTE_MANDATORY: DWORD = 0x0020;
+pub const CLAIM_SECURITY_ATTRIBUTE_VALID_FLAGS: DWORD = CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE
+    | CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE | CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY
+    | CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT | CLAIM_SECURITY_ATTRIBUTE_DISABLED
+    | CLAIM_SECURITY_ATTRIBUTE_MANDATORY;
+pub const CLAIM_SECURITY_ATTRIBUTE_CUSTOM_FLAGS: DWORD = 0xFFFF0000;
+UNION!{union CLAIM_SECURITY_ATTRIBUTE_V1_Values {
+    [usize; 1],
+    pInt64 pInt64_mut: PLONG64,
+    pUint64 pUint64_mut: PDWORD64,
+    ppString ppString_mut: PWSTR,
+    pFqbn pFqbn_mut: PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE,
+    pOctetString pOctetString_mut: PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE,
+}}
+STRUCT!{struct CLAIM_SECURITY_ATTRIBUTE_V1 {
+    Name: PWSTR,
+    ValueType: WORD,
+    Reserved: WORD,
+    Flags: DWORD,
+    ValueCount: DWORD,
+    Values: CLAIM_SECURITY_ATTRIBUTE_V1_Values,
+}}
+pub type PCLAIM_SECURITY_ATTRIBUTE_V1 = *mut CLAIM_SECURITY_ATTRIBUTE_V1;
+UNION!{union CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_Values {
+    [u32; 1],
+    pInt64 pInt64_mut: [DWORD; ANYSIZE_ARRAY],
+    pUint64 pUint64_mut: [DWORD; ANYSIZE_ARRAY],
+    ppString ppString_mut: [DWORD; ANYSIZE_ARRAY],
+    pFqbn pFqbn_mut: [DWORD; ANYSIZE_ARRAY],
+    pOctetString pOctetString_mut: [DWORD; ANYSIZE_ARRAY],
+}}
+STRUCT!{struct CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {
+    Name: DWORD,
+    ValueType: WORD,
+    Reserved: WORD,
+    Flags: DWORD,
+    ValueCount: DWORD,
+    Values: CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_Values,
+}}
+pub type PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = *mut CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1;
+pub const CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1: WORD = 1;
+pub const CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION: WORD =
+    CLAIM_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1;
+UNION!{union CLAIM_SECURITY_ATTRIBUTES_INFORMATION_Attribute {
+    [usize; 1],
+    pAttributeV1 pAttributeV1_mut: PCLAIM_SECURITY_ATTRIBUTE_V1,
+}}
+STRUCT!{struct CLAIM_SECURITY_ATTRIBUTES_INFORMATION {
+    Version: WORD,
+    Reserved: WORD,
+    AttributeCount: DWORD,
+    Attribute: CLAIM_SECURITY_ATTRIBUTES_INFORMATION_Attribute,
+}}
+pub type PCLAIM_SECURITY_ATTRIBUTES_INFORMATION = *mut CLAIM_SECURITY_ATTRIBUTES_INFORMATION;
+pub const SECURITY_DYNAMIC_TRACKING: BOOLEAN = TRUE as u8;
+pub const SECURITY_STATIC_TRACKING: BOOLEAN = FALSE as u8;
+pub type SECURITY_CONTEXT_TRACKING_MODE = BOOLEAN;
+pub type PSECURITY_CONTEXT_TRACKING_MODE = *mut BOOLEAN;
+STRUCT!{struct SECURITY_QUALITY_OF_SERVICE {
+    Length: DWORD,
+    ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
+    ContextTrackingMode: SECURITY_CONTEXT_TRACKING_MODE,
+    EffectiveOnly: BOOLEAN,
+}}
+pub type PSECURITY_QUALITY_OF_SERVICE = *mut SECURITY_QUALITY_OF_SERVICE;
+STRUCT!{struct SE_IMPERSONATION_STATE {
+    Token: PACCESS_TOKEN,
+    CopyOnOpen: BOOLEAN,
+    EffectiveOnly: BOOLEAN,
+    Level: SECURITY_IMPERSONATION_LEVEL,
+}}
+pub type PSE_IMPERSONATION_STATE = *mut SE_IMPERSONATION_STATE;
+pub const DISABLE_MAX_PRIVILEGE: DWORD = 0x1;
+pub const SANDBOX_INERT: DWORD = 0x2;
+pub const LUA_TOKEN: DWORD = 0x4;
+pub const WRITE_RESTRICTED: DWORD = 0x8;
+pub type SECURITY_INFORMATION = DWORD;
+pub type PSECURITY_INFORMATION = *mut DWORD;
+pub const OWNER_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000001;
+pub const GROUP_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000002;
+pub const DACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000004;
+pub const SACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000008;
+pub const LABEL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000010;
+pub const ATTRIBUTE_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000020;
+pub const SCOPE_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000040;
+pub const PROCESS_TRUST_LABEL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000080;
+pub const ACCESS_FILTER_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00000100;
+pub const BACKUP_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x00010000;
+pub const PROTECTED_DACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x80000000;
+pub const PROTECTED_SACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x40000000;
+pub const UNPROTECTED_DACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x20000000;
+pub const UNPROTECTED_SACL_SECURITY_INFORMATION: SECURITY_INFORMATION = 0x10000000;
+pub type SE_SIGNING_LEVEL = BYTE;
+pub type PSE_SIGNING_LEVEL = *mut BYTE;
+pub const SE_SIGNING_LEVEL_UNCHECKED: BYTE = 0x00000000;
+pub const SE_SIGNING_LEVEL_UNSIGNED: BYTE = 0x00000001;
+pub const SE_SIGNING_LEVEL_ENTERPRISE: BYTE = 0x00000002;
+pub const SE_SIGNING_LEVEL_CUSTOM_1: BYTE = 0x00000003;
+pub const SE_SIGNING_LEVEL_AUTHENTICODE: BYTE = 0x00000004;
+pub const SE_SIGNING_LEVEL_CUSTOM_2: BYTE = 0x00000005;
+pub const SE_SIGNING_LEVEL_STORE: BYTE = 0x00000006;
+pub const SE_SIGNING_LEVEL_CUSTOM_3: BYTE = 0x00000007;
+pub const SE_SIGNING_LEVEL_ANTIMALWARE: BYTE = SE_SIGNING_LEVEL_CUSTOM_3;
+pub const SE_SIGNING_LEVEL_MICROSOFT: BYTE = 0x00000008;
+pub const SE_SIGNING_LEVEL_CUSTOM_4: BYTE = 0x00000009;
+pub const SE_SIGNING_LEVEL_CUSTOM_5: BYTE = 0x0000000A;
+pub const SE_SIGNING_LEVEL_DYNAMIC_CODEGEN: BYTE = 0x0000000B;
+pub const SE_SIGNING_LEVEL_WINDOWS: BYTE = 0x0000000C;
+pub const SE_SIGNING_LEVEL_CUSTOM_7: BYTE = 0x0000000D;
+pub const SE_SIGNING_LEVEL_WINDOWS_TCB: BYTE = 0x0000000E;
+pub const SE_SIGNING_LEVEL_CUSTOM_6: BYTE = 0x0000000F;
+ENUM!{enum SE_IMAGE_SIGNATURE_TYPE {
+    SeImageSignatureNone = 0,
+    SeImageSignatureEmbedded,
+    SeImageSignatureCache,
+    SeImageSignatureCatalogCached,
+    SeImageSignatureCatalogNotCached,
+    SeImageSignatureCatalogHint,
+    SeImageSignaturePackageCatalog,
+}}
+pub type PSE_IMAGE_SIGNATURE_TYPE = *mut SE_IMAGE_SIGNATURE_TYPE;
+ENUM!{enum SE_LEARNING_MODE_DATA_TYPE {
+    SeLearningModeInvalidType = 0,
+    SeLearningModeSettings,
+    SeLearningModeMax,
+}}
+STRUCT!{struct SECURITY_CAPABILITIES {
+    AppContainerSid: PSID,
+    Capabilities: PSID_AND_ATTRIBUTES,
+    CapabilityCount: DWORD,
+    Reserved: DWORD,
+}}
+pub type PSECURITY_CAPABILITIES = *mut SECURITY_CAPABILITIES;
+pub type LPSECURITY_CAPABILITIES = *mut SECURITY_CAPABILITIES;
+pub const PROCESS_TERMINATE: DWORD = 0x0001;
+pub const PROCESS_CREATE_THREAD: DWORD = 0x0002;
+pub const PROCESS_SET_SESSIONID: DWORD = 0x0004;
+pub const PROCESS_VM_OPERATION: DWORD = 0x0008;
+pub const PROCESS_VM_READ: DWORD = 0x0010;
+pub const PROCESS_VM_WRITE: DWORD = 0x0020;
+pub const PROCESS_DUP_HANDLE: DWORD = 0x0040;
+pub const PROCESS_CREATE_PROCESS: DWORD = 0x0080;
+pub const PROCESS_SET_QUOTA: DWORD = 0x0100;
+pub const PROCESS_SET_INFORMATION: DWORD = 0x0200;
+pub const PROCESS_QUERY_INFORMATION: DWORD = 0x0400;
+pub const PROCESS_SUSPEND_RESUME: DWORD = 0x0800;
+pub const PROCESS_QUERY_LIMITED_INFORMATION: DWORD = 0x1000;
+pub const PROCESS_SET_LIMITED_INFORMATION: DWORD = 0x2000;
+pub const PROCESS_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFFF;
+pub const THREAD_TERMINATE: DWORD = 0x0001;
+pub const THREAD_SUSPEND_RESUME: DWORD = 0x0002;
+pub const THREAD_GET_CONTEXT: DWORD = 0x0008;
+pub const THREAD_SET_CONTEXT: DWORD = 0x0010;
+pub const THREAD_QUERY_INFORMATION: DWORD = 0x0040;
+pub const THREAD_SET_INFORMATION: DWORD = 0x0020;
+pub const THREAD_SET_THREAD_TOKEN: DWORD = 0x0080;
+pub const THREAD_IMPERSONATE: DWORD = 0x0100;
+pub const THREAD_DIRECT_IMPERSONATION: DWORD = 0x0200;
+pub const THREAD_SET_LIMITED_INFORMATION: DWORD = 0x0400;
+pub const THREAD_QUERY_LIMITED_INFORMATION: DWORD = 0x0800;
+pub const THREAD_RESUME: DWORD = 0x1000;
+pub const THREAD_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFFF;
+pub const JOB_OBJECT_ASSIGN_PROCESS: DWORD = 0x0001;
+pub const JOB_OBJECT_SET_ATTRIBUTES: DWORD = 0x0002;
+pub const JOB_OBJECT_QUERY: DWORD = 0x0004;
+pub const JOB_OBJECT_TERMINATE: DWORD = 0x0008;
+pub const JOB_OBJECT_SET_SECURITY_ATTRIBUTES: DWORD = 0x0010;
+pub const JOB_OBJECT_IMPERSONATE: DWORD = 0x0020;
+pub const JOB_OBJECT_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3F;
+STRUCT!{struct JOB_SET_ARRAY {
+    JobHandle: HANDLE,
+    MemberLevel: DWORD,
+    Flags: DWORD,
+}}
+pub type PJOB_SET_ARRAY = *mut JOB_SET_ARRAY;
+pub const FLS_MAXIMUM_AVAILABLE: DWORD = 128;
+pub const TLS_MINIMUM_AVAILABLE: DWORD = 64;
+STRUCT!{struct EXCEPTION_REGISTRATION_RECORD {
+    Next: *mut EXCEPTION_REGISTRATION_RECORD,
+    Handler: PEXCEPTION_ROUTINE,
+}}
+pub type PEXCEPTION_REGISTRATION_RECORD = *mut EXCEPTION_REGISTRATION_RECORD;
+UNION!{union NT_TIB_u {
+    [usize; 1],
+    FiberData FiberData_mut: PVOID,
+    Version Version_mut: DWORD,
+}}
+STRUCT!{struct NT_TIB {
+    ExceptionList: *mut EXCEPTION_REGISTRATION_RECORD,
+    StackBase: PVOID,
+    StackLimit: PVOID,
+    SubSystemTib: PVOID,
+    u: NT_TIB_u,
+    ArbitraryUserPointer: PVOID,
+    _Self: *mut NT_TIB,
+}}
+pub type PNT_TIB = *mut NT_TIB;
+UNION!{union NT_TIB32_u {
+    [u32; 1],
+    FiberData FiberData_mut: DWORD,
+    Version Version_mut: DWORD,
+}}
+STRUCT!{struct NT_TIB32 {
+    ExceptionList: DWORD,
+    StackBase: DWORD,
+    StackLimit: DWORD,
+    SubSystemTib: DWORD,
+    u: NT_TIB32_u,
+    ArbitraryUserPointer: DWORD,
+    Self_: DWORD,
+}}
+pub type PNT_TIB32 = *mut NT_TIB32;
+UNION!{union NT_TIB64_u {
+    [u64; 1],
+    FiberData FiberData_mut: DWORD64,
+    Version Version_mut: DWORD,
+}}
+STRUCT!{struct NT_TIB64 {
+    ExceptionList: DWORD64,
+    StackBase: DWORD64,
+    StackLimit: DWORD64,
+    SubSystemTib: DWORD64,
+    u: NT_TIB64_u,
+    ArbitraryUserPointer: DWORD64,
+    _Self: DWORD64,
+}}
+pub type PNT_TIB64 = *mut NT_TIB64;
+pub const THREAD_DYNAMIC_CODE_ALLOW: DWORD = 1;
+pub const THREAD_BASE_PRIORITY_LOWRT: DWORD = 15;
+pub const THREAD_BASE_PRIORITY_MAX: DWORD = 2;
+pub const THREAD_BASE_PRIORITY_MIN: DWORD = -2i32 as u32;
+pub const THREAD_BASE_PRIORITY_IDLE: DWORD = -15i32 as u32;
+STRUCT!{struct UMS_CREATE_THREAD_ATTRIBUTES {
+    UmsVersion: DWORD,
+    UmsContext: PVOID,
+    UmsCompletionList: PVOID,
+}}
+pub type PUMS_CREATE_THREAD_ATTRIBUTES = *mut UMS_CREATE_THREAD_ATTRIBUTES;
+STRUCT!{struct WOW64_ARCHITECTURE_INFORMATION {
+    BitFields: DWORD,
+}}
+pub type PWOW64_ARCHITECTURE_INFORMATION = *mut WOW64_ARCHITECTURE_INFORMATION;
+BITFIELD!{WOW64_ARCHITECTURE_INFORMATION BitFields: DWORD [
+    Machine set_Machine[0..16],
+    KernelMode set_KernelMode[16..17],
+    UserMode set_UserMode[17..18],
+    Native set_Native[18..19],
+    Process set_Process[19..20],
+    ReservedZero0 set_ReservedZero0[20..32],
+]}
+pub const MEMORY_PRIORITY_LOWEST: ULONG = 0;
+pub const MEMORY_PRIORITY_VERY_LOW: ULONG = 1;
+pub const MEMORY_PRIORITY_LOW: ULONG = 2;
+pub const MEMORY_PRIORITY_MEDIUM: ULONG = 3;
+pub const MEMORY_PRIORITY_BELOW_NORMAL: ULONG = 4;
+pub const MEMORY_PRIORITY_NORMAL: ULONG = 5;
+STRUCT!{struct QUOTA_LIMITS {
+    PagedPoolLimit: SIZE_T,
+    NonPagedPoolLimit: SIZE_T,
+    MinimumWorkingSetSize: SIZE_T,
+    MaximumWorkingSetSize: SIZE_T,
+    PagefileLimit: SIZE_T,
+    TimeLimit: LARGE_INTEGER,
+}}
+pub type PQUOTA_LIMITS = *mut QUOTA_LIMITS;
+pub const QUOTA_LIMITS_HARDWS_MIN_ENABLE: DWORD = 0x00000001;
+pub const QUOTA_LIMITS_HARDWS_MIN_DISABLE: DWORD = 0x00000002;
+pub const QUOTA_LIMITS_HARDWS_MAX_ENABLE: DWORD = 0x00000004;
+pub const QUOTA_LIMITS_HARDWS_MAX_DISABLE: DWORD = 0x00000008;
+pub const QUOTA_LIMITS_USE_DEFAULT_LIMITS: DWORD = 0x00000010;
+STRUCT!{struct RATE_QUOTA_LIMIT {
+    RateData: DWORD,
+}}
+BITFIELD!{RATE_QUOTA_LIMIT RateData: DWORD [
+    RatePercent set_RatePercent[0..7],
+    Reserved0 set_Reserved0[7..32],
+]}
+pub type PRATE_QUOTA_LIMIT = *mut RATE_QUOTA_LIMIT;
+STRUCT!{struct QUOTA_LIMITS_EX {
+    PagedPoolLimit: SIZE_T,
+    NonPagedPoolLimit: SIZE_T,
+    MinimumWorkingSetSize: SIZE_T,
+    MaximumWorkingSetSize: SIZE_T,
+    PagefileLimit: SIZE_T,
+    TimeLimit: LARGE_INTEGER,
+    WorkingSetLimit: SIZE_T,
+    Reserved2: SIZE_T,
+    Reserved3: SIZE_T,
+    Reserved4: SIZE_T,
+    Flags: DWORD,
+    CpuRateLimit: RATE_QUOTA_LIMIT,
+}}
+pub type PQUOTA_LIMITS_EX = *mut QUOTA_LIMITS_EX;
+STRUCT!{struct IO_COUNTERS {
+    ReadOperationCount: ULONGLONG,
+    WriteOperationCount: ULONGLONG,
+    OtherOperationCount: ULONGLONG,
+    ReadTransferCount: ULONGLONG,
+    WriteTransferCount: ULONGLONG,
+    OtherTransferCount: ULONGLONG,
+}}
+pub type PIO_COUNTERS = *mut IO_COUNTERS;
+pub const MAX_HW_COUNTERS: usize = 16;
+pub const THREAD_PROFILING_FLAG_DISPATCH: DWORD = 0x00000001;
+ENUM!{enum HARDWARE_COUNTER_TYPE {
+    PMCCounter,
+    MaxHardwareCounterType,
+}}
+pub type PHARDWARE_COUNTER_TYPE = *mut HARDWARE_COUNTER_TYPE;
+ENUM!{enum PROCESS_MITIGATION_POLICY {
+    ProcessDEPPolicy,
+    ProcessASLRPolicy,
+    ProcessDynamicCodePolicy,
+    ProcessStrictHandleCheckPolicy,
+    ProcessSystemCallDisablePolicy,
+    ProcessMitigationOptionsMask,
+    ProcessExtensionPointDisablePolicy,
+    ProcessControlFlowGuardPolicy,
+    ProcessSignaturePolicy,
+    ProcessFontDisablePolicy,
+    ProcessImageLoadPolicy,
+    MaxProcessMitigationPolicy,
+}}
+pub type PPROCESS_MITIGATION_POLICY = *mut PROCESS_MITIGATION_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_ASLR_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_ASLR_POLICY Flags: DWORD [
+    EnableBottomUpRandomization set_EnableBottomUpRandomization[0..1],
+    EnableForceRelocateImages set_EnableForceRelocateImages[1..2],
+    EnableHighEntropy set_EnableHighEntropy[2..3],
+    DisallowStrippedImages set_DisallowStrippedImages[3..4],
+    ReservedFlags set_ReservedFlags[4..32],
+]}
+pub type PPROCESS_MITIGATION_ASLR_POLICY = *mut PROCESS_MITIGATION_ASLR_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_DEP_POLICY {
+    Flags: DWORD,
+    Permanent: BOOLEAN,
+}}
+BITFIELD!{PROCESS_MITIGATION_DEP_POLICY Flags: DWORD [
+    Enable set_Enable[0..1],
+    DisableAtlThunkEmulation set_DisableAtlThunkEmulation[1..2],
+    ReservedFlags set_ReservedFlags[2..32],
+]}
+pub type PPROCESS_MITIGATION_DEP_POLICY = *mut PROCESS_MITIGATION_DEP_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY Flags: DWORD [
+    RaiseExceptionOnInvalidHandleReference set_RaiseExceptionOnInvalidHandleReference[0..1],
+    HandleExceptionsPermanentlyEnabled set_HandleExceptionsPermanentlyEnabled[1..2],
+    ReservedFlags set_ReservedFlags[2..32],
+]}
+pub type PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY
+    = *mut PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY Flags: DWORD [
+    DisallowWin32kSystemCalls set_DisallowWin32kSystemCalls[0..1],
+    ReservedFlags set_ReservedFlags[1..32],
+]}
+pub type PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY
+    = *mut PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY Flags: DWORD [
+    DisableExtensionPoints set_DisableExtensionPoints[0..1],
+    ReservedFlags set_ReservedFlags[1..32],
+]}
+pub type PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY
+    = *mut PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_DYNAMIC_CODE_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_DYNAMIC_CODE_POLICY Flags: DWORD [
+    ProhibitDynamicCode set_ProhibitDynamicCode[0..1],
+    AllowThreadOptOut set_AllowThreadOptOut[1..2],
+    AllowRemoteDowngrade set_AllowRemoteDowngrade[2..3],
+    ReservedFlags set_ReservedFlags[3..32],
+]}
+pub type PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY = *mut PROCESS_MITIGATION_DYNAMIC_CODE_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY Flags: DWORD [
+    EnableControlFlowGuard set_EnableControlFlowGuard[0..1],
+    EnableExportSuppression set_EnableExportSuppression[1..2],
+    StrictMode set_StrictMode[2..3],
+    ReservedFlags set_ReservedFlags[3..32],
+]}
+pub type PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY
+    = *mut PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY Flags: DWORD [
+    MicrosoftSignedOnly set_MicrosoftSignedOnly[0..1],
+    StoreSignedOnly set_StoreSignedOnly[1..2],
+    MitigationOptIn set_MitigationOptIn[2..3],
+    ReservedFlags set_ReservedFlags[3..32],
+]}
+pub type PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY
+    = *mut PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_FONT_DISABLE_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_FONT_DISABLE_POLICY Flags: DWORD [
+    DisableNonSystemFonts set_DisableNonSystemFonts[0..1],
+    AuditNonSystemFontLoading set_AuditNonSystemFontLoading[1..2],
+    ReservedFlags set_ReservedFlags[2..32],
+]}
+pub type PPROCESS_MITIGATION_FONT_DISABLE_POLICY = *mut PROCESS_MITIGATION_FONT_DISABLE_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_IMAGE_LOAD_POLICY {
+    Flags: DWORD,
+}}
+BITFIELD!{PROCESS_MITIGATION_IMAGE_LOAD_POLICY Flags: DWORD [
+    NoRemoteImages set_NoRemoteImages[0..1],
+    NoLowMandatoryLabelImages set_NoLowMandatoryLabelImages[1..2],
+    PreferSystem32Images set_PreferSystem32Images[2..3],
+    ReservedFlags set_ReservedFlags[3..32],
+]}
+pub type PPROCESS_MITIGATION_IMAGE_LOAD_POLICY = *mut PROCESS_MITIGATION_IMAGE_LOAD_POLICY;
+STRUCT!{struct PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY {
+    Flags: DWORD,
+}}
+pub type PPPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY =
+    *mut PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY;
+BITFIELD!{PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY Flags: DWORD [
+    FilterId set_FilterId[0..4],
+    ReservedFlags set_ReservedFlags[4..32],
+]}
+STRUCT!{struct PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY {
+    Flags: DWORD,
+}}
+pub type PPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY =
+    *mut PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY;
+BITFIELD!{PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY Flags: DWORD [
+    EnableExportAddressFilter set_EnableExportAddressFilter[0..1],
+    AuditExportAddressFilter set_AuditExportAddressFilter[1..2],
+    EnableExportAddressFilterPlus set_EnableExportAddressFilterPlus[2..3],
+    AuditExportAddressFilterPlus set_AuditExportAddressFilterPlus[3..4],
+    EnableImportAddressFilter set_EnableImportAddressFilter[4..5],
+    AuditImportAddressFilter set_AuditImportAddressFilter[5..6],
+    EnableRopStackPivot set_EnableRopStackPivot[6..7],
+    AuditRopStackPivot set_AuditRopStackPivot[7..8],
+    EnableRopCallerCheck set_EnableRopCallerCheck[8..9],
+    AuditRopCallerCheck set_AuditRopCallerCheck[9..10],
+    EnableRopSimExec set_EnableRopSimExec[10..11],
+    AuditRopSimExec set_AuditRopSimExec[11..12],
+    ReservedFlags set_ReservedFlags[12..32],
+]}
+STRUCT!{struct PROCESS_MITIGATION_CHILD_PROCESS_POLICY {
+    Flags: DWORD,
+}}
+pub type PPROCESS_MITIGATION_CHILD_PROCESS_POLICY = *mut PROCESS_MITIGATION_CHILD_PROCESS_POLICY;
+BITFIELD!{PROCESS_MITIGATION_CHILD_PROCESS_POLICY Flags: DWORD [
+    NoChildProcessCreation set_NoChildProcessCreation[0..1],
+    AuditNoChildProcessCreation set_AuditNoChildProcessCreation[1..2],
+    AllowSecureProcessCreation set_AllowSecureProcessCreation[2..3],
+    ReservedFlags set_ReservedFlags[3..32],
+]}
+STRUCT!{struct JOBOBJECT_BASIC_ACCOUNTING_INFORMATION {
+    TotalUserTime: LARGE_INTEGER,
+    TotalKernelTime: LARGE_INTEGER,
+    ThisPeriodTotalUserTime: LARGE_INTEGER,
+    ThisPeriodTotalKernelTime: LARGE_INTEGER,
+    TotalPageFaultCount: DWORD,
+    TotalProcesses: DWORD,
+    ActiveProcesses: DWORD,
+    TotalTerminatedProcesses: DWORD,
+}}
+pub type PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION = *mut JOBOBJECT_BASIC_ACCOUNTING_INFORMATION;
+STRUCT!{struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
+    PerProcessUserTimeLimit: LARGE_INTEGER,
+    PerJobUserTimeLimit: LARGE_INTEGER,
+    LimitFlags: DWORD,
+    MinimumWorkingSetSize: SIZE_T,
+    MaximumWorkingSetSize: SIZE_T,
+    ActiveProcessLimit: DWORD,
+    Affinity: ULONG_PTR,
+    PriorityClass: DWORD,
+    SchedulingClass: DWORD,
+}}
+pub type PJOBOBJECT_BASIC_LIMIT_INFORMATION = *mut JOBOBJECT_BASIC_LIMIT_INFORMATION;
+STRUCT!{struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+    BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
+    IoInfo: IO_COUNTERS,
+    ProcessMemoryLimit: SIZE_T,
+    JobMemoryLimit: SIZE_T,
+    PeakProcessMemoryUsed: SIZE_T,
+    PeakJobMemoryUsed: SIZE_T,
+}}
+pub type PJOBOBJECT_EXTENDED_LIMIT_INFORMATION = *mut JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
+STRUCT!{struct JOBOBJECT_BASIC_PROCESS_ID_LIST {
+    NumberOfAssignedProcesses: DWORD,
+    NumberOfProcessIdsInList: DWORD,
+    ProcessIdList: [ULONG_PTR; 1],
+}}
+pub type PJOBOBJECT_BASIC_PROCESS_ID_LIST = *mut JOBOBJECT_BASIC_PROCESS_ID_LIST;
+STRUCT!{struct JOBOBJECT_BASIC_UI_RESTRICTIONS {
+    UIRestrictionsClass: DWORD,
+}}
+pub type PJOBOBJECT_BASIC_UI_RESTRICTIONS = *mut JOBOBJECT_BASIC_UI_RESTRICTIONS;
+STRUCT!{struct JOBOBJECT_SECURITY_LIMIT_INFORMATION {
+    SecurityLimitFlags: DWORD,
+    JobToken: HANDLE,
+    SidsToDisable: PTOKEN_GROUPS,
+    PrivilegesToDelete: PTOKEN_PRIVILEGES,
+    RestrictedSids: PTOKEN_GROUPS,
+}}
+pub type PJOBOBJECT_SECURITY_LIMIT_INFORMATION = *mut JOBOBJECT_SECURITY_LIMIT_INFORMATION;
+STRUCT!{struct JOBOBJECT_END_OF_JOB_TIME_INFORMATION {
+    EndOfJobTimeAction: DWORD,
+}}
+pub type PJOBOBJECT_END_OF_JOB_TIME_INFORMATION = *mut JOBOBJECT_END_OF_JOB_TIME_INFORMATION;
+STRUCT!{struct JOBOBJECT_ASSOCIATE_COMPLETION_PORT {
+    CompletionKey: PVOID,
+    CompletionPort: HANDLE,
+}}
+pub type PJOBOBJECT_ASSOCIATE_COMPLETION_PORT = *mut JOBOBJECT_ASSOCIATE_COMPLETION_PORT;
+STRUCT!{struct JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION {
+    BasicInfo: JOBOBJECT_BASIC_ACCOUNTING_INFORMATION,
+    IoInfo: IO_COUNTERS,
+}}
+pub type PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION
+    = *mut JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION;
+STRUCT!{struct JOBOBJECT_JOBSET_INFORMATION {
+    MemberLevel: DWORD,
+}}
+pub type PJOBOBJECT_JOBSET_INFORMATION = *mut JOBOBJECT_JOBSET_INFORMATION;
+ENUM!{enum JOBOBJECT_RATE_CONTROL_TOLERANCE {
+    ToleranceLow = 1,
+    ToleranceMedium,
+    ToleranceHigh,
+}}
+pub type PJOBOBJECT_RATE_CONTROL_TOLERANCE = *mut JOBOBJECT_RATE_CONTROL_TOLERANCE;
+ENUM!{enum JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL {
+    ToleranceIntervalShort = 1,
+    ToleranceIntervalMedium,
+    ToleranceIntervalLong,
+}}
+pub type PJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL
+    = *mut JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL;
+STRUCT!{struct JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION {
+    IoReadBytesLimit: DWORD64,
+    IoWriteBytesLimit: DWORD64,
+    PerJobUserTimeLimit: LARGE_INTEGER,
+    JobMemoryLimit: DWORD64,
+    RateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    RateControlToleranceInterval: JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
+    LimitFlags: DWORD,
+}}
+pub type PJOBOBJECT_NOTIFICATION_LIMIT_INFORMATION = *mut JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION;
+UNION!{union JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u1 {
+    [u64; 1],
+    JobHighMemoryLimit JobHighMemoryLimit_mut: DWORD64,
+    JobMemoryLimit JobMemoryLimit_mut: DWORD64,
+}}
+UNION!{union JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u2 {
+    [u32; 1],
+    RateControlTolerance RateControlTolerance_mut: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    CpuRateControlTolerance CpuRateControlTolerance_mut: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+}}
+UNION!{union JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u3 {
+    [u32; 1],
+    RateControlToleranceInterval RateControlToleranceInterval_mut:
+        JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
+    CpuRateControlToleranceInterval CpuRateControlToleranceInterval_mut:
+        JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
+}}
+STRUCT!{struct JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2 {
+    IoReadBytesLimit: DWORD64,
+    IoWriteBytesLimit: DWORD64,
+    PerJobUserTimeLimit: LARGE_INTEGER,
+    u1: JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u1,
+    u2: JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u2,
+    u3: JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2_u3,
+    LimitFlags: DWORD,
+    IoRateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    JobLowMemoryLimit: DWORD64,
+    IoRateControlToleranceInterval: JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
+    NetRateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    NetRateControlToleranceInterval: JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
+}}
+STRUCT!{struct JOBOBJECT_LIMIT_VIOLATION_INFORMATION {
+    LimitFlags: DWORD,
+    ViolationLimitFlags: DWORD,
+    IoReadBytes: DWORD64,
+    IoReadBytesLimit: DWORD64,
+    IoWriteBytes: DWORD64,
+    IoWriteBytesLimit: DWORD64,
+    PerJobUserTime: LARGE_INTEGER,
+    PerJobUserTimeLimit: LARGE_INTEGER,
+    JobMemory: DWORD64,
+    JobMemoryLimit: DWORD64,
+    RateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    RateControlToleranceLimit: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+}}
+pub type PJOBOBJECT_LIMIT_VIOLATION_INFORMATION = *mut JOBOBJECT_LIMIT_VIOLATION_INFORMATION;
+UNION!{union JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u1 {
+    [u64; 1],
+    JobHighMemoryLimit JobHighMemoryLimit_mut: DWORD64,
+    JobMemoryLimit JobMemoryLimit_mut: DWORD64,
+}}
+UNION!{union JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u2 {
+    [u32; 1],
+    RateControlTolerance RateControlTolerance_mut: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    CpuRateControlTolerance CpuRateControlTolerance_mut: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+}}
+UNION!{union JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u3 {
+    [u32; 1],
+    RateControlToleranceLimit RateControlToleranceLimit_mut: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    CpuRateControlToleranceLimit CpuRateControlToleranceLimit_mut:
+        JOBOBJECT_RATE_CONTROL_TOLERANCE,
+}}
+STRUCT!{struct JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2 {
+    LimitFlags: DWORD,
+    ViolationLimitFlags: DWORD,
+    IoReadBytes: DWORD64,
+    IoReadBytesLimit: DWORD64,
+    IoWriteBytes: DWORD64,
+    IoWriteBytesLimit: DWORD64,
+    PerJobUserTime: LARGE_INTEGER,
+    PerJobUserTimeLimit: LARGE_INTEGER,
+    JobMemory: DWORD64,
+    u1: JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u1,
+    u2: JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u2,
+    u3: JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2_u3,
+    JobLowMemoryLimit: DWORD64,
+    IoRateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    IoRateControlToleranceLimit: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    NetRateControlTolerance: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+    NetRateControlToleranceLimit: JOBOBJECT_RATE_CONTROL_TOLERANCE,
+}}
+STRUCT!{struct JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_u_s {
+    MinRate: WORD,
+    MaxRate: WORD,
+}}
+UNION!{union JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_u {
+    [u32; 1],
+    CpuRate CpuRate_mut: DWORD,
+    Weight Weight_mut: DWORD,
+    s s_mut: JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_u_s,
+}}
+STRUCT!{struct JOBOBJECT_CPU_RATE_CONTROL_INFORMATION {
+    ControlFlags: DWORD,
+    u: JOBOBJECT_CPU_RATE_CONTROL_INFORMATION_u,
+}}
+pub type PJOBOBJECT_CPU_RATE_CONTROL_INFORMATION = *mut JOBOBJECT_CPU_RATE_CONTROL_INFORMATION;
+ENUM!{enum JOB_OBJECT_NET_RATE_CONTROL_FLAGS {
+    JOB_OBJECT_NET_RATE_CONTROL_ENABLE = 0x1,
+    JOB_OBJECT_NET_RATE_CONTROL_MAX_BANDWIDTH = 0x2,
+    JOB_OBJECT_NET_RATE_CONTROL_DSCP_TAG = 0x4,
+    JOB_OBJECT_NET_RATE_CONTROL_VALID_FLAGS = 0x7,
+}}
+pub const JOB_OBJECT_NET_RATE_CONTROL_MAX_DSCP_TAG: DWORD = 64;
+STRUCT!{struct JOBOBJECT_NET_RATE_CONTROL_INFORMATION {
+    MaxBandwidth: DWORD64,
+    ControlFlags: JOB_OBJECT_NET_RATE_CONTROL_FLAGS,
+    DscpTag: BYTE,
+}}
+ENUM!{enum JOB_OBJECT_IO_RATE_CONTROL_FLAGS {
+    JOB_OBJECT_IO_RATE_CONTROL_ENABLE = 0x1,
+    JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME = 0x2,
+    JOB_OBJECT_IO_RATE_CONTROL_VALID_FLAGS = JOB_OBJECT_IO_RATE_CONTROL_ENABLE
+        | JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME,
+}}
+STRUCT!{struct JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE {
+    MaxIops: LONG64,
+    MaxBandwidth: LONG64,
+    ReservationIops: LONG64,
+    VolumeName: PWSTR,
+    BaseIoSize: DWORD,
+    ControlFlags: JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
+    VolumeNameLength: WORD,
+}}
+pub type JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1
+    = JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE;
+STRUCT!{struct JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V2 {
+    MaxIops: LONG64,
+    MaxBandwidth: LONG64,
+    ReservationIops: LONG64,
+    VolumeName: PWSTR,
+    BaseIoSize: DWORD,
+    ControlFlags: JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
+    VolumeNameLength: WORD,
+    CriticalReservationIops: LONG64,
+    ReservationBandwidth: LONG64,
+    CriticalReservationBandwidth: LONG64,
+    MaxTimePercent: LONG64,
+    ReservationTimePercent: LONG64,
+    CriticalReservationTimePercent: LONG64,
+}}
+STRUCT!{struct JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V3 {
+    MaxIops: LONG64,
+    MaxBandwidth: LONG64,
+    ReservationIops: LONG64,
+    VolumeName: PWSTR,
+    BaseIoSize: DWORD,
+    ControlFlags: JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
+    VolumeNameLength: WORD,
+    CriticalReservationIops: LONG64,
+    ReservationBandwidth: LONG64,
+    CriticalReservationBandwidth: LONG64,
+    MaxTimePercent: LONG64,
+    ReservationTimePercent: LONG64,
+    CriticalReservationTimePercent: LONG64,
+    SoftMaxIops: LONG64,
+    SoftMaxBandwidth: LONG64,
+    SoftMaxTimePercent: LONG64,
+    LimitExcessNotifyIops: LONG64,
+    LimitExcessNotifyBandwidth: LONG64,
+    LimitExcessNotifyTimePercent: LONG64,
+}}
+ENUM!{enum JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS {
+    JOBOBJECT_IO_ATTRIBUTION_CONTROL_ENABLE = 0x1,
+    JOBOBJECT_IO_ATTRIBUTION_CONTROL_DISABLE = 0x2,
+    JOBOBJECT_IO_ATTRIBUTION_CONTROL_VALID_FLAGS = 0x3,
+}}
+STRUCT!{struct JOBOBJECT_IO_ATTRIBUTION_STATS {
+    IoCount: ULONG_PTR,
+    TotalNonOverlappedQueueTime: ULONGLONG,
+    TotalNonOverlappedServiceTime: ULONGLONG,
+    TotalSize: ULONGLONG,
+}}
+pub type PJOBOBJECT_IO_ATTRIBUTION_STATS = *mut JOBOBJECT_IO_ATTRIBUTION_STATS;
+STRUCT!{struct JOBOBJECT_IO_ATTRIBUTION_INFORMATION {
+    ControlFlags: DWORD,
+    ReadStats: JOBOBJECT_IO_ATTRIBUTION_STATS,
+    WriteStats: JOBOBJECT_IO_ATTRIBUTION_STATS,
+}}
+pub type PJOBOBJECT_IO_ATTRIBUTION_INFORMATION = *mut JOBOBJECT_IO_ATTRIBUTION_INFORMATION;
+pub const JOB_OBJECT_TERMINATE_AT_END_OF_JOB: DWORD = 0;
+pub const JOB_OBJECT_POST_AT_END_OF_JOB: DWORD = 1;
+pub const JOB_OBJECT_MSG_END_OF_JOB_TIME: DWORD = 1;
+pub const JOB_OBJECT_MSG_END_OF_PROCESS_TIME: DWORD = 2;
+pub const JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT: DWORD = 3;
+pub const JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO: DWORD = 4;
+pub const JOB_OBJECT_MSG_NEW_PROCESS: DWORD = 6;
+pub const JOB_OBJECT_MSG_EXIT_PROCESS: DWORD = 7;
+pub const JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS: DWORD = 8;
+pub const JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT: DWORD = 9;
+pub const JOB_OBJECT_MSG_JOB_MEMORY_LIMIT: DWORD = 10;
+pub const JOB_OBJECT_MSG_NOTIFICATION_LIMIT: DWORD = 11;
+pub const JOB_OBJECT_MSG_JOB_CYCLE_TIME_LIMIT: DWORD = 12;
+pub const JOB_OBJECT_MSG_SILO_TERMINATED: DWORD = 13;
+pub const JOB_OBJECT_MSG_MINIMUM: DWORD = 1;
+pub const JOB_OBJECT_MSG_MAXIMUM: DWORD = 13;
+pub const JOB_OBJECT_VALID_COMPLETION_FILTER: DWORD = ((1 << (JOB_OBJECT_MSG_MAXIMUM + 1)) - 1)
+    - ((1 << JOB_OBJECT_MSG_MINIMUM) - 1);
+pub const JOB_OBJECT_LIMIT_WORKINGSET: DWORD = 0x00000001;
+pub const JOB_OBJECT_LIMIT_PROCESS_TIME: DWORD = 0x00000002;
+pub const JOB_OBJECT_LIMIT_JOB_TIME: DWORD = 0x00000004;
+pub const JOB_OBJECT_LIMIT_ACTIVE_PROCESS: DWORD = 0x00000008;
+pub const JOB_OBJECT_LIMIT_AFFINITY: DWORD = 0x00000010;
+pub const JOB_OBJECT_LIMIT_PRIORITY_CLASS: DWORD = 0x00000020;
+pub const JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME: DWORD = 0x00000040;
+pub const JOB_OBJECT_LIMIT_SCHEDULING_CLASS: DWORD = 0x00000080;
+pub const JOB_OBJECT_LIMIT_PROCESS_MEMORY: DWORD = 0x00000100;
+pub const JOB_OBJECT_LIMIT_JOB_MEMORY: DWORD = 0x00000200;
+pub const JOB_OBJECT_LIMIT_JOB_MEMORY_HIGH: DWORD = JOB_OBJECT_LIMIT_JOB_MEMORY;
+pub const JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION: DWORD = 0x00000400;
+pub const JOB_OBJECT_LIMIT_BREAKAWAY_OK: DWORD = 0x00000800;
+pub const JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK: DWORD = 0x00001000;
+pub const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: DWORD = 0x00002000;
+pub const JOB_OBJECT_LIMIT_SUBSET_AFFINITY: DWORD = 0x00004000;
+pub const JOB_OBJECT_LIMIT_JOB_MEMORY_LOW: DWORD = 0x00008000;
+pub const JOB_OBJECT_LIMIT_JOB_READ_BYTES: DWORD = 0x00010000;
+pub const JOB_OBJECT_LIMIT_JOB_WRITE_BYTES: DWORD = 0x00020000;
+pub const JOB_OBJECT_LIMIT_RATE_CONTROL: DWORD = 0x00040000;
+pub const JOB_OBJECT_LIMIT_CPU_RATE_CONTROL: DWORD = JOB_OBJECT_LIMIT_RATE_CONTROL;
+pub const JOB_OBJECT_LIMIT_IO_RATE_CONTROL: DWORD = 0x00008000;
+pub const JOB_OBJECT_LIMIT_NET_RATE_CONTROL: DWORD = 0x00010000;
+pub const JOB_OBJECT_LIMIT_VALID_FLAGS: DWORD = 0x0007ffff;
+pub const JOB_OBJECT_BASIC_LIMIT_VALID_FLAGS: DWORD = 0x000000ff;
+pub const JOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGS: DWORD = 0x00007fff;
+pub const JOB_OBJECT_NOTIFICATION_LIMIT_VALID_FLAGS: DWORD = JOB_OBJECT_LIMIT_JOB_READ_BYTES
+    | JOB_OBJECT_LIMIT_JOB_WRITE_BYTES | JOB_OBJECT_LIMIT_JOB_TIME
+    | JOB_OBJECT_LIMIT_JOB_MEMORY_LOW | JOB_OBJECT_LIMIT_JOB_MEMORY_HIGH
+    | JOB_OBJECT_LIMIT_CPU_RATE_CONTROL | JOB_OBJECT_LIMIT_IO_RATE_CONTROL
+    | JOB_OBJECT_LIMIT_NET_RATE_CONTROL;
+pub const JOB_OBJECT_UILIMIT_NONE: DWORD = 0x00000000;
+pub const JOB_OBJECT_UILIMIT_HANDLES: DWORD = 0x00000001;
+pub const JOB_OBJECT_UILIMIT_READCLIPBOARD: DWORD = 0x00000002;
+pub const JOB_OBJECT_UILIMIT_WRITECLIPBOARD: DWORD = 0x00000004;
+pub const JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS: DWORD = 0x00000008;
+pub const JOB_OBJECT_UILIMIT_DISPLAYSETTINGS: DWORD = 0x00000010;
+pub const JOB_OBJECT_UILIMIT_GLOBALATOMS: DWORD = 0x00000020;
+pub const JOB_OBJECT_UILIMIT_DESKTOP: DWORD = 0x00000040;
+pub const JOB_OBJECT_UILIMIT_EXITWINDOWS: DWORD = 0x00000080;
+pub const JOB_OBJECT_UILIMIT_ALL: DWORD = 0x000000FF;
+pub const JOB_OBJECT_UI_VALID_FLAGS: DWORD = 0x000000FF;
+pub const JOB_OBJECT_SECURITY_NO_ADMIN: DWORD = 0x00000001;
+pub const JOB_OBJECT_SECURITY_RESTRICTED_TOKEN: DWORD = 0x00000002;
+pub const JOB_OBJECT_SECURITY_ONLY_TOKEN: DWORD = 0x00000004;
+pub const JOB_OBJECT_SECURITY_FILTER_TOKENS: DWORD = 0x00000008;
+pub const JOB_OBJECT_SECURITY_VALID_FLAGS: DWORD = 0x0000000f;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_ENABLE: DWORD = 0x1;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASED: DWORD = 0x2;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP: DWORD = 0x4;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_NOTIFY: DWORD = 0x8;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_MIN_MAX_RATE: DWORD = 0x10;
+pub const JOB_OBJECT_CPU_RATE_CONTROL_VALID_FLAGS: DWORD = 0x1f;
+ENUM!{enum JOBOBJECTINFOCLASS {
+    JobObjectBasicAccountingInformation = 1,
+    JobObjectBasicLimitInformation,
+    JobObjectBasicProcessIdList,
+    JobObjectBasicUIRestrictions,
+    JobObjectSecurityLimitInformation,
+    JobObjectEndOfJobTimeInformation,
+    JobObjectAssociateCompletionPortInformation,
+    JobObjectBasicAndIoAccountingInformation,
+    JobObjectExtendedLimitInformation,
+    JobObjectJobSetInformation,
+    JobObjectGroupInformation,
+    JobObjectNotificationLimitInformation,
+    JobObjectLimitViolationInformation,
+    JobObjectGroupInformationEx,
+    JobObjectCpuRateControlInformation,
+    JobObjectCompletionFilter,
+    JobObjectCompletionCounter,
+    JobObjectReserved1Information = 18,
+    JobObjectReserved2Information,
+    JobObjectReserved3Information,
+    JobObjectReserved4Information,
+    JobObjectReserved5Information,
+    JobObjectReserved6Information,
+    JobObjectReserved7Information,
+    JobObjectReserved8Information,
+    JobObjectReserved9Information,
+    JobObjectReserved10Information,
+    JobObjectReserved11Information,
+    JobObjectReserved12Information,
+    JobObjectReserved13Information,
+    JobObjectReserved14Information = 31,
+    JobObjectNetRateControlInformation,
+    JobObjectNotificationLimitInformation2,
+    JobObjectLimitViolationInformation2,
+    JobObjectCreateSilo,
+    JobObjectSiloBasicInformation,
+    JobObjectReserved15Information = 37,
+    JobObjectReserved16Information = 38,
+    JobObjectReserved17Information = 39,
+    JobObjectReserved18Information = 40,
+    JobObjectReserved19Information = 41,
+    JobObjectReserved20Information = 42,
+    JobObjectReserved21Information = 43,
+    JobObjectReserved22Information = 44,
+    JobObjectReserved23Information = 45,
+    JobObjectReserved24Information = 46,
+    JobObjectReserved25Information = 47,
+    MaxJobObjectInfoClass,
+}}
+STRUCT!{struct SILOOBJECT_BASIC_INFORMATION {
+    SiloId: DWORD,
+    SiloParentId: DWORD,
+    NumberOfProcesses: DWORD,
+    IsInServerSilo: BOOLEAN,
+    Reserved: [BYTE; 3],
+}}
+pub type PSILOOBJECT_BASIC_INFORMATION = *mut SILOOBJECT_BASIC_INFORMATION;
+ENUM!{enum SERVERSILO_STATE {
+    SERVERSILO_INITING = 0,
+    SERVERSILO_STARTED,
+    SERVERSILO_SHUTTING_DOWN,
+    SERVERSILO_TERMINATING,
+    SERVERSILO_TERMINATED,
+}}
+pub type PSERVERSILO_STATE = *mut SERVERSILO_STATE;
+STRUCT!{struct SERVERSILO_BASIC_INFORMATION {
+    ServiceSessionId: DWORD,
+    State: SERVERSILO_STATE,
+    ExitStatus: DWORD,
+}}
+pub type PSERVERSILO_BASIC_INFORMATION = *mut SERVERSILO_BASIC_INFORMATION;
+ENUM!{enum FIRMWARE_TYPE {
+    FirmwareTypeUnknown,
+    FirmwareTypeBios,
+    FirmwareTypeUefi,
+    FirmwareTypeMax,
+}}
+pub type PFIRMWARE_TYPE = *mut FIRMWARE_TYPE;
+pub const EVENT_MODIFY_STATE: DWORD = 0x0002;
+pub const EVENT_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3;
+pub const MUTANT_QUERY_STATE: DWORD = 0x0001;
+pub const MUTANT_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | MUTANT_QUERY_STATE;
+pub const SEMAPHORE_MODIFY_STATE: DWORD = 0x0002;
+pub const SEMAPHORE_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3;
+pub const TIMER_QUERY_STATE: DWORD = 0x0001;
+pub const TIMER_MODIFY_STATE: DWORD = 0x0002;
+pub const TIMER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | TIMER_QUERY_STATE
+    | TIMER_MODIFY_STATE;
+pub const TIME_ZONE_ID_UNKNOWN: DWORD = 0;
+pub const TIME_ZONE_ID_STANDARD: DWORD = 1;
+pub const TIME_ZONE_ID_DAYLIGHT: DWORD = 2;
+ENUM!{enum LOGICAL_PROCESSOR_RELATIONSHIP {
+    RelationProcessorCore,
+    RelationNumaNode,
+    RelationCache,
+    RelationProcessorPackage,
+    RelationGroup,
+    RelationAll = 0xffff,
+}}
+pub const LTP_PC_SMT: BYTE = 0x1;
+ENUM!{enum PROCESSOR_CACHE_TYPE {
+    CacheUnified,
+    CacheInstruction,
+    CacheData,
+    CacheTrace,
+}}
+pub const CACHE_FULLY_ASSOCIATIVE: BYTE = 0xFF;
+STRUCT!{struct CACHE_DESCRIPTOR {
+    Level: BYTE,
+    Associativity: BYTE,
+    LineSize: WORD,
+    Size: DWORD,
+    Type: PROCESSOR_CACHE_TYPE,
+}}
+pub type PCACHE_DESCRIPTOR = *mut CACHE_DESCRIPTOR;
+STRUCT!{struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION_ProcessorCore {
+    Flags: BYTE,
+}}
+STRUCT!{struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION_NumaNode {
+    NodeNumber: DWORD,
+}}
+UNION!{union SYSTEM_LOGICAL_PROCESSOR_INFORMATION_u {
+    [u64; 2],
+    ProcessorCore ProcessorCore_mut: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_ProcessorCore,
+    NumaNode NumaNode_mut: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_NumaNode,
+    Cache Cache_mut: CACHE_DESCRIPTOR,
+    Reserved Reserved_mut: [ULONGLONG; 2],
+}}
+STRUCT!{struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION {
+    ProcessorMask: ULONG_PTR,
+    Relationship: LOGICAL_PROCESSOR_RELATIONSHIP,
+    u: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_u,
+}}
+pub type PSYSTEM_LOGICAL_PROCESSOR_INFORMATION = *mut SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
+STRUCT!{struct PROCESSOR_RELATIONSHIP {
+    Flags: BYTE,
+    EfficiencyClass: BYTE,
+    Reserved: [BYTE; 20],
+    GroupCount: WORD,
+    GroupMask: [GROUP_AFFINITY; ANYSIZE_ARRAY],
+}}
+pub type PPROCESSOR_RELATIONSHIP = *mut PROCESSOR_RELATIONSHIP;
+STRUCT!{struct NUMA_NODE_RELATIONSHIP {
+    NodeNumber: DWORD,
+    Reserved: [BYTE; 20],
+    GroupMask: GROUP_AFFINITY,
+}}
+pub type PNUMA_NODE_RELATIONSHIP = *mut NUMA_NODE_RELATIONSHIP;
+STRUCT!{struct CACHE_RELATIONSHIP {
+    Level: BYTE,
+    Associativity: BYTE,
+    LineSize: WORD,
+    CacheSize: DWORD,
+    Type: PROCESSOR_CACHE_TYPE,
+    Reserved: [BYTE; 20],
+    GroupMask: GROUP_AFFINITY,
+}}
+pub type PCACHE_RELATIONSHIP = *mut CACHE_RELATIONSHIP;
+STRUCT!{struct PROCESSOR_GROUP_INFO {
+    MaximumProcessorCount: BYTE,
+    ActiveProcessorCount: BYTE,
+    Reserved: [BYTE; 38],
+    ActiveProcessorMask: KAFFINITY,
+}}
+pub type PPROCESSOR_GROUP_INFO = *mut PROCESSOR_GROUP_INFO;
+STRUCT!{struct GROUP_RELATIONSHIP {
+    MaximumGroupCount: WORD,
+    ActiveGroupCount: WORD,
+    Reserved: [BYTE; 20],
+    GroupInfo: [PROCESSOR_GROUP_INFO; ANYSIZE_ARRAY],
+}}
+pub type PGROUP_RELATIONSHIP = *mut GROUP_RELATIONSHIP;
+UNION!{union SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_u {
+    [u32; 17] [u64; 9],
+    Processor Processor_mut: PROCESSOR_RELATIONSHIP,
+    NumaNode NumaNode_mut: NUMA_NODE_RELATIONSHIP,
+    Cache Cache_mut: CACHE_RELATIONSHIP,
+    Group Group_mut: GROUP_RELATIONSHIP,
+}}
+STRUCT!{struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX {
+    Relationship: LOGICAL_PROCESSOR_RELATIONSHIP,
+    Size: DWORD,
+    u: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_u,
+}}
+pub type PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX = *mut SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;
+ENUM!{enum CPU_SET_INFORMATION_TYPE {
+    CpuSetInformation,
+}}
+pub type PCPU_SET_INFORMATION_TYPE = *mut CPU_SET_INFORMATION_TYPE;
+pub const SYSTEM_CPU_SET_INFORMATION_PARKED: BYTE = 0x1;
+pub const SYSTEM_CPU_SET_INFORMATION_ALLOCATED: BYTE = 0x2;
+pub const SYSTEM_CPU_SET_INFORMATION_ALLOCATED_TO_TARGET_PROCESS: BYTE = 0x4;
+pub const SYSTEM_CPU_SET_INFORMATION_REALTIME: BYTE = 0x8;
+STRUCT!{struct SYSTEM_CPU_SET_INFORMATION_CpuSet {
+    Id: DWORD,
+    Group: WORD,
+    LogicalProcessorIndex: BYTE,
+    CoreIndex: BYTE,
+    LastLevelCacheIndex: BYTE,
+    NumaNodeIndex: BYTE,
+    EfficiencyClass: BYTE,
+    AllFlags: BYTE,
+    Reserved: DWORD,
+    AllocationTag: DWORD64,
+}}
+BITFIELD!{SYSTEM_CPU_SET_INFORMATION_CpuSet AllFlags: BYTE [
+    Parked set_Parked[0..1],
+    Allocated set_Allocated[1..2],
+    AllocatedToTargetProcess set_AllocatedToTargetProcess[2..3],
+    RealTime set_RealTime[3..4],
+    ReservedFlags set_ReservedFlags[4..8],
+]}
+STRUCT!{struct SYSTEM_CPU_SET_INFORMATION {
+    Size: DWORD,
+    Type: CPU_SET_INFORMATION_TYPE,
+    CpuSet: SYSTEM_CPU_SET_INFORMATION_CpuSet,
+}}
+pub type PSYSTEM_CPU_SET_INFORMATION = *mut SYSTEM_CPU_SET_INFORMATION;
+STRUCT!{struct SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION {
+    CycleTime: DWORD64,
+}}
+pub type PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION = *mut SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION;
+pub const PROCESSOR_INTEL_386: DWORD = 386;
+pub const PROCESSOR_INTEL_486: DWORD = 486;
+pub const PROCESSOR_INTEL_PENTIUM: DWORD = 586;
+pub const PROCESSOR_INTEL_IA64: DWORD = 2200;
+pub const PROCESSOR_AMD_X8664: DWORD = 8664;
+pub const PROCESSOR_MIPS_R4000: DWORD = 4000;
+pub const PROCESSOR_ALPHA_21064: DWORD = 21064;
+pub const PROCESSOR_PPC_601: DWORD = 601;
+pub const PROCESSOR_PPC_603: DWORD = 603;
+pub const PROCESSOR_PPC_604: DWORD = 604;
+pub const PROCESSOR_PPC_620: DWORD = 620;
+pub const PROCESSOR_HITACHI_SH3: DWORD = 10003;
+pub const PROCESSOR_HITACHI_SH3E: DWORD = 10004;
+pub const PROCESSOR_HITACHI_SH4: DWORD = 10005;
+pub const PROCESSOR_MOTOROLA_821: DWORD = 821;
+pub const PROCESSOR_SHx_SH3: DWORD = 103;
+pub const PROCESSOR_SHx_SH4: DWORD = 104;
+pub const PROCESSOR_STRONGARM: DWORD = 2577;
+pub const PROCESSOR_ARM720: DWORD = 1824;
+pub const PROCESSOR_ARM820: DWORD = 2080;
+pub const PROCESSOR_ARM920: DWORD = 2336;
+pub const PROCESSOR_ARM_7TDMI: DWORD = 70001;
+pub const PROCESSOR_OPTIL: DWORD = 0x494f;
+pub const PROCESSOR_ARCHITECTURE_INTEL: WORD = 0;
+pub const PROCESSOR_ARCHITECTURE_MIPS: WORD = 1;
+pub const PROCESSOR_ARCHITECTURE_ALPHA: WORD = 2;
+pub const PROCESSOR_ARCHITECTURE_PPC: WORD = 3;
+pub const PROCESSOR_ARCHITECTURE_SHX: WORD = 4;
+pub const PROCESSOR_ARCHITECTURE_ARM: WORD = 5;
+pub const PROCESSOR_ARCHITECTURE_IA64: WORD = 6;
+pub const PROCESSOR_ARCHITECTURE_ALPHA64: WORD = 7;
+pub const PROCESSOR_ARCHITECTURE_MSIL: WORD = 8;
+pub const PROCESSOR_ARCHITECTURE_AMD64: WORD = 9;
+pub const PROCESSOR_ARCHITECTURE_IA32_ON_WIN64: WORD = 10;
+pub const PROCESSOR_ARCHITECTURE_NEUTRAL: WORD = 11;
+pub const PROCESSOR_ARCHITECTURE_ARM64: WORD = 12;
+pub const PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64: WORD = 13;
+pub const PROCESSOR_ARCHITECTURE_IA32_ON_ARM64: WORD = 14;
+pub const PROCESSOR_ARCHITECTURE_UNKNOWN: WORD = 0xFFFF;
+pub const PF_FLOATING_POINT_PRECISION_ERRATA: DWORD = 0;
+pub const PF_FLOATING_POINT_EMULATED: DWORD = 1;
+pub const PF_COMPARE_EXCHANGE_DOUBLE: DWORD = 2;
+pub const PF_MMX_INSTRUCTIONS_AVAILABLE: DWORD = 3;
+pub const PF_PPC_MOVEMEM_64BIT_OK: DWORD = 4;
+pub const PF_ALPHA_BYTE_INSTRUCTIONS: DWORD = 5;
+pub const PF_XMMI_INSTRUCTIONS_AVAILABLE: DWORD = 6;
+pub const PF_3DNOW_INSTRUCTIONS_AVAILABLE: DWORD = 7;
+pub const PF_RDTSC_INSTRUCTION_AVAILABLE: DWORD = 8;
+pub const PF_PAE_ENABLED: DWORD = 9;
+pub const PF_XMMI64_INSTRUCTIONS_AVAILABLE: DWORD = 10;
+pub const PF_SSE_DAZ_MODE_AVAILABLE: DWORD = 11;
+pub const PF_NX_ENABLED: DWORD = 12;
+pub const PF_SSE3_INSTRUCTIONS_AVAILABLE: DWORD = 13;
+pub const PF_COMPARE_EXCHANGE128: DWORD = 14;
+pub const PF_COMPARE64_EXCHANGE128: DWORD = 15;
+pub const PF_CHANNELS_ENABLED: DWORD = 16;
+pub const PF_XSAVE_ENABLED: DWORD = 17;
+pub const PF_ARM_VFP_32_REGISTERS_AVAILABLE: DWORD = 18;
+pub const PF_ARM_NEON_INSTRUCTIONS_AVAILABLE: DWORD = 19;
+pub const PF_SECOND_LEVEL_ADDRESS_TRANSLATION: DWORD = 20;
+pub const PF_VIRT_FIRMWARE_ENABLED: DWORD = 21;
+pub const PF_RDWRFSGSBASE_AVAILABLE: DWORD = 22;
+pub const PF_FASTFAIL_AVAILABLE: DWORD = 23;
+pub const PF_ARM_DIVIDE_INSTRUCTION_AVAILABLE: DWORD = 24;
+pub const PF_ARM_64BIT_LOADSTORE_ATOMIC: DWORD = 25;
+pub const PF_ARM_EXTERNAL_CACHE_AVAILABLE: DWORD = 26;
+pub const PF_ARM_FMAC_INSTRUCTIONS_AVAILABLE: DWORD = 27;
+pub const PF_RDRAND_INSTRUCTION_AVAILABLE: DWORD = 28;
+pub const PF_ARM_V8_INSTRUCTIONS_AVAILABLE: DWORD = 29;
+pub const PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE: DWORD = 30;
+pub const PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE: DWORD = 31;
+pub const PF_RDTSCP_INSTRUCTION_AVAILABLE: DWORD = 32;
+pub const XSTATE_LEGACY_FLOATING_POINT: ULONG64 = 0;
+pub const XSTATE_LEGACY_SSE: ULONG64 = 1;
+pub const XSTATE_GSSE: ULONG64 = 2;
+pub const XSTATE_AVX: ULONG64 = XSTATE_GSSE;
+pub const XSTATE_MPX_BNDREGS: ULONG64 = 3;
+pub const XSTATE_MPX_BNDCSR: ULONG64 = 4;
+pub const XSTATE_AVX512_KMASK: ULONG64 = 5;
+pub const XSTATE_AVX512_ZMM_H: ULONG64 = 6;
+pub const XSTATE_AVX512_ZMM: ULONG64 = 7;
+pub const XSTATE_IPT: ULONG64 = 8;
+pub const XSTATE_LWP: ULONG64 = 62;
+pub const MAXIMUM_XSTATE_FEATURES: usize = 64;
+pub const XSTATE_MASK_LEGACY_FLOATING_POINT: ULONG64 = 1 << XSTATE_LEGACY_FLOATING_POINT;
+pub const XSTATE_MASK_LEGACY_SSE: ULONG64 = 1 << XSTATE_LEGACY_SSE;
+pub const XSTATE_MASK_LEGACY: ULONG64 = XSTATE_MASK_LEGACY_FLOATING_POINT | XSTATE_MASK_LEGACY_SSE;
+pub const XSTATE_MASK_GSSE: ULONG64 = 1 << XSTATE_GSSE;
+pub const XSTATE_MASK_AVX: ULONG64 = XSTATE_MASK_GSSE;
+pub const XSTATE_MASK_MPX: ULONG64 = (1 << XSTATE_MPX_BNDREGS) | (1 << XSTATE_MPX_BNDCSR);
+pub const XSTATE_MASK_AVX512: ULONG64 = (1 << XSTATE_AVX512_KMASK) | (1 << XSTATE_AVX512_ZMM_H)
+    | (1 << XSTATE_AVX512_ZMM);
+pub const XSTATE_MASK_IPT: ULONG64 = 1 << XSTATE_IPT;
+pub const XSTATE_MASK_LWP: ULONG64 = 1 << XSTATE_LWP;
+pub const XSTATE_MASK_ALLOWED: ULONG64 = XSTATE_MASK_LEGACY | XSTATE_MASK_AVX | XSTATE_MASK_MPX
+    | XSTATE_MASK_AVX512 | XSTATE_MASK_IPT | XSTATE_MASK_LWP;
+pub const XSTATE_MASK_PERSISTENT: ULONG64 = (1 << XSTATE_MPX_BNDCSR) | XSTATE_MASK_LWP;
+pub const XSTATE_COMPACTION_ENABLE: ULONG64 = 63;
+pub const XSTATE_COMPACTION_ENABLE_MASK: ULONG64 = 1 << XSTATE_COMPACTION_ENABLE;
+pub const XSTATE_ALIGN_BIT: ULONG64 = 1;
+pub const XSTATE_ALIGN_MASK: ULONG64 = 1 << XSTATE_ALIGN_BIT;
+pub const XSTATE_CONTROLFLAG_XSAVEOPT_MASK: ULONG64 = 1;
+pub const XSTATE_CONTROLFLAG_XSAVEC_MASK: ULONG64 = 2;
+pub const XSTATE_CONTROLFLAG_VALID_MASK: ULONG64 = XSTATE_CONTROLFLAG_XSAVEOPT_MASK
+    | XSTATE_CONTROLFLAG_XSAVEC_MASK;
+STRUCT!{struct XSTATE_FEATURE {
+    Offset: DWORD,
+    Size: DWORD,
+}}
+pub type PXSTATE_FEATURE = *mut XSTATE_FEATURE;
+STRUCT!{struct XSTATE_CONFIGURATION {
+    EnabledFeatures: DWORD64,
+    EnabledVolatileFeatures: DWORD64,
+    Size: DWORD,
+    ControlFlags: DWORD,
+    Features: [XSTATE_FEATURE; MAXIMUM_XSTATE_FEATURES],
+    EnabledSupervisorFeatures: DWORD64,
+    AlignedFeatures: DWORD64,
+    AllFeatureSize: DWORD,
+    AllFeatures: [DWORD; MAXIMUM_XSTATE_FEATURES],
+}}
+BITFIELD!{XSTATE_CONFIGURATION ControlFlags: DWORD [
+    OptimizedSave set_OptimizedSave[0..1],
+    CompactionEnabled set_CompactionEnabled[1..2],
+]}
+pub type PXSTATE_CONFIGURATION = *mut XSTATE_CONFIGURATION;
+STRUCT!{struct MEMORY_BASIC_INFORMATION {
+    BaseAddress: PVOID,
+    AllocationBase: PVOID,
+    AllocationProtect: DWORD,
+    RegionSize: SIZE_T,
+    State: DWORD,
+    Protect: DWORD,
+    Type: DWORD,
+}}
+pub type PMEMORY_BASIC_INFORMATION = *mut MEMORY_BASIC_INFORMATION;
+STRUCT!{struct MEMORY_BASIC_INFORMATION32 {
+    BaseAddress: DWORD,
+    AllocationBase: DWORD,
+    AllocationProtect: DWORD,
+    RegionSize: DWORD,
+    State: DWORD,
+    Protect: DWORD,
+    Type: DWORD,
+}}
+pub type PMEMORY_BASIC_INFORMATION32 = *mut MEMORY_BASIC_INFORMATION32;
+STRUCT!{struct MEMORY_BASIC_INFORMATION64 { // FIXME: align 16
+    BaseAddress: ULONGLONG,
+    AllocationBase: ULONGLONG,
+    AllocationProtect: DWORD,
+    __alignment1: DWORD,
+    RegionSize: ULONGLONG,
+    State: DWORD,
+    Protect: DWORD,
+    Type: DWORD,
+    __alignment2: DWORD,
+}}
+pub type PMEMORY_BASIC_INFORMATION64 = *mut MEMORY_BASIC_INFORMATION64;
+pub const CFG_CALL_TARGET_VALID: ULONG_PTR = 0x00000001;
+pub const CFG_CALL_TARGET_PROCESSED: ULONG_PTR = 0x00000002;
+pub const CFG_CALL_TARGET_CONVERT_EXPORT_SUPPRESSED_TO_VALID: ULONG_PTR = 0x00000004;
+STRUCT!{struct CFG_CALL_TARGET_INFO {
+    Offset: ULONG_PTR,
+    Flags: ULONG_PTR,
+}}
+pub type PCFG_CALL_TARGET_INFO = *mut CFG_CALL_TARGET_INFO;
+pub const SECTION_QUERY: DWORD = 0x0001;
+pub const SECTION_MAP_WRITE: DWORD = 0x0002;
+pub const SECTION_MAP_READ: DWORD = 0x0004;
+pub const SECTION_MAP_EXECUTE: DWORD = 0x0008;
+pub const SECTION_EXTEND_SIZE: DWORD = 0x0010;
+pub const SECTION_MAP_EXECUTE_EXPLICIT: DWORD = 0x0020;
+pub const SECTION_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY
+    | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE;
+pub const SESSION_QUERY_ACCESS: DWORD = 0x0001;
+pub const SESSION_MODIFY_ACCESS: DWORD = 0x0002;
+pub const SESSION_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SESSION_QUERY_ACCESS
+    | SESSION_MODIFY_ACCESS;
+pub const MEMORY_PARTITION_QUERY_ACCESS: DWORD = 0x0001;
+pub const MEMORY_PARTITION_MODIFY_ACCESS: DWORD = 0x0002;
+pub const MEMORY_PARTITION_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE
+    | MEMORY_PARTITION_QUERY_ACCESS | MEMORY_PARTITION_MODIFY_ACCESS;
+pub const PAGE_NOACCESS: DWORD = 0x01;
+pub const PAGE_READONLY: DWORD = 0x02;
+pub const PAGE_READWRITE: DWORD = 0x04;
+pub const PAGE_WRITECOPY: DWORD = 0x08;
+pub const PAGE_EXECUTE: DWORD = 0x10;
+pub const PAGE_EXECUTE_READ: DWORD = 0x20;
+pub const PAGE_EXECUTE_READWRITE: DWORD = 0x40;
+pub const PAGE_EXECUTE_WRITECOPY: DWORD = 0x80;
+pub const PAGE_GUARD: DWORD = 0x100;
+pub const PAGE_NOCACHE: DWORD = 0x200;
+pub const PAGE_WRITECOMBINE: DWORD = 0x400;
+pub const PAGE_ENCLAVE_THREAD_CONTROL: DWORD = 0x80000000;
+pub const PAGE_REVERT_TO_FILE_MAP: DWORD = 0x80000000;
+pub const PAGE_TARGETS_NO_UPDATE: DWORD = 0x40000000;
+pub const PAGE_TARGETS_INVALID: DWORD = 0x40000000;
+pub const PAGE_ENCLAVE_UNVALIDATED: DWORD = 0x20000000;
+pub const PAGE_ENCLAVE_DECOMMIT: DWORD = 0x10000000;
+pub const MEM_COMMIT: DWORD = 0x1000;
+pub const MEM_RESERVE: DWORD = 0x2000;
+pub const MEM_DECOMMIT: DWORD = 0x4000;
+pub const MEM_RELEASE: DWORD = 0x8000;
+pub const MEM_FREE: DWORD = 0x10000;
+pub const MEM_PRIVATE: DWORD = 0x20000;
+pub const MEM_MAPPED: DWORD = 0x40000;
+pub const MEM_RESET: DWORD = 0x80000;
+pub const MEM_TOP_DOWN: DWORD = 0x100000;
+pub const MEM_WRITE_WATCH: DWORD = 0x200000;
+pub const MEM_PHYSICAL: DWORD = 0x400000;
+pub const MEM_ROTATE: DWORD = 0x800000;
+pub const MEM_DIFFERENT_IMAGE_BASE_OK: DWORD = 0x800000;
+pub const MEM_RESET_UNDO: DWORD = 0x1000000;
+pub const MEM_LARGE_PAGES: DWORD = 0x20000000;
+pub const MEM_4MB_PAGES: DWORD = 0x80000000;
+pub const MEM_64K_PAGES: DWORD = MEM_LARGE_PAGES | MEM_PHYSICAL;
+pub const SEC_64K_PAGES: DWORD = 0x00080000;
+pub const SEC_FILE: DWORD = 0x800000;
+pub const SEC_IMAGE: DWORD = 0x1000000;
+pub const SEC_PROTECTED_IMAGE: DWORD = 0x2000000;
+pub const SEC_RESERVE: DWORD = 0x4000000;
+pub const SEC_COMMIT: DWORD = 0x8000000;
+pub const SEC_NOCACHE: DWORD = 0x10000000;
+pub const SEC_WRITECOMBINE: DWORD = 0x40000000;
+pub const SEC_LARGE_PAGES: DWORD = 0x80000000;
+pub const SEC_IMAGE_NO_EXECUTE: DWORD = SEC_IMAGE | SEC_NOCACHE;
+pub const MEM_IMAGE: DWORD = SEC_IMAGE;
+pub const WRITE_WATCH_FLAG_RESET: DWORD = 0x01;
+pub const MEM_UNMAP_WITH_TRANSIENT_BOOST: DWORD = 0x01;
+pub const ENCLAVE_TYPE_SGX: DWORD = 0x00000001;
+pub const ENCLAVE_TYPE_SGX2: DWORD = 0x00000002;
+STRUCT!{struct ENCLAVE_CREATE_INFO_SGX {
+    Secs: [BYTE; 4096],
+}}
+pub type PENCLAVE_CREATE_INFO_SGX = *mut ENCLAVE_CREATE_INFO_SGX;
+STRUCT!{struct ENCLAVE_INIT_INFO_SGX {
+    SigStruct: [BYTE; 1808],
+    Reserved1: [BYTE; 240],
+    EInitToken: [BYTE; 304],
+    Reserved2: [BYTE; 1744],
+}}
+pub type PENCLAVE_INIT_INFO_SGX = *mut ENCLAVE_INIT_INFO_SGX;
+pub const FILE_READ_DATA: DWORD = 0x0001;
+pub const FILE_LIST_DIRECTORY: DWORD = 0x0001;
+pub const FILE_WRITE_DATA: DWORD = 0x0002;
+pub const FILE_ADD_FILE: DWORD = 0x0002;
+pub const FILE_APPEND_DATA: DWORD = 0x0004;
+pub const FILE_ADD_SUBDIRECTORY: DWORD = 0x0004;
+pub const FILE_CREATE_PIPE_INSTANCE: DWORD = 0x0004;
+pub const FILE_READ_EA: DWORD = 0x0008;
+pub const FILE_WRITE_EA: DWORD = 0x0010;
+pub const FILE_EXECUTE: DWORD = 0x0020;
+pub const FILE_TRAVERSE: DWORD = 0x0020;
+pub const FILE_DELETE_CHILD: DWORD = 0x0040;
+pub const FILE_READ_ATTRIBUTES: DWORD = 0x0080;
+pub const FILE_WRITE_ATTRIBUTES: DWORD = 0x0100;
+pub const FILE_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF;
+pub const FILE_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ | FILE_READ_DATA
+    | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE;
+pub const FILE_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA
+    | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE;
+pub const FILE_GENERIC_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES
+    | FILE_EXECUTE | SYNCHRONIZE;
+pub const FILE_SHARE_READ: DWORD = 0x00000001;
+pub const FILE_SHARE_WRITE: DWORD = 0x00000002;
+pub const FILE_SHARE_DELETE: DWORD = 0x00000004;
+pub const FILE_ATTRIBUTE_READONLY: DWORD = 0x00000001;
+pub const FILE_ATTRIBUTE_HIDDEN: DWORD = 0x00000002;
+pub const FILE_ATTRIBUTE_SYSTEM: DWORD = 0x00000004;
+pub const FILE_ATTRIBUTE_DIRECTORY: DWORD = 0x00000010;
+pub const FILE_ATTRIBUTE_ARCHIVE: DWORD = 0x00000020;
+pub const FILE_ATTRIBUTE_DEVICE: DWORD = 0x00000040;
+pub const FILE_ATTRIBUTE_NORMAL: DWORD = 0x00000080;
+pub const FILE_ATTRIBUTE_TEMPORARY: DWORD = 0x00000100;
+pub const FILE_ATTRIBUTE_SPARSE_FILE: DWORD = 0x00000200;
+pub const FILE_ATTRIBUTE_REPARSE_POINT: DWORD = 0x00000400;
+pub const FILE_ATTRIBUTE_COMPRESSED: DWORD = 0x00000800;
+pub const FILE_ATTRIBUTE_OFFLINE: DWORD = 0x00001000;
+pub const FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: DWORD = 0x00002000;
+pub const FILE_ATTRIBUTE_ENCRYPTED: DWORD = 0x00004000;
+pub const FILE_ATTRIBUTE_INTEGRITY_STREAM: DWORD = 0x00008000;
+pub const FILE_ATTRIBUTE_VIRTUAL: DWORD = 0x00010000;
+pub const FILE_ATTRIBUTE_NO_SCRUB_DATA: DWORD = 0x00020000;
+pub const FILE_ATTRIBUTE_EA: DWORD = 0x00040000;
+pub const FILE_ATTRIBUTE_PINNED: DWORD = 0x00080000;
+pub const FILE_ATTRIBUTE_UNPINNED: DWORD = 0x00100000;
+pub const FILE_ATTRIBUTE_RECALL_ON_OPEN: DWORD = 0x00040000;
+pub const FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS: DWORD = 0x00400000;
+pub const FILE_NOTIFY_CHANGE_FILE_NAME: DWORD = 0x00000001;
+pub const FILE_NOTIFY_CHANGE_DIR_NAME: DWORD = 0x00000002;
+pub const FILE_NOTIFY_CHANGE_ATTRIBUTES: DWORD = 0x00000004;
+pub const FILE_NOTIFY_CHANGE_SIZE: DWORD = 0x00000008;
+pub const FILE_NOTIFY_CHANGE_LAST_WRITE: DWORD = 0x00000010;
+pub const FILE_NOTIFY_CHANGE_LAST_ACCESS: DWORD = 0x00000020;
+pub const FILE_NOTIFY_CHANGE_CREATION: DWORD = 0x00000040;
+pub const FILE_NOTIFY_CHANGE_SECURITY: DWORD = 0x00000100;
+pub const FILE_ACTION_ADDED: DWORD = 0x00000001;
+pub const FILE_ACTION_REMOVED: DWORD = 0x00000002;
+pub const FILE_ACTION_MODIFIED: DWORD = 0x00000003;
+pub const FILE_ACTION_RENAMED_OLD_NAME: DWORD = 0x00000004;
+pub const FILE_ACTION_RENAMED_NEW_NAME: DWORD = 0x00000005;
+pub const MAILSLOT_NO_MESSAGE: DWORD = 0xFFFFFFFF;
+pub const MAILSLOT_WAIT_FOREVER: DWORD = 0xFFFFFFFF;
+pub const FILE_CASE_SENSITIVE_SEARCH: DWORD = 0x00000001;
+pub const FILE_CASE_PRESERVED_NAMES: DWORD = 0x00000002;
+pub const FILE_UNICODE_ON_DISK: DWORD = 0x00000004;
+pub const FILE_PERSISTENT_ACLS: DWORD = 0x00000008;
+pub const FILE_FILE_COMPRESSION: DWORD = 0x00000010;
+pub const FILE_VOLUME_QUOTAS: DWORD = 0x00000020;
+pub const FILE_SUPPORTS_SPARSE_FILES: DWORD = 0x00000040;
+pub const FILE_SUPPORTS_REPARSE_POINTS: DWORD = 0x00000080;
+pub const FILE_SUPPORTS_REMOTE_STORAGE: DWORD = 0x00000100;
+pub const FILE_RETURNS_CLEANUP_RESULT_INFO: DWORD = 0x00000200;
+pub const FILE_VOLUME_IS_COMPRESSED: DWORD = 0x00008000;
+pub const FILE_SUPPORTS_OBJECT_IDS: DWORD = 0x00010000;
+pub const FILE_SUPPORTS_ENCRYPTION: DWORD = 0x00020000;
+pub const FILE_NAMED_STREAMS: DWORD = 0x00040000;
+pub const FILE_READ_ONLY_VOLUME: DWORD = 0x00080000;
+pub const FILE_SEQUENTIAL_WRITE_ONCE: DWORD = 0x00100000;
+pub const FILE_SUPPORTS_TRANSACTIONS: DWORD = 0x00200000;
+pub const FILE_SUPPORTS_HARD_LINKS: DWORD = 0x00400000;
+pub const FILE_SUPPORTS_EXTENDED_ATTRIBUTES: DWORD = 0x00800000;
+pub const FILE_SUPPORTS_OPEN_BY_FILE_ID: DWORD = 0x01000000;
+pub const FILE_SUPPORTS_USN_JOURNAL: DWORD = 0x02000000;
+pub const FILE_SUPPORTS_INTEGRITY_STREAMS: DWORD = 0x04000000;
+pub const FILE_SUPPORTS_BLOCK_REFCOUNTING: DWORD = 0x08000000;
+pub const FILE_SUPPORTS_SPARSE_VDL: DWORD = 0x10000000;
+pub const FILE_DAX_VOLUME: DWORD = 0x20000000;
+pub const FILE_SUPPORTS_GHOSTING: DWORD = 0x40000000;
+pub const FILE_INVALID_FILE_ID: LONGLONG = -1;
+STRUCT!{struct FILE_ID_128 {
+    Identifier: [BYTE; 16],
+}}
+pub type PFILE_ID_128 = *mut FILE_ID_128;
+STRUCT!{struct FILE_NOTIFY_INFORMATION {
+    NextEntryOffset: DWORD,
+    Action: DWORD,
+    FileNameLength: DWORD,
+    FileName: [WCHAR; 1],
+}}
+UNION!{union FILE_SEGMENT_ELEMENT {
+    [u64; 1],
+    Buffer Buffer_mut: PVOID64,
+    Alignment Alignment_mut: ULONGLONG,
+}}
+pub type PFILE_SEGMENT_ELEMENT = *mut FILE_SEGMENT_ELEMENT;
+pub const FLUSH_FLAGS_FILE_DATA_ONLY: ULONG = 0x00000001;
+pub const FLUSH_FLAGS_NO_SYNC: ULONG = 0x00000002;
+pub const FLUSH_FLAGS_FILE_DATA_SYNC_ONLY: ULONG = 0x00000004;
+STRUCT!{struct REPARSE_GUID_DATA_BUFFER_GenericReparseBuffer {
+    DataBuffer: [BYTE; 1],
+}}
+STRUCT!{struct REPARSE_GUID_DATA_BUFFER {
+    ReparseTag: DWORD,
+    ReparseDataLength: WORD,
+    Reserved: WORD,
+    ReparseGuid: GUID,
+    GenericReparseBuffer: REPARSE_GUID_DATA_BUFFER_GenericReparseBuffer,
+}}
+pub type PREPARSE_GUID_DATA_BUFFER = *mut REPARSE_GUID_DATA_BUFFER;
+pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: DWORD = 16 * 1024;
+pub const IO_REPARSE_TAG_RESERVED_ZERO: DWORD = 0;
+pub const IO_REPARSE_TAG_RESERVED_ONE: DWORD = 1;
+pub const IO_REPARSE_TAG_RESERVED_TWO: DWORD = 2;
+pub const IO_REPARSE_TAG_RESERVED_RANGE: DWORD = IO_REPARSE_TAG_RESERVED_TWO;
+#[inline]
+pub fn IsReparseTagMicrosoft(_tag: DWORD) -> bool {
+    (_tag & 0x80000000) != 0
+}
+#[inline]
+pub fn IsReparseTagNameSurrogate(_tag: DWORD) -> bool {
+    (_tag & 0x20000000) != 0
+}
+#[inline]
+pub fn IsReparseTagDirectory(_tag: DWORD) -> bool {
+    (_tag & 0x10000000) != 0
+}
+pub const IO_REPARSE_TAG_MOUNT_POINT: DWORD = 0xA0000003;
+pub const IO_REPARSE_TAG_HSM: DWORD = 0xC0000004;
+pub const IO_REPARSE_TAG_HSM2: DWORD = 0x80000006;
+pub const IO_REPARSE_TAG_SIS: DWORD = 0x80000007;
+pub const IO_REPARSE_TAG_WIM: DWORD = 0x80000008;
+pub const IO_REPARSE_TAG_CSV: DWORD = 0x80000009;
+pub const IO_REPARSE_TAG_DFS: DWORD = 0x8000000A;
+pub const IO_REPARSE_TAG_SYMLINK: DWORD = 0xA000000C;
+pub const IO_REPARSE_TAG_DFSR: DWORD = 0x80000012;
+pub const IO_REPARSE_TAG_DEDUP: DWORD = 0x80000013;
+pub const IO_REPARSE_TAG_NFS: DWORD = 0x80000014;
+pub const IO_REPARSE_TAG_FILE_PLACEHOLDER: DWORD = 0x80000015;
+pub const IO_REPARSE_TAG_WOF: DWORD = 0x80000017;
+pub const IO_REPARSE_TAG_WCI: DWORD = 0x80000018;
+pub const IO_REPARSE_TAG_GLOBAL_REPARSE: DWORD = 0xA0000019;
+pub const IO_REPARSE_TAG_CLOUD: DWORD = 0x9000001A;
+pub const IO_REPARSE_TAG_CLOUD_ROOT: DWORD = 0x9000101A;
+pub const IO_REPARSE_TAG_CLOUD_ON_DEMAND: DWORD = 0x9000201A;
+pub const IO_REPARSE_TAG_CLOUD_ROOT_ON_DEMAND: DWORD = 0x9000301A;
+pub const IO_REPARSE_TAG_APPEXECLINK: DWORD = 0x8000001B;
+pub const IO_REPARSE_TAG_GVFS: DWORD = 0x9000001C;
+pub const IO_REPARSE_TAG_WCI_TOMBSTONE: DWORD = 0xA000001F;
+pub const IO_REPARSE_TAG_UNHANDLED: DWORD = 0x80000020;
+pub const IO_REPARSE_TAG_ONEDRIVE: DWORD = 0x80000021;
+pub const IO_REPARSE_TAG_GVFS_TOMBSTONE: DWORD = 0xA0000022;
+pub const SCRUB_DATA_INPUT_FLAG_RESUME: DWORD = 0x00000001;
+pub const SCRUB_DATA_INPUT_FLAG_SKIP_IN_SYNC: DWORD = 0x00000002;
+pub const SCRUB_DATA_INPUT_FLAG_SKIP_NON_INTEGRITY_DATA: DWORD = 0x00000004;
+pub const SCRUB_DATA_OUTPUT_FLAG_INCOMPLETE: DWORD = 0x00000001;
+pub const SCRUB_DATA_OUTPUT_FLAG_NON_USER_DATA_RANGE: DWORD = 0x00010000;
+pub const SCRUB_DATA_OUTPUT_FLAG_PARITY_EXTENT_DATA_RETURNED: DWORD = 0x00020000;
+pub const SCRUB_DATA_OUTPUT_FLAG_RESUME_CONTEXT_LENGTH_SPECIFIED: DWORD = 0x00040000;
+STRUCT!{struct SCRUB_DATA_INPUT {
+    Size: DWORD,
+    Flags: DWORD,
+    MaximumIos: DWORD,
+    Reserved: [DWORD; 17],
+    ResumeContext: [BYTE; 816],
+}}
+pub type PSCRUB_DATA_INPUT = *mut SCRUB_DATA_INPUT;
+STRUCT!{struct SCRUB_PARITY_EXTENT {
+    Offset: LONGLONG,
+    Length: ULONGLONG,
+}}
+pub type PSCRUB_PARITY_EXTENT = *mut SCRUB_PARITY_EXTENT;
+STRUCT!{struct SCRUB_PARITY_EXTENT_DATA {
+    Size: WORD,
+    Flags: WORD,
+    NumberOfParityExtents: WORD,
+    MaximumNumberOfParityExtents: WORD,
+    ParityExtents: [SCRUB_PARITY_EXTENT; ANYSIZE_ARRAY],
+}}
+pub type PSCRUB_PARITY_EXTENT_DATA = *mut SCRUB_PARITY_EXTENT_DATA;
+STRUCT!{struct SCRUB_DATA_OUTPUT {
+    Size: DWORD,
+    Flags: DWORD,
+    Status: DWORD,
+    ErrorFileOffset: ULONGLONG,
+    ErrorLength: ULONGLONG,
+    NumberOfBytesRepaired: ULONGLONG,
+    NumberOfBytesFailed: ULONGLONG,
+    InternalFileReference: ULONGLONG,
+    ResumeContextLength: WORD,
+    ParityExtentDataOffset: WORD,
+    Reserved: [DWORD; 5],
+    ResumeContext: [BYTE; 816],
+}}
+pub type PSCRUB_DATA_OUTPUT = *mut SCRUB_DATA_OUTPUT;
+ENUM!{enum SharedVirtualDiskSupportType {
+    SharedVirtualDisksUnsupported = 0,
+    SharedVirtualDisksSupported = 1,
+    SharedVirtualDiskSnapshotsSupported = 3,
+    SharedVirtualDiskCDPSnapshotsSupported = 7,
+}}
+ENUM!{enum SharedVirtualDiskHandleState {
+    SharedVirtualDiskHandleStateNone = 0,
+    SharedVirtualDiskHandleStateFileShared = 1,
+    SharedVirtualDiskHandleStateHandleShared = 3,
+}}
+STRUCT!{struct SHARED_VIRTUAL_DISK_SUPPORT {
+    SharedVirtualDiskSupport: SharedVirtualDiskSupportType,
+    HandleState: SharedVirtualDiskHandleState,
+}}
+pub type PSHARED_VIRTUAL_DISK_SUPPORT = *mut SHARED_VIRTUAL_DISK_SUPPORT;
+#[inline]
+pub fn IsVirtualDiskFileShared(HandleState: SharedVirtualDiskHandleState) -> bool {
+    (HandleState & SharedVirtualDiskHandleStateFileShared) != 0
+}
+pub const IO_COMPLETION_MODIFY_STATE: DWORD = 0x0002;
+pub const IO_COMPLETION_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3;
+pub const IO_QOS_MAX_RESERVATION: DWORD64 = 1000000000;
+pub const SMB_CCF_APP_INSTANCE_EA_NAME: &'static str = "ClusteredApplicationInstance";
+pub const NETWORK_APP_INSTANCE_CSV_FLAGS_VALID_ONLY_IF_CSV_COORDINATOR: DWORD = 0x00000001;
+STRUCT!{struct NETWORK_APP_INSTANCE_EA {
+    AppInstanceID: GUID,
+    CsvFlags: DWORD,
+}}
+pub type PNETWORK_APP_INSTANCE_EA = *mut NETWORK_APP_INSTANCE_EA;
+pub const DUPLICATE_CLOSE_SOURCE: DWORD = 0x00000001;
+pub const DUPLICATE_SAME_ACCESS: DWORD = 0x00000002;
+DEFINE_GUID!{GUID_MAX_POWER_SAVINGS,
+    0xa1841308, 0x3541, 0x4fab, 0xbc, 0x81, 0xf7, 0x15, 0x56, 0xf2, 0x0b, 0x4a}
+DEFINE_GUID!{GUID_MIN_POWER_SAVINGS,
+    0x8c5e7fda, 0xe8bf, 0x4a96, 0x9a, 0x85, 0xa6, 0xe2, 0x3a, 0x8c, 0x63, 0x5c}
+DEFINE_GUID!{GUID_TYPICAL_POWER_SAVINGS,
+    0x381b4222, 0xf694, 0x41f0, 0x96, 0x85, 0xff, 0x5b, 0xb2, 0x60, 0xdf, 0x2e}
+DEFINE_GUID!{NO_SUBGROUP_GUID,
+    0xfea3413e, 0x7e05, 0x4911, 0x9a, 0x71, 0x70, 0x03, 0x31, 0xf1, 0xc2, 0x94}
+DEFINE_GUID!{ALL_POWERSCHEMES_GUID,
+    0x68a1e95e, 0x13ea, 0x41e1, 0x80, 0x11, 0x0c, 0x49, 0x6c, 0xa4, 0x90, 0xb0}
+DEFINE_GUID!{GUID_POWERSCHEME_PERSONALITY,
+    0x245d8541, 0x3943, 0x4422, 0xb0, 0x25, 0x13, 0xa7, 0x84, 0xf6, 0x79, 0xb7}
+DEFINE_GUID!{GUID_ACTIVE_POWERSCHEME,
+    0x31f9f286, 0x5084, 0x42fe, 0xb7, 0x20, 0x2b, 0x02, 0x64, 0x99, 0x37, 0x63}
+DEFINE_GUID!{GUID_IDLE_RESILIENCY_SUBGROUP,
+    0x2e601130, 0x5351, 0x4d9d, 0x8e, 0x4, 0x25, 0x29, 0x66, 0xba, 0xd0, 0x54}
+DEFINE_GUID!{GUID_IDLE_RESILIENCY_PERIOD,
+    0xc42b79aa, 0xaa3a, 0x484b, 0xa9, 0x8f, 0x2c, 0xf3, 0x2a, 0xa9, 0xa, 0x28}
+DEFINE_GUID!{GUID_DEEP_SLEEP_ENABLED,
+    0xd502f7ee, 0x1dc7, 0x4efd, 0xa5, 0x5d, 0xf0, 0x4b, 0x6f, 0x5c, 0x5, 0x45}
+DEFINE_GUID!{GUID_DEEP_SLEEP_PLATFORM_STATE,
+    0xd23f2fb8, 0x9536, 0x4038, 0x9c, 0x94, 0x1c, 0xe0, 0x2e, 0x5c, 0x21, 0x52}
+DEFINE_GUID!{GUID_DISK_COALESCING_POWERDOWN_TIMEOUT,
+    0xc36f0eb4, 0x2988, 0x4a70, 0x8e, 0xee, 0x8, 0x84, 0xfc, 0x2c, 0x24, 0x33}
+DEFINE_GUID!{GUID_EXECUTION_REQUIRED_REQUEST_TIMEOUT,
+    0x3166bc41, 0x7e98, 0x4e03, 0xb3, 0x4e, 0xec, 0xf, 0x5f, 0x2b, 0x21, 0x8e}
+DEFINE_GUID!{GUID_VIDEO_SUBGROUP,
+    0x7516b95f, 0xf776, 0x4464, 0x8c, 0x53, 0x06, 0x16, 0x7f, 0x40, 0xcc, 0x99}
+DEFINE_GUID!{GUID_VIDEO_POWERDOWN_TIMEOUT,
+    0x3c0bc021, 0xc8a8, 0x4e07, 0xa9, 0x73, 0x6b, 0x14, 0xcb, 0xcb, 0x2b, 0x7e}
+DEFINE_GUID!{GUID_VIDEO_ANNOYANCE_TIMEOUT,
+    0x82dbcf2d, 0xcd67, 0x40c5, 0xbf, 0xdc, 0x9f, 0x1a, 0x5c, 0xcd, 0x46, 0x63}
+DEFINE_GUID!{GUID_VIDEO_ADAPTIVE_PERCENT_INCREASE,
+    0xeed904df, 0xb142, 0x4183, 0xb1, 0x0b, 0x5a, 0x11, 0x97, 0xa3, 0x78, 0x64}
+DEFINE_GUID!{GUID_VIDEO_DIM_TIMEOUT,
+    0x17aaa29b, 0x8b43, 0x4b94, 0xaa, 0xfe, 0x35, 0xf6, 0x4d, 0xaa, 0xf1, 0xee}
+DEFINE_GUID!{GUID_VIDEO_ADAPTIVE_POWERDOWN,
+    0x90959d22, 0xd6a1, 0x49b9, 0xaf, 0x93, 0xbc, 0xe8, 0x85, 0xad, 0x33, 0x5b}
+DEFINE_GUID!{GUID_MONITOR_POWER_ON,
+    0x02731015, 0x4510, 0x4526, 0x99, 0xe6, 0xe5, 0xa1, 0x7e, 0xbd, 0x1a, 0xea}
+DEFINE_GUID!{GUID_DEVICE_POWER_POLICY_VIDEO_BRIGHTNESS,
+    0xaded5e82, 0xb909, 0x4619, 0x99, 0x49, 0xf5, 0xd7, 0x1d, 0xac, 0x0b, 0xcb}
+DEFINE_GUID!{GUID_DEVICE_POWER_POLICY_VIDEO_DIM_BRIGHTNESS,
+    0xf1fbfde2, 0xa960, 0x4165, 0x9f, 0x88, 0x50, 0x66, 0x79, 0x11, 0xce, 0x96}
+DEFINE_GUID!{GUID_VIDEO_CURRENT_MONITOR_BRIGHTNESS,
+    0x8ffee2c6, 0x2d01, 0x46be, 0xad, 0xb9, 0x39, 0x8a, 0xdd, 0xc5, 0xb4, 0xff}
+DEFINE_GUID!{GUID_VIDEO_ADAPTIVE_DISPLAY_BRIGHTNESS,
+    0xfbd9aa66, 0x9553, 0x4097, 0xba, 0x44, 0xed, 0x6e, 0x9d, 0x65, 0xea, 0xb8}
+DEFINE_GUID!{GUID_CONSOLE_DISPLAY_STATE,
+    0x6fe69556, 0x704a, 0x47a0, 0x8f, 0x24, 0xc2, 0x8d, 0x93, 0x6f, 0xda, 0x47}
+DEFINE_GUID!{GUID_ALLOW_DISPLAY_REQUIRED,
+    0xa9ceb8da, 0xcd46, 0x44fb, 0xa9, 0x8b, 0x02, 0xaf, 0x69, 0xde, 0x46, 0x23}
+DEFINE_GUID!{GUID_VIDEO_CONSOLE_LOCK_TIMEOUT,
+    0x8ec4b3a5, 0x6868, 0x48c2, 0xbe, 0x75, 0x4f, 0x30, 0x44, 0xbe, 0x88, 0xa7}
+DEFINE_GUID!{GUID_ADAPTIVE_POWER_BEHAVIOR_SUBGROUP,
+    0x8619b916, 0xe004, 0x4dd8, 0x9b, 0x66, 0xda, 0xe8, 0x6f, 0x80, 0x66, 0x98}
+DEFINE_GUID!{GUID_NON_ADAPTIVE_INPUT_TIMEOUT,
+    0x5adbbfbc, 0x74e, 0x4da1, 0xba, 0x38, 0xdb, 0x8b, 0x36, 0xb2, 0xc8, 0xf3}
+DEFINE_GUID!{GUID_ADAPTIVE_INPUT_CONTROLLER_STATE,
+    0xe98fae9, 0xf45a, 0x4de1, 0xa7, 0x57, 0x60, 0x31, 0xf1, 0x97, 0xf6, 0xea}
+DEFINE_GUID!{GUID_DISK_SUBGROUP,
+    0x0012ee47, 0x9041, 0x4b5d, 0x9b, 0x77, 0x53, 0x5f, 0xba, 0x8b, 0x14, 0x42}
+DEFINE_GUID!{GUID_DISK_MAX_POWER,
+    0x51dea550, 0xbb38, 0x4bc4, 0x99, 0x1b, 0xea, 0xcf, 0x37, 0xbe, 0x5e, 0xc8}
+DEFINE_GUID!{GUID_DISK_POWERDOWN_TIMEOUT,
+    0x6738e2c4, 0xe8a5, 0x4a42, 0xb1, 0x6a, 0xe0, 0x40, 0xe7, 0x69, 0x75, 0x6e}
+DEFINE_GUID!{GUID_DISK_IDLE_TIMEOUT,
+    0x58e39ba8, 0xb8e6, 0x4ef6, 0x90, 0xd0, 0x89, 0xae, 0x32, 0xb2, 0x58, 0xd6}
+DEFINE_GUID!{GUID_DISK_BURST_IGNORE_THRESHOLD,
+    0x80e3c60e, 0xbb94, 0x4ad8, 0xbb, 0xe0, 0x0d, 0x31, 0x95, 0xef, 0xc6, 0x63}
+DEFINE_GUID!{GUID_DISK_ADAPTIVE_POWERDOWN,
+    0x396a32e1, 0x499a, 0x40b2, 0x91, 0x24, 0xa9, 0x6a, 0xfe, 0x70, 0x76, 0x67}
+DEFINE_GUID!{GUID_SLEEP_SUBGROUP,
+    0x238c9fa8, 0x0aad, 0x41ed, 0x83, 0xf4, 0x97, 0xbe, 0x24, 0x2c, 0x8f, 0x20}
+DEFINE_GUID!{GUID_SLEEP_IDLE_THRESHOLD,
+    0x81cd32e0, 0x7833, 0x44f3, 0x87, 0x37, 0x70, 0x81, 0xf3, 0x8d, 0x1f, 0x70}
+DEFINE_GUID!{GUID_STANDBY_TIMEOUT,
+    0x29f6c1db, 0x86da, 0x48c5, 0x9f, 0xdb, 0xf2, 0xb6, 0x7b, 0x1f, 0x44, 0xda}
+DEFINE_GUID!{GUID_UNATTEND_SLEEP_TIMEOUT,
+    0x7bc4a2f9, 0xd8fc, 0x4469, 0xb0, 0x7b, 0x33, 0xeb, 0x78, 0x5a, 0xac, 0xa0}
+DEFINE_GUID!{GUID_HIBERNATE_TIMEOUT,
+    0x9d7815a6, 0x7ee4, 0x497e, 0x88, 0x88, 0x51, 0x5a, 0x05, 0xf0, 0x23, 0x64}
+DEFINE_GUID!{GUID_HIBERNATE_FASTS4_POLICY,
+    0x94ac6d29, 0x73ce, 0x41a6, 0x80, 0x9f, 0x63, 0x63, 0xba, 0x21, 0xb4, 0x7e}
+DEFINE_GUID!{GUID_CRITICAL_POWER_TRANSITION,
+    0xb7a27025, 0xe569, 0x46c2, 0xa5, 0x04, 0x2b, 0x96, 0xca, 0xd2, 0x25, 0xa1}
+DEFINE_GUID!{GUID_SYSTEM_AWAYMODE,
+    0x98a7f580, 0x01f7, 0x48aa, 0x9c, 0x0f, 0x44, 0x35, 0x2c, 0x29, 0xe5, 0xc0}
+DEFINE_GUID!{GUID_ALLOW_AWAYMODE,
+    0x25dfa149, 0x5dd1, 0x4736, 0xb5, 0xab, 0xe8, 0xa3, 0x7b, 0x5b, 0x81, 0x87}
+DEFINE_GUID!{GUID_USER_PRESENCE_PREDICTION,
+    0x82011705, 0xfb95, 0x4d46, 0x8d, 0x35, 0x40, 0x42, 0xb1, 0xd2, 0xd, 0xef}
+DEFINE_GUID!{GUID_STANDBY_BUDGET_GRACE_PERIOD,
+    0x60c07fe1, 0x0556, 0x45cf, 0x99, 0x03, 0xd5, 0x6e, 0x32, 0x21, 0x2, 0x42}
+DEFINE_GUID!{GUID_STANDBY_BUDGET_PERCENT,
+    0x9fe527be, 0x1b70, 0x48da, 0x93, 0x0d, 0x7b, 0xcf, 0x17, 0xb4, 0x49, 0x90}
+DEFINE_GUID!{GUID_STANDBY_RESERVE_GRACE_PERIOD,
+    0xc763ee92, 0x71e8, 0x4127, 0x84, 0xeb, 0xf6, 0xed, 0x04, 0x3a, 0x3e, 0x3d}
+DEFINE_GUID!{GUID_STANDBY_RESERVE_TIME,
+    0x468fe7e5, 0x1158, 0x46ec, 0x88, 0xbc, 0x5b, 0x96, 0xc9, 0xe4, 0x4f, 0xd0}
+DEFINE_GUID!{GUID_STANDBY_RESET_PERCENT,
+    0x49cb11a5, 0x56e2, 0x4afb, 0x9d, 0x38, 0x3d, 0xf4, 0x78, 0x72, 0xe2, 0x1b}
+DEFINE_GUID!{GUID_ALLOW_STANDBY_STATES,
+    0xabfc2519, 0x3608, 0x4c2a, 0x94, 0xea, 0x17, 0x1b, 0x0e, 0xd5, 0x46, 0xab}
+DEFINE_GUID!{GUID_ALLOW_RTC_WAKE,
+    0xbd3b718a, 0x0680, 0x4d9d, 0x8a, 0xb2, 0xe1, 0xd2, 0xb4, 0xac, 0x80, 0x6d}
+DEFINE_GUID!{GUID_ALLOW_SYSTEM_REQUIRED,
+    0xa4b195f5, 0x8225, 0x47d8, 0x80, 0x12, 0x9d, 0x41, 0x36, 0x97, 0x86, 0xe2}
+DEFINE_GUID!{GUID_POWER_SAVING_STATUS,
+    0xe00958c0, 0xc213, 0x4ace, 0xac, 0x77, 0xfe, 0xcc, 0xed, 0x2e, 0xee, 0xa5}
+DEFINE_GUID!{GUID_ENERGY_SAVER_SUBGROUP,
+    0xde830923, 0xa562, 0x41af, 0xa0, 0x86, 0xe3, 0xa2, 0xc6, 0xba, 0xd2, 0xda}
+DEFINE_GUID!{GUID_ENERGY_SAVER_BATTERY_THRESHOLD,
+    0xe69653ca, 0xcf7f, 0x4f05, 0xaa, 0x73, 0xcb, 0x83, 0x3f, 0xa9, 0x0a, 0xd4}
+DEFINE_GUID!{GUID_ENERGY_SAVER_BRIGHTNESS,
+    0x13d09884, 0xf74e, 0x474a, 0xa8, 0x52, 0xb6, 0xbd, 0xe8, 0xad, 0x03, 0xa8}
+DEFINE_GUID!{GUID_ENERGY_SAVER_POLICY,
+    0x5c5bb349, 0xad29, 0x4ee2, 0x9d, 0xb, 0x2b, 0x25, 0x27, 0xf, 0x7a, 0x81}
+DEFINE_GUID!{GUID_SYSTEM_BUTTON_SUBGROUP,
+    0x4f971e89, 0xeebd, 0x4455, 0xa8, 0xde, 0x9e, 0x59, 0x04, 0x0e, 0x73, 0x47}
+pub const POWERBUTTON_ACTION_INDEX_NOTHING: DWORD = 0;
+pub const POWERBUTTON_ACTION_INDEX_SLEEP: DWORD = 1;
+pub const POWERBUTTON_ACTION_INDEX_HIBERNATE: DWORD = 2;
+pub const POWERBUTTON_ACTION_INDEX_SHUTDOWN: DWORD = 3;
+pub const POWERBUTTON_ACTION_INDEX_TURN_OFF_THE_DISPLAY: DWORD = 4;
+pub const POWERBUTTON_ACTION_VALUE_NOTHING: DWORD = 0;
+pub const POWERBUTTON_ACTION_VALUE_SLEEP: DWORD = 2;
+pub const POWERBUTTON_ACTION_VALUE_HIBERNATE: DWORD = 3;
+pub const POWERBUTTON_ACTION_VALUE_SHUTDOWN: DWORD = 6;
+pub const POWERBUTTON_ACTION_VALUE_TURN_OFF_THE_DISPLAY: DWORD = 8;
+DEFINE_GUID!{GUID_POWERBUTTON_ACTION,
+    0x7648efa3, 0xdd9c, 0x4e3e, 0xb5, 0x66, 0x50, 0xf9, 0x29, 0x38, 0x62, 0x80}
+DEFINE_GUID!{GUID_SLEEPBUTTON_ACTION,
+    0x96996bc0, 0xad50, 0x47ec, 0x92, 0x3b, 0x6f, 0x41, 0x87, 0x4d, 0xd9, 0xeb}
+DEFINE_GUID!{GUID_USERINTERFACEBUTTON_ACTION,
+    0xa7066653, 0x8d6c, 0x40a8, 0x91, 0x0e, 0xa1, 0xf5, 0x4b, 0x84, 0xc7, 0xe5}
+DEFINE_GUID!{GUID_LIDCLOSE_ACTION,
+    0x5ca83367, 0x6e45, 0x459f, 0xa2, 0x7b, 0x47, 0x6b, 0x1d, 0x01, 0xc9, 0x36}
+DEFINE_GUID!{GUID_LIDOPEN_POWERSTATE,
+    0x99ff10e7, 0x23b1, 0x4c07, 0xa9, 0xd1, 0x5c, 0x32, 0x06, 0xd7, 0x41, 0xb4}
+DEFINE_GUID!{GUID_BATTERY_SUBGROUP,
+    0xe73a048d, 0xbf27, 0x4f12, 0x97, 0x31, 0x8b, 0x20, 0x76, 0xe8, 0x89, 0x1f}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_ACTION_0,
+    0x637ea02f, 0xbbcb, 0x4015, 0x8e, 0x2c, 0xa1, 0xc7, 0xb9, 0xc0, 0xb5, 0x46}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_LEVEL_0,
+    0x9a66d8d7, 0x4ff7, 0x4ef9, 0xb5, 0xa2, 0x5a, 0x32, 0x6c, 0xa2, 0xa4, 0x69}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_FLAGS_0,
+    0x5dbb7c9f, 0x38e9, 0x40d2, 0x97, 0x49, 0x4f, 0x8a, 0x0e, 0x9f, 0x64, 0x0f}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_ACTION_1,
+    0xd8742dcb, 0x3e6a, 0x4b3c, 0xb3, 0xfe, 0x37, 0x46, 0x23, 0xcd, 0xcf, 0x06}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_LEVEL_1,
+    0x8183ba9a, 0xe910, 0x48da, 0x87, 0x69, 0x14, 0xae, 0x6d, 0xc1, 0x17, 0x0a}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_FLAGS_1,
+    0xbcded951, 0x187b, 0x4d05, 0xbc, 0xcc, 0xf7, 0xe5, 0x19, 0x60, 0xc2, 0x58}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_ACTION_2,
+    0x421cba38, 0x1a8e, 0x4881, 0xac, 0x89, 0xe3, 0x3a, 0x8b, 0x04, 0xec, 0xe4}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_LEVEL_2,
+    0x07a07ca2, 0xadaf, 0x40d7, 0xb0, 0x77, 0x53, 0x3a, 0xad, 0xed, 0x1b, 0xfa}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_FLAGS_2,
+    0x7fd2f0c4, 0xfeb7, 0x4da3, 0x81, 0x17, 0xe3, 0xfb, 0xed, 0xc4, 0x65, 0x82}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_ACTION_3,
+    0x80472613, 0x9780, 0x455e, 0xb3, 0x08, 0x72, 0xd3, 0x00, 0x3c, 0xf2, 0xf8}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_LEVEL_3,
+    0x58afd5a6, 0xc2dd, 0x47d2, 0x9f, 0xbf, 0xef, 0x70, 0xcc, 0x5c, 0x59, 0x65}
+DEFINE_GUID!{GUID_BATTERY_DISCHARGE_FLAGS_3,
+    0x73613ccf, 0xdbfa, 0x4279, 0x83, 0x56, 0x49, 0x35, 0xf6, 0xbf, 0x62, 0xf3}
+DEFINE_GUID!{GUID_PROCESSOR_SETTINGS_SUBGROUP,
+    0x54533251, 0x82be, 0x4824, 0x96, 0xc1, 0x47, 0xb6, 0x0b, 0x74, 0x0d, 0x00}
+DEFINE_GUID!{GUID_PROCESSOR_THROTTLE_POLICY,
+    0x57027304, 0x4af6, 0x4104, 0x92, 0x60, 0xe3, 0xd9, 0x52, 0x48, 0xfc, 0x36}
+pub const PERFSTATE_POLICY_CHANGE_IDEAL: DWORD = 0;
+pub const PERFSTATE_POLICY_CHANGE_SINGLE: DWORD = 1;
+pub const PERFSTATE_POLICY_CHANGE_ROCKET: DWORD = 2;
+pub const PERFSTATE_POLICY_CHANGE_IDEAL_AGGRESSIVE: DWORD = 3;
+pub const PERFSTATE_POLICY_CHANGE_DECREASE_MAX: DWORD = PERFSTATE_POLICY_CHANGE_ROCKET;
+pub const PERFSTATE_POLICY_CHANGE_INCREASE_MAX: DWORD = PERFSTATE_POLICY_CHANGE_IDEAL_AGGRESSIVE;
+DEFINE_GUID!{GUID_PROCESSOR_THROTTLE_MAXIMUM,
+    0xbc5038f7, 0x23e0, 0x4960, 0x96, 0xda, 0x33, 0xab, 0xaf, 0x59, 0x35, 0xec}
+DEFINE_GUID!{GUID_PROCESSOR_THROTTLE_MAXIMUM_1,
+    0xbc5038f7, 0x23e0, 0x4960, 0x96, 0xda, 0x33, 0xab, 0xaf, 0x59, 0x35, 0xed}
+DEFINE_GUID!{GUID_PROCESSOR_THROTTLE_MINIMUM,
+    0x893dee8e, 0x2bef, 0x41e0, 0x89, 0xc6, 0xb5, 0x5d, 0x09, 0x29, 0x96, 0x4c}
+DEFINE_GUID!{GUID_PROCESSOR_THROTTLE_MINIMUM_1,
+    0x893dee8e, 0x2bef, 0x41e0, 0x89, 0xc6, 0xb5, 0x5d, 0x09, 0x29, 0x96, 0x4d}
+DEFINE_GUID!{GUID_PROCESSOR_FREQUENCY_LIMIT,
+    0x75b0ae3f, 0xbce0, 0x45a7, 0x8c, 0x89, 0xc9, 0x61, 0x1c, 0x25, 0xe1, 0x00}
+DEFINE_GUID!{GUID_PROCESSOR_FREQUENCY_LIMIT_1,
+    0x75b0ae3f, 0xbce0, 0x45a7, 0x8c, 0x89, 0xc9, 0x61, 0x1c, 0x25, 0xe1, 0x01}
+DEFINE_GUID!{GUID_PROCESSOR_ALLOW_THROTTLING,
+    0x3b04d4fd, 0x1cc7, 0x4f23, 0xab, 0x1c, 0xd1, 0x33, 0x78, 0x19, 0xc4, 0xbb}
+pub const PROCESSOR_THROTTLE_DISABLED: DWORD = 0;
+pub const PROCESSOR_THROTTLE_ENABLED: DWORD = 1;
+pub const PROCESSOR_THROTTLE_AUTOMATIC: DWORD = 2;
+DEFINE_GUID!{GUID_PROCESSOR_IDLESTATE_POLICY,
+    0x68f262a7, 0xf621, 0x4069, 0xb9, 0xa5, 0x48, 0x74, 0x16, 0x9b, 0xe2, 0x3c}
+DEFINE_GUID!{GUID_PROCESSOR_PERFSTATE_POLICY,
+    0xbbdc3814, 0x18e9, 0x4463, 0x8a, 0x55, 0xd1, 0x97, 0x32, 0x7c, 0x45, 0xc0}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_THRESHOLD,
+    0x06cadf0e, 0x64ed, 0x448a, 0x89, 0x27, 0xce, 0x7b, 0xf9, 0x0e, 0xb3, 0x5d}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_THRESHOLD_1,
+    0x06cadf0e, 0x64ed, 0x448a, 0x89, 0x27, 0xce, 0x7b, 0xf9, 0x0e, 0xb3, 0x5e}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_THRESHOLD,
+    0x12a0ab44, 0xfe28, 0x4fa9, 0xb3, 0xbd, 0x4b, 0x64, 0xf4, 0x49, 0x60, 0xa6}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_THRESHOLD_1,
+    0x12a0ab44, 0xfe28, 0x4fa9, 0xb3, 0xbd, 0x4b, 0x64, 0xf4, 0x49, 0x60, 0xa7}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_POLICY,
+    0x465e1f50, 0xb610, 0x473a, 0xab, 0x58, 0x0, 0xd1, 0x7, 0x7d, 0xc4, 0x18}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_POLICY_1,
+    0x465e1f50, 0xb610, 0x473a, 0xab, 0x58, 0x0, 0xd1, 0x7, 0x7d, 0xc4, 0x19}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_POLICY,
+    0x40fbefc7, 0x2e9d, 0x4d25, 0xa1, 0x85, 0xc, 0xfd, 0x85, 0x74, 0xba, 0xc6}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_POLICY_1,
+    0x40fbefc7, 0x2e9d, 0x4d25, 0xa1, 0x85, 0xc, 0xfd, 0x85, 0x74, 0xba, 0xc7}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_TIME,
+    0x984cf492, 0x3bed, 0x4488, 0xa8, 0xf9, 0x42, 0x86, 0xc9, 0x7b, 0xf5, 0xaa}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_TIME_1,
+    0x984cf492, 0x3bed, 0x4488, 0xa8, 0xf9, 0x42, 0x86, 0xc9, 0x7b, 0xf5, 0xab}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_TIME,
+    0xd8edeb9b, 0x95cf, 0x4f95, 0xa7, 0x3c, 0xb0, 0x61, 0x97, 0x36, 0x93, 0xc8}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_TIME_1,
+    0xd8edeb9b, 0x95cf, 0x4f95, 0xa7, 0x3c, 0xb0, 0x61, 0x97, 0x36, 0x93, 0xc9}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_TIME_CHECK,
+    0x4d2b0152, 0x7d5c, 0x498b, 0x88, 0xe2, 0x34, 0x34, 0x53, 0x92, 0xa2, 0xc5}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_BOOST_POLICY,
+    0x45bcc044, 0xd885, 0x43e2, 0x86, 0x5, 0xee, 0xe, 0xc6, 0xe9, 0x6b, 0x59}
+pub const PROCESSOR_PERF_BOOST_POLICY_DISABLED: DWORD = 0;
+pub const PROCESSOR_PERF_BOOST_POLICY_MAX: DWORD = 100;
+DEFINE_GUID!{GUID_PROCESSOR_PERF_BOOST_MODE,
+    0xbe337238, 0xd82, 0x4146, 0xa9, 0x60, 0x4f, 0x37, 0x49, 0xd4, 0x70, 0xc7}
+pub const PROCESSOR_PERF_BOOST_MODE_DISABLED: DWORD = 0;
+pub const PROCESSOR_PERF_BOOST_MODE_ENABLED: DWORD = 1;
+pub const PROCESSOR_PERF_BOOST_MODE_AGGRESSIVE: DWORD = 2;
+pub const PROCESSOR_PERF_BOOST_MODE_EFFICIENT_ENABLED: DWORD = 3;
+pub const PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE: DWORD = 4;
+pub const PROCESSOR_PERF_BOOST_MODE_AGGRESSIVE_AT_GUARANTEED: DWORD = 5;
+pub const PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE_AT_GUARANTEED: DWORD = 6;
+pub const PROCESSOR_PERF_BOOST_MODE_MAX: DWORD
+    = PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE_AT_GUARANTEED;
+DEFINE_GUID!{GUID_PROCESSOR_PERF_AUTONOMOUS_MODE,
+    0x8baa4a8a, 0x14c6, 0x4451, 0x8e, 0x8b, 0x14, 0xbd, 0xbd, 0x19, 0x75, 0x37}
+pub const PROCESSOR_PERF_AUTONOMOUS_MODE_DISABLED: DWORD = 0;
+pub const PROCESSOR_PERF_AUTONOMOUS_MODE_ENABLED: DWORD = 1;
+DEFINE_GUID!{GUID_PROCESSOR_PERF_ENERGY_PERFORMANCE_PREFERENCE,
+    0x36687f9e, 0xe3a5, 0x4dbf, 0xb1, 0xdc, 0x15, 0xeb, 0x38, 0x1c, 0x68, 0x63}
+pub const PROCESSOR_PERF_PERFORMANCE_PREFERENCE: DWORD = 0xff;
+pub const PROCESSOR_PERF_ENERGY_PREFERENCE: DWORD = 0;
+DEFINE_GUID!{GUID_PROCESSOR_PERF_AUTONOMOUS_ACTIVITY_WINDOW,
+    0xcfeda3d0, 0x7697, 0x4566, 0xa9, 0x22, 0xa9, 0x8, 0x6c, 0xd4, 0x9d, 0xfa}
+pub const PROCESSOR_PERF_MINIMUM_ACTIVITY_WINDOW: DWORD = 0;
+pub const PROCESSOR_PERF_MAXIMUM_ACTIVITY_WINDOW: DWORD = 1270000000;
+DEFINE_GUID!{GUID_PROCESSOR_DUTY_CYCLING,
+    0x4e4450b3, 0x6179, 0x4e91, 0xb8, 0xf1, 0x5b, 0xb9, 0x93, 0x8f, 0x81, 0xa1}
+pub const PROCESSOR_DUTY_CYCLING_DISABLED: DWORD = 0;
+pub const PROCESSOR_DUTY_CYCLING_ENABLED: DWORD = 1;
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_ALLOW_SCALING,
+    0x6c2993b0, 0x8f48, 0x481f, 0xbc, 0xc6, 0x0, 0xdd, 0x27, 0x42, 0xaa, 0x6}
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_DISABLE,
+    0x5d76a2ca, 0xe8c0, 0x402f, 0xa1, 0x33, 0x21, 0x58, 0x49, 0x2d, 0x58, 0xad}
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_STATE_MAXIMUM,
+    0x9943e905, 0x9a30, 0x4ec1, 0x9b, 0x99, 0x44, 0xdd, 0x3b, 0x76, 0xf7, 0xa2}
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_TIME_CHECK,
+    0xc4581c31, 0x89ab, 0x4597, 0x8e, 0x2b, 0x9c, 0x9c, 0xab, 0x44, 0xe, 0x6b}
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_DEMOTE_THRESHOLD,
+    0x4b92d758, 0x5a24, 0x4851, 0xa4, 0x70, 0x81, 0x5d, 0x78, 0xae, 0xe1, 0x19}
+DEFINE_GUID!{GUID_PROCESSOR_IDLE_PROMOTE_THRESHOLD,
+    0x7b224883, 0xb3cc, 0x4d79, 0x81, 0x9f, 0x83, 0x74, 0x15, 0x2c, 0xbe, 0x7c}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_INCREASE_THRESHOLD,
+    0xdf142941, 0x20f3, 0x4edf, 0x9a, 0x4a, 0x9c, 0x83, 0xd3, 0xd7, 0x17, 0xd1}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_DECREASE_THRESHOLD,
+    0x68dd2f27, 0xa4ce, 0x4e11, 0x84, 0x87, 0x37, 0x94, 0xe4, 0x13, 0x5d, 0xfa}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_INCREASE_POLICY,
+    0xc7be0679, 0x2817, 0x4d69, 0x9d, 0x02, 0x51, 0x9a, 0x53, 0x7e, 0xd0, 0xc6}
+pub const CORE_PARKING_POLICY_CHANGE_IDEAL: DWORD = 0;
+pub const CORE_PARKING_POLICY_CHANGE_SINGLE: DWORD = 1;
+pub const CORE_PARKING_POLICY_CHANGE_ROCKET: DWORD = 2;
+pub const CORE_PARKING_POLICY_CHANGE_MULTISTEP: DWORD = 3;
+pub const CORE_PARKING_POLICY_CHANGE_MAX: DWORD = CORE_PARKING_POLICY_CHANGE_MULTISTEP;
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_DECREASE_POLICY,
+    0x71021b41, 0xc749, 0x4d21, 0xbe, 0x74, 0xa0, 0x0f, 0x33, 0x5d, 0x58, 0x2b}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_MAX_CORES,
+    0xea062031, 0x0e34, 0x4ff1, 0x9b, 0x6d, 0xeb, 0x10, 0x59, 0x33, 0x40, 0x28}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_MAX_CORES_1,
+    0xea062031, 0x0e34, 0x4ff1, 0x9b, 0x6d, 0xeb, 0x10, 0x59, 0x33, 0x40, 0x29}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_MIN_CORES,
+    0x0cc5b647, 0xc1df, 0x4637, 0x89, 0x1a, 0xde, 0xc3, 0x5c, 0x31, 0x85, 0x83}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_MIN_CORES_1,
+    0x0cc5b647, 0xc1df, 0x4637, 0x89, 0x1a, 0xde, 0xc3, 0x5c, 0x31, 0x85, 0x84}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_INCREASE_TIME,
+    0x2ddd5a84, 0x5a71, 0x437e, 0x91, 0x2a, 0xdb, 0x0b, 0x8c, 0x78, 0x87, 0x32}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_DECREASE_TIME,
+    0xdfd10d17, 0xd5eb, 0x45dd, 0x87, 0x7a, 0x9a, 0x34, 0xdd, 0xd1, 0x5c, 0x82}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_DECREASE_FACTOR,
+    0x8f7b45e3, 0xc393, 0x480a, 0x87, 0x8c, 0xf6, 0x7a, 0xc3, 0xd0, 0x70, 0x82}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_THRESHOLD,
+    0x5b33697b, 0xe89d, 0x4d38, 0xaa, 0x46, 0x9e, 0x7d, 0xfb, 0x7c, 0xd2, 0xf9}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_AFFINITY_WEIGHTING,
+    0xe70867f1, 0xfa2f, 0x4f4e, 0xae, 0xa1, 0x4d, 0x8a, 0x0b, 0xa2, 0x3b, 0x20}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_DECREASE_FACTOR,
+    0x1299023c, 0xbc28, 0x4f0a, 0x81, 0xec, 0xd3, 0x29, 0x5a, 0x8d, 0x81, 0x5d}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_THRESHOLD,
+    0x9ac18e92, 0xaa3c, 0x4e27, 0xb3, 0x07, 0x01, 0xae, 0x37, 0x30, 0x71, 0x29}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_WEIGHTING,
+    0x8809c2d8, 0xb155, 0x42d4, 0xbc, 0xda, 0x0d, 0x34, 0x56, 0x51, 0xb1, 0xdb}
+DEFINE_GUID!{GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_THRESHOLD,
+    0x943c8cb6, 0x6f93, 0x4227, 0xad, 0x87, 0xe9, 0xa3, 0xfe, 0xec, 0x08, 0xd1}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_CORE_OVERRIDE,
+    0xa55612aa, 0xf624, 0x42c6, 0xa4, 0x43, 0x73, 0x97, 0xd0, 0x64, 0xc0, 0x4f}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_PERF_STATE,
+    0x447235c7, 0x6a8d, 0x4cc0, 0x8e, 0x24, 0x9e, 0xaf, 0x70, 0xb9, 0x6e, 0x2b}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_PERF_STATE_1,
+    0x447235c7, 0x6a8d, 0x4cc0, 0x8e, 0x24, 0x9e, 0xaf, 0x70, 0xb9, 0x6e, 0x2c}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_CONCURRENCY_THRESHOLD,
+    0x2430ab6f, 0xa520, 0x44a2, 0x96, 0x01, 0xf7, 0xf2, 0x3b, 0x51, 0x34, 0xb1}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_HEADROOM_THRESHOLD,
+    0xf735a673, 0x2066, 0x4f80, 0xa0, 0xc5, 0xdd, 0xee, 0x0c, 0xf1, 0xbf, 0x5d}
+DEFINE_GUID!{GUID_PROCESSOR_PARKING_DISTRIBUTION_THRESHOLD,
+    0x4bdaf4e9, 0xd103, 0x46d7, 0xa5, 0xf0, 0x62, 0x80, 0x12, 0x16, 0x16, 0xef}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_HISTORY,
+    0x7d24baa7, 0x0b84, 0x480f, 0x84, 0x0c, 0x1b, 0x07, 0x43, 0xc0, 0x0f, 0x5f}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_HISTORY_1,
+    0x7d24baa7, 0x0b84, 0x480f, 0x84, 0x0c, 0x1b, 0x07, 0x43, 0xc0, 0x0f, 0x60}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_INCREASE_HISTORY,
+    0x99b3ef01, 0x752f, 0x46a1, 0x80, 0xfb, 0x77, 0x30, 0x1, 0x1f, 0x23, 0x54}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_DECREASE_HISTORY,
+    0x300f6f8, 0xabd6, 0x45a9, 0xb7, 0x4f, 0x49, 0x8, 0x69, 0x1a, 0x40, 0xb5}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_CORE_PARKING_HISTORY,
+    0x77d7f282, 0x8f1a, 0x42cd, 0x85, 0x37, 0x45, 0x45, 0xa, 0x83, 0x9b, 0xe8}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_LATENCY_HINT,
+    0x0822df31, 0x9c83, 0x441c, 0xa0, 0x79, 0x0d, 0xe4, 0xcf, 0x00, 0x9c, 0x7b}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_LATENCY_HINT_PERF,
+    0x619b7505, 0x3b, 0x4e82, 0xb7, 0xa6, 0x4d, 0xd2, 0x9c, 0x30, 0x9, 0x71}
+DEFINE_GUID!{GUID_PROCESSOR_PERF_LATENCY_HINT_PERF_1,
+    0x619b7505, 0x3b, 0x4e82, 0xb7, 0xa6, 0x4d, 0xd2, 0x9c, 0x30, 0x9, 0x72}
+DEFINE_GUID!{GUID_PROCESSOR_LATENCY_HINT_MIN_UNPARK,
+    0x616cdaa5, 0x695e, 0x4545, 0x97, 0xad, 0x97, 0xdc, 0x2d, 0x1b, 0xdd, 0x88}
+DEFINE_GUID!{GUID_PROCESSOR_LATENCY_HINT_MIN_UNPARK_1,
+    0x616cdaa5, 0x695e, 0x4545, 0x97, 0xad, 0x97, 0xdc, 0x2d, 0x1b, 0xdd, 0x89}
+DEFINE_GUID!{GUID_PROCESSOR_DISTRIBUTE_UTILITY,
+    0xe0007330, 0xf589, 0x42ed, 0xa4, 0x01, 0x5d, 0xdb, 0x10, 0xe7, 0x85, 0xd3}
+DEFINE_GUID!{GUID_PROCESSOR_HETEROGENEOUS_POLICY,
+    0x7f2f5cfa, 0xf10c, 0x4823, 0xb5, 0xe1, 0xe9, 0x3a, 0xe8, 0x5f, 0x46, 0xb5}
+DEFINE_GUID!{GUID_PROCESSOR_HETERO_DECREASE_TIME,
+    0x7f2492b6, 0x60b1, 0x45e5, 0xae, 0x55, 0x77, 0x3f, 0x8c, 0xd5, 0xca, 0xec}
+DEFINE_GUID!{GUID_PROCESSOR_HETERO_INCREASE_TIME,
+    0x4009efa7, 0xe72d, 0x4cba, 0x9e, 0xdf, 0x91, 0x08, 0x4e, 0xa8, 0xcb, 0xc3}
+DEFINE_GUID!{GUID_PROCESSOR_HETERO_DECREASE_THRESHOLD,
+    0xf8861c27, 0x95e7, 0x475c, 0x86, 0x5b, 0x13, 0xc0, 0xcb, 0x3f, 0x9d, 0x6b}
+DEFINE_GUID!{GUID_PROCESSOR_HETERO_INCREASE_THRESHOLD,
+    0xb000397d, 0x9b0b, 0x483d, 0x98, 0xc9, 0x69, 0x2a, 0x60, 0x60, 0xcf, 0xbf}
+DEFINE_GUID!{GUID_PROCESSOR_CLASS0_FLOOR_PERF,
+    0xfddc842b, 0x8364, 0x4edc, 0x94, 0xcf, 0xc1, 0x7f, 0x60, 0xde, 0x1c, 0x80}
+DEFINE_GUID!{GUID_PROCESSOR_CLASS1_INITIAL_PERF,
+    0x1facfc65, 0xa930, 0x4bc5, 0x9f, 0x38, 0x50, 0x4e, 0xc0, 0x97, 0xbb, 0xc0}
+DEFINE_GUID!{GUID_SYSTEM_COOLING_POLICY,
+    0x94d3a615, 0xa899, 0x4ac5, 0xae, 0x2b, 0xe4, 0xd8, 0xf6, 0x34, 0x36, 0x7f}
+DEFINE_GUID!{GUID_LOCK_CONSOLE_ON_WAKE,
+    0x0e796bdb, 0x100d, 0x47d6, 0xa2, 0xd5, 0xf7, 0xd2, 0xda, 0xa5, 0x1f, 0x51}
+DEFINE_GUID!{GUID_DEVICE_IDLE_POLICY,
+    0x4faab71a, 0x92e5, 0x4726, 0xb5, 0x31, 0x22, 0x45, 0x59, 0x67, 0x2d, 0x19}
+pub const POWER_DEVICE_IDLE_POLICY_PERFORMANCE: DWORD = 0;
+pub const POWER_DEVICE_IDLE_POLICY_CONSERVATIVE: DWORD = 1;
+DEFINE_GUID!{GUID_CONNECTIVITY_IN_STANDBY,
+    0xf15576e8, 0x98b7, 0x4186, 0xb9, 0x44, 0xea, 0xfa, 0x66, 0x44, 0x02, 0xd9}
+pub const POWER_CONNECTIVITY_IN_STANDBY_DISABLED: DWORD = 0;
+pub const POWER_CONNECTIVITY_IN_STANDBY_ENABLED: DWORD = 1;
+pub const POWER_CONNECTIVITY_IN_STANDBY_DISABLED_LID_CLOSE: DWORD = 2;
+DEFINE_GUID!{GUID_DISCONNECTED_STANDBY_MODE,
+    0x68afb2d9, 0xee95, 0x47a8, 0x8f, 0x50, 0x41, 0x15, 0x08, 0x80, 0x73, 0xb1}
+pub const POWER_DISCONNECTED_STANDBY_MODE_NORMAL: DWORD = 0;
+pub const POWER_DISCONNECTED_STANDBY_MODE_AGGRESSIVE: DWORD = 1;
+DEFINE_GUID!{GUID_ACDC_POWER_SOURCE,
+    0x5d3e9a59, 0xe9d5, 0x4b00, 0xa6, 0xbd, 0xff, 0x34, 0xff, 0x51, 0x65, 0x48}
+DEFINE_GUID!{GUID_LIDSWITCH_STATE_CHANGE,
+    0xba3e0f4d, 0xb817, 0x4094, 0xa2, 0xd1, 0xd5, 0x63, 0x79, 0xe6, 0xa0, 0xf3}
+DEFINE_GUID!{GUID_BATTERY_PERCENTAGE_REMAINING,
+    0xa7ad8041, 0xb45a, 0x4cae, 0x87, 0xa3, 0xee, 0xcb, 0xb4, 0x68, 0xa9, 0xe1}
+DEFINE_GUID!{GUID_BATTERY_COUNT,
+    0x7d263f15, 0xfca4, 0x49e5, 0x85, 0x4b, 0xa9, 0xf2, 0xbf, 0xbd, 0x5c, 0x24}
+DEFINE_GUID!{GUID_GLOBAL_USER_PRESENCE,
+    0x786e8a1d, 0xb427, 0x4344, 0x92, 0x7, 0x9, 0xe7, 0xb, 0xdc, 0xbe, 0xa9}
+DEFINE_GUID!{GUID_SESSION_DISPLAY_STATUS,
+    0x2b84c20e, 0xad23, 0x4ddf, 0x93, 0xdb, 0x5, 0xff, 0xbd, 0x7e, 0xfc, 0xa5}
+DEFINE_GUID!{GUID_SESSION_USER_PRESENCE,
+    0x3c0f4548, 0xc03f, 0x4c4d, 0xb9, 0xf2, 0x23, 0x7e, 0xde, 0x68, 0x63, 0x76}
+DEFINE_GUID!{GUID_IDLE_BACKGROUND_TASK,
+    0x515c31d8, 0xf734, 0x163d, 0xa0, 0xfd, 0x11, 0xa0, 0x8c, 0x91, 0xe8, 0xf1}
+DEFINE_GUID!{GUID_BACKGROUND_TASK_NOTIFICATION,
+    0xcf23f240, 0x2a54, 0x48d8, 0xb1, 0x14, 0xde, 0x15, 0x18, 0xff, 0x05, 0x2e}
+DEFINE_GUID!{GUID_APPLAUNCH_BUTTON,
+    0x1a689231, 0x7399, 0x4e9a, 0x8f, 0x99, 0xb7, 0x1f, 0x99, 0x9d, 0xb3, 0xfa}
+DEFINE_GUID!{GUID_PCIEXPRESS_SETTINGS_SUBGROUP,
+    0x501a4d13, 0x42af,0x4429, 0x9f, 0xd1, 0xa8, 0x21, 0x8c, 0x26, 0x8e, 0x20}
+DEFINE_GUID!{GUID_PCIEXPRESS_ASPM_POLICY,
+    0xee12f906, 0xd277, 0x404b, 0xb6, 0xda, 0xe5, 0xfa, 0x1a, 0x57, 0x6d, 0xf5}
+DEFINE_GUID!{GUID_ENABLE_SWITCH_FORCED_SHUTDOWN,
+    0x833a6b62, 0xdfa4, 0x46d1, 0x82, 0xf8, 0xe0, 0x9e, 0x34, 0xd0, 0x29, 0xd6}
+DEFINE_GUID!{GUID_INTSTEER_SUBGROUP,
+    0x48672f38, 0x7a9a, 0x4bb2, 0x8b, 0xf8, 0x3d, 0x85, 0xbe, 0x19, 0xde, 0x4e}
+DEFINE_GUID!{GUID_INTSTEER_MODE,
+    0x2bfc24f9, 0x5ea2, 0x4801, 0x82, 0x13, 0x3d, 0xba, 0xe0, 0x1a, 0xa3, 0x9d}
+DEFINE_GUID!{GUID_INTSTEER_LOAD_PER_PROC_TRIGGER,
+    0x73cde64d, 0xd720, 0x4bb2, 0xa8, 0x60, 0xc7, 0x55, 0xaf, 0xe7, 0x7e, 0xf2}
+DEFINE_GUID!{GUID_INTSTEER_TIME_UNPARK_TRIGGER,
+    0xd6ba4903, 0x386f, 0x4c2c, 0x8a, 0xdb, 0x5c, 0x21, 0xb3, 0x32, 0x8d, 0x25}
+ENUM!{enum SYSTEM_POWER_STATE {
+    PowerSystemUnspecified = 0,
+    PowerSystemWorking = 1,
+    PowerSystemSleeping1 = 2,
+    PowerSystemSleeping2 = 3,
+    PowerSystemSleeping3 = 4,
+    PowerSystemHibernate = 5,
+    PowerSystemShutdown = 6,
+    PowerSystemMaximum = 7,
+}}
+pub type PSYSTEM_POWER_STATE = *mut SYSTEM_POWER_STATE;
+pub const POWER_SYSTEM_MAXIMUM: usize = 7;
+ENUM!{enum POWER_ACTION {
+    PowerActionNone = 0,
+    PowerActionReserved,
+    PowerActionSleep,
+    PowerActionHibernate,
+    PowerActionShutdown,
+    PowerActionShutdownReset,
+    PowerActionShutdownOff,
+    PowerActionWarmEject,
+    PowerActionDisplayOff,
+}}
+pub type PPOWER_ACTION = *mut POWER_ACTION;
+ENUM!{enum DEVICE_POWER_STATE {
+    PowerDeviceUnspecified = 0,
+    PowerDeviceD0,
+    PowerDeviceD1,
+    PowerDeviceD2,
+    PowerDeviceD3,
+    PowerDeviceMaximum,
+}}
+pub type PDEVICE_POWER_STATE = *mut DEVICE_POWER_STATE;
+ENUM!{enum MONITOR_DISPLAY_STATE {
+    PowerMonitorOff = 0,
+    PowerMonitorOn,
+    PowerMonitorDim,
+}}
+pub type PMONITOR_DISPLAY_STATE = *mut MONITOR_DISPLAY_STATE;
+ENUM!{enum USER_ACTIVITY_PRESENCE {
+    PowerUserPresent = 0,
+    PowerUserNotPresent,
+    PowerUserInactive,
+    PowerUserMaximum,
+    PowerUserInvalid = PowerUserMaximum,
+}}
+pub type PUSER_ACTIVITY_PRESENCE = *mut USER_ACTIVITY_PRESENCE;
+pub const ES_SYSTEM_REQUIRED: DWORD = 0x00000001;
+pub const ES_DISPLAY_REQUIRED: DWORD = 0x00000002;
+pub const ES_USER_PRESENT: DWORD = 0x00000004;
+pub const ES_AWAYMODE_REQUIRED: DWORD = 0x00000040;
+pub const ES_CONTINUOUS: DWORD = 0x80000000;
+pub type EXECUTION_STATE = DWORD;
+pub type PEXECUTION_STATE = *mut DWORD;
+ENUM!{enum LATENCY_TIME {
+    LT_DONT_CARE,
+    LT_LOWEST_LATENCY,
+}}
+pub const DIAGNOSTIC_REASON_VERSION: ULONG = 0;
+pub const DIAGNOSTIC_REASON_SIMPLE_STRING: ULONG = 0x00000001;
+pub const DIAGNOSTIC_REASON_DETAILED_STRING: ULONG = 0x00000002;
+pub const DIAGNOSTIC_REASON_NOT_SPECIFIED: ULONG = 0x80000000;
+pub const DIAGNOSTIC_REASON_INVALID_FLAGS: ULONG = !0x80000007;
+pub const POWER_REQUEST_CONTEXT_VERSION: ULONG = DIAGNOSTIC_REASON_VERSION;
+pub const POWER_REQUEST_CONTEXT_SIMPLE_STRING: ULONG = DIAGNOSTIC_REASON_SIMPLE_STRING;
+pub const POWER_REQUEST_CONTEXT_DETAILED_STRING: ULONG = DIAGNOSTIC_REASON_DETAILED_STRING;
+ENUM!{enum POWER_REQUEST_TYPE {
+    PowerRequestDisplayRequired,
+    PowerRequestSystemRequired,
+    PowerRequestAwayModeRequired,
+    PowerRequestExecutionRequired,
+}}
+pub type PPOWER_REQUEST_TYPE = *mut POWER_REQUEST_TYPE;
+pub const PDCAP_D0_SUPPORTED: DWORD = 0x00000001;
+pub const PDCAP_D1_SUPPORTED: DWORD = 0x00000002;
+pub const PDCAP_D2_SUPPORTED: DWORD = 0x00000004;
+pub const PDCAP_D3_SUPPORTED: DWORD = 0x00000008;
+pub const PDCAP_WAKE_FROM_D0_SUPPORTED: DWORD = 0x00000010;
+pub const PDCAP_WAKE_FROM_D1_SUPPORTED: DWORD = 0x00000020;
+pub const PDCAP_WAKE_FROM_D2_SUPPORTED: DWORD = 0x00000040;
+pub const PDCAP_WAKE_FROM_D3_SUPPORTED: DWORD = 0x00000080;
+pub const PDCAP_WARM_EJECT_SUPPORTED: DWORD = 0x00000100;
+STRUCT!{struct CM_POWER_DATA {
+    PD_Size: DWORD,
+    PD_MostRecentPowerState: DEVICE_POWER_STATE,
+    PD_Capabilities: DWORD,
+    PD_D1Latency: DWORD,
+    PD_D2Latency: DWORD,
+    PD_D3Latency: DWORD,
+    PD_PowerStateMapping: [DEVICE_POWER_STATE; POWER_SYSTEM_MAXIMUM],
+    PD_DeepestSystemWake: SYSTEM_POWER_STATE,
+}}
+pub type PCM_POWER_DATA = *mut CM_POWER_DATA;
+ENUM!{enum POWER_INFORMATION_LEVEL {
+    SystemPowerPolicyAc,
+    SystemPowerPolicyDc,
+    VerifySystemPolicyAc,
+    VerifySystemPolicyDc,
+    SystemPowerCapabilities,
+    SystemBatteryState,
+    SystemPowerStateHandler,
+    ProcessorStateHandler,
+    SystemPowerPolicyCurrent,
+    AdministratorPowerPolicy,
+    SystemReserveHiberFile,
+    ProcessorInformation,
+    SystemPowerInformation,
+    ProcessorStateHandler2,
+    LastWakeTime,
+    LastSleepTime,
+    SystemExecutionState,
+    SystemPowerStateNotifyHandler,
+    ProcessorPowerPolicyAc,
+    ProcessorPowerPolicyDc,
+    VerifyProcessorPowerPolicyAc,
+    VerifyProcessorPowerPolicyDc,
+    ProcessorPowerPolicyCurrent,
+    SystemPowerStateLogging,
+    SystemPowerLoggingEntry,
+    SetPowerSettingValue,
+    NotifyUserPowerSetting,
+    PowerInformationLevelUnused0,
+    SystemMonitorHiberBootPowerOff,
+    SystemVideoState,
+    TraceApplicationPowerMessage,
+    TraceApplicationPowerMessageEnd,
+    ProcessorPerfStates,
+    ProcessorIdleStates,
+    ProcessorCap,
+    SystemWakeSource,
+    SystemHiberFileInformation,
+    TraceServicePowerMessage,
+    ProcessorLoad,
+    PowerShutdownNotification,
+    MonitorCapabilities,
+    SessionPowerInit,
+    SessionDisplayState,
+    PowerRequestCreate,
+    PowerRequestAction,
+    GetPowerRequestList,
+    ProcessorInformationEx,
+    NotifyUserModeLegacyPowerEvent,
+    GroupPark,
+    ProcessorIdleDomains,
+    WakeTimerList,
+    SystemHiberFileSize,
+    ProcessorIdleStatesHv,
+    ProcessorPerfStatesHv,
+    ProcessorPerfCapHv,
+    ProcessorSetIdle,
+    LogicalProcessorIdling,
+    UserPresence,
+    PowerSettingNotificationName,
+    GetPowerSettingValue,
+    IdleResiliency,
+    SessionRITState,
+    SessionConnectNotification,
+    SessionPowerCleanup,
+    SessionLockState,
+    SystemHiberbootState,
+    PlatformInformation,
+    PdcInvocation,
+    MonitorInvocation,
+    FirmwareTableInformationRegistered,
+    SetShutdownSelectedTime,
+    SuspendResumeInvocation,
+    PlmPowerRequestCreate,
+    ScreenOff,
+    CsDeviceNotification,
+    PlatformRole,
+    LastResumePerformance,
+    DisplayBurst,
+    ExitLatencySamplingPercentage,
+    RegisterSpmPowerSettings,
+    PlatformIdleStates,
+    ProcessorIdleVeto,
+    PlatformIdleVeto,
+    SystemBatteryStatePrecise,
+    ThermalEvent,
+    PowerRequestActionInternal,
+    BatteryDeviceState,
+    PowerInformationInternal,
+    ThermalStandby,
+    SystemHiberFileType,
+    PhysicalPowerButtonPress,
+    QueryPotentialDripsConstraint,
+    EnergyTrackerCreate,
+    EnergyTrackerQuery,
+    UpdateBlackBoxRecorder,
+    PowerInformationLevelMaximum,
+}}
+ENUM!{enum POWER_USER_PRESENCE_TYPE {
+    UserNotPresent = 0,
+    UserPresent = 1,
+    UserUnknown = 0xff,
+}}
+pub type PPOWER_USER_PRESENCE_TYPE = *mut POWER_USER_PRESENCE_TYPE;
+STRUCT!{struct POWER_USER_PRESENCE {
+    UserPresence: POWER_USER_PRESENCE_TYPE,
+}}
+pub type PPOWER_USER_PRESENCE = *mut POWER_USER_PRESENCE;
+STRUCT!{struct POWER_SESSION_CONNECT {
+    Connected: BOOLEAN,
+    Console: BOOLEAN,
+}}
+pub type PPOWER_SESSION_CONNECT = *mut POWER_SESSION_CONNECT;
+STRUCT!{struct POWER_SESSION_TIMEOUTS {
+    InputTimeout: DWORD,
+    DisplayTimeout: DWORD,
+}}
+pub type PPOWER_SESSION_TIMEOUTS = *mut POWER_SESSION_TIMEOUTS;
+STRUCT!{struct POWER_SESSION_RIT_STATE {
+    Active: BOOLEAN,
+    LastInputTime: DWORD,
+}}
+pub type PPOWER_SESSION_RIT_STATE = *mut POWER_SESSION_RIT_STATE;
+STRUCT!{struct POWER_SESSION_WINLOGON {
+    SessionId: DWORD,
+    Console: BOOLEAN,
+    Locked: BOOLEAN,
+}}
+pub type PPOWER_SESSION_WINLOGON = *mut POWER_SESSION_WINLOGON;
+STRUCT!{struct POWER_IDLE_RESILIENCY {
+    CoalescingTimeout: DWORD,
+    IdleResiliencyPeriod: DWORD,
+}}
+pub type PPOWER_IDLE_RESILIENCY = *mut POWER_IDLE_RESILIENCY;
+ENUM!{enum POWER_MONITOR_REQUEST_REASON {
+    MonitorRequestReasonUnknown,
+    MonitorRequestReasonPowerButton,
+    MonitorRequestReasonRemoteConnection,
+    MonitorRequestReasonScMonitorpower,
+    MonitorRequestReasonUserInput,
+    MonitorRequestReasonAcDcDisplayBurst,
+    MonitorRequestReasonUserDisplayBurst,
+    MonitorRequestReasonPoSetSystemState,
+    MonitorRequestReasonSetThreadExecutionState,
+    MonitorRequestReasonFullWake,
+    MonitorRequestReasonSessionUnlock,
+    MonitorRequestReasonScreenOffRequest,
+    MonitorRequestReasonIdleTimeout,
+    MonitorRequestReasonPolicyChange,
+    MonitorRequestReasonSleepButton,
+    MonitorRequestReasonLid,
+    MonitorRequestReasonBatteryCountChange,
+    MonitorRequestReasonGracePeriod,
+    MonitorRequestReasonPnP,
+    MonitorRequestReasonDP,
+    MonitorRequestReasonSxTransition,
+    MonitorRequestReasonSystemIdle,
+    MonitorRequestReasonNearProximity,
+    MonitorRequestReasonThermalStandby,
+    MonitorRequestReasonResumePdc,
+    MonitorRequestReasonResumeS4,
+    MonitorRequestReasonTerminal,
+    MonitorRequestReasonPdcSignal,
+    MonitorRequestReasonAcDcDisplayBurstSuppressed,
+    MonitorRequestReasonSystemStateEntered,
+    MonitorRequestReasonWinrt,
+    MonitorRequestReasonMax,
+}}
+ENUM!{enum POWER_MONITOR_REQUEST_TYPE {
+    MonitorRequestTypeOff,
+    MonitorRequestTypeOnAndPresent,
+    MonitorRequestTypeToggleOn,
+}}
+STRUCT!{struct POWER_MONITOR_INVOCATION {
+    Console: BOOLEAN,
+    RequestReason: POWER_MONITOR_REQUEST_REASON,
+}}
+pub type PPOWER_MONITOR_INVOCATION = *mut POWER_MONITOR_INVOCATION;
+STRUCT!{struct RESUME_PERFORMANCE {
+    PostTimeMs: DWORD,
+    TotalResumeTimeMs: ULONGLONG,
+    ResumeCompleteTimestamp: ULONGLONG,
+}}
+pub type PRESUME_PERFORMANCE = *mut RESUME_PERFORMANCE;
+ENUM!{enum SYSTEM_POWER_CONDITION {
+    PoAc,
+    PoDc,
+    PoHot,
+    PoConditionMaximum,
+}}
+STRUCT!{struct SET_POWER_SETTING_VALUE {
+    Version: DWORD,
+    Guid: GUID,
+    PowerCondition: SYSTEM_POWER_CONDITION,
+    DataLength: DWORD,
+    Data: [BYTE; ANYSIZE_ARRAY],
+}}
+pub type PSET_POWER_SETTING_VALUE = *mut SET_POWER_SETTING_VALUE;
+STRUCT!{struct NOTIFY_USER_POWER_SETTING {
+    Guid: GUID,
+}}
+pub type PNOTIFY_USER_POWER_SETTING = *mut NOTIFY_USER_POWER_SETTING;
+STRUCT!{struct APPLICATIONLAUNCH_SETTING_VALUE {
+    ActivationTime: LARGE_INTEGER,
+    Flags: DWORD,
+    ButtonInstanceID: DWORD,
+}}
+pub type PAPPLICATIONLAUNCH_SETTING_VALUE = *mut APPLICATIONLAUNCH_SETTING_VALUE;
+ENUM!{enum POWER_PLATFORM_ROLE {
+    PlatformRoleUnspecified = 0,
+    PlatformRoleDesktop,
+    PlatformRoleMobile,
+    PlatformRoleWorkstation,
+    PlatformRoleEnterpriseServer,
+    PlatformRoleSOHOServer,
+    PlatformRoleAppliancePC,
+    PlatformRolePerformanceServer,
+    PlatformRoleSlate,
+    PlatformRoleMaximum,
+}}
+pub type PPOWER_PLATFORM_ROLE = *mut POWER_PLATFORM_ROLE;
+pub const POWER_PLATFORM_ROLE_V1: ULONG = 0x00000001;
+pub const POWER_PLATFORM_ROLE_V1_MAX: POWER_PLATFORM_ROLE = PlatformRolePerformanceServer + 1;
+pub const POWER_PLATFORM_ROLE_V2: ULONG = 0x00000002;
+pub const POWER_PLATFORM_ROLE_V2_MAX: POWER_PLATFORM_ROLE = PlatformRoleSlate + 1;
+pub const POWER_PLATFORM_ROLE_VERSION: ULONG = POWER_PLATFORM_ROLE_V2;
+pub const POWER_PLATFORM_ROLE_VERSION_MAX: POWER_PLATFORM_ROLE = POWER_PLATFORM_ROLE_V2_MAX;
+STRUCT!{struct POWER_PLATFORM_INFORMATION {
+    AoAc: BOOLEAN,
+}}
+pub type PPOWER_PLATFORM_INFORMATION = *mut POWER_PLATFORM_INFORMATION;
+STRUCT!{struct BATTERY_REPORTING_SCALE {
+    Granularity: DWORD,
+    Capacity: DWORD,
+}}
+pub type PBATTERY_REPORTING_SCALE = *mut BATTERY_REPORTING_SCALE;
+STRUCT!{struct PPM_WMI_LEGACY_PERFSTATE {
+    Frequency: DWORD,
+    Flags: DWORD,
+    PercentFrequency: DWORD,
+}}
+pub type PPPM_WMI_LEGACY_PERFSTATE = *mut PPM_WMI_LEGACY_PERFSTATE;
+STRUCT!{struct PPM_WMI_IDLE_STATE {
+    Latency: DWORD,
+    Power: DWORD,
+    TimeCheck: DWORD,
+    PromotePercent: BYTE,
+    DemotePercent: BYTE,
+    StateType: BYTE,
+    Reserved: BYTE,
+    StateFlags: DWORD,
+    Context: DWORD,
+    IdleHandler: DWORD,
+    Reserved1: DWORD,
+}}
+pub type PPPM_WMI_IDLE_STATE = *mut PPM_WMI_IDLE_STATE;
+STRUCT!{struct PPM_WMI_IDLE_STATES {
+    Type: DWORD,
+    Count: DWORD,
+    TargetState: DWORD,
+    OldState: DWORD,
+    TargetProcessors: DWORD64,
+    State: [PPM_WMI_IDLE_STATE; ANYSIZE_ARRAY],
+}}
+pub type PPPM_WMI_IDLE_STATES = *mut PPM_WMI_IDLE_STATES;
+STRUCT!{struct PPM_WMI_IDLE_STATES_EX {
+    Type: DWORD,
+    Count: DWORD,
+    TargetState: DWORD,
+    OldState: DWORD,
+    TargetProcessors: PVOID,
+    State: [PPM_WMI_IDLE_STATE; ANYSIZE_ARRAY],
+}}
+pub type PPPM_WMI_IDLE_STATES_EX = *mut PPM_WMI_IDLE_STATES_EX;
+STRUCT!{struct PPM_WMI_PERF_STATE {
+    Frequency: DWORD,
+    Power: DWORD,
+    PercentFrequency: BYTE,
+    IncreaseLevel: BYTE,
+    DecreaseLevel: BYTE,
+    Type: BYTE,
+    IncreaseTime: DWORD,
+    DecreaseTime: DWORD,
+    Control: DWORD64,
+    Status: DWORD64,
+    HitCount: DWORD,
+    Reserved1: DWORD,
+    Reserved2: DWORD64,
+    Reserved3: DWORD64,
+}}
+pub type PPPM_WMI_PERF_STATE = *mut PPM_WMI_PERF_STATE;
+STRUCT!{struct PPM_WMI_PERF_STATES {
+    Count: DWORD,
+    MaxFrequency: DWORD,
+    CurrentState: DWORD,
+    MaxPerfState: DWORD,
+    MinPerfState: DWORD,
+    LowestPerfState: DWORD,
+    ThermalConstraint: DWORD,
+    BusyAdjThreshold: BYTE,
+    PolicyType: BYTE,
+    Type: BYTE,
+    Reserved: BYTE,
+    TimerInterval: DWORD,
+    TargetProcessors: DWORD64,
+    PStateHandler: DWORD,
+    PStateContext: DWORD,
+    TStateHandler: DWORD,
+    TStateContext: DWORD,
+    FeedbackHandler: DWORD,
+    Reserved1: DWORD,
+    Reserved2: DWORD64,
+    State: [PPM_WMI_PERF_STATE; ANYSIZE_ARRAY],
+}}
+pub type PPPM_WMI_PERF_STATES = *mut PPM_WMI_PERF_STATES;
+STRUCT!{struct PPM_WMI_PERF_STATES_EX {
+    Count: DWORD,
+    MaxFrequency: DWORD,
+    CurrentState: DWORD,
+    MaxPerfState: DWORD,
+    MinPerfState: DWORD,
+    LowestPerfState: DWORD,
+    ThermalConstraint: DWORD,
+    BusyAdjThreshold: BYTE,
+    PolicyType: BYTE,
+    Type: BYTE,
+    Reserved: BYTE,
+    TimerInterval: DWORD,
+    TargetProcessors: PVOID,
+    PStateHandler: DWORD,
+    PStateContext: DWORD,
+    TStateHandler: DWORD,
+    TStateContext: DWORD,
+    FeedbackHandler: DWORD,
+    Reserved1: DWORD,
+    Reserved2: DWORD64,
+    State: [PPM_WMI_PERF_STATE; ANYSIZE_ARRAY],
+}}
+pub type PPPM_WMI_PERF_STATES_EX = *mut PPM_WMI_PERF_STATES_EX;
+pub const PROC_IDLE_BUCKET_COUNT: usize = 6;
+STRUCT!{struct PPM_IDLE_STATE_ACCOUNTING {
+    IdleTransitions: DWORD,
+    FailedTransitions: DWORD,
+    InvalidBucketIndex: DWORD,
+    TotalTime: DWORD64,
+    IdleTimeBuckets: [DWORD; PROC_IDLE_BUCKET_COUNT],
+}}
+pub type PPPM_IDLE_STATE_ACCOUNTING = *mut PPM_IDLE_STATE_ACCOUNTING;
+STRUCT!{struct PPM_IDLE_ACCOUNTING {
+    StateCount: DWORD,
+    TotalTransitions: DWORD,
+    ResetCount: DWORD,
+    StartTime: DWORD64,
+    State: [PPM_IDLE_STATE_ACCOUNTING; ANYSIZE_ARRAY],
+}}
+pub type PPPM_IDLE_ACCOUNTING = *mut PPM_IDLE_ACCOUNTING;
+pub const PROC_IDLE_BUCKET_COUNT_EX: usize = 16;
+STRUCT!{struct PPM_IDLE_STATE_BUCKET_EX {
+    TotalTimeUs: DWORD64,
+    MinTimeUs: DWORD,
+    MaxTimeUs: DWORD,
+    Count: DWORD,
+}}
+pub type PPPM_IDLE_STATE_BUCKET_EX = *mut PPM_IDLE_STATE_BUCKET_EX;
+STRUCT!{struct PPM_IDLE_STATE_ACCOUNTING_EX {
+    TotalTime: DWORD64,
+    IdleTransitions: DWORD,
+    FailedTransitions: DWORD,
+    InvalidBucketIndex: DWORD,
+    MinTimeUs: DWORD,
+    MaxTimeUs: DWORD,
+    CancelledTransitions: DWORD,
+    IdleTimeBuckets: [PPM_IDLE_STATE_BUCKET_EX; PROC_IDLE_BUCKET_COUNT_EX],
+}}
+pub type PPPM_IDLE_STATE_ACCOUNTING_EX = *mut PPM_IDLE_STATE_ACCOUNTING_EX;
+STRUCT!{struct PPM_IDLE_ACCOUNTING_EX {
+    StateCount: DWORD,
+    TotalTransitions: DWORD,
+    ResetCount: DWORD,
+    AbortCount: DWORD,
+    StartTime: DWORD64,
+    State: [PPM_IDLE_STATE_ACCOUNTING_EX; ANYSIZE_ARRAY],
+}}
+pub type PPPM_IDLE_ACCOUNTING_EX = *mut PPM_IDLE_ACCOUNTING_EX;
+pub const ACPI_PPM_SOFTWARE_ALL: DWORD = 0xFC;
+pub const ACPI_PPM_SOFTWARE_ANY: DWORD = 0xFD;
+pub const ACPI_PPM_HARDWARE_ALL: DWORD = 0xFE;
+pub const MS_PPM_SOFTWARE_ALL: DWORD = 0x1;
+pub const PPM_FIRMWARE_ACPI1C2: DWORD = 0x00000001;
+pub const PPM_FIRMWARE_ACPI1C3: DWORD = 0x00000002;
+pub const PPM_FIRMWARE_ACPI1TSTATES: DWORD = 0x00000004;
+pub const PPM_FIRMWARE_CST: DWORD = 0x00000008;
+pub const PPM_FIRMWARE_CSD: DWORD = 0x00000010;
+pub const PPM_FIRMWARE_PCT: DWORD = 0x00000020;
+pub const PPM_FIRMWARE_PSS: DWORD = 0x00000040;
+pub const PPM_FIRMWARE_XPSS: DWORD = 0x00000080;
+pub const PPM_FIRMWARE_PPC: DWORD = 0x00000100;
+pub const PPM_FIRMWARE_PSD: DWORD = 0x00000200;
+pub const PPM_FIRMWARE_PTC: DWORD = 0x00000400;
+pub const PPM_FIRMWARE_TSS: DWORD = 0x00000800;
+pub const PPM_FIRMWARE_TPC: DWORD = 0x00001000;
+pub const PPM_FIRMWARE_TSD: DWORD = 0x00002000;
+pub const PPM_FIRMWARE_PCCH: DWORD = 0x00004000;
+pub const PPM_FIRMWARE_PCCP: DWORD = 0x00008000;
+pub const PPM_FIRMWARE_OSC: DWORD = 0x00010000;
+pub const PPM_FIRMWARE_PDC: DWORD = 0x00020000;
+pub const PPM_FIRMWARE_CPC: DWORD = 0x00040000;
+pub const PPM_FIRMWARE_LPI: DWORD = 0x00080000;
+pub const PPM_PERFORMANCE_IMPLEMENTATION_NONE: DWORD = 0x00000000;
+pub const PPM_PERFORMANCE_IMPLEMENTATION_PSTATES: DWORD = 0x00000001;
+pub const PPM_PERFORMANCE_IMPLEMENTATION_PCCV1: DWORD = 0x00000002;
+pub const PPM_PERFORMANCE_IMPLEMENTATION_CPPC: DWORD = 0x00000003;
+pub const PPM_PERFORMANCE_IMPLEMENTATION_PEP: DWORD = 0x00000004;
+pub const PPM_IDLE_IMPLEMENTATION_NONE: DWORD = 0x00000000;
+pub const PPM_IDLE_IMPLEMENTATION_CSTATES: DWORD = 0x00000001;
+pub const PPM_IDLE_IMPLEMENTATION_PEP: DWORD = 0x00000002;
+pub const PPM_IDLE_IMPLEMENTATION_MICROPEP: DWORD = 0x00000003;
+pub const PPM_IDLE_IMPLEMENTATION_LPISTATES: DWORD = 0x00000004;
+DEFINE_GUID!{PPM_PERFSTATE_CHANGE_GUID,
+    0xa5b32ddd, 0x7f39, 0x4abc, 0xb8, 0x92, 0x90, 0xe, 0x43, 0xb5, 0x9e, 0xbb}
+DEFINE_GUID!{PPM_PERFSTATE_DOMAIN_CHANGE_GUID,
+    0x995e6b7f, 0xd653, 0x497a, 0xb9, 0x78, 0x36, 0xa3, 0xc, 0x29, 0xbf, 0x1}
+DEFINE_GUID!{PPM_IDLESTATE_CHANGE_GUID,
+    0x4838fe4f, 0xf71c, 0x4e51, 0x9e, 0xcc, 0x84, 0x30, 0xa7, 0xac, 0x4c, 0x6c}
+DEFINE_GUID!{PPM_PERFSTATES_DATA_GUID,
+    0x5708cc20, 0x7d40, 0x4bf4, 0xb4, 0xaa, 0x2b, 0x01, 0x33, 0x8d, 0x01, 0x26}
+DEFINE_GUID!{PPM_IDLESTATES_DATA_GUID,
+    0xba138e10, 0xe250, 0x4ad7, 0x86, 0x16, 0xcf, 0x1a, 0x7a, 0xd4, 0x10, 0xe7}
+DEFINE_GUID!{PPM_IDLE_ACCOUNTING_GUID,
+    0xe2a26f78, 0xae07, 0x4ee0, 0xa3, 0x0f, 0xce, 0x54, 0xf5, 0x5a, 0x94, 0xcd}
+DEFINE_GUID!{PPM_IDLE_ACCOUNTING_EX_GUID,
+    0xd67abd39, 0x81f8, 0x4a5e, 0x81, 0x52, 0x72, 0xe3, 0x1e, 0xc9, 0x12, 0xee}
+DEFINE_GUID!{PPM_THERMALCONSTRAINT_GUID,
+    0xa852c2c8, 0x1a4c, 0x423b, 0x8c, 0x2c, 0xf3, 0x0d, 0x82, 0x93, 0x1a, 0x88}
+DEFINE_GUID!{PPM_PERFMON_PERFSTATE_GUID,
+    0x7fd18652, 0xcfe, 0x40d2, 0xb0, 0xa1, 0xb, 0x6, 0x6a, 0x87, 0x75, 0x9e}
+DEFINE_GUID!{PPM_THERMAL_POLICY_CHANGE_GUID,
+    0x48f377b8, 0x6880, 0x4c7b, 0x8b, 0xdc, 0x38, 0x1, 0x76, 0xc6, 0x65, 0x4d}
+STRUCT!{struct PPM_PERFSTATE_EVENT {
+    State: DWORD,
+    Status: DWORD,
+    Latency: DWORD,
+    Speed: DWORD,
+    Processor: DWORD,
+}}
+pub type PPPM_PERFSTATE_EVENT = *mut PPM_PERFSTATE_EVENT;
+STRUCT!{struct PPM_PERFSTATE_DOMAIN_EVENT {
+    State: DWORD,
+    Latency: DWORD,
+    Speed: DWORD,
+    Processors: DWORD64,
+}}
+pub type PPPM_PERFSTATE_DOMAIN_EVENT = *mut PPM_PERFSTATE_DOMAIN_EVENT;
+STRUCT!{struct PPM_IDLESTATE_EVENT {
+    NewState: DWORD,
+    OldState: DWORD,
+    Processors: DWORD64,
+}}
+pub type PPPM_IDLESTATE_EVENT = *mut PPM_IDLESTATE_EVENT;
+STRUCT!{struct PPM_THERMALCHANGE_EVENT {
+    ThermalConstraint: DWORD,
+    Processors: DWORD64,
+}}
+pub type PPPM_THERMALCHANGE_EVENT = *mut PPM_THERMALCHANGE_EVENT;
+STRUCT!{struct PPM_THERMAL_POLICY_EVENT {
+    Mode: BYTE,
+    Processors: DWORD64,
+}}
+pub type PPPM_THERMAL_POLICY_EVENT = *mut PPM_THERMAL_POLICY_EVENT;
+STRUCT!{struct POWER_ACTION_POLICY {
+    Action: POWER_ACTION,
+    Flags: DWORD,
+    EventCode: DWORD,
+}}
+pub type PPOWER_ACTION_POLICY = *mut POWER_ACTION_POLICY;
+pub const POWER_ACTION_QUERY_ALLOWED: DWORD = 0x00000001;
+pub const POWER_ACTION_UI_ALLOWED: DWORD = 0x00000002;
+pub const POWER_ACTION_OVERRIDE_APPS: DWORD = 0x00000004;
+pub const POWER_ACTION_HIBERBOOT: DWORD = 0x00000008;
+pub const POWER_ACTION_USER_NOTIFY: DWORD = 0x00000010;
+pub const POWER_ACTION_DOZE_TO_HIBERNATE: DWORD = 0x00000020;
+pub const POWER_ACTION_PSEUDO_TRANSITION: DWORD = 0x08000000;
+pub const POWER_ACTION_LIGHTEST_FIRST: DWORD = 0x10000000;
+pub const POWER_ACTION_LOCK_CONSOLE: DWORD = 0x20000000;
+pub const POWER_ACTION_DISABLE_WAKES: DWORD = 0x40000000;
+pub const POWER_ACTION_CRITICAL: DWORD = 0x80000000;
+pub const POWER_LEVEL_USER_NOTIFY_TEXT: DWORD = 0x00000001;
+pub const POWER_LEVEL_USER_NOTIFY_SOUND: DWORD = 0x00000002;
+pub const POWER_LEVEL_USER_NOTIFY_EXEC: DWORD = 0x00000004;
+pub const POWER_USER_NOTIFY_BUTTON: DWORD = 0x00000008;
+pub const POWER_USER_NOTIFY_SHUTDOWN: DWORD = 0x00000010;
+pub const POWER_USER_NOTIFY_FORCED_SHUTDOWN: DWORD = 0x00000020;
+pub const POWER_FORCE_TRIGGER_RESET: DWORD = 0x80000000;
+pub const BATTERY_DISCHARGE_FLAGS_EVENTCODE_MASK: DWORD = 0x00000007;
+pub const BATTERY_DISCHARGE_FLAGS_ENABLE: DWORD = 0x80000000;
+STRUCT!{struct SYSTEM_POWER_LEVEL {
+    Enable: BOOLEAN,
+    Spare: [BYTE; 3],
+    BatteryLevel: DWORD,
+    PowerPolicy: POWER_ACTION_POLICY,
+    MinSystemState: SYSTEM_POWER_STATE,
+}}
+pub type PSYSTEM_POWER_LEVEL = *mut SYSTEM_POWER_LEVEL;
+pub const NUM_DISCHARGE_POLICIES: usize = 4;
+pub const DISCHARGE_POLICY_CRITICAL: DWORD = 0;
+pub const DISCHARGE_POLICY_LOW: DWORD = 1;
+STRUCT!{struct SYSTEM_POWER_POLICY {
+    Revision: DWORD,
+    PowerButton: POWER_ACTION_POLICY,
+    SleepButton: POWER_ACTION_POLICY,
+    LidClose: POWER_ACTION_POLICY,
+    LidOpenWake: SYSTEM_POWER_STATE,
+    Reserved: DWORD,
+    Idle: POWER_ACTION_POLICY,
+    IdleTimeout: DWORD,
+    IdleSensitivity: BYTE,
+    DynamicThrottle: BYTE,
+    Spare2: [BYTE; 2],
+    MinSleep: SYSTEM_POWER_STATE,
+    MaxSleep: SYSTEM_POWER_STATE,
+    ReducedLatencySleep: SYSTEM_POWER_STATE,
+    WinLogonFlags: DWORD,
+    Spare3: DWORD,
+    DozeS4Timeout: DWORD,
+    BroadcastCapacityResolution: DWORD,
+    DischargePolicy: [SYSTEM_POWER_LEVEL; NUM_DISCHARGE_POLICIES],
+    VideoTimeout: DWORD,
+    VideoDimDisplay: BOOLEAN,
+    VideoReserved: [DWORD; 3],
+    SpindownTimeout: DWORD,
+    OptimizeForPower: BOOLEAN,
+    FanThrottleTolerance: BYTE,
+    ForcedThrottle: BYTE,
+    MinThrottle: BYTE,
+    OverThrottled: POWER_ACTION_POLICY,
+}}
+pub type PSYSTEM_POWER_POLICY = *mut SYSTEM_POWER_POLICY;
+pub const PROCESSOR_IDLESTATE_POLICY_COUNT: usize = 0x3;
+STRUCT!{struct PROCESSOR_IDLESTATE_INFO {
+    TimeCheck: DWORD,
+    DemotePercent: BYTE,
+    PromotePercent: BYTE,
+    Spare: [BYTE; 2],
+}}
+pub type PPROCESSOR_IDLESTATE_INFO = *mut PROCESSOR_IDLESTATE_INFO;
+STRUCT!{struct PROCESSOR_IDLESTATE_POLICY_Flags {
+    AsWORD: WORD,
+}}
+BITFIELD!{PROCESSOR_IDLESTATE_POLICY_Flags AsWORD: WORD [
+    AllowScaling set_AllowScaling[0..1],
+    Disabled set_Disabled[1..2],
+    Reserved set_Reserved[2..16],
+]}
+STRUCT!{struct PROCESSOR_IDLESTATE_POLICY {
+    Revision: WORD,
+    Flags: PROCESSOR_IDLESTATE_POLICY_Flags,
+    PolicyCount: DWORD,
+    Policy: [PROCESSOR_IDLESTATE_INFO; PROCESSOR_IDLESTATE_POLICY_COUNT],
+}}
+pub type PPROCESSOR_IDLESTATE_POLICY = *mut PROCESSOR_IDLESTATE_POLICY;
+pub const PO_THROTTLE_NONE: DWORD = 0;
+pub const PO_THROTTLE_CONSTANT: DWORD = 1;
+pub const PO_THROTTLE_DEGRADE: DWORD = 2;
+pub const PO_THROTTLE_ADAPTIVE: DWORD = 3;
+pub const PO_THROTTLE_MAXIMUM: DWORD = 4;
+STRUCT!{struct PROCESSOR_POWER_POLICY_INFO {
+    TimeCheck: DWORD,
+    DemoteLimit: DWORD,
+    PromoteLimit: DWORD,
+    DemotePercent: BYTE,
+    PromotePercent: BYTE,
+    Spare: [BYTE; 2],
+    Reserved: DWORD,
+}}
+BITFIELD!{PROCESSOR_POWER_POLICY_INFO Reserved: DWORD [
+    AllowDemotion set_AllowDemotion[0..1],
+    AllowPromotion set_AllowPromotion[1..2],
+    Reserved set_Reserved[2..32],
+]}
+pub type PPROCESSOR_POWER_POLICY_INFO = *mut PROCESSOR_POWER_POLICY_INFO;
+STRUCT!{struct PROCESSOR_POWER_POLICY {
+    Revision: DWORD,
+    DynamicThrottle: BYTE,
+    Spare: [BYTE; 3],
+    BitFields: DWORD,
+    PolicyCount: DWORD,
+    Policy: [PROCESSOR_POWER_POLICY_INFO; 3],
+}}
+BITFIELD!{PROCESSOR_POWER_POLICY BitFields: DWORD [
+    DisableCStates set_DisableCStates[0..1],
+    Reserved set_Reserved[1..32],
+]}
+pub type PPROCESSOR_POWER_POLICY = *mut PROCESSOR_POWER_POLICY;
+STRUCT!{struct PROCESSOR_PERFSTATE_POLICY_u_Flags {
+    AsBYTE: BYTE,
+}}
+BITFIELD!{PROCESSOR_PERFSTATE_POLICY_u_Flags AsBYTE: BYTE [
+    NoDomainAccounting set_NoDomainAccounting[0..1],
+    IncreasePolicy set_IncreasePolicy[1..3],
+    DecreasePolicy set_DecreasePolicy[3..5],
+    Reserved set_Reserved[5..8],
+]}
+UNION!{union PROCESSOR_PERFSTATE_POLICY_u {
+    [u8; 1],
+    Spare Spare_mut: BYTE,
+    Flags Flags_mut: PROCESSOR_PERFSTATE_POLICY_u_Flags,
+}}
+STRUCT!{struct PROCESSOR_PERFSTATE_POLICY {
+    Revision: DWORD,
+    MaxThrottle: BYTE,
+    MinThrottle: BYTE,
+    BusyAdjThreshold: BYTE,
+    u: PROCESSOR_PERFSTATE_POLICY_u,
+    TimeCheck: DWORD,
+    IncreaseTime: DWORD,
+    DecreaseTime: DWORD,
+    IncreasePercent: DWORD,
+    DecreasePercent: DWORD,
+}}
+pub type PPROCESSOR_PERFSTATE_POLICY = *mut PROCESSOR_PERFSTATE_POLICY;
+STRUCT!{struct ADMINISTRATOR_POWER_POLICY {
+    MinSleep: SYSTEM_POWER_STATE,
+    MaxSleep: SYSTEM_POWER_STATE,
+    MinVideoTimeout: DWORD,
+    MaxVideoTimeout: DWORD,
+    MinSpindownTimeout: DWORD,
+    MaxSpindownTimeout: DWORD,
+}}
+pub type PADMINISTRATOR_POWER_POLICY = *mut ADMINISTRATOR_POWER_POLICY;
+ENUM!{enum HIBERFILE_BUCKET_SIZE {
+    HiberFileBucket1GB = 0,
+    HiberFileBucket2GB,
+    HiberFileBucket4GB,
+    HiberFileBucket8GB,
+    HiberFileBucket16GB,
+    HiberFileBucket32GB,
+    HiberFileBucketUnlimited,
+    HiberFileBucketMax,
+}}
+pub const HIBERFILE_TYPE_NONE: BYTE = 0x00;
+pub const HIBERFILE_TYPE_REDUCED: BYTE = 0x01;
+pub const HIBERFILE_TYPE_FULL: BYTE = 0x02;
+pub const HIBERFILE_TYPE_MAX: usize = 0x03;
+STRUCT!{struct HIBERFILE_BUCKET {
+    MaxPhysicalMemory: DWORD64,
+    PhysicalMemoryPercent: [DWORD; HIBERFILE_TYPE_MAX],
+}}
+pub type PHIBERFILE_BUCKET = *mut HIBERFILE_BUCKET;
+STRUCT!{struct SYSTEM_POWER_CAPABILITIES {
+    PowerButtonPresent: BOOLEAN,
+    SleepButtonPresent: BOOLEAN,
+    LidPresent: BOOLEAN,
+    SystemS1: BOOLEAN,
+    SystemS2: BOOLEAN,
+    SystemS3: BOOLEAN,
+    SystemS4: BOOLEAN,
+    SystemS5: BOOLEAN,
+    HiberFilePresent: BOOLEAN,
+    FullWake: BOOLEAN,
+    VideoDimPresent: BOOLEAN,
+    ApmPresent: BOOLEAN,
+    UpsPresent: BOOLEAN,
+    ThermalControl: BOOLEAN,
+    ProcessorThrottle: BOOLEAN,
+    ProcessorMinThrottle: BYTE,
+    ProcessorMaxThrottle: BYTE,
+    FastSystemS4: BOOLEAN,
+    Hiberboot: BOOLEAN,
+    WakeAlarmPresent: BOOLEAN,
+    AoAc: BOOLEAN,
+    DiskSpinDown: BOOLEAN,
+    HiberFileType: BYTE,
+    AoAcConnectivitySupported: BOOLEAN,
+    spare3: [BYTE; 6],
+    SystemBatteriesPresent: BOOLEAN,
+    BatteriesAreShortTerm: BOOLEAN,
+    BatteryScale: [BATTERY_REPORTING_SCALE; 3],
+    AcOnLineWake: SYSTEM_POWER_STATE,
+    SoftLidWake: SYSTEM_POWER_STATE,
+    RtcWake: SYSTEM_POWER_STATE,
+    MinDeviceWakeState: SYSTEM_POWER_STATE,
+    DefaultLowLatencyWake: SYSTEM_POWER_STATE,
+}}
+pub type PSYSTEM_POWER_CAPABILITIES = *mut SYSTEM_POWER_CAPABILITIES;
+STRUCT!{struct SYSTEM_BATTERY_STATE {
+    AcOnLine: BOOLEAN,
+    BatteryPresent: BOOLEAN,
+    Charging: BOOLEAN,
+    Discharging: BOOLEAN,
+    Spare1: [BOOLEAN; 3],
+    Tag: BYTE,
+    MaxCapacity: DWORD,
+    RemainingCapacity: DWORD,
+    Rate: DWORD,
+    EstimatedTime: DWORD,
+    DefaultAlert1: DWORD,
+    DefaultAlert2: DWORD,
+}}
+pub type PSYSTEM_BATTERY_STATE = *mut SYSTEM_BATTERY_STATE;
+pub const IMAGE_DOS_SIGNATURE: WORD = 0x5A4D;
+pub const IMAGE_OS2_SIGNATURE: WORD = 0x454E;
+pub const IMAGE_OS2_SIGNATURE_LE: WORD = 0x454C;
+pub const IMAGE_VXD_SIGNATURE: WORD = 0x454C;
+pub const IMAGE_NT_SIGNATURE: DWORD = 0x00004550;
+STRUCT!{struct IMAGE_DOS_HEADER {
+    e_magic: WORD,
+    e_cblp: WORD,
+    e_cp: WORD,
+    e_crlc: WORD,
+    e_cparhdr: WORD,
+    e_minalloc: WORD,
+    e_maxalloc: WORD,
+    e_ss: WORD,
+    e_sp: WORD,
+    e_csum: WORD,
+    e_ip: WORD,
+    e_cs: WORD,
+    e_lfarlc: WORD,
+    e_ovno: WORD,
+    e_res: [WORD; 4],
+    e_oemid: WORD,
+    e_oeminfo: WORD,
+    e_res2: [WORD; 10],
+    e_lfanew: LONG,
+}}
+pub type PIMAGE_DOS_HEADER = *mut IMAGE_DOS_HEADER;
+STRUCT!{struct IMAGE_OS2_HEADER {
+    ne_magic: WORD,
+    ne_ver: CHAR,
+    ne_rev: CHAR,
+    ne_enttab: WORD,
+    ne_cbenttab: WORD,
+    ne_crc: LONG,
+    ne_flags: WORD,
+    ne_autodata: WORD,
+    ne_heap: WORD,
+    ne_stack: WORD,
+    ne_csip: LONG,
+    ne_sssp: LONG,
+    ne_cseg: WORD,
+    ne_cmod: WORD,
+    ne_cbnrestab: WORD,
+    ne_segtab: WORD,
+    ne_rsrctab: WORD,
+    ne_restab: WORD,
+    ne_modtab: WORD,
+    ne_imptab: WORD,
+    ne_nrestab: LONG,
+    ne_cmovent: WORD,
+    ne_align: WORD,
+    ne_cres: WORD,
+    ne_exetyp: BYTE,
+    ne_flagsothers: BYTE,
+    ne_pretthunks: WORD,
+    ne_psegrefbytes: WORD,
+    ne_swaparea: WORD,
+    ne_expver: WORD,
+}}
+pub type PIMAGE_OS2_HEADER = *mut IMAGE_OS2_HEADER;
+STRUCT!{struct IMAGE_VXD_HEADER {
+    e32_magic: WORD,
+    e32_border: BYTE,
+    e32_worder: BYTE,
+    e32_level: DWORD,
+    e32_cpu: WORD,
+    e32_os: WORD,
+    e32_ver: DWORD,
+    e32_mflags: DWORD,
+    e32_mpages: DWORD,
+    e32_startobj: DWORD,
+    e32_eip: DWORD,
+    e32_stackobj: DWORD,
+    e32_esp: DWORD,
+    e32_pagesize: DWORD,
+    e32_lastpagesize: DWORD,
+    e32_fixupsize: DWORD,
+    e32_fixupsum: DWORD,
+    e32_ldrsize: DWORD,
+    e32_ldrsum: DWORD,
+    e32_objtab: DWORD,
+    e32_objcnt: DWORD,
+    e32_objmap: DWORD,
+    e32_itermap: DWORD,
+    e32_rsrctab: DWORD,
+    e32_rsrccnt: DWORD,
+    e32_restab: DWORD,
+    e32_enttab: DWORD,
+    e32_dirtab: DWORD,
+    e32_dircnt: DWORD,
+    e32_fpagetab: DWORD,
+    e32_frectab: DWORD,
+    e32_impmod: DWORD,
+    e32_impmodcnt: DWORD,
+    e32_impproc: DWORD,
+    e32_pagesum: DWORD,
+    e32_datapage: DWORD,
+    e32_preload: DWORD,
+    e32_nrestab: DWORD,
+    e32_cbnrestab: DWORD,
+    e32_nressum: DWORD,
+    e32_autodata: DWORD,
+    e32_debuginfo: DWORD,
+    e32_debuglen: DWORD,
+    e32_instpreload: DWORD,
+    e32_instdemand: DWORD,
+    e32_heapsize: DWORD,
+    e32_res3: [BYTE; 12],
+    e32_winresoff: DWORD,
+    e32_winreslen: DWORD,
+    e32_devid: WORD,
+    e32_ddkver: WORD,
+}}
+pub type PIMAGE_VXD_HEADER = *mut IMAGE_VXD_HEADER;
+STRUCT!{struct IMAGE_FILE_HEADER {
+    Machine: WORD,
+    NumberOfSections: WORD,
+    TimeDateStamp: DWORD,
+    PointerToSymbolTable: DWORD,
+    NumberOfSymbols: DWORD,
+    SizeOfOptionalHeader: WORD,
+    Characteristics: WORD,
+}}
+pub type PIMAGE_FILE_HEADER = *mut IMAGE_FILE_HEADER;
+pub const IMAGE_SIZEOF_FILE_HEADER: usize = 20;
+pub const IMAGE_FILE_RELOCS_STRIPPED: WORD = 0x0001;
+pub const IMAGE_FILE_EXECUTABLE_IMAGE: WORD = 0x0002;
+pub const IMAGE_FILE_LINE_NUMS_STRIPPED: WORD = 0x0004;
+pub const IMAGE_FILE_LOCAL_SYMS_STRIPPED: WORD = 0x0008;
+pub const IMAGE_FILE_AGGRESIVE_WS_TRIM: WORD = 0x0010;
+pub const IMAGE_FILE_LARGE_ADDRESS_AWARE: WORD = 0x0020;
+pub const IMAGE_FILE_BYTES_REVERSED_LO: WORD = 0x0080;
+pub const IMAGE_FILE_32BIT_MACHINE: WORD = 0x0100;
+pub const IMAGE_FILE_DEBUG_STRIPPED: WORD = 0x0200;
+pub const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: WORD = 0x0400;
+pub const IMAGE_FILE_NET_RUN_FROM_SWAP: WORD = 0x0800;
+pub const IMAGE_FILE_SYSTEM: WORD = 0x1000;
+pub const IMAGE_FILE_DLL: WORD = 0x2000;
+pub const IMAGE_FILE_UP_SYSTEM_ONLY: WORD = 0x4000;
+pub const IMAGE_FILE_BYTES_REVERSED_HI: WORD = 0x8000;
+pub const IMAGE_FILE_MACHINE_UNKNOWN: WORD = 0;
+pub const IMAGE_FILE_MACHINE_TARGET_HOST: WORD = 0x0001;
+pub const IMAGE_FILE_MACHINE_I386: WORD = 0x014c;
+pub const IMAGE_FILE_MACHINE_R3000: WORD = 0x0162;
+pub const IMAGE_FILE_MACHINE_R4000: WORD = 0x0166;
+pub const IMAGE_FILE_MACHINE_R10000: WORD = 0x0168;
+pub const IMAGE_FILE_MACHINE_WCEMIPSV2: WORD = 0x0169;
+pub const IMAGE_FILE_MACHINE_ALPHA: WORD = 0x0184;
+pub const IMAGE_FILE_MACHINE_SH3: WORD = 0x01a2;
+pub const IMAGE_FILE_MACHINE_SH3DSP: WORD = 0x01a3;
+pub const IMAGE_FILE_MACHINE_SH3E: WORD = 0x01a4;
+pub const IMAGE_FILE_MACHINE_SH4: WORD = 0x01a6;
+pub const IMAGE_FILE_MACHINE_SH5: WORD = 0x01a8;
+pub const IMAGE_FILE_MACHINE_ARM: WORD = 0x01c0;
+pub const IMAGE_FILE_MACHINE_THUMB: WORD = 0x01c2;
+pub const IMAGE_FILE_MACHINE_ARMNT: WORD = 0x01c4;
+pub const IMAGE_FILE_MACHINE_AM33: WORD = 0x01d3;
+pub const IMAGE_FILE_MACHINE_POWERPC: WORD = 0x01F0;
+pub const IMAGE_FILE_MACHINE_POWERPCFP: WORD = 0x01f1;
+pub const IMAGE_FILE_MACHINE_IA64: WORD = 0x0200;
+pub const IMAGE_FILE_MACHINE_MIPS16: WORD = 0x0266;
+pub const IMAGE_FILE_MACHINE_ALPHA64: WORD = 0x0284;
+pub const IMAGE_FILE_MACHINE_MIPSFPU: WORD = 0x0366;
+pub const IMAGE_FILE_MACHINE_MIPSFPU16: WORD = 0x0466;
+pub const IMAGE_FILE_MACHINE_AXP64: WORD = IMAGE_FILE_MACHINE_ALPHA64;
+pub const IMAGE_FILE_MACHINE_TRICORE: WORD = 0x0520;
+pub const IMAGE_FILE_MACHINE_CEF: WORD = 0x0CEF;
+pub const IMAGE_FILE_MACHINE_EBC: WORD = 0x0EBC;
+pub const IMAGE_FILE_MACHINE_AMD64: WORD = 0x8664;
+pub const IMAGE_FILE_MACHINE_M32R: WORD = 0x9041;
+pub const IMAGE_FILE_MACHINE_ARM64: WORD = 0xAA64;
+pub const IMAGE_FILE_MACHINE_CEE: WORD = 0xC0EE;
+STRUCT!{struct IMAGE_DATA_DIRECTORY {
+    VirtualAddress: DWORD,
+    Size: DWORD,
+}}
+pub type PIMAGE_DATA_DIRECTORY = *mut IMAGE_DATA_DIRECTORY;
+pub const IMAGE_NUMBEROF_DIRECTORY_ENTRIES: usize = 16;
+STRUCT!{struct IMAGE_OPTIONAL_HEADER32 {
+    Magic: WORD,
+    MajorLinkerVersion: BYTE,
+    MinorLinkerVersion: BYTE,
+    SizeOfCode: DWORD,
+    SizeOfInitializedData: DWORD,
+    SizeOfUninitializedData: DWORD,
+    AddressOfEntryPoint: DWORD,
+    BaseOfCode: DWORD,
+    BaseOfData: DWORD,
+    ImageBase: DWORD,
+    SectionAlignment: DWORD,
+    FileAlignment: DWORD,
+    MajorOperatingSystemVersion: WORD,
+    MinorOperatingSystemVersion: WORD,
+    MajorImageVersion: WORD,
+    MinorImageVersion: WORD,
+    MajorSubsystemVersion: WORD,
+    MinorSubsystemVersion: WORD,
+    Win32VersionValue: DWORD,
+    SizeOfImage: DWORD,
+    SizeOfHeaders: DWORD,
+    CheckSum: DWORD,
+    Subsystem: WORD,
+    DllCharacteristics: WORD,
+    SizeOfStackReserve: DWORD,
+    SizeOfStackCommit: DWORD,
+    SizeOfHeapReserve: DWORD,
+    SizeOfHeapCommit: DWORD,
+    LoaderFlags: DWORD,
+    NumberOfRvaAndSizes: DWORD,
+    DataDirectory: [IMAGE_DATA_DIRECTORY; IMAGE_NUMBEROF_DIRECTORY_ENTRIES],
+}}
+pub type PIMAGE_OPTIONAL_HEADER32 = *mut IMAGE_OPTIONAL_HEADER32;
+STRUCT!{struct IMAGE_ROM_OPTIONAL_HEADER {
+    Magic: WORD,
+    MajorLinkerVersion: BYTE,
+    MinorLinkerVersion: BYTE,
+    SizeOfCode: DWORD,
+    SizeOfInitializedData: DWORD,
+    SizeOfUninitializedData: DWORD,
+    AddressOfEntryPoint: DWORD,
+    BaseOfCode: DWORD,
+    BaseOfData: DWORD,
+    BaseOfBss: DWORD,
+    GprMask: DWORD,
+    CprMask: [DWORD; 4],
+    GpValue: DWORD,
+}}
+pub type PIMAGE_ROM_OPTIONAL_HEADER = *mut IMAGE_ROM_OPTIONAL_HEADER;
+STRUCT!{struct IMAGE_OPTIONAL_HEADER64 {
+    Magic: WORD,
+    MajorLinkerVersion: BYTE,
+    MinorLinkerVersion: BYTE,
+    SizeOfCode: DWORD,
+    SizeOfInitializedData: DWORD,
+    SizeOfUninitializedData: DWORD,
+    AddressOfEntryPoint: DWORD,
+    BaseOfCode: DWORD,
+    ImageBase: ULONGLONG,
+    SectionAlignment: DWORD,
+    FileAlignment: DWORD,
+    MajorOperatingSystemVersion: WORD,
+    MinorOperatingSystemVersion: WORD,
+    MajorImageVersion: WORD,
+    MinorImageVersion: WORD,
+    MajorSubsystemVersion: WORD,
+    MinorSubsystemVersion: WORD,
+    Win32VersionValue: DWORD,
+    SizeOfImage: DWORD,
+    SizeOfHeaders: DWORD,
+    CheckSum: DWORD,
+    Subsystem: WORD,
+    DllCharacteristics: WORD,
+    SizeOfStackReserve: ULONGLONG,
+    SizeOfStackCommit: ULONGLONG,
+    SizeOfHeapReserve: ULONGLONG,
+    SizeOfHeapCommit: ULONGLONG,
+    LoaderFlags: DWORD,
+    NumberOfRvaAndSizes: DWORD,
+    DataDirectory: [IMAGE_DATA_DIRECTORY; IMAGE_NUMBEROF_DIRECTORY_ENTRIES],
+}}
+pub type PIMAGE_OPTIONAL_HEADER64 = *mut IMAGE_OPTIONAL_HEADER64;
+pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC: WORD = 0x10b;
+pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC: WORD = 0x20b;
+pub const IMAGE_ROM_OPTIONAL_HDR_MAGIC: WORD = 0x107;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub type IMAGE_OPTIONAL_HEADER = IMAGE_OPTIONAL_HEADER64;
+pub type PIMAGE_OPTIONAL_HEADER = PIMAGE_OPTIONAL_HEADER64;
+pub const IMAGE_NT_OPTIONAL_HDR_MAGIC: WORD = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub type IMAGE_OPTIONAL_HEADER = IMAGE_OPTIONAL_HEADER32;
+pub type PIMAGE_OPTIONAL_HEADER = PIMAGE_OPTIONAL_HEADER32;
+pub const IMAGE_NT_OPTIONAL_HDR_MAGIC: WORD = IMAGE_NT_OPTIONAL_HDR32_MAGIC;
+}
+STRUCT!{struct IMAGE_NT_HEADERS64 {
+    Signature: DWORD,
+    FileHeader: IMAGE_FILE_HEADER,
+    OptionalHeader: IMAGE_OPTIONAL_HEADER64,
+}}
+pub type PIMAGE_NT_HEADERS64 = *mut IMAGE_NT_HEADERS64;
+STRUCT!{struct IMAGE_NT_HEADERS32 {
+    Signature: DWORD,
+    FileHeader: IMAGE_FILE_HEADER,
+    OptionalHeader: IMAGE_OPTIONAL_HEADER32,
+}}
+pub type PIMAGE_NT_HEADERS32 = *mut IMAGE_NT_HEADERS32;
+STRUCT!{struct IMAGE_ROM_HEADERS {
+    FileHeader: IMAGE_FILE_HEADER,
+    OptionalHeader: IMAGE_ROM_OPTIONAL_HEADER,
+}}
+pub type PIMAGE_ROM_HEADERS = *mut IMAGE_ROM_HEADERS;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub type IMAGE_NT_HEADERS = IMAGE_NT_HEADERS64;
+pub type PIMAGE_NT_HEADERS = PIMAGE_NT_HEADERS64;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub type IMAGE_NT_HEADERS = IMAGE_NT_HEADERS32;
+pub type PIMAGE_NT_HEADERS = PIMAGE_NT_HEADERS32;
+}
+pub const IMAGE_SUBSYSTEM_UNKNOWN: WORD = 0;
+pub const IMAGE_SUBSYSTEM_NATIVE: WORD = 1;
+pub const IMAGE_SUBSYSTEM_WINDOWS_GUI: WORD = 2;
+pub const IMAGE_SUBSYSTEM_WINDOWS_CUI: WORD = 3;
+pub const IMAGE_SUBSYSTEM_OS2_CUI: WORD = 5;
+pub const IMAGE_SUBSYSTEM_POSIX_CUI: WORD = 7;
+pub const IMAGE_SUBSYSTEM_NATIVE_WINDOWS: WORD = 8;
+pub const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: WORD = 9;
+pub const IMAGE_SUBSYSTEM_EFI_APPLICATION: WORD = 10;
+pub const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: WORD = 11;
+pub const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: WORD = 12;
+pub const IMAGE_SUBSYSTEM_EFI_ROM: WORD = 13;
+pub const IMAGE_SUBSYSTEM_XBOX: WORD = 14;
+pub const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION: WORD = 16;
+pub const IMAGE_SUBSYSTEM_XBOX_CODE_CATALOG: WORD = 17;
+pub const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA: WORD = 0x0020;
+pub const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: WORD = 0x0040;
+pub const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: WORD = 0x0080;
+pub const IMAGE_DLLCHARACTERISTICS_NX_COMPAT: WORD = 0x0100;
+pub const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: WORD = 0x0200;
+pub const IMAGE_DLLCHARACTERISTICS_NO_SEH: WORD = 0x0400;
+pub const IMAGE_DLLCHARACTERISTICS_NO_BIND: WORD = 0x0800;
+pub const IMAGE_DLLCHARACTERISTICS_APPCONTAINER: WORD = 0x1000;
+pub const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: WORD = 0x2000;
+pub const IMAGE_DLLCHARACTERISTICS_GUARD_CF: WORD = 0x4000;
+pub const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: WORD = 0x8000;
+pub const IMAGE_DIRECTORY_ENTRY_EXPORT: WORD = 0;
+pub const IMAGE_DIRECTORY_ENTRY_IMPORT: WORD = 1;
+pub const IMAGE_DIRECTORY_ENTRY_RESOURCE: WORD = 2;
+pub const IMAGE_DIRECTORY_ENTRY_EXCEPTION: WORD = 3;
+pub const IMAGE_DIRECTORY_ENTRY_SECURITY: WORD = 4;
+pub const IMAGE_DIRECTORY_ENTRY_BASERELOC: WORD = 5;
+pub const IMAGE_DIRECTORY_ENTRY_DEBUG: WORD = 6;
+pub const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE: WORD = 7;
+pub const IMAGE_DIRECTORY_ENTRY_GLOBALPTR: WORD = 8;
+pub const IMAGE_DIRECTORY_ENTRY_TLS: WORD = 9;
+pub const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG: WORD = 10;
+pub const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT: WORD = 11;
+pub const IMAGE_DIRECTORY_ENTRY_IAT: WORD = 12;
+pub const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT: WORD = 13;
+pub const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR: WORD = 14;
+STRUCT!{struct ANON_OBJECT_HEADER {
+    Sig1: WORD,
+    Sig2: WORD,
+    Version: WORD,
+    Machine: WORD,
+    TimeDateStamp: DWORD,
+    ClassID: CLSID,
+    SizeOfData: DWORD,
+}}
+STRUCT!{struct ANON_OBJECT_HEADER_V2 {
+    Sig1: WORD,
+    Sig2: WORD,
+    Version: WORD,
+    Machine: WORD,
+    TimeDateStamp: DWORD,
+    ClassID: CLSID,
+    SizeOfData: DWORD,
+    Flags: DWORD,
+    MetaDataSize: DWORD,
+    MetaDataOffset: DWORD,
+}}
+STRUCT!{struct ANON_OBJECT_HEADER_BIGOBJ {
+    Sig1: WORD,
+    Sig2: WORD,
+    Version: WORD,
+    Machine: WORD,
+    TimeDateStamp: DWORD,
+    ClassID: CLSID,
+    SizeOfData: DWORD,
+    Flags: DWORD,
+    MetaDataSize: DWORD,
+    MetaDataOffset: DWORD,
+    NumberOfSections: DWORD,
+    PointerToSymbolTable: DWORD,
+    NumberOfSymbols: DWORD,
+}}
+pub const IMAGE_SIZEOF_SHORT_NAME: usize = 8;
+UNION!{union IMAGE_SECTION_HEADER_Misc {
+    [u32; 1],
+    PhysicalAddress PhysicalAddress_mut: DWORD,
+    VirtualSize VirtualSize_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_SECTION_HEADER {
+    Name: [BYTE; IMAGE_SIZEOF_SHORT_NAME],
+    Misc: IMAGE_SECTION_HEADER_Misc,
+    VirtualAddress: DWORD,
+    SizeOfRawData: DWORD,
+    PointerToRawData: DWORD,
+    PointerToRelocations: DWORD,
+    PointerToLinenumbers: DWORD,
+    NumberOfRelocations: WORD,
+    NumberOfLinenumbers: WORD,
+    Characteristics: DWORD,
+}}
+pub type PIMAGE_SECTION_HEADER = *mut IMAGE_SECTION_HEADER;
+pub const IMAGE_SIZEOF_SECTION_HEADER: usize = 40;
+pub const IMAGE_SCN_TYPE_NO_PAD: DWORD = 0x00000008;
+pub const IMAGE_SCN_CNT_CODE: DWORD = 0x00000020;
+pub const IMAGE_SCN_CNT_INITIALIZED_DATA: DWORD = 0x00000040;
+pub const IMAGE_SCN_CNT_UNINITIALIZED_DATA: DWORD = 0x00000080;
+pub const IMAGE_SCN_LNK_OTHER: DWORD = 0x00000100;
+pub const IMAGE_SCN_LNK_INFO: DWORD = 0x00000200;
+pub const IMAGE_SCN_LNK_REMOVE: DWORD = 0x00000800;
+pub const IMAGE_SCN_LNK_COMDAT: DWORD = 0x00001000;
+pub const IMAGE_SCN_NO_DEFER_SPEC_EXC: DWORD = 0x00004000;
+pub const IMAGE_SCN_GPREL: DWORD = 0x00008000;
+pub const IMAGE_SCN_MEM_FARDATA: DWORD = 0x00008000;
+pub const IMAGE_SCN_MEM_PURGEABLE: DWORD = 0x00020000;
+pub const IMAGE_SCN_MEM_16BIT: DWORD = 0x00020000;
+pub const IMAGE_SCN_MEM_LOCKED: DWORD = 0x00040000;
+pub const IMAGE_SCN_MEM_PRELOAD: DWORD = 0x00080000;
+pub const IMAGE_SCN_ALIGN_1BYTES: DWORD = 0x00100000;
+pub const IMAGE_SCN_ALIGN_2BYTES: DWORD = 0x00200000;
+pub const IMAGE_SCN_ALIGN_4BYTES: DWORD = 0x00300000;
+pub const IMAGE_SCN_ALIGN_8BYTES: DWORD = 0x00400000;
+pub const IMAGE_SCN_ALIGN_16BYTES: DWORD = 0x00500000;
+pub const IMAGE_SCN_ALIGN_32BYTES: DWORD = 0x00600000;
+pub const IMAGE_SCN_ALIGN_64BYTES: DWORD = 0x00700000;
+pub const IMAGE_SCN_ALIGN_128BYTES: DWORD = 0x00800000;
+pub const IMAGE_SCN_ALIGN_256BYTES: DWORD = 0x00900000;
+pub const IMAGE_SCN_ALIGN_512BYTES: DWORD = 0x00A00000;
+pub const IMAGE_SCN_ALIGN_1024BYTES: DWORD = 0x00B00000;
+pub const IMAGE_SCN_ALIGN_2048BYTES: DWORD = 0x00C00000;
+pub const IMAGE_SCN_ALIGN_4096BYTES: DWORD = 0x00D00000;
+pub const IMAGE_SCN_ALIGN_8192BYTES: DWORD = 0x00E00000;
+pub const IMAGE_SCN_ALIGN_MASK: DWORD = 0x00F00000;
+pub const IMAGE_SCN_LNK_NRELOC_OVFL: DWORD = 0x01000000;
+pub const IMAGE_SCN_MEM_DISCARDABLE: DWORD = 0x02000000;
+pub const IMAGE_SCN_MEM_NOT_CACHED: DWORD = 0x04000000;
+pub const IMAGE_SCN_MEM_NOT_PAGED: DWORD = 0x08000000;
+pub const IMAGE_SCN_MEM_SHARED: DWORD = 0x10000000;
+pub const IMAGE_SCN_MEM_EXECUTE: DWORD = 0x20000000;
+pub const IMAGE_SCN_MEM_READ: DWORD = 0x40000000;
+pub const IMAGE_SCN_MEM_WRITE: DWORD = 0x80000000;
+pub const IMAGE_SCN_SCALE_INDEX: DWORD = 0x00000001;
+STRUCT!{struct IMAGE_SYMBOL_N_Name {
+    Short: DWORD,
+    Long: DWORD,
+}}
+UNION!{union IMAGE_SYMBOL_N {
+    [u32; 2],
+    ShortName ShortName_mut: [BYTE; 8],
+    Name Name_mut: IMAGE_SYMBOL_N_Name,
+    LongName LongName_mut: [DWORD; 2],
+}}
+STRUCT!{struct IMAGE_SYMBOL {
+    N: IMAGE_SYMBOL_N,
+    Value: DWORD,
+    SectionNumber: SHORT,
+    Type: WORD,
+    StorageClass: BYTE,
+    NumberOfAuxSymbols: BYTE,
+}}
+pub type PIMAGE_SYMBOL = *mut IMAGE_SYMBOL;
+pub const IMAGE_SIZEOF_SYMBOL: usize = 18;
+STRUCT!{struct IMAGE_SYMBOL_EX_N_Name {
+    Short: DWORD,
+    Long: DWORD,
+}}
+UNION!{union IMAGE_SYMBOL_EX_N {
+    [u32; 2],
+    ShortName ShortName_mut: [BYTE; 8],
+    Name Name_mut: IMAGE_SYMBOL_EX_N_Name,
+    LongName LongName_mut: [DWORD; 2],
+}}
+STRUCT!{struct IMAGE_SYMBOL_EX {
+    N: IMAGE_SYMBOL_EX_N,
+    Value: DWORD,
+    SectionNumber: LONG,
+    Type: WORD,
+    StorageClass: BYTE,
+    NumberOfAuxSymbols: BYTE,
+}}
+pub type PIMAGE_SYMBOL_EX = *mut IMAGE_SYMBOL_EX;
+pub const IMAGE_SYM_UNDEFINED: SHORT = 0;
+pub const IMAGE_SYM_ABSOLUTE: SHORT = -1;
+pub const IMAGE_SYM_DEBUG: SHORT = -2;
+pub const IMAGE_SYM_SECTION_MAX: USHORT = 0xFEFF;
+pub const IMAGE_SYM_SECTION_MAX_EX: LONG = MAXLONG;
+pub const IMAGE_SYM_TYPE_NULL: WORD = 0x0000;
+pub const IMAGE_SYM_TYPE_VOID: WORD = 0x0001;
+pub const IMAGE_SYM_TYPE_CHAR: WORD = 0x0002;
+pub const IMAGE_SYM_TYPE_SHORT: WORD = 0x0003;
+pub const IMAGE_SYM_TYPE_INT: WORD = 0x0004;
+pub const IMAGE_SYM_TYPE_LONG: WORD = 0x0005;
+pub const IMAGE_SYM_TYPE_FLOAT: WORD = 0x0006;
+pub const IMAGE_SYM_TYPE_DOUBLE: WORD = 0x0007;
+pub const IMAGE_SYM_TYPE_STRUCT: WORD = 0x0008;
+pub const IMAGE_SYM_TYPE_UNION: WORD = 0x0009;
+pub const IMAGE_SYM_TYPE_ENUM: WORD = 0x000A;
+pub const IMAGE_SYM_TYPE_MOE: WORD = 0x000B;
+pub const IMAGE_SYM_TYPE_BYTE: WORD = 0x000C;
+pub const IMAGE_SYM_TYPE_WORD: WORD = 0x000D;
+pub const IMAGE_SYM_TYPE_UINT: WORD = 0x000E;
+pub const IMAGE_SYM_TYPE_DWORD: WORD = 0x000F;
+pub const IMAGE_SYM_TYPE_PCODE: WORD = 0x8000;
+pub const IMAGE_SYM_DTYPE_NULL: WORD = 0;
+pub const IMAGE_SYM_DTYPE_POINTER: WORD = 1;
+pub const IMAGE_SYM_DTYPE_FUNCTION: WORD = 2;
+pub const IMAGE_SYM_DTYPE_ARRAY: WORD = 3;
+pub const IMAGE_SYM_CLASS_END_OF_FUNCTION: BYTE = -1i8 as u8;
+pub const IMAGE_SYM_CLASS_NULL: BYTE = 0x0000;
+pub const IMAGE_SYM_CLASS_AUTOMATIC: BYTE = 0x0001;
+pub const IMAGE_SYM_CLASS_EXTERNAL: BYTE = 0x0002;
+pub const IMAGE_SYM_CLASS_STATIC: BYTE = 0x0003;
+pub const IMAGE_SYM_CLASS_REGISTER: BYTE = 0x0004;
+pub const IMAGE_SYM_CLASS_EXTERNAL_DEF: BYTE = 0x0005;
+pub const IMAGE_SYM_CLASS_LABEL: BYTE = 0x0006;
+pub const IMAGE_SYM_CLASS_UNDEFINED_LABEL: BYTE = 0x0007;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_STRUCT: BYTE = 0x0008;
+pub const IMAGE_SYM_CLASS_ARGUMENT: BYTE = 0x0009;
+pub const IMAGE_SYM_CLASS_STRUCT_TAG: BYTE = 0x000A;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_UNION: BYTE = 0x000B;
+pub const IMAGE_SYM_CLASS_UNION_TAG: BYTE = 0x000C;
+pub const IMAGE_SYM_CLASS_TYPE_DEFINITION: BYTE = 0x000D;
+pub const IMAGE_SYM_CLASS_UNDEFINED_STATIC: BYTE = 0x000E;
+pub const IMAGE_SYM_CLASS_ENUM_TAG: BYTE = 0x000F;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_ENUM: BYTE = 0x0010;
+pub const IMAGE_SYM_CLASS_REGISTER_PARAM: BYTE = 0x0011;
+pub const IMAGE_SYM_CLASS_BIT_FIELD: BYTE = 0x0012;
+pub const IMAGE_SYM_CLASS_FAR_EXTERNAL: BYTE = 0x0044;
+pub const IMAGE_SYM_CLASS_BLOCK: BYTE = 0x0064;
+pub const IMAGE_SYM_CLASS_FUNCTION: BYTE = 0x0065;
+pub const IMAGE_SYM_CLASS_END_OF_STRUCT: BYTE = 0x0066;
+pub const IMAGE_SYM_CLASS_FILE: BYTE = 0x0067;
+pub const IMAGE_SYM_CLASS_SECTION: BYTE = 0x0068;
+pub const IMAGE_SYM_CLASS_WEAK_EXTERNAL: BYTE = 0x0069;
+pub const IMAGE_SYM_CLASS_CLR_TOKEN: BYTE = 0x006B;
+pub const N_BTMASK: WORD = 0x000F;
+pub const N_TMASK: WORD = 0x0030;
+pub const N_TMASK1: WORD = 0x00C0;
+pub const N_TMASK2: WORD = 0x00F0;
+pub const N_BTSHFT: usize = 4;
+pub const N_TSHIFT: usize = 2;
+#[inline]
+pub fn BTYPE(x: WORD) -> bool {
+    (x & N_BTMASK) != 0
+}
+#[inline]
+pub fn ISPTR(x: WORD) -> bool {
+    (x & N_TMASK) == (IMAGE_SYM_DTYPE_POINTER << N_BTSHFT)
+}
+#[inline]
+pub fn ISFCN(x: WORD) -> bool {
+    (x & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT)
+}
+#[inline]
+pub fn ISARY(x: WORD) -> bool {
+    (x & N_TMASK) == (IMAGE_SYM_DTYPE_ARRAY << N_BTSHFT)
+}
+#[inline]
+pub fn ISTAG(x: BYTE) -> bool {
+    (x == IMAGE_SYM_CLASS_STRUCT_TAG) || (x == IMAGE_SYM_CLASS_UNION_TAG)
+    || (x == IMAGE_SYM_CLASS_ENUM_TAG)
+}
+#[inline]
+pub fn INCREF(x: WORD) -> WORD {
+    ((x & !N_BTMASK) << N_TSHIFT) | (IMAGE_SYM_DTYPE_POINTER << N_BTSHFT) | (x & N_BTMASK)
+}
+#[inline]
+pub fn DECREF(x: WORD) -> WORD {
+    ((x >> N_TSHIFT) & !N_BTMASK) | (x & N_BTMASK)
+}
+STRUCT!{struct IMAGE_AUX_SYMBOL_TOKEN_DEF {
+    bAuxType: BYTE,
+    bReserved: BYTE,
+    SymbolTableIndex: DWORD,
+    rgbReserved: [BYTE; 12],
+}}
+pub type PIMAGE_AUX_SYMBOL_TOKEN_DEF = *mut IMAGE_AUX_SYMBOL_TOKEN_DEF;
+STRUCT!{struct IMAGE_AUX_SYMBOL_Sym_Misc_LnSz {
+    Linenumber: WORD,
+    Size: WORD,
+}}
+UNION!{union IMAGE_AUX_SYMBOL_Sym_Misc {
+    [u32; 1],
+    LnSz LnSz_mut: IMAGE_AUX_SYMBOL_Sym_Misc_LnSz,
+    TotalSize TotalSize_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_Sym_FcnAry_Function {
+    PointerToLinenumber: DWORD,
+    PointerToNextFunction: DWORD,
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_Sym_FcnAry_Array {
+    Dimension: [WORD; 4],
+}}
+UNION!{union IMAGE_AUX_SYMBOL_Sym_FcnAry {
+    [u32; 2],
+    Function Function_mut: IMAGE_AUX_SYMBOL_Sym_FcnAry_Function,
+    Array Array_mut: IMAGE_AUX_SYMBOL_Sym_FcnAry_Array,
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_Sym {
+    TagIndex: DWORD,
+    Misc: IMAGE_AUX_SYMBOL_Sym_Misc,
+    FcnAry: IMAGE_AUX_SYMBOL_Sym_FcnAry,
+    TvIndex: WORD,
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_File {
+    Name: [BYTE; IMAGE_SIZEOF_SYMBOL],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_Section {
+    Length: DWORD,
+    NumberOfRelocations: WORD,
+    NumberOfLinenumbers: WORD,
+    CheckSum: DWORD,
+    Number: SHORT,
+    Selection: BYTE,
+    bReserved: BYTE,
+    HighNumber: SHORT,
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_CRC {
+    crc: DWORD,
+    rgbReserved: [BYTE; 14],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL {
+    Sym: IMAGE_AUX_SYMBOL_Sym,
+    File: IMAGE_AUX_SYMBOL_File,
+    Section: IMAGE_AUX_SYMBOL_Section,
+    TokenDef: IMAGE_AUX_SYMBOL_TOKEN_DEF,
+    CRC: IMAGE_AUX_SYMBOL_CRC,
+}}
+pub type PIMAGE_AUX_SYMBOL = *mut IMAGE_AUX_SYMBOL;
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX_Sym {
+    WeakDefaultSymIndex: DWORD,
+    WeakSearchType: DWORD,
+    rgbReserved: [BYTE; 12],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX_File {
+    Name: [BYTE; 20],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX_Section {
+    Length: DWORD,
+    NumberOfRelocations: WORD,
+    NumberOfLinenumbers: WORD,
+    CheckSum: DWORD,
+    Number: SHORT,
+    Selection: BYTE,
+    bReserved: BYTE,
+    HighNumber: SHORT,
+    rgbReserved: [BYTE; 2],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX_s {
+    TokenDef: IMAGE_AUX_SYMBOL_TOKEN_DEF,
+    rgbReserved: [BYTE; 2],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX_CRC {
+    crc: DWORD,
+    rgbReserved: [BYTE; 16],
+}}
+STRUCT!{struct IMAGE_AUX_SYMBOL_EX {
+    Sym: IMAGE_AUX_SYMBOL_EX_Sym,
+    File: IMAGE_AUX_SYMBOL_EX_File,
+    Section: IMAGE_AUX_SYMBOL_EX_Section,
+    s: IMAGE_AUX_SYMBOL_EX_s,
+    CRC: IMAGE_AUX_SYMBOL_EX_CRC,
+}}
+pub type PIMAGE_AUX_SYMBOL_EX = *mut IMAGE_AUX_SYMBOL_EX;
+ENUM!{enum IMAGE_AUX_SYMBOL_TYPE {
+    IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF = 1,
+}}
+pub const IMAGE_COMDAT_SELECT_NODUPLICATES: BYTE = 1;
+pub const IMAGE_COMDAT_SELECT_ANY: BYTE = 2;
+pub const IMAGE_COMDAT_SELECT_SAME_SIZE: BYTE = 3;
+pub const IMAGE_COMDAT_SELECT_EXACT_MATCH: BYTE = 4;
+pub const IMAGE_COMDAT_SELECT_ASSOCIATIVE: BYTE = 5;
+pub const IMAGE_COMDAT_SELECT_LARGEST: BYTE = 6;
+pub const IMAGE_COMDAT_SELECT_NEWEST: BYTE = 7;
+pub const IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY: BYTE = 1;
+pub const IMAGE_WEAK_EXTERN_SEARCH_LIBRARY: BYTE = 2;
+pub const IMAGE_WEAK_EXTERN_SEARCH_ALIAS: BYTE = 3;
+UNION!{union IMAGE_RELOCATION_u {
+    [u32; 1],
+    VirtualAddress VirtualAddress_mut: DWORD,
+    RelocCount RelocCount_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_RELOCATION {
+    u: IMAGE_RELOCATION_u,
+    SymbolTableIndex: DWORD,
+    Type: WORD,
+}}
+pub type PIMAGE_RELOCATION = *mut IMAGE_RELOCATION;
+pub const IMAGE_REL_I386_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_I386_DIR16: WORD = 0x0001;
+pub const IMAGE_REL_I386_REL16: WORD = 0x0002;
+pub const IMAGE_REL_I386_DIR32: WORD = 0x0006;
+pub const IMAGE_REL_I386_DIR32NB: WORD = 0x0007;
+pub const IMAGE_REL_I386_SEG12: WORD = 0x0009;
+pub const IMAGE_REL_I386_SECTION: WORD = 0x000A;
+pub const IMAGE_REL_I386_SECREL: WORD = 0x000B;
+pub const IMAGE_REL_I386_TOKEN: WORD = 0x000C;
+pub const IMAGE_REL_I386_SECREL7: WORD = 0x000D;
+pub const IMAGE_REL_I386_REL32: WORD = 0x0014;
+pub const IMAGE_REL_MIPS_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_MIPS_REFHALF: WORD = 0x0001;
+pub const IMAGE_REL_MIPS_REFWORD: WORD = 0x0002;
+pub const IMAGE_REL_MIPS_JMPADDR: WORD = 0x0003;
+pub const IMAGE_REL_MIPS_REFHI: WORD = 0x0004;
+pub const IMAGE_REL_MIPS_REFLO: WORD = 0x0005;
+pub const IMAGE_REL_MIPS_GPREL: WORD = 0x0006;
+pub const IMAGE_REL_MIPS_LITERAL: WORD = 0x0007;
+pub const IMAGE_REL_MIPS_SECTION: WORD = 0x000A;
+pub const IMAGE_REL_MIPS_SECREL: WORD = 0x000B;
+pub const IMAGE_REL_MIPS_SECRELLO: WORD = 0x000C;
+pub const IMAGE_REL_MIPS_SECRELHI: WORD = 0x000D;
+pub const IMAGE_REL_MIPS_TOKEN: WORD = 0x000E;
+pub const IMAGE_REL_MIPS_JMPADDR16: WORD = 0x0010;
+pub const IMAGE_REL_MIPS_REFWORDNB: WORD = 0x0022;
+pub const IMAGE_REL_MIPS_PAIR: WORD = 0x0025;
+pub const IMAGE_REL_ALPHA_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_ALPHA_REFLONG: WORD = 0x0001;
+pub const IMAGE_REL_ALPHA_REFQUAD: WORD = 0x0002;
+pub const IMAGE_REL_ALPHA_GPREL32: WORD = 0x0003;
+pub const IMAGE_REL_ALPHA_LITERAL: WORD = 0x0004;
+pub const IMAGE_REL_ALPHA_LITUSE: WORD = 0x0005;
+pub const IMAGE_REL_ALPHA_GPDISP: WORD = 0x0006;
+pub const IMAGE_REL_ALPHA_BRADDR: WORD = 0x0007;
+pub const IMAGE_REL_ALPHA_HINT: WORD = 0x0008;
+pub const IMAGE_REL_ALPHA_INLINE_REFLONG: WORD = 0x0009;
+pub const IMAGE_REL_ALPHA_REFHI: WORD = 0x000A;
+pub const IMAGE_REL_ALPHA_REFLO: WORD = 0x000B;
+pub const IMAGE_REL_ALPHA_PAIR: WORD = 0x000C;
+pub const IMAGE_REL_ALPHA_MATCH: WORD = 0x000D;
+pub const IMAGE_REL_ALPHA_SECTION: WORD = 0x000E;
+pub const IMAGE_REL_ALPHA_SECREL: WORD = 0x000F;
+pub const IMAGE_REL_ALPHA_REFLONGNB: WORD = 0x0010;
+pub const IMAGE_REL_ALPHA_SECRELLO: WORD = 0x0011;
+pub const IMAGE_REL_ALPHA_SECRELHI: WORD = 0x0012;
+pub const IMAGE_REL_ALPHA_REFQ3: WORD = 0x0013;
+pub const IMAGE_REL_ALPHA_REFQ2: WORD = 0x0014;
+pub const IMAGE_REL_ALPHA_REFQ1: WORD = 0x0015;
+pub const IMAGE_REL_ALPHA_GPRELLO: WORD = 0x0016;
+pub const IMAGE_REL_ALPHA_GPRELHI: WORD = 0x0017;
+pub const IMAGE_REL_PPC_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_PPC_ADDR64: WORD = 0x0001;
+pub const IMAGE_REL_PPC_ADDR32: WORD = 0x0002;
+pub const IMAGE_REL_PPC_ADDR24: WORD = 0x0003;
+pub const IMAGE_REL_PPC_ADDR16: WORD = 0x0004;
+pub const IMAGE_REL_PPC_ADDR14: WORD = 0x0005;
+pub const IMAGE_REL_PPC_REL24: WORD = 0x0006;
+pub const IMAGE_REL_PPC_REL14: WORD = 0x0007;
+pub const IMAGE_REL_PPC_TOCREL16: WORD = 0x0008;
+pub const IMAGE_REL_PPC_TOCREL14: WORD = 0x0009;
+pub const IMAGE_REL_PPC_ADDR32NB: WORD = 0x000A;
+pub const IMAGE_REL_PPC_SECREL: WORD = 0x000B;
+pub const IMAGE_REL_PPC_SECTION: WORD = 0x000C;
+pub const IMAGE_REL_PPC_IFGLUE: WORD = 0x000D;
+pub const IMAGE_REL_PPC_IMGLUE: WORD = 0x000E;
+pub const IMAGE_REL_PPC_SECREL16: WORD = 0x000F;
+pub const IMAGE_REL_PPC_REFHI: WORD = 0x0010;
+pub const IMAGE_REL_PPC_REFLO: WORD = 0x0011;
+pub const IMAGE_REL_PPC_PAIR: WORD = 0x0012;
+pub const IMAGE_REL_PPC_SECRELLO: WORD = 0x0013;
+pub const IMAGE_REL_PPC_SECRELHI: WORD = 0x0014;
+pub const IMAGE_REL_PPC_GPREL: WORD = 0x0015;
+pub const IMAGE_REL_PPC_TOKEN: WORD = 0x0016;
+pub const IMAGE_REL_PPC_TYPEMASK: WORD = 0x00FF;
+pub const IMAGE_REL_PPC_NEG: WORD = 0x0100;
+pub const IMAGE_REL_PPC_BRTAKEN: WORD = 0x0200;
+pub const IMAGE_REL_PPC_BRNTAKEN: WORD = 0x0400;
+pub const IMAGE_REL_PPC_TOCDEFN: WORD = 0x0800;
+pub const IMAGE_REL_SH3_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_SH3_DIRECT16: WORD = 0x0001;
+pub const IMAGE_REL_SH3_DIRECT32: WORD = 0x0002;
+pub const IMAGE_REL_SH3_DIRECT8: WORD = 0x0003;
+pub const IMAGE_REL_SH3_DIRECT8_WORD: WORD = 0x0004;
+pub const IMAGE_REL_SH3_DIRECT8_LONG: WORD = 0x0005;
+pub const IMAGE_REL_SH3_DIRECT4: WORD = 0x0006;
+pub const IMAGE_REL_SH3_DIRECT4_WORD: WORD = 0x0007;
+pub const IMAGE_REL_SH3_DIRECT4_LONG: WORD = 0x0008;
+pub const IMAGE_REL_SH3_PCREL8_WORD: WORD = 0x0009;
+pub const IMAGE_REL_SH3_PCREL8_LONG: WORD = 0x000A;
+pub const IMAGE_REL_SH3_PCREL12_WORD: WORD = 0x000B;
+pub const IMAGE_REL_SH3_STARTOF_SECTION: WORD = 0x000C;
+pub const IMAGE_REL_SH3_SIZEOF_SECTION: WORD = 0x000D;
+pub const IMAGE_REL_SH3_SECTION: WORD = 0x000E;
+pub const IMAGE_REL_SH3_SECREL: WORD = 0x000F;
+pub const IMAGE_REL_SH3_DIRECT32_NB: WORD = 0x0010;
+pub const IMAGE_REL_SH3_GPREL4_LONG: WORD = 0x0011;
+pub const IMAGE_REL_SH3_TOKEN: WORD = 0x0012;
+pub const IMAGE_REL_SHM_PCRELPT: WORD = 0x0013;
+pub const IMAGE_REL_SHM_REFLO: WORD = 0x0014;
+pub const IMAGE_REL_SHM_REFHALF: WORD = 0x0015;
+pub const IMAGE_REL_SHM_RELLO: WORD = 0x0016;
+pub const IMAGE_REL_SHM_RELHALF: WORD = 0x0017;
+pub const IMAGE_REL_SHM_PAIR: WORD = 0x0018;
+pub const IMAGE_REL_SH_NOMODE: WORD = 0x8000;
+pub const IMAGE_REL_ARM_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_ARM_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_ARM_ADDR32NB: WORD = 0x0002;
+pub const IMAGE_REL_ARM_BRANCH24: WORD = 0x0003;
+pub const IMAGE_REL_ARM_BRANCH11: WORD = 0x0004;
+pub const IMAGE_REL_ARM_TOKEN: WORD = 0x0005;
+pub const IMAGE_REL_ARM_GPREL12: WORD = 0x0006;
+pub const IMAGE_REL_ARM_GPREL7: WORD = 0x0007;
+pub const IMAGE_REL_ARM_BLX24: WORD = 0x0008;
+pub const IMAGE_REL_ARM_BLX11: WORD = 0x0009;
+pub const IMAGE_REL_ARM_SECTION: WORD = 0x000E;
+pub const IMAGE_REL_ARM_SECREL: WORD = 0x000F;
+pub const IMAGE_REL_ARM_MOV32A: WORD = 0x0010;
+pub const IMAGE_REL_ARM_MOV32: WORD = 0x0010;
+pub const IMAGE_REL_ARM_MOV32T: WORD = 0x0011;
+pub const IMAGE_REL_THUMB_MOV32: WORD = 0x0011;
+pub const IMAGE_REL_ARM_BRANCH20T: WORD = 0x0012;
+pub const IMAGE_REL_THUMB_BRANCH20: WORD = 0x0012;
+pub const IMAGE_REL_ARM_BRANCH24T: WORD = 0x0014;
+pub const IMAGE_REL_THUMB_BRANCH24: WORD = 0x0014;
+pub const IMAGE_REL_ARM_BLX23T: WORD = 0x0015;
+pub const IMAGE_REL_THUMB_BLX23: WORD = 0x0015;
+pub const IMAGE_REL_AM_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_AM_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_AM_ADDR32NB: WORD = 0x0002;
+pub const IMAGE_REL_AM_CALL32: WORD = 0x0003;
+pub const IMAGE_REL_AM_FUNCINFO: WORD = 0x0004;
+pub const IMAGE_REL_AM_REL32_1: WORD = 0x0005;
+pub const IMAGE_REL_AM_REL32_2: WORD = 0x0006;
+pub const IMAGE_REL_AM_SECREL: WORD = 0x0007;
+pub const IMAGE_REL_AM_SECTION: WORD = 0x0008;
+pub const IMAGE_REL_AM_TOKEN: WORD = 0x0009;
+pub const IMAGE_REL_ARM64_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_ARM64_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_ARM64_ADDR32NB: WORD = 0x0002;
+pub const IMAGE_REL_ARM64_BRANCH26: WORD = 0x0003;
+pub const IMAGE_REL_ARM64_PAGEBASE_REL21: WORD = 0x0004;
+pub const IMAGE_REL_ARM64_REL21: WORD = 0x0005;
+pub const IMAGE_REL_ARM64_PAGEOFFSET_12A: WORD = 0x0006;
+pub const IMAGE_REL_ARM64_PAGEOFFSET_12L: WORD = 0x0007;
+pub const IMAGE_REL_ARM64_SECREL: WORD = 0x0008;
+pub const IMAGE_REL_ARM64_SECREL_LOW12A: WORD = 0x0009;
+pub const IMAGE_REL_ARM64_SECREL_HIGH12A: WORD = 0x000A;
+pub const IMAGE_REL_ARM64_SECREL_LOW12L: WORD = 0x000B;
+pub const IMAGE_REL_ARM64_TOKEN: WORD = 0x000C;
+pub const IMAGE_REL_ARM64_SECTION: WORD = 0x000D;
+pub const IMAGE_REL_ARM64_ADDR64: WORD = 0x000E;
+pub const IMAGE_REL_ARM64_BRANCH19: WORD = 0x000F;
+pub const IMAGE_REL_AMD64_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_AMD64_ADDR64: WORD = 0x0001;
+pub const IMAGE_REL_AMD64_ADDR32: WORD = 0x0002;
+pub const IMAGE_REL_AMD64_ADDR32NB: WORD = 0x0003;
+pub const IMAGE_REL_AMD64_REL32: WORD = 0x0004;
+pub const IMAGE_REL_AMD64_REL32_1: WORD = 0x0005;
+pub const IMAGE_REL_AMD64_REL32_2: WORD = 0x0006;
+pub const IMAGE_REL_AMD64_REL32_3: WORD = 0x0007;
+pub const IMAGE_REL_AMD64_REL32_4: WORD = 0x0008;
+pub const IMAGE_REL_AMD64_REL32_5: WORD = 0x0009;
+pub const IMAGE_REL_AMD64_SECTION: WORD = 0x000A;
+pub const IMAGE_REL_AMD64_SECREL: WORD = 0x000B;
+pub const IMAGE_REL_AMD64_SECREL7: WORD = 0x000C;
+pub const IMAGE_REL_AMD64_TOKEN: WORD = 0x000D;
+pub const IMAGE_REL_AMD64_SREL32: WORD = 0x000E;
+pub const IMAGE_REL_AMD64_PAIR: WORD = 0x000F;
+pub const IMAGE_REL_AMD64_SSPAN32: WORD = 0x0010;
+pub const IMAGE_REL_IA64_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_IA64_IMM14: WORD = 0x0001;
+pub const IMAGE_REL_IA64_IMM22: WORD = 0x0002;
+pub const IMAGE_REL_IA64_IMM64: WORD = 0x0003;
+pub const IMAGE_REL_IA64_DIR32: WORD = 0x0004;
+pub const IMAGE_REL_IA64_DIR64: WORD = 0x0005;
+pub const IMAGE_REL_IA64_PCREL21B: WORD = 0x0006;
+pub const IMAGE_REL_IA64_PCREL21M: WORD = 0x0007;
+pub const IMAGE_REL_IA64_PCREL21F: WORD = 0x0008;
+pub const IMAGE_REL_IA64_GPREL22: WORD = 0x0009;
+pub const IMAGE_REL_IA64_LTOFF22: WORD = 0x000A;
+pub const IMAGE_REL_IA64_SECTION: WORD = 0x000B;
+pub const IMAGE_REL_IA64_SECREL22: WORD = 0x000C;
+pub const IMAGE_REL_IA64_SECREL64I: WORD = 0x000D;
+pub const IMAGE_REL_IA64_SECREL32: WORD = 0x000E;
+pub const IMAGE_REL_IA64_DIR32NB: WORD = 0x0010;
+pub const IMAGE_REL_IA64_SREL14: WORD = 0x0011;
+pub const IMAGE_REL_IA64_SREL22: WORD = 0x0012;
+pub const IMAGE_REL_IA64_SREL32: WORD = 0x0013;
+pub const IMAGE_REL_IA64_UREL32: WORD = 0x0014;
+pub const IMAGE_REL_IA64_PCREL60X: WORD = 0x0015;
+pub const IMAGE_REL_IA64_PCREL60B: WORD = 0x0016;
+pub const IMAGE_REL_IA64_PCREL60F: WORD = 0x0017;
+pub const IMAGE_REL_IA64_PCREL60I: WORD = 0x0018;
+pub const IMAGE_REL_IA64_PCREL60M: WORD = 0x0019;
+pub const IMAGE_REL_IA64_IMMGPREL64: WORD = 0x001A;
+pub const IMAGE_REL_IA64_TOKEN: WORD = 0x001B;
+pub const IMAGE_REL_IA64_GPREL32: WORD = 0x001C;
+pub const IMAGE_REL_IA64_ADDEND: WORD = 0x001F;
+pub const IMAGE_REL_CEF_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_CEF_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_CEF_ADDR64: WORD = 0x0002;
+pub const IMAGE_REL_CEF_ADDR32NB: WORD = 0x0003;
+pub const IMAGE_REL_CEF_SECTION: WORD = 0x0004;
+pub const IMAGE_REL_CEF_SECREL: WORD = 0x0005;
+pub const IMAGE_REL_CEF_TOKEN: WORD = 0x0006;
+pub const IMAGE_REL_CEE_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_CEE_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_CEE_ADDR64: WORD = 0x0002;
+pub const IMAGE_REL_CEE_ADDR32NB: WORD = 0x0003;
+pub const IMAGE_REL_CEE_SECTION: WORD = 0x0004;
+pub const IMAGE_REL_CEE_SECREL: WORD = 0x0005;
+pub const IMAGE_REL_CEE_TOKEN: WORD = 0x0006;
+pub const IMAGE_REL_M32R_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_M32R_ADDR32: WORD = 0x0001;
+pub const IMAGE_REL_M32R_ADDR32NB: WORD = 0x0002;
+pub const IMAGE_REL_M32R_ADDR24: WORD = 0x0003;
+pub const IMAGE_REL_M32R_GPREL16: WORD = 0x0004;
+pub const IMAGE_REL_M32R_PCREL24: WORD = 0x0005;
+pub const IMAGE_REL_M32R_PCREL16: WORD = 0x0006;
+pub const IMAGE_REL_M32R_PCREL8: WORD = 0x0007;
+pub const IMAGE_REL_M32R_REFHALF: WORD = 0x0008;
+pub const IMAGE_REL_M32R_REFHI: WORD = 0x0009;
+pub const IMAGE_REL_M32R_REFLO: WORD = 0x000A;
+pub const IMAGE_REL_M32R_PAIR: WORD = 0x000B;
+pub const IMAGE_REL_M32R_SECTION: WORD = 0x000C;
+pub const IMAGE_REL_M32R_SECREL32: WORD = 0x000D;
+pub const IMAGE_REL_M32R_TOKEN: WORD = 0x000E;
+pub const IMAGE_REL_EBC_ABSOLUTE: WORD = 0x0000;
+pub const IMAGE_REL_EBC_ADDR32NB: WORD = 0x0001;
+pub const IMAGE_REL_EBC_REL32: WORD = 0x0002;
+pub const IMAGE_REL_EBC_SECTION: WORD = 0x0003;
+pub const IMAGE_REL_EBC_SECREL: WORD = 0x0004;
+UNION!{union IMAGE_LINENUMBER_Type {
+    [u32; 1],
+    SymbolTableIndex SymbolTableIndex_mut: DWORD,
+    VirtualAddress VirtualAddress_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_LINENUMBER {
+    Type: IMAGE_LINENUMBER_Type,
+    Linenumber: WORD,
+}}
+pub type PIMAGE_LINENUMBER = *mut IMAGE_LINENUMBER;
+STRUCT!{struct IMAGE_BASE_RELOCATION {
+    VirtualAddress: DWORD,
+    SizeOfBlock: DWORD,
+}}
+pub type PIMAGE_BASE_RELOCATION = *mut IMAGE_BASE_RELOCATION;
+pub const IMAGE_REL_BASED_ABSOLUTE: WORD = 0;
+pub const IMAGE_REL_BASED_HIGH: WORD = 1;
+pub const IMAGE_REL_BASED_LOW: WORD = 2;
+pub const IMAGE_REL_BASED_HIGHLOW: WORD = 3;
+pub const IMAGE_REL_BASED_HIGHADJ: WORD = 4;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_5: WORD = 5;
+pub const IMAGE_REL_BASED_RESERVED: WORD = 6;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_7: WORD = 7;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_8: WORD = 8;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_9: WORD = 9;
+pub const IMAGE_REL_BASED_DIR64: WORD = 10;
+pub const IMAGE_REL_BASED_IA64_IMM64: WORD = 9;
+pub const IMAGE_REL_BASED_MIPS_JMPADDR: WORD = 5;
+pub const IMAGE_REL_BASED_MIPS_JMPADDR16: WORD = 9;
+pub const IMAGE_REL_BASED_ARM_MOV32: WORD = 5;
+pub const IMAGE_REL_BASED_THUMB_MOV32: WORD = 7;
+pub const IMAGE_ARCHIVE_START_SIZE: usize = 8;
+pub const IMAGE_ARCHIVE_START: &'static str = "!<arch>\n";
+pub const IMAGE_ARCHIVE_END: &'static str = "`\n";
+pub const IMAGE_ARCHIVE_PAD: &'static str = "\n";
+pub const IMAGE_ARCHIVE_LINKER_MEMBER: &'static str = "/               ";
+pub const IMAGE_ARCHIVE_LONGNAMES_MEMBER: &'static str = "//              ";
+pub const IMAGE_ARCHIVE_HYBRIDMAP_MEMBER: &'static str = "/<HYBRIDMAP>/   ";
+STRUCT!{struct IMAGE_ARCHIVE_MEMBER_HEADER {
+    Name: [BYTE; 16],
+    Date: [BYTE; 12],
+    UserID: [BYTE; 6],
+    GroupID: [BYTE; 6],
+    Mode: [BYTE; 8],
+    Size: [BYTE; 10],
+    EndHeader: [BYTE; 2],
+}}
+pub type PIMAGE_ARCHIVE_MEMBER_HEADER = *mut IMAGE_ARCHIVE_MEMBER_HEADER;
+pub const IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR: usize = 60;
+STRUCT!{struct IMAGE_EXPORT_DIRECTORY {
+    Characteristics: DWORD,
+    TimeDateStamp: DWORD,
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+    Name: DWORD,
+    Base: DWORD,
+    NumberOfFunctions: DWORD,
+    NumberOfNames: DWORD,
+    AddressOfFunctions: DWORD,
+    AddressOfNames: DWORD,
+    AddressOfNameOrdinals: DWORD,
+}}
+pub type PIMAGE_EXPORT_DIRECTORY = *mut IMAGE_EXPORT_DIRECTORY;
+STRUCT!{struct IMAGE_IMPORT_BY_NAME {
+    Hint: WORD,
+    Name: [CHAR; 1],
+}}
+pub type PIMAGE_IMPORT_BY_NAME = *mut IMAGE_IMPORT_BY_NAME;
+UNION!{union IMAGE_THUNK_DATA64_u1 {
+    [u64; 1],
+    ForwarderString ForwarderString_mut: ULONGLONG,
+    Function Function_mut: ULONGLONG,
+    Ordinal Ordinal_mut: ULONGLONG,
+    AddressOfData AddressOfData_mut: ULONGLONG,
+}}
+STRUCT!{struct IMAGE_THUNK_DATA64 {
+    u1: IMAGE_THUNK_DATA64_u1,
+}}
+pub type PIMAGE_THUNK_DATA64 = *mut IMAGE_THUNK_DATA64;
+UNION!{union IMAGE_THUNK_DATA32_u1 {
+    [u32; 1],
+    ForwarderString ForwarderString_mut: DWORD,
+    Function Function_mut: DWORD,
+    Ordinal Ordinal_mut: DWORD,
+    AddressOfData AddressOfData_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_THUNK_DATA32 {
+    u1: IMAGE_THUNK_DATA32_u1,
+}}
+pub type PIMAGE_THUNK_DATA32 = *mut IMAGE_THUNK_DATA32;
+pub const IMAGE_ORDINAL_FLAG64: ULONGLONG = 0x8000000000000000;
+pub const IMAGE_ORDINAL_FLAG32: DWORD = 0x80000000;
+#[inline]
+pub fn IMAGE_ORDINAL64(Ordinal: ULONGLONG) -> ULONGLONG {
+    Ordinal & 0xffff
+}
+#[inline]
+pub fn IMAGE_ORDINAL32(Ordinal: DWORD) -> DWORD {
+    Ordinal & 0xffff
+}
+#[inline]
+pub fn IMAGE_SNAP_BY_ORDINAL64(Ordinal: ULONGLONG) -> bool {
+    (Ordinal & IMAGE_ORDINAL_FLAG64) != 0
+}
+#[inline]
+pub fn IMAGE_SNAP_BY_ORDINAL32(Ordinal: DWORD) -> bool {
+    (Ordinal & IMAGE_ORDINAL_FLAG32) != 0
+}
+FN!{stdcall PIMAGE_TLS_CALLBACK(
+    DllHandle: PVOID,
+    Reason: DWORD,
+    Reserved: PVOID,
+) -> ()}
+STRUCT!{struct IMAGE_TLS_DIRECTORY64 {
+    StartAddressOfRawData: ULONGLONG,
+    EndAddressOfRawData: ULONGLONG,
+    AddressOfIndex: ULONGLONG,
+    AddressOfCallBacks: ULONGLONG,
+    SizeOfZeroFill: DWORD,
+    Characteristics: DWORD,
+}}
+BITFIELD!{IMAGE_TLS_DIRECTORY64 Characteristics: DWORD [
+    Reserved0 set_Reserved0[0..20],
+    Alignment set_Alignment[20..24],
+    Reserved1 set_Reserved1[24..32],
+]}
+pub type PIMAGE_TLS_DIRECTORY64 = *mut IMAGE_TLS_DIRECTORY64;
+STRUCT!{struct IMAGE_TLS_DIRECTORY32 {
+    StartAddressOfRawData: DWORD,
+    EndAddressOfRawData: DWORD,
+    AddressOfIndex: DWORD,
+    AddressOfCallBacks: DWORD,
+    SizeOfZeroFill: DWORD,
+    Characteristics: DWORD,
+}}
+BITFIELD!{IMAGE_TLS_DIRECTORY32 Characteristics: DWORD [
+    Reserved0 set_Reserved0[0..20],
+    Alignment set_Alignment[20..24],
+    Reserved1 set_Reserved1[24..32],
+]}
+pub type PIMAGE_TLS_DIRECTORY32 = *mut IMAGE_TLS_DIRECTORY32;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub const IMAGE_ORDINAL_FLAG: ULONGLONG = IMAGE_ORDINAL_FLAG64;
+#[inline]
+pub fn IMAGE_ORDINAL(Ordinal: ULONGLONG) -> ULONGLONG {
+    IMAGE_ORDINAL64(Ordinal)
+}
+pub type IMAGE_THUNK_DATA = IMAGE_THUNK_DATA64;
+pub type PIMAGE_THUNK_DATA = PIMAGE_THUNK_DATA64;
+#[inline]
+pub fn IMAGE_SNAP_BY_ORDINAL(Ordinal: ULONGLONG) -> bool {
+    IMAGE_SNAP_BY_ORDINAL64(Ordinal)
+}
+pub type IMAGE_TLS_DIRECTORY = IMAGE_TLS_DIRECTORY64;
+pub type PIMAGE_TLS_DIRECTORY = PIMAGE_TLS_DIRECTORY64;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub const IMAGE_ORDINAL_FLAG: DWORD = IMAGE_ORDINAL_FLAG32;
+#[inline]
+pub fn IMAGE_ORDINAL(Ordinal: DWORD) -> DWORD {
+    IMAGE_ORDINAL32(Ordinal)
+}
+pub type IMAGE_THUNK_DATA = IMAGE_THUNK_DATA32;
+pub type PIMAGE_THUNK_DATA = PIMAGE_THUNK_DATA32;
+#[inline]
+pub fn IMAGE_SNAP_BY_ORDINAL(Ordinal: DWORD) -> bool {
+    IMAGE_SNAP_BY_ORDINAL32(Ordinal)
+}
+pub type IMAGE_TLS_DIRECTORY = IMAGE_TLS_DIRECTORY32;
+pub type PIMAGE_TLS_DIRECTORY = PIMAGE_TLS_DIRECTORY32;
+}
+UNION!{union IMAGE_IMPORT_DESCRIPTOR_u {
+    [u32; 1],
+    Characteristics Characteristics_mut: DWORD,
+    OriginalFirstThunk OriginalFirstThunk_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_IMPORT_DESCRIPTOR {
+    u: IMAGE_IMPORT_DESCRIPTOR_u,
+    TimeDateStamp: DWORD,
+    ForwarderChain: DWORD,
+    Name: DWORD,
+    FirstThunk: DWORD,
+}}
+pub type PIMAGE_IMPORT_DESCRIPTOR = *mut IMAGE_IMPORT_DESCRIPTOR;
+STRUCT!{struct IMAGE_BOUND_IMPORT_DESCRIPTOR {
+    TimeDateStamp: DWORD,
+    OffsetModuleName: WORD,
+    NumberOfModuleForwarderRefs: WORD,
+}}
+pub type PIMAGE_BOUND_IMPORT_DESCRIPTOR = *mut IMAGE_BOUND_IMPORT_DESCRIPTOR;
+STRUCT!{struct IMAGE_BOUND_FORWARDER_REF {
+    TimeDateStamp: DWORD,
+    OffsetModuleName: WORD,
+    Reserved: WORD,
+}}
+pub type PIMAGE_BOUND_FORWARDER_REF = *mut IMAGE_BOUND_FORWARDER_REF;
+STRUCT!{struct IMAGE_DELAYLOAD_DESCRIPTOR_Attributes {
+    AllAttributes: DWORD,
+}}
+BITFIELD!{IMAGE_DELAYLOAD_DESCRIPTOR_Attributes AllAttributes: DWORD [
+    RvaBased set_RvaBased[0..1],
+    ReservedAttributes set_ReservedAttributes[1..32],
+]}
+STRUCT!{struct IMAGE_DELAYLOAD_DESCRIPTOR {
+    Attributes: IMAGE_DELAYLOAD_DESCRIPTOR_Attributes,
+    DllNameRVA: DWORD,
+    ModuleHandleRVA: DWORD,
+    ImportAddressTableRVA: DWORD,
+    ImportNameTableRVA: DWORD,
+    BoundImportAddressTableRVA: DWORD,
+    UnloadInformationTableRVA: DWORD,
+    TimeDateStamp: DWORD,
+}}
+pub type PIMAGE_DELAYLOAD_DESCRIPTOR = *mut IMAGE_DELAYLOAD_DESCRIPTOR;
+pub type PCIMAGE_DELAYLOAD_DESCRIPTOR = *const IMAGE_DELAYLOAD_DESCRIPTOR;
+STRUCT!{struct IMAGE_RESOURCE_DIRECTORY {
+    Characteristics: DWORD,
+    TimeDateStamp: DWORD,
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+    NumberOfNamedEntries: WORD,
+    NumberOfIdEntries: WORD,
+}}
+pub type PIMAGE_RESOURCE_DIRECTORY = *mut IMAGE_RESOURCE_DIRECTORY;
+pub const IMAGE_RESOURCE_NAME_IS_STRING: DWORD = 0x80000000;
+pub const IMAGE_RESOURCE_DATA_IS_DIRECTORY: DWORD = 0x80000000;
+STRUCT!{struct IMAGE_RESOURCE_DIRECTORY_ENTRY_u_s {
+    BitFields: DWORD,
+}}
+BITFIELD!{IMAGE_RESOURCE_DIRECTORY_ENTRY_u_s BitFields: DWORD [
+    NameOffset set_NameOffset[0..31],
+    NameIsString set_NameIsString[31..32],
+]}
+UNION!{union IMAGE_RESOURCE_DIRECTORY_ENTRY_u {
+    [u32; 1],
+    s s_mut: IMAGE_RESOURCE_DIRECTORY_ENTRY_u_s,
+    Name Name_mut: DWORD,
+    Id Id_mut: WORD,
+}}
+STRUCT!{struct IMAGE_RESOURCE_DIRECTORY_ENTRY {
+    u: IMAGE_RESOURCE_DIRECTORY_ENTRY_u,
+    OffsetToData: DWORD,
+}}
+BITFIELD!{IMAGE_RESOURCE_DIRECTORY_ENTRY OffsetToData: DWORD [
+    OffsetToDirectory set_OffsetToDirectory[0..31],
+    DataIsDirectory set_DataIsDirectory[31..32],
+]}
+pub type PIMAGE_RESOURCE_DIRECTORY_ENTRY = *mut IMAGE_RESOURCE_DIRECTORY_ENTRY;
+STRUCT!{struct IMAGE_RESOURCE_DIRECTORY_STRING {
+    Length: WORD,
+    NameString: [CHAR; 1],
+}}
+pub type PIMAGE_RESOURCE_DIRECTORY_STRING = *mut IMAGE_RESOURCE_DIRECTORY_STRING;
+STRUCT!{struct IMAGE_RESOURCE_DIR_STRING_U {
+    Length: WORD,
+    NameString: [WCHAR; 1],
+}}
+pub type PIMAGE_RESOURCE_DIR_STRING_U = *mut IMAGE_RESOURCE_DIR_STRING_U;
+STRUCT!{struct IMAGE_RESOURCE_DATA_ENTRY {
+    OffsetToData: DWORD,
+    Size: DWORD,
+    CodePage: DWORD,
+    Reserved: DWORD,
+}}
+pub type PIMAGE_RESOURCE_DATA_ENTRY = *mut IMAGE_RESOURCE_DATA_ENTRY;
+STRUCT!{struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
+    Flags: WORD,
+    Catalog: WORD,
+    CatalogOffset: DWORD,
+    Reserved: DWORD,
+}}
+pub type PIMAGE_LOAD_CONFIG_CODE_INTEGRITY = *mut IMAGE_LOAD_CONFIG_CODE_INTEGRITY;
+STRUCT!{struct IMAGE_DYNAMIC_RELOCATION_TABLE {
+    Version: DWORD,
+    Size: DWORD,
+}}
+pub type PIMAGE_DYNAMIC_RELOCATION_TABLE = *mut IMAGE_DYNAMIC_RELOCATION_TABLE;
+STRUCT!{#[repr(packed)] struct IMAGE_DYNAMIC_RELOCATION32 {
+    Symbol: DWORD,
+    BaseRelocSize: DWORD,
+}}
+pub type PIMAGE_DYNAMIC_RELOCATION32 = *mut IMAGE_DYNAMIC_RELOCATION32;
+STRUCT!{#[repr(packed)] struct IMAGE_DYNAMIC_RELOCATION64 {
+    Symbol: ULONGLONG,
+    BaseRelocSize: DWORD,
+}}
+pub type PIMAGE_DYNAMIC_RELOCATION64 = *mut IMAGE_DYNAMIC_RELOCATION64;
+STRUCT!{#[repr(packed)] struct IMAGE_DYNAMIC_RELOCATION32_V2 {
+    HeaderSize: DWORD,
+    FixupInfoSize: DWORD,
+    Symbol: DWORD,
+    SymbolGroup: DWORD,
+    Flags: DWORD,
+}}
+pub type PIMAGE_DYNAMIC_RELOCATION32_V2 = *mut IMAGE_DYNAMIC_RELOCATION32_V2;
+STRUCT!{#[repr(packed)] struct IMAGE_DYNAMIC_RELOCATION64_V2 {
+    HeaderSize: DWORD,
+    FixupInfoSize: DWORD,
+    Symbol: ULONGLONG,
+    SymbolGroup: DWORD,
+    Flags: DWORD,
+}}
+pub type PIMAGE_DYNAMIC_RELOCATION64_V2 = *mut IMAGE_DYNAMIC_RELOCATION64_V2;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub type IMAGE_DYNAMIC_RELOCATION = IMAGE_DYNAMIC_RELOCATION64;
+pub type PIMAGE_DYNAMIC_RELOCATION = PIMAGE_DYNAMIC_RELOCATION64;
+pub type IMAGE_DYNAMIC_RELOCATION_V2 = IMAGE_DYNAMIC_RELOCATION64_V2;
+pub type PIMAGE_DYNAMIC_RELOCATION_V2 = PIMAGE_DYNAMIC_RELOCATION64_V2;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub type IMAGE_DYNAMIC_RELOCATION = IMAGE_DYNAMIC_RELOCATION32;
+pub type PIMAGE_DYNAMIC_RELOCATION = PIMAGE_DYNAMIC_RELOCATION32;
+pub type IMAGE_DYNAMIC_RELOCATION_V2 = IMAGE_DYNAMIC_RELOCATION32_V2;
+pub type PIMAGE_DYNAMIC_RELOCATION_V2 = PIMAGE_DYNAMIC_RELOCATION32_V2;
+}
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_PROLOGUE: DWORD = 0x00000001;
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_EPILOGUE: DWORD = 0x00000002;
+STRUCT!{#[repr(packed)] struct IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER {
+    PrologueByteCount: BYTE,
+}}
+pub type PIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER = *mut IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER;
+STRUCT!{#[repr(packed)] struct IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER {
+    EpilogueCount: DWORD,
+    EpilogueByteCount: BYTE,
+    BranchDescriptorElementSize: BYTE,
+    BranchDescriptorCount: WORD,
+}}
+pub type PIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER = *mut IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER;
+STRUCT!{struct IMAGE_LOAD_CONFIG_DIRECTORY32 {
+    Size: DWORD,
+    TimeDateStamp: DWORD,
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+    GlobalFlagsClear: DWORD,
+    GlobalFlagsSet: DWORD,
+    CriticalSectionDefaultTimeout: DWORD,
+    DeCommitFreeBlockThreshold: DWORD,
+    DeCommitTotalFreeThreshold: DWORD,
+    LockPrefixTable: DWORD,
+    MaximumAllocationSize: DWORD,
+    VirtualMemoryThreshold: DWORD,
+    ProcessHeapFlags: DWORD,
+    ProcessAffinityMask: DWORD,
+    CSDVersion: WORD,
+    DependentLoadFlags: WORD,
+    EditList: DWORD,
+    SecurityCookie: DWORD,
+    SEHandlerTable: DWORD,
+    SEHandlerCount: DWORD,
+    GuardCFCheckFunctionPointer: DWORD,
+    GuardCFDispatchFunctionPointer: DWORD,
+    GuardCFFunctionTable: DWORD,
+    GuardCFFunctionCount: DWORD,
+    GuardFlags: DWORD,
+    CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
+    GuardAddressTakenIatEntryTable: DWORD,
+    GuardAddressTakenIatEntryCount: DWORD,
+    GuardLongJumpTargetTable: DWORD,
+    GuardLongJumpTargetCount: DWORD,
+    DynamicValueRelocTable: DWORD,
+    CHPEMetadataPointer: DWORD,
+    GuardRFFailureRoutine: DWORD,
+    GuardRFFailureRoutineFunctionPointer: DWORD,
+    DynamicValueRelocTableOffset: DWORD,
+    DynamicValueRelocTableSection: WORD,
+    Reserved2: WORD,
+    GuardRFVerifyStackPointerFunctionPointer: DWORD,
+    HotPatchTableOffset: DWORD,
+    Reserved3: DWORD,
+    EnclaveConfigurationPointer: DWORD,
+}}
+pub type PIMAGE_LOAD_CONFIG_DIRECTORY32 = *mut IMAGE_LOAD_CONFIG_DIRECTORY32;
+STRUCT!{struct IMAGE_LOAD_CONFIG_DIRECTORY64 {
+    Size: DWORD,
+    TimeDateStamp: DWORD,
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+    GlobalFlagsClear: DWORD,
+    GlobalFlagsSet: DWORD,
+    CriticalSectionDefaultTimeout: DWORD,
+    DeCommitFreeBlockThreshold: ULONGLONG,
+    DeCommitTotalFreeThreshold: ULONGLONG,
+    LockPrefixTable: ULONGLONG,
+    MaximumAllocationSize: ULONGLONG,
+    VirtualMemoryThreshold: ULONGLONG,
+    ProcessAffinityMask: ULONGLONG,
+    ProcessHeapFlags: DWORD,
+    CSDVersion: WORD,
+    DependentLoadFlags: WORD,
+    EditList: ULONGLONG,
+    SecurityCookie: ULONGLONG,
+    SEHandlerTable: ULONGLONG,
+    SEHandlerCount: ULONGLONG,
+    GuardCFCheckFunctionPointer: ULONGLONG,
+    GuardCFDispatchFunctionPointer: ULONGLONG,
+    GuardCFFunctionTable: ULONGLONG,
+    GuardCFFunctionCount: ULONGLONG,
+    GuardFlags: DWORD,
+    CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
+    GuardAddressTakenIatEntryTable: ULONGLONG,
+    GuardAddressTakenIatEntryCount: ULONGLONG,
+    GuardLongJumpTargetTable: ULONGLONG,
+    GuardLongJumpTargetCount: ULONGLONG,
+    DynamicValueRelocTable: ULONGLONG,
+    CHPEMetadataPointer: ULONGLONG,
+    GuardRFFailureRoutine: ULONGLONG,
+    GuardRFFailureRoutineFunctionPointer: ULONGLONG,
+    DynamicValueRelocTableOffset: DWORD,
+    DynamicValueRelocTableSection: WORD,
+    Reserved2: WORD,
+    GuardRFVerifyStackPointerFunctionPointer: ULONGLONG,
+    HotPatchTableOffset: DWORD,
+    Reserved3: DWORD,
+    EnclaveConfigurationPointer: ULONGLONG,
+}}
+pub type PIMAGE_LOAD_CONFIG_DIRECTORY64 = *mut IMAGE_LOAD_CONFIG_DIRECTORY64;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+pub type IMAGE_LOAD_CONFIG_DIRECTORY = IMAGE_LOAD_CONFIG_DIRECTORY64;
+pub type PIMAGE_LOAD_CONFIG_DIRECTORY = PIMAGE_LOAD_CONFIG_DIRECTORY64;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+pub type IMAGE_LOAD_CONFIG_DIRECTORY = IMAGE_LOAD_CONFIG_DIRECTORY32;
+pub type PIMAGE_LOAD_CONFIG_DIRECTORY = PIMAGE_LOAD_CONFIG_DIRECTORY32;
+}
+STRUCT!{struct IMAGE_HOT_PATCH_INFO {
+    Version: DWORD,
+    Size: DWORD,
+    SequenceNumber: DWORD,
+    BaseImageList: DWORD,
+    BaseImageCount: DWORD,
+    BufferOffset: DWORD,
+}}
+pub type PIMAGE_HOT_PATCH_INFO = *mut IMAGE_HOT_PATCH_INFO;
+STRUCT!{struct IMAGE_HOT_PATCH_BASE {
+    SequenceNumber: DWORD,
+    Flags: DWORD,
+    OriginalTimeDateStamp: DWORD,
+    OriginalCheckSum: DWORD,
+    CodeIntegrityInfo: DWORD,
+    CodeIntegritySize: DWORD,
+    PatchTable: DWORD,
+    BufferOffset: DWORD,
+}}
+pub type PIMAGE_HOT_PATCH_BASE = *mut IMAGE_HOT_PATCH_BASE;
+STRUCT!{struct IMAGE_HOT_PATCH_HASHES {
+    SHA256: [BYTE; 32],
+    SHA1: [BYTE; 20],
+}}
+pub type PIMAGE_HOT_PATCH_HASHES = *mut IMAGE_HOT_PATCH_HASHES;
+pub const IMAGE_HOT_PATCH_BASE_OBLIGATORY: DWORD = 0x00000001;
+pub const IMAGE_HOT_PATCH_CHUNK_INVERSE: DWORD = 0x80000000;
+pub const IMAGE_HOT_PATCH_CHUNK_OBLIGATORY: DWORD = 0x40000000;
+pub const IMAGE_HOT_PATCH_CHUNK_RESERVED: DWORD = 0x3FF03000;
+pub const IMAGE_HOT_PATCH_CHUNK_TYPE: DWORD = 0x000FC000;
+pub const IMAGE_HOT_PATCH_CHUNK_SOURCE_RVA: DWORD = 0x00008000;
+pub const IMAGE_HOT_PATCH_CHUNK_TARGET_RVA: DWORD = 0x00004000;
+pub const IMAGE_HOT_PATCH_CHUNK_SIZE: DWORD = 0x00000FFF;
+pub const IMAGE_HOT_PATCH_NONE: DWORD = 0x00000000;
+pub const IMAGE_HOT_PATCH_FUNCTION: DWORD = 0x0001C000;
+pub const IMAGE_HOT_PATCH_ABSOLUTE: DWORD = 0x0002C000;
+pub const IMAGE_HOT_PATCH_REL32: DWORD = 0x0003C000;
+pub const IMAGE_HOT_PATCH_CALL_TARGET: DWORD = 0x00044000;
+pub const IMAGE_HOT_PATCH_INDIRECT: DWORD = 0x0005C000;
+pub const IMAGE_HOT_PATCH_NO_CALL_TARGET: DWORD = 0x00064000;
+pub const IMAGE_HOT_PATCH_DYNAMIC_VALUE: DWORD = 0x00078000;
+pub const IMAGE_GUARD_CF_INSTRUMENTED: DWORD = 0x00000100;
+pub const IMAGE_GUARD_CFW_INSTRUMENTED: DWORD = 0x00000200;
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT: DWORD = 0x00000400;
+pub const IMAGE_GUARD_SECURITY_COOKIE_UNUSED: DWORD = 0x00000800;
+pub const IMAGE_GUARD_PROTECT_DELAYLOAD_IAT: DWORD = 0x00001000;
+pub const IMAGE_GUARD_DELAYLOAD_IAT_IN_ITS_OWN_SECTION: DWORD = 0x00002000;
+pub const IMAGE_GUARD_CF_EXPORT_SUPPRESSION_INFO_PRESENT: DWORD = 0x00004000;
+pub const IMAGE_GUARD_CF_ENABLE_EXPORT_SUPPRESSION: DWORD = 0x00008000;
+pub const IMAGE_GUARD_CF_LONGJUMP_TABLE_PRESENT: DWORD = 0x00010000;
+pub const IMAGE_GUARD_RF_INSTRUMENTED: DWORD = 0x00020000;
+pub const IMAGE_GUARD_RF_ENABLE: DWORD = 0x00040000;
+pub const IMAGE_GUARD_RF_STRICT: DWORD = 0x00080000;
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK: DWORD = 0xF0000000;
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_SHIFT: usize = 28;
+pub const IMAGE_GUARD_FLAG_FID_SUPPRESSED: DWORD = 0x01;
+pub const IMAGE_GUARD_FLAG_EXPORT_SUPPRESSED: DWORD = 0x02;
+STRUCT!{struct IMAGE_CE_RUNTIME_FUNCTION_ENTRY {
+    FuncStart: DWORD,
+    BitFields: DWORD,
+}}
+BITFIELD!{IMAGE_CE_RUNTIME_FUNCTION_ENTRY BitFields: DWORD [
+    PrologLen set_PrologLen[0..8],
+    FuncLen set_FuncLen[8..30],
+    ThirtyTwoBit set_ThirtyTwoBit[30..31],
+    ExceptionFlag set_ExceptionFlag[31..32],
+]}
+pub type PIMAGE_CE_RUNTIME_FUNCTION_ENTRY = *mut IMAGE_CE_RUNTIME_FUNCTION_ENTRY;
+STRUCT!{struct IMAGE_ARM_RUNTIME_FUNCTION_ENTRY {
+    BeginAddress: DWORD,
+    UnwindData: DWORD,
+}}
+BITFIELD!{IMAGE_ARM_RUNTIME_FUNCTION_ENTRY UnwindData: DWORD [
+    Flag set_Flag[0..2],
+    FunctionLength set_FunctionLength[2..13],
+    Ret set_Ret[13..15],
+    H set_H[15..16],
+    Reg set_Reg[16..19],
+    R set_R[19..20],
+    L set_L[20..21],
+    C set_c[21..22],
+    StackAdjust set_StackAdjust[22..32],
+]}
+pub type PIMAGE_ARM_RUNTIME_FUNCTION_ENTRY = *mut IMAGE_ARM_RUNTIME_FUNCTION_ENTRY;
+STRUCT!{struct IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
+    BeginAddress: DWORD,
+    UnwindData: DWORD,
+}}
+BITFIELD!{IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY UnwindData: DWORD [
+    Flag set_Flag[0..2],
+    FunctionLength set_FunctionLength[2..13],
+    RegF set_RegF[13..16],
+    RegI set_RegI[16..20],
+    H set_H[20..21],
+    CR set_cR[21..23],
+    FrameSize set_FrameSize[23..32],
+]}
+pub type PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY = *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;
+STRUCT!{struct IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY {
+    BeginAddress: ULONGLONG,
+    EndAddress: ULONGLONG,
+    ExceptionHandler: ULONGLONG,
+    HandlerData: ULONGLONG,
+    PrologEndAddress: ULONGLONG,
+}}
+pub type PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY = *mut IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY;
+STRUCT!{struct IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY {
+    BeginAddress: DWORD,
+    EndAddress: DWORD,
+    ExceptionHandler: DWORD,
+    HandlerData: DWORD,
+    PrologEndAddress: DWORD,
+}}
+pub type PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY = *mut IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY;
+UNION!{union IMAGE_RUNTIME_FUNCTION_ENTRY_u {
+    [u32; 1],
+    UnwindInfoAddress UnwindInfoAddress_mut: DWORD,
+    UnwindData UnwindData_mut: DWORD,
+}}
+STRUCT!{struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
+    BeginAddress: DWORD,
+    EndAddress: DWORD,
+    u: IMAGE_RUNTIME_FUNCTION_ENTRY_u,
+}}
+pub type _PIMAGE_RUNTIME_FUNCTION_ENTRY = *mut _IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type IMAGE_IA64_RUNTIME_FUNCTION_ENTRY = _IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY = _PIMAGE_RUNTIME_FUNCTION_ENTRY;
+#[cfg(target_arch = "aarch64")]
+IFDEF!{
+pub type IMAGE_RUNTIME_FUNCTION_ENTRY = IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;
+pub type PIMAGE_RUNTIME_FUNCTION_ENTRY = PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;
+}
+#[cfg(not(target_arch = "aarch64"))]
+IFDEF!{
+pub type IMAGE_RUNTIME_FUNCTION_ENTRY = _IMAGE_RUNTIME_FUNCTION_ENTRY;
+pub type PIMAGE_RUNTIME_FUNCTION_ENTRY = _PIMAGE_RUNTIME_FUNCTION_ENTRY;
+}
+STRUCT!{struct IMAGE_DEBUG_DIRECTORY {
+    Characteristics: DWORD,
+    TimeDateStamp: DWORD,
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+    Type: DWORD,
+    SizeOfData: DWORD,
+    AddressOfRawData: DWORD,
+    PointerToRawData: DWORD,
+}}
+pub type PIMAGE_DEBUG_DIRECTORY = *mut IMAGE_DEBUG_DIRECTORY;
+pub const IMAGE_DEBUG_TYPE_UNKNOWN: DWORD = 0;
+pub const IMAGE_DEBUG_TYPE_COFF: DWORD = 1;
+pub const IMAGE_DEBUG_TYPE_CODEVIEW: DWORD = 2;
+pub const IMAGE_DEBUG_TYPE_FPO: DWORD = 3;
+pub const IMAGE_DEBUG_TYPE_MISC: DWORD = 4;
+pub const IMAGE_DEBUG_TYPE_EXCEPTION: DWORD = 5;
+pub const IMAGE_DEBUG_TYPE_FIXUP: DWORD = 6;
+pub const IMAGE_DEBUG_TYPE_OMAP_TO_SRC: DWORD = 7;
+pub const IMAGE_DEBUG_TYPE_OMAP_FROM_SRC: DWORD = 8;
+pub const IMAGE_DEBUG_TYPE_BORLAND: DWORD = 9;
+pub const IMAGE_DEBUG_TYPE_RESERVED10: DWORD = 10;
+pub const IMAGE_DEBUG_TYPE_CLSID: DWORD = 11;
+pub const IMAGE_DEBUG_TYPE_VC_FEATURE: DWORD = 12;
+pub const IMAGE_DEBUG_TYPE_POGO: DWORD = 13;
+pub const IMAGE_DEBUG_TYPE_ILTCG: DWORD = 14;
+pub const IMAGE_DEBUG_TYPE_MPX: DWORD = 15;
+pub const IMAGE_DEBUG_TYPE_REPRO: DWORD = 16;
+STRUCT!{struct IMAGE_COFF_SYMBOLS_HEADER {
+    NumberOfSymbols: DWORD,
+    LvaToFirstSymbol: DWORD,
+    NumberOfLinenumbers: DWORD,
+    LvaToFirstLinenumber: DWORD,
+    RvaToFirstByteOfCode: DWORD,
+    RvaToLastByteOfCode: DWORD,
+    RvaToFirstByteOfData: DWORD,
+    RvaToLastByteOfData: DWORD,
+}}
+pub type PIMAGE_COFF_SYMBOLS_HEADER = *mut IMAGE_COFF_SYMBOLS_HEADER;
+pub const FRAME_FPO: WORD = 0;
+pub const FRAME_TRAP: WORD = 1;
+pub const FRAME_TSS: WORD = 2;
+pub const FRAME_NONFPO: WORD = 3;
+STRUCT!{struct FPO_DATA {
+    ulOffStart: DWORD,
+    cbProcSize: DWORD,
+    cdwLocals: DWORD,
+    cdwParams: WORD,
+    BitFields: WORD,
+}}
+BITFIELD!{FPO_DATA BitFields: WORD [
+    cbProlog set_cbProlog[0..8],
+    cbRegs set_cbRegs[8..11],
+    fHasSEH set_fHasSEH[11..12],
+    fUseBP set_fUseBP[12..13],
+    reserved set_reserved[13..14],
+    cbFrame set_cbFrame[14..16],
+]}
+pub type PFPO_DATA = *mut FPO_DATA;
+pub const SIZEOF_RFPO_DATA: usize = 16;
+pub const IMAGE_DEBUG_MISC_EXENAME: DWORD = 1;
+STRUCT!{struct IMAGE_DEBUG_MISC {
+    DataType: DWORD,
+    Length: DWORD,
+    Unicode: BOOLEAN,
+    Reserved: [BYTE; 3],
+    Data: [BYTE; 1],
+}}
+pub type PIMAGE_DEBUG_MISC = *mut IMAGE_DEBUG_MISC;
+STRUCT!{struct IMAGE_FUNCTION_ENTRY {
+    StartingAddress: DWORD,
+    EndingAddress: DWORD,
+    EndOfPrologue: DWORD,
+}}
+pub type PIMAGE_FUNCTION_ENTRY = *mut IMAGE_FUNCTION_ENTRY;
+UNION!{union IMAGE_FUNCTION_ENTRY64_u {
+    [u64; 1],
+    EndOfPrologue EndOfPrologue_mut: ULONGLONG,
+    UnwindInfoAddress UnwindInfoAddress_mut: ULONGLONG,
+}}
+STRUCT!{struct IMAGE_FUNCTION_ENTRY64 {
+    StartingAddress: ULONGLONG,
+    EndingAddress: ULONGLONG,
+    u: IMAGE_FUNCTION_ENTRY64_u,
+}}
+pub type PIMAGE_FUNCTION_ENTRY64 = *mut IMAGE_FUNCTION_ENTRY64;
+STRUCT!{struct IMAGE_SEPARATE_DEBUG_HEADER {
+    Signature: WORD,
+    Flags: WORD,
+    Machine: WORD,
+    Characteristics: WORD,
+    TimeDateStamp: DWORD,
+    CheckSum: DWORD,
+    ImageBase: DWORD,
+    SizeOfImage: DWORD,
+    NumberOfSections: DWORD,
+    ExportedNamesSize: DWORD,
+    DebugDirectorySize: DWORD,
+    SectionAlignment: DWORD,
+    Reserved: [DWORD; 2],
+}}
+pub type PIMAGE_SEPARATE_DEBUG_HEADER = *mut IMAGE_SEPARATE_DEBUG_HEADER;
+STRUCT!{struct NON_PAGED_DEBUG_INFO {
+    Signature: WORD,
+    Flags: WORD,
+    Size: DWORD,
+    Machine: WORD,
+    Characteristics: WORD,
+    TimeDateStamp: DWORD,
+    CheckSum: DWORD,
+    SizeOfImage: DWORD,
+    ImageBase: ULONGLONG,
+}}
+pub type PNON_PAGED_DEBUG_INFO = *mut NON_PAGED_DEBUG_INFO;
+pub const IMAGE_SEPARATE_DEBUG_SIGNATURE: WORD = 0x4944;
+pub const NON_PAGED_DEBUG_SIGNATURE: WORD = 0x494E;
+pub const IMAGE_SEPARATE_DEBUG_FLAGS_MASK: WORD = 0x8000;
+pub const IMAGE_SEPARATE_DEBUG_MISMATCH: WORD = 0x8000;
+STRUCT!{struct IMAGE_ARCHITECTURE_HEADER {
+    BitFields: c_uint,
+    FirstEntryRVA: DWORD,
+}}
+BITFIELD!{IMAGE_ARCHITECTURE_HEADER BitFields: c_uint [
+    AmaskValue set_AmaskValue[0..1],
+    unused1 set_unused1[1..8],
+    AmaskShift set_AmaskShift[8..16],
+    unused2 set_unused2[8..32],
+]}
+pub type PIMAGE_ARCHITECTURE_HEADER = *mut IMAGE_ARCHITECTURE_HEADER;
+STRUCT!{struct IMAGE_ARCHITECTURE_ENTRY {
+    FixupInstRVA: DWORD,
+    NewInst: DWORD,
+}}
+pub type PIMAGE_ARCHITECTURE_ENTRY = *mut IMAGE_ARCHITECTURE_ENTRY;
+pub const IMPORT_OBJECT_HDR_SIG2: WORD = 0xffff;
+UNION!{union IMPORT_OBJECT_HEADER_u {
+    [u16; 1],
+    Ordinal Ordinal_mut: WORD,
+    Hint Hint_mut: WORD,
+}}
+STRUCT!{struct IMPORT_OBJECT_HEADER {
+    Sig1: WORD,
+    Sig2: WORD,
+    Version: WORD,
+    Machine: WORD,
+    TimeDateStamp: DWORD,
+    SizeOfData: DWORD,
+    u: IMPORT_OBJECT_HEADER_u,
+    BitFields: WORD,
+}}
+BITFIELD!{IMPORT_OBJECT_HEADER BitFields: WORD [
+    Type set_Type[0..2],
+    NameType set_NameType[2..5],
+    Reserved set_Reserved[5..16],
+]}
+ENUM!{enum IMPORT_OBJECT_TYPE {
+    IMPORT_OBJECT_CODE = 0,
+    IMPORT_OBJECT_DATA = 1,
+    IMPORT_OBJECT_CONST = 2,
+}}
+ENUM!{enum IMPORT_OBJECT_NAME_TYPE {
+    IMPORT_OBJECT_ORDINAL = 0,
+    IMPORT_OBJECT_NAME = 1,
+    IMPORT_OBJECT_NAME_NO_PREFIX = 2,
+    IMPORT_OBJECT_NAME_UNDECORATE = 3,
+    IMPORT_OBJECT_NAME_EXPORTAS = 4,
+}}
+ENUM!{enum ReplacesCorHdrNumericDefines {
+    COMIMAGE_FLAGS_ILONLY = 0x00000001,
+    COMIMAGE_FLAGS_32BITREQUIRED = 0x00000002,
+    COMIMAGE_FLAGS_IL_LIBRARY = 0x00000004,
+    COMIMAGE_FLAGS_STRONGNAMESIGNED = 0x00000008,
+    COMIMAGE_FLAGS_NATIVE_ENTRYPOINT = 0x00000010,
+    COMIMAGE_FLAGS_TRACKDEBUGDATA = 0x00010000,
+    COMIMAGE_FLAGS_32BITPREFERRED = 0x00020000,
+    COR_VERSION_MAJOR_V2 = 2,
+    COR_VERSION_MAJOR = COR_VERSION_MAJOR_V2,
+    COR_VERSION_MINOR = 5,
+    COR_DELETED_NAME_LENGTH = 8,
+    COR_VTABLEGAP_NAME_LENGTH = 8,
+    NATIVE_TYPE_MAX_CB = 1,
+    COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE= 0xFF,
+    IMAGE_COR_MIH_METHODRVA = 0x01,
+    IMAGE_COR_MIH_EHRVA = 0x02,
+    IMAGE_COR_MIH_BASICBLOCK = 0x08,
+    COR_VTABLE_32BIT = 0x01,
+    COR_VTABLE_64BIT = 0x02,
+    COR_VTABLE_FROM_UNMANAGED = 0x04,
+    COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN = 0x08,
+    COR_VTABLE_CALL_MOST_DERIVED = 0x10,
+    IMAGE_COR_EATJ_THUNK_SIZE = 32,
+    MAX_CLASS_NAME = 1024,
+    MAX_PACKAGE_NAME = 1024,
+}}
+UNION!{union IMAGE_COR20_HEADER_u {
+    [u32; 1],
+    EntryPointToken EntryPointToken_mut: DWORD,
+    EntryPointRVA EntryPointRVA_mut: DWORD,
+}}
+STRUCT!{struct IMAGE_COR20_HEADER {
+    cb: DWORD,
+    MajorRuntimeVersion: WORD,
+    MinorRuntimeVersion: WORD,
+    MetaData: IMAGE_DATA_DIRECTORY,
+    Flags: DWORD,
+    u: IMAGE_COR20_HEADER_u,
+    Resources: IMAGE_DATA_DIRECTORY,
+    StrongNameSignature: IMAGE_DATA_DIRECTORY,
+    CodeManagerTable: IMAGE_DATA_DIRECTORY,
+    VTableFixups: IMAGE_DATA_DIRECTORY,
+    ExportAddressTableJumps: IMAGE_DATA_DIRECTORY,
+    ManagedNativeHeader: IMAGE_DATA_DIRECTORY,
+}}
+pub type PIMAGE_COR20_HEADER = *mut IMAGE_COR20_HEADER;
+extern "system" {
+    pub fn RtlCaptureStackBackTrace(
+        FramesToSkip: DWORD,
+        FramesToCapture: DWORD,
+        BackTrace: *mut PVOID,
+        BackTraceHash: PDWORD,
+    ) -> WORD;
+    pub fn RtlCaptureContext(
+        ContextRecord: PCONTEXT,
+    );
+    pub fn RtlUnwind(
+        TargetFrame: PVOID,
+        TargetIp: PVOID,
+        ExceptionRecord: PEXCEPTION_RECORD,
+        ReturnValue: PVOID,
+    );
+}
+#[cfg(target_pointer_width = "64")]
+extern "system" {
+    pub fn RtlAddFunctionTable(
+        FunctionTable: PRUNTIME_FUNCTION,
+        EntryCount: DWORD,
+        BaseAddress: DWORD64,
+    ) -> BOOLEAN;
+    pub fn RtlDeleteFunctionTable(
+        FunctionTable: PRUNTIME_FUNCTION,
+    ) -> BOOLEAN;
+    pub fn RtlInstallFunctionTableCallback(
+        TableIdentifier: DWORD64,
+        BaseAddress: DWORD64,
+        Length: DWORD,
+        Callback: PGET_RUNTIME_FUNCTION_CALLBACK,
+        Context: PVOID,
+        OutOfProcessCallbackDll: PCWSTR,
+    ) -> BOOLEAN;
+    pub fn RtlAddGrowableFunctionTable(
+        DynamicTable: *mut PVOID,
+        FunctionTable: PRUNTIME_FUNCTION,
+        EntryCount: DWORD,
+        MaximumEntryCount: DWORD,
+        RangeBase: ULONG_PTR,
+        RangeEnd: ULONG_PTR,
+    ) -> DWORD;
+    pub fn RtlGrowFunctionTable(
+        DynamicTable: PVOID,
+        NewEntryCount: DWORD,
+    );
+    pub fn RtlDeleteGrowableFunctionTable(
+        DynamicTable: PVOID,
+    );
+    pub fn RtlLookupFunctionEntry(
+        ControlPc: DWORD64,
+        ImageBase: PDWORD64,
+        HistoryTable: PUNWIND_HISTORY_TABLE,
+    ) -> PRUNTIME_FUNCTION;
+}
+#[cfg(target_arch = "x86_64")]
+IFDEF!{
+extern "C" {
+    pub fn RtlRestoreContext(
+        ContextRecord: PCONTEXT,
+        ExceptionRecord: *mut EXCEPTION_RECORD,
+    );
+}
+extern "system" {
+    pub fn RtlUnwindEx(
+        TargetFrame: PVOID,
+        TargetIp: PVOID,
+        ExceptionRecord: PEXCEPTION_RECORD,
+        ReturnValue: PVOID,
+        ContextRecord: PCONTEXT,
+        HistoryTable: PUNWIND_HISTORY_TABLE,
+    );
+    pub fn RtlVirtualUnwind(
+        HandlerType: DWORD,
+        ImageBase: DWORD64,
+        ControlPc: DWORD64,
+        FunctionEntry: PRUNTIME_FUNCTION,
+        ContextRecord: PCONTEXT,
+        HandlerData: *mut PVOID,
+        EstablisherFrame: PDWORD64,
+        ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS,
+    ) -> PEXCEPTION_ROUTINE;
+}
+}
+extern "system" {
+    pub fn RtlPcToFileHeader(
+        PcValue: PVOID,
+        BaseOfImage: *mut PVOID,
+    ) -> PVOID;
+    pub fn RtlCompareMemory(
+        Source1: *const VOID,
+        Source2: *const VOID,
+        Length: SIZE_T,
+    ) -> SIZE_T;
+}
+STRUCT!{struct SLIST_ENTRY {
+    Next: *mut SLIST_ENTRY,
+}}
+pub type PSLIST_ENTRY = *mut SLIST_ENTRY;
+#[cfg(target_pointer_width = "64")]
+IFDEF!{
+STRUCT!{struct SLIST_HEADER_s {
+    Alignment: ULONGLONG,
+    Region: ULONGLONG,
+}}
+STRUCT!{struct SLIST_HEADER_HeaderX64 {
+    BitFields1: ULONGLONG,
+    BitFields2: ULONGLONG,
+}}
+BITFIELD!{SLIST_HEADER_HeaderX64 BitFields1: ULONGLONG [
+    Depth set_Depth[0..16],
+    Sequence set_Sequence[16..64],
+]}
+BITFIELD!{SLIST_HEADER_HeaderX64 BitFields2: ULONGLONG [
+    Reserved set_Reserved[0..4],
+    NextEntry set_NextEntry[4..64],
+]}
+UNION!{union SLIST_HEADER {
+    [u64; 2],
+    s s_mut: SLIST_HEADER_s,
+    HeaderX64 HeaderX64_mut: SLIST_HEADER_HeaderX64,
+}}
+pub type PSLIST_HEADER = *mut SLIST_HEADER;
+}
+#[cfg(target_pointer_width = "32")]
+IFDEF!{
+STRUCT!{struct SLIST_HEADER_s {
+    Next: SLIST_ENTRY,
+    Depth: WORD,
+    Reserved: WORD,
+}}
+UNION!{union SLIST_HEADER {
+    [u64; 1],
+    Alignment Alignment_mut: ULONGLONG,
+    s s_mut: SLIST_HEADER_s,
+}}
+pub type PSLIST_HEADER = *mut SLIST_HEADER;
+}
+extern "system" {
+    pub fn RtlInitializeSListHead(
+        ListHead: PSLIST_HEADER,
+    );
+    pub fn RtlFirstEntrySList(
+        ListHead: *const SLIST_HEADER,
+    ) -> PSLIST_ENTRY;
+    pub fn RtlInterlockedPopEntrySList(
+        ListHead: PSLIST_HEADER,
+    ) -> PSLIST_ENTRY;
+    pub fn RtlInterlockedPushEntrySList(
+        ListHead: PSLIST_HEADER,
+        ListEntry: PSLIST_ENTRY,
+    ) -> PSLIST_ENTRY;
+    pub fn RtlInterlockedPushListSListEx(
+        ListHead: PSLIST_HEADER,
+        ListEntry: PSLIST_ENTRY,
+        ListEnd: PSLIST_ENTRY,
+        Count: DWORD,
+    ) -> PSLIST_ENTRY;
+    pub fn RtlInterlockedFlushSList(
+        ListHead: PSLIST_HEADER,
+    ) -> PSLIST_ENTRY;
+    pub fn RtlQueryDepthSList(
+        ListHead: PSLIST_HEADER,
+    ) -> WORD;
+}
+pub const RTL_RUN_ONCE_INIT: RTL_RUN_ONCE = RTL_RUN_ONCE { Ptr: 0 as PVOID };
+pub const RTL_RUN_ONCE_CHECK_ONLY: ULONG = 0x00000001;
+pub const RTL_RUN_ONCE_ASYNC: ULONG = 0x00000002;
+pub const RTL_RUN_ONCE_INIT_FAILED: ULONG = 0x00000004;
+STRUCT!{struct RTL_RUN_ONCE {
+    Ptr: PVOID,
+}}
+pub type PRTL_RUN_ONCE = *mut RTL_RUN_ONCE;
+STRUCT!{struct RTL_BARRIER {
+    Reserved1: DWORD,
+    Reserved2: DWORD,
+    Reserved3: [ULONG_PTR; 2],
+    Reserved4: DWORD,
+    Reserved5: DWORD,
+}}
+pub type PRTL_BARRIER = *mut RTL_BARRIER;
+pub const FAST_FAIL_LEGACY_GS_VIOLATION: c_uint = 0;
+pub const FAST_FAIL_VTGUARD_CHECK_FAILURE: c_uint = 1;
+pub const FAST_FAIL_STACK_COOKIE_CHECK_FAILURE: c_uint = 2;
+pub const FAST_FAIL_CORRUPT_LIST_ENTRY: c_uint = 3;
+pub const FAST_FAIL_INCORRECT_STACK: c_uint = 4;
+pub const FAST_FAIL_INVALID_ARG: c_uint = 5;
+pub const FAST_FAIL_GS_COOKIE_INIT: c_uint = 6;
+pub const FAST_FAIL_FATAL_APP_EXIT: c_uint = 7;
+pub const FAST_FAIL_RANGE_CHECK_FAILURE: c_uint = 8;
+pub const FAST_FAIL_UNSAFE_REGISTRY_ACCESS: c_uint = 9;
+pub const FAST_FAIL_GUARD_ICALL_CHECK_FAILURE: c_uint = 10;
+pub const FAST_FAIL_GUARD_WRITE_CHECK_FAILURE: c_uint = 11;
+pub const FAST_FAIL_INVALID_FIBER_SWITCH: c_uint = 12;
+pub const FAST_FAIL_INVALID_SET_OF_CONTEXT: c_uint = 13;
+pub const FAST_FAIL_INVALID_REFERENCE_COUNT: c_uint = 14;
+pub const FAST_FAIL_INVALID_JUMP_BUFFER: c_uint = 18;
+pub const FAST_FAIL_MRDATA_MODIFIED: c_uint = 19;
+pub const FAST_FAIL_CERTIFICATION_FAILURE: c_uint = 20;
+pub const FAST_FAIL_INVALID_EXCEPTION_CHAIN: c_uint = 21;
+pub const FAST_FAIL_CRYPTO_LIBRARY: c_uint = 22;
+pub const FAST_FAIL_INVALID_CALL_IN_DLL_CALLOUT: c_uint = 23;
+pub const FAST_FAIL_INVALID_IMAGE_BASE: c_uint = 24;
+pub const FAST_FAIL_DLOAD_PROTECTION_FAILURE: c_uint = 25;
+pub const FAST_FAIL_UNSAFE_EXTENSION_CALL: c_uint = 26;
+pub const FAST_FAIL_DEPRECATED_SERVICE_INVOKED: c_uint = 27;
+pub const FAST_FAIL_INVALID_BUFFER_ACCESS: c_uint = 28;
+pub const FAST_FAIL_INVALID_BALANCED_TREE: c_uint = 29;
+pub const FAST_FAIL_INVALID_NEXT_THREAD: c_uint = 30;
+pub const FAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSED: c_uint = 31;
+pub const FAST_FAIL_APCS_DISABLED: c_uint = 32;
+pub const FAST_FAIL_INVALID_IDLE_STATE: c_uint = 33;
+pub const FAST_FAIL_MRDATA_PROTECTION_FAILURE: c_uint = 34;
+pub const FAST_FAIL_UNEXPECTED_HEAP_EXCEPTION: c_uint = 35;
+pub const FAST_FAIL_INVALID_LOCK_STATE: c_uint = 36;
+pub const FAST_FAIL_GUARD_JUMPTABLE: c_uint = 37;
+pub const FAST_FAIL_INVALID_LONGJUMP_TARGET: c_uint = 38;
+pub const FAST_FAIL_INVALID_DISPATCH_CONTEXT: c_uint = 39;
+pub const FAST_FAIL_INVALID_THREAD: c_uint = 40;
+pub const FAST_FAIL_INVALID_SYSCALL_NUMBER: c_uint = 41;
+pub const FAST_FAIL_INVALID_FILE_OPERATION: c_uint = 42;
+pub const FAST_FAIL_LPAC_ACCESS_DENIED: c_uint = 43;
+pub const FAST_FAIL_GUARD_SS_FAILURE: c_uint = 44;
+pub const FAST_FAIL_LOADER_CONTINUITY_FAILURE: c_uint = 45;
+pub const FAST_FAIL_GUARD_EXPORT_SUPPRESSION_FAILURE: c_uint = 46;
+pub const FAST_FAIL_INVALID_CONTROL_STACK: c_uint = 47;
+pub const FAST_FAIL_SET_CONTEXT_DENIED: c_uint = 48;
+pub const FAST_FAIL_INVALID_FAST_FAIL_CODE: c_uint = 0xFFFFFFFF;
+pub const HEAP_NO_SERIALIZE: DWORD = 0x00000001;
+pub const HEAP_GROWABLE: DWORD = 0x00000002;
+pub const HEAP_GENERATE_EXCEPTIONS: DWORD = 0x00000004;
+pub const HEAP_ZERO_MEMORY: DWORD = 0x00000008;
+pub const HEAP_REALLOC_IN_PLACE_ONLY: DWORD = 0x00000010;
+pub const HEAP_TAIL_CHECKING_ENABLED: DWORD = 0x00000020;
+pub const HEAP_FREE_CHECKING_ENABLED: DWORD = 0x00000040;
+pub const HEAP_DISABLE_COALESCE_ON_FREE: DWORD = 0x00000080;
+pub const HEAP_CREATE_ALIGN_16: DWORD = 0x00010000;
+pub const HEAP_CREATE_ENABLE_TRACING: DWORD = 0x00020000;
+pub const HEAP_CREATE_ENABLE_EXECUTE: DWORD = 0x00040000;
+pub const HEAP_MAXIMUM_TAG: DWORD = 0x0FFF;
+pub const HEAP_PSEUDO_TAG_FLAG: DWORD = 0x8000;
+pub const HEAP_TAG_SHIFT: usize = 18;
+pub const HEAP_CREATE_SEGMENT_HEAP: DWORD = 0x00000100;
+pub const HEAP_CREATE_HARDENED: DWORD = 0x00000200;
+#[inline]
+pub fn HEAP_MAKE_TAG_FLAGS(TagBase: DWORD, Tag: DWORD) -> DWORD {
+    TagBase + (Tag << HEAP_TAG_SHIFT)
+}
+pub const IS_TEXT_UNICODE_ASCII16: INT = 0x0001;
+pub const IS_TEXT_UNICODE_REVERSE_ASCII16: INT = 0x0010;
+pub const IS_TEXT_UNICODE_STATISTICS: INT = 0x0002;
+pub const IS_TEXT_UNICODE_REVERSE_STATISTICS: INT = 0x0020;
+pub const IS_TEXT_UNICODE_CONTROLS: INT = 0x0004;
+pub const IS_TEXT_UNICODE_REVERSE_CONTROLS: INT = 0x0040;
+pub const IS_TEXT_UNICODE_SIGNATURE: INT = 0x0008;
+pub const IS_TEXT_UNICODE_REVERSE_SIGNATURE: INT = 0x0080;
+pub const IS_TEXT_UNICODE_ILLEGAL_CHARS: INT = 0x0100;
+pub const IS_TEXT_UNICODE_ODD_LENGTH: INT = 0x0200;
+pub const IS_TEXT_UNICODE_DBCS_LEADBYTE: INT = 0x0400;
+pub const IS_TEXT_UNICODE_NULL_BYTES: INT = 0x1000;
+pub const IS_TEXT_UNICODE_UNICODE_MASK: INT = 0x000F;
+pub const IS_TEXT_UNICODE_REVERSE_MASK: INT = 0x00F0;
+pub const IS_TEXT_UNICODE_NOT_UNICODE_MASK: INT = 0x0F00;
+pub const IS_TEXT_UNICODE_NOT_ASCII_MASK: INT = 0xF000;
+pub const COMPRESSION_FORMAT_NONE: USHORT = 0x0000;
+pub const COMPRESSION_FORMAT_DEFAULT: USHORT = 0x0001;
+pub const COMPRESSION_FORMAT_LZNT1: USHORT = 0x0002;
+pub const COMPRESSION_FORMAT_XPRESS: USHORT = 0x0003;
+pub const COMPRESSION_FORMAT_XPRESS_HUFF: USHORT = 0x0004;
+pub const COMPRESSION_ENGINE_STANDARD: USHORT = 0x0000;
+pub const COMPRESSION_ENGINE_MAXIMUM: USHORT = 0x0100;
+pub const COMPRESSION_ENGINE_HIBER: USHORT = 0x0200;
+// RtlEqualMemory
+#[inline]
+pub unsafe fn RtlMoveMemory(Destination: *mut c_void, Source: *const c_void, Length: usize) {
+    use core::ptr::copy;
+    copy(Source as *const u8, Destination as *mut u8, Length);
+}
+#[inline]
+pub unsafe fn RtlCopyMemory(Destination: *mut c_void, Source: *const c_void, Length: usize) {
+    use core::ptr::copy_nonoverlapping;
+    copy_nonoverlapping(Source as *const u8, Destination as *mut u8, Length);
+}
+#[inline]
+pub unsafe fn RtlFillMemory(Destination: *mut c_void, Length: usize, Fill: u8) {
+    use core::ptr::write_bytes;
+    write_bytes(Destination as *mut u8, Fill, Length);
+}
+#[inline]
+pub unsafe fn RtlZeroMemory(Destination: *mut c_void, Length: usize) {
+    use core::ptr::write_bytes;
+    write_bytes(Destination as *mut u8, 0, Length);
+}
+pub const SEF_DACL_AUTO_INHERIT: ULONG = 0x01;
+pub const SEF_SACL_AUTO_INHERIT: ULONG = 0x02;
+pub const SEF_DEFAULT_DESCRIPTOR_FOR_OBJECT: ULONG = 0x04;
+pub const SEF_AVOID_PRIVILEGE_CHECK: ULONG = 0x08;
+pub const SEF_AVOID_OWNER_CHECK: ULONG = 0x10;
+pub const SEF_DEFAULT_OWNER_FROM_PARENT: ULONG = 0x20;
+pub const SEF_DEFAULT_GROUP_FROM_PARENT: ULONG = 0x40;
+pub const SEF_MACL_NO_WRITE_UP: ULONG = 0x100;
+pub const SEF_MACL_NO_READ_UP: ULONG = 0x200;
+pub const SEF_MACL_NO_EXECUTE_UP: ULONG = 0x400;
+pub const SEF_AI_USE_EXTRA_PARAMS: ULONG = 0x800;
+pub const SEF_AVOID_OWNER_RESTRICTION: ULONG = 0x1000;
+pub const SEF_MACL_VALID_FLAGS: ULONG = SEF_MACL_NO_WRITE_UP | SEF_MACL_NO_READ_UP
+    | SEF_MACL_NO_EXECUTE_UP;
+STRUCT!{struct MESSAGE_RESOURCE_ENTRY {
+    Length: WORD,
+    Flags: WORD,
+    Text: [BYTE; 1],
+}}
+pub type PMESSAGE_RESOURCE_ENTRY = *mut MESSAGE_RESOURCE_ENTRY;
+pub const MESSAGE_RESOURCE_UNICODE: WORD = 0x0001;
+STRUCT!{struct MESSAGE_RESOURCE_BLOCK {
+    LowId: DWORD,
+    HighId: DWORD,
+    OffsetToEntries: DWORD,
+}}
+pub type PMESSAGE_RESOURCE_BLOCK = *mut MESSAGE_RESOURCE_BLOCK;
+STRUCT!{struct MESSAGE_RESOURCE_DATA {
+    NumberOfBlocks: DWORD,
+    Blocks: [MESSAGE_RESOURCE_BLOCK; 1],
+}}
+pub type PMESSAGE_RESOURCE_DATA = *mut MESSAGE_RESOURCE_DATA;
+STRUCT!{struct OSVERSIONINFOA {
+    dwOSVersionInfoSize: DWORD,
+    dwMajorVersion: DWORD,
+    dwMinorVersion: DWORD,
+    dwBuildNumber: DWORD,
+    dwPlatformId: DWORD,
+    szCSDVersion: [CHAR; 128],
+}}
+pub type POSVERSIONINFOA = *mut OSVERSIONINFOA;
+pub type LPOSVERSIONINFOA = *mut OSVERSIONINFOA;
+STRUCT!{struct OSVERSIONINFOW {
+    dwOSVersionInfoSize: DWORD,
+    dwMajorVersion: DWORD,
+    dwMinorVersion: DWORD,
+    dwBuildNumber: DWORD,
+    dwPlatformId: DWORD,
+    szCSDVersion: [WCHAR; 128],
+}}
+pub type POSVERSIONINFOW = *mut OSVERSIONINFOW;
+pub type LPOSVERSIONINFOW = *mut OSVERSIONINFOW;
+pub type RTL_OSVERSIONINFOW = OSVERSIONINFOW;
+pub type PRTL_OSVERSIONINFOW = *mut OSVERSIONINFOW;
+STRUCT!{struct OSVERSIONINFOEXA {
+    dwOSVersionInfoSize: DWORD,
+    dwMajorVersion: DWORD,
+    dwMinorVersion: DWORD,
+    dwBuildNumber: DWORD,
+    dwPlatformId: DWORD,
+    szCSDVersion: [CHAR; 128],
+    wServicePackMajor: WORD,
+    wServicePackMinor: WORD,
+    wSuiteMask: WORD,
+    wProductType: BYTE,
+    wReserved: BYTE,
+}}
+pub type POSVERSIONINFOEXA = *mut OSVERSIONINFOEXA;
+pub type LPOSVERSIONINFOEXA = *mut OSVERSIONINFOEXA;
+STRUCT!{struct OSVERSIONINFOEXW {
+    dwOSVersionInfoSize: DWORD,
+    dwMajorVersion: DWORD,
+    dwMinorVersion: DWORD,
+    dwBuildNumber: DWORD,
+    dwPlatformId: DWORD,
+    szCSDVersion: [WCHAR; 128],
+    wServicePackMajor: WORD,
+    wServicePackMinor: WORD,
+    wSuiteMask: WORD,
+    wProductType: BYTE,
+    wReserved: BYTE,
+}}
+pub type POSVERSIONINFOEXW = *mut OSVERSIONINFOEXW;
+pub type LPOSVERSIONINFOEXW = *mut OSVERSIONINFOEXW;
+pub type RTL_OSVERSIONINFOEXW = OSVERSIONINFOEXW;
+pub type PRTL_OSVERSIONINFOEXW = *mut OSVERSIONINFOEXW;
+pub const VER_EQUAL: BYTE = 1;
+pub const VER_GREATER: BYTE = 2;
+pub const VER_GREATER_EQUAL: BYTE = 3;
+pub const VER_LESS: BYTE = 4;
+pub const VER_LESS_EQUAL: BYTE = 5;
+pub const VER_AND: BYTE = 6;
+pub const VER_OR: BYTE = 7;
+pub const VER_CONDITION_MASK: BYTE = 7;
+pub const VER_NUM_BITS_PER_CONDITION_MASK: BYTE = 3;
+pub const VER_MINORVERSION: DWORD = 0x0000001;
+pub const VER_MAJORVERSION: DWORD = 0x0000002;
+pub const VER_BUILDNUMBER: DWORD = 0x0000004;
+pub const VER_PLATFORMID: DWORD = 0x0000008;
+pub const VER_SERVICEPACKMINOR: DWORD = 0x0000010;
+pub const VER_SERVICEPACKMAJOR: DWORD = 0x0000020;
+pub const VER_SUITENAME: DWORD = 0x0000040;
+pub const VER_PRODUCT_TYPE: DWORD = 0x0000080;
+pub const VER_NT_WORKSTATION: BYTE = 0x0000001;
+pub const VER_NT_DOMAIN_CONTROLLER: BYTE = 0x0000002;
+pub const VER_NT_SERVER: BYTE = 0x0000003;
+pub const VER_PLATFORM_WIN32s: DWORD = 0;
+pub const VER_PLATFORM_WIN32_WINDOWS: DWORD = 1;
+pub const VER_PLATFORM_WIN32_NT: DWORD = 2;
+extern "system" {
+    pub fn VerSetConditionMask(
+        ConditionMask: ULONGLONG,
+        TypeMask: DWORD,
+        Condition: BYTE,
+    ) -> ULONGLONG;
+    pub fn RtlGetProductInfo(
+        OSMajorVersion: DWORD,
+        OSMinorVersion: DWORD,
+        SpMajorVersion: DWORD,
+        SpMinorVersion: DWORD,
+        ReturnedProductType: PDWORD,
+    ) -> BOOLEAN;
+}
+pub const RTL_UMS_VERSION: DWORD = 0x100;
+ENUM!{enum RTL_UMS_THREAD_INFO_CLASS {
+    UmsThreadInvalidInfoClass = 0,
+    UmsThreadUserContext,
+    UmsThreadPriority,
+    UmsThreadAffinity,
+    UmsThreadTeb,
+    UmsThreadIsSuspended,
+    UmsThreadIsTerminated,
+    UmsThreadMaxInfoClass,
+}}
+ENUM!{enum RTL_UMS_SCHEDULER_REASON {
+    UmsSchedulerStartup = 0,
+    UmsSchedulerThreadBlocked,
+    UmsSchedulerThreadYield,
+}}
+FN!{stdcall PRTL_UMS_SCHEDULER_ENTRY_POINT(
+    Reason: RTL_UMS_SCHEDULER_REASON,
+    ActivationPayload: ULONG_PTR,
+    SchedulerParam: PVOID,
+) -> ()}
+#[inline]
+pub fn IS_VALIDATION_ENABLED(C: DWORD, L: DWORD) -> bool {
+    (L & C) != 0
+}
+pub const VRL_PREDEFINED_CLASS_BEGIN: DWORD = 1 << 0;
+pub const VRL_CUSTOM_CLASS_BEGIN: DWORD = 1 << 8;
+pub const VRL_CLASS_CONSISTENCY: DWORD = VRL_CUSTOM_CLASS_BEGIN << 8;
+pub const VRL_ENABLE_KERNEL_BREAKS: DWORD = 1 << 31;
+pub const CTMF_INCLUDE_APPCONTAINER: ULONG = 0x00000001;
+pub const CTMF_INCLUDE_LPAC: ULONG = 0x00000002;
+pub const CTMF_VALID_FLAGS: ULONG = CTMF_INCLUDE_APPCONTAINER | CTMF_INCLUDE_LPAC;
+extern "system" {
+    pub fn RtlCrc32(
+        Buffer: *const c_void,
+        Size: size_t,
+        InitialCrc: DWORD,
+    ) -> DWORD;
+    pub fn RtlCrc64(
+        Buffer: *const c_void,
+        Size: size_t,
+        InitialCrc: ULONGLONG,
+    ) -> ULONGLONG;
+}
+ENUM!{enum OS_DEPLOYEMENT_STATE_VALUES {
+    OS_DEPLOYMENT_STANDARD = 1,
+    OS_DEPLOYMENT_COMPACT,
+}}
+extern "system" {
+    pub fn RtlOsDeploymentState(
+        Flags: DWORD,
+    ) -> OS_DEPLOYEMENT_STATE_VALUES;
+}
+#[cfg(target_arch = "x86_64")]
+IFDEF!{
+STRUCT!{struct NV_MEMORY_RANGE {
+    BaseAddress: *mut VOID,
+    Length: SIZE_T,
+}}
+pub type PNV_MEMORY_RANGE = *mut NV_MEMORY_RANGE;
+pub const FLUSH_NV_MEMORY_IN_FLAG_NO_DRAIN: ULONG = 0x00000001;
+pub const FLUSH_NV_MEMORY_DEFAULT_TOKEN: ULONG_PTR = -1isize as usize;
+}
+STRUCT!{struct RTL_CRITICAL_SECTION_DEBUG {
+    Type: WORD,
+    CreatorBackTraceIndex: WORD,
+    CriticalSection: *mut RTL_CRITICAL_SECTION,
+    ProcessLocksList: LIST_ENTRY,
+    EntryCount: DWORD,
+    ContentionCount: DWORD,
+    Flags: DWORD,
+    CreatorBackTraceIndexHigh: WORD,
+    SpareWORD: WORD,
+}}
+pub type PRTL_CRITICAL_SECTION_DEBUG = *mut RTL_CRITICAL_SECTION_DEBUG;
+pub type RTL_RESOURCE_DEBUG = RTL_CRITICAL_SECTION_DEBUG;
+pub type PRTL_RESOURCE_DEBUG = *mut RTL_CRITICAL_SECTION_DEBUG;
+pub const RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO: ULONG_PTR = 0x01000000;
+pub const RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN: ULONG_PTR = 0x02000000;
+pub const RTL_CRITICAL_SECTION_FLAG_STATIC_INIT: ULONG_PTR = 0x04000000;
+pub const RTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPE: ULONG_PTR = 0x08000000;
+pub const RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO: ULONG_PTR = 0x10000000;
+pub const RTL_CRITICAL_SECTION_ALL_FLAG_BITS: ULONG_PTR = 0xFF000000;
+pub const RTL_CRITICAL_SECTION_FLAG_RESERVED: ULONG_PTR = RTL_CRITICAL_SECTION_ALL_FLAG_BITS
+    & !(RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO | RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN
+        | RTL_CRITICAL_SECTION_FLAG_STATIC_INIT | RTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPE
+        | RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
+pub const RTL_CRITICAL_SECTION_DEBUG_FLAG_STATIC_INIT: DWORD = 0x00000001;
+STRUCT!{struct RTL_CRITICAL_SECTION {
+    DebugInfo: PRTL_CRITICAL_SECTION_DEBUG,
+    LockCount: LONG,
+    RecursionCount: LONG,
+    OwningThread: HANDLE,
+    LockSemaphore: HANDLE,
+    SpinCount: ULONG_PTR,
+}}
+pub type PRTL_CRITICAL_SECTION = *mut RTL_CRITICAL_SECTION;
+STRUCT!{struct RTL_SRWLOCK {
+    Ptr: PVOID,
+}}
+pub type PRTL_SRWLOCK = *mut RTL_SRWLOCK;
+pub const RTL_SRWLOCK_INIT: RTL_SRWLOCK = RTL_SRWLOCK { Ptr: 0 as PVOID };
+STRUCT!{struct RTL_CONDITION_VARIABLE {
+    Ptr: PVOID,
+}}
+pub type PRTL_CONDITION_VARIABLE = *mut RTL_CONDITION_VARIABLE;
+pub const RTL_CONDITION_VARIABLE_INIT: RTL_CONDITION_VARIABLE = RTL_CONDITION_VARIABLE {
+    Ptr: 0 as PVOID,
+};
+pub const RTL_CONDITION_VARIABLE_LOCKMODE_SHARED: DWORD = 0x1;
+FN!{stdcall PAPCFUNC(
+    Parameter: ULONG_PTR,
+) -> ()}
+FN!{stdcall PVECTORED_EXCEPTION_HANDLER(
+    ExceptionInfo: *mut EXCEPTION_POINTERS,
+) -> LONG}
+ENUM!{enum HEAP_INFORMATION_CLASS {
+    HeapCompatibilityInformation = 0,
+    HeapEnableTerminationOnCorruption = 1,
+    HeapOptimizeResources = 3,
+}}
+pub const HEAP_OPTIMIZE_RESOURCES_CURRENT_VERSION: DWORD = 1;
+STRUCT!{struct HEAP_OPTIMIZE_RESOURCES_INFORMATION {
+    Version: DWORD,
+    Flags: DWORD,
+}}
+pub type PHEAP_OPTIMIZE_RESOURCES_INFORMATION = *mut HEAP_OPTIMIZE_RESOURCES_INFORMATION;
+pub const WT_EXECUTEDEFAULT: ULONG = 0x00000000;
+pub const WT_EXECUTEINIOTHREAD: ULONG = 0x00000001;
+pub const WT_EXECUTEINUITHREAD: ULONG = 0x00000002;
+pub const WT_EXECUTEINWAITTHREAD: ULONG = 0x00000004;
+pub const WT_EXECUTEONLYONCE: ULONG = 0x00000008;
+pub const WT_EXECUTEINTIMERTHREAD: ULONG = 0x00000020;
+pub const WT_EXECUTELONGFUNCTION: ULONG = 0x00000010;
+pub const WT_EXECUTEINPERSISTENTIOTHREAD: ULONG = 0x00000040;
+pub const WT_EXECUTEINPERSISTENTTHREAD: ULONG = 0x00000080;
+pub const WT_TRANSFER_IMPERSONATION: ULONG = 0x00000100;
+#[inline]
+pub fn WT_SET_MAX_THREADPOOL_THREADS(Flags: ULONG, Limit: ULONG) -> ULONG {
+    Flags | (Limit << 16)
+}
+FN!{stdcall WAITORTIMERCALLBACKFUNC(
+    PVOID,
+    BOOLEAN,
+) -> ()}
+FN!{stdcall WORKERCALLBACKFUNC(
+    PVOID,
+) -> ()}
+FN!{stdcall APC_CALLBACK_FUNCTION(
+    DWORD,
+    PVOID,
+    PVOID,
+) -> ()}
+pub type WAITORTIMERCALLBACK = WAITORTIMERCALLBACKFUNC;
+FN!{stdcall PFLS_CALLBACK_FUNCTION(
+    lpFlsData: PVOID,
+) -> ()}
+FN!{stdcall PSECURE_MEMORY_CACHE_CALLBACK(
+    Addr: PVOID,
+    Range: SIZE_T,
+) -> BOOLEAN}
+pub const WT_EXECUTEINLONGTHREAD: ULONG = 0x00000010;
+pub const WT_EXECUTEDELETEWAIT: ULONG = 0x00000008;
+ENUM!{enum ACTIVATION_CONTEXT_INFO_CLASS {
+    ActivationContextBasicInformation = 1,
+    ActivationContextDetailedInformation = 2,
+    AssemblyDetailedInformationInActivationContext = 3,
+    FileInformationInAssemblyOfAssemblyInActivationContext = 4,
+    RunlevelInformationInActivationContext = 5,
+    CompatibilityInformationInActivationContext = 6,
+    ActivationContextManifestResourceName = 7,
+    MaxActivationContextInfoClass,
+    AssemblyDetailedInformationInActivationContxt = 3,
+    FileInformationInAssemblyOfAssemblyInActivationContxt = 4,
+}}
+pub type ACTIVATIONCONTEXTINFOCLASS = ACTIVATION_CONTEXT_INFO_CLASS;
+STRUCT!{struct ACTIVATION_CONTEXT_QUERY_INDEX {
+    ulAssemblyIndex: DWORD,
+    ulFileIndexInAssembly: DWORD,
+}}
+pub type PACTIVATION_CONTEXT_QUERY_INDEX = *mut ACTIVATION_CONTEXT_QUERY_INDEX;
+pub type PCACTIVATION_CONTEXT_QUERY_INDEX = *const ACTIVATION_CONTEXT_QUERY_INDEX;
+pub const ACTIVATION_CONTEXT_PATH_TYPE_NONE: DWORD = 1;
+pub const ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE: DWORD = 2;
+pub const ACTIVATION_CONTEXT_PATH_TYPE_URL: DWORD = 3;
+pub const ACTIVATION_CONTEXT_PATH_TYPE_ASSEMBLYREF: DWORD = 4;
+STRUCT!{struct ASSEMBLY_FILE_DETAILED_INFORMATION {
+    ulFlags: DWORD,
+    ulFilenameLength: DWORD,
+    ulPathLength: DWORD,
+    lpFileName: PCWSTR,
+    lpFilePath: PCWSTR,
+}}
+pub type PASSEMBLY_FILE_DETAILED_INFORMATION = *mut ASSEMBLY_FILE_DETAILED_INFORMATION;
+pub type PCASSEMBLY_FILE_DETAILED_INFORMATION = *const ASSEMBLY_FILE_DETAILED_INFORMATION;
+pub type ASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION = ASSEMBLY_FILE_DETAILED_INFORMATION;
+pub type PASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION = PASSEMBLY_FILE_DETAILED_INFORMATION;
+pub type PCASSEMBLY_DLL_REDIRECTION_DETAILED_INFORMATION = PCASSEMBLY_FILE_DETAILED_INFORMATION;
+STRUCT!{struct ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
+    ulFlags: DWORD,
+    ulEncodedAssemblyIdentityLength: DWORD,
+    ulManifestPathType: DWORD,
+    ulManifestPathLength: DWORD,
+    liManifestLastWriteTime: LARGE_INTEGER,
+    ulPolicyPathType: DWORD,
+    ulPolicyPathLength: DWORD,
+    liPolicyLastWriteTime: LARGE_INTEGER,
+    ulMetadataSatelliteRosterIndex: DWORD,
+    ulManifestVersionMajor: DWORD,
+    ulManifestVersionMinor: DWORD,
+    ulPolicyVersionMajor: DWORD,
+    ulPolicyVersionMinor: DWORD,
+    ulAssemblyDirectoryNameLength: DWORD,
+    lpAssemblyEncodedAssemblyIdentity: PCWSTR,
+    lpAssemblyManifestPath: PCWSTR,
+    lpAssemblyPolicyPath: PCWSTR,
+    lpAssemblyDirectoryName: PCWSTR,
+    ulFileCount: DWORD,
+}}
+pub type PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
+    = *mut ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;
+pub type PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
+    = *const ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;
+ENUM!{enum ACTCTX_REQUESTED_RUN_LEVEL {
+    ACTCTX_RUN_LEVEL_UNSPECIFIED = 0,
+    ACTCTX_RUN_LEVEL_AS_INVOKER,
+    ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE,
+    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN,
+    ACTCTX_RUN_LEVEL_NUMBERS,
+}}
+STRUCT!{struct ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
+    ulFlags: DWORD,
+    RunLevel: ACTCTX_REQUESTED_RUN_LEVEL,
+    UiAccess: DWORD,
+}}
+pub type PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION = *mut ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;
+pub type PCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION
+    = *const ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;
+ENUM!{enum ACTCTX_COMPATIBILITY_ELEMENT_TYPE {
+    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN = 0,
+    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS,
+    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION,
+}}
+STRUCT!{struct COMPATIBILITY_CONTEXT_ELEMENT {
+    Id: GUID,
+    Type: ACTCTX_COMPATIBILITY_ELEMENT_TYPE,
+}}
+pub type PCOMPATIBILITY_CONTEXT_ELEMENT = *mut COMPATIBILITY_CONTEXT_ELEMENT;
+pub type PCCOMPATIBILITY_CONTEXT_ELEMENT = *const COMPATIBILITY_CONTEXT_ELEMENT;
+STRUCT!{struct ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
+    ElementCount: DWORD,
+    Elements: [COMPATIBILITY_CONTEXT_ELEMENT; 0],
+}}
+pub type PACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION
+    = *mut ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION;
+pub type PCACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION
+    = *const ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION;
+STRUCT!{struct SUPPORTED_OS_INFO {
+    MajorVersion: WORD,
+    MinorVersion: WORD,
+}}
+pub type PSUPPORTED_OS_INFO = *mut SUPPORTED_OS_INFO;
+STRUCT!{struct ACTIVATION_CONTEXT_DETAILED_INFORMATION {
+    dwFlags: DWORD,
+    ulFormatVersion: DWORD,
+    ulAssemblyCount: DWORD,
+    ulRootManifestPathType: DWORD,
+    ulRootManifestPathChars: DWORD,
+    ulRootConfigurationPathType: DWORD,
+    ulRootConfigurationPathChars: DWORD,
+    ulAppDirPathType: DWORD,
+    ulAppDirPathChars: DWORD,
+    lpRootManifestPath: PCWSTR,
+    lpRootConfigurationPath: PCWSTR,
+    lpAppDirPath: PCWSTR,
+}}
+pub type PACTIVATION_CONTEXT_DETAILED_INFORMATION = *mut ACTIVATION_CONTEXT_DETAILED_INFORMATION;
+pub type PCACTIVATION_CONTEXT_DETAILED_INFORMATION
+    = *const ACTIVATION_CONTEXT_DETAILED_INFORMATION;
+pub const CREATE_BOUNDARY_DESCRIPTOR_ADD_APPCONTAINER_SID: DWORD = 0x1;
+STRUCT!{struct HARDWARE_COUNTER_DATA {
+    Type: HARDWARE_COUNTER_TYPE,
+    Reserved: DWORD,
+    Value: DWORD64,
+}}
+pub type PHARDWARE_COUNTER_DATA = *mut HARDWARE_COUNTER_DATA;
+pub const PERFORMANCE_DATA_VERSION: BYTE = 1;
+STRUCT!{struct PERFORMANCE_DATA {
+    Size: WORD,
+    Version: BYTE,
+    HwCountersCount: BYTE,
+    ContextSwitchCount: DWORD,
+    WaitReasonBitMap: DWORD64,
+    CycleTime: DWORD64,
+    RetryCount: DWORD,
+    Reserved: DWORD,
+    HwCounters: [HARDWARE_COUNTER_DATA; MAX_HW_COUNTERS],
+}}
+pub type PPERFORMANCE_DATA = *mut PERFORMANCE_DATA;
+pub const READ_THREAD_PROFILING_FLAG_DISPATCHING: DWORD = 0x00000001;
+pub const READ_THREAD_PROFILING_FLAG_HARDWARE_COUNTERS: DWORD = 0x00000002;
+pub const UNIFIEDBUILDREVISION_KEY: &'static str
+    = "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion";
+pub const UNIFIEDBUILDREVISION_VALUE: &'static str = "UBR";
+pub const UNIFIEDBUILDREVISION_MIN: DWORD = 0x00000000;
+pub const DEVICEFAMILYDEVICEFORM_KEY: &'static str
+    = "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\OEM";
+pub const DEVICEFAMILYDEVICEFORM_VALUE: &'static str = "DeviceForm";
+pub const DEVICEFAMILYINFOENUM_UAP: DWORD = 0x00000000;
+pub const DEVICEFAMILYINFOENUM_WINDOWS_8X: DWORD = 0x00000001;
+pub const DEVICEFAMILYINFOENUM_WINDOWS_PHONE_8X: DWORD = 0x00000002;
+pub const DEVICEFAMILYINFOENUM_DESKTOP: DWORD = 0x00000003;
+pub const DEVICEFAMILYINFOENUM_MOBILE: DWORD = 0x00000004;
+pub const DEVICEFAMILYINFOENUM_XBOX: DWORD = 0x00000005;
+pub const DEVICEFAMILYINFOENUM_TEAM: DWORD = 0x00000006;
+pub const DEVICEFAMILYINFOENUM_IOT: DWORD = 0x00000007;
+pub const DEVICEFAMILYINFOENUM_IOT_HEADLESS: DWORD = 0x00000008;
+pub const DEVICEFAMILYINFOENUM_SERVER: DWORD = 0x00000009;
+pub const DEVICEFAMILYINFOENUM_HOLOGRAPHIC: DWORD = 0x0000000A;
+pub const DEVICEFAMILYINFOENUM_XBOXSRA: DWORD = 0x0000000B;
+pub const DEVICEFAMILYINFOENUM_XBOXERA: DWORD = 0x0000000C;
+pub const DEVICEFAMILYINFOENUM_SERVER_NANO: DWORD = 0x0000000D;
+pub const DEVICEFAMILYINFOENUM_MAX: DWORD = 0x0000000D;
+pub const DEVICEFAMILYDEVICEFORM_UNKNOWN: DWORD = 0x00000000;
+pub const DEVICEFAMILYDEVICEFORM_PHONE: DWORD = 0x00000001;
+pub const DEVICEFAMILYDEVICEFORM_TABLET: DWORD = 0x00000002;
+pub const DEVICEFAMILYDEVICEFORM_DESKTOP: DWORD = 0x00000003;
+pub const DEVICEFAMILYDEVICEFORM_NOTEBOOK: DWORD = 0x00000004;
+pub const DEVICEFAMILYDEVICEFORM_CONVERTIBLE: DWORD = 0x00000005;
+pub const DEVICEFAMILYDEVICEFORM_DETACHABLE: DWORD = 0x00000006;
+pub const DEVICEFAMILYDEVICEFORM_ALLINONE: DWORD = 0x00000007;
+pub const DEVICEFAMILYDEVICEFORM_STICKPC: DWORD = 0x00000008;
+pub const DEVICEFAMILYDEVICEFORM_PUCK: DWORD = 0x00000009;
+pub const DEVICEFAMILYDEVICEFORM_LARGESCREEN: DWORD = 0x0000000A;
+pub const DEVICEFAMILYDEVICEFORM_HMD: DWORD = 0x0000000B;
+pub const DEVICEFAMILYDEVICEFORM_INDUSTRY_HANDHELD: DWORD = 0x0000000C;
+pub const DEVICEFAMILYDEVICEFORM_INDUSTRY_TABLET: DWORD = 0x0000000D;
+pub const DEVICEFAMILYDEVICEFORM_BANKING: DWORD = 0x0000000E;
+pub const DEVICEFAMILYDEVICEFORM_BUILDING_AUTOMATION: DWORD = 0x0000000F;
+pub const DEVICEFAMILYDEVICEFORM_DIGITAL_SIGNAGE: DWORD = 0x00000010;
+pub const DEVICEFAMILYDEVICEFORM_GAMING: DWORD = 0x00000011;
+pub const DEVICEFAMILYDEVICEFORM_HOME_AUTOMATION: DWORD = 0x00000012;
+pub const DEVICEFAMILYDEVICEFORM_INDUSTRIAL_AUTOMATION: DWORD = 0x00000013;
+pub const DEVICEFAMILYDEVICEFORM_KIOSK: DWORD = 0x00000014;
+pub const DEVICEFAMILYDEVICEFORM_MAKER_BOARD: DWORD = 0x00000015;
+pub const DEVICEFAMILYDEVICEFORM_MEDICAL: DWORD = 0x00000016;
+pub const DEVICEFAMILYDEVICEFORM_NETWORKING: DWORD = 0x00000017;
+pub const DEVICEFAMILYDEVICEFORM_POINT_OF_SERVICE: DWORD = 0x00000018;
+pub const DEVICEFAMILYDEVICEFORM_PRINTING: DWORD = 0x00000019;
+pub const DEVICEFAMILYDEVICEFORM_THIN_CLIENT: DWORD = 0x0000001A;
+pub const DEVICEFAMILYDEVICEFORM_TOY: DWORD = 0x0000001B;
+pub const DEVICEFAMILYDEVICEFORM_VENDING: DWORD = 0x0000001C;
+pub const DEVICEFAMILYDEVICEFORM_INDUSTRY_OTHER: DWORD = 0x0000001D;
+pub const DEVICEFAMILYDEVICEFORM_MAX: DWORD = 0x0000001D;
+extern "system" {
+    pub fn RtlGetDeviceFamilyInfoEnum(
+        pullUAPInfo: *mut ULONGLONG,
+        pulDeviceFamily: *mut DWORD,
+        pulDeviceForm: *mut DWORD,
+    );
+    pub fn RtlConvertDeviceFamilyInfoToString(
+        pulDeviceFamilyBufferSize: PDWORD,
+        pulDeviceFormBufferSize: PDWORD,
+        DeviceFamily: PWSTR,
+        DeviceForm: PWSTR,
+    ) -> DWORD;
+    pub fn RtlSwitchedVVI(
+        VersionInfo: PRTL_OSVERSIONINFOEXW,
+        TypeMask: DWORD,
+        ConditionMask: ULONGLONG,
+    ) -> DWORD;
+}
+pub const DLL_PROCESS_ATTACH: DWORD = 1;
+pub const DLL_THREAD_ATTACH: DWORD = 2;
+pub const DLL_THREAD_DETACH: DWORD = 3;
+pub const DLL_PROCESS_DETACH: DWORD = 0;
+pub const EVENTLOG_SEQUENTIAL_READ: DWORD = 0x0001;
+pub const EVENTLOG_SEEK_READ: DWORD = 0x0002;
+pub const EVENTLOG_FORWARDS_READ: DWORD = 0x0004;
+pub const EVENTLOG_BACKWARDS_READ: DWORD = 0x0008;
+pub const EVENTLOG_SUCCESS: WORD = 0x0000;
+pub const EVENTLOG_ERROR_TYPE: WORD = 0x0001;
+pub const EVENTLOG_WARNING_TYPE: WORD = 0x0002;
+pub const EVENTLOG_INFORMATION_TYPE: WORD = 0x0004;
+pub const EVENTLOG_AUDIT_SUCCESS: WORD = 0x0008;
+pub const EVENTLOG_AUDIT_FAILURE: WORD = 0x0010;
+pub const EVENTLOG_START_PAIRED_EVENT: WORD = 0x0001;
+pub const EVENTLOG_END_PAIRED_EVENT: WORD = 0x0002;
+pub const EVENTLOG_END_ALL_PAIRED_EVENTS: WORD = 0x0004;
+pub const EVENTLOG_PAIRED_EVENT_ACTIVE: WORD = 0x0008;
+pub const EVENTLOG_PAIRED_EVENT_INACTIVE: WORD = 0x0010;
+STRUCT!{struct EVENTLOGRECORD {
+    Length: DWORD,
+    Reserved: DWORD,
+    RecordNumber: DWORD,
+    TimeGenerated: DWORD,
+    TimeWritten: DWORD,
+    EventID: DWORD,
+    EventType: WORD,
+    NumStrings: WORD,
+    EventCategory: WORD,
+    ReservedFlags: WORD,
+    ClosingRecordNumber: DWORD,
+    StringOffset: DWORD,
+    UserSidLength: DWORD,
+    UserSidOffset: DWORD,
+    DataLength: DWORD,
+    DataOffset: DWORD,
+}}
+pub type PEVENTLOGRECORD = *mut EVENTLOGRECORD;
+pub const MAXLOGICALLOGNAMESIZE: usize = 256;
+pub type PEVENTSFORLOGFILE = *mut EVENTSFORLOGFILE;
+pub type PPACKEDEVENTINFO = *mut PACKEDEVENTINFO;
+STRUCT!{struct EVENTSFORLOGFILE {
+    ulSize: DWORD,
+    szLogicalLogFile: [WCHAR; MAXLOGICALLOGNAMESIZE],
+    ulNumRecords: DWORD,
+    pEventLogRecords: [EVENTLOGRECORD; 0],
+}}
+STRUCT!{struct PACKEDEVENTINFO {
+    ulSize: DWORD,
+    ulNumEventsForLogFile: DWORD,
+    ulOffsets: [DWORD; 0],
+}}
+pub const KEY_QUERY_VALUE: u32 = 0x0001;
+pub const KEY_SET_VALUE: u32 = 0x0002;
+pub const KEY_CREATE_SUB_KEY: u32 = 0x0004;
+pub const KEY_ENUMERATE_SUB_KEYS: u32 = 0x0008;
+pub const KEY_NOTIFY: u32 = 0x0010;
+pub const KEY_CREATE_LINK: u32 = 0x0020;
+pub const KEY_WOW64_32KEY: u32 = 0x0200;
+pub const KEY_WOW64_64KEY: u32 = 0x0100;
+pub const KEY_WOW64_RES: u32 = 0x0300;
+pub const KEY_READ: u32 = (STANDARD_RIGHTS_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS
+    | KEY_NOTIFY) & !SYNCHRONIZE;
+pub const KEY_WRITE: u32 = (STANDARD_RIGHTS_WRITE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY)
+    & !SYNCHRONIZE;
+pub const KEY_EXECUTE: u32 = KEY_READ & !SYNCHRONIZE;
+pub const KEY_ALL_ACCESS: u32 = (STANDARD_RIGHTS_ALL | KEY_QUERY_VALUE | KEY_SET_VALUE
+    | KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY | KEY_CREATE_LINK) & !SYNCHRONIZE;
+pub const REG_OPTION_RESERVED: DWORD = 0x00000000;
+pub const REG_OPTION_NON_VOLATILE: DWORD = 0x00000000;
+pub const REG_OPTION_VOLATILE: DWORD = 0x00000001;
+pub const REG_OPTION_CREATE_LINK: DWORD = 0x00000002;
+pub const REG_OPTION_BACKUP_RESTORE: DWORD = 0x00000004;
+pub const REG_OPTION_OPEN_LINK: DWORD = 0x00000008;
+pub const REG_OPTION_DONT_VIRTUALIZE: DWORD = 0x00000010;
+pub const REG_LEGAL_OPTION: DWORD = REG_OPTION_RESERVED | REG_OPTION_NON_VOLATILE
+    | REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK | REG_OPTION_BACKUP_RESTORE
+    | REG_OPTION_OPEN_LINK | REG_OPTION_DONT_VIRTUALIZE;
+pub const REG_OPEN_LEGAL_OPTION: DWORD = REG_OPTION_RESERVED | REG_OPTION_BACKUP_RESTORE
+    | REG_OPTION_OPEN_LINK | REG_OPTION_DONT_VIRTUALIZE;
+pub const REG_CREATED_NEW_KEY: DWORD = 0x00000001;
+pub const REG_OPENED_EXISTING_KEY: DWORD = 0x00000002;
+pub const REG_STANDARD_FORMAT: DWORD = 1;
+pub const REG_LATEST_FORMAT: DWORD = 2;
+pub const REG_NO_COMPRESSION: DWORD = 4;
+pub const REG_WHOLE_HIVE_VOLATILE: DWORD = 0x00000001;
+pub const REG_REFRESH_HIVE: DWORD = 0x00000002;
+pub const REG_NO_LAZY_FLUSH: DWORD = 0x00000004;
+pub const REG_FORCE_RESTORE: DWORD = 0x00000008;
+pub const REG_APP_HIVE: DWORD = 0x00000010;
+pub const REG_PROCESS_PRIVATE: DWORD = 0x00000020;
+pub const REG_START_JOURNAL: DWORD = 0x00000040;
+pub const REG_HIVE_EXACT_FILE_GROWTH: DWORD = 0x00000080;
+pub const REG_HIVE_NO_RM: DWORD = 0x00000100;
+pub const REG_HIVE_SINGLE_LOG: DWORD = 0x00000200;
+pub const REG_BOOT_HIVE: DWORD = 0x00000400;
+pub const REG_LOAD_HIVE_OPEN_HANDLE: DWORD = 0x00000800;
+pub const REG_FLUSH_HIVE_FILE_GROWTH: DWORD = 0x00001000;
+pub const REG_OPEN_READ_ONLY: DWORD = 0x00002000;
+pub const REG_IMMUTABLE: DWORD = 0x00004000;
+pub const REG_APP_HIVE_OPEN_READ_ONLY: DWORD = REG_OPEN_READ_ONLY;
+pub const REG_FORCE_UNLOAD: DWORD = 1;
+pub const REG_UNLOAD_LEGAL_FLAGS: DWORD = REG_FORCE_UNLOAD;
+pub const REG_NOTIFY_CHANGE_NAME: DWORD = 0x00000001;
+pub const REG_NOTIFY_CHANGE_ATTRIBUTES: DWORD = 0x00000002;
+pub const REG_NOTIFY_CHANGE_LAST_SET: DWORD = 0x00000004;
+pub const REG_NOTIFY_CHANGE_SECURITY: DWORD = 0x00000008;
+pub const REG_NOTIFY_THREAD_AGNOSTIC: DWORD = 0x10000000;
+pub const REG_LEGAL_CHANGE_FILTER: DWORD = REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_ATTRIBUTES
+    | REG_NOTIFY_CHANGE_LAST_SET | REG_NOTIFY_CHANGE_SECURITY | REG_NOTIFY_THREAD_AGNOSTIC;
+pub const REG_NONE: DWORD = 0;
+pub const REG_SZ: DWORD = 1;
+pub const REG_EXPAND_SZ: DWORD = 2;
+pub const REG_BINARY: DWORD = 3;
+pub const REG_DWORD: DWORD = 4;
+pub const REG_DWORD_LITTLE_ENDIAN: DWORD = 4;
+pub const REG_DWORD_BIG_ENDIAN: DWORD = 5;
+pub const REG_LINK: DWORD = 6;
+pub const REG_MULTI_SZ: DWORD = 7;
+pub const REG_RESOURCE_LIST: DWORD = 8;
+pub const REG_FULL_RESOURCE_DESCRIPTOR: DWORD = 9;
+pub const REG_RESOURCE_REQUIREMENTS_LIST: DWORD = 10;
+pub const REG_QWORD: DWORD = 11;
+pub const REG_QWORD_LITTLE_ENDIAN: DWORD = 11;
+pub const SERVICE_KERNEL_DRIVER: DWORD = 0x00000001;
+pub const SERVICE_FILE_SYSTEM_DRIVER: DWORD = 0x00000002;
+pub const SERVICE_ADAPTER: DWORD = 0x00000004;
+pub const SERVICE_RECOGNIZER_DRIVER: DWORD = 0x00000008;
+pub const SERVICE_DRIVER: DWORD = SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER
+    | SERVICE_RECOGNIZER_DRIVER;
+pub const SERVICE_WIN32_OWN_PROCESS: DWORD = 0x00000010;
+pub const SERVICE_WIN32_SHARE_PROCESS: DWORD = 0x00000020;
+pub const SERVICE_WIN32: DWORD = SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS;
+pub const SERVICE_USER_SERVICE: DWORD = 0x00000040;
+pub const SERVICE_USERSERVICE_INSTANCE: DWORD = 0x00000080;
+pub const SERVICE_USER_SHARE_PROCESS: DWORD = SERVICE_USER_SERVICE | SERVICE_WIN32_SHARE_PROCESS;
+pub const SERVICE_USER_OWN_PROCESS: DWORD = SERVICE_USER_SERVICE | SERVICE_WIN32_OWN_PROCESS;
+pub const SERVICE_INTERACTIVE_PROCESS: DWORD = 0x00000100;
+pub const SERVICE_PKG_SERVICE: DWORD = 0x00000200;
+pub const SERVICE_TYPE_ALL: DWORD = SERVICE_WIN32 | SERVICE_ADAPTER | SERVICE_DRIVER
+    | SERVICE_INTERACTIVE_PROCESS | SERVICE_USER_SERVICE | SERVICE_USERSERVICE_INSTANCE
+    | SERVICE_PKG_SERVICE;
+pub const SERVICE_BOOT_START: DWORD = 0x00000000;
+pub const SERVICE_SYSTEM_START: DWORD = 0x00000001;
+pub const SERVICE_AUTO_START: DWORD = 0x00000002;
+pub const SERVICE_DEMAND_START: DWORD = 0x00000003;
+pub const SERVICE_DISABLED: DWORD = 0x00000004;
+pub const SERVICE_ERROR_IGNORE: DWORD = 0x00000000;
+pub const SERVICE_ERROR_NORMAL: DWORD = 0x00000001;
+pub const SERVICE_ERROR_SEVERE: DWORD = 0x00000002;
+pub const SERVICE_ERROR_CRITICAL: DWORD = 0x00000003;
+ENUM!{enum SERVICE_NODE_TYPE {
+    DriverType = SERVICE_KERNEL_DRIVER,
+    FileSystemType = SERVICE_FILE_SYSTEM_DRIVER,
+    Win32ServiceOwnProcess = SERVICE_WIN32_OWN_PROCESS,
+    Win32ServiceShareProcess = SERVICE_WIN32_SHARE_PROCESS,
+    AdapterType = SERVICE_ADAPTER,
+    RecognizerType = SERVICE_RECOGNIZER_DRIVER,
+}}
+ENUM!{enum SERVICE_LOAD_TYPE {
+    BootLoad = SERVICE_BOOT_START,
+    SystemLoad = SERVICE_SYSTEM_START,
+    AutoLoad = SERVICE_AUTO_START,
+    DemandLoad = SERVICE_DEMAND_START,
+    DisableLoad = SERVICE_DISABLED,
+}}
+ENUM!{enum SERVICE_ERROR_TYPE {
+    IgnoreError = SERVICE_ERROR_IGNORE,
+    NormalError = SERVICE_ERROR_NORMAL,
+    SevereError = SERVICE_ERROR_SEVERE,
+    CriticalError = SERVICE_ERROR_CRITICAL,
+}}
+pub const CM_SERVICE_NETWORK_BOOT_LOAD: DWORD = 0x00000001;
+pub const CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD: DWORD = 0x00000002;
+pub const CM_SERVICE_USB_DISK_BOOT_LOAD: DWORD = 0x00000004;
+pub const CM_SERVICE_SD_DISK_BOOT_LOAD: DWORD = 0x00000008;
+pub const CM_SERVICE_USB3_DISK_BOOT_LOAD: DWORD = 0x00000010;
+pub const CM_SERVICE_MEASURED_BOOT_LOAD: DWORD = 0x00000020;
+pub const CM_SERVICE_VERIFIER_BOOT_LOAD: DWORD = 0x00000040;
+pub const CM_SERVICE_WINPE_BOOT_LOAD: DWORD = 0x00000080;
+pub const CM_SERVICE_VALID_PROMOTION_MASK: DWORD = CM_SERVICE_NETWORK_BOOT_LOAD
+    | CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD | CM_SERVICE_USB_DISK_BOOT_LOAD
+    | CM_SERVICE_SD_DISK_BOOT_LOAD | CM_SERVICE_USB3_DISK_BOOT_LOAD
+    | CM_SERVICE_MEASURED_BOOT_LOAD | CM_SERVICE_VERIFIER_BOOT_LOAD | CM_SERVICE_WINPE_BOOT_LOAD;
+pub const TAPE_ERASE_SHORT: DWORD = 0;
+pub const TAPE_ERASE_LONG: DWORD = 1;
+STRUCT!{struct TAPE_ERASE {
+    Type: DWORD,
+    Immediate: BOOLEAN,
+}}
+pub type PTAPE_ERASE = *mut TAPE_ERASE;
+pub const TAPE_LOAD: DWORD = 0;
+pub const TAPE_UNLOAD: DWORD = 1;
+pub const TAPE_TENSION: DWORD = 2;
+pub const TAPE_LOCK: DWORD = 3;
+pub const TAPE_UNLOCK: DWORD = 4;
+pub const TAPE_FORMAT: DWORD = 5;
+STRUCT!{struct TAPE_PREPARE {
+    Operation: DWORD,
+    Immediate: BOOLEAN,
+}}
+pub type PTAPE_PREPARE = *mut TAPE_PREPARE;
+pub const TAPE_SETMARKS: DWORD = 0;
+pub const TAPE_FILEMARKS: DWORD = 1;
+pub const TAPE_SHORT_FILEMARKS: DWORD = 2;
+pub const TAPE_LONG_FILEMARKS: DWORD = 3;
+STRUCT!{struct TAPE_WRITE_MARKS {
+    Type: DWORD,
+    Count: DWORD,
+    Immediate: BOOLEAN,
+}}
+pub type PTAPE_WRITE_MARKS = *mut TAPE_WRITE_MARKS;
+pub const TAPE_ABSOLUTE_POSITION: DWORD = 0;
+pub const TAPE_LOGICAL_POSITION: DWORD = 1;
+pub const TAPE_PSEUDO_LOGICAL_POSITION: DWORD = 2;
+STRUCT!{struct TAPE_GET_POSITION {
+    Type: DWORD,
+    Partition: DWORD,
+    Offset: LARGE_INTEGER,
+}}
+pub type PTAPE_GET_POSITION = *mut TAPE_GET_POSITION;
+pub const TAPE_REWIND: DWORD = 0;
+pub const TAPE_ABSOLUTE_BLOCK: DWORD = 1;
+pub const TAPE_LOGICAL_BLOCK: DWORD = 2;
+pub const TAPE_PSEUDO_LOGICAL_BLOCK: DWORD = 3;
+pub const TAPE_SPACE_END_OF_DATA: DWORD = 4;
+pub const TAPE_SPACE_RELATIVE_BLOCKS: DWORD = 5;
+pub const TAPE_SPACE_FILEMARKS: DWORD = 6;
+pub const TAPE_SPACE_SEQUENTIAL_FMKS: DWORD = 7;
+pub const TAPE_SPACE_SETMARKS: DWORD = 8;
+pub const TAPE_SPACE_SEQUENTIAL_SMKS: DWORD = 9;
+STRUCT!{struct TAPE_SET_POSITION {
+    Method: DWORD,
+    Partition: DWORD,
+    Offset: LARGE_INTEGER,
+    Immediate: BOOLEAN,
+}}
+pub type PTAPE_SET_POSITION = *mut TAPE_SET_POSITION;
+pub const TAPE_DRIVE_FIXED: DWORD = 0x00000001;
+pub const TAPE_DRIVE_SELECT: DWORD = 0x00000002;
+pub const TAPE_DRIVE_INITIATOR: DWORD = 0x00000004;
+pub const TAPE_DRIVE_ERASE_SHORT: DWORD = 0x00000010;
+pub const TAPE_DRIVE_ERASE_LONG: DWORD = 0x00000020;
+pub const TAPE_DRIVE_ERASE_BOP_ONLY: DWORD = 0x00000040;
+pub const TAPE_DRIVE_ERASE_IMMEDIATE: DWORD = 0x00000080;
+pub const TAPE_DRIVE_TAPE_CAPACITY: DWORD = 0x00000100;
+pub const TAPE_DRIVE_TAPE_REMAINING: DWORD = 0x00000200;
+pub const TAPE_DRIVE_FIXED_BLOCK: DWORD = 0x00000400;
+pub const TAPE_DRIVE_VARIABLE_BLOCK: DWORD = 0x00000800;
+pub const TAPE_DRIVE_WRITE_PROTECT: DWORD = 0x00001000;
+pub const TAPE_DRIVE_EOT_WZ_SIZE: DWORD = 0x00002000;
+pub const TAPE_DRIVE_ECC: DWORD = 0x00010000;
+pub const TAPE_DRIVE_COMPRESSION: DWORD = 0x00020000;
+pub const TAPE_DRIVE_PADDING: DWORD = 0x00040000;
+pub const TAPE_DRIVE_REPORT_SMKS: DWORD = 0x00080000;
+pub const TAPE_DRIVE_GET_ABSOLUTE_BLK: DWORD = 0x00100000;
+pub const TAPE_DRIVE_GET_LOGICAL_BLK: DWORD = 0x00200000;
+pub const TAPE_DRIVE_SET_EOT_WZ_SIZE: DWORD = 0x00400000;
+pub const TAPE_DRIVE_EJECT_MEDIA: DWORD = 0x01000000;
+pub const TAPE_DRIVE_CLEAN_REQUESTS: DWORD = 0x02000000;
+pub const TAPE_DRIVE_SET_CMP_BOP_ONLY: DWORD = 0x04000000;
+pub const TAPE_DRIVE_RESERVED_BIT: DWORD = 0x80000000;
+pub const TAPE_DRIVE_LOAD_UNLOAD: DWORD = 0x80000001;
+pub const TAPE_DRIVE_TENSION: DWORD = 0x80000002;
+pub const TAPE_DRIVE_LOCK_UNLOCK: DWORD = 0x80000004;
+pub const TAPE_DRIVE_REWIND_IMMEDIATE: DWORD = 0x80000008;
+pub const TAPE_DRIVE_SET_BLOCK_SIZE: DWORD = 0x80000010;
+pub const TAPE_DRIVE_LOAD_UNLD_IMMED: DWORD = 0x80000020;
+pub const TAPE_DRIVE_TENSION_IMMED: DWORD = 0x80000040;
+pub const TAPE_DRIVE_LOCK_UNLK_IMMED: DWORD = 0x80000080;
+pub const TAPE_DRIVE_SET_ECC: DWORD = 0x80000100;
+pub const TAPE_DRIVE_SET_COMPRESSION: DWORD = 0x80000200;
+pub const TAPE_DRIVE_SET_PADDING: DWORD = 0x80000400;
+pub const TAPE_DRIVE_SET_REPORT_SMKS: DWORD = 0x80000800;
+pub const TAPE_DRIVE_ABSOLUTE_BLK: DWORD = 0x80001000;
+pub const TAPE_DRIVE_ABS_BLK_IMMED: DWORD = 0x80002000;
+pub const TAPE_DRIVE_LOGICAL_BLK: DWORD = 0x80004000;
+pub const TAPE_DRIVE_LOG_BLK_IMMED: DWORD = 0x80008000;
+pub const TAPE_DRIVE_END_OF_DATA: DWORD = 0x80010000;
+pub const TAPE_DRIVE_RELATIVE_BLKS: DWORD = 0x80020000;
+pub const TAPE_DRIVE_FILEMARKS: DWORD = 0x80040000;
+pub const TAPE_DRIVE_SEQUENTIAL_FMKS: DWORD = 0x80080000;
+pub const TAPE_DRIVE_SETMARKS: DWORD = 0x80100000;
+pub const TAPE_DRIVE_SEQUENTIAL_SMKS: DWORD = 0x80200000;
+pub const TAPE_DRIVE_REVERSE_POSITION: DWORD = 0x80400000;
+pub const TAPE_DRIVE_SPACE_IMMEDIATE: DWORD = 0x80800000;
+pub const TAPE_DRIVE_WRITE_SETMARKS: DWORD = 0x81000000;
+pub const TAPE_DRIVE_WRITE_FILEMARKS: DWORD = 0x82000000;
+pub const TAPE_DRIVE_WRITE_SHORT_FMKS: DWORD = 0x84000000;
+pub const TAPE_DRIVE_WRITE_LONG_FMKS: DWORD = 0x88000000;
+pub const TAPE_DRIVE_WRITE_MARK_IMMED: DWORD = 0x90000000;
+pub const TAPE_DRIVE_FORMAT: DWORD = 0xA0000000;
+pub const TAPE_DRIVE_FORMAT_IMMEDIATE: DWORD = 0xC0000000;
+pub const TAPE_DRIVE_HIGH_FEATURES: DWORD = 0x80000000;
+STRUCT!{struct TAPE_GET_DRIVE_PARAMETERS {
+    ECC: BOOLEAN,
+    Compression: BOOLEAN,
+    DataPadding: BOOLEAN,
+    ReportSetmarks: BOOLEAN,
+    DefaultBlockSize: DWORD,
+    MaximumBlockSize: DWORD,
+    MinimumBlockSize: DWORD,
+    MaximumPartitionCount: DWORD,
+    FeaturesLow: DWORD,
+    FeaturesHigh: DWORD,
+    EOTWarningZoneSize: DWORD,
+}}
+pub type PTAPE_GET_DRIVE_PARAMETERS = *mut TAPE_GET_DRIVE_PARAMETERS;
+STRUCT!{struct TAPE_SET_DRIVE_PARAMETERS {
+    ECC: BOOLEAN,
+    Compression: BOOLEAN,
+    DataPadding: BOOLEAN,
+    ReportSetmarks: BOOLEAN,
+    EOTWarningZoneSize: DWORD,
+}}
+pub type PTAPE_SET_DRIVE_PARAMETERS = *mut TAPE_SET_DRIVE_PARAMETERS;
+STRUCT!{struct TAPE_GET_MEDIA_PARAMETERS {
+    Capacity: LARGE_INTEGER,
+    Remaining: LARGE_INTEGER,
+    BlockSize: DWORD,
+    PartitionCount: DWORD,
+    WriteProtected: BOOLEAN,
+}}
+pub type PTAPE_GET_MEDIA_PARAMETERS = *mut TAPE_GET_MEDIA_PARAMETERS;
+STRUCT!{struct TAPE_SET_MEDIA_PARAMETERS {
+    BlockSize: DWORD,
+}}
+pub type PTAPE_SET_MEDIA_PARAMETERS = *mut TAPE_SET_MEDIA_PARAMETERS;
+pub const TAPE_FIXED_PARTITIONS: DWORD = 0;
+pub const TAPE_SELECT_PARTITIONS: DWORD = 1;
+pub const TAPE_INITIATOR_PARTITIONS: DWORD = 2;
+STRUCT!{struct TAPE_CREATE_PARTITION {
+    Method: DWORD,
+    Count: DWORD,
+    Size: DWORD,
+}}
+pub type PTAPE_CREATE_PARTITION = *mut TAPE_CREATE_PARTITION;
+pub const TAPE_QUERY_DRIVE_PARAMETERS: DWORD = 0;
+pub const TAPE_QUERY_MEDIA_CAPACITY: DWORD = 1;
+pub const TAPE_CHECK_FOR_DRIVE_PROBLEM: DWORD = 2;
+pub const TAPE_QUERY_IO_ERROR_DATA: DWORD = 3;
+pub const TAPE_QUERY_DEVICE_ERROR_DATA: DWORD = 4;
+STRUCT!{struct TAPE_WMI_OPERATIONS {
+    Method: DWORD,
+    DataBufferSize: DWORD,
+    DataBuffer: PVOID,
+}}
+pub type PTAPE_WMI_OPERATIONS = *mut TAPE_WMI_OPERATIONS;
+ENUM!{enum TAPE_DRIVE_PROBLEM_TYPE {
+    TapeDriveProblemNone,
+    TapeDriveReadWriteWarning,
+    TapeDriveReadWriteError,
+    TapeDriveReadWarning,
+    TapeDriveWriteWarning,
+    TapeDriveReadError,
+    TapeDriveWriteError,
+    TapeDriveHardwareError,
+    TapeDriveUnsupportedMedia,
+    TapeDriveScsiConnectionError,
+    TapeDriveTimetoClean,
+    TapeDriveCleanDriveNow,
+    TapeDriveMediaLifeExpired,
+    TapeDriveSnappedTape,
+}}
+pub const TRANSACTIONMANAGER_QUERY_INFORMATION: DWORD = 0x0001;
+pub const TRANSACTIONMANAGER_SET_INFORMATION: DWORD = 0x0002;
+pub const TRANSACTIONMANAGER_RECOVER: DWORD = 0x0004;
+pub const TRANSACTIONMANAGER_RENAME: DWORD = 0x0008;
+pub const TRANSACTIONMANAGER_CREATE_RM: DWORD = 0x0010;
+pub const TRANSACTIONMANAGER_BIND_TRANSACTION: DWORD = 0x0020;
+pub const TRANSACTIONMANAGER_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ
+    | TRANSACTIONMANAGER_QUERY_INFORMATION;
+pub const TRANSACTIONMANAGER_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE
+    | TRANSACTIONMANAGER_SET_INFORMATION | TRANSACTIONMANAGER_RECOVER | TRANSACTIONMANAGER_RENAME
+    | TRANSACTIONMANAGER_CREATE_RM;
+pub const TRANSACTIONMANAGER_GENERIC_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE;
+pub const TRANSACTIONMANAGER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED
+    | TRANSACTIONMANAGER_GENERIC_READ | TRANSACTIONMANAGER_GENERIC_WRITE
+    | TRANSACTIONMANAGER_GENERIC_EXECUTE | TRANSACTIONMANAGER_BIND_TRANSACTION;
+pub const TRANSACTION_QUERY_INFORMATION: DWORD = 0x0001;
+pub const TRANSACTION_SET_INFORMATION: DWORD = 0x0002;
+pub const TRANSACTION_ENLIST: DWORD = 0x0004;
+pub const TRANSACTION_COMMIT: DWORD = 0x0008;
+pub const TRANSACTION_ROLLBACK: DWORD = 0x0010;
+pub const TRANSACTION_PROPAGATE: DWORD = 0x0020;
+pub const TRANSACTION_RIGHT_RESERVED1: DWORD = 0x0040;
+pub const TRANSACTION_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ | TRANSACTION_QUERY_INFORMATION
+    | SYNCHRONIZE;
+pub const TRANSACTION_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE | TRANSACTION_SET_INFORMATION
+    | TRANSACTION_COMMIT | TRANSACTION_ENLIST | TRANSACTION_ROLLBACK | TRANSACTION_PROPAGATE
+    | SYNCHRONIZE;
+pub const TRANSACTION_GENERIC_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE | TRANSACTION_COMMIT
+    | TRANSACTION_ROLLBACK | SYNCHRONIZE;
+pub const TRANSACTION_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | TRANSACTION_GENERIC_READ
+    | TRANSACTION_GENERIC_WRITE | TRANSACTION_GENERIC_EXECUTE;
+pub const TRANSACTION_RESOURCE_MANAGER_RIGHTS: DWORD = TRANSACTION_GENERIC_READ
+    | STANDARD_RIGHTS_WRITE | TRANSACTION_SET_INFORMATION | TRANSACTION_ENLIST
+    | TRANSACTION_ROLLBACK | TRANSACTION_PROPAGATE | SYNCHRONIZE;
+pub const RESOURCEMANAGER_QUERY_INFORMATION: DWORD = 0x0001;
+pub const RESOURCEMANAGER_SET_INFORMATION: DWORD = 0x0002;
+pub const RESOURCEMANAGER_RECOVER: DWORD = 0x0004;
+pub const RESOURCEMANAGER_ENLIST: DWORD = 0x0008;
+pub const RESOURCEMANAGER_GET_NOTIFICATION: DWORD = 0x0010;
+pub const RESOURCEMANAGER_REGISTER_PROTOCOL: DWORD = 0x0020;
+pub const RESOURCEMANAGER_COMPLETE_PROPAGATION: DWORD = 0x0040;
+pub const RESOURCEMANAGER_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ
+    | RESOURCEMANAGER_QUERY_INFORMATION | SYNCHRONIZE;
+pub const RESOURCEMANAGER_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE
+    | RESOURCEMANAGER_SET_INFORMATION | RESOURCEMANAGER_RECOVER | RESOURCEMANAGER_ENLIST
+    | RESOURCEMANAGER_GET_NOTIFICATION | RESOURCEMANAGER_REGISTER_PROTOCOL
+    | RESOURCEMANAGER_COMPLETE_PROPAGATION | SYNCHRONIZE;
+pub const RESOURCEMANAGER_GENERIC_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE
+    | RESOURCEMANAGER_RECOVER | RESOURCEMANAGER_ENLIST | RESOURCEMANAGER_GET_NOTIFICATION
+    | RESOURCEMANAGER_COMPLETE_PROPAGATION | SYNCHRONIZE;
+pub const RESOURCEMANAGER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED
+    | RESOURCEMANAGER_GENERIC_READ | RESOURCEMANAGER_GENERIC_WRITE
+    | RESOURCEMANAGER_GENERIC_EXECUTE;
+pub const ENLISTMENT_QUERY_INFORMATION: DWORD = 0x0001;
+pub const ENLISTMENT_SET_INFORMATION: DWORD = 0x0002;
+pub const ENLISTMENT_RECOVER: DWORD = 0x0004;
+pub const ENLISTMENT_SUBORDINATE_RIGHTS: DWORD = 0x0008;
+pub const ENLISTMENT_SUPERIOR_RIGHTS: DWORD = 0x0010;
+pub const ENLISTMENT_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ | ENLISTMENT_QUERY_INFORMATION;
+pub const ENLISTMENT_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE | ENLISTMENT_SET_INFORMATION
+    | ENLISTMENT_RECOVER | ENLISTMENT_SUBORDINATE_RIGHTS | ENLISTMENT_SUPERIOR_RIGHTS;
+pub const ENLISTMENT_GENERIC_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE | ENLISTMENT_RECOVER
+    | ENLISTMENT_SUBORDINATE_RIGHTS | ENLISTMENT_SUPERIOR_RIGHTS;
+pub const ENLISTMENT_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | ENLISTMENT_GENERIC_READ
+    | ENLISTMENT_GENERIC_WRITE | ENLISTMENT_GENERIC_EXECUTE;
+ENUM!{enum TRANSACTION_OUTCOME {
+    TransactionOutcomeUndetermined = 1,
+    TransactionOutcomeCommitted,
+    TransactionOutcomeAborted,
+}}
+ENUM!{enum TRANSACTION_STATE {
+    TransactionStateNormal = 1,
+    TransactionStateIndoubt,
+    TransactionStateCommittedNotify,
+}}
+STRUCT!{struct TRANSACTION_BASIC_INFORMATION {
+    TransactionId: GUID,
+    State: DWORD,
+    Outcome: DWORD,
+}}
+pub type PTRANSACTION_BASIC_INFORMATION = *mut TRANSACTION_BASIC_INFORMATION;
+STRUCT!{struct TRANSACTIONMANAGER_BASIC_INFORMATION {
+    TmIdentity: GUID,
+    VirtualClock: LARGE_INTEGER,
+}}
+pub type PTRANSACTIONMANAGER_BASIC_INFORMATION = *mut TRANSACTIONMANAGER_BASIC_INFORMATION;
+STRUCT!{struct TRANSACTIONMANAGER_LOG_INFORMATION {
+    LogIdentity: GUID,
+}}
+pub type PTRANSACTIONMANAGER_LOG_INFORMATION = *mut TRANSACTIONMANAGER_LOG_INFORMATION;
+STRUCT!{struct TRANSACTIONMANAGER_LOGPATH_INFORMATION {
+    LogPathLength: DWORD,
+    LogPath: [WCHAR; 1],
+}}
+pub type PTRANSACTIONMANAGER_LOGPATH_INFORMATION = *mut TRANSACTIONMANAGER_LOGPATH_INFORMATION;
+STRUCT!{struct TRANSACTIONMANAGER_RECOVERY_INFORMATION {
+    LastRecoveredLsn: ULONGLONG,
+}}
+pub type PTRANSACTIONMANAGER_RECOVERY_INFORMATION = *mut TRANSACTIONMANAGER_RECOVERY_INFORMATION;
+STRUCT!{struct TRANSACTIONMANAGER_OLDEST_INFORMATION {
+    OldestTransactionGuid: GUID,
+}}
+pub type PTRANSACTIONMANAGER_OLDEST_INFORMATION = *mut TRANSACTIONMANAGER_OLDEST_INFORMATION;
+STRUCT!{struct TRANSACTION_PROPERTIES_INFORMATION {
+    IsolationLevel: DWORD,
+    IsolationFlags: DWORD,
+    Timeout: LARGE_INTEGER,
+    Outcome: DWORD,
+    DescriptionLength: DWORD,
+    Description: [WCHAR; 1],
+}}
+pub type PTRANSACTION_PROPERTIES_INFORMATION = *mut TRANSACTION_PROPERTIES_INFORMATION;
+STRUCT!{struct TRANSACTION_BIND_INFORMATION {
+    TmHandle: HANDLE,
+}}
+pub type PTRANSACTION_BIND_INFORMATION = *mut TRANSACTION_BIND_INFORMATION;
+STRUCT!{struct TRANSACTION_ENLISTMENT_PAIR {
+    EnlistmentId: GUID,
+    ResourceManagerId: GUID,
+}}
+pub type PTRANSACTION_ENLISTMENT_PAIR = *mut TRANSACTION_ENLISTMENT_PAIR;
+STRUCT!{struct TRANSACTION_ENLISTMENTS_INFORMATION {
+    NumberOfEnlistments: DWORD,
+    EnlistmentPair: [TRANSACTION_ENLISTMENT_PAIR; 1],
+}}
+pub type PTRANSACTION_ENLISTMENTS_INFORMATION = *mut TRANSACTION_ENLISTMENTS_INFORMATION;
+STRUCT!{struct TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION {
+    SuperiorEnlistmentPair: TRANSACTION_ENLISTMENT_PAIR,
+}}
+pub type PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION
+    = *mut TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION;
+STRUCT!{struct RESOURCEMANAGER_BASIC_INFORMATION {
+    ResourceManagerId: GUID,
+    DescriptionLength: DWORD,
+    Description: [WCHAR; 1],
+}}
+pub type PRESOURCEMANAGER_BASIC_INFORMATION = *mut RESOURCEMANAGER_BASIC_INFORMATION;
+STRUCT!{struct RESOURCEMANAGER_COMPLETION_INFORMATION {
+    IoCompletionPortHandle: HANDLE,
+    CompletionKey: ULONG_PTR,
+}}
+pub type PRESOURCEMANAGER_COMPLETION_INFORMATION = *mut RESOURCEMANAGER_COMPLETION_INFORMATION;
+ENUM!{enum TRANSACTION_INFORMATION_CLASS {
+    TransactionBasicInformation,
+    TransactionPropertiesInformation,
+    TransactionEnlistmentInformation,
+    TransactionSuperiorEnlistmentInformation,
+    TransactionBindInformation,
+    TransactionDTCPrivateInformation,
+}}
+ENUM!{enum TRANSACTIONMANAGER_INFORMATION_CLASS {
+    TransactionManagerBasicInformation,
+    TransactionManagerLogInformation,
+    TransactionManagerLogPathInformation,
+    TransactionManagerRecoveryInformation = 4,
+    TransactionManagerOnlineProbeInformation = 3,
+    TransactionManagerOldestTransactionInformation = 5,
+}}
+ENUM!{enum RESOURCEMANAGER_INFORMATION_CLASS {
+    ResourceManagerBasicInformation,
+    ResourceManagerCompletionInformation,
+}}
+STRUCT!{struct ENLISTMENT_BASIC_INFORMATION {
+    EnlistmentId: GUID,
+    TransactionId: GUID,
+    ResourceManagerId: GUID,
+}}
+pub type PENLISTMENT_BASIC_INFORMATION = *mut ENLISTMENT_BASIC_INFORMATION;
+STRUCT!{struct ENLISTMENT_CRM_INFORMATION {
+    CrmTransactionManagerId: GUID,
+    CrmResourceManagerId: GUID,
+    CrmEnlistmentId: GUID,
+}}
+pub type PENLISTMENT_CRM_INFORMATION = *mut ENLISTMENT_CRM_INFORMATION;
+ENUM!{enum ENLISTMENT_INFORMATION_CLASS {
+    EnlistmentBasicInformation,
+    EnlistmentRecoveryInformation,
+    EnlistmentCrmInformation,
+}}
+STRUCT!{struct TRANSACTION_LIST_ENTRY {
+    UOW: UOW,
+}}
+pub type PTRANSACTION_LIST_ENTRY = *mut TRANSACTION_LIST_ENTRY;
+STRUCT!{struct TRANSACTION_LIST_INFORMATION {
+    NumberOfTransactions: DWORD,
+    TransactionInformation: [TRANSACTION_LIST_ENTRY; 1],
+}}
+pub type PTRANSACTION_LIST_INFORMATION = *mut TRANSACTION_LIST_INFORMATION;
+ENUM!{enum KTMOBJECT_TYPE {
+    KTMOBJECT_TRANSACTION,
+    KTMOBJECT_TRANSACTION_MANAGER,
+    KTMOBJECT_RESOURCE_MANAGER,
+    KTMOBJECT_ENLISTMENT,
+    KTMOBJECT_INVALID,
+}}
+pub type PKTMOBJECT_TYPE = *mut KTMOBJECT_TYPE;
+STRUCT!{struct KTMOBJECT_CURSOR {
+    LastQuery: GUID,
+    ObjectIdCount: DWORD,
+    ObjectIds: [GUID; 1],
+}}
+pub type PKTMOBJECT_CURSOR = *mut KTMOBJECT_CURSOR;
+pub type TP_VERSION = DWORD;
+pub type PTP_VERSION = *mut DWORD;
+STRUCT!{struct TP_CALLBACK_INSTANCE {
+    dummy: *mut c_void,
+}}
+pub type PTP_CALLBACK_INSTANCE = *mut TP_CALLBACK_INSTANCE;
+FN!{stdcall PTP_SIMPLE_CALLBACK(
+    Instance: PTP_CALLBACK_INSTANCE,
+    Context: PVOID,
+) -> ()}
+STRUCT!{struct TP_POOL {
+    dummy: *mut c_void,
+}}
+pub type PTP_POOL = *mut TP_POOL;
+ENUM!{enum TP_CALLBACK_PRIORITY {
+    TP_CALLBACK_PRIORITY_HIGH,
+    TP_CALLBACK_PRIORITY_NORMAL,
+    TP_CALLBACK_PRIORITY_LOW,
+    TP_CALLBACK_PRIORITY_INVALID,
+    TP_CALLBACK_PRIORITY_COUNT = TP_CALLBACK_PRIORITY_INVALID,
+}}
+STRUCT!{struct TP_POOL_STACK_INFORMATION {
+    StackReserve: SIZE_T,
+    StackCommit: SIZE_T,
+}}
+pub type PTP_POOL_STACK_INFORMATION = *mut TP_POOL_STACK_INFORMATION;
+STRUCT!{struct TP_CLEANUP_GROUP {
+    dummy: *mut c_void,
+}}
+pub type PTP_CLEANUP_GROUP = *mut TP_CLEANUP_GROUP;
+FN!{stdcall PTP_CLEANUP_GROUP_CANCEL_CALLBACK(
+    ObjectContext: PVOID,
+    CleanupContext: PVOID,
+) -> ()}
+STRUCT!{struct TP_CALLBACK_ENVIRON_V3_u_s {
+    BitFields: DWORD,
+}}
+BITFIELD!{TP_CALLBACK_ENVIRON_V3_u_s BitFields: DWORD [
+    LongFunction set_LongFunction[0..1],
+    Persistent set_Persistent[1..2],
+    Private set_Private[2..32],
+]}
+UNION!{union TP_CALLBACK_ENVIRON_V3_u {
+    [u32; 1],
+    Flags Flags_mut: DWORD,
+    s s_mut: TP_CALLBACK_ENVIRON_V3_u_s,
+}}
+STRUCT!{struct TP_CALLBACK_ENVIRON_V3 {
+    Version: TP_VERSION,
+    Pool: PTP_POOL,
+    CleanupGroup: PTP_CLEANUP_GROUP,
+    CleanupGroupCancelCallback: PTP_CLEANUP_GROUP_CANCEL_CALLBACK,
+    RaceDll: PVOID,
+    ActivationContext: *mut ACTIVATION_CONTEXT,
+    FinalizationCallback: PTP_SIMPLE_CALLBACK,
+    u: TP_CALLBACK_ENVIRON_V3_u,
+    CallbackPriority: TP_CALLBACK_PRIORITY,
+    Size: DWORD,
+}}
+pub type TP_CALLBACK_ENVIRON = TP_CALLBACK_ENVIRON_V3;
+pub type PTP_CALLBACK_ENVIRON = *mut TP_CALLBACK_ENVIRON_V3;
+STRUCT!{struct TP_WORK {
+    dummy: *mut c_void,
+}}
+pub type PTP_WORK = *mut TP_WORK;
+FN!{stdcall PTP_WORK_CALLBACK(
+    Instance: PTP_CALLBACK_INSTANCE,
+    Context: PVOID,
+    Work: PTP_WORK,
+) -> ()}
+STRUCT!{struct TP_TIMER {
+    dummy: *mut c_void,
+}}
+pub type PTP_TIMER = *mut TP_TIMER;
+FN!{stdcall PTP_TIMER_CALLBACK(
+    Instance: PTP_CALLBACK_INSTANCE,
+    Context: PVOID,
+    Timer: PTP_TIMER,
+) -> ()}
+pub type TP_WAIT_RESULT = DWORD;
+STRUCT!{struct TP_WAIT {
+    dummy: *mut c_void,
+}}
+pub type PTP_WAIT = *mut TP_WAIT;
+FN!{stdcall PTP_WAIT_CALLBACK(
+    Instance: PTP_CALLBACK_INSTANCE,
+    Context: PVOID,
+    Wait: PTP_WAIT,
+    WaitResult: TP_WAIT_RESULT,
+) -> ()}
+STRUCT!{struct TP_IO {
+    dummy: *mut c_void,
+}}
+pub type PTP_IO = *mut TP_IO;
+pub const ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION: ULONG = 1;
+pub const ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION: ULONG = 2;
+pub const ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION: ULONG = 3;
+pub const ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION: ULONG = 4;
+pub const ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION: ULONG = 5;
+pub const ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION: ULONG = 6;
+pub const ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION: ULONG = 7;
+pub const ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE: ULONG = 8;
+pub const ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES: ULONG = 9;
+pub const ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS: ULONG = 10;
+pub const ACTIVATION_CONTEXT_SECTION_COMPATIBILITY_INFO: ULONG = 11;
+STRUCT!{struct ACTIVATION_CONTEXT {
+    dummy: *mut c_void,
+}}